String query = "*";
        int allRecordCount = 1000;
        int pageSize = 100;
        int offset = 50;
        try (RankFusionProcessor rankFusionProcessor = new RankFusionProcessor()) {
            rankFusionProcessor.setSeacher(new TestMainSearcher(allRecordCount));
            rankFusionProcessor.register(new TestSubSearcher(0, 0, 1000));
            rankFusionProcessor.init();

		{"06 k=v\n", "06 k=v\n", "", "", false},
		{"00006 k=v\n", "00006 k=v\n", "", "", false},
		{"000006 k=v\n", "000006 k=v\n", "", "", false},
		{"000000 k=v\n", "000000 k=v\n", "", "", false},
		{"0 k=v\n", "0 k=v\n", "", "", false},
		{"+0000005 x=\n", "+0000005 x=\n", "", "", false},
	}

	for _, v := range vectors {
		key, val, res, err := parsePAXRecord(v.in)

        validator.validateArrayAllocation(100, 10, 1000);
        validator.validateArrayAllocation(0, 10, 1000); // Zero size should be allowed
    }

    @Test
    public void testArrayAllocationNegativeSize() throws Exception {
        assertThrows(SmbException.class, () -> {
            validator.validateArrayAllocation(-1, 10, 1000);
        });
    }

    @Test

		uint32_t rid;
		uint32_t sid_index;
	} LsarTranslatedSid;

	typedef struct {
		[range(0,1000)] uint32_t count;
		[size_is(count)] LsarTranslatedSid *sids;
	} LsarTransSidArray;

	typedef struct {
		unicode_string name;
		sid_t *sid;
	} LsarTrustInformation;

	typedef struct {
		[range(0,1000)] uint32_t count;
		[size_is(count)] LsarTrustInformation *domains;
		uint32_t max_count;
	} LsarRefDomainList;

		uint32_t rid;
		uint32_t sid_index;
	} LsarTranslatedSid;

	typedef struct {
		[range(0,1000)] uint32_t count;
		[size_is(count)] LsarTranslatedSid *sids;
	} LsarTransSidArray;

	typedef struct {
		unicode_string name;
		sid_t *sid;
	} LsarTrustInformation;

	typedef struct {
		[range(0,1000)] uint32_t count;
		[size_is(count)] LsarTrustInformation *domains;
		uint32_t max_count;
	} LsarRefDomainList;

        message.setFlag(0b0001, false);
        assertEquals(0b0100, message.getFlags(), "Flag 0b0001 should be cleared.");

        message.setFlag(0b0100, false);
        assertEquals(0, message.getFlags(), "Flag 0b0100 should be cleared.");

        // Test setting a flag that is already set
        message.setFlags(0b1000);
        message.setFlag(0b1000, true);

    assertThat(ImmutableDoubleArray.of(0, 1).asList()).containsExactly(0.0, 1.0).inOrder();
  }

  public void testOf3() {
    assertThat(ImmutableDoubleArray.of(0, 1, 3).asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
  }

  public void testOf4() {
    assertThat(ImmutableDoubleArray.of(0, 1, 3, 6).asList())
        .containsExactly(0.0, 1.0, 3.0, 6.0)
        .inOrder();
  }

  public void testOf5() {

00000d0 00 eb ff 42 88 21 c4 00 00 14 00 eb ff 42 88 21
00000e0 c4 00 00 00 00 ff ff 00 00 00 ff ff 00 34 00 cb
00000f0 ff 42 88 21 c4 00 00 00 00 ff ff 00 00 00 ff ff
0000100 00 34 00 cb ff 42 e8 21 5e 0f 00 00 00 ff ff 0a
0000110 f0 66 64 12 61 c0 15 dc e8 a0 48 bf 48 af 2a b3
0000120 20 c0 9b 95 0d c4 67 04 42 53 06 06 06 40 00 06
0000130 00 f9 ff 6d 01 00 00 00 00 42 e8 21 5e 0f 00 00

    font-size: 10pt;
    color: #000000;
    text-decoration: none
}
a.plain {
    display: inline;
    float: none;
    width: auto;
    height: auto
}
a.sort {
    display: block;
    float: left;
    width: 100px;
    height: 15px;
    font-family: Verdana, sans-serif;
    font-size: 8pt;
    font-weight: bold;
    text-decoration: none;
    color: #000000;
    background-color: #d0d0d0;

    val addressF = decodeIpv6("0:0:0:0:0:ffff:7f00:1")!!
    assertThat(canonicalizeInetAddress(addressF)).isEqualTo(addressB)

    val addressG = decodeIpv6("0:0:0:0:0:ffff:c0a8:1")!!
    assertThat(canonicalizeInetAddress(addressG)).isEqualTo(addressC)
  }

  @Test
  fun canonicalizeInetAddressMapped() {
    val addressAIpv6 = decodeIpv6("0:0:0:0:0:ffff:7f00:1")!!
    val addressAIpv4 = byteArrayOf(127, 0, 0, 1)