// cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")
	// result: (Int64Make (Arg <typ.Int32> {n} [off+4]) (Arg <typ.UInt32> {n} [off]))
	for {
		off := auxIntToInt32(v.AuxInt)
		n := auxToSym(v.Aux)
		if !(is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) {
			break
		}
		v.reset(OpInt64Make)

        if (!hasNext()) {
          throw new NoSuchElementException();
        }
        /*
         * requireNonNull is safe because our callers always pass non-null arguments. Each element
         * of the array becomes null only when we iterate past it and then clear it.
         */
        I result = requireNonNull(elements[index]);
        elements[index] = null;
        index++;
        return result;
      }

        if (!hasNext()) {
          throw new NoSuchElementException();
        }
        /*
         * requireNonNull is safe because our callers always pass non-null arguments. Each element
         * of the array becomes null only when we iterate past it and then clear it.
         */
        I result = requireNonNull(elements[index]);
        elements[index] = null;
        index++;
        return result;
      }

		g.Expect(ok).NotTo(BeFalse())
		g.Expect(redirectAction.Redirect.ResponseCode).To(Equal(envoyroute.RedirectAction_PERMANENT_REDIRECT))
	})

	t.Run("for path prefix redirect", func(t *testing.T) {
		g := NewWithT(t)
		cg := core.NewConfigGenTest(t, core.TestOptions{})

    tf_device.return %3 : tensor<*xi32>
  }) {cluster_attr = "cluster_attr"} : () -> tensor<*xi32>

  // CHECK: return %[[CLUSTER_RES]]
  return %0 : tensor<*xi32>
}

// -----

// Tests that pass lifts resource reads/writes from a loop, and removed unused
// resources.

// CHECK-LABEL: func @cluster_with_loop
func.func @cluster_with_loop() -> () {

|===
| Original Input | New Input | Reasoning

| `file:relative/path` | `relative/path` | The `file` scheme does not support relative paths.
| `file:relative/path%21` | `relative/path!` | Without a scheme, the path is taken as-is, without decoding.
| `https://example.com/my folder/` | `https://example.com/my%20folder/` | Spaces are not valid in URLs.

	ws := a.newWebService()

	// Register the paths in a deterministic (sorted) order to get a deterministic swagger spec.
	paths := make([]string, len(a.group.Storage))
	var i int = 0
	for path := range a.group.Storage {
		paths[i] = path
		i++
	}
	sort.Strings(paths)
	for _, path := range paths {
		apiResource, resourceInfo, err := a.registerResourceHandlers(path, a.group.Storage[path], ws)
		if err != nil {

====

As you can see, you can pass strings, `File` instances and `{javaApi}/java/nio/file/Path.html[Path]` instances to the `file()` method, all of which result in an absolute `File` object.

In the case of multi-project builds, the `file()` method will always turn relative paths into paths relative to the current project directory, which may be a child project.

=== Using `Project.getRootDir()`

// This tiling algorithm supports array data, since the type always refers to
// the element type of the array. Single objects are considered the same as
// single-element arrays.
// The tiling algorithm may scan data past the end of the compiler-recognized
// object, but any unused data within the allocation slot (i.e. within s.elemsize)
// is zeroed, so the GC just observes nil pointers.

	err        error
}

// TestBuildUpstreamClusterTLSContext tests the buildUpstreamClusterTLSContext function
func TestBuildUpstreamClusterTLSContext(t *testing.T) {
	clientCert := "/path/to/cert"
	rootCert := "path/to/cacert"
	clientKey := "/path/to/key"

	credentialName := "some-fake-credential"

	testCases := []struct {
		name                     string
		opts                     *buildClusterOpts