// Assert
        assertEquals(0, result);
    }

    @Test
    @DisplayName("toString should return formatted string with pipe name")
    void testToString() {
        // Arrange
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, testPipeName);

        // Act
        String result = transWaitNamedPipe.toString();

        // Assert
        assertNotNull(result);

        assertThat(args.length, is(1));
        assertThat(args[0].getRawClass(), is(sameClass(String.class)));
        assertThat(args[0].getArguments(), is(nullValue()));
    }

    /**
     * @author koichik
     */
    public interface Hoge {

        /** */
        public static Map<String, Set<Integer>[]> foo = null;

        /**
         * @param arg1
         * @param arg2

    return configureSocket(sslSocket)
  }

  override fun getDefaultCipherSuites(): Array<String> = delegate.defaultCipherSuites

  override fun getSupportedCipherSuites(): Array<String> = delegate.supportedCipherSuites

  @Throws(IOException::class)
  override fun createSocket(
    socket: Socket,
    host: String,
    port: Int,
    autoClose: Boolean,
  ): SSLSocket {

        String result = (String) readStringMethod.invoke(response, buffer, 10, 128, false);

        assertEquals(testString, result);
    }

    @Test
    @DisplayName("Test readString with null terminator in middle")
    void testReadStringWithNullTerminator() throws Exception {
        byte[] buffer = new byte[128];
        String testString = "Test";

class NetServerEnum2Response extends SmbComTransactionResponse {

    class ServerInfo1 implements FileEntry {
        String name;
        int versionMajor;
        int versionMinor;
        int type;
        String commentOrMasterBrowser;

        @Override
        public String getName() {
            return name;
        }

        @Override
        public int getType() {

            return (T) BooleanConversionUtil.toBoolean(arg);
        } else if (arg != null && arg.getClass() != String.class && String.class == propertyType) {
            return (T) arg.toString();
        } else if (arg instanceof String && !String.class.equals(propertyType)) {
            return (T) convertWithString(arg);
        } else if (java.util.Calendar.class.isAssignableFrom(propertyType)) {

     *
     * @param path the file path to encode
     * @return the Base64 encoded path
     */
    protected String encodePath(final String path) {
        return Base64.getUrlEncoder().encodeToString(path.getBytes(Constants.CHARSET_UTF_8));
    }

    /**
     * Checks if the given path matches this creator's pattern.
     *
     * @param path the file path to check

    }

    /**
     * Returns method parameters from method signature, e.g. "(Ljava/lang/String;I)V" -> "(Ljava/lang/String;I)"
     */
    private static String methodParametersFromSignature(CtMethod method) {
        return method.signature.substring(0, method.signature.indexOf(")") + 1)
    }

  }

  public void testRecursiveComputation() throws InterruptedException {
    AtomicReference<LoadingCache<Integer, String>> cacheRef = new AtomicReference<>();
    CacheLoader<Integer, String> recursiveLoader =
        new CacheLoader<Integer, String>() {
          @Override
          public String load(Integer key) {
            if (key > 0) {
              return key + ", " + cacheRef.get().getUnchecked(key - 1);

  }

  public void testRecursiveComputation() throws InterruptedException {
    AtomicReference<LoadingCache<Integer, String>> cacheRef = new AtomicReference<>();
    CacheLoader<Integer, String> recursiveLoader =
        new CacheLoader<Integer, String>() {
          @Override
          public String load(Integer key) {
            if (key > 0) {
              return key + ", " + cacheRef.get().getUnchecked(key - 1);