}

    @Override
    public boolean equals(@Nullable Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return super.equals(object);
    }

    @Override
    public K getKey() {
      assertTrue(Thread.holdsLock(mutex));
      return super.getKey();
    }

    @Override
    public V getValue() {
      assertTrue(Thread.holdsLock(mutex));
      return super.getValue();
    }

    @Override

        final String content = tarExtractor.getText(in, null).getContent();
        CloseableUtil.closeQuietly(in);
        logger.info(content);
        assertTrue(content.contains("テスト"));
        assertTrue(content.contains("テキスト"));
    }

    public void test_getText_maxSize() throws IOException {
        try (final InputStream in = ResourceUtil.getResourceAsStream("extractor/tar/test.tar")) {

  }

  public void testIsConnected() {
    assertTrue(Range.closed(3, 5).isConnected(Range.open(5, 6)));
    assertTrue(Range.closed(3, 5).isConnected(Range.closed(5, 6)));
    assertTrue(Range.closed(5, 6).isConnected(Range.closed(3, 5)));
    assertTrue(Range.closed(3, 5).isConnected(Range.openClosed(5, 5)));
    assertTrue(Range.open(3, 5).isConnected(Range.closed(5, 6)));
    assertTrue(Range.closed(3, 7).isConnected(Range.open(6, 8)));

    File i18nFile = getTestFile("i18n.txt");
    assertTrue(Files.equal(i18nFile, temp));
  }

  public void testTouch() throws IOException {
    File temp = createTempFile();
    assertTrue(temp.exists());
    assertTrue(temp.delete());
    assertFalse(temp.exists());
    Files.touch(temp);
    assertTrue(temp.exists());
    Files.touch(temp);
    assertTrue(temp.exists());

    assertThrows(

import static org.junit.jupiter.api.Assertions.assertTrue;

@PlexusTest
@Deprecated
class TransformationManagerTest {
    @Inject
    ArtifactTransformationManager tm;

    @Test
    void testTransformationManager() {
        List<ArtifactTransformation> tms = tm.getArtifactTransformations();

        assertEquals(3, tms.size());

        assertTrue(

      assertFalse(name, domain.isPublicSuffix());
      assertTrue(name, domain.hasPublicSuffix());
      assertTrue(name, domain.isUnderPublicSuffix());
    }
  }

  public void testUnderPublicSuffix() {
    for (String name : SOMEWHERE_UNDER_PS) {
      final InternetDomainName domain = InternetDomainName.from(name);
      assertFalse(name, domain.isPublicSuffix());
      assertTrue(name, domain.hasPublicSuffix());

    assertTrue("addAll(n, hasDuplicates) should return true", getList().addAll(0, elementsToAdd));
    expectAdded(0, e0(), e1(), e0(), e1());
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  @CollectionFeature.Require(ALLOWS_NULL_VALUES)
  public void testAddAllAtIndex_nullSupported() {
    List<E> containsNull = singletonList(null);

    @Override
    public boolean offer(E o) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.offer(o);
    }

    @Override
    public @Nullable E poll() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.poll();
    }

    @Override
    public E remove() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove();
    }

    @Override

    assertTrue(TypeToken.of(char[][].class).isArray());
    assertTrue(TypeToken.of(byte[].class).isArray());
    assertTrue(TypeToken.of(short[].class).isArray());
    assertTrue(TypeToken.of(int[].class).isArray());
    assertTrue(TypeToken.of(long[].class).isArray());
    assertTrue(TypeToken.of(float[].class).isArray());
    assertTrue(TypeToken.of(double[].class).isArray());

        values = "http://www.foo.com/";
        assertTrue(UriTypeValidator.check(protocols, values));

        protocols = new String[] { "http:" };
        values = "http://www.foo.com/\nhttp://www.bar.com/";
        assertTrue(UriTypeValidator.check(protocols, values));

        protocols = new String[] { "http:" };
        values = "http://www.foo.com/ \r\nhttp://www.bar.com/";
        assertTrue(UriTypeValidator.check(protocols, values));