if pollErr := wait.Poll(100*time.Millisecond, 5*perfCounterUpdatePeriod, func() (bool, error) {
				data, err := counter.getData()
				if err != nil {
					return false, err
				}

				if data != 0 {
					return true, nil
				}

				return false, nil
			}); pollErr != nil {
				t.Fatalf("Encountered error: `%v'", pollErr)
				return
			}

	}

	// Create volume to use in conjunction with other StorageAPI's file API(s)
	err = fs.MakeVol(context.Background(), "voldir")
	if err != nil {
		t.Fatal(err)
	}

	for i, test := range testCases {
		t.Run(fmt.Sprint(i), func(t *testing.T) {
			err = fs.AppendFile(context.Background(), "voldir", test.objName, []byte("hello"))
			if err != nil && test.pass {
				t.Error(err)
			} else if err == nil && !test.pass {

			t.Fatalf("expected error matching stdlib, got %v, %v", err, goerr)
		} else {
			t.Log(err)
		}
	}

	{
		var v *map[string]interface{}
		err := Unmarshal([]byte(`{}`), v)
		goerr := gojson.Unmarshal([]byte(`{}`), v)
		if err == nil || goerr == nil || err.Error() != goerr.Error() {
			t.Fatalf("expected error matching stdlib, got %v, %v", err, goerr)
		} else {
			t.Log(err)
		}
	}

		_, ctx := ktesting.NewTestContext(t)
		logger := klog.FromContext(ctx)
		gotTimeLeft, gotExpireAt, gotErr := timeLeft(logger, job, tc.since)
		if tc.expectErr != (gotErr != nil) {
			t.Errorf("%s: expected error is %t, got %t, error: %v", tc.name, tc.expectErr, gotErr != nil, gotErr)
		}
		if tc.expectErr && len(tc.expectErrStr) == 0 {

			}
		}
		poolErr := reduceWriteQuorumErrs(ctx, perPoolErrs, bucketOpIgnoredErrs, len(perPoolErrs)/2+1)
		if poolErr != nil && !errors.Is(poolErr, errVolumeNotFound) {
			if !opts.NoRecreate {
				// re-create successful deletes, since we are return an error.
				sys.MakeBucket(ctx, bucket, MakeBucketOptions{})
			}
			return toObjectErr(poolErr, bucket)
		}
	}
	return nil
}

			volumeName,
			nodeName)
	}

	// Act
	generatedVolumeName, podErr := dsw.AddPod(types.UniquePodName(podName), controllervolumetesting.NewPod(podName, podName), volumeSpec, nodeName)

	// Assert
	if podErr != nil {
		t.Fatalf("AddPod failed. Expected: <no error> Actual: <%v>", podErr)
	}

	volumeExists = dsw.VolumeExists(generatedVolumeName, nodeName)
	if !volumeExists {
		t.Fatalf(

}

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) {

			}
			got, err := YAMLManifestPatch(base, "istio-system", rc.Overlays)
			if gotErr, wantErr := errToString(err), tt.wantErr; gotErr != wantErr {
				t.Fatalf("YAMLManifestPatch(%s): gotErr:%s, wantErr:%s", tt.desc, gotErr, wantErr)
			}
			if want := tt.want; !util.IsYAMLEqual(got, want) {

	}

	for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			got := Version{}
			err := yaml.Unmarshal([]byte(tt.yamlStr), &got)
			if gotErr, wantErr := errToString(err), tt.wantErr; gotErr != wantErr {
				t.Fatalf("yaml.Unmarshal(%s): got error: %s, want error: %s", tt.desc, gotErr, wantErr)
			}
			if tt.wantErr == "" {
				assert.Equal(t, got, tt.want)
			}
		})
	}
}

		},
	}

	for _, testCase := range testCases {
		testCase := testCase
		t.Run(testCase.timeStr, func(t *testing.T) {
			gott, goterr := Parse(testCase.timeStr)
			if !errors.Is(goterr, testCase.expectedErr) {
				t.Errorf("expected %v, got %v", testCase.expectedErr, goterr)
			}
			if !gott.Equal(testCase.expectedTime) {
				t.Errorf("expected %v, got %v", testCase.expectedTime, gott)
			}
		})
	}