// 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_AdvancedNetworking_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 AdvancedNetworking via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAdvancedNetworking, AdvancedNetworkingGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// AdvancedNetworkingGenerator returns a generator of AdvancedNetworking instances for property testing.
func AdvancedNetworkingGenerator() gopter.Gen {
	if advancedNetworkingGenerator != nil {
		return advancedNetworkingGenerator
	}

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

	return advancedNetworkingGenerator
}

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

func Test_AdvancedNetworkingObservability_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 AdvancedNetworkingObservability via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAdvancedNetworkingObservability, AdvancedNetworkingObservabilityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// AdvancedNetworkingObservabilityGenerator returns a generator of AdvancedNetworkingObservability instances for property testing.
func AdvancedNetworkingObservabilityGenerator() gopter.Gen {
	if advancedNetworkingObservabilityGenerator != nil {
		return advancedNetworkingObservabilityGenerator
	}

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

	return advancedNetworkingObservabilityGenerator
}

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

func Test_AzureKeyVaultKms_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 AzureKeyVaultKms via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAzureKeyVaultKms, AzureKeyVaultKmsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// AzureKeyVaultKmsGenerator returns a generator of AzureKeyVaultKms instances for property testing.
func AzureKeyVaultKmsGenerator() gopter.Gen {
	if azureKeyVaultKmsGenerator != nil {
		return azureKeyVaultKmsGenerator
	}

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

	return azureKeyVaultKmsGenerator
}

// AddIndependentPropertyGeneratorsForAzureKeyVaultKms is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAzureKeyVaultKms(gens map[string]gopter.Gen) {
	gens["Enabled"] = gen.PtrOf(gen.Bool())
	gens["KeyId"] = gen.PtrOf(gen.AlphaString())
	gens["KeyVaultNetworkAccess"] = gen.PtrOf(gen.OneConstOf(AzureKeyVaultKms_KeyVaultNetworkAccess_Private, AzureKeyVaultKms_KeyVaultNetworkAccess_Public))
	gens["KeyVaultResourceId"] = gen.PtrOf(gen.AlphaString())
}

func Test_ClusterUpgradeSettings_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 ClusterUpgradeSettings via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForClusterUpgradeSettings, ClusterUpgradeSettingsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ClusterUpgradeSettingsGenerator returns a generator of ClusterUpgradeSettings instances for property testing.
func ClusterUpgradeSettingsGenerator() gopter.Gen {
	if clusterUpgradeSettingsGenerator != nil {
		return clusterUpgradeSettingsGenerator
	}

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

	return clusterUpgradeSettingsGenerator
}

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

func Test_ContainerServiceLinuxProfile_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 ContainerServiceLinuxProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerServiceLinuxProfile, ContainerServiceLinuxProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainerServiceLinuxProfile(generators)
	AddRelatedPropertyGeneratorsForContainerServiceLinuxProfile(generators)
	containerServiceLinuxProfileGenerator = gen.Struct(reflect.TypeOf(ContainerServiceLinuxProfile{}), generators)

	return containerServiceLinuxProfileGenerator
}

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

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

func Test_ContainerServiceNetworkProfile_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 ContainerServiceNetworkProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerServiceNetworkProfile, ContainerServiceNetworkProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainerServiceNetworkProfile(generators)
	AddRelatedPropertyGeneratorsForContainerServiceNetworkProfile(generators)
	containerServiceNetworkProfileGenerator = gen.Struct(reflect.TypeOf(ContainerServiceNetworkProfile{}), generators)

	return containerServiceNetworkProfileGenerator
}

// AddIndependentPropertyGeneratorsForContainerServiceNetworkProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainerServiceNetworkProfile(gens map[string]gopter.Gen) {
	gens["DnsServiceIP"] = gen.PtrOf(gen.AlphaString())
	gens["IpFamilies"] = gen.SliceOf(gen.OneConstOf(IpFamily_IPv4, IpFamily_IPv6))
	gens["LoadBalancerSku"] = gen.PtrOf(gen.OneConstOf(LoadBalancerSku_Basic, LoadBalancerSku_Standard))
	gens["NetworkDataplane"] = gen.PtrOf(gen.OneConstOf(NetworkDataplane_Azure, NetworkDataplane_Cilium))
	gens["NetworkMode"] = gen.PtrOf(gen.OneConstOf(NetworkMode_Bridge, NetworkMode_Transparent))
	gens["NetworkPlugin"] = gen.PtrOf(gen.OneConstOf(NetworkPlugin_Azure, NetworkPlugin_Kubenet, NetworkPlugin_None))
	gens["NetworkPluginMode"] = gen.PtrOf(gen.OneConstOf(NetworkPluginMode_Overlay))
	gens["NetworkPolicy"] = gen.PtrOf(gen.OneConstOf(
		NetworkPolicy_Azure,
		NetworkPolicy_Calico,
		NetworkPolicy_Cilium,
		NetworkPolicy_None))
	gens["OutboundType"] = gen.PtrOf(gen.OneConstOf(
		ContainerServiceNetworkProfile_OutboundType_LoadBalancer,
		ContainerServiceNetworkProfile_OutboundType_ManagedNATGateway,
		ContainerServiceNetworkProfile_OutboundType_None,
		ContainerServiceNetworkProfile_OutboundType_UserAssignedNATGateway,
		ContainerServiceNetworkProfile_OutboundType_UserDefinedRouting))
	gens["PodCidr"] = gen.PtrOf(gen.AlphaString())
	gens["PodCidrs"] = gen.SliceOf(gen.AlphaString())
	gens["PodLinkLocalAccess"] = gen.PtrOf(gen.OneConstOf(PodLinkLocalAccess_IMDS, PodLinkLocalAccess_None))
	gens["ServiceCidr"] = gen.PtrOf(gen.AlphaString())
	gens["ServiceCidrs"] = gen.SliceOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForContainerServiceNetworkProfile is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForContainerServiceNetworkProfile(gens map[string]gopter.Gen) {
	gens["AdvancedNetworking"] = gen.PtrOf(AdvancedNetworkingGenerator())
	gens["KubeProxyConfig"] = gen.PtrOf(ContainerServiceNetworkProfile_KubeProxyConfigGenerator())
	gens["LoadBalancerProfile"] = gen.PtrOf(ManagedClusterLoadBalancerProfileGenerator())
	gens["NatGatewayProfile"] = gen.PtrOf(ManagedClusterNATGatewayProfileGenerator())
	gens["StaticEgressGatewayProfile"] = gen.PtrOf(ManagedClusterStaticEgressGatewayProfileGenerator())
}

func Test_ContainerServiceNetworkProfile_KubeProxyConfig_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 ContainerServiceNetworkProfile_KubeProxyConfig via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerServiceNetworkProfile_KubeProxyConfig, ContainerServiceNetworkProfile_KubeProxyConfigGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainerServiceNetworkProfile_KubeProxyConfig(generators)
	AddRelatedPropertyGeneratorsForContainerServiceNetworkProfile_KubeProxyConfig(generators)
	containerServiceNetworkProfile_KubeProxyConfigGenerator = gen.Struct(reflect.TypeOf(ContainerServiceNetworkProfile_KubeProxyConfig{}), generators)

	return containerServiceNetworkProfile_KubeProxyConfigGenerator
}

// AddIndependentPropertyGeneratorsForContainerServiceNetworkProfile_KubeProxyConfig is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainerServiceNetworkProfile_KubeProxyConfig(gens map[string]gopter.Gen) {
	gens["Enabled"] = gen.PtrOf(gen.Bool())
	gens["Mode"] = gen.PtrOf(gen.OneConstOf(ContainerServiceNetworkProfile_KubeProxyConfig_Mode_IPTABLES, ContainerServiceNetworkProfile_KubeProxyConfig_Mode_IPVS))
}

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

func Test_ContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfig_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 ContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfig via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfig, ContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfigGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfigGenerator returns a generator of ContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfig instances for property testing.
func ContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfigGenerator() gopter.Gen {
	if containerServiceNetworkProfile_KubeProxyConfig_IpvsConfigGenerator != nil {
		return containerServiceNetworkProfile_KubeProxyConfig_IpvsConfigGenerator
	}

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

	return containerServiceNetworkProfile_KubeProxyConfig_IpvsConfigGenerator
}

// AddIndependentPropertyGeneratorsForContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfig is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfig(gens map[string]gopter.Gen) {
	gens["Scheduler"] = gen.PtrOf(gen.OneConstOf(ContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfig_Scheduler_LeastConnection, ContainerServiceNetworkProfile_KubeProxyConfig_IpvsConfig_Scheduler_RoundRobin))
	gens["TcpFinTimeoutSeconds"] = gen.PtrOf(gen.Int())
	gens["TcpTimeoutSeconds"] = gen.PtrOf(gen.Int())
	gens["UdpTimeoutSeconds"] = gen.PtrOf(gen.Int())
}

