// Code generated by azure-service-operator-codegen. DO NOT EDIT.
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
package storage

import (
	"encoding/json"
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/kr/pretty"
	"github.com/kylelemons/godebug/diff"
	"github.com/leanovate/gopter"
	"github.com/leanovate/gopter/gen"
	"github.com/leanovate/gopter/prop"
	"os"
	"reflect"
	"testing"
)

func Test_ClientEncryptionIncludedPath_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ClientEncryptionIncludedPath via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForClientEncryptionIncludedPath, ClientEncryptionIncludedPathGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForClientEncryptionIncludedPath runs a test to see if a specific instance of ClientEncryptionIncludedPath round trips to JSON and back losslessly
func RunJSONSerializationTestForClientEncryptionIncludedPath(subject ClientEncryptionIncludedPath) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ClientEncryptionIncludedPath
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ClientEncryptionIncludedPath instances for property testing - lazily instantiated by
// ClientEncryptionIncludedPathGenerator()
var clientEncryptionIncludedPathGenerator gopter.Gen

// ClientEncryptionIncludedPathGenerator returns a generator of ClientEncryptionIncludedPath instances for property testing.
func ClientEncryptionIncludedPathGenerator() gopter.Gen {
	if clientEncryptionIncludedPathGenerator != nil {
		return clientEncryptionIncludedPathGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForClientEncryptionIncludedPath(generators)
	clientEncryptionIncludedPathGenerator = gen.Struct(reflect.TypeOf(ClientEncryptionIncludedPath{}), generators)

	return clientEncryptionIncludedPathGenerator
}

// AddIndependentPropertyGeneratorsForClientEncryptionIncludedPath is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForClientEncryptionIncludedPath(gens map[string]gopter.Gen) {
	gens["ClientEncryptionKeyId"] = gen.PtrOf(gen.AlphaString())
	gens["EncryptionAlgorithm"] = gen.PtrOf(gen.AlphaString())
	gens["EncryptionType"] = gen.PtrOf(gen.AlphaString())
	gens["Path"] = gen.PtrOf(gen.AlphaString())
}

