use t.Fatal instead t.Error

TTWShell · TTWShell · commit 00b0ef535ec5 · 2017-05-27T17:09:13.000+08:00
diff --git a/leetcode/array/generate_test.go b/leetcode/array/generate_test.go
@@ -9,7 +9,7 @@ func Test_generate(t *testing.T) {
 	for i := 0; i < len(r); i++ {
 		for j := 0; j < len(r[i]); j++ {
 			if r[i][j] != result[i][j] {
-				t.Error(r, result)
+				t.Fatal(r, result)
 			}
 		}
 	}
diff --git a/leetcode/array/getRow_test.go b/leetcode/array/getRow_test.go
@@ -8,7 +8,7 @@ func Test_getRow(t *testing.T) {
 		r := getRow(i)
 		for j := 0; j < len(r); j++ {
 			if r[j] != result[i][j] {
-				t.Error(i-1, result[i], r)
+				t.Fatal(i-1, result[i], r)
 			}
 		}
 	}
diff --git a/leetcode/array/majorityElement_test.go b/leetcode/array/majorityElement_test.go
@@ -5,10 +5,10 @@ import "testing"
 func Test_majorityElement(t *testing.T) {
 	nums := []int{1, 2, 3, 4, 2, 2, 2}
 	if r := majorityElement(nums); r != 2 {
-		t.Error(nums, r)
+		t.Fatal(nums, r)
 	}
 	nums = []int{1}
 	if r := majorityElement(nums); r != 1 {
-		t.Error(nums, r)
+		t.Fatal(nums, r)
 	}
 }
diff --git a/leetcode/array/maxSubArray_test.go b/leetcode/array/maxSubArray_test.go
@@ -5,16 +5,16 @@ import "testing"
 func Test_maxSubArray(t *testing.T) {
 	nums := []int{-2, 1, -3, 4, -1, 2, 1, -5, 4}
 	if r := maxSubArray(nums); r != 6 {
-		t.Error(r)
+		t.Fatal(r)
 	}
 
 	nums = []int{-2, -3, -1, -5}
 	if r := maxSubArray(nums); r != -1 {
-		t.Error(r)
+		t.Fatal(r)
 	}
 
 	nums = []int{-1, 2}
 	if r := maxSubArray(nums); r != 2 {
-		t.Error(r)
+		t.Fatal(r)
 	}
 }
diff --git a/leetcode/array/merge_test.go b/leetcode/array/merge_test.go
@@ -13,7 +13,7 @@ func Test_merge(t *testing.T) {
 
 	for i := 0; i < len(result); i++ {
 		if result[i] != nums1[i] {
-			t.Error(result, nums1)
+			t.Fatal(result, nums1)
 		}
 	}
 }
diff --git a/leetcode/array/plusOne_test.go b/leetcode/array/plusOne_test.go
@@ -8,7 +8,7 @@ func Test_plusOne(t *testing.T) {
 	r := plusOne(digits)
 	for i := 0; i < len(r); i++ {
 		if r[i] != result[i] {
-			t.Error(result, r)
+			t.Fatal(result, r)
 		}
 	}
 }
diff --git a/leetcode/array/removeDuplicates_test.go b/leetcode/array/removeDuplicates_test.go
@@ -8,7 +8,7 @@ func Test_removeDuplicates(t *testing.T) {
 	length := removeDuplicates(nums)
 	for i := 0; i < len(dealedNums); i++ {
 		if length != 6 || nums[i] != dealedNums[i] {
-			t.Error("return is:", length, nums[i], "!=", dealedNums[i])
+			t.Fatal("return is:", length, nums[i], "!=", dealedNums[i])
 		}
 	}
 
diff --git a/leetcode/array/removeElement_test.go b/leetcode/array/removeElement_test.go
@@ -8,7 +8,7 @@ func Test_removeElement(t *testing.T) {
 	length := removeElement(input, 3)
 	for i := 0; i < len(result); i++ {
 		if length != 8 || input[i] != result[i] {
-			t.Error(length, input[i], result[i])
+			t.Fatal(length, input[i], result[i])
 		}
 	}
 }
diff --git a/leetcode/array/rotate_test.go b/leetcode/array/rotate_test.go
@@ -9,7 +9,7 @@ func Test_rotate(t *testing.T) {
 	rotate(nums, 3)
 	for i := 0; i < len(nums); i++ {
 		if nums[i] != result[i] {
-			t.Error(nums, result)
+			t.Fatal(nums, result)
 		}
 	}
 }
diff --git a/leetcode/array/searchInsert_test.go b/leetcode/array/searchInsert_test.go
@@ -8,7 +8,7 @@ func Test_searchInsert(t *testing.T) {
 	results := []int{2, 1, 4, 0}
 	for i := 0; i < len(targets); i++ {
 		if r := searchInsert(nums, targets[i]); r != results[i] {
-			t.Error(nums, targets[i], r)
+			t.Fatal(nums, targets[i], r)
 		}
 	}
 }
diff --git a/leetcode/array/twoSum2_test.go b/leetcode/array/twoSum2_test.go
@@ -6,6 +6,6 @@ func Test_twoSum2(t *testing.T) {
 	numbers := []int{2, 7, 11, 15}
 	target := 9
 	if r := twoSum2(numbers, target); r[0] != 1 || r[1] != 2 {
-		t.Error(numbers, target, r)
+		t.Fatal(numbers, target, r)
 	}
 }
diff --git a/leetcode/array/twoSum_test.go b/leetcode/array/twoSum_test.go
@@ -6,6 +6,6 @@ func Test_twoSum(t *testing.T) {
 	nums := []int{2, 7, 11, 15}
 	result := twoSum(nums, 9)
 	if result[0] != 0 || result[1] != 1 {
-		t.Error(result)
+		t.Fatal(result)
 	}
 }
diff --git a/leetcode/dynamic-programming/climbStairs_test.go b/leetcode/dynamic-programming/climbStairs_test.go
@@ -7,7 +7,7 @@ func Test_climbStairs(t *testing.T) {
 	results := []int{0, 0, 1, 2, 3, 5}
 	for i := 0; i < len(nums); i++ {
 		if result := climbStairs(nums[i]); result != results[i] {
-			t.Error(nums[i], results[i], result)
+			t.Fatal(nums[i], results[i], result)
 		}
 	}
 }
diff --git a/leetcode/dynamic-programming/maxProfit2_test.go b/leetcode/dynamic-programming/maxProfit2_test.go
@@ -8,7 +8,7 @@ func Test_maxProfit2(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := maxProfit2(input[i]); r != result[i] {
-			t.Error(input[i], r, "Expected:", result[i])
+			t.Fatal(input[i], r, "Expected:", result[i])
 		}
 	}
 }
diff --git a/leetcode/dynamic-programming/maxProfit3_test.go b/leetcode/dynamic-programming/maxProfit3_test.go
@@ -8,7 +8,7 @@ func Test_maxProfit3(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := maxProfit3(input[i]); r != result[i] {
-			t.Error(input[i], r, "Expected:", result[i])
+			t.Fatal(input[i], r, "Expected:", result[i])
 		}
 	}
 }
