}
        };

    recursiveCache = CacheBuilder.newBuilder().weakKeys().weakValues().build(recursiveLoader);
    cacheRef.set(recursiveCache);

    // tells the test when the computation has completed
    CountDownLatch doneSignal = new CountDownLatch(1);

    Thread thread =
        new Thread() {
          @Override
          public void run() {
            try {

// From https://github.com/Kotlin/kotlinx-atomicfu/blob/master/atomicfu/build.gradle.kts
val compileJavaModuleInfo by tasks.registering(JavaCompile::class) {
  val moduleName = "okhttp3"
  val compilation = kotlin.targets["jvm"].compilations["main"]
  val compileKotlinTask = compilation.compileTaskProvider.get() as KotlinJvmCompile
  val targetDir = compileKotlinTask.destinationDirectory.dir("../java9")
  val sourceDir = file("src/jvmMain/java9/")

		decSizes []int64
		oi       ObjectInfo
	}{
		{s1, mkMPObj(s1)},
		{s2, mkMPObj(s2)},
		{s3, mkMPObj(s3)},
	}

	// This function is a reference (re-)implementation of
	// decrypted range computation, written solely for the purpose
	// of the unit tests.
	//
	// `s` gives the decrypted part sizes, and the other
	// parameters describe the desired read segment. When

        /*
         * a * b == aHi * bHi * 2^64 + (aHi * bLo + aLo * bHi) * 2^32 + aLo * bLo.
         *       == (aHi * bHi * 2^32 + aHi * bLo + aLo * bHi) * 2^32 + aLo * bLo
         *
         * We carry out this computation in modular arithmetic. Since times2ToThe32Mod accepts any
         * unsigned long, we don't have to do a mod on every operation, only when intermediate
         * results can exceed 2^63.
         */

        if (session == null) {
            session = createMaven4Session();
        }
        return session;
    }

    /**
     * Creates a new Maven 4 session for effective POM computation.
     */
    private Session createMaven4Session() {
        Session session = ApiRunner.createSession(injector -> {
            injector.bindInstance(Dispatcher.class, new LegacyDispatcher());

    // clear absent
    assertFalse(segment.clearValueForTesting(key, hash, valueRef));

    segment.setTableEntryForTesting(0, entry);
    // don't increment count; this is used during computation
    assertTrue(segment.clearValueForTesting(key, hash, valueRef));
    // no notification sent with clearValue
    assertEquals(0, segment.count);
    assertThat(table.get(0)).isNull();

    // clear absent
    assertFalse(segment.clearValueForTesting(key, hash, valueRef));

    segment.setTableEntryForTesting(0, entry);
    // don't increment count; this is used during computation
    assertTrue(segment.clearValueForTesting(key, hash, valueRef));
    // no notification sent with clearValue
    assertEquals(0, segment.count);
    assertThat(table.get(0)).isNull();

        .isEqualTo(EntryFactory.WEAK_WRITE);
    assertThat(EntryFactory.getFactory(Strength.WEAK, true, true))
        .isEqualTo(EntryFactory.WEAK_ACCESS_WRITE);
  }

  // computation tests

  public void testCompute() throws ExecutionException {
    CountingLoader loader = new CountingLoader();
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());

        .isEqualTo(EntryFactory.WEAK_WRITE);
    assertThat(EntryFactory.getFactory(Strength.WEAK, true, true))
        .isEqualTo(EntryFactory.WEAK_ACCESS_WRITE);
  }

  // computation tests

  public void testCompute() throws ExecutionException {
    CountingLoader loader = new CountingLoader();
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());

X0 // H * 2 PSHUFD $0xff, X0, X11 MOVOU X0, X12 PSRAL $0x1f, X11 PAND X14, X11 PSRLL $0x1f, X12 PSLLDQ $0x04, X12 PSLLL $0x01, X0 PXOR X11, X0 PXOR X12, X0 // Karatsuba pre-computations MOVOU X0, 224(DI) PSHUFD $0x4e, X0, X1 PXOR X0, X1 MOVOU X1, 240(DI) MOVOU X0, X2 MOVOU X1, X3 // Now prepare powers of H and pre-computations for them MOVQ $0x00000007, AX initLoop: MOVOU X2, X11 MOVOU X2, X12 MOVOU X3, X13 PCLMULQDQ $0x00, X0, X11 PCLMULQDQ $0x11, X0, X12 PCLMULQDQ $0x00, X1, X13 PXOR X11, X13 PXOR...