Add structs package

arrays/sum.go

@@ -0,0 +1,23 @@
+package main
+
+func Sum(numbers []int) int {
+	sum := 0
+	for _, n := range numbers {
+		sum += n
+	}
+	return sum
+}
+
+func SumAllTails(numbersToSum ...[]int) []int {
+	sums := make([]int, 0, len(numbersToSum))
+
+	for _, numbers := range numbersToSum {
+		if len(numbers) == 0 {
+			sums = append(sums, 0)
+		} else {
+			tail := numbers[1:]
+			sums = append(sums, Sum(tail))
+		}
+	}
+	return sums
+}

arrays/sum_test.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSum(t *testing.T) {
+
+	t.Run("collection of 5 numbers", func(t *testing.T) {
+		numbers := []int{1, 2, 3, 4, 5}
+
+		got := Sum(numbers)
+		want := 15
+
+		if got != want {
+			t.Errorf("got %d want %d given, %v", got, want, numbers)
+		}
+	})
+
+	t.Run("collection of any size", func(t *testing.T) {
+		numbers := []int{1, 2, 3}
+
+		got := Sum(numbers)
+		want := 6
+
+		if got != want {
+			t.Errorf("got %d want %d given, %v", got, want, numbers)
+		}
+	})
+
+}
+
+//func TestSumAll(t *testing.T) {
+//got := SumAll([]int{1, 2}, []int{0, 9})
+//want := []int{3, 9}
+
+//if !reflect.DeepEqual(got, want) {
+//t.Errorf("got %v want %v", got, want)
+//}
+//}
+
+func TestSumAllTails(t *testing.T) {
+	checkSums := func(t testing.TB, got, want []int) {
+		t.Helper()
+		if !reflect.DeepEqual(got, want) {
+			t.Errorf("got %v want %v", got, want)
+		}
+	}
+
+	t.Run("make the sums of tails of", func(t *testing.T) {
+		got := SumAllTails([]int{1, 2}, []int{0, 9})
+		want := []int{2, 9}
+		checkSums(t, got, want)
+	})
+
+	t.Run("safely sum empty slices", func(t *testing.T) {
+		got := SumAllTails([]int{}, []int{3, 4, 5})
+		want := []int{0, 9}
+		checkSums(t, got, want)
+	})
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/halfdan/learn-go-with-tests
+
+go 1.17

hello/hello.go

@@ -0,0 +1,33 @@
+package main
+
+import "fmt"
+
+const spanish = "Spanish"
+const french = "French"
+
+const englishHelloPrefix = "Hello, "
+const spanishHelloPrefix = "Hola, "
+const frenchHelloPrefix = "Bonjour, "
+
+func Hello(name string, language string) string {
+	if name == "" {
+		name = "World"
+	}
+
+	return greetingPrefix(language) + name
+}
+
+func greetingPrefix(language string) (prefix string) {
+	switch language {
+	case french:
+		prefix = frenchHelloPrefix
+	case spanish:
+		prefix = spanishHelloPrefix
+	default:
+		prefix = englishHelloPrefix
+	}
+	return
+}
+func main() {
+	fmt.Println(Hello("world", ""))
+}

hello/hello_test.go

@@ -0,0 +1,28 @@
+package main
+
+import "testing"
+
+func TestHello(t *testing.T) {
+	assertCorrectMessage := func(t testing.TB, got, want string) {
+		t.Helper()
+		if got != want {
+			t.Errorf("got %q want %q", got, want)
+		}
+	}
+
+	t.Run("saying hello to people", func(t *testing.T) {
+		got := Hello("Chris", "")
+		want := "Hello, Chris"
+		assertCorrectMessage(t, got, want)
+	})
+	t.Run("empty string defaults to 'World'", func(t *testing.T) {
+		got := Hello("", "")
+		want := "Hello, World"
+		assertCorrectMessage(t, got, want)
+	})
+	t.Run("in Spanish", func(t *testing.T) {
+		got := Hello("Elodie", "Spanish")
+		want := "Hola, Elodie"
+		assertCorrectMessage(t, got, want)
+	})
+}

integers/adder.go

@@ -0,0 +1,6 @@
+package integers
+
+// Add takes two integers and return the sum of them.
+func Add(a, b int) int {
+	return a + b
+}

integers/adder_test.go

@@ -0,0 +1,21 @@
+package integers
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestAdder(t *testing.T) {
+	sum := Add(2, 2)
+	expected := 4
+
+	if sum != expected {
+		t.Errorf("expected %v, got %v", expected, sum)
+	}
+}
+
+func ExampleAdd() {
+	sum := Add(1, 5)
+	fmt.Println(sum)
+	// Output: 6
+}

iteration/repeat.go

@@ -0,0 +1,16 @@
+package iteration
+
+import "strings"
+
+func Repeat(character string, count int) string {
+	var repeated string
+
+	for i := 0; i < count; i++ {
+		repeated += character
+	}
+	return repeated
+}
+
+func StringsRepeat(s string, count int) string {
+	return strings.Repeat(s, count)
+}

iteration/repeat_test.go

@@ -0,0 +1,32 @@
+package iteration
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestRepeat(t *testing.T) {
+	repeated := Repeat("a", 5)
+	expected := "aaaaa"
+
+	if repeated != expected {
+		t.Errorf("expected %v, got %v", expected, repeated)
+	}
+}
+
+func BenchmarkRepeat(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Repeat("a", 5)
+	}
+}
+func BenchmarkStringsRepeat(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		StringsRepeat("a", 5)
+	}
+}
+
+func ExampleRepeat() {
+	data := Repeat("a", 5)
+	fmt.Println(data)
+	// Outputs: aaaaa
+}

