135 lines
3 KiB
Go
135 lines
3 KiB
Go
package stringutils
|
|
|
|
import (
|
|
"encoding/json"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestStrSliceMarshalJSON(t *testing.T) {
|
|
strss := map[*StrSlice]string{
|
|
nil: "",
|
|
&StrSlice{}: "null",
|
|
&StrSlice{[]string{"/bin/sh", "-c", "echo"}}: `["/bin/sh","-c","echo"]`,
|
|
}
|
|
|
|
for strs, expected := range strss {
|
|
data, err := strs.MarshalJSON()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(data) != expected {
|
|
t.Fatalf("Expected %v, got %v", expected, string(data))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStrSliceUnmarshalJSON(t *testing.T) {
|
|
parts := map[string][]string{
|
|
"": {"default", "values"},
|
|
"[]": {},
|
|
`["/bin/sh","-c","echo"]`: {"/bin/sh", "-c", "echo"},
|
|
}
|
|
for json, expectedParts := range parts {
|
|
strs := &StrSlice{
|
|
[]string{"default", "values"},
|
|
}
|
|
if err := strs.UnmarshalJSON([]byte(json)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
actualParts := strs.Slice()
|
|
if len(actualParts) != len(expectedParts) {
|
|
t.Fatalf("Expected %v parts, got %v (%v)", len(expectedParts), len(actualParts), expectedParts)
|
|
}
|
|
for index, part := range actualParts {
|
|
if part != expectedParts[index] {
|
|
t.Fatalf("Expected %v, got %v", expectedParts, actualParts)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStrSliceUnmarshalString(t *testing.T) {
|
|
var e *StrSlice
|
|
echo, err := json.Marshal("echo")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := json.Unmarshal(echo, &e); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
slice := e.Slice()
|
|
if len(slice) != 1 {
|
|
t.Fatalf("expected 1 element after unmarshal: %q", slice)
|
|
}
|
|
|
|
if slice[0] != "echo" {
|
|
t.Fatalf("expected `echo`, got: %q", slice[0])
|
|
}
|
|
}
|
|
|
|
func TestStrSliceUnmarshalSlice(t *testing.T) {
|
|
var e *StrSlice
|
|
echo, err := json.Marshal([]string{"echo"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := json.Unmarshal(echo, &e); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
slice := e.Slice()
|
|
if len(slice) != 1 {
|
|
t.Fatalf("expected 1 element after unmarshal: %q", slice)
|
|
}
|
|
|
|
if slice[0] != "echo" {
|
|
t.Fatalf("expected `echo`, got: %q", slice[0])
|
|
}
|
|
}
|
|
|
|
func TestStrSliceToString(t *testing.T) {
|
|
slices := map[*StrSlice]string{
|
|
NewStrSlice(""): "",
|
|
NewStrSlice("one"): "one",
|
|
NewStrSlice("one", "two"): "one two",
|
|
}
|
|
for s, expected := range slices {
|
|
toString := s.ToString()
|
|
if toString != expected {
|
|
t.Fatalf("Expected %v, got %v", expected, toString)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStrSliceLen(t *testing.T) {
|
|
var emptyStrSlice *StrSlice
|
|
slices := map[*StrSlice]int{
|
|
NewStrSlice(""): 1,
|
|
NewStrSlice("one"): 1,
|
|
NewStrSlice("one", "two"): 2,
|
|
emptyStrSlice: 0,
|
|
}
|
|
for s, expected := range slices {
|
|
if s.Len() != expected {
|
|
t.Fatalf("Expected %d, got %d", s.Len(), expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStrSliceSlice(t *testing.T) {
|
|
var emptyStrSlice *StrSlice
|
|
slices := map[*StrSlice][]string{
|
|
NewStrSlice("one"): {"one"},
|
|
NewStrSlice("one", "two"): {"one", "two"},
|
|
emptyStrSlice: nil,
|
|
}
|
|
for s, expected := range slices {
|
|
if !reflect.DeepEqual(s.Slice(), expected) {
|
|
t.Fatalf("Expected %v, got %v", s.Slice(), expected)
|
|
}
|
|
}
|
|
}
|