diff --git a/leetcode/dynamic-programming/maxProfit4_test.go b/leetcode/dynamic-programming/maxProfit4_test.go
@@ -8,7 +8,7 @@ func Test_maxProfit4(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := maxProfit4(2, input[i]); r != result[i] {
-			t.Error(input[i], r, "Expected:", result[i])
+			t.Fatal(input[i], r, "Expected:", result[i])
 		}
 	}
 }
diff --git a/leetcode/dynamic-programming/maxProfit_test.go b/leetcode/dynamic-programming/maxProfit_test.go
@@ -8,7 +8,7 @@ func Test_maxProfit(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := maxProfit(input[i]); r != result[i] {
-			t.Error(input[i], result[i])
+			t.Fatal(input[i], result[i])
 		}
 	}
 }
diff --git a/leetcode/dynamic-programming/rob_test.go b/leetcode/dynamic-programming/rob_test.go
@@ -8,7 +8,7 @@ func Test_rob(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := rob(input[i]); r != result[i] {
-			t.Error(input[i], result[i], r)
+			t.Fatal(input[i], result[i], r)
 		}
 	}
 }
diff --git a/leetcode/hash-table/containsDuplicate_test.go b/leetcode/hash-table/containsDuplicate_test.go
@@ -8,7 +8,7 @@ func Test_containsDuplicate(t *testing.T) {
 
 	for i, nums := range input {
 		if r := containsDuplicate(nums); r != result[i] {
-			t.Error(nums, r)
+			t.Fatal(nums, r)
 		}
 	}
 }
