@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class SetMultimapEqualsTester<K, V> extends AbstractMultimapTester<K, V, SetMultimap<K, V>> {
  @CollectionSize.Require(SEVERAL)
  public void testOrderingDoesntAffectEqualsComparisons() {
    SetMultimap<K, V> multimap1 =
        getSubjectGenerator()
            .create(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k0(), v4()));

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class CollectionSerializationEqualTester<E> extends AbstractCollectionTester<E> {
  @CollectionFeature.Require(SERIALIZABLE)
  /*
   * As the class docs say, this test only makes sense for collections that define equals().
   * Accordingly, our testing framework adds it only when testing an implementation of List, Set, or
   * Multiset.

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListMultimapPutAllTester<K, V> extends AbstractListMultimapTester<K, V> {
  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllAddsAtEndInOrder() {
    List<V> values = asList(v3(), v1(), v4());

    for (K k : sampleKeys()) {
      resetContainer();

    if (!disjoint(newFeatures, earlierFeatures)) {
      throw new ConflictingRequirementsException(
          String.format(
              Locale.ROOT,
              "Annotation requires to be %s features that earlier "
                  + "annotations required to be %s.",
              newRequirement,
              earlierRequirement),
          intersection(newFeatures, earlierFeatures),
          source);
    }
  }

{* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}

## Paramètres de requête requis { #required-query-parameters }

Quand vous déclarez une valeur par défaut pour des paramètres qui ne sont pas des paramètres de chemin (pour l'instant, nous n'avons vu que les paramètres de requête), alors ils ne sont pas requis.

Si vous ne voulez pas leur donner de valeur spécifique mais simplement les rendre optionnels, définissez la valeur par défaut à `None`.

  }

  public void testGetTesterAnnotations_class() {
    @Require
    @NotTesterAnnotation
    class Tester {}

    assertThat(getTesterAnnotations(Tester.class))
        .containsExactly(Tester.class.getAnnotation(Require.class));
  }

  public void testGetTesterAnnotations_method() throws Exception {
    class Tester {
      @Keep
      @Require
      @NotTesterAnnotation
      public void test() {}
    }

        }
        val version = milestone.get()
        val parts = version.split(".")
        require(parts.size == 3 && parts[2].toIntOrNull()?.let { it != 0 } == true) {
            "Version '$version' is not a patch release. Expected format: x.y.z with z > 0."
        }
        val issues = getFixedIssues()
        require(!issues.isEmpty()) {
            "No fixed issues found for milestone ${milestone.get()}"
        }

  return null
}

internal fun Headers.Builder.commonBuild(): Headers = Headers(namesAndValues.toTypedArray())

internal fun headersCheckName(name: String) {
  require(name.isNotEmpty()) { "name is empty" }
  for (i in name.indices) {
    val c = name[i]
    require(c in '\u0021'..'\u007e') {
      "Unexpected char 0x${c.charCode()} at $i in header name: $name"
    }
  }
}

internal fun headersCheckValue(

    repositoryPlugin.deployDirectory(testResourceDir / "deployments")
    repositoryPlugin.deployClassPath()
  }

  private fun createBndRun(workspace: Workspace): Bndrun {
    // Creating the run require string. It will always use the latest version of each bundle
    // available in the repository.
    val runRequireString =
      REQUIRED_BUNDLES.joinToString(separator = ",") {

  public void testToArray_noArg() {
    Object[] actual = getList().toArray();
    assertArrayEquals("toArray() order should match list", createOrderedArray(), actual);
  }

  @CollectionSize.Require(absent = ZERO)
  public void testToArray_tooSmall() {
    Object[] actual = getList().toArray(new Object[0]);
    assertArrayEquals("toArray(tooSmall) order should match list", createOrderedArray(), actual);
  }