"main": "SourceSet",
                        "test": "SourceSet"
                    )
                    assertSchemaIs(repositories,
                        // TODO: These should be more specific eventually
                        "maven": "ArtifactRepository",
                        "ivy": "ArtifactRepository"
                    )
                    assertSchemaIs(configurations,

// Flush local buffers to the filesystem. If the process terminates after a
// successful flush, the contents may still be persisted, since the underlying
// filesystem may eventually flush the contents.  If the OS or machine crashes
// after a successful flush, the contents may or may not be persisted, depending
// on the implementation.

 * - a `writeObject` method with no corresponding `readObject`; `writeObject` must eventually call [ObjectOutputStream.defaultWriteObject];
 * - a `readObject` method with no corresponding `writeObject`; `readObject` must eventually call [ObjectInputStream.defaultReadObject];
 * - a `writeReplace` method to allow the class to nominate a replacement to be written;

        target << "apply plugin: '${getPluginName()}'\n"
    }

    def "does not realize all possible tasks"() {
        // TODO: This isn't done yet, we still realize many tasks
        // Eventually, this should only realize "help"

        Assume.assumeFalse(pluginName in [
            'xctest', // Almost, still realizes compileTestSwift

            'visual-studio',
            'xcode',

	config := &Config{
		Generic: genericConfig,
		Extra: Extra{
			APIResourceConfigSource: storageFactory.APIResourceConfigSource,
			StorageFactory:          storageFactory,
			EventTTL:                opts.EventTTL,
			EnableLogsSupport:       opts.EnableLogsHandler,
			ProxyTransport:          proxyTransport,
			SystemNamespaces:        opts.SystemNamespaces,

 *
 * The project also allows for "overlapping" inputs where the build output and source files are
 * arranged in a way to force the project to include the root directory as an input.
 *
 * We may also eventually include overlapping source directories, where a single directory is used
 * to build multiple components where none/some/a lot of the source files are shared between components

	f        FilterFunc
}

// ResultChan returns a channel which will receive filtered events.
func (fw *filteredWatch) ResultChan() <-chan Event {
	return fw.result
}

// Stop stops the upstream watch, which will eventually stop this watch.
func (fw *filteredWatch) Stop() {
	fw.incoming.Stop()
}

// loop waits for new values, filters them, and resends them.
func (fw *filteredWatch) loop() {
	defer close(fw.result)

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * Describes the set of filtered XCTests.
 *
 * NOTE: Eventually we want to support regular Java-like test filtering, like filtering for a set of test cases
 * or test suites that match a particular pattern.  Unfortunately, XCTest is very limited with how much up-front

        return resolveModuleComponentCoordinates(dependency.getGroup(), dependency.getName());
    }

    @Override
    public ResolvedCoordinates resolveComponentCoordinates(ProjectDependency dependency) {
        // TODO: Eventually resolved project coordinates should be made available
        //       via the resolution result.
        Path identityPath = ((ProjectDependencyInternal) dependency).getIdentityPath();

    the file will be written. To minimize this, just before writing reports
    the code checks again to see if they exist.
1C. Once there is an existing well-formed file YYYY-MM-DD.json in localdir
    eventually the upload will succeed, and the file will be moved to updatedir.
    It is possible that other processes will not see the file in updatedir and
    upload it again and also move it to uploaddir. This is harmless as all