// helloworld.go is package main
    run("go tool compile -p=main -importcfg", tmp("importcfg"), "-o", tmp("linkmain.o"), "helloworld.go")
	run("go tool compile -p=main -importcfg", tmp("importcfg"), " -pack -o", tmp("linkmain.a"), "helloworld.go")
	run("go tool link -importcfg", tmp("importcfg"), "-o", tmp("linkmain.exe"), tmp("linkmain.o"))
	run("go tool link -importcfg", tmp("importcfg"), "-o", tmp("linkmain.exe"), tmp("linkmain.a"))

the device capabilites. For example, If the user specified the desired targets
are "GPU", "CPU", `conv2d` can run on both "GPU" and "CPU", we will annotate
the op `conv2d` with "GPU" since it's preferred; `pack` can only run on "CPU",
so we will annotate the op with "CPU" since "GPU" does not support this op.

#### Raise Target Subgraphs Pass

In this pass, ops will be broken down into subgraph. Those ops have the same

	"time"
)

// TestMain executes the test binary as the pack command if
// GO_PACKTEST_IS_PACK is set, and runs the tests otherwise.
func TestMain(m *testing.M) {
	if os.Getenv("GO_PACKTEST_IS_PACK") != "" {
		main()
		os.Exit(0)
	}

	os.Setenv("GO_PACKTEST_IS_PACK", "1") // Set for subprocesses to inherit.
	os.Exit(m.Run())
}

// packPath returns the path to the "pack" binary to run.
func packPath(t testing.TB) string {

! stdout vendor/golang.org
! stdout cmd/vendor

# In GOPATH mode, packages vendored into GOROOT should be reported as standard.
go list -f '{{if .Standard}}{{.ImportPath}}{{end}}' std cmd
stdout golang.org/x/net/http2/hpack
stdout cmd/vendor/golang\.org/x/arch/x86/x86asm

# However, vendored packages should not match wildcard patterns beginning with cmd.
go list cmd/...
stdout cmd/compile

        given:
        MavenModuleResolveMetadata metadata = Stub()
        metadata.getPackaging() >> "pack"
        def factory = new MetadataDescriptorFactory(metadata)

        when:
        def descriptor = factory.createDescriptor(PomModuleDescriptor)

        then:
        descriptor.packaging == "pack"
    }

    def 'does not expose #name descriptor if no #name metadata present'() {
        given:

// TFR function name. Examples:
//   tf.Pack => tf__pack
//   tf.ConcatV2 => tf__concat_v2
// TODO(fengliuai): move to an util file.
std::string GetComposeFuncName(StringRef tf_op_name);

// This is a hardcoded rule for mapping a TFR function op name to the
// corresponding TF opname. Examples:
//   tf__pack -> tf.Pack
//   tf__concat_v2 => tf.ConcatV2

    // Construct forward graph.
    auto a = Const(scope, 1, {4, 2});
    auto b = Const(scope, 2, {4, 2});
    auto c = Const(scope, 3, {4, 2});

    auto pack = Stack(scope, {a, b, c});
    auto unpack = Unstack(scope, pack.output, 3);
    TF_ASSERT_OK(scope.status());

    // Construct grad inputs.
    auto dx = Const(scope, 4, {4, 2});
    auto dy = Const(scope, 5, {4, 2});

        ex.message == "unpacking error"
        outputFile.exists()
        0 * _
    }

    def "pack invokes packer"() {
        def output = temporaryFolder.createFile("output")
        def entity = entity(prop("output"))
        def outputSnapshots = Mock(Map)

        when:
        packOperationExecutor.pack(output, key, entity, outputSnapshots, Duration.ofMillis(421L))

        then:

      }
  },
  "customizations": {
      "vscode": {
          "settings": {
              "java.server.launchMode": "Standard"
          },
          "extensions": [
              "vscjava.vscode-java-pack",
              "vscjava.vscode-gradle"
          ]
      }
  }

go list -f '{{.TestImports}}'
stdout net/http # from .TestImports

# 'go list' should report standard-vendored packages by path.
go list -f '{{.Dir}}' vendor/golang.org/x/net/http2/hpack
stdout $GOROOT[/\\]src[/\\]vendor

# 'go list -test' should report vendored transitive dependencies of _test.go
# imports in the Deps field, with a 'vendor' prefix on their import paths.
go list -test -f '{{.Deps}}'