}
	if p == ^uintptr(0) {
		return 0, false
	}
	return *(*uint32)(unsafe.Pointer(p + _HPET_MAIN_COUNTER)), true
}

//go:systemstack
func initHPETTimecounter(idx int) {
	const digits = "0123456789"

	var devPath [len(hpetDevPath)]byte
	copy(devPath[:], hpetDevPath)
	devPath[9] = digits[idx]

	fd := open(&devPath[0], 0 /* O_RDONLY */ |_O_CLOEXEC, 0)
	if fd < 0 {

			},
			stDefaultCPUSet:           cpuset.New(1, 2, 3, 4, 5, 6, 7),
			lastUpdateStAssignments:   state.ContainerCPUAssignments{},
			lastUpdateStDefaultCPUSet: cpuset.New(),
			expectStAssignments: state.ContainerCPUAssignments{
				"fakePodUID": map[string]cpuset.CPUSet{
					"fakeContainerName": cpuset.New(),
				},
			},
			expectStDefaultCPUSet:        cpuset.New(1, 2, 3, 4, 5, 6, 7),
			expectSucceededContainerName: "",

	{"0b__1000", 0, false, nat{0x8}, 2, 4, errInvalSep, 0},
	{"0o60___0", 0, false, nat{0600}, 8, 3, errInvalSep, 0},
	{"0466_", 0, false, nat{0466}, 8, 3, errInvalSep, 0},
	{"01234567_8", 0, false, nat{01234567}, 8, 7, errInvalSep, '8'},
	{"1_.", 0, true, nat{1}, 10, 0, errInvalSep, 0},
	{"0._1", 0, true, nat{1}, 10, -1, errInvalSep, 0},
	{"2.7_", 0, true, nat{27}, 10, -1, errInvalSep, 0},

  // CHECK: return %[[RES_TRANSPOSE]]

  %0 = "tf.Conv2D"(%input, %filter)
       {
         data_format = "NCHW",
         dilations = [1, 2, 3, 4],
         explicit_paddings = [1, 2, 3, 4, 5, 6, 7, 8],
         padding = "EXPLICIT",
         strides = [5, 6, 7, 8]
       } : (tensor<1x3x32x32xf32>, tensor<1x1x3x8xf32>) -> tensor<1x8x7x6xf32>

  func.return %0 : tensor<1x8x7x6xf32>
}

	s := []byte("0123456789")
	for i := 0; i < b.N; i++ {
		RuneCount(s)
	}
}

func BenchmarkRuneCountTenJapaneseChars(b *testing.B) {
	s := []byte("日本語日本語日本語日")
	for i := 0; i < b.N; i++ {
		RuneCount(s)
	}
}

func BenchmarkRuneCountInStringTenASCIIChars(b *testing.B) {
	for i := 0; i < b.N; i++ {
		RuneCountInString("0123456789")
	}
}

    }
    def fileAccessTracker = Mock(FileAccessTracker)
    def cache = new DirectoryBuildCache(persistentCache, fileAccessTracker, ".failed")
    def key = TestHashCodes.hashCodeFrom(12345678)
    def hashCode = key.toString()

    def "does not store partial result"() {
        when:
        cache.store(key) { output ->
            // Check that partial result file is created inside the cache directory

        CacheBuilder.newBuilder().concurrencyLevel(1).maximumSize(10).build(loader);
    CacheTesting.warmUp(cache, 0, 10);
    Set<Integer> keySet = cache.asMap().keySet();
    assertThat(keySet).containsExactly(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

    // re-order
    getAll(cache, asList(0, 1, 2));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(3, 4, 5, 6, 7, 8, 9, 0, 1, 2);

    // evict 3, 4, 5

	}
}

func TestDtoi(t *testing.T) {
	for _, tt := range []struct {
		in  string
		out int
		off int
		ok  bool
	}{
		{"", 0, 0, false},
		{"0", 0, 1, true},
		{"65536", 65536, 5, true},
		{"123456789", big, 8, false},
		{"-0", 0, 0, false},
		{"-1234", 0, 0, false},
	} {
		n, i, ok := dtoi(tt.in)
		if n != tt.out || i != tt.off || ok != tt.ok {

        assertEquals("1234567...", documentHelper.getDigest(responseData, "1234567890123456789", dataMap, 10));
        assertEquals("1234567...", documentHelper.getDigest(responseData, "12345678901", dataMap, 10));
        assertEquals("1234567890", documentHelper.getDigest(responseData, "1234567890", dataMap, 10));
        assertEquals("123456789", documentHelper.getDigest(responseData, "123456789", dataMap, 10));

				break
			}
		}
		if i == 0 && testing.Short() && testenv.Builder() == "" {
			break
		}
	}
}

func TestWriterDict(t *testing.T) {
	const dictionary = "0123456789."
	for i, fn := range filenames {
		testFileLevelDict(t, fn, DefaultCompression, dictionary)
		testFileLevelDict(t, fn, NoCompression, dictionary)
		testFileLevelDict(t, fn, HuffmanOnly, dictionary)