}

    @Singleton
    @Named(Lifecycle.CLEAN)
    @SuppressWarnings("unused")
    static class CleanLifecycleProvider extends BaseLifecycleProvider {
        CleanLifecycleProvider() {
            super(Lifecycle.CLEAN);
        }
    }

    @Singleton
    @Named(Lifecycle.DEFAULT)
    @SuppressWarnings("unused")
    static class DefaultLifecycleProvider extends BaseLifecycleProvider {

    testComparator(comparator, empty, z, abc);

    // Just demonstrate that no explicit type parameter is required
    Comparator<Optional<String>> unused = emptiesFirst(naturalOrder());
  }

  public void testEmptiesLast() {
    Optional<String> empty = Optional.empty();
    Optional<String> abc = Optional.of("abc");
    Optional<String> z = Optional.of("z");

import okio.ByteString

/**
 * Like a [ByteString], but whose bits are not necessarily a strict multiple of 8.
 */
internal data class BitString(
  val byteString: ByteString,
  /** 0-7 unused bits in the last byte. */
  val unusedBitsCount: Int,
) {
  // Avoid Long.hashCode(long) which isn't available on Android 5.
  override fun hashCode(): Int {
    var result = 0

@State(Scope.Benchmark)
@SuppressWarnings("unused") // invoked by benchmarking framework
public class DateFormatterFromBenchmark {

    private final TemporalAccessor accessor = DateFormatter.forPattern("epoch_millis").parse("1234567890");

    @Benchmark
    public TemporalAccessor benchmarkFrom() {
        // benchmark an accessor that does not contain a timezone
        // this used to throw an exception earlier and thus was very very slow

# Bring in all of the public TensorFlow interface into this
# module.

# pylint: disable=g-bad-import-order
from tensorflow.python import pywrap_tensorflow  # pylint: disable=unused-import

from tensorflow.python.platform import flags  # pylint: disable=g-import-not-at-top
from tensorflow.python.platform import app  # pylint: disable=g-import-not-at-top
app.flags = flags

        String::class.java,
        String::class.java,
      )
    } catch (_: NoSuchMethodException) {
      null
    }

  /** Android method to clean and sort certificates, called via reflection. */
  @Suppress("unused", "UNCHECKED_CAST")
  fun checkServerTrusted(
    chain: Array<out X509Certificate>,
    authType: String,
    host: String,
  ): List<Certificate> {
    if (host in insecureHosts) return listOf()
    try {

applyAutomaticUpgradeOfCapabilities()
dependencies {
    configurations.all {
        exclude("org.slf4j", "slf4j-simple")
    }
    components {
        // Gradle distribution - minify: remove unused transitive dependencies
        applyRule<DependencyRemovalByNameRule>("com.amazonaws:aws-java-sdk-core", setOf("jackson-dataformat-cbor"))

    // stored log records causes a ConcurrentModificationException
    assertTrue(handler.getStoredLogRecords().isEmpty());
    ExampleClassUnderTest.foo();
    ExampleClassUnderTest.foo();
    for (LogRecord unused : handler.getStoredLogRecords()) {
      ExampleClassUnderTest.foo();
    }
  }

  @Override
  public final void runBare() throws Throwable {
    try {
      setUp();
      runTest();
    } finally {

    Object[] prevArray = null;
    for (int i = 0; i < 10; i++) {
      builder.add(i);
      assertNotSame(builder.contents, prevArray);
      prevArray = builder.contents;
      ImmutableSet<Integer> unused = builder.build();
    }
  }

  @GwtIncompatible // Builder impl
  public void testPresizedBuilderDedups() {
    ImmutableSet.Builder<String> builder = ImmutableSet.builderWithExpectedSize(4);

  private static final Supplier<LongAddable> SUPPLIER;

  static {
    Supplier<LongAddable> supplier;
    try {
      // trigger static initialization of the LongAdder class, which may fail
      LongAdder unused = new LongAdder();
      supplier =
          new Supplier<LongAddable>() {
            @Override
            public LongAddable get() {
              return new LongAdder();
            }
          };