Externalize tests

tests/README.md

@@ -0,0 +1,23 @@
+# tests
+
+## Docker image
+
+The tests must be in a Docker image that will be executed with (among others) the following options :
+
+- `--read-only` Mount the container's root filesystem as read only
+- `--user 1000:1000` Avoid to give root rights
+- `--tmpfs /jail:size=200M,noatime,exec,nodev,nosuid,uid=1000,gid=1000,nr_inodes=5k,mode=1700` Mount a 200MB tmpfs directory to create files and run tests
+- `--memory 500M` Memory limit of 500 MB
+- `--cpus 2.0` Number of CPUs (2 threads)
+- `--mount readonly,type=volume,source=student/username,destination=/app/student` The student's code is available in /app/student
+- `--env HOME=/jail` Set the only writable folder as home directory
+- `--env TMPDIR=/jail` Set the only writable folder as temporary directory
+- `--env USERNAME=` Username
+- `--env EXERCISE=` Exercise name
+- `--env DOMAIN=` Domain name (e.g. gp.ynov-bordeaux.com)
+- `--env EXPECTED_FILES=` A space-separated list of required files
+
+The username is the Gitea login.
+No command or arguments are used, the entrypoint has to run the tests.
+The exit status of the container will determine whether or not the test has passed.
+Any output will be printed in the platform but not interpreted.

tests/go/Dockerfile

@@ -0,0 +1,7 @@
+FROM golang:1
+
+RUN go get golang.org/x/tools/cmd/goimports
+RUN go get github.com/01-edu/z01
+RUN go get github.com/01-edu/public/rc
+COPY . /app
+ENTRYPOINT ["/bin/bash", "/app/entrypoint.sh"]

tests/go/abort_test.go

@@ -0,0 +1,19 @@
+package student_test
+
+import (
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+func TestAbort(t *testing.T) {
+	arg := z01.MultRandInt()
+	arg = append(arg, z01.RandInt())
+	for i := 0; i < 15; i++ {
+		z01.Challenge(t, student.Abort, solutions.Abort, arg[0], arg[1], arg[2], arg[3], arg[4])
+		arg = z01.MultRandInt()
+		arg = append(arg, z01.RandInt())
+	}
+}

tests/go/activebits_test.go

@@ -0,0 +1,21 @@
+package student_test
+
+import (
+	solutions "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+	"testing"
+)
+
+func TestActiveBits(t *testing.T) {
+	args := []int{z01.RandIntBetween(2, 20)}
+
+	for i := 0; i < 20; i++ {
+		args = append(args, z01.RandIntBetween(2, 20))
+	}
+
+	for _, v := range args {
+		z01.Challenge(t, student.ActiveBits, solutions.ActiveBits, v)
+	}
+
+}

tests/go/advancedsortwordarr_test.go

@@ -0,0 +1,44 @@
+package student_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestAdvancedSortWordArr(t *testing.T) {
+	var table [][]string
+
+	for i := 0; i < 10; i++ {
+		table = append(table, z01.MultRandWords())
+	}
+
+	table = append(table, []string{"a", "A", "1", "b", "B", "2", "c", "C", "3"})
+
+	for _, org := range table {
+		//copy for using the solution function
+		cp_sol := make([]string, len(org))
+		//copy for using the student function
+		cp_stu := make([]string, len(org))
+
+		copy(cp_sol, org)
+		copy(cp_stu, org)
+
+		solutions.AdvancedSortWordArr(cp_sol, solutions.CompArray)
+		student.AdvancedSortWordArr(cp_stu, solutions.CompArray)
+
+		if !reflect.DeepEqual(cp_stu, cp_sol) {
+			t.Errorf("%s(%v) == %v instead of %v\n",
+				"AdvancedSortWordArr",
+				org,
+				cp_stu,
+				cp_sol,
+			)
+		}
+	}
+
+}

tests/go/alphacount_test.go

@@ -0,0 +1,30 @@
+package student_test
+
+import (
+	"testing"
+
+	solutions "./solutions"
+
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+func TestAlphaCount(t *testing.T) {
+	var arr []string
+	for l := 0; l < 7; l++ {
+		a := z01.RandIntBetween(5, 20)
+		b := z01.RandASCII()
+		str := z01.RandStr(a, b)
+		arr = append(arr, str)
+	}
+
+	arr = append(arr, " ")
+
+	// example from the subject
+	arr = append(arr, "Hello 78 World!    4455 /")
+
+	for i := 0; i < len(arr); i++ {
+		z01.Challenge(t, student.AlphaCount, solutions.AlphaCount, arr[i])
+
+	}
+}

tests/go/any_test.go

@@ -0,0 +1,73 @@
+package student_test
+
+import (
+	solutions "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+	"testing"
+)
+
+func TestAny(t *testing.T) {
+	functionsArray := []func(string) bool{solutions.IsNumeric, solutions.IsLower, solutions.IsUpper}
+
+	type node struct {
+		f   func(string) bool
+		arr []string
+	}
+
+	table := []node{}
+
+	for i := 0; i < 5; i++ {
+
+		functionSelected := functionsArray[z01.RandIntBetween(0, len(functionsArray)-1)]
+		val := node{
+			f:   functionSelected,
+			arr: z01.MultRandWords(),
+		}
+		table = append(table, val)
+
+	}
+	for i := 0; i < 5; i++ {
+
+		val := node{
+			f:   solutions.IsNumeric,
+			arr: z01.MultRandDigit(),
+		}
+		table = append(table, val)
+
+	}
+
+	for i := 0; i < 5; i++ {
+
+		val := node{
+			f:   solutions.IsLower,
+			arr: z01.MultRandLower(),
+		}
+		table = append(table, val)
+
+	}
+	for i := 0; i < 5; i++ {
+
+		val := node{
+			f:   solutions.IsUpper,
+			arr: z01.MultRandUpper(),
+		}
+		table = append(table, val)
+
+	}
+
+	table = append(table,
+		node{
+			f:   solutions.IsNumeric,
+			arr: []string{"Hello", "how", "are", "you"},
+		},
+		node{
+			f:   solutions.IsNumeric,
+			arr: []string{"This", "is", "4", "you"},
+		},
+	)
+
+	for _, arg := range table {
+		z01.Challenge(t, student.Any, solutions.Any, arg.f, arg.arr)
+	}
+}

tests/go/appendrange_test.go

@@ -0,0 +1,53 @@
+package student_test
+
+import (
+	"github.com/01-edu/z01"
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestAppendRange(t *testing.T) {
+
+	type node struct {
+		min int
+		max int
+	}
+
+	table := []node{}
+	//15 random pairs of ints for a Valid Range
+
+	for i := 0; i < 15; i++ {
+
+		minVal := z01.RandIntBetween(-10000000, 1000000)
+		gap := z01.RandIntBetween(1, 20)
+		val := node{
+			min: minVal,
+			max: minVal + gap,
+		}
+		table = append(table, val)
+	}
+	//15 random pairs of ints with ||invalid range||
+	for i := 0; i < 15; i++ {
+
+		minVal := z01.RandIntBetween(-10000000, 1000000)
+		gap := z01.RandIntBetween(1, 20)
+		val := node{
+			min: minVal,
+			max: minVal - gap,
+		}
+		table = append(table, val)
+	}
+
+	table = append(table,
+		node{min: 0, max: 1},
+		node{min: 0, max: 0},
+		node{min: 5, max: 10},
+		node{min: 10, max: 5},
+	)
+
+	for _, arg := range table {
+		z01.Challenge(t, student.AppendRange, solutions.AppendRange, arg.min, arg.max)
+	}
+}

tests/go/atoi_test.go

@@ -0,0 +1,39 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestAtoi(t *testing.T) {
+	table := make([]string, 30)
+	for i := range table {
+		table[i] = strconv.Itoa(z01.RandInt())
+	}
+	table = append(table,
+		strconv.Itoa(z01.MinInt),
+		strconv.Itoa(z01.MaxInt),
+		"",
+		"-",
+		"+",
+		"0",
+		"+0",
+		"-Invalid123",
+		"--123",
+		"-+123",
+		"++123",
+		"123-",
+		"123+",
+		"123.",
+		"123.0",
+		"123a45",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.Atoi, solutions.Atoi, arg)
+	}
+}

tests/go/atoibase_test.go

@@ -0,0 +1,49 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+// this is the function that creates the TESTS
+func TestAtoiBase(t *testing.T) {
+	type node struct {
+		s    string
+		base string
+	}
+
+	table := []node{}
+
+	// 15 random pairs of string numbers with valid bases
+	for i := 0; i < 15; i++ {
+		validBaseToInput := solutions.RandomValidBase()
+		val := node{
+			s:    solutions.RandomStringFromBase(validBaseToInput),
+			base: validBaseToInput,
+		}
+		table = append(table, val)
+	}
+	// 15 random pairs of string numbers with invalid bases
+	for i := 0; i < 15; i++ {
+		invalidBaseToInput := solutions.RandomInvalidBase()
+		val := node{
+			s:    "thisinputshouldnotmatter",
+			base: invalidBaseToInput,
+		}
+		table = append(table, val)
+	}
+	table = append(table,
+		node{s: "125", base: "0123456789"},
+		node{s: "1111101", base: "01"},
+		node{s: "7D", base: "0123456789ABCDEF"},
+		node{s: "uoi", base: "choumi"},
+		node{s: "bbbbbab", base: "-ab"},
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.AtoiBase, solutions.AtoiBase, arg.s, arg.base)
+	}
+}

tests/go/atoibaseprog_test.go

@@ -0,0 +1,92 @@
+package student_test
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/01-edu/z01"
+)
+
+//randomValidBase function is used to create the tests (input VALID bases here)
+func randomValidBase() string {
+	validBases := []string{
+		"01",
+		"CHOUMIisDAcat!",
+		"choumi",
+		"0123456789",
+		"abc", "Zone01",
+		"0123456789ABCDEF",
+		"WhoAmI?",
+	}
+	index := rand.Intn(len(validBases))
+	return validBases[index]
+}
+
+//randomInvalidBase function is used to create the tests (input INVALID bases here)
+func randomInvalidBase() string {
+	invalidBases := []string{
+		"0",
+		"1",
+		"CHOUMIisdacat!",
+		"choumiChoumi",
+		"01234567890",
+		"abca",
+		"Zone01Zone01",
+		"0123456789ABCDEF0",
+		"WhoAmI?IamWhoIam",
+	}
+	index := z01.RandIntBetween(0, len(invalidBases)-1)
+	return invalidBases[index]
+}
+
+//randomStringFromBase function is used to create the random STRING number from VALID BASES
+func randomStringFromBase(base string) string {
+	letters := []rune(base)
+	size := z01.RandIntBetween(1, 10)
+	r := make([]rune, size)
+	for i := range r {
+		r[i] = letters[rand.Intn(len(letters))]
+	}
+	return string(r)
+}
+
+// this is the function that creates the TESTS
+func TestAtoiBaseProg(t *testing.T) {
+	type node struct {
+		s    string
+		base string
+	}
+
+	table := []node{}
+
+	// 5 random pairs of string numbers with valid bases
+	for i := 0; i < 5; i++ {
+		validBaseToInput := randomValidBase()
+		val := node{
+			s:    randomStringFromBase(validBaseToInput),
+			base: validBaseToInput,
+		}
+		table = append(table, val)
+	}
+	// 5 random pairs of string numbers with invalid bases
+	for i := 0; i < 5; i++ {
+		invalidBaseToInput := randomInvalidBase()
+		val := node{
+			s:    "thisinputshouldnotmatter",
+			base: invalidBaseToInput,
+		}
+		table = append(table, val)
+	}
+	table = append(table,
+		node{s: "125", base: "0123456789"},
+		node{s: "1111101", base: "01"},
+		node{s: "7D", base: "0123456789ABCDEF"},
+		node{s: "uoi", base: "choumi"},
+		node{s: "bbbbbab", base: "-ab"},
+	)
+	for _, arg := range table {
+		z01.ChallengeMain(t, arg.s, arg.base)
+	}
+	z01.ChallengeMain(t)
+	z01.ChallengeMain(t, "125", "0123456789", "something")
+}

tests/go/basicatoi2_test.go

@@ -0,0 +1,33 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestBasicAtoi2(t *testing.T) {
+	table := make([]string, 30)
+	for i := range table {
+		table[i] = strconv.Itoa(z01.RandPosZ())
+	}
+	table = append(table,
+		strconv.Itoa(z01.MaxInt),
+		"",
+		"0",
+		"Invalid123",
+		"123Invalid",
+		"Invalid",
+		"1Invalid23",
+		"123",
+		"123.",
+		"123.0",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.BasicAtoi2, solutions.BasicAtoi2, arg)
+	}
+}

tests/go/basicatoi_test.go

@@ -0,0 +1,29 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestBasicAtoi(t *testing.T) {
+	table := make([]string, 30)
+	for i := range table {
+		table[i] = strconv.Itoa(z01.RandPosZ())
+	}
+	table = append(table,
+		strconv.Itoa(z01.MaxInt),
+		"",
+		"0",
+		"12345",
+		"0000012345",
+		"000000",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.BasicAtoi, solutions.BasicAtoi, arg)
+	}
+}

tests/go/basicjoin_test.go

@@ -0,0 +1,25 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestBasicJoin(t *testing.T) {
+	table := [][]string{}
+
+	// 30 valid pair of ramdom slice of strings to concatenate
+	for i := 0; i < 30; i++ {
+		table = append(table, z01.MultRandASCII())
+	}
+	table = append(table,
+		[]string{"Hello!", " How are you?", "well and yourself?"},
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.BasicJoin, solutions.BasicJoin, arg)
+	}
+}

tests/go/benchmark_tests.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+IFS='
+'
+
+cd -P "$(dirname "$BASH_SOURCE")"
+
+rm -rf student
+cp -a solutions student
+go test -v -json|jq -c 'select(.Action == "pass") | {Test, Elapsed}' | jq -sr 'sort_by(.Elapsed) | .[-30:] | .[] | [.Elapsed, .Test] | @tsv'

tests/go/boolean_test.go

@@ -0,0 +1,17 @@
+package student_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/01-edu/z01"
+)
+
+func TestBoolean(t *testing.T) {
+
+	table := append(z01.MultRandWords(), "1 2 3 4 5")
+
+	for _, s := range table {
+		z01.ChallengeMain(t, strings.Fields(s)...)
+	}
+}

tests/go/btreeapplybylevel_test.go

