is then described by additional elements.
            Projects should only list the license(s) that applies to the project
            and not the licenses that apply to dependencies.
            If multiple licenses are listed, it is assumed that the user can select
            any of them, not that they must accept all.
            ]]>
          </description>
          <association>
            <type>License</type>

            assertEquals(1, buffer.getReferrals().length);
            assertEquals(3, buffer.getReferrals()[0].getVersion());
        }

        @Test
        @DisplayName("Should decode buffer with multiple referrals")
        void testDecodeMultipleReferrals() {
            // Create buffer with two v1 referrals
            byte[] testBuffer = new byte[200];

        // Assert
        assertFalse(result);
        verify(negotiationResponse).haveCapabilitiy(capability);
    }

    @Test
    @DisplayName("Test haveCapability with multiple capability flags")
    void testHaveCapabilityMultipleFlags() {
        // Arrange
        int cap1 = 0x00000001;
        int cap2 = 0x00000002;
        int cap3 = 0x00000004;

 *
 * Note that any other form is unsupported. You may not use asterisks in any position other than
 * the leftmost label.
 *
 * If multiple patterns match a hostname, any match is sufficient. For example, suppose pin A
 * applies to `*.publicobject.com` and pin B applies to `api.publicobject.com`. Handshakes for

        bean.setAdditionalCron("also invalid");

        Set<ConstraintViolation<ExtendedTestBean>> violations = validator.validate(bean);
        assertEquals(2, violations.size());
    }

    // Test multiple annotations on same field
    public void test_multipleValidations() {
        MultiValidationBean bean = new MultiValidationBean();
        bean.setRequiredCron(null); // Violates NotNull

 * could in principle cause problems for some users. Still, we expect that the benefits of the
 * nullness annotations in particular will outweigh the costs. (And it's worth noting that we have
 * released multiple ListenableFuture.class files that are not byte-for-byte compatible even from
 * the beginning, thanks to using different `-source -target` values for compiling our `-jre` and
 * `-android` "flavors.")
 *

        assertEquals(firstInstance.getIndexNumber(), secondInstance.getIndexNumber());
        assertEquals(expectedIndexNumber, secondInstance.getIndexNumber());
    }

    @Test
    @DisplayName("Test multiple decode operations")
    void testMultipleDecodeOperations() throws SMBProtocolDecodingException {
        // First decode
        byte[] buffer1 = new byte[8];
        long indexNumber1 = 0x1111111111111111L;

    void testHashCodeConsistency() {
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, TEST_TYPE, TEST_REMARK);
        int hashCode1 = info.hashCode();
        int hashCode2 = info.hashCode();

        // Multiple calls should return same value
        assertEquals(hashCode1, hashCode2);
    }

    @Test
    @DisplayName("Test toString method")
    void testToString() {

        response.setResults(emptyEntries);
        assertSame(emptyEntries, response.getResults());
        assertEquals(0, response.getResults().length);

        // Test with multiple entries
        FileEntry[] entries = { mockFileEntry1, mockFileEntry2 };
        response.setResults(entries);
        assertEquals(2, response.getResults().length);
        response.setNumEntries(2);

///

## Sem o Pydantic