}
	}

	backingDev, okBackingDev := backingDevMap[path]
	if !okBackingDev {
		backingDev, err = detectBackingDev(m, mountpoint)
		if err != nil {
			return "", "", fmt.Errorf("cannot determine backing device for %s: %v", path, err)
		}
	}
	mountpointMap[path] = mountpoint
	backingDevMap[path] = backingDev
	return mountpoint, backingDev, nil
}

func clearFSInfo(path string) {

	}
	if testcase.expectFailure {
		return fmt.Errorf("path %s expected to fail; succeeded and got %s", testcase.path, backingDev)
	}
	if backingDev == testcase.expectedResult {
		return nil
	}
	return fmt.Errorf("mismatch: path %s expects mountpoint %s got %s", testcase.path, testcase.expectedResult, backingDev)
}

func TestBackingDev(t *testing.T) {
	testcasesBackingDev := map[string]backingDevTest{
		"Root": {

// GetQuotaApplier -- does this backing device support quotas that
// can be applied to directories?
func (*VolumeProvider) GetQuotaApplier(mountpoint string, backingDev string) LinuxVolumeQuotaApplier {
	for _, fsType := range linuxSupportedFilesystems {
		if isFilesystemOfType(mountpoint, backingDev, fsType.typeMagic) {
			return linuxVolumeQuotaApplier{mountpoint: mountpoint,
				maxQuota:         fsType.maxQuota,

type LinuxVolumeQuotaProvider interface {
	// GetQuotaApplier retrieves an object that can apply
	// quotas (or nil if this provider cannot support quotas
	// on the device)
	GetQuotaApplier(mountpoint string, backingDev string) LinuxVolumeQuotaApplier
}

// LinuxVolumeQuotaApplier is a generic interface to any quota
// mechanism supported by Linux
type LinuxVolumeQuotaApplier interface {

        DomainObjectSet<PublishArtifact> backingSet,
        FileCollectionFactory fileCollectionFactory,
        TaskDependencyFactory taskDependencyFactory
    ) {
        this(Describables.of(displayName), backingSet, fileCollectionFactory, taskDependencyFactory);
    }

    public DefaultPublishArtifactSet(
        Describable displayName,
        DomainObjectSet<PublishArtifact> backingSet,

  static class StandardImplForwardingNavigableSet<T> extends ForwardingNavigableSet<T> {
    private final NavigableSet<T> backingSet;

    StandardImplForwardingNavigableSet(NavigableSet<T> backingSet) {
      this.backingSet = backingSet;
    }

    @Override
    protected NavigableSet<T> delegate() {
      return backingSet;
    }

    @Override
    public boolean equals(@Nullable Object object) {

    private final Action<? super ModuleDependency> mutationValidator;

    public DefaultDependencySet(Describable displayName, final ConfigurationInternal clientConfiguration, DomainObjectSet<Dependency> backingSet) {
        super(backingSet);
        this.displayName = displayName;
        this.clientConfiguration = clientConfiguration;
        this.mutationValidator = toMutationValidator(clientConfiguration);
    }

    private final ConfigurationInternal clientConfiguration;

    public DefaultDependencyConstraintSet(Describable displayName, ConfigurationInternal clientConfiguration, DomainObjectSet<DependencyConstraint> backingSet) {
        super(backingSet);
        this.displayName = displayName;
        this.clientConfiguration = clientConfiguration;
    }

    @Override
    public String toString() {
        return displayName.getDisplayName();

@SuppressWarnings("serial")
@ElementTypesAreNonnullByDefault
final class ImmutableSortedAsList<E> extends RegularImmutableAsList<E>
    implements SortedIterable<E> {
  ImmutableSortedAsList(ImmutableSortedSet<E> backingSet, ImmutableList<E> backingList) {
    super(backingSet, backingList);
  }

  @Override
  ImmutableSortedSet<E> delegateCollection() {
    return (ImmutableSortedSet<E>) super.delegateCollection();
  }

  @Override

 */
public class DelegatingNamedDomainObjectSet<T> extends DelegatingDomainObjectSet<T> implements NamedDomainObjectSet<T> {

    public DelegatingNamedDomainObjectSet(NamedDomainObjectSet<T> backingSet) {
        super(backingSet);
    }

    @Override
    protected NamedDomainObjectSet<T> getDelegate() {
        return (NamedDomainObjectSet<T>) super.getDelegate();
    }

    @Override