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

import (
	"encoding/json"
	storage "github.com/Azure/azure-service-operator/v2/api/machinelearningservices/v1api20240401/storage"
	"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_AcrDetails_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from AcrDetails to AcrDetails via AssignProperties_To_AcrDetails & AssignProperties_From_AcrDetails returns original",
		prop.ForAll(RunPropertyAssignmentTestForAcrDetails, AcrDetailsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForAcrDetails tests if a specific instance of AcrDetails can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForAcrDetails(subject AcrDetails) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.AcrDetails
	err := copied.AssignProperties_To_AcrDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual AcrDetails
	err = actual.AssignProperties_From_AcrDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual AcrDetails
	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 AcrDetails instances for property testing - lazily instantiated by AcrDetailsGenerator()
var acrDetailsGenerator gopter.Gen

// AcrDetailsGenerator returns a generator of AcrDetails instances for property testing.
func AcrDetailsGenerator() gopter.Gen {
	if acrDetailsGenerator != nil {
		return acrDetailsGenerator
	}

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

	return acrDetailsGenerator
}

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

func Test_AcrDetails_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from AcrDetails_STATUS to AcrDetails_STATUS via AssignProperties_To_AcrDetails_STATUS & AssignProperties_From_AcrDetails_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForAcrDetails_STATUS, AcrDetails_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForAcrDetails_STATUS tests if a specific instance of AcrDetails_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForAcrDetails_STATUS(subject AcrDetails_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.AcrDetails_STATUS
	err := copied.AssignProperties_To_AcrDetails_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual AcrDetails_STATUS
	err = actual.AssignProperties_From_AcrDetails_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_AcrDetails_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 AcrDetails_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAcrDetails_STATUS, AcrDetails_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AcrDetails_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 AcrDetails_STATUS instances for property testing - lazily instantiated by AcrDetails_STATUSGenerator()
var acrDetails_STATUSGenerator gopter.Gen

// AcrDetails_STATUSGenerator returns a generator of AcrDetails_STATUS instances for property testing.
func AcrDetails_STATUSGenerator() gopter.Gen {
	if acrDetails_STATUSGenerator != nil {
		return acrDetails_STATUSGenerator
	}

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

	return acrDetails_STATUSGenerator
}

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

func Test_ArmResourceId_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from ArmResourceId to ArmResourceId via AssignProperties_To_ArmResourceId & AssignProperties_From_ArmResourceId returns original",
		prop.ForAll(RunPropertyAssignmentTestForArmResourceId, ArmResourceIdGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForArmResourceId tests if a specific instance of ArmResourceId can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForArmResourceId(subject ArmResourceId) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.ArmResourceId
	err := copied.AssignProperties_To_ArmResourceId(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual ArmResourceId
	err = actual.AssignProperties_From_ArmResourceId(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual ArmResourceId
	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 ArmResourceId instances for property testing - lazily instantiated by ArmResourceIdGenerator()
var armResourceIdGenerator gopter.Gen

// ArmResourceIdGenerator returns a generator of ArmResourceId instances for property testing.
func ArmResourceIdGenerator() gopter.Gen {
	if armResourceIdGenerator != nil {
		return armResourceIdGenerator
	}

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

	return armResourceIdGenerator
}

func Test_ArmResourceId_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from ArmResourceId_STATUS to ArmResourceId_STATUS via AssignProperties_To_ArmResourceId_STATUS & AssignProperties_From_ArmResourceId_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForArmResourceId_STATUS, ArmResourceId_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForArmResourceId_STATUS tests if a specific instance of ArmResourceId_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForArmResourceId_STATUS(subject ArmResourceId_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.ArmResourceId_STATUS
	err := copied.AssignProperties_To_ArmResourceId_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual ArmResourceId_STATUS
	err = actual.AssignProperties_From_ArmResourceId_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_ArmResourceId_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 ArmResourceId_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForArmResourceId_STATUS, ArmResourceId_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ArmResourceId_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 ArmResourceId_STATUS instances for property testing - lazily instantiated by
// ArmResourceId_STATUSGenerator()
var armResourceId_STATUSGenerator gopter.Gen

// ArmResourceId_STATUSGenerator returns a generator of ArmResourceId_STATUS instances for property testing.
func ArmResourceId_STATUSGenerator() gopter.Gen {
	if armResourceId_STATUSGenerator != nil {
		return armResourceId_STATUSGenerator
	}

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

	return armResourceId_STATUSGenerator
}

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

func Test_ManagedServiceIdentity_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from ManagedServiceIdentity to ManagedServiceIdentity via AssignProperties_To_ManagedServiceIdentity & AssignProperties_From_ManagedServiceIdentity returns original",
		prop.ForAll(RunPropertyAssignmentTestForManagedServiceIdentity, ManagedServiceIdentityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForManagedServiceIdentity tests if a specific instance of ManagedServiceIdentity can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForManagedServiceIdentity(subject ManagedServiceIdentity) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.ManagedServiceIdentity
	err := copied.AssignProperties_To_ManagedServiceIdentity(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual ManagedServiceIdentity
	err = actual.AssignProperties_From_ManagedServiceIdentity(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual ManagedServiceIdentity
	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 ManagedServiceIdentity instances for property testing - lazily instantiated by
// ManagedServiceIdentityGenerator()
var managedServiceIdentityGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedServiceIdentity(generators)
	AddRelatedPropertyGeneratorsForManagedServiceIdentity(generators)
	managedServiceIdentityGenerator = gen.Struct(reflect.TypeOf(ManagedServiceIdentity{}), generators)

	return managedServiceIdentityGenerator
}

// AddIndependentPropertyGeneratorsForManagedServiceIdentity is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedServiceIdentity(gens map[string]gopter.Gen) {
	gens["Type"] = gen.PtrOf(gen.OneConstOf(
		ManagedServiceIdentityType_None,
		ManagedServiceIdentityType_SystemAssigned,
		ManagedServiceIdentityType_SystemAssignedUserAssigned,
		ManagedServiceIdentityType_UserAssigned))
}

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

func Test_ManagedServiceIdentity_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from ManagedServiceIdentity_STATUS to ManagedServiceIdentity_STATUS via AssignProperties_To_ManagedServiceIdentity_STATUS & AssignProperties_From_ManagedServiceIdentity_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForManagedServiceIdentity_STATUS, ManagedServiceIdentity_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForManagedServiceIdentity_STATUS tests if a specific instance of ManagedServiceIdentity_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForManagedServiceIdentity_STATUS(subject ManagedServiceIdentity_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.ManagedServiceIdentity_STATUS
	err := copied.AssignProperties_To_ManagedServiceIdentity_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual ManagedServiceIdentity_STATUS
	err = actual.AssignProperties_From_ManagedServiceIdentity_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_ManagedServiceIdentity_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 ManagedServiceIdentity_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedServiceIdentity_STATUS, ManagedServiceIdentity_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ManagedServiceIdentity_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 ManagedServiceIdentity_STATUS instances for property testing - lazily instantiated by
// ManagedServiceIdentity_STATUSGenerator()
var managedServiceIdentity_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedServiceIdentity_STATUS(generators)
	AddRelatedPropertyGeneratorsForManagedServiceIdentity_STATUS(generators)
	managedServiceIdentity_STATUSGenerator = gen.Struct(reflect.TypeOf(ManagedServiceIdentity_STATUS{}), generators)

	return managedServiceIdentity_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForManagedServiceIdentity_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedServiceIdentity_STATUS(gens map[string]gopter.Gen) {
	gens["PrincipalId"] = gen.PtrOf(gen.AlphaString())
	gens["TenantId"] = gen.PtrOf(gen.AlphaString())
	gens["Type"] = gen.PtrOf(gen.OneConstOf(
		ManagedServiceIdentityType_STATUS_None,
		ManagedServiceIdentityType_STATUS_SystemAssigned,
		ManagedServiceIdentityType_STATUS_SystemAssignedUserAssigned,
		ManagedServiceIdentityType_STATUS_UserAssigned))
}

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

func Test_PrivateEndpointResource_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from PrivateEndpointResource to PrivateEndpointResource via AssignProperties_To_PrivateEndpointResource & AssignProperties_From_PrivateEndpointResource returns original",
		prop.ForAll(RunPropertyAssignmentTestForPrivateEndpointResource, PrivateEndpointResourceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForPrivateEndpointResource tests if a specific instance of PrivateEndpointResource can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForPrivateEndpointResource(subject PrivateEndpointResource) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.PrivateEndpointResource
	err := copied.AssignProperties_To_PrivateEndpointResource(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual PrivateEndpointResource
	err = actual.AssignProperties_From_PrivateEndpointResource(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual PrivateEndpointResource
	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 PrivateEndpointResource instances for property testing - lazily instantiated by
// PrivateEndpointResourceGenerator()
var privateEndpointResourceGenerator gopter.Gen

// PrivateEndpointResourceGenerator returns a generator of PrivateEndpointResource instances for property testing.
func PrivateEndpointResourceGenerator() gopter.Gen {
	if privateEndpointResourceGenerator != nil {
		return privateEndpointResourceGenerator
	}

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

	return privateEndpointResourceGenerator
}

func Test_PrivateEndpointResource_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from PrivateEndpointResource_STATUS to PrivateEndpointResource_STATUS via AssignProperties_To_PrivateEndpointResource_STATUS & AssignProperties_From_PrivateEndpointResource_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForPrivateEndpointResource_STATUS, PrivateEndpointResource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForPrivateEndpointResource_STATUS tests if a specific instance of PrivateEndpointResource_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForPrivateEndpointResource_STATUS(subject PrivateEndpointResource_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.PrivateEndpointResource_STATUS
	err := copied.AssignProperties_To_PrivateEndpointResource_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual PrivateEndpointResource_STATUS
	err = actual.AssignProperties_From_PrivateEndpointResource_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_PrivateEndpointResource_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 PrivateEndpointResource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrivateEndpointResource_STATUS, PrivateEndpointResource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PrivateEndpointResource_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 PrivateEndpointResource_STATUS instances for property testing - lazily instantiated by
// PrivateEndpointResource_STATUSGenerator()
var privateEndpointResource_STATUSGenerator gopter.Gen

// PrivateEndpointResource_STATUSGenerator returns a generator of PrivateEndpointResource_STATUS instances for property testing.
func PrivateEndpointResource_STATUSGenerator() gopter.Gen {
	if privateEndpointResource_STATUSGenerator != nil {
		return privateEndpointResource_STATUSGenerator
	}

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

	return privateEndpointResource_STATUSGenerator
}

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

func Test_Registry_WhenConvertedToHub_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	parameters.MinSuccessfulTests = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from Registry to hub returns original",
		prop.ForAll(RunResourceConversionTestForRegistry, RegistryGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunResourceConversionTestForRegistry tests if a specific instance of Registry round trips to the hub storage version and back losslessly
func RunResourceConversionTestForRegistry(subject Registry) string {
	// Copy subject to make sure conversion doesn't modify it
	copied := subject.DeepCopy()

	// Convert to our hub version
	var hub storage.Registry
	err := copied.ConvertTo(&hub)
	if err != nil {
		return err.Error()
	}

	// Convert from our hub version
	var actual Registry
	err = actual.ConvertFrom(&hub)
	if err != nil {
		return err.Error()
	}

	// Compare actual with what we started with
	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 ""
}

func Test_Registry_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from Registry to Registry via AssignProperties_To_Registry & AssignProperties_From_Registry returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistry, RegistryGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistry tests if a specific instance of Registry can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistry(subject Registry) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.Registry
	err := copied.AssignProperties_To_Registry(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual Registry
	err = actual.AssignProperties_From_Registry(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual Registry
	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 Registry instances for property testing - lazily instantiated by RegistryGenerator()
var registryGenerator gopter.Gen

// RegistryGenerator returns a generator of Registry instances for property testing.
func RegistryGenerator() gopter.Gen {
	if registryGenerator != nil {
		return registryGenerator
	}

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

	return registryGenerator
}

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

func Test_RegistryOperatorConfigMaps_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from RegistryOperatorConfigMaps to RegistryOperatorConfigMaps via AssignProperties_To_RegistryOperatorConfigMaps & AssignProperties_From_RegistryOperatorConfigMaps returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistryOperatorConfigMaps, RegistryOperatorConfigMapsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistryOperatorConfigMaps tests if a specific instance of RegistryOperatorConfigMaps can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistryOperatorConfigMaps(subject RegistryOperatorConfigMaps) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.RegistryOperatorConfigMaps
	err := copied.AssignProperties_To_RegistryOperatorConfigMaps(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual RegistryOperatorConfigMaps
	err = actual.AssignProperties_From_RegistryOperatorConfigMaps(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual RegistryOperatorConfigMaps
	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 RegistryOperatorConfigMaps instances for property testing - lazily instantiated by
// RegistryOperatorConfigMapsGenerator()
var registryOperatorConfigMapsGenerator gopter.Gen

// RegistryOperatorConfigMapsGenerator returns a generator of RegistryOperatorConfigMaps instances for property testing.
func RegistryOperatorConfigMapsGenerator() gopter.Gen {
	if registryOperatorConfigMapsGenerator != nil {
		return registryOperatorConfigMapsGenerator
	}

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

	return registryOperatorConfigMapsGenerator
}

func Test_RegistryOperatorSpec_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from RegistryOperatorSpec to RegistryOperatorSpec via AssignProperties_To_RegistryOperatorSpec & AssignProperties_From_RegistryOperatorSpec returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistryOperatorSpec, RegistryOperatorSpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistryOperatorSpec tests if a specific instance of RegistryOperatorSpec can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistryOperatorSpec(subject RegistryOperatorSpec) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.RegistryOperatorSpec
	err := copied.AssignProperties_To_RegistryOperatorSpec(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual RegistryOperatorSpec
	err = actual.AssignProperties_From_RegistryOperatorSpec(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual RegistryOperatorSpec
	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 RegistryOperatorSpec instances for property testing - lazily instantiated by
// RegistryOperatorSpecGenerator()
var registryOperatorSpecGenerator gopter.Gen

// RegistryOperatorSpecGenerator returns a generator of RegistryOperatorSpec instances for property testing.
func RegistryOperatorSpecGenerator() gopter.Gen {
	if registryOperatorSpecGenerator != nil {
		return registryOperatorSpecGenerator
	}

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

	return registryOperatorSpecGenerator
}

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

func Test_RegistryPrivateEndpointConnection_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from RegistryPrivateEndpointConnection to RegistryPrivateEndpointConnection via AssignProperties_To_RegistryPrivateEndpointConnection & AssignProperties_From_RegistryPrivateEndpointConnection returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistryPrivateEndpointConnection, RegistryPrivateEndpointConnectionGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistryPrivateEndpointConnection tests if a specific instance of RegistryPrivateEndpointConnection can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistryPrivateEndpointConnection(subject RegistryPrivateEndpointConnection) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.RegistryPrivateEndpointConnection
	err := copied.AssignProperties_To_RegistryPrivateEndpointConnection(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual RegistryPrivateEndpointConnection
	err = actual.AssignProperties_From_RegistryPrivateEndpointConnection(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual RegistryPrivateEndpointConnection
	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 RegistryPrivateEndpointConnection instances for property testing - lazily instantiated by
// RegistryPrivateEndpointConnectionGenerator()
var registryPrivateEndpointConnectionGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForRegistryPrivateEndpointConnection(generators)
	AddRelatedPropertyGeneratorsForRegistryPrivateEndpointConnection(generators)
	registryPrivateEndpointConnectionGenerator = gen.Struct(reflect.TypeOf(RegistryPrivateEndpointConnection{}), generators)

	return registryPrivateEndpointConnectionGenerator
}

// AddIndependentPropertyGeneratorsForRegistryPrivateEndpointConnection is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForRegistryPrivateEndpointConnection(gens map[string]gopter.Gen) {
	gens["GroupIds"] = gen.SliceOf(gen.AlphaString())
	gens["Location"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForRegistryPrivateEndpointConnection is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForRegistryPrivateEndpointConnection(gens map[string]gopter.Gen) {
	gens["PrivateEndpoint"] = gen.PtrOf(PrivateEndpointResourceGenerator())
	gens["RegistryPrivateLinkServiceConnectionState"] = gen.PtrOf(RegistryPrivateLinkServiceConnectionStateGenerator())
}

func Test_RegistryPrivateEndpointConnection_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from RegistryPrivateEndpointConnection_STATUS to RegistryPrivateEndpointConnection_STATUS via AssignProperties_To_RegistryPrivateEndpointConnection_STATUS & AssignProperties_From_RegistryPrivateEndpointConnection_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistryPrivateEndpointConnection_STATUS, RegistryPrivateEndpointConnection_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistryPrivateEndpointConnection_STATUS tests if a specific instance of RegistryPrivateEndpointConnection_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistryPrivateEndpointConnection_STATUS(subject RegistryPrivateEndpointConnection_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.RegistryPrivateEndpointConnection_STATUS
	err := copied.AssignProperties_To_RegistryPrivateEndpointConnection_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual RegistryPrivateEndpointConnection_STATUS
	err = actual.AssignProperties_From_RegistryPrivateEndpointConnection_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_RegistryPrivateEndpointConnection_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 RegistryPrivateEndpointConnection_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRegistryPrivateEndpointConnection_STATUS, RegistryPrivateEndpointConnection_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual RegistryPrivateEndpointConnection_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 RegistryPrivateEndpointConnection_STATUS instances for property testing - lazily instantiated by
// RegistryPrivateEndpointConnection_STATUSGenerator()
var registryPrivateEndpointConnection_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForRegistryPrivateEndpointConnection_STATUS(generators)
	AddRelatedPropertyGeneratorsForRegistryPrivateEndpointConnection_STATUS(generators)
	registryPrivateEndpointConnection_STATUSGenerator = gen.Struct(reflect.TypeOf(RegistryPrivateEndpointConnection_STATUS{}), generators)

	return registryPrivateEndpointConnection_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForRegistryPrivateEndpointConnection_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForRegistryPrivateEndpointConnection_STATUS(gens map[string]gopter.Gen) {
	gens["PrivateEndpoint"] = gen.PtrOf(PrivateEndpointResource_STATUSGenerator())
	gens["RegistryPrivateLinkServiceConnectionState"] = gen.PtrOf(RegistryPrivateLinkServiceConnectionState_STATUSGenerator())
}

func Test_RegistryPrivateLinkServiceConnectionState_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from RegistryPrivateLinkServiceConnectionState to RegistryPrivateLinkServiceConnectionState via AssignProperties_To_RegistryPrivateLinkServiceConnectionState & AssignProperties_From_RegistryPrivateLinkServiceConnectionState returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistryPrivateLinkServiceConnectionState, RegistryPrivateLinkServiceConnectionStateGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistryPrivateLinkServiceConnectionState tests if a specific instance of RegistryPrivateLinkServiceConnectionState can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistryPrivateLinkServiceConnectionState(subject RegistryPrivateLinkServiceConnectionState) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.RegistryPrivateLinkServiceConnectionState
	err := copied.AssignProperties_To_RegistryPrivateLinkServiceConnectionState(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual RegistryPrivateLinkServiceConnectionState
	err = actual.AssignProperties_From_RegistryPrivateLinkServiceConnectionState(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual RegistryPrivateLinkServiceConnectionState
	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 RegistryPrivateLinkServiceConnectionState instances for property testing - lazily instantiated by
// RegistryPrivateLinkServiceConnectionStateGenerator()
var registryPrivateLinkServiceConnectionStateGenerator gopter.Gen

// RegistryPrivateLinkServiceConnectionStateGenerator returns a generator of RegistryPrivateLinkServiceConnectionState instances for property testing.
func RegistryPrivateLinkServiceConnectionStateGenerator() gopter.Gen {
	if registryPrivateLinkServiceConnectionStateGenerator != nil {
		return registryPrivateLinkServiceConnectionStateGenerator
	}

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

	return registryPrivateLinkServiceConnectionStateGenerator
}

// AddIndependentPropertyGeneratorsForRegistryPrivateLinkServiceConnectionState is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForRegistryPrivateLinkServiceConnectionState(gens map[string]gopter.Gen) {
	gens["ActionsRequired"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["Status"] = gen.PtrOf(gen.OneConstOf(
		EndpointServiceConnectionStatus_Approved,
		EndpointServiceConnectionStatus_Disconnected,
		EndpointServiceConnectionStatus_Pending,
		EndpointServiceConnectionStatus_Rejected))
}

func Test_RegistryPrivateLinkServiceConnectionState_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from RegistryPrivateLinkServiceConnectionState_STATUS to RegistryPrivateLinkServiceConnectionState_STATUS via AssignProperties_To_RegistryPrivateLinkServiceConnectionState_STATUS & AssignProperties_From_RegistryPrivateLinkServiceConnectionState_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistryPrivateLinkServiceConnectionState_STATUS, RegistryPrivateLinkServiceConnectionState_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistryPrivateLinkServiceConnectionState_STATUS tests if a specific instance of RegistryPrivateLinkServiceConnectionState_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistryPrivateLinkServiceConnectionState_STATUS(subject RegistryPrivateLinkServiceConnectionState_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.RegistryPrivateLinkServiceConnectionState_STATUS
	err := copied.AssignProperties_To_RegistryPrivateLinkServiceConnectionState_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual RegistryPrivateLinkServiceConnectionState_STATUS
	err = actual.AssignProperties_From_RegistryPrivateLinkServiceConnectionState_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_RegistryPrivateLinkServiceConnectionState_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 RegistryPrivateLinkServiceConnectionState_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRegistryPrivateLinkServiceConnectionState_STATUS, RegistryPrivateLinkServiceConnectionState_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual RegistryPrivateLinkServiceConnectionState_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 RegistryPrivateLinkServiceConnectionState_STATUS instances for property testing - lazily instantiated by
// RegistryPrivateLinkServiceConnectionState_STATUSGenerator()
var registryPrivateLinkServiceConnectionState_STATUSGenerator gopter.Gen

// RegistryPrivateLinkServiceConnectionState_STATUSGenerator returns a generator of RegistryPrivateLinkServiceConnectionState_STATUS instances for property testing.
func RegistryPrivateLinkServiceConnectionState_STATUSGenerator() gopter.Gen {
	if registryPrivateLinkServiceConnectionState_STATUSGenerator != nil {
		return registryPrivateLinkServiceConnectionState_STATUSGenerator
	}

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

	return registryPrivateLinkServiceConnectionState_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForRegistryPrivateLinkServiceConnectionState_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForRegistryPrivateLinkServiceConnectionState_STATUS(gens map[string]gopter.Gen) {
	gens["ActionsRequired"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["Status"] = gen.PtrOf(gen.OneConstOf(
		EndpointServiceConnectionStatus_STATUS_Approved,
		EndpointServiceConnectionStatus_STATUS_Disconnected,
		EndpointServiceConnectionStatus_STATUS_Pending,
		EndpointServiceConnectionStatus_STATUS_Rejected))
}

func Test_RegistryRegionArmDetails_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from RegistryRegionArmDetails to RegistryRegionArmDetails via AssignProperties_To_RegistryRegionArmDetails & AssignProperties_From_RegistryRegionArmDetails returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistryRegionArmDetails, RegistryRegionArmDetailsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistryRegionArmDetails tests if a specific instance of RegistryRegionArmDetails can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistryRegionArmDetails(subject RegistryRegionArmDetails) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.RegistryRegionArmDetails
	err := copied.AssignProperties_To_RegistryRegionArmDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual RegistryRegionArmDetails
	err = actual.AssignProperties_From_RegistryRegionArmDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual RegistryRegionArmDetails
	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 RegistryRegionArmDetails instances for property testing - lazily instantiated by
// RegistryRegionArmDetailsGenerator()
var registryRegionArmDetailsGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForRegistryRegionArmDetails(generators)
	AddRelatedPropertyGeneratorsForRegistryRegionArmDetails(generators)
	registryRegionArmDetailsGenerator = gen.Struct(reflect.TypeOf(RegistryRegionArmDetails{}), generators)

	return registryRegionArmDetailsGenerator
}

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

// AddRelatedPropertyGeneratorsForRegistryRegionArmDetails is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForRegistryRegionArmDetails(gens map[string]gopter.Gen) {
	gens["AcrDetails"] = gen.SliceOf(AcrDetailsGenerator())
	gens["StorageAccountDetails"] = gen.SliceOf(StorageAccountDetailsGenerator())
}

func Test_RegistryRegionArmDetails_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from RegistryRegionArmDetails_STATUS to RegistryRegionArmDetails_STATUS via AssignProperties_To_RegistryRegionArmDetails_STATUS & AssignProperties_From_RegistryRegionArmDetails_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistryRegionArmDetails_STATUS, RegistryRegionArmDetails_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistryRegionArmDetails_STATUS tests if a specific instance of RegistryRegionArmDetails_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistryRegionArmDetails_STATUS(subject RegistryRegionArmDetails_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.RegistryRegionArmDetails_STATUS
	err := copied.AssignProperties_To_RegistryRegionArmDetails_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual RegistryRegionArmDetails_STATUS
	err = actual.AssignProperties_From_RegistryRegionArmDetails_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_RegistryRegionArmDetails_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 RegistryRegionArmDetails_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRegistryRegionArmDetails_STATUS, RegistryRegionArmDetails_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual RegistryRegionArmDetails_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 RegistryRegionArmDetails_STATUS instances for property testing - lazily instantiated by
// RegistryRegionArmDetails_STATUSGenerator()
var registryRegionArmDetails_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForRegistryRegionArmDetails_STATUS(generators)
	AddRelatedPropertyGeneratorsForRegistryRegionArmDetails_STATUS(generators)
	registryRegionArmDetails_STATUSGenerator = gen.Struct(reflect.TypeOf(RegistryRegionArmDetails_STATUS{}), generators)

	return registryRegionArmDetails_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForRegistryRegionArmDetails_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForRegistryRegionArmDetails_STATUS(gens map[string]gopter.Gen) {
	gens["AcrDetails"] = gen.SliceOf(AcrDetails_STATUSGenerator())
	gens["StorageAccountDetails"] = gen.SliceOf(StorageAccountDetails_STATUSGenerator())
}

func Test_RegistryTrackedResource_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from RegistryTrackedResource_STATUS to RegistryTrackedResource_STATUS via AssignProperties_To_RegistryTrackedResource_STATUS & AssignProperties_From_RegistryTrackedResource_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistryTrackedResource_STATUS, RegistryTrackedResource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistryTrackedResource_STATUS tests if a specific instance of RegistryTrackedResource_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistryTrackedResource_STATUS(subject RegistryTrackedResource_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.RegistryTrackedResource_STATUS
	err := copied.AssignProperties_To_RegistryTrackedResource_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual RegistryTrackedResource_STATUS
	err = actual.AssignProperties_From_RegistryTrackedResource_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_RegistryTrackedResource_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 RegistryTrackedResource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRegistryTrackedResource_STATUS, RegistryTrackedResource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual RegistryTrackedResource_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 RegistryTrackedResource_STATUS instances for property testing - lazily instantiated by
// RegistryTrackedResource_STATUSGenerator()
var registryTrackedResource_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForRegistryTrackedResource_STATUS(generators)
	AddRelatedPropertyGeneratorsForRegistryTrackedResource_STATUS(generators)
	registryTrackedResource_STATUSGenerator = gen.Struct(reflect.TypeOf(RegistryTrackedResource_STATUS{}), generators)

	return registryTrackedResource_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForRegistryTrackedResource_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForRegistryTrackedResource_STATUS(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(ManagedServiceIdentity_STATUSGenerator())
	gens["ManagedResourceGroup"] = gen.PtrOf(ArmResourceId_STATUSGenerator())
	gens["RegionDetails"] = gen.SliceOf(RegistryRegionArmDetails_STATUSGenerator())
	gens["RegistryPrivateEndpointConnections"] = gen.SliceOf(RegistryPrivateEndpointConnection_STATUSGenerator())
	gens["Sku"] = gen.PtrOf(Sku_STATUSGenerator())
	gens["SystemData"] = gen.PtrOf(SystemData_STATUSGenerator())
}

func Test_Registry_Spec_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from Registry_Spec to Registry_Spec via AssignProperties_To_Registry_Spec & AssignProperties_From_Registry_Spec returns original",
		prop.ForAll(RunPropertyAssignmentTestForRegistry_Spec, Registry_SpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForRegistry_Spec tests if a specific instance of Registry_Spec can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForRegistry_Spec(subject Registry_Spec) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.Registry_Spec
	err := copied.AssignProperties_To_Registry_Spec(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual Registry_Spec
	err = actual.AssignProperties_From_Registry_Spec(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

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

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

	return ""
}

// Generator of Registry_Spec instances for property testing - lazily instantiated by Registry_SpecGenerator()
var registry_SpecGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForRegistry_Spec(generators)
	AddRelatedPropertyGeneratorsForRegistry_Spec(generators)
	registry_SpecGenerator = gen.Struct(reflect.TypeOf(Registry_Spec{}), generators)

	return registry_SpecGenerator
}

// AddIndependentPropertyGeneratorsForRegistry_Spec is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForRegistry_Spec(gens map[string]gopter.Gen) {
	gens["AzureName"] = gen.AlphaString()
	gens["DiscoveryUrl"] = gen.PtrOf(gen.AlphaString())
	gens["IntellectualPropertyPublisher"] = gen.PtrOf(gen.AlphaString())
	gens["Kind"] = gen.PtrOf(gen.AlphaString())
	gens["Location"] = gen.PtrOf(gen.AlphaString())
	gens["MlFlowRegistryUri"] = gen.PtrOf(gen.AlphaString())
	gens["PublicNetworkAccess"] = gen.PtrOf(gen.AlphaString())
	gens["Tags"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForRegistry_Spec is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForRegistry_Spec(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(ManagedServiceIdentityGenerator())
	gens["ManagedResourceGroup"] = gen.PtrOf(ArmResourceIdGenerator())
	gens["OperatorSpec"] = gen.PtrOf(RegistryOperatorSpecGenerator())
	gens["RegionDetails"] = gen.SliceOf(RegistryRegionArmDetailsGenerator())
	gens["RegistryPrivateEndpointConnections"] = gen.SliceOf(RegistryPrivateEndpointConnectionGenerator())
	gens["Sku"] = gen.PtrOf(SkuGenerator())
}

func Test_Sku_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from Sku to Sku via AssignProperties_To_Sku & AssignProperties_From_Sku returns original",
		prop.ForAll(RunPropertyAssignmentTestForSku, SkuGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSku tests if a specific instance of Sku can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSku(subject Sku) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.Sku
	err := copied.AssignProperties_To_Sku(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual Sku
	err = actual.AssignProperties_From_Sku(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

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

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

	return ""
}

// Generator of Sku instances for property testing - lazily instantiated by SkuGenerator()
var skuGenerator gopter.Gen

// SkuGenerator returns a generator of Sku instances for property testing.
func SkuGenerator() gopter.Gen {
	if skuGenerator != nil {
		return skuGenerator
	}

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

	return skuGenerator
}

// AddIndependentPropertyGeneratorsForSku is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSku(gens map[string]gopter.Gen) {
	gens["Capacity"] = gen.PtrOf(gen.Int())
	gens["Family"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Size"] = gen.PtrOf(gen.AlphaString())
	gens["Tier"] = gen.PtrOf(gen.OneConstOf(
		SkuTier_Basic,
		SkuTier_Free,
		SkuTier_Premium,
		SkuTier_Standard))
}

func Test_Sku_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from Sku_STATUS to Sku_STATUS via AssignProperties_To_Sku_STATUS & AssignProperties_From_Sku_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForSku_STATUS, Sku_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSku_STATUS tests if a specific instance of Sku_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSku_STATUS(subject Sku_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.Sku_STATUS
	err := copied.AssignProperties_To_Sku_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual Sku_STATUS
	err = actual.AssignProperties_From_Sku_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

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

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

	return ""
}

// Generator of Sku_STATUS instances for property testing - lazily instantiated by Sku_STATUSGenerator()
var sku_STATUSGenerator gopter.Gen

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

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

	return sku_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSku_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSku_STATUS(gens map[string]gopter.Gen) {
	gens["Capacity"] = gen.PtrOf(gen.Int())
	gens["Family"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Size"] = gen.PtrOf(gen.AlphaString())
	gens["Tier"] = gen.PtrOf(gen.OneConstOf(
		SkuTier_STATUS_Basic,
		SkuTier_STATUS_Free,
		SkuTier_STATUS_Premium,
		SkuTier_STATUS_Standard))
}

func Test_StorageAccountDetails_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from StorageAccountDetails to StorageAccountDetails via AssignProperties_To_StorageAccountDetails & AssignProperties_From_StorageAccountDetails returns original",
		prop.ForAll(RunPropertyAssignmentTestForStorageAccountDetails, StorageAccountDetailsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForStorageAccountDetails tests if a specific instance of StorageAccountDetails can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForStorageAccountDetails(subject StorageAccountDetails) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.StorageAccountDetails
	err := copied.AssignProperties_To_StorageAccountDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual StorageAccountDetails
	err = actual.AssignProperties_From_StorageAccountDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual StorageAccountDetails
	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 StorageAccountDetails instances for property testing - lazily instantiated by
// StorageAccountDetailsGenerator()
var storageAccountDetailsGenerator gopter.Gen

// StorageAccountDetailsGenerator returns a generator of StorageAccountDetails instances for property testing.
func StorageAccountDetailsGenerator() gopter.Gen {
	if storageAccountDetailsGenerator != nil {
		return storageAccountDetailsGenerator
	}

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

	return storageAccountDetailsGenerator
}

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

func Test_StorageAccountDetails_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from StorageAccountDetails_STATUS to StorageAccountDetails_STATUS via AssignProperties_To_StorageAccountDetails_STATUS & AssignProperties_From_StorageAccountDetails_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForStorageAccountDetails_STATUS, StorageAccountDetails_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForStorageAccountDetails_STATUS tests if a specific instance of StorageAccountDetails_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForStorageAccountDetails_STATUS(subject StorageAccountDetails_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.StorageAccountDetails_STATUS
	err := copied.AssignProperties_To_StorageAccountDetails_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual StorageAccountDetails_STATUS
	err = actual.AssignProperties_From_StorageAccountDetails_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_StorageAccountDetails_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 StorageAccountDetails_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStorageAccountDetails_STATUS, StorageAccountDetails_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StorageAccountDetails_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 StorageAccountDetails_STATUS instances for property testing - lazily instantiated by
// StorageAccountDetails_STATUSGenerator()
var storageAccountDetails_STATUSGenerator gopter.Gen

// StorageAccountDetails_STATUSGenerator returns a generator of StorageAccountDetails_STATUS instances for property testing.
func StorageAccountDetails_STATUSGenerator() gopter.Gen {
	if storageAccountDetails_STATUSGenerator != nil {
		return storageAccountDetails_STATUSGenerator
	}

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

	return storageAccountDetails_STATUSGenerator
}

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

func Test_SystemCreatedAcrAccount_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SystemCreatedAcrAccount to SystemCreatedAcrAccount via AssignProperties_To_SystemCreatedAcrAccount & AssignProperties_From_SystemCreatedAcrAccount returns original",
		prop.ForAll(RunPropertyAssignmentTestForSystemCreatedAcrAccount, SystemCreatedAcrAccountGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSystemCreatedAcrAccount tests if a specific instance of SystemCreatedAcrAccount can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSystemCreatedAcrAccount(subject SystemCreatedAcrAccount) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.SystemCreatedAcrAccount
	err := copied.AssignProperties_To_SystemCreatedAcrAccount(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SystemCreatedAcrAccount
	err = actual.AssignProperties_From_SystemCreatedAcrAccount(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual SystemCreatedAcrAccount
	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 SystemCreatedAcrAccount instances for property testing - lazily instantiated by
// SystemCreatedAcrAccountGenerator()
var systemCreatedAcrAccountGenerator gopter.Gen

// SystemCreatedAcrAccountGenerator returns a generator of SystemCreatedAcrAccount instances for property testing.
func SystemCreatedAcrAccountGenerator() gopter.Gen {
	if systemCreatedAcrAccountGenerator != nil {
		return systemCreatedAcrAccountGenerator
	}

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

	return systemCreatedAcrAccountGenerator
}

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

func Test_SystemCreatedAcrAccount_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SystemCreatedAcrAccount_STATUS to SystemCreatedAcrAccount_STATUS via AssignProperties_To_SystemCreatedAcrAccount_STATUS & AssignProperties_From_SystemCreatedAcrAccount_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForSystemCreatedAcrAccount_STATUS, SystemCreatedAcrAccount_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSystemCreatedAcrAccount_STATUS tests if a specific instance of SystemCreatedAcrAccount_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSystemCreatedAcrAccount_STATUS(subject SystemCreatedAcrAccount_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.SystemCreatedAcrAccount_STATUS
	err := copied.AssignProperties_To_SystemCreatedAcrAccount_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SystemCreatedAcrAccount_STATUS
	err = actual.AssignProperties_From_SystemCreatedAcrAccount_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_SystemCreatedAcrAccount_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 SystemCreatedAcrAccount_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSystemCreatedAcrAccount_STATUS, SystemCreatedAcrAccount_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SystemCreatedAcrAccount_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 SystemCreatedAcrAccount_STATUS instances for property testing - lazily instantiated by
// SystemCreatedAcrAccount_STATUSGenerator()
var systemCreatedAcrAccount_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSystemCreatedAcrAccount_STATUS(generators)
	AddRelatedPropertyGeneratorsForSystemCreatedAcrAccount_STATUS(generators)
	systemCreatedAcrAccount_STATUSGenerator = gen.Struct(reflect.TypeOf(SystemCreatedAcrAccount_STATUS{}), generators)

	return systemCreatedAcrAccount_STATUSGenerator
}

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

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

func Test_SystemCreatedStorageAccount_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SystemCreatedStorageAccount to SystemCreatedStorageAccount via AssignProperties_To_SystemCreatedStorageAccount & AssignProperties_From_SystemCreatedStorageAccount returns original",
		prop.ForAll(RunPropertyAssignmentTestForSystemCreatedStorageAccount, SystemCreatedStorageAccountGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSystemCreatedStorageAccount tests if a specific instance of SystemCreatedStorageAccount can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSystemCreatedStorageAccount(subject SystemCreatedStorageAccount) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.SystemCreatedStorageAccount
	err := copied.AssignProperties_To_SystemCreatedStorageAccount(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SystemCreatedStorageAccount
	err = actual.AssignProperties_From_SystemCreatedStorageAccount(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual SystemCreatedStorageAccount
	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 SystemCreatedStorageAccount instances for property testing - lazily instantiated by
// SystemCreatedStorageAccountGenerator()
var systemCreatedStorageAccountGenerator gopter.Gen

// SystemCreatedStorageAccountGenerator returns a generator of SystemCreatedStorageAccount instances for property testing.
func SystemCreatedStorageAccountGenerator() gopter.Gen {
	if systemCreatedStorageAccountGenerator != nil {
		return systemCreatedStorageAccountGenerator
	}

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

	return systemCreatedStorageAccountGenerator
}

// AddIndependentPropertyGeneratorsForSystemCreatedStorageAccount is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSystemCreatedStorageAccount(gens map[string]gopter.Gen) {
	gens["AllowBlobPublicAccess"] = gen.PtrOf(gen.Bool())
	gens["StorageAccountHnsEnabled"] = gen.PtrOf(gen.Bool())
	gens["StorageAccountName"] = gen.PtrOf(gen.AlphaString())
	gens["StorageAccountType"] = gen.PtrOf(gen.AlphaString())
}

func Test_SystemCreatedStorageAccount_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SystemCreatedStorageAccount_STATUS to SystemCreatedStorageAccount_STATUS via AssignProperties_To_SystemCreatedStorageAccount_STATUS & AssignProperties_From_SystemCreatedStorageAccount_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForSystemCreatedStorageAccount_STATUS, SystemCreatedStorageAccount_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSystemCreatedStorageAccount_STATUS tests if a specific instance of SystemCreatedStorageAccount_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSystemCreatedStorageAccount_STATUS(subject SystemCreatedStorageAccount_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.SystemCreatedStorageAccount_STATUS
	err := copied.AssignProperties_To_SystemCreatedStorageAccount_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SystemCreatedStorageAccount_STATUS
	err = actual.AssignProperties_From_SystemCreatedStorageAccount_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_SystemCreatedStorageAccount_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 SystemCreatedStorageAccount_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSystemCreatedStorageAccount_STATUS, SystemCreatedStorageAccount_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SystemCreatedStorageAccount_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 SystemCreatedStorageAccount_STATUS instances for property testing - lazily instantiated by
// SystemCreatedStorageAccount_STATUSGenerator()
var systemCreatedStorageAccount_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSystemCreatedStorageAccount_STATUS(generators)
	AddRelatedPropertyGeneratorsForSystemCreatedStorageAccount_STATUS(generators)
	systemCreatedStorageAccount_STATUSGenerator = gen.Struct(reflect.TypeOf(SystemCreatedStorageAccount_STATUS{}), generators)

	return systemCreatedStorageAccount_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSystemCreatedStorageAccount_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSystemCreatedStorageAccount_STATUS(gens map[string]gopter.Gen) {
	gens["AllowBlobPublicAccess"] = gen.PtrOf(gen.Bool())
	gens["StorageAccountHnsEnabled"] = gen.PtrOf(gen.Bool())
	gens["StorageAccountName"] = gen.PtrOf(gen.AlphaString())
	gens["StorageAccountType"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_SystemData_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SystemData_STATUS to SystemData_STATUS via AssignProperties_To_SystemData_STATUS & AssignProperties_From_SystemData_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForSystemData_STATUS, SystemData_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSystemData_STATUS tests if a specific instance of SystemData_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSystemData_STATUS(subject SystemData_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.SystemData_STATUS
	err := copied.AssignProperties_To_SystemData_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SystemData_STATUS
	err = actual.AssignProperties_From_SystemData_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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_UserAssignedIdentityDetails_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from UserAssignedIdentityDetails to UserAssignedIdentityDetails via AssignProperties_To_UserAssignedIdentityDetails & AssignProperties_From_UserAssignedIdentityDetails returns original",
		prop.ForAll(RunPropertyAssignmentTestForUserAssignedIdentityDetails, UserAssignedIdentityDetailsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForUserAssignedIdentityDetails tests if a specific instance of UserAssignedIdentityDetails can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForUserAssignedIdentityDetails(subject UserAssignedIdentityDetails) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.UserAssignedIdentityDetails
	err := copied.AssignProperties_To_UserAssignedIdentityDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual UserAssignedIdentityDetails
	err = actual.AssignProperties_From_UserAssignedIdentityDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

	// Deserialize back into memory
	var actual UserAssignedIdentityDetails
	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 UserAssignedIdentityDetails instances for property testing - lazily instantiated by
// UserAssignedIdentityDetailsGenerator()
var userAssignedIdentityDetailsGenerator gopter.Gen

// UserAssignedIdentityDetailsGenerator returns a generator of UserAssignedIdentityDetails instances for property testing.
func UserAssignedIdentityDetailsGenerator() gopter.Gen {
	if userAssignedIdentityDetailsGenerator != nil {
		return userAssignedIdentityDetailsGenerator
	}

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

	return userAssignedIdentityDetailsGenerator
}

func Test_UserAssignedIdentity_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from UserAssignedIdentity_STATUS to UserAssignedIdentity_STATUS via AssignProperties_To_UserAssignedIdentity_STATUS & AssignProperties_From_UserAssignedIdentity_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForUserAssignedIdentity_STATUS, UserAssignedIdentity_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForUserAssignedIdentity_STATUS tests if a specific instance of UserAssignedIdentity_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForUserAssignedIdentity_STATUS(subject UserAssignedIdentity_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.UserAssignedIdentity_STATUS
	err := copied.AssignProperties_To_UserAssignedIdentity_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual UserAssignedIdentity_STATUS
	err = actual.AssignProperties_From_UserAssignedIdentity_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

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

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

	return ""
}

// Generator of UserAssignedIdentity_STATUS instances for property testing - lazily instantiated by
// UserAssignedIdentity_STATUSGenerator()
var userAssignedIdentity_STATUSGenerator gopter.Gen

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

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

	return userAssignedIdentity_STATUSGenerator
}

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