pointers/wallet.go

@@ -0,0 +1,35 @@
+package pointers
+
+import (
+	"errors"
+	"fmt"
+)
+
+type Bitcoin int
+
+type Wallet struct {
+	balance Bitcoin
+}
+
+func (w *Wallet) Deposit(a Bitcoin) {
+	w.balance += a
+}
+
+var ErrInsufficientFunds = errors.New("cannot withdraw, insufficient funds")
+
+func (w *Wallet) Withdraw(a Bitcoin) error {
+	if a > w.balance {
+		return ErrInsufficientFunds
+	}
+
+	w.balance -= a
+	return nil
+}
+
+func (w Wallet) Balance() Bitcoin {
+	return w.balance
+}
+
+func (b Bitcoin) String() string {
+	return fmt.Sprintf("%d BTC", b)
+}

pointers/wallet_test.go

@@ -0,0 +1,52 @@
+package pointers
+
+import (
+	"testing"
+)
+
+func TestWallet(t *testing.T) {
+	assertBalance := func(t testing.TB, w Wallet, want Bitcoin) {
+		t.Helper()
+		balance := w.Balance()
+
+		if balance != want {
+			t.Errorf("got %s want %s", balance, want)
+		}
+	}
+
+	t.Run("Deposit", func(t *testing.T) {
+		wallet := Wallet{}
+		wallet.Deposit(Bitcoin(10))
+		want := Bitcoin(10)
+
+		assertBalance(t, wallet, want)
+	})
+
+	t.Run("Withdraw", func(t *testing.T) {
+		wallet := Wallet{balance: Bitcoin(20)}
+		wallet.Withdraw(Bitcoin(10))
+
+		want := Bitcoin(10)
+		assertBalance(t, wallet, want)
+	})
+
+	assertError := func(t testing.TB, got, want error) {
+		t.Helper()
+
+		if got == nil {
+			t.Fatal("wanted an error but didn't get one")
+		}
+
+		if got != want {
+			t.Errorf("got %q, want %q", got, want)
+		}
+	}
+
+	t.Run("Withdraw insufficient funds", func(t *testing.T) {
+		startingBalance := Bitcoin(20)
+		wallet := Wallet{startingBalance}
+		err := wallet.Withdraw(Bitcoin(100))
+		assertError(t, err, ErrInsufficientFunds)
+		assertBalance(t, wallet, startingBalance)
+	})
+}

structs/shapes.go

@@ -0,0 +1,37 @@
+package structs
+
+import "math"
+
+type Shape interface {
+	Area() float64
+}
+
+type Rectangle struct {
+	Width  float64
+	Height float64
+}
+
+type Circle struct {
+	Radius float64
+}
+
+type Triangle struct {
+	Base   float64
+	Height float64
+}
+
+func Perimiter(r Rectangle) float64 {
+	return 2 * (r.Width + r.Height)
+}
+
+func (c Circle) Area() float64 {
+	return math.Pi * c.Radius * c.Radius
+}
+
+func (r Rectangle) Area() float64 {
+	return r.Width * r.Height
+}
+
+func (t Triangle) Area() float64 {
+	return t.Base * t.Height / 2
+}

structs/shapes_test.go

@@ -0,0 +1,38 @@
+package structs
+
+import "testing"
+
+func TestPerimiter(t *testing.T) {
+	rectangle := Rectangle{10.0, 10.0}
+	got := Perimiter(rectangle)
+	want := 40.0
+
+	if got != want {
+		t.Errorf("got %.2f want %.2f", got, want)
+	}
+}
+
+func TestArea(t *testing.T) {
+
+	areaTests := []struct {
+		name    string
+		shape   Shape
+		hasArea float64
+	}{
+		{name: "Rectangle", shape: Rectangle{Width: 12, Height: 6}, hasArea: 72.0},
+		{name: "Circle", shape: Circle{Radius: 10}, hasArea: 314.1592653589793},
+		{name: "Triangle", shape: Triangle{Base: 12, Height: 6}, hasArea: 36.0},
+	}
+
+	for _, tt := range areaTests {
+		// using tt.name from the case to use it as the `t.Run` test name
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.shape.Area()
+			if got != tt.hasArea {
+				t.Errorf("%#v got %g want %g", tt.shape, got, tt.hasArea)
+			}
+		})
+
+	}
+
+}