@Override
          protected Scheduler scheduler() {
            return newFixedDelaySchedule(Long.MAX_VALUE, Long.MAX_VALUE, SECONDS);
          }
        };
    service.startAsync().awaitRunning();
    assertThrows(TimeoutException.class, () -> service.firstBarrier.await(5, SECONDS));
    assertEquals(0, service.numIterations.get());
    service.stopAsync();
    service.awaitTerminated();
  }

    }

    val client =
      clientTestRule.newClientBuilder()
        .dns { listOf(InetAddress.getByName("localhost")) }
        .callTimeout(4, SECONDS)
        .writeTimeout(2, SECONDS)
        .readTimeout(2, SECONDS)
        .apply {
          if (socketMode is TlsInstance) {
            if (socketMode.socketMode == Channel) {
              socketFactory(ChannelSocketFactory())
            }

		return FromInt(int64(hours)), nil
	case timePartMinute:
		minutes := duration / time.Minute
		return FromInt(int64(minutes)), nil
	case timePartSecond:
		seconds := duration / time.Second
		return FromInt(int64(seconds)), nil
	default:

	}
	return nil, errNotImplemented

import static com.google.common.util.concurrent.Uninterruptibles.getUninterruptibly;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.fail;

import com.google.common.annotations.GwtCompatible;
import java.util.concurrent.ExecutionException;

            ImmutableSet.of(
                DurationSpec.of(0, SECONDS), DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)))
        .withExpireAfterAccesses(
            ImmutableSet.of(
                DurationSpec.of(0, SECONDS), DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)))
        .withRefreshes(ImmutableSet.of(DurationSpec.of(1, SECONDS), DurationSpec.of(1, DAYS)));
  }

    assertThrows(IllegalArgumentException.class, () -> builder.refreshAfterWrite(0, SECONDS));
  }

  @GwtIncompatible // refreshAfterWrite
  public void testRefresh_setTwice() {
    CacheBuilder<Object, Object> builder =
        CacheBuilder.newBuilder().refreshAfterWrite(3600, SECONDS);
    assertThrows(IllegalStateException.class, () -> builder.refreshAfterWrite(3600, SECONDS));
  }

  public void testTicker_setTwice() {

| `start_time_seconds`          | `gauge`   | Start time for MinIO process in seconds since Unix epoc                                                        | `server` |
| `uptime_seconds`              | `gauge`   | Uptime for MinIO process in seconds                                                                            | `server` |

    CacheBuilderSpec spec = parse("expireAfterWrite=10s");
    assertEquals(TimeUnit.SECONDS, spec.writeExpirationTimeUnit);
    assertEquals(10L, spec.writeExpirationDuration);
    assertCacheBuilderEquivalence(
        CacheBuilder.newBuilder().expireAfterWrite(10L, TimeUnit.SECONDS), CacheBuilder.from(spec));
  }

  public void testParse_writeExpirationRepeated() {
    assertThrows(

    // Now give the get() thread time to finish:
    assertTrue(earlyListener.wasRun.await(1, SECONDS));

    // Now test an additional addListener call, which will be run in-thread:
    RecordingRunnable lateListener = new RecordingRunnable();
    listenable.addListener(lateListener, directExecutor());
    assertTrue(lateListener.wasRun.await(1, SECONDS));
  }

  public void testAdapters_nullChecks() throws Exception {

    runLatch.await();
    taskLatch.countDown();

    ExecutionException e =
        assertThrows(ExecutionException.class, () -> task.get(5, TimeUnit.SECONDS));
    assertEquals(IllegalStateException.class, e.getCause().getClass());

    assertTrue(listenerLatch.await(5, TimeUnit.SECONDS));
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
  }