Merge pull request #66 from fabianoflorentino/development

Development to Main

Author: fabianoflorentino

internal/exercicios_ninja_nivel_3/resolution_exercises_test.go

@@ -90,16 +90,23 @@ func TestResolucaoExercicioNaPratica3(t *testing.T) {
 		if year == currentYear {
 			yearsCount += fmt.Sprintf("%d\n", year)
 		} else {
+			if year%11 == 0 {
+				yearsCount = strings.TrimSuffix(yearsCount, ", ") + ",\n"
+			}
 			yearsCount += fmt.Sprintf("%d, ", year)
 		}
 	}
 
 	age := fmt.Sprintf("%v\nSua idade: %v", yearsCount, currentYear-birthYear)
 
 	expect := `
-1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024
+1985, 1986, 1987, 1988, 1989, 1990,
+1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012,
+2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023,
+2024, 2025
 
-Sua idade: 39
+Sua idade: 40
 `
 
 	if strings.TrimSpace(age) != strings.TrimSpace(expect) {

internal/exercicios_ninja_nivel_4/resolution_exercises.go

@@ -140,7 +140,7 @@ func ResolucaoNaPraticaExercicio7() {
 	var resolucao string
 
 	pessoas := [][]string{
-		{"Fábio", "Florentino", "Programar"},
+		{"Fabiano", "Florentino", "Programar"},
 		{"Fulano", "de Tal", "Jogar bola"},
 		{"Ciclano", "da Silva", "Assistir filmes"},
 	}
@@ -161,9 +161,9 @@ func ResolucaoNaPraticaExercicio8() {
 	var resolucao string
 
 	pessoas := map[string][]string{
-		"florentino_fabio": {"Programar", "Jogar bola", "Assistir filmes"},
-		"de_tal_fulano":    {"Programar", "Jogar bola", "Assistir filmes"},
-		"da_silva_ciclano": {"Programar 2", "Jogar bola 2", "Assistir filmes 2"},
+		"florentino_fabiano": {"Programar", "Jogar bola", "Assistir filmes"},
+		"de_tal_fulano":      {"Programar", "Jogar bola", "Assistir filmes"},
+		"da_silva_ciclano":   {"Programar 2", "Jogar bola 2", "Assistir filmes 2"},
 	}
 
 	for sobrenome_nome, hobbies := range pessoas {
@@ -185,10 +185,10 @@ func ResolucaoNaPraticaExercicio9() {
 	var resolucao string
 
 	pessoas := map[string][]string{
-		"florentino_fabio": {"Programar", "Jogar bola", "Assistir filmes"},
-		"de_tal_fulano":    {"Programar", "Jogar bola", "Assistir filmes"},
-		"da_silva_ciclano": {"Programar 2", "Jogar bola 2", "Assistir filmes 2"},
-		"de_tal_ciclano":   {"Programar 3", "Jogar bola 3", "Assistir filmes 3"},
+		"florentino_fabiano": {"Programar", "Jogar bola", "Assistir filmes"},
+		"de_tal_fulano":      {"Programar", "Jogar bola", "Assistir filmes"},
+		"da_silva_ciclano":   {"Programar 2", "Jogar bola 2", "Assistir filmes 2"},
+		"de_tal_ciclano":     {"Programar 3", "Jogar bola 3", "Assistir filmes 3"},
 	}
 
 	for sobrenome_nome, hobbies := range pessoas {

internal/exercicios_ninja_nivel_4/resolution_exercises_test.go

@@ -0,0 +1,268 @@
+// Package exercicios_ninja_nivel_4 contains solutions and tests for exercises
+// aimed at practicing and improving Go programming skills. The exercises cover
+// various topics and concepts, providing hands-on experience and reinforcing
+// understanding of the language.
+package exercicios_ninja_nivel_4
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/fabianoflorentino/aprendago/pkg/output"
+	"github.com/fabianoflorentino/aprendago/pkg/trim"
+)
+
+// testTemplate is a constant string used for formatting test output.
+// It provides a template for displaying the expected and actual values
+// in test results, making it easier to compare them.
+const (
+	expectTemplate = "\nwant:\n%s\n, \ngot:\n%s\n"
+)
+
+// TestResolucaoNaPraticaExercicio1 tests the functionality of iterating over an array of integers,
+// concatenating each integer to a string with a comma and space separator, and comparing the result
+// to an expected string. If the resulting string does not match the expected string, the test fails.
+func TestResolucaoNaPraticaExercicio1(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio1)
+
+	expect := `
+Resolução:
+1, 2, 3, 4, 5
+`
+
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}
+
+// TestResolucaoNaPraticaExercicio2 tests the function ResolucaoNaPraticaExercicio2
+// by capturing its output and comparing it to the expected output. It uses a
+// deferred function to recover from any panic that might occur during the execution
+// of ResolucaoNaPraticaExercicio2 and captures the panic message if it happens.
+// The test checks if the captured output contains the expected string, ignoring
+// leading and trailing whitespace, and reports an error if it does not match.
+func TestResolucaoNaPraticaExercicio2(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio2)
+
+	expect := `
+Resolução:
+
+Slice: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+Tipo: []string
+`
+
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}
+
+// TestResolucaoNaPraticaExercicio3 tests the function ResolucaoNaPraticaExercicio3
+// by capturing its output and comparing it to the expected result. It uses the
+// output.Capture utility to capture the function's output and the trim.New utility
+// to normalize the strings before comparison. If the captured output does not
+// contain the expected result, the test fails with an error message.
+func TestResolucaoNaPraticaExercicio3(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio3)
+
+	expect := `
+Resolução:
+
+Slice: 1, 2, 3, 4
+Tipo: []string
+`
+
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}
+
+// TestResolucaoNaPraticaExercicio4 tests the function ResolucaoNaPraticaExercicio4
+// by capturing its output and comparing it to the expected result. The test
+// verifies that the function correctly appends elements to slices and produces
+// the expected output. If the actual output does not match the expected output,
+// the test will fail and report the discrepancy.
+func TestResolucaoNaPraticaExercicio4(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio4)
+
+	expect := `
+Resolução:
+append52: [42 43 44 45 46 47 48 49 50 51 52]
+append53to55: [42 43 44 45 46 47 48 49 50 51 52 53 54 55]
+appendSliceY: [42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60]
+`
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}
+
+// TestResolucaoNaPraticaExercicio5 tests the function ResolucaoNaPraticaExercicio5
+// by capturing its output and comparing it to the expected result.
+// It uses the output.Capture utility to capture the function's output
+// and the trim.New utility to normalize the strings before comparison.
+// If the captured output does not contain the expected result, the test fails
+// and an error message is displayed.
+func TestResolucaoNaPraticaExercicio5(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio5)
+
+	expect := `
+Resolução:
+[42 43 44 48 49 50 51]
+`
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}
+
+// TestResolucaoNaPraticaExercicio6 tests the function ResolucaoNaPraticaExercicio6.
+// It captures the output of the function and compares it with the expected result.
+// If the captured output does not match the expected result, the test fails with an error message.
+func TestResolucaoNaPraticaExercicio6(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio6)
+
+	expect := `
+Resolução:
+len: 26 cap: 26
+Estados: Acre, Alagoas, Amapá, Amazonas, Bahia, Ceará, Espírito Santo, Goiás, Maranhão, Mato Grosso, Mato Grosso do Sul, Minas Gerais, Pará, Paraíba, Paraná, Pernambuco, Piauí, Rio de Janeiro, Rio Grande do Norte, Rio Grande do Sul, Rondônia, Roraima, Santa Catarina, São Paulo, Sergipe, Tocantins
+`
+
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}
+
+// TestResolucaoNaPraticaExercicio7 tests the function ResolucaoNaPraticaExercicio7
+// by capturing its output and comparing it to the expected result. The test
+// verifies that the output contains the expected formatted strings for names,
+// surnames, and favorite hobbies.
+func TestResolucaoNaPraticaExercicio7(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio7)
+
+	expect := `
+Resolução:
+Nome: Fabiano, Sobrenome: Florentino, Hobby favorito: Programar
+Nome: Fulano, Sobrenome: de Tal, Hobby favorito: Jogar bola
+Nome: Ciclano, Sobrenome: da Silva, Hobby favorito: Assistir filmes
+`
+
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}
+
+// TestResolucaoNaPraticaExercicio8 tests the function ResolucaoNaPraticaExercicio8
+// by capturing its output and comparing it with the expected result. The test
+// checks if the output contains the expected formatted string with names and hobbies.
+// If the output does not match the expected result, the test will fail and report an error.
+func TestResolucaoNaPraticaExercicio8(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio8)
+
+	expect := `
+Resolução:
+Sobrenome_Nome: florentino_fabiano
+  Hobby 1: Programar
+  Hobby 2: Jogar bola
+  Hobby 3: Assistir filmes
+Sobrenome_Nome: de_tal_fulano
+  Hobby 1: Programar
+  Hobby 2: Jogar bola
+  Hobby 3: Assistir filmes
+Sobrenome_Nome: da_silva_ciclano
+  Hobby 1: Programar 2
+  Hobby 2: Jogar bola 2
+  Hobby 3: Assistir filmes 2
+`
+
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}
+
+// TestResolucaoNaPraticaExercicio9 tests the function ResolucaoNaPraticaExercicio9
+// by capturing its output and comparing it to the expected result. The test
+// verifies that the output contains the expected formatted strings for different
+// individuals and their hobbies. If the output does not match the expected result,
+// the test will fail and report the discrepancy.
+func TestResolucaoNaPraticaExercicio9(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio9)
+
+	expect := `
+Resolução:
+Sobrenome_Nome: florentino_fabiano
+  Hobby 1: Programar
+  Hobby 2: Jogar bola
+  Hobby 3: Assistir filmes
+Sobrenome_Nome: de_tal_fulano
+  Hobby 1: Programar
+  Hobby 2: Jogar bola
+  Hobby 3: Assistir filmes
+Sobrenome_Nome: da_silva_ciclano
+  Hobby 1: Programar 2
+  Hobby 2: Jogar bola 2
+  Hobby 3: Assistir filmes 2
+Sobrenome_Nome: de_tal_ciclano
+  Hobby 1: Programar 3
+  Hobby 2: Jogar bola 3
+  Hobby 3: Assistir filmes 3
+`
+
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}
+
+// TestResolucaoNaPraticaExercicio10 tests the function ResolucaoNaPraticaExercicio10.
+// It captures the output of the function and compares it with the expected output.
+// If the captured output does not match the expected output, the test fails and an error is reported.
+func TestResolucaoNaPraticaExercicio10(t *testing.T) {
+	output := output.New()
+	result := output.Capture(ResolucaoNaPraticaExercicio10)
+
+	expect := `
+Resolução:
+Sobrenome_Nome: florentino_fabio
+  Hobby 1: Programar
+  Hobby 2: Jogar bola
+  Hobby 3: Assistir filmes
+Sobrenome_Nome: de_tal_fulano
+  Hobby 1: Programar
+  Hobby 2: Jogar bola
+  Hobby 3: Assistir filmes
+Sobrenome_Nome: de_tal_ciclano
+  Hobby 1: Programar 3
+  Hobby 2: Jogar bola 3
+  Hobby 3: Assistir filmes 3
+`
+
+	trim := trim.New()
+
+	if !strings.Contains(trim.String(result), trim.String(expect)) {
+		t.Errorf(expectTemplate, expect, result)
+	}
+}