func Test_ContainerServiceSshConfiguration_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 ContainerServiceSshConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerServiceSshConfiguration, ContainerServiceSshConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ContainerServiceSshConfigurationGenerator returns a generator of ContainerServiceSshConfiguration instances for property testing.
func ContainerServiceSshConfigurationGenerator() gopter.Gen {
	if containerServiceSshConfigurationGenerator != nil {
		return containerServiceSshConfigurationGenerator
	}

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

	return containerServiceSshConfigurationGenerator
}

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

func Test_ContainerServiceSshPublicKey_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 ContainerServiceSshPublicKey via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerServiceSshPublicKey, ContainerServiceSshPublicKeyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ContainerServiceSshPublicKeyGenerator returns a generator of ContainerServiceSshPublicKey instances for property testing.
func ContainerServiceSshPublicKeyGenerator() gopter.Gen {
	if containerServiceSshPublicKeyGenerator != nil {
		return containerServiceSshPublicKeyGenerator
	}

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

	return containerServiceSshPublicKeyGenerator
}

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

func Test_CreationData_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 CreationData via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCreationData, CreationDataGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// CreationDataGenerator returns a generator of CreationData instances for property testing.
func CreationDataGenerator() gopter.Gen {
	if creationDataGenerator != nil {
		return creationDataGenerator
	}

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

	return creationDataGenerator
}

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

func Test_DelegatedResource_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 DelegatedResource via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDelegatedResource, DelegatedResourceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// DelegatedResourceGenerator returns a generator of DelegatedResource instances for property testing.
func DelegatedResourceGenerator() gopter.Gen {
	if delegatedResourceGenerator != nil {
		return delegatedResourceGenerator
	}

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

	return delegatedResourceGenerator
}

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

func Test_ExtendedLocation_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 ExtendedLocation via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForExtendedLocation, ExtendedLocationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ExtendedLocationGenerator returns a generator of ExtendedLocation instances for property testing.
func ExtendedLocationGenerator() gopter.Gen {
	if extendedLocationGenerator != nil {
		return extendedLocationGenerator
	}

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

	return extendedLocationGenerator
}

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

func Test_IstioCertificateAuthority_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 IstioCertificateAuthority via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIstioCertificateAuthority, IstioCertificateAuthorityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// IstioCertificateAuthorityGenerator returns a generator of IstioCertificateAuthority instances for property testing.
func IstioCertificateAuthorityGenerator() gopter.Gen {
	if istioCertificateAuthorityGenerator != nil {
		return istioCertificateAuthorityGenerator
	}

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

	return istioCertificateAuthorityGenerator
}

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

func Test_IstioComponents_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 IstioComponents via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIstioComponents, IstioComponentsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// IstioComponentsGenerator returns a generator of IstioComponents instances for property testing.
func IstioComponentsGenerator() gopter.Gen {
	if istioComponentsGenerator != nil {
		return istioComponentsGenerator
	}

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

	return istioComponentsGenerator
}

// AddRelatedPropertyGeneratorsForIstioComponents is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForIstioComponents(gens map[string]gopter.Gen) {
	gens["EgressGateways"] = gen.SliceOf(IstioEgressGatewayGenerator())
	gens["IngressGateways"] = gen.SliceOf(IstioIngressGatewayGenerator())
}

func Test_IstioEgressGateway_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 IstioEgressGateway via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIstioEgressGateway, IstioEgressGatewayGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// IstioEgressGatewayGenerator returns a generator of IstioEgressGateway instances for property testing.
func IstioEgressGatewayGenerator() gopter.Gen {
	if istioEgressGatewayGenerator != nil {
		return istioEgressGatewayGenerator
	}

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

	return istioEgressGatewayGenerator
}

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

func Test_IstioIngressGateway_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 IstioIngressGateway via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIstioIngressGateway, IstioIngressGatewayGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// IstioIngressGatewayGenerator returns a generator of IstioIngressGateway instances for property testing.
func IstioIngressGatewayGenerator() gopter.Gen {
	if istioIngressGatewayGenerator != nil {
		return istioIngressGatewayGenerator
	}

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

	return istioIngressGatewayGenerator
}

// AddIndependentPropertyGeneratorsForIstioIngressGateway is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIstioIngressGateway(gens map[string]gopter.Gen) {
	gens["Enabled"] = gen.PtrOf(gen.Bool())
	gens["Mode"] = gen.PtrOf(gen.OneConstOf(IstioIngressGateway_Mode_External, IstioIngressGateway_Mode_Internal))
}

func Test_IstioPluginCertificateAuthority_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 IstioPluginCertificateAuthority via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIstioPluginCertificateAuthority, IstioPluginCertificateAuthorityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// IstioPluginCertificateAuthorityGenerator returns a generator of IstioPluginCertificateAuthority instances for property testing.
func IstioPluginCertificateAuthorityGenerator() gopter.Gen {
	if istioPluginCertificateAuthorityGenerator != nil {
		return istioPluginCertificateAuthorityGenerator
	}

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

	return istioPluginCertificateAuthorityGenerator
}

// AddIndependentPropertyGeneratorsForIstioPluginCertificateAuthority is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIstioPluginCertificateAuthority(gens map[string]gopter.Gen) {
	gens["CertChainObjectName"] = gen.PtrOf(gen.AlphaString())
	gens["CertObjectName"] = gen.PtrOf(gen.AlphaString())
	gens["KeyObjectName"] = gen.PtrOf(gen.AlphaString())
	gens["KeyVaultId"] = gen.PtrOf(gen.AlphaString())
	gens["RootCertObjectName"] = gen.PtrOf(gen.AlphaString())
}

func Test_IstioServiceMesh_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 IstioServiceMesh via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIstioServiceMesh, IstioServiceMeshGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIstioServiceMesh(generators)
	AddRelatedPropertyGeneratorsForIstioServiceMesh(generators)
	istioServiceMeshGenerator = gen.Struct(reflect.TypeOf(IstioServiceMesh{}), generators)

	return istioServiceMeshGenerator
}

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

// AddRelatedPropertyGeneratorsForIstioServiceMesh is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForIstioServiceMesh(gens map[string]gopter.Gen) {
	gens["CertificateAuthority"] = gen.PtrOf(IstioCertificateAuthorityGenerator())
	gens["Components"] = gen.PtrOf(IstioComponentsGenerator())
}