func Test_ClientEncryptionIncludedPath_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ClientEncryptionIncludedPath_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForClientEncryptionIncludedPath_STATUS, ClientEncryptionIncludedPath_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForClientEncryptionIncludedPath_STATUS runs a test to see if a specific instance of ClientEncryptionIncludedPath_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForClientEncryptionIncludedPath_STATUS(subject ClientEncryptionIncludedPath_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ClientEncryptionIncludedPath_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ClientEncryptionIncludedPath_STATUS instances for property testing - lazily instantiated by
// ClientEncryptionIncludedPath_STATUSGenerator()
var clientEncryptionIncludedPath_STATUSGenerator gopter.Gen

// ClientEncryptionIncludedPath_STATUSGenerator returns a generator of ClientEncryptionIncludedPath_STATUS instances for property testing.
func ClientEncryptionIncludedPath_STATUSGenerator() gopter.Gen {
	if clientEncryptionIncludedPath_STATUSGenerator != nil {
		return clientEncryptionIncludedPath_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForClientEncryptionIncludedPath_STATUS(generators)
	clientEncryptionIncludedPath_STATUSGenerator = gen.Struct(reflect.TypeOf(ClientEncryptionIncludedPath_STATUS{}), generators)

	return clientEncryptionIncludedPath_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForClientEncryptionIncludedPath_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForClientEncryptionIncludedPath_STATUS(gens map[string]gopter.Gen) {
	gens["ClientEncryptionKeyId"] = gen.PtrOf(gen.AlphaString())
	gens["EncryptionAlgorithm"] = gen.PtrOf(gen.AlphaString())
	gens["EncryptionType"] = gen.PtrOf(gen.AlphaString())
	gens["Path"] = gen.PtrOf(gen.AlphaString())
}

func Test_ClientEncryptionPolicy_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ClientEncryptionPolicy via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForClientEncryptionPolicy, ClientEncryptionPolicyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForClientEncryptionPolicy runs a test to see if a specific instance of ClientEncryptionPolicy round trips to JSON and back losslessly
func RunJSONSerializationTestForClientEncryptionPolicy(subject ClientEncryptionPolicy) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ClientEncryptionPolicy
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ClientEncryptionPolicy instances for property testing - lazily instantiated by
// ClientEncryptionPolicyGenerator()
var clientEncryptionPolicyGenerator gopter.Gen

// ClientEncryptionPolicyGenerator returns a generator of ClientEncryptionPolicy instances for property testing.
// We first initialize clientEncryptionPolicyGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func ClientEncryptionPolicyGenerator() gopter.Gen {
	if clientEncryptionPolicyGenerator != nil {
		return clientEncryptionPolicyGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForClientEncryptionPolicy(generators)
	clientEncryptionPolicyGenerator = gen.Struct(reflect.TypeOf(ClientEncryptionPolicy{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForClientEncryptionPolicy(generators)
	AddRelatedPropertyGeneratorsForClientEncryptionPolicy(generators)
	clientEncryptionPolicyGenerator = gen.Struct(reflect.TypeOf(ClientEncryptionPolicy{}), generators)

	return clientEncryptionPolicyGenerator
}

// AddIndependentPropertyGeneratorsForClientEncryptionPolicy is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForClientEncryptionPolicy(gens map[string]gopter.Gen) {
	gens["PolicyFormatVersion"] = gen.PtrOf(gen.Int())
}

// AddRelatedPropertyGeneratorsForClientEncryptionPolicy is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForClientEncryptionPolicy(gens map[string]gopter.Gen) {
	gens["IncludedPaths"] = gen.SliceOf(ClientEncryptionIncludedPathGenerator())
}

func Test_ClientEncryptionPolicy_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ClientEncryptionPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForClientEncryptionPolicy_STATUS, ClientEncryptionPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForClientEncryptionPolicy_STATUS runs a test to see if a specific instance of ClientEncryptionPolicy_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForClientEncryptionPolicy_STATUS(subject ClientEncryptionPolicy_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ClientEncryptionPolicy_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ClientEncryptionPolicy_STATUS instances for property testing - lazily instantiated by
// ClientEncryptionPolicy_STATUSGenerator()
var clientEncryptionPolicy_STATUSGenerator gopter.Gen

// ClientEncryptionPolicy_STATUSGenerator returns a generator of ClientEncryptionPolicy_STATUS instances for property testing.
// We first initialize clientEncryptionPolicy_STATUSGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func ClientEncryptionPolicy_STATUSGenerator() gopter.Gen {
	if clientEncryptionPolicy_STATUSGenerator != nil {
		return clientEncryptionPolicy_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForClientEncryptionPolicy_STATUS(generators)
	clientEncryptionPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(ClientEncryptionPolicy_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForClientEncryptionPolicy_STATUS(generators)
	AddRelatedPropertyGeneratorsForClientEncryptionPolicy_STATUS(generators)
	clientEncryptionPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(ClientEncryptionPolicy_STATUS{}), generators)

	return clientEncryptionPolicy_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForClientEncryptionPolicy_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForClientEncryptionPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["PolicyFormatVersion"] = gen.PtrOf(gen.Int())
}

// AddRelatedPropertyGeneratorsForClientEncryptionPolicy_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForClientEncryptionPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["IncludedPaths"] = gen.SliceOf(ClientEncryptionIncludedPath_STATUSGenerator())
}

func Test_CompositePath_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of CompositePath via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCompositePath, CompositePathGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForCompositePath runs a test to see if a specific instance of CompositePath round trips to JSON and back losslessly
func RunJSONSerializationTestForCompositePath(subject CompositePath) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual CompositePath
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of CompositePath instances for property testing - lazily instantiated by CompositePathGenerator()
var compositePathGenerator gopter.Gen

// CompositePathGenerator returns a generator of CompositePath instances for property testing.
func CompositePathGenerator() gopter.Gen {
	if compositePathGenerator != nil {
		return compositePathGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForCompositePath(generators)
	compositePathGenerator = gen.Struct(reflect.TypeOf(CompositePath{}), generators)

	return compositePathGenerator
}

// AddIndependentPropertyGeneratorsForCompositePath is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCompositePath(gens map[string]gopter.Gen) {
	gens["Order"] = gen.PtrOf(gen.AlphaString())
	gens["Path"] = gen.PtrOf(gen.AlphaString())
}

func Test_CompositePath_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of CompositePath_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCompositePath_STATUS, CompositePath_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForCompositePath_STATUS runs a test to see if a specific instance of CompositePath_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForCompositePath_STATUS(subject CompositePath_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual CompositePath_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of CompositePath_STATUS instances for property testing - lazily instantiated by
// CompositePath_STATUSGenerator()
var compositePath_STATUSGenerator gopter.Gen

// CompositePath_STATUSGenerator returns a generator of CompositePath_STATUS instances for property testing.
func CompositePath_STATUSGenerator() gopter.Gen {
	if compositePath_STATUSGenerator != nil {
		return compositePath_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForCompositePath_STATUS(generators)
	compositePath_STATUSGenerator = gen.Struct(reflect.TypeOf(CompositePath_STATUS{}), generators)

	return compositePath_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForCompositePath_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCompositePath_STATUS(gens map[string]gopter.Gen) {
	gens["Order"] = gen.PtrOf(gen.AlphaString())
	gens["Path"] = gen.PtrOf(gen.AlphaString())
}

func Test_ComputedProperty_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ComputedProperty via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputedProperty, ComputedPropertyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForComputedProperty runs a test to see if a specific instance of ComputedProperty round trips to JSON and back losslessly
func RunJSONSerializationTestForComputedProperty(subject ComputedProperty) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ComputedProperty
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ComputedProperty instances for property testing - lazily instantiated by ComputedPropertyGenerator()
var computedPropertyGenerator gopter.Gen

// ComputedPropertyGenerator returns a generator of ComputedProperty instances for property testing.
func ComputedPropertyGenerator() gopter.Gen {
	if computedPropertyGenerator != nil {
		return computedPropertyGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForComputedProperty(generators)
	computedPropertyGenerator = gen.Struct(reflect.TypeOf(ComputedProperty{}), generators)

	return computedPropertyGenerator
}

// AddIndependentPropertyGeneratorsForComputedProperty is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputedProperty(gens map[string]gopter.Gen) {
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Query"] = gen.PtrOf(gen.AlphaString())
}

func Test_ComputedProperty_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ComputedProperty_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputedProperty_STATUS, ComputedProperty_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForComputedProperty_STATUS runs a test to see if a specific instance of ComputedProperty_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForComputedProperty_STATUS(subject ComputedProperty_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ComputedProperty_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ComputedProperty_STATUS instances for property testing - lazily instantiated by
// ComputedProperty_STATUSGenerator()
var computedProperty_STATUSGenerator gopter.Gen

// ComputedProperty_STATUSGenerator returns a generator of ComputedProperty_STATUS instances for property testing.
func ComputedProperty_STATUSGenerator() gopter.Gen {
	if computedProperty_STATUSGenerator != nil {
		return computedProperty_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForComputedProperty_STATUS(generators)
	computedProperty_STATUSGenerator = gen.Struct(reflect.TypeOf(ComputedProperty_STATUS{}), generators)

	return computedProperty_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForComputedProperty_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputedProperty_STATUS(gens map[string]gopter.Gen) {
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Query"] = gen.PtrOf(gen.AlphaString())
}

func Test_ConflictResolutionPolicy_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ConflictResolutionPolicy via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForConflictResolutionPolicy, ConflictResolutionPolicyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForConflictResolutionPolicy runs a test to see if a specific instance of ConflictResolutionPolicy round trips to JSON and back losslessly
func RunJSONSerializationTestForConflictResolutionPolicy(subject ConflictResolutionPolicy) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ConflictResolutionPolicy
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ConflictResolutionPolicy instances for property testing - lazily instantiated by
// ConflictResolutionPolicyGenerator()
var conflictResolutionPolicyGenerator gopter.Gen

// ConflictResolutionPolicyGenerator returns a generator of ConflictResolutionPolicy instances for property testing.
func ConflictResolutionPolicyGenerator() gopter.Gen {
	if conflictResolutionPolicyGenerator != nil {
		return conflictResolutionPolicyGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForConflictResolutionPolicy(generators)
	conflictResolutionPolicyGenerator = gen.Struct(reflect.TypeOf(ConflictResolutionPolicy{}), generators)

	return conflictResolutionPolicyGenerator
}

// AddIndependentPropertyGeneratorsForConflictResolutionPolicy is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForConflictResolutionPolicy(gens map[string]gopter.Gen) {
	gens["ConflictResolutionPath"] = gen.PtrOf(gen.AlphaString())
	gens["ConflictResolutionProcedure"] = gen.PtrOf(gen.AlphaString())
	gens["Mode"] = gen.PtrOf(gen.AlphaString())
}

func Test_ConflictResolutionPolicy_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ConflictResolutionPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForConflictResolutionPolicy_STATUS, ConflictResolutionPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForConflictResolutionPolicy_STATUS runs a test to see if a specific instance of ConflictResolutionPolicy_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForConflictResolutionPolicy_STATUS(subject ConflictResolutionPolicy_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ConflictResolutionPolicy_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ConflictResolutionPolicy_STATUS instances for property testing - lazily instantiated by
// ConflictResolutionPolicy_STATUSGenerator()
var conflictResolutionPolicy_STATUSGenerator gopter.Gen

// ConflictResolutionPolicy_STATUSGenerator returns a generator of ConflictResolutionPolicy_STATUS instances for property testing.
func ConflictResolutionPolicy_STATUSGenerator() gopter.Gen {
	if conflictResolutionPolicy_STATUSGenerator != nil {
		return conflictResolutionPolicy_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForConflictResolutionPolicy_STATUS(generators)
	conflictResolutionPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(ConflictResolutionPolicy_STATUS{}), generators)

	return conflictResolutionPolicy_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForConflictResolutionPolicy_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForConflictResolutionPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["ConflictResolutionPath"] = gen.PtrOf(gen.AlphaString())
	gens["ConflictResolutionProcedure"] = gen.PtrOf(gen.AlphaString())
	gens["Mode"] = gen.PtrOf(gen.AlphaString())
}

func Test_ContainerPartitionKey_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ContainerPartitionKey via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerPartitionKey, ContainerPartitionKeyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForContainerPartitionKey runs a test to see if a specific instance of ContainerPartitionKey round trips to JSON and back losslessly
func RunJSONSerializationTestForContainerPartitionKey(subject ContainerPartitionKey) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ContainerPartitionKey
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ContainerPartitionKey instances for property testing - lazily instantiated by
// ContainerPartitionKeyGenerator()
var containerPartitionKeyGenerator gopter.Gen

// ContainerPartitionKeyGenerator returns a generator of ContainerPartitionKey instances for property testing.
func ContainerPartitionKeyGenerator() gopter.Gen {
	if containerPartitionKeyGenerator != nil {
		return containerPartitionKeyGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainerPartitionKey(generators)
	containerPartitionKeyGenerator = gen.Struct(reflect.TypeOf(ContainerPartitionKey{}), generators)

	return containerPartitionKeyGenerator
}

// AddIndependentPropertyGeneratorsForContainerPartitionKey is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainerPartitionKey(gens map[string]gopter.Gen) {
	gens["Kind"] = gen.PtrOf(gen.AlphaString())
	gens["Paths"] = gen.SliceOf(gen.AlphaString())
	gens["Version"] = gen.PtrOf(gen.Int())
}

func Test_ContainerPartitionKey_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ContainerPartitionKey_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerPartitionKey_STATUS, ContainerPartitionKey_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForContainerPartitionKey_STATUS runs a test to see if a specific instance of ContainerPartitionKey_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForContainerPartitionKey_STATUS(subject ContainerPartitionKey_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ContainerPartitionKey_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ContainerPartitionKey_STATUS instances for property testing - lazily instantiated by
// ContainerPartitionKey_STATUSGenerator()
var containerPartitionKey_STATUSGenerator gopter.Gen

// ContainerPartitionKey_STATUSGenerator returns a generator of ContainerPartitionKey_STATUS instances for property testing.
func ContainerPartitionKey_STATUSGenerator() gopter.Gen {
	if containerPartitionKey_STATUSGenerator != nil {
		return containerPartitionKey_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainerPartitionKey_STATUS(generators)
	containerPartitionKey_STATUSGenerator = gen.Struct(reflect.TypeOf(ContainerPartitionKey_STATUS{}), generators)

	return containerPartitionKey_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForContainerPartitionKey_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainerPartitionKey_STATUS(gens map[string]gopter.Gen) {
	gens["Kind"] = gen.PtrOf(gen.AlphaString())
	gens["Paths"] = gen.SliceOf(gen.AlphaString())
	gens["SystemKey"] = gen.PtrOf(gen.Bool())
	gens["Version"] = gen.PtrOf(gen.Int())
}

func Test_ExcludedPath_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ExcludedPath via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForExcludedPath, ExcludedPathGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForExcludedPath runs a test to see if a specific instance of ExcludedPath round trips to JSON and back losslessly
func RunJSONSerializationTestForExcludedPath(subject ExcludedPath) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ExcludedPath
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ExcludedPath instances for property testing - lazily instantiated by ExcludedPathGenerator()
var excludedPathGenerator gopter.Gen

// ExcludedPathGenerator returns a generator of ExcludedPath instances for property testing.
func ExcludedPathGenerator() gopter.Gen {
	if excludedPathGenerator != nil {
		return excludedPathGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForExcludedPath(generators)
	excludedPathGenerator = gen.Struct(reflect.TypeOf(ExcludedPath{}), generators)

	return excludedPathGenerator
}

// AddIndependentPropertyGeneratorsForExcludedPath is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForExcludedPath(gens map[string]gopter.Gen) {
	gens["Path"] = gen.PtrOf(gen.AlphaString())
}

func Test_ExcludedPath_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ExcludedPath_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForExcludedPath_STATUS, ExcludedPath_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForExcludedPath_STATUS runs a test to see if a specific instance of ExcludedPath_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForExcludedPath_STATUS(subject ExcludedPath_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual ExcludedPath_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of ExcludedPath_STATUS instances for property testing - lazily instantiated by
// ExcludedPath_STATUSGenerator()
var excludedPath_STATUSGenerator gopter.Gen

// ExcludedPath_STATUSGenerator returns a generator of ExcludedPath_STATUS instances for property testing.
func ExcludedPath_STATUSGenerator() gopter.Gen {
	if excludedPath_STATUSGenerator != nil {
		return excludedPath_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForExcludedPath_STATUS(generators)
	excludedPath_STATUSGenerator = gen.Struct(reflect.TypeOf(ExcludedPath_STATUS{}), generators)

	return excludedPath_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForExcludedPath_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForExcludedPath_STATUS(gens map[string]gopter.Gen) {
	gens["Path"] = gen.PtrOf(gen.AlphaString())
}

func Test_IncludedPath_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of IncludedPath via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIncludedPath, IncludedPathGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForIncludedPath runs a test to see if a specific instance of IncludedPath round trips to JSON and back losslessly
func RunJSONSerializationTestForIncludedPath(subject IncludedPath) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual IncludedPath
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of IncludedPath instances for property testing - lazily instantiated by IncludedPathGenerator()
var includedPathGenerator gopter.Gen

// IncludedPathGenerator returns a generator of IncludedPath instances for property testing.
// We first initialize includedPathGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func IncludedPathGenerator() gopter.Gen {
	if includedPathGenerator != nil {
		return includedPathGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIncludedPath(generators)
	includedPathGenerator = gen.Struct(reflect.TypeOf(IncludedPath{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIncludedPath(generators)
	AddRelatedPropertyGeneratorsForIncludedPath(generators)
	includedPathGenerator = gen.Struct(reflect.TypeOf(IncludedPath{}), generators)

	return includedPathGenerator
}

// AddIndependentPropertyGeneratorsForIncludedPath is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIncludedPath(gens map[string]gopter.Gen) {
	gens["Path"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForIncludedPath is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForIncludedPath(gens map[string]gopter.Gen) {
	gens["Indexes"] = gen.SliceOf(IndexesGenerator())
}

func Test_IncludedPath_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of IncludedPath_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIncludedPath_STATUS, IncludedPath_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForIncludedPath_STATUS runs a test to see if a specific instance of IncludedPath_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForIncludedPath_STATUS(subject IncludedPath_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual IncludedPath_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of IncludedPath_STATUS instances for property testing - lazily instantiated by
// IncludedPath_STATUSGenerator()
var includedPath_STATUSGenerator gopter.Gen

// IncludedPath_STATUSGenerator returns a generator of IncludedPath_STATUS instances for property testing.
// We first initialize includedPath_STATUSGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func IncludedPath_STATUSGenerator() gopter.Gen {
	if includedPath_STATUSGenerator != nil {
		return includedPath_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIncludedPath_STATUS(generators)
	includedPath_STATUSGenerator = gen.Struct(reflect.TypeOf(IncludedPath_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIncludedPath_STATUS(generators)
	AddRelatedPropertyGeneratorsForIncludedPath_STATUS(generators)
	includedPath_STATUSGenerator = gen.Struct(reflect.TypeOf(IncludedPath_STATUS{}), generators)

	return includedPath_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIncludedPath_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIncludedPath_STATUS(gens map[string]gopter.Gen) {
	gens["Path"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForIncludedPath_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForIncludedPath_STATUS(gens map[string]gopter.Gen) {
	gens["Indexes"] = gen.SliceOf(Indexes_STATUSGenerator())
}

func Test_Indexes_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of Indexes via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIndexes, IndexesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForIndexes runs a test to see if a specific instance of Indexes round trips to JSON and back losslessly
func RunJSONSerializationTestForIndexes(subject Indexes) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual Indexes
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of Indexes instances for property testing - lazily instantiated by IndexesGenerator()
var indexesGenerator gopter.Gen

// IndexesGenerator returns a generator of Indexes instances for property testing.
func IndexesGenerator() gopter.Gen {
	if indexesGenerator != nil {
		return indexesGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIndexes(generators)
	indexesGenerator = gen.Struct(reflect.TypeOf(Indexes{}), generators)

	return indexesGenerator
}

// AddIndependentPropertyGeneratorsForIndexes is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIndexes(gens map[string]gopter.Gen) {
	gens["DataType"] = gen.PtrOf(gen.AlphaString())
	gens["Kind"] = gen.PtrOf(gen.AlphaString())
	gens["Precision"] = gen.PtrOf(gen.Int())
}

func Test_Indexes_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of Indexes_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIndexes_STATUS, Indexes_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForIndexes_STATUS runs a test to see if a specific instance of Indexes_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForIndexes_STATUS(subject Indexes_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual Indexes_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of Indexes_STATUS instances for property testing - lazily instantiated by Indexes_STATUSGenerator()
var indexes_STATUSGenerator gopter.Gen

// Indexes_STATUSGenerator returns a generator of Indexes_STATUS instances for property testing.
func Indexes_STATUSGenerator() gopter.Gen {
	if indexes_STATUSGenerator != nil {
		return indexes_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIndexes_STATUS(generators)
	indexes_STATUSGenerator = gen.Struct(reflect.TypeOf(Indexes_STATUS{}), generators)

	return indexes_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIndexes_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIndexes_STATUS(gens map[string]gopter.Gen) {
	gens["DataType"] = gen.PtrOf(gen.AlphaString())
	gens["Kind"] = gen.PtrOf(gen.AlphaString())
	gens["Precision"] = gen.PtrOf(gen.Int())
}

func Test_IndexingPolicy_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of IndexingPolicy via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIndexingPolicy, IndexingPolicyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForIndexingPolicy runs a test to see if a specific instance of IndexingPolicy round trips to JSON and back losslessly
func RunJSONSerializationTestForIndexingPolicy(subject IndexingPolicy) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual IndexingPolicy
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of IndexingPolicy instances for property testing - lazily instantiated by IndexingPolicyGenerator()
var indexingPolicyGenerator gopter.Gen

// IndexingPolicyGenerator returns a generator of IndexingPolicy instances for property testing.
// We first initialize indexingPolicyGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func IndexingPolicyGenerator() gopter.Gen {
	if indexingPolicyGenerator != nil {
		return indexingPolicyGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIndexingPolicy(generators)
	indexingPolicyGenerator = gen.Struct(reflect.TypeOf(IndexingPolicy{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIndexingPolicy(generators)
	AddRelatedPropertyGeneratorsForIndexingPolicy(generators)
	indexingPolicyGenerator = gen.Struct(reflect.TypeOf(IndexingPolicy{}), generators)

	return indexingPolicyGenerator
}

// AddIndependentPropertyGeneratorsForIndexingPolicy is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIndexingPolicy(gens map[string]gopter.Gen) {
	gens["Automatic"] = gen.PtrOf(gen.Bool())
	gens["IndexingMode"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForIndexingPolicy is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForIndexingPolicy(gens map[string]gopter.Gen) {
	gens["CompositeIndexes"] = gen.SliceOf(gen.SliceOf(CompositePathGenerator()))
	gens["ExcludedPaths"] = gen.SliceOf(ExcludedPathGenerator())
	gens["IncludedPaths"] = gen.SliceOf(IncludedPathGenerator())
	gens["SpatialIndexes"] = gen.SliceOf(SpatialSpecGenerator())
}

func Test_IndexingPolicy_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of IndexingPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIndexingPolicy_STATUS, IndexingPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForIndexingPolicy_STATUS runs a test to see if a specific instance of IndexingPolicy_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForIndexingPolicy_STATUS(subject IndexingPolicy_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual IndexingPolicy_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of IndexingPolicy_STATUS instances for property testing - lazily instantiated by
// IndexingPolicy_STATUSGenerator()
var indexingPolicy_STATUSGenerator gopter.Gen

// IndexingPolicy_STATUSGenerator returns a generator of IndexingPolicy_STATUS instances for property testing.
// We first initialize indexingPolicy_STATUSGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func IndexingPolicy_STATUSGenerator() gopter.Gen {
	if indexingPolicy_STATUSGenerator != nil {
		return indexingPolicy_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIndexingPolicy_STATUS(generators)
	indexingPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(IndexingPolicy_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIndexingPolicy_STATUS(generators)
	AddRelatedPropertyGeneratorsForIndexingPolicy_STATUS(generators)
	indexingPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(IndexingPolicy_STATUS{}), generators)

	return indexingPolicy_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIndexingPolicy_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIndexingPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["Automatic"] = gen.PtrOf(gen.Bool())
	gens["IndexingMode"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForIndexingPolicy_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForIndexingPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["CompositeIndexes"] = gen.SliceOf(gen.SliceOf(CompositePath_STATUSGenerator()))
	gens["ExcludedPaths"] = gen.SliceOf(ExcludedPath_STATUSGenerator())
	gens["IncludedPaths"] = gen.SliceOf(IncludedPath_STATUSGenerator())
	gens["SpatialIndexes"] = gen.SliceOf(SpatialSpec_STATUSGenerator())
}

func Test_SpatialSpec_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SpatialSpec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSpatialSpec, SpatialSpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForSpatialSpec runs a test to see if a specific instance of SpatialSpec round trips to JSON and back losslessly
func RunJSONSerializationTestForSpatialSpec(subject SpatialSpec) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual SpatialSpec
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of SpatialSpec instances for property testing - lazily instantiated by SpatialSpecGenerator()
var spatialSpecGenerator gopter.Gen

// SpatialSpecGenerator returns a generator of SpatialSpec instances for property testing.
func SpatialSpecGenerator() gopter.Gen {
	if spatialSpecGenerator != nil {
		return spatialSpecGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSpatialSpec(generators)
	spatialSpecGenerator = gen.Struct(reflect.TypeOf(SpatialSpec{}), generators)

	return spatialSpecGenerator
}

// AddIndependentPropertyGeneratorsForSpatialSpec is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSpatialSpec(gens map[string]gopter.Gen) {
	gens["Path"] = gen.PtrOf(gen.AlphaString())
	gens["Types"] = gen.SliceOf(gen.AlphaString())
}

func Test_SpatialSpec_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SpatialSpec_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSpatialSpec_STATUS, SpatialSpec_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForSpatialSpec_STATUS runs a test to see if a specific instance of SpatialSpec_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForSpatialSpec_STATUS(subject SpatialSpec_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual SpatialSpec_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of SpatialSpec_STATUS instances for property testing - lazily instantiated by SpatialSpec_STATUSGenerator()
var spatialSpec_STATUSGenerator gopter.Gen

// SpatialSpec_STATUSGenerator returns a generator of SpatialSpec_STATUS instances for property testing.
func SpatialSpec_STATUSGenerator() gopter.Gen {
	if spatialSpec_STATUSGenerator != nil {
		return spatialSpec_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSpatialSpec_STATUS(generators)
	spatialSpec_STATUSGenerator = gen.Struct(reflect.TypeOf(SpatialSpec_STATUS{}), generators)

	return spatialSpec_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSpatialSpec_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSpatialSpec_STATUS(gens map[string]gopter.Gen) {
	gens["Path"] = gen.PtrOf(gen.AlphaString())
	gens["Types"] = gen.SliceOf(gen.AlphaString())
}

func Test_SqlContainerGetProperties_Resource_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SqlContainerGetProperties_Resource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSqlContainerGetProperties_Resource_STATUS, SqlContainerGetProperties_Resource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForSqlContainerGetProperties_Resource_STATUS runs a test to see if a specific instance of SqlContainerGetProperties_Resource_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForSqlContainerGetProperties_Resource_STATUS(subject SqlContainerGetProperties_Resource_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual SqlContainerGetProperties_Resource_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of SqlContainerGetProperties_Resource_STATUS instances for property testing - lazily instantiated by
// SqlContainerGetProperties_Resource_STATUSGenerator()
var sqlContainerGetProperties_Resource_STATUSGenerator gopter.Gen

// SqlContainerGetProperties_Resource_STATUSGenerator returns a generator of SqlContainerGetProperties_Resource_STATUS instances for property testing.
// We first initialize sqlContainerGetProperties_Resource_STATUSGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func SqlContainerGetProperties_Resource_STATUSGenerator() gopter.Gen {
	if sqlContainerGetProperties_Resource_STATUSGenerator != nil {
		return sqlContainerGetProperties_Resource_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSqlContainerGetProperties_Resource_STATUS(generators)
	sqlContainerGetProperties_Resource_STATUSGenerator = gen.Struct(reflect.TypeOf(SqlContainerGetProperties_Resource_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSqlContainerGetProperties_Resource_STATUS(generators)
	AddRelatedPropertyGeneratorsForSqlContainerGetProperties_Resource_STATUS(generators)
	sqlContainerGetProperties_Resource_STATUSGenerator = gen.Struct(reflect.TypeOf(SqlContainerGetProperties_Resource_STATUS{}), generators)

	return sqlContainerGetProperties_Resource_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSqlContainerGetProperties_Resource_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSqlContainerGetProperties_Resource_STATUS(gens map[string]gopter.Gen) {
	gens["AnalyticalStorageTtl"] = gen.PtrOf(gen.Int())
	gens["CreateMode"] = gen.PtrOf(gen.AlphaString())
	gens["DefaultTtl"] = gen.PtrOf(gen.Int())
	gens["Etag"] = gen.PtrOf(gen.AlphaString())
	gens["Id"] = gen.PtrOf(gen.AlphaString())
	gens["Rid"] = gen.PtrOf(gen.AlphaString())
	gens["Ts"] = gen.PtrOf(gen.Float64())
}

// AddRelatedPropertyGeneratorsForSqlContainerGetProperties_Resource_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForSqlContainerGetProperties_Resource_STATUS(gens map[string]gopter.Gen) {
	gens["ClientEncryptionPolicy"] = gen.PtrOf(ClientEncryptionPolicy_STATUSGenerator())
	gens["ComputedProperties"] = gen.SliceOf(ComputedProperty_STATUSGenerator())
	gens["ConflictResolutionPolicy"] = gen.PtrOf(ConflictResolutionPolicy_STATUSGenerator())
	gens["IndexingPolicy"] = gen.PtrOf(IndexingPolicy_STATUSGenerator())
	gens["PartitionKey"] = gen.PtrOf(ContainerPartitionKey_STATUSGenerator())
	gens["RestoreParameters"] = gen.PtrOf(RestoreParametersBase_STATUSGenerator())
	gens["UniqueKeyPolicy"] = gen.PtrOf(UniqueKeyPolicy_STATUSGenerator())
}

func Test_SqlContainerResource_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SqlContainerResource via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSqlContainerResource, SqlContainerResourceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForSqlContainerResource runs a test to see if a specific instance of SqlContainerResource round trips to JSON and back losslessly
func RunJSONSerializationTestForSqlContainerResource(subject SqlContainerResource) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual SqlContainerResource
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of SqlContainerResource instances for property testing - lazily instantiated by
// SqlContainerResourceGenerator()
var sqlContainerResourceGenerator gopter.Gen

// SqlContainerResourceGenerator returns a generator of SqlContainerResource instances for property testing.
// We first initialize sqlContainerResourceGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func SqlContainerResourceGenerator() gopter.Gen {
	if sqlContainerResourceGenerator != nil {
		return sqlContainerResourceGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSqlContainerResource(generators)
	sqlContainerResourceGenerator = gen.Struct(reflect.TypeOf(SqlContainerResource{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSqlContainerResource(generators)
	AddRelatedPropertyGeneratorsForSqlContainerResource(generators)
	sqlContainerResourceGenerator = gen.Struct(reflect.TypeOf(SqlContainerResource{}), generators)

	return sqlContainerResourceGenerator
}

// AddIndependentPropertyGeneratorsForSqlContainerResource is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSqlContainerResource(gens map[string]gopter.Gen) {
	gens["AnalyticalStorageTtl"] = gen.PtrOf(gen.Int())
	gens["CreateMode"] = gen.PtrOf(gen.AlphaString())
	gens["DefaultTtl"] = gen.PtrOf(gen.Int())
	gens["Id"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForSqlContainerResource is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForSqlContainerResource(gens map[string]gopter.Gen) {
	gens["ClientEncryptionPolicy"] = gen.PtrOf(ClientEncryptionPolicyGenerator())
	gens["ComputedProperties"] = gen.SliceOf(ComputedPropertyGenerator())
	gens["ConflictResolutionPolicy"] = gen.PtrOf(ConflictResolutionPolicyGenerator())
	gens["IndexingPolicy"] = gen.PtrOf(IndexingPolicyGenerator())
	gens["PartitionKey"] = gen.PtrOf(ContainerPartitionKeyGenerator())
	gens["RestoreParameters"] = gen.PtrOf(RestoreParametersBaseGenerator())
	gens["UniqueKeyPolicy"] = gen.PtrOf(UniqueKeyPolicyGenerator())
}

func Test_SqlDatabaseContainer_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 20
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SqlDatabaseContainer via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSqlDatabaseContainer, SqlDatabaseContainerGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForSqlDatabaseContainer runs a test to see if a specific instance of SqlDatabaseContainer round trips to JSON and back losslessly
func RunJSONSerializationTestForSqlDatabaseContainer(subject SqlDatabaseContainer) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual SqlDatabaseContainer
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of SqlDatabaseContainer instances for property testing - lazily instantiated by
// SqlDatabaseContainerGenerator()
var sqlDatabaseContainerGenerator gopter.Gen

// SqlDatabaseContainerGenerator returns a generator of SqlDatabaseContainer instances for property testing.
func SqlDatabaseContainerGenerator() gopter.Gen {
	if sqlDatabaseContainerGenerator != nil {
		return sqlDatabaseContainerGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForSqlDatabaseContainer(generators)
	sqlDatabaseContainerGenerator = gen.Struct(reflect.TypeOf(SqlDatabaseContainer{}), generators)

	return sqlDatabaseContainerGenerator
}

// AddRelatedPropertyGeneratorsForSqlDatabaseContainer is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForSqlDatabaseContainer(gens map[string]gopter.Gen) {
	gens["Spec"] = SqlDatabaseContainer_SpecGenerator()
	gens["Status"] = SqlDatabaseContainer_STATUSGenerator()
}

func Test_SqlDatabaseContainerOperatorSpec_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SqlDatabaseContainerOperatorSpec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSqlDatabaseContainerOperatorSpec, SqlDatabaseContainerOperatorSpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForSqlDatabaseContainerOperatorSpec runs a test to see if a specific instance of SqlDatabaseContainerOperatorSpec round trips to JSON and back losslessly
func RunJSONSerializationTestForSqlDatabaseContainerOperatorSpec(subject SqlDatabaseContainerOperatorSpec) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual SqlDatabaseContainerOperatorSpec
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of SqlDatabaseContainerOperatorSpec instances for property testing - lazily instantiated by
// SqlDatabaseContainerOperatorSpecGenerator()
var sqlDatabaseContainerOperatorSpecGenerator gopter.Gen

// SqlDatabaseContainerOperatorSpecGenerator returns a generator of SqlDatabaseContainerOperatorSpec instances for property testing.
func SqlDatabaseContainerOperatorSpecGenerator() gopter.Gen {
	if sqlDatabaseContainerOperatorSpecGenerator != nil {
		return sqlDatabaseContainerOperatorSpecGenerator
	}

	generators := make(map[string]gopter.Gen)
	sqlDatabaseContainerOperatorSpecGenerator = gen.Struct(reflect.TypeOf(SqlDatabaseContainerOperatorSpec{}), generators)

	return sqlDatabaseContainerOperatorSpecGenerator
}

func Test_SqlDatabaseContainer_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SqlDatabaseContainer_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSqlDatabaseContainer_STATUS, SqlDatabaseContainer_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForSqlDatabaseContainer_STATUS runs a test to see if a specific instance of SqlDatabaseContainer_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForSqlDatabaseContainer_STATUS(subject SqlDatabaseContainer_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual SqlDatabaseContainer_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of SqlDatabaseContainer_STATUS instances for property testing - lazily instantiated by
// SqlDatabaseContainer_STATUSGenerator()
var sqlDatabaseContainer_STATUSGenerator gopter.Gen

// SqlDatabaseContainer_STATUSGenerator returns a generator of SqlDatabaseContainer_STATUS instances for property testing.
// We first initialize sqlDatabaseContainer_STATUSGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func SqlDatabaseContainer_STATUSGenerator() gopter.Gen {
	if sqlDatabaseContainer_STATUSGenerator != nil {
		return sqlDatabaseContainer_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSqlDatabaseContainer_STATUS(generators)
	sqlDatabaseContainer_STATUSGenerator = gen.Struct(reflect.TypeOf(SqlDatabaseContainer_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSqlDatabaseContainer_STATUS(generators)
	AddRelatedPropertyGeneratorsForSqlDatabaseContainer_STATUS(generators)
	sqlDatabaseContainer_STATUSGenerator = gen.Struct(reflect.TypeOf(SqlDatabaseContainer_STATUS{}), generators)

	return sqlDatabaseContainer_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSqlDatabaseContainer_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSqlDatabaseContainer_STATUS(gens map[string]gopter.Gen) {
	gens["Id"] = gen.PtrOf(gen.AlphaString())
	gens["Location"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Tags"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["Type"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForSqlDatabaseContainer_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForSqlDatabaseContainer_STATUS(gens map[string]gopter.Gen) {
	gens["Options"] = gen.PtrOf(OptionsResource_STATUSGenerator())
	gens["Resource"] = gen.PtrOf(SqlContainerGetProperties_Resource_STATUSGenerator())
}

func Test_SqlDatabaseContainer_Spec_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SqlDatabaseContainer_Spec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSqlDatabaseContainer_Spec, SqlDatabaseContainer_SpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForSqlDatabaseContainer_Spec runs a test to see if a specific instance of SqlDatabaseContainer_Spec round trips to JSON and back losslessly
func RunJSONSerializationTestForSqlDatabaseContainer_Spec(subject SqlDatabaseContainer_Spec) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual SqlDatabaseContainer_Spec
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of SqlDatabaseContainer_Spec instances for property testing - lazily instantiated by
// SqlDatabaseContainer_SpecGenerator()
var sqlDatabaseContainer_SpecGenerator gopter.Gen

// SqlDatabaseContainer_SpecGenerator returns a generator of SqlDatabaseContainer_Spec instances for property testing.
// We first initialize sqlDatabaseContainer_SpecGenerator with a simplified generator based on the
// fields with primitive types then replacing it with a more complex one that also handles complex fields
// to ensure any cycles in the object graph properly terminate.
func SqlDatabaseContainer_SpecGenerator() gopter.Gen {
	if sqlDatabaseContainer_SpecGenerator != nil {
		return sqlDatabaseContainer_SpecGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSqlDatabaseContainer_Spec(generators)
	sqlDatabaseContainer_SpecGenerator = gen.Struct(reflect.TypeOf(SqlDatabaseContainer_Spec{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSqlDatabaseContainer_Spec(generators)
	AddRelatedPropertyGeneratorsForSqlDatabaseContainer_Spec(generators)
	sqlDatabaseContainer_SpecGenerator = gen.Struct(reflect.TypeOf(SqlDatabaseContainer_Spec{}), generators)

	return sqlDatabaseContainer_SpecGenerator
}

// AddIndependentPropertyGeneratorsForSqlDatabaseContainer_Spec is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSqlDatabaseContainer_Spec(gens map[string]gopter.Gen) {
	gens["AzureName"] = gen.AlphaString()
	gens["Location"] = gen.PtrOf(gen.AlphaString())
	gens["OriginalVersion"] = gen.AlphaString()
	gens["Tags"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForSqlDatabaseContainer_Spec is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForSqlDatabaseContainer_Spec(gens map[string]gopter.Gen) {
	gens["OperatorSpec"] = gen.PtrOf(SqlDatabaseContainerOperatorSpecGenerator())
	gens["Options"] = gen.PtrOf(CreateUpdateOptionsGenerator())
	gens["Resource"] = gen.PtrOf(SqlContainerResourceGenerator())
}

func Test_UniqueKey_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of UniqueKey via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUniqueKey, UniqueKeyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForUniqueKey runs a test to see if a specific instance of UniqueKey round trips to JSON and back losslessly
func RunJSONSerializationTestForUniqueKey(subject UniqueKey) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual UniqueKey
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of UniqueKey instances for property testing - lazily instantiated by UniqueKeyGenerator()
var uniqueKeyGenerator gopter.Gen

// UniqueKeyGenerator returns a generator of UniqueKey instances for property testing.
func UniqueKeyGenerator() gopter.Gen {
	if uniqueKeyGenerator != nil {
		return uniqueKeyGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForUniqueKey(generators)
	uniqueKeyGenerator = gen.Struct(reflect.TypeOf(UniqueKey{}), generators)

	return uniqueKeyGenerator
}

// AddIndependentPropertyGeneratorsForUniqueKey is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForUniqueKey(gens map[string]gopter.Gen) {
	gens["Paths"] = gen.SliceOf(gen.AlphaString())
}

func Test_UniqueKeyPolicy_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of UniqueKeyPolicy via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUniqueKeyPolicy, UniqueKeyPolicyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForUniqueKeyPolicy runs a test to see if a specific instance of UniqueKeyPolicy round trips to JSON and back losslessly
func RunJSONSerializationTestForUniqueKeyPolicy(subject UniqueKeyPolicy) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual UniqueKeyPolicy
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of UniqueKeyPolicy instances for property testing - lazily instantiated by UniqueKeyPolicyGenerator()
var uniqueKeyPolicyGenerator gopter.Gen

// UniqueKeyPolicyGenerator returns a generator of UniqueKeyPolicy instances for property testing.
func UniqueKeyPolicyGenerator() gopter.Gen {
	if uniqueKeyPolicyGenerator != nil {
		return uniqueKeyPolicyGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForUniqueKeyPolicy(generators)
	uniqueKeyPolicyGenerator = gen.Struct(reflect.TypeOf(UniqueKeyPolicy{}), generators)

	return uniqueKeyPolicyGenerator
}

// AddRelatedPropertyGeneratorsForUniqueKeyPolicy is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForUniqueKeyPolicy(gens map[string]gopter.Gen) {
	gens["UniqueKeys"] = gen.SliceOf(UniqueKeyGenerator())
}

func Test_UniqueKeyPolicy_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of UniqueKeyPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUniqueKeyPolicy_STATUS, UniqueKeyPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForUniqueKeyPolicy_STATUS runs a test to see if a specific instance of UniqueKeyPolicy_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForUniqueKeyPolicy_STATUS(subject UniqueKeyPolicy_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual UniqueKeyPolicy_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of UniqueKeyPolicy_STATUS instances for property testing - lazily instantiated by
// UniqueKeyPolicy_STATUSGenerator()
var uniqueKeyPolicy_STATUSGenerator gopter.Gen

// UniqueKeyPolicy_STATUSGenerator returns a generator of UniqueKeyPolicy_STATUS instances for property testing.
func UniqueKeyPolicy_STATUSGenerator() gopter.Gen {
	if uniqueKeyPolicy_STATUSGenerator != nil {
		return uniqueKeyPolicy_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForUniqueKeyPolicy_STATUS(generators)
	uniqueKeyPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(UniqueKeyPolicy_STATUS{}), generators)

	return uniqueKeyPolicy_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForUniqueKeyPolicy_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForUniqueKeyPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["UniqueKeys"] = gen.SliceOf(UniqueKey_STATUSGenerator())
}

func Test_UniqueKey_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of UniqueKey_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUniqueKey_STATUS, UniqueKey_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

// RunJSONSerializationTestForUniqueKey_STATUS runs a test to see if a specific instance of UniqueKey_STATUS round trips to JSON and back losslessly
func RunJSONSerializationTestForUniqueKey_STATUS(subject UniqueKey_STATUS) string {
	// Serialize to JSON
	bin, err := json.Marshal(subject)
	if err != nil {
		return err.Error()
	}

	// Deserialize back into memory
	var actual UniqueKey_STATUS
	err = json.Unmarshal(bin, &actual)
	if err != nil {
		return err.Error()
	}

	// Check for outcome
	match := cmp.Equal(subject, actual, cmpopts.EquateEmpty())
	if !match {
		actualFmt := pretty.Sprint(actual)
		subjectFmt := pretty.Sprint(subject)
		result := diff.Diff(subjectFmt, actualFmt)
		return result
	}

	return ""
}

// Generator of UniqueKey_STATUS instances for property testing - lazily instantiated by UniqueKey_STATUSGenerator()
var uniqueKey_STATUSGenerator gopter.Gen

// UniqueKey_STATUSGenerator returns a generator of UniqueKey_STATUS instances for property testing.
func UniqueKey_STATUSGenerator() gopter.Gen {
	if uniqueKey_STATUSGenerator != nil {
		return uniqueKey_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForUniqueKey_STATUS(generators)
	uniqueKey_STATUSGenerator = gen.Struct(reflect.TypeOf(UniqueKey_STATUS{}), generators)

	return uniqueKey_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForUniqueKey_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForUniqueKey_STATUS(gens map[string]gopter.Gen) {
	gens["Paths"] = gen.SliceOf(gen.AlphaString())
}
