for _, test := range []struct{ in, want string }{
		// Short; unchanged:
		{`C:\short.txt`, `C:\short.txt`},
		{`C:\`, `C:\`},
		{`C:`, `C:`},
		// The "long" substring is replaced by a looooooong
		// string which triggers the rewriting. Except in the
		// cases below where it doesn't.
		{`C:\long\foo.txt`, `\\?\C:\long\foo.txt`},
		{`C:/long/foo.txt`, `\\?\C:\long\foo.txt`},

        then:
        component.deployName == constructorDeployName
        component.contextPath == constructorContextPath
        // dependent modules are replaced, other entries are added up
        component.wbModuleEntries as Set == [
                new WbDependentModule('foo-1.2.3.jar', '/WEB-INF/lib', "module:/classpath/foo-1.2.3.jar"),

	if labels == nil {
		return labelMap(nil)
	}
	return *labels
}

// labelMap is the representation of the label set held in the context type.
// This is an initial implementation, but it will be replaced with something
// that admits incremental immutable modification more efficiently.
type labelMap map[string]string

// String satisfies Stringer and returns key, value pairs in a consistent
// order.

[!short] go build
[!short] ! go build -mod=vendor

# Without vendoring, 'go list' should report the replacement directory for
# a package in a replaced module.
go list -f {{.Dir}} x
stdout 'src[\\/]x'

# 'go mod vendor' should copy all replaced modules to the vendor directory.
go mod vendor -v
stderr '^# x v1.0.0 => ./x'
stderr '^x'
stderr '^# y v1.0.0 => ./y'
stderr '^y'
stderr '^# z v1.0.0 => ./z'

        def replaced1 = Stub(FileCollectionInternal)
        def supplier = Stub(Supplier)

        collection.from(collection1, collection2)

        when:
        def replaced = collection.replace(collection1, supplier)

        then:
        replaced != collection
        replaced.sourceCollections == [replaced1, collection2]

        1 * collection1.replace(collection1, supplier) >> replaced1

2. Run the `my-app` application, including the `my-utils` build.

```
cd my-app
gradle --include-build ../my-utils run
```

Using _dependency substitution_, the module dependencies on the util libraries are replaced by project dependencies on `my-utils`.

== Converting `my-app` to a composite build

It's possible to make the above arrangement persistent, by making `my-app` a composite build that includes `my-utils`.

```

 * there is a class-level lower bound for both versions.
 *
 * In addition, in version 6.6 the deprecated {@code DependencySubstitutions#with(ComponentSelector)} method
 * was removed, to be replaced by {@code #using(ComponentSelector)} so there are 2 versions of tests
 * present using either of those methods - pre and post Gradle 6.6.  And when the TAPI or Gradle versions

	if err != nil {
		return nil, fmt.Errorf("fail to read section relocations: %v", err)
	}
	return relocs, nil
}

// SectionHeader is similar to [SectionHeader32] with Name
// field replaced by Go string.
type SectionHeader struct {
	Name                 string
	VirtualSize          uint32
	VirtualAddress       uint32
	Size                 uint32
	Offset               uint32
	PointerToRelocations uint32

      old_parallel_execute->getLoc(),
      num_moved_children + num_cores_per_replica, concatenated_output_types);

  // `cluster_idx` is the index of the child with the `ClusterFuncOp`, which
  // will be replaced.
  int cluster_idx = -1;
  for (size_t child_idx = 0;
       child_idx < old_parallel_execute.getRegions().size(); ++child_idx) {
    auto& block = old_parallel_execute.GetRegionBlockWithIndex(child_idx);

                File platformSdkPath = sdkPlatformPathLocator.find();
                File frameworkDir = new File(platformSdkPath, "Developer/Library/Frameworks");
                // Since Xcode 11/12, the XCTest framework is being replaced by a different library that's available in the sdk root
                File extraInclude = new File(platformSdkPath, "Developer/usr/lib");