pkg/output/output.go

@@ -0,0 +1,53 @@
+// Package output provides utilities for capturing and redirecting standard output.
+// It allows capturing the output of functions that write to os.Stdout and returning
+// the captured output as a string. This can be useful for testing and logging purposes.
+package output
+
+import (
+	"bytes"
+	"io"
+	"os"
+)
+
+// Output represents a structure that holds file descriptors for standard output,
+// and read/write operations. It contains the following fields:
+// - stdout: a file descriptor for standard output.
+// - read: a file descriptor for reading operations.
+// - write: a file descriptor for writing operations.
+type Output struct {
+	stdout *os.File
+	read   *os.File
+	write  *os.File
+}
+
+// New creates a new Output instance with a pipe for reading and writing.
+// It returns a pointer to the Output struct with stdout set to the standard output,
+// and read and write set to the ends of the pipe.
+func New() *Output {
+	read, write, _ := os.Pipe()
+
+	return &Output{
+		stdout: os.Stdout,
+		read:   read,
+		write:  write,
+	}
+}
+
+// Capture redirects the standard output to a buffer, executes the provided
+// captureOutput function, and then restores the standard output. It returns
+// the captured output as a string. This is useful for capturing and testing
+// output generated by functions that write to standard output.
+func (o *Output) Capture(captureOutput func()) string {
+	var buf bytes.Buffer
+
+	os.Stdout = o.write
+
+	captureOutput()
+
+	o.write.Close()
+
+	os.Stdout = o.stdout
+	io.Copy(&buf, o.read)
+
+	return buf.String()
+}