DfsReferralDataImpl second = createInitializedDfsReferralDataImpl();
            DfsReferralDataImpl third = createInitializedDfsReferralDataImpl();

            // Build chain
            first.append(second);
            first.append(third);

            // Verify chain
            assertEquals(third, first.next());
            assertEquals(second, third.next());

	}

	client := &http.Client{Transport: a.Transport}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer a.CloseRespFn(resp.Body)

	return nil
}

// UnmarshalJSON - decodes JSON data.
func (a *Args) UnmarshalJSON(data []byte) error {
	// subtype to avoid recursive call to UnmarshalJSON()
	type subArgs Args
	var so subArgs

	if err := json.Unmarshal(data, &so); err != nil {
		return err

          serialNumber = it[1] as BigInteger,
          signature = it[2] as AlgorithmIdentifier,
          issuer = (it[3] as Pair<*, *>).second as List<List<AttributeTypeAndValue>>,
          validity = it[4] as Validity,
          subject = (it[5] as Pair<*, *>).second as List<List<AttributeTypeAndValue>>,
          subjectPublicKeyInfo = it[6] as SubjectPublicKeyInfo,
          issuerUniqueID = it[7] as BitString?,

	for {
		if err := sm.load(ctx, newObjectLayerFn()); err == nil {
			<-ctx.Done()
			return
		}
		duration := max(time.Duration(r.Float64()*float64(time.Second*10)),
			// Make sure to sleep at least a second to avoid high CPU ticks.
			time.Second)
		time.Sleep(duration)
	}
}

// load resync metrics saved on disk into memory
func (sm *siteResyncMetrics) load(ctx context.Context, objAPI ObjectLayer) error {

        }
      },
    )

    // This should fail the Call, but not cause an unhandled Exception bubbling up
    client.dispatcher.executorService.shutdownNow()

    val exception = callFailure.get(5, TimeUnit.SECONDS)
    assertThat(exception.message)
      .isNotNull()
      .startsWith("canceled due to")
    assertThat(exception).isInstanceOf<IOException>()
    assertThat(exception.cause)
      .isNotNull()

const (
	// browserCSPPolicy setting name for Content-Security-Policy response header value
	browserCSPPolicy = "csp_policy"
	// browserHSTSSeconds setting name for Strict-Transport-Security response header, amount of seconds for 'max-age'
	browserHSTSSeconds = "hsts_seconds"
	// browserHSTSIncludeSubdomains setting name for Strict-Transport-Security response header 'includeSubDomains' flag (true or false)

| :--        | :--      |
| _Type_     | _String_ |
| _Required_ | _Yes_    |

### DurationSeconds

The duration, in seconds. The value can range from 900 seconds (15 minutes) up to 365 days. If value is higher than this setting, then operation fails. By default, the value is set to 3600 seconds.

| Params        | Value                                              |
| :--           | :--                                                |

    protected int maxRedirectCount;

    /** Executor service for concurrent processing of file operations. */
    private final ExecutorService executor;

    /** Timeout in seconds for executor service termination during shutdown. */
    private int executorTerminationTimeout = 300;

    /**
     * Constructs a new FileListIndexUpdateCallbackImpl with the specified parameters.
     *

    /**
     * Indicates whether or not the build could be resumed by a second invocation of Maven.
     * @see BuildResumptionDataRepository
     * @return <code>true</code> when it is possible to resume the build, <code>false</code> otherwise.
     */
    boolean canResume();

    /**
     * Indicate that the build can or cannot be resumed by a second invocation of Maven.

			if err != nil {
				log.Fatalf("Error reading session policy file: %v", err)
			}
			policy = string(bs)
		}
		stsOpts.Policy = policy
	}
	if expiryDuration != 0 {
		stsOpts.DurationSeconds = int(expiryDuration.Seconds())
	}
	li, err := cr.NewSTSAssumeRole(stsEndpoint, stsOpts)
	if err != nil {
		log.Fatalf("Error initializing STS Identity: %v", err)
	}

	stsEndpointURL, err := url.Parse(stsEndpoint)
	if err != nil {