package main

import (
    "bytes"
    "encoding/gob"
    "encoding/json"
    "encoding/xml"
    "fmt"
    "io"
)

type encoder interface {
    Encode(interface{}) error
}

type encoderType int

const (
    JSON encoderType = iota
    XML
    GOB
)

func (e encoderType) String() string {
    switch e {
    case JSON:
        return "json"
    case XML:
        return "xml"
    case GOB:
        return "gob"
    default:
        return "unknown"
    }
}

func (et encoderType) encoderProducer() func(io.Writer) encoder {
    switch et {
    case JSON:
        return func(w io.Writer) encoder { return json.NewEncoder(w) }
    case GOB:
        return func(w io.Writer) encoder { return gob.NewEncoder(w) }
    case XML:
        return func(w io.Writer) encoder { return xml.NewEncoder(w) }
    default:
        return nil
    }
}

func (et encoderType) nilBehavior(src interface{}) (serializedBytes []byte, err interface{}) {
    defer func() {
        if rerr := recover(); rerr != nil {
            switch rerr := rerr.(type) {
            case error:
                err = rerr
            default:
                err = fmt.Errorf("%v", rerr)
            }
        }
    }()
    buf := new(bytes.Buffer)
    encoderFn := et.encoderProducer()
    err = encoderFn(buf).Encode(src)
    serializedBytes = buf.Bytes()
    return
}

func main() {
    var fn func() error = nil
    gob.Register(fn)
    testCases := [...]struct {
        typ       encoderType
        wantErr   error
        wantBytes []byte
        value     interface{}
    }{
        {JSON, nil, []byte("null\n"), nil},
        {JSON, nil, []byte("null\n"), map[string]string(nil)},

        {XML, nil, []byte(""), nil},

        {GOB, nil, []byte(""), nil},
        {GOB, nil, []byte("\x0e\xff\x81\x04\x01\x02\xff\x82\x00\x01\f\x01\f\x00\x00\x04\xff\x82\x00\x00"), map[string]string(nil)},
        {GOB, nil, []byte(""), func() (fn func() error) { return }},
        {GOB, nil, []byte("\x03\f\x00\x00"), new(string)},
    }

    for i, tt := range testCases {
        gotBytes, gotErr := tt.typ.nilBehavior(tt.value)
        if !bytes.Equal(gotBytes, tt.wantBytes) {
            fmt.Printf("#%d: %s: gotBytes=%q wantBytes=%q\n", i, tt.typ, gotBytes, tt.wantBytes)
        }

        if gotErr != tt.wantErr {
            fmt.Printf("#%d: %s: gotErr=%v wantErr=%v\n", i, tt.typ, gotErr, tt.wantErr)
        }
    }
}