}

                if (modified) {
                    List<Dependency> newDeps = new ArrayList<>(dependencies.size());
                    for (Dependency dep : model.getDependencies()) {
                        Object key = getDependencyKey().apply(dep);
                        Dependency dependency = dependencies.get(key);
                        newDeps.add(dependency);
                    }

                library.name = it.@name
                library.level = it.@level
                return library
            } else {
                def dep = new ImlDependency()
                dep.type = it.@type
                return dep
            }
        })

    }

    class ImlDependencies {
        List<ImlDependency> dependencies

        buildFile << """
            buildscript {
                configurations.classpath {
                    withDependencies { dependencies ->
                       dependencies.configureEach { dep ->
                            dep.attributes {
                                attribute(Attribute.of("org.gradle.status", String.class), "integration")
                            }
                        }
                    }

	"strings"
	"testing"

	"github.com/google/go-cmp/cmp"

	testutil "istio.io/istio/pilot/test/util"
	"istio.io/istio/tools/istio-clean-iptables/pkg/config"
	"istio.io/istio/tools/istio-iptables/pkg/constants"
	dep "istio.io/istio/tools/istio-iptables/pkg/dependencies"
)

func constructTestConfig() *config.Config {
	return &config.Config{
		ProxyUID:           constants.DefaultProxyUID,
		ProxyGID:           constants.DefaultProxyUID,

type IptablesError struct {
	Error    error
	ExitCode int
}

func ProgramIptables(cfg *config.Config) error {
	var ext dep.Dependencies
	if cfg.DryRun {
		log.Info("running iptables in dry-run mode, no rule changes will be made")
		ext = &dep.DependenciesStub{}
	} else {
		ext = &dep.RealDependencies{
			CNIMode:          cfg.CNIMode,
			NetworkNamespace: cfg.NetworkNamespace,
		}
	}

        List<Throwable> exceptions = []
        do {
            try {
                Dependency dep = resolutionServices.dependencyHandler.create(dependency)
                Configuration config = resolutionServices.configurationContainer.detachedConfiguration(dep)
                config.resolutionStrategy.disableDependencyVerification()
                return config.files
            } catch (Throwable t) {

    }

    @Override
    public DependencyConstraint enforcedPlatform(Object notation, Action<? super DependencyConstraint> configureAction) {
        DependencyConstraint dep = enforcedPlatform(notation);
        configureAction.execute(dep);
        return dep;
    }

    private DependencyConstraint doCreate(Object dependencyNotation, @Nullable Action<? super DependencyConstraint> configureAction) {

		} else {
			buf.WriteByte('\n')
			formatMod("=>", *m.Replace)
		}
		buf.WriteByte('\n')
	}
	if bi.Main != (Module{}) {
		formatMod("mod", bi.Main)
	}
	for _, dep := range bi.Deps {
		formatMod("dep", *dep)
	}
	for _, s := range bi.Settings {
		key := s.Key
		if quoteKey(key) {
			key = strconv.Quote(key)
		}
		value := s.Value
		if quoteValue(value) {

                }

                if (modified) {
                    List<Dependency> newDeps = new ArrayList<>(dependencies.size());
                    for (Dependency dep : model.getDependencies()) {
                        Object key = getDependencyKey().apply(dep);
                        Dependency dependency = dependencies.get(key);
                        newDeps.add(dependency);
                    }

    private static boolean selectorAcceptsCandidate(ResolvableSelectorState dep, ComponentIdResolveResult candidate, boolean candidateIsFromLock) {
        if (hasFailure(candidate)) {
            return false;
        }
        ResolvedVersionConstraint versionConstraint = dep.getVersionConstraint();
        if (versionConstraint == null) {
            return dep.getSelector().matchesStrictly(candidate.getId());
        }