assertHasZeroOrMoreTrees()
        return operations
    }

    /**
     * Returns all operations with no parent, in the order started.
     */
    List<Operation> getTrees() {
        assertHasZeroOrMoreTrees()
        return operations.findAll { it.descriptor.parent == null }
    }

    /**
     * Returns all generic build operations, in the order started.
     */

        return getTree().first(displayName)
    }

    @Override
    List<BuildOperationRecord> all() {
        return getTree().all()
    }

    @Override
    List<BuildOperationRecord> all(Pattern displayName) {
        return getTree().all(displayName)
    }

    @Override
    BuildOperationRecord only(Pattern displayName) {
        return getTree().only(displayName)
    }

    @Override

        contentFile.write("content");
        archiveFileToRoot(getArchiveFile());

        assertVisits(getTree(), toList("file1.txt"), new ArrayList<>());
        contentFile.makeOlder();
        TestFile.Snapshot snapshot = contentFile.snapshot();
        assertVisits(getTree(), toList("file1.txt"), new ArrayList<>());
        contentFile.assertHasNotChangedSince(snapshot);
    }

    @Test

    @Override
    protected TestFile getArchiveFile() {
        return archiveFile;
    }

    @Override
    protected ZipFileTree getTree() {
        return tree;
    }

    @Test
    public void failsWhenArchiveFileDoesNotExist() {
        try {
            getTree().visit(new EmptyFileVisitor());
            fail();
        } catch (InvalidUserDataException e) {

        snapshot.getPhysicalMemory().getFree() == MemoryAmount.ofGigaBytes(16).bytes
        snapshot.getVirtualMemory() instanceof OsMemoryStatusAspect.Available
        snapshot.getVirtualMemory().getTotal() == MemoryAmount.ofGigaBytes(64).bytes
        snapshot.getVirtualMemory().getFree() == MemoryAmount.ofGigaBytes(16).bytes
    }

        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.versionedGraph)) {
            return new MetadataGraph(getTree(), true, false);
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.scopedGraph)) {
            return new MetadataGraph(getTree(), true, true);
        }
        return null;
    }
    // ----------------------------------------------------------------------------

        } catch (UnsupportedOperationException e) {
            return cGroupDelegate;
        }

        long cGroupFreeMemory = cGroupSnapshot.getPhysicalMemory().getFree();
        long memInfoFreeMemory = memInfoSnapshot.getPhysicalMemory().getFree();

        return cGroupFreeMemory > memInfoFreeMemory ? memInfoDelegate : cGroupDelegate;
    }

    @Override
    public OsMemoryStatus getOsSnapshot() {

        def free = osMemoryInfo.getOsSnapshot().getPhysicalMemory().getFree()

        then:
        free == TEST_FREE_MEMORY
    }

    def "getFreePhysicalMemory fails when memory MBeans are #availability"() {
        given:
        def osMemoryInfo = createMemoryInfo(availability)

        when:
        osMemoryInfo.getOsSnapshot().getPhysicalMemory().getFree()

        then:
        thrown UnsupportedOperationException

    help="give verbose output regarding why a file does not pass",
    action="store_true",
)

args = parser.parse_args()

verbose_out = sys.stderr if args.verbose else open("/dev/null", "w")


def get_refs():
    refs = {}

    for path in glob.glob(os.path.join(args.boilerplate_dir, "boilerplate.*.txt")):
        extension = os.path.basename(path).split(".")[1]

        with open(path, "r") as ref_file:

        then:
        notThrown UnsupportedOperationException
    }

    def "gets OS free memory on any system"() {
        when:
        new DefaultOsMemoryInfo().getOsSnapshot().getPhysicalMemory().getFree()

        then:
        notThrown UnsupportedOperationException
    }

    @Requires(UnitTestPreconditions.Windows)
    def "gets OS virtual memory on a Windows system"() {
        when: