import org.codelibs.core.exception.ConverterRuntimeException;

/**
 * Options to specify when copying JavaBeans or {@link Map} using {@link BeanUtil}.
 *
 * @author higa
 */
public class CopyOptions {

    /**
     * Creates a new {@link CopyOptions} instance.
     */
    public CopyOptions() {
    }

    /**
     * Default converter for dates.
     */

        }
        phase.links().forEach(link -> {
            if (link.pointer().type() == Lifecycle.Pointer.Type.PROJECT) {
                if (link.kind() == Lifecycle.Link.Kind.AFTER) {
                    graph.addEdge(graph.addVertex(link.pointer().phase()), ep0);
                } else {
                    graph.addEdge(ep3, graph.addVertex(BEFORE + link.pointer().phase()));
                }
            }

    /**
     * Builds the effective toolchains for the specified toolchains sources.
     *
     * @param session the {@link Session}, must not be {@code null}
     * @param installationToolchainsFile The {@link Source} pointing to the installation toolchains, must not be {@code null}
     * @param userToolchainsSource The {@link Source} pointing to the user toolchains, must not be {@code null}

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Most of the logic for {@link IteratorTester} and {@link ListIteratorTester}.
 *
 * @param <E> the type of element returned by the iterator
 * @param <I> the type of the iterator ({@link Iterator} or {@link ListIterator})
 * @author Kevin Bourrillion
 * @author Chris Povirk
 */
@GwtCompatible
@NullMarked

            tr.appendChild(td);
            Element literal = document.createElement("literal");
            td.appendChild(literal);
            Element link = document.createElement("link");
            literal.appendChild(link);
            link.setAttribute("linkend", methodDoc.getId());
            link.appendChild(document.createTextNode(methodDoc.getName()));
            StringBuilder signature = new StringBuilder();
            signature.append("(");

        this.targetClass = targetClass;
        this.methodName = methodName;
        this.methodArgClasses = methodArgClasses;
    }

    /**
     * Returns the {@link Class} of the target.
     *
     * @return {@link Class} of the target
     */
    public Class<?> getTargetClass() {
        return targetClass;
    }

    /**
     * Returns the method name.
     *
     * @return Method name

  /**
   * Compares the specified object with this instance for equality. Returns {@code true} if the
   * given object is also a {@code MapDifference} and the values returned by the {@link
   * #entriesOnlyOnLeft()}, {@link #entriesOnlyOnRight()}, {@link #entriesInCommon()} and {@link
   * #entriesDiffering()} of the two instances are equal.
   */
  @Override
  boolean equals(@Nullable Object object);

  /**

import jcifs.CIFSException;
import jcifs.config.PropertyConfiguration;
import jcifs.internal.smb1.SMB1SigningDigest;
import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * Tests for the {@link SmbComClose} class.
 */
public class SmbComCloseTest {

    private CIFSContext context;
    private PropertyConfiguration config;

    @BeforeEach
    public void setUp() throws CIFSException {

 * without changing the iterator's state, using the {@link #hasNext} method. But many data sources,
 * such as {@link java.io.Reader#read()}, do not expose this information; the only way to discover
 * whether there is any data left is by trying to retrieve it. These types of data sources are
 * ordinarily difficult to write iterators for. But using this class, one must implement only the

 *       {@link Hasher}), but this is merely a convenience; these are always translated into raw
 *       byte sequences under the covers.
 *   <li><b>hash code:</b> each hash function always yields hash codes of the same fixed bit length
 *       (given by {@link #bits}). For example, {@link Hashing#sha1} produces a 160-bit number,