}

  /**
   * Removes and returns the greatest element of this queue.
   *
   * @throws NoSuchElementException if the queue is empty
   */
  @CanIgnoreReturnValue
  public E removeLast() {
    if (isEmpty()) {
      throw new NoSuchElementException();
    }
    return removeAndGet(getMaxElementIndex());
  }

  /**

    return FS.getRootDirectories().iterator().next();
  }

  private Path tempDir;

  @Override
  protected void setUp() throws Exception {
    tempDir = Files.createTempDirectory("MoreFilesTest");
  }

  @Override
  protected void tearDown() throws Exception {
    if (tempDir != null) {
      // delete tempDir and its contents
      Files.walkFileTree(
          tempDir,

    }
    throw new AssertionError();
  }

  private static final double LN_10 = Math.log(10);
  private static final double LN_2 = Math.log(2);

  /**
   * Returns the square root of {@code x}, rounded with the specified rounding mode.
   *
   * @throws IllegalArgumentException if {@code x < 0}

    /**
     * 
     */
    public SecurityDescriptor () {}


    /**
     * @param buffer
     * @param bufferIndex
     * @param len
     * @throws IOException
     */
    public SecurityDescriptor ( byte[] buffer, int bufferIndex, int len ) throws IOException {
        this.decode(buffer, bufferIndex, len);
    }


    /**
     * @return the type
     */
    public final int getType () {

public class GraphTest {

    @Test
    void testCycle() throws Graph.CycleDetectedException {
        Graph graph = new Graph();
        graph.addEdge("a1", "a2");
        assertThrows(Graph.CycleDetectedException.class, () -> graph.addEdge("a2", "a1"));
    }

    @Test
    public void testPerf() throws IOException {
        List<String[]> data = new ArrayList<>();
        String k = null;

        }
        catch ( GSSException e ) {
            throw new SmbException("Context setup failed", e);
        }
    }


    /**
     * @param subject
     *            the subject to set
     */
    protected void setSubject ( Subject subject ) {
        this.subject = subject;
    }


    @Override
    public void refresh () throws CIFSException {

    protected int compareNames ( SmbFile f1, String f1name, SmbFile f2 ) throws IOException {
        if ( f1.isDirectory() != f2.isDirectory() ) {
            return f1.isDirectory() ? -1 : 1;
        }
        return f1name.compareToIgnoreCase(f2.getName());
    }


    protected int compareSizes ( SmbFile f1, String f1name, SmbFile f2 ) throws IOException {
        long diff;

  @Param({"0", "1", "5", "10"})
  int numThreads;

  private final Set<Thread> blockedThreads = new HashSet<>();

  @BeforeExperiment
  void setUp() throws Exception {
    if (state != State.NOT_DONE && (numListeners != 0 || numThreads != 0)) {
      throw new SkipThisScenarioException();
    }
  }

  // This exclusion doesn't exclude the TOMBSTONE objects we set. So 'done' NEW futures will look
  // larger than they are.

    @Override
    protected MavenOptions parseArgs(String source, List<String> args) throws ParserException {
        try {
            return CommonsCliMavenOptions.parse(source, args.toArray(new String[0]));
        } catch (ParseException e) {
            throw new ParserException("Failed to parse source " + source, e.getCause());
        }
    }

    try {
      return new CharSource() {
        @Override
        public Reader openStream() throws IOException {
          return new StringReader(string);
        }
      }.readLines();
    } catch (IOException e) {
      throw new AssertionError();
    }
  }

  @Override
  public void tearDown() throws IOException {
    factory.tearDown();
  }