Go Coding One Pager

cd <project directory>
go mod init <repo url>/<teamname>/<project name> # i.e., the module

go mod init github.com/PentheusLennuye/go_cheatsheet

cp <path/to/go template> canasta
cd canasta
code .  # Starts MS Visual Studio Code

vscode@whatever/workspaces/canasta $ go mod init github.com/<path/to/>canasta

.DEFAULT_GOAL := build

.PHONY:fmt
fmt:
    go fmt ./...

.PHONY:build
build: fmt
    go build -o bin/ cmd/hello_word/hello_world.go

|- bin/ ①
|- cmd/ ②
|  |- hello_world/
|  |  |- hello_world.go
|  |- k8s_user_add/
|  |  |- k8s_user_add.go
|- internal/ ③
|  |  |- libA.go
|- pkg/
|  |- <package name A>/ ④
|  |  |- source_file_A.go
|  |  |- source_file_B.go
|  |- <package name B>/
|  |  |- source_file_C.go
|  |  |- source_file_D.go
|  |- internal/ ⑤
|  |  |- libB.go
...

package main

import "fmt"

func main() {
    fmt.Println("Hello world")
}

package main

import (
    crand "crypto/rand" // ❶
    "fmt"
    "math/rand"

    "github.com/PentheusLennuye/foo/pkg/directoryA" // ❷
    "github.com/PentheusLennuye/foo/pkg/directoryB"
)

... // code here

func main()
{
 ...   
}

func main() {
    ...
}

var m int
if m, ok = fooie("Looie"); ok {
    // "Looie" was accepted, deal with 'm'
} else {
    // "Looie" is a problem. Deal with the problem
}

func fooie (string argumentString) (int, bool) {
   ...
   return whatever, true
}

func myFunction() (int, error) {
    ...
    if <terrible thing a happens> {
        return 0, error.New("terrible thing a") // ❶
    }
    if <terrible thing b happens. {
        return 0, fmt.Errorf("terrible thing %s", b)
    }
    // A successful function returns nil instead of Error
    return myResult, nil
}
result, err := myFunction()
if err != nil {
    ... // process the error, including passing it up
}
... // continue on your merry way

func getFile(path string) (*os.File, func(), error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, nil, err
    }
    return file, func() { file.Close() }, nil
}

f, closer, err := getFile(os.Args[1])
if err != nil {
    log.Fatal(err)
}
defer closer() // ① 

f, closer, err := getFile(os.Args[1])
if err != nil {
    log.Fatal(err)
}
defer closer()
data := make([]byte, 256)  // 256-byte slice of 0's
for {
    count, err := file.Read(data)
    if err != nil {
        return err
    }
    if count == 0 {
        return nil
    }
    process(data[:count]) // if only 138 bytes were used, process those 138 only
}

// Package cards provides card decks and cards for games. ❶
//
// The cards package can be used to represent game states with
// ranks and suits, e.g. English card games.
package cards

// These are the card game types defined in this package.
const (
    STANDARD_DECK = iota // ❷ 
    EUCHRE_DECK
    BRIDGE_DECK
    CANASTA_DECK
    ...
)

// Card represents an English card, with rank and suit. Face
// cards are also ranked with an integer as they also have value
// (traditionally, jack = 11 and so on).
type Card struct {
    rank int
    suit int
}

// CardDeck is a slice of Cards.
// It must be initiated with "make(CardDeck, int)" to be useful
// and then be populated and optionally shuffled by its Factory.
type CardDeck []card

// Populate initializes its CardDeck with the appropriate number
// and values of cards according to deckType.
// Use the constants defined above as arguments to populate the
// deck according to Hoyle, e.g. cards.STANDARD_DECK,
// cards.EUCHRE_DECK, etc.
func (cd *CardDeck) Populate(deckType int) bool {
    cd[0] = Card{Joker, 0}
    // Jump-table here
    // ...
} 

// silly demonstrates comments on a variable.
func silly() int {

    // Gadzooks holds the number of gadzooks in a gadzookathon.
    var gadzooks int = 10

    return gadzooks
}

# Test the go files in all directories ...
go test ./... -cover -coverprofile=c.out
# ... passes!

SEMVER=<maj.min.patch-comment>
git add <whatever needs adding, or -u, or just plain .>
git commit -m "<Your team's chosen message format>"
git tag [-a|-s] v${SEMVER}
git push origin v${SEMVER}

