! 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++ {

                                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 {

			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,
		},

			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)

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

		expect string
	}{{
		input: &packages.Package{
			PkgPath:      "example.com/foo/bar/qux",
			GoFiles:      []string{"/src/prj/file.go"},
			IgnoredFiles: []string{"/otherdir/file.go"},
		},
		expect: filepath.Clean("/src/prj"),
	}, {
		input: &packages.Package{
			PkgPath:      "example.com/foo/bar/qux",
			IgnoredFiles: []string{"/src/prj/file.go"},
		},
		expect: filepath.Clean("/src/prj"),
	}, {

		}
	}
}

func renameImportUsages(f *ast.File, old, new string) {
	// use this to avoid renaming the package declaration, eg:
	//   given: package foo; import foo "bar"; foo.Baz, rename foo->qux
	//   yield: package foo; import qux "bar"; qux.Baz
	var pkg *ast.Ident

	// Rename top-level old to new, both unresolved names
	// (probably defined in another file) and names that resolve
	// to a declaration we renamed.