logger.debug("Using {} for detected MIME type {}, not {}", extractor.getClass().getName(), detectedMimeType, mimeType);
                }
            } else if (logger.isDebugEnabled()) {
                logger.debug("Using {} for MIME type {}", extractor.getClass().getName(), mimeType);
            }

            if (maxContentLength < 0) {

        // When
        NetbiosName localName = nameServiceClient.getLocalName();

        // Then
        assertNotNull(localName, "Local name should not be null");
        assertTrue(localName.getName().length() > 0, "Local name should not be empty");
    }

    @Test
    @DisplayName("Should get unknown name")
    void testGetUnknownName() {
        // When

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public final class LoggingInterceptors {
  private static final Logger logger = Logger.getLogger(LoggingInterceptors.class.getName());
  private final OkHttpClient client = new OkHttpClient.Builder()
      .addInterceptor(new LoggingInterceptor())
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()

            return this
        }
        return new MethodDoc(refererMetaData, metaData, comment)
    }

    String getId() {
        return id
    }

    String getName() {
        return metaData.name
    }

    MethodMetaData getMetaData() {
        return metaData
    }

    boolean isDeprecated() {
        return metaData.deprecated && !referringClass.deprecated
    }

    }

    protected void mergeModel_Name(Model target, Model source, boolean sourceDominant, Map<Object, Object> context) {
        String src = source.getName();
        if (src != null) {
            if (sourceDominant || target.getName() == null) {
                target.setName(src);
                target.setLocation("name", source.getLocation("name"));
            }
        }
    }

    for (Class<?> cls : classes) {
      classMap.put(cls.getName(), cls);
    }
    // Foo.class -> [FooTest.class, FooTests.class, FooTestSuite.class, ...]
    Multimap<Class<?>, Class<?>> testClasses = HashMultimap.create();
    LinkedHashSet<Class<?>> candidateClasses = new LinkedHashSet<>();
    for (Class<?> cls : classes) {
      Optional<String> testedClassName = TEST_SUFFIX.chop(cls.getName());
      if (testedClassName.isPresent()) {

     * @param fe
     * @return
     * @throws MalformedURLException
     */
    @Override
    protected SmbResource adapt(final FileEntry e) throws MalformedURLException {
        return new SmbFile(getParent(), e.getName(), false, e.getType(), SmbConstants.ATTR_READONLY | SmbConstants.ATTR_DIRECTORY, 0L, 0L,
                0L, 0L);
    }

 *
 * @author Luiz-Otavio Zorzella
 * @since 10.0
 */
@GwtCompatible
@NullMarked
public abstract class SloppyTearDown implements TearDown {
  private static final Logger logger = Logger.getLogger(SloppyTearDown.class.getName());

  @Override
  public final void tearDown() {
    try {
      sloppyTearDown();
    } catch (Throwable t) {
      logger.log(Level.INFO, "exception thrown during tearDown: " + t.getMessage(), t);
    }
  }

/**
 */
@Deprecated
public abstract class AbstractProjectInheritanceTestCase extends AbstractMavenProjectTestCase {
    protected String getTestSeries() {
        String className = getClass().getPackage().getName();

        return className.substring(className.lastIndexOf('.') + 1);
    }

    protected File projectFile(String name) {
        return projectFile("maven", name);
    }

@Deprecated
public interface ModelInterpolator {
    String DEFAULT_BUILD_TIMESTAMP_FORMAT = "yyyyMMdd-HHmm";

    String BUILD_TIMESTAMP_FORMAT_PROPERTY = "maven.build.timestamp.format";

    String ROLE = ModelInterpolator.class.getName();

    /**
     * @deprecated Use {@link ModelInterpolator#interpolate(Model, File, ProjectBuilderConfiguration, boolean)} instead.
     */
    @Deprecated