return tmp.toArray(new String[0]);
  }

  static <T> Comparator<T> arbitraryNullFriendlyComparator() {
    return new NullFriendlyComparator<>();
  }

  private static final class NullFriendlyComparator<T> implements Comparator<T>, Serializable {
    @Override
    public int compare(T left, T right) {
      return String.valueOf(left).compareTo(String.valueOf(right));
    }
  }

 * result. (If you want such access, you may prefer {@link Futures#addCallback
 * Futures.addCallback}.) Still, direct {@code addListener} calls are occasionally useful:
 *
 * {@snippet :
 * final String name = ...;
 * inFlight.add(name);
 * ListenableFuture<Result> future = service.query(name);
 * future.addListener(new Runnable() {
 *   public void run() {
 *     processedCount.incrementAndGet();

 * result. (If you want such access, you may prefer {@link Futures#addCallback
 * Futures.addCallback}.) Still, direct {@code addListener} calls are occasionally useful:
 *
 * {@snippet :
 * final String name = ...;
 * inFlight.add(name);
 * ListenableFuture<Result> future = service.query(name);
 * future.addListener(new Runnable() {
 *   public void run() {
 *     processedCount.incrementAndGet();

import java.util.Properties;

import jcifs.CIFSException;
import jcifs.Configuration;

/**
 * Configuration implementation reading the classic jcifs settings from properties
 *
 * @author mbechler
 */
public final class PropertyConfiguration extends BaseConfiguration implements Configuration {

    private boolean useMultiChannelExplicitlySet = false;
    private boolean channelBindingPolicyExplicitlySet = false;

    /**

        assertOperationEquals(
            a, b, "s^", saturatedCast(valueOf(a).pow(b)), IntMath.saturatedPow(a, b));
      }
    }
  }

  private static final BigInteger MAX_INT = BigInteger.valueOf(Integer.MAX_VALUE);
  private static final BigInteger MIN_INT = BigInteger.valueOf(Integer.MIN_VALUE);

  private static int saturatedCast(BigInteger big) {
    if (big.compareTo(MAX_INT) > 0) {

// newSignV4ChunkedReader returns a new s3ChunkedReader that translates the data read from r
// out of HTTP "chunked" format before returning it.
// The s3ChunkedReader returns io.EOF when the final 0-length chunk is read.
//
// NewChunkedReader is not needed by normal applications. The http package
// automatically decodes chunking when reading response bodies.

        assertTrue(memoryLog2.contains("Mem:"));
    }

    // Custom test class for fallback object testing
    private static class CustomTestObject {
        @SuppressWarnings("unused")
        private final String field = "test";
    }

    private long getObjectSize(Object value) {
        System.setProperty("java.vm.name", "Java HotSpot(TM) ");
        return ObjectSizeCalculator.getObjectSize(value);
    }

@ExtendWith(MockitoExtension.class)
class NtlmServletTest {

    // A concrete implementation of the abstract NtlmServlet for testing purposes.
    private static class TestNtlmServlet extends NtlmServlet {
        private static final long serialVersionUID = 1L;

        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            // Do nothing - just for testing
        }

import org.codelibs.fess.unit.UnitFessTestCase;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

public class GsaConfigParserTest extends UnitFessTestCase {

    private static final Logger logger = LogManager.getLogger(GsaConfigParserTest.class);

    @Override
    public void setUp() throws Exception {
        super.setUp();
        ComponentUtil.register(new SystemHelper(), "systemHelper");
    }

 * intended to "fill the gap" and provide those features of {@code Ordering} not already provided by
 * the JDK.
 *
 * @since 21.0
 * @author Louis Wasserman
 */
@GwtCompatible
public final class Comparators {
  private Comparators() {}

  /**
   * Returns a new comparator which sorts iterables by comparing corresponding elements pairwise