// 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_AcceptedAudiences_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 AcceptedAudiences_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAcceptedAudiences_STATUS, AcceptedAudiences_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AcceptedAudiences_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 AcceptedAudiences_STATUS instances for property testing - lazily instantiated by
// AcceptedAudiences_STATUSGenerator()
var acceptedAudiences_STATUSGenerator gopter.Gen

// AcceptedAudiences_STATUSGenerator returns a generator of AcceptedAudiences_STATUS instances for property testing.
func AcceptedAudiences_STATUSGenerator() gopter.Gen {
	if acceptedAudiences_STATUSGenerator != nil {
		return acceptedAudiences_STATUSGenerator
	}

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

	return acceptedAudiences_STATUSGenerator
}

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

func Test_AzureSku_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 AzureSku_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAzureSku_STATUS, AzureSku_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AzureSku_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 AzureSku_STATUS instances for property testing - lazily instantiated by AzureSku_STATUSGenerator()
var azureSku_STATUSGenerator gopter.Gen

// AzureSku_STATUSGenerator returns a generator of AzureSku_STATUS instances for property testing.
func AzureSku_STATUSGenerator() gopter.Gen {
	if azureSku_STATUSGenerator != nil {
		return azureSku_STATUSGenerator
	}

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

	return azureSku_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAzureSku_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAzureSku_STATUS(gens map[string]gopter.Gen) {
	gens["Capacity"] = gen.PtrOf(gen.Int())
	gens["Name"] = gen.PtrOf(gen.OneConstOf(
		AzureSku_Name_STATUS_DevNoSLA_Standard_D11_V2,
		AzureSku_Name_STATUS_DevNoSLA_Standard_E2A_V4,
		AzureSku_Name_STATUS_Standard_D11_V2,
		AzureSku_Name_STATUS_Standard_D12_V2,
		AzureSku_Name_STATUS_Standard_D13_V2,
		AzureSku_Name_STATUS_Standard_D14_V2,
		AzureSku_Name_STATUS_Standard_D16D_V5,
		AzureSku_Name_STATUS_Standard_D32D_V4,
		AzureSku_Name_STATUS_Standard_D32D_V5,
		AzureSku_Name_STATUS_Standard_DS13_V21TB_PS,
		AzureSku_Name_STATUS_Standard_DS13_V22TB_PS,
		AzureSku_Name_STATUS_Standard_DS14_V23TB_PS,
		AzureSku_Name_STATUS_Standard_DS14_V24TB_PS,
		AzureSku_Name_STATUS_Standard_E16A_V4,
		AzureSku_Name_STATUS_Standard_E16Ads_V5,
		AzureSku_Name_STATUS_Standard_E16As_V43TB_PS,
		AzureSku_Name_STATUS_Standard_E16As_V44TB_PS,
		AzureSku_Name_STATUS_Standard_E16As_V53TB_PS,
		AzureSku_Name_STATUS_Standard_E16As_V54TB_PS,
		AzureSku_Name_STATUS_Standard_E16D_V4,
		AzureSku_Name_STATUS_Standard_E16D_V5,
		AzureSku_Name_STATUS_Standard_E16S_V43TB_PS,
		AzureSku_Name_STATUS_Standard_E16S_V44TB_PS,
		AzureSku_Name_STATUS_Standard_E16S_V53TB_PS,
		AzureSku_Name_STATUS_Standard_E16S_V54TB_PS,
		AzureSku_Name_STATUS_Standard_E2A_V4,
		AzureSku_Name_STATUS_Standard_E2Ads_V5,
		AzureSku_Name_STATUS_Standard_E2D_V4,
		AzureSku_Name_STATUS_Standard_E2D_V5,
		AzureSku_Name_STATUS_Standard_E4A_V4,
		AzureSku_Name_STATUS_Standard_E4Ads_V5,
		AzureSku_Name_STATUS_Standard_E4D_V4,
		AzureSku_Name_STATUS_Standard_E4D_V5,
		AzureSku_Name_STATUS_Standard_E64I_V3,
		AzureSku_Name_STATUS_Standard_E80Ids_V4,
		AzureSku_Name_STATUS_Standard_E8A_V4,
		AzureSku_Name_STATUS_Standard_E8Ads_V5,
		AzureSku_Name_STATUS_Standard_E8As_V41TB_PS,
		AzureSku_Name_STATUS_Standard_E8As_V42TB_PS,
		AzureSku_Name_STATUS_Standard_E8As_V51TB_PS,
		AzureSku_Name_STATUS_Standard_E8As_V52TB_PS,
		AzureSku_Name_STATUS_Standard_E8D_V4,
		AzureSku_Name_STATUS_Standard_E8D_V5,
		AzureSku_Name_STATUS_Standard_E8S_V41TB_PS,
		AzureSku_Name_STATUS_Standard_E8S_V42TB_PS,
		AzureSku_Name_STATUS_Standard_E8S_V51TB_PS,
		AzureSku_Name_STATUS_Standard_E8S_V52TB_PS,
		AzureSku_Name_STATUS_Standard_EC16Ads_V5,
		AzureSku_Name_STATUS_Standard_EC16As_V53TB_PS,
		AzureSku_Name_STATUS_Standard_EC16As_V54TB_PS,
		AzureSku_Name_STATUS_Standard_EC8Ads_V5,
		AzureSku_Name_STATUS_Standard_EC8As_V51TB_PS,
		AzureSku_Name_STATUS_Standard_EC8As_V52TB_PS,
		AzureSku_Name_STATUS_Standard_L16As_V3,
		AzureSku_Name_STATUS_Standard_L16S,
		AzureSku_Name_STATUS_Standard_L16S_V2,
		AzureSku_Name_STATUS_Standard_L16S_V3,
		AzureSku_Name_STATUS_Standard_L32As_V3,
		AzureSku_Name_STATUS_Standard_L32S_V3,
		AzureSku_Name_STATUS_Standard_L4S,
		AzureSku_Name_STATUS_Standard_L8As_V3,
		AzureSku_Name_STATUS_Standard_L8S,
		AzureSku_Name_STATUS_Standard_L8S_V2,
		AzureSku_Name_STATUS_Standard_L8S_V3))
	gens["Tier"] = gen.PtrOf(gen.OneConstOf(AzureSku_Tier_STATUS_Basic, AzureSku_Tier_STATUS_Standard))
}

func Test_CalloutPolicy_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 CalloutPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCalloutPolicy_STATUS, CalloutPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CalloutPolicy_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 CalloutPolicy_STATUS instances for property testing - lazily instantiated by
// CalloutPolicy_STATUSGenerator()
var calloutPolicy_STATUSGenerator gopter.Gen

// CalloutPolicy_STATUSGenerator returns a generator of CalloutPolicy_STATUS instances for property testing.
func CalloutPolicy_STATUSGenerator() gopter.Gen {
	if calloutPolicy_STATUSGenerator != nil {
		return calloutPolicy_STATUSGenerator
	}

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

	return calloutPolicy_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForCalloutPolicy_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCalloutPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["CalloutId"] = gen.PtrOf(gen.AlphaString())
	gens["CalloutType"] = gen.PtrOf(gen.OneConstOf(
		CalloutPolicy_CalloutType_STATUS_Azure_Digital_Twins,
		CalloutPolicy_CalloutType_STATUS_Azure_Openai,
		CalloutPolicy_CalloutType_STATUS_Cosmosdb,
		CalloutPolicy_CalloutType_STATUS_External_Data,
		CalloutPolicy_CalloutType_STATUS_Genevametrics,
		CalloutPolicy_CalloutType_STATUS_Kusto,
		CalloutPolicy_CalloutType_STATUS_Mysql,
		CalloutPolicy_CalloutType_STATUS_Postgresql,
		CalloutPolicy_CalloutType_STATUS_Sandbox_Artifacts,
		CalloutPolicy_CalloutType_STATUS_Sql,
		CalloutPolicy_CalloutType_STATUS_Webapi))
	gens["CalloutUriRegex"] = gen.PtrOf(gen.AlphaString())
	gens["OutboundAccess"] = gen.PtrOf(gen.OneConstOf(CalloutPolicy_OutboundAccess_STATUS_Allow, CalloutPolicy_OutboundAccess_STATUS_Deny))
}

func Test_ClusterProperties_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 ClusterProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForClusterProperties_STATUS, ClusterProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ClusterProperties_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 ClusterProperties_STATUS instances for property testing - lazily instantiated by
// ClusterProperties_STATUSGenerator()
var clusterProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForClusterProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForClusterProperties_STATUS(generators)
	clusterProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(ClusterProperties_STATUS{}), generators)

	return clusterProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForClusterProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForClusterProperties_STATUS(gens map[string]gopter.Gen) {
	gens["AllowedFqdnList"] = gen.SliceOf(gen.AlphaString())
	gens["AllowedIpRangeList"] = gen.SliceOf(gen.AlphaString())
	gens["DataIngestionUri"] = gen.PtrOf(gen.AlphaString())
	gens["EnableAutoStop"] = gen.PtrOf(gen.Bool())
	gens["EnableDiskEncryption"] = gen.PtrOf(gen.Bool())
	gens["EnableDoubleEncryption"] = gen.PtrOf(gen.Bool())
	gens["EnablePurge"] = gen.PtrOf(gen.Bool())
	gens["EnableStreamingIngest"] = gen.PtrOf(gen.Bool())
	gens["EngineType"] = gen.PtrOf(gen.OneConstOf(ClusterProperties_EngineType_STATUS_V2, ClusterProperties_EngineType_STATUS_V3))
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ProvisioningState_STATUS_Canceled,
		ProvisioningState_STATUS_Creating,
		ProvisioningState_STATUS_Deleting,
		ProvisioningState_STATUS_Failed,
		ProvisioningState_STATUS_Moving,
		ProvisioningState_STATUS_Running,
		ProvisioningState_STATUS_Succeeded))
	gens["PublicIPType"] = gen.PtrOf(gen.OneConstOf(ClusterProperties_PublicIPType_STATUS_DualStack, ClusterProperties_PublicIPType_STATUS_IPv4))
	gens["PublicNetworkAccess"] = gen.PtrOf(gen.OneConstOf(ClusterProperties_PublicNetworkAccess_STATUS_Disabled, ClusterProperties_PublicNetworkAccess_STATUS_Enabled))
	gens["RestrictOutboundNetworkAccess"] = gen.PtrOf(gen.OneConstOf(ClusterProperties_RestrictOutboundNetworkAccess_STATUS_Disabled, ClusterProperties_RestrictOutboundNetworkAccess_STATUS_Enabled))
	gens["State"] = gen.PtrOf(gen.OneConstOf(
		ClusterProperties_State_STATUS_Creating,
		ClusterProperties_State_STATUS_Deleted,
		ClusterProperties_State_STATUS_Deleting,
		ClusterProperties_State_STATUS_Migrated,
		ClusterProperties_State_STATUS_Running,
		ClusterProperties_State_STATUS_Starting,
		ClusterProperties_State_STATUS_Stopped,
		ClusterProperties_State_STATUS_Stopping,
		ClusterProperties_State_STATUS_Unavailable,
		ClusterProperties_State_STATUS_Updating))
	gens["StateReason"] = gen.PtrOf(gen.AlphaString())
	gens["Uri"] = gen.PtrOf(gen.AlphaString())
	gens["ZoneStatus"] = gen.PtrOf(gen.OneConstOf(ClusterProperties_ZoneStatus_STATUS_NonZonal, ClusterProperties_ZoneStatus_STATUS_Zonal, ClusterProperties_ZoneStatus_STATUS_ZonalInconsistency))
}