diff --git a/leetcode/hash-table/singleNumber_test.go b/leetcode/hash-table/singleNumber_test.go
@@ -8,7 +8,7 @@ func Test_singleNumber(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := singleNumber(input[i]); r != result[i] {
-			t.Error(input[i], r)
+			t.Fatal(input[i], r)
 		}
 	}
 }
diff --git a/leetcode/linked-list/addTwoNumbers_test.go b/leetcode/linked-list/addTwoNumbers_test.go
@@ -6,6 +6,6 @@ func Test_addTwoNumbers(t *testing.T) {
 	l1 := &ListNode{Val: 2, Next: &ListNode{Val: 4, Next: &ListNode{Val: 5}}}
 	l2 := &ListNode{Val: 5, Next: &ListNode{Val: 6, Next: &ListNode{Val: 4}}}
 	if result := addTwoNumbers(l1, l2); result.String() != "7 0 0 1 <nil>" {
-		t.Error(result)
+		t.Fatal(result)
 	}
 }
diff --git a/leetcode/linked-list/deleteDuplicates_test.go b/leetcode/linked-list/deleteDuplicates_test.go
@@ -5,6 +5,6 @@ import "testing"
 func Test_deleteDuplicates(t *testing.T) {
 	input := &ListNode{Val: 1, Next: &ListNode{Val: 1, Next: &ListNode{Val: 2, Next: &ListNode{Val: 3, Next: &ListNode{Val: 3, Next: nil}}}}}
 	if result := deleteDuplicates(input); result.String() != "1 2 3 <nil>" {
-		t.Error(result, "1 2 3 <nil>")
+		t.Fatal(result, "1 2 3 <nil>")
 	}
 }
diff --git a/leetcode/linked-list/mergeTwoLists_test.go b/leetcode/linked-list/mergeTwoLists_test.go
@@ -6,12 +6,12 @@ func Test_mergeTwoLists(t *testing.T) {
 	l1 := &ListNode{Val: 2, Next: &ListNode{Val: 4, Next: &ListNode{Val: 5, Next: &ListNode{Val: 6}}}}
 	l2 := &ListNode{Val: 1, Next: &ListNode{Val: 4, Next: &ListNode{Val: 5}}}
 	if result := mergeTwoLists(l1, l2); result.String() != "1 2 4 4 5 5 6 <nil>" {
-		t.Error(result)
+		t.Fatal(result)
 	}
 
 	l1 = nil
 	l2 = &ListNode{Val: 1}
 	if result := mergeTwoLists(l1, l2); result.String() != "1 <nil>" {
-		t.Error(result)
+		t.Fatal(result)
 	}
 }
diff --git a/leetcode/linked-list/removeElements_test.go b/leetcode/linked-list/removeElements_test.go
@@ -5,6 +5,6 @@ import "testing"
 func Test_removeElements(t *testing.T) {
 	head := &ListNode{Val: 1, Next: &ListNode{Val: 2, Next: &ListNode{Val: 6, Next: &ListNode{Val: 3, Next: &ListNode{Val: 6}}}}}
 	if r := removeElements(head, 6); r.String() != "1 2 3 <nil>" {
-		t.Error(r)
+		t.Fatal(r)
 	}
 }
diff --git a/leetcode/linked-list/reverseList_test.go b/leetcode/linked-list/reverseList_test.go
@@ -5,6 +5,6 @@ import "testing"
 func Test_reverseList(t *testing.T) {
 	head := &ListNode{Val: 1, Next: &ListNode{Val: 2, Next: &ListNode{Val: 6, Next: &ListNode{Val: 3, Next: &ListNode{Val: 6}}}}}
 	if r := reverseList(head); r.String() != "6 3 6 2 1 <nil>" {
-		t.Error(r)
+		t.Fatal(r)
 	}
 }
diff --git a/leetcode/math/convertToTitle_test.go b/leetcode/math/convertToTitle_test.go
@@ -8,7 +8,7 @@ func Test_convertToTitle(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := convertToTitle(input[i]); r != result[i] {
-			t.Error(input[i], result[i], r)
+			t.Fatal(input[i], result[i], r)
 		}
 	}
 }
