// 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_ComputeRuntimeDto_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 ComputeRuntimeDto_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeRuntimeDto_STATUS, ComputeRuntimeDto_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeRuntimeDto_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 ComputeRuntimeDto_STATUS instances for property testing - lazily instantiated by
// ComputeRuntimeDto_STATUSGenerator()
var computeRuntimeDto_STATUSGenerator gopter.Gen

// ComputeRuntimeDto_STATUSGenerator returns a generator of ComputeRuntimeDto_STATUS instances for property testing.
func ComputeRuntimeDto_STATUSGenerator() gopter.Gen {
	if computeRuntimeDto_STATUSGenerator != nil {
		return computeRuntimeDto_STATUSGenerator
	}

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

	return computeRuntimeDto_STATUSGenerator
}

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

func Test_CosmosDbSettings_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 CosmosDbSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCosmosDbSettings_STATUS, CosmosDbSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CosmosDbSettings_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 CosmosDbSettings_STATUS instances for property testing - lazily instantiated by
// CosmosDbSettings_STATUSGenerator()
var cosmosDbSettings_STATUSGenerator gopter.Gen

// CosmosDbSettings_STATUSGenerator returns a generator of CosmosDbSettings_STATUS instances for property testing.
func CosmosDbSettings_STATUSGenerator() gopter.Gen {
	if cosmosDbSettings_STATUSGenerator != nil {
		return cosmosDbSettings_STATUSGenerator
	}

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

	return cosmosDbSettings_STATUSGenerator
}

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

func Test_EncryptionKeyVaultProperties_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 EncryptionKeyVaultProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEncryptionKeyVaultProperties_STATUS, EncryptionKeyVaultProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EncryptionKeyVaultProperties_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 EncryptionKeyVaultProperties_STATUS instances for property testing - lazily instantiated by
// EncryptionKeyVaultProperties_STATUSGenerator()
var encryptionKeyVaultProperties_STATUSGenerator gopter.Gen

// EncryptionKeyVaultProperties_STATUSGenerator returns a generator of EncryptionKeyVaultProperties_STATUS instances for property testing.
func EncryptionKeyVaultProperties_STATUSGenerator() gopter.Gen {
	if encryptionKeyVaultProperties_STATUSGenerator != nil {
		return encryptionKeyVaultProperties_STATUSGenerator
	}

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

	return encryptionKeyVaultProperties_STATUSGenerator
}

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

func Test_EncryptionProperty_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 EncryptionProperty_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEncryptionProperty_STATUS, EncryptionProperty_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EncryptionProperty_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 EncryptionProperty_STATUS instances for property testing - lazily instantiated by
// EncryptionProperty_STATUSGenerator()
var encryptionProperty_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEncryptionProperty_STATUS(generators)
	AddRelatedPropertyGeneratorsForEncryptionProperty_STATUS(generators)
	encryptionProperty_STATUSGenerator = gen.Struct(reflect.TypeOf(EncryptionProperty_STATUS{}), generators)

	return encryptionProperty_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForEncryptionProperty_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForEncryptionProperty_STATUS(gens map[string]gopter.Gen) {
	gens["Status"] = gen.PtrOf(gen.OneConstOf(EncryptionProperty_Status_STATUS_Disabled, EncryptionProperty_Status_STATUS_Enabled))
}

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

func Test_FeatureStoreSettings_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 FeatureStoreSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForFeatureStoreSettings_STATUS, FeatureStoreSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual FeatureStoreSettings_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 FeatureStoreSettings_STATUS instances for property testing - lazily instantiated by
// FeatureStoreSettings_STATUSGenerator()
var featureStoreSettings_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForFeatureStoreSettings_STATUS(generators)
	AddRelatedPropertyGeneratorsForFeatureStoreSettings_STATUS(generators)
	featureStoreSettings_STATUSGenerator = gen.Struct(reflect.TypeOf(FeatureStoreSettings_STATUS{}), generators)

	return featureStoreSettings_STATUSGenerator
}

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

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

func Test_FqdnOutboundRule_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 FqdnOutboundRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForFqdnOutboundRule_STATUS, FqdnOutboundRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual FqdnOutboundRule_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 FqdnOutboundRule_STATUS instances for property testing - lazily instantiated by
// FqdnOutboundRule_STATUSGenerator()
var fqdnOutboundRule_STATUSGenerator gopter.Gen