@@ -0,0 +1,23 @@
+package student_test
+
+import (
+	"fmt"
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestBTreeApplyByLevel(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+
+	ins := []string{"01", "07", "05", "12", "02", "03", "10"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+	}
+
+	solutions.ChallengeTree(t, solutions.BTreeApplyByLevel, student.BTreeApplyByLevel, root, rootS, fmt.Print)
+}

tests/go/btreeapplyinorder_test.go

@@ -0,0 +1,36 @@
+package student_test
+
+import (
+	"fmt"
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestBTreeApplyInorder(t *testing.T) {
+	root := &solutions.TreeNode{Data: "08"}
+	rootS := &student.TreeNode{Data: "08"}
+	var pos []string
+
+	pos = append(pos,
+		"x",
+		"z",
+		"y",
+		"t",
+		"r",
+		"q",
+		"01",
+		"b",
+		"c",
+		"a",
+		"d",
+	)
+
+	for _, arg := range pos {
+		root = solutions.BTreeInsertData(root, arg)
+		rootS = student.BTreeInsertData(rootS, arg)
+	}
+
+	solutions.ChallengeTree(t, solutions.BTreeApplyInorder, student.BTreeApplyInorder, root, rootS, fmt.Println)
+}

tests/go/btreeapplypostorder_test.go

@@ -0,0 +1,36 @@
+package student_test
+
+import (
+	"fmt"
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestBTreeApplyPostorder(t *testing.T) {
+	root := &solutions.TreeNode{Data: "08"}
+	rootS := &student.TreeNode{Data: "08"}
+	var pos []string
+
+	pos = append(pos,
+		"x",
+		"z",
+		"y",
+		"t",
+		"r",
+		"q",
+		"01",
+		"b",
+		"c",
+		"a",
+		"d",
+	)
+
+	for _, arg := range pos {
+		root = solutions.BTreeInsertData(root, arg)
+		rootS = student.BTreeInsertData(rootS, arg)
+	}
+
+	solutions.ChallengeTree(t, solutions.BTreeApplyPostorder, student.BTreeApplyPostorder, root, rootS, fmt.Println)
+}

tests/go/btreeapplypreorder_test.go

@@ -0,0 +1,36 @@
+package student_test
+
+import (
+	"fmt"
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestBTreeApplyPreorder(t *testing.T) {
+	root := &solutions.TreeNode{Data: "08"}
+	rootS := &student.TreeNode{Data: "08"}
+	var pos []string
+
+	pos = append(pos,
+		"x",
+		"z",
+		"y",
+		"t",
+		"r",
+		"q",
+		"01",
+		"b",
+		"c",
+		"a",
+		"d",
+	)
+
+	for _, arg := range pos {
+		root = solutions.BTreeInsertData(root, arg)
+		rootS = student.BTreeInsertData(rootS, arg)
+	}
+
+	solutions.ChallengeTree(t, solutions.BTreeApplyPreorder, student.BTreeApplyPreorder, root, rootS, fmt.Println)
+}

tests/go/btreedeletenode_test.go

@@ -0,0 +1,123 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func parentListDelete(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+
+	var parent string
+
+	if root.Parent == nil {
+		parent = "nil"
+	} else {
+		parent = root.Parent.Data
+	}
+
+	r := "Node: " + root.Data + " Parent: " + parent + "\n"
+	r += parentListDelete(root.Left) + parentListDelete(root.Right)
+	return r
+}
+
+func FormatTree_delete(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+	res := root.Data + "\n"
+	res += formatSubTree_delete(root, "")
+	return res
+}
+
+func formatSubTree_delete(root *student.TreeNode, prefix string) string {
+	if root == nil {
+		return ""
+	}
+
+	var res string
+
+	hasLeft := root.Left != nil
+	hasRight := root.Right != nil
+
+	if !hasLeft && !hasRight {
+		return res
+	}
+
+	res += prefix
+	if hasLeft && hasRight {
+		res += "├── "
+	}
+
+	if !hasLeft && hasRight {
+		res += "└── "
+	}
+
+	if hasRight {
+		printStrand := (hasLeft && hasRight && (root.Right.Right != nil || root.Right.Left != nil))
+		newPrefix := prefix
+		if printStrand {
+			newPrefix += "│   "
+		} else {
+			newPrefix += "    "
+		}
+		res += root.Right.Data + "\n"
+		res += formatSubTree_delete(root.Right, newPrefix)
+	}
+
+	if hasLeft {
+		if hasRight {
+			res += prefix
+		}
+		res += "└── " + root.Left.Data + "\n"
+		res += formatSubTree_delete(root.Left, prefix+"    ")
+	}
+	return res
+}
+
+func errorMessage_delete(t *testing.T, fn interface{}, deleted string, rootOr, root *solutions.TreeNode, rootS *student.TreeNode) {
+	t.Errorf("%s(\n%s, %s\n) ==\n%s instead of\n%s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(rootOr),
+		deleted,
+		FormatTree_delete(rootS),
+		solutions.FormatTree(root),
+	)
+}
+
+func CompareTrees_delete(t *testing.T, fn interface{}, deleted string, rootOr, root *solutions.TreeNode, rootS *student.TreeNode) {
+	sel := student.BTreeSearchItem(rootS, deleted)
+
+	if !student.BTreeIsBinary(rootS) || sel != nil {
+		errorMessage_delete(t, fn, deleted, rootOr, root, rootS)
+	}
+
+}
+
+func TestBTreeDeleteNode(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+	rootOr := &solutions.TreeNode{Data: "04"}
+
+	ins := []string{"01", "07", "05", "12", "02", "03", "10"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+		rootOr = solutions.BTreeInsertData(rootOr, v)
+	}
+
+	selected := solutions.BTreeSearchItem(root, "04")
+	selectedS := student.BTreeSearchItem(rootS, "04")
+
+	root = solutions.BTreeDeleteNode(root, selected)
+	rootS = student.BTreeDeleteNode(rootS, selectedS)
+	fn := interface{}(solutions.BTreeDeleteNode)
+	CompareTrees_delete(t, fn, selected.Data, rootOr, root, rootS)
+}

tests/go/btreeinsertdata_test.go

@@ -0,0 +1,129 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func parentListInsert(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+
+	var parent string
+
+	if root.Parent == nil {
+		parent = "nil"
+	} else {
+		parent = root.Parent.Data
+	}
+
+	r := "Node: " + root.Data + " Parent: " + parent + "\n"
+	r += parentListInsert(root.Left) + parentListInsert(root.Right)
+	return r
+}
+
+func FormatTree_insert(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+	res := root.Data + "\n"
+	res += formatSubTree_insert(root, "")
+	return res
+}
+
+func formatSubTree_insert(root *student.TreeNode, prefix string) string {
+	if root == nil {
+		return ""
+	}
+
+	var res string
+
+	hasLeft := root.Left != nil
+	hasRight := root.Right != nil
+
+	if !hasLeft && !hasRight {
+		return res
+	}
+
+	res += prefix
+	if hasLeft && hasRight {
+		res += "├── "
+	}
+
+	if !hasLeft && hasRight {
+		res += "└── "
+	}
+
+	if hasRight {
+		printStrand := (hasLeft && hasRight && (root.Right.Right != nil || root.Right.Left != nil))
+		newPrefix := prefix
+		if printStrand {
+			newPrefix += "│   "
+		} else {
+			newPrefix += "    "
+		}
+		res += root.Right.Data + "\n"
+		res += formatSubTree_insert(root.Right, newPrefix)
+	}
+
+	if hasLeft {
+		if hasRight {
+			res += prefix
+		}
+		res += "└── " + root.Left.Data + "\n"
+		res += formatSubTree_insert(root.Left, prefix+"    ")
+	}
+	return res
+}
+
+func errorMessage_insert(t *testing.T, fn interface{}, inserted string, root *solutions.TreeNode, rootS *student.TreeNode) {
+	t.Errorf("%s(\n%s, %s\n) ==\n%s instead of\n%s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(root),
+		inserted,
+		FormatTree_insert(rootS),
+		solutions.FormatTree(root),
+	)
+}
+
+func CompareTrees_insert(t *testing.T, fn interface{}, inserted string, root *solutions.TreeNode, rootS *student.TreeNode) {
+	solTree := solutions.FormatTree(root)
+	stuTree := FormatTree_insert(rootS)
+
+	if solTree != stuTree {
+		errorMessage_insert(t, fn, inserted, root, rootS)
+	}
+}
+
+func TestBTreeInsertData(t *testing.T) {
+	root := &solutions.TreeNode{Data: "08"}
+	rootS := &student.TreeNode{Data: "08"}
+
+	var pos []string
+
+	pos = append(pos,
+		"x",
+		"z",
+		"y",
+		"t",
+		"r",
+		"q",
+		"01",
+		"b",
+		"c",
+		"a",
+		"d",
+	)
+	fn := interface{}(solutions.BTreeInsertData)
+	for _, arg := range pos {
+		root = solutions.BTreeInsertData(root, arg)
+		rootS = student.BTreeInsertData(rootS, arg)
+		CompareTrees_insert(t, fn, arg, root, rootS)
+	}
+
+}

tests/go/btreeisbinary_test.go

@@ -0,0 +1,120 @@
+package student_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func BTreeMinStu(root *student.TreeNode) *student.TreeNode {
+	if root == nil || root.Left == nil {
+		return root
+	}
+
+	return BTreeMinStu(root.Left)
+}
+
+func errorMessage_isbin(t *testing.T, fn interface{}, root, a *solutions.TreeNode, b *student.TreeNode) {
+	t.Errorf("%s(\n%s\n) == %s instead of %s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(root),
+		b.Data,
+		a.Data,
+	)
+}
+
+func CompareNode_isbin(t *testing.T, fn interface{}, arg1, a *solutions.TreeNode, b *student.TreeNode) {
+	if a == nil || b == nil {
+		t.Errorf("Expected %v instead of %v\n", a, b)
+		return
+	}
+
+	if a.Data != b.Data {
+		errorMessage_isbin(t, fn, arg1, a, b)
+	}
+
+	if a.Parent != nil && b.Parent != nil {
+		if a.Parent.Data != b.Parent.Data {
+			errorMessage_isbin(t, fn, arg1, a, b)
+			t.Errorf("Expected parent value %v instead of %v\n", a.Parent.Data, b.Parent.Data)
+		}
+	} else if (a.Parent == nil && b.Parent != nil) || (a.Parent != nil && b.Parent == nil) {
+		t.Errorf("Expected parent value %v instead of %v\n", a.Parent, b.Parent)
+	}
+
+	if a.Right != nil && b.Right != nil {
+		if a.Right.Data != b.Right.Data {
+			errorMessage_isbin(t, fn, arg1, a, b)
+			t.Errorf("Expected right child value %v instead of %v\n", a.Right.Data, b.Right.Data)
+		}
+	} else if (a.Right == nil && b.Right != nil) || (a.Right != nil && b.Right == nil) {
+		t.Errorf("Expected right child value %v instead of %v\n", a.Right, b.Right)
+	}
+
+	if a.Left != nil && b.Left != nil {
+		if a.Left.Data != b.Left.Data {
+			errorMessage_isbin(t, fn, arg1, a, b)
+			t.Errorf("Expected left child value %v instead of %v\n", a.Left, b.Left)
+		}
+	} else if (a.Left == nil && b.Left != nil) || (a.Left != nil && b.Left == nil) {
+		t.Errorf("Expected left child value %v instead of %v\n", a, b)
+	}
+}
+
+func CompareReturn_isbin(t *testing.T, fn1, fn2 interface{}, arg1 *solutions.TreeNode, arg2 interface{}) {
+	arar1 := []interface{}{arg1}
+	arar2 := []interface{}{arg2}
+
+	out1 := z01.Monitor(fn1, arar1)
+	out2 := z01.Monitor(fn2, arar2)
+
+	for i, v := range out1.Results {
+		switch str := v.(type) {
+		case *solutions.TreeNode:
+			CompareNode_isbin(t, fn1, arg1, str, out2.Results[i].(*student.TreeNode))
+		default:
+			if !reflect.DeepEqual(str, out2.Results[i]) {
+				t.Errorf("%s(\n%s) == %s instead of %s\n",
+					z01.NameOfFunc(fn1),
+					solutions.FormatTree(arg1),
+					z01.Format(out2.Results...),
+					z01.Format(out1.Results...),
+				)
+			}
+		}
+	}
+}
+
+func TestBTreeIsBinary(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+
+	ins := []string{"01", "07", "05", "12", "02", "03", "10"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+	}
+
+	CompareReturn_isbin(t, solutions.BTreeIsBinary, student.BTreeIsBinary, root, rootS)
+
+	rootNB := &solutions.TreeNode{Data: "04"}
+	rootNB_stu := &student.TreeNode{Data: "04"}
+	//Test a non-binarysearch tree
+	for _, v := range ins {
+		rootNB = solutions.BTreeInsertData(rootNB, v)
+		rootNB_stu = student.BTreeInsertData(rootNB_stu, v)
+	}
+
+	min := solutions.BTreeMin(rootNB)
+	minStu := BTreeMinStu(rootNB_stu)
+
+	min.Left = &solutions.TreeNode{Data: "123"}
+	minStu.Left = &student.TreeNode{Data: "123"}
+
+	CompareReturn_isbin(t, solutions.BTreeIsBinary, student.BTreeIsBinary, rootNB, rootNB_stu)
+}

tests/go/btreelevelcount_test.go

@@ -0,0 +1,95 @@
+package student_test
+
+import (
+	"reflect"
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+
+	"github.com/01-edu/z01"
+)
+
+func errorMessage_level(t *testing.T, fn interface{}, root, a *solutions.TreeNode, b *student.TreeNode) {
+	t.Errorf("%s(\n%s\n) == %s instead of %s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(root),
+		b.Data,
+		a.Data,
+	)
+}
+
+func CompareNode_level(t *testing.T, fn interface{}, arg1, a *solutions.TreeNode, b *student.TreeNode) {
+	if a == nil || b == nil {
+		t.Errorf("Expected %v instead of %v\n", a, b)
+		return
+	}
+
+	if a.Data != b.Data {
+		errorMessage_level(t, fn, arg1, a, b)
+	}
+
+	if a.Parent != nil && b.Parent != nil {
+		if a.Parent.Data != b.Parent.Data {
+			errorMessage_level(t, fn, arg1, a, b)
+			t.Errorf("Expected parent value %v instead of %v\n", a.Parent.Data, b.Parent.Data)
+		}
+	} else if (a.Parent == nil && b.Parent != nil) || (a.Parent != nil && b.Parent == nil) {
+		t.Errorf("Expected parent value %v instead of %v\n", a.Parent, b.Parent)
+	}
+
+	if a.Right != nil && b.Right != nil {
+		if a.Right.Data != b.Right.Data {
+			errorMessage_level(t, fn, arg1, a, b)
+			t.Errorf("Expected right child value %v instead of %v\n", a.Right.Data, b.Right.Data)
+		}
+	} else if (a.Right == nil && b.Right != nil) || (a.Right != nil && b.Right == nil) {
+		t.Errorf("Expected right child value %v instead of %v\n", a.Right, b.Right)
+	}
+
+	if a.Left != nil && b.Left != nil {
+		if a.Left.Data != b.Left.Data {
+			errorMessage_level(t, fn, arg1, a, b)
+			t.Errorf("Expected left child value %v instead of %v\n", a.Left, b.Left)
+		}
+	} else if (a.Left == nil && b.Left != nil) || (a.Left != nil && b.Left == nil) {
+		t.Errorf("Expected left child value %v instead of %v\n", a, b)
+	}
+}
+
+func CompareReturn_level(t *testing.T, fn1, fn2 interface{}, arg1 *solutions.TreeNode, arg2 interface{}) {
+	arar1 := []interface{}{arg1}
+	arar2 := []interface{}{arg2}
+
+	out1 := z01.Monitor(fn1, arar1)
+	out2 := z01.Monitor(fn2, arar2)
+
+	for i, v := range out1.Results {
+		switch str := v.(type) {
+		case *solutions.TreeNode:
+			CompareNode_level(t, fn1, arg1, str, out2.Results[i].(*student.TreeNode))
+		default:
+			if !reflect.DeepEqual(str, out2.Results[i]) {
+				t.Errorf("%s(\n%s) == %s instead of %s\n",
+					z01.NameOfFunc(fn1),
+					solutions.FormatTree(arg1),
+					z01.Format(out2.Results...),
+					z01.Format(out1.Results...),
+				)
+			}
+		}
+	}
+}
+
+func TestBTreeLevelCount(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+
+	ins := []string{"01", "07", "05", "12", "02", "03", "10"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+		CompareReturn_level(t, solutions.BTreeLevelCount, student.BTreeLevelCount, root, rootS)
+	}
+}

tests/go/btreemax_test.go

@@ -0,0 +1,96 @@
+package student_test
+
+import (
+	"reflect"
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+
+	"github.com/01-edu/z01"
+)
+
+func errorMessage_max(t *testing.T, fn interface{}, root, a *solutions.TreeNode, b *student.TreeNode) {
+	t.Errorf("%s(\n%s) == %s instead of %s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(root),
+		b.Data,
+		a.Data,
+	)
+}
+
+func CompareNode_max(t *testing.T, fn interface{}, arg1, a *solutions.TreeNode, b *student.TreeNode) {
+	if a == nil || b == nil {
+		t.Errorf("Expected %v instead of %v\n", a, b)
+		return
+	}
+
+	if a.Data != b.Data {
+		errorMessage_max(t, fn, arg1, a, b)
+	}
+
+	if a.Parent != nil && b.Parent != nil {
+		if a.Parent.Data != b.Parent.Data {
+			errorMessage_max(t, fn, arg1, a, b)
+			t.Errorf("Expected parent value %v instead of %v\n", a.Parent.Data, b.Parent.Data)
+		}
+	} else if (a.Parent == nil && b.Parent != nil) || (a.Parent != nil && b.Parent == nil) {
+		t.Errorf("Expected parent value %v instead of %v\n", a.Parent, b.Parent)
+	}
+
+	if a.Right != nil && b.Right != nil {
+		if a.Right.Data != b.Right.Data {
+			errorMessage_max(t, fn, arg1, a, b)
+			t.Errorf("Expected right child value %v instead of %v\n", a.Right.Data, b.Right.Data)
+		}
+	} else if (a.Right == nil && b.Right != nil) || (a.Right != nil && b.Right == nil) {
+		t.Errorf("Expected right child value %v instead of %v\n", a.Right, b.Right)
+	}
+
+	if a.Left != nil && b.Left != nil {
+		if a.Left.Data != b.Left.Data {
+			errorMessage_max(t, fn, arg1, a, b)
+			t.Errorf("Expected left child value %v instead of %v\n", a.Left, b.Left)
+		}
+	} else if (a.Left == nil && b.Left != nil) || (a.Left != nil && b.Left == nil) {
+		t.Errorf("Expected left child value %v instead of %v\n", a, b)
+	}
+}
+
+func CompareReturn_max(t *testing.T, fn1, fn2 interface{}, arg1 *solutions.TreeNode, arg2 interface{}) {
+	arar1 := []interface{}{arg1}
+	arar2 := []interface{}{arg2}
+
+	out1 := z01.Monitor(fn1, arar1)
+	out2 := z01.Monitor(fn2, arar2)
+
+	for i, v := range out1.Results {
+		switch str := v.(type) {
+		case *solutions.TreeNode:
+			CompareNode_max(t, fn1, arg1, str, out2.Results[i].(*student.TreeNode))
+		default:
+			if !reflect.DeepEqual(str, out2.Results[i]) {
+				t.Errorf("%s(\n%s) == %s instead of\n %s\n",
+					z01.NameOfFunc(fn1),
+					solutions.FormatTree(arg1),
+					z01.Format(out2.Results...),
+					z01.Format(out1.Results...),
+				)
+			}
+		}
+	}
+}
+
+func TestBTreeMax(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+
+	ins := []string{"01", "07", "05", "12", "02", "03", "10"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+	}
+
+	CompareReturn_max(t, solutions.BTreeMax, student.BTreeMax, root, rootS)
+}

tests/go/btreemin_test.go

@@ -0,0 +1,96 @@
+package student_test
+
+import (
+	"reflect"
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+
+	"github.com/01-edu/z01"
+)
+
+func errorMessage_min(t *testing.T, fn interface{}, root, a *solutions.TreeNode, b *student.TreeNode) {
+	t.Errorf("%s(\n%s) == %s instead of %s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(root),
+		b.Data,
+		a.Data,
+	)
+}
+
+func CompareNode_min(t *testing.T, fn interface{}, arg1, a *solutions.TreeNode, b *student.TreeNode) {
+	if a == nil || b == nil {
+		t.Errorf("Expected %v instead of %v\n", a, b)
+		return
+	}
+
+	if a.Data != b.Data {
+		errorMessage_min(t, fn, arg1, a, b)
+	}
+
+	if a.Parent != nil && b.Parent != nil {
+		if a.Parent.Data != b.Parent.Data {
+			errorMessage_min(t, fn, arg1, a, b)
+			t.Errorf("Expected parent value %v instead of %v\n", a.Parent.Data, b.Parent.Data)
+		}
+	} else if (a.Parent == nil && b.Parent != nil) || (a.Parent != nil && b.Parent == nil) {
+		t.Errorf("Expected parent value %v instead of %v\n", a.Parent, b.Parent)
+	}
+
+	if a.Right != nil && b.Right != nil {
+		if a.Right.Data != b.Right.Data {
+			errorMessage_min(t, fn, arg1, a, b)
+			t.Errorf("Expected right child value %v instead of %v\n", a.Right.Data, b.Right.Data)
+		}
+	} else if (a.Right == nil && b.Right != nil) || (a.Right != nil && b.Right == nil) {
+		t.Errorf("Expected right child value %v instead of %v\n", a.Right, b.Right)
+	}
+
+	if a.Left != nil && b.Left != nil {
+		if a.Left.Data != b.Left.Data {
+			errorMessage_min(t, fn, arg1, a, b)
+			t.Errorf("Expected left child value %v instead of %v\n", a.Left, b.Left)
+		}
+	} else if (a.Left == nil && b.Left != nil) || (a.Left != nil && b.Left == nil) {
+		t.Errorf("Expected left child value %v instead of %v\n", a, b)
+	}
+}
+
+func CompareReturn_min(t *testing.T, fn1, fn2, arg1, arg2 interface{}) {
+	arar1 := []interface{}{arg1}
+	arar2 := []interface{}{arg2}
+
+	out1 := z01.Monitor(fn1, arar1)
+	out2 := z01.Monitor(fn2, arar2)
+
+	for i, v := range out1.Results {
+		switch str := v.(type) {
+		case *solutions.TreeNode:
+			CompareNode_min(t, fn1, arg1.(*solutions.TreeNode), str, out2.Results[i].(*student.TreeNode))
+		default:
+			if !reflect.DeepEqual(str, out2.Results[i]) {
+				t.Errorf("%s(%s) == %s instead of %s\n",
+					z01.NameOfFunc(fn1),
+					z01.Format(arg1),
+					z01.Format(out2.Results...),
+					z01.Format(out1.Results...),
+				)
+			}
+		}
+	}
+}
+
+func TestBTreeMin(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+
+	ins := []string{"03", "02", "01", "07", "05", "12", "10"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+	}
+
+	CompareReturn_min(t, solutions.BTreeMin, student.BTreeMin, root, rootS)
+}

tests/go/btreerotateleft_test.go

@@ -0,0 +1,152 @@
+package student_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func parentListRotLeft(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+
+	var parent string
+
+	if root.Parent == nil {
+		parent = "nil"
+	} else {
+		parent = root.Parent.Data
+	}
+
+	r := "Node: " + root.Data + " Parent: " + parent + "\n"
+	r += parentListRotLeft(root.Left) + parentListRotLeft(root.Right)
+	return r
+}
+
+func FormatTree_rotleft(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+	res := root.Data + "\n"
+	res += formatSubTree_rotleft(root, "")
+	return res
+}
+
+func formatSubTree_rotleft(root *student.TreeNode, prefix string) string {
+	if root == nil {
+		return ""
+	}
+
+	var res string
+
+	hasLeft := root.Left != nil
+	hasRight := root.Right != nil
+
+	if !hasLeft && !hasRight {
+		return res
+	}
+
+	res += prefix
+	if hasLeft && hasRight {
+		res += "├── "
+	}
+
+	if !hasLeft && hasRight {
+		res += "└── "
+	}
+
+	if hasRight {
+		printStrand := (hasLeft && hasRight && (root.Right.Right != nil || root.Right.Left != nil))
+		newPrefix := prefix
+		if printStrand {
+			newPrefix += "│   "
+		} else {
+			newPrefix += "    "
+		}
+		res += root.Right.Data + "\n"
+		res += formatSubTree_rotleft(root.Right, newPrefix)
+	}
+
+	if hasLeft {
+		if hasRight {
+			res += prefix
+		}
+		res += "└── " + root.Left.Data + "\n"
+		res += formatSubTree_rotleft(root.Left, prefix+"    ")
+	}
+	return res
+}
+
+func errorMessage_rotleft(t *testing.T, fn interface{}, rootOr, root *solutions.TreeNode, rootS *student.TreeNode) {
+	t.Errorf("%s(\n%s\n)\n == \n%s instead of \n%s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(rootOr),
+		FormatTree_rotleft(rootS),
+		solutions.FormatTree(root),
+	)
+}
+
+func CompareTreesRotLeft(t *testing.T, fn interface{}, root, rootA *solutions.TreeNode, rootAS *student.TreeNode) {
+	parentSol := solutions.ParentList(rootA)
+	parentStu := parentListRotLeft(rootAS)
+	solTree := solutions.FormatTree(root)
+	if parentSol != parentStu {
+		t.Errorf("Tree:\n%s\nExpected\n%s instead of\n%s\n", solTree, parentSol, parentStu)
+	}
+}
+
+func CompareNode_rotleft(t *testing.T, fn interface{}, rootOr, root *solutions.TreeNode, rootS *student.TreeNode) {
+	solTree := solutions.FormatTree(root)
+	stuTree := FormatTree_rotleft(rootS)
+
+	if solTree != stuTree {
+		errorMessage_rotleft(t, fn, rootOr, root, rootS)
+	}
+}
+
+func CompareReturn_rotleft(t *testing.T, fn1, fn2, rootOr, arg1, arg2 interface{}) {
+	arar1 := []interface{}{arg1}
+	arar2 := []interface{}{arg2}
+
+	out1 := z01.Monitor(fn1, arar1)
+	out2 := z01.Monitor(fn2, arar2)
+
+	for i, v := range out1.Results {
+		switch str := v.(type) {
+		case *solutions.TreeNode:
+			CompareNode_rotleft(t, fn1, rootOr.(*solutions.TreeNode), str, out2.Results[i].(*student.TreeNode))
+		default:
+			if !reflect.DeepEqual(str, out2.Results[i]) {
+				t.Errorf("%s(%s) == %s instead of %s\n",
+					z01.NameOfFunc(fn1),
+					z01.Format(arg1),
+					z01.Format(out2.Results...),
+					z01.Format(out1.Results...),
+				)
+			}
+		}
+	}
+}
+
+func TestBTreeRotateLeft(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootOr := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+
+	ins := []string{"01", "07", "05", "12", "02", "03", "10"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+		rootOr = solutions.BTreeInsertData(rootOr, v)
+	}
+
+	fn := interface{}(solutions.BTreeRotateLeft)
+	CompareReturn_rotleft(t, fn, student.BTreeRotateLeft, rootOr, root, rootS)
+	CompareTreesRotLeft(t, fn, rootOr, root, rootS)
+}

tests/go/btreerotateright_test.go

@@ -0,0 +1,151 @@
+package student_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func parentListRotRight(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+
+	var parent string
+
+	if root.Parent == nil {
+		parent = "nil"
+	} else {
+		parent = root.Parent.Data
+	}
+
+	r := "Node: " + root.Data + " Parent: " + parent + "\n"
+	r += parentListRotRight(root.Left) + parentListRotRight(root.Right)
+	return r
+}
+
+func CompareTreesRotRight(t *testing.T, fn interface{}, root, rootA *solutions.TreeNode, rootAS *student.TreeNode) {
+	parentSol := solutions.ParentList(rootA)
+	parentStu := parentListRotRight(rootAS)
+	solTree := solutions.FormatTree(root)
+	if parentSol != parentStu {
+		t.Errorf("Tree:\n%s\nExpected\n%s instead of\n%s\n", solTree, parentSol, parentStu)
+	}
+}
+
+func FormatTree_rotright(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+	res := root.Data + "\n"
+	res += formatSubTree_rotright(root, "")
+	return res
+}
+
+func formatSubTree_rotright(root *student.TreeNode, prefix string) string {
+	if root == nil {
+		return ""
+	}
+
+	var res string
+
+	hasLeft := root.Left != nil
+	hasRight := root.Right != nil
+
+	if !hasLeft && !hasRight {
+		return res
+	}
+
+	res += prefix
+	if hasLeft && hasRight {
+		res += "├── "
+	}
+
+	if !hasLeft && hasRight {
+		res += "└── "
+	}
+
+	if hasRight {
+		printStrand := (hasLeft && hasRight && (root.Right.Right != nil || root.Right.Left != nil))
+		newPrefix := prefix
+		if printStrand {
+			newPrefix += "│   "
+		} else {
+			newPrefix += "    "
+		}
+		res += root.Right.Data + "\n"
+		res += formatSubTree_rotright(root.Right, newPrefix)
+	}
+
+	if hasLeft {
+		if hasRight {
+			res += prefix
+		}
+		res += "└── " + root.Left.Data + "\n"
+		res += formatSubTree_rotright(root.Left, prefix+"    ")
+	}
+	return res
+}
+
+func errorMessage_rotright(t *testing.T, fn interface{}, rootOr, root *solutions.TreeNode, rootS *student.TreeNode) {
+	t.Errorf("%s(\n%s\n)\n == \n%s instead of \n%s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(rootOr),
+		FormatTree_rotright(rootS),
+		solutions.FormatTree(root),
+	)
+}
+
+func CompareNode_rotright(t *testing.T, fn interface{}, rootOr, root *solutions.TreeNode, rootS *student.TreeNode) {
+	solTree := solutions.FormatTree(root)
+	stuTree := FormatTree_rotright(rootS)
+
+	if solTree != stuTree {
+		errorMessage_rotright(t, fn, rootOr, root, rootS)
+	}
+}
+
+func CompareReturn_rotright(t *testing.T, fn1, fn2, rootOr, arg1, arg2 interface{}) {
+	arar1 := []interface{}{arg1}
+	arar2 := []interface{}{arg2}
+
+	out1 := z01.Monitor(fn1, arar1)
+	out2 := z01.Monitor(fn2, arar2)
+
+	for i, v := range out1.Results {
+		switch str := v.(type) {
+		case *solutions.TreeNode:
+			CompareNode_rotright(t, fn1, rootOr.(*solutions.TreeNode), str, out2.Results[i].(*student.TreeNode))
+		default:
+			if !reflect.DeepEqual(str, out2.Results[i]) {
+				t.Errorf("%s(%s) == %s instead of %s\n",
+					z01.NameOfFunc(fn1),
+					z01.Format(arg1),
+					z01.Format(out2.Results...),
+					z01.Format(out1.Results...),
+				)
+			}
+		}
+	}
+}
+
+func TestBTreeRotateRight(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootOr := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+
+	ins := []string{"01", "07", "05", "12", "02", "03", "10"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+		rootOr = solutions.BTreeInsertData(rootOr, v)
+	}
+	fn := interface{}(solutions.BTreeRotateRight)
+	CompareReturn_rotright(t, fn, student.BTreeRotateRight, rootOr, root, rootS)
+	CompareTreesRotRight(t, fn, rootOr, root, rootS)
+}

tests/go/btreesearchitem_test.go

@@ -0,0 +1,90 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+	"fmt"
+)
+
+func errorMessage_search(t *testing.T, fn interface{}, root, a *solutions.TreeNode, b *student.TreeNode,
+	seaVal string) {
+	t.Errorf("%s(\n%s\n, %s) == %s instead of %s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(root),
+		seaVal,
+		b.Data,
+		a.Data,
+	)
+}
+
+func CompareNode_search(t *testing.T, fn interface{}, arg1, a *solutions.TreeNode, b *student.TreeNode,
+	seaVal string) {
+
+	if a == nil && b == nil {
+		return
+	}
+
+	if (a == nil && b != nil) || (b == nil && a != nil) {
+		t.Errorf("Expected %v instead of %v\n", a, b)
+		return
+	}
+
+	if a.Data != b.Data {
+		errorMessage_search(t, fn, arg1, a, b, seaVal)
+	}
+
+	if a.Parent != nil && b.Parent != nil {
+		if a.Parent.Data != b.Parent.Data {
+			errorMessage_search(t, fn, arg1, a, b, seaVal)
+			t.Errorf("Expected parent value %v instead of %v\n", a.Parent.Data, b.Parent.Data)
+			fmt.Println("Parent.Data", a.Parent.Data, b.Parent.Data)
+		}
+	} else if (a.Parent == nil && b.Parent != nil) || (a.Parent != nil && b.Parent == nil) {
+		t.Errorf("Expected parent value %v instead of %v\n", a.Parent, b.Parent)
+	}
+
+	if a.Right != nil && b.Right != nil {
+		if a.Right.Data != b.Right.Data {
+			errorMessage_search(t, fn, arg1, a, b, seaVal)
+			t.Errorf("Expected right child value %v instead of %v\n", a.Right.Data, b.Right.Data)
+			fmt.Println("Right.Data", a.Right.Data, b.Right.Data)
+		}
+	} else if (a.Right == nil && b.Right != nil) || (a.Right != nil && b.Right == nil) {
+		t.Errorf("Expected right child value %v instead of %v\n", a.Right, b.Right)
+	}
+
+	if a.Left != nil && b.Left != nil {
+		if a.Left.Data != b.Left.Data {
+			errorMessage_search(t, fn, arg1, a, b, seaVal)
+			t.Errorf("Expected left child value %v instead of %v\n", a.Left, b.Left)
+			fmt.Println("Left.Data", a.Left.Data, b.Left.Data)
+		}
+	} else if (a.Left == nil && b.Left != nil) || (a.Left != nil && b.Left == nil) {
+		t.Errorf("Expected left child value %v instead of %v\n", a, b)
+	}
+}
+
+func TestBTreeSearchItem(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+
+	ins := []string{"01", "07", "05", "12", "02", "03", "10"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+	}
+	fn := interface{}(solutions.BTreeSearchItem)
+
+	ins = append(ins, "322")
+	for _, v := range ins {
+		selectedSol := solutions.BTreeSearchItem(root, v)
+		selectedStu := student.BTreeSearchItem(rootS, v)
+		CompareNode_search(t, fn, root, selectedSol, selectedStu, v)
+	}
+
+}

tests/go/btreetransplant_test.go

@@ -0,0 +1,142 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+	"fmt"
+)
+
+func parentListTransp(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+
+	var parent string
+
+	if root.Parent == nil {
+		parent = "nil"
+	} else {
+		parent = root.Parent.Data
+	}
+
+	r := "Node: " + root.Data + " Parent: " + parent + "\n"
+	r += parentListTransp(root.Left) + parentListTransp(root.Right)
+	return r
+}
+
+func FormatTree_transp(root *student.TreeNode) string {
+	if root == nil {
+		return ""
+	}
+	res := root.Data + "\n"
+	res += formatSubTree_transp(root, "")
+	return res
+}
+
+func formatSubTree_transp(root *student.TreeNode, prefix string) string {
+	if root == nil {
+		return ""
+	}
+
+	var res string
+
+	hasLeft := root.Left != nil
+	hasRight := root.Right != nil
+
+	if !hasLeft && !hasRight {
+		return res
+	}
+
+	res += prefix
+	if hasLeft && hasRight {
+		res += "├── "
+	}
+
+	if !hasLeft && hasRight {
+		res += "└── "
+	}
+
+	if hasRight {
+		printStrand := (hasLeft && hasRight && (root.Right.Right != nil || root.Right.Left != nil))
+		newPrefix := prefix
+		if printStrand {
+			newPrefix += "│   "
+		} else {
+			newPrefix += "    "
+		}
+		res += root.Right.Data + "\n"
+		res += formatSubTree_transp(root.Right, newPrefix)
+	}
+
+	if hasLeft {
+		if hasRight {
+			res += prefix
+		}
+		res += "└── " + root.Left.Data + "\n"
+		res += formatSubTree_transp(root.Left, prefix+"    ")
+	}
+	return res
+}
+
+func errorMessage_transp(t *testing.T, fn interface{}, root, sel, repl *solutions.TreeNode, rootA *solutions.TreeNode, rootAS *student.TreeNode) {
+	t.Errorf("%s(\nRoot:\n %s, Selected:\n%s, Replacement:\n%s\n) ==\n%s instead of\n%s\n",
+		z01.NameOfFunc(fn),
+		solutions.FormatTree(root),
+		solutions.FormatTree(sel),
+		solutions.FormatTree(repl),
+		FormatTree_transp(rootAS),
+		solutions.FormatTree(rootA),
+	)
+}
+
+func CompareTrees_transp(t *testing.T, fn interface{}, root, sel, repl *solutions.TreeNode, rootA *solutions.TreeNode, rootAS *student.TreeNode) {
+	solTree := solutions.FormatTree(rootA)
+	stuTree := FormatTree_transp(rootAS)
+
+	if solTree != stuTree {
+		errorMessage_transp(t, fn, root, sel, repl, rootA, rootAS)
+	}
+	parentSol := solutions.ParentList(rootA)
+	parentStu := parentListTransp(rootAS)
+
+	if parentSol != parentStu {
+		fmt.Println("Tree:\n", solTree)
+		t.Errorf("Expected\n%s instead of\n%s\n", parentSol, parentStu)
+	}
+}
+
+func TestBTreeTransplant(t *testing.T) {
+	root := &solutions.TreeNode{Data: "04"}
+	rootS := &student.TreeNode{Data: "04"}
+	rootOr := &solutions.TreeNode{Data: "04"}
+
+	replacement := &solutions.TreeNode{Data: "55"}
+	replacementS := &student.TreeNode{Data: "55"}
+
+	ins := []string{"01", "07", "05", "12", "02", "03", "10"}
+
+	rep := []string{"33", "12", "15", "60"}
+
+	for _, v := range ins {
+		root = solutions.BTreeInsertData(root, v)
+		rootS = student.BTreeInsertData(rootS, v)
+		rootOr = solutions.BTreeInsertData(rootOr, v)
+	}
+
+	for _, v := range rep {
+		replacement = solutions.BTreeInsertData(replacement, v)
+		replacementS = student.BTreeInsertData(replacementS, v)
+	}
+
+	selected := solutions.BTreeSearchItem(root, "07")
+	selectedS := student.BTreeSearchItem(rootS, "07")
+	root = solutions.BTreeTransplant(root, selected, replacement)
+	rootS = student.BTreeTransplant(rootS, selectedS, replacementS)
+	fn := interface{}(solutions.BTreeTransplant)
+
+	CompareTrees_transp(t, fn, rootOr, selected, replacement, root, rootS)
+}

tests/go/capitalize_test.go

@@ -0,0 +1,26 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestCapitalize(t *testing.T) {
+	table := append(
+		z01.MultRandASCII(),
+		"Hello! How are you? How+are+things+4you?",
+		"Hello! How are you?",
+		"a",
+		"z",
+		"!",
+		"9a",
+		"9a LALALA!",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.Capitalize, solutions.Capitalize, arg)
+	}
+}

tests/go/cat_test.go

@@ -0,0 +1,93 @@
+package student_test
+
+import (
+	"errors"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+
+	solutions "./solutions"
+
+	"github.com/01-edu/z01"
+)
+
+//executes commands
+func execC(name string, args ...string) (string, error) {
+	out, err := exec.Command(name, args...).Output()
+
+	output := string(out)
+	if err == nil {
+		return output, nil
+	}
+	if output == "" {
+		return "", z01.Wrap(err, "Command failed")
+	}
+	return "", errors.New(output)
+}
+
+func TestCat(t *testing.T) {
+
+	var table []string
+	pathFileName := "./student/cat/quest8.txt"
+	pathFileName2 := "./student/cat/quest8T.txt"
+
+	solutions.CheckFile(t, pathFileName)
+	solutions.CheckFile(t, pathFileName2)
+
+	table = append(table, pathFileName, pathFileName+" "+pathFileName2, "asd")
+
+	for _, s := range table {
+		z01.ChallengeMain(t, strings.Fields(s)...)
+	}
+	_, err := execC("go", "build", "-o", "cat_student", "./student/cat/main.go")
+	_, err = execC("go", "build", "-o", "cat_solution", "./solutions/cat/main.go")
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	pwd, err := os.Getwd()
+
+	if err != nil {
+		t.Errorf(err.Error())
+	}
+
+	for i := 0; i < 2; i++ {
+		randStdin := z01.RandAlnum()
+		cmd := exec.Command("sh", "-c", pwd+"/cat_solution")
+		solutionResult := execStdin(cmd, randStdin)
+		cmdS := exec.Command(pwd + "/cat_student")
+		studentResult := execStdin(cmdS, randStdin)
+
+		if solutionResult != studentResult {
+			t.Errorf("./cat prints %s instead of %s\n", studentResult, solutionResult)
+		}
+	}
+	execC("rm", "cat_student", "cat_solution")
+}
+
+func execStdin(cmd *exec.Cmd, randomStdin string) string {
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		log.Fatal(err)
+	}
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if err := cmd.Start(); err != nil {
+		log.Fatal(err)
+	}
+	_, err = stdin.Write([]byte(randomStdin))
+	if err != nil {
+		log.Fatal(err)
+	}
+	stdin.Close()
+
+	out, _ := ioutil.ReadAll(stdout)
+	if err := cmd.Wait(); err != nil {
+		log.Fatal(err)
+	}
+	return string(out)
+}

