});
                    }

                    private Configuration createBaseConfiguration(Project project) {
                        return project.getConfigurations().create("$TRANSFORM_SOURCE_CONFIGURATION", cfg -> {
                            cfg.setCanBeConsumed(false);
                            cfg.setCanBeResolved(true);
                        });
                    }

                        suppliers.add(supplier);
                    }

                    public void addSupplierWithConfiguration() {
                        Configuration c = getProject().getConfigurations().create("test");
                        addSupplier(() -> "configuration name is " + c.getName());
                    }

                    public void addSupplierWithSourceDirectorySet() {

        return () -> {
            SourceSet sourceSet = extension.getPluginSourceSet();
            Configuration runtimeClasspath = project.getConfigurations().getByName(sourceSet.getRuntimeClasspathConfigurationName());
            ArtifactView view = runtimeClasspath.getIncoming().artifactView(config ->

        }

        override fun ant(configureAction: Action<in AntBuilder>): AntBuilder {
            onAccess("ant")
            return delegate.ant(configureAction)
        }

        override fun getConfigurations(): RoleBasedConfigurationContainerInternal {
            onAccess("configurations")
            return delegate.configurations
        }

        override fun configurations(configureClosure: Closure<*>) {

        } catch (Exception e) {
            throw new PluginContainerException(mojoDescriptor, pluginRealm, "Unable to lookup Mojo", e);
        }

        XmlNode dom = mojoExecution.getConfiguration() != null
                ? mojoExecution.getConfiguration().getDom()
                : null;

        PlexusConfiguration pomConfiguration;

        if (dom == null) {

        LocalComponentGraphResolveState state = getComponentState(module, componentIdentifier);
        ConfigurationGraphResolveState configuration = state.getConfiguration(configurationName);
        if (configuration == null) {
            throw new IllegalArgumentException(String.format("Expected configuration '%s' to be present in %s", configurationName, componentIdentifier));
        }

                realm,
                Collections.singleton(artifacts.get(0).getFile()),
                extension.getGroupId() + ":" + extension.getArtifactId(),
                extension.getConfiguration());
    }

    private List<Artifact> resolveExtension(
            CoreExtension extension,
            RepositorySystemSession repoSession,
            List<RemoteRepository> repositories,

					} else {
						w := &httpwasm.Wasm{}

						if err := f.GetTypedConfig().UnmarshalTo(w); err != nil {
							t.Fatal(err)
						}
						cfg := &wrappers.StringValue{}
						if err := w.GetConfig().GetConfiguration().UnmarshalTo(cfg); err != nil {
							t.Fatal(err)
						}
						if _, dupe := res[f.GetName()]; dupe {
							t.Fatalf("duplicate filter found: %v", f.GetName())
						}