* Test contains method with empty list
     */
    @Test
    @DisplayName("Contains should return false for empty list")
    void testContainsEmptyList() {
        List<AvPair> emptyList = new ArrayList<>();
        assertFalse(AvPairs.contains(emptyList, AvPair.MsvAvFlags), "Should return false for empty list");
    }

    /**
     * Test contains method with existing type
     */
    @Test

    val x509KeyManager = newKeyManager(keystoreType, heldCertificate, *intermediates)
    val trustManager =
      newTrustManager(
        keystoreType,
        emptyList(),
        emptyList(),
      )
    val sslContext = get().newSSLContext()
    sslContext.init(
      arrayOf<KeyManager>(x509KeyManager),
      arrayOf<TrustManager>(trustManager),
      SecureRandom(),
    )

        validSubprojects.forEach {
            if (!subProjectToClassTimes.containsKey(it.name)) {
                subProjectToClassTimes[it.name] = emptyList()
            }
        }

        val subProjectTestClassTimes: List<SubprojectTestClassTime> =
            subProjectToClassTimes
                .entries
                .filter { "UNKNOWN" != it.key }

            "${testCoverage.asName()} for gradle ($startInclusive <= gradle <$endExclusive)",
            testCoverage,
            stage,
            parallelizationMethod,
            emptyList(),
            extraParameters = "-PonlyTestGradleVersion=$startInclusive-$endExclusive",
        )
    }

    val couldBeExtensionProperty =
        (hasGetterName && paramCount == 1 && !returnsVoid) || (hasSetterName && paramCount == 2 && returnsVoid)

    if (!couldBeProperty && !couldBeExtensionProperty) {
        return emptyList()
    }

    val propertyJavaType =
        if (hasGetterName) method.returnType.name
        else method.parameterTypes.last().name

    val isBoolean =

                listOf(testProjectToScenarioDurations, testProjectScenarioDurationsFallback)
                    .mapNotNull {
                        it.getOrDefault(scenario.testProject, emptyList()).firstOrNull { duration ->
                            duration.scenario ==
                                scenario.scenario
                        }
                    }.firstOrNull()

  apply {
    for (e in suppressed) addSuppressed(e)
  }

internal inline fun <T> Iterable<T>.filterList(predicate: T.() -> Boolean): List<T> {
  var result: List<T> = emptyList()
  for (i in this) {
    if (predicate(i)) {
      if (result.isEmpty()) result = mutableListOf()
      (result as MutableList<T>).add(i)
    }
  }
  return result
}

        val reports: List<File> = executedTaskPaths.asSequence()
            .flatMap { taskPathToReports.getOrDefault(it, emptyList()) }
            .map { it.file }
            .toList()
        if (isAnyTestTaskFailed(projectPath) || tmpTestFiles.isNotEmpty()) {
            prepareReportForCiPublishing(tmpTestFiles + reports)
        } else {

        if (protwordsItemList == null) {
            reload(null);
        }

        if (offset >= protwordsItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<ProtwordsItem> emptyList(), offset, size, protwordsItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > protwordsItemList.size()) {
            toIndex = protwordsItemList.size();
        }

import static com.google.common.collect.testing.features.MapFeature.ALLOWS_ANY_NULL_QUERIES;
import static com.google.common.truth.Truth.assertThat;
import static java.util.Collections.emptyList;
import static java.util.Collections.emptySet;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;