func ScrewUpThisInt(x int) int {}
func ScrewUpThisUint(x uint) int {}

var (
    x int
    y = 20
    g = "George"
    s, w = 13, "William"
)

const x int64 = 10  // Note x is lowercase. Do not CAPITALIZE
const g = "George"  // outside package-level declarations.
const (
    westmount = iota  // Starts at 0
    ville_marie       // Automatically assigned 1 due to iota
    southeast         // Automatically 2
    ndg               // 3 etc...
    cdn
)

var x = 32
var pointerX *int  // a memory address to an integer, set to nil
pointerX = &x   // &x is, say, address 0xc00001c148 holding 32.

fmt.Println(x, &x, pointerX, *pointerX)
// 32 0xc00001c148 0xc0001c148 32
// * is the "dereference" operator that returns the value held
// at address pointerX

/* Rare */
var pointerY = new(int)  // Creates a 0 and assigns its address 
                         // to pointerY

var x [3]int    // Assigns [0, 0, 0] to x
var x [3][4]int // Assigns
                // [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
var x = [3]int{2, 4, 8}    // Assigns [2, 4, 8]
var x = [...]int{2, 4, 8}  // Also assigns [2, 4, 8] to x
var x = [6]int{1, 3:2} // Assigns [1, 0, 0, 2, 0, 0] to x.
// Remember: Arrays are 0-indexed!

a := 2
var x [3]int
var y [4]int
var z [3]float64
var b [a]int  // Bang! Error. ❶

if x == y {  // Bang! type [3]int != type [4]int
    // ...
}

c := int(z)  // Bang! Type conversion does not work on arrays.

var x []int  // x = nil
var x [][]int  // x = [nil]
var x = []int{} // x = non-nil zero-length. ❶
var x = []int{1, 2, 3, 5, 7, 11} // ❷
var x = []int{1, 3:2, 4} // Assigns [1, 0, 0, 2, 4] to x.

var x = []int{3, 5, 2}

fmt.Println(len(x))
y := append(x, 13)  // y has been assigned to [3, 5, 2, 13]
y = append(x, 13, 17, 19)  // y is now [3, 5, 2, 13, 17, 19]
b := y[3:5]  // Subslice [13, 17], i.e. [3] to just before [5]

x:= []int{1, 2, 3, 5, 7, 11}
fmt.Println("Length of x:", len(x))  // 6
fmt.Println("Capacity of x:", cap(x))  // 6
x = append(x, 13)
fmt.Println("Length of x:", len(x))  // 7
fmt.Println("Capacity of x:", cap(x))  // 12!

x := []int{1, 2, 3, 5, 7, 11}
y := x[2:5]  // i.e. {3, 5, 7}
y[0] = 13
fmt.Println(y)  // {13, 5, 7} OK
fmt.Println(x)  // {1, 2, 13, 5, 7, 11} Whut?
y = append(y, 17)
fmt.Println(y)  // {13, 5, 7, 17} OK
fmt.Println(x)  // {1, 2, 13, 5, 7, 17} NOK!
y = append(y, 19)
fmt.Println(y)  // {13, 5, 7, 17, 19} OK
fmt.Println(x)  // {1, 2, 13, 5, 7, 17} NOK: 19 never made it

x := []int{1, 2, 3, 5, 7, 11}
y := make([]int, 3)
copy(y, x[2:5])  // Copies [1, 2] into y and returns '2'.
y[0] = 13
fmt.Println(y)  // {13, 5, 7} OK
fmt.Println(x)  // {1, 2, 3, 5, 7, 11} OK

// doHorribleThings does nothing of the sort. The w_ prefix in
// this example means "working (local) copy"
func doHorribleThings(x []int) []int{
    w_x := make([]int, len(x))
    copy(w_x, x)
    // Do things to i_x
    return w_x
}

x := []int{1, 2, 3, 5, 7, 11}
y := doHorribleThings(x)

func main() {
    var x = []int{1, 2, 3}
    var y = []int{1, 2, 3}
    if x == y {  // Bang!
        // ...
    }
    if reflect.DeepEqual(x, y) {  // Much better
        // ...
    }
}

