*/
  private static final class Directed<N> extends EndpointPairIterator<N> {
    private Directed(BaseGraph<N> graph) {
      super(graph);
    }

    @Override
    @CheckForNull
    protected EndpointPair<N> computeNext() {
      while (true) {
        if (successorIterator.hasNext()) {
          // requireNonNull is safe because successorIterator is empty until we set this.node.

/**
 * @author shinsuke
 *
 */
public class DataServiceImpl implements DataService<AccessResultImpl<Long>> {

    protected static volatile long idCount = 0L;

    private static Object idCountLock = new Object();

    @Resource
    protected MemoryDataHelper dataHelper;

    /*
     * (non-Javadoc)
     *

            }
        }
    }


    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 {

  }

  /** Private constructor for inverse bimap. */
  private AbstractBiMap(Map<K, V> backward, AbstractBiMap<V, K> forward) {
    delegate = backward;
    inverse = forward;
  }

  @Override
  protected Map<K, V> delegate() {
    return delegate;
  }

  /** Returns its input, or throws an exception if this is not a valid key. */
  @CanIgnoreReturnValue
  @ParametricNullness
  K checkKey(@ParametricNullness K key) {

    @Override
    public String toString () {
        return this.binding.toString();
    }


    protected abstract void doSendFragment ( byte[] buf, int off, int length ) throws IOException;


    protected abstract int doReceiveFragment ( byte[] buf ) throws IOException;


    protected abstract int doSendReceiveFragment ( byte[] out, int off, int length, byte[] inB ) throws IOException;


    @Override

            }
        }
        // TODO catch IOException
    }
    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 {

  private final Map<Class<? extends @NonNull B>, B> delegate;

  private MutableClassToInstanceMap(Map<Class<? extends @NonNull B>, B> delegate) {
    this.delegate = checkNotNull(delegate);
  }

  @Override
  protected Map<Class<? extends @NonNull B>, B> delegate() {
    return delegate;
  }

  /**
   * Wraps the {@code setValue} implementation of an {@code Entry} to enforce the class constraint.
   */

   * @throws ClassCastException if a data element has the wrong type
   */
  protected abstract Table<String, Integer, C> create(@Nullable Object... data);

  protected void assertSize(int expectedSize) {
    assertEquals(expectedSize, table.size());
  }

  @Override
  public void setUp() throws Exception {
    super.setUp();
    table = create();
  }

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.util.logging.Logger;

public class ContentCache implements Closeable {

    protected static final Logger logger = Logger.getLogger(ContentCache.class.getName());

    private final byte[] data;

    private final File file;

    public ContentCache(final byte[] data) {
        this.data = data;

        new ConcurrentNavigableMapTestSuiteBuilder<>();
    result.usingGenerator(generator);
    return result;
  }

  @SuppressWarnings("rawtypes") // class literals
  @Override
  protected List<Class<? extends AbstractTester>> getTesters() {
    List<Class<? extends AbstractTester>> testers = copyToList(super.getTesters());
    testers.addAll(ConcurrentMapTestSuiteBuilder.TESTERS);
    return testers;
  }