*/
    private static class TestRequest implements Request<TestResponse> {
        private TestResponse response;
        private boolean ignoreDisconnect = false;
        private int tid = 0;
        private SMBSigningDigest digest;
        private long mid = 0;
        private int command = 0;
        private byte[] rawPayload;
        private boolean retainPayload = false;

    private final BuildPluginManager pluginManager;
    private final MavenPluginManager mavenPluginManager;
    private final LifecycleDependencyResolver lifeCycleDependencyResolver;
    private final ExecutionEventCatapult eventCatapult;

    private final OwnerReentrantReadWriteLock aggregatorLock = new OwnerReentrantReadWriteLock();

    /**
     * CacheRecord
     */
    public class CacheRecord {
        private Artifact pomArtifact;
        private Artifact relocatedArtifact;
        private List<Artifact> artifacts;
        private Map<String, Artifact> managedVersions;
        private List<ArtifactRepository> remoteRepositories;

        private long length;
        private long timestamp;

        CacheRecord(
                Artifact pomArtifact,

    private static final Logger log = LoggerFactory.getLogger(SecureCredentialStorage.class);

    private static final String ENCRYPTION_ALGORITHM = "AES/GCM/NoPadding";
    private static final String KEY_ALGORITHM = "AES";
    private static final String KEY_DERIVATION_ALGORITHM = "PBKDF2WithHmacSHA256";
    private static final int KEY_SIZE = 256;
    private static final int GCM_TAG_SIZE = 128;

    assertThat(second.toString()).contains(secondCallable.future.toString());
  }

  private static class BlockingCallable implements Callable<@Nullable Void> {
    private final CountDownLatch startLatch = new CountDownLatch(1);
    private final CountDownLatch stopLatch = new CountDownLatch(1);

    private volatile boolean running = false;

    @Override
    public @Nullable Void call() throws InterruptedException {

  }

  private static final ByteSource BROKEN_CLOSE_SOURCE =
      new TestByteSource(new byte[10], CLOSE_THROWS);
  private static final ByteSource BROKEN_OPEN_SOURCE =
      new TestByteSource(new byte[10], OPEN_THROWS);
  private static final ByteSource BROKEN_READ_SOURCE =
      new TestByteSource(new byte[10], READ_THROWS);

 */
public class ChannelManager {

    private static final Logger log = LoggerFactory.getLogger(ChannelManager.class);

    private final CIFSContext context;
    private final SmbSession session;
    private final Map<String, ChannelInfo> channels;
    private final List<NetworkInterfaceInfo> localInterfaces;
    private final List<NetworkInterfaceInfo> remoteInterfaces;
    private final ScheduledExecutorService scheduler;

private
fun matchesName(name: String, candidateName: String) =
    name == candidateName.replace(".*\\$".toRegex(), "") // strip outer class names

private
val SINCE_REGEX = Regex("""@since ([^\s]+)""")

private
fun BodyDeclaration<*>.getSince(): String? =
    comment?.orElse(null)?.content?.let { content ->
        SINCE_REGEX.find(content)?.groupValues?.get(1)
    }


private

    private String extractGoalPrefix(PlexusConfiguration c) {
        return c.getChild("goalPrefix").getValue();
    }

    private String extractName(PlexusConfiguration c) {
        return c.getChild("name").getValue();
    }

    private String extractDescription(PlexusConfiguration c) {
        return c.getChild("description").getValue();
    }

    private VirtualHostHelper virtualHostHelper;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        virtualHostHelper = new VirtualHostHelper();
    }

    @Test
    public void test_getVirtualHostPath() {
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;