def outputFile = testDir.file("output/lib")

        final expectedArgs = [
            "-emit-library",
            "-o", outputFile.absolutePath,
            testDir.file("one.o").absolutePath].flatten()

        when:
        NativePlatform platform = Mock(NativePlatform)
        platform.getOperatingSystem() >> new DefaultOperatingSystem(operatingSystem.name, operatingSystem)

            } else if (flattenType.isInstance(spec)) {
                flatten = true;
                size += ((CompositeExclude) spec).size();
            } else {
                size++;
            }
        }
        if (!filtered && !flatten) {
            return FlattenOperationResult.of(specs);
        }
        if (filtered && !flatten) {
            return filterOnly(specs, ignoreSpec);
        }

		// Lookup remainder of path in each array element and
		// make result array.
		var result []interface{}
		for _, a := range arr {
			rval, flatten, err := jsonpathEval(p[1:], a)
			if err != nil {
				return nil, false, err
			}

			if flatten {
				// Flatten if array.
				if arr, ok := rval.([]interface{}); ok {
					result = append(result, arr...)
					continue
				}
			}

                assert files*.name == ['someDir']
            }
        }

        task run(dependsOn: configurations.compile) {
            doLast {
                assert files*.listFiles().flatten().text == ['some text']
            }
        }
        '''

        when:
        run 'check'

        then:
        executed ':check'

        when:
        run 'run'

        then:

                "-o", outputFile.absolutePath,
                testDir.file("one.o").absolutePath,
                testDir.file("two.o").absolutePath,
                "-arg1", "-arg2"].flatten()

        when:
        LinkerSpec spec = Mock(SharedLibraryLinkerSpec)
        spec.getSystemArgs() >> ['-sys1', '-sys2']
        spec.getArgs() >> ['-arg1', '-arg2']
        spec.getOutputFile() >> outputFile

	}
	return []T{*t}
}

// TypeName returns the name of the type
func TypeName[T any]() string {
	var empty T
	return fmt.Sprintf("%T", empty)
}

// Flatten converts a double pointer to a single pointer by referencing if its non-nil
func Flatten[T any](t **T) *T {
	if t == nil {
		return nil
	}
	return *t

        } catch (DependencyCollectionException e) {
            throw new DependencyResolverException("Unable to collect dependencies", e);
        }
    }

    @Override
    public List<Node> flatten(Session s, Node node, PathScope scope) throws DependencyResolverException {
        InternalSession session = InternalSession.from(s);
        DependencyNode root = cast(AbstractNode.class, node, "node").getDependencyNode();

EndProject"""
        }
        builder << """
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution"""
        Set<String> configurationNames = Sets.newLinkedHashSet(projectConfigurations.values().flatten().collect({ it.name }).sort())
        configurationNames.each { String configurationName ->
            builder << """\n\t\t${configurationName} = ${configurationName}"""
        }
        builder << """
	EndGlobalSection

    @Override
    Statement apply(@NotNull Statement base, @NotNull Description description) {
        List<Class<? extends TestPrecondition>> preconditions = description.annotations.findAll { it instanceof Requires }*.value().flatten()
        PredicatesFile.checkValidCombinations(preconditions, PredicatesFile.DEFAULT_ACCEPTED_COMBINATIONS)

// TODO(b/190203981): Move to a separate nest-like library.
void Flatten(const TaggedValue& value,
             std::vector<AbstractTensorHandle*>* flat_args) {
  if (value.type() == TaggedValue::Type::TENSOR) {
    flat_args->emplace_back(value.tensor().get());
  } else if (value.type() == TaggedValue::Type::TUPLE) {
    for (const auto& t : value.tuple()) {
      Flatten(t, flat_args);
    }
  } else {