return result;
  }

  private static final class ThrowingTearDown implements TearDown {

    private final String id;
    boolean ran = false;

    ThrowingTearDown(String id) {
      this.id = id;
    }

    @Override
    public void tearDown() throws Exception {
      ran = true;
      throw new RuntimeException(id);
    }
  }

    }
  }

  companion object {
    private val WILDCARD_LABEL = ByteString.of('*'.code.toByte())
    private val PREVAILING_RULE = listOf("*")

    private const val EXCEPTION_MARKER = '!'

    private var instance = PublicSuffixDatabase(PublicSuffixList.Default)

    fun get(): PublicSuffixDatabase = instance

    private fun ByteString.binarySearch(
      labels: Array<ByteString>,

   * @since 15.0
   */
  public static final class Builder {
    private final Map<Character, String> replacementMap = new HashMap<>();
    private char safeMin = Character.MIN_VALUE;
    private char safeMax = Character.MAX_VALUE;
    private @Nullable String unsafeReplacement = null;

    // The constructor is exposed via the builder() method above.
    private Builder() {}

    /**

 */
class SmbComTransactionTest {

    @Mock
    private Configuration mockConfig;

    private TestSmbComTransaction transaction;

    // Test implementation of abstract SmbComTransaction
    private static class TestSmbComTransaction extends SmbComTransaction {
        private int setupWireFormatReturn = 0;
        private int parametersWireFormatReturn = 0;
        private int dataWireFormatReturn = 0;

class NetworkExplorerTest {

    private NetworkExplorer networkExplorer;

    @Mock
    private ServletConfig servletConfig;

    @Mock
    private ServletContext servletContext;

    @Mock
    private HttpServletRequest request;

    @Mock
    private HttpServletResponse response;

    @Mock
    private HttpSession session;

    @Mock
    private SmbFile smbFile;

    @Mock

    return new FunctionBasedConverter<>(forwardFunction, backwardFunction);
  }

  private static final class FunctionBasedConverter<A, B> extends Converter<A, B>
      implements Serializable {
    private final Function<? super A, ? extends B> forwardFunction;
    private final Function<? super B, ? extends A> backwardFunction;

    private FunctionBasedConverter(
        Function<? super A, ? extends B> forwardFunction,

     */
    static class TestCreateContextRequest implements CreateContextRequest {
        private byte[] name;
        private byte[] data;
        private int encodedSize;
        private boolean throwOnEncode = false;
        private boolean throwOnSize = false;
        private int sizeCallCount = 0;
        private int encodeCallCount = 0;

        public TestCreateContextRequest(byte[] name) {
            this.name = name;

    }

    /**
     * Gets or creates the cached Maven 4 session.
     */
    private Session getSession() {
        if (session == null) {
            session = createMaven4Session();
        }
        return session;
    }

    /**
     * Creates a new Maven 4 session for effective POM computation.
     */
    private Session createMaven4Session() {
        Session session = ApiRunner.createSession(injector -> {

  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

    WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {

     */
    private int allRecordCount;

    /**
     * The total number of pages available.
     */
    private int allPageCount;

    /**
     * Indicates whether a previous page exists before the current page.
     */
    private boolean existPrePage;

    /**
     * Indicates whether a next page exists after the current page.
     */
    private boolean existNextPage;

    /**