foo := map[string]string {
    "rank": "Detective",
    "sn": "Edwards",
    "firstname": "Jay"
}
foo["rank"] = "Agent"
foo["identity"] = 'J'
delete(foo, "sn")
delete(foo, "firstname")

bar := make(map[int][]string, 10) // One integer-keyed map of
                                  // ten string arrays

// Anything not true is false as false is the zero value
values := []int{2, 18, 52, 18}
mySet := make(map[int]bool)
for _, v := range values {
    mySet[v] = true
}
fmt.Println(mySet) // [2:true 18:true 52:true]

if mySet[5] {
    fmt.Println("This shouldn't happen.")
} else {
    fmt.Println("5 is not in the set.")
}
if mySet[2] {
    fmt.Println("2 is in the set.")
} else {
    fmt.Println("This shouldn't happen.")
}

// Package block

import (
    // file block
    "fmt"
    "time"
)

func myFunction() /* block */ { 
    // function block
}

x = 0
if x > 5 { // control block
    ...
} else if {  // control block

} else {  // control block

}

if x := myFunction(); x > 5 {
    ...
} else {

}
fmt.Println(x)  // Bang! Compile error

// Complete for
for i := 0; i < 10; i++ {

}

// Condition-only for
for i < 10 {
    ...
    i = i + 1
}

// Infinite for
for {
    if CONDITION_X {
        continue
    }
    ...
    if CONDITION_Y {
        break
    }
}

// For-range loop
values := []int{1, 2, 3, 5, 8, 13}
for i, v := range values {
    // You must actually *do* something with i (the index)
    // and v (the value at i) or get a compiler error
}
// Range works with maps as well, but idiomatically use k, v
// instead of i, v.
for _, v := range values {
    // Do something with v (the value at the index).
    // "_" does not need references
}

