fix the vendor files

vendor/github.com/mozillazg/go-httpheader/encode_test.go

@@ -0,0 +1,282 @@
+package httpheader
+
+import (
+	"fmt"
+	"net/http"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestHeader_types(t *testing.T) {
+	str := "string"
+	strPtr := &str
+	timeVal := time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)
+
+	tests := []struct {
+		in   interface{}
+		want http.Header
+	}{
+		{
+			// basic primitives
+			struct {
+				A string
+				B int
+				C uint
+				D float32
+				E bool
+			}{},
+			http.Header{
+				"A": []string{""},
+				"B": []string{"0"},
+				"C": []string{"0"},
+				"D": []string{"0"},
+				"E": []string{"false"},
+			},
+		},
+		{
+			// pointers
+			struct {
+				A *string
+				B *int
+				C **string
+				D *time.Time
+			}{
+				A: strPtr,
+				C: &strPtr,
+				D: &timeVal,
+			},
+			http.Header{
+				"A": []string{str},
+				"B": []string{""},
+				"C": []string{str},
+				"D": []string{"Sat, 01 Jan 2000 12:34:56 GMT"},
+			},
+		},
+		{
+			// slices and arrays
+			struct {
+				A []string
+				B []*string
+				C [2]string
+				D []bool `header:",int"`
+			}{
+				A: []string{"a", "b"},
+				B: []*string{&str, &str},
+				C: [2]string{"a", "b"},
+				D: []bool{true, false},
+			},
+			http.Header{
+				"A": []string{"a", "b"},
+				"B": {"string", "string"},
+				"C": []string{"a", "b"},
+				"D": {"1", "0"},
+			},
+		},
+		{
+			// other types
+			struct {
+				A time.Time
+				B time.Time `header:",unix"`
+				C bool      `header:",int"`
+				D bool      `header:",int"`
+				E http.Header
+			}{
+				A: time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC),
+				B: time.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC),
+				C: true,
+				D: false,
+				E: http.Header{
+					"F": []string{"f1"},
+					"G": []string{"gg"},
+				},
+			},
+			http.Header{
+				"A": []string{"Sat, 01 Jan 2000 12:34:56 GMT"},
+				"B": []string{"946730096"},
+				"C": []string{"1"},
+				"D": []string{"0"},
+				"F": []string{"f1"},
+				"G": []string{"gg"},
+			},
+		},
+		{
+			nil,
+			http.Header{},
+		},
+		{
+			&struct {
+				A string
+			}{"test"},
+			http.Header{
+				"A": []string{"test"},
+			},
+		},
+	}
+
+	for i, tt := range tests {
+		v, err := Header(tt.in)
+		if err != nil {
+			t.Errorf("%d. Header(%q) returned error: %v", i, tt.in, err)
+		}
+
+		if !reflect.DeepEqual(tt.want, v) {
+			t.Errorf("%d. Header(%q) returned %#v, want %#v", i, tt.in, v, tt.want)
+		}
+	}
+}
+
+func TestHeader_omitEmpty(t *testing.T) {
+	str := ""
+	s := struct {
+		a string
+		A string
+		B string    `header:",omitempty"`
+		C string    `header:"-"`
+		D string    `header:"omitempty"` // actually named omitempty, not an option
+		E *string   `header:",omitempty"`
+		F bool      `header:",omitempty"`
+		G int       `header:",omitempty"`
+		H uint      `header:",omitempty"`
+		I float32   `header:",omitempty"`
+		J time.Time `header:",omitempty"`
+		K struct{}  `header:",omitempty"`
+	}{E: &str}
+
+	v, err := Header(s)
+	if err != nil {
+		t.Errorf("Header(%#v) returned error: %v", s, err)
+	}
+
+	want := http.Header{
+		"A":         []string{""},
+		"Omitempty": []string{""},
+		"E":         []string{""}, // E is included because the pointer is not empty, even though the string being pointed to is
+	}
+	if !reflect.DeepEqual(want, v) {
+		t.Errorf("Header(%#v) returned %v, want %v", s, v, want)
+	}
+}
+
+type A struct {
+	B
+}
+
+type B struct {
+	C string
+}
+
+type D struct {
+	B
+	C string
+}
+
+type e struct {
+	B
+	C string
+}
+
+type F struct {
+	e
+}
+
+func TestHeader_embeddedStructs(t *testing.T) {
+	tests := []struct {
+		in   interface{}
+		want http.Header
+	}{
+		{
+			A{B{C: "foo"}},
+			http.Header{"C": []string{"foo"}},
+		},
+		{
+			D{B: B{C: "bar"}, C: "foo"},
+			http.Header{"C": []string{"foo", "bar"}},
+		},
+		{
+			F{e{B: B{C: "bar"}, C: "foo"}}, // With unexported embed
+			http.Header{"C": []string{"foo", "bar"}},
+		},
+	}
+
+	for i, tt := range tests {
+		v, err := Header(tt.in)
+		if err != nil {
+			t.Errorf("%d. Header(%q) returned error: %v", i, tt.in, err)
+		}
+
+		if !reflect.DeepEqual(tt.want, v) {
+			t.Errorf("%d. Header(%q) returned %v, want %v", i, tt.in, v, tt.want)
+		}
+	}
+}
+
+func TestHeader_invalidInput(t *testing.T) {
+	_, err := Header("")
+	if err == nil {
+		t.Errorf("expected Header() to return an error on invalid input")
+	}
+}
+
+type EncodedArgs []string
+
+func (m EncodedArgs) EncodeHeader(key string, v *http.Header) error {
+	for i, arg := range m {
+		v.Set(fmt.Sprintf("%s.%d", key, i), arg)
+	}
+	return nil
+}
+
+func TestHeader_Marshaler(t *testing.T) {
+	s := struct {
+		Args EncodedArgs `header:"arg"`
+	}{[]string{"a", "b", "c"}}
+	v, err := Header(s)
+	if err != nil {
+		t.Errorf("Header(%q) returned error: %v", s, err)
+	}
+
+	want := http.Header{
+		"Arg.0": []string{"a"},
+		"Arg.1": []string{"b"},
+		"Arg.2": []string{"c"},
+	}
+	if !reflect.DeepEqual(want, v) {
+		t.Errorf("Header(%q) returned %v, want %v", s, v, want)
+	}
+}
+
+func TestHeader_MarshalerWithNilPointer(t *testing.T) {
+	s := struct {
+		Args *EncodedArgs `header:"arg"`
+	}{}
+	v, err := Header(s)
+	if err != nil {
+		t.Errorf("Header(%q) returned error: %v", s, err)
+	}
+
+	want := http.Header{}
+	if !reflect.DeepEqual(want, v) {
+		t.Errorf("Header(%q) returned %v, want %v", s, v, want)
+	}
+}
+
+func TestTagParsing(t *testing.T) {
+	name, opts := parseTag("field,foobar,foo")
+	if name != "field" {
+		t.Fatalf("name = %q, want field", name)
+	}
+	for _, tt := range []struct {
+		opt  string
+		want bool
+	}{
+		{"foobar", true},
+		{"foo", true},
+		{"bar", false},
+		{"field", false},
+	} {
+		if opts.Contains(tt.opt) != tt.want {
+			t.Errorf("Contains(%q) = %v", tt.opt, !tt.want)
+		}
+	}
+}