tests/go/collatzcountdown_test.go

@@ -0,0 +1,21 @@
+package student_test
+
+import (
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+func TestCollatzCountdown(t *testing.T) {
+	args := []int{z01.RandIntBetween(-6, 20)}
+	args = append(args, -5, 0)
+	for i := 0; i < 20; i++ {
+		args = append(args, z01.RandIntBetween(2, 20))
+	}
+
+	for _, v := range args {
+		z01.Challenge(t, student.CollatzCountdown, solutions.CollatzCountdown, v)
+	}
+}

tests/go/comcheck_test.go

@@ -0,0 +1,23 @@
+package student_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/01-edu/z01"
+)
+
+func TestComCheck(t *testing.T) {
+	table := append(z01.MultRandWords(),
+		"01",
+		"galaxy",
+		"galaxy01",
+		" 01",
+		"as das d 01 asd",
+		"as galaxy d 12",
+		"as ds galaxy 01 asd")
+
+	for _, s := range table {
+		z01.ChallengeMain(t, strings.Fields(s)...)
+	}
+}

tests/go/compact_test.go

@@ -0,0 +1,59 @@
+package student_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestCompact(t *testing.T) {
+	var arg [][]string
+
+	for i := 0; i < 20; i++ {
+		n := z01.RandIntBetween(5, 20) // random size of the slice
+
+		orig := make([]string, n) //slice with the original value
+
+		num_pos := z01.RandIntBetween(1, n-1) // random number of positions to be written
+
+		for i := 0; i < num_pos; i++ {
+			word := z01.RandWords()                // random string value
+			rand_pos := z01.RandIntBetween(0, n-1) // random position in the slice
+			orig[rand_pos] = word
+		}
+		arg = append(arg, orig)
+	}
+
+	arg = append(arg, []string{"hello", "", "hi", "", "salut", "", ""})
+
+	for _, v := range arg {
+		sli_sol := make([]string, len(arg)) // slice to apply the solution function
+		sli_stu := make([]string, len(arg)) // slice to apply the student function
+
+		copy(sli_sol, v)
+		copy(sli_stu, v)
+
+		sol_size := solutions.Compact(&sli_sol)
+		stu_size := student.Compact(&sli_stu)
+
+		if !reflect.DeepEqual(sli_stu, sli_sol) {
+			t.Errorf("Produced slice: %v, instead of %v\n",
+				sli_stu,
+				sli_sol,
+			)
+		}
+
+		if sol_size != stu_size {
+			t.Errorf("%s(%v) == %v instead of %v\n",
+				"Compact",
+				v,
+				sli_stu,
+				sli_sol,
+			)
+		}
+	}
+}

