add tests

Author: kakugirai

src/power-of-two/solution_test.go

@@ -0,0 +1,29 @@
+package main
+
+import "testing"
+
+func Test_isPowerOfTwo(t *testing.T) {
+	type args struct {
+		n int
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			"1",
+			args{
+				8,
+			},
+			true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := isPowerOfTwo(tt.args.n); got != tt.want {
+				t.Errorf("isPowerOfTwo() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/powx-n/solution.go

@@ -16,6 +16,6 @@ func myPow(x float64, n int) float64 {
 }
 
 func main() {
-	x := 2.1
+	x := 2.0
 	fmt.Println(myPow(x, 3))
 }

src/powx-n/solution_test.go

@@ -0,0 +1,28 @@
+package main
+
+import "testing"
+
+func Test_myPow(t *testing.T) {
+	type args struct {
+		x float64
+		n int
+	}
+	tests := []struct {
+		name string
+		args args
+		want float64
+	}{
+		{
+			"1",
+			args{2.0, 3},
+			8,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := myPow(tt.args.x, tt.args.n); got != tt.want {
+				t.Errorf("myPow() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/range-sum-query-immutable/solution_test.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestNumArray_SumRange(t *testing.T) {
+	type fields struct {
+		sums []int
+	}
+	type args struct {
+		i int
+		j int
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   int
+	}{
+		{
+			"1",
+			fields{
+				[]int{-2, 0, 3, -5, 2, -1},
+			},
+			args{
+				2, 5,
+			},
+			-1,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			na := Constructor(tt.fields.sums)
+			if got := na.SumRange(tt.args.i, tt.args.j); got != tt.want {
+				t.Errorf("NumArray.SumRange() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/remove-duplicates-from-sorted-array/solution.go

@@ -2,11 +2,6 @@ package main
 
 import "fmt"
 
-func main() {
-	nums := []int{1, 2, 3, 4, 4, 5}
-	fmt.Println(removeDuplicates(nums))
-}
-
 func removeDuplicates(nums []int) int {
 	if len(nums) == 0 {
 		return 0
@@ -20,3 +15,8 @@ func removeDuplicates(nums []int) int {
 	}
 	return i + 1
 }
+
+func main() {
+	nums := []int{1, 2, 3, 4, 4, 5}
+	fmt.Println(removeDuplicates(nums))
+}

src/remove-duplicates-from-sorted-array/solution_test.go

@@ -0,0 +1,29 @@
+package main
+
+import "testing"
+
+func Test_removeDuplicates(t *testing.T) {
+	type args struct {
+		nums []int
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			"1",
+			args{
+				[]int{1, 2, 3, 4, 4, 5},
+			},
+			5,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := removeDuplicates(tt.args.nums); got != tt.want {
+				t.Errorf("removeDuplicates() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/remove-element/solution.go

@@ -2,12 +2,6 @@ package main
 
 import "fmt"
 
-func main() {
-	nums := []int{3, 2, 2, 3}
-	val := 3
-	fmt.Println(removeElement(nums, val))
-}
-
 func removeElement(nums []int, val int) int {
 	i := 0
 	for j := range nums {
@@ -18,3 +12,9 @@ func removeElement(nums []int, val int) int {
 	}
 	return i
 }
+
+func main() {
+	nums := []int{3, 2, 2, 3}
+	val := 3
+	fmt.Println(removeElement(nums, val))
+}

src/remove-element/solution_test.go

@@ -0,0 +1,31 @@
+package main
+
+import "testing"
+
+func Test_removeElement(t *testing.T) {
+	type args struct {
+		nums []int
+		val  int
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			"1",
+			args{
+				[]int{3, 2, 2, 3},
+				3,
+			},
+			2,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := removeElement(tt.args.nums, tt.args.val); got != tt.want {
+				t.Errorf("removeElement() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/remove-nth-node-from-end-of-list/solution.go

@@ -33,5 +33,8 @@ func removeNthFromEnd(head *ListNode, n int) *ListNode {
 
 func main() {
 	head := &ListNode{1, &ListNode{2, &ListNode{3, &ListNode{4, &ListNode{5, nil}}}}}
-	fmt.Println(removeNthFromEnd(head, 2))
+	removeNthFromEnd(head, 2)
+	for root := head; root != nil; root = root.Next {
+		fmt.Println(root.Val)
+	}
 }

src/remove-nth-node-from-end-of-list/solution_test.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_removeNthFromEnd(t *testing.T) {
+	type args struct {
+		head *ListNode
+		n    int
+	}
+	tests := []struct {
+		name string
+		args args
+		want *ListNode
+	}{
+		{
+			"1",
+			args{
+				&ListNode{1, &ListNode{2, &ListNode{3, &ListNode{4, &ListNode{5, nil}}}}},
+				2,
+			},
+			&ListNode{1, &ListNode{2, &ListNode{3, &ListNode{5, nil}}}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := removeNthFromEnd(tt.args.head, tt.args.n); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("removeNthFromEnd() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/remove-outermost-parentheses/solution_test.go

@@ -0,0 +1,27 @@
+package main
+
+import "testing"
+
+func Test_removeOuterParentheses(t *testing.T) {
+	type args struct {
+		S string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			"1",
+			args{"(()())(())(()(()))"},
+			"()()()()(())",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := removeOuterParentheses(tt.args.S); got != tt.want {
+				t.Errorf("removeOuterParentheses() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/reverse-integer/solution.go

@@ -23,7 +23,7 @@ func reverse(x int) int {
 
 func main() {
 	result := reverse(-210)
-	fmt.Println(reverse(result))
+	fmt.Println(result)
 	fmt.Println(2<<31 - 1)
 	fmt.Println(2147483651)
 }

src/reverse-integer/solution_test.go

@@ -0,0 +1,29 @@
+package main
+
+import "testing"
+
+func Test_reverse(t *testing.T) {
+	type args struct {
+		x int
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			"1",
+			args{
+				-210,
+			},
+			-12,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := reverse(tt.args.x); got != tt.want {
+				t.Errorf("reverse() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/reverse-linked-list/solution.go

@@ -21,6 +21,6 @@ func reverseList(head *ListNode) *ListNode {
 }
 
 func main() {
-	head := ListNode{1, &ListNode{2, &ListNode{3, &ListNode{4, &ListNode{5, nil}}}}}
-	fmt.Println(reverseList(&head))
+	head := &ListNode{1, &ListNode{2, &ListNode{3, &ListNode{4, &ListNode{5, nil}}}}}
+	fmt.Println(reverseList(head))
 }

src/reverse-linked-list/solution_test.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_reverseList(t *testing.T) {
+	type args struct {
+		head *ListNode
+	}
+	tests := []struct {
+		name string
+		args args
+		want *ListNode
+	}{
+		{
+			"1",
+			args{
+				&ListNode{1, &ListNode{2, &ListNode{3, &ListNode{4, &ListNode{5, nil}}}}},
+			},
+			&ListNode{5, &ListNode{4, &ListNode{3, &ListNode{2, &ListNode{1, nil}}}}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := reverseList(tt.args.head); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("reverseList() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/reverse-string/solution.go

@@ -11,5 +11,5 @@ func reverseString(s []byte) {
 func main() {
 	s := []byte{'a', 'b', 'd', 'e'}
 	reverseString(s)
-	fmt.Println(s)
+	fmt.Printf("%#v", s)
 }