return toDate(src, null, LocaleUtil.getDefault());
    }

    /**
     * Converts an object to {@link Date}.
     *
     * @param src the source object
     * @param pattern the pattern string
     * @return the converted {@link Date}
     */
    public static Date toDate(final Object src, final String pattern) {
        return toDate(src, pattern, LocaleUtil.getDefault());
    }

    /**

     */
    public void testFindFractionDelimeter3() throws Exception {
        final String delim = NumberConversionUtil.findDecimalSeparator(null);
        final char c = new DecimalFormatSymbols(LocaleUtil.getDefault()).getDecimalSeparator();
        assertEquals(Character.toString(c), delim);
    }

    /**
     * @throws Exception
     */
    public void testFindIntegerDelimeter() throws Exception {

    val tlsSpec =
      ConnectionSpec
        .Builder(true)
        .tlsVersions(TlsVersion.TLS_1_2)
        .supportsTlsExtensions(false)
        .build()
    val socket = SSLSocketFactory.getDefault().createSocket() as SSLSocket
    socket.enabledCipherSuites =
      arrayOf(
        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.javaName,
        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA.javaName,

    }

    private static Predicate<Artifact> toPredicate(Exclusion exclusion) {
        PathMatcher groupId = FileSystems.getDefault().getPathMatcher("glob:" + exclusion.getGroupId());
        PathMatcher artifactId = FileSystems.getDefault().getPathMatcher("glob:" + exclusion.getArtifactId());
        Predicate<Artifact> predGroupId = a -> groupId.matches(createPathProxy(a.getGroupId()));

    proxySelector: ProxySelector = this.proxySelector,
  ): Address =
    Address(
      uriHost = uriHost,
      uriPort = uriPort,
      dns = dns,
      socketFactory = SocketFactory.getDefault(),
      sslSocketFactory = null,
      hostnameVerifier = null,
      certificatePinner = null,
      proxyAuthenticator = proxyAuthenticator,
      proxy = proxy,
      protocols = protocols,

/**
 * @author higa
 *
 */
public class LocaleUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testGetLocale() throws Exception {
        assertEquals("1", LocaleUtil.getDefault(), LocaleUtil.getLocale(null));
        assertEquals("2", Locale.JAPANESE, LocaleUtil.getLocale("ja"));
        assertEquals("3", Locale.JAPAN, LocaleUtil.getLocale("ja_JP"));
    }

                () -> {
                  throw new IOException("unrecognized FileSystem type " + FileSystems.getDefault());
                };
      }
    }

    private static PermissionSupplier userPermissions() {
      try {
        UserPrincipal user =
            FileSystems.getDefault()
                .getUserPrincipalLookupService()
                .lookupPrincipalByName(getUsername());

      override val badValue: SocketFactory =
        object : DelegatingSocketFactory(getDefault()) {
          override fun configureSocket(socket: Socket): Socket = TODO()
        }

      override fun isDefaultValue(value: SocketFactory): Boolean = value === SocketFactory.getDefault()
    }

/**
 * A [SocketFactory] that redirects connections to [defaultAddress] or specific overridden address via [set].
 */
class SpecificHostSocketFactory(
  val defaultAddress: InetSocketAddress?,
) : DelegatingSocketFactory(getDefault()) {
  private val hostMapping = mutableMapOf<InetAddress, InetSocketAddress>()

  /** Sets the [real] address for [requested].  */
  operator fun set(
    requested: InetAddress,
    real: InetSocketAddress,
  ) {

    mockWebServer.serverSocketFactory = ServerSocketFactory.getDefault()
    val url: HttpUrl = mockWebServer.url("")
    mockWebServer.bodyLimit = 0L
    mockWebServer.protocolNegotiationEnabled = false
    mockWebServer.protocols = listOf()
    val protocols: List<Protocol> = mockWebServer.protocols
    mockWebServer.useHttps(SSLSocketFactory.getDefault() as SSLSocketFactory, false)
    mockWebServer.noClientAuth()