}
                                }
                            }
                        }
                    }
                } else if (dependencies || !variants.dependencies.flatten().empty) {
                    dependencies {
                        dependencies.each { dep ->
                            dependency {
                                groupId(dep.groupId)

    return durationsPerTestProject
        .mapValues { (_, durations) -> durations.flatten().map { it.scenario } }
}

class EmptyTestProjectBucket(private val index: Int) : PerformanceTestBucket {
    override

        val subprojectRoots = File("../platforms").listFiles(File::isDirectory).plus(File("../subprojects"))
        val subProjectFolders = subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten().filter { dir ->
            // filter out the directories that have only a `build` subdirectory - this usually happens after branch switching
            dir.listFiles { _: File, name: String -> name != "build" }!!.isNotEmpty()

            return causes
        }

        @Override
        List<String> getResolutions() {
            return causes.collect { it instanceof ResolutionProvider ? ((ResolutionProvider) it).getResolutions() : null }.flatten() as List<String>
        }
    }

    @Contextual
    abstract static class TestException extends LocationAwareException {
        protected TestException(Throwable cause, ScriptSource source, Integer lineNumber) {

			input: [][]int{{1, 2}, {}, {3, 4}},
			want:  []int{1, 2, 3, 4},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			got := Flatten(tc.input)
			if !reflect.DeepEqual(got, tc.want) {
				t.Errorf("Flatten(%v) = %v; want %v", tc.input, got, tc.want)
			}
		})
	}
}

// nolint: unused
type myStruct struct {
	a, b, c, d string
	n          int
}

    }

    /**
     * Recursively unpacks all the given things into a flat list.
     *
     * Nulls are not removed, they are left intact.
     *
     * @param things The things to flatten
     * @return A flattened list of the given things
     */
    public static List<?> flattenCollections(Object... things) {
        return flattenCollections(Object.class, things);
    }

    /**

			cc.PodMaxBackoffSeconds, "must be greater than or equal to PodInitialBackoffSeconds"))
	}

	errs = append(errs, validateExtenders(field.NewPath("extenders"), cc.Extenders)...)
	return utilerrors.Flatten(utilerrors.NewAggregate(errs))
}

func validatePercentageOfNodesToScore(path *field.Path, percentageOfNodesToScore *int32) error {
	if percentageOfNodesToScore != nil {

        def byteArrayList = [[(byte) 1, (byte) 2, (byte) 3] as byte[], [(byte) 4] as byte[], [(byte) 5, (byte) 6] as byte[]]
        expect:
        StreamByteBuffer.of(byteArrayList).readAsByteArray() == (byteArrayList.flatten() as byte[])
    }

 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface DependencyResolverRequest {

    enum RequestType {
        COLLECT,
        FLATTEN,
        RESOLVE
    }

    @Nonnull
    Session getSession();

    @Nonnull
    RequestType getRequestType();

    @Nonnull
    Optional<Project> getProject();

    @Nonnull

            this.rootNode = new Node(path);
        }

        PrefixFileSet(Node rootNode) {
            this.rootNode = rootNode;
        }

        @VisibleForTesting
        List<String> flatten() {
            final List<String> prefixes = new ArrayList<String>();
            rootNode.visitHierarchy(0, new NodeVisitor() {
                @Override
                public void visitNode(int depth, Node node) {