* @throws NoSuchElementException if {@code iterator} is empty
   * @throws ClassCastException if the parameters are not <i>mutually comparable</i> under this
   *     ordering.
   * @since 11.0
   */
  @ParametricNullness
  public <E extends T> E min(Iterator<E> iterator) {
    // let this throw NoSuchElementException as necessary
    E minSoFar = iterator.next();

    }

    private class ToBeFixedInterceptor implements IMethodInterceptor {

        @Override
        void intercept(IMethodInvocation invocation) throws Throwable {
            if (failsAsExpected(invocation, feature)) {
                return
            }
            throw new UnexpectedSuccessException(feature)
        }
    }

    private class ToBeFixedIterationInterceptor implements IMethodInterceptor {

     * @return where to place the dependency, or an empty value if the placement cannot be determined
     * @throws IOException if an error occurred while reading module information
     */
    Optional<PathType> selectPathType(Set<PathType> types, Predicate<PathType> filter, Path path) throws IOException {
        PathType selected = null;
        boolean classes = false;
        boolean modules = false;

                    throw new UnsupportedClassVersionErrorWithJavaVersion(e, JavaVersion.forClassVersion(majorVersion));
                }
                // We could not find the class. Throw the original error.
                throw e;
            } catch (IOException ignored) {
                // There was an error parsing the class. Throw the original error.
                throw e;
            }
        }
    }

    }
  }

  private void runTestMethod(ClassLoader classLoader) throws Exception {
    Class<?> test = classLoader.loadClass(AbstractFutureTest.class.getName());
    test.getMethod(getName()).invoke(test.getDeclaredConstructor().newInstance());
  }

  private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)
      throws Exception {

public class NullSafeStringSerializer implements Serializer<String> {
    @Override
    public String read(Decoder decoder) throws Exception {
        return decoder.readNullableString();
    }

    @Override
    public void write(Encoder encoder, String value) throws Exception {
        encoder.writeNullableString(value);
    }

    private Artifact projectArtifact;

    @BeforeEach
    @Override
    public void setUp() throws Exception {
        super.setUp();
        projectArtifact = createLocalArtifact("project", "3.0");
    }

    @Override
    protected String component() {
        return "resolver";
    }

    @Test
    void testMNG4738() throws Exception {
        Artifact g = createLocalArtifact("g", "1.0");

    MetadataGraphVertex v2;
    MetadataGraphVertex v3;
    MetadataGraphVertex v4;

    // ------------------------------------------------------------------------------------------
    @BeforeEach
    void setUp() throws Exception {
        graph = new MetadataGraph(4, 3);
        /*
         *       v2
         *   v1<
         *       v3-v4
         *
         */

                } catch (IOException e) {
                    throw new FileException(e);
                }
                return nextEntry == null ? endOfData() : new StreamZipEntry(nextEntry);
            }
        };
    }

    @Override
    public void close() throws IOException {
        inputStream.close();
    }

    private class StreamZipEntry extends AbstractZipEntry {

        if (stack == null || stack.isEmpty()) {
            throw new IllegalStateException();
        }
        return stack.getFirst();
    }

    public void exit() throws MojoExecutionException {
        final LinkedList<ScopeState> stack = values.get();
        if (stack == null || stack.isEmpty()) {
            throw new IllegalStateException();
        }
        stack.removeFirst();