func Test_ManagedClusterAADProfile_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 ManagedClusterAADProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAADProfile, ManagedClusterAADProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAADProfileGenerator returns a generator of ManagedClusterAADProfile instances for property testing.
func ManagedClusterAADProfileGenerator() gopter.Gen {
	if managedClusterAADProfileGenerator != nil {
		return managedClusterAADProfileGenerator
	}

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

	return managedClusterAADProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterAADProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterAADProfile(gens map[string]gopter.Gen) {
	gens["AdminGroupObjectIDs"] = gen.SliceOf(gen.AlphaString())
	gens["ClientAppID"] = gen.PtrOf(gen.AlphaString())
	gens["EnableAzureRBAC"] = gen.PtrOf(gen.Bool())
	gens["Managed"] = gen.PtrOf(gen.Bool())
	gens["ServerAppID"] = gen.PtrOf(gen.AlphaString())
	gens["ServerAppSecret"] = gen.PtrOf(gen.AlphaString())
	gens["TenantID"] = gen.PtrOf(gen.AlphaString())
}

func Test_ManagedClusterAIToolchainOperatorProfile_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 ManagedClusterAIToolchainOperatorProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAIToolchainOperatorProfile, ManagedClusterAIToolchainOperatorProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAIToolchainOperatorProfileGenerator returns a generator of ManagedClusterAIToolchainOperatorProfile instances for property testing.
func ManagedClusterAIToolchainOperatorProfileGenerator() gopter.Gen {
	if managedClusterAIToolchainOperatorProfileGenerator != nil {
		return managedClusterAIToolchainOperatorProfileGenerator
	}

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

	return managedClusterAIToolchainOperatorProfileGenerator
}

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

func Test_ManagedClusterAPIServerAccessProfile_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 ManagedClusterAPIServerAccessProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAPIServerAccessProfile, ManagedClusterAPIServerAccessProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAPIServerAccessProfileGenerator returns a generator of ManagedClusterAPIServerAccessProfile instances for property testing.
func ManagedClusterAPIServerAccessProfileGenerator() gopter.Gen {
	if managedClusterAPIServerAccessProfileGenerator != nil {
		return managedClusterAPIServerAccessProfileGenerator
	}

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

	return managedClusterAPIServerAccessProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterAPIServerAccessProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterAPIServerAccessProfile(gens map[string]gopter.Gen) {
	gens["AuthorizedIPRanges"] = gen.SliceOf(gen.AlphaString())
	gens["DisableRunCommand"] = gen.PtrOf(gen.Bool())
	gens["EnablePrivateCluster"] = gen.PtrOf(gen.Bool())
	gens["EnablePrivateClusterPublicFQDN"] = gen.PtrOf(gen.Bool())
	gens["EnableVnetIntegration"] = gen.PtrOf(gen.Bool())
	gens["PrivateDNSZone"] = gen.PtrOf(gen.AlphaString())
	gens["SubnetId"] = gen.PtrOf(gen.AlphaString())
}

func Test_ManagedClusterAddonProfile_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 ManagedClusterAddonProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAddonProfile, ManagedClusterAddonProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAddonProfileGenerator returns a generator of ManagedClusterAddonProfile instances for property testing.
func ManagedClusterAddonProfileGenerator() gopter.Gen {
	if managedClusterAddonProfileGenerator != nil {
		return managedClusterAddonProfileGenerator
	}

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

	return managedClusterAddonProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterAddonProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterAddonProfile(gens map[string]gopter.Gen) {
	gens["Config"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["Enabled"] = gen.PtrOf(gen.Bool())
}

func Test_ManagedClusterAgentPoolProfile_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 ManagedClusterAgentPoolProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAgentPoolProfile, ManagedClusterAgentPoolProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAgentPoolProfileGenerator returns a generator of ManagedClusterAgentPoolProfile instances for property testing.
func ManagedClusterAgentPoolProfileGenerator() gopter.Gen {
	if managedClusterAgentPoolProfileGenerator != nil {
		return managedClusterAgentPoolProfileGenerator
	}

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

	return managedClusterAgentPoolProfileGenerator
}

// AddRelatedPropertyGeneratorsForManagedClusterAgentPoolProfile is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedClusterAgentPoolProfile(gens map[string]gopter.Gen) {
	gens["ArtifactStreamingProfile"] = gen.PtrOf(AgentPoolArtifactStreamingProfileGenerator())
	gens["CreationData"] = gen.PtrOf(CreationDataGenerator())
	gens["GatewayProfile"] = gen.PtrOf(AgentPoolGatewayProfileGenerator())
	gens["GpuProfile"] = gen.PtrOf(AgentPoolGPUProfileGenerator())
	gens["KubeletConfig"] = gen.PtrOf(KubeletConfigGenerator())
	gens["LinuxOSConfig"] = gen.PtrOf(LinuxOSConfigGenerator())
	gens["NetworkProfile"] = gen.PtrOf(AgentPoolNetworkProfileGenerator())
	gens["PowerState"] = gen.PtrOf(PowerStateGenerator())
	gens["SecurityProfile"] = gen.PtrOf(AgentPoolSecurityProfileGenerator())
	gens["UpgradeSettings"] = gen.PtrOf(AgentPoolUpgradeSettingsGenerator())
	gens["VirtualMachineNodesStatus"] = gen.SliceOf(VirtualMachineNodesGenerator())
	gens["VirtualMachinesProfile"] = gen.PtrOf(VirtualMachinesProfileGenerator())
	gens["WindowsProfile"] = gen.PtrOf(AgentPoolWindowsProfileGenerator())
}

func Test_ManagedClusterAutoUpgradeProfile_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 ManagedClusterAutoUpgradeProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAutoUpgradeProfile, ManagedClusterAutoUpgradeProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAutoUpgradeProfileGenerator returns a generator of ManagedClusterAutoUpgradeProfile instances for property testing.
func ManagedClusterAutoUpgradeProfileGenerator() gopter.Gen {
	if managedClusterAutoUpgradeProfileGenerator != nil {
		return managedClusterAutoUpgradeProfileGenerator
	}

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

	return managedClusterAutoUpgradeProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterAutoUpgradeProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterAutoUpgradeProfile(gens map[string]gopter.Gen) {
	gens["NodeOSUpgradeChannel"] = gen.PtrOf(gen.OneConstOf(
		ManagedClusterAutoUpgradeProfile_NodeOSUpgradeChannel_NodeImage,
		ManagedClusterAutoUpgradeProfile_NodeOSUpgradeChannel_None,
		ManagedClusterAutoUpgradeProfile_NodeOSUpgradeChannel_SecurityPatch,
		ManagedClusterAutoUpgradeProfile_NodeOSUpgradeChannel_Unmanaged))
	gens["UpgradeChannel"] = gen.PtrOf(gen.OneConstOf(
		ManagedClusterAutoUpgradeProfile_UpgradeChannel_NodeImage,
		ManagedClusterAutoUpgradeProfile_UpgradeChannel_None,
		ManagedClusterAutoUpgradeProfile_UpgradeChannel_Patch,
		ManagedClusterAutoUpgradeProfile_UpgradeChannel_Rapid,
		ManagedClusterAutoUpgradeProfile_UpgradeChannel_Stable))
}

func Test_ManagedClusterAzureMonitorProfile_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 ManagedClusterAzureMonitorProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAzureMonitorProfile, ManagedClusterAzureMonitorProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAzureMonitorProfileGenerator returns a generator of ManagedClusterAzureMonitorProfile instances for property testing.
func ManagedClusterAzureMonitorProfileGenerator() gopter.Gen {
	if managedClusterAzureMonitorProfileGenerator != nil {
		return managedClusterAzureMonitorProfileGenerator
	}

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

	return managedClusterAzureMonitorProfileGenerator
}

// AddRelatedPropertyGeneratorsForManagedClusterAzureMonitorProfile is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedClusterAzureMonitorProfile(gens map[string]gopter.Gen) {
	gens["AppMonitoring"] = gen.PtrOf(ManagedClusterAzureMonitorProfileAppMonitoringGenerator())
	gens["ContainerInsights"] = gen.PtrOf(ManagedClusterAzureMonitorProfileContainerInsightsGenerator())
	gens["Metrics"] = gen.PtrOf(ManagedClusterAzureMonitorProfileMetricsGenerator())
}

func Test_ManagedClusterAzureMonitorProfileAppMonitoring_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 ManagedClusterAzureMonitorProfileAppMonitoring via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAzureMonitorProfileAppMonitoring, ManagedClusterAzureMonitorProfileAppMonitoringGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAzureMonitorProfileAppMonitoringGenerator returns a generator of ManagedClusterAzureMonitorProfileAppMonitoring instances for property testing.
func ManagedClusterAzureMonitorProfileAppMonitoringGenerator() gopter.Gen {
	if managedClusterAzureMonitorProfileAppMonitoringGenerator != nil {
		return managedClusterAzureMonitorProfileAppMonitoringGenerator
	}

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

	return managedClusterAzureMonitorProfileAppMonitoringGenerator
}

// AddRelatedPropertyGeneratorsForManagedClusterAzureMonitorProfileAppMonitoring is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedClusterAzureMonitorProfileAppMonitoring(gens map[string]gopter.Gen) {
	gens["AutoInstrumentation"] = gen.PtrOf(ManagedClusterAzureMonitorProfileAppMonitoringAutoInstrumentationGenerator())
	gens["OpenTelemetryLogs"] = gen.PtrOf(ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogsGenerator())
	gens["OpenTelemetryMetrics"] = gen.PtrOf(ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetricsGenerator())
}

func Test_ManagedClusterAzureMonitorProfileAppMonitoringAutoInstrumentation_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 ManagedClusterAzureMonitorProfileAppMonitoringAutoInstrumentation via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAzureMonitorProfileAppMonitoringAutoInstrumentation, ManagedClusterAzureMonitorProfileAppMonitoringAutoInstrumentationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAzureMonitorProfileAppMonitoringAutoInstrumentationGenerator returns a generator of ManagedClusterAzureMonitorProfileAppMonitoringAutoInstrumentation instances for property testing.
func ManagedClusterAzureMonitorProfileAppMonitoringAutoInstrumentationGenerator() gopter.Gen {
	if managedClusterAzureMonitorProfileAppMonitoringAutoInstrumentationGenerator != nil {
		return managedClusterAzureMonitorProfileAppMonitoringAutoInstrumentationGenerator
	}

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

	return managedClusterAzureMonitorProfileAppMonitoringAutoInstrumentationGenerator
}

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

func Test_ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogs_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 ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogs via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogs, ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogsGenerator returns a generator of ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogs instances for property testing.
func ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogsGenerator() gopter.Gen {
	if managedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogsGenerator != nil {
		return managedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogsGenerator
	}

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

	return managedClusterAzureMonitorProfileAppMonitoringOpenTelemetryLogsGenerator
}

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

func Test_ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetrics_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 ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetrics via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetrics, ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetricsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetricsGenerator returns a generator of ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetrics instances for property testing.
func ManagedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetricsGenerator() gopter.Gen {
	if managedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetricsGenerator != nil {
		return managedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetricsGenerator
	}

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

	return managedClusterAzureMonitorProfileAppMonitoringOpenTelemetryMetricsGenerator
}

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

func Test_ManagedClusterAzureMonitorProfileContainerInsights_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 ManagedClusterAzureMonitorProfileContainerInsights via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAzureMonitorProfileContainerInsights, ManagedClusterAzureMonitorProfileContainerInsightsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAzureMonitorProfileContainerInsightsGenerator returns a generator of ManagedClusterAzureMonitorProfileContainerInsights instances for property testing.
func ManagedClusterAzureMonitorProfileContainerInsightsGenerator() gopter.Gen {
	if managedClusterAzureMonitorProfileContainerInsightsGenerator != nil {
		return managedClusterAzureMonitorProfileContainerInsightsGenerator
	}

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

	return managedClusterAzureMonitorProfileContainerInsightsGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterAzureMonitorProfileContainerInsights is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterAzureMonitorProfileContainerInsights(gens map[string]gopter.Gen) {
	gens["DisableCustomMetrics"] = gen.PtrOf(gen.Bool())
	gens["DisablePrometheusMetricsScraping"] = gen.PtrOf(gen.Bool())
	gens["Enabled"] = gen.PtrOf(gen.Bool())
	gens["LogAnalyticsWorkspaceResourceId"] = gen.PtrOf(gen.AlphaString())
	gens["SyslogPort"] = gen.PtrOf(gen.Int())
}

func Test_ManagedClusterAzureMonitorProfileKubeStateMetrics_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 ManagedClusterAzureMonitorProfileKubeStateMetrics via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAzureMonitorProfileKubeStateMetrics, ManagedClusterAzureMonitorProfileKubeStateMetricsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterAzureMonitorProfileKubeStateMetricsGenerator returns a generator of ManagedClusterAzureMonitorProfileKubeStateMetrics instances for property testing.
func ManagedClusterAzureMonitorProfileKubeStateMetricsGenerator() gopter.Gen {
	if managedClusterAzureMonitorProfileKubeStateMetricsGenerator != nil {
		return managedClusterAzureMonitorProfileKubeStateMetricsGenerator
	}

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

	return managedClusterAzureMonitorProfileKubeStateMetricsGenerator
}

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

func Test_ManagedClusterAzureMonitorProfileMetrics_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 ManagedClusterAzureMonitorProfileMetrics via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterAzureMonitorProfileMetrics, ManagedClusterAzureMonitorProfileMetricsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterAzureMonitorProfileMetrics(generators)
	AddRelatedPropertyGeneratorsForManagedClusterAzureMonitorProfileMetrics(generators)
	managedClusterAzureMonitorProfileMetricsGenerator = gen.Struct(reflect.TypeOf(ManagedClusterAzureMonitorProfileMetrics{}), generators)

	return managedClusterAzureMonitorProfileMetricsGenerator
}

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

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

func Test_ManagedClusterBootstrapProfile_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 ManagedClusterBootstrapProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterBootstrapProfile, ManagedClusterBootstrapProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterBootstrapProfileGenerator returns a generator of ManagedClusterBootstrapProfile instances for property testing.
func ManagedClusterBootstrapProfileGenerator() gopter.Gen {
	if managedClusterBootstrapProfileGenerator != nil {
		return managedClusterBootstrapProfileGenerator
	}

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

	return managedClusterBootstrapProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterBootstrapProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterBootstrapProfile(gens map[string]gopter.Gen) {
	gens["ArtifactSource"] = gen.PtrOf(gen.OneConstOf(ManagedClusterBootstrapProfile_ArtifactSource_Cache, ManagedClusterBootstrapProfile_ArtifactSource_Direct))
	gens["ContainerRegistryId"] = gen.PtrOf(gen.AlphaString())
}

func Test_ManagedClusterCostAnalysis_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 ManagedClusterCostAnalysis via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterCostAnalysis, ManagedClusterCostAnalysisGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterCostAnalysisGenerator returns a generator of ManagedClusterCostAnalysis instances for property testing.
func ManagedClusterCostAnalysisGenerator() gopter.Gen {
	if managedClusterCostAnalysisGenerator != nil {
		return managedClusterCostAnalysisGenerator
	}

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

	return managedClusterCostAnalysisGenerator
}

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

func Test_ManagedClusterHTTPProxyConfig_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 ManagedClusterHTTPProxyConfig via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterHTTPProxyConfig, ManagedClusterHTTPProxyConfigGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterHTTPProxyConfigGenerator returns a generator of ManagedClusterHTTPProxyConfig instances for property testing.
func ManagedClusterHTTPProxyConfigGenerator() gopter.Gen {
	if managedClusterHTTPProxyConfigGenerator != nil {
		return managedClusterHTTPProxyConfigGenerator
	}

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

	return managedClusterHTTPProxyConfigGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterHTTPProxyConfig is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterHTTPProxyConfig(gens map[string]gopter.Gen) {
	gens["HttpProxy"] = gen.PtrOf(gen.AlphaString())
	gens["HttpsProxy"] = gen.PtrOf(gen.AlphaString())
	gens["NoProxy"] = gen.SliceOf(gen.AlphaString())
	gens["TrustedCa"] = gen.PtrOf(gen.AlphaString())
}

func Test_ManagedClusterIdentity_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 ManagedClusterIdentity via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterIdentity, ManagedClusterIdentityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterIdentity(generators)
	AddRelatedPropertyGeneratorsForManagedClusterIdentity(generators)
	managedClusterIdentityGenerator = gen.Struct(reflect.TypeOf(ManagedClusterIdentity{}), generators)

	return managedClusterIdentityGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterIdentity is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterIdentity(gens map[string]gopter.Gen) {
	gens["Type"] = gen.PtrOf(gen.OneConstOf(ManagedClusterIdentity_Type_None, ManagedClusterIdentity_Type_SystemAssigned, ManagedClusterIdentity_Type_UserAssigned))
}

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

func Test_ManagedClusterIngressProfile_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 ManagedClusterIngressProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterIngressProfile, ManagedClusterIngressProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterIngressProfileGenerator returns a generator of ManagedClusterIngressProfile instances for property testing.
func ManagedClusterIngressProfileGenerator() gopter.Gen {
	if managedClusterIngressProfileGenerator != nil {
		return managedClusterIngressProfileGenerator
	}

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

	return managedClusterIngressProfileGenerator
}

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

func Test_ManagedClusterIngressProfileWebAppRouting_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 ManagedClusterIngressProfileWebAppRouting via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterIngressProfileWebAppRouting, ManagedClusterIngressProfileWebAppRoutingGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterIngressProfileWebAppRoutingGenerator returns a generator of ManagedClusterIngressProfileWebAppRouting instances for property testing.
func ManagedClusterIngressProfileWebAppRoutingGenerator() gopter.Gen {
	if managedClusterIngressProfileWebAppRoutingGenerator != nil {
		return managedClusterIngressProfileWebAppRoutingGenerator
	}

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

	return managedClusterIngressProfileWebAppRoutingGenerator
}

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

func Test_ManagedClusterLoadBalancerProfile_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 ManagedClusterLoadBalancerProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterLoadBalancerProfile, ManagedClusterLoadBalancerProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterLoadBalancerProfile(generators)
	AddRelatedPropertyGeneratorsForManagedClusterLoadBalancerProfile(generators)
	managedClusterLoadBalancerProfileGenerator = gen.Struct(reflect.TypeOf(ManagedClusterLoadBalancerProfile{}), generators)

	return managedClusterLoadBalancerProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterLoadBalancerProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterLoadBalancerProfile(gens map[string]gopter.Gen) {
	gens["AllocatedOutboundPorts"] = gen.PtrOf(gen.Int())
	gens["BackendPoolType"] = gen.PtrOf(gen.OneConstOf(ManagedClusterLoadBalancerProfile_BackendPoolType_NodeIP, ManagedClusterLoadBalancerProfile_BackendPoolType_NodeIPConfiguration))
	gens["ClusterServiceLoadBalancerHealthProbeMode"] = gen.PtrOf(gen.OneConstOf(ManagedClusterLoadBalancerProfile_ClusterServiceLoadBalancerHealthProbeMode_ServiceNodePort, ManagedClusterLoadBalancerProfile_ClusterServiceLoadBalancerHealthProbeMode_Shared))
	gens["EnableMultipleStandardLoadBalancers"] = gen.PtrOf(gen.Bool())
	gens["IdleTimeoutInMinutes"] = gen.PtrOf(gen.Int())
}

// AddRelatedPropertyGeneratorsForManagedClusterLoadBalancerProfile is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedClusterLoadBalancerProfile(gens map[string]gopter.Gen) {
	gens["EffectiveOutboundIPs"] = gen.SliceOf(ResourceReferenceGenerator())
	gens["ManagedOutboundIPs"] = gen.PtrOf(ManagedClusterLoadBalancerProfile_ManagedOutboundIPsGenerator())
	gens["OutboundIPPrefixes"] = gen.PtrOf(ManagedClusterLoadBalancerProfile_OutboundIPPrefixesGenerator())
	gens["OutboundIPs"] = gen.PtrOf(ManagedClusterLoadBalancerProfile_OutboundIPsGenerator())
}

func Test_ManagedClusterLoadBalancerProfile_ManagedOutboundIPs_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 ManagedClusterLoadBalancerProfile_ManagedOutboundIPs via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterLoadBalancerProfile_ManagedOutboundIPs, ManagedClusterLoadBalancerProfile_ManagedOutboundIPsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterLoadBalancerProfile_ManagedOutboundIPsGenerator returns a generator of ManagedClusterLoadBalancerProfile_ManagedOutboundIPs instances for property testing.
func ManagedClusterLoadBalancerProfile_ManagedOutboundIPsGenerator() gopter.Gen {
	if managedClusterLoadBalancerProfile_ManagedOutboundIPsGenerator != nil {
		return managedClusterLoadBalancerProfile_ManagedOutboundIPsGenerator
	}

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

	return managedClusterLoadBalancerProfile_ManagedOutboundIPsGenerator
}

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

func Test_ManagedClusterLoadBalancerProfile_OutboundIPPrefixes_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 ManagedClusterLoadBalancerProfile_OutboundIPPrefixes via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterLoadBalancerProfile_OutboundIPPrefixes, ManagedClusterLoadBalancerProfile_OutboundIPPrefixesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterLoadBalancerProfile_OutboundIPPrefixesGenerator returns a generator of ManagedClusterLoadBalancerProfile_OutboundIPPrefixes instances for property testing.
func ManagedClusterLoadBalancerProfile_OutboundIPPrefixesGenerator() gopter.Gen {
	if managedClusterLoadBalancerProfile_OutboundIPPrefixesGenerator != nil {
		return managedClusterLoadBalancerProfile_OutboundIPPrefixesGenerator
	}

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

	return managedClusterLoadBalancerProfile_OutboundIPPrefixesGenerator
}

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

func Test_ManagedClusterLoadBalancerProfile_OutboundIPs_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 ManagedClusterLoadBalancerProfile_OutboundIPs via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterLoadBalancerProfile_OutboundIPs, ManagedClusterLoadBalancerProfile_OutboundIPsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterLoadBalancerProfile_OutboundIPsGenerator returns a generator of ManagedClusterLoadBalancerProfile_OutboundIPs instances for property testing.
func ManagedClusterLoadBalancerProfile_OutboundIPsGenerator() gopter.Gen {
	if managedClusterLoadBalancerProfile_OutboundIPsGenerator != nil {
		return managedClusterLoadBalancerProfile_OutboundIPsGenerator
	}

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

	return managedClusterLoadBalancerProfile_OutboundIPsGenerator
}

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

func Test_ManagedClusterManagedOutboundIPProfile_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 ManagedClusterManagedOutboundIPProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterManagedOutboundIPProfile, ManagedClusterManagedOutboundIPProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterManagedOutboundIPProfileGenerator returns a generator of ManagedClusterManagedOutboundIPProfile instances for property testing.
func ManagedClusterManagedOutboundIPProfileGenerator() gopter.Gen {
	if managedClusterManagedOutboundIPProfileGenerator != nil {
		return managedClusterManagedOutboundIPProfileGenerator
	}

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

	return managedClusterManagedOutboundIPProfileGenerator
}

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

func Test_ManagedClusterMetricsProfile_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 ManagedClusterMetricsProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterMetricsProfile, ManagedClusterMetricsProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterMetricsProfileGenerator returns a generator of ManagedClusterMetricsProfile instances for property testing.
func ManagedClusterMetricsProfileGenerator() gopter.Gen {
	if managedClusterMetricsProfileGenerator != nil {
		return managedClusterMetricsProfileGenerator
	}

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

	return managedClusterMetricsProfileGenerator
}

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

func Test_ManagedClusterNATGatewayProfile_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 ManagedClusterNATGatewayProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterNATGatewayProfile, ManagedClusterNATGatewayProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterNATGatewayProfile(generators)
	AddRelatedPropertyGeneratorsForManagedClusterNATGatewayProfile(generators)
	managedClusterNATGatewayProfileGenerator = gen.Struct(reflect.TypeOf(ManagedClusterNATGatewayProfile{}), generators)

	return managedClusterNATGatewayProfileGenerator
}

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

// AddRelatedPropertyGeneratorsForManagedClusterNATGatewayProfile is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedClusterNATGatewayProfile(gens map[string]gopter.Gen) {
	gens["EffectiveOutboundIPs"] = gen.SliceOf(ResourceReferenceGenerator())
	gens["ManagedOutboundIPProfile"] = gen.PtrOf(ManagedClusterManagedOutboundIPProfileGenerator())
}

func Test_ManagedClusterNodeProvisioningProfile_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 ManagedClusterNodeProvisioningProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterNodeProvisioningProfile, ManagedClusterNodeProvisioningProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterNodeProvisioningProfileGenerator returns a generator of ManagedClusterNodeProvisioningProfile instances for property testing.
func ManagedClusterNodeProvisioningProfileGenerator() gopter.Gen {
	if managedClusterNodeProvisioningProfileGenerator != nil {
		return managedClusterNodeProvisioningProfileGenerator
	}

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

	return managedClusterNodeProvisioningProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterNodeProvisioningProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterNodeProvisioningProfile(gens map[string]gopter.Gen) {
	gens["Mode"] = gen.PtrOf(gen.OneConstOf(ManagedClusterNodeProvisioningProfile_Mode_Auto, ManagedClusterNodeProvisioningProfile_Mode_Manual))
}

func Test_ManagedClusterNodeResourceGroupProfile_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 ManagedClusterNodeResourceGroupProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterNodeResourceGroupProfile, ManagedClusterNodeResourceGroupProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterNodeResourceGroupProfileGenerator returns a generator of ManagedClusterNodeResourceGroupProfile instances for property testing.
func ManagedClusterNodeResourceGroupProfileGenerator() gopter.Gen {
	if managedClusterNodeResourceGroupProfileGenerator != nil {
		return managedClusterNodeResourceGroupProfileGenerator
	}

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

	return managedClusterNodeResourceGroupProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterNodeResourceGroupProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterNodeResourceGroupProfile(gens map[string]gopter.Gen) {
	gens["RestrictionLevel"] = gen.PtrOf(gen.OneConstOf(ManagedClusterNodeResourceGroupProfile_RestrictionLevel_ReadOnly, ManagedClusterNodeResourceGroupProfile_RestrictionLevel_Unrestricted))
}

func Test_ManagedClusterOIDCIssuerProfile_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 ManagedClusterOIDCIssuerProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterOIDCIssuerProfile, ManagedClusterOIDCIssuerProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterOIDCIssuerProfileGenerator returns a generator of ManagedClusterOIDCIssuerProfile instances for property testing.
func ManagedClusterOIDCIssuerProfileGenerator() gopter.Gen {
	if managedClusterOIDCIssuerProfileGenerator != nil {
		return managedClusterOIDCIssuerProfileGenerator
	}

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

	return managedClusterOIDCIssuerProfileGenerator
}

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

func Test_ManagedClusterPodIdentity_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 ManagedClusterPodIdentity via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterPodIdentity, ManagedClusterPodIdentityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterPodIdentity(generators)
	AddRelatedPropertyGeneratorsForManagedClusterPodIdentity(generators)
	managedClusterPodIdentityGenerator = gen.Struct(reflect.TypeOf(ManagedClusterPodIdentity{}), generators)

	return managedClusterPodIdentityGenerator
}

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

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

func Test_ManagedClusterPodIdentityException_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 ManagedClusterPodIdentityException via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterPodIdentityException, ManagedClusterPodIdentityExceptionGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterPodIdentityExceptionGenerator returns a generator of ManagedClusterPodIdentityException instances for property testing.
func ManagedClusterPodIdentityExceptionGenerator() gopter.Gen {
	if managedClusterPodIdentityExceptionGenerator != nil {
		return managedClusterPodIdentityExceptionGenerator
	}

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

	return managedClusterPodIdentityExceptionGenerator
}

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

func Test_ManagedClusterPodIdentityProfile_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 ManagedClusterPodIdentityProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterPodIdentityProfile, ManagedClusterPodIdentityProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterPodIdentityProfile(generators)
	AddRelatedPropertyGeneratorsForManagedClusterPodIdentityProfile(generators)
	managedClusterPodIdentityProfileGenerator = gen.Struct(reflect.TypeOf(ManagedClusterPodIdentityProfile{}), generators)

	return managedClusterPodIdentityProfileGenerator
}

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

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

func Test_ManagedClusterProperties_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 ManagedClusterProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterProperties, ManagedClusterPropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterProperties(generators)
	AddRelatedPropertyGeneratorsForManagedClusterProperties(generators)
	managedClusterPropertiesGenerator = gen.Struct(reflect.TypeOf(ManagedClusterProperties{}), generators)

	return managedClusterPropertiesGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterProperties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterProperties(gens map[string]gopter.Gen) {
	gens["DisableLocalAccounts"] = gen.PtrOf(gen.Bool())
	gens["DiskEncryptionSetID"] = gen.PtrOf(gen.AlphaString())
	gens["DnsPrefix"] = gen.PtrOf(gen.AlphaString())
	gens["EnableNamespaceResources"] = gen.PtrOf(gen.Bool())
	gens["EnablePodSecurityPolicy"] = gen.PtrOf(gen.Bool())
	gens["EnableRBAC"] = gen.PtrOf(gen.Bool())
	gens["FqdnSubdomain"] = gen.PtrOf(gen.AlphaString())
	gens["KubernetesVersion"] = gen.PtrOf(gen.AlphaString())
	gens["NodeResourceGroup"] = gen.PtrOf(gen.AlphaString())
	gens["PublicNetworkAccess"] = gen.PtrOf(gen.OneConstOf(ManagedClusterProperties_PublicNetworkAccess_Disabled, ManagedClusterProperties_PublicNetworkAccess_Enabled, ManagedClusterProperties_PublicNetworkAccess_SecuredByPerimeter))
	gens["SupportPlan"] = gen.PtrOf(gen.OneConstOf(KubernetesSupportPlan_AKSLongTermSupport, KubernetesSupportPlan_KubernetesOfficial))
}

// AddRelatedPropertyGeneratorsForManagedClusterProperties is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedClusterProperties(gens map[string]gopter.Gen) {
	gens["AadProfile"] = gen.PtrOf(ManagedClusterAADProfileGenerator())
	gens["AddonProfiles"] = gen.MapOf(
		gen.AlphaString(),
		ManagedClusterAddonProfileGenerator())
	gens["AgentPoolProfiles"] = gen.SliceOf(ManagedClusterAgentPoolProfileGenerator())
	gens["AiToolchainOperatorProfile"] = gen.PtrOf(ManagedClusterAIToolchainOperatorProfileGenerator())
	gens["ApiServerAccessProfile"] = gen.PtrOf(ManagedClusterAPIServerAccessProfileGenerator())
	gens["AutoScalerProfile"] = gen.PtrOf(ManagedClusterProperties_AutoScalerProfileGenerator())
	gens["AutoUpgradeProfile"] = gen.PtrOf(ManagedClusterAutoUpgradeProfileGenerator())
	gens["AzureMonitorProfile"] = gen.PtrOf(ManagedClusterAzureMonitorProfileGenerator())
	gens["BootstrapProfile"] = gen.PtrOf(ManagedClusterBootstrapProfileGenerator())
	gens["CreationData"] = gen.PtrOf(CreationDataGenerator())
	gens["HttpProxyConfig"] = gen.PtrOf(ManagedClusterHTTPProxyConfigGenerator())
	gens["IdentityProfile"] = gen.MapOf(
		gen.AlphaString(),
		UserAssignedIdentityGenerator())
	gens["IngressProfile"] = gen.PtrOf(ManagedClusterIngressProfileGenerator())
	gens["LinuxProfile"] = gen.PtrOf(ContainerServiceLinuxProfileGenerator())
	gens["MetricsProfile"] = gen.PtrOf(ManagedClusterMetricsProfileGenerator())
	gens["NetworkProfile"] = gen.PtrOf(ContainerServiceNetworkProfileGenerator())
	gens["NodeProvisioningProfile"] = gen.PtrOf(ManagedClusterNodeProvisioningProfileGenerator())
	gens["NodeResourceGroupProfile"] = gen.PtrOf(ManagedClusterNodeResourceGroupProfileGenerator())
	gens["OidcIssuerProfile"] = gen.PtrOf(ManagedClusterOIDCIssuerProfileGenerator())
	gens["PodIdentityProfile"] = gen.PtrOf(ManagedClusterPodIdentityProfileGenerator())
	gens["PrivateLinkResources"] = gen.SliceOf(PrivateLinkResourceGenerator())
	gens["SafeguardsProfile"] = gen.PtrOf(SafeguardsProfileGenerator())
	gens["SecurityProfile"] = gen.PtrOf(ManagedClusterSecurityProfileGenerator())
	gens["ServiceMeshProfile"] = gen.PtrOf(ServiceMeshProfileGenerator())
	gens["ServicePrincipalProfile"] = gen.PtrOf(ManagedClusterServicePrincipalProfileGenerator())
	gens["StorageProfile"] = gen.PtrOf(ManagedClusterStorageProfileGenerator())
	gens["UpgradeSettings"] = gen.PtrOf(ClusterUpgradeSettingsGenerator())
	gens["WindowsProfile"] = gen.PtrOf(ManagedClusterWindowsProfileGenerator())
	gens["WorkloadAutoScalerProfile"] = gen.PtrOf(ManagedClusterWorkloadAutoScalerProfileGenerator())
}

