Go言語プログラミングエッセンス

n := 50
a = append(a[:n], a[n+1:]...)

n := 50
a = a[:n+copy(a[n:], a[n+1:])]

func TestString(t *testing.T) {
	s := "あいうえお"
	rs := []rune(s)
	if len(rs) != utf8.RuneCountInString(s) {
		t.Error(len(rs))
	}

	rs[0] = 'か'
	if string(rs) != "かいうえお" {
		t.Error(s)
	}
}

*v

package main

var _ A = (*B)(nil)

type A interface {
	Do()
}

type B struct {
}

func (b *B) Do() {
}

func TestPanic(t *testing.T) {
	defer func() {
		if e := recover(); e == nil {
			t.Fatal("no panic")
		} else {
			log.Printf("%+v", e)
		}
	}()
	var i int
	log.Println(1 / i)
}

package main_test

import (
	_ "embed"
	"strings"
	"testing"
)

//go:embed embed_test.go
var code string

func TestEmbed(t *testing.T) {
	line := code[:strings.Index(code, "\n")]
	if line != "package main_test" {
		t.Error()
	}
}

package main_test

import "testing"

type FOP struct {
	a string
	b string
}

type Option func(*FOP)

func WithB(s string) Option {
	return func(a *FOP) {
		a.b = s
	}
}

func NewFOP(a string, opts ...Option) *FOP {
	s := &FOP{a: a}
	for _, opt := range opts {
		opt(s)
	}
	return s
}

func TestFunctionalOptionsPattern(t *testing.T) {
	a := NewFOP("a", WithB("b"))
	if a.a != "a" {
		t.Error("a")
	}
	if a.b != "b" {
		t.Error("b")
	}
}

package main_test

import (
	"fmt"
	"log"
	"testing"
)

func generator(msg string) <-chan string {
	ch := make(chan string)
	go func() {
		for i := 0; ; i++ {
			ch <- fmt.Sprintf("%d: %s", i, msg)
		}
	}()
	return ch
}

func join(generators ...<-chan string) <-chan string {
	ch := make(chan string)
	for _, g := range generators {
		go func(g <-chan string) {
			for {
				ch <- <-g
			}
		}(g)
	}
	return ch
}

func TestJoin(t *testing.T) {
	ch := join(
		generator("a"),
		generator("b"),
		generator("c"),
		generator("d"),
		generator("e"),
	)

	for i := 0; i < 10; i++ {
		s := <-ch
		log.Println(s)
	}
}

func TestThrottling(t *testing.T) {
	limit := make(chan struct{}, 5)

	wg := sync.WaitGroup{}
	for i := 0; i < 10; i++ {
		go func(i int) {
			wg.Add(1)
			defer wg.Done()
			limit <- struct{}{}
			log.Printf("no: %d", i)
			time.Sleep(2 * time.Second)
			<-limit
		}(i)
	}
	time.Sleep(1 * time.Second)
	if l := len(limit); l != 5 {
		t.Error(l)
	}
	wg.Wait()
}