templates

Documentation

Index

• Variables

Variables

var EnumCodecsTemplate = `` /* 3851-byte string literal not displayed */

var EnumCodecsTestTemplate = `{{- if not .OmitGeneratedNotice}}
// Code generated by go generate; DO NOT EDIT.
// This file was generated at
// {{ .Timestamp }}
// by go-enum
{{- end }}

package {{ .Package }}

import (
	"encoding/json"
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.mongodb.org/mongo-driver/bson"
)

type fooEnumValue struct {
	EnumValue stringEnumValue ` + "`" + `json:"enum_value"` + "`" + `
}

type fooEnumValueOmitEmpty struct {
	EnumValue stringEnumValue ` + "`" + `json:"enum_value,omitempty"` + "`" + `
}

type fooEnumValuePtr struct {
	EnumValue *stringEnumValue ` + "`" + `json:"enum_value"` + "`" + `
}

type fooEnumValuePtrOmitEmpty struct {
	EnumValue *stringEnumValue ` + "`" + `json:"enum_value,omitempty"` + "`" + `
}

func TestEnumValue_MarshalJSON(t *testing.T) {
	t.Run("Marshal_AnnonStructField", func(t *testing.T) {
		c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }
		v := struct {
			A stringEnumValue ` + "`" + `json:"enum_value"` + "`" + `
		}{c}
		data, err := json.Marshal(&v)
		require.Nil(t, err)
		assert.EqualValues(t, fmt.Sprintf(` + "`" + `{"enum_value":"%s"}` + "`" + `, v.A.String()), string(data))
	})
	t.Run("Marshal_StructField", func(t *testing.T) {
		v := fooEnumValue{EnumValue: stringEnumValue{key: {{ .IndexKeyName }} }}
		data, err := json.Marshal(v)
		require.Nil(t, err)
		assert.EqualValues(t, fmt.Sprintf(` + "`" + `{"enum_value":"%s"}` + "`" + `, v.EnumValue.String()), string(data))
	})
	t.Run("Marshal_OmitEmptyStruct", func(t *testing.T) {
		// encoding/json ignores omitempty on struct zero values
		// https://github.com/golang/go/issues/11939
		v := fooEnumValueOmitEmpty{}
		data, err := json.Marshal(v)
		require.Nil(t, err)
		assert.EqualValues(t, ` + "`" + `{"enum_value":""}` + "`" + `, string(data))
	})
	t.Run("Marshal_StructFieldPtr", func(t *testing.T) {
		vPtr := fooEnumValuePtr{EnumValue: &stringEnumValue{key: {{ .IndexKeyName }} }}
		data, err := json.Marshal(vPtr)
		require.Nil(t, err)
		assert.EqualValues(t, ` + "`" + `{"enum_value":""}` + "`" + `, string(data))
	})
	t.Run("Marshal_StructFieldPtr", func(t *testing.T) {
		c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }
		vPtr := fooEnumValuePtr{EnumValue: &c}
		data, err := json.Marshal(vPtr)
		require.Nil(t, err)
		assert.EqualValues(t, fmt.Sprintf(` + "`" + `{"enum_value":"%s"}` + "`" + `, vPtr.EnumValue.String()), string(data))
	})
	t.Run("Marshal_StructFieldNilPtr", func(t *testing.T) {
		vPtr := fooEnumValuePtr{}
		data, err := json.Marshal(vPtr)
		require.Nil(t, err)
		assert.EqualValues(t, ` + "`" + `{"enum_value":null}` + "`" + `, string(data))
	})
	t.Run("Marshal_OmitEmptyStructPtr", func(t *testing.T) {
		vPtr := fooEnumValuePtrOmitEmpty{}
		data, err := json.Marshal(vPtr)
		require.Nil(t, err)
		assert.EqualValues(t, ` + "`" + `{}` + "`" + `, string(data))
	})
}

func TestEnumValue_UnmarshalJSON(t *testing.T) {
	t.Run("Unmarshal_InvalidJSON", func(t *testing.T) {
		data := ` + "`" + `{"enum_value":"PA` + "`" + `
rawData := []byte(data)

c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }
v := struct {
A stringEnumValue ` + "`" + `json:"enum_value"` + "`" + `
}{c}
// Invalid JSON structures fail on json.Unmarshal
err := json.Unmarshal(rawData, &v)
require.NotNil(t, err)
})
t.Run("Unmarshal_InvalidValue", func(t *testing.T) {
	data := ` + "`" + `{"enum_value":"{{ .TestCase.InvalidValue }}"}` + "`" + `
	rawData := []byte(data)

	c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }
	v := struct {
		A stringEnumValue ` + "`" + `json:"enum_value"` + "`" + `
	}{c}
	err := json.Unmarshal(rawData, &v)
	require.NotNil(t, err)
})
t.Run("Unmarshal_InvalidValueJSON", func(t *testing.T) {
	data := ` + "`" + `{"enum_value":123}` + "`" + `
	rawData := []byte(data)

	c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }
	v := struct {
		A stringEnumValue ` + "`" + `json:"enum_value"` + "`" + `
	}{c}
	// Invalid field values but whithin a valid JSON are caught on UnmarshalJSON
	err := json.Unmarshal(rawData, &v)
	require.NotNil(t, err)
})
t.Run("Unmarshal_AnnonStructField", func(t *testing.T) {
	data := ` + "`" + `{"enum_value":"{{ .TestCase.Value }}"}` + "`" + `
	rawData := []byte(data)

	c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }
	v := struct {
		A stringEnumValue ` + "`" + `json:"enum_value"` + "`" + `
	}{c}
	err := json.Unmarshal(rawData, &v)
	require.Nil(t, err)
	assert.EqualValues(t, "{{ .TestCase.Value }}", v.A.String())
})
t.Run("Unmarshal_StructField", func(t *testing.T) {
	data := ` + "`" + `{"enum_value":"{{ .TestCase.Value }}"}` + "`" + `
	rawData := []byte(data)

	v := fooEnumValue{EnumValue: stringEnumValue{key: {{ .IndexKeyName }} }}
	err := json.Unmarshal(rawData, &v)
	require.Nil(t, err)
	assert.EqualValues(t, "{{ .TestCase.Value }}", v.EnumValue.String())
})
t.Run("Unmarshal_OmitEmptyStruct", func(t *testing.T) {
	data := ` + "`" + `{"enum_value":null}` + "`" + `
	rawData := []byte(data)

	v := fooEnumValueOmitEmpty{}
	err := json.Unmarshal(rawData, &v)
	require.NoError(t, err)
})
t.Run("Unmarshal_StructFieldPtr", func(t *testing.T) {
	data := ` + "`" + `{"enum_value":"{{ .TestCase.Value }}"}` + "`" + `
	rawData := []byte(data)

	vPtr := fooEnumValuePtr{EnumValue: &stringEnumValue{key: {{ .IndexKeyName }} }}
	err := json.Unmarshal(rawData, &vPtr)
	require.Nil(t, err)
	assert.EqualValues(t, "{{ .TestCase.Value }}", vPtr.EnumValue.String())
})
t.Run("Unmarshal_StructFieldNilPtr", func(t *testing.T) {
	data := ` + "`" + `{"enum_value":null}` + "`" + `
	rawData := []byte(data)

	vPtr := fooEnumValuePtr{}
	err := json.Unmarshal(rawData, &vPtr)
	require.Nil(t, err)
	assert.Nil(t, vPtr.EnumValue)
})
t.Run("Unmarshal_TableUnmatch", func(t *testing.T) {
	data := ` + "`" + `{"enum_value":"PPP"}` + "`" + `
	rawData := []byte(data)

	v := fooEnumValue{}
	err := json.Unmarshal(rawData, &v)
	require.NotNil(t, err)
})
}

func TestEnumValue_TextCodec(t *testing.T) {
	t.Run("MarshalText_Valid", func(t *testing.T) {
		c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }

		data, err := c.MarshalText()
		require.Nil(t, err)
		require.True(t, len(data) > 0)
	})
	t.Run("UnmarshalText_Valid", func(t *testing.T) {
		c := &stringEnumValue{key: {{ .IndexKeyName }} }
		err := c.UnmarshalText([]byte("{{ .TestCase.Value }}"))
		require.Nil(t, err)
		require.EqualValues(t, {{ .TestCase.Name }}().String(), c.value)
	})
	t.Run("UnmarshalText_Invalid", func(t *testing.T) {
		c := &stringEnumValue{key: {{ .IndexKeyName }} }
		err := c.UnmarshalText([]byte(""))
		require.NoError(t, err)
		err = c.UnmarshalText([]byte("{{ .TestCase.InvalidValue }}"))
		require.NotNil(t, err)
	})
}

func TestEnumValue_Stringer(t *testing.T) {
	c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }
	require.EqualValues(t, c.value, c.String())
}

func TestEnumValue_DriverValues(t *testing.T) {
	t.Run("Scan_String", func(t *testing.T) {
		c := &stringEnumValue{key: {{ .IndexKeyName }} }
		require.Nil(t, c.Scan({{ .TestCase.Name }}().String()))
		require.EqualValues(t, {{ .TestCase.Name }}().String(), c.value)
	})
	t.Run("Scan_Bytes", func(t *testing.T) {
		c := &stringEnumValue{key: {{ .IndexKeyName }} }
		require.Nil(t, c.Scan([]byte({{ .TestCase.Name }}().String())))
		require.EqualValues(t, {{ .TestCase.Name }}().String(), c.value)
	})
	t.Run("Scan_Invalid", func(t *testing.T) {
		c := &stringEnumValue{key: {{ .IndexKeyName }} }
		require.NotNil(t, c.Scan(1))
	})
	t.Run("Scan_Invalid", func(t *testing.T) {
		c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }

		v, err := c.Value()
		assert.Nil(t, err)
		require.EqualValues(t, {{ .TestCase.Name }}().String(), fmt.Sprintf("%v", v))
	})
}

func TestEnumValue_BinaryCodec(t *testing.T) {
	t.Run("MarshalBinary_Valid", func(t *testing.T) {
		c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }

		data, err := c.MarshalBinary()
		require.Nil(t, err)
		assert.Len(t, data, {{ .TestCase.BinaryLen }})
	})
	t.Run("UnmarshalBinary_Valid", func(t *testing.T) {
		c := &stringEnumValue{key: {{ .IndexKeyName }} }
		err := c.UnmarshalBinary([]byte("{{ .TestCase.Value }}"))
		require.Nil(t, err)
		require.EqualValues(t, {{ .TestCase.Name }}().String(), c.value)
	})
	t.Run("UnmarshalText_Invalid", func(t *testing.T) {
		c := &stringEnumValue{key: {{ .IndexKeyName }} }
		err := c.UnmarshalBinary(nil)
		require.NoError(t, err)
		err = c.UnmarshalBinary([]byte("{{ .TestCase.InvalidValue }}"))
		require.NotNil(t, err)
	})
}

func TestEnumValue_GobCodec(t *testing.T) {
	t.Run("MarshalBinary_Valid", func(t *testing.T) {
		c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }

		data, err := c.GobEncode()
		require.Nil(t, err)
		assert.Len(t, data, {{ .TestCase.BinaryLen }})
	})
	t.Run("UnmarshalBinary_Valid", func(t *testing.T) {
		c := &stringEnumValue{key: {{ .IndexKeyName }} }
		err := c.GobDecode([]byte("{{ .TestCase.Value }}"))
		require.Nil(t, err)
		require.EqualValues(t, {{ .TestCase.Name }}().String(), c.value)
	})
	t.Run("UnmarshalText_Invalid", func(t *testing.T) {
		c := &stringEnumValue{key: {{ .IndexKeyName }} }
		err := c.GobDecode(nil)
		require.NoError(t, err)
		err = c.GobDecode([]byte("{{ .TestCase.InvalidValue }}"))
		require.NotNil(t, err)
	})
}

func TestEnumValue_MarshalBSON(t *testing.T) {
	t.Run("MarshalBSON_Valid", func(t *testing.T) {
		c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }

		data, err := c.MarshalBSON()
		require.Nil(t, err)
		assert.Len(t, data, {{ .TestCase.BSONLen }})
	})
}

func TestEnumValue_UnmarshalBSON(t *testing.T) {
	t.Run("UnmarshalBSON_Valid", func(t *testing.T) {
		c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }

		v1 := &fooEnumValue{EnumValue: c}
		rawData, err := bson.Marshal(v1)
		require.Nil(t, err)

		v2 := &fooEnumValue{EnumValue: c}
		err = bson.Unmarshal(rawData, &v2)
		require.Nil(t, err)
		assert.EqualValues(t, "{{ .TestCase.Value }}", v2.EnumValue.String())
	})
	t.Run("UnmarshalBSON_InvalidTable", func(t *testing.T) {
		c := stringEnumValue{ {{ .TestCase.Name }}().String(), {{ .IndexKeyName }} }
		ptr := &c
		ptr.value = "PPP"
		v1 := &fooEnumValue{EnumValue: c}
		rawData, err := bson.Marshal(v1)
		require.Nil(t, err)

		v2 := &fooEnumValue{}
		err = bson.Unmarshal(rawData, &v2)
		require.NotNil(t, err)
	})
}

`