// FqdnOutboundRule_STATUSGenerator returns a generator of FqdnOutboundRule_STATUS instances for property testing.
func FqdnOutboundRule_STATUSGenerator() gopter.Gen {
	if fqdnOutboundRule_STATUSGenerator != nil {
		return fqdnOutboundRule_STATUSGenerator
	}

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

	return fqdnOutboundRule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForFqdnOutboundRule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForFqdnOutboundRule_STATUS(gens map[string]gopter.Gen) {
	gens["Category"] = gen.PtrOf(gen.OneConstOf(
		RuleCategory_STATUS_Dependency,
		RuleCategory_STATUS_Recommended,
		RuleCategory_STATUS_Required,
		RuleCategory_STATUS_UserDefined))
	gens["Destination"] = gen.PtrOf(gen.AlphaString())
	gens["Status"] = gen.PtrOf(gen.OneConstOf(RuleStatus_STATUS_Active, RuleStatus_STATUS_Inactive))
	gens["Type"] = gen.OneConstOf(FqdnOutboundRule_Type_STATUS_FQDN)
}

func Test_IdentityForCmk_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 IdentityForCmk_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIdentityForCmk_STATUS, IdentityForCmk_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual IdentityForCmk_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 IdentityForCmk_STATUS instances for property testing - lazily instantiated by
// IdentityForCmk_STATUSGenerator()
var identityForCmk_STATUSGenerator gopter.Gen

// IdentityForCmk_STATUSGenerator returns a generator of IdentityForCmk_STATUS instances for property testing.
func IdentityForCmk_STATUSGenerator() gopter.Gen {
	if identityForCmk_STATUSGenerator != nil {
		return identityForCmk_STATUSGenerator
	}

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

	return identityForCmk_STATUSGenerator
}

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

func Test_ManagedNetworkProvisionStatus_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 ManagedNetworkProvisionStatus_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedNetworkProvisionStatus_STATUS, ManagedNetworkProvisionStatus_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ManagedNetworkProvisionStatus_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 ManagedNetworkProvisionStatus_STATUS instances for property testing - lazily instantiated by
// ManagedNetworkProvisionStatus_STATUSGenerator()
var managedNetworkProvisionStatus_STATUSGenerator gopter.Gen

// ManagedNetworkProvisionStatus_STATUSGenerator returns a generator of ManagedNetworkProvisionStatus_STATUS instances for property testing.
func ManagedNetworkProvisionStatus_STATUSGenerator() gopter.Gen {
	if managedNetworkProvisionStatus_STATUSGenerator != nil {
		return managedNetworkProvisionStatus_STATUSGenerator
	}

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

	return managedNetworkProvisionStatus_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForManagedNetworkProvisionStatus_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedNetworkProvisionStatus_STATUS(gens map[string]gopter.Gen) {
	gens["SparkReady"] = gen.PtrOf(gen.Bool())
	gens["Status"] = gen.PtrOf(gen.OneConstOf(ManagedNetworkStatus_STATUS_Active, ManagedNetworkStatus_STATUS_Inactive))
}

func Test_ManagedNetworkSettings_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 ManagedNetworkSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedNetworkSettings_STATUS, ManagedNetworkSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ManagedNetworkSettings_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 ManagedNetworkSettings_STATUS instances for property testing - lazily instantiated by
// ManagedNetworkSettings_STATUSGenerator()
var managedNetworkSettings_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedNetworkSettings_STATUS(generators)
	AddRelatedPropertyGeneratorsForManagedNetworkSettings_STATUS(generators)
	managedNetworkSettings_STATUSGenerator = gen.Struct(reflect.TypeOf(ManagedNetworkSettings_STATUS{}), generators)

	return managedNetworkSettings_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForManagedNetworkSettings_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedNetworkSettings_STATUS(gens map[string]gopter.Gen) {
	gens["IsolationMode"] = gen.PtrOf(gen.OneConstOf(IsolationMode_STATUS_AllowInternetOutbound, IsolationMode_STATUS_AllowOnlyApprovedOutbound, IsolationMode_STATUS_Disabled))
	gens["NetworkId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForManagedNetworkSettings_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedNetworkSettings_STATUS(gens map[string]gopter.Gen) {
	gens["OutboundRules"] = gen.MapOf(
		gen.AlphaString(),
		OutboundRule_STATUSGenerator())
	gens["Status"] = gen.PtrOf(ManagedNetworkProvisionStatus_STATUSGenerator())
}

func Test_NotebookPreparationError_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 NotebookPreparationError_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNotebookPreparationError_STATUS, NotebookPreparationError_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NotebookPreparationError_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 NotebookPreparationError_STATUS instances for property testing - lazily instantiated by
// NotebookPreparationError_STATUSGenerator()
var notebookPreparationError_STATUSGenerator gopter.Gen

// NotebookPreparationError_STATUSGenerator returns a generator of NotebookPreparationError_STATUS instances for property testing.
func NotebookPreparationError_STATUSGenerator() gopter.Gen {
	if notebookPreparationError_STATUSGenerator != nil {
		return notebookPreparationError_STATUSGenerator
	}

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

	return notebookPreparationError_STATUSGenerator
}

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

func Test_NotebookResourceInfo_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 NotebookResourceInfo_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNotebookResourceInfo_STATUS, NotebookResourceInfo_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NotebookResourceInfo_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 NotebookResourceInfo_STATUS instances for property testing - lazily instantiated by
// NotebookResourceInfo_STATUSGenerator()
var notebookResourceInfo_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNotebookResourceInfo_STATUS(generators)
	AddRelatedPropertyGeneratorsForNotebookResourceInfo_STATUS(generators)
	notebookResourceInfo_STATUSGenerator = gen.Struct(reflect.TypeOf(NotebookResourceInfo_STATUS{}), generators)

	return notebookResourceInfo_STATUSGenerator
}

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

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

func Test_OutboundRule_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 OutboundRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForOutboundRule_STATUS, OutboundRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual OutboundRule_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 OutboundRule_STATUS instances for property testing - lazily instantiated by
// OutboundRule_STATUSGenerator()
var outboundRule_STATUSGenerator gopter.Gen

// OutboundRule_STATUSGenerator returns a generator of OutboundRule_STATUS instances for property testing.
func OutboundRule_STATUSGenerator() gopter.Gen {
	if outboundRule_STATUSGenerator != nil {
		return outboundRule_STATUSGenerator
	}

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

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

	return outboundRule_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForOutboundRule_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForOutboundRule_STATUS(gens map[string]gopter.Gen) {
	gens["FQDN"] = FqdnOutboundRule_STATUSGenerator().Map(func(it FqdnOutboundRule_STATUS) *FqdnOutboundRule_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["PrivateEndpoint"] = PrivateEndpointOutboundRule_STATUSGenerator().Map(func(it PrivateEndpointOutboundRule_STATUS) *PrivateEndpointOutboundRule_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["ServiceTag"] = ServiceTagOutboundRule_STATUSGenerator().Map(func(it ServiceTagOutboundRule_STATUS) *ServiceTagOutboundRule_STATUS {
		return &it
	}) // generate one case for OneOf type
}

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_PrivateEndpointDestination_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 PrivateEndpointDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrivateEndpointDestination_STATUS, PrivateEndpointDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PrivateEndpointDestination_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 PrivateEndpointDestination_STATUS instances for property testing - lazily instantiated by
// PrivateEndpointDestination_STATUSGenerator()
var privateEndpointDestination_STATUSGenerator gopter.Gen

// PrivateEndpointDestination_STATUSGenerator returns a generator of PrivateEndpointDestination_STATUS instances for property testing.
func PrivateEndpointDestination_STATUSGenerator() gopter.Gen {
	if privateEndpointDestination_STATUSGenerator != nil {
		return privateEndpointDestination_STATUSGenerator
	}

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

	return privateEndpointDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForPrivateEndpointDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForPrivateEndpointDestination_STATUS(gens map[string]gopter.Gen) {
	gens["ServiceResourceId"] = gen.PtrOf(gen.AlphaString())
	gens["SparkEnabled"] = gen.PtrOf(gen.Bool())
	gens["SparkStatus"] = gen.PtrOf(gen.OneConstOf(RuleStatus_STATUS_Active, RuleStatus_STATUS_Inactive))
	gens["SubresourceTarget"] = gen.PtrOf(gen.AlphaString())
}

func Test_PrivateEndpointOutboundRule_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 PrivateEndpointOutboundRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrivateEndpointOutboundRule_STATUS, PrivateEndpointOutboundRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PrivateEndpointOutboundRule_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 PrivateEndpointOutboundRule_STATUS instances for property testing - lazily instantiated by
// PrivateEndpointOutboundRule_STATUSGenerator()
var privateEndpointOutboundRule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForPrivateEndpointOutboundRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForPrivateEndpointOutboundRule_STATUS(generators)
	privateEndpointOutboundRule_STATUSGenerator = gen.Struct(reflect.TypeOf(PrivateEndpointOutboundRule_STATUS{}), generators)

	return privateEndpointOutboundRule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForPrivateEndpointOutboundRule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForPrivateEndpointOutboundRule_STATUS(gens map[string]gopter.Gen) {
	gens["Category"] = gen.PtrOf(gen.OneConstOf(
		RuleCategory_STATUS_Dependency,
		RuleCategory_STATUS_Recommended,
		RuleCategory_STATUS_Required,
		RuleCategory_STATUS_UserDefined))
	gens["Status"] = gen.PtrOf(gen.OneConstOf(RuleStatus_STATUS_Active, RuleStatus_STATUS_Inactive))
	gens["Type"] = gen.OneConstOf(PrivateEndpointOutboundRule_Type_STATUS_PrivateEndpoint)
}

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

func Test_ServerlessComputeSettings_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 ServerlessComputeSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServerlessComputeSettings_STATUS, ServerlessComputeSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ServerlessComputeSettings_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 ServerlessComputeSettings_STATUS instances for property testing - lazily instantiated by
// ServerlessComputeSettings_STATUSGenerator()
var serverlessComputeSettings_STATUSGenerator gopter.Gen

// ServerlessComputeSettings_STATUSGenerator returns a generator of ServerlessComputeSettings_STATUS instances for property testing.
func ServerlessComputeSettings_STATUSGenerator() gopter.Gen {
	if serverlessComputeSettings_STATUSGenerator != nil {
		return serverlessComputeSettings_STATUSGenerator
	}

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

	return serverlessComputeSettings_STATUSGenerator
}

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

func Test_ServiceManagedResourcesSettings_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 ServiceManagedResourcesSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServiceManagedResourcesSettings_STATUS, ServiceManagedResourcesSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ServiceManagedResourcesSettings_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 ServiceManagedResourcesSettings_STATUS instances for property testing - lazily instantiated by
// ServiceManagedResourcesSettings_STATUSGenerator()
var serviceManagedResourcesSettings_STATUSGenerator gopter.Gen

// ServiceManagedResourcesSettings_STATUSGenerator returns a generator of ServiceManagedResourcesSettings_STATUS instances for property testing.
func ServiceManagedResourcesSettings_STATUSGenerator() gopter.Gen {
	if serviceManagedResourcesSettings_STATUSGenerator != nil {
		return serviceManagedResourcesSettings_STATUSGenerator
	}

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

	return serviceManagedResourcesSettings_STATUSGenerator
}

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

func Test_ServiceTagDestination_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 ServiceTagDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServiceTagDestination_STATUS, ServiceTagDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ServiceTagDestination_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 ServiceTagDestination_STATUS instances for property testing - lazily instantiated by
// ServiceTagDestination_STATUSGenerator()
var serviceTagDestination_STATUSGenerator gopter.Gen

// ServiceTagDestination_STATUSGenerator returns a generator of ServiceTagDestination_STATUS instances for property testing.
func ServiceTagDestination_STATUSGenerator() gopter.Gen {
	if serviceTagDestination_STATUSGenerator != nil {
		return serviceTagDestination_STATUSGenerator
	}

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

	return serviceTagDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForServiceTagDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForServiceTagDestination_STATUS(gens map[string]gopter.Gen) {
	gens["Action"] = gen.PtrOf(gen.OneConstOf(RuleAction_STATUS_Allow, RuleAction_STATUS_Deny))
	gens["AddressPrefixes"] = gen.SliceOf(gen.AlphaString())
	gens["PortRanges"] = gen.PtrOf(gen.AlphaString())
	gens["Protocol"] = gen.PtrOf(gen.AlphaString())
	gens["ServiceTag"] = gen.PtrOf(gen.AlphaString())
}

func Test_ServiceTagOutboundRule_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 ServiceTagOutboundRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServiceTagOutboundRule_STATUS, ServiceTagOutboundRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ServiceTagOutboundRule_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 ServiceTagOutboundRule_STATUS instances for property testing - lazily instantiated by
// ServiceTagOutboundRule_STATUSGenerator()
var serviceTagOutboundRule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForServiceTagOutboundRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForServiceTagOutboundRule_STATUS(generators)
	serviceTagOutboundRule_STATUSGenerator = gen.Struct(reflect.TypeOf(ServiceTagOutboundRule_STATUS{}), generators)

	return serviceTagOutboundRule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForServiceTagOutboundRule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForServiceTagOutboundRule_STATUS(gens map[string]gopter.Gen) {
	gens["Category"] = gen.PtrOf(gen.OneConstOf(
		RuleCategory_STATUS_Dependency,
		RuleCategory_STATUS_Recommended,
		RuleCategory_STATUS_Required,
		RuleCategory_STATUS_UserDefined))
	gens["Status"] = gen.PtrOf(gen.OneConstOf(RuleStatus_STATUS_Active, RuleStatus_STATUS_Inactive))
	gens["Type"] = gen.OneConstOf(ServiceTagOutboundRule_Type_STATUS_ServiceTag)
}

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

func Test_SharedPrivateLinkResourceProperty_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 SharedPrivateLinkResourceProperty_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSharedPrivateLinkResourceProperty_STATUS, SharedPrivateLinkResourceProperty_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SharedPrivateLinkResourceProperty_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 SharedPrivateLinkResourceProperty_STATUS instances for property testing - lazily instantiated by
// SharedPrivateLinkResourceProperty_STATUSGenerator()
var sharedPrivateLinkResourceProperty_STATUSGenerator gopter.Gen

// SharedPrivateLinkResourceProperty_STATUSGenerator returns a generator of SharedPrivateLinkResourceProperty_STATUS instances for property testing.
func SharedPrivateLinkResourceProperty_STATUSGenerator() gopter.Gen {
	if sharedPrivateLinkResourceProperty_STATUSGenerator != nil {
		return sharedPrivateLinkResourceProperty_STATUSGenerator
	}

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

	return sharedPrivateLinkResourceProperty_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSharedPrivateLinkResourceProperty_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSharedPrivateLinkResourceProperty_STATUS(gens map[string]gopter.Gen) {
	gens["GroupId"] = gen.PtrOf(gen.AlphaString())
	gens["PrivateLinkResourceId"] = gen.PtrOf(gen.AlphaString())
	gens["RequestMessage"] = gen.PtrOf(gen.AlphaString())
	gens["Status"] = gen.PtrOf(gen.OneConstOf(
		PrivateEndpointServiceConnectionStatus_STATUS_Approved,
		PrivateEndpointServiceConnectionStatus_STATUS_Disconnected,
		PrivateEndpointServiceConnectionStatus_STATUS_Pending,
		PrivateEndpointServiceConnectionStatus_STATUS_Rejected,
		PrivateEndpointServiceConnectionStatus_STATUS_Timeout))
}

func Test_SharedPrivateLinkResource_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 SharedPrivateLinkResource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSharedPrivateLinkResource_STATUS, SharedPrivateLinkResource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SharedPrivateLinkResource_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 SharedPrivateLinkResource_STATUS instances for property testing - lazily instantiated by
// SharedPrivateLinkResource_STATUSGenerator()
var sharedPrivateLinkResource_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSharedPrivateLinkResource_STATUS(generators)
	AddRelatedPropertyGeneratorsForSharedPrivateLinkResource_STATUS(generators)
	sharedPrivateLinkResource_STATUSGenerator = gen.Struct(reflect.TypeOf(SharedPrivateLinkResource_STATUS{}), generators)

	return sharedPrivateLinkResource_STATUSGenerator
}

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

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

func Test_WorkspaceHubConfig_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 WorkspaceHubConfig_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWorkspaceHubConfig_STATUS, WorkspaceHubConfig_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual WorkspaceHubConfig_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 WorkspaceHubConfig_STATUS instances for property testing - lazily instantiated by
// WorkspaceHubConfig_STATUSGenerator()
var workspaceHubConfig_STATUSGenerator gopter.Gen

// WorkspaceHubConfig_STATUSGenerator returns a generator of WorkspaceHubConfig_STATUS instances for property testing.
func WorkspaceHubConfig_STATUSGenerator() gopter.Gen {
	if workspaceHubConfig_STATUSGenerator != nil {
		return workspaceHubConfig_STATUSGenerator
	}

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

	return workspaceHubConfig_STATUSGenerator
}

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

func Test_WorkspaceProperties_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 WorkspaceProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWorkspaceProperties_STATUS, WorkspaceProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual WorkspaceProperties_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 WorkspaceProperties_STATUS instances for property testing - lazily instantiated by
// WorkspaceProperties_STATUSGenerator()
var workspaceProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForWorkspaceProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForWorkspaceProperties_STATUS(generators)
	workspaceProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(WorkspaceProperties_STATUS{}), generators)

	return workspaceProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForWorkspaceProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForWorkspaceProperties_STATUS(gens map[string]gopter.Gen) {
	gens["AllowPublicAccessWhenBehindVnet"] = gen.PtrOf(gen.Bool())
	gens["ApplicationInsights"] = gen.PtrOf(gen.AlphaString())
	gens["AssociatedWorkspaces"] = gen.SliceOf(gen.AlphaString())
	gens["ContainerRegistry"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DiscoveryUrl"] = gen.PtrOf(gen.AlphaString())
	gens["EnableDataIsolation"] = gen.PtrOf(gen.Bool())
	gens["FriendlyName"] = gen.PtrOf(gen.AlphaString())
	gens["HbiWorkspace"] = gen.PtrOf(gen.Bool())
	gens["HubResourceId"] = gen.PtrOf(gen.AlphaString())
	gens["ImageBuildCompute"] = gen.PtrOf(gen.AlphaString())
	gens["KeyVault"] = gen.PtrOf(gen.AlphaString())
	gens["MlFlowTrackingUri"] = gen.PtrOf(gen.AlphaString())
	gens["PrimaryUserAssignedIdentity"] = gen.PtrOf(gen.AlphaString())
	gens["PrivateLinkCount"] = gen.PtrOf(gen.Int())
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		WorkspaceProperties_ProvisioningState_STATUS_Canceled,
		WorkspaceProperties_ProvisioningState_STATUS_Creating,
		WorkspaceProperties_ProvisioningState_STATUS_Deleting,
		WorkspaceProperties_ProvisioningState_STATUS_Failed,
		WorkspaceProperties_ProvisioningState_STATUS_Succeeded,
		WorkspaceProperties_ProvisioningState_STATUS_Unknown,
		WorkspaceProperties_ProvisioningState_STATUS_Updating))
	gens["PublicNetworkAccess"] = gen.PtrOf(gen.OneConstOf(WorkspaceProperties_PublicNetworkAccess_STATUS_Disabled, WorkspaceProperties_PublicNetworkAccess_STATUS_Enabled))
	gens["ServiceProvisionedResourceGroup"] = gen.PtrOf(gen.AlphaString())
	gens["StorageAccount"] = gen.PtrOf(gen.AlphaString())
	gens["StorageHnsEnabled"] = gen.PtrOf(gen.Bool())
	gens["TenantId"] = gen.PtrOf(gen.AlphaString())
	gens["V1LegacyMode"] = gen.PtrOf(gen.Bool())
	gens["WorkspaceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForWorkspaceProperties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForWorkspaceProperties_STATUS(gens map[string]gopter.Gen) {
	gens["Encryption"] = gen.PtrOf(EncryptionProperty_STATUSGenerator())
	gens["FeatureStoreSettings"] = gen.PtrOf(FeatureStoreSettings_STATUSGenerator())
	gens["ManagedNetwork"] = gen.PtrOf(ManagedNetworkSettings_STATUSGenerator())
	gens["NotebookInfo"] = gen.PtrOf(NotebookResourceInfo_STATUSGenerator())
	gens["PrivateEndpointConnections"] = gen.SliceOf(PrivateEndpointConnection_STATUSGenerator())
	gens["ServerlessComputeSettings"] = gen.PtrOf(ServerlessComputeSettings_STATUSGenerator())
	gens["ServiceManagedResourcesSettings"] = gen.PtrOf(ServiceManagedResourcesSettings_STATUSGenerator())
	gens["SharedPrivateLinkResources"] = gen.SliceOf(SharedPrivateLinkResource_STATUSGenerator())
	gens["WorkspaceHubConfig"] = gen.PtrOf(WorkspaceHubConfig_STATUSGenerator())
}

func Test_Workspace_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 Workspace_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWorkspace_STATUS, Workspace_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Workspace_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 Workspace_STATUS instances for property testing - lazily instantiated by Workspace_STATUSGenerator()
var workspace_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForWorkspace_STATUS(generators)
	AddRelatedPropertyGeneratorsForWorkspace_STATUS(generators)
	workspace_STATUSGenerator = gen.Struct(reflect.TypeOf(Workspace_STATUS{}), generators)

	return workspace_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForWorkspace_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForWorkspace_STATUS(gens map[string]gopter.Gen) {
	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())
}

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