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

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_AbsoluteDeleteOption_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 AbsoluteDeleteOption_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAbsoluteDeleteOption_STATUS, AbsoluteDeleteOption_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AbsoluteDeleteOption_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 AbsoluteDeleteOption_STATUS instances for property testing - lazily instantiated by
// AbsoluteDeleteOption_STATUSGenerator()
var absoluteDeleteOption_STATUSGenerator gopter.Gen

// AbsoluteDeleteOption_STATUSGenerator returns a generator of AbsoluteDeleteOption_STATUS instances for property testing.
func AbsoluteDeleteOption_STATUSGenerator() gopter.Gen {
	if absoluteDeleteOption_STATUSGenerator != nil {
		return absoluteDeleteOption_STATUSGenerator
	}

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

	return absoluteDeleteOption_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAbsoluteDeleteOption_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAbsoluteDeleteOption_STATUS(gens map[string]gopter.Gen) {
	gens["Duration"] = gen.PtrOf(gen.AlphaString())
	gens["ObjectType"] = gen.OneConstOf(AbsoluteDeleteOption_ObjectType_STATUS_AbsoluteDeleteOption)
}

func Test_AdhocBasedTaggingCriteria_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 AdhocBasedTaggingCriteria_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAdhocBasedTaggingCriteria_STATUS, AdhocBasedTaggingCriteria_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AdhocBasedTaggingCriteria_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 AdhocBasedTaggingCriteria_STATUS instances for property testing - lazily instantiated by
// AdhocBasedTaggingCriteria_STATUSGenerator()
var adhocBasedTaggingCriteria_STATUSGenerator gopter.Gen

// AdhocBasedTaggingCriteria_STATUSGenerator returns a generator of AdhocBasedTaggingCriteria_STATUS instances for property testing.
func AdhocBasedTaggingCriteria_STATUSGenerator() gopter.Gen {
	if adhocBasedTaggingCriteria_STATUSGenerator != nil {
		return adhocBasedTaggingCriteria_STATUSGenerator
	}

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

	return adhocBasedTaggingCriteria_STATUSGenerator
}

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

func Test_AdhocBasedTriggerContext_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 AdhocBasedTriggerContext_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAdhocBasedTriggerContext_STATUS, AdhocBasedTriggerContext_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AdhocBasedTriggerContext_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 AdhocBasedTriggerContext_STATUS instances for property testing - lazily instantiated by
// AdhocBasedTriggerContext_STATUSGenerator()
var adhocBasedTriggerContext_STATUSGenerator gopter.Gen

// AdhocBasedTriggerContext_STATUSGenerator returns a generator of AdhocBasedTriggerContext_STATUS instances for property testing.
// We first initialize adhocBasedTriggerContext_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 AdhocBasedTriggerContext_STATUSGenerator() gopter.Gen {
	if adhocBasedTriggerContext_STATUSGenerator != nil {
		return adhocBasedTriggerContext_STATUSGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAdhocBasedTriggerContext_STATUS(generators)
	AddRelatedPropertyGeneratorsForAdhocBasedTriggerContext_STATUS(generators)
	adhocBasedTriggerContext_STATUSGenerator = gen.Struct(reflect.TypeOf(AdhocBasedTriggerContext_STATUS{}), generators)

	return adhocBasedTriggerContext_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAdhocBasedTriggerContext_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAdhocBasedTriggerContext_STATUS(gens map[string]gopter.Gen) {
	gens["ObjectType"] = gen.OneConstOf(AdhocBasedTriggerContext_ObjectType_STATUS_AdhocBasedTriggerContext)
}

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

func Test_AzureBackupParams_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 AzureBackupParams_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAzureBackupParams_STATUS, AzureBackupParams_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AzureBackupParams_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 AzureBackupParams_STATUS instances for property testing - lazily instantiated by
// AzureBackupParams_STATUSGenerator()
var azureBackupParams_STATUSGenerator gopter.Gen

// AzureBackupParams_STATUSGenerator returns a generator of AzureBackupParams_STATUS instances for property testing.
func AzureBackupParams_STATUSGenerator() gopter.Gen {
	if azureBackupParams_STATUSGenerator != nil {
		return azureBackupParams_STATUSGenerator
	}

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

	return azureBackupParams_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAzureBackupParams_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAzureBackupParams_STATUS(gens map[string]gopter.Gen) {
	gens["BackupType"] = gen.PtrOf(gen.AlphaString())
	gens["ObjectType"] = gen.OneConstOf(AzureBackupParams_ObjectType_STATUS_AzureBackupParams)
}

func Test_AzureBackupRule_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 AzureBackupRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAzureBackupRule_STATUS, AzureBackupRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AzureBackupRule_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 AzureBackupRule_STATUS instances for property testing - lazily instantiated by
// AzureBackupRule_STATUSGenerator()
var azureBackupRule_STATUSGenerator gopter.Gen

// AzureBackupRule_STATUSGenerator returns a generator of AzureBackupRule_STATUS instances for property testing.
// We first initialize azureBackupRule_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 AzureBackupRule_STATUSGenerator() gopter.Gen {
	if azureBackupRule_STATUSGenerator != nil {
		return azureBackupRule_STATUSGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAzureBackupRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForAzureBackupRule_STATUS(generators)
	azureBackupRule_STATUSGenerator = gen.Struct(reflect.TypeOf(AzureBackupRule_STATUS{}), generators)

	return azureBackupRule_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForAzureBackupRule_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAzureBackupRule_STATUS(gens map[string]gopter.Gen) {
	gens["BackupParameters"] = gen.PtrOf(BackupParameters_STATUSGenerator())
	gens["DataStore"] = gen.PtrOf(DataStoreInfoBase_STATUSGenerator())
	gens["Trigger"] = gen.PtrOf(TriggerContext_STATUSGenerator())
}

func Test_AzureRetentionRule_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 AzureRetentionRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAzureRetentionRule_STATUS, AzureRetentionRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AzureRetentionRule_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 AzureRetentionRule_STATUS instances for property testing - lazily instantiated by
// AzureRetentionRule_STATUSGenerator()
var azureRetentionRule_STATUSGenerator gopter.Gen

// AzureRetentionRule_STATUSGenerator returns a generator of AzureRetentionRule_STATUS instances for property testing.
// We first initialize azureRetentionRule_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 AzureRetentionRule_STATUSGenerator() gopter.Gen {
	if azureRetentionRule_STATUSGenerator != nil {
		return azureRetentionRule_STATUSGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAzureRetentionRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForAzureRetentionRule_STATUS(generators)
	azureRetentionRule_STATUSGenerator = gen.Struct(reflect.TypeOf(AzureRetentionRule_STATUS{}), generators)

	return azureRetentionRule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAzureRetentionRule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAzureRetentionRule_STATUS(gens map[string]gopter.Gen) {
	gens["IsDefault"] = gen.PtrOf(gen.Bool())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["ObjectType"] = gen.OneConstOf(AzureRetentionRule_ObjectType_STATUS_AzureRetentionRule)
}

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

func Test_BackupCriteria_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 BackupCriteria_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBackupCriteria_STATUS, BackupCriteria_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BackupCriteria_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 BackupCriteria_STATUS instances for property testing - lazily instantiated by
// BackupCriteria_STATUSGenerator()
var backupCriteria_STATUSGenerator gopter.Gen

// BackupCriteria_STATUSGenerator returns a generator of BackupCriteria_STATUS instances for property testing.
func BackupCriteria_STATUSGenerator() gopter.Gen {
	if backupCriteria_STATUSGenerator != nil {
		return backupCriteria_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForBackupCriteria_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(BackupCriteria_STATUS{}), props))
	}
	backupCriteria_STATUSGenerator = gen.OneGenOf(gens...)

	return backupCriteria_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForBackupCriteria_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForBackupCriteria_STATUS(gens map[string]gopter.Gen) {
	gens["ScheduleBasedBackupCriteria"] = ScheduleBasedBackupCriteria_STATUSGenerator().Map(func(it ScheduleBasedBackupCriteria_STATUS) *ScheduleBasedBackupCriteria_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_BackupParameters_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 BackupParameters_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBackupParameters_STATUS, BackupParameters_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BackupParameters_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 BackupParameters_STATUS instances for property testing - lazily instantiated by
// BackupParameters_STATUSGenerator()
var backupParameters_STATUSGenerator gopter.Gen

// BackupParameters_STATUSGenerator returns a generator of BackupParameters_STATUS instances for property testing.
func BackupParameters_STATUSGenerator() gopter.Gen {
	if backupParameters_STATUSGenerator != nil {
		return backupParameters_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForBackupParameters_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(BackupParameters_STATUS{}), props))
	}
	backupParameters_STATUSGenerator = gen.OneGenOf(gens...)

	return backupParameters_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForBackupParameters_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForBackupParameters_STATUS(gens map[string]gopter.Gen) {
	gens["AzureBackupParams"] = AzureBackupParams_STATUSGenerator().Map(func(it AzureBackupParams_STATUS) *AzureBackupParams_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_BackupPolicy_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 BackupPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBackupPolicy_STATUS, BackupPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BackupPolicy_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 BackupPolicy_STATUS instances for property testing - lazily instantiated by
// BackupPolicy_STATUSGenerator()
var backupPolicy_STATUSGenerator gopter.Gen

// BackupPolicy_STATUSGenerator returns a generator of BackupPolicy_STATUS instances for property testing.
// We first initialize backupPolicy_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 BackupPolicy_STATUSGenerator() gopter.Gen {
	if backupPolicy_STATUSGenerator != nil {
		return backupPolicy_STATUSGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForBackupPolicy_STATUS(generators)
	AddRelatedPropertyGeneratorsForBackupPolicy_STATUS(generators)
	backupPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(BackupPolicy_STATUS{}), generators)

	return backupPolicy_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForBackupPolicy_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForBackupPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["DatasourceTypes"] = gen.SliceOf(gen.AlphaString())
	gens["ObjectType"] = gen.OneConstOf(BackupPolicy_ObjectType_STATUS_BackupPolicy)
}

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

func Test_BackupSchedule_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 BackupSchedule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBackupSchedule_STATUS, BackupSchedule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BackupSchedule_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 BackupSchedule_STATUS instances for property testing - lazily instantiated by
// BackupSchedule_STATUSGenerator()
var backupSchedule_STATUSGenerator gopter.Gen

// BackupSchedule_STATUSGenerator returns a generator of BackupSchedule_STATUS instances for property testing.
func BackupSchedule_STATUSGenerator() gopter.Gen {
	if backupSchedule_STATUSGenerator != nil {
		return backupSchedule_STATUSGenerator
	}

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

	return backupSchedule_STATUSGenerator
}

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

func Test_BackupVaultsBackupPolicy_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 BackupVaultsBackupPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBackupVaultsBackupPolicy_STATUS, BackupVaultsBackupPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BackupVaultsBackupPolicy_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 BackupVaultsBackupPolicy_STATUS instances for property testing - lazily instantiated by
// BackupVaultsBackupPolicy_STATUSGenerator()
var backupVaultsBackupPolicy_STATUSGenerator gopter.Gen

// BackupVaultsBackupPolicy_STATUSGenerator returns a generator of BackupVaultsBackupPolicy_STATUS instances for property testing.
// We first initialize backupVaultsBackupPolicy_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 BackupVaultsBackupPolicy_STATUSGenerator() gopter.Gen {
	if backupVaultsBackupPolicy_STATUSGenerator != nil {
		return backupVaultsBackupPolicy_STATUSGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForBackupVaultsBackupPolicy_STATUS(generators)
	AddRelatedPropertyGeneratorsForBackupVaultsBackupPolicy_STATUS(generators)
	backupVaultsBackupPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(BackupVaultsBackupPolicy_STATUS{}), generators)

	return backupVaultsBackupPolicy_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForBackupVaultsBackupPolicy_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForBackupVaultsBackupPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(BaseBackupPolicy_STATUSGenerator())
	gens["SystemData"] = gen.PtrOf(SystemData_STATUSGenerator())
}

func Test_BaseBackupPolicy_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 BaseBackupPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBaseBackupPolicy_STATUS, BaseBackupPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BaseBackupPolicy_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 BaseBackupPolicy_STATUS instances for property testing - lazily instantiated by
// BaseBackupPolicy_STATUSGenerator()
var baseBackupPolicy_STATUSGenerator gopter.Gen

// BaseBackupPolicy_STATUSGenerator returns a generator of BaseBackupPolicy_STATUS instances for property testing.
func BaseBackupPolicy_STATUSGenerator() gopter.Gen {
	if baseBackupPolicy_STATUSGenerator != nil {
		return baseBackupPolicy_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForBaseBackupPolicy_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(BaseBackupPolicy_STATUS{}), props))
	}
	baseBackupPolicy_STATUSGenerator = gen.OneGenOf(gens...)

	return baseBackupPolicy_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForBaseBackupPolicy_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForBaseBackupPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["BackupPolicy"] = BackupPolicy_STATUSGenerator().Map(func(it BackupPolicy_STATUS) *BackupPolicy_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_BasePolicyRule_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 BasePolicyRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBasePolicyRule_STATUS, BasePolicyRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BasePolicyRule_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 BasePolicyRule_STATUS instances for property testing - lazily instantiated by
// BasePolicyRule_STATUSGenerator()
var basePolicyRule_STATUSGenerator gopter.Gen

// BasePolicyRule_STATUSGenerator returns a generator of BasePolicyRule_STATUS instances for property testing.
func BasePolicyRule_STATUSGenerator() gopter.Gen {
	if basePolicyRule_STATUSGenerator != nil {
		return basePolicyRule_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForBasePolicyRule_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(BasePolicyRule_STATUS{}), props))
	}
	basePolicyRule_STATUSGenerator = gen.OneGenOf(gens...)

	return basePolicyRule_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForBasePolicyRule_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForBasePolicyRule_STATUS(gens map[string]gopter.Gen) {
	gens["AzureBackup"] = AzureBackupRule_STATUSGenerator().Map(func(it AzureBackupRule_STATUS) *AzureBackupRule_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["AzureRetention"] = AzureRetentionRule_STATUSGenerator().Map(func(it AzureRetentionRule_STATUS) *AzureRetentionRule_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_CopyOnExpiryOption_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 CopyOnExpiryOption_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCopyOnExpiryOption_STATUS, CopyOnExpiryOption_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CopyOnExpiryOption_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 CopyOnExpiryOption_STATUS instances for property testing - lazily instantiated by
// CopyOnExpiryOption_STATUSGenerator()
var copyOnExpiryOption_STATUSGenerator gopter.Gen

// CopyOnExpiryOption_STATUSGenerator returns a generator of CopyOnExpiryOption_STATUS instances for property testing.
func CopyOnExpiryOption_STATUSGenerator() gopter.Gen {
	if copyOnExpiryOption_STATUSGenerator != nil {
		return copyOnExpiryOption_STATUSGenerator
	}

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

	return copyOnExpiryOption_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForCopyOnExpiryOption_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCopyOnExpiryOption_STATUS(gens map[string]gopter.Gen) {
	gens["ObjectType"] = gen.OneConstOf(CopyOnExpiryOption_ObjectType_STATUS_CopyOnExpiryOption)
}

func Test_CopyOption_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 CopyOption_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCopyOption_STATUS, CopyOption_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CopyOption_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 CopyOption_STATUS instances for property testing - lazily instantiated by CopyOption_STATUSGenerator()
var copyOption_STATUSGenerator gopter.Gen

// CopyOption_STATUSGenerator returns a generator of CopyOption_STATUS instances for property testing.
func CopyOption_STATUSGenerator() gopter.Gen {
	if copyOption_STATUSGenerator != nil {
		return copyOption_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForCopyOption_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(CopyOption_STATUS{}), props))
	}
	copyOption_STATUSGenerator = gen.OneGenOf(gens...)

	return copyOption_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForCopyOption_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForCopyOption_STATUS(gens map[string]gopter.Gen) {
	gens["CopyOnExpiry"] = CopyOnExpiryOption_STATUSGenerator().Map(func(it CopyOnExpiryOption_STATUS) *CopyOnExpiryOption_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["CustomCopy"] = CustomCopyOption_STATUSGenerator().Map(func(it CustomCopyOption_STATUS) *CustomCopyOption_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["ImmediateCopy"] = ImmediateCopyOption_STATUSGenerator().Map(func(it ImmediateCopyOption_STATUS) *ImmediateCopyOption_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_CustomCopyOption_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 CustomCopyOption_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCustomCopyOption_STATUS, CustomCopyOption_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CustomCopyOption_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 CustomCopyOption_STATUS instances for property testing - lazily instantiated by
// CustomCopyOption_STATUSGenerator()
var customCopyOption_STATUSGenerator gopter.Gen

// CustomCopyOption_STATUSGenerator returns a generator of CustomCopyOption_STATUS instances for property testing.
func CustomCopyOption_STATUSGenerator() gopter.Gen {
	if customCopyOption_STATUSGenerator != nil {
		return customCopyOption_STATUSGenerator
	}

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

	return customCopyOption_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForCustomCopyOption_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCustomCopyOption_STATUS(gens map[string]gopter.Gen) {
	gens["Duration"] = gen.PtrOf(gen.AlphaString())
	gens["ObjectType"] = gen.OneConstOf(CustomCopyOption_ObjectType_STATUS_CustomCopyOption)
}

func Test_DataStoreInfoBase_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 DataStoreInfoBase_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataStoreInfoBase_STATUS, DataStoreInfoBase_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DataStoreInfoBase_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 DataStoreInfoBase_STATUS instances for property testing - lazily instantiated by
// DataStoreInfoBase_STATUSGenerator()
var dataStoreInfoBase_STATUSGenerator gopter.Gen

// DataStoreInfoBase_STATUSGenerator returns a generator of DataStoreInfoBase_STATUS instances for property testing.
func DataStoreInfoBase_STATUSGenerator() gopter.Gen {
	if dataStoreInfoBase_STATUSGenerator != nil {
		return dataStoreInfoBase_STATUSGenerator
	}

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

	return dataStoreInfoBase_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForDataStoreInfoBase_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDataStoreInfoBase_STATUS(gens map[string]gopter.Gen) {
	gens["DataStoreType"] = gen.PtrOf(gen.OneConstOf(DataStoreInfoBase_DataStoreType_STATUS_ArchiveStore, DataStoreInfoBase_DataStoreType_STATUS_OperationalStore, DataStoreInfoBase_DataStoreType_STATUS_VaultStore))
	gens["ObjectType"] = gen.PtrOf(gen.AlphaString())
}

func Test_Day_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 Day_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDay_STATUS, Day_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Day_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 Day_STATUS instances for property testing - lazily instantiated by Day_STATUSGenerator()
var day_STATUSGenerator gopter.Gen

// Day_STATUSGenerator returns a generator of Day_STATUS instances for property testing.
func Day_STATUSGenerator() gopter.Gen {
	if day_STATUSGenerator != nil {
		return day_STATUSGenerator
	}

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

	return day_STATUSGenerator
}

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

func Test_DeleteOption_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 DeleteOption_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDeleteOption_STATUS, DeleteOption_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DeleteOption_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 DeleteOption_STATUS instances for property testing - lazily instantiated by
// DeleteOption_STATUSGenerator()
var deleteOption_STATUSGenerator gopter.Gen

// DeleteOption_STATUSGenerator returns a generator of DeleteOption_STATUS instances for property testing.
func DeleteOption_STATUSGenerator() gopter.Gen {
	if deleteOption_STATUSGenerator != nil {
		return deleteOption_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForDeleteOption_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(DeleteOption_STATUS{}), props))
	}
	deleteOption_STATUSGenerator = gen.OneGenOf(gens...)

	return deleteOption_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForDeleteOption_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDeleteOption_STATUS(gens map[string]gopter.Gen) {
	gens["AbsoluteDeleteOption"] = AbsoluteDeleteOption_STATUSGenerator().Map(func(it AbsoluteDeleteOption_STATUS) *AbsoluteDeleteOption_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_ImmediateCopyOption_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 ImmediateCopyOption_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForImmediateCopyOption_STATUS, ImmediateCopyOption_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ImmediateCopyOption_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 ImmediateCopyOption_STATUS instances for property testing - lazily instantiated by
// ImmediateCopyOption_STATUSGenerator()
var immediateCopyOption_STATUSGenerator gopter.Gen

// ImmediateCopyOption_STATUSGenerator returns a generator of ImmediateCopyOption_STATUS instances for property testing.
func ImmediateCopyOption_STATUSGenerator() gopter.Gen {
	if immediateCopyOption_STATUSGenerator != nil {
		return immediateCopyOption_STATUSGenerator
	}

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

	return immediateCopyOption_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForImmediateCopyOption_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForImmediateCopyOption_STATUS(gens map[string]gopter.Gen) {
	gens["ObjectType"] = gen.OneConstOf(ImmediateCopyOption_ObjectType_STATUS_ImmediateCopyOption)
}

func Test_RetentionTag_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 RetentionTag_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRetentionTag_STATUS, RetentionTag_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual RetentionTag_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 RetentionTag_STATUS instances for property testing - lazily instantiated by
// RetentionTag_STATUSGenerator()
var retentionTag_STATUSGenerator gopter.Gen

// RetentionTag_STATUSGenerator returns a generator of RetentionTag_STATUS instances for property testing.
func RetentionTag_STATUSGenerator() gopter.Gen {
	if retentionTag_STATUSGenerator != nil {
		return retentionTag_STATUSGenerator
	}

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

	return retentionTag_STATUSGenerator
}

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

func Test_ScheduleBasedBackupCriteria_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 ScheduleBasedBackupCriteria_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScheduleBasedBackupCriteria_STATUS, ScheduleBasedBackupCriteria_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ScheduleBasedBackupCriteria_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 ScheduleBasedBackupCriteria_STATUS instances for property testing - lazily instantiated by
// ScheduleBasedBackupCriteria_STATUSGenerator()
var scheduleBasedBackupCriteria_STATUSGenerator gopter.Gen

// ScheduleBasedBackupCriteria_STATUSGenerator returns a generator of ScheduleBasedBackupCriteria_STATUS instances for property testing.
// We first initialize scheduleBasedBackupCriteria_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 ScheduleBasedBackupCriteria_STATUSGenerator() gopter.Gen {
	if scheduleBasedBackupCriteria_STATUSGenerator != nil {
		return scheduleBasedBackupCriteria_STATUSGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForScheduleBasedBackupCriteria_STATUS(generators)
	AddRelatedPropertyGeneratorsForScheduleBasedBackupCriteria_STATUS(generators)
	scheduleBasedBackupCriteria_STATUSGenerator = gen.Struct(reflect.TypeOf(ScheduleBasedBackupCriteria_STATUS{}), generators)

	return scheduleBasedBackupCriteria_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForScheduleBasedBackupCriteria_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForScheduleBasedBackupCriteria_STATUS(gens map[string]gopter.Gen) {
	gens["AbsoluteCriteria"] = gen.SliceOf(gen.OneConstOf(
		ScheduleBasedBackupCriteria_AbsoluteCriteria_STATUS_AllBackup,
		ScheduleBasedBackupCriteria_AbsoluteCriteria_STATUS_FirstOfDay,
		ScheduleBasedBackupCriteria_AbsoluteCriteria_STATUS_FirstOfMonth,
		ScheduleBasedBackupCriteria_AbsoluteCriteria_STATUS_FirstOfWeek,
		ScheduleBasedBackupCriteria_AbsoluteCriteria_STATUS_FirstOfYear))
	gens["DaysOfTheWeek"] = gen.SliceOf(gen.OneConstOf(
		ScheduleBasedBackupCriteria_DaysOfTheWeek_STATUS_Friday,
		ScheduleBasedBackupCriteria_DaysOfTheWeek_STATUS_Monday,
		ScheduleBasedBackupCriteria_DaysOfTheWeek_STATUS_Saturday,
		ScheduleBasedBackupCriteria_DaysOfTheWeek_STATUS_Sunday,
		ScheduleBasedBackupCriteria_DaysOfTheWeek_STATUS_Thursday,
		ScheduleBasedBackupCriteria_DaysOfTheWeek_STATUS_Tuesday,
		ScheduleBasedBackupCriteria_DaysOfTheWeek_STATUS_Wednesday))
	gens["MonthsOfYear"] = gen.SliceOf(gen.OneConstOf(
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_April,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_August,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_December,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_February,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_January,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_July,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_June,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_March,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_May,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_November,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_October,
		ScheduleBasedBackupCriteria_MonthsOfYear_STATUS_September))
	gens["ObjectType"] = gen.OneConstOf(ScheduleBasedBackupCriteria_ObjectType_STATUS_ScheduleBasedBackupCriteria)
	gens["ScheduleTimes"] = gen.SliceOf(gen.AlphaString())
	gens["WeeksOfTheMonth"] = gen.SliceOf(gen.OneConstOf(
		ScheduleBasedBackupCriteria_WeeksOfTheMonth_STATUS_First,
		ScheduleBasedBackupCriteria_WeeksOfTheMonth_STATUS_Fourth,
		ScheduleBasedBackupCriteria_WeeksOfTheMonth_STATUS_Last,
		ScheduleBasedBackupCriteria_WeeksOfTheMonth_STATUS_Second,
		ScheduleBasedBackupCriteria_WeeksOfTheMonth_STATUS_Third))
}

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

func Test_ScheduleBasedTriggerContext_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 ScheduleBasedTriggerContext_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScheduleBasedTriggerContext_STATUS, ScheduleBasedTriggerContext_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ScheduleBasedTriggerContext_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 ScheduleBasedTriggerContext_STATUS instances for property testing - lazily instantiated by
// ScheduleBasedTriggerContext_STATUSGenerator()
var scheduleBasedTriggerContext_STATUSGenerator gopter.Gen

// ScheduleBasedTriggerContext_STATUSGenerator returns a generator of ScheduleBasedTriggerContext_STATUS instances for property testing.
// We first initialize scheduleBasedTriggerContext_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 ScheduleBasedTriggerContext_STATUSGenerator() gopter.Gen {
	if scheduleBasedTriggerContext_STATUSGenerator != nil {
		return scheduleBasedTriggerContext_STATUSGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForScheduleBasedTriggerContext_STATUS(generators)
	AddRelatedPropertyGeneratorsForScheduleBasedTriggerContext_STATUS(generators)
	scheduleBasedTriggerContext_STATUSGenerator = gen.Struct(reflect.TypeOf(ScheduleBasedTriggerContext_STATUS{}), generators)

	return scheduleBasedTriggerContext_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForScheduleBasedTriggerContext_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForScheduleBasedTriggerContext_STATUS(gens map[string]gopter.Gen) {
	gens["ObjectType"] = gen.OneConstOf(ScheduleBasedTriggerContext_ObjectType_STATUS_ScheduleBasedTriggerContext)
}

// AddRelatedPropertyGeneratorsForScheduleBasedTriggerContext_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForScheduleBasedTriggerContext_STATUS(gens map[string]gopter.Gen) {
	gens["Schedule"] = gen.PtrOf(BackupSchedule_STATUSGenerator())
	gens["TaggingCriteria"] = gen.SliceOf(TaggingCriteria_STATUSGenerator())
}

func Test_SourceLifeCycle_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 SourceLifeCycle_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSourceLifeCycle_STATUS, SourceLifeCycle_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SourceLifeCycle_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 SourceLifeCycle_STATUS instances for property testing - lazily instantiated by
// SourceLifeCycle_STATUSGenerator()
var sourceLifeCycle_STATUSGenerator gopter.Gen

// SourceLifeCycle_STATUSGenerator returns a generator of SourceLifeCycle_STATUS instances for property testing.
func SourceLifeCycle_STATUSGenerator() gopter.Gen {
	if sourceLifeCycle_STATUSGenerator != nil {
		return sourceLifeCycle_STATUSGenerator
	}

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

	return sourceLifeCycle_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForSourceLifeCycle_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForSourceLifeCycle_STATUS(gens map[string]gopter.Gen) {
	gens["DeleteAfter"] = gen.PtrOf(DeleteOption_STATUSGenerator())
	gens["SourceDataStore"] = gen.PtrOf(DataStoreInfoBase_STATUSGenerator())
	gens["TargetDataStoreCopySettings"] = gen.SliceOf(TargetCopySetting_STATUSGenerator())
}

func Test_TaggingCriteria_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 TaggingCriteria_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTaggingCriteria_STATUS, TaggingCriteria_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual TaggingCriteria_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 TaggingCriteria_STATUS instances for property testing - lazily instantiated by
// TaggingCriteria_STATUSGenerator()
var taggingCriteria_STATUSGenerator gopter.Gen

// TaggingCriteria_STATUSGenerator returns a generator of TaggingCriteria_STATUS instances for property testing.
// We first initialize taggingCriteria_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 TaggingCriteria_STATUSGenerator() gopter.Gen {
	if taggingCriteria_STATUSGenerator != nil {
		return taggingCriteria_STATUSGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForTaggingCriteria_STATUS(generators)
	AddRelatedPropertyGeneratorsForTaggingCriteria_STATUS(generators)
	taggingCriteria_STATUSGenerator = gen.Struct(reflect.TypeOf(TaggingCriteria_STATUS{}), generators)

	return taggingCriteria_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForTaggingCriteria_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForTaggingCriteria_STATUS(gens map[string]gopter.Gen) {
	gens["Criteria"] = gen.SliceOf(BackupCriteria_STATUSGenerator())
	gens["TagInfo"] = gen.PtrOf(RetentionTag_STATUSGenerator())
}

func Test_TargetCopySetting_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 TargetCopySetting_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTargetCopySetting_STATUS, TargetCopySetting_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual TargetCopySetting_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 TargetCopySetting_STATUS instances for property testing - lazily instantiated by
// TargetCopySetting_STATUSGenerator()
var targetCopySetting_STATUSGenerator gopter.Gen

// TargetCopySetting_STATUSGenerator returns a generator of TargetCopySetting_STATUS instances for property testing.
func TargetCopySetting_STATUSGenerator() gopter.Gen {
	if targetCopySetting_STATUSGenerator != nil {
		return targetCopySetting_STATUSGenerator
	}

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

	return targetCopySetting_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForTargetCopySetting_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForTargetCopySetting_STATUS(gens map[string]gopter.Gen) {
	gens["CopyAfter"] = gen.PtrOf(CopyOption_STATUSGenerator())
	gens["DataStore"] = gen.PtrOf(DataStoreInfoBase_STATUSGenerator())
}

func Test_TriggerContext_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 TriggerContext_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTriggerContext_STATUS, TriggerContext_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual TriggerContext_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 TriggerContext_STATUS instances for property testing - lazily instantiated by
// TriggerContext_STATUSGenerator()
var triggerContext_STATUSGenerator gopter.Gen

// TriggerContext_STATUSGenerator returns a generator of TriggerContext_STATUS instances for property testing.
func TriggerContext_STATUSGenerator() gopter.Gen {
	if triggerContext_STATUSGenerator != nil {
		return triggerContext_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForTriggerContext_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(TriggerContext_STATUS{}), props))
	}
	triggerContext_STATUSGenerator = gen.OneGenOf(gens...)

	return triggerContext_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForTriggerContext_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForTriggerContext_STATUS(gens map[string]gopter.Gen) {
	gens["Adhoc"] = AdhocBasedTriggerContext_STATUSGenerator().Map(func(it AdhocBasedTriggerContext_STATUS) *AdhocBasedTriggerContext_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["Schedule"] = ScheduleBasedTriggerContext_STATUSGenerator().Map(func(it ScheduleBasedTriggerContext_STATUS) *ScheduleBasedTriggerContext_STATUS {
		return &it
	}) // generate one case for OneOf type
}
