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

import (
	"encoding/json"
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/kr/pretty"
	"github.com/kylelemons/godebug/diff"
	"github.com/leanovate/gopter"
	"github.com/leanovate/gopter/gen"
	"github.com/leanovate/gopter/prop"
	"os"
	"reflect"
	"testing"
)

func Test_FlowLogFormatParameters_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 FlowLogFormatParameters via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForFlowLogFormatParameters, FlowLogFormatParametersGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// FlowLogFormatParametersGenerator returns a generator of FlowLogFormatParameters instances for property testing.
func FlowLogFormatParametersGenerator() gopter.Gen {
	if flowLogFormatParametersGenerator != nil {
		return flowLogFormatParametersGenerator
	}

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

	return flowLogFormatParametersGenerator
}

// AddIndependentPropertyGeneratorsForFlowLogFormatParameters is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForFlowLogFormatParameters(gens map[string]gopter.Gen) {
	gens["Type"] = gen.PtrOf(gen.OneConstOf(FlowLogFormatParameters_Type_JSON))
	gens["Version"] = gen.PtrOf(gen.Int())
}

func Test_FlowLogPropertiesFormat_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 FlowLogPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForFlowLogPropertiesFormat, FlowLogPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForFlowLogPropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForFlowLogPropertiesFormat(generators)
	flowLogPropertiesFormatGenerator = gen.Struct(reflect.TypeOf(FlowLogPropertiesFormat{}), generators)

	return flowLogPropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForFlowLogPropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForFlowLogPropertiesFormat(gens map[string]gopter.Gen) {
	gens["Enabled"] = gen.PtrOf(gen.Bool())
	gens["EnabledFilteringCriteria"] = gen.PtrOf(gen.AlphaString())
	gens["StorageId"] = gen.PtrOf(gen.AlphaString())
	gens["TargetResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForFlowLogPropertiesFormat is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForFlowLogPropertiesFormat(gens map[string]gopter.Gen) {
	gens["FlowAnalyticsConfiguration"] = gen.PtrOf(TrafficAnalyticsPropertiesGenerator())
	gens["Format"] = gen.PtrOf(FlowLogFormatParametersGenerator())
	gens["RetentionPolicy"] = gen.PtrOf(RetentionPolicyParametersGenerator())
}

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(
		ManagedServiceIdentity_Type_None,
		ManagedServiceIdentity_Type_SystemAssigned,
		ManagedServiceIdentity_Type_SystemAssignedUserAssigned,
		ManagedServiceIdentity_Type_UserAssigned))
}

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

func Test_NetworkWatchersFlowLog_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 NetworkWatchersFlowLog_Spec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNetworkWatchersFlowLog_Spec, NetworkWatchersFlowLog_SpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NetworkWatchersFlowLog_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 NetworkWatchersFlowLog_Spec instances for property testing - lazily instantiated by
// NetworkWatchersFlowLog_SpecGenerator()
var networkWatchersFlowLog_SpecGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNetworkWatchersFlowLog_Spec(generators)
	AddRelatedPropertyGeneratorsForNetworkWatchersFlowLog_Spec(generators)
	networkWatchersFlowLog_SpecGenerator = gen.Struct(reflect.TypeOf(NetworkWatchersFlowLog_Spec{}), generators)

	return networkWatchersFlowLog_SpecGenerator
}

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

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

func Test_RetentionPolicyParameters_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 RetentionPolicyParameters via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRetentionPolicyParameters, RetentionPolicyParametersGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// RetentionPolicyParametersGenerator returns a generator of RetentionPolicyParameters instances for property testing.
func RetentionPolicyParametersGenerator() gopter.Gen {
	if retentionPolicyParametersGenerator != nil {
		return retentionPolicyParametersGenerator
	}

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

	return retentionPolicyParametersGenerator
}

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

func Test_TrafficAnalyticsConfigurationProperties_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 TrafficAnalyticsConfigurationProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTrafficAnalyticsConfigurationProperties, TrafficAnalyticsConfigurationPropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// TrafficAnalyticsConfigurationPropertiesGenerator returns a generator of TrafficAnalyticsConfigurationProperties instances for property testing.
func TrafficAnalyticsConfigurationPropertiesGenerator() gopter.Gen {
	if trafficAnalyticsConfigurationPropertiesGenerator != nil {
		return trafficAnalyticsConfigurationPropertiesGenerator
	}

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

	return trafficAnalyticsConfigurationPropertiesGenerator
}

// AddIndependentPropertyGeneratorsForTrafficAnalyticsConfigurationProperties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForTrafficAnalyticsConfigurationProperties(gens map[string]gopter.Gen) {
	gens["Enabled"] = gen.PtrOf(gen.Bool())
	gens["TrafficAnalyticsInterval"] = gen.PtrOf(gen.Int())
	gens["WorkspaceRegion"] = gen.PtrOf(gen.AlphaString())
	gens["WorkspaceResourceId"] = gen.PtrOf(gen.AlphaString())
}

func Test_TrafficAnalyticsProperties_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 TrafficAnalyticsProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTrafficAnalyticsProperties, TrafficAnalyticsPropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// TrafficAnalyticsPropertiesGenerator returns a generator of TrafficAnalyticsProperties instances for property testing.
func TrafficAnalyticsPropertiesGenerator() gopter.Gen {
	if trafficAnalyticsPropertiesGenerator != nil {
		return trafficAnalyticsPropertiesGenerator
	}

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

	return trafficAnalyticsPropertiesGenerator
}

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

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
}
