Testing and profiling golang program

package main

import (
	"bytes"
	"fmt"
	"strings"
	"sync"
)

func main() {
	sentence := "The quick brown fox jumps over the lazy dog"
	words := Map(sentence)
	rwords := process(words)
	fmt.Println(reduce(rwords))
}

func process(words []string) []string {
	nosOfWords := len(words)
	buffChannel := make(chan string, nosOfWords)
	task := new(sync.WaitGroup)
	task.Add(nosOfWords)

	for _, word := range words {
		go func(word string) {
			defer task.Done()
			buffChannel <- reverse(word)
		}(word)
	}
	task.Wait()
	close(buffChannel)

	rwords := make([]string, 0)
	for rword := range buffChannel {
		rwords = append(rwords, rword)
	}
	return rwords
}

func Map(sentence string) []string {
	return strings.Split(sentence, " ")
}

func reduce(reverseWords []string) string {
	return strings.Join(reverseWords, " ")
}

func reverse(word string) string {
	var buff bytes.Buffer
	for index := len(word) - 1; index >= 0; index-- {
		buff.WriteString(string(word[index]))
	}
	return buff.String()
}

func TestMap(t *testing.T) {
	
	//Arrange
	phrase := "The quick brown fox jumps over the lazy dog"
	
	//Act
	slicedWord := Map(phrase)
	
	//Assert
	if len(slicedWord) != 9 {
		t.Log("Test failed, nos of words returned are incorrect")
		t.Fail()
	}
}

func TestMapForBlankSentence(t *testing.T) {
	words := Map("")
	if len(words) != 0 {
		t.Error("TestMapForBlankSentence failed")
	}
}

func TestReverse(t *testing.T) {
	if reverse("Hello") != "olleH" {
		t.Fatal("Reverse is incorrect")
	}
}

func TestReverse(t *testing.T) {
	if testing.short(){
		t.Skip()
	}
	if reverse("Hello") != "olleH" {
		t.Fatal("Reverse is incorrect")
	}
}

func TestReverse(t *testing.T) {
	if testing.Verbose(){
		b.Skip("Reverse skipped")
	}
	if reverse("Hello") != "olleH" {
		t.Fatal("Reverse is incorrect")
	}
}

func TestReverse(t *testing.T) {
	t.Parallel()
	if reverse("Hello") != "olleH" {
		t.Fatal("Reverse is incorrect")
	}
}

func TestReverseForMultipleInput(t *testing.T){
	if testing.Short() {
		t.Skip("TestReverseForMultipleInput skipped")
	}
	 tests := []struct{
		input string
		output string
	}{
		{"Hello", "olleH"},
		{"benchmarks", "skramhcneb"},
		{"provide","edivorp"},
		{"flag","galf"},
	}
	for _,test := range tests {
		if reverse(test.input) != test.output {
			t.Fatal("TestReverseForMultipleInput failed")
		}
	}
}

br := testing.Benchmark(func( b *testing.B){
	/*
		is a stand alone function that runs independtly of test runner.
	*/
})
// here we can get the benchmark metrics

func BenchmarkMap(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		Map("There is no flag you can provide, that will run only benchmarks")
	}
}

func BenchmarkProcess(b *testing.B) {
	b.StopTimer()
	words := []string{"There", "is", "no", "flag", "you", "can", "provide", ",",
		"that", "will", "run", "only", "benchmarks"}
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		process(words)
	}
}

func BenchmarkReduce(b *testing.B){
	words := []string{"olleH", "skramhcneb" }
	b.SetParallelism(30)
	b.RunParallel(func (pb *testing.PB){
		for pb.Next(){
			reduce(words)
		}
	})
}