l.x = v
}

func main() {
	sl := Lockable[string]{x: "a"}
	if got := sl.get(); got != "a" {
		panic(got)
	}
	sl.set("b")
	if got := sl.get(); got != "b" {
		panic(got)
	}

	il := Lockable[int]{x: 1}
	if got := il.get(); got != 1 {
		panic(got)
	}
	il.set(2)
	if got := il.get(); got != 2 {
		panic(got)
	}

		b1: "a",
		b2: "b",
	}

	if got, want := x.b2, "b"; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}
	x.b1 = "y"
	x.val = 5

	return x
}

func main() {
	x := f[MyStruct]()
	if got, want := x.b1, "y"; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}
	if got, want := x.val, 5; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}
}

	}
	if got, want := js.Null().Type(), js.TypeNull; got != want {
		t.Errorf("got %s, want %s", got, want)
	}
	if got, want := js.ValueOf(true).Type(), js.TypeBoolean; got != want {
		t.Errorf("got %s, want %s", got, want)
	}
	if got, want := js.ValueOf(0).Type(), js.TypeNumber; got != want {
		t.Errorf("got %s, want %s", got, want)
	}
	if got, want := js.ValueOf(42).Type(), js.TypeNumber; got != want {

	vec1 := []string{"ab", "cd", "ef"}
	if got := Index(vec1, "ef"); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	vec2 := []byte{'c', '6', '@'}
	if got := Index(vec2, '@'); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	vec3 := []*obj{&obj{2}, &obj{42}, &obj{1}}
	if got := Index(vec3, vec3[2]); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

		}
	}
}

func TestBitLen16(t *testing.T) {
	for i := 0; i <= 16; i++ {
		got := bits.Len16(1 << i)
		want := i + 1
		if want == 17 {
			want = 0
		}
		if got != want {
			t.Errorf("Len16(1<<%d) = %d, want %d", i, got, want)
		}
	}
}

func TestBitLen8(t *testing.T) {
	for i := 0; i <= 8; i++ {
		got := bits.Len8(1 << i)
		want := i + 1
		if want == 9 {
			want = 0
		}

	}
	got := runTestProg(t, "testprogcgo", "CgoSignalDeadlock")
	want := "OK\n"
	if got != want {
		t.Fatalf("expected %q, but got:\n%s", want, got)
	}
}

func TestCgoTraceback(t *testing.T) {
	t.Parallel()
	got := runTestProg(t, "testprogcgo", "CgoTraceback")
	want := "OK\n"
	if got != want {
		t.Fatalf("expected %q, but got:\n%s", want, got)
	}
}

		t.Errorf("testBitwiseAnd failed, wanted %d got %d", want, got)
	}
	if want, got := uint32(1333785343), testBitwiseOr_ssa(a, b); want != got {
		t.Errorf("testBitwiseOr failed, wanted %d got %d", want, got)
	}
	if want, got := uint32(1295233564), testBitwiseXor_ssa(a, b); want != got {
		t.Errorf("testBitwiseXor failed, wanted %d got %d", want, got)
	}
	if want, got := int32(832), testBitwiseLsh_ssa(13, 4, 2); want != got {

		}
	}
}

func TestIsUpperLatin1(t *testing.T) {
	for i := rune(0); i <= MaxLatin1; i++ {
		got := IsUpper(i)
		want := Is(Upper, i)
		if got != want {
			t.Errorf("%U incorrect: got %t; want %t", i, got, want)
		}
	}
}

func TestIsLowerLatin1(t *testing.T) {
	for i := rune(0); i <= MaxLatin1; i++ {
		got := IsLower(i)
		want := Is(Lower, i)
		if got != want {

	for _, want := range []string{
		"∅",
		"𝓤",
		"int",
		"~int",
		"myInt",
		"∅ | ∅",
		"𝓤 | 𝓤",
		"∅ | 𝓤 | int",
		"∅ | 𝓤 | int | myInt",
	} {
		if got := maketl(want).String(); got != want {
			t.Errorf("(%v).String() == %v", want, got)
		}
	}
}

func TestTermlistIsEmpty(t *testing.T) {
	for test, want := range map[string]bool{
		"∅":             true,
		"∅ | ∅":         true,

			t.Errorf("%v: expect: %+v, got %+v", utils.FileWithLineNum(), expect, got)
			return
		}

		if valuer, ok := got.(driver.Valuer); ok {
			got, _ = valuer.Value()
		}

		if valuer, ok := expect.(driver.Valuer); ok {
			expect, _ = valuer.Value()
		}

		if got != nil {
			got = reflect.Indirect(reflect.ValueOf(got)).Interface()
		}

		if expect != nil {