}

  @Override
  public UnmodifiableIterator<E> iterator() {
    return Iterators.unmodifiableIterator(delegate.iterator());
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && delegate.contains(object);
  }

  @Override
  public boolean containsAll(Collection<?> targets) {
    return delegate.containsAll(targets);
  }

  @Override
  public int size() {

    if (derivedFeatures.contains(CollectionFeature.SUPPORTS_ADD)) {
      derivedFeatures.add(ListFeature.SUPPORTS_ADD_WITH_INDEX);
    }
    if (derivedFeatures.contains(CollectionFeature.SUPPORTS_REMOVE)) {
      derivedFeatures.add(ListFeature.SUPPORTS_REMOVE_WITH_INDEX);
    }
    if (derivedFeatures.contains(CollectionFeature.GENERAL_PURPOSE)) {

  public void testCopyOf_collection_general() {
    Collection<String> c = MinimalCollection.of("a", "b", "a");
    Set<String> set = copyOf(c);
    assertEquals(2, set.size());
    assertTrue(set.contains("a"));
    assertTrue(set.contains("b"));
  }

  public void testCopyOf_collectionContainingNull() {
    Collection<@Nullable String> c = MinimalCollection.of("a", null, "b");

include(":samples:crawler")
include(":samples:guide")
include(":samples:simple-client")
include(":samples:slack")
include(":samples:static-server")
include(":samples:tlssurvey")
include(":samples:unixdomainsockets")
include(":container-tests")
val okhttpModuleTests: String by settings
if (okhttpModuleTests.toBoolean()) {
  include(":module-tests")
}

project(":okhttp-logging-interceptor").name = "logging-interceptor"

      PlatformVersion.majorVersion == 11 -> {
        assertThat(s.enabledProtocols.toList()).contains(
          "TLSv1.2",
        )
      }

      // JDK 8 291 removed older versions
      // See https://java.com/en/jre-jdk-cryptoroadmap.html
      PlatformVersion.majorVersion == 8 -> {
        assertThat(s.enabledProtocols.toList()).contains(
          "TLSv1.2",
        )
      }

      else -> {

    }

    @Test
    @DisplayName("toString representation contains expected fields")
    void toStringContainsKeyData() {
        SmbComNTCreateAndX req = createRequest(0, 0);
        String str = req.toString();
        assertTrue(str.startsWith("SmbComNTCreateAndX["), "toString should start with class name");
        assertTrue(str.contains("name=test.txt"), "The file name should appear");

            severities.add(problem.getSeverity());
        }
    }

    public boolean hasFatalErrors() {
        return severities.contains(ModelProblem.Severity.FATAL);
    }

    public boolean hasErrors() {
        return severities.contains(ModelProblem.Severity.ERROR) || severities.contains(ModelProblem.Severity.FATAL);
    }

    @Override
    public List<ModelProblem> getProblems() {
        return problems;
    }

        roleSet = buildByParameter(roleQueryHelperImpl, getMockRequest());
        assertEquals(3, roleSet.size());
        assertTrue(roleSet.contains("role1"));
        assertTrue(roleSet.contains("role2"));
        assertTrue(roleSet.contains("role3"));

        roleQueryHelperImpl.parameterKey = "fess2";

        roleQueryHelperImpl.cipher = cipher;

/** Example: "0x00,0x08",TLS_RSA_EXPORT_WITH_DES40_CBC_SHA,Y,N,[RFC4346] */
val IANA_CSV_PATTERN = "\"0x(\\w\\w),0x(\\w\\w)\",(\\w+).*".toRegex()

fun parseIanaCsvRow(s: String): SuiteId? {
  if (s.contains("Reserved") || s.contains("Unassigned")) return null
  val matcher = IANA_CSV_PATTERN.matchEntire(s) ?: return null
  val id = (matcher.groupValues[1] + matcher.groupValues[2]).decodeHex()
  return SuiteId(id, matcher.groupValues[3])
}

    if (cancelMode == CANCEL) {
      assertThat(events).contains("Canceled")
    } else {
      assertThat(events).doesNotContain("Canceled")
    }
    assertThat(events).contains("ResponseFailed")
    assertThat(events).contains("ConnectionReleased")

    val call2 = client.newCall(Request(server.url("/")))
    call2.execute().use {