// 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_AbusePenalty_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 AbusePenalty_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAbusePenalty_STATUS, AbusePenalty_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AbusePenalty_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 AbusePenalty_STATUS instances for property testing - lazily instantiated by
// AbusePenalty_STATUSGenerator()
var abusePenalty_STATUSGenerator gopter.Gen

// AbusePenalty_STATUSGenerator returns a generator of AbusePenalty_STATUS instances for property testing.
func AbusePenalty_STATUSGenerator() gopter.Gen {
	if abusePenalty_STATUSGenerator != nil {
		return abusePenalty_STATUSGenerator
	}

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

	return abusePenalty_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAbusePenalty_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAbusePenalty_STATUS(gens map[string]gopter.Gen) {
	gens["Action"] = gen.PtrOf(gen.OneConstOf(AbusePenalty_Action_STATUS_Block, AbusePenalty_Action_STATUS_Throttle))
	gens["Expiration"] = gen.PtrOf(gen.AlphaString())
	gens["RateLimitPercentage"] = gen.PtrOf(gen.Float64())
}

func Test_AccountProperties_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 AccountProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAccountProperties_STATUS, AccountProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AccountProperties_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 AccountProperties_STATUS instances for property testing - lazily instantiated by
// AccountProperties_STATUSGenerator()
var accountProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAccountProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForAccountProperties_STATUS(generators)
	accountProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(AccountProperties_STATUS{}), generators)

	return accountProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAccountProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAccountProperties_STATUS(gens map[string]gopter.Gen) {
	gens["AllowProjectManagement"] = gen.PtrOf(gen.Bool())
	gens["AllowedFqdnList"] = gen.SliceOf(gen.AlphaString())
	gens["AssociatedProjects"] = gen.SliceOf(gen.AlphaString())
	gens["CustomSubDomainName"] = gen.PtrOf(gen.AlphaString())
	gens["DateCreated"] = gen.PtrOf(gen.AlphaString())
	gens["DefaultProject"] = gen.PtrOf(gen.AlphaString())
	gens["DeletionDate"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["DynamicThrottlingEnabled"] = gen.PtrOf(gen.Bool())
	gens["Endpoint"] = gen.PtrOf(gen.AlphaString())
	gens["Endpoints"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["InternalId"] = gen.PtrOf(gen.AlphaString())
	gens["IsMigrated"] = gen.PtrOf(gen.Bool())
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		AccountProperties_ProvisioningState_STATUS_Accepted,
		AccountProperties_ProvisioningState_STATUS_Creating,
		AccountProperties_ProvisioningState_STATUS_Deleting,
		AccountProperties_ProvisioningState_STATUS_Failed,
		AccountProperties_ProvisioningState_STATUS_Moving,
		AccountProperties_ProvisioningState_STATUS_ResolvingDNS,
		AccountProperties_ProvisioningState_STATUS_Succeeded))
	gens["PublicNetworkAccess"] = gen.PtrOf(gen.OneConstOf(AccountProperties_PublicNetworkAccess_STATUS_Disabled, AccountProperties_PublicNetworkAccess_STATUS_Enabled))
	gens["Restore"] = gen.PtrOf(gen.Bool())
	gens["RestrictOutboundNetworkAccess"] = gen.PtrOf(gen.Bool())
	gens["ScheduledPurgeDate"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForAccountProperties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAccountProperties_STATUS(gens map[string]gopter.Gen) {
	gens["AbusePenalty"] = gen.PtrOf(AbusePenalty_STATUSGenerator())
	gens["AmlWorkspace"] = gen.PtrOf(UserOwnedAmlWorkspace_STATUSGenerator())
	gens["ApiProperties"] = gen.PtrOf(ApiProperties_STATUSGenerator())
	gens["CallRateLimit"] = gen.PtrOf(CallRateLimit_STATUSGenerator())
	gens["Capabilities"] = gen.SliceOf(SkuCapability_STATUSGenerator())
	gens["CommitmentPlanAssociations"] = gen.SliceOf(CommitmentPlanAssociation_STATUSGenerator())
	gens["Encryption"] = gen.PtrOf(Encryption_STATUSGenerator())
	gens["Locations"] = gen.PtrOf(MultiRegionSettings_STATUSGenerator())
	gens["NetworkAcls"] = gen.PtrOf(NetworkRuleSet_STATUSGenerator())
	gens["NetworkInjections"] = gen.SliceOf(NetworkInjection_STATUSGenerator())
	gens["PrivateEndpointConnections"] = gen.SliceOf(PrivateEndpointConnection_STATUSGenerator())
	gens["QuotaLimit"] = gen.PtrOf(QuotaLimit_STATUSGenerator())
	gens["RaiMonitorConfig"] = gen.PtrOf(RaiMonitorConfig_STATUSGenerator())
	gens["SkuChangeInfo"] = gen.PtrOf(SkuChangeInfo_STATUSGenerator())
	gens["UserOwnedStorage"] = gen.SliceOf(UserOwnedStorage_STATUSGenerator())
}

func Test_Account_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 Account_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAccount_STATUS, Account_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Account_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 Account_STATUS instances for property testing - lazily instantiated by Account_STATUSGenerator()
var account_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAccount_STATUS(generators)
	AddRelatedPropertyGeneratorsForAccount_STATUS(generators)
	account_STATUSGenerator = gen.Struct(reflect.TypeOf(Account_STATUS{}), generators)

	return account_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAccount_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAccount_STATUS(gens map[string]gopter.Gen) {
	gens["Etag"] = gen.PtrOf(gen.AlphaString())
	gens["Id"] = gen.PtrOf(gen.AlphaString())
	gens["Kind"] = 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())
}

// AddRelatedPropertyGeneratorsForAccount_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAccount_STATUS(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(Identity_STATUSGenerator())
	gens["Properties"] = gen.PtrOf(AccountProperties_STATUSGenerator())
	gens["Sku"] = gen.PtrOf(Sku_STATUSGenerator())
	gens["SystemData"] = gen.PtrOf(SystemData_STATUSGenerator())
}

