int CAP_LEVEL_II_OPLOCKS = 0x0080;
    /** Lock and read capability */
    int CAP_LOCK_AND_READ = 0x0100;
    /** NT find capability */
    int CAP_NT_FIND = 0x0200;
    /** DFS capability */
    int CAP_DFS = 0x1000;
    /** Extended security capability */
    int CAP_EXTENDED_SECURITY = 0x80000000;

    // file attribute encoding
    /** Read-only file attribute */
    int ATTR_READONLY = 0x01;

	}
}

// process sends error logs to the heal channel for an attempt to heal replication.
func (p *ReplicationPool) queueMRFHeal() error {
	p.mrfMU.Lock()
	defer p.mrfMU.Unlock()

	if !p.initialized() {
		return errServerNotInitialized
	}

	mrfRec, err := p.loadMRF()
	if err != nil {
		return err
	}

	// queue replication heal in a goroutine to avoid holding up mrf save routine

    assertThat(inputStream.read()).isEqualTo('A'.code)
    assertThat(inputStream.read()).isEqualTo('B'.code)
    assertThat(inputStream.read()).isEqualTo('C'.code)
    assertThat(inputStream.read()).isEqualTo('D'.code)
    assertThat(inputStream.read()).isEqualTo('E'.code)
    assertThat(inputStream.read()).isEqualTo('F'.code)
    assertThat(inputStream.read()).isEqualTo(-1)

    Reader reader = new StringReader(testString);

    assertEquals(testString.charAt(0), reader.read());
    CharStreams.skipFully(reader, 1);
    assertEquals(testString.charAt(2), reader.read());
    CharStreams.skipFully(reader, 2);
    assertEquals(testString.charAt(5), reader.read());

    assertEquals(-1, reader.read());
  }

  public void testAsWriter() {
    // Should wrap Appendable in a new object

    Reader reader = new StringReader(testString);

    assertEquals(testString.charAt(0), reader.read());
    CharStreams.skipFully(reader, 1);
    assertEquals(testString.charAt(2), reader.read());
    CharStreams.skipFully(reader, 2);
    assertEquals(testString.charAt(5), reader.read());

    assertEquals(-1, reader.read());
  }

  public void testAsWriter() {
    // Should wrap Appendable in a new object

            byte[] expectedFileId = createTestData(16);
            System.arraycopy(expectedFileId, 0, buffer, bufferIndex, 16);

            // Read the buffer
            int bytesRead = notification.readBytesWireFormat(buffer, 0);

            // Verify the bytes read
            assertEquals(24, bytesRead);

            // Verify the fields were set correctly using reflection

        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test", "*.*", 0x16, 10, 1024);

        byte[] buffer = new byte[100];
        int read = trans2FindFirst2.readSetupWireFormat(buffer, 0, 100);

        assertEquals(0, read);
    }

    @Test
    @DisplayName("Test readParametersWireFormat returns 0")
    void testReadParametersWireFormat() {

    val derReader = DerReader(buffer)

    derReader.read("test") { header ->
      assertThat(header.tag).isEqualTo(16L)

      derReader.read("test") { header2 ->
        assertThat(header2.tag).isEqualTo(21L)
        assertThat(derReader.readOctetString()).isEqualTo("Smith".encodeUtf8())
      }

      derReader.read("test") { header3 ->
        assertThat(header3.tag).isEqualTo(1L)

     */

    @Override
    public int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.
     *
     * @throws IOException if a network error occurs
     */

    @Override
    public int read(final byte[] b, final int off, final int len) throws IOException {

// reads in Scanner.Scan.
type slowReader struct {
	max int
	buf io.Reader
}

func (sr *slowReader) Read(p []byte) (n int, err error) {
	if len(p) > sr.max {
		p = p[0:sr.max]
	}
	return sr.buf.Read(p)
}

// genLine writes to buf a predictable but non-trivial line of text of length
// n, including the terminal newline and an occasional carriage return.