in:   `foo\:bar:baz\:qux`,
			want: []string{`foo\:bar`, `baz\:qux`},
		},
	}
	for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			if got, want := splitEscaped(tt.in, kvSeparatorRune), tt.want; !stringSlicesEqual(got, want) {
				t.Errorf("%s: got:%v, want:%v", tt.desc, got, want)
			}
		})
	}
}

func TestIsNPathElement(t *testing.T) {
	tests := []struct {
		desc   string
		in     string
		expect bool

}

func testMod() {
	got := mod3(1<<32 - 1)
	want := uint64((1<<32 - 1) % 3)
	if got != want {
		fmt.Printf("testMod: got %x want %x\n", got, want)
	}

}

//go:noinline
func mul3(a uint32) uint64 {
	return uint64(a * 3)
}

func testMul() {
	got := mul3(1<<32 - 1)
	want := uint64((1<<32-1)*3 - 2<<32)
	if got != want {
		fmt.Printf("testMul: got %x want %x\n", got, want)
	}

		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			got := MapFilter(tc.input, tc.function)

			if len(got) != len(tc.want) {
				t.Errorf("got %d, want %d", got, tc.want)
			}

			for i := range got {
				if got[i] != tc.want[i] {
					t.Errorf("got %d, want %d", got[i], tc.want[i])
				}
			}
		})
	}
}

func TestReference(t *testing.T) {

			inVals:      nil,
			expectedOut: "null\n",
		},
	}
	for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			if got := ToYAML(tt.inVals); got != tt.expectedOut {
				t.Errorf("%s: expected out %v got %s", tt.desc, tt.expectedOut, got)
			}
		})
	}
}

func TestOverlayTrees(t *testing.T) {
	tests := []struct {
		desc            string
		inBase          map[string]any

		t.Errorf("invalid index name generated, got %v", idxName)
	}

	chkName := ns.CheckerName("public.table", "name")
	if chkName != "chk_public_table_name" {
		t.Errorf("invalid checker name generated, got %v", chkName)
	}

	joinTable := ns.JoinTableName("user_languages")
	if joinTable != "public.user_languages" {
		t.Errorf("invalid join table generated, got %v", joinTable)
	}

	var got scanner
	got.init(strings.NewReader(src), errh, 0)
	for _, want := range tokens {
		got.next()
		if got.tok != want {
			t.Errorf("%d:%d: got %s; want %s", got.line, got.col, got.tok, want)
			continue
		}
	}
}

// Once TestSmoke passes, run TestTokens next.
func TestTokens(t *testing.T) {
	var got scanner
	for _, want := range sampleTokens {

			t.Fatalf("first expects: %v, got %v", u1, got)
		}

		results = DB.Select("id, name").Find(&got)
		if results.Error != nil {
			t.Fatalf("errors happened on first: %v", results.Error)
		} else if results.RowsAffected != 1 {
			t.Fatalf("rows affected expects: %v, got %v", 1, results.RowsAffected)
		} else if got.ID != u1.ID {
			t.Fatalf("select expects: %v, got %v", u1, got)
		}

		u1.Name = "jinzhu"

	defer cleanup()

	// case-sensitive lookup
	if got := TypeByExtension(".tesT"); got != custom {
		t.Fatalf("for .tesT, got %q; want %q", got, custom)
	}
	if got := TypeByExtension(".TEST"); got != caps {
		t.Fatalf("for .TEST, got %q; want %s", got, caps)
	}

	// case-insensitive
	if got := TypeByExtension(".TesT"); got != custom {
		t.Fatalf("for .TesT, got %q; want %q", got, custom)
	}
}

		got := syscall.DecodeWTF16(u16, nil)
		if utf8.Valid(got) {
			// if the input is a valid UTF-8 string, then
			// test that syscall.DecodeWTF16 behaves as
			// utf16.Decode
			want := utf16.Decode(u16)
			if string(got) != string(want) {
				t.Errorf("got:\n%s\nwant:\n%s", string(got), string(want))
			}
		}
		// WTF-8 should always roundtrip
		got2 := syscall.EncodeWTF16(string(got), nil)

		CriticalErrors: []string{"e1", "e2"},
		IgnoredErrors:  []string{"e3", "e4"},
	}

	got := &BugReportConfig{}
	if err := yaml.Unmarshal([]byte(config), got); err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(got, want) {
		t.Errorf("got:\n%s\nwant:\n%s\n\ndiff (-got, +want):\n%s\n", pretty.Sprint(got), pretty.Sprint(want), cmp.Diff(got, want))
	}
}

func TestUnmarshalSelectionSpec(t *testing.T) {