add tests

Author: kakugirai

src/binary-tree-inorder-traversal/solution.go

@@ -59,5 +59,5 @@ func main() {
 				&TreeNode{8, nil, nil},
 				&TreeNode{9, nil, nil}},
 			nil}}
-	fmt.Println(inorderTraversal(tree))
+	fmt.Printf("%#v", inorderTraversal(tree))
 }

src/binary-tree-inorder-traversal/solution_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_inorderTraversal(t *testing.T) {
+	type args struct {
+		root *TreeNode
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int
+	}{
+		{
+			"1",
+			args{
+				&TreeNode{1,
+					&TreeNode{2,
+						&TreeNode{4,
+							&TreeNode{7, nil, nil},
+							nil},
+						&TreeNode{5, nil, nil}},
+					&TreeNode{3,
+						&TreeNode{6,
+							&TreeNode{8, nil, nil},
+							&TreeNode{9, nil, nil}},
+						nil}},
+			},
+			[]int{7, 4, 2, 5, 1, 8, 6, 9, 3},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := inorderTraversal(tt.args.root); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("inorderTraversal() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/binary-tree-level-order-traversal/solution.go

@@ -52,5 +52,5 @@ func main() {
 				&TreeNode{8, nil, nil},
 				&TreeNode{9, nil, nil}},
 			nil}}
-	fmt.Println(levelOrder(tree))
+	fmt.Printf("%#v", levelOrder(tree))
 }

src/binary-tree-level-order-traversal/solution_test.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_levelOrder(t *testing.T) {
+	type args struct {
+		root *TreeNode
+	}
+	tests := []struct {
+		name string
+		args args
+		want [][]int
+	}{
+		{
+			"1",
+			args{&TreeNode{1,
+				&TreeNode{2,
+					&TreeNode{4,
+						&TreeNode{7, nil, nil},
+						nil},
+					&TreeNode{5, nil, nil}},
+				&TreeNode{3,
+					&TreeNode{6,
+						&TreeNode{8, nil, nil},
+						&TreeNode{9, nil, nil}},
+					nil}}},
+			[][]int{{1}, {2, 3}, {4, 5, 6}, {7, 8, 9}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := levelOrder(tt.args.root); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("levelOrder() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/binary-tree-postorder-traversal/solution.go

@@ -56,5 +56,5 @@ func main() {
 				&TreeNode{8, nil, nil},
 				&TreeNode{9, nil, nil}},
 			nil}}
-	fmt.Println(postorderTraversal(tree))
+	fmt.Printf("%#v",postorderTraversal(tree))
 }

src/binary-tree-postorder-traversal/solution_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_postorderTraversal(t *testing.T) {
+	type args struct {
+		root *TreeNode
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int
+	}{
+		{
+			"1",
+			args{
+				&TreeNode{1,
+					&TreeNode{2,
+						&TreeNode{4,
+							&TreeNode{7, nil, nil},
+							nil},
+						&TreeNode{5, nil, nil}},
+					&TreeNode{3,
+						&TreeNode{6,
+							&TreeNode{8, nil, nil},
+							&TreeNode{9, nil, nil}},
+						nil}},
+			},
+			[]int{7, 4, 5, 2, 8, 9, 6, 3, 1},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := postorderTraversal(tt.args.root); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("postorderTraversal() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/binary-tree-preorder-traversal/solution.go

@@ -47,5 +47,5 @@ func main() {
 				&TreeNode{8, nil, nil},
 				&TreeNode{9, nil, nil}},
 			nil}}
-	fmt.Println(preorderTraversal(tree))
+	fmt.Printf("%#v", preorderTraversal(tree))
 }

src/binary-tree-preorder-traversal/solution_test.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_preorderTraversal(t *testing.T) {
+	type args struct {
+		root *TreeNode
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int
+	}{
+		{
+			"1",
+			args{
+				&TreeNode{1,
+					&TreeNode{2,
+						&TreeNode{4,
+							&TreeNode{7, nil, nil},
+							nil},
+						&TreeNode{5, nil, nil}},
+					&TreeNode{3,
+						&TreeNode{6,
+							&TreeNode{8, nil, nil},
+							&TreeNode{9, nil, nil}},
+						nil}},
+			},
+			[]int{1, 2, 4, 7, 5, 3, 6, 8, 9},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := preorderTraversal(tt.args.root); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("preorderTraversal() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+

src/binary-tree-right-side-view/solution.go

@@ -43,5 +43,5 @@ func main() {
 				&TreeNode{8, nil, nil},
 				&TreeNode{9, nil, nil}},
 			nil}}
-	fmt.Println(rightSideView(tree))
+	fmt.Printf("%#v", rightSideView(tree))
 }

src/binary-tree-right-side-view/solution_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_rightSideView(t *testing.T) {
+	type args struct {
+		root *TreeNode
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int
+	}{
+		{
+			"1",
+			args{
+				&TreeNode{1,
+					&TreeNode{2,
+						&TreeNode{4,
+							&TreeNode{7, nil, nil},
+							nil},
+						&TreeNode{5, nil, nil}},
+					&TreeNode{3,
+						&TreeNode{6,
+							&TreeNode{8, nil, nil},
+							&TreeNode{9, nil, nil}},
+						nil}},
+			},
+			[]int{1, 3, 6, 9},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := rightSideView(tt.args.root); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("rightSideView() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/boats-to-save-people/solution_test.go

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

src/climbing-stairs/solution_test.go

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

src/coin-change/solution_test.go

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

src/combination-sum-ii/solution.go

@@ -38,5 +38,5 @@ func findCombination(candidates []int, index int, target int, current []int, res
 func main() {
 	candidates := []int{10, 1, 2, 7, 6, 1, 5}
 	target := 8
-	fmt.Println(combinationSum2(candidates, target))
+	fmt.Printf("%#v", combinationSum2(candidates, target))
 }

src/combination-sum-ii/solution_test.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_combinationSum2(t *testing.T) {
+	type args struct {
+		candidates []int
+		target     int
+	}
+	tests := []struct {
+		name string
+		args args
+		want [][]int
+	}{
+		{
+			"1",
+			args{[]int{10, 1, 2, 7, 6, 1, 5}, 8},
+			[][]int{{1, 1, 6}, {1, 2, 5}, {1, 7}, {2, 6}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := combinationSum2(tt.args.candidates, tt.args.target); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("combinationSum2() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

src/combination-sum/solution.go

@@ -32,5 +32,5 @@ func dfs(candidates []int, idx int, target int, curr []int, result *[][]int) {
 
 func main() {
 	candidates := []int{2, 3, 5}
-	fmt.Println(combinationSum(candidates, 8))
+	fmt.Printf("%#v", combinationSum(candidates, 8))
 }