Merge branch 'master' of https://github.com/ardanlabs/gotraining

Author: ardan-bkennedy

README.md

@@ -187,6 +187,7 @@ July(10-12)         Chicago, IL           Enova               Corporate    Adv G
 July(24-26)         St. Louis, MO         Centene             Corporate    Go (3 day)
 September(11-13)    Santa Monica, CA      ZipRecruiter        Corporate    Go (3 day)
 October(09-11)      San Jose, CA          Oracle              Corporate    Adv Go (3 day)
+October(16-18)      Torrance, CA          Dollar Shave Club   Corporate    Go (3 day)
 October(23-25)      St. Louis, MO         Centene             Corporate    Go (3 day)
 November(07-09)     Portland, OR          New Relic           Corporate    Go (3 day)
 ```

topics/go/testing/strings/README.md

@@ -0,0 +1,21 @@
+## Strings Testing
+
+This package is an exercise intended to introduce the most commonly used testing and benchmarking tools.
+
+## Package Review
+
+[Basic Tests](example1/)  
+[Table Driven Tests](example2/)  
+[Subtests](example3/)  
+[Benchmarks](example4/)  
+
+_Look at the [benchmarks](../benchmarks/README.md) section to learn more about measuring performance._
+
+_Look at the profiling topic to learn more about using benchmarks to [profile](../../profiling/README.md) code._
+
+## Links
+
+[Table Driven Tests / Dave Cheney](https://dave.cheney.net/2013/06/09/writing-table-driven-tests-in-go).
+
+___
+All material is licensed under the [Apache License Version 2.0, January 2004](http://www.apache.org/licenses/LICENSE-2.0).

topics/go/testing/strings/example1/reverse.go

@@ -0,0 +1,13 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Package strings provides some useful string manipulation functions.
+package strings
+
+// Reverse gives the reversed form of s.
+//
+// This is the initial implementation.
+// It passes our test so it must be good! :)
+func Reverse(s string) string {
+	return "bocaj"
+}

topics/go/testing/strings/example1/reverse_test.go

@@ -0,0 +1,22 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Go + testing = ❤!
+//
+// This is our first iteration of the test. It only tests a single
+// input/output combination. Run this with:
+//
+// go test
+package strings
+
+import "testing"
+
+func TestReverse(t *testing.T) {
+	in := "jacob"
+	want := "bocaj"
+	got := Reverse(in)
+
+	if got != want {
+		t.Errorf("Reverse(%q) = %q, want %q", in, got, want)
+	}
+}

topics/go/testing/strings/example2/reverse.go

@@ -0,0 +1,19 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Package strings provides some useful string manipulation functions.
+package strings
+
+// Reverse gives the reversed form of s.
+//
+// This is the first real implementation.
+// It is not very efficient and it will fail on multibyte input.
+func Reverse(s string) string {
+	var r string
+
+	for i := len(s) - 1; i >= 0; i-- {
+		r = r + string(s[i])
+	}
+
+	return r
+}

topics/go/testing/strings/example2/reverse_test.go

@@ -0,0 +1,34 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Go + testing = ❤!
+//
+// This is our second test iteration. We define a type for a test scenario as
+// well as a "table" of test inputs. We loop over that and run each test. This
+// is commonly called a "Table Driven Test".
+package strings
+
+import "testing"
+
+// reverseTest defines a single scenario for testing the Reverse function.
+type reverseTest struct {
+	in   string
+	want string
+}
+
+func TestReverse(t *testing.T) {
+
+	// tests is a "table" of test scenarios.
+	tests := []reverseTest{
+		{"jacob", "bocaj"},
+		{"john", "nhoj"},
+	}
+
+	// loop through the table and run each test.
+	for _, test := range tests {
+		got := Reverse(test.in)
+		if got != test.want {
+			t.Errorf("Reverse(%q) = %q, want %q", test.in, got, test.want)
+		}
+	}
+}

topics/go/testing/strings/example3/reverse.go

@@ -0,0 +1,22 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Package strings provides some useful string manipulation functions.
+package strings
+
+// Reverse gives the reversed form of s.
+//
+// This is the first correct implementation. It may not behave how you want for
+// things like unicode combining characters. If you can break it let me know :)
+//
+// It is still not very efficient but maybe it's good enough?
+func Reverse(s string) string {
+	in := []rune(s)
+	var r string
+
+	for i := len(in) - 1; i >= 0; i-- {
+		r = r + string(in[i])
+	}
+
+	return r
+}

topics/go/testing/strings/example3/reverse_test.go

@@ -0,0 +1,49 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Go + testing = ❤!
+//
+// This is our third test iteration. We added more scenarios but one is
+// failing. We name each of our scenarios so we can identify the failing
+// scenario. We also launch them in subtests so we can run just the failing
+// scenario on demand. Run with -v to see each subtest in action. To limit
+// execution use -run:
+//
+// go test -v
+// go test -v -run TestReverse/multibyte
+package strings
+
+import "testing"
+
+// reverseTest defines a single scenario for testing the Reverse function.
+type reverseTest struct {
+	name string
+	in   string
+	want string
+}
+
+func TestReverse(t *testing.T) {
+
+	// tests is a "table" of test scenarios.
+	tests := []reverseTest{
+		{"odd", "jacob", "bocaj"},
+		{"even", "john", "nhoj"},
+		{"multibyte", "I ❤ NY", "YN ❤ I"},
+		{"empty", "", ""},
+	}
+
+	// loop through the table and run each test.
+	for _, test := range tests {
+
+		// Encapsulate the test behavior in a closure.
+		fn := func(t *testing.T) {
+			got := Reverse(test.in)
+			if got != test.want {
+				t.Errorf("Reverse(%q) = %q, want %q", test.in, got, test.want)
+			}
+		}
+
+		// Run the test closure as a subtest
+		t.Run(test.name, fn)
+	}
+}

topics/go/testing/strings/example4/reverse.go

@@ -0,0 +1,24 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Package strings provides some useful string manipulation functions.
+package strings
+
+// Reverse gives the reversed form of s.
+//
+// This implementation attempts to improve performance by removing unnecessary
+// string conversions. Further improvements could be made by:
+//
+// 1. Preallocating enough capacity in r.
+// 2. Remove r and sort the input in place.
+// 3. Something much more complicated.
+func Reverse(s string) string {
+	in := []rune(s)
+	var r []rune
+
+	for i := len(in) - 1; i >= 0; i-- {
+		r = append(r, in[i])
+	}
+
+	return string(r)
+}

topics/go/testing/strings/example4/reverse_test.go

@@ -0,0 +1,55 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Go + testing = ❤!
+//
+// In this iteration we haven't really changed the test but we have added a
+// benchmark. This is how we can measure the performance of our function. To
+// run benchmarks run these commands:
+//
+// go test -bench .
+// go test -bench . -benchmem
+// go test -bench . -benchmem -benchtime 5s
+package strings
+
+import "testing"
+
+// reverseTest defines a single scenario for testing the Reverse function.
+type reverseTest struct {
+	name string
+	in   string
+	want string
+}
+
+func TestReverse(t *testing.T) {
+
+	// tests is a "table" of test scenarios.
+	tests := []reverseTest{
+		{"odd", "jacob", "bocaj"},
+		{"even", "john", "nhoj"},
+		{"multibyte", "I ❤ NY", "YN ❤ I"},
+		{"empty", "", ""},
+		{"alphabet", "abcdefghijklmnopqrstuvwxyz", "zyxwvutsrqponmlkjihgfedcba"},
+	}
+
+	// loop through the table and run each test.
+	for _, test := range tests {
+
+		// Encapsulate the test behavior in a closure.
+		fn := func(t *testing.T) {
+			got := Reverse(test.in)
+			if got != test.want {
+				t.Errorf("Reverse(%q) = %q, want %q", test.in, got, test.want)
+			}
+		}
+
+		// Run the test closure as a subtest
+		t.Run(test.name, fn)
+	}
+}
+
+func BenchmarkReverse(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Reverse("abcdefghijklmnopqrstuvwxyz")
+	}
+}

topics/go/testing/strings/reverse.go

@@ -0,0 +1,10 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Package strings provides some useful string manipulation functions.
+package strings
+
+// Reverse gives the reversed form of s.
+func Reverse(s string) string {
+	return ""
+}

topics/go/testing/strings/reverse_test.go

@@ -0,0 +1,13 @@
+// All material is licensed under the Apache License Version 2.0, January 2004
+// http://www.apache.org/licenses/LICENSE-2.0
+
+// Go + testing = ❤!
+//
+// This is the basic structure for writing tests. Follow along with the
+// instructor or look ahead to "example1" to see the first iteration.
+package strings
+
+import "testing"
+
+func TestReverse(t *testing.T) {
+}