void "reports and recovers from missing module"() {
        given:
        def repo = mavenHttpRepo("repo1")
        def module = repo.module("group", "projectA", "1.2").publish()

        buildFile << """
repositories {
    maven { url "${repo.uri}"}
}
configurations { missing }
dependencies {
    missing 'group:projectA:1.2'
}
task showMissing {

                    "type": "value_error.missing",
                },
            ]
        }
    )


def test_put_no_header(client: TestClient):
    response = client.put("/items/foo")
    assert response.status_code == 422, response.text
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "missing",

	var i1 interface{} = X1{}
	check(func() { _ = i1.(p.I1) }, "interface conversion: main.X1 is not p.I1: missing method Foo")

	var i2 interface{} = X2{}
	check(func() { _ = i2.(p.I2) }, "interface conversion: main.X2 is not p.I2: missing method foo")

	var i3 interface{} = X3{}
	check(func() { _ = i3.(p.I2) }, "interface conversion: main.X3 is not p.I2: missing method foo")

	var i4 interface{} = X4{}

        FileType.RegularFile | FileType.RegularFile | "has changed"
        FileType.Missing     | FileType.RegularFile | "has been added"
        FileType.Missing     | FileType.Directory   | "has been added"
        FileType.RegularFile | FileType.Missing     | "has been removed"
        FileType.Directory   | FileType.Missing     | "has been removed"
    }

    def "change message for ChangeType #fileChange.change is '#message'"() {

		t.Run("podspec_"+tc.name, func(t *testing.T) {
			actual := sets.New[string](GetWarningsForStorageClass(tc.template)...)
			expected := sets.New[string](tc.expected...)
			for _, missing := range sets.List[string](expected.Difference(actual)) {
				t.Errorf("missing: %s", missing)
			}
			for _, extra := range sets.List[string](actual.Difference(expected)) {
				t.Errorf("extra: %s", extra)
			}
		})

	}
}

# to individual missing packages.
# Verifies golang.org/issue/34829.
go list -mod=readonly -e -deps -f '{{if .Error}}{{.ImportPath}}: {{.Error}}{{end}}' .
stdout 'example.com/missing: use.go:3:8: cannot find module providing package example.com/missing: import lookup disabled by -mod=readonly'

-- go.mod --
module example.com/m

go 1.14

-- use.go --
package use

     * A {@link #isMissing() missing} value never carries a side effect.
     */
    interface Value<T> {
        Value<Object> MISSING = new Missing<>();
        Value<Void> SUCCESS = new Present<>(null);

        static <T> Value<T> ofNullable(@Nullable T value) {
            if (value == null) {
                return MISSING.asType();
            }
            return new Present<>(value);

		}
	} else {
		if missing := sets.SortedList(sets.New(want.NetworkFilters...).Difference(sets.New(haveNetwork...))); len(missing) > 0 {
			t.Fatalf("%v/%v: missing network filters: %v, have %v", have.Name, haveType, missing, haveNetwork)
		}
		if missing := sets.SortedList(sets.New(want.HTTPFilters...).Difference(sets.New(haveHTTP...))); len(missing) > 0 {

go fmt xnofmt.go
cmp xnofmt.go xfmt.ref
! go build xnofmt.go
stderr 'xnofmt.go:5:12: pattern missing.txt: no matching files found'

-- xnofmt.go --
package p

import "embed"

//go:embed missing.txt
var X  embed.FS
-- xfmt.ref --
package p

import "embed"

//go:embed missing.txt
var X embed.FS
-- go.mod --

      <activation>
        <file>
          <exists>${basedir}/test.txt</exists>
        </file>
      </activation>
    </profile>
    <profile>
      <id>missing-basedir</id>
      <activation>
        <file>
          <missing>${basedir}/test.txt</missing>
        </file>
      </activation>
    </profile>

    <profile>
      <id>exists-project-basedir</id>
      <activation>
        <file>