//===----------------------------------------------------------------------===//
// The prepare-quantize-drq Pass.
//
namespace mlir {
namespace quant {

namespace {

using QuantizationUnit = std::pair<Operation*, int>;
using QuantizationUnits = llvm::SetVector<QuantizationUnit>;
using ::tensorflow::quantization::OpSet;

// Applies prepare quantization on the model in TF dialect for dynamic range
// quantization case.

        when(logger.isInfoEnabled()).thenReturn(true);
        executionEventLogger = new ExecutionEventLogger(messageBuilderFactory, logger);
    }

    @Test
    void testProjectStarted() {
        // prepare
        File basedir = new File("").getAbsoluteFile();
        ExecutionEvent event = mock(ExecutionEvent.class);
        MavenProject project = mock(MavenProject.class);

}
project(":b") {
    group = 'org.gradle'
    version = '1.0'

    configurations {
        compile
    }
    dependencies {
        compile project(':a')
    }
}
"""
        resolve.prepare()

        expect:
        succeeds ":b:checkDeps"
        executedAndNotSkipped ":a:jar"
        resolve.expectGraph {
            root(":b", "org.gradle:b:1.0") {
                project(":a", "test:a:") {

			}

			// If this claim is already prepared, there is no need to prepare it again.
			if claimInfo.isPrepared() {
				return nil
			}

			// This saved claim will be used to update ClaimInfo cache
			// after NodePrepareResources GRPC succeeds
			resourceClaims[claimInfo.ClaimUID] = resourceClaim

			// Loop through all plugins and prepare for calling NodePrepareResources.

	}
	AssertAssociationCount(t, user2, "Pets", 0, "after delete")

	// Prepare Data for Clear
	if err := DB.Model(&user2).Association("Pets").Append(&pet); err != nil {
		t.Fatalf("Error happened when append Pets, got %v", err)
	}

	AssertAssociationCount(t, user2, "Pets", 1, "after prepare data")

	// Clear
	if err := DB.Model(&user2).Association("Pets").Clear(); err != nil {

        when:
        buildFile << """
configurations.compile.withDependencies {
    throw new RuntimeException("Bad user code")
}
"""

        then:
        resolve.prepare()
        fails ":checkDeps"

        failure.assertHasCause("Bad user code")
    }

    @ToBeFixedForConfigurationCache(because = "task uses Configuration API")

// RUN: tf-opt %s -tfl-prepare-quantize-dynamic-range="enable-custom-op-quantization=CustomTestOp=1" -tfl-quantize="enable-dynamic-range-quantization=true enable-custom-op-weight-only=CustomTestOp=false" -tfl-post-quantize="enable-no-side-effect=CustomTestOp=false" | FileCheck --check-prefix=NotPrune %s

// RUN: tf-opt %s -tfl-prepare-quantize-dynamic-range -tfl-quantize="enable-dynamic-range-quantization=true" | FileCheck %s
// RUN: tf-opt %s -tfl-prepare-quantize-dynamic-range -tfl-quantize="enable-dynamic-range-quantization=true enable-weight-only-quantization=true" | FileCheck --check-prefix=PerChannelWeightOnly %s

                }
                dependencies {
                    'default'('com.acme.external:external:1.0')
                }
            }
        '''
        resolve.prepare {
            config('_compileFreeDebug', 'checkDebug')
            config('_compileFreeRelease', 'checkRelease')
        }

        file('includedBuild/build.gradle') << """

            group = 'com.acme.external'

             "Whether the source graph is a QDQ model intended for conversion only.">,
  ];
}

def PrepareDynamicRangeQuantizePass : Pass<"tfl-prepare-quantize-dynamic-range", "mlir::func::FuncOp"> {
  let summary = "Prepare TFL dialect for dynamic range quantization.";
  let constructor = "CreatePrepareDynamicRangeQuantizePass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect",