@SuppressWarnings({"rawtypes", "unchecked"})
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Set.class,
            new Function<Set, Set>() {
              @Override
              public Set apply(Set delegate) {
                return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    Set<String> set1 = ImmutableSet.of("one");

            }
        }

        public void updateHash(byte[] newHash) {
            synchronized (hashLock) {
                if (newHash != null && newHash.length == currentHash.length) {
                    this.currentHash = newHash.clone();
                }
            }
        }

        public boolean isValid() {
            return isValid;
        }

        public void invalidate() {

   * @throws BucketOverflowException if this bucket has too many entries, which may indicate a hash
   *     flooding attack
   */
  private static void checkNoConflictInValueBucket(
      Object value, Entry<?, ?> entry, @Nullable ImmutableMapEntry<?, ?> valueBucketHead)
      throws BucketOverflowException {
    int bucketSize = 0;

import org.junit.Test;

/**
 * @author koichik
 */
public class ParameterizedClassDescFactoryTest {

    /**
     * @throws Exception
     */
    @Test
    public void testFieldType() throws Exception {
        final Map<TypeVariable<?>, Type> map = ParameterizedClassDescFactory.getTypeVariables(Hoge.class);
        final Field field = Hoge.class.getField("foo");

    }

    this.values = values;
  }

  @Override
  final void collectOneValue(int index, @ParametricNullness V returnValue) {
    @RetainedLocalRef List<@Nullable Present<V>> localValues = values;
    if (localValues != null) {
      localValues.set(index, new Present<>(returnValue));
    }
  }

  @Override
  final void handleAllCompleted() {
    @RetainedLocalRef List<@Nullable Present<V>> localValues = values;

     * @param charset the charset to set
     */
    public void setCharset(final String charset) {
        this.charset = charset;
    }

    /**
     * Sets the SMB authentication holder.
     *
     * @param smbAuthenticationHolder the SMB authentication holder to set
     */
    public void setSmbAuthenticationHolder(final SmbAuthenticationHolder smbAuthenticationHolder) {

        SMBUtil.writeInt4(bc, buf, 4); // ByteCount
        if (bc > 0 && errorData != null) {
            System.arraycopy(errorData, 0, buf, 8, bc);
        }
        return buf;
    }

    @Test
    void decodesErrorStructureThroughReadBytesWireFormat() throws Exception {
        // For STATUS_INVALID_PARAMETER the override makes isErrorResponseStatus() return false,

 */
package gradlebuild.docs.dsl.docbook;

import gradlebuild.docs.dsl.docbook.model.ClassDoc;
import org.w3c.dom.Element;

public interface ClassDocMemberRenderer {
    void renderSummaryTo(ClassDoc classDoc, Element parent);

    void renderDetailsTo(ClassDoc classDoc, Element parent);

    }

    /**
     * Aligns the stream position to the specified boundary.
     * @param mask the alignment mask (typically 2, 4, or 8)
     * @throws IOException if an I/O error occurs
     */
    public void align(final int mask) throws IOException {
        final int position = this.size - this.dis.available();
        final int shift = position & mask - 1;
        if (mask != 0 && shift != 0) {

     * @param handler
     *            The SAX {@link DefaultHandler} to use. Must not be {@literal null}.
     */
    public static void parse(final SAXParser parser, final InputSource inputSource, final DefaultHandler handler) {
        assertArgumentNotNull("parser", parser);
        assertArgumentNotNull("inputSource", inputSource);