outputs.cacheIf { true }

                inputs.files(inputFile)
                    .withPropertyName("dummy-input")
                    .withPathSensitivity(PathSensitivity.RELATIVE)

                outputs.dir(outputDir)
                    .withPropertyName('dummy-output')

                doLast {
                    outputFile.text = inputFile.text
                }
            }

        (MHLO_CompositeOp:$composite
          (variadic $inputs),
          ConstantStrAttr<StrAttr, "aten.gelu.default">, $attrs, $_, $_),
        (TFL_GeluOp $inputs, ConstBoolAttrFalse),
        [(IsStrCompositeAttribute<"approximate", "none"> $attrs)]>;

def LegalizeCompositeApproximateAtenGELU : Pat<
        (MHLO_CompositeOp:$composite
          (variadic $inputs),

            try {
                String location = System.getProperty("input.file");
                BufferedReader reader = new BufferedReader(new FileReader(location));
                String input = reader.readLine();
                reader.close();
                FileWriter out = new FileWriter(args[args.length - 1], false);
                out.write(input);
                out.close();
            } catch (IOException e) {

    def "configuration inputs are tracked during task graph serialization"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        and: "a project that has a provider having undeclared configuration inputs, which is linked to a task"
        buildFile("""
            abstract class MyTask extends DefaultTask {
                @Input

        val gradleUserHomeDir: File,
        val jvm: String,
        val startParameterProperties: Map<String, Any?>,
        /**
         * Whether the undeclared inputs accessed while serializing the task graph will be
         * excluded from input tracking. This is a temporary opt-out flag after a change
         * was made in that behavior.
         */
        val ignoreInputsInConfigurationCacheTaskGraphWriting: Boolean,

)

var Decode cbor.DecMode = func() cbor.DecMode {
	decode, err := cbor.DecOptions{
		// Maps with duplicate keys are well-formed but invalid according to the CBOR spec
		// and never acceptable. Unlike the JSON serializer, inputs containing duplicate map
		// keys are rejected outright and not surfaced as a strict decoding error.
		DupMapKey: cbor.DupMapKeyEnforcedAPF,

		// For JSON parity, decoding an RFC3339 string into time.Time needs to be accepted

 * 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.
 */

package org.gradle.internal.cc.impl.inputs.undeclared

class UndeclaredBuildInputsDynamicGroovyBuildScriptIntegrationTest extends AbstractUndeclaredBuildInputsIntegrationTest implements GroovyPluginImplementation {
    @Override
    String getLocation() {

	t.Cleanup(func() {
		t.Helper()
		types := slices.Map(mc.inputs, func(e any) string {
			return fmt.Sprintf("%T", e)
		})
		assert.Equal(t, len(mc.inputs), 0, fmt.Sprintf("some inputs were not consumed: %v (%v)", mc.inputs, types))
	})
	return mc
}

func GetMockCollection[T any](mc *MockCollection) krt.Collection[T] {
	return krt.NewStaticCollection(extractType[T](&mc.inputs))
}

            // Transforms may have inputs or parameters that are task outputs or other changing files
            // When this is not the case, we should run the transform now and write the result.
            // However, currently it is not easy to determine whether this is the case so assume that all transforms
            // have changing inputs
            FileCollectionStructureVisitor.VisitType.NoContents

 * 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.
 */

package org.gradle.internal.cc.impl.inputs.process.instrument

/**
 * Test cases for triple-argument {@code ProcessGroovyMethods.execute}:
 * <pre>
 *     ProcessGroovyMethod.execute("echo 123", env, cwd)