return configureSocket(socket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
  ): Socket {
    val socket = delegate.createSocket(host, port)
    return configureSocket(socket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
    localAddress: InetAddress,
    localPort: Int,
  ): Socket {

     * @param cause The cause.
     */
    public LdapOperationException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new LDAP operation exception with the specified detail message.
     *
     * @param message The detail message.
     */
    public LdapOperationException(final String message) {
        super(message);
    }

 *
 * <p>This exception wraps errors that occur during toolchain creation or initialization.</p>
 */
public class ToolchainFactoryException extends MavenException {

    public ToolchainFactoryException(String message) {
        super(message);
    }

    public ToolchainFactoryException(String message, Throwable cause) {
        super(message, cause);
    }

// CheckCrossDevice - check if any input path has multiple sub-mounts.
// this is a dummy function and returns nil for now.
func CheckCrossDevice(paths []string) error {
	return nil
}

// IsLikelyMountPoint determines if a directory is a mountpoint.
func IsLikelyMountPoint(file string) bool {
	return false

        Object bn = ConfigUtils.getObject(session, null, "maven.buildNumber");
        if (bn instanceof Integer integer) {
            this.buildNumber = integer;
        } else if (bn instanceof String string) {
            this.buildNumber = Integer.valueOf(string);
        } else {
            this.buildNumber = null;
        }

        snapshots = new LinkedHashMap<>();

        /*

            final List<String> rules = Analysis.parseWordList(env, settings, "synonyms", s -> s);
            final StringBuilder sb = new StringBuilder();
            for (final String line : rules) {
                sb.append(line).append(System.getProperty("line.separator"));
            }
            reader = new StringReader(sb.toString());
        } else if (settings.get("synonyms_path") != null) {

      TlsVersion.TLS_1_2.javaName,
    )
    val expectedCipherSuites: MutableList<String> = ArrayList()
    expectedCipherSuites.add(CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.javaName)
    expectedCipherSuites.add(CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA.javaName)
    if (listOf<String>(*socket.supportedCipherSuites).contains("TLS_FALLBACK_SCSV")) {
      expectedCipherSuites.add("TLS_FALLBACK_SCSV")

    private val failedTaskPaths = CopyOnWriteArrayList<String>()
    override val collectedInformation: Serializable = failedTaskPaths

    override fun shouldInclude(taskPath: String): Boolean {
        // https://github.com/gradle/gradle/issues/21351
        return super.shouldInclude(taskPath) || taskPath.contains("detekt")
    }

    override fun action(taskPath: String, taskResult: TaskOperationResult) {

    override fun getName(): String = "IntegrationTestFixtures"

    override fun getPriority(): Int = 1

    override fun setPriority(priority: Int) {
        throw UnsupportedOperationException()
    }

    override fun setName(name: String?) {
        throw UnsupportedOperationException()
    }

    override fun getDescription(): String = "Reports incorrect usages of integration test fixtures"

        assertThat(hoge.getKeyClassOfMap(), is(sameClass(String.class)));
        assertThat(hoge.getValueClassOfMap(), is(sameClass(Integer.class)));
    }

    /**
     *
     */
    @SuppressWarnings("unused")
    public static class MyBean {
        /** */
        public static final String HOGE = "hoge";

        private Class<?> aaa;

        private List<String> list;