diff --git a/leetcode/math/countPrimes_test.go b/leetcode/math/countPrimes_test.go
@@ -8,7 +8,7 @@ func Test_countPrimes(t *testing.T) {
 
 	for i := 0; i < len(nums); i++ {
 		if r := countPrimes(nums[i]); r != results[i] {
-			t.Error(nums[i], r)
+			t.Fatal(nums[i], r)
 		}
 	}
 }
diff --git a/leetcode/math/isHappy_test.go b/leetcode/math/isHappy_test.go
@@ -8,7 +8,7 @@ func Test_isHappy(t *testing.T) {
 
 	for i := 0; i < len(nums); i++ {
 		if r := isHappy(nums[i]); r != result[i] {
-			t.Error(nums[i], result[i], r)
+			t.Fatal(nums[i], result[i], r)
 		}
 	}
 }
diff --git a/leetcode/math/isPalindrome_test.go b/leetcode/math/isPalindrome_test.go
@@ -7,7 +7,7 @@ func Test_isPalindrome(t *testing.T) {
 	results := []bool{false, true, false, true}
 	for index, num := range nums {
 		if r := isPalindrome(num); r != results[index] {
-			t.Error(num, r, results[index])
+			t.Fatal(num, r, results[index])
 		}
 	}
 }
diff --git a/leetcode/math/mySqrt_test.go b/leetcode/math/mySqrt_test.go
@@ -7,7 +7,7 @@ func Test_mySqrt(t *testing.T) {
 	results := []int{0, 1, 1, 2, 2, 3, 90}
 	for i := 0; i < len(nums); i++ {
 		if result := mySqrt(nums[i]); result != results[i] {
-			t.Error(nums[i], results[i], result)
+			t.Fatal(nums[i], results[i], result)
 		}
 	}
 }
diff --git a/leetcode/math/reverse_test.go b/leetcode/math/reverse_test.go
@@ -7,7 +7,7 @@ func Test_reverse(t *testing.T) {
 	results := []int{1, 2, 321, 123, 4321, -3543, 0, 0}
 	for index, num := range nums {
 		if r := reverse(num); r != results[index] {
-			t.Error(num, r, results[index])
+			t.Fatal(num, r, results[index])
 		}
 	}
 }
diff --git a/leetcode/math/romanToInt_test.go b/leetcode/math/romanToInt_test.go
@@ -7,7 +7,7 @@ func Test_romanToInt(t *testing.T) {
 	results := []int{621}
 	for index, num := range nums {
 		if r := romanToInt(num); r != results[index] {
-			t.Error(num, r, results[index])
+			t.Fatal(num, r, results[index])
 		}
 	}
 }
diff --git a/leetcode/math/titleToNumber_test.go b/leetcode/math/titleToNumber_test.go
@@ -8,7 +8,7 @@ func Test_titleToNumber(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := titleToNumber(input[i]); r != result[i] {
-			t.Error(input[i], result[i], r)
+			t.Fatal(input[i], result[i], r)
 		}
 	}
 }
diff --git a/leetcode/math/trailingZeroes_test.go b/leetcode/math/trailingZeroes_test.go
@@ -8,7 +8,7 @@ func Test_trailingZeroes(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := trailingZeroes(input[i]); r != result[i] {
-			t.Error(input[i], result[i], r)
+			t.Fatal(input[i], result[i], r)
 		}
 	}
 }
diff --git a/leetcode/stack/MinStack_test.go b/leetcode/stack/MinStack_test.go
@@ -9,15 +9,15 @@ func Test_MinStack(t *testing.T) {
 	stack.Push(-3)
 
 	if r := stack.GetMin(); r != -3 {
-		t.Error("GetMin:", r)
+		t.Fatal("GetMin:", r)
 	}
 
 	stack.Pop()
 	if r := stack.Top(); r != 0 {
-		t.Error("Top", r)
+		t.Fatal("Top", r)
 	}
 
 	if r := stack.GetMin(); r != -2 {
-		t.Error("GetMin:", r)
+		t.Fatal("GetMin:", r)
 	}
 }