var EnumImplTemplate = `` /* 2979-byte string literal not displayed */

var EnumImplTestTemplate = `{{- if not .OmitGeneratedNotice}}
// Code generated by go generate; DO NOT EDIT.
// This file was generated at
// {{ .Timestamp }}
// by go-enum
{{- end }}

package {{ .Package }}_test

import (
	"testing"
	"encoding/json"
	"fmt"

	"{{ .ImportPath }}"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.mongodb.org/mongo-driver/bson"
)

type foo{{ .StructName }} struct {
	TestValue {{ .Package }}.{{ .StructName }} ` + "`" + `json:"{{ .TestCase.Key }}"` + "`" + `
}

type foo{{ .StructName }}OmitEmpty struct {
	TestValue {{ .Package }}.{{ .StructName }} ` + "`" + `json:"{{ .TestCase.Key }},omitempty"` + "`" + `
}

type foo{{ .StructName }}Ptr struct {
	TestValue *{{ .Package }}.{{ .StructName }} ` + "`" + `json:"{{ .TestCase.Key }}"` + "`" + `
}

type foo{{ .StructName }}PtrOmitEmpty struct {
	TestValue *{{ .Package }}.{{ .StructName }} ` + "`" + `json:"{{ .TestCase.Key }},omitempty"` + "`" + `
}

func Test{{ .StructName }}_MarshalJSON(t *testing.T) {
	t.Run("Marshal_AnnonStructField", func(t *testing.T) {
		v := struct {
			A {{ .Package }}.{{ .StructName }} ` + "`" + `json:"{{ .TestCase.Key }}"` + "`" + `
		}{ {{ .Package }}.{{ .TestCase.Name }}()}
		data, err := json.Marshal(&v)
		require.Nil(t, err)
		assert.EqualValues(t, fmt.Sprintf(` + "`" + `{"{{ .TestCase.Key }}":"%s"}` + "`" + `, v.A.String()), string(data))
	})
	t.Run("Marshal_StructField", func(t *testing.T) {
		v := foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .StructName }}{}}
		data, err := json.Marshal(v)
		require.Nil(t, err)
		assert.EqualValues(t, fmt.Sprintf(` + "`" + `{"{{ .TestCase.Key }}":"%s"}` + "`" + `, v.TestValue.String()), string(data))
	})
	t.Run("Marshal_OmitEmptyStruct", func(t *testing.T) {
		// encoding/json ignores omitempty on struct zero values
		// https://github.com/golang/go/issues/11939
		v := foo{{ .StructName }}OmitEmpty{}
		data, err := json.Marshal(v)
		require.Nil(t, err)
		assert.EqualValues(t, ` + "`" + `{"{{ .TestCase.Key }}":""}` + "`" + `, string(data))
	})
	t.Run("Marshal_StructFieldEmptyPtr", func(t *testing.T) {
		vPtr := foo{{ .StructName }}Ptr{TestValue: &{{ .Package }}.{{ .StructName }}{}}
		data, err := json.Marshal(vPtr)
		require.Nil(t, err)
		assert.EqualValues(t, ` + "`" + `{"{{ .TestCase.Key }}":""}` + "`" + `, string(data))
	})
	t.Run("Marshal_StructFieldPtr", func(t *testing.T) {
		dt := {{ .Package }}.{{ .TestCase.Name }}
		val := dt() 
		vPtr := foo{{ .StructName }}Ptr{TestValue: &val}
		data, err := json.Marshal(vPtr)
		require.Nil(t, err)
		assert.EqualValues(t, fmt.Sprintf(` + "`" + `{"{{ .TestCase.Key }}":"%s"}` + "`" + `, vPtr.TestValue.String()), string(data))
	})
	t.Run("Marshal_StructFieldNilPtr", func(t *testing.T) {
		vPtr := foo{{ .StructName }}Ptr{}
		data, err := json.Marshal(vPtr)
		require.Nil(t, err)
		assert.EqualValues(t, ` + "`" + `{"{{ .TestCase.Key }}":null}` + "`" + `, string(data))
	})
	t.Run("Marshal_OmitEmptyStructPtr", func(t *testing.T) {
		vPtr := foo{{ .StructName }}PtrOmitEmpty{}
		data, err := json.Marshal(vPtr)
		require.Nil(t, err)
		assert.EqualValues(t, ` + "`" + `{}` + "`" + `, string(data))
	})
}

func Test{{ .StructName }}_UnmarshalJSON(t *testing.T) {
	t.Run("Unmarshal_InvalidValue", func(t *testing.T) {
		data := ` + "`" + `{"{{ .TestCase.Key }}":"{{ .TestCase.InvalidValue }}"}` + "`" + `
		rawData := []byte(data)

		v := struct {
			A {{ .Package }}.{{ .StructName }} ` + "`" + `json:"{{ .TestCase.Key }}"` + "`" + `
		}{ {{ .Package }}.{{ .TestCase.Name }}()}
		err := json.Unmarshal(rawData, &v)
		require.NotNil(t, err)
	})
	t.Run("Unmarshal_AnnonStructField", func(t *testing.T) {
		data := ` + "`" + `{"{{ .TestCase.Key }}":"{{ .TestCase.Value }}"}` + "`" + `
		rawData := []byte(data)

		v := struct {
			A {{ .Package }}.{{ .StructName }} ` + "`" + `json:"{{ .TestCase.Key }}"` + "`" + `
		}{ {{ .Package }}.{{ .TestCase.Name }}() }
		err := json.Unmarshal(rawData, &v)
		require.Nil(t, err)
		assert.EqualValues(t, "{{ .TestCase.Value }}", v.A.String())
	})
	t.Run("Unmarshal_StructField", func(t *testing.T) {
		data := ` + "`" + `{"{{ .TestCase.Key }}":"{{ .TestCase.Value }}"}` + "`" + `
		rawData := []byte(data)

		v := foo{{ .StructName }}{}
		err := json.Unmarshal(rawData, &v)
		require.Nil(t, err)
		assert.EqualValues(t, "{{ .TestCase.Value }}", v.TestValue.String())
	})
	t.Run("Unmarshal_OmitEmptyStruct", func(t *testing.T) {
		data := ` + "`" + `{"{{ .TestCase.Key }}":null}` + "`" + `
		rawData := []byte(data)

		v := foo{{ .StructName }}OmitEmpty{}
		err := json.Unmarshal(rawData, &v)
		require.NoError(t, err)
	})
	t.Run("Unmarshal_StructFieldPtr", func(t *testing.T) {
		data := ` + "`" + `{"{{ .TestCase.Key }}":"{{ .TestCase.Value }}"}` + "`" + `
		rawData := []byte(data)

		vPtr := foo{{ .StructName }}Ptr{}
		err := json.Unmarshal(rawData, &vPtr)
		require.Nil(t, err)
		assert.EqualValues(t, "{{ .TestCase.Value }}", vPtr.TestValue.String())
	})
	t.Run("Unmarshal_StructFieldNilPtr", func(t *testing.T) {
		data := ` + "`" + `{"{{ .TestCase.Key }}":null}` + "`" + `
		rawData := []byte(data)

		vPtr := foo{{ .StructName }}Ptr{}
		err := json.Unmarshal(rawData, &vPtr)
		require.Nil(t, err)
		assert.Nil(t, vPtr.TestValue)
	})
}

func Test{{ .StructName }}_EmptyValues(t *testing.T) {
	t.Run("StructField", func(t *testing.T) {
		v := foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .StructName }}{}}
		data, err := json.Marshal(v)
		require.NoError(t, err)
		assert.EqualValues(t, fmt.Sprintf(` + "`" + `{"{{ .TestCase.Key }}":"%s"}` + "`" + `, v.TestValue.String()), string(data))

		v2 := foo{{ .StructName }}{}
		err = json.Unmarshal(data, &v2)
		require.NoError(t, err)
		require.True(t, v2.TestValue.IsEmpty())

		v3 := foo{{ .StructName }}{}
		err = json.Unmarshal(data, &v3)
		require.NoError(t, err)
		require.True(t, v3.TestValue.IsEmpty())
	})
	t.Run("PtrField", func(t *testing.T) {
		v := foo{{ .StructName }}Ptr{TestValue: nil}
		data, err := json.Marshal(v)
		require.NoError(t, err)
		assert.EqualValues(t, fmt.Sprintf(` + "`" + `{"{{ .TestCase.Key }}":%s}` + "`" + `, "null"), string(data))

		v2 := foo{{ .StructName }}{}
		err = json.Unmarshal(data, &v2)
		require.NoError(t, err)
		require.True(t, v2.TestValue.IsEmpty())

		v3 := foo{{ .StructName }}{}
		err = json.Unmarshal(data, &v3)
		require.NoError(t, err)
		require.True(t, v3.TestValue.IsEmpty())
	})
}

func Test{{ .StructName }}_UndefinedValue(t *testing.T) {
	require.True(t, {{ .Package }}.{{ .StructName }}{}.IsUndefined())
}

func Test{{ .StructName }}_ForEach(t *testing.T) {
	j := 0
	{{ .Package }}.Enum{{ .StructName }}.ForEach(func(i int, enumValue {{ .Package }}.{{ .StructName }}) {
		j++
		value, found := {{ .Package }}.{{ .StructName }}FromValue(enumValue.String(), false)
		assert.True(t, found)
		assert.True(t, value == enumValue)

		assert.True(t, enumValue.Equals(value.String()))
		assert.True(t, enumValue.EqualsIgnoreCase(value.String()))
		assert.True(t, value.Equals(enumValue.String()))
		assert.True(t, value.EqualsIgnoreCase(enumValue.String()))
	})
	assert.EqualValues(t, {{ .Package }}.Enum{{ .StructName }}.Len(), j)
}

func Test{{ .StructName }}_TextCodec(t *testing.T) {
	t.Run("MarshalText_Valid", func(t *testing.T) {
		c :=foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }

		data, err := c.TestValue.MarshalText()
		require.Nil(t, err)
		require.True(t, len(data) > 0)
	})
	t.Run("UnmarshalText_Valid", func(t *testing.T) {
		c := &foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
		err := c.TestValue.UnmarshalText([]byte("{{ .TestCase.Value }}"))
		require.Nil(t, err)
		require.EqualValues(t, {{ .Package }}.{{ .TestCase.Name }}().String(), c.TestValue.String())
	})
	t.Run("UnmarshalText_Invalid", func(t *testing.T) {
		c := &foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
		err := c.TestValue.UnmarshalText([]byte(""))
		require.NoError(t, err)
		err = c.TestValue.UnmarshalText([]byte("{{ .TestCase.InvalidValue }}"))
		require.NotNil(t, err)
	})
}

func Test{{ .StructName }}_Stringer(t *testing.T) {
	c :=foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
	require.EqualValues(t, "{{ .TestCase.Value }}", c.TestValue.String())
}

func Test{{ .StructName }}_DriverValues(t *testing.T) {
	t.Run("Scan_String", func(t *testing.T) {
		c := &foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
		require.Nil(t, c.TestValue.Scan({{ .Package }}.{{ .TestCase.Name }}().String()))
		require.EqualValues(t, {{ .Package }}.{{ .TestCase.Name }}().String(), c.TestValue.String())
	})
	t.Run("Scan_Bytes", func(t *testing.T) {
		c := &foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
		require.Nil(t, c.TestValue.Scan([]byte({{ .Package }}.{{ .TestCase.Name }}().String())))
		require.EqualValues(t, {{ .Package }}.{{ .TestCase.Name }}().String(), c.TestValue.String())
	})
	t.Run("Scan_Invalid", func(t *testing.T) {
		c := &foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
		require.NotNil(t, c.TestValue.Scan(1))
	})
	t.Run("Scan_Invalid", func(t *testing.T) {
		c :=foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }

		v, err := c.TestValue.Value()
		assert.Nil(t, err)
		require.EqualValues(t, {{ .Package }}.{{ .TestCase.Name }}().String(), fmt.Sprintf("%v", v))
	})
}

func Test{{ .StructName }}_BinaryCodec(t *testing.T) {
	t.Run("MarshalBinary_Valid", func(t *testing.T) {
		c :=foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }

		data, err := c.TestValue.MarshalBinary()
		require.Nil(t, err)
		assert.Len(t, data, {{ .TestCase.BinaryLen }})
	})
	t.Run("UnmarshalBinary_Valid", func(t *testing.T) {
		c := &foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
		err := c.TestValue.UnmarshalBinary([]byte("{{ .TestCase.Value }}"))
		require.Nil(t, err)
		require.EqualValues(t, {{ .Package }}.{{ .TestCase.Name }}().String(), c.TestValue.String())
	})
	t.Run("UnmarshalText_Invalid", func(t *testing.T) {
		c := &foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
		err := c.TestValue.UnmarshalBinary(nil)
		require.NoError(t, err)
		err = c.TestValue.UnmarshalBinary([]byte("{{ .TestCase.InvalidValue }}"))
		require.NotNil(t, err)
	})
}

func Test{{ .StructName }}_GobCodec(t *testing.T) {
	t.Run("MarshalBinary_Valid", func(t *testing.T) {
		c :=foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }

		data, err := c.TestValue.GobEncode()
		require.Nil(t, err)
		assert.Len(t, data, {{ .TestCase.BinaryLen }})
	})
	t.Run("UnmarshalBinary_Valid", func(t *testing.T) {
		c := &foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
		err := c.TestValue.GobDecode([]byte("{{ .TestCase.Value }}"))
		require.Nil(t, err)
		require.EqualValues(t, {{ .Package }}.{{ .TestCase.Name }}().String(), c.TestValue.String())
	})
	t.Run("UnmarshalText_Invalid", func(t *testing.T) {
		c := &foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }
		err := c.TestValue.GobDecode(nil)
		require.NoError(t, err)
		err = c.TestValue.GobDecode([]byte("{{ .TestCase.InvalidValue }}"))
		require.NotNil(t, err)
	})
}

func Test{{ .StructName }}_MarshalBSON(t *testing.T) {
	t.Run("MarshalBSON_Valid", func(t *testing.T) {
		c :=foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }

		data, err := c.TestValue.MarshalBSON()
		require.Nil(t, err)
		assert.Len(t, data, {{ .TestCase.BSONLen }})
	})
}

func Test{{ .StructName }}_UnmarshalBSON(t *testing.T) {
	t.Run("UnmarshalBSON_Valid", func(t *testing.T) {
		c :=foo{{ .StructName }}{TestValue: {{ .Package }}.{{ .TestCase.Name }}() }

		v1 := &c
		rawData, err := bson.Marshal(v1)
		require.Nil(t, err)

		v2 := &foo{{ .StructName }}{}
		err = bson.Unmarshal(rawData, &v2)
		require.Nil(t, err)
		assert.EqualValues(t, "{{ .TestCase.Value }}", v2.TestValue.String())
	})
}

`

var EnumTemplate = `` /* 1872-byte string literal not displayed */

var EnumTestTemplate = `` /* 1616-byte string literal not displayed */