}

        fun assertHasAccepted(vararg accepted: String) {
            assertThat("Has accepted", richReport.accepted.map { it.message }, inAnyOrder(accepted))
        }

        fun assertHasAccepted(vararg accepted: Pair<String, List<String>>) {
            assertThat("Has accepted", richReport.accepted, inAnyOrder(accepted.map { ReportMessage(it.first, it.second) }))
        }

        // Test with no roles
        testUser.setRoleNames(new String[] {});
        assertFalse(fessUserBean.hasRoles(new String[] { "admin", "user" }));

        // Test with single role matching one of accepted
        testUser.setRoleNames(new String[] { "admin" });
        assertTrue(fessUserBean.hasRoles(new String[] { "admin", "user" }));
        assertTrue(fessUserBean.hasRoles(new String[] { "guest", "admin" }));

        // Threshold of 0 should be accepted
        request.threshold(0);

        assertEquals(0, request.threshold());
    }

    @Test
    public void testThresholdWithNegative() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");

        // Negative threshold should be accepted (though may not make sense)
        request.threshold(-1);

This includes adding the description of the changes to the `accepted-public-api-changes.json` file, and providing a reason for each change.
You can add the changes to any place in the file, e.g. at the top.

3. Make sure the file with accepted changes is sorted.\
Use the `./gradlew :architecture-test:sortAcceptedApiChanges` task to sort the file.

   *
   * <p>If the supplied future is {@linkplain #isDone done} when this method is called and the call
   * is accepted, then this future is guaranteed to have been completed with the supplied future by
   * the time this method returns. If the supplied future is not done and the call is accepted, then
   * the future will be <i>set asynchronously</i>. Note that such a result, though not yet known,

    }

    @Test
    @DisplayName("Iterator with rejecting filter - finds next acceptable")
    void iteratorWithRejectingFilter() throws Exception {
        // Setup: first entry rejected, second accepted
        FileEntry entry1 = mock(FileEntry.class);
        FileEntry entry2 = mock(FileEntry.class);

        when(delegate.hasNext()).thenReturn(true, true, false);

        // Assert
        assertNotNull(e1);
        assertNotNull(e2);
        assertEquals("first", e1.getName());
        assertEquals(acceptedName, e2.getName(), "Should return the first name accepted by filter");

        // Verify filter interactions: not called for '.' and '..', called for others
        verify(nameFilter, never()).accept(parent, ".");
        verify(nameFilter, never()).accept(parent, "..");

        new SecureRandom().nextBytes(standardFileId);
        new SecureRandom().nextBytes(longFileId);

        RequestWithFileId request = new Smb2CloseRequest(mockConfig, emptyFileId);

        // All sizes should be accepted without exception
        assertDoesNotThrow(() -> request.setFileId(shortFileId), "Should handle 8-byte file ID");
        assertDoesNotThrow(() -> request.setFileId(standardFileId), "Should handle 16-byte file ID");

testing/architecture-test                   @gradle/bt-architecture-council

# These files change frequently, and changes to them don't need to automatically alert the architecture council
testing/architecture-test/src/changes/accepted-changes/accepted-public-api-changes.json
testing/architecture-test/src/changes/archunit-store/internal-api-nullability.txt

# Core automation platform (core/configuration)
platforms/core-configuration/               @gradle/bt-cortex

        // This test documents the actual behavior - any tag number is accepted
        byte[] token =
                buildInitToken(new ASN1ObjectIdentifier[] { OID_KRB }, NegTokenInit.INTEGRITY, new byte[] { 0x42 }, null, false, null, 1, // Non-zero tag number is currently accepted
                        null);

        // The implementation accepts any tag number without validation