want := fmt.Sprintf(`"%d:%d"`, line, err.Pos.Col())
			if got != want {
				t.Errorf("%v: got msg %q; want %q", err, got, want)
				continue
			}
			found++
		}
	}

	want := strings.Count(src, " ERROR ")
	if found != want {
		t.Errorf("CommentMap got %d errors; want %d", found, want)
	}

static struct passwd mygetpwuid_r(int uid, char *buf, size_t buflen, int *found, int *perr) {
	struct passwd pwd;
	struct passwd *result;
	memset (&pwd, 0, sizeof(pwd));
	*perr = getpwuid_r(uid, &pwd, buf, buflen, &result);
	*found = result != NULL;
	return pwd;
}

static struct passwd mygetpwnam_r(const char *name, char *buf, size_t buflen, int *found, int *perr) {
	struct passwd pwd;
	struct passwd *result;

	if err == nil {
		t.Fatal("Expected error but found nil")
	}
	if err.Error() != "Bucket not found: bucket1" {
		t.Errorf("%s: Expected the error msg to be `%s`, but instead found `%s`", instanceType, "Bucket not found: bucket1", err.Error())
	}
}

// Wrapper for calling testBucketRecreateFails for both Erasure and FS.

	// but this is good enough and not significantly more
	// likely to have a false positive.
	r := New(NewPCG(1, 0))
	found := 0
	for i := 0; i < 1000; i++ {
		x := r.Int64()
		if x == out[found] {
			found++
			if found == len(out) {
				t.Fatalf("found unseeded output in Seed(1) output")
			}
		}
	}

	g := NewWithT(t)
	mt := NewMessageType(Error, "IST-0042", "Cheese type not found: %q")
	m := NewMessage(mt, nil, "Feta")

	g.Expect(m.String()).To(Equal(`Error [IST-0042] Cheese type not found: "Feta"`))
}

func TestMessageWithResource_String(t *testing.T) {
	g := NewWithT(t)
	mt := NewMessageType(Error, "IST-0042", "Cheese type not found: %q")

            exists() >> false
        }
        def found = Stub(File)

        1 * writeStore.whereIs(key, "checksum") >> { missing }
        1 * readStore.whereIs(key, "checksum") >> { found }

        expect:
        twoStageStore.whereIs(key, "checksum") == found
    }

    def "whereIs uses file found in write store"() {
        def found = Stub(File) {
            exists() >> true
        }

    conditions:
    - lastTransitionTime: fake
      message: No errors found
      reason: Accepted
      status: "True"
      type: Accepted
    - lastTransitionTime: fake
      message: No errors found
      reason: NoConflicts
      status: "False"
      type: Conflicted
    - lastTransitionTime: fake
      message: No errors found
      reason: Programmed
      status: "True"
      type: Programmed

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test var x = x + 1 works.

package main

func main() {
	var x int = 1
	if x != 1 {
		print("found ", x, ", expected 1\n")
		panic("fail")
	}
	{
		var x int = x + 1
		if x != 2 {
			print("found ", x, ", expected 2\n")
			panic("fail")
		}
	}
	{
		x := x + 1
		if x != 2 {

				t.Fatal(err)
			}

			if !reflect.DeepEqual(got, wantTree) {
				t.Errorf("Find() got = %v, want %v", got, tt.want)
			}
			if found != tt.found {
				t.Errorf("Find() found = %v, want %v", found, tt.found)
			}
		})
	}
}

func TestManifestMap_Consolidated(t *testing.T) {
	tests := []struct {
		name string
		mm   ManifestMap
		want map[string]string
	}{

! go work use
stderr '^go: no go\.work file found\n\t\(run ''go work init'' first or specify path using GOWORK environment variable\)$'

! go work use .
stderr '^go: no go\.work file found\n\t\(run ''go work init'' first or specify path using GOWORK environment variable\)$'

! go work edit
stderr '^go: no go\.work file found\n\t\(run ''go work init'' first or specify path using GOWORK environment variable\)$'

! go work edit -go=1.18