disjoint = new Target(disjointList, "disjoint");
    superset = new Target(MinimalCollection.of(e0(), e1(), e2(), e3(), e4()), "superset");
    nonEmptyProperSubset = new Target(MinimalCollection.of(e1()), "subset");
    sameElements = new Target(asList(createSamplesArray()), "sameElements");
    containsDuplicates =
        new Target(MinimalCollection.of(e0(), e0(), e3(), e3()), "containsDuplicates");

 --%><%@taglib prefix="la" uri="http://lastaflute.org/latags" %><%--
 --%><%@taglib prefix="f" uri="http://lastaflute.org/functions" %><%--
 --%><%@taglib prefix="fe" uri="fess.tags.functions" %><%--

    ModelField,
    get_definitions,
    get_flat_models_from_fields,
    get_model_name_map,
    get_schema_from_model_field,
    lenient_issubclass,
)
from fastapi.datastructures import DefaultPlaceholder, _Unset
from fastapi.dependencies.models import Dependant
from fastapi.dependencies.utils import (
    _get_flat_fields_from_params,
    get_flat_dependant,
    get_flat_params,
    get_validation_alias,
)

          }
          return elemItr.next();
        }
      };
    }

    ImmutableSortedSet<C> subSet(Range<C> range) {
      return subRangeSet(range).asSet(domain);
    }

    @Override
    ImmutableSortedSet<C> headSetImpl(C toElement, boolean inclusive) {
      return subSet(Range.upTo(toElement, BoundType.forBoolean(inclusive)));
    }

    @Override
    ImmutableSortedSet<C> subSetImpl(

    disjoint = new Target(disjointList, "disjoint");
    superset = new Target(MinimalCollection.of(e0(), e1(), e2(), e3(), e4()), "superset");
    nonEmptyProperSubset = new Target(MinimalCollection.of(e1()), "subset");
    sameElements = new Target(asList(createSamplesArray()), "sameElements");
    containsDuplicates =
        new Target(MinimalCollection.of(e0(), e0(), e3(), e3()), "containsDuplicates");

          export amazon_s3_access_key=$(echo $data | jq -r .data.access_key)
          export amazon_s3_secret_key=$(echo $data | jq -r .data.secret_key)
          unset VAULT_TOKEN data
          set -x

    assertTrue(ArbitraryInstances.get(BitSet.class).isEmpty());
    assertTrue(ArbitraryInstances.get(TreeSet.class).isEmpty());
    assertTrue(ArbitraryInstances.get(TreeMap.class).isEmpty());
    assertFreshInstanceReturned(
        LinkedList.class,
        Deque.class,
        Queue.class,
        PriorityQueue.class,
        BitSet.class,
        TreeSet.class,
        TreeMap.class);
  }

    @Override
    public SortedSet<E> create(Object... elements) {
      List<?> normalValues = (List<?>) asList(elements);
      List<E> extremeValues = new ArrayList<>();

      // nulls are usually out of bounds for a subset, so ban them altogether
      for (Object o : elements) {
        if (o == null) {
          throw new NullPointerException();
        }
      }

      // prepare extreme values to be filtered out of view

        "containsAll(empty) should return true", collection.containsAll(MinimalCollection.of()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testContainsAll_subset() {
    assertTrue(
        "containsAll(subset) should return true",
        collection.containsAll(MinimalCollection.of(e0())));
  }

  public void testContainsAll_sameElements() {
    assertTrue(
        "containsAll(sameElements) should return true",

    return forward.tailSet(toElement, inclusive).descendingSet();
  }

  @Override
  ImmutableSortedSet<E> subSetImpl(
      E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
    return forward.subSet(toElement, toInclusive, fromElement, fromInclusive).descendingSet();
  }

  @Override
  ImmutableSortedSet<E> tailSetImpl(E fromElement, boolean inclusive) {
    return forward.headSet(fromElement, inclusive).descendingSet();