InstallExecutable installTask = (InstallExecutable) tasks.getInstall();
            RunTestExecutable runTask = (RunTestExecutable) tasks.getRun();
            runTask.getInputs().files(installTask.getOutputs().getFiles()).withPropertyName("installTask.outputs").withPathSensitivity(PathSensitivity.RELATIVE);
            runTask.setExecutable(installTask.getRunScriptFile().get().getAsFile().getPath());

            this.astTransformationClasspath.from((Callable<FileCollection>) this::getClasspath);
        }
        CompilerForkUtils.doNotCacheIfForkingViaExecutable(compileOptions, getOutputs());
    }

    @Override
    @CompileClasspath
    @Incremental
    public FileCollection getClasspath() {

    protected Generator<T> generator;

    protected T domainObject;

    public GeneratorTask() {
        if (!getIncremental()) {
            getOutputs().upToDateWhen(Specs.satisfyNone());
        }
    }

    /**
     * Whether this generator task can be treated as an incremental task or not
     *
     * @since 4.7
     */
    @Internal

        TaskCollection<Test> testTaskCollection = Mock()
        _ * testTaskCollection.iterator() >> [testTask].iterator()
        _ * tasksContainerInternal.withType(AbstractTestTask) >> testTaskCollection
        _ * testTask.getOutputs() >> outputsInternal
        _ * testTask.getPath() >> TEST_TASK_NAME
        _ * taskSelectionResult.collectTasks(_) >> { args ->
            Collection<? super Task> tasks = args[0]
            tasks.add(testTask)

            return;
        }

        if (element instanceof Task) {
            visitor.accept((FileCollectionInternal) ((Task) element).getOutputs().getFiles());
        } else if (element instanceof TaskOutputs) {
            visitor.accept((FileCollectionInternal) ((TaskOutputs) element).getFiles());
        } else if (DeferredUtil.isNestableDeferred(element)) {

        boolean cleanedOutputs = StaleOutputCleaner.cleanOutputs(
            getDeleter(),
            getOutputs().getPreviousOutputFiles(),
            getObjectFileDir()
        );

        DefaultAssembleSpec spec = new DefaultAssembleSpec();
        spec.setTempDir(getTemporaryDir());

            DirectoryProperty generatedJavadocDirectory = objects.directoryProperty();
            generatedJavadocDirectory.set(layout.getBuildDirectory().dir("javadoc"));
            task.getOutputs().dir(generatedJavadocDirectory);
            task.getExtensions().getExtraProperties().set("destinationDirectory", generatedJavadocDirectory);
            // TODO: This breaks the provider

            inputFileProperties.build(),
            outputFileProperties.build()
        );
    }

    @Override
    public void doNotStoreInCache(Test task) {
        ((TaskOutputsEnterpriseInternal) task.getOutputs()).doNotStoreInCache();
    }

    private ImmutableList<CandidateClassFile> collectCandidateClassFiles(Test task) {
        ImmutableList.Builder<CandidateClassFile> builder = ImmutableList.builder();

            DirectoryFileTreeFactory directoryFileTreeFactory,
            FileSystemAccess fileSystemAccess,
            TaskFileVarFactory fileVarFactory
        ) {
            this.taskOutputs = task.getOutputs();
            this.taskPath = task.getPath();
            this.includeDirs = includeDirs;
            this.sourceFiles = sourceFiles;
            this.macros = macros;
            this.importAware = importAware;

        tf_op.getLoc(), qtype.getValue(), input);
    auto dequantize = rewriter.create<quantfork::DequantizeCastOp>(
        tf_op.getLoc(), res_type, quantize.getResult());
    tf_op.getOutputs().replaceAllUsesWith(dequantize);

    return success();
  }

  bool use_fake_quant_num_bits_;
};

// Removes the wrapper of the tf.FakeQuant* ops and creates the quant.qcast