// AddRelatedPropertyGeneratorsForClusterProperties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForClusterProperties_STATUS(gens map[string]gopter.Gen) {
	gens["AcceptedAudiences"] = gen.SliceOf(AcceptedAudiences_STATUSGenerator())
	gens["CalloutPolicies"] = gen.SliceOf(CalloutPolicy_STATUSGenerator())
	gens["KeyVaultProperties"] = gen.PtrOf(KeyVaultProperties_STATUSGenerator())
	gens["LanguageExtensions"] = gen.PtrOf(LanguageExtensionsList_STATUSGenerator())
	gens["MigrationCluster"] = gen.PtrOf(MigrationClusterProperties_STATUSGenerator())
	gens["OptimizedAutoscale"] = gen.PtrOf(OptimizedAutoscale_STATUSGenerator())
	gens["PrivateEndpointConnections"] = gen.SliceOf(PrivateEndpointConnection_STATUSGenerator())
	gens["TrustedExternalTenants"] = gen.SliceOf(TrustedExternalTenant_STATUSGenerator())
	gens["VirtualNetworkConfiguration"] = gen.PtrOf(VirtualNetworkConfiguration_STATUSGenerator())
}

func Test_Cluster_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 Cluster_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCluster_STATUS, Cluster_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Cluster_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 Cluster_STATUS instances for property testing - lazily instantiated by Cluster_STATUSGenerator()
var cluster_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForCluster_STATUS(generators)
	AddRelatedPropertyGeneratorsForCluster_STATUS(generators)
	cluster_STATUSGenerator = gen.Struct(reflect.TypeOf(Cluster_STATUS{}), generators)

	return cluster_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForCluster_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForCluster_STATUS(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(Identity_STATUSGenerator())
	gens["Properties"] = gen.PtrOf(ClusterProperties_STATUSGenerator())
	gens["Sku"] = gen.PtrOf(AzureSku_STATUSGenerator())
	gens["SystemData"] = gen.PtrOf(SystemData_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(),
		Identity_UserAssignedIdentities_STATUSGenerator())
}

