return new String(chars);
  }

  private static byte[] toByteArray(int... bytes) {
    byte[] realBytes = new byte[bytes.length];
    for (int i = 0; i < bytes.length; i++) {
      realBytes[i] = (byte) bytes[i];
    }
    return realBytes;
  }

  private static void assertWellFormed(int... bytes) {
    assertTrue(Utf8.isWellFormed(toByteArray(bytes)));
  }

            readParams.setAccessible(true);
            readParams.invoke(cancel, buffer, 0);

            Method readBytes = SmbComNtCancel.class.getDeclaredMethod("readBytesWireFormat", byte[].class, int.class);
            readBytes.setAccessible(true);
            readBytes.invoke(cancel, buffer, 0);

            // Then - buffer should remain unchanged
            assertArrayEquals(originalBuffer, buffer);

            byte[] arr = new byte[15];
            assertEquals(0, response.readParameterWordsWireFormat(arr, idx));
        }
    }

    @Nested
    @DisplayName("readBytesWireFormat tests")
    class ReadBytes {

        @Test
        @DisplayName("Returns 0 with null array")
        void nullArray() {
            assertEquals(0, response.readBytesWireFormat(null, 0));
        }

        @ParameterizedTest

              readBytesDelivered = readBuffer.read(sink, minOf(byteCount, readBuffer.size))
              readBytes.update(total = readBytesDelivered)

              val unacknowledgedBytesRead = readBytes.unacknowledged
              if (errorExceptionToDeliver == null &&
                unacknowledgedBytesRead >= connection.okHttpSettings.initialWindowSize / 2
              ) {

            }
        }
        try {
            return new String(FileUtil.readBytes(outputFile), outputEncoding);
        } catch (final UnsupportedEncodingException e) {
            return new String(FileUtil.readBytes(outputFile), Constants.UTF_8_CHARSET);
        }
    }

    /**
     * Gets the extractor for the specified file extension.
     *

    withLock {
      readBytes.update(total = read)
      val readBytesToAcknowledge = readBytes.unacknowledged
      if (readBytesToAcknowledge >= okHttpSettings.initialWindowSize / 2) {
        writeWindowUpdateLater(0, readBytesToAcknowledge)
        readBytes.update(acknowledged = readBytesToAcknowledge)
      }
      flowControlListener.receivingConnectionWindowChanged(readBytes)
    }
  }

  /**

	totalLen += len(frag)
	return fullBuffers, frag, totalLen, err
}

// ReadBytes reads until the first occurrence of delim in the input,
// returning a slice containing the data up to and including the delimiter.
// If ReadBytes encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often io.EOF).
// ReadBytes returns err != nil if and only if the returned data does not end in
// delim.

        assertNotNull(readParameterWords);

        Method readBytes = clazz.getDeclaredMethod("readBytesWireFormat", byte[].class, int.class);
        assertNotNull(readBytes);

        Method toString = clazz.getDeclaredMethod("toString");
        assertNotNull(toString);
    }

        final String jspType = "view";
        final File jspFile = getJspFile(form.fileName, jspType);
        try {
            form.content = encodeJsp(new String(FileUtil.readBytes(jspFile), Constants.UTF_8));
        } catch (final UnsupportedEncodingException e) {
            throw new FessSystemException("Invalid encoding", e);
        }
        saveToken();
        return asEditHtml(form);

          @Override
          public byte[] getResult() {
            return out.toByteArray();
          }
        };

    File asciiFile = getTestFile("ascii.txt");
    byte[] result = Files.readBytes(asciiFile, processor);
    assertEquals(Bytes.asList(Files.toByteArray(asciiFile)), Bytes.asList(result));
  }

  public void testReadBytes_returnFalse() throws IOException {
    ByteProcessor<byte[]> processor =