package gorm

import (
	"context"
	"database/sql"

	"gorm.io/gorm/clause"
	"gorm.io/gorm/schema"
)

// Dialector GORM database dialector
type Dialector interface {
	Name() string
	Initialize(*DB) error
	Migrator(db *DB) Migrator
	DataTypeOf(*schema.Field) string
	DefaultValueOf(*schema.Field) clause.Expression
	BindVarTo(writer clause.Writer, stmt *Statement, v interface{})
	QuoteTo(clause.Writer, string)

                // if the collection is a read-only property, it must be initialized first (it will never be null)
                // if the collection is *not* read-only, then we will initialize it only if the collection is the
                // subject of a rule, that is to say that it can be mutated. This may look strange, if a read-write
                // collection is null to initialize it to an empty list, but this is how the specs define reaw-write

	config := doNothingQuotaConfiguration{}
	initializer := NewPluginInitializer(config, nil)
	wantsQuotaConfigurationAdmission := &WantsQuotaConfigurationAdmissionPlugin{}
	initializer.Initialize(wantsQuotaConfigurationAdmission)

	if wantsQuotaConfigurationAdmission.config == nil {
		t.Errorf("Expected quota configuration to be initialized but found nil")
	}

<project>
    <target name='target1' depends='target2,initialize'>
        <touch file='build/target1.txt'/>
    </target>
    <target name='target2' depends='initialize'>
        <touch file='build/target2.txt'/>
    </target>
</project>
"""
        testFile('build.gradle') << """
ant.importBuild(file('build.xml'))
task initialize { doLast { buildDir.mkdirs() } }
task ant(dependsOn: target1)
"""

namespace tensorflow {
namespace quantization {

// Saves variables in `module_op` to the checkpoint file inside `prefix`.
// It finds variables that are initialized with "tf.AssignVariableOp" inside the
// initializer function with type "restore_op". The "tf.Const"s used to
// initialize the variables are saved. This function does not modify the
// `module_op`. Returns a list of saved names of the saved variables.

	"context"
	"encoding/base64"
	"testing"
)

func TestSingleKeyRoundtrip(t *testing.T) {
	KMS, err := ParseSecretKey("my-key:eEm+JI9/q4JhH8QwKvf3LKo4DEBl6QbfvAl1CAbMIv8=")
	if err != nil {
		t.Fatalf("Failed to initialize KMS: %v", err)
	}

	key, err := KMS.GenerateKey(context.Background(), &GenerateKeyRequest{Name: "my-key"})
	if err != nil {
		t.Fatalf("Failed to generate key: %v", err)
	}

    def credential = Mock(Credential)
    def credentialSupplier = new Supplier<Credential>() {
        @Override
        Credential get() {
            return credential
        }
    }

    def "initialize should configure request for retries"() {
        given:
        def retryHttpInitializerWrapper = new RetryHttpInitializerWrapper(credentialSupplier)

  let constructor = "mlir::tf_test::CreateLiftVariablesTestPass()";
}

def InitializeVariablesInSessionInitializerPass : Pass<"tf-saved-model-initialize-variables-in-session-init", "ModuleOp"> {
  let summary = "Initialize variables in session initializer function.";

  let constructor = "mlir::tf_test::CreateInitializeVariablesInSessionInitializerTestPass()";
}

  LogicalResult RewriteFunc();

  int GetNumInputs() { return n_input_; }

 protected:
  // verify input func op arguments/attributes and initialize internal state.
  virtual LogicalResult InitializeFromFuncAttributes();
  virtual LogicalResult Initialize();

  void UpdateFuncSignature();
  void GenerateFusedOpOperands();

  void SetWeightForInputToCellGate();
  void SetWeightForInputToInputGate();

        }
        registerAction(modelPath, modelType, ModelActionRole.Initialize, modelAction);
    }

    private <T> void registerAction(ModelPath modelPath, ModelType<T> viewType, final ModelActionRole role, final DeferredModelAction action) {
        ModelReference<T> reference = ModelReference.of(modelPath, viewType);