*/
    private long determinePollInterval(ChangeNotificationHandle handle) {
        int failures = getFailureCount(handle);

        // Base interval starts at 1 second, increases with failures
        // Max interval is 30 seconds for inactive directories
        return Math.min(MAX_POLL_INTERVAL, BASE_POLL_INTERVAL + (failures * 2000));
    }

    /**
     * Get failure count for a handle
     *

        while (e != null) {
          println(e)
          e = e.cause
        }
      }
    }
    println()
  }
  time = System.currentTimeMillis() - time
  println("Time: ${time.toDouble() / 1000} seconds\n")
}

fun main() {
  Security.insertProviderAt(OpenSSLProvider(), 1)
  var bootstrapClient = OkHttpClient()
  var names = listOf("google.com", "graph.facebook.com", "sdflkhfsdlkjdf.ee")
  try {

        Map<String, Object> stats = resourceManager.getStatistics();
        assertNotNull(stats);
    }

    @Test
    @DisplayName("Test force cleanup")
    @Timeout(value = 5, unit = TimeUnit.SECONDS)
    void testForceCleanup() {
        TestResource resource1 = new TestResource("cleanup1");
        TestResource resource2 = new TestResource("cleanup2");

        resourceManager.registerResource(resource1);

                    }
                } finally {
                    latch.countDown();
                }
            });
        }

        // Then
        assertTrue(latch.await(10, TimeUnit.SECONDS), "All threads should complete");
        executor.shutdown();
        assertEquals(0, collisions.get(), "There should be no nonce collisions");

    @Keep public static final WithPublicConstants SECOND = new WithPublicConstants();
  }

  private static class FirstConstantIsNull {
    // To test that null constant is ignored
    @Keep public static final @Nullable FirstConstantIsNull FIRST = null;

    @Keep public static final FirstConstantIsNull SECOND = new FirstConstantIsNull();
  }

  public static class NonFinalFieldIgnored {

    //      last modified: 105 seconds ago
    //             served:   5 seconds ago
    //   default lifetime: (105 - 5) / 10 = 10 seconds
    //            expires:  10 seconds from served date = 5 seconds from now
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Last-Modified: " + formatDate(-105, TimeUnit.SECONDS))
        .addHeader("Date: " + formatDate(-5, TimeUnit.SECONDS))

    assertFailsWith<SocketTimeoutException> {
      call.execute()
    }
    val elapsedNanos = System.nanoTime() - startNanos
    org.junit.jupiter.api.Assertions.assertTrue(
      elapsedNanos < TimeUnit.SECONDS.toNanos(5),
      "Timeout should have taken ~100ms but was " + elapsedNanos / 1e6 + " ms",
    )
  }

  @Test
  fun chainWithReadTimeout() {
    val interceptor1 =

                        endLatch.countDown();
                    }
                }
            });
        }

        startLatch.countDown();
        endLatch.await(10, TimeUnit.SECONDS);
        executor.shutdown();

        assertEquals(0, errorCount.get());
        assertEquals("concurrentName", testTransformer.getName());
    }

    /**
     * Test concurrent name changes
     */

      // If any partial is omitted or out of range, return -1. The date is impossible. Note that leap
      // seconds are not supported by this syntax.
      require(year >= 1601)
      require(month != -1)
      require(dayOfMonth in 1..31)
      require(hour in 0..23)
      require(minute in 0..59)
      require(second in 0..59)

      GregorianCalendar(UTC).apply {
        isLenient = false
        set(Calendar.YEAR, year)

                    }
                });
            }

            startLatch.countDown(); // Start all threads
            boolean completed = endLatch.await(10, TimeUnit.SECONDS);
            executor.shutdown();

            assertTrue(completed, "All threads should complete without deadlock");