"resource_api_version": "V3"
                            }
                          }
                        }
                      },
                      "require_client_certificate": true
                    }
                  },
                  "name": "default"
                }
              ]
            },
            "last_updated": "2024-03-04T08:37:44.851Z"

                              "resource_api_version": "V3"
                            }
                          }
                        }
                      },
                      "require_client_certificate": true
                    }
                  },
                  "name": "default"
                }
              ]
            },
            "last_updated": "2024-03-04T08:37:44.851Z"

                )
            }
            is FirPropertyAccessExpression, is FirCallableReferenceAccess -> {
                @Suppress("USELESS_IS_CHECK") // K2 warning suppression, TODO: KT-62472
                require(fir is FirQualifiedAccessExpression)
                when (unsubstitutedKtSignature.symbol) {
                    is KtVariableLikeSymbol -> {

   * nullness checker can already "prove" are non-null. That means that the first parameter to
   * checkNotNull *should* be annotated to require it to be non-null.
   *
   * However, for a variety of reasons, Google developers have written a ton of code over the past
   * decade that assumes that they can use checkNotNull for non-precondition checks. I had hoped to

   * nullness checker can already "prove" are non-null. That means that the first parameter to
   * checkNotNull *should* be annotated to require it to be non-null.
   *
   * However, for a variety of reasons, Google developers have written a ton of code over the past
   * decade that assumes that they can use checkNotNull for non-precondition checks. I had hoped to

     * Exception.)
     */
    throw new UncheckedExecutionException(cause);
  }

  /*
   * Arguably we don't need a timed getUnchecked because any operation slow enough to require a
   * timeout is heavyweight enough to throw a checked exception and therefore be inappropriate to
   * use with getUnchecked. Further, it's not clear that converting the checked TimeoutException to

		groups := createReq.Groups

		_, err := ldap.NormalizeDN(parent)
		if err != nil {
			// not a valid DN, ignore.
			continue
		}

		hasDiff := false

		// For the parent value, we require that the parent exists in the LDAP
		// server and is under a configured base DN.
		validatedParent, isUnderBaseDN, err := sys.LDAPConfig.GetValidatedUserDN(conn, parent)
		if err != nil {

  uint64_t (*length)(const TF_ReadOnlyMemoryRegion* region);
} TF_ReadOnlyMemoryRegionOps;
// LINT.ThenChange(:read_only_memory_region_ops_version)

// LINT.IfChange
typedef struct TF_FilesystemOps {
  /// Acquires all resources used by the filesystem.
  ///
  /// This operation must be provided. See "REQUIRED OPERATIONS" above.
  void (*init)(TF_Filesystem* filesystem, TF_Status* status);

	// the 'null' version. We add a free-version to track its tiered
	// content for asynchronous deletion.
	//
	// Note: RestoreObject and HealObject requests don't end up replacing the
	// null version and therefore don't require the free-version to track
	// anything
	if fi.VersionID == "" && !fi.IsRestoreObjReq() && !fi.Healing() {
		// Note: Restore object request reuses PutObject/Multipart

    assertThat(parse("http://[0:0:0:0:0:0:0:0]/").host).isEqualTo("::")
    assertThat(parse("http://[::ffff:c0a8:1fe]/").host).isEqualTo("192.168.1.254")
  }

  /**
   * The builder permits square braces but does not require them.
   */
  @Test
  fun hostIpv6Builder() {
    val base = parse("http://example.com/")
    assertThat(base.newBuilder().host("[::1]").build().toString())
      .isEqualTo("http://[::1]/")