func Test_ManagedClusterProperties_AutoScalerProfile_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 ManagedClusterProperties_AutoScalerProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterProperties_AutoScalerProfile, ManagedClusterProperties_AutoScalerProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterProperties_AutoScalerProfileGenerator returns a generator of ManagedClusterProperties_AutoScalerProfile instances for property testing.
func ManagedClusterProperties_AutoScalerProfileGenerator() gopter.Gen {
	if managedClusterProperties_AutoScalerProfileGenerator != nil {
		return managedClusterProperties_AutoScalerProfileGenerator
	}

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

	return managedClusterProperties_AutoScalerProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterProperties_AutoScalerProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterProperties_AutoScalerProfile(gens map[string]gopter.Gen) {
	gens["BalanceSimilarNodeGroups"] = gen.PtrOf(gen.AlphaString())
	gens["DaemonsetEvictionForEmptyNodes"] = gen.PtrOf(gen.Bool())
	gens["DaemonsetEvictionForOccupiedNodes"] = gen.PtrOf(gen.Bool())
	gens["Expander"] = gen.PtrOf(gen.OneConstOf(
		Expander_LeastWaste,
		Expander_MostPods,
		Expander_Priority,
		Expander_Random))
	gens["IgnoreDaemonsetsUtilization"] = gen.PtrOf(gen.Bool())
	gens["MaxEmptyBulkDelete"] = gen.PtrOf(gen.AlphaString())
	gens["MaxGracefulTerminationSec"] = gen.PtrOf(gen.AlphaString())
	gens["MaxNodeProvisionTime"] = gen.PtrOf(gen.AlphaString())
	gens["MaxTotalUnreadyPercentage"] = gen.PtrOf(gen.AlphaString())
	gens["NewPodScaleUpDelay"] = gen.PtrOf(gen.AlphaString())
	gens["OkTotalUnreadyCount"] = gen.PtrOf(gen.AlphaString())
	gens["ScaleDownDelayAfterAdd"] = gen.PtrOf(gen.AlphaString())
	gens["ScaleDownDelayAfterDelete"] = gen.PtrOf(gen.AlphaString())
	gens["ScaleDownDelayAfterFailure"] = gen.PtrOf(gen.AlphaString())
	gens["ScaleDownUnneededTime"] = gen.PtrOf(gen.AlphaString())
	gens["ScaleDownUnreadyTime"] = gen.PtrOf(gen.AlphaString())
	gens["ScaleDownUtilizationThreshold"] = gen.PtrOf(gen.AlphaString())
	gens["ScanInterval"] = gen.PtrOf(gen.AlphaString())
	gens["SkipNodesWithLocalStorage"] = gen.PtrOf(gen.AlphaString())
	gens["SkipNodesWithSystemPods"] = gen.PtrOf(gen.AlphaString())
}

func Test_ManagedClusterSKU_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 ManagedClusterSKU via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterSKU, ManagedClusterSKUGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterSKUGenerator returns a generator of ManagedClusterSKU instances for property testing.
func ManagedClusterSKUGenerator() gopter.Gen {
	if managedClusterSKUGenerator != nil {
		return managedClusterSKUGenerator
	}

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

	return managedClusterSKUGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterSKU is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterSKU(gens map[string]gopter.Gen) {
	gens["Name"] = gen.PtrOf(gen.OneConstOf(ManagedClusterSKU_Name_Automatic, ManagedClusterSKU_Name_Base))
	gens["Tier"] = gen.PtrOf(gen.OneConstOf(ManagedClusterSKU_Tier_Free, ManagedClusterSKU_Tier_Premium, ManagedClusterSKU_Tier_Standard))
}

func Test_ManagedClusterSecurityProfile_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 ManagedClusterSecurityProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterSecurityProfile, ManagedClusterSecurityProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterSecurityProfile(generators)
	AddRelatedPropertyGeneratorsForManagedClusterSecurityProfile(generators)
	managedClusterSecurityProfileGenerator = gen.Struct(reflect.TypeOf(ManagedClusterSecurityProfile{}), generators)

	return managedClusterSecurityProfileGenerator
}

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

// AddRelatedPropertyGeneratorsForManagedClusterSecurityProfile is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedClusterSecurityProfile(gens map[string]gopter.Gen) {
	gens["AzureKeyVaultKms"] = gen.PtrOf(AzureKeyVaultKmsGenerator())
	gens["Defender"] = gen.PtrOf(ManagedClusterSecurityProfileDefenderGenerator())
	gens["ImageCleaner"] = gen.PtrOf(ManagedClusterSecurityProfileImageCleanerGenerator())
	gens["ImageIntegrity"] = gen.PtrOf(ManagedClusterSecurityProfileImageIntegrityGenerator())
	gens["NodeRestriction"] = gen.PtrOf(ManagedClusterSecurityProfileNodeRestrictionGenerator())
	gens["WorkloadIdentity"] = gen.PtrOf(ManagedClusterSecurityProfileWorkloadIdentityGenerator())
}