func labelDemo() {
    x := [][]int{{1, 3, 5, 7}, {2, 4, 6, 8}, {12, 14, 16, 18}}

outer:
    for _, v := range x { 
        fmt.Println(v)
    inner:
        for _, vv := range v {
            if vv == 5 {
                continue outer  // Goes to next v
            } else if vv == 4 {
                continue       // Goes to next vv
            }
        fmt.Println(vv)
    }
}

const animal_field = 1
line := []string{"20230831","robin","lake louise"}

switch animal = line[animal_field]; animal {
case "cow":
    mammals += 1
case "bluejay", "robin":
    birds += 1
case default:
    unknown += 1
}

switch {
case totalAmount <= 5000.0:
   ...  // theft under 5000
case totalAmount > 5.0 && totalAmount <= 100000.0:
   ...  // theft under 5000 but who cares?
default:
   ...  // Send the detective!
}

type agent struct {
    badge      string
    sn         string
    firstName  string
    precinct   precinct
}

// The developer *must* set *every* value when using :=
j := agent{"12J43", "Edwards", "James", westmount}

var k agent
k = agent{
    badge: "02K34",
    sn: "Brown",
    firstname: "Kevin"
    // here, precinct is set to the zero value
}

fmt.Println(j.badge)

// Pointers!
pz := &agent{"00Z24", "Scott", "Zachary", ville_marie}

// Notice there is no requirement for * here, but ...
fmt.Println("Zed", pz.badge)  

// .. if you really want to dereference, use parentheses
fmt.Println("Zed", (*pz).badge

type agent struct {
    badge      string
    sn         string
    firstName  string
    precinct   *string
}

func stringPtr(s string) *string {
    return &s
}

func main() {
    /* This will fail
    j := agent{"12J43", "Edwards", "James", "Westmount"}
    */
    j := agent{"12J43", "Edwards", "James", stringPtr("Westmount")}
    
}

computerLanguage := struct {
    name string
    inventors []string
}{
    name: "C",
    inventors: []string["Ritchie"]
}

func functionName() {
    ...
}

func functionWithIntegerReturnValue() int {
    ...
    return integerReturnValue
}

func functionWithParameter(argument int) int {
    ...
    return integerReturnValue
}

func functionWithMultipleParamsAndReturns(arg1 int, arg2 int) (int, bool) {
    // Multiple return values are automatically enclosed
    // in parentheses.
    // ...
    return returnValue, true
}

a, ok = functionWithMultipleParamsAndReturns(2, 4)  // OK
a = functionWithMultipleParamsAndReturns(2, 4)  // Bang!
_, ok = functionWithMultipleParamsAndReturns(2, 4)  // OK

func functionWithSimilarParameters(arg1, arg2 int) (int, error) {
    // Same as above, but using the error pattern.
    // error is always last in multiple return values.
    // ...
    return returnValue, nil
}

func namedReturns(arg1, arg2 int) (namedResult1 int, namedResult2 error) {

    return namedResult1, namedResult2
}

func blankReturns(arg1, arg2 int) (namedResult1 int, namedResult2 error) {
    // Blank returns work, but are considered an antipattern 
    namedResult = 5
    namedResult = nil

    // Do other stuff.
    return  // returns 5, nil
}

// anonymousFunction prints "Hello, Syd"
func anonymousFunction() {
    func(addressee string) {
        fmt.Println("Hello,", addressee)
    }("Syd")
}

// closure demonstrates that functions are first-class
// objects
func closure() (func(string), error) {
    /* A function inside a function using the outside
     * function's variables or arguments is called a
     * Closure.
     */
    greeting := "Hello,"
    sayHello := func (addressee string) {
        fmt.Println(greeting, addressee)
    }
    return sayHello, nil
}

func main() {
    myfunc, err := closure()
    if err != nil {
        return
    }
    myfunc("Anca")  // prints "Hello, Anca"
}

func variadicArguments(values ...string) {
    /* called with
     * variadicArguments(a...) or
     * variadicArguments("foo", "choo") or
     * variadicArguments([]string{"foo", "choo"}...).
     * Note the ... for literals AND variables.
     */
    fmt.Println(len(values))
    for _, v += range values {
        ...
    }
    ...
}

// Variadic parameters MUST be the _last_ or _only_ arguments.
func brokenVariadicArguments(values ...string, lastArgument string) {
    ...
}  // Bang!

// thisHasADeferBlock demonstrates the defer statement
func thisHasADeferBlock() namedError error {
    f, err := os.Open(os.Args[1])
    if err != nil {
        log.Fatal(err)
    }
    // Anonymous function to be executed on return
    defer func() {
        error = setUpAnError(5)
    }()  // Note the parenthesis!

    // No matter what happens, the file is closed.
    defer f.Close()

    // Defers are run in last-in,first-out order.
    defer fmt.Println("Me first")
    // ...
    return nil  // The defers are run _after_ return.
                // "nil" here will change because the
                // anonymous defer function changes the
                // namedError
}

/* Read the caveat about mutable data */
func mutableParameter(a *agent) {
    a.firstName = &localName
}
mutableParameter(&a)
fmt.Println(a.firstName)  // Prints Bob. If we weren't using pointers, the
                          // original name would remain since Go is value copy.

type person struct {name string}
func crush(victim person) error {return nil}
func stretch(candidate person) error {return nil}

func main() {
    jumpTable := map[string]func(person) error{
        "crush": crush,
        "stretch": stretch,
    }

    johnny := person{"Johnny"}
    fmt.Println(jumpTable["crush"](johnny))
}

type person struct {name string}
type tortureFunc func(person) error
func crush(victim person) error {return nil}
func stretch(candidate person) error {return nil}

func main() {
    jumpTable := map[string]tortureFunc{
        "crush": crush,
        "stretch": stretch,
    }

    johnny := person{"Johnny"}
    fmt.Println(jumpTable["crush"](johnny))
}

type card struct {
    rank int
    suit rune
}

/* I am aware of the unicode full deck of cards. No, I'm not using them.
 * Toy problem!
 */
func (c card) reveal() string {
    switch {
    case c.rank == 0:
        return fmt.Sprintf("JK")
    case c.rank == 1:
        return fmt.Sprintf("%cA", c.suit)
    case rank <= 10:
        return fmt.Sprintf("%c%d", c.suit, c.rank)
    }
    return fmt.Sprintf("%c%c", c.suit, faces[c.rank-11])
}

type superInt int

func (s *superInt) plusequal(addend int) {
    *s = *s + superInt(addend)
}

var myInteger superInt = 5
superInt.plusplus(6)
fmt.Println(superInt)

type Position struct {
    x int
    y int
    z int
}
type Fish struct {
    Position  // Embedded non-named struct
    tailPosition int
    oxygenLevel int
    tastiness int
}

tuna := Fish{
    Position: Position{23, -23, 5},  // note "Position: Position"
    tailPosition: 0,
    oxygenLevel: 23,
    tastiness: 100,
}
tuna.x++  // x is part of the tuna.

type LifeFunctioner interface {
    move(int, int, int)
    respire()
    eat(string)
    drink(string)
}

func (f *Fish) move(x, y, z int) {...}
func (f *Fish) respire() {...}
func (f *Fish) eat(food) {...}
func (f *Fish) drink(beverage) {...}

type FoodChainMember struct {
    eats    LifeFunctioner
    eatenBy LifeFunctioner
}

pescatarian := FoodChainMember{
    eats: Fish{...},
    eatenBy: nil,
}

func fileChecker(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return fmt.Errorf("in fileChecker: %w", err)
    }
}

func throwsAnError() (_ string, err error) {
    defer func() {
        if err != nil {
            err = fmt.Errorf("in throwsAnError: %w", err)
        }
    }()  // Remember the parenthesis for anonymous functions?
    val1, err = doSomething1()
    if err != nil {
        return "", err
    }
    val2, err = doSomething2()
    if err != nil {
        return "", err
    }
}

type ErrTooEvil struct {
    /* The struct can be anything you want. In fact, the type does not even
     * have to be a struct. */
    status  int
    message string
    moronWhoCausedThisMessage userID
}

/* The error{} interface has only one method: Error(). */
func (e ErrTooEvil) Error() string {
    return e.message + string(moronWhoCausedThisMessage)
}

var ErrBadThingA = errors.New("bad thing a")
type BadThingErr struct {
    signal int
    message string
}
func (ebtc BadThingErr) Error() string {
    return fmt.Sprintf("ErrBadThingC: %s", ebtc.message)
}

func wrapsErrors() error {
    if <terrible thing a> {
        return fmt.Errorf("wrapsErrors: %w", ErrBadThingA)
    }
    if <terrible thing b> { 
        return fmt.Errorf("wrapsErrors: %w", BadThingCError{5, "bad thing b"})
    }
    return nil
}

func main() {
  err = wrapsErrors()
  if errors.Is(err, ErrBadThingA) {
    // process the error
  } else if errors.As(err, &BadThingErr) {
    // process the error
  }
}

targetUrl := "https://cummings-online.ca/coding/go_environment"
client := &http.Client{  // One client for all requests. It runs concurrently.
    Timeout: 30 * time.Second,
}
req, err := http.NewRequestWithContext(
    context.Background(), http.MethodGet, targetUrl, nil,
)
req.Header.Add("User-Agent", "ExampleGobot/0.1 https://example.com/bot.html")
response, err := client.Do(req)
if err != nil {
    panic(err)
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
    panic(res.Status)
}
fmt.Println(res.Header.Get("Content-Type"))
fmt.Println(res.Body)

var restResponseTemplate {
    MonitorStatus int       `json:"status"`
    SystemNames   []string  `json:"system_names`
    LastReboot    time.Time `json:"last_reboot"`
}
err = json.NewDecoder(res.Body).Decode(&data) // "Unmarshalling" JSON
fmt.Println(data)

type MyHandler struct{}
func (mh MyHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
    header := rw.Header()
    header.Add("Content-Type", "text/html; charset=utf-8")
    rw.WriteHeader(http.StatusNotFound)
    rw.Write([]byte("<html><body><h1>404. Hahaha.</h1></body></html>"))
}

myHandler := http.NewServeMux()

myHandler.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request){
    header := rw.Header()
    header.Add("Content-Type", "text/html; charset=utf-8")
    rw.WriteHeader(http.StatusNotFound)
    rw.Write([]byte("<html><body><h1>404. Hahaha.</h1></body></html>"))
})