func Test_ApiProperties_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 ApiProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApiProperties_STATUS, ApiProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApiProperties_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 ApiProperties_STATUS instances for property testing - lazily instantiated by
// ApiProperties_STATUSGenerator()
var apiProperties_STATUSGenerator gopter.Gen

// ApiProperties_STATUSGenerator returns a generator of ApiProperties_STATUS instances for property testing.
func ApiProperties_STATUSGenerator() gopter.Gen {
	if apiProperties_STATUSGenerator != nil {
		return apiProperties_STATUSGenerator
	}

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

	return apiProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForApiProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApiProperties_STATUS(gens map[string]gopter.Gen) {
	gens["AadClientId"] = gen.PtrOf(gen.AlphaString())
	gens["AadTenantId"] = gen.PtrOf(gen.AlphaString())
	gens["QnaAzureSearchEndpointId"] = gen.PtrOf(gen.AlphaString())
	gens["QnaRuntimeEndpoint"] = gen.PtrOf(gen.AlphaString())
	gens["StatisticsEnabled"] = gen.PtrOf(gen.Bool())
	gens["SuperUser"] = gen.PtrOf(gen.AlphaString())
	gens["WebsiteName"] = gen.PtrOf(gen.AlphaString())
}

func Test_CallRateLimit_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 CallRateLimit_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCallRateLimit_STATUS, CallRateLimit_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CallRateLimit_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 CallRateLimit_STATUS instances for property testing - lazily instantiated by
// CallRateLimit_STATUSGenerator()
var callRateLimit_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForCallRateLimit_STATUS(generators)
	AddRelatedPropertyGeneratorsForCallRateLimit_STATUS(generators)
	callRateLimit_STATUSGenerator = gen.Struct(reflect.TypeOf(CallRateLimit_STATUS{}), generators)

	return callRateLimit_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForCallRateLimit_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCallRateLimit_STATUS(gens map[string]gopter.Gen) {
	gens["Count"] = gen.PtrOf(gen.Float64())
	gens["RenewalPeriod"] = gen.PtrOf(gen.Float64())
}

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

func Test_CommitmentPlanAssociation_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 CommitmentPlanAssociation_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCommitmentPlanAssociation_STATUS, CommitmentPlanAssociation_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CommitmentPlanAssociation_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 CommitmentPlanAssociation_STATUS instances for property testing - lazily instantiated by
// CommitmentPlanAssociation_STATUSGenerator()
var commitmentPlanAssociation_STATUSGenerator gopter.Gen

// CommitmentPlanAssociation_STATUSGenerator returns a generator of CommitmentPlanAssociation_STATUS instances for property testing.
func CommitmentPlanAssociation_STATUSGenerator() gopter.Gen {
	if commitmentPlanAssociation_STATUSGenerator != nil {
		return commitmentPlanAssociation_STATUSGenerator
	}

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

	return commitmentPlanAssociation_STATUSGenerator
}

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

func Test_Encryption_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 Encryption_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEncryption_STATUS, Encryption_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Encryption_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 Encryption_STATUS instances for property testing - lazily instantiated by Encryption_STATUSGenerator()
var encryption_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEncryption_STATUS(generators)
	AddRelatedPropertyGeneratorsForEncryption_STATUS(generators)
	encryption_STATUSGenerator = gen.Struct(reflect.TypeOf(Encryption_STATUS{}), generators)

	return encryption_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForEncryption_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForEncryption_STATUS(gens map[string]gopter.Gen) {
	gens["KeySource"] = gen.PtrOf(gen.OneConstOf(Encryption_KeySource_STATUS_MicrosoftCognitiveServices, Encryption_KeySource_STATUS_MicrosoftKeyVault))
}

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

func Test_Identity_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 Identity_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIdentity_STATUS, Identity_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Identity_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 Identity_STATUS instances for property testing - lazily instantiated by Identity_STATUSGenerator()
var identity_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIdentity_STATUS(generators)
	AddRelatedPropertyGeneratorsForIdentity_STATUS(generators)
	identity_STATUSGenerator = gen.Struct(reflect.TypeOf(Identity_STATUS{}), generators)

	return identity_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIdentity_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIdentity_STATUS(gens map[string]gopter.Gen) {
	gens["PrincipalId"] = gen.PtrOf(gen.AlphaString())
	gens["TenantId"] = gen.PtrOf(gen.AlphaString())
	gens["Type"] = gen.PtrOf(gen.OneConstOf(
		Identity_Type_STATUS_None,
		Identity_Type_STATUS_SystemAssigned,
		Identity_Type_STATUS_SystemAssignedUserAssigned,
		Identity_Type_STATUS_UserAssigned))
}

// AddRelatedPropertyGeneratorsForIdentity_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForIdentity_STATUS(gens map[string]gopter.Gen) {
	gens["UserAssignedIdentities"] = gen.MapOf(
		gen.AlphaString(),
		UserAssignedIdentity_STATUSGenerator())
}

