// license that can be found in the LICENSE file.

// Addr2line is a minimal simulation of the GNU addr2line tool,
// just enough to support pprof.
//
// Usage:
//
//	go tool addr2line binary
//
// Addr2line reads hexadecimal addresses, one per line and with optional 0x prefix,
// from standard input. For each input address, addr2line prints two output lines,
// first the name of the function containing the address and second the file:line

  /**
   * Opens a new {@link Stream} for reading text one line at a time from this source. This method
   * returns a new, independent stream each time it is called.
   *
   * <p>The returned stream is lazy and only reads from the source in the terminal operation. If an
   * I/O error occurs while the stream is reading from the source or when the stream is closed, an
   * {@link UncheckedIOException} is thrown.
   *

    @MethodSource("int32Provider")
    @DisplayName("readParameterWordsWireFormat correctly decodes 32-bit offset")
    void testReadParameterWords(int expectedInt, byte[] bytes) {
        // The implementation reads via SMBUtil.readInt4 which returns an int
        // When assigned to a long field, it gets sign-extended
        int readLen = response.readParameterWordsWireFormat(bytes, 0);

        return tmp[0] & 0xFF;
    }

    /**
     * Reads up to b.length 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) throws IOException {
        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.

        try {
            return channel.size();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Reads the contents of the file channel into a byte buffer.
     *
     * @param channel
     *            The file channel. Must not be {@literal null}.
     * @param buffer

// Reader - JSON record reader for S3Select.
type Reader struct {
	args       *ReaderArgs
	decoder    *jstream.Decoder
	valueCh    chan *jstream.MetaValue
	readCloser io.ReadCloser
}

// Read - reads single record.
func (r *Reader) Read(dst sql.Record) (sql.Record, error) {
	v, ok := <-r.valueCh
	if !ok {
		if err := r.decoder.Err(); err != nil {
			return nil, errJSONParsingError(err)
		}
		return nil, io.EOF

     */
    @Test
    void testReadParameterWordsWireFormat() {
        byte[] buffer = new byte[10];
        int bufferIndex = 0;
        // The method should return 0 as it reads no parameter words
        int result = smbComNegotiate.readParameterWordsWireFormat(buffer, bufferIndex);
        assertEquals(0, result, "readParameterWordsWireFormat should return 0.");
    }

    /**

    /**
     * Reads setup data from wire format
     * @param buffer source buffer
     * @param bufferIndex starting index in source buffer
     * @param len length of data to read
     * @return number of bytes read
     */
    protected abstract int readSetupWireFormat(byte[] buffer, int bufferIndex, int len);

    /**
     * Reads parameters from wire format

 * under the License.
 */
package org.apache.maven.api.services.xml;

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.model.Model;

/**
 * Reads or writes a {@link Model} using XML.
 *
 * @since 4.0.0
 */
@Experimental

        SMBUtil.writeInt2(bytesPerSect, buffer, offset);
        offset += 2;

        // Decode
        int bytesDecoded = smbInfoAllocation.decode(buffer, 0, buffer.length);

        // Verify - actual implementation reads 20 bytes (4 + 4 + 4 + 4 + 4)
        // bytesPerSect is read as Int2 but advances by 4 bytes (padding)
        assertEquals(20, bytesDecoded);

        // Verify capacity calculation: alloc * sectPerAlloc * bytesPerSect