func Test_ManagedClusterSecurityProfileDefender_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 ManagedClusterSecurityProfileDefender via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterSecurityProfileDefender, ManagedClusterSecurityProfileDefenderGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterSecurityProfileDefender(generators)
	AddRelatedPropertyGeneratorsForManagedClusterSecurityProfileDefender(generators)
	managedClusterSecurityProfileDefenderGenerator = gen.Struct(reflect.TypeOf(ManagedClusterSecurityProfileDefender{}), generators)

	return managedClusterSecurityProfileDefenderGenerator
}

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

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

func Test_ManagedClusterSecurityProfileDefenderSecurityMonitoring_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 ManagedClusterSecurityProfileDefenderSecurityMonitoring via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterSecurityProfileDefenderSecurityMonitoring, ManagedClusterSecurityProfileDefenderSecurityMonitoringGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterSecurityProfileDefenderSecurityMonitoringGenerator returns a generator of ManagedClusterSecurityProfileDefenderSecurityMonitoring instances for property testing.
func ManagedClusterSecurityProfileDefenderSecurityMonitoringGenerator() gopter.Gen {
	if managedClusterSecurityProfileDefenderSecurityMonitoringGenerator != nil {
		return managedClusterSecurityProfileDefenderSecurityMonitoringGenerator
	}

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

	return managedClusterSecurityProfileDefenderSecurityMonitoringGenerator
}

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

