func TestJoin(t *testing.T) { testing2. Expect("abc,abc,abc").Arg("abc", ",", 3). Expect("abc,abc").Arg("abc", ",", 2). Expect("abc").Arg("abc", ",", 1). Expect("").Arg("abc", ",", 0). Run(t, RepeatJoin) testing2. Expect("").Arg([]int{}, ","). Expect("1,2,3,4").Arg([]int{1, 2, 3, 4}, ","). Run(t, JoinInt) testing2. Expect("").Arg([]uint{}, ","). Expect("1,2,3,4").Arg([]uint{1, 2, 3, 4}, ","). Run(t, JoinUint) testing2. Expect("").Arg([]string{}, "=?", ", "). Expect("a=?").Arg([]string{"a"}, "=?", ", "). Expect("a=?, b=?, c=?").Arg([]string{"a", "b", "c"}, "=?", ", "). Run(t, SuffixJoin) }
func TestCols(t *testing.T) { var cols Cols = &cols{cols: []string{"id", "age", "name"}} testing2.Eq(t, 3, cols.Length()) testing2. Expect("?,?,?").Arg(cols.OnlyParam()). Expect("id,age,name").Arg(cols.String()). Expect("id=?,age=?,name=?").Arg(cols.Paramed()). Run(t, strings2.RemoveSpace) cols = singleCol("id") testing2.Eq(t, 1, cols.Length()) testing2. Expect("?").Arg(cols.OnlyParam()). Expect("id").Arg(cols.String()). Expect("id=?").Arg(cols.Paramed()). Run(t, strings2.RemoveSpace) cols = _emptyCols testing2.Eq(t, 0, cols.Length()) testing2. Expect("").Arg(cols.OnlyParam()). Expect("").Arg(cols.String()). Expect("").Arg(cols.Paramed()). Run(t, strings2.RemoveSpace) }
func testPager(p *Pager, t *testing.T) { testing2. Expect(p.BeginIndex).Arg("abcde"). Expect(p.BeginIndex).Arg(""). Expect(p.BeginIndex).Arg("-1"). Expect(p.BeginIndex).Arg("0"). Expect(p.BeginIndex).Arg("1"). Expect(p.PageSize).Arg("2"). Expect(p.PageSize*2).Arg("3"). Run(t, p.BeginByString) testing2. Expect(p.PageSize).Arg("abcde"). Expect(p.PageSize).Arg(""). Expect(p.PageSize).Arg("-1"). Expect(p.PageSize).Arg("0"). Expect(p.PageSize).Arg("1"). Expect(p.PageSize*2).Arg("2"). Expect(p.PageSize*3).Arg("3"). Run(t, p.EndByString) testing2. Expect(p.PageSize).Arg(-1). Expect(p.PageSize).Arg(0). Expect(p.PageSize).Arg(1). Expect(p.PageSize*2).Arg(2). Expect(p.PageSize*3).Arg(3). Run(t, p.End) }
func TestAbridgeString(t *testing.T) { testing2. Expect("ABC").Arg("AaaBbbCcc"). Expect("ABC").Arg("AaaBbbCcc"). Expect("").Arg(""). Run(t, ToAbridge) testing2. Expect("abc").Arg("AaaBbbCcc"). Expect("abc").Arg("AaaBbbCcc"). Expect("").Arg(""). Run(t, ToLowerAbridge) }
func TestNumMatched(t *testing.T) { testing2. Expect(0).Arg(IsNotEmpty, "", "", "", ""). Expect(1).Arg(IsNotEmpty, "1", "", "", ""). Expect(2).Arg(IsNotEmpty, "1", "2", "", ""). Run(t, NumMatched) testing2. Expect(4).Arg(IsEmpty, "", "", "", ""). Expect(3).Arg(IsEmpty, "1", "", "", ""). Expect(2).Arg(IsEmpty, "1", "2", "", ""). Run(t, NumMatched) }
func TestMidSep(t *testing.T) { testing2. Expect(-1).Arg("123", byte('1')). Expect(-1).Arg("123", byte('3')). Expect(-1).Arg("123", byte('4')). Expect(1).Arg("123", byte('2')). Run(t, MidIndex) testing2. Expect("", "").Arg("123", byte('1')). Expect("", "").Arg("123", byte('3')). Expect("", "").Arg("123", byte('4')). Expect("1", "3").Arg("123", byte('2')). Run(t, Separate) }
func TestSplitAtN(t *testing.T) { testing2. Expect(3).Arg("123123123", "12", 2). Expect(6).Arg("123123123", "12", 3). Expect(-1).Arg("123123123", "12", 4). Run(t, IndexN) }
func TestRemoveSpace(t *testing.T) { testing2. Expect("abcdefg").Arg(`a b c d e f g`). Run(t, RemoveSpace) }
func TestTrimQuote(t *testing.T) { testing2. Expect("aaa", true).Arg("\"aaa\""). Expect("aaa", true).Arg("'aaa'"). Expect("aaa", true).Arg("`aaa`"). Expect("", testing2.NonNil).Arg("`aaa"). Run(t, TrimQuote) }
func TestIndexNonSpace(t *testing.T) { testing2. Expect(1).Arg(" 1 "). Expect(-1).Arg(" "). Expect(0).Arg("a "). Run(t, IndexNonSpace). Run(t, LastIndexNonSpace) }
func TestCompare(t *testing.T) { testing2. Expect(1).Arg("123", "012"). Expect(-1).Arg("123", "212"). Expect(0).Arg("123", "123"). Expect(-1).Arg("123", "1234"). Expect(1).Arg("123", "12"). Run(t, Compare) }
func TestSnakeCase(t *testing.T) { testing2. Expect("_xy_xy").Arg("_xy_xy"). Expect("_xy_xy").Arg("_xy_xy"). Expect("_xy_xy").Arg("_xyXy"). Expect("_xy xy").Arg("_Xy Xy"). Expect("_xy_xy").Arg("_Xy_Xy"). Run(t, ToSnake) }
func TestUser(t *testing.T) { tt := testing2.Wrap(t) u1 := User{ Name: "User1", Age: 20, } tt.Nil(u1.Add()) // add user1 u2 := u1 // duplicate user name tt.Eq(ErrDuplicateUserName, u2.Add()) u2.Name = "User2" tt.Nil(u2.Add()) // add user2 f1 := Follow{ UserId: u1.Id, FollowUserId: 1024000, // user id doesn't exists } tt.Eq(ErrNoUser, f1.Add()) f1.FollowUserId = u2.Id tt.Nil(f1.Add()) // user1 follow user2 f2 := Follow{ UserId: u2.Id, FollowUserId: u1.Id, } tt. Nil(f2.Add()). // user2 follow user1 Eq(ErrFollowed, f2.Add()) tt. Nil(u1.ById()). // query latest user1 info Eq(1, u1.Followers). Eq(1, u1.Followings). Nil(u2.ById()). // query latest user2 info Eq(1, u2.Followers). Eq(1, u2.Followings) tt. Nil(f1.Delete()). // delete follow relationships Nil(f2.Delete()) tt. Nil(u1.ById()). // query latest user1 info Eq(0, u1.Followings). Eq(0, u1.Followings). Nil(u2.ById()). // query latest user2 info Eq(0, u2.Followings). Eq(0, u2.Followings) testing2. Expect(nil).Arg(u1.Id). // delete user1, user2 Expect(nil).Arg(u2.Id). Run(t, DeleteUserById) }
func TestParseHuman(t *testing.T) { testing2. Expect(time.Hour, nil).Arg("1H"). Expect(time.Minute, nil).Arg("1M"). Expect(time.Second, nil).Arg("1S"). Expect(time.Millisecond, nil).Arg("1m"). Expect(time.Microsecond, nil).Arg("1u"). Expect(time.Nanosecond, nil).Arg("1n"). Expect(time.Duration(0), testing2.NonNil).Arg("1z"). Run(t, ParseHuman) }
func TestIn(t *testing.T) { tt := testing2.Wrap(t) tt.Eq(1, StringIn("b", []string{"a", "b", "c"})) tt.Eq(0, StringIn("a", []string{"a", "b", "c"})) tt.Eq(-1, StringIn("d", []string{"a", "b", "c"})) tt.Eq(0, CharIn('a', "abc")) tt.Eq(1, CharIn('b', "abc")) tt.Eq(2, CharIn('d', "abd")) tt.Eq(-1, CharIn('e', "abcd")) testing2. Expect(uint(0)).Arg(-1, uint(1<<0|1<<2)). Expect(uint(0)).Arg(8, uint(1<<0|1<<2)). Expect(uint(0)).Arg(1, uint(1<<0|1<<2)). Expect(uint(1<<1)).Arg(1, uint(1<<1|1<<2|1<<3)). Expect(uint(1<<2)).Arg(2, uint(1<<2|1<<2|1<<3)). Run(t, BitIn) testing2. Expect(uint(0)).Arg(-1, uint(1<<0|1<<2)). Expect(uint(0)).Arg(2, uint(1<<0|1<<2)). Expect(uint(1<<9)).Arg(9, uint(1<<0|1<<2)). Expect(uint(1<<5)).Arg(5, uint(1<<1|1<<2|1<<3)). Expect(uint(1<<8)).Arg(8, uint(1<<2|1<<2|1<<3)). Run(t, BitNotIn) tt.Eq(2, ByteIn('A', 'B', 'C', 'A')) tt.Eq(0, ByteIn('A', 'A', 'B', 'C', 'A')) tt.Eq(-1, ByteIn('A', 'B', 'C')) tt.Eq(2, SortedNumberIn('C', 'A', 'B', 'C')) tt.Eq(0, SortedNumberIn('A', 'A', 'B', 'C', 'D')) tt.Eq(-1, SortedNumberIn('A', 'B', 'C')) tt.Eq(3, RuneIn('界', '你', '好', '世', '界')) tt.Eq(0, RuneIn('你', '你', '好', '世', '界')) tt.Eq(-1, RuneIn('是', '你', '好', '世', '界')) }
func TestCamelString(t *testing.T) { testing2. Expect("XyXy").Arg("xy_xy"). Expect("Xy__Xy").Arg("xy__Xy"). Expect("Xy Xy").Arg("xy Xy"). Expect("XY Xy").Arg("x_y Xy"). Expect("X_Y XY").Arg("x__y XY"). Expect("XY XY").Arg("x_y xY"). Expect("XY XY").Arg("x_y _x_y"). Expect(" XY").Arg(" x_y"). Run(t, ToCamel) }
func TestTrim(t *testing.T) { tt := testing2.Wrap(t) tt. Eq("0123", TrimAfter("01234567", "45")). Eq("4567", TrimBefore("01234567", "23")) left, right := ("["), ("]") testing2. Expect("123", true).Arg("[123]", left, right, true). Expect(testing2.NoCheck, false).Arg("[123", left, right, true). Expect("123", true).Arg("[123", left, right, false). Expect("123", true).Arg("123", left, right, true). Expect("", true).Arg("", left, right, true). Run(t, TrimWrap) testing2. Expect([]string{"1", "2", "3"}).Arg(" 1 , 2 , 3 ", ","). Run(t, SplitAndTrim) tt.Eq("abcde", TrimAndToLower(" ABCDE ")) tt.Eq("ABCDE", TrimAndToUpper(" abcde ")) }
func TestUnitSize(t *testing.T) { testing2. Expect(uint(1)).Arg(uint(0)). Expect(uint(1)).Arg(uint(1)). Expect(uint(1)).Arg(uint(2)). Expect(uint(2)).Arg(uint(3)). Expect(uint(2)).Arg(uint(4)). Expect(uint(3)).Arg(uint(5)). Expect(uint(3)).Arg(uint(6)). Expect(uint(3)).Arg(uint(7)). Expect(uint(3)).Arg(uint(8)). Expect(uint(4)).Arg(uint(9)). Run(t, UnitSize) }
func TestTrim(t *testing.T) { tt := testing2.Wrap(t) tt. Eq("0123", TrimAfter("01234567", "45")). Eq("4567", TrimBefore("01234567", "23")) left, right := ("["), ("]") testing2. Expect("123", true).Arg("[123]", left, right, true). Expect(testing2.NoCheck, false).Arg("[123", left, right, true). Expect("123", true).Arg("[123", left, right, false). Expect("123", true).Arg("123", left, right, true). Run(t, TrimWrap) }
func TestMergeSpace(t *testing.T) { testing2. Expect("a b c dd").Arg(" a b c dd ", true). Expect(" a b c dd ").Arg(" a b c dd ", false). Run(t, MergeSpace) }
func TestRepeatJoin(t *testing.T) { testing2. Expect("abc=?,abc=?,abc").Arg("abc", "=?,", 3). Run(t, RepeatJoin) }
func TestLastIndexByte(t *testing.T) { testing2. Expect(0).Arg("123", byte('1')). Expect(-1).Arg("123", byte('4')). Run(t, LastIndexByte) }