tests/go/compare_test.go

@@ -0,0 +1,53 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestCompare(t *testing.T) {
+	type node struct {
+		s         string
+		toCompare string
+	}
+
+	table := []node{}
+
+	// the first 15 values are returning 0 for this test
+	for i := 0; i < 15; i++ {
+		wordToTest := z01.RandASCII()
+
+		val := node{
+			s:         wordToTest,
+			toCompare: wordToTest,
+		}
+		table = append(table, val)
+	}
+
+	// the next 15 values are supposed to return 1 or -1 for this test
+	for i := 0; i < 15; i++ {
+		wordToTest := z01.RandASCII()
+		wrongMatch := z01.RandASCII()
+
+		val := node{
+			s:         wordToTest,
+			toCompare: wrongMatch,
+		}
+		table = append(table, val)
+
+	}
+	// those are the test values from the README examples
+	table = append(table,
+		node{s: "Hello!", toCompare: "Hello!"},
+		node{s: "Salut!", toCompare: "lut!"},
+		node{s: "Ola!", toCompare: "Ol"},
+	)
+
+	for _, arg := range table {
+		z01.Challenge(t, student.Compare, solutions.Compare, arg.s, arg.toCompare)
+	}
+}

tests/go/concat_test.go

@@ -0,0 +1,26 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestConcat(t *testing.T) {
+	table := [][]string{}
+
+	// 30 valid pair of ramdom strings to concatenate
+	for i := 0; i < 30; i++ {
+		value := []string{z01.RandASCII(), z01.RandASCII()}
+		table = append(table, value)
+	}
+	table = append(table,
+		[]string{"Hello!", " How are you?"},
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.Concat, solutions.Concat, arg[0], arg[1])
+	}
+}

tests/go/concatparams_test.go

@@ -0,0 +1,29 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestConcatParams(t *testing.T) {
+
+	table := [][]string{}
+	//30 random slice of strings
+
+	for i := 0; i < 30; i++ {
+		val := z01.MultRandASCII()
+		table = append(table, val)
+	}
+
+	table = append(table,
+		[]string{"Hello", "how", "are", "you?"},
+	)
+
+	for _, arg := range table {
+		z01.Challenge(t, student.ConcatParams, solutions.ConcatParams, arg)
+	}
+}

tests/go/convertbase_test.go

@@ -0,0 +1,42 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestConvertBase(t *testing.T) {
+
+	type node struct {
+		nbr      string
+		baseFrom string
+		baseTo   string
+	}
+	table := []node{}
+
+	for i := 0; i < 30; i++ {
+		validBaseToInput1 := solutions.RandomValidBase()
+		validBaseToInput2 := solutions.RandomValidBase()
+		str := solutions.ConvertNbrBase(z01.RandIntBetween(0, 1000000), validBaseToInput1)
+		val := node{
+			nbr:      str,
+			baseFrom: validBaseToInput1,
+			baseTo:   validBaseToInput2,
+		}
+		table = append(table, val)
+	}
+
+	table = append(table, node{
+		nbr:      "101011",
+		baseFrom: "01",
+		baseTo:   "0123456789"},
+	)
+
+	for _, arg := range table {
+		z01.Challenge(t, student.ConvertBase, solutions.ConvertBase, arg.nbr, arg.baseFrom, arg.baseTo)
+	}
+}

tests/go/countif_test.go

@@ -0,0 +1,75 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestCountIf(t *testing.T) {
+	functionsArray := []func(string) bool{solutions.IsNumeric, solutions.IsLower, solutions.IsUpper}
+
+	type node struct {
+		f   func(string) bool
+		arr []string
+	}
+
+	table := []node{}
+
+	for i := 0; i < 5; i++ {
+
+		functionSelected := functionsArray[z01.RandIntBetween(0, len(functionsArray)-1)]
+		val := node{
+			f:   functionSelected,
+			arr: z01.MultRandWords(),
+		}
+		table = append(table, val)
+
+	}
+	for i := 0; i < 5; i++ {
+
+		val := node{
+			f:   solutions.IsNumeric,
+			arr: z01.MultRandDigit(),
+		}
+		table = append(table, val)
+
+	}
+
+	for i := 0; i < 5; i++ {
+
+		val := node{
+			f:   solutions.IsLower,
+			arr: z01.MultRandLower(),
+		}
+		table = append(table, val)
+
+	}
+	for i := 0; i < 5; i++ {
+
+		val := node{
+			f:   solutions.IsUpper,
+			arr: z01.MultRandUpper(),
+		}
+		table = append(table, val)
+
+	}
+
+	table = append(table,
+		node{
+			f:   solutions.IsNumeric,
+			arr: []string{"Hello", "how", "are", "you"},
+		},
+		node{
+			f:   solutions.IsNumeric,
+			arr: []string{"This", "is", "4", "you"},
+		},
+	)
+
+	for _, arg := range table {
+		z01.Challenge(t, student.CountIf, solutions.CountIf, arg.f, arg.arr)
+	}
+}

tests/go/createelem_test.go

