* @param isDirect whether to use direct transmission
     * @throws IOException if an I/O error occurs
     */
    protected abstract void doSendFragment(byte[] buf, int off, int length, boolean isDirect) throws IOException;

    /**
     * Receives a DCERPC fragment from the remote endpoint
     * @param buf the buffer to receive the fragment
     * @param isDirect whether to use direct reception

            out = (SmbFileOutputStream) pipe.getNamedPipeOutputStream();
        }
        if (isDirect) {
            out.writeDirect(buf, off, length, 1);
            return;
        }
        out.write(buf, off, length);
    }

    @Override
    protected void doReceiveFragment(final byte[] buf, final boolean isDirect) throws IOException {
        int off, flags, length;

        if (buf.length < max_recv) {

        // In real implementation, this would get the native memory address:
        // For direct ByteBuffers, this could be obtained through unsafe operations
        // or DiSNI-specific methods

        if (buffer.isDirect()) {
            // Assign a unique address to each buffer instance
            return bufferAddresses.computeIfAbsent(buffer, b -> addressCounter.getAndIncrement());
        } else {

        assertNotNull(buffer, "Buffer should not be null");
        assertTrue(buffer.capacity() >= 2048, "Buffer should be at least requested size");
        assertTrue(buffer.isDirect(), "Buffer should be direct");
    }

    @Test
    public void testReleaseBuffer() {
        ByteBuffer buffer = bufferManager.allocateBuffer(1024);

        // Release should not throw exception

            off += fragSize;
        }
        throw new IOException();
    }

    /**
     * @param msg
     * @param in
     * @param off
     * @param isDirect
     * @return
     * @throws IOException
     * @throws DcerpcException
     * @throws NdrException
     */

	github.com/rivo/uniseg v0.4.7 // indirect
	github.com/rjeczalik/notify v0.9.3 // indirect
	github.com/rs/xid v1.6.0 // indirect
	github.com/safchain/ethtool v0.5.10 // indirect
	github.com/segmentio/asm v1.2.0 // indirect
	github.com/shoenig/go-m1cpu v0.1.6 // indirect
	github.com/spiffe/go-spiffe/v2 v2.5.0 // indirect
	github.com/tidwall/gjson v1.18.0 // indirect
	github.com/tidwall/match v1.1.1 // indirect

	github.com/jackc/pgx/v5 v5.7.5 // indirect
	github.com/jackc/puddle/v2 v2.2.2 // indirect
	github.com/jinzhu/inflection v1.0.0 // indirect
	github.com/mattn/go-sqlite3 v1.14.32 // indirect
	github.com/microsoft/go-mssqldb v1.9.3 // indirect
	github.com/pmezard/go-difflib v1.0.0 // indirect
	github.com/tjfoc/gmsm v1.4.1 // indirect
	golang.org/x/crypto v0.41.0 // indirect
	golang.org/x/sync v0.16.0 // indirect

		field.ValueOf = func(ctx context.Context, v reflect.Value) (interface{}, bool) {
			v = reflect.Indirect(v)
			fieldValue := v.Field(fieldIndex)
			return fieldValue.Interface(), fieldValue.IsZero()
		}
	default:
		field.ValueOf = func(ctx context.Context, v reflect.Value) (interface{}, bool) {
			v = reflect.Indirect(v)
			for _, fieldIdx := range field.StructField.Index {
				if fieldIdx >= 0 {
					v = v.Field(fieldIdx)

        assertTrue(pacCredentialType.isCredentialTypeCorrect());
    }

    /**
     * Tests the isCredentialTypeCorrect method with a null byte array.
     * This test is indirect as the constructor would throw an exception.
     * We can't instantiate the class with null, so we can't directly test this method's behavior with null.
     * However, the constructor logic `!isCredentialTypeCorrect()` covers this.

func (db *DB) Save(value interface{}) (tx *DB) {
	tx = db.getInstance()
	tx.Statement.Dest = value

	reflectValue := reflect.Indirect(reflect.ValueOf(value))
	for reflectValue.Kind() == reflect.Ptr || reflectValue.Kind() == reflect.Interface {
		reflectValue = reflect.Indirect(reflectValue)
	}

	switch reflectValue.Kind() {
	case reflect.Slice, reflect.Array:
		if _, ok := tx.Statement.Clauses["ON CONFLICT"]; !ok {