myHandler.HandleFunc("/george", func(rw http.ResponseWriter, r *http.Request){
    header := rw.Header()
    header.Add("Content-Type", "text/html; charset=utf-8")
    rw.Write([]byte("<html><body><p>This is George.</p></body></html>"))
})

server = http.Server{
    Addr: fmt.Sprintf(":%d", port),
    ReadTimeout: readTimeout * time.Second,
    WriteTimeout: writeTimeout * time.Second,
    IdleTimeout: idleTimeout * time.Second,
    Handler: MyHandler,
}
err := server.ListenAndServe()
if err != nil {
    if err != http.ErrServerClosed {
        panic(err)
    }
}

type HTTP404Handler struct{}
func (h4h HTTP404Handler) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
    header = rw.Header()
    header.Add("Content-Type", "text/html; charset=utf-8")
    rw.WriteHeader(http.StatusNotFound)
    rw.Write([]byte("<html><body><p>404. Hahaha.</p></body></html>"))
}

employeeHandler := http.NewServeMux()
resourceHandler := http.NewServeMux()
rootHandler := http.NewServeMux()

// ... etc ...

rootHandler.Handle("/", HTTP404Handler{})  // Note the {} since it's a struct
rootHandler.Handle("/employee/", http.StripPrefix("/employee"), employeeHandler)
rootHandler.Handle("/resource/", http.StripPrefix("/resource"), resourceHandler)

