assertThrows(UnsupportedOperationException.class, () -> lazyStackTrace(e).set(0, null));

    // Now we test a property that holds only for the lazy implementation.

    if (!lazyStackTraceIsLazy()) {
      return;
    }

    e.setStackTrace(new StackTraceElement[0]);
    assertThat(lazyStackTrace(e)).containsExactly((Object[]) originalStackTrace).inOrder();

     * to be populated will all state requiring a Node Status on every host
     * encountered. The below methods allow state to be populated when requested
     * in a lazy fashon.
     */

    void checkData(final CIFSContext tc) throws UnknownHostException {
        if (this.hostName.isUnknown()) {
            tc.getNameServiceClient().getNbtAllByAddress(this);
        }
    }

// Returns a peer S3 client.
func newPeerS3Client(node Node) peerS3Client {
	var gridConn atomic.Pointer[grid.Connection]

	return &remotePeerS3Client{
		node: node,
		gridConn: func() *grid.Connection {
			// Lazy initialization of grid connection.
			// When we create this peer client, the grid connection is likely not yet initialized.
			if node.GridHost == "" {

{
  "performanceTests" : [ {
    "testId" : "org.gradle.performance.crossbuild.TaskAvoidancePerformanceTest.help with lazy and eager tasks",
    "groups" : [ {
      "testProject" : "largeJavaMultiProject",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    }, {
      "testProject" : "largeMonolithicJavaProject",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    } ]
  }, {

        }
        ComponentUtil.getSsoManager().register(this);
    }

    /**
     * Gets or creates the SPNEGO authenticator instance.
     *
     * This method implements lazy initialization with synchronization to ensure
     * the authenticator is only created once. It configures the authenticator
     * with the appropriate SPNEGO settings and marks initialization as complete.
     *

func (sys *BucketTargetSys) GetRemoteTargetClient(bucket, arn string) *TargetClient {
	sys.RLock()
	tgt := sys.arnRemotesMap[arn]
	sys.RUnlock()

	if tgt.Client != nil {
		return tgt.Client
	}
	defer func() { // lazy refresh remote targets
		if tgt.Client == nil && !sys.isReloadingTarget(bucket, arn) && (tgt.lastRefresh.Equal(timeSentinel) || tgt.lastRefresh.Before(UTCNow().Add(-5*time.Minute))) {

   * to be a view, but it means that the function will be applied many times for bulk operations
   * like {@link Map#containsValue} and {@code Map.toString()}. For this to perform well, {@code
   * function} should be fast. To avoid lazy evaluation when the returned map doesn't need to be a
   * view, copy the returned map into a new map of your choosing.
   */
  public static <

  }

  /** Returns whether arrays need to be allocated. */
  boolean needsAllocArrays() {
    return table == null;
  }

  /** Handle lazy allocation of arrays. */
  @CanIgnoreReturnValue
  int allocArrays() {
    Preconditions.checkState(needsAllocArrays(), "Arrays already allocated");

    int expectedSize = metadata;

 *
 * <ul>
 *   <li>Can't be passed directly to methods that expect {@code Iterable}, {@code Collection}, or
 *       {@code List} (though the most common utilities do have replacements here, and there is a
 *       lazy {@link #asList} view).
 * </ul>
 *
 * @since 22.0
 */
@GwtCompatible
@Immutable
public final class ImmutableLongArray implements Serializable {

   * to be a view, but it means that the function will be applied many times for bulk operations
   * like {@link Map#containsValue} and {@code Map.toString()}. For this to perform well, {@code
   * function} should be fast. To avoid lazy evaluation when the returned map doesn't need to be a
   * view, copy the returned map into a new map of your choosing.
   */
  public static <