func Test_IpRule_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 IpRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIpRule_STATUS, IpRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual IpRule_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 IpRule_STATUS instances for property testing - lazily instantiated by IpRule_STATUSGenerator()
var ipRule_STATUSGenerator gopter.Gen

// IpRule_STATUSGenerator returns a generator of IpRule_STATUS instances for property testing.
func IpRule_STATUSGenerator() gopter.Gen {
	if ipRule_STATUSGenerator != nil {
		return ipRule_STATUSGenerator
	}

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

	return ipRule_STATUSGenerator
}

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

func Test_KeyVaultProperties_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 KeyVaultProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForKeyVaultProperties_STATUS, KeyVaultProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual KeyVaultProperties_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 KeyVaultProperties_STATUS instances for property testing - lazily instantiated by
// KeyVaultProperties_STATUSGenerator()
var keyVaultProperties_STATUSGenerator gopter.Gen

// KeyVaultProperties_STATUSGenerator returns a generator of KeyVaultProperties_STATUS instances for property testing.
func KeyVaultProperties_STATUSGenerator() gopter.Gen {
	if keyVaultProperties_STATUSGenerator != nil {
		return keyVaultProperties_STATUSGenerator
	}

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

	return keyVaultProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForKeyVaultProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForKeyVaultProperties_STATUS(gens map[string]gopter.Gen) {
	gens["IdentityClientId"] = gen.PtrOf(gen.AlphaString())
	gens["KeyName"] = gen.PtrOf(gen.AlphaString())
	gens["KeyVaultUri"] = gen.PtrOf(gen.AlphaString())
	gens["KeyVersion"] = gen.PtrOf(gen.AlphaString())
}

func Test_MultiRegionSettings_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 MultiRegionSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForMultiRegionSettings_STATUS, MultiRegionSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual MultiRegionSettings_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 MultiRegionSettings_STATUS instances for property testing - lazily instantiated by
// MultiRegionSettings_STATUSGenerator()
var multiRegionSettings_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForMultiRegionSettings_STATUS(generators)
	AddRelatedPropertyGeneratorsForMultiRegionSettings_STATUS(generators)
	multiRegionSettings_STATUSGenerator = gen.Struct(reflect.TypeOf(MultiRegionSettings_STATUS{}), generators)

	return multiRegionSettings_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForMultiRegionSettings_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForMultiRegionSettings_STATUS(gens map[string]gopter.Gen) {
	gens["RoutingMethod"] = gen.PtrOf(gen.OneConstOf(MultiRegionSettings_RoutingMethod_STATUS_Performance, MultiRegionSettings_RoutingMethod_STATUS_Priority, MultiRegionSettings_RoutingMethod_STATUS_Weighted))
}

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

func Test_NetworkInjection_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 NetworkInjection_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNetworkInjection_STATUS, NetworkInjection_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NetworkInjection_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 NetworkInjection_STATUS instances for property testing - lazily instantiated by
// NetworkInjection_STATUSGenerator()
var networkInjection_STATUSGenerator gopter.Gen

// NetworkInjection_STATUSGenerator returns a generator of NetworkInjection_STATUS instances for property testing.
func NetworkInjection_STATUSGenerator() gopter.Gen {
	if networkInjection_STATUSGenerator != nil {
		return networkInjection_STATUSGenerator
	}

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

	return networkInjection_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNetworkInjection_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNetworkInjection_STATUS(gens map[string]gopter.Gen) {
	gens["Scenario"] = gen.PtrOf(gen.OneConstOf(NetworkInjection_Scenario_STATUS_Agent, NetworkInjection_Scenario_STATUS_None))
	gens["SubnetArmId"] = gen.PtrOf(gen.AlphaString())
	gens["UseMicrosoftManagedNetwork"] = gen.PtrOf(gen.Bool())
}

func Test_NetworkRuleSet_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 NetworkRuleSet_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNetworkRuleSet_STATUS, NetworkRuleSet_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NetworkRuleSet_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 NetworkRuleSet_STATUS instances for property testing - lazily instantiated by
// NetworkRuleSet_STATUSGenerator()
var networkRuleSet_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNetworkRuleSet_STATUS(generators)
	AddRelatedPropertyGeneratorsForNetworkRuleSet_STATUS(generators)
	networkRuleSet_STATUSGenerator = gen.Struct(reflect.TypeOf(NetworkRuleSet_STATUS{}), generators)

	return networkRuleSet_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNetworkRuleSet_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNetworkRuleSet_STATUS(gens map[string]gopter.Gen) {
	gens["Bypass"] = gen.PtrOf(gen.OneConstOf(NetworkRuleSet_Bypass_STATUS_AzureServices, NetworkRuleSet_Bypass_STATUS_None))
	gens["DefaultAction"] = gen.PtrOf(gen.OneConstOf(NetworkRuleSet_DefaultAction_STATUS_Allow, NetworkRuleSet_DefaultAction_STATUS_Deny))
}

// AddRelatedPropertyGeneratorsForNetworkRuleSet_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForNetworkRuleSet_STATUS(gens map[string]gopter.Gen) {
	gens["IpRules"] = gen.SliceOf(IpRule_STATUSGenerator())
	gens["VirtualNetworkRules"] = gen.SliceOf(VirtualNetworkRule_STATUSGenerator())
}

func Test_PrivateEndpointConnection_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 PrivateEndpointConnection_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrivateEndpointConnection_STATUS, PrivateEndpointConnection_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PrivateEndpointConnection_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 PrivateEndpointConnection_STATUS instances for property testing - lazily instantiated by
// PrivateEndpointConnection_STATUSGenerator()
var privateEndpointConnection_STATUSGenerator gopter.Gen

// PrivateEndpointConnection_STATUSGenerator returns a generator of PrivateEndpointConnection_STATUS instances for property testing.
func PrivateEndpointConnection_STATUSGenerator() gopter.Gen {
	if privateEndpointConnection_STATUSGenerator != nil {
		return privateEndpointConnection_STATUSGenerator
	}

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

	return privateEndpointConnection_STATUSGenerator
}

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

func Test_QuotaLimit_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 QuotaLimit_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForQuotaLimit_STATUS, QuotaLimit_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual QuotaLimit_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 QuotaLimit_STATUS instances for property testing - lazily instantiated by QuotaLimit_STATUSGenerator()
var quotaLimit_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForQuotaLimit_STATUS(generators)
	AddRelatedPropertyGeneratorsForQuotaLimit_STATUS(generators)
	quotaLimit_STATUSGenerator = gen.Struct(reflect.TypeOf(QuotaLimit_STATUS{}), generators)

	return quotaLimit_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForQuotaLimit_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForQuotaLimit_STATUS(gens map[string]gopter.Gen) {
	gens["Count"] = gen.PtrOf(gen.Float64())
	gens["RenewalPeriod"] = gen.PtrOf(gen.Float64())
}

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

func Test_RaiMonitorConfig_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 RaiMonitorConfig_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRaiMonitorConfig_STATUS, RaiMonitorConfig_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual RaiMonitorConfig_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 RaiMonitorConfig_STATUS instances for property testing - lazily instantiated by
// RaiMonitorConfig_STATUSGenerator()
var raiMonitorConfig_STATUSGenerator gopter.Gen

// RaiMonitorConfig_STATUSGenerator returns a generator of RaiMonitorConfig_STATUS instances for property testing.
func RaiMonitorConfig_STATUSGenerator() gopter.Gen {
	if raiMonitorConfig_STATUSGenerator != nil {
		return raiMonitorConfig_STATUSGenerator
	}

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

	return raiMonitorConfig_STATUSGenerator
}

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

func Test_RegionSetting_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 RegionSetting_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRegionSetting_STATUS, RegionSetting_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual RegionSetting_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 RegionSetting_STATUS instances for property testing - lazily instantiated by
// RegionSetting_STATUSGenerator()
var regionSetting_STATUSGenerator gopter.Gen

// RegionSetting_STATUSGenerator returns a generator of RegionSetting_STATUS instances for property testing.
func RegionSetting_STATUSGenerator() gopter.Gen {
	if regionSetting_STATUSGenerator != nil {
		return regionSetting_STATUSGenerator
	}

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

	return regionSetting_STATUSGenerator
}

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

func Test_SkuCapability_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 SkuCapability_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSkuCapability_STATUS, SkuCapability_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SkuCapability_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 SkuCapability_STATUS instances for property testing - lazily instantiated by
// SkuCapability_STATUSGenerator()
var skuCapability_STATUSGenerator gopter.Gen

// SkuCapability_STATUSGenerator returns a generator of SkuCapability_STATUS instances for property testing.
func SkuCapability_STATUSGenerator() gopter.Gen {
	if skuCapability_STATUSGenerator != nil {
		return skuCapability_STATUSGenerator
	}

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

	return skuCapability_STATUSGenerator
}

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

func Test_SkuChangeInfo_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 SkuChangeInfo_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSkuChangeInfo_STATUS, SkuChangeInfo_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SkuChangeInfo_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 SkuChangeInfo_STATUS instances for property testing - lazily instantiated by
// SkuChangeInfo_STATUSGenerator()
var skuChangeInfo_STATUSGenerator gopter.Gen

// SkuChangeInfo_STATUSGenerator returns a generator of SkuChangeInfo_STATUS instances for property testing.
func SkuChangeInfo_STATUSGenerator() gopter.Gen {
	if skuChangeInfo_STATUSGenerator != nil {
		return skuChangeInfo_STATUSGenerator
	}

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

	return skuChangeInfo_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSkuChangeInfo_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSkuChangeInfo_STATUS(gens map[string]gopter.Gen) {
	gens["CountOfDowngrades"] = gen.PtrOf(gen.Float64())
	gens["CountOfUpgradesAfterDowngrades"] = gen.PtrOf(gen.Float64())
	gens["LastChangeDate"] = gen.PtrOf(gen.AlphaString())
}

func Test_Sku_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 Sku_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSku_STATUS, Sku_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Sku_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 Sku_STATUS instances for property testing - lazily instantiated by Sku_STATUSGenerator()
var sku_STATUSGenerator gopter.Gen

// Sku_STATUSGenerator returns a generator of Sku_STATUS instances for property testing.
func Sku_STATUSGenerator() gopter.Gen {
	if sku_STATUSGenerator != nil {
		return sku_STATUSGenerator
	}

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

	return sku_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSku_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSku_STATUS(gens map[string]gopter.Gen) {
	gens["Capacity"] = gen.PtrOf(gen.Int())
	gens["Family"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Size"] = gen.PtrOf(gen.AlphaString())
	gens["Tier"] = gen.PtrOf(gen.OneConstOf(
		Sku_Tier_STATUS_Basic,
		Sku_Tier_STATUS_Enterprise,
		Sku_Tier_STATUS_Free,
		Sku_Tier_STATUS_Premium,
		Sku_Tier_STATUS_Standard))
}

func Test_SystemData_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 SystemData_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSystemData_STATUS, SystemData_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SystemData_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 SystemData_STATUS instances for property testing - lazily instantiated by SystemData_STATUSGenerator()
var systemData_STATUSGenerator gopter.Gen

// SystemData_STATUSGenerator returns a generator of SystemData_STATUS instances for property testing.
func SystemData_STATUSGenerator() gopter.Gen {
	if systemData_STATUSGenerator != nil {
		return systemData_STATUSGenerator
	}

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

	return systemData_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSystemData_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSystemData_STATUS(gens map[string]gopter.Gen) {
	gens["CreatedAt"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedBy"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedByType"] = gen.PtrOf(gen.OneConstOf(
		SystemData_CreatedByType_STATUS_Application,
		SystemData_CreatedByType_STATUS_Key,
		SystemData_CreatedByType_STATUS_ManagedIdentity,
		SystemData_CreatedByType_STATUS_User))
	gens["LastModifiedAt"] = gen.PtrOf(gen.AlphaString())
	gens["LastModifiedBy"] = gen.PtrOf(gen.AlphaString())
	gens["LastModifiedByType"] = gen.PtrOf(gen.OneConstOf(
		SystemData_LastModifiedByType_STATUS_Application,
		SystemData_LastModifiedByType_STATUS_Key,
		SystemData_LastModifiedByType_STATUS_ManagedIdentity,
		SystemData_LastModifiedByType_STATUS_User))
}

func Test_UserAssignedIdentity_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 UserAssignedIdentity_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUserAssignedIdentity_STATUS, UserAssignedIdentity_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual UserAssignedIdentity_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 UserAssignedIdentity_STATUS instances for property testing - lazily instantiated by
// UserAssignedIdentity_STATUSGenerator()
var userAssignedIdentity_STATUSGenerator gopter.Gen

// UserAssignedIdentity_STATUSGenerator returns a generator of UserAssignedIdentity_STATUS instances for property testing.
func UserAssignedIdentity_STATUSGenerator() gopter.Gen {
	if userAssignedIdentity_STATUSGenerator != nil {
		return userAssignedIdentity_STATUSGenerator
	}

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

	return userAssignedIdentity_STATUSGenerator
}

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

func Test_UserOwnedAmlWorkspace_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 UserOwnedAmlWorkspace_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUserOwnedAmlWorkspace_STATUS, UserOwnedAmlWorkspace_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual UserOwnedAmlWorkspace_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 UserOwnedAmlWorkspace_STATUS instances for property testing - lazily instantiated by
// UserOwnedAmlWorkspace_STATUSGenerator()
var userOwnedAmlWorkspace_STATUSGenerator gopter.Gen

// UserOwnedAmlWorkspace_STATUSGenerator returns a generator of UserOwnedAmlWorkspace_STATUS instances for property testing.
func UserOwnedAmlWorkspace_STATUSGenerator() gopter.Gen {
	if userOwnedAmlWorkspace_STATUSGenerator != nil {
		return userOwnedAmlWorkspace_STATUSGenerator
	}

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

	return userOwnedAmlWorkspace_STATUSGenerator
}

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

func Test_UserOwnedStorage_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 UserOwnedStorage_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUserOwnedStorage_STATUS, UserOwnedStorage_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual UserOwnedStorage_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 UserOwnedStorage_STATUS instances for property testing - lazily instantiated by
// UserOwnedStorage_STATUSGenerator()
var userOwnedStorage_STATUSGenerator gopter.Gen

// UserOwnedStorage_STATUSGenerator returns a generator of UserOwnedStorage_STATUS instances for property testing.
func UserOwnedStorage_STATUSGenerator() gopter.Gen {
	if userOwnedStorage_STATUSGenerator != nil {
		return userOwnedStorage_STATUSGenerator
	}

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

	return userOwnedStorage_STATUSGenerator
}

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

func Test_VirtualNetworkRule_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 VirtualNetworkRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVirtualNetworkRule_STATUS, VirtualNetworkRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual VirtualNetworkRule_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 VirtualNetworkRule_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkRule_STATUSGenerator()
var virtualNetworkRule_STATUSGenerator gopter.Gen

// VirtualNetworkRule_STATUSGenerator returns a generator of VirtualNetworkRule_STATUS instances for property testing.
func VirtualNetworkRule_STATUSGenerator() gopter.Gen {
	if virtualNetworkRule_STATUSGenerator != nil {
		return virtualNetworkRule_STATUSGenerator
	}

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

	return virtualNetworkRule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualNetworkRule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualNetworkRule_STATUS(gens map[string]gopter.Gen) {
	gens["Id"] = gen.PtrOf(gen.AlphaString())
	gens["IgnoreMissingVnetServiceEndpoint"] = gen.PtrOf(gen.Bool())
	gens["State"] = gen.PtrOf(gen.AlphaString())
}
