
The `//go:embed` directive lets you bundle static files and directories into the compiled binary at build time. The `embed` package provides the `embed.FS` type for accessing embedded content at runtime.

<ExamplePair>
<ExampleProse>

Import the `embed` package and place a `//go:embed` comment immediately before a variable of type `string`, `[]byte`, or `embed.FS`. The compiler reads the file at build time and bakes it into the binary.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    _ "embed"
    "fmt"
)

//go:embed hello.txt
var content string

func main() {
    fmt.Print(content)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`embed.FS` can hold multiple files or entire directory trees. Use `fs.ReadFile` or the methods on `embed.FS` to read them. The embedded paths must be relative and cannot use `..`.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "embed"
    "fmt"
)

//go:embed templates
var templateFS embed.FS

func main() {
    data, err := templateFS.ReadFile("templates/index.html")
    if err != nil {
        panic(err)
    }
    fmt.Printf("template size: %d bytes\n", len(data))

    entries, _ := templateFS.ReadDir("templates")
    for _, e := range entries {
        fmt.Println(e.Name())
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Pass an `embed.FS` to `http.FileServer` via `http.FS` to serve embedded static assets. The server reads from the in-memory filesystem, not the disk.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "embed"
    "net/http"
)

//go:embed static
var staticFiles embed.FS

func main() {
    http.Handle("/", http.FileServer(http.FS(staticFiles)))
    http.ListenAndServe(":8080", nil)
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`go:embed` is the idiomatic way to ship static assets (HTML templates, database migrations, default config files) inside a single binary. The embedded content is read-only at runtime - you cannot write back to it. For large assets, weigh the binary size increase against the deployment simplicity gain; embedding gigabytes of media is a valid use case for dedicated object storage instead. `embed.FS` implements `fs.FS`, so any function that accepts `fs.FS` (including `html/template.ParseFS` and `text/template.ParseFS`) works directly with it. In tests, use `//go:embed testdata` in test files to embed fixtures alongside the test - the testdata directory is the convention for this.
</InProduction>


The //go:embed directive bundles static files and directories into the compiled binary using embed.FS, enabling single-binary deployments.

Embed Directive


Go ships a test runner in the standard library. Test files end in `_test.go` and contain functions named `TestXxx` or `BenchmarkXxx`. Run tests with `go test ./...`.

<ExamplePair>
<ExampleProse>

A test function accepts `*testing.T`. Call `t.Error` or `t.Errorf` to mark a failure without stopping the test. Call `t.Fatal` or `t.Fatalf` to mark a failure and stop immediately.

</ExampleProse>
<ExampleCode>

```go
// math_test.go
package main

import "testing"

func add(a, b int) int { return a + b }

func TestAdd(t *testing.T) {
    got := add(2, 3)
    want := 5
    if got != want {
        t.Errorf("add(2, 3) = %d; want %d", got, want)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Table-driven tests loop over a slice of cases. Each entry specifies inputs and the expected output. When a case fails, `t.Errorf` reports the case name so you can identify it without reading the data manually.

</ExampleProse>
<ExampleCode>

```go
func TestAddTable(t *testing.T) {
    cases := []struct {
        name    string
        a, b    int
        want    int
    }{
        {"positive", 2, 3, 5},
        {"zero", 0, 0, 0},
        {"negative", -1, -2, -3},
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            got := add(tc.a, tc.b)
            if got != tc.want {
                t.Errorf("got %d; want %d", got, tc.want)
            }
        })
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Benchmark functions accept `*testing.B`. The `b.N` field is set by the runner to the number of iterations needed to get a stable measurement. Run with `go test -bench=. -benchmem` to include allocation counts.

</ExampleProse>
<ExampleCode>

```go
func BenchmarkAdd(b *testing.B) {
    for range b.N {
        add(2, 3)
    }
}

// With expensive setup:
func BenchmarkAddSetup(b *testing.B) {
    data := make([]int, 1000) // expensive setup
    b.ResetTimer()            // exclude setup from measurement
    b.ReportAllocs()          // surface allocation counts

    for range b.N {
        _ = data[0] + data[1]
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Table-driven tests are idiomatic Go - they make adding cases trivial and the failure output shows which case failed by name. Use `t.Helper()` in assertion helper functions so failure line numbers point to the test that called the helper, not inside the helper itself. Benchmarks require `b.ResetTimer()` when setup is expensive, so setup time is excluded from the reported ns/op. `b.ReportAllocs()` surfaces allocation counts in the output, which is often more diagnostic than raw speed. Place fixture files under a `testdata/` directory in the package - the `go test` tool changes to the package directory before running, so `os.Open("testdata/input.json")` works without path arithmetic. Use `t.TempDir()` for temporary directories in tests; it is automatically cleaned up when the test ends.
</InProduction>


Go's built-in testing package provides TestXxx functions, table-driven tests, BenchmarkXxx functions, and the testdata directory convention without external frameworks.

Testing and Benchmarking


`os.CreateTemp` and `os.MkdirTemp` create temporary files and directories with unique, non-colliding names. They are the safe replacement for manual temp-file construction, which is vulnerable to race conditions.

<ExamplePair>
<ExampleProse>

`os.CreateTemp` creates a new file in the system temp directory (or a specified dir) with a unique name built from the given pattern. The returned `*os.File` is open for reading and writing. Clean up with `os.Remove` when done.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    // "" uses os.TempDir(); the name will be something like /tmp/example-1234567890
    f, err := os.CreateTemp("", "example-")
    if err != nil {
        panic(err)
    }
    defer os.Remove(f.Name()) // clean up on exit
    defer f.Close()

    fmt.Println("temp file:", f.Name())

    _, err = f.WriteString("temporary content\n")
    if err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`os.MkdirTemp` creates a temporary directory. Use it when you need a temporary workspace for multiple files. Clean up the whole tree with `os.RemoveAll` when done.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "os"
    "path/filepath"
)

func main() {
    dir, err := os.MkdirTemp("", "workspace-")
    if err != nil {
        panic(err)
    }
    defer os.RemoveAll(dir) // clean up entire directory

    fmt.Println("temp dir:", dir)

    // Create files inside the temp directory
    p := filepath.Join(dir, "data.txt")
    err = os.WriteFile(p, []byte("hello"), 0600)
    if err != nil {
        panic(err)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

In tests, use `t.TempDir()` instead of `os.MkdirTemp`. It returns a unique directory that the test runner removes automatically when the test completes - no manual cleanup needed.

</ExampleProse>
<ExampleCode>

```go
package mypackage_test

import (
    "os"
    "path/filepath"
    "testing"
)

func TestWriteConfig(t *testing.T) {
    dir := t.TempDir() // cleaned up automatically after the test

    cfg := filepath.Join(dir, "config.json")
    err := os.WriteFile(cfg, []byte(`{"debug":true}`), 0600)
    if err != nil {
        t.Fatal(err)
    }

    // test logic that reads from cfg...
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Always clean up temp files and directories, preferably with `defer` immediately after creation - a crash or early return without the defer running leaves them on disk. Temp files created by `os.CreateTemp` are not deleted on process exit. In tests, `t.TempDir()` is always preferable to manual `os.MkdirTemp` + `defer os.RemoveAll` - the test runner handles cleanup even if the test panics. When writing to a temp file and then renaming it over a real file (atomic write pattern), create the temp file in the same directory as the target so the rename stays on the same filesystem - cross-device renames fail with `EXDEV`. Set restrictive permissions (`0600` for files, `0700` for directories) on temp paths that contain sensitive data; `os.TempDir()` is world-readable on Linux by default.
</InProduction>


os.CreateTemp and os.MkdirTemp for creating temporary files and directories, deferred cleanup, and t.TempDir in tests.