int offset = 0;
        int size = 3;

        // Simulate successful verification
        when(mockResponse.verifySignature(buffer, offset, size)).thenReturn(true);
        assertTrue(mockResponse.verifySignature(buffer, offset, size));

        // Simulate failed verification
        when(mockResponse.verifySignature(buffer, offset, size)).thenReturn(false);

	if lastAddr, ok := p.dataAddr[name]; ok && nameAddr.Offset < lastAddr {
		p.errorf("overlapping DATA entry for %s", name)
		return
	}
	p.dataAddr[name] = nameAddr.Offset + int64(sz)

	switch valueAddr.Type {
	case obj.TYPE_CONST:
		switch sz {
		case 1, 2, 4, 8:
			nameAddr.Sym.WriteInt(p.ctxt, nameAddr.Offset, sz, valueAddr.Offset)
		default:
			p.errorf("bad int size for DATA argument: %d", sz)

    @Test
    @DisplayName("Test encode with offset")
    void testEncodeWithOffset() {
        ValidateNegotiateInfoRequest request =
                new ValidateNegotiateInfoRequest(DEFAULT_CAPABILITIES, defaultClientGuid, DEFAULT_SECURITY_MODE, defaultDialects);

        int offset = 100;
        byte[] buffer = new byte[offset + request.size()];
        int encodedLength = request.encode(buffer, offset);

        // Verify encoded length

            int offset = 128;
            Smb2ReadRequest requestWithBuffer = new Smb2ReadRequest(mockConfig, testFileId, specificBuffer, offset);

            Smb2ReadResponse response = requestWithBuffer.createResponse(mockContext, requestWithBuffer);
            assertNotNull(response);
            // Response should be created with same buffer and offset
        }
    }

    @Nested

        assertArrayEquals(new byte[] { 0x02, 0x03, 0x04, 0x00, 0x00 }, dest, "Encoded bytes should match the expected subset");
    }

    @Test
    void testEncodeWithOffset() {
        // Test encoding with a destination offset
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 0, 3);
        byte[] dest = new byte[5]; // {0,0,0,0,0}

     * Verifies that the method returns the correct time zone offset.
     * @throws CIFSException
     */
    @Test
    void testGetServerTimeZoneOffset() throws CIFSException {
        when(smbTreeHandle.getServerTimeZoneOffset()).thenReturn(0L);
        assertEquals(0L, smbTreeHandle.getServerTimeZoneOffset(), "Server time zone offset should be 0");
        when(smbTreeHandle.getServerTimeZoneOffset()).thenReturn(3600000L);

			let offset = 4096;

			const strPtr = (str) => {
				const ptr = offset;
				const bytes = encoder.encode(str + "\0");
				new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
				offset += bytes.length;
				if (offset % 8 !== 0) {
					offset += 8 - (offset % 8);
				}
				return ptr;
			};

			const argc = this.argv.length;

			p.get(',')
		}
	}
	a.Type = obj.TYPE_REGLIST
	switch p.arch.Family {
	case sys.ARM:
		a.Offset = int64(bits)
	case sys.ARM64:
		offset, err := arch.ARM64RegisterListOffset(firstReg, regCnt, arrangement)
		if err != nil {
			p.errorf("%v", err)
		}
		a.Offset = offset
	default:
		p.errorf("register list not supported on this architecture")
	}
}

    delegateList.forEach(action);
  }

  @GwtIncompatible // not present in emulated superclass
  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    return delegateList.copyIntoArray(dst, offset);
  }

  @Override
  Object @Nullable [] internalArray() {
    return delegateList.internalArray();
  }

  @Override
  int internalArrayStart() {

    @DisplayName("Should handle hexdump with offset")
    void testHexdumpWithOffset() {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(baos);

        // Create test data and dump from offset
        byte[] data = createTestData(64);
        int offset = 16;
        int length = 32;

        Hexdump.hexdump(ps, data, offset, length);