@@ -0,0 +1,50 @@
+package student_test
+
+import (
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+//the structs from the other packages
+//struct just for the first exercise
+type NodeF = student.Node
+type NodeFS = solution.Node
+
+//exercise 1
+//simple struct, just insert a element in the struct
+func TestCreateElem(t *testing.T) {
+	n := &NodeFS{}
+	n1 := &NodeF{}
+
+	type nodeTest struct {
+		data []int
+	}
+
+	table := []nodeTest{}
+
+	for i := 0; i < 5; i++ {
+		val := nodeTest{
+			data: z01.MultRandIntBetween(-1000000, 10000000),
+		}
+		table = append(table, val)
+	}
+
+	table = append(table,
+		nodeTest{
+			data: []int{132423},
+		},
+	)
+	for _, arg := range table {
+		for i := 0; i < len(arg.data); i++ {
+			solution.CreateElem(n, arg.data[i])
+			student.CreateElem(n1, arg.data[i])
+		}
+
+		if n.Data != n1.Data {
+			t.Errorf("CreateElem == %d instead of %d\n", n, n1)
+		}
+	}
+}

tests/go/displayfile_test.go

@@ -0,0 +1,23 @@
+package student_test
+
+import (
+	"strings"
+	"testing"
+
+	solutions "./solutions"
+	"github.com/01-edu/z01"
+)
+
+func TestDisplayfile(t *testing.T) {
+
+	var table []string
+	pathFileName := "./student/displayfile/quest8.txt"
+
+	solutions.CheckFile(t, pathFileName)
+
+	table = append(table, "", pathFileName, "quest8.txt asdsada")
+
+	for _, s := range table {
+		z01.ChallengeMain(t, strings.Fields(s)...)
+	}
+}

tests/go/divmod_test.go

@@ -0,0 +1,27 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	student "./student"
+)
+
+func TestDivMod(t *testing.T) {
+	i := 0
+	for i < z01.SliceLen {
+		a := z01.RandInt()
+		b := z01.RandInt()
+		var div int
+		var mod int
+		student.DivMod(a, b, &div, &mod)
+		if div != a/b {
+			t.Errorf("DivMod(%d, %d, &div, &mod), div == %d instead of %d", a, b, div, a/b)
+		}
+		if mod != a%b {
+			t.Errorf("DivMod(%d, %d, &div, &mod), mod == %d instead of %d", a, b, mod, a%b)
+		}
+		i++
+	}
+}

tests/go/doop_test.go

@@ -0,0 +1,44 @@
+package student_test
+
+import (
+	"strings"
+	"testing"
+
+	"strconv"
+
+	"github.com/01-edu/z01"
+)
+
+func TestDoop(t *testing.T) {
+
+	operatorsTable := []string{"+", "-", "*", "/", "%"}
+
+	table := []string{}
+
+	for i := 0; i < 4; i++ {
+		firstArg := strconv.Itoa(z01.RandIntBetween(-1000, 1000))
+		secondArg := strconv.Itoa(z01.RandIntBetween(0, 1000))
+
+		for _, operator := range operatorsTable {
+			table = append(table, firstArg+" "+operator+" "+secondArg)
+
+		}
+	}
+
+	table = append(table, "1 + 1")
+	table = append(table, "hello + 1")
+	table = append(table, "1 p 1")
+	table = append(table, "1 / 0")
+	table = append(table, "1 # 1")
+	table = append(table, "1 % 0")
+	table = append(table, "1 * 1")
+	table = append(table, "1argument")
+	table = append(table, "2 arguments")
+	table = append(table, "4 arguments so invalid")
+	table = append(table, "9223372036854775807 + 1")
+	table = append(table, "9223372036854775809 - 3")
+	table = append(table, "9223372036854775807 * 3")
+	for _, s := range table {
+		z01.ChallengeMain(t, strings.Fields(s)...)
+	}
+}

tests/go/eightqueens_test.go

@@ -0,0 +1,14 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestEightQueens(t *testing.T) {
+	z01.Challenge(t, student.EightQueens, solutions.EightQueens)
+}

tests/go/enigma_test.go

@@ -0,0 +1,70 @@
+package student_test
+
+import (
+	solutions "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+	"testing"
+)
+
+func TestEnigma(t *testing.T) {
+	args := []int{z01.RandIntBetween(2, 20)}
+	for i := 0; i < 3; i++ {
+		args = append(args, z01.RandIntBetween(2, 20))
+	}
+
+	aval := args[0]
+	x := args[0]
+	y := &x
+	z := &y
+	a := &z
+
+	bval := args[1]
+	w := args[1]
+	b := &w
+
+	cval := args[2]
+	u := args[2]
+	e := &u
+	f := &e
+	g := &f
+	h := &g
+	i := &h
+	j := &i
+	c := &j
+
+	dval := args[3]
+	k := args[3]
+	l := &k
+	m := &l
+	n := &m
+	d := &n
+
+	student.Enigma(a, b, c, d)
+	solutions.Decript(a, b, c, d)
+
+	if aval != ***a {
+		t.Errorf("Expected ***a = %d instead of %d\n",
+			aval,
+			***a,
+		)
+	}
+	if bval != *b {
+		t.Errorf("Expected *b = %d instead of %d\n",
+			bval,
+			*b,
+		)
+	}
+	if cval != *******c {
+		t.Errorf("Expected *******c = %d instead of %d\n",
+			cval,
+			*******c,
+		)
+	}
+	if dval != ****d {
+		t.Errorf("Expected ****d = %d instead of %d\n",
+			dval,
+			****d,
+		)
+	}
+}

tests/go/entrypoint.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+
+# Unofficial Bash Strict Mode
+set -euo pipefail
+IFS='
+'
+
+cp -rT /app /jail
+
+if test -v EXPECTED_FILES; then
+	echo -n "Formatting... "
+	cd /jail/student
+	s=$(goimports -d $(echo $EXPECTED_FILES | fmt -w1 | grep '\.go$'))
+	if test "$s"; then
+		echo
+		echo "$s"
+		exit 1
+	fi
+	echo OK
+	if test -v ALLOWED_FUNCTIONS; then
+		rc "$EXPECTED_FILES" $ALLOWED_FUNCTIONS
+	fi
+fi
+
+cd /jail
+
+if ! test -f ${EXERCISE}_test.go; then
+	echo No test file found for the exercise : "$EXERCISE"
+	exit 1
+fi
+
+# TODO: maybe change btree exercises so that they work without student code and then delete this line
+find . -name '*_test.go' ! -name ${EXERCISE}_test.go -delete
+
+go test -failfast -run=\(?i\)test${EXERCISE}

tests/go/fibonacci_test.go

@@ -0,0 +1,22 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestFibonacci(t *testing.T) {
+	table := append(
+		z01.MultRandIntBetween(0, 25),
+		4,
+		5,
+		-5,
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.Fibonacci, solutions.Fibonacci, arg)
+	}
+}

tests/go/findnextprime_test.go

@@ -0,0 +1,36 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestFindNextPrime(t *testing.T) {
+	table := append(
+		z01.MultRandIntBetween(-1000000, 1000000),
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		100,
+		1000000086,
+		1000000087,
+		1000000088,
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.FindNextPrime, solutions.FindNextPrime, arg)
+	}
+}

tests/go/firstrune_test.go

@@ -0,0 +1,23 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestFirstRune(t *testing.T) {
+	table := append(
+		z01.MultRandASCII(),
+		"Hello!",
+		"Salut!",
+		"Ola!",
+		"♥01",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.FirstRune, solutions.FirstRune, arg)
+	}
+}

tests/go/fixthemain_test.go

@@ -0,0 +1,12 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+)
+
+func TestFixthemain(t *testing.T) {
+
+	z01.ChallengeMain(t)
+}

tests/go/flags_test.go

@@ -0,0 +1,51 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+)
+
+type node struct {
+	flags          []string
+	flagsShorthand []string
+	randArgFlag    []string
+	randArg        []string
+}
+
+func TestFlags(t *testing.T) {
+	str := []string{"--insert=", "--order"}
+	strShorthand := []string{"-i=", "-o"}
+	var randflag []string
+	var randflagarg []string
+	for i := 0; i < 2; i++ {
+		randflagarg = append(randflagarg, z01.RandWords())
+		randflag = append(randflag, z01.RandWords())
+	}
+
+	node := &node{
+		flags:          str,
+		flagsShorthand: strShorthand,
+		randArgFlag:    randflagarg,
+		randArg:        randflag,
+	}
+
+	node.randArg = append(node.randArg, "")
+
+	z01.ChallengeMain(t, node.flagsShorthand[0]+"v2", "v1")
+	z01.ChallengeMain(t, node.flagsShorthand[1], "v1")
+	z01.ChallengeMain(t, "-h")
+	z01.ChallengeMain(t, "--help")
+	z01.ChallengeMain(t)
+
+	for _, v2 := range node.randArgFlag {
+		for _, v1 := range node.randArg {
+			z01.ChallengeMain(t, node.flags[0]+v2, node.flags[1], v1)
+		}
+	}
+	for _, v2 := range node.randArgFlag {
+		for _, v1 := range node.randArg {
+			z01.ChallengeMain(t, node.flagsShorthand[0]+v2, node.flagsShorthand[1], v1)
+		}
+	}
+}

tests/go/foreach_test.go

@@ -0,0 +1,44 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestForEach(t *testing.T) {
+
+	functionsArray := []func(int){solutions.Add0, solutions.Add1, solutions.Add2, solutions.Add3}
+
+	type node struct {
+		f   func(int)
+		arr []int
+	}
+
+	table := []node{}
+
+	//15 random slice of random ints with a random function from selection
+
+	for i := 0; i < 15; i++ {
+
+		functionSelected := functionsArray[z01.RandIntBetween(0, len(functionsArray)-1)]
+		val := node{
+			f:   functionSelected,
+			arr: z01.MultRandIntBetween(-1000000, 1000000),
+		}
+		table = append(table, val)
+
+	}
+
+	table = append(table, node{
+		f:   solutions.Add0,
+		arr: []int{1, 2, 3, 4, 5, 6},
+	})
+
+	for _, arg := range table {
+		z01.Challenge(t, student.ForEach, solutions.ForEach, arg.f, arg.arr)
+	}
+}

tests/go/index_test.go

@@ -0,0 +1,55 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIndex(t *testing.T) {
+	type node struct {
+		s      string
+		toFind string
+	}
+
+	table := []node{}
+
+	// the first 15 values are valid for this test
+	for i := 0; i < 15; i++ {
+		wordToTest := z01.RandASCII()
+		firstLetterIndex := z01.RandIntBetween(0, (len(wordToTest)-1)/2)
+		lastLetterIndex := z01.RandIntBetween(firstLetterIndex, len(wordToTest)-1)
+
+		val := node{
+			s:      wordToTest,
+			toFind: wordToTest[firstLetterIndex:lastLetterIndex],
+		}
+		table = append(table, val)
+	}
+
+	// the next 15 values are supposed to be invalid for this test
+	for i := 0; i < 15; i++ {
+		wordToTest := z01.RandASCII()
+		wrongMatch := z01.RandASCII()
+
+		val := node{
+			s:      wordToTest,
+			toFind: wrongMatch,
+		}
+		table = append(table, val)
+
+	}
+	// those are the test values from the README examples
+	table = append(table,
+		node{s: "Hello!", toFind: "l"},
+		node{s: "Salut!", toFind: "alu"},
+		node{s: "Ola!", toFind: "hOl"},
+	)
+
+	for _, arg := range table {
+		z01.Challenge(t, student.Index, solutions.Index, arg.s, arg.toFind)
+	}
+}

tests/go/isalpha_test.go

@@ -0,0 +1,28 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIsAlpha(t *testing.T) {
+	table := append(
+		z01.MultRandASCII(),
+		"Hello! €How are you?",
+		"a",
+		"z",
+		"!",
+		"HelloHowareyou",
+		"What's this 4?",
+		"Whatsthis4",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.IsAlpha, solutions.IsAlpha, arg)
+	}
+}

tests/go/islower_test.go

@@ -0,0 +1,47 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIsLower(t *testing.T) {
+	// 15 unvalid strings in the table
+	table := z01.MultRandASCII()
+
+	// 15 valid lowercase strings of random size between 1 and 20 letters in the table
+	for i := 0; i < 15; i++ {
+		size := z01.RandIntBetween(1, 20)
+		randLow := z01.RandLower()
+		if len(randLow) <= size {
+			table = append(table, randLow)
+		} else {
+			table = append(table, randLow[:size])
+		}
+	}
+
+	// Special cases added to table
+	table = append(table,
+		"Hello! How are you?",
+		"a",
+		"z",
+		"!",
+		"HelloHowareyou",
+		"What's this 4?",
+		"Whatsthis4",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!",
+		"0123456789",
+		"01,02,03",
+		"abcdefghijklmnopqrstuvwxyz",
+		"hello",
+		"hello!",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.IsLower, solutions.IsLower, arg)
+	}
+}

tests/go/isnegative_test.go

@@ -0,0 +1,22 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIsNegative(t *testing.T) {
+	table := append(
+		z01.MultRandInt(),
+		z01.MinInt,
+		z01.MaxInt,
+		0,
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.IsNegative, solutions.IsNegative, arg)
+	}
+}

tests/go/isnumeric_test.go

@@ -0,0 +1,40 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIsNumeric(t *testing.T) {
+	// 15 unvalid strings in the table
+	table := z01.MultRandASCII()
+
+	// 15 valid strings in the table
+	for i := 0; i < 15; i++ {
+		table = append(table, strconv.Itoa(z01.RandIntBetween(0, 1000000)))
+	}
+
+	// Special cases added to table
+	table = append(table,
+		"Hello! How are you?",
+		"a",
+		"z",
+		"!",
+		"HelloHowareyou",
+		"What's this 4?",
+		"Whatsthis4",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!",
+		"0123456789",
+		"010203",
+		"01,02,03",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.IsNumeric, solutions.IsNumeric, arg)
+	}
+}

tests/go/isprime_test.go

@@ -0,0 +1,35 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIsPrime(t *testing.T) {
+	table := append(
+		z01.MultRandIntBetween(-1000000, 1000000),
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		100,
+		1000000086,
+		1000000087,
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.IsPrime, solutions.IsPrime, arg)
+	}
+}

tests/go/isprintable_test.go

@@ -0,0 +1,51 @@
+package student_test
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIsPrintable(t *testing.T) {
+	// 15 unvalid strings in the table
+	table := z01.MultRandASCII()
+
+	// 15 valid lowercase strings of random size between 1 and 20 letters in the table
+	for i := 0; i < 15; i++ {
+		letters := []rune("\a\b\f\r\n\v\t")
+		size := z01.RandIntBetween(1, 20)
+		r := make([]rune, size)
+		for i := range r {
+			r[i] = letters[rand.Intn(len(letters))]
+		}
+		table = append(table, string(r))
+
+	}
+
+	// Special cases added to table
+	table = append(table,
+		"Hello! How are you?",
+		"a",
+		"z",
+		"!",
+		"HelloHowareyou",
+		"What's this 4?",
+		"Whatsthis4",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!",
+		"0123456789",
+		"01,02,03",
+		"abcdefghijklmnopqrstuvwxyz",
+		"hello",
+		"hello!",
+		"hello\n",
+		"\n",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.IsPrintable, solutions.IsPrintable, arg)
+	}
+}

tests/go/issorted_test.go

@@ -0,0 +1,87 @@
+package student_test
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIsSorted(t *testing.T) {
+	functionsArray := []func(int, int) int{solutions.IsSortedByDiff, solutions.IsSortedBy1, solutions.IsSortedBy10}
+
+	type node struct {
+		f   func(int, int) int
+		arr []int
+	}
+
+	table := []node{}
+
+	//5 unordered slices
+	for i := 0; i < 5; i++ {
+
+		functionSelected := functionsArray[z01.RandIntBetween(0, len(functionsArray)-1)]
+		val := node{
+			f:   functionSelected,
+			arr: z01.MultRandIntBetween(-1000000, 1000000),
+		}
+		table = append(table, val)
+
+	}
+
+	//5 slices ordered in ascending order
+	for i := 0; i < 5; i++ {
+
+		functionSelected := functionsArray[z01.RandIntBetween(0, len(functionsArray)-1)]
+		orderedArr := z01.MultRandIntBetween(-1000000, 1000000)
+		sort.Ints(orderedArr)
+
+		val := node{
+			f:   functionSelected,
+			arr: orderedArr,
+		}
+		table = append(table, val)
+
+	}
+
+	//5 slices ordered in descending order
+	for i := 0; i < 5; i++ {
+
+		functionSelected := functionsArray[z01.RandIntBetween(0, len(functionsArray)-1)]
+		reverseArr := z01.MultRandIntBetween(-1000000, 1000000)
+		sort.Sort(sort.Reverse(sort.IntSlice(reverseArr)))
+		val := node{
+			f:   functionSelected,
+			arr: reverseArr,
+		}
+		table = append(table, val)
+
+	}
+
+	table = append(table, node{
+		f:   solutions.IsSortedByDiff,
+		arr: []int{1, 2, 3, 4, 5, 6},
+	})
+
+	table = append(table, node{
+		f:   solutions.IsSortedByDiff,
+		arr: []int{6, 5, 4, 3, 2, 1},
+	})
+
+	table = append(table, node{
+		f:   solutions.IsSortedByDiff,
+		arr: []int{0, 0, 0, 0, 0, 0, 0},
+	})
+
+	table = append(table, node{
+		f:   solutions.IsSortedByDiff,
+		arr: []int{0},
+	})
+
+	for _, arg := range table {
+		z01.Challenge(t, student.IsSorted, solutions.IsSorted, arg.f, arg.arr)
+	}
+}

