to auto-update code from Go 1.14 and earlier:

	go tool fix -r eglconf <pkg>

# Using cgo directly

Usage:

	go tool cgo [cgo options] [-- compiler options] gofiles...

Cgo transforms the specified input Go source files into several output
Go and C source files.

The compiler options are passed through uninterpreted when

			Actor:      work.ActorFunc(builderPrintTest),
			Deps:       []*work.Action{cleanAction},
			Package:    p,
			IgnoreFail: true, // print even if test failed
		}
	}

	if len(ptest.GoFiles)+len(ptest.CgoFiles) > 0 {
		addTestVet(b, ptest, vetRunAction, installAction)
	}
	if pxtest != nil {
		addTestVet(b, pxtest, vetRunAction, installAction)
	}

	if installAction != nil {

	p := importRaw(path, ".")

	wantFiles := []string{"a.syso", "b.go", "c.c"}

	var gotFiles []string
	for i := range p.sourceFiles {
		gotFiles = append(gotFiles, p.sourceFiles[i].name)
	}

	if !reflect.DeepEqual(gotFiles, wantFiles) {
		t.Errorf("names of files in importRaw(testdata/ignore_non_source): got %v; want %v",
			gotFiles, wantFiles)
	}

	testenv.MustHaveGoBuild(t)

	t.Parallel()

	goFile := filepath.Join(t.TempDir(), "notes.go")
	if err := os.WriteFile(goFile, []byte(goSource), 0444); err != nil {
		t.Fatal(err)
	}
	outFile := filepath.Join(t.TempDir(), "notes.exe")
	goTool := testenv.GoToolPath(t)

	cmd := testenv.Command(t, goTool, "build", "-o", outFile, "-ldflags", "-buildid 0x1234 -B gobuildid", goFile)
	cmd.Dir = t.TempDir()

		env := make([]byte, len(name)+r)
		copy(env, name)
		copy(env[len(name):], buf[:r])
		envs = append(envs, string(env))
	})
}

// dofiles reads the directory opened with file descriptor fd, applying function f
// to each filename in it.
//
//go:nosplit
func dofiles(dirfd int32, f func([]byte)) {
	dirbuf := new([dirBufSize]byte)

	var off int64 = 0
	for {

        then:
        javaPlatform.assertPublished()
        javaPlatform.assertNoDependencies()

        and:
        resolveArtifacts(javaPlatform) { noFiles() }
        resolveApiArtifacts(javaPlatform) { noFiles() }
        resolveRuntimeArtifacts(javaPlatform) { noFiles() }
    }

    def "can publish java-platform with constraints"() {
        given:

					decl.Recv = nil
				}
			}
			decls = append(decls, decl)
		}
		f.Decls = decls
		if debug {
			format.Node(os.Stderr, fset, f) // debugging
		}
		cgoFiles = append(cgoFiles, f)
	}
	if cgoFiles == nil {
		return nil, nil, nil // nothing to do (can't happen?)
	}

	// Type-check the synthetic files.
	tc := &types.Config{
		FakeImportC: true,

            builder.applicationClasspath(classPathRegistry.getClassPath("MINIMUM_WORKER_RUNTIME").getAsFiles());
            builder.useApplicationClassloaderOnly();
            builder.applicationClasspath(toFiles(flatClassLoaderStructure.getSpec()));
        } else {
            builder.applicationClasspath(classPathRegistry.getClassPath("CORE_WORKER_RUNTIME").getAsFiles());
        }

     * @param fileNames
     */
    void expectFiles(String... fileNames) {
        always {
            expectFiles(fileNames as List<String>)
        }
    }

    void noFiles() {
        always {
            noFiles()
        }
    }

    /**
     * Short-hand notation for expecting a list of files independently of the fact module metadata is used or not
     * @param fileNames
     */

		// That currently brings in the client via Conn.handleRenegotiation.

	}
	tmpDir := t.TempDir()
	goFile := filepath.Join(tmpDir, "x.go")
	exeFile := filepath.Join(tmpDir, "x.exe")
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := os.WriteFile(goFile, []byte(tt.program), 0644); err != nil {
				t.Fatal(err)
			}
			os.Remove(exeFile)