g.Expect(err).To(BeNil())

	keys := c.AllKeys()
	g.Expect(keys).To(HaveLen(1))
	g.Expect(keys1).To(HaveLen(1))
	g.Expect(keys2).To(HaveLen(1))
	g.Expect(keys).To(ContainElement(keys1[0]))
	g.Expect(keys).To(ContainElement(keys2[0]))

	items, err := os.ReadDir(d)
	g.Expect(err).To(BeNil())
	g.Expect(items).To(HaveLen(1))
}

func TestCache_Clear(t *testing.T) {
	g := NewWithT(t)
	d := t.TempDir()

		t.Fatalf("RemoveVolumeFromReportAsAttached failed. Expected: <no error> Actual: <%v>", markDesireToDetachErr)
	}
	if addErr != nil {
		t.Fatalf("AddVolumeNode failed. Expected: <no error> Actual: <%v>", addErr)
	}

	// Assert
	attachedVolumes := asw.GetAttachedVolumes()
	if len(attachedVolumes) != 1 {
		t.Fatalf("len(attachedVolumes) Expected: <1> Actual: <%v>", len(attachedVolumes))
	}

			fail = true
			t.Errorf("Case %v (%s, %s, %v) podQuotaCount mismatch: got %v, expect %v", seq, testcase.name, testcase.path, enabled, len(podQuotaMap), expectedPodQuotaCount)
		}
		if len(dirQuotaMap) != expectedDirQuotaCount {
			fail = true
			t.Errorf("Case %v (%s, %s, %v) dirQuotaCount mismatch: got %v, expect %v", seq, testcase.name, testcase.path, enabled, len(dirQuotaMap), expectedDirQuotaCount)
		}

		}

		if expect != nil {
			expect = reflect.Indirect(reflect.ValueOf(expect)).Interface()
		}

		if reflect.ValueOf(got).IsValid() != reflect.ValueOf(expect).IsValid() {
			t.Errorf("%v: expect: %+v, got %+v", utils.FileWithLineNum(), expect, got)
			return
		}

		if reflect.ValueOf(got).Kind() == reflect.Slice {
			if reflect.ValueOf(expect).Kind() == reflect.Slice {

	if err != nil {
		t.Errorf("Received unexpected error: %v", err)
	}

	if !reflect.DeepEqual(expect, output) {
		t.Errorf("Received unexpected output. Expected %#v, got %#v", expect, output)
	}
}

func TestDockerConfigEntryJSONDecode(t *testing.T) {
	tests := []struct {
		input  []byte
		expect DockerConfigEntry
		fail   bool
	}{
		// simple case, just decode the fields
		{

func TestStringList(t *testing.T) {
	cases := []struct {
		in          string
		expect      model.StringList
		noRoundTrip bool
	}{
		{in: `"a,b,c"`, expect: []string{"a", "b", "c"}},
		{in: `"\"a,b,c"`, expect: []string{`"a`, "b", "c"}},
		{in: `"a"`, expect: []string{"a"}},
		{in: `""`, expect: []string{}},
		{in: `"123,@#$#,abcdef"`, expect: []string{"123", "@#$#", "abcdef"}},
	}
	for _, tt := range cases {

			if err != nil {
				t.Fatalf("did not expect decoding error but got: %v", err)
			}
			if !reflect.DeepEqual(decoded, test.expected) {
				t.Fatalf("expected:\n%v\nbut got:\n%v", test.expected, decoded)
			}
		})
	}
}

func TestSortEncodedManagedFields(t *testing.T) {
	tests := []struct {
		name          string
		managedFields []metav1.ManagedFieldsEntry
		expected      []metav1.ManagedFieldsEntry
	}{
		{

	// for purge case we expect all resources removed
	if purge {
		if len(reStrList) != 0 {
			msg := fmt.Sprintf("resources expected to be pruned but still exist in the cluster: %s",
				strings.Join(reStrList, " "))
			scopes.Framework.Warnf(msg)
			return fmt.Errorf(msg)
		}
		return nil
	}
	// for other cases, we expect base component resources to be kept.
	if len(reStrList) != 0 {

	bar.ReportError("some error")
	expect(`❌ ` + cnbo + ` encountered an error: some error`)

	foo.ReportProgress()
	expect(`- Processing resources for ` + cnpo + `.`)

	foo.ReportFinished()
	expect(`🧠 ` + cnpo + ` installed`)

	p.SetState(StatePruning)
	expect(`- Pruning removed resources`)

	p.SetState(StateComplete)
	expect(`✅ Installation complete`)

	p.SetState(StateUninstallComplete)
	expect(`✅ Uninstall complete`)

			g := NewWithT(t)
			actual := c.actual()
			g.Expect(actual).To(Equal(c.expected))
		})
	}
}

func TestSchemas_Remove(t *testing.T) {
	g := NewWithT(t)

	schemas := collection.SchemasFor(emptyResource, structResource)
	g.Expect(schemas.Remove(structResource)).To(Equal(collection.SchemasFor(emptyResource)))
	g.Expect(schemas.Remove(emptyResource, structResource)).To(Equal(collection.SchemasFor()))