}
					} else if tt.gomodErr != "" {
						t.Errorf("repo.GoMod(%q) = %q, want error %q", tt.version, data, tt.gomodErr)
					} else if string(data) != tt.gomod {
						t.Errorf("repo.GoMod(%q) = %q, want %q", tt.version, data, tt.gomod)
					}
				}

				needHash := !testing.Short() && (tt.zipFileHash != "" || tt.zipSum != "")
				if tt.zip != nil || tt.zipErr != "" || needHash {

				return
			}
			if clusterVersion != tt.wantClusterVersion {
				t.Errorf("clusterVersion = %v, wantClusterVersion = %v", clusterVersion, tt.wantClusterVersion)
			}
			if tt.wantParsedVersion == "" {
				if parsedVersion != nil {
					t.Errorf("parsedVersion = %v, wantParsedVersion = %v", parsedVersion, tt.wantParsedVersion)
				}
			} else if parsedVersion.String() != tt.wantParsedVersion {

				} else if err != nil && !tt.wantErr {
					t.Errorf("PrintSecretSummary (%v) produced unexpected err: %v", tt.name, err)
				}
				util.CompareContent(t, gotOut.Bytes(), tt.wantOutputSecret)
			}
			if tt.wantOutputWorkload != "" {
				wf := WorkloadFilter{}
				if tt.configNamespace != "" {
					wf.Namespace = tt.configNamespace
				}
				err := cw.PrintWorkloadSummary(wf)
				if err == nil && tt.wantErr {

			wantUint64: 3728699739546630719,
		},
	}

	for _, tt := range testCases {
		t.Run(tt.name, func(t *testing.T) {
			h := New()
			h.Write([]byte(tt.str))
			if gotStr := h.Sum(); tt.wantStr != gotStr {
				t.Errorf("wantStr %v, but got %v", tt.wantStr, gotStr)
			}
			if gotUint64 := h.Sum64(); tt.wantUint64 != gotUint64 {
				t.Errorf("wantUint64 %v, but got %v", tt.wantUint64, gotUint64)
			}
		})
	}
}

        this.context = tc;
    }


    /**
     * Create an <tt>NtlmPasswordAuthentication</tt> object from a
     * domain, username, and password. Parameters that are <tt>null</tt>
     * will be substituted with <tt>jcifs.smb.client.domain</tt>,
     * <tt>jcifs.smb.client.username</tt>, <tt>jcifs.smb.client.password</tt>
     * property values.
     * 
     * @param tc
     *            context to use

func TestValueConverters(t *testing.T) {
	for i, tt := range valueConverterTests {
		out, err := tt.c.ConvertValue(tt.in)
		goterr := ""
		if err != nil {
			goterr = err.Error()
		}
		if goterr != tt.err {
			t.Errorf("test %d: %T(%T(%v)) error = %q; want error = %q",
				i, tt.c, tt.in, tt.in, goterr, tt.err)
		}
		if tt.err != "" {
			continue
		}
		if !reflect.DeepEqual(out, tt.out) {

			"",
			"",
		},
	}
	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {
			got, _ := SdsCertificateConfigFromResourceName(tt.resource)
			if got != tt.output {
				t.Fatalf("got %v, expected %v", got, tt.output)
			}
			if root := got.IsRootCertificate(); root != tt.root {
				t.Fatalf("unexpected isRootCertificate got %v, expected %v", root, tt.root)
			}

			},
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			thr := bucketThrottle{
				NodeBandwidthPerSec: 1024 * 1024,
			}
			th := make(map[BucketOptions]*bucketThrottle)
			th[BucketOptions{Name: "bucket", ReplicationARN: "arn"}] = &thr
			m := &Monitor{
				bucketsMeasurement: tt.fields.activeBuckets,
				bucketsThrottle:    th,

}

func TestParsePort(t *testing.T) {
	// The following test cases are cribbed from the strconv
	for _, tt := range parsePortTests {
		if port, needsLookup := parsePort(tt.service); port != tt.port || needsLookup != tt.needsLookup {
			t.Errorf("parsePort(%q) = %d, %t; want %d, %t", tt.service, port, needsLookup, tt.port, tt.needsLookup)
		}
	}

	testHookLookupIP = lookupLocalhost

	for _, tt := range resolveIPAddrTests {
		addr, err := ResolveIPAddr(tt.network, tt.litAddrOrName)
		if !reflect.DeepEqual(addr, tt.addr) || !reflect.DeepEqual(err, tt.err) {
			t.Errorf("ResolveIPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
			continue
		}
		if err == nil {