func Test_ManagedClusterSecurityProfileImageCleaner_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 ManagedClusterSecurityProfileImageCleaner via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterSecurityProfileImageCleaner, ManagedClusterSecurityProfileImageCleanerGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterSecurityProfileImageCleanerGenerator returns a generator of ManagedClusterSecurityProfileImageCleaner instances for property testing.
func ManagedClusterSecurityProfileImageCleanerGenerator() gopter.Gen {
	if managedClusterSecurityProfileImageCleanerGenerator != nil {
		return managedClusterSecurityProfileImageCleanerGenerator
	}

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

	return managedClusterSecurityProfileImageCleanerGenerator
}

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

func Test_ManagedClusterSecurityProfileImageIntegrity_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 ManagedClusterSecurityProfileImageIntegrity via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterSecurityProfileImageIntegrity, ManagedClusterSecurityProfileImageIntegrityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterSecurityProfileImageIntegrityGenerator returns a generator of ManagedClusterSecurityProfileImageIntegrity instances for property testing.
func ManagedClusterSecurityProfileImageIntegrityGenerator() gopter.Gen {
	if managedClusterSecurityProfileImageIntegrityGenerator != nil {
		return managedClusterSecurityProfileImageIntegrityGenerator
	}

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

	return managedClusterSecurityProfileImageIntegrityGenerator
}

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

