* reflected in that iterator. These iterators never throw {@link ConcurrentModificationException}.
 *
 * <p><b>Note:</b> by default, the returned cache uses equality comparisons (the {@link
 * Object#equals equals} method) to determine equality for keys or values. However, if {@link
 * #weakKeys} was specified, the cache uses identity ({@code ==}) comparisons instead for keys.

        try (CurlResponse response = req.execute()) {
            // ## Assert ##
            assertEquals(200, response.getHttpStatusCode());
            assertNotNull(mockHolder[0]);
            assertTrue(Arrays.equals(bodyBytes, mockHolder[0].getCapturedOutput()));
        }
    }

    @Test
    public void test_StringBody_WrittenToConnection() throws Exception {
        // ## Arrange ##

			wantResult: ``,
		},
		{
			name:       "indexed-list-match-equals",
			query:      `SELECT * from s3object s WHERE (7,8.5,9) = s.nested[1]`,
			wantResult: `{"id":3,"title":"Second Record","desc":"another text","nested":[[2,3,4],[7,8.5,9]]}`,
		},
		{
			name:       "indexed-list-match-equals-s-star",
			query:      `SELECT s.* from s3object s WHERE (7,8.5,9) = s.nested[1]`,

      assertEquals(isRoundTrippable, Utf8.isWellFormed(bytes, 0, numBytes));
      String s = new String(bytes, UTF_8);
      byte[] bytesReencoded = s.getBytes(UTF_8);
      boolean bytesEqual = Arrays.equals(bytes, bytesReencoded);

      if (bytesEqual != isRoundTrippable) {
        fail();
      }
      if (isRoundTrippable) {
        countRoundTripped++;
      }
    }

        return ImmutableList.this.get(index);
      }
    };
  }

  @Override
  public ImmutableList<E> asList() {
    return this;
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    return Lists.equalsImpl(this, obj);
  }

  @Override
  public int hashCode() {
    return Lists.hashCodeImpl(this);
  }

  public ImmutableList<E> reverse() {

                    this.requireMic = true;
                }
                this.firstResponse = false;
            } else if (targ.getMechanism() != null && !targ.getMechanism().equals(this.selectedMech)) {
                throw new SmbException("Server switched mechanism");
            }
            inputToken = targ.getMechanismToken();
        } else {

                    final String newQuery = llmClientManager.regenerateQuery(userMessage, query, "no_results", history);
                    if (StringUtil.isNotBlank(newQuery) && !newQuery.equals(query)) {
                        logger.info("[RAG] Regenerated query. newQuery={}", newQuery);
                        searchResult = searchWithQueryAndMetadata(newQuery, safeFields, safeExtraQueries);
                    }

        }
      if (method != defaultMethod) {
        append(" \\\n  -X ${method.shellEscape()}")
      }

      // Append headers.
      for ((name, value) in headers) {
        if (contentType != null && name.equals("Content-Type", ignoreCase = true)) continue
        append(" \\\n  -H ${"$name: $value".shellEscape()}")
      }

      if (contentType != null) {

    FreshValueGenerator generator = new FreshValueGenerator();
    String[] a1 = generator.generateFresh(String[].class);
    String[] a2 = generator.generateFresh(String[].class);
    assertFalse(a1[0].equals(a2[0]));
  }

  public void testPrimitiveArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    int[] a1 = generator.generateFresh(int[].class);

 *
 * <p>Each of the {@code standard} methods uses the map's comparator (or the natural ordering of the
 * elements, if there is no comparator) to test element equality. As a result, if the comparator is
 * not consistent with equals, some of the standard implementations may violate the {@code Map}
 * contract.
 *
 * <p>The {@code standard} methods and the collection views they return are not guaranteed to be