mirror of
https://github.com/MetaCubeX/mihomo.git
synced 2026-10-11 01:38:14 +08:00
339 lines
8.6 KiB
Go
339 lines
8.6 KiB
Go
package orderedmap
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// to test marshalling TextMarshalers and unmarshalling TextUnmarshalers
|
|
type marshallable int
|
|
|
|
func (m marshallable) MarshalText() ([]byte, error) {
|
|
return []byte(fmt.Sprintf("#%d#", m)), nil
|
|
}
|
|
|
|
func (m *marshallable) UnmarshalText(text []byte) error {
|
|
if len(text) < 3 {
|
|
return errors.New("too short")
|
|
}
|
|
if text[0] != '#' || text[len(text)-1] != '#' {
|
|
return errors.New("missing prefix or suffix")
|
|
}
|
|
|
|
value, err := strconv.Atoi(string(text[1 : len(text)-1]))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
*m = marshallable(value)
|
|
return nil
|
|
}
|
|
|
|
func TestMarshalJSON(t *testing.T) {
|
|
t.Run("int key", func(t *testing.T) {
|
|
om := New[int, any]()
|
|
om.Set(1, "bar")
|
|
om.Set(7, "baz")
|
|
om.Set(2, 28)
|
|
om.Set(3, 100)
|
|
om.Set(4, "baz")
|
|
om.Set(5, "28")
|
|
om.Set(6, "100")
|
|
om.Set(8, "baz")
|
|
om.Set(8, "baz")
|
|
om.Set(9, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque auctor augue accumsan mi maximus, quis viverra massa pretium. Phasellus imperdiet sapien a interdum sollicitudin. Duis at commodo lectus, a lacinia sem.")
|
|
|
|
b, err := json.Marshal(om)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, `{"1":"bar","7":"baz","2":28,"3":100,"4":"baz","5":"28","6":"100","8":"baz","9":"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque auctor augue accumsan mi maximus, quis viverra massa pretium. Phasellus imperdiet sapien a interdum sollicitudin. Duis at commodo lectus, a lacinia sem."}`, string(b))
|
|
})
|
|
|
|
t.Run("string key", func(t *testing.T) {
|
|
om := New[string, any]()
|
|
om.Set("test", "bar")
|
|
om.Set("abc", true)
|
|
|
|
b, err := json.Marshal(om)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, `{"test":"bar","abc":true}`, string(b))
|
|
})
|
|
|
|
t.Run("typed string key", func(t *testing.T) {
|
|
type myString string
|
|
om := New[myString, any]()
|
|
om.Set("test", "bar")
|
|
om.Set("abc", true)
|
|
|
|
b, err := json.Marshal(om)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, `{"test":"bar","abc":true}`, string(b))
|
|
})
|
|
|
|
t.Run("typed int key", func(t *testing.T) {
|
|
type myInt uint32
|
|
om := New[myInt, any]()
|
|
om.Set(1, "bar")
|
|
om.Set(7, "baz")
|
|
om.Set(2, 28)
|
|
om.Set(3, 100)
|
|
om.Set(4, "baz")
|
|
|
|
b, err := json.Marshal(om)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, `{"1":"bar","7":"baz","2":28,"3":100,"4":"baz"}`, string(b))
|
|
})
|
|
|
|
t.Run("TextMarshaller key", func(t *testing.T) {
|
|
om := New[marshallable, any]()
|
|
om.Set(marshallable(1), "bar")
|
|
om.Set(marshallable(28), true)
|
|
|
|
b, err := json.Marshal(om)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, `{"#1#":"bar","#28#":true}`, string(b))
|
|
})
|
|
|
|
t.Run("empty map", func(t *testing.T) {
|
|
om := New[string, any]()
|
|
|
|
b, err := json.Marshal(om)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, `{}`, string(b))
|
|
})
|
|
}
|
|
|
|
func TestUnmarshallJSON(t *testing.T) {
|
|
t.Run("int key", func(t *testing.T) {
|
|
data := `{"1":"bar","7":"baz","2":28,"3":100,"4":"baz","5":"28","6":"100","8":"baz"}`
|
|
|
|
om := New[int, any]()
|
|
require.NoError(t, json.Unmarshal([]byte(data), &om))
|
|
|
|
assertOrderedPairsEqual(t, om,
|
|
[]int{1, 7, 2, 3, 4, 5, 6, 8},
|
|
[]any{"bar", "baz", float64(28), float64(100), "baz", "28", "100", "baz"})
|
|
})
|
|
|
|
t.Run("string key", func(t *testing.T) {
|
|
data := `{"test":"bar","abc":true}`
|
|
|
|
om := New[string, any]()
|
|
require.NoError(t, json.Unmarshal([]byte(data), &om))
|
|
|
|
assertOrderedPairsEqual(t, om,
|
|
[]string{"test", "abc"},
|
|
[]any{"bar", true})
|
|
})
|
|
|
|
t.Run("typed string key", func(t *testing.T) {
|
|
data := `{"test":"bar","abc":true}`
|
|
|
|
type myString string
|
|
om := New[myString, any]()
|
|
require.NoError(t, json.Unmarshal([]byte(data), &om))
|
|
|
|
assertOrderedPairsEqual(t, om,
|
|
[]myString{"test", "abc"},
|
|
[]any{"bar", true})
|
|
})
|
|
|
|
t.Run("typed int key", func(t *testing.T) {
|
|
data := `{"1":"bar","7":"baz","2":28,"3":100,"4":"baz","5":"28","6":"100","8":"baz"}`
|
|
|
|
type myInt uint32
|
|
om := New[myInt, any]()
|
|
require.NoError(t, json.Unmarshal([]byte(data), &om))
|
|
|
|
assertOrderedPairsEqual(t, om,
|
|
[]myInt{1, 7, 2, 3, 4, 5, 6, 8},
|
|
[]any{"bar", "baz", float64(28), float64(100), "baz", "28", "100", "baz"})
|
|
})
|
|
|
|
t.Run("TextUnmarshaler key", func(t *testing.T) {
|
|
data := `{"#1#":"bar","#28#":true}`
|
|
|
|
om := New[marshallable, any]()
|
|
require.NoError(t, json.Unmarshal([]byte(data), &om))
|
|
|
|
assertOrderedPairsEqual(t, om,
|
|
[]marshallable{1, 28},
|
|
[]any{"bar", true})
|
|
})
|
|
|
|
t.Run("when fed with an input that's not an object", func(t *testing.T) {
|
|
for _, data := range []string{"true", `["foo"]`, "42", `"foo"`} {
|
|
om := New[int, any]()
|
|
require.Error(t, json.Unmarshal([]byte(data), &om))
|
|
}
|
|
})
|
|
|
|
t.Run("empty map", func(t *testing.T) {
|
|
data := `{}`
|
|
|
|
om := New[int, any]()
|
|
require.NoError(t, json.Unmarshal([]byte(data), &om))
|
|
|
|
assertLenEqual(t, om, 0)
|
|
})
|
|
}
|
|
|
|
// const specialCharacters = "\\\\/\"\b\f\n\r\t\x00\uffff\ufffd世界\u007f\u00ff\U0010FFFF"
|
|
const specialCharacters = "\uffff\ufffd世界\u007f\u00ff\U0010FFFF"
|
|
|
|
func TestJSONSpecialCharacters(t *testing.T) {
|
|
baselineMap := map[string]any{specialCharacters: specialCharacters}
|
|
baselineData, err := json.Marshal(baselineMap)
|
|
require.NoError(t, err) // baseline proves this key is supported by official json library
|
|
t.Logf("specialCharacters: %#v as []rune:%v", specialCharacters, []rune(specialCharacters))
|
|
t.Logf("baseline json data: %s", baselineData)
|
|
|
|
t.Run("marshal special characters", func(t *testing.T) {
|
|
om := New[string, any]()
|
|
om.Set(specialCharacters, specialCharacters)
|
|
b, err := json.Marshal(om)
|
|
require.NoError(t, err)
|
|
require.Equal(t, baselineData, b)
|
|
|
|
type myString string
|
|
om2 := New[myString, myString]()
|
|
om2.Set(specialCharacters, specialCharacters)
|
|
b, err = json.Marshal(om2)
|
|
require.NoError(t, err)
|
|
require.Equal(t, baselineData, b)
|
|
})
|
|
|
|
t.Run("unmarshall special characters", func(t *testing.T) {
|
|
om := New[string, any]()
|
|
require.NoError(t, json.Unmarshal(baselineData, &om))
|
|
assertOrderedPairsEqual(t, om,
|
|
[]string{specialCharacters},
|
|
[]any{specialCharacters})
|
|
|
|
type myString string
|
|
om2 := New[myString, myString]()
|
|
require.NoError(t, json.Unmarshal(baselineData, &om2))
|
|
assertOrderedPairsEqual(t, om2,
|
|
[]myString{specialCharacters},
|
|
[]myString{specialCharacters})
|
|
})
|
|
}
|
|
|
|
// to test structs that have nested map fields
|
|
type nestedMaps struct {
|
|
X int `json:"x" yaml:"x"`
|
|
M *OrderedMap[string, []*OrderedMap[int, *OrderedMap[string, any]]] `json:"m" yaml:"m"`
|
|
}
|
|
|
|
func TestJSONRoundTrip(t *testing.T) {
|
|
for _, testCase := range []struct {
|
|
name string
|
|
input string
|
|
targetFactory func() any
|
|
isPrettyPrinted bool
|
|
}{
|
|
{
|
|
name: "",
|
|
input: `{
|
|
"x": 28,
|
|
"m": {
|
|
"foo": [
|
|
{
|
|
"12": {
|
|
"i": 12,
|
|
"b": true,
|
|
"n": null,
|
|
"m": {
|
|
"a": "b",
|
|
"c": 28
|
|
}
|
|
},
|
|
"28": {
|
|
"a": false,
|
|
"b": [
|
|
1,
|
|
2,
|
|
3
|
|
]
|
|
}
|
|
},
|
|
{
|
|
"3": {
|
|
"c": null,
|
|
"d": 87
|
|
},
|
|
"4": {
|
|
"e": true
|
|
},
|
|
"5": {
|
|
"f": 4,
|
|
"g": 5,
|
|
"h": 6
|
|
}
|
|
}
|
|
],
|
|
"bar": [
|
|
{
|
|
"5": {
|
|
"foo": "bar"
|
|
}
|
|
}
|
|
]
|
|
}
|
|
}`,
|
|
targetFactory: func() any { return &nestedMaps{} },
|
|
isPrettyPrinted: true,
|
|
},
|
|
{
|
|
name: "with UTF-8 special chars in key",
|
|
input: `{"�":0}`,
|
|
targetFactory: func() any { return &OrderedMap[string, int]{} },
|
|
},
|
|
} {
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
target := testCase.targetFactory()
|
|
|
|
require.NoError(t, json.Unmarshal([]byte(testCase.input), target))
|
|
|
|
var (
|
|
out []byte
|
|
err error
|
|
)
|
|
if testCase.isPrettyPrinted {
|
|
out, err = json.MarshalIndent(target, "", " ")
|
|
} else {
|
|
out, err = json.Marshal(target)
|
|
}
|
|
|
|
if assert.NoError(t, err) {
|
|
assert.Equal(t, strings.TrimSpace(testCase.input), string(out))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func BenchmarkMarshalJSON(b *testing.B) {
|
|
om := New[int, any]()
|
|
om.Set(1, "bar")
|
|
om.Set(7, "baz")
|
|
om.Set(2, 28)
|
|
om.Set(3, 100)
|
|
om.Set(4, "baz")
|
|
om.Set(5, "28")
|
|
om.Set(6, "100")
|
|
om.Set(8, "baz")
|
|
om.Set(8, "baz")
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = json.Marshal(om)
|
|
}
|
|
}
|