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;
    }
    // ----------------------------------------------------------------------------

        return this.ctx.getConfig();
    }


    private synchronized SmbTreeImpl getTree () {
        SmbTreeImpl t = this.tree;
        if ( t != null ) {
            return t.acquire(false);
        }
        else if ( this.delegate != null ) {
            this.tree = this.delegate.getTree();
            return this.tree;
        }
        return t;
    }


    /**

        } 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

public interface AllocInfo extends FileSystemInformation {

    /**
     * 
     * @return total capacity
     */
    long getCapacity ();


    /**
     * 
     * @return free space
     */
    long getFree ();