// Test registerSmbURLHandler when java.protocol.handler.pkgs is null
        System.clearProperty("java.protocol.handler.pkgs");
        SingletonContext.registerSmbURLHandler();
        assertEquals("jcifs", System.getProperty("java.protocol.handler.pkgs"));
    }

    @Test
    void testRegisterSmbURLHandlerWhenPkgsDoesNotContainJcifs() {

     * @throws ConfigPropertyNotFoundException When the property is not found.
     */
    String get(String propertyKey);

    /**
     * Is the property true?
     * @param propertyKey The key of the property which is boolean type. (NotNull)
     * @return The determination, true or false. (if not found, exception)
     * @throws ConfigPropertyNotFoundException When the property is not found.
     */

import kotlin.metadata.jvm.signature
import kotlin.metadata.visibility


internal
fun KotlinClassMetadata.hasAttribute(memberType: MemberType, jvmSignature: String, predicate: AttributePredicate): Boolean =
    when (this) {
        is KotlinClassMetadata.Class -> hasClassAttribute(this::kmClass, memberType, jvmSignature, predicate)
        is KotlinClassMetadata.FileFacade -> hasPackageAttribute(this::kmPackage, memberType, jvmSignature, predicate)

			t.Errorf("errors happened when query before user: %v", err)
		}
		CheckUser(t, first, *users[0])

		if err := DB.Where("id = ?", users[2].ID).First(&last).Error; err != nil {
			t.Errorf("errors happened when query after user: %v", err)
		}
		CheckUser(t, last, *users[2])
	}

	if err := DB.Create(&users).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	} else if user.ID == 0 {

	TTL      uint32      `json:"ttl,omitempty"`

	// Holds info about when the entry was created first.
	CreationDate time.Time `json:"creationDate"`

	// When a SRV record with a "Host: IP-address" is added, we synthesize
	// a srv.Target domain name.  Normally we convert the full Key where
	// the record lives to a DNS name and use this as the srv.Target. When
	// TargetStrip > 0 we strip the left most TargetStrip labels from the

 */
class Route(
  @get:JvmName("address") val address: Address,
  /**
   * Returns the [Proxy] of this route.
   *
   * **Warning:** This may disagree with [Address.proxy] when it is null. When the address's proxy
   * is null, the proxy selector is used.
   */
  @get:JvmName("proxy") val proxy: Proxy,
  @get:JvmName("socketAddress") val socketAddress: InetSocketAddress,
) {

    void testSetResolveInDfs() {
        // Test with mock
        doNothing().when(requestWithPath).setResolveInDfs(true);
        requestWithPath.setResolveInDfs(true);
        verify(requestWithPath, times(1)).setResolveInDfs(true);

        doNothing().when(requestWithPath).setResolveInDfs(false);
        requestWithPath.setResolveInDfs(false);

    val sectionList = result.getOrPut(section) { mutableListOf() }

    sectionList +=
      when (mapping.type) {
        TYPE_MAPPED ->
          run {
            val deltaMapping = inlineDeltaOrNull(mapping)
            if (deltaMapping != null) {
              return@run deltaMapping
            }

            when (mapping.mappedTo.size) {
              1 -> MappedRange.Inline1(rangeStart, mapping.mappedTo)

/**
 * Simple non-reflection SocketAdapter for Conscrypt when included as an application dependency
 * directly.
 */
class ConscryptSocketAdapter : SocketAdapter {
  override fun matchesSocket(sslSocket: SSLSocket): Boolean = Conscrypt.isConscrypt(sslSocket)

  override fun isSupported(): Boolean = isSupported

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    when {

    fun prepNightlyTaskName() = nightlyTaskName("prep")

    fun promoteMilestoneTaskName(): String =
        when {
            isRelease -> "promoteReleaseMilestone"
            else -> "promoteMilestone"
        }

    fun promoteFinalReleaseTaskName(): String =
        when {
            isMaster -> throw UnsupportedOperationException("No final release job on master branch")