! go work use foo bar baz

stderr '^go: foo is not a directory'
stderr '^go: directory baz does not exist'
cmp go.work go.work_want

! go work use -r qux
stderr '^go: qux is not a directory'

-- go.work --
go 1.18
-- go.work_want --
go 1.18
-- foo --
-- qux --
-- bar/go.mod --

			options:  RunnerOptions{},
			expected: map[string]bool{"foo": true, "foo/bar": true, "foo/baz": true, "qux": true},
		},
		{
			name:     "options can filter phases",
			options:  RunnerOptions{FilterPhases: []string{"foo/baz", "qux"}},
			expected: map[string]bool{"foo": false, "foo/bar": false, "foo/baz": true, "qux": true},
		},
		{
			name:     "options can filter phases - hierarchy is considered",

		fieldpath.MakePathOrDie("foo", 1, "bar", "baz"),
		fieldpath.MakePathOrDie("foo", 1, "bar"),
		fieldpath.MakePathOrDie("qux", fieldpath.KeyByFields("name", "first")),
		fieldpath.MakePathOrDie("qux", fieldpath.KeyByFields("name", "first"), "bar"),
		fieldpath.MakePathOrDie("qux", fieldpath.KeyByFields("name", "second"), "bar"),
	)

	b.ReportAllocs()
	b.ResetTimer()
	for n := 0; n < b.N; n++ {

		f.Action(Modified, testType("qux"))
		f.Modify(testType("bar"))
		f.Delete(testType("bar"))
		f.Error(testType("error: blah"))
		f.Stop()
	}

	go sender()
	consumer(f)
}

func TestRaceFreeFake(t *testing.T) {
	f := NewRaceFreeFake()

	table := []struct {
		t EventType
		s testType
	}{
		{Added, testType("foo")},
		{Modified, testType("qux")},
		{Modified, testType("bar")},

                                developer {
                                    id.set("baz")
                                    name.set("Baz Qux")
                                    email.set("baz.qux@example.org")
                                    url.set("http://example.org/users/baz.qux")
                                    organization.set("Example Organization")
                                    organizationUrl.set("https://example.org")

			},
		}
	})
	w.AddRow(newTestObject("foo", "bar", "1.0"))
	w.AddRow(newTestObject("baz", "qux", "2.0"))
	w.AddRow(newTestObject("qux", "quux", "3"))
	w.Flush()
	expected := "NAME  NAMESPACE      VERSION\n" +
		"foo   \x1b[32mbar\x1b[0m            1.0\n" +
		"baz   \x1b[32mqux\x1b[0m            2.0\n" +
		"qux   \x1b[32mquux\x1b[0m           3\n"
	if got.String() != expected {

			rhs:      &certKeyContent{cert: []byte("foo"), key: []byte("qux")},
			expected: false,
		},
		{
			name:     "different cert and key",
			lhs:      &certKeyContent{cert: []byte("foo"), key: []byte("baz")},
			rhs:      &certKeyContent{cert: []byte("bar"), key: []byte("qux")},
			expected: false,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {

			out: mustParse("baz in (norf,qux)"),
		},
		{
			in:  &LabelSelector{MatchLabels: matchLabels, MatchExpressions: matchExpressions},
			out: mustParse("baz in (norf,qux),foo=bar"),
		},
		{
			in: &LabelSelector{
				MatchExpressions: []LabelSelectorRequirement{{
					Key:      "baz",
					Operator: LabelSelectorOpExists,
					Values:   []string{"qux", "norf"},
				}},
			},
			expectErr: true,
		},

)

func TestFilter(t *testing.T) {
	table := []Event{
		{Type: Added, Object: testType("foo")},
		{Type: Added, Object: testType("bar")},
		{Type: Added, Object: testType("baz")},
		{Type: Added, Object: testType("qux")},
		{Type: Added, Object: testType("zoo")},
	}

	source := NewFake()
	filtered := Filter(source, func(e Event) (Event, bool) {
		return e, e.Object.(testType)[0] != 'b'
	})

	go func() {

			t.Errorf("error message did not contain expected part '%v'", part)
		}
	}

	type complicated struct {
		Baz   int
		Qux   string
		Inner interface{}
		KV    map[string]int
	}
	s = Invalid(
		NewPath("foo"),
		&complicated{
			Baz:   1,
			Qux:   "aoeu",
			Inner: &complicated{Qux: "asdf"},
			KV:    map[string]int{"Billy": 2},
		},
		"detail",
	).Error()
	t.Logf("message: %v", s)