checkNotNull(valueComparator);
    return Comparator.<Optional<T>, @Nullable T>comparing(
        o -> orElseNull(o), Comparator.nullsLast(valueComparator));
  }

  // For discussion of why this exists, see the Android flavor.
  private static <T> @Nullable T orElseNull(Optional<T> optional) {
    return optional.orElse(null);
  }

  /**

import java.util.Arrays;
import java.util.Optional;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

/**
 * Tests for {@link DosError}.  Since {@link DosError} only contains
 * constants, the tests exercise the data and small helper logic in this
 * test class.
 */
public class DosErrorTest {
    private static Optional<Integer> findNtStatus(int dosErrorCode) {

significant (trailing in little-endian) zero limbs. // We assume comparison with zero (but not the branch) is constant time. for i := len(x.limbs) - 1; i >= 0; i-- { if x.limbs[i] != 0 { break } x.limbs = x.limbs[:i] } return x } // set assigns x = y, optionally resizing x to the appropriate size. func (x *Nat) set(y *Nat) *Nat { x.reset(len(y.limbs)) copy(x.limbs, y.limbs) return x } // Bits returns x as a little-endian slice of uint. The length of the slice // matches the announced length of x. The result...

        @Override
        public Iterator<Lifecycle> iterator() {
            return Collections.emptyIterator();
        }

        @Override
        public Optional<Lifecycle> lookup(String id) {
            return Optional.empty();
        }

        @Override
        public List<String> computePhases(Lifecycle lifecycle) {
            return List.of();
        }
    };

                @Nonnull
                @Override
                public Optional<Path> getPomFile() {
                    return Optional.ofNullable(res.getPomFile()).map(File::toPath);
                }

                @Nonnull
                @Override
                public Optional<Project> getProject() {
                    return Optional.ofNullable(session.getProject(res.getProject()));
                }

            }

            @Nonnull
            @Override
            public Optional<Path> getPath() {
                return Optional.ofNullable(path);
            }

            @Nonnull
            @Override
            public Optional<Source> getSource() {
                return Optional.ofNullable(source);
            }

            @Override

    private static final String RUNNER_DEBUG = "RUNNER_DEBUG";

    @Override
    public Optional<CIInfo> detectCI() {
        String ciEnv = System.getenv(GITHUB_ACTIONS);
        if ("true".equals(ciEnv)) {
            return Optional.of(new CIInfo() {
                @Override
                public String name() {
                    return NAME;
                }

                @Override

    private static final String TRAVIS_DEBUG_MODE = "TRAVIS_DEBUG_MODE";

    @Override
    public Optional<CIInfo> detectCI() {
        String ciEnv = System.getenv(TRAVIS);
        if ("true".equals(ciEnv)) {
            return Optional.of(new CIInfo() {
                @Override
                public String name() {
                    return NAME;
                }

                @Override

  /**
   * Returns a comparator of {@link Optional} values which treats {@link Optional#empty} as less
   * than all other values, and orders the rest using {@code valueComparator} on the contained
   * value.
   *
   * @since 33.4.0 (but since 22.0 in the JRE flavor)
   */
  @IgnoreJRERequirement // Users will use this only if they're already using Optional.

            .addValue(null)
            .add(SHORT_NAME, java.util.Optional.of("1"))
            .add(LONG_NAME, java.util.Optional.of("1"))
            .add(SHORT_NAME, java.util.Optional.empty())
            .add(LONG_NAME, java.util.Optional.empty())
            .add(SHORT_NAME, Optional.of("2"))
            .add(SHORT_NAME, Optional.absent())
            .addValue(null)
            .add(SHORT_NAME, new int[] {1})