return false, fmt.Errorf("RUnlock attempted on a write locked entity: %s", args.Resources[0])
	}
	if locksHeld > ReadLock {
		l.lockMap[args.Resources[0]] = locksHeld - ReadLock // Remove one of the read locks held
	} else {
		delete(l.lockMap, args.Resources[0]) // Remove the (last) read lock
	}
	return reply, nil
}

        // Test with zero
        buffer.putInt(0, 0);
        assertEquals(0, NtlmMessage.readULong(data, 0), "Should read zero ULong correctly.");

        // Test with max int value (unsigned interpretation)
        buffer.putInt(0, 0xFFFFFFFF);
        assertEquals(0xFFFFFFFF, NtlmMessage.readULong(data, 0), "Should read max ULong correctly.");

        trans2QueryPathInfo = new Trans2QueryPathInformation(config, TEST_FILENAME, TEST_INFO_LEVEL);

        byte[] buffer = new byte[256];
        int read = trans2QueryPathInfo.readSetupWireFormat(buffer, 0, buffer.length);

        // Should read nothing (returns 0)
        assertEquals(0, read);
    }

    @Test
    void testReadParametersWireFormat() {

    /**
     * Lock and read operation is supported capability.
     */
    int CAP_LOCK_AND_READ = 0x0100;
    /**
     * NT find operations are supported capability.
     */
    int CAP_NT_FIND = 0x0200;
    /**
     * DFS operations are supported capability.
     */
    int CAP_DFS = 0x1000;
    /**
     * Large read operations are supported capability.
     */

        NameServicePacket.writeInt2(2, src, 6);
        NameServicePacket.writeInt2(3, src, 8);
        NameServicePacket.writeInt2(4, src, 10);

        int read = packet.readHeaderWireFormat(src, 0);
        assertEquals(NameServicePacket.HEADER_LENGTH, read);

        assertEquals(0x1234, packet.nameTrnId);
        assertTrue(packet.isResponse);
        assertEquals(NameServicePacket.QUERY, packet.opCode);

) {
  private val countingSource: CountingSource = CountingSource(source)
  private val source: BufferedSource = countingSource.buffer()

  /** Total bytes read thus far. */
  private val byteCount: Long
    get() = countingSource.bytesRead - source.buffer.size

  /** How many bytes to read before [peekHeader] should return false, or -1L for no limit. */
  private var limit = -1L

	dst   chan []jstream.KVS // result of block decode
	err   error              // any error encountered will be set here
}

// Read - reads single record.
// Once Read is called the previous record should no longer be referenced.
func (r *PReader) Read(dst sql.Record) (sql.Record, error) {
	// If we have have any records left, return these before any error.
	for len(r.current) <= r.recordsRead {
		if r.err != nil {

        final int ftag = in.read();
        final int tag = readTagNumber(in, ftag);
        if (tag != expectTag) {
            throw new IOException("Unexpected tag " + tag);
        }
        final int length = readLength(in, limit, false);
        final byte[] content = new byte[length];
        in.read(content);
        return content;
    }

        }
    }

    /**
     * Returns an InputStream to read the content from the cache.
     * If the content is stored in a file, a FileInputStream is returned.
     * Otherwise, a ByteArrayInputStream is returned to read the data from memory.
     *
     * @return an InputStream to read the cached content
     * @throws IOException if an I/O error occurs while creating the InputStream
     */

    ByteStreams.skipFully(multi, 20);
    assertEquals(20, multi.read());
  }

  public void testReadSingle_noStackOverflow() throws IOException {
    // https://github.com/google/guava/issues/2996
    // no data, just testing that there's no StackOverflowException
    assertEquals(-1, tenMillionEmptySources().read());
  }

  public void testReadArray_noStackOverflow() throws IOException {