@TaskAction
                void test() {
                    def resolved = result.get().dependencies
                    assert declared.get() == resolved*.selected*.moduleVersion*.name as Set
                }
            }

            allprojects {
                configurations {
                    foo
                }
                repositories {

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

moduleName=model-core
moduleVersion=1.0

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

moduleName=dependency-management
moduleVersion=1.0

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

moduleName=model-core-tests
moduleVersion=1.0

    abstract String getProjectPath();

    abstract String dependsOnMechanism(String projectName, String taskName);

    abstract String declareDependency(String moduleName, String moduleVersion);

    abstract String declaredDependencyId(String moduleName, String moduleVersion);

    abstract void moduleDefinition(String name, String definition);

    /**

        args.add("-classpath");
        args.add(Joiner.on(File.pathSeparatorChar).join(classpath));

        if (!modulePath.isEmpty()) {
            if (moduleVersion != null) {
                args.add("--module-version");
                args.add(moduleVersion);
            }
            args.add("--module-path");
            args.add(Joiner.on(File.pathSeparatorChar).join(modulePath));
        }
    }

    /**
     * Visit graph independent details of the component.
     */
    void visitComponentDetails(ComponentIdentifier componentId, ModuleVersionIdentifier moduleVersion);

    /**
     * Visit a selected variant of the component.
     */
    void visitSelectedVariant(Long id, ResolvedVariantResult variant);

    /**
     * Visit variants of the component.
     */

                    println "scriptTask - " + this.getClass().classLoader.getResource('d/v.txt').text
                }
            }

            task buildscriptDependencies {
                def moduleVersion = buildscript.configurations.classpath.incoming.artifacts.artifacts
                    .collect { it.id }
                    .findAll { it.componentIdentifier instanceof ModuleComponentIdentifier }

                assert !t.changing
                t.refresh()
            }
        })
        cachePolicy.moduleExpiry(moduleComponent('g', 'n', 'v'), moduleVersion('group', 'name', 'version'), Duration.ofMillis(5)).mustCheck
    }

    def "provides details of cached changing module"() {
        expect:
        cachePolicy.eachModule(new Action<ModuleResolutionControl>() {

    // https://github.com/gradle/configuration-cache/issues/183
    val modules = provider {
        embeddedKotlinBaseDependencies.incoming.resolutionResult.allComponents
            .asSequence()
            .mapNotNull { it.moduleVersion }
            .filter { it.name !in skippedModules }
            .associate { "${it.group}:${it.name}" to it.version }
    }

    doLast {
        ReproduciblePropertiesWriter.store(
            modules.get(),