*/
    public static Set<DialectVersion> range ( DialectVersion min, DialectVersion max ) {
        EnumSet<DialectVersion> vers = EnumSet.noneOf(DialectVersion.class);
        for ( DialectVersion ver : values() ) {

            if ( min != null && !ver.atLeast(min) ) {
                continue;
            }

            if ( max != null && !ver.atMost(max) ) {
                continue;
            }

    override
    val failsStage: Boolean
        get() = false

    val buildSpecs: List<FlameGraphGenerationBuildSpec>
        get() = scenarios.flatMap { scenario ->
            Os.values().flatMap { os ->
                val arch = if (os == Os.MACOS) Arch.AARCH64 else Arch.AMD64
                if (os == Os.WINDOWS) {
                    listOf("jprofiler")
                } else {

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o isCheckColumnDefOrderDiff: (NotRequired - Default false)
    #  Does it check differences of column-def order?
    #  (except added or deleted columns)
    #
    #; isCheckColumnDefOrderDiff = false
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o isCheckDbCommentDiff: (NotRequired - Default false)

/**
 * CompactLinkedHashMap is an implementation of a Map with insertion or LRU iteration order,
 * maintained with a doubly linked list through the entries. All optional operations (put and
 * remove) are supported. Null keys and values are supported.
 *
 * <p>{@code containsKey(k)}, {@code put(k, v)} and {@code remove(k)} are all (expected and
 * amortized) constant time operations. Expected in the hashtable sense (depends on the hash

 * way of "cutting" a "number line" (actually of instances of type {@code C}, not necessarily
 * "numbers") into two sections; this can be done below a certain value, above a certain value,
 * below all values or above all values. With this object defined in this way, an interval can
 * always be represented by a pair of {@code Cut} instances.
 *
 * @author Kevin Bourrillion
 */

    entries.add(entry(k3(), null));

    resetContainer(getSubjectGenerator().create(entries.toArray()));
    assertTrue(
        "A Map should equal any other Map containing the same entries,"
            + " even if some values are null.",
        getMap().equals(newHashMap(entries)));
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  public void testEquals_otherContainsNullValue() {

 *
 * <p>Like any other {@code Map<Class, Object>}, this map may contain entries for primitive types,
 * and a primitive type and its corresponding wrapper type may map to different values.
 *
 * @param <B> the common supertype that all entries must share; often this is simply {@link Object}
 * @author Ben Yu
 * @since 13.0
 */
@DoNotMock("Use ImmutableTypeToInstanceMap or MutableTypeToInstanceMap")

      if (constants == null) {
        constants = populateCache(enumClass);
      }
      return constants;
    }
  }

  /**
   * Returns a serializable converter that converts between strings and {@code enum} values of type
   * {@code enumClass} using {@link Enum#valueOf(Class, String)} and {@link Enum#name()}. The
   * converter will throw an {@code IllegalArgumentException} if the argument is not the name of any

 *
 * <p>Like any other {@code Map<Class, Object>}, this map may contain entries for primitive types,
 * and a primitive type and its corresponding wrapper type may map to different values.
 *
 * @param <B> the common supertype that all entries must share; often this is simply {@link Object}
 * @author Ben Yu
 * @since 13.0
 */
@DoNotMock("Use ImmutableTypeToInstanceMap or MutableTypeToInstanceMap")

            return roundFloorAsDouble;
          } else if (diff > 0) { // closer to ceiling
            return roundCeilingAsDouble;
          }
          // halfway between the representable values; do the half-whatever logic
          switch (mode) {
            case HALF_EVEN:
              // roundFloorAsDouble and roundCeilingAsDouble are neighbors, so precisely