CreateContextResponse[] contexts = new CreateContextResponse[3];
            byte[] buffer = new byte[300];

            contexts[0] = new TestCreateContextResponse("CONTEXT1".getBytes(StandardCharsets.UTF_8));
            contexts[1] = new TestCreateContextResponse("CONTEXT2".getBytes(StandardCharsets.UTF_8));
            contexts[2] = new TestCreateContextResponse("CONTEXT3".getBytes(StandardCharsets.UTF_8));

        assertNull(user.getName());

        // Test with special characters in name
        user = new TestFessUser("******@****.***", new String[] {}, new String[] {}, new String[] {});
        assertEquals("******@****.***", user.getName());

        // Test with Unicode characters
        user = new TestFessUser("ユーザー名", new String[] {}, new String[] {}, new String[] {});

        super.setUp(testInfo);
        labelTypeHelper = new LabelTypeHelper();
        ComponentUtil.register(new SystemHelper(), "systemHelper");
        ComponentUtil.register(new MockLabelTypeService(), LabelTypeService.class.getCanonicalName());
        ComponentUtil.register(new MockVirtualHostHelper(), "virtualHostHelper");
        ComponentUtil.register(new MockRoleQueryHelper(), "roleQueryHelper");
    }

    @Test

        where:
        ruleElem << [new BinaryBreakingChangesRule([:]), new SinceAnnotationRule([:]), new IncubatingMissingRule([:])]
        error << ['Is not binary compatible.', 'Is not annotated with @since', 'Is not annotated with @Incubating']
    }

    def "the @since annotation on inner classes is recognised"() {
        given:
        def rule = withContext(new SinceAnnotationRule([:]))

    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockContext.getConfig()).thenReturn(mockConfig);

        testFileId = new byte[16];
        new SecureRandom().nextBytes(testFileId);
        outputBuffer = new byte[4096];
        request = new Smb2ReadRequest(mockConfig, testFileId, outputBuffer, 0);
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

    AtomicReference<Object> valueRef = new AtomicReference<>();
    Cache<Object, Object> cache =
        new AbstractCache<Object, Object>() {
          @Override
          public @Nullable Object getIfPresent(Object key) {
            return valueRef.get();
          }
        };

    assertThat(cache.getIfPresent(new Object())).isNull();

    Object newValue = new Object();
    valueRef.set(newValue);

            // Given: SAM array with one entry
            samr.SamrSamArray array = new samr.SamrSamArray();
            array.count = 1;
            samr.SamrSamEntry entry = new samr.SamrSamEntry();
            entry.name = new rpc.unicode_string();
            array.entries = new samr.SamrSamEntry[] { entry };

            // When: Encoding array
            array.encode(mockNdrBuffer);

        Map<String, String> andParams = new HashMap<>();
        andParams.put("q", query.replace("OR", "AND"));
        String andResponse = checkMethodBase(new HashMap<>()).params(andParams).get("/api/v1/documents").asString();
        int andRecordCount = JsonPath.from(andResponse).getInt("record_count");

        Map<String, String> params = new HashMap<>();
        params.put("q", query);

        SuggestItem[] items = new SuggestItem[3];

        for (int i = 0; i < 3; i++) {
            String[][] readings = new String[1][];
            readings[0] = new String[] { "test" + i };
            items[i] = new SuggestItem(new String[] { "テスト" + i }, readings, new String[] { "content" }, 1, 0, -1, new String[] { "tag1" },

        NtlmContext context = new NtlmContext(mockAuth, true);
        context.initSecContext(new byte[0], 0, 0); // state -> 2

        byte[] serverChallenge = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
        int type2Flags = NtlmFlags.NTLMSSP_NEGOTIATE_NTLM | NtlmFlags.NTLMSSP_REQUEST_TARGET;
        Type2Message type2Message = new Type2Message(type2Flags, serverChallenge, domain);