}

  private void setSuccessor(int entry, int succ) {
    long succMask = (~0L) >>> 32;
    setLink(entry, (link(entry) & ~succMask) | ((succ + 1) & succMask));
  }

  private void setPredecessor(int entry, int pred) {
    long predMask = ~0L << 32;
    setLink(entry, (link(entry) & ~predMask) | ((long) (pred + 1) << 32));
  }

  private void setSucceeds(int pred, int succ) {

 */
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
final class Java8Compatibility {
  static void clear(Buffer b) {
    b.clear();
  }

  static void flip(Buffer b) {
    b.flip();
  }

  static void limit(Buffer b, int limit) {
    b.limit(limit);
  }

  static void position(Buffer b, int position) {
    b.position(position);
  }

  private Java8Compatibility() {}

public class QueueOfferTester<E> extends AbstractQueueTester<E> {
  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testOffer_supportedNotPresent() {
    assertTrue("offer(notPresent) should return true", getQueue().offer(e3()));
    expectAdded(e3());
  }

  @CollectionFeature.Require({SUPPORTS_ADD, ALLOWS_NULL_VALUES})
  public void testOffer_nullSupported() {
    assertTrue("offer(null) should return true", getQueue().offer(null));

        return fileInputStream.available();
    }

    @Override
    public void close() throws IOException {
        try {
            fileInputStream.close();
        } finally {
            FileUtil.deleteInBackground(tempFile);
        }
    }

    @Override
    public synchronized void mark(final int readlimit) {
        fileInputStream.mark(readlimit);
    }

    @Override

  public void testBigToDouble() {
    for (BigInteger b : ALL_BIGINTEGER_CANDIDATES) {
      if (b.doubleValue() != DoubleUtils.bigToDouble(b)) {
        failFormat(
            "Converting %s to double: expected doubleValue %s but got bigToDouble %s",
            b, b.doubleValue(), DoubleUtils.bigToDouble(b));
      }
    }
  }

  public void testEnsureNonNegative() {

    }

    public void setMd(ArtifactMetadata md) {
        this.md = md;
    }

    public MetadataTreeNode getParent() {
        return parent;
    }

    public void setParent(MetadataTreeNode parent) {
        this.parent = parent;
    }

    public MetadataTreeNode[] getChildren() {
        return children;
    }

    public void setChildren(MetadataTreeNode[] children) {

public class MultimapKeySetTester<K, V> extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  public void testKeySet() {
    for (Entry<K, V> entry : getSampleElements()) {
      assertTrue(multimap().keySet().contains(entry.getKey()));
    }
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(ALLOWS_NULL_KEYS)
  public void testKeySetContainsNullKeyPresent() {
    initMultimapWithNullKey();

  public void testCustomEscaper_withpercent() {
    UnicodeEscaper e = new PercentEscaper("%", false);
    assertEquals("foo%7Cbar", e.escape("foo|bar"));
    assertEquals("foo%7Cbar", e.escape("foo%7Cbar")); // idempotent
  }

  /** Test that giving a null 'safeChars' string causes a {@link NullPointerException}. */
  public void testBadArguments_null() {

     * {@link Element}の文字列表現を追加します。
     *
     * @param element
     *            要素。{@literal null}であってはいけません
     * @param buf
     *            文字列バッファ。{@literal null}であってはいけません
     */
    public static void appendElement(final Element element, final StringBuilder buf) {
        assertArgumentNotNull("element", element);
        assertArgumentNotNull("buf", buf);

        final String tag = element.getTagName();

            @Override
            public void transferInitiated(TransferEvent transferEvent) {
                events.add(transferEvent);
            }
        }

        TransferListener listener = new TransferListener();
        wagonManager.getArtifact(artifact, repos, listener, false);
        assertEquals(1, listener.events.size());
    }

    @Test