}

        @Test
        @DisplayName("Should create response with same configuration")
        void testCreateResponseConfiguration() {
            Smb2WriteResponse response = request.createResponse(mockContext, request);
            assertNotNull(response);
            // Response should be created with the same config from context
            verify(mockContext, times(1)).getConfig();
        }
    }

   *
   * <p><b>Note:</b> If the specified iterable is a {@code SortedSet} or a {@code PriorityQueue},
   * this priority queue will be ordered according to the same ordering.
   *
   * @since 11.0 (but the bound of {@code E} was changed from {@code Object} to {@code Comparable}
   *     in 15.0)
   */
  @SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989

        .inOrder();
  }

  public void testCopyOf_array_empty() {
    /*
     * We don't guarantee the same-as property, so we aren't obligated to test it. However, it's
     * useful in testing - when two things are the same then one can't have bugs the other doesn't.
     */
    assertThat(ImmutableDoubleArray.copyOf(new double[0]))
        .isSameInstanceAs(ImmutableDoubleArray.of());

        assertNotNull(response.getInfo());
        assertTrue(response.getInfo() instanceof FileInternalInfo);
    }

    @Test
    @DisplayName("Test multiple calls to getInfo return same instance")
    void testMultipleGetInfoCalls() throws Exception {
        response = new Smb2QueryInfoResponse(mockConfig, (byte) 1, (byte) 2);

        // Use reflection to set the info field

        // Execute
        final InvalidQueryException exception = new InvalidQueryException(messageCode, message);

        // Verify getMessageCode returns the same instance
        final VaMessenger<FessMessages> retrievedCode1 = exception.getMessageCode();
        final VaMessenger<FessMessages> retrievedCode2 = exception.getMessageCode();

        assertNotNull(retrievedCode1);

 *
 * The full range of code points is 0..0x10fffe. We can represent any of these code points with 21
 * bits.
 *
 * We split each code point into a 14-bit prefix and a 7-bit suffix. All code points with the same
 * prefix are called a 'section'. There are 128 code points per section.
 *
 * Ranges Data (32,612 bytes)
 * ==========================
 *

    "fffe".decodeHex(),
    // UTF-32BE.
    "0000feff".decodeHex(),
  )

/**
 * Returns an array containing only elements found in this array and also in [other]. The returned
 * elements are in the same order as in this.
 */
internal fun Array<String>.intersect(
  other: Array<String>,
  comparator: Comparator<in String>,
): Array<String> {
  val result = mutableListOf<String>()
  for (a in this) {

efficiently makes your stuff load faster and saves bandwidth.

OkHttp is an HTTP client that’s efficient by default:

 * HTTP/2 support allows all requests to the same host to share a socket.
 * Connection pooling reduces request latency (if HTTP/2 isn’t available).
 * Transparent GZIP shrinks download sizes.
 * Response caching avoids the network completely for repeat requests.

        assertEquals(1, notifications.size());
        assertEquals("offset_test.txt", notifications.get(0).getFileName());
    }

    @Test
    @DisplayName("Test getNotifyInformation returns same list instance")
    void testGetNotifyInformationReturnsSameInstance() {
        List<FileNotifyInformation> list1 = response.getNotifyInformation();
        List<FileNotifyInformation> list2 = response.getNotifyInformation();

	// unicode.IsSpace() internally here) to one space and return
	return strings.Join(strings.Fields(input), " ")
}

// checkMetaHeaders will check if the metadata from header/url is the same with the one from signed headers
func checkMetaHeaders(signedHeadersMap http.Header, r *http.Request) APIErrorCode {
	// check values from http header
	for k, val := range r.Header {