diff --git a/leetcode/stack/MyStack_test.go b/leetcode/stack/MyStack_test.go
@@ -9,17 +9,17 @@ func Test_MyStack(t *testing.T) {
 	stack.Push(-3)
 
 	if r := stack.Empty(); r != false {
-		t.Error("Empty:", r)
+		t.Fatal("Empty:", r)
 	}
 
 	stack.Pop()
 	if r := stack.Top(); r != 0 {
-		t.Error("Top", r)
+		t.Fatal("Top", r)
 	}
 
 	stack.Pop()
 	stack.Pop()
 	if r := stack.Empty(); r != true {
-		t.Error("Empty:", r)
+		t.Fatal("Empty:", r)
 	}
 }
diff --git a/leetcode/string/addBinary_test.go b/leetcode/string/addBinary_test.go
@@ -8,7 +8,7 @@ func Test_addBinary(t *testing.T) {
 	rs := []string{"0", "1", "10", "101", "100", "11110"}
 	for i := 0; i < len(as); i++ {
 		if r := addBinary(as[i], bs[i]); r != rs[i] {
-			t.Error(as[i], bs[i], rs[i], r)
+			t.Fatal(as[i], bs[i], rs[i], r)
 		}
 	}
 }
diff --git a/leetcode/string/countAndSay_test.go b/leetcode/string/countAndSay_test.go
@@ -7,7 +7,7 @@ func Test_countAndSay(t *testing.T) {
 	results := []string{"1", "11", "21", "1211", "111221"}
 	for i := 1; i < len(nums); i++ {
 		if r := countAndSay(nums[i]); r != results[i] {
-			t.Error(nums[i], results[i], "output is:", r)
+			t.Fatal(nums[i], results[i], "output is:", r)
 		}
 	}
 }
diff --git a/leetcode/string/isPalindrome_test.go b/leetcode/string/isPalindrome_test.go
@@ -8,7 +8,7 @@ func Test_isPalindrome(t *testing.T) {
 
 	for i := 0; i < len(input); i++ {
 		if r := isPalindrome(input[i]); r != result[i] {
-			t.Error(input[i], r)
+			t.Fatal(input[i], r)
 		}
 	}
 }
diff --git a/leetcode/string/isValid_test.go b/leetcode/string/isValid_test.go
@@ -7,7 +7,7 @@ func Test_isValid(t *testing.T) {
 	results := []bool{false, false, true, true, false}
 	for i := 0; i < len(inputs); i++ {
 		if r := isValid(inputs[i]); r != results[i] {
-			t.Error(inputs[i], results[i], r)
+			t.Fatal(inputs[i], results[i], r)
 		}
 	}
 }
