//  1. legacy kube group preferred version, extensions preferred version, metrics preferred version, legacy
//     kube any version, extensions any version, metrics any version, all other groups alphabetical preferred version,
//     all other groups alphabetical.
//
// TODO callers of this method should be updated to build their own specific restmapper based on their scheme for their tests

        }
        // Generate external jar with entries in alphabetical order
        def externalJar = file('build/libs/external.jar')
        succeeds(":a:javadoc", "-Dreverse=false")
        new ZipTestFixture(externalJar).hasDescendantsInOrder('META-INF/MANIFEST.MF', 'a', 'b', 'c', 'd')

        when:
        // Re-generate external jar with entries in reverse alphabetical order
        succeeds(":a:javadoc", "-Dreverse=true")

    EnumBiMap<Currency, Country> bimap = EnumBiMap.create(Currency.class, Country.class);
    assertEquals(Country.class, bimap.valueType());
  }

  public void testIterationOrder() {
    // The enum orderings are alphabetical, leading to the bimap and its inverse
    // having inconsistent iteration orderings.
    Map<Currency, Country> map =
        ImmutableMap.of(
            Currency.DOLLAR, Country.CANADA,

        when:
        run()

        then:
        output.contains("greetings from user home")
    }

    def "executes init scripts from init.d directory in user home dir in alphabetical order"() {
        given:
        executer.requireOwnGradleUserHomeDir()

        and:
        executer.gradleUserHomeDir.file('init.d/a.gradle') << 'println "init #a#"'

				"X-Remote-User":                                            {"Bob"},
				"X-Remote-Group":                                           {"one-a", "one-b"},
				"X-Remote-Extra-Alpha":                                     {"alphabetical"},
				"X-Remote-Extra-Alph4num3r1c":                              {"alphanumeric"},
				"X-Remote-Extra-Percent%20encoded":                         {"percent encoded"},

        suggestionsFor("foor") == ["foob", "for", "bor", "fo"]
        suggestionsFor("foora") == ["foob", "for"]
    }

    def "suggestions are ordered by distance then alphabetical"() {
        when:
        availablePaths = ["tasks.foobar", "task.afoobar", "tasks.f", "tasks.boofar", "fooba", "tasks.foo"]

        then:

# (error on undefined variables). This ensures that (a) every TFCI variable
# has an explicit default value, and (b) no script can accidentally use a
# variable that doesn't exist. Please keep this list in alphabetical order.
#
# Find usage in scripts with e.g.:
#   cd ci/official
#   ls *.sh utilities/*.sh | xargs grep -H --color=always TFCI_ARG_HERE
# You may also get an overview, e.g.:
#   cd ci/official

current build. It utilizes the `_api/v2/api_packages.txt` list of packages from
the local wheel file specified in the `requirements_lock_<python_version>.txt`.

Packages are imported one by one in alphabetical order during runtime.

The test doesn't identify package's order-dependent issues; for instance,
importing "tf.foo" followed by "tf.bar" won't reveal that "tf.bar" depends on
"tf.foo" being imported first.

rc=0

# List of dependencies we need to avoid dragging back into kubernetes/kubernetes
# Check if unwanted dependencies are removed
# The array and map in `unwanted-dependencies.json` are in alphabetical order.
go run k8s.io/kubernetes/cmd/dependencyverifier "${KUBE_ROOT}/hack/unwanted-dependencies.json"

outdated=$(go list -m -json all | jq -r "
  select(.Replace.Version != null) |
  select(.Version != .Replace.Version) |

   * depth 1, then 2, and so on.
   *
   * <p><b>Example:</b> The following graph with {@code startNode} {@code a} would return nodes in
   * the order {@code abcdef} (assuming successors are returned in alphabetical order).
   *
   * <pre>{@code
   * b ---- a ---- d
   * |      |
   * |      |
   * e ---- c ---- f
   * }</pre>
   *