@Override
              public Deque<?> apply(Deque delegate) {
                return wrap((Deque<?>) delegate);
              }
            });
  }

  private static <T> Deque<T> wrap(Deque<T> delegate) {
    return new ForwardingDeque<T>() {
      @Override
      protected Deque<T> delegate() {
        return delegate;
      }
    };
  }

              public ListIterator<?> apply(ListIterator delegate) {
                return wrap((ListIterator<?>) delegate);
              }
            });
  }

  private static <T> ListIterator<T> wrap(ListIterator<T> delegate) {
    return new ForwardingListIterator<T>() {
      @Override
      protected ListIterator<T> delegate() {
        return delegate;
      }
    };
  }

  }

  @Override
  public boolean wasStreamOpened() {
    return byteSource.wasStreamOpened();
  }

  @Override
  public boolean wasStreamClosed() {
    return byteSource.wasStreamClosed();
  }

  @Override
  public Reader openStream() throws IOException {
    return new InputStreamReader(byteSource.openStream(), UTF_8);
  }

  }

  @GwtIncompatible // java.util.BitSet
  private static BitSet bitSet(String chars) {
    return bitSet(chars.toCharArray());
  }

  @GwtIncompatible // java.util.BitSet
  private static BitSet bitSet(char[] chars) {
    BitSet tmp = new BitSet();
    for (char c : chars) {
      tmp.set(c);
    }
    return tmp;
  }

  @GwtIncompatible // java.util.Random, java.util.BitSet

  public void testToString_minimal() {
    assertNotNull("toString() should not return null", getMap().toString());
  }

  @CollectionSize.Require(ZERO)
  @CollectionFeature.Require(absent = NON_STANDARD_TOSTRING)
  public void testToString_size0() {
    assertEquals("emptyMap.toString should return {}", "{}", getMap().toString());
  }

  @CollectionSize.Require(ONE)

    private static String getResultMessage(final int result) {
        return result < 4 ? result_message[result] : "0x" + jcifs.util.Hexdump.toHexString(result, 4);
    }

    @Override
    public DcerpcException getResult() {
        if (this.result != 0) {
            return new DcerpcException(getResultMessage(this.result));
        }
        return null;
    }

    private DcerpcBinding binding;

    static String getResultMessage(final int result) {
        return result < 4 ? result_message[result] : "0x" + jcifs.smb1.util.Hexdump.toHexString(result, 4);
    }

    @Override
    public DcerpcException getResult() {
        if (result != 0) {
            return new DcerpcException(getResultMessage(result));
        }
        return null;
    }

    DcerpcBinding binding;
    int max_xmit, max_recv;

  }

  public void testSetValue_simpleThreaded() throws Exception {
    SettableFuture<Integer> future = SettableFuture.create();
    assertTrue(future.set(42));
    // Later attempts to set the future should return false.
    assertFalse(future.set(23));
    assertFalse(future.setException(new Exception("bar")));
    assertFalse(future.setFuture(SettableFuture.<Integer>create()));
    // Check that the future has been set properly.

    /**
     * Retrieves a client that matches the given URL key.
     * @param urlKey The URL key to match.
     * @return The matching CrawlerClient instance, or null if no match is found.
     */
    public CrawlerClient getClient(final String urlKey) {
        if (StringUtil.isBlank(urlKey)) {
            return null;
        }

        for (final Map.Entry<Pattern, CrawlerClient> entry : clientMap.entrySet()) {

        assertEquals("def", headerMap.get("X-Def"));
    }

    private FessConfig createFessConfigWithResponseHeaders(final String text) {
        return new FessConfig.SimpleImpl() {
            @Override
            public String getResponseHeaders() {
                return text;
            }
        };
    }