public TearDownStack(boolean suppressThrows) {
    this.suppressThrows = suppressThrows;
  }

  @Override
  public final void addTearDown(TearDown tearDown) {
    synchronized (lock) {
      stack.addFirst(checkNotNull(tearDown));
    }
  }

  /** Causes teardown to execute. */
  public final void runTearDown() {
    Throwable exception = null;
    List<TearDown> stackCopy;
    synchronized (lock) {

  public TearDownStack(boolean suppressThrows) {
    this.suppressThrows = suppressThrows;
  }

  @Override
  public final void addTearDown(TearDown tearDown) {
    synchronized (lock) {
      stack.addFirst(checkNotNull(tearDown));
    }
  }

  /** Causes teardown to execute. */
  public final void runTearDown() {
    Throwable exception = null;
    List<TearDown> stackCopy;
    synchronized (lock) {

  MultiReader(Iterator<? extends CharSource> readers) throws IOException {
    this.it = readers;
    advance();
  }

  /** Closes the current reader and opens the next one, if any. */
  private void advance() throws IOException {
    close();
    if (it.hasNext()) {
      current = it.next().openStream();
    }
  }

  @Override
  public int read(char[] cbuf, int off, int len) throws IOException {

/**
 */
@Deprecated
class DefaultMavenMetadataCacheTest {
    private RepositorySystem repositorySystem;

    @BeforeEach
    void setUp() {
        repositorySystem = new TestRepositorySystem();
    }

    @Test
    void testCacheKey() throws Exception {
        Artifact a1 = repositorySystem.createArtifact("testGroup", "testArtifact", "1.2.3", "jar");
        @SuppressWarnings("deprecation")

     * @deprecated to be removed before 2.0 after the install/deploy plugins use the alternate
     *             method
     */
    @Deprecated
    void deploy(
            String basedir,
            String finalName,
            Artifact artifact,
            ArtifactRepository deploymentRepository,
            ArtifactRepository localRepository)

     * All existing client mappings will be loaded into the new factory.
     * @param crawlerClientFactory The CrawlerClientFactory to register.
     */
    public synchronized void register(final CrawlerClientFactory crawlerClientFactory) {
        clientMap.entrySet().stream().forEach(e -> load(crawlerClientFactory, e.getKey(), e.getValue()));
        clientFactoryList.add(crawlerClientFactory);

     * @param method the HTTP method
     */
    public void setMethod(final Method method) {
        this.method = method;
    }

    /**
     * Sets the HTTP method for this request using a string value.
     * Defaults to GET if the method is not recognized.
     * @param method the HTTP method as a string
     */
    public void setMethod(final String method) {
        if (Constants.GET_METHOD.equals(method)) {

    }

    /**
     * @throws Exception
     */
    public void testToBigDecimalForEmptyString() throws Exception {
        assertNull(BigDecimalConversionUtil.toBigDecimal(""));
    }

    /**
     * @throws Exception
     */
    public void testBigDouble() throws Exception {
        assertEquals("12500000", BigDecimalConversionUtil.toBigDecimal(12500000D).toString());
    }

  /** Updates this hasher with the given byte. */
  protected abstract void update(byte b);

  /** Updates this hasher with the given bytes. */
  protected void update(byte[] b) {
    update(b, 0, b.length);
  }

  /** Updates this hasher with {@code len} bytes starting at {@code off} in the given buffer. */
  protected void update(byte[] b, int off, int len) {
    for (int i = off; i < off + len; i++) {

import jcifs.dcerpc.rpc.policy_handle;

class MsrpcSamrCloseHandleTest {

    @Mock
    private policy_handle mockPolicyHandle;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void constructorShouldInitializeCorrectly() {
        // Given
        // mockPolicyHandle is already mocked by @Mock and initialized by @BeforeEach

        // When