// Then
        assertEquals(bytes1, bytes2);
        assertEquals(SMBUtil.readInt2(buffer1, 0), SMBUtil.readInt2(buffer2, 10));
    }

    @Test
    @DisplayName("Should maintain immutability of structure size")
    void testStructureSizeImmutability() {
        // Given
        Configuration mockConfig = mock(Configuration.class);

        // Test prepare method (should not throw exception)
        assertDoesNotThrow(() -> response.prepare(mockRequest));
    }

    @Test
    @DisplayName("Test NotifyResponse returned list immutability")
    void testNotifyResponseListImmutability() {
        List<FileNotifyInformation> inputList = new ArrayList<>(Arrays.asList(mockNotifyInfo1, mockNotifyInfo2));

        // Then
        assertTrue(request instanceof ServerMessageBlock2Request);
        assertTrue(request instanceof ServerMessageBlock2);
    }

    @Test
    @DisplayName("Should maintain immutability of structure size")
    void testStructureSizeImmutability() throws Exception {
        // Given
        byte[] buffer = new byte[2048];

        // When - encode at multiple positions

        Secured secured = SecuredInterfaceImpl.class.getAnnotation(Secured.class);
        assertNull(secured); // Interface annotations are not inherited by implementing classes
    }

    // Test annotation array immutability
    public void test_annotationValueImmutability() {
        Secured secured = MultipleRolesClass.class.getAnnotation(Secured.class);
        String[] roles1 = secured.value();
        String[] roles2 = secured.value();

/**
 * An immutable array of {@code long} values, with an API resembling {@link List}.
 *
 * <p>Advantages compared to {@code long[]}:
 *
 * <ul>
 *   <li>All the many well-known advantages of immutability (read <i>Effective Java</i>, third
 *       edition, Item 17).
 *   <li>Has the value-based (not identity-based) {@link #equals}, {@link #hashCode}, and {@link
 *       #toString} behavior you expect.

/**
 * An immutable array of {@code int} values, with an API resembling {@link List}.
 *
 * <p>Advantages compared to {@code int[]}:
 *
 * <ul>
 *   <li>All the many well-known advantages of immutability (read <i>Effective Java</i>, third
 *       edition, Item 17).
 *   <li>Has the value-based (not identity-based) {@link #equals}, {@link #hashCode}, and {@link
 *       #toString} behavior you expect.

            // Then
            assertEquals(1024L * 1024L * 1024L * 60L, used); // 60GB used
        }

        @Test
        @DisplayName("Should maintain immutability")
        void shouldMaintainImmutability() {
            // Given
            long capacity = 1000L;
            long free = 500L;
            TestAllocInfo allocInfo = new TestAllocInfo(capacity, free);

    return CollectCollectors.toImmutableSet();
  }

  /**
   * Returns the empty immutable set. Preferred over {@link Collections#emptySet} for code
   * consistency, and because the return type conveys the immutability guarantee.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   */
  @SuppressWarnings({"unchecked"}) // fully variant implementation (never actually produces any Es)

## Version 2.0.0-RC1

_2014-05-23_

OkHttp 2 is designed around a new API that is true to HTTP, with classes for
requests, responses, headers, and calls. It uses modern Java patterns like
immutability and chained builders. The API now offers asynchronous callbacks
in addition to synchronous blocking calls.

#### API Changes

 *  **New Request and Response types,** each with their own builder. There's also

  }

  /**
   * Verifies that the {@code Set} returned by {@code nodes} has the expected mutability property
   * (see the {@code Network} documentation for more information).
   */
  @Test
  public abstract void nodes_checkReturnedSetMutability();

  /**
   * Verifies that the {@code Set} returned by {@code edges} has the expected mutability property
   * (see the {@code Network} documentation for more information).
   */