import (
    log "github.com/sirupsen/logrus"
)

func Log404Access(h http.Handler) http.Handler {
    return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request){
        log.Info(fmt.Sprintf("%s [%d]", r.URL.Path, http.StatusNotFound))
        h.ServeHTTP(rw, r)
    }) 
}

rootHandler.Handle("/", Log404Access(HTTP404Handler{}))

ch1 := make(chan string) // Unbuffered channel. Most channels are like this.
                         // Unbuffered channels are blocked until they have been
                         // read.
ch2 := make(chan int, 2)  // Buffered channel with two places.

func main() {
    go func {
        y := "Concurrency isn't all that difficult."
        ch1 <- y
    }()  // Remember anonymous functions end with ()!
    go func {
        x := 5
        y := 7
        ch2 <- x
        ch2 <- y
    }()
    select {
        case result, ok := <- ch1:
          if !ok {
            fmt.Println("Closed channel 1")
            ch1 = nil  // This case will never need to be checked again
                       // (not necessary here, but sure needed for a loop)
            // continue // Only needed if in a loop.
          }
          fmt.Println(result)
        case result, ok := <- ch2:
          if !ok {
            fmt.Println("Closed channel 2")
            ch2 = nil
          }
          fmt.Println(result)
    }
    close(ch1)
    close(ch2)
}

// This is a terrible, terrible useless 2-pass loop just to demonstrate the
// Done Channel Pattern. It fires up four concurrent, blocking goroutines.
func uselessTwoPassLoop() {
  done := make(chan struct{})  // Empty struct has size 0
  i = 0
  for {
    i++
    go func {
      i := i  // Shadowing is necessary when using parent variables that
              // change in a loop.
      fmt.Println(i)
      select {
        case <- done: // Blocked until "done" is closed.
      }
    }()
    go func(i int) {
      fmt.Println(i)
      select {
        case <- done:  // Blocked until "done" is closed.
      }
    }(i)
    if i > 2 {
      break
    }
  }
  close(done)  // Stops the go funcs
}

func uselessLoops(max int) func() {  // func() is a return value
  done := make(chan struct{})  // Empty struct has size 0
  cancel := func() {
    close(done)
  }
  for i := 0; i < max; i++ {
    go func {
      i := i
      fmt.Println(i)
      select {
        case <- done:
      }
    }()
    go func(i int) {
      fmt.Println(i)
      select {
        case <- done:
      }
    }(i)
  }
  return cancel
}

func main() {
    cancel = uselessLoops(5)
    cancel()
}

var wg sync.WaitGroup
wg.add(2)
go func() {
    defer wg.Done()
    // code here
}
go func() {
    defer wg.Done()
    // code here
}
wg.Wait()

func doNothingWithThis(ctx context.Context, x int) (int, error) {
    return x, nil
}

ctx:= context.Background()

// File: odd_things.go
func addNiToString(x string) string {
    return fmt.Sprintf("%sni", x)
}

// File: odd_things_test.go

// TestMain is an optional set up function
func TestMain(m *testing.M) {
    var foo string = "bar"
}

// helperFunction is an optional function for DRY
func helperFunction(t *testing.T)  {

    os.doStuff(...)
    
    // optional Cleanup cleans temporary resources
    t.Cleanup(func() {  
        // remove resources
    })
}

func Test_addNiToString(t *testing.T) {
    result := addNiToString("Bob")
    if result != "Bobni" {
        t.Error("incorrect result: expected Bobni, got", result )
    }
}