* value that may be consumed only once and then closed. All other properties are immutable.
 *
 * This class implements [Closeable]. Closing it simply closes its response body. See
 * [ResponseBody] for an explanation and examples.
 */
class Response internal constructor(
  /**
   * The request that initiated this HTTP response. This is not necessarily the same request issued
   * by the application:
   *

        if (authenticationTTL <= 0) {
            return false; // No expiration
        }
        long age = System.currentTimeMillis() - authenticationTimestamp;
        return age > authenticationTTL;
    }

    /**
     * Set the authentication time-to-live in milliseconds
     *
     * @param ttl time-to-live in milliseconds (0 or negative for no expiration)
     */
    public void setAuthenticationTTL(long ttl) {

	for {
		result, ok := lc.Get("key1")
		if ok && result == "" {
			t.Fatalf("ok should return a result")
		}
		if !ok {
			break
		}
	}

	time.Sleep(time.Millisecond * 100) // wait for expiration reaper
	if lc.Len() != 0 {
		t.Fatalf("length differs from expected")
	}

	v, ok = lc.Peek("key1")
	if v != "" {
		t.Fatalf("should be empty")
	}
	if ok {
		t.Fatalf("should be false")
	}

	cred.Status = string(auth.AccountOn)
	cred.Name = opts.name
	cred.Description = opts.description

	if opts.expiration != nil {
		expirationInUTC := opts.expiration.UTC()
		if err := validateSvcExpirationInUTC(expirationInUTC); err != nil {
			return auth.Credentials{}, time.Time{}, err
		}
		cred.Expiration = expirationInUTC
	}

	updatedAt, err := sys.store.AddServiceAccount(ctx, cred)
	if err != nil {

		cr.Name = opts.name
	}

	if opts.description != "" {
		cr.Description = opts.description
	}

	if opts.expiration != nil {
		expirationInUTC := opts.expiration.UTC()
		if err := validateSvcExpirationInUTC(expirationInUTC); err != nil {
			return updatedAt, err
		}
		cr.Expiration = expirationInUTC
	}

	switch opts.status {
	// The caller did not ask to update status account, do nothing

bit.ly/tf-sig-build-notes) if you'd like to discuss the future of contributions.

### Brief System Overview

The top-level scripts and utility scripts should be fairly well-documented. Here
is a brief explanation of how they tie together:

1.  `envs/*` are lists of variables made with bash syntax. A user must set a
    `TFCI` env param pointing to a list of `env` files.

		TargetUser: accessKey,
		AccessKey:  "svc-accesskey",
		SecretKey:  "svc-secretkey",
		Expiration: &closeExpiration,
	})
	if err == nil {
		c.Fatalf("Creating a svc acc with distant expiration should fail")
	}
}

func (s *TestSuiteIAM) TestServiceAccountOpsByAdmin(c *check) {

			if err := xml.Unmarshal(meta.LifecycleConfigXML, &lcCfg); err != nil {
				return updatedAt, err
			}
			// find a single expiry rule set the flag
			for _, rl := range lcCfg.Rules {
				if !rl.Expiration.IsNull() || !rl.NoncurrentVersionExpiration.IsNull() {
					expiryRuleRemoved = true
					break
				}
			}
		}

		// Form empty ILM details with `ExpiryUpdatedAt` field and save
		var cfgData []byte

		err := iamOS.loadUser(ctx, userName, stsUser, stsAccountsFromStore)
		if err != nil && !errors.Is(err, errNoSuchUser) {
			iamLogIf(ctx, err)
		}
		// No need to return errors for failed expiration of STS users
	}

	// Loading the STS policy mappings from disk ensures that stale entries
	// (removed during loadUser() in the loop above) are removed from memory.

            assertFalse(testBlock.isExtendedSecurity());
            testBlock.setExtendedSecurity(true);
            assertTrue(testBlock.isExtendedSecurity());
        }

        @Test
        @DisplayName("Test expiration property")
        void testExpirationProperty() {
            assertNull(testBlock.getExpiration());
            testBlock.setExpiration(123456789L);
            assertEquals(123456789L, testBlock.getExpiration());