//                                                                             =======
    @Override
    public AccessTokenDbm asDBMeta() {
        return AccessTokenDbm.getInstance();
    }

    @Override
    public String asTableDbName() {
        return "access_token";
    }

    return result;
  }

  @SuppressWarnings("rawtypes") // class literals
  @Override
  protected List<Class<? extends AbstractTester>> getTesters() {
    List<Class<? extends AbstractTester>> testers = copyToList(super.getTesters());
    testers.add(SortedMapNavigationTester.class);
    return testers;
  }

  @Override
  public TestSuite createTestSuite() {
    if (!getFeatures().contains(KNOWN_ORDER)) {

import okio.FileSystem
import okio.Path
import okio.Path.Companion.toPath
import okio.Source

internal class ResourcePublicSuffixList(
  override val path: Path = PUBLIC_SUFFIX_RESOURCE,
  val fileSystem: FileSystem = FileSystem.Companion.RESOURCES,
) : BasePublicSuffixList() {
  override fun listSource(): Source = fileSystem.source(path)

  companion object {
    @JvmField
    val PUBLIC_SUFFIX_RESOURCE =

     */
    @Override
    public final int getTid() {
        return getTreeId();
    }

    @Override
    public boolean isValidTid() {
        return getTreeId() != -1;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.TreeConnectResponse#getService()
     */
    @Override
    public String getService() {
        return null;

              if (parameters != null) {
                clientEventsList.add(parameters.first().toString())
              }
            }
          }
        }
      }

      override fun flush() {
      }

      override fun close() {
      }
    }.apply {
      level = Level.FINEST
    }

  private fun applyLogger(fn: Logger.() -> Unit) {

    @Override
    protected Future<V> delegate() {
      return delegate;
    }

    void set(V value) {
      delegate.set(value);
    }
  }

  private static final class RuntimeExceptionThrowingFuture<V> implements Future<V> {
    final CountDownLatch allowGetToComplete = new CountDownLatch(1);

    @Override

    private BigDecimalToDoubleRounder() {}

    @Override
    double roundToDoubleArbitrarily(BigDecimal bigDecimal) {
      return bigDecimal.doubleValue();
    }

    @Override
    int sign(BigDecimal bigDecimal) {
      return bigDecimal.signum();
    }

    @Override
    BigDecimal toX(double d, RoundingMode mode) {
      return new BigDecimal(d);
    }

    @Override
    BigDecimal minus(BigDecimal a, BigDecimal b) {

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override
    public int size() {
        return 20 + 2 * this.fileName.length();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.fscc.FileInformation#getFileInformationLevel()
     */
    @Override
    public byte getFileInformationLevel() {
        return FileInformation.FILE_RENAME_INFO;
    }

    }

    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#hasNext()
     */
    @Override
    public boolean hasNext() {
        return this.next != null;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#next()
     */
    @Override
    public SmbResource next() {
        final SmbResource n = this.next;
        this.next = advance();

      object : BaseTestHandler() {
        override fun priority(
          streamId: Int,
          streamDependency: Int,
          weight: Int,
          exclusive: Boolean,
        ) {
          assertThat(streamDependency).isEqualTo(0)
          assertThat(weight).isEqualTo(256)
          assertThat(exclusive).isFalse()
        }

        override fun headers(
          inFinished: Boolean,