825 lines
19 KiB
Go
825 lines
19 KiB
Go
package stream_test
|
|
|
|
import (
|
|
"github.com/kercylan98/minotaur/utils/stream"
|
|
"testing"
|
|
)
|
|
|
|
func TestNewString(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "hello"},
|
|
{name: "case2", in: "world", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s) = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_String(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "hello"},
|
|
{name: "case2", in: "world", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).String()
|
|
if got != c.want {
|
|
t.Fatalf("String(%s).String() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Index(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
i int
|
|
want string
|
|
shouldPanic bool
|
|
}{
|
|
{name: "case1", in: "hello", i: 0, want: "h", shouldPanic: false},
|
|
{name: "case2", in: "world", i: 2, want: "r", shouldPanic: false},
|
|
{name: "case3", in: "world", i: 5, want: "", shouldPanic: true},
|
|
{name: "case4", in: "world", i: -1, want: "", shouldPanic: true},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
defer func() {
|
|
if r := recover(); (r != nil) != c.shouldPanic {
|
|
t.Fatalf("NewString(%s).Index(%d) should panic", c.in, c.i)
|
|
}
|
|
}()
|
|
got := stream.NewString(c.in).Index(c.i)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Index(%d) = %s; want %s", c.in, c.i, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Range(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
start int
|
|
end int
|
|
want string
|
|
shouldPanic bool
|
|
}{
|
|
{name: "case1", in: "hello", start: 0, end: 2, want: "he", shouldPanic: false},
|
|
{name: "case2", in: "world", start: 2, end: 5, want: "rld", shouldPanic: false},
|
|
{name: "case3", in: "world", start: 5, end: 6, want: "", shouldPanic: true},
|
|
{name: "case4", in: "world", start: -1, end: 6, want: "", shouldPanic: true},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
defer func() {
|
|
if r := recover(); (r != nil) != c.shouldPanic {
|
|
t.Fatalf("NewString(%s).Range(%d, %d) should panic", c.in, c.start, c.end)
|
|
}
|
|
}()
|
|
got := stream.NewString(c.in).Range(c.start, c.end)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Range(%d, %d) = %s; want %s", c.in, c.start, c.end, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_TrimSpace(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: " hello ", want: "hello"},
|
|
{name: "case2", in: " world ", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).TrimSpace()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).TrimSpace() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Trim(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
cs string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", cs: "h", want: "ello"},
|
|
{name: "case2", in: "world", cs: "d", want: "worl"},
|
|
{name: "none", in: "world", cs: "", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Trim(c.cs)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Trim(%s) = %s; want %s", c.in, c.cs, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_TrimPrefix(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
prefix string
|
|
want string
|
|
isEqual bool
|
|
}{
|
|
{name: "case1", in: "hello", prefix: "h", want: "ello", isEqual: false},
|
|
{name: "case2", in: "world", prefix: "w", want: "orld", isEqual: false},
|
|
{name: "none", in: "world", prefix: "x", want: "world", isEqual: true},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).TrimPrefix(c.prefix)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).TrimPrefix(%s) = %s; want %s", c.in, c.prefix, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_TrimSuffix(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
suffix string
|
|
want string
|
|
isEqual bool
|
|
}{
|
|
{name: "case1", in: "hello", suffix: "o", want: "hell", isEqual: false},
|
|
{name: "case2", in: "world", suffix: "d", want: "worl", isEqual: false},
|
|
{name: "none", in: "world", suffix: "x", want: "world", isEqual: true},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).TrimSuffix(c.suffix)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).TrimSuffix(%s) = %s; want %s", c.in, c.suffix, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_ToUpper(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "HELLO"},
|
|
{name: "case2", in: "world", want: "WORLD"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).ToUpper()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).ToUpper() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_ToLower(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "HELLO", want: "hello"},
|
|
{name: "case2", in: "WORLD", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).ToLower()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).ToLower() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Equal(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
ss string
|
|
want bool
|
|
}{
|
|
{name: "case1", in: "hello", ss: "hello", want: true},
|
|
{name: "case2", in: "world", ss: "world", want: true},
|
|
{name: "case3", in: "world", ss: "worldx", want: false},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Equal(c.ss)
|
|
if got != c.want {
|
|
t.Fatalf("NewString(%s).Equal(%s) = %t; want %t", c.in, c.ss, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_HasPrefix(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
prefix string
|
|
want bool
|
|
}{
|
|
{name: "case1", in: "hello", prefix: "h", want: true},
|
|
{name: "case2", in: "world", prefix: "w", want: true},
|
|
{name: "case3", in: "world", prefix: "x", want: false},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).HasPrefix(c.prefix)
|
|
if got != c.want {
|
|
t.Fatalf("NewString(%s).HasPrefix(%s) = %t; want %t", c.in, c.prefix, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Len(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want int
|
|
}{
|
|
{name: "case1", in: "hello", want: 5},
|
|
{name: "case2", in: "world", want: 5},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Len()
|
|
if got != c.want {
|
|
t.Fatalf("NewString(%s).Len() = %d; want %d", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Contains(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
ss string
|
|
want bool
|
|
}{
|
|
{name: "case1", in: "hello", ss: "he", want: true},
|
|
{name: "case2", in: "world", ss: "or", want: true},
|
|
{name: "case3", in: "world", ss: "x", want: false},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Contains(c.ss)
|
|
if got != c.want {
|
|
t.Fatalf("NewString(%s).Contains(%s) = %t; want %t", c.in, c.ss, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Count(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
ss string
|
|
want int
|
|
}{
|
|
{name: "case1", in: "hello", ss: "l", want: 2},
|
|
{name: "case2", in: "world", ss: "o", want: 1},
|
|
{name: "case3", in: "world", ss: "x", want: 0},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Count(c.ss)
|
|
if got != c.want {
|
|
t.Fatalf("NewString(%s).Count(%s) = %d; want %d", c.in, c.ss, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Repeat(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
count int
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", count: 2, want: "hellohello"},
|
|
{name: "case2", in: "world", count: 3, want: "worldworldworld"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Repeat(c.count)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Repeat(%d) = %s; want %s", c.in, c.count, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Replace(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
old string
|
|
new string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", old: "l", new: "x", want: "hexxo"},
|
|
{name: "case2", in: "world", old: "o", new: "x", want: "wxrld"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Replace(c.old, c.new, -1)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Replace(%s, %s) = %s; want %s", c.in, c.old, c.new, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_ReplaceAll(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
old string
|
|
new string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", old: "l", new: "x", want: "hexxo"},
|
|
{name: "case2", in: "world", old: "o", new: "x", want: "wxrld"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).ReplaceAll(c.old, c.new)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).ReplaceAll(%s, %s) = %s; want %s", c.in, c.old, c.new, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Append(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
ss string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", ss: " world", want: "hello world"},
|
|
{name: "case2", in: "world", ss: " hello", want: "world hello"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Append(c.ss)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Append(%s) = %s; want %s", c.in, c.ss, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Prepend(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
ss string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", ss: "world ", want: "world hello"},
|
|
{name: "case2", in: "world", ss: "hello ", want: "hello world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Prepend(c.ss)
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Prepend(%s) = %s; want %s", c.in, c.ss, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Clear(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: ""},
|
|
{name: "case2", in: "world", want: ""},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Clear()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Clear() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Reverse(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "olleh"},
|
|
{name: "case2", in: "world", want: "dlrow"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Reverse()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Reverse() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Queto(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "\"hello\""},
|
|
{name: "case2", in: "world", want: "\"world\""},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Queto()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Queto() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_QuetoToASCII(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "\"hello\""},
|
|
{name: "case2", in: "world", want: "\"world\""},
|
|
{name: "case3", in: "你好", want: "\"\\u4f60\\u597d\""},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).QuetoToASCII()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).QuetoToASCII() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_FirstUpper(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "Hello"},
|
|
{name: "case2", in: "world", want: "World"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).FirstUpper()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).FirstUpper() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_FirstLower(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "Hello", want: "hello"},
|
|
{name: "case2", in: "World", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).FirstLower()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).FirstLower() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_SnakeCase(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "HelloWorld", want: "hello_world"},
|
|
{name: "case2", in: "HelloWorldHello", want: "hello_world_hello"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).SnakeCase()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).SnakeCase() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_CamelCase(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello_world", want: "helloWorld"},
|
|
{name: "case2", in: "hello_world_hello", want: "helloWorldHello"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).CamelCase()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).CamelCase() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_KebabCase(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "HelloWorld", want: "hello-world"},
|
|
{name: "case2", in: "HelloWorldHello", want: "hello-world-hello"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).KebabCase()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).KebabCase() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_TitleCase(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello_world", want: "HelloWorld"},
|
|
{name: "case2", in: "hello_world_hello", want: "HelloWorldHello"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).TitleCase()
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).TitleCase() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Bytes(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "hello"},
|
|
{name: "case2", in: "world", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Bytes()
|
|
if string(got) != c.want {
|
|
t.Fatalf("NewString(%s).Bytes() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Runes(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "hello"},
|
|
{name: "case2", in: "world", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Runes()
|
|
if string(got) != c.want {
|
|
t.Fatalf("NewString(%s).Runes() = %v; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Default(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "", want: "default"},
|
|
{name: "case2", in: "world", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Default("default")
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Default() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Handle(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "hello"},
|
|
{name: "case2", in: "world", want: "world"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
var w string
|
|
got := stream.NewString(c.in).Handle(func(s string) {
|
|
w = s
|
|
})
|
|
if w != c.want {
|
|
t.Fatalf("NewString(%s).Handle() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Update(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{name: "case1", in: "hello", want: "HELLO"},
|
|
{name: "case2", in: "world", want: "WORLD"},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Update(func(s string) string {
|
|
return stream.NewString(s).ToUpper().String()
|
|
})
|
|
if got.String() != c.want {
|
|
t.Fatalf("NewString(%s).Update() = %s; want %s", c.in, got, c.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Split(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
sep string
|
|
want []string
|
|
}{
|
|
{name: "case1", in: "hello world", sep: " ", want: []string{"hello", "world"}},
|
|
{name: "case2", in: "hello,world", sep: ",", want: []string{"hello", "world"}},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Split(c.sep)
|
|
for i, v := range got {
|
|
if v != c.want[i] {
|
|
t.Fatalf("NewString(%s).Split(%s) = %v; want %v", c.in, c.sep, got, c.want)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_SplitN(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
sep string
|
|
n int
|
|
want []string
|
|
}{
|
|
{name: "case1", in: "hello world", sep: " ", n: 2, want: []string{"hello", "world"}},
|
|
{name: "case2", in: "hello,world", sep: ",", n: 2, want: []string{"hello", "world"}},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).SplitN(c.sep, c.n)
|
|
for i, v := range got {
|
|
if v != c.want[i] {
|
|
t.Fatalf("NewString(%s).SplitN(%s, %d) = %v; want %v", c.in, c.sep, c.n, got, c.want)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestString_Batched(t *testing.T) {
|
|
var cases = []struct {
|
|
name string
|
|
in string
|
|
size int
|
|
want []string
|
|
}{
|
|
{name: "case1", in: "hello world", size: 5, want: []string{"hello", " worl", "d"}},
|
|
{name: "case2", in: "hello,world", size: 5, want: []string{"hello", ",worl", "d"}},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
got := stream.NewString(c.in).Batched(c.size)
|
|
for i, v := range got {
|
|
if v != c.want[i] {
|
|
t.Fatalf("NewString(%s).Batched(%d) = %v; want %v", c.in, c.size, got, c.want)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|