assert => is

thoas · Jan 13, 2017 · b7851f1 · b7851f1
1 parent e5fc744
commit b7851f1
Show file tree

Hide file tree

Showing 7 changed files with 152 additions and 152 deletions.
diff --git a/helpers_test.go b/helpers_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestSliceOf(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
 	f := &Foo{
 		ID:        1,
@@ -24,48 +24,48 @@ func TestSliceOf(t *testing.T) {
 
 	resultType := reflect.TypeOf(result)
 
-	assert.True(resultType.Kind() == reflect.Slice)
-	assert.True(resultType.Elem().Kind() == reflect.Ptr)
+	is.True(resultType.Kind() == reflect.Slice)
+	is.True(resultType.Elem().Kind() == reflect.Ptr)
 
 	elemType := resultType.Elem().Elem()
 
-	assert.True(elemType.Kind() == reflect.Struct)
+	is.True(elemType.Kind() == reflect.Struct)
 
 	value := reflect.ValueOf(result)
 
-	assert.Equal(value.Len(), 1)
+	is.Equal(value.Len(), 1)
 
 	_, ok := value.Index(0).Interface().(*Foo)
 
-	assert.True(ok)
+	is.True(ok)
 }
 
 func TestRandomInt(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.True(RandomInt(0, 10) <= 10)
+	is.True(RandomInt(0, 10) <= 10)
 }
 
 func TestShard(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
 	tokey := "e89d66bdfdd4dd26b682cc77e23a86eb"
 
-	assert.Equal(Shard(tokey, 1, 2, false), []string{"e", "8", "e89d66bdfdd4dd26b682cc77e23a86eb"})
-	assert.Equal(Shard(tokey, 2, 2, false), []string{"e8", "9d", "e89d66bdfdd4dd26b682cc77e23a86eb"})
-	assert.Equal(Shard(tokey, 2, 3, true), []string{"e8", "9d", "66", "bdfdd4dd26b682cc77e23a86eb"})
+	is.Equal(Shard(tokey, 1, 2, false), []string{"e", "8", "e89d66bdfdd4dd26b682cc77e23a86eb"})
+	is.Equal(Shard(tokey, 2, 2, false), []string{"e8", "9d", "e89d66bdfdd4dd26b682cc77e23a86eb"})
+	is.Equal(Shard(tokey, 2, 3, true), []string{"e8", "9d", "66", "bdfdd4dd26b682cc77e23a86eb"})
 }
 
 func TestRandomString(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Len(RandomString(10), 10)
+	is.Len(RandomString(10), 10)
 
 	result := RandomString(10, []rune("abcdefg"))
 
-	assert.Len(result, 10)
+	is.Len(result, 10)
 
 	for _, char := range result {
-		assert.True(char >= []rune("a")[0] && char <= []rune("g")[0])
+		is.True(char >= []rune("a")[0] && char <= []rune("g")[0])
 	}
 }
diff --git a/map_test.go b/map_test.go
@@ -8,29 +8,29 @@ import (
 )
 
 func TestKeys(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
 	results := Keys(map[string]int{"one": 1, "two": 2}).([]string)
 	sort.Strings(results)
 
-	assert.Equal(results, []string{"one", "two"})
+	is.Equal(results, []string{"one", "two"})
 
 	fields := Keys(foo).([]string)
 
 	sort.Strings(fields)
 
-	assert.Equal(fields, []string{"Age", "Bar", "Bars", "EmptyValue", "FirstName", "ID", "LastName"})
+	is.Equal(fields, []string{"Age", "Bar", "Bars", "EmptyValue", "FirstName", "ID", "LastName"})
 }
 
 func TestValues(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
 	results := Values(map[string]int{"one": 1, "two": 2}).([]int)
 	sort.Ints(results)
 
-	assert.Equal(results, []int{1, 2})
+	is.Equal(results, []int{1, 2})
 
 	values := Values(foo).([]interface{})
 
-	assert.Len(values, 7)
+	is.Len(values, 7)
 }
diff --git a/presence_test.go b/presence_test.go
@@ -7,9 +7,9 @@ import (
 )
 
 func TestContains(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.True(Contains([]string{"foo", "bar"}, "bar"))
+	is.True(Contains([]string{"foo", "bar"}, "bar"))
 
 	f := &Foo{
 		ID:        1,
@@ -30,23 +30,23 @@ func TestContains(t *testing.T) {
 
 	results := []*Foo{f}
 
-	assert.True(Contains(results, f))
-	assert.False(Contains(results, nil))
-	assert.False(Contains(results, b))
+	is.True(Contains(results, f))
+	is.False(Contains(results, nil))
+	is.False(Contains(results, b))
 
-	assert.True(Contains("florent", "rent"))
-	assert.False(Contains("florent", "gilles"))
+	is.True(Contains("florent", "rent"))
+	is.False(Contains("florent", "gilles"))
 
 	mapping := ToMap(results, "ID")
 
-	assert.True(Contains(mapping, 1))
-	assert.False(Contains(mapping, 2))
+	is.True(Contains(mapping, 1))
+	is.False(Contains(mapping, 2))
 }
 
 func TestIndexOf(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Equal(IndexOf([]string{"foo", "bar"}, "bar"), 1)
+	is.Equal(IndexOf([]string{"foo", "bar"}, "bar"), 1)
 
 	f := &Foo{
 		ID:        1,
@@ -67,34 +67,34 @@ func TestIndexOf(t *testing.T) {
 
 	results := []*Foo{f}
 
-	assert.Equal(IndexOf(results, f), 0)
-	assert.Equal(IndexOf(results, b), -1)
+	is.Equal(IndexOf(results, f), 0)
+	is.Equal(IndexOf(results, b), -1)
 }
 
 func TestLastIndexOf(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Equal(LastIndexOf([]string{"foo", "bar", "bar"}, "bar"), 2)
-	assert.Equal(LastIndexOf([]int{1, 2, 2, 3}, 2), 2)
-	assert.Equal(LastIndexOf([]int{1, 2, 2, 3}, 4), -1)
+	is.Equal(LastIndexOf([]string{"foo", "bar", "bar"}, "bar"), 2)
+	is.Equal(LastIndexOf([]int{1, 2, 2, 3}, 2), 2)
+	is.Equal(LastIndexOf([]int{1, 2, 2, 3}, 4), -1)
 }
 
 func TestFilter(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
 	r := Filter([]int{1, 2, 3, 4}, func(x int) bool {
 		return x%2 == 0
 	})
 
-	assert.Equal(r, []int{2, 4})
+	is.Equal(r, []int{2, 4})
 }
 
 func TestFind(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
 	r := Find([]int{1, 2, 3, 4}, func(x int) bool {
 		return x%2 == 0
 	})
 
-	assert.Equal(r, 2)
+	is.Equal(r, 2)
 }
diff --git a/retrieve_test.go b/retrieve_test.go
@@ -7,42 +7,42 @@ import (
 )
 
 func TestGetSlice(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Equal(Get(SliceOf(foo), "ID"), []int{1})
-	assert.Equal(Get(SliceOf(foo), "Bar.Name"), []string{"Test"})
-	assert.Equal(Get(SliceOf(foo), "Bar"), []*Bar{bar})
+	is.Equal(Get(SliceOf(foo), "ID"), []int{1})
+	is.Equal(Get(SliceOf(foo), "Bar.Name"), []string{"Test"})
+	is.Equal(Get(SliceOf(foo), "Bar"), []*Bar{bar})
 }
 
 func TestGetSliceMultiLevel(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Equal(Get(foo, "Bar.Bars.Bar.Name"), []string{"Level2-1", "Level2-2"})
-	assert.Equal(Get(SliceOf(foo), "Bar.Bars.Bar.Name"), []string{"Level2-1", "Level2-2"})
+	is.Equal(Get(foo, "Bar.Bars.Bar.Name"), []string{"Level2-1", "Level2-2"})
+	is.Equal(Get(SliceOf(foo), "Bar.Bars.Bar.Name"), []string{"Level2-1", "Level2-2"})
 }
 
 func TestGetNull(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Equal(Get(foo, "EmptyValue.Int64"), int64(10))
-	assert.Equal(Get(SliceOf(foo), "EmptyValue.Int64"), []int64{10})
+	is.Equal(Get(foo, "EmptyValue.Int64"), int64(10))
+	is.Equal(Get(SliceOf(foo), "EmptyValue.Int64"), []int64{10})
 }
 
 func TestGetNil(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Equal(Get(foo2, "Bar.Name"), nil)
-	assert.Equal(Get([]*Foo{foo, foo2}, "Bar.Name"), []string{"Test"})
+	is.Equal(Get(foo2, "Bar.Name"), nil)
+	is.Equal(Get([]*Foo{foo, foo2}, "Bar.Name"), []string{"Test"})
 }
 
 func TestGetSimple(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Equal(Get(foo, "ID"), 1)
+	is.Equal(Get(foo, "ID"), 1)
 
-	assert.Equal(Get(foo, "Bar.Name"), "Test")
+	is.Equal(Get(foo, "Bar.Name"), "Test")
 
 	result := Get(foo, "Bar.Bars.Name")
 
-	assert.Equal(result, []string{"Level1-1", "Level1-2"})
+	is.Equal(result, []string{"Level1-1", "Level1-2"})
 }
diff --git a/scan_test.go b/scan_test.go
@@ -7,7 +7,7 @@ import (
 )
 
 func TestForEach(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
 	results := []int{}
 
@@ -17,28 +17,28 @@ func TestForEach(t *testing.T) {
 		}
 	})
 
-	assert.Equal(results, []int{2, 4})
+	is.Equal(results, []int{2, 4})
 
 	mapping := map[int]string{
 		1: "Florent",
 		2: "Gilles",
 	}
 
 	ForEach(mapping, func(k int, v string) {
-		assert.Equal(v, mapping[k])
+		is.Equal(v, mapping[k])
 	})
 }
 
 func TestForEachRight(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
 	results := []int{}
 
 	ForEachRight([]int{1, 2, 3, 4}, func(x int) {
 		results = append(results, x*2)
 	})
 
-	assert.Equal(results, []int{8, 6, 4, 2})
+	is.Equal(results, []int{8, 6, 4, 2})
 
 	mapping := map[int]string{
 		1: "Florent",
@@ -48,22 +48,22 @@ func TestForEachRight(t *testing.T) {
 	mapKeys := []int{}
 
 	ForEachRight(mapping, func(k int, v string) {
-		assert.Equal(v, mapping[k])
+		is.Equal(v, mapping[k])
 
 		mapKeys = append(mapKeys, k)
 	})
 
-	assert.Equal(mapKeys, []int{2, 1})
+	is.Equal(mapKeys, []int{2, 1})
 }
 
 func TestHead(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Equal(Head([]int{1, 2, 3, 4}), 1)
+	is.Equal(Head([]int{1, 2, 3, 4}), 1)
 }
 
 func TestLast(t *testing.T) {
-	assert := assert.New(t)
+	is := assert.New(t)
 
-	assert.Equal(Last([]int{1, 2, 3, 4}), 4)
+	is.Equal(Last([]int{1, 2, 3, 4}), 4)
 }