X := T.Bswap64(x) // ERROR "intrinsic substitution for Bswap64"
		Y := T.Bswap64(y) // ERROR "intrinsic substitution for Bswap64"
		if y != X {
			logf("Bswap64(0x%08x) expected 0x%08x but got 0x%08x\n", x, y, X)
		}
		if x != Y {
			logf("Bswap64(0x%08x) expected 0x%08x but got 0x%08x\n", y, x, Y)
		}

		x32 := uint32(X)
		y32 := uint32(Y >> 32)

		X32 := T.Bswap32(x32) // ERROR "intrinsic substitution for Bswap32"

     */
    public String generateGid(String pbxClassName, int hash) {
        int counter = 0;
        String gid;
        do {
            gid = String.format("%08X%08X%08X", pbxClassName.hashCode(), hash, counter++);
        } while (generatedAndReservedIds.contains(gid));
        generatedAndReservedIds.add(gid);
        return gid;
    }

		got32 := RotateLeft32(x32, int(k))
		want32 := x32<<(k&0x1f) | x32>>(32-k&0x1f)
		if got32 != want32 {
			t.Fatalf("RotateLeft32(%#08x, %d) == %#08x; want %#08x", x32, k, got32, want32)
		}
		got32 = RotateLeft32(want32, -int(k))
		if got32 != x32 {
			t.Fatalf("RotateLeft32(%#08x, -%d) == %#08x; want %#08x", want32, k, got32, x32)
		}
		if UintSize == 32 {
			x := uint(m)
			got := RotateLeft(x, int(k))

		{9e-45, 0x00000006},
		{1.0e-44, 0x00000007},
		{1.1e-44, 0x00000008},
		{1.2e-44, 0x00000009},
	} {
		got := math.Float32bits(t.value)
		want := t.bits
		if got != want {
			panic(fmt.Sprintf("bits(%g) = 0x%08x; want 0x%08x", t.value, got, want))
		}
	}

		fmt.Fprintf(w, "\t/* x^%d mod p(x)%s, x^%d mod p(x)%s, x^%d mod p(x)%s, x^%d mod p(x)%s */\n", i+128, "", i+96, "", i+64, "", i+32, "")
		fmt.Fprintf(w, "DATA ·%sConst+%d(SB)/8,$0x%08x%08x\n", polyid, j*8, c, d)
		fmt.Fprintf(w, "DATA ·%sConst+%d(SB)/8,$0x%08x%08x\n", polyid, (j+1)*8, a, b)

		j += 2
		fmt.Fprintf(w, "\n")
	}

	fmt.Fprintf(w, "GLOBL ·%sConst(SB),RODATA,$4336\n", polyid)

				return volume.NewSpecFromPersistentVolume(makeTestPV(specName, 20, driver, volName), false)
			},
			podFunc: func() *api.Pod {
				podUID := types.UID(fmt.Sprintf("%08X", rand.Uint64()))
				return &api.Pod{ObjectMeta: meta.ObjectMeta{UID: podUID, Namespace: testns}}
			},
		},
		{
			name:     "PersistentVolume with driver info",
			specName: "pv2",
			driver:   "simple-driver",

		{{range $i, $s := dup 4 .Shift1 -}}
			{{printf "arg0 = arg1 + bits.RotateLeft32((((arg2^arg3)&arg1)^arg3)+arg0+x%x+%#08x, %d)" (idx 1 $i) (index $.Table1 $i) $s | relabel}}
			{{rotate -}}
		{{end}}

		// round 2
		{{range $i, $s := dup 4 .Shift2 -}}
			{{printf "arg0 = arg1 + bits.RotateLeft32((((arg1^arg2)&arg3)^arg2)+arg0+x%x+%#08x, %d)" (idx 2 $i) (index $.Table2 $i) $s | relabel}}
			{{rotate -}}
		{{end}}

		// round 3

			podUID:     types.UID(fmt.Sprintf("%08X", rand.Uint64())),
		},
		{
			name:       "construct spec2 from original persistent spec",
			specVolID:  "spec2",
			volHandle:  "handle2",
			originSpec: volume.NewSpecFromPersistentVolume(makeTestPV("spec2", 20, testDriver, "handle2"), true),
			podUID:     types.UID(fmt.Sprintf("%08X", rand.Uint64())),
		},
		{

func f64(x float64) float64 { return float64(x) }

func test32(a, b float32) {
	abits := math.Float32bits(a)
	bbits := math.Float32bits(b)
	if abits != bbits {
		panic(fmt.Sprintf("%08x != %08x\n", abits, bbits))
	}
}

func test64(a, b float64) {
	abits := math.Float64bits(a)
	bbits := math.Float64bits(b)
	if abits != bbits {
		panic(fmt.Sprintf("%016x != %016x\n", abits, bbits))
	}

    assertEquals(
        String.format("expected: %08x, actual: %08x", expectedCrc, actualCrc),
        expectedCrc,
        actualCrc);
    int actualCrcHasher = Hashing.crc32c().newHasher().putBytes(data).hash().asInt();
    assertEquals(
        String.format("expected: %08x, actual: %08x", expectedCrc, actualCrc),
        expectedCrc,
        actualCrcHasher);
  }