func Test_Identity_UserAssignedIdentities_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_UserAssignedIdentities_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIdentity_UserAssignedIdentities_STATUS, Identity_UserAssignedIdentities_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Identity_UserAssignedIdentities_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_UserAssignedIdentities_STATUS instances for property testing - lazily instantiated by
// Identity_UserAssignedIdentities_STATUSGenerator()
var identity_UserAssignedIdentities_STATUSGenerator gopter.Gen

// Identity_UserAssignedIdentities_STATUSGenerator returns a generator of Identity_UserAssignedIdentities_STATUS instances for property testing.
func Identity_UserAssignedIdentities_STATUSGenerator() gopter.Gen {
	if identity_UserAssignedIdentities_STATUSGenerator != nil {
		return identity_UserAssignedIdentities_STATUSGenerator
	}

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

	return identity_UserAssignedIdentities_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIdentity_UserAssignedIdentities_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIdentity_UserAssignedIdentities_STATUS(gens map[string]gopter.Gen) {
	gens["ClientId"] = gen.PtrOf(gen.AlphaString())
	gens["PrincipalId"] = 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["KeyName"] = gen.PtrOf(gen.AlphaString())
	gens["KeyVaultUri"] = gen.PtrOf(gen.AlphaString())
	gens["KeyVersion"] = gen.PtrOf(gen.AlphaString())
	gens["UserIdentity"] = gen.PtrOf(gen.AlphaString())
}

func Test_LanguageExtension_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 LanguageExtension_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForLanguageExtension_STATUS, LanguageExtension_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual LanguageExtension_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 LanguageExtension_STATUS instances for property testing - lazily instantiated by
// LanguageExtension_STATUSGenerator()
var languageExtension_STATUSGenerator gopter.Gen

// LanguageExtension_STATUSGenerator returns a generator of LanguageExtension_STATUS instances for property testing.
func LanguageExtension_STATUSGenerator() gopter.Gen {
	if languageExtension_STATUSGenerator != nil {
		return languageExtension_STATUSGenerator
	}

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

	return languageExtension_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForLanguageExtension_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForLanguageExtension_STATUS(gens map[string]gopter.Gen) {
	gens["LanguageExtensionCustomImageName"] = gen.PtrOf(gen.AlphaString())
	gens["LanguageExtensionImageName"] = gen.PtrOf(gen.OneConstOf(
		LanguageExtensionImageName_STATUS_Python3_10_8,
		LanguageExtensionImageName_STATUS_Python3_10_8_DL,
		LanguageExtensionImageName_STATUS_Python3_11_7,
		LanguageExtensionImageName_STATUS_Python3_11_7_DL,
		LanguageExtensionImageName_STATUS_Python3_6_5,
		LanguageExtensionImageName_STATUS_PythonCustomImage,
		LanguageExtensionImageName_STATUS_R))
	gens["LanguageExtensionName"] = gen.PtrOf(gen.OneConstOf(LanguageExtensionName_STATUS_PYTHON, LanguageExtensionName_STATUS_R))
}

func Test_LanguageExtensionsList_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 LanguageExtensionsList_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForLanguageExtensionsList_STATUS, LanguageExtensionsList_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual LanguageExtensionsList_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 LanguageExtensionsList_STATUS instances for property testing - lazily instantiated by
// LanguageExtensionsList_STATUSGenerator()
var languageExtensionsList_STATUSGenerator gopter.Gen

// LanguageExtensionsList_STATUSGenerator returns a generator of LanguageExtensionsList_STATUS instances for property testing.
func LanguageExtensionsList_STATUSGenerator() gopter.Gen {
	if languageExtensionsList_STATUSGenerator != nil {
		return languageExtensionsList_STATUSGenerator
	}

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

	return languageExtensionsList_STATUSGenerator
}

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

func Test_MigrationClusterProperties_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 MigrationClusterProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForMigrationClusterProperties_STATUS, MigrationClusterProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual MigrationClusterProperties_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 MigrationClusterProperties_STATUS instances for property testing - lazily instantiated by
// MigrationClusterProperties_STATUSGenerator()
var migrationClusterProperties_STATUSGenerator gopter.Gen

// MigrationClusterProperties_STATUSGenerator returns a generator of MigrationClusterProperties_STATUS instances for property testing.
func MigrationClusterProperties_STATUSGenerator() gopter.Gen {
	if migrationClusterProperties_STATUSGenerator != nil {
		return migrationClusterProperties_STATUSGenerator
	}

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

	return migrationClusterProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForMigrationClusterProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForMigrationClusterProperties_STATUS(gens map[string]gopter.Gen) {
	gens["DataIngestionUri"] = gen.PtrOf(gen.AlphaString())
	gens["Id"] = gen.PtrOf(gen.AlphaString())
	gens["Role"] = gen.PtrOf(gen.OneConstOf(MigrationClusterProperties_Role_STATUS_Destination, MigrationClusterProperties_Role_STATUS_Source))
	gens["Uri"] = gen.PtrOf(gen.AlphaString())
}

func Test_OptimizedAutoscale_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 OptimizedAutoscale_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForOptimizedAutoscale_STATUS, OptimizedAutoscale_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual OptimizedAutoscale_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 OptimizedAutoscale_STATUS instances for property testing - lazily instantiated by
// OptimizedAutoscale_STATUSGenerator()
var optimizedAutoscale_STATUSGenerator gopter.Gen

// OptimizedAutoscale_STATUSGenerator returns a generator of OptimizedAutoscale_STATUS instances for property testing.
func OptimizedAutoscale_STATUSGenerator() gopter.Gen {
	if optimizedAutoscale_STATUSGenerator != nil {
		return optimizedAutoscale_STATUSGenerator
	}

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

	return optimizedAutoscale_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForOptimizedAutoscale_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForOptimizedAutoscale_STATUS(gens map[string]gopter.Gen) {
	gens["IsEnabled"] = gen.PtrOf(gen.Bool())
	gens["Maximum"] = gen.PtrOf(gen.Int())
	gens["Minimum"] = gen.PtrOf(gen.Int())
	gens["Version"] = gen.PtrOf(gen.Int())
}

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_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_TrustedExternalTenant_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 TrustedExternalTenant_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTrustedExternalTenant_STATUS, TrustedExternalTenant_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual TrustedExternalTenant_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 TrustedExternalTenant_STATUS instances for property testing - lazily instantiated by
// TrustedExternalTenant_STATUSGenerator()
var trustedExternalTenant_STATUSGenerator gopter.Gen

// TrustedExternalTenant_STATUSGenerator returns a generator of TrustedExternalTenant_STATUS instances for property testing.
func TrustedExternalTenant_STATUSGenerator() gopter.Gen {
	if trustedExternalTenant_STATUSGenerator != nil {
		return trustedExternalTenant_STATUSGenerator
	}

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

	return trustedExternalTenant_STATUSGenerator
}

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

func Test_VirtualNetworkConfiguration_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 VirtualNetworkConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVirtualNetworkConfiguration_STATUS, VirtualNetworkConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual VirtualNetworkConfiguration_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 VirtualNetworkConfiguration_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkConfiguration_STATUSGenerator()
var virtualNetworkConfiguration_STATUSGenerator gopter.Gen

// VirtualNetworkConfiguration_STATUSGenerator returns a generator of VirtualNetworkConfiguration_STATUS instances for property testing.
func VirtualNetworkConfiguration_STATUSGenerator() gopter.Gen {
	if virtualNetworkConfiguration_STATUSGenerator != nil {
		return virtualNetworkConfiguration_STATUSGenerator
	}

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

	return virtualNetworkConfiguration_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualNetworkConfiguration_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualNetworkConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["DataManagementPublicIpId"] = gen.PtrOf(gen.AlphaString())
	gens["EnginePublicIpId"] = gen.PtrOf(gen.AlphaString())
	gens["State"] = gen.PtrOf(gen.OneConstOf(VirtualNetworkConfiguration_State_STATUS_Disabled, VirtualNetworkConfiguration_State_STATUS_Enabled))
	gens["SubnetId"] = gen.PtrOf(gen.AlphaString())
}