tests/go/isupper_test.go

@@ -0,0 +1,49 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIsUpper(t *testing.T) {
+	// 15 unvalid strings in the table
+	table := z01.MultRandASCII()
+
+	// 15 valid lowercase strings of random size between 1 and 20 letters in the table
+	for i := 0; i < 15; i++ {
+		size := z01.RandIntBetween(1, 20)
+		randLow := z01.RandLower()
+		if len(randLow) <= size {
+			table = append(table, randLow)
+		} else {
+			table = append(table, randLow[:size])
+		}
+	}
+
+	// Special cases added to table
+	table = append(table,
+		"Hello! How are you?",
+		"a",
+		"z",
+		"!",
+		"HelloHowareyou",
+		"What's this 4?",
+		"Whatsthis4",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890",
+		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!",
+		"0123456789",
+		"01,02,03",
+		"abcdefghijklmnopqrstuvwxyz",
+		"hello",
+		"hello!",
+		"HELLO",
+		"HELLO!",
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.IsUpper, solutions.IsUpper, arg)
+	}
+}

tests/go/iterativefactorial_test.go

@@ -0,0 +1,24 @@
+package student_test
+
+import (
+	"math/bits"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIterativeFactorial(t *testing.T) {
+	table := append(
+		z01.MultRandInt(),
+		z01.IntRange(0, 12)...,
+	)
+	if bits.UintSize == 64 {
+		table = append(table, z01.IntRange(13, 20)...)
+	}
+	for _, arg := range table {
+		z01.Challenge(t, student.IterativeFactorial, solutions.IterativeFactorial, arg)
+	}
+}

tests/go/iterativepower_test.go

@@ -0,0 +1,22 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestIterativePower(t *testing.T) {
+	i := 0
+	for i < 30 {
+		nb := z01.RandIntBetween(-8, 8)
+		power := z01.RandIntBetween(-10, 10)
+		z01.Challenge(t, student.IterativePower, solutions.IterativePower, nb, power)
+		i++
+	}
+	z01.Challenge(t, student.IterativePower, solutions.IterativePower, 0, 0)
+	z01.Challenge(t, student.IterativePower, solutions.IterativePower, 0, 1)
+}

tests/go/itoa_test.go

@@ -0,0 +1,16 @@
+package student_test
+
+import (
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+func TestItoa(t *testing.T) {
+	for i := 0; i < 50; i++ {
+		arg := z01.RandIntBetween(-2000000000, 2000000000)
+		z01.Challenge(t, student.Itoa, solutions.Itoa, arg)
+	}
+}

tests/go/itoabase_test.go

@@ -0,0 +1,23 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestItoaBase(t *testing.T) {
+	for i := 0; i < 30; i++ {
+		value := z01.RandIntBetween(-1000000, 1000000)
+		base := z01.RandIntBetween(2, 16)
+		z01.Challenge(t, student.ItoaBase, solutions.ItoaBase, value, base)
+	}
+	for i := 0; i < 5; i++ {
+		base := z01.RandIntBetween(2, 16)
+		z01.Challenge(t, student.ItoaBase, solutions.ItoaBase, z01.MaxInt, base)
+		z01.Challenge(t, student.ItoaBase, solutions.ItoaBase, z01.MinInt, base)
+	}
+}

tests/go/join_test.go

@@ -0,0 +1,26 @@
+package student_test
+
+import (
+	solutions "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+	"testing"
+)
+
+func TestJoin(t *testing.T) {
+	arg1 := []string{"hello", "how", "are", "you", "doing"}
+	arg2 := []string{"fine", "and", "you"}
+	arg3 := []string{"I'm", "O.K."}
+	seps := []string{" ", "-", " ,", "_", "SPC", " . "}
+
+	args := [][]string{arg1, arg2, arg3}
+
+	for i := 0; i < 5; i++ {
+		//random position for the array of arguments
+		posA := z01.RandIntBetween(0, len(args)-1)
+		//random position for the array of separators
+		posS := z01.RandIntBetween(0, len(seps)-1)
+
+		z01.Challenge(t, student.Join, solutions.Join, args[posA], seps[posS])
+	}
+}

tests/go/lastrune_test.go

@@ -0,0 +1,23 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestLastRune(t *testing.T) {
+	table := z01.MultRandASCII()
+	table = append(table,
+		"Hello!",
+		"Salut!",
+		"Ola!",
+		z01.RandStr(z01.RandIntBetween(1, 15), z01.RandAlnum()),
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.LastRune, solutions.LastRune, arg)
+	}
+}

tests/go/listat_test.go

@@ -0,0 +1,101 @@
+package student_test
+
+import (
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+type Node5 = student.NodeL
+type NodeS5 = solution.NodeL
+
+func nodePushBackList5(l *Node5, l1 *NodeS5, data interface{}) (*Node5, *NodeS5) {
+	n := &Node5{Data: data}
+	n1 := &NodeS5{Data: data}
+	it := l
+	itS := l1
+
+	if it == nil {
+		it = n
+	} else {
+		iterator := it
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+	if itS == nil {
+		itS = n1
+	} else {
+		iterator1 := itS
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+	return it, itS
+}
+
+// compare functions that consist on inserting using the structure node
+func comparFuncNode5(solutionList *NodeS5, l *Node5, l1 *NodeS5, t *testing.T, arg int) {
+	if l == nil && l1 == nil {
+	} else if l != nil && l1 == nil {
+		t.Errorf("\nListAt(%s, %d) == %v instead of %v\n\n",
+			solution.ListToString(solutionList), arg, l, l1)
+	} else if l.Data != l1.Data {
+		t.Errorf("\nListAt(%s, %d) == %v instead of %v\n\n",
+			solution.ListToString(solutionList), arg, l.Data, l1.Data)
+	}
+}
+
+// exercise 7
+// finds an element of a solution.ListS using a given position
+func TestListAt(t *testing.T) {
+	var link *Node5
+	var link2 *NodeS5
+
+	type nodeTest struct {
+		data []interface{}
+		pos  int
+	}
+
+	var table []nodeTest
+
+	for i := 0; i < 4; i++ {
+		val := nodeTest{
+			data: solution.ConvertIntToInterface(z01.MultRandInt()),
+			pos:  z01.RandIntBetween(1, 12),
+		}
+		table = append(table, val)
+	}
+
+	for i := 0; i < 4; i++ {
+		val := nodeTest{
+			data: solution.ConvertIntToStringface(z01.MultRandWords()),
+			pos:  z01.RandIntBetween(1, 12),
+		}
+		table = append(table, val)
+	}
+
+	table = append(table,
+		nodeTest{
+			data: []interface{}{"I", 1, "something", 2},
+			pos:  z01.RandIntBetween(1, 4),
+		},
+	)
+
+	for _, arg := range table {
+		for i := 0; i < len(arg.data); i++ {
+			link, link2 = nodePushBackList5(link, link2, arg.data[i])
+		}
+
+		result := student.ListAt(link, arg.pos)
+		result2 := solution.ListAt(link2, arg.pos)
+
+		comparFuncNode5(link2, result, result2, t, arg.pos)
+		link = nil
+		link2 = nil
+	}
+}

tests/go/listclear_test.go

@@ -0,0 +1,84 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+)
+
+type Node4 = student.NodeL
+type List4 = solution.List
+type NodeS4 = solution.NodeL
+type ListS4 = student.List
+
+func listToStringStu5(l *ListS4) string {
+	var res string
+	it := l.Head
+	for it != nil {
+		switch it.Data.(type) {
+		case int:
+			res += strconv.Itoa(it.Data.(int)) + "-> "
+		case string:
+			res += it.Data.(string) + "-> "
+		}
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+func listPushBackTest4(l *ListS4, l1 *List4, data interface{}) {
+	n := &Node4{Data: data}
+	n1 := &NodeS4{Data: data}
+	if l.Head == nil {
+		l.Head = n
+	} else {
+		iterator := l.Head
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+	if l1.Head == nil {
+		l1.Head = n1
+	} else {
+		iterator1 := l1.Head
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+}
+
+//exercise 6
+//simply cleans the linked solution.ListS
+func TestListClear(t *testing.T) {
+	link := &List4{}
+	link2 := &ListS4{}
+
+	table := []solution.NodeTest{}
+
+	table = solution.ElementsToTest(table)
+
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{"I", 1, "something", 2},
+		},
+	)
+
+	for _, arg := range table {
+
+		for i := 0; i < len(arg.Data); i++ {
+			listPushBackTest4(link2, link, arg.Data[i])
+		}
+		solution.ListClear(link)
+		student.ListClear(link2)
+
+		if link2.Head != nil {
+			t.Errorf("\nstudent list:%s\nlist:%s\n\nListClear() == %v instead of %v\n\n",
+				listToStringStu5(link2), solution.ListToString(link.Head), link2.Head, link.Head)
+		}
+	}
+}

tests/go/listfind_test.go

@@ -0,0 +1,81 @@
+package student_test
+
+import (
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+)
+
+type Node9 = student.NodeL
+type List9 = solution.List
+type NodeS9 = solution.NodeL
+type ListS9 = student.List
+
+func listPushBackTest9(l *ListS9, l1 *List9, data interface{}) {
+	n := &Node9{Data: data}
+	n1 := &NodeS9{Data: data}
+	if l.Head == nil {
+		l.Head = n
+	} else {
+		iterator := l.Head
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+	if l1.Head == nil {
+		l1.Head = n1
+	} else {
+		iterator1 := l1.Head
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+}
+
+// exercise 11
+func TestListFind(t *testing.T) {
+	link := &List9{}
+	link2 := &ListS9{}
+
+	table := []solution.NodeTest{}
+	table = solution.ElementsToTest(table)
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{"hello", "hello1", "hello2", "hello3"},
+		},
+	)
+
+	for _, arg := range table {
+		for i := 0; i < len(arg.Data); i++ {
+			listPushBackTest9(link2, link, arg.Data[i])
+		}
+		if len(arg.Data) != 0 {
+			aux := student.ListFind(link2, arg.Data[(len(arg.Data)-1)/2], student.CompStr)
+			aux1 := solution.ListFind(link, arg.Data[(len(arg.Data)-1)/2], solution.CompStr)
+
+			if aux != nil || aux1 != nil {
+				if *aux != *aux1 {
+					t.Errorf("ListFind(ref: %s) == %s instead of %s\n", arg.Data[(len(arg.Data)-1)/2], *aux, *aux1)
+				}
+			}
+		}
+		link = &List9{}
+		link2 = &ListS9{}
+	}
+
+	for i := 0; i < len(table[0].Data); i++ {
+		listPushBackTest9(link2, link, table[0].Data[i])
+	}
+
+	aux := student.ListFind(link2, "lksdf", student.CompStr)
+	aux1 := solution.ListFind(link, "lksdf", solution.CompStr)
+	if aux != nil && aux1 != nil {
+		if *aux != *aux1 {
+			t.Errorf("ListFind(ref: lksdf) == %s instead of %s\n", *aux, *aux1)
+		}
+	}
+
+}

tests/go/listforeach_test.go

@@ -0,0 +1,102 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+)
+
+type Node7 = student.NodeL
+type List7 = solution.List
+type NodeS7 = solution.NodeL
+type ListS7 = student.List
+
+func listToStringStu8(l *ListS7) string {
+	var res string
+	it := l.Head
+	for it != nil {
+		switch it.Data.(type) {
+		case int:
+			res += strconv.Itoa(it.Data.(int)) + "-> "
+		case string:
+			res += it.Data.(string) + "-> "
+		}
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+func listPushBackTest7(l *ListS7, l1 *List7, data interface{}) {
+	n := &Node7{Data: data}
+	n1 := &NodeS7{Data: data}
+	if l.Head == nil {
+		l.Head = n
+	} else {
+		iterator := l.Head
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+	if l1.Head == nil {
+		l1.Head = n1
+	} else {
+		iterator1 := l1.Head
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+}
+
+func comparFuncList7(l *List7, l1 *ListS7, t *testing.T, f func(*Node7)) {
+	funcName := solution.GetName(f)
+	for l.Head != nil || l1.Head != nil {
+		if (l.Head == nil && l1.Head != nil) || (l.Head != nil && l1.Head == nil) {
+			t.Errorf("\nstudent list: %s\nlist: %s\nfunction used: %s\n\nListForEach() == %v instead of %v\n\n",
+				listToStringStu8(l1), solution.ListToString(l.Head), funcName, l1.Head, l.Head)
+			return
+		} else if l.Head.Data != l1.Head.Data {
+			t.Errorf("\nstudent list: %s\nlist: %s\nfunction used: %s\n\nListForEach() == %v instead of %v\n\n",
+				listToStringStu8(l1), solution.ListToString(l.Head), funcName, l1.Head.Data, l.Head.Data)
+			return
+		}
+		l.Head = l.Head.Next
+		l1.Head = l1.Head.Next
+	}
+}
+
+//exercise 9
+//applies a function to the solution.ListS
+func TestListForEach(t *testing.T) {
+	link := &List7{}
+	link2 := &ListS7{}
+	table := []solution.NodeTest{}
+	table = solution.ElementsToTest(table)
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{"I", 1, "something", 2},
+		},
+	)
+	for _, arg := range table {
+
+		for i := 0; i < len(arg.Data); i++ {
+			listPushBackTest7(link2, link, arg.Data[i])
+		}
+		student.ListForEach(link2, student.Add2_node)
+		solution.ListForEach(link, solution.Add2_node)
+
+		comparFuncList7(link, link2, t, student.Add2_node)
+
+		student.ListForEach(link2, student.Subtract3_node)
+		solution.ListForEach(link, solution.Subtract3_node)
+
+		comparFuncList7(link, link2, t, student.Subtract3_node)
+
+		link = &List7{}
+		link2 = &ListS7{}
+	}
+}

tests/go/listforeachif_test.go

@@ -0,0 +1,151 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+type Node8 = student.NodeL
+type List8 = solution.List
+type NodeS8 = solution.NodeL
+type ListS8 = student.List
+
+// function to apply, in listforeachif
+func addOneS(node *NodeS8) {
+	data := node.Data.(int)
+	data++
+	node.Data = interface{}(data)
+}
+
+// function to apply, in listforeachif
+func addOne(node *Node8) {
+	data := node.Data.(int)
+	data++
+	node.Data = interface{}(data)
+}
+
+func subtract1_sol(node *NodeS8) {
+	data := node.Data.(int)
+	data--
+	node.Data = interface{}(data)
+}
+
+func subtractOne(node *Node8) {
+	data := node.Data.(int)
+	data--
+	node.Data = interface{}(data)
+}
+
+func listToStringStu7(l *ListS8) string {
+	var res string
+	it := l.Head
+	for it != nil {
+		switch it.Data.(type) {
+		case int:
+			res += strconv.Itoa(it.Data.(int)) + "-> "
+		case string:
+			res += it.Data.(string) + "-> "
+		}
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+func listPushBackTest8(l *ListS8, l1 *List8, data interface{}) {
+
+	n := &Node8{Data: data}
+	n1 := &NodeS8{Data: data}
+
+	if l.Head == nil {
+		l.Head = n
+	} else {
+		iterator := l.Head
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+
+	if l1.Head == nil {
+		l1.Head = n1
+	} else {
+		iterator1 := l1.Head
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+}
+
+func comparFuncList8(l *List8, l1 *ListS8, t *testing.T, f func(*Node8) bool, comp func(*Node8)) {
+	funcFName := solution.GetName(f)
+	funcComp := solution.GetName(comp)
+	for l.Head != nil || l1.Head != nil {
+		if (l.Head == nil && l1.Head != nil) || (l.Head != nil && l1.Head == nil) {
+			t.Errorf("\nstudent list:%s\nlist:%s\nfunction f used: %s\nfunction comp: %s\n\nListForEachIf() == %v instead of %v\n\n",
+				listToStringStu7(l1), solution.ListToString(l.Head), funcComp, funcFName, l1.Head, l.Head)
+			return
+		} else if l.Head.Data != l1.Head.Data {
+			t.Errorf("\nstudent list:%s\nlist:%s\nfunction f used: %s\nfunction comp: %s\n\nListForEachIf() == %v instead of %v\n\n",
+				listToStringStu7(l1), solution.ListToString(l.Head), funcComp, funcFName, l1.Head.Data, l.Head.Data)
+			return
+		}
+		l.Head = l.Head.Next
+		l1.Head = l1.Head.Next
+	}
+}
+
+// exercise 10
+// applies a function to an element of the linked solution.ListS
+func TestListForEachIf(t *testing.T) {
+	link := &ListS8{}
+	link2 := &List8{}
+
+	table := []solution.NodeTest{}
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{},
+		},
+	)
+
+	// just numbers/ints
+	for i := 0; i < 3; i++ {
+		val := solution.NodeTest{
+			Data: solution.ConvertIntToInterface(z01.MultRandInt()),
+		}
+		table = append(table, val)
+
+	}
+	// just strings
+	for i := 0; i < 3; i++ {
+		val := solution.NodeTest{
+			Data: solution.ConvertIntToStringface(z01.MultRandWords()),
+		}
+		table = append(table, val)
+	}
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{"I", 1, "something", 2},
+		},
+	)
+	for _, arg := range table {
+		for i := 0; i < len(arg.Data); i++ {
+			listPushBackTest8(link, link2, arg.Data[i])
+		}
+		solution.ListForEachIf(link2, addOneS, solution.IsPositive_node)
+		student.ListForEachIf(link, addOne, student.IsPositive_node)
+		comparFuncList8(link2, link, t, student.IsPositive_node, addOne)
+
+		solution.ListForEachIf(link2, subtract1_sol, solution.IsPositive_node)
+		student.ListForEachIf(link, subtractOne, student.IsPositive_node)
+		comparFuncList8(link2, link, t, student.IsPositive_node, subtractOne)
+
+		link = &ListS8{}
+		link2 = &List8{}
+	}
+}

tests/go/listlast_test.go

@@ -0,0 +1,79 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+)
+
+type Node3 = student.NodeL
+type List3 = solution.List
+type NodeS3 = solution.NodeL
+type ListS3 = student.List
+
+func listToStringStu9(l *ListS3) string {
+	var res string
+	it := l.Head
+	for it != nil {
+		switch it.Data.(type) {
+		case int:
+			res += strconv.Itoa(it.Data.(int)) + "-> "
+		case string:
+			res += it.Data.(string) + "-> "
+		}
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+//inserts node on two lists
+func listPushBackTest3(l *ListS3, l1 *List3, data interface{}) {
+	n := &Node3{Data: data}
+	n1 := &NodeS3{Data: data}
+	if l.Head == nil {
+		l.Head = n
+		l.Tail = n
+	} else {
+		l.Tail.Next = n
+		l.Tail = n
+	}
+	if l1.Head == nil {
+		l1.Head = n1
+		l1.Tail = n1
+	} else {
+		l1.Tail.Next = n1
+		l1.Tail = n1
+	}
+}
+
+//exercise 5
+//last element of the solution.ListS
+func TestListLast(t *testing.T) {
+	link := &List3{}
+	link2 := &ListS3{}
+	table := []solution.NodeTest{}
+
+	table = solution.ElementsToTest(table)
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{3, 2, 1},
+		},
+	)
+	for _, arg := range table {
+		for i := 0; i < len(arg.Data); i++ {
+			listPushBackTest3(link2, link, arg.Data[i])
+		}
+		aux := solution.ListLast(link)
+		aux1 := student.ListLast(link2)
+
+		if aux != aux1 {
+			t.Errorf("\nlist:%s\n\nListLast() == %v instead of %v\n\n",
+				listToStringStu9(link2), aux1, aux)
+		}
+		link = &List3{}
+		link2 = &ListS3{}
+	}
+}

tests/go/listmerge_test.go

@@ -0,0 +1,141 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solution "./solutions"
+	student "./student"
+)
+
+type Node11 = student.NodeL
+type List11 = solution.List
+type NodeS11 = solution.NodeL
+type ListS11 = student.List
+
+func listToStringStu(l *ListS11) string {
+	var res string
+	it := l.Head
+	for it != nil {
+		switch it.Data.(type) {
+		case int:
+			res += strconv.Itoa(it.Data.(int)) + "->"
+		case string:
+			res += it.Data.(string) + "->"
+		}
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+func listPushBackTest11(l *ListS11, l1 *List11, data interface{}) {
+	n := &Node11{Data: data}
+	n1 := &NodeS11{Data: data}
+
+	if l.Head == nil {
+		l.Head = n
+	} else {
+		iterator := l.Head
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+	l.Tail = n
+
+	if l1.Head == nil {
+		l1.Head = n1
+	} else {
+		iterator1 := l1.Head
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+	l1.Tail = n1
+}
+
+func comparFuncList11(l *List11, l1 *ListS11, t *testing.T) {
+	for l.Head != nil || l1.Head != nil {
+		if (l.Head == nil && l1.Head != nil) || (l.Head != nil && l1.Head == nil) {
+			t.Errorf("\nstudent list:%s\nlist:%s\n\nListMerge() == %v instead of %v\n\n",
+				listToStringStu(l1), solution.ListToString(l.Head), l1.Head, l.Head)
+			return
+		} else if l.Head.Data != l1.Head.Data {
+			t.Errorf("\nstudent list:%s\nlist:%s\n\nListMerge() == %v instead of %v\n\n",
+				listToStringStu(l1), solution.ListToString(l.Head), l1.Head.Data, l.Head.Data)
+			return
+		}
+		l.Head = l.Head.Next
+		l1.Head = l1.Head.Next
+	}
+}
+
+//exercise 14
+func TestListMerge(t *testing.T) {
+	link := &List11{}
+	linkTest := &List11{}
+	link2 := &ListS11{}
+	link2Test := &ListS11{}
+
+	type nodeTest struct {
+		data  []interface{}
+		data2 []interface{}
+	}
+	table := []nodeTest{}
+	// empty list
+	table = append(table,
+		nodeTest{
+			data:  []interface{}{},
+			data2: []interface{}{},
+		})
+	table = append(table,
+		nodeTest{
+			data:  solution.ConvertIntToInterface(z01.MultRandInt()),
+			data2: []interface{}{},
+		})
+	// jut ints
+	for i := 0; i < 3; i++ {
+		val := nodeTest{
+			data:  solution.ConvertIntToInterface(z01.MultRandInt()),
+			data2: solution.ConvertIntToInterface(z01.MultRandInt()),
+		}
+		table = append(table, val)
+	}
+	// just strings
+	for i := 0; i < 2; i++ {
+		val := nodeTest{
+			data:  solution.ConvertIntToStringface(z01.MultRandWords()),
+			data2: solution.ConvertIntToStringface(z01.MultRandWords()),
+		}
+		table = append(table, val)
+	}
+	table = append(table,
+		nodeTest{
+			data:  []interface{}{},
+			data2: []interface{}{"a", 1},
+		},
+	)
+	for _, arg := range table {
+		for i := 0; i < len(arg.data); i++ {
+			listPushBackTest11(link2, link, arg.data[i])
+		}
+		for i := 0; i < len(arg.data2); i++ {
+			listPushBackTest11(link2Test, linkTest, arg.data2[i])
+		}
+
+		solution.ListMerge(link, linkTest)
+
+		student.ListMerge(link2, link2Test)
+
+		comparFuncList11(link, link2, t)
+
+		link = &List11{}
+		linkTest = &List11{}
+		link2 = &ListS11{}
+		link2Test = &ListS11{}
+	}
+}

tests/go/listpushback_test.go

@@ -0,0 +1,66 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+)
+
+type ListS = solution.List
+type List = student.List
+
+func listToStringStu10(l *List) string {
+	var res string
+	it := l.Head
+	for it != nil {
+		switch it.Data.(type) {
+		case int:
+			res += strconv.Itoa(it.Data.(int)) + "-> "
+		case string:
+			res += it.Data.(string) + "-> "
+		}
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+// makes the test, compares 2 lists one from the solutions and the other from the student
+func comparFuncList(l *ListS, l1 *List, t *testing.T, data []interface{}) {
+	for l.Head != nil || l1.Head != nil {
+		if (l.Head == nil && l1.Head != nil) || (l.Head != nil && l1.Head == nil) {
+			t.Errorf("\ndata used: %v\nstudent list:%s\nlist:%s\n\nListPushBack()== %v instead of %v\n\n",
+				data, listToStringStu10(l1), solution.ListToString(l.Head), l1.Head, l.Head)
+			return
+		} else if l.Head.Data != l1.Head.Data {
+			t.Errorf("\ndata used: %v\nstudent list:%s\nlist:%s\n\nListPushBack()== %v instead of %v\n\n",
+				data, listToStringStu10(l1), solution.ListToString(l.Head), l1.Head.Data, l.Head.Data)
+			return
+		}
+		l.Head = l.Head.Next
+		l1.Head = l1.Head.Next
+	}
+}
+
+// exercise 2
+func TestListPushBack(t *testing.T) {
+	link := &ListS{}
+	link2 := &List{}
+
+	table := []solution.NodeTest{}
+	table = solution.ElementsToTest(table)
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{"Hello", "man", "how are you"},
+		},
+	)
+	for _, arg := range table {
+		for i := 0; i < len(arg.Data); i++ {
+			student.ListPushBack(link2, arg.Data[i])
+			solution.ListPushBack(link, arg.Data[i])
+		}
+		comparFuncList(link, link2, t, arg.Data)
+	}
+}

tests/go/listpushfront_test.go

@@ -0,0 +1,68 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+)
+
+type ListSa = solution.List
+type Lista = student.List
+
+func listToStringStu11(l *Lista) string {
+	var res string
+	it := l.Head
+	for it != nil {
+		switch it.Data.(type) {
+		case int:
+			res += strconv.Itoa(it.Data.(int)) + "-> "
+		case string:
+			res += it.Data.(string) + "-> "
+		}
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+//makes the test, compares 2 lists one from the solutions and the other from the student
+func comparFuncList1(l *Lista, l1 *ListSa, t *testing.T, data []interface{}) {
+	for l.Head != nil || l1.Head != nil {
+		if (l.Head == nil && l1.Head != nil) || (l.Head != nil && l1.Head == nil) {
+			t.Errorf("\ndata used: %v\nstudent list:%s\nlist:%s\n\nListPushFront()== %v instead of %v\n\n",
+				data, listToStringStu11(l), solution.ListToString(l1.Head), l.Head, l1.Head)
+			return
+		} else if l.Head.Data != l1.Head.Data {
+			t.Errorf("\ndata used: %v\nstudent list:%s\nlist:%s\n\nListPushFront()== %v instead of %v\n\n",
+				data, listToStringStu11(l), solution.ListToString(l1.Head), l.Head, l1.Head)
+			return
+		}
+		l1.Head = l1.Head.Next
+		l.Head = l.Head.Next
+	}
+}
+
+//exercise 3
+//to insert a value in the first position of the list
+func TestListPushFront(t *testing.T) {
+	link := &Lista{}
+	link2 := &ListSa{}
+	table := []solution.NodeTest{}
+	table = solution.ElementsToTest(table)
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{"Hello", "man", "how are you"},
+		},
+	)
+	for _, arg := range table {
+		for i := 0; i < len(arg.Data); i++ {
+			student.ListPushFront(link, arg.Data[i])
+			solution.ListPushFront(link2, arg.Data[i])
+		}
+		comparFuncList1(link, link2, t, arg.Data)
+		link = &Lista{}
+		link2 = &ListSa{}
+	}
+}

tests/go/listremoveif_test.go

@@ -0,0 +1,109 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+type Node10 = student.NodeL
+type List10 = solution.List
+type NodeS10 = solution.NodeL
+type ListS10 = student.List
+
+func listToStringStu12(l *ListS10) string {
+	var res string
+	it := l.Head
+	for it != nil {
+		switch it.Data.(type) {
+		case int:
+			res += strconv.Itoa(it.Data.(int)) + "-> "
+		case string:
+			res += it.Data.(string) + "-> "
+		}
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+func listPushBackTest10(l *ListS10, l1 *List10, data interface{}) {
+	n := &Node10{Data: data}
+	n1 := &NodeS10{Data: data}
+	if l.Head == nil {
+		l.Head = n
+	} else {
+		iterator := l.Head
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+	if l1.Head == nil {
+		l1.Head = n1
+	} else {
+		iterator1 := l1.Head
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+}
+
+func comparFuncList10(l *List10, l1 *ListS10, t *testing.T, data interface{}) {
+	for l.Head != nil || l1.Head != nil {
+		if (l.Head == nil && l1.Head != nil) || (l.Head != nil && l1.Head == nil) {
+			t.Errorf("\ndata used: %v\nstudent list:%s\nlist:%s\n\nListRemoveIf() == %v instead of %v\n\n",
+				data, listToStringStu12(l1), solution.ListToString(l.Head), l1.Head, l.Head)
+			return
+		} else if l.Head.Data != l1.Head.Data {
+			t.Errorf("\ndata used: %v\nstudent list:%s\nlist:%s\n\nListRemoveIf() == %v instead of %v\n\n",
+				data, listToStringStu12(l1), solution.ListToString(l.Head), l1.Head.Data, l.Head.Data)
+			return
+		}
+		l.Head = l.Head.Next
+		l1.Head = l1.Head.Next
+	}
+}
+
+//exercise 13
+//removes all the elements that are equal to a value
+func TestListRemoveIf(t *testing.T) {
+	link := &List10{}
+	link2 := &ListS10{}
+	var index int
+	table := []solution.NodeTest{}
+
+	table = solution.ElementsToTest(table)
+
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{"hello", "hello1", "hello2", "hello3"},
+		},
+	)
+
+	for _, arg := range table {
+		for i := 0; i < len(arg.Data); i++ {
+			listPushBackTest10(link2, link, arg.Data[i])
+		}
+		aux := len(arg.Data) - 1
+
+		index = z01.RandIntBetween(0, aux)
+		if link.Head != nil && link2.Head != nil {
+			cho := arg.Data[index]
+			student.ListRemoveIf(link2, cho)
+			solution.ListRemoveIf(link, cho)
+			comparFuncList10(link, link2, t, cho)
+		} else {
+			student.ListRemoveIf(link2, 1)
+			solution.ListRemoveIf(link, 1)
+			comparFuncList10(link, link2, t, 1)
+		}
+
+		link = &List10{}
+		link2 = &ListS10{}
+	}
+}

tests/go/listreverse_test.go

@@ -0,0 +1,91 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+)
+
+type Node6 = student.NodeL
+type List6 = solution.List
+type NodeS6 = solution.NodeL
+type ListS6 = student.List
+
+func listToStringStu13(l *ListS6) string {
+	var res string
+	it := l.Head
+	for it != nil {
+		switch it.Data.(type) {
+		case int:
+			res += strconv.Itoa(it.Data.(int)) + "-> "
+		case string:
+			res += it.Data.(string) + "-> "
+		}
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+func comparFuncList6(l *List6, l1 *ListS6, t *testing.T) {
+	for l.Head != nil || l1.Head != nil {
+		if (l.Head == nil && l1.Head != nil) || (l.Head != nil && l1.Head == nil) {
+			t.Errorf("\nstudent list:%s\nlist:%s\n\nListReverse() == %v instead of %v\n\n",
+				listToStringStu13(l1), solution.ListToString(l.Head), l1.Head, l.Head)
+			return
+		} else if l.Head.Data != l1.Head.Data {
+			t.Errorf("\nstudent list:%s\nlist:%s\n\nListReverse() == %v instead of %v\n\n",
+				listToStringStu13(l1), solution.ListToString(l.Head), l1.Head.Data, l.Head.Data)
+			return
+		}
+		l.Head = l.Head.Next
+		l1.Head = l1.Head.Next
+	}
+}
+func listPushBackTest6(l *ListS6, l1 *List6, data interface{}) {
+	n := &Node6{Data: data}
+	n1 := &NodeS6{Data: data}
+	if l.Head == nil {
+		l.Head = n
+	} else {
+		iterator := l.Head
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+	if l1.Head == nil {
+		l1.Head = n1
+	} else {
+		iterator1 := l1.Head
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+}
+
+// exercise 8
+func TestListReverse(t *testing.T) {
+	link := &List6{}
+	link2 := &ListS6{}
+	table := []solution.NodeTest{}
+	table = solution.ElementsToTest(table)
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{"I", 1, "something", 2},
+		},
+	)
+	for _, arg := range table {
+		for i := 0; i < len(arg.Data); i++ {
+			listPushBackTest6(link2, link, arg.Data[i])
+		}
+		student.ListReverse(link2)
+		solution.ListReverse(link)
+		comparFuncList6(link, link2, t)
+		link = &List6{}
+		link2 = &ListS6{}
+	}
+}

tests/go/listsize_test.go

@@ -0,0 +1,62 @@
+package student_test
+
+import (
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+)
+
+type Node2 = student.NodeL
+type List2 = solution.List
+type NodeS2 = solution.NodeL
+type ListS2 = student.List
+
+func listPushBackTest2(l *ListS2, l1 *List2, data interface{}) {
+	n := &Node2{Data: data}
+	n1 := &NodeS2{Data: data}
+	if l.Head == nil {
+		l.Head = n
+	} else {
+		iterator := l.Head
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+
+	if l1.Head == nil {
+		l1.Head = n1
+	} else {
+		iterator1 := l1.Head
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+}
+
+//exercise 4
+func TestListSize(t *testing.T) {
+	link := &List2{}
+	link2 := &ListS2{}
+	table := []solution.NodeTest{}
+	table = solution.ElementsToTest(table)
+	table = append(table,
+		solution.NodeTest{
+			Data: []interface{}{"Hello", "man", "how are you"},
+		},
+	)
+	for _, arg := range table {
+		for i := 0; i < len(arg.Data); i++ {
+			listPushBackTest2(link2, link, arg.Data[i])
+		}
+		aux := solution.ListSize(link)
+		aux2 := student.ListSize(link2)
+		if aux != aux2 {
+			t.Errorf("ListSize(%v) == %d instead of %d\n", solution.ListToString(link.Head), aux2, aux)
+		}
+		link = &List2{}
+		link2 = &ListS2{}
+	}
+}

tests/go/listsort_test.go

@@ -0,0 +1,106 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	solution "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+type NodeI12 = student.NodeI
+type NodeIS12 = solution.NodeI
+
+func printListStudent(n *NodeI12) string {
+	var res string
+	it := n
+	for it != nil {
+		res += strconv.Itoa(it.Data) + "-> "
+		it = it.Next
+	}
+	res += "<nil>"
+	return res
+}
+
+func nodePushBackListInt12(l *NodeI12, l1 *NodeIS12, data int) {
+	n := &NodeI12{Data: data}
+	n1 := &NodeIS12{Data: data}
+
+	if l == nil {
+		l = n
+	} else {
+		iterator := l
+		for iterator.Next != nil {
+			iterator = iterator.Next
+		}
+		iterator.Next = n
+	}
+
+	if l1 == nil {
+		l1 = n1
+	} else {
+		iterator1 := l1
+		for iterator1.Next != nil {
+			iterator1 = iterator1.Next
+		}
+		iterator1.Next = n1
+	}
+}
+
+func comparFuncNodeInt12(l *NodeI12, l1 *NodeIS12, t *testing.T) {
+	for l != nil || l1 != nil {
+		if (l == nil && l1 != nil) || (l != nil && l1 == nil) {
+			t.Errorf("\nstudent list:%s\nlist:%s\n\nListSort() == %v instead of %v\n\n",
+				printListStudent(l), solution.PrintList(l1), l, l1)
+			return
+		} else if l.Data != l1.Data {
+			t.Errorf("\nstudent list:%s\nlist:%s\n\nListSort() == %v instead of %v\n\n",
+				printListStudent(l), solution.PrintList(l1), l.Data, l1.Data)
+			return
+		}
+		l = l.Next
+		l1 = l1.Next
+	}
+}
+
+//exercise 15
+func TestListSort(t *testing.T) {
+	var link *NodeI12
+	var link2 *NodeIS12
+
+	type nodeTest struct {
+		data []int
+	}
+	table := []nodeTest{}
+
+	table = append(table,
+		nodeTest{
+			data: []int{},
+		})
+	//just numbers/ints
+	for i := 0; i < 2; i++ {
+		val := nodeTest{
+			data: z01.MultRandInt(),
+		}
+		table = append(table, val)
+	}
+
+	table = append(table,
+		nodeTest{
+			data: []int{5, 4, 3, 2, 1},
+		},
+	)
+	for _, arg := range table {
+		for i := 0; i < len(arg.data); i++ {
+			nodePushBackListInt12(link, link2, arg.data[i])
+		}
+		aux := solution.ListSort(link2)
+		aux2 := student.ListSort(link)
+
+		comparFuncNodeInt12(aux2, aux, t)
+
+		link = &NodeI12{}
+		link2 = &NodeIS12{}
+	}
+}

tests/go/makerange_test.go

@@ -0,0 +1,50 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestMakeRange(t *testing.T) {
+	type node struct {
+		min int
+		max int
+	}
+
+	table := []node{}
+
+	// 15 random pairs of ints for a Valid Range
+	for i := 0; i < 15; i++ {
+		minVal := z01.RandIntBetween(-10000000, 1000000)
+		gap := z01.RandIntBetween(1, 20)
+		val := node{
+			min: minVal,
+			max: minVal + gap,
+		}
+		table = append(table, val)
+	}
+	// 15 random pairs of ints with ||invalid range||
+	for i := 0; i < 15; i++ {
+		minVal := z01.RandIntBetween(-10000000, 1000000)
+		gap := z01.RandIntBetween(1, 20)
+		val := node{
+			min: minVal,
+			max: minVal - gap,
+		}
+		table = append(table, val)
+	}
+
+	table = append(table,
+		node{min: 0, max: 1},
+		node{min: 0, max: 0},
+		node{min: 5, max: 10},
+		node{min: 10, max: 5},
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.MakeRange, solutions.MakeRange, arg.min, arg.max)
+	}
+}

tests/go/map_test.go

@@ -0,0 +1,41 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestMap(t *testing.T) {
+	functionsArray := []func(int) bool{solutions.IsPositive, solutions.IsNegative0, solutions.IsPrime}
+
+	type node struct {
+		f   func(int) bool
+		arr []int
+	}
+
+	table := []node{}
+
+	for i := 0; i < 15; i++ {
+
+		functionSelected := functionsArray[z01.RandIntBetween(0, len(functionsArray)-1)]
+		val := node{
+			f:   functionSelected,
+			arr: z01.MultRandIntBetween(-1000000, 1000000),
+		}
+		table = append(table, val)
+
+	}
+
+	table = append(table, node{
+		f:   solutions.IsPrime,
+		arr: []int{1, 2, 3, 4, 5, 6},
+	})
+
+	for _, arg := range table {
+		z01.Challenge(t, student.Map, solutions.Map, arg.f, arg.arr)
+	}
+}

tests/go/max_test.go

@@ -0,0 +1,18 @@
+package student_test
+
+import (
+	solutions "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+	"testing"
+)
+
+func TestMax(t *testing.T) {
+	args := []int{z01.RandInt()}
+	limit := z01.RandIntBetween(20, 50)
+	for i := 0; i < limit; i++ {
+		args = append(args, z01.RandInt())
+	}
+
+	z01.Challenge(t, student.Max, solutions.Max, args)
+}

tests/go/nbrconvertalpha_test.go

@@ -0,0 +1,47 @@
+package student_test
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/01-edu/z01"
+)
+
+func TestNbrConvertAlpha(t *testing.T) {
+
+	type node struct {
+		array []string
+	}
+
+	table := []node{}
+	for i := 0; i < 5; i++ {
+		m := z01.MultRandIntBetween(1, 46)
+		s := ""
+		str := []string{}
+		for _, j := range m {
+			s += strconv.Itoa(j) + " "
+		}
+		str = append(str, s)
+		v := node{
+			array: str,
+		}
+		table = append(table, v)
+	}
+
+	table = append(table, node{
+		array: []string{
+			"--upper 8 5 25",
+			"8 5 12 12 15",
+			"12 5 7 5 14 56 4 1 18 25",
+			"12 5 7 5 14 56 4 1 18 25 32 86 h",
+			"32 86 h",
+			""},
+	})
+
+	for _, i := range table {
+		for _, a := range i.array {
+			z01.ChallengeMain(t, strings.Fields((a))...)
+		}
+	}
+}

tests/go/nrune_test.go

@@ -0,0 +1,45 @@
+package student_test
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestNRune(t *testing.T) {
+	type node struct {
+		word string
+		n    int
+	}
+
+	table := []node{}
+
+	for i := 0; i < 30; i++ {
+		wordToInput := z01.RandASCII()
+		val := node{
+			word: wordToInput,
+			n:    rand.Intn(len(wordToInput)) + 1,
+		}
+		table = append(table, val)
+	}
+
+	table = append(table,
+		node{word: "Hello!", n: 3},
+		node{word: "Salut!", n: 2},
+		node{word: "Ola!", n: 4},
+		node{word: "♥01!", n: 1},
+		node{word: "Not", n: 6},
+		node{word: "Also not", n: 9},
+		node{word: "Tree house", n: 5},
+		node{word: "Whatever", n: 0},
+		node{word: "Whatshisname", n: -2},
+	)
+
+	for _, arg := range table {
+		z01.Challenge(t, student.NRune, solutions.NRune, arg.word, arg.n)
+	}
+}

tests/go/paramcount_test.go

@@ -0,0 +1,36 @@
+package student_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/01-edu/z01"
+)
+
+func TestParamCount(t *testing.T) {
+	arg1 := []string{"2", "5", "u", "19"}
+	arg2 := []string{"2"}
+	arg3 := []string{"1", "2", "3", "5", "7", "24"}
+	arg4 := []string{"6", "12", "24"}
+
+	args := [][]string{arg1, arg2, arg3, arg4}
+
+	for i := 0; i < 10; i++ {
+		var arg []string
+		init := z01.RandIntBetween(0, 10)
+		for i := init; i < init+z01.RandIntBetween(5, 10); i++ {
+			arg = append(arg, strconv.Itoa(i))
+		}
+		args = append(args, arg)
+	}
+
+	for i := 0; i < 1; i++ {
+		args = append(args, z01.MultRandWords())
+	}
+
+	for _, v := range args {
+		z01.ChallengeMain(t, v...)
+	}
+
+	z01.ChallengeMain(t)
+}

tests/go/pilot_test.go

@@ -0,0 +1,10 @@
+package student_test
+
+import (
+	"github.com/01-edu/z01"
+	"testing"
+)
+
+func TestPilot(t *testing.T) {
+	z01.ChallengeMain(t)
+}

tests/go/point_test.go

@@ -0,0 +1,11 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+)
+
+func TestPoint(t *testing.T) {
+	z01.ChallengeMain(t, "")
+}

tests/go/pointone_test.go

@@ -0,0 +1,15 @@
+package student_test
+
+import (
+	"testing"
+
+	student "./student"
+)
+
+func TestPointOne(t *testing.T) {
+	n := 0
+	student.PointOne(&n)
+	if n != 1 {
+		t.Errorf("PointOne(&n), n == %d instead of 1", n)
+	}
+}

tests/go/printalphabet_test.go

@@ -0,0 +1,10 @@
+package student_test
+
+import (
+	"github.com/01-edu/z01"
+	"testing"
+)
+
+func TestPrintAlphabet(t *testing.T) {
+	z01.ChallengeMain(t)
+}

tests/go/printcomb2_test.go

@@ -0,0 +1,14 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestPrintComb2(t *testing.T) {
+	z01.Challenge(t, student.PrintComb2, solutions.PrintComb2)
+}

tests/go/printcomb_test.go

@@ -0,0 +1,14 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestPrintComb(t *testing.T) {
+	z01.Challenge(t, student.PrintComb, solutions.PrintComb)
+}

tests/go/printcombn_test.go

@@ -0,0 +1,17 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestPrintCombN(t *testing.T) {
+	table := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
+	for _, arg := range table {
+		z01.Challenge(t, student.PrintCombN, solutions.PrintCombN, arg)
+	}
+}

tests/go/printdigits_test.go

@@ -0,0 +1,10 @@
+package student_test
+
+import (
+	"github.com/01-edu/z01"
+	"testing"
+)
+
+func TestPrintDigits(t *testing.T) {
+	z01.ChallengeMain(t)
+}

tests/go/printnbr_test.go

@@ -0,0 +1,22 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestPrintNbr(t *testing.T) {
+	table := append(
+		z01.MultRandInt(),
+		z01.MinInt,
+		z01.MaxInt,
+		0,
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.PrintNbr, solutions.PrintNbr, arg)
+	}
+}

tests/go/printnbrbase_test.go

@@ -0,0 +1,51 @@
+package student_test
+
+import (
+	"testing"
+
+	"github.com/01-edu/z01"
+
+	solutions "./solutions"
+	student "./student"
+)
+
+func TestPrintNbrBase(t *testing.T) {
+	type node struct {
+		n    int
+		base string
+	}
+
+	table := []node{}
+
+	// 15 random pairs of ints with valid bases
+	for i := 0; i < 15; i++ {
+		validBaseToInput := solutions.RandomValidBase()
+		val := node{
+			n:    z01.RandIntBetween(-1000000, 1000000),
+			base: validBaseToInput,
+		}
+		table = append(table, val)
+	}
+
+	// 15 random pairs of ints with invalid bases
+	for i := 0; i < 15; i++ {
+		invalidBaseToInput := solutions.RandomInvalidBase()
+		val := node{
+			n:    z01.RandIntBetween(-1000000, 1000000),
+			base: invalidBaseToInput,
+		}
+		table = append(table, val)
+	}
+
+	table = append(table,
+		node{n: 125, base: "0123456789"},
+		node{n: -125, base: "01"},
+		node{n: 125, base: "0123456789ABCDEF"},
+		node{n: -125, base: "choumi"},
+		node{n: 125, base: "-ab"},
+		node{n: z01.MinInt, base: "0123456789"},
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.PrintNbrBase, solutions.PrintNbrBase, arg.n, arg.base)
+	}
+}

tests/go/printnbrinorder_test.go

@@ -0,0 +1,23 @@
+package student_test
+
+import (
+	"testing"
+
+	solutions "./solutions"
+	student "./student"
+	"github.com/01-edu/z01"
+)
+
+func TestPrintNbrInOrder(t *testing.T) {
+	table := append(
+		z01.MultRandIntBetween(0, z01.MaxInt),
+		z01.MaxInt,
+		321,
+		321321,
+		0,
+	)
+	for _, arg := range table {
+		z01.Challenge(t, student.PrintNbrInOrder, solutions.PrintNbrInOrder, arg)
+	}
+
+}

tests/go/printparams_test.go

@@ -0,0 +1,15 @@
+package student_test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/01-edu/z01"
+)
+
+func TestPrintParams(t *testing.T) {
+	table := append(z01.MultRandWords(), "choumi is the best cat")
+	for _, s := range table {
+		z01.ChallengeMain(t, strings.Fields(s)...)
+	}
+}

tests/go/printprogramname_test.go

@@ -0,0 +1,29 @@
+package student_test
+
+import (
+	"github.com/01-edu/z01"
+	"strings"
+	"testing"
+)
+
+func TestPrintProgramName(t *testing.T) {
+	exercise := strings.ToLower(
+		strings.TrimPrefix(t.Name(), "Test"))
+	out, err1 := z01.MainOut("./student/printprogramname")
+	if err1 != nil {
+		t.Errorf(err1.Error())
+	}
+
+	correct, err2 := z01.MainOut("./solutions/printprogramname")
+
+	if err2 != nil {
+		t.Errorf(err2.Error())
+	}
+
+	arrOut := strings.Split(out, "/")
+	ArrCor := strings.Split(correct, "/")
+	if ArrCor[len(ArrCor)-1] != arrOut[len(arrOut)-1] {
+		t.Errorf("./%s prints %q instead of %q\n",
+			exercise, arrOut[len(arrOut)-1], ArrCor[len(ArrCor)-1])
+	}
+}