return suite;
  }

  private static TestStringMultisetGenerator concurrentHashMultisetGenerator() {
    return new TestStringMultisetGenerator() {
      @Override
      protected Multiset<String> create(String[] elements) {
        return ConcurrentHashMultiset.create(asList(elements));
      }
    };
  }

  private static TestStringMultisetGenerator concurrentSkipListMultisetGenerator() {

class TaskRunnerTest {
  private val taskFaker = TaskFaker()

  @RegisterExtension @JvmField
  val testLogHandler = TestLogHandler(taskFaker.logger)

  private val taskRunner = taskFaker.taskRunner
  private val log = mutableListOf<String>()
  private val redQueue = taskRunner.newQueue()
  private val blueQueue = taskRunner.newQueue()
  private val greenQueue = taskRunner.newQueue()

  @AfterEach

import org.lastaflute.job.LaJobRuntime;
import org.lastaflute.job.LaScheduledJob;
import org.lastaflute.job.key.LaJobUnique;
import org.lastaflute.job.subsidiary.CronParamsSupplier;

public class JobHelper {
    private static final Logger logger = LogManager.getLogger(JobHelper.class);

    protected int monitorInterval = 60 * 60;// 1hour

    protected ThreadLocal<LaJobRuntime> jobRuntimeLocal = new ThreadLocal<>();

 *
 * @author Joshua O'Madadhain
 * @since 20.0
 */
@Beta
@Immutable
@ElementTypesAreNonnullByDefault
public final class ElementOrder<T> {
  private final Type type;

  @SuppressWarnings("Immutable") // Hopefully the comparator provided is immutable!
  @CheckForNull
  private final Comparator<T> comparator;

  /**
   * The type of ordering that this object specifies.
   *
   * <ul>

 *
 * @author Joshua O'Madadhain
 * @since 20.0
 */
@Beta
@Immutable
@ElementTypesAreNonnullByDefault
public final class ElementOrder<T> {
  private final Type type;

  @SuppressWarnings("Immutable") // Hopefully the comparator provided is immutable!
  @CheckForNull
  private final Comparator<T> comparator;

  /**
   * The type of ordering that this object specifies.
   *
   * <ul>

  @Override
  public double doubleValue() {
    return (double) sum();
  }

  private void writeObject(ObjectOutputStream s) throws IOException {
    s.defaultWriteObject();
    s.writeLong(sum());
  }

  private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
    s.defaultReadObject();
    busy = 0;
    cells = null;

                }
            }
            throw e;
        }
    }

    public static class FtpInfo {

        private static final int DEFAULT_FTP_PORT = 21;

        private URL uri;

        private String parent;

        private String name;

        public FtpInfo(final String s) {
            try {
                uri = new URL(normalize(s));

 */
package jcifs.spnego;


import jcifs.CIFSException;


/**
 * @author mbechler
 *
 */
public class SpnegoException extends CIFSException {

    /**
     * 
     */
    private static final long serialVersionUID = -4591854684249021395L;


    /**
     * 
     */
    public SpnegoException () {
        super();
    }


    /**
     * @param message
     * @param cause

 */
package jcifs.util.transport;


/**
 * @author mbechler
 *
 */
public class RequestTimeoutException extends TransportException {

    /**
     * 
     */
    private static final long serialVersionUID = -8825922797594232534L;


    /**
     * 
     */
    public RequestTimeoutException () {
        super();
    }


    /**
     * @param msg

import org.apache.maven.artifact.resolver.DefaultArtifactResolver;

@Named("classpath")
@Singleton
@Deprecated
public class TestArtifactResolver extends DefaultArtifactResolver {
    private ArtifactMetadataSource source;

    @Inject
    public TestArtifactResolver(final @Named("classpath") ArtifactMetadataSource source) {
        this.source = source;
    }