func Test_ManagedClusterSecurityProfileNodeRestriction_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 ManagedClusterSecurityProfileNodeRestriction via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterSecurityProfileNodeRestriction, ManagedClusterSecurityProfileNodeRestrictionGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterSecurityProfileNodeRestrictionGenerator returns a generator of ManagedClusterSecurityProfileNodeRestriction instances for property testing.
func ManagedClusterSecurityProfileNodeRestrictionGenerator() gopter.Gen {
	if managedClusterSecurityProfileNodeRestrictionGenerator != nil {
		return managedClusterSecurityProfileNodeRestrictionGenerator
	}

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

	return managedClusterSecurityProfileNodeRestrictionGenerator
}

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

func Test_ManagedClusterSecurityProfileWorkloadIdentity_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 ManagedClusterSecurityProfileWorkloadIdentity via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterSecurityProfileWorkloadIdentity, ManagedClusterSecurityProfileWorkloadIdentityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterSecurityProfileWorkloadIdentityGenerator returns a generator of ManagedClusterSecurityProfileWorkloadIdentity instances for property testing.
func ManagedClusterSecurityProfileWorkloadIdentityGenerator() gopter.Gen {
	if managedClusterSecurityProfileWorkloadIdentityGenerator != nil {
		return managedClusterSecurityProfileWorkloadIdentityGenerator
	}

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

	return managedClusterSecurityProfileWorkloadIdentityGenerator
}

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

func Test_ManagedClusterServicePrincipalProfile_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 ManagedClusterServicePrincipalProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterServicePrincipalProfile, ManagedClusterServicePrincipalProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterServicePrincipalProfileGenerator returns a generator of ManagedClusterServicePrincipalProfile instances for property testing.
func ManagedClusterServicePrincipalProfileGenerator() gopter.Gen {
	if managedClusterServicePrincipalProfileGenerator != nil {
		return managedClusterServicePrincipalProfileGenerator
	}

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

	return managedClusterServicePrincipalProfileGenerator
}

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

func Test_ManagedClusterStaticEgressGatewayProfile_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 ManagedClusterStaticEgressGatewayProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterStaticEgressGatewayProfile, ManagedClusterStaticEgressGatewayProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterStaticEgressGatewayProfileGenerator returns a generator of ManagedClusterStaticEgressGatewayProfile instances for property testing.
func ManagedClusterStaticEgressGatewayProfileGenerator() gopter.Gen {
	if managedClusterStaticEgressGatewayProfileGenerator != nil {
		return managedClusterStaticEgressGatewayProfileGenerator
	}

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

	return managedClusterStaticEgressGatewayProfileGenerator
}

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

func Test_ManagedClusterStorageProfile_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 ManagedClusterStorageProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterStorageProfile, ManagedClusterStorageProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterStorageProfileGenerator returns a generator of ManagedClusterStorageProfile instances for property testing.
func ManagedClusterStorageProfileGenerator() gopter.Gen {
	if managedClusterStorageProfileGenerator != nil {
		return managedClusterStorageProfileGenerator
	}

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

	return managedClusterStorageProfileGenerator
}

// AddRelatedPropertyGeneratorsForManagedClusterStorageProfile is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedClusterStorageProfile(gens map[string]gopter.Gen) {
	gens["BlobCSIDriver"] = gen.PtrOf(ManagedClusterStorageProfileBlobCSIDriverGenerator())
	gens["DiskCSIDriver"] = gen.PtrOf(ManagedClusterStorageProfileDiskCSIDriverGenerator())
	gens["FileCSIDriver"] = gen.PtrOf(ManagedClusterStorageProfileFileCSIDriverGenerator())
	gens["SnapshotController"] = gen.PtrOf(ManagedClusterStorageProfileSnapshotControllerGenerator())
}

func Test_ManagedClusterStorageProfileBlobCSIDriver_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 ManagedClusterStorageProfileBlobCSIDriver via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterStorageProfileBlobCSIDriver, ManagedClusterStorageProfileBlobCSIDriverGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterStorageProfileBlobCSIDriverGenerator returns a generator of ManagedClusterStorageProfileBlobCSIDriver instances for property testing.
func ManagedClusterStorageProfileBlobCSIDriverGenerator() gopter.Gen {
	if managedClusterStorageProfileBlobCSIDriverGenerator != nil {
		return managedClusterStorageProfileBlobCSIDriverGenerator
	}

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

	return managedClusterStorageProfileBlobCSIDriverGenerator
}

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

func Test_ManagedClusterStorageProfileDiskCSIDriver_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 ManagedClusterStorageProfileDiskCSIDriver via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterStorageProfileDiskCSIDriver, ManagedClusterStorageProfileDiskCSIDriverGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterStorageProfileDiskCSIDriverGenerator returns a generator of ManagedClusterStorageProfileDiskCSIDriver instances for property testing.
func ManagedClusterStorageProfileDiskCSIDriverGenerator() gopter.Gen {
	if managedClusterStorageProfileDiskCSIDriverGenerator != nil {
		return managedClusterStorageProfileDiskCSIDriverGenerator
	}

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

	return managedClusterStorageProfileDiskCSIDriverGenerator
}

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

func Test_ManagedClusterStorageProfileFileCSIDriver_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 ManagedClusterStorageProfileFileCSIDriver via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterStorageProfileFileCSIDriver, ManagedClusterStorageProfileFileCSIDriverGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterStorageProfileFileCSIDriverGenerator returns a generator of ManagedClusterStorageProfileFileCSIDriver instances for property testing.
func ManagedClusterStorageProfileFileCSIDriverGenerator() gopter.Gen {
	if managedClusterStorageProfileFileCSIDriverGenerator != nil {
		return managedClusterStorageProfileFileCSIDriverGenerator
	}

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

	return managedClusterStorageProfileFileCSIDriverGenerator
}

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

func Test_ManagedClusterStorageProfileSnapshotController_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 ManagedClusterStorageProfileSnapshotController via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterStorageProfileSnapshotController, ManagedClusterStorageProfileSnapshotControllerGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterStorageProfileSnapshotControllerGenerator returns a generator of ManagedClusterStorageProfileSnapshotController instances for property testing.
func ManagedClusterStorageProfileSnapshotControllerGenerator() gopter.Gen {
	if managedClusterStorageProfileSnapshotControllerGenerator != nil {
		return managedClusterStorageProfileSnapshotControllerGenerator
	}

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

	return managedClusterStorageProfileSnapshotControllerGenerator
}

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

func Test_ManagedClusterWindowsProfile_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 ManagedClusterWindowsProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterWindowsProfile, ManagedClusterWindowsProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedClusterWindowsProfile(generators)
	AddRelatedPropertyGeneratorsForManagedClusterWindowsProfile(generators)
	managedClusterWindowsProfileGenerator = gen.Struct(reflect.TypeOf(ManagedClusterWindowsProfile{}), generators)

	return managedClusterWindowsProfileGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterWindowsProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterWindowsProfile(gens map[string]gopter.Gen) {
	gens["AdminPassword"] = gen.PtrOf(gen.AlphaString())
	gens["AdminUsername"] = gen.PtrOf(gen.AlphaString())
	gens["EnableCSIProxy"] = gen.PtrOf(gen.Bool())
	gens["LicenseType"] = gen.PtrOf(gen.OneConstOf(ManagedClusterWindowsProfile_LicenseType_None, ManagedClusterWindowsProfile_LicenseType_Windows_Server))
}

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

func Test_ManagedClusterWorkloadAutoScalerProfile_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 ManagedClusterWorkloadAutoScalerProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterWorkloadAutoScalerProfile, ManagedClusterWorkloadAutoScalerProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterWorkloadAutoScalerProfileGenerator returns a generator of ManagedClusterWorkloadAutoScalerProfile instances for property testing.
func ManagedClusterWorkloadAutoScalerProfileGenerator() gopter.Gen {
	if managedClusterWorkloadAutoScalerProfileGenerator != nil {
		return managedClusterWorkloadAutoScalerProfileGenerator
	}

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

	return managedClusterWorkloadAutoScalerProfileGenerator
}

// AddRelatedPropertyGeneratorsForManagedClusterWorkloadAutoScalerProfile is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedClusterWorkloadAutoScalerProfile(gens map[string]gopter.Gen) {
	gens["Keda"] = gen.PtrOf(ManagedClusterWorkloadAutoScalerProfileKedaGenerator())
	gens["VerticalPodAutoscaler"] = gen.PtrOf(ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerGenerator())
}

func Test_ManagedClusterWorkloadAutoScalerProfileKeda_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 ManagedClusterWorkloadAutoScalerProfileKeda via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterWorkloadAutoScalerProfileKeda, ManagedClusterWorkloadAutoScalerProfileKedaGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterWorkloadAutoScalerProfileKedaGenerator returns a generator of ManagedClusterWorkloadAutoScalerProfileKeda instances for property testing.
func ManagedClusterWorkloadAutoScalerProfileKedaGenerator() gopter.Gen {
	if managedClusterWorkloadAutoScalerProfileKedaGenerator != nil {
		return managedClusterWorkloadAutoScalerProfileKedaGenerator
	}

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

	return managedClusterWorkloadAutoScalerProfileKedaGenerator
}

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

func Test_ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler_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 ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler, ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerGenerator returns a generator of ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler instances for property testing.
func ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerGenerator() gopter.Gen {
	if managedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerGenerator != nil {
		return managedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerGenerator
	}

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

	return managedClusterWorkloadAutoScalerProfileVerticalPodAutoscalerGenerator
}

// AddIndependentPropertyGeneratorsForManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler(gens map[string]gopter.Gen) {
	gens["AddonAutoscaling"] = gen.PtrOf(gen.OneConstOf(ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler_AddonAutoscaling_Disabled, ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler_AddonAutoscaling_Enabled))
	gens["Enabled"] = gen.PtrOf(gen.Bool())
}

func Test_ManagedCluster_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 ManagedCluster_Spec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedCluster_Spec, ManagedCluster_SpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ManagedCluster_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 ManagedCluster_Spec instances for property testing - lazily instantiated by
// ManagedCluster_SpecGenerator()
var managedCluster_SpecGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedCluster_Spec(generators)
	AddRelatedPropertyGeneratorsForManagedCluster_Spec(generators)
	managedCluster_SpecGenerator = gen.Struct(reflect.TypeOf(ManagedCluster_Spec{}), generators)

	return managedCluster_SpecGenerator
}

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

// AddRelatedPropertyGeneratorsForManagedCluster_Spec is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedCluster_Spec(gens map[string]gopter.Gen) {
	gens["ExtendedLocation"] = gen.PtrOf(ExtendedLocationGenerator())
	gens["Identity"] = gen.PtrOf(ManagedClusterIdentityGenerator())
	gens["Properties"] = gen.PtrOf(ManagedClusterPropertiesGenerator())
	gens["Sku"] = gen.PtrOf(ManagedClusterSKUGenerator())
}

func Test_PrivateLinkResource_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 PrivateLinkResource via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrivateLinkResource, PrivateLinkResourceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// PrivateLinkResourceGenerator returns a generator of PrivateLinkResource instances for property testing.
func PrivateLinkResourceGenerator() gopter.Gen {
	if privateLinkResourceGenerator != nil {
		return privateLinkResourceGenerator
	}

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

	return privateLinkResourceGenerator
}

// AddIndependentPropertyGeneratorsForPrivateLinkResource is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForPrivateLinkResource(gens map[string]gopter.Gen) {
	gens["GroupId"] = gen.PtrOf(gen.AlphaString())
	gens["Id"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["RequiredMembers"] = gen.SliceOf(gen.AlphaString())
	gens["Type"] = gen.PtrOf(gen.AlphaString())
}

func Test_ResourceReference_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 ResourceReference via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForResourceReference, ResourceReferenceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ResourceReferenceGenerator returns a generator of ResourceReference instances for property testing.
func ResourceReferenceGenerator() gopter.Gen {
	if resourceReferenceGenerator != nil {
		return resourceReferenceGenerator
	}

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

	return resourceReferenceGenerator
}

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

func Test_SafeguardsProfile_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 SafeguardsProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSafeguardsProfile, SafeguardsProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// SafeguardsProfileGenerator returns a generator of SafeguardsProfile instances for property testing.
func SafeguardsProfileGenerator() gopter.Gen {
	if safeguardsProfileGenerator != nil {
		return safeguardsProfileGenerator
	}

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

	return safeguardsProfileGenerator
}

// AddIndependentPropertyGeneratorsForSafeguardsProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSafeguardsProfile(gens map[string]gopter.Gen) {
	gens["ExcludedNamespaces"] = gen.SliceOf(gen.AlphaString())
	gens["Level"] = gen.PtrOf(gen.OneConstOf(SafeguardsProfile_Level_Enforcement, SafeguardsProfile_Level_Off, SafeguardsProfile_Level_Warning))
	gens["Version"] = gen.PtrOf(gen.AlphaString())
}

func Test_ServiceMeshProfile_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 ServiceMeshProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServiceMeshProfile, ServiceMeshProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForServiceMeshProfile(generators)
	AddRelatedPropertyGeneratorsForServiceMeshProfile(generators)
	serviceMeshProfileGenerator = gen.Struct(reflect.TypeOf(ServiceMeshProfile{}), generators)

	return serviceMeshProfileGenerator
}

// AddIndependentPropertyGeneratorsForServiceMeshProfile is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForServiceMeshProfile(gens map[string]gopter.Gen) {
	gens["Mode"] = gen.PtrOf(gen.OneConstOf(ServiceMeshProfile_Mode_Disabled, ServiceMeshProfile_Mode_Istio))
}

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

func Test_UpgradeOverrideSettings_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 UpgradeOverrideSettings via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUpgradeOverrideSettings, UpgradeOverrideSettingsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// UpgradeOverrideSettingsGenerator returns a generator of UpgradeOverrideSettings instances for property testing.
func UpgradeOverrideSettingsGenerator() gopter.Gen {
	if upgradeOverrideSettingsGenerator != nil {
		return upgradeOverrideSettingsGenerator
	}

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

	return upgradeOverrideSettingsGenerator
}

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

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

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

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

// UserAssignedIdentityGenerator returns a generator of UserAssignedIdentity instances for property testing.
func UserAssignedIdentityGenerator() gopter.Gen {
	if userAssignedIdentityGenerator != nil {
		return userAssignedIdentityGenerator
	}

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

	return userAssignedIdentityGenerator
}

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

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_WindowsGmsaProfile_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 WindowsGmsaProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWindowsGmsaProfile, WindowsGmsaProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// WindowsGmsaProfileGenerator returns a generator of WindowsGmsaProfile instances for property testing.
func WindowsGmsaProfileGenerator() gopter.Gen {
	if windowsGmsaProfileGenerator != nil {
		return windowsGmsaProfileGenerator
	}

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

	return windowsGmsaProfileGenerator
}

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