/**
 */
@Named
@Singleton
@Deprecated
public class DefaultArtifactRepositoryFactory implements ArtifactRepositoryFactory {
    // TODO use settings?
    private String globalUpdatePolicy;

    private String globalChecksumPolicy;

    @Inject
    private Map<String, ArtifactRepositoryLayout> repositoryLayouts;

    public ArtifactRepositoryLayout getLayout(String layoutId) throws UnknownRepositoryLayoutException {

 * available in JDK11 or Conscrypt.
 */
private val TLS_13 =
  ConnectionSpec.Builder(true)
    .cipherSuites(*TLS13_CIPHER_SUITES.toTypedArray())
    .tlsVersions(TlsVersion.TLS_1_3)
    .build()

private val TLS_12 =
  ConnectionSpec.Builder(ConnectionSpec.RESTRICTED_TLS)
    .tlsVersions(TlsVersion.TLS_1_2)
    .build()

private fun testClient(
  urls: List<String>,
  client: OkHttpClient,
) {

import org.dbflute.util.DfTypeUtil;

/**
 * @author FreeGen
 */
public class UserBhv extends BsUserBhv {

    private static final String ROLES = "roles";
    private static final String GROUPS = "groups";
    private static final String PASSWORD = "password";
    private static final String NAME = "name";

    private String indexName = null;

    @Override
    protected String asEsIndex() {
        if (indexName == null) {

    private ServerMessageBlock response;

    private Configuration config;

    private Long expiration;

    private Exception exception;

    private boolean isError;

    private byte[] rawPayload;

    private boolean retainPayload;

    private String fullPath;
    private String server;
    private String domain;

    private Integer overrideTimeout;

      byteCount = buffer.size
      buffer.clear()
    }

    return byteCount
  }

  class Builder
    @JvmOverloads
    constructor(private val charset: Charset? = null) {
      private val names = mutableListOf<String>()
      private val values = mutableListOf<String>()

      fun add(
        name: String,
        value: String,
      ) = apply {
        names +=

    private final Logger log = LoggerFactory.getLogger(getClass());

    private final DefaultPluginDependenciesResolver pluginDependenciesResolver;

    private final RepositorySystemSessionFactory repositorySystemSessionFactory;

    private final CoreExports coreExports;

    private final ClassWorld classWorld;

    private final ClassRealm parentRealm;

/**
 */
@PlexusTest
@Deprecated
class DefaultWagonManagerTest {
    @Inject
    private WagonManager wagonManager;

    private final TransferListener transferListener = new Debug();

    @Inject
    private ArtifactFactory artifactFactory;

    @Inject
    private ArtifactRepositoryFactory artifactRepositoryFactory;

    @Test
    void testUnnecessaryRepositoryLookup() throws Exception {

   */
  private var executeCallCount = 0
  private var runCallCount = 0

  /** Queues with tasks that are currently executing their [TaskQueue.activeTask]. */
  private val busyQueues = mutableListOf<TaskQueue>()

  /** Queues not in [busyQueues] that have non-empty [TaskQueue.futureTasks]. */
  private val readyQueues = mutableListOf<TaskQueue>()

  private val runnable: Runnable =
    object : Runnable {

                reportConfigurationOf(getRichReport())
        );
    }

    private static RichReport.Configuration reportConfigurationOf(Provider<RichReport> report) {
        if (report.isPresent()) {
            return report.get().toConfiguration();
        }
        return null;
    }

    private static File maybeFile(RegularFileProperty property) {
        if (property.isPresent()) {

/**
 * Container capsule backed by Plexus Container.
 */
public class PlexusContainerCapsule implements ContainerCapsule {
    private final ClassLoader previousClassLoader;
    private final PlexusContainer plexusContainer;
    private final Lookup lookup;

    public PlexusContainerCapsule(ClassLoader previousClassLoader, PlexusContainer plexusContainer) {