}

    private int computeHashCode() {
        int result = owner.hashCode();
        result = 31 * result + displayName.hashCode();
        result = 31 * result + attributes.hashCode();
        result = 31 * result + capabilities.hashCode();
        if (externalVariant != null) {
            result = 31 * externalVariant.hashCode();
        }
        return result;
    }

    @Override
    public String toString() {

        succeeds "b"

        then:
        result.assertTasksSkipped(":a", ":b")

        // Remove input file
        when:
        file('src/file2.txt').delete()
        succeeds "b"

        then:
        result.assertTasksNotSkipped(":a")
        result.assertTasksSkipped(":b")

        when:
        succeeds "b"

        then:
        result.assertTasksSkipped(":a", ":b")

  // expected-remark@below {{Result #0, ID 0 : 0}}
  %vh0 = "tf.VarHandleOp"() {container = "c", shared_name = "v0"} : () -> !tf_res
  %read0 = "tf.ReadVariableOp"(%vh0) : (!tf_res) -> tensor<32xf32>
  // expected-remark@below {{Result #0, ID 1 : Unknown}}
  // expected-remark@below {{Result #1, ID 2 : 1, 2, 3, 5}}
  // expected-remark@below {{Result #2, ID 3 : 0, 1, 2, 3, 5}}
  %if:3 = "tf.If"(%read0, %arg1, %vh0) {

    /**
     * @see LoadProjectsBuildOperationType.Result#getBuildPath()
     */
    String getBuildPath();

    /**
     * @see LoadProjectsBuildOperationType.Result#getRootProject()
     */
    Project getRootProject();

    interface Project {
        /**
         * @see LoadProjectsBuildOperationType.Result.Project#getName()
         */
        String getName();

        /**

	// match: (MOVBUreg x:(Equal _))
	// result: x
	for {
		x := v_0
		if x.Op != OpARM64Equal {
			break
		}
		v.copyOf(x)
		return true
	}
	// match: (MOVBUreg x:(NotEqual _))
	// result: x
	for {
		x := v_0
		if x.Op != OpARM64NotEqual {
			break
		}
		v.copyOf(x)
		return true
	}
	// match: (MOVBUreg x:(LessThan _))
	// result: x
	for {
		x := v_0

        def serialized = serialize(invocation1, invocation2, invocation3)
        def result = deserializeMultiple(serialized, 3)

        then:
        result[0].method == method1
        result[0].arguments == [1, 2] as Object[]
        result[1].method == method2
        result[1].arguments == [3] as Object[]
        result[2].method == method1
        result[2].arguments == [4, 5] as Object[]
    }

            }
        """
        )
        withKotlinSourceFile()

        val result = build("compileKotlin")

        result.assertOutputContains("before compiling")
        result.assertOutputContains("after compiling")
        result.assertNotOutput(experimentalWarningHeader)
        result.assertNotOutput(experimentalFeatureWithoutWarning)
    }

    @Test

    }

    @Override
    protected <RESULT extends FileConfig> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setAvailable(DfTypeUtil.toBoolean(source.get("available")));
            result.setBoost(DfTypeUtil.toFloat(source.get("boost")));

     *
     * @param <RESULT> the type of entry stored in the cache.
     */
    public interface EntryValidator<RESULT> {
        boolean isValid(CachePolicy policy, CachedEntry<RESULT> entry);
    }

    private static class CacheEntrySerializer<RESULT> extends AbstractSerializer<CachedEntry<RESULT>> {
        private final Serializer<RESULT> resultSerializer;

import org.gradle.internal.component.model.ModuleSources;
import org.gradle.internal.resolve.result.BuildableArtifactFileResolveResult;
import org.gradle.internal.resolve.result.BuildableArtifactSetResolveResult;
import org.gradle.internal.resolve.result.BuildableModuleComponentMetaDataResolveResult;
import org.gradle.internal.resolve.result.BuildableModuleVersionListingResolveResult;

/**