import java.io.IOException
import okhttp3.internal.platform.PlatformRegistry
import okio.Source
import okio.source

internal class AssetPublicSuffixList(
  override val path: String = PUBLIC_SUFFIX_RESOURCE,
) : BasePublicSuffixList() {
  override fun listSource(): Source {
    val assets = PlatformRegistry.applicationContext?.assets

    if (assets == null) {
      if (Build.FINGERPRINT == null) {

    return new OpenJdk6QueueTests().allTests();
  }

  private static final List<Method> PQ_SUPPRESS = asList(getCreateWithNullUnsupportedMethod());

  @Override
  protected Collection<Method> suppressForPriorityBlockingQueue() {
    return PQ_SUPPRESS;
  }

  @Override
  protected Collection<Method> suppressForPriorityQueue() {
    return PQ_SUPPRESS;
  }

  public TablesTransformValuesColumnMapTest() {
    super(false, true, true, false);
  }

  @Override
  Table<Integer, String, Character> makeTable() {
    Table<Integer, String, String> original = HashBasedTable.create();
    return transformValues(original, FIRST_CHARACTER);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {

  public TablesTransformValuesRowMapTest() {
    super(false, true, true, true);
  }

  @Override
  Table<String, Integer, Character> makeTable() {
    Table<String, Integer, String> original = HashBasedTable.create();
    return transformValues(original, TableCollectionTest.FIRST_CHARACTER);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {

  public UnmodifiableRowSortedTableColumnTest() {
    super(false, false, false, false, false);
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    RowSortedTable<String, Character, Integer> table = TreeBasedTable.create();
    return unmodifiableRowSortedTable(table);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {

  public UnmodifiableTableColumnTest() {
    super(false, false, false, false, false);
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    Table<String, Character, Integer> table = HashBasedTable.create();
    return unmodifiableTable(table);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<String, Character, Integer> table = HashBasedTable.create();

  public TablesTransformValuesRowTest() {
    super(false, false, true, true, true);
  }

  @Override
  Table<Character, String, Integer> makeTable() {
    Table<Character, String, Integer> table = HashBasedTable.create();
    return transformValues(table, TableCollectionTest.DIVIDE_BY_2);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {

  private final Runnable monitoredRunnable =
      new Runnable() {
        @Override
        public void run() {
          completed = true;
        }
      };

  private static final UncaughtExceptionHandler UNCAUGHT_EXCEPTION_HANDLER =
      new UncaughtExceptionHandler() {
        @Override
        public void uncaughtException(Thread t, Throwable e) {
          // No-op
        }
      };

      else -> Log.DEBUG
    }

object AndroidLogHandler : Handler() {
  override fun publish(record: LogRecord) {
    androidLog(record.loggerName, record.androidLevel, record.message, record.thrown)
  }

  override fun flush() {
  }

  override fun close() {
  }
}

@SuppressSignatureCheck
object AndroidLog {
  private const val MAX_LOG_LENGTH = 4000

  }

  ListenableFutureTask(Runnable runnable, @ParametricNullness V result) {
    super(runnable, result);
  }

  @Override
  public void addListener(Runnable listener, Executor exec) {
    executionList.add(listener, exec);
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit)
      throws TimeoutException, InterruptedException, ExecutionException {