long max = (1L << 32) - 1;
    for (long value : TEST_LONGS) {
      boolean expectSuccess = value >= min && value <= max;
      try {
        assertThat(UnsignedInteger.valueOf(value).longValue()).isEqualTo(value);
        assertThat(expectSuccess).isTrue();
      } catch (IllegalArgumentException e) {
        assertThat(expectSuccess).isFalse();
      }
    }
  }

  public void testValueOfBigInteger() {

@CompileStatic
class SingleArtifactResolutionResultSpec<T extends Module> {
    private final T module

    SingleArtifactResolutionResultSpec(T module) {
        this.module = module
    }

    boolean expectSuccess = true
    List<String> expectedFileNames = []
    List<Closure<?>> failureExpectations = []

    void expectFiles(String... fileNames) {
        expectFiles(fileNames as List<String>)
    }

    long max = (1L << 32) - 1;
    for (long value : TEST_LONGS) {
      boolean expectSuccess = value >= min && value <= max;
      try {
        assertThat(UnsignedInteger.valueOf(value).longValue()).isEqualTo(value);
        assertThat(expectSuccess).isTrue();
      } catch (IllegalArgumentException e) {
        assertThat(expectSuccess).isFalse();
      }
    }
  }

  public void testValueOfBigInteger() {

						destinationRule string
						expectSuccess   bool
					}{
						{
							name:            "connection fails when DR doesn't match SA",
							destinationRule: defaultIdentityDR,
							expectSuccess:   false,
						},
						{
							name:            "connection succeeds when DR matches SA",
							destinationRule: correctIdentityDR,
							expectSuccess:   true,
						},
						{

)

func TestGetMetrics(t *testing.T) {
	tests := []struct {
		name          string
		volumeID      string
		targetPath    string
		expectSuccess bool
	}{
		{
			name:          "with valid name and volume id",
			expectSuccess: true,
			volumeID:      "foobar",
			targetPath:    "/mnt/foo",
		},
	}

	for _, tc := range tests {

		desc          string
		node          *v1.Node
		nodeErr       error
		expectSuccess bool
	}{{
		desc:          "cannot get node",
		nodeErr:       errors.New("expected: cannot get node"),
		expectSuccess: false,
	}, {
		desc: "node missing UID",
		node: &v1.Node{
			ObjectMeta: metav1.ObjectMeta{
				Name: testNodeName,
			},
		},
		expectSuccess: false,
	}, {
		desc: "successfully fetched node",
		node: &v1.Node{

        client = new HttpClientHelper(new DocumentationRegistry(), settings)
    }

    private def performRequest(boolean expectSuccess = true, boolean needClientAuth = false) {
        createClient()

        server.configure(keyStore, needClientAuth)
        server.start()
        if (expectSuccess) {
            server.expect("/test")
        }

        client.performGet("${server.getUri()}/test", false)
    }

                additionalArtifacts: additionalArtifacts?.asImmutable(),
                variant: variant,
                resolveModuleMetadata: withModuleMetadata,
                expectFailure: !expectationSpec.expectSuccess,
                optionalFeatureCapabilities: optionalFeatureCapabilities,
            )

	"strings"
)

// Expectation represents the expected result of some operation.
type Expectation struct {
	failure      bool
	errorMatcher *regexp.Regexp
}

// ExpectSuccess returns an Expectation that trivially expects success.
func ExpectSuccess() *Expectation {
	return new(Expectation)
}

// Check validates whether err conforms to the expectation. Returns
// an error if it does not conform.
//

								// TODO(https://github.com/istio/istio/issues/37629) go back to 5s
								opts.Timeout = time.Second * 10

								expectSuccess := c.ExpectSuccess(from, opts)
								expectMTLS := c.ExpectMTLS(from, opts)
								var tpe string
								if expectSuccess {
									tpe = "positive"
									opts.Check = check.And(
										check.OK(),
										check.ReachedTargetClusters(t))