diff --git a/leetcode/string/lengthOfLastWord_test.go b/leetcode/string/lengthOfLastWord_test.go
diff --git a/leetcode/string/lengthOfLongestSubstring_test.go b/leetcode/string/lengthOfLongestSubstring_test.go
diff --git a/leetcode/string/longestCommonPrefix_test.go b/leetcode/string/longestCommonPrefix_test.go
diff --git a/leetcode/string/strStr_test.go b/leetcode/string/strStr_test.go
diff --git a/leetcode/tree/hasPathSum_test.go b/leetcode/tree/hasPathSum_test.go
diff --git a/leetcode/tree/isBalanced_test.go b/leetcode/tree/isBalanced_test.go
diff --git a/leetcode/tree/isSameTree_test.go b/leetcode/tree/isSameTree_test.go
diff --git a/leetcode/tree/isSymmetric_test.go b/leetcode/tree/isSymmetric_test.go
diff --git a/leetcode/tree/levelOrderBottom_test.go b/leetcode/tree/levelOrderBottom_test.go
diff --git a/leetcode/tree/maxDepth_test.go b/leetcode/tree/maxDepth_test.go
diff --git a/leetcode/tree/minDepth_test.go b/leetcode/tree/minDepth_test.go
diff --git a/leetcode/tree/sortedArrayToBST_test.go b/leetcode/tree/sortedArrayToBST_test.go
diff --git a/search/binary-search/BinarySearch_test.go b/search/binary-search/BinarySearch_test.go
diff --git a/string/matching/string-matching_test.go b/string/matching/string-matching_test.go

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ func Test_generate(t *testing.T) {`
`9`	`9`	`for i := 0; i < len(r); i++ {`
`10`	`10`	`for j := 0; j < len(r[i]); j++ {`
`11`	`11`	`if r[i][j] != result[i][j] {`
`12`		`- t.Error(r, result)`
	`12`	`+ t.Fatal(r, result)`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ func Test_getRow(t *testing.T) {`
`8`	`8`	`r := getRow(i)`
`9`	`9`	`for j := 0; j < len(r); j++ {`
`10`	`10`	`if r[j] != result[i][j] {`
`11`		`- t.Error(i-1, result[i], r)`
	`11`	`+ t.Fatal(i-1, result[i], r)`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,10 +5,10 @@ import "testing"`
`5`	`5`	`func Test_majorityElement(t *testing.T) {`
`6`	`6`	`nums := []int{1, 2, 3, 4, 2, 2, 2}`
`7`	`7`	`if r := majorityElement(nums); r != 2 {`
`8`		`- t.Error(nums, r)`
	`8`	`+ t.Fatal(nums, r)`
`9`	`9`	`}`
`10`	`10`	`nums = []int{1}`
`11`	`11`	`if r := majorityElement(nums); r != 1 {`
`12`		`- t.Error(nums, r)`
	`12`	`+ t.Fatal(nums, r)`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,16 +5,16 @@ import "testing"`
`5`	`5`	`func Test_maxSubArray(t *testing.T) {`
`6`	`6`	`nums := []int{-2, 1, -3, 4, -1, 2, 1, -5, 4}`
`7`	`7`	`if r := maxSubArray(nums); r != 6 {`
`8`		`- t.Error(r)`
	`8`	`+ t.Fatal(r)`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`nums = []int{-2, -3, -1, -5}`
`12`	`12`	`if r := maxSubArray(nums); r != -1 {`
`13`		`- t.Error(r)`
	`13`	`+ t.Fatal(r)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`nums = []int{-1, 2}`
`17`	`17`	`if r := maxSubArray(nums); r != 2 {`
`18`		`- t.Error(r)`
	`18`	`+ t.Fatal(r)`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ func Test_merge(t *testing.T) {`
`13`	`13`
`14`	`14`	`for i := 0; i < len(result); i++ {`
`15`	`15`	`if result[i] != nums1[i] {`
`16`		`- t.Error(result, nums1)`
	`16`	`+ t.Fatal(result, nums1)`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ func Test_plusOne(t *testing.T) {`
`8`	`8`	`r := plusOne(digits)`
`9`	`9`	`for i := 0; i < len(r); i++ {`
`10`	`10`	`if r[i] != result[i] {`
`11`		`- t.Error(result, r)`
	`11`	`+ t.Fatal(result, r)`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ func Test_removeDuplicates(t *testing.T) {`
`8`	`8`	`length := removeDuplicates(nums)`
`9`	`9`	`for i := 0; i < len(dealedNums); i++ {`
`10`	`10`	`if length != 6 \|\| nums[i] != dealedNums[i] {`
`11`		`- t.Error("return is:", length, nums[i], "!=", dealedNums[i])`
	`11`	`+ t.Fatal("return is:", length, nums[i], "!=", dealedNums[i])`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ func Test_removeElement(t *testing.T) {`
`8`	`8`	`length := removeElement(input, 3)`
`9`	`9`	`for i := 0; i < len(result); i++ {`
`10`	`10`	`if length != 8 \|\| input[i] != result[i] {`
`11`		`- t.Error(length, input[i], result[i])`
	`11`	`+ t.Fatal(length, input[i], result[i])`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ func Test_rotate(t *testing.T) {`
`9`	`9`	`rotate(nums, 3)`
`10`	`10`	`for i := 0; i < len(nums); i++ {`
`11`	`11`	`if nums[i] != result[i] {`
`12`		`- t.Error(nums, result)`
	`12`	`+ t.Fatal(nums, result)`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ func Test_searchInsert(t *testing.T) {`
`8`	`8`	`results := []int{2, 1, 4, 0}`
`9`	`9`	`for i := 0; i < len(targets); i++ {`
`10`	`10`	`if r := searchInsert(nums, targets[i]); r != results[i] {`
`11`		`- t.Error(nums, targets[i], r)`
	`11`	`+ t.Fatal(nums, targets[i], r)`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`}`