import java.util.Date;

import jcifs.smb1.util.Hexdump;
import jcifs.smb1.util.LogStream;
import jcifs.smb1.util.transport.Request;
import jcifs.smb1.util.transport.Response;

abstract class ServerMessageBlock extends Response implements Request, SmbConstants {

    static LogStream log = LogStream.getInstance();

     * @param <V> the value type of {@link EnumMap}
     * @param keyType the class object of the key type for this {@literal enum} map
     * @return a new instance of {@link EnumMap}
     * @see EnumMap#EnumMap(Class)
     */
    public static <K extends Enum<K>, V> EnumMap<K, V> newEnumMap(final Class<K> keyType) {
        return new EnumMap<>(keyType);
    }

    /**

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.codelibs.fess.Constants;
import org.codelibs.fess.opensearch.config.exentity.PathMapping;
import org.codelibs.fess.unit.UnitFessTestCase;

public class PathMappingHelperTest extends UnitFessTestCase {

    public PathMappingHelper pathMappingHelper;

    @Override
    public void setUp() throws Exception {
        super.setUp();

elif set_java_home; then
  verbose "Falling back to use Java to download"
  javaSource="$TMP_DOWNLOAD_DIR/Downloader.java"
  targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName"
  cat >"$javaSource" <<-END
	public class Downloader extends java.net.Authenticator
	{
	  protected java.net.PasswordAuthentication getPasswordAuthentication()
	  {

import java.util.concurrent.atomic.AtomicReference;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * @author Charles Fry
 */
@NullUnmarked
public class LocalLoadingCacheTest extends TestCase {

  private static <K, V> LocalLoadingCache<K, V> makeCache(
      CacheBuilder<K, V> builder, CacheLoader<? super K, V> loader) {
    return new LocalLoadingCache<>(builder, loader);

        return create(maxCountLimit, p -> true);
    }

    /**
     * Default implementation of the ProblemCollector interface.
     *
     * @param <P> the type of problem
     */
    class Impl<P extends BuilderProblem> implements ProblemCollector<P> {

        private final int maxCountLimit;
        private final AtomicInteger totalCount;

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

import org.codelibs.fess.unit.UnitFessTestCase;

public class WebApiExceptionTest extends UnitFessTestCase {

    public void test_constructor_withStatusCodeAndMessage() {
        // Test constructor with status code and message
        int statusCode = 404;

        differences between them.


        Additionally, it's very useful to us if you can provide a "straw API" — what the
        method signatures would look like, for example, even if the method and class names are still
        in flux. This can make the feature you're suggesting much clearer to us.

  - type: textarea
    attributes:
      label: (Optional) What would the method signatures for your feature look like?

/**
 * Benchmarks against the Apache Commons Math utilities.
 *
 * <p>Note: the Apache benchmarks are not open sourced to avoid the extra dependency.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class ApacheBenchmark {
  private enum Impl {
    GUAVA {
      @Override
      public double factorialDouble(int n) {
        return DoubleMath.factorial(n);
      }

      @Override

import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Unit test for Fingerprint2011.
 *
 * @author ******@****.*** (Kyle Maddison)
 */
@NullUnmarked
public class Fingerprint2011Test extends TestCase {

  // Length of the sample string to produce
  private static final int MAX_BYTES = 1000;

  // Map from sample string lengths to the fingerprint