go run check_file/main.go $GOCACHE/fuzz/FuzzCovMin ab

-- go.mod --
module test

-- covmin_test.go --
package covmin

import "testing"

func FuzzCovMin(f *testing.F) {
	f.Add([]byte("aa"))
	f.Fuzz(func(t *testing.T, data []byte) {
		if len(data) == 2 && data[0] == 'a' && data[1] == 'b' {
			return
		}
	})
}

-- check_file/main.go --
package main

import (
	"bytes"
	"fmt"

	(*reflect.StringHeader)(unsafe.Pointer(&bad2)).Data = uintptr(unsafe.Pointer(&b[1]))

	for _, test := range []struct {
		a, b interface{}
	}{
		{SI{s: bad1, i: 1}, SI{s: bad2, i: 2}},
		{SS{s: bad1, t: "a"}, SS{s: bad2, t: "aa"}},
		{SS{s: "a", t: bad1}, SS{s: "b", t: bad2}},
		// This one would panic because the length of both strings match, and we check
		// the body of the bad strings before the body of the good strings.

    t.pushRight(2).left == t
    t.pushRight(2).right == 2

    t.mapLeft { it + 1 }.left == 2
    t.mapLeft { it + 1 }.right == "a"
    t.mapRight { it * 2 }.left == 1
    t.mapRight { it * 2 }.right == "aa"

    t.nestLeft(2).mapLeft(unpackLeft()).left == 2
    t.nestLeft(2).mapLeft(unpackRight()).left == 1
    t.nestLeft(2).mapLeft(unpackLeft()).right == "a"
    t.nestLeft(2).mapLeft(unpackRight()).right == "a"

	f1 := &a.List[float64]{f2, 4.5}
	if got, want := f1.Largest(), 13.5; got != want {
		panic(fmt.Sprintf("got %f, want %f", got, want))
	}

	s3 := &a.List[string]{nil, "dd"}
	s2 := &a.List[string]{s3, "aa"}
	s1 := &a.List[string]{s2, "bb"}
	if got, want := s1.Largest(), "dd"; got != want {
		panic(fmt.Sprintf("got %s, want %s", got, want))
	}
	j3 := &a.ListNum[int]{nil, 1}
	j2 := &a.ListNum[int]{j3, 32}

				t.Errorf("%s: expect %v got %v", tt.desc, tt.expect, got)
			}
		})
	}
}

func stringSlicesEqual(a, b []string) bool {
	if len(a) != len(b) {
		return false
	}
	for i, aa := range a {
		if aa != b[i] {
			return false
		}
	}
	return true
}

func TestPathFromString(t *testing.T) {
	tests := []struct {
		desc   string
		in     string
		expect Path
	}{
		{

000001e0  d3 aa f7 77 30 43 6e 5f  4e fa e3 b1 a6 c8 80 47  |...w0Cn_N......G|
000001f0  16 71 a0 bc 9e d3 89 14  49 ca 9a 87 8b b0 3b c7  |.q......I.....;.|
00000200  a7 f4 6d 2a cb 0a 5e 8a  e5 f1 45 65 e4 51 da b1  |..m*..^...Ee.Q..|
00000210  5c e2 88 90 46 e7 cb 01  0b 99 64 fe 5b b4 b3 e6  |\...F.....d.[...|
00000220  aa 6f 59 25 25 79 2b 8e  6b 59 65 15 51 a1 8f a2  |.oY%%y+.kYe.Q...|

	"log" // for Fatal
	"math"

	"errors"
	"fmt" // for Printf
	"io"  // for Reader
	"log" // for Fatal
	"math"
)

// Test deduping and extended sorting
import (
	a "A" // aA
	b "A" // bA1
	b "A" // bA2
	"B"   // B
	. "B" // .B
	_ "B" // _b
	"C"
	a "D" // aD
)

import (
	"dedup_by_group"

	"dedup_by_group"
)

import (

		{"d", "abcdefg", 3},
		{"nan", "banana", 2},
		{"pan", "anpanman", 2},
		{"nnaaman", "anpanmanam", -1},
		{"abcd", "abc", -1},
		{"abcd", "bcd", -1},
		{"bcd", "abcd", 1},
		{"abc", "acca", -1},
		{"aa", "aaa", 0},
		{"baa", "aaaaa", -1},
		{"at that", "which finally halts.  at that point", 22},
	}

	for _, tc := range testCases {
		got := StringFind(tc.pat, tc.text)
		want := tc.index
		if got != want {

	}
}

func TestMax() {
	s1 := []int{1, 2, 3, -5}
	if got, want := a.SliceMax(s1), 3; got != want {
		panic(fmt.Sprintf("a.Max(%v) = %d, want %d", s1, got, want))
	}

	s2 := []string{"aaa", "a", "aa", "aaaa"}
	if got, want := a.SliceMax(s2), "aaaa"; got != want {
		panic(fmt.Sprintf("a.Max(%v) = %q, want %q", s2, got, want))
	}

	if got, want := a.SliceMax(s2[:0]), ""; got != want {

            syncAt(2)
            System.arraycopy('aaaa'.bytes, 0, buffer, pos, 4)
            return 4
        }
        source.onRead { buffer, pos, count ->
            syncAt(3)
            System.arraycopy('aa'.bytes, 0, buffer, pos, 2)
            syncAt(4)
            return 2
        }

        def instr = new DisconnectableInputStream(source, toActionExecuter(executorFactory), 10)

        run {