// 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_APIServerProfile_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of APIServerProfile_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAPIServerProfile_STATUS, APIServerProfile_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of APIServerProfile_STATUS instances for property testing - lazily instantiated by
// APIServerProfile_STATUSGenerator()
var apiServerProfile_STATUSGenerator gopter.Gen

// APIServerProfile_STATUSGenerator returns a generator of APIServerProfile_STATUS instances for property testing.
func APIServerProfile_STATUSGenerator() gopter.Gen {
	if apiServerProfile_STATUSGenerator != nil {
		return apiServerProfile_STATUSGenerator
	}

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

	return apiServerProfile_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAPIServerProfile_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAPIServerProfile_STATUS(gens map[string]gopter.Gen) {
	gens["Ip"] = gen.PtrOf(gen.AlphaString())
	gens["Url"] = gen.PtrOf(gen.AlphaString())
	gens["Visibility"] = gen.PtrOf(gen.OneConstOf(Visibility_STATUS_Private, Visibility_STATUS_Public))
}

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

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

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

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

	return ""
}

// Generator of ClusterProfile_STATUS instances for property testing - lazily instantiated by
// ClusterProfile_STATUSGenerator()
var clusterProfile_STATUSGenerator gopter.Gen

// ClusterProfile_STATUSGenerator returns a generator of ClusterProfile_STATUS instances for property testing.
func ClusterProfile_STATUSGenerator() gopter.Gen {
	if clusterProfile_STATUSGenerator != nil {
		return clusterProfile_STATUSGenerator
	}

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

	return clusterProfile_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForClusterProfile_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForClusterProfile_STATUS(gens map[string]gopter.Gen) {
	gens["Domain"] = gen.PtrOf(gen.AlphaString())
	gens["FipsValidatedModules"] = gen.PtrOf(gen.OneConstOf(FipsValidatedModules_STATUS_Disabled, FipsValidatedModules_STATUS_Enabled))
	gens["ResourceGroupId"] = gen.PtrOf(gen.AlphaString())
	gens["Version"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

	return ""
}

// Generator of ConsoleProfile_STATUS instances for property testing - lazily instantiated by
// ConsoleProfile_STATUSGenerator()
var consoleProfile_STATUSGenerator gopter.Gen

// ConsoleProfile_STATUSGenerator returns a generator of ConsoleProfile_STATUS instances for property testing.
func ConsoleProfile_STATUSGenerator() gopter.Gen {
	if consoleProfile_STATUSGenerator != nil {
		return consoleProfile_STATUSGenerator
	}

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

	return consoleProfile_STATUSGenerator
}

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

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

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

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

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

	return ""
}

// Generator of EffectiveOutboundIP_STATUS instances for property testing - lazily instantiated by
// EffectiveOutboundIP_STATUSGenerator()
var effectiveOutboundIP_STATUSGenerator gopter.Gen

// EffectiveOutboundIP_STATUSGenerator returns a generator of EffectiveOutboundIP_STATUS instances for property testing.
func EffectiveOutboundIP_STATUSGenerator() gopter.Gen {
	if effectiveOutboundIP_STATUSGenerator != nil {
		return effectiveOutboundIP_STATUSGenerator
	}

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

	return effectiveOutboundIP_STATUSGenerator
}

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

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

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

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

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

	return ""
}

// Generator of IngressProfile_STATUS instances for property testing - lazily instantiated by
// IngressProfile_STATUSGenerator()
var ingressProfile_STATUSGenerator gopter.Gen

// IngressProfile_STATUSGenerator returns a generator of IngressProfile_STATUS instances for property testing.
func IngressProfile_STATUSGenerator() gopter.Gen {
	if ingressProfile_STATUSGenerator != nil {
		return ingressProfile_STATUSGenerator
	}

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

	return ingressProfile_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIngressProfile_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIngressProfile_STATUS(gens map[string]gopter.Gen) {
	gens["Ip"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Visibility"] = gen.PtrOf(gen.OneConstOf(Visibility_STATUS_Private, Visibility_STATUS_Public))
}

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

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

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

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

	return ""
}

// Generator of LoadBalancerProfile_STATUS instances for property testing - lazily instantiated by
// LoadBalancerProfile_STATUSGenerator()
var loadBalancerProfile_STATUSGenerator gopter.Gen

// LoadBalancerProfile_STATUSGenerator returns a generator of LoadBalancerProfile_STATUS instances for property testing.
func LoadBalancerProfile_STATUSGenerator() gopter.Gen {
	if loadBalancerProfile_STATUSGenerator != nil {
		return loadBalancerProfile_STATUSGenerator
	}

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

	return loadBalancerProfile_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForLoadBalancerProfile_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForLoadBalancerProfile_STATUS(gens map[string]gopter.Gen) {
	gens["EffectiveOutboundIps"] = gen.SliceOf(EffectiveOutboundIP_STATUSGenerator())
	gens["ManagedOutboundIps"] = gen.PtrOf(ManagedOutboundIPs_STATUSGenerator())
}

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

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

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

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

	return ""
}

// Generator of ManagedOutboundIPs_STATUS instances for property testing - lazily instantiated by
// ManagedOutboundIPs_STATUSGenerator()
var managedOutboundIPs_STATUSGenerator gopter.Gen

// ManagedOutboundIPs_STATUSGenerator returns a generator of ManagedOutboundIPs_STATUS instances for property testing.
func ManagedOutboundIPs_STATUSGenerator() gopter.Gen {
	if managedOutboundIPs_STATUSGenerator != nil {
		return managedOutboundIPs_STATUSGenerator
	}

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

	return managedOutboundIPs_STATUSGenerator
}

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

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

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

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

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

	return ""
}

// Generator of MasterProfile_STATUS instances for property testing - lazily instantiated by
// MasterProfile_STATUSGenerator()
var masterProfile_STATUSGenerator gopter.Gen

// MasterProfile_STATUSGenerator returns a generator of MasterProfile_STATUS instances for property testing.
func MasterProfile_STATUSGenerator() gopter.Gen {
	if masterProfile_STATUSGenerator != nil {
		return masterProfile_STATUSGenerator
	}

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

	return masterProfile_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForMasterProfile_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForMasterProfile_STATUS(gens map[string]gopter.Gen) {
	gens["DiskEncryptionSetId"] = gen.PtrOf(gen.AlphaString())
	gens["EncryptionAtHost"] = gen.PtrOf(gen.OneConstOf(EncryptionAtHost_STATUS_Disabled, EncryptionAtHost_STATUS_Enabled))
	gens["SubnetId"] = gen.PtrOf(gen.AlphaString())
	gens["VmSize"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

	return ""
}

// Generator of NetworkProfile_STATUS instances for property testing - lazily instantiated by
// NetworkProfile_STATUSGenerator()
var networkProfile_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNetworkProfile_STATUS(generators)
	AddRelatedPropertyGeneratorsForNetworkProfile_STATUS(generators)
	networkProfile_STATUSGenerator = gen.Struct(reflect.TypeOf(NetworkProfile_STATUS{}), generators)

	return networkProfile_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNetworkProfile_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNetworkProfile_STATUS(gens map[string]gopter.Gen) {
	gens["OutboundType"] = gen.PtrOf(gen.OneConstOf(OutboundType_STATUS_Loadbalancer, OutboundType_STATUS_UserDefinedRouting))
	gens["PodCidr"] = gen.PtrOf(gen.AlphaString())
	gens["PreconfiguredNSG"] = gen.PtrOf(gen.OneConstOf(PreconfiguredNSG_STATUS_Disabled, PreconfiguredNSG_STATUS_Enabled))
	gens["ServiceCidr"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

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

	return ""
}

// Generator of OpenShiftClusterProperties_STATUS instances for property testing - lazily instantiated by
// OpenShiftClusterProperties_STATUSGenerator()
var openShiftClusterProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForOpenShiftClusterProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForOpenShiftClusterProperties_STATUS(generators)
	openShiftClusterProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(OpenShiftClusterProperties_STATUS{}), generators)

	return openShiftClusterProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForOpenShiftClusterProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForOpenShiftClusterProperties_STATUS(gens map[string]gopter.Gen) {
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ProvisioningState_STATUS_AdminUpdating,
		ProvisioningState_STATUS_Canceled,
		ProvisioningState_STATUS_Creating,
		ProvisioningState_STATUS_Deleting,
		ProvisioningState_STATUS_Failed,
		ProvisioningState_STATUS_Succeeded,
		ProvisioningState_STATUS_Updating))
}

// AddRelatedPropertyGeneratorsForOpenShiftClusterProperties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForOpenShiftClusterProperties_STATUS(gens map[string]gopter.Gen) {
	gens["ApiserverProfile"] = gen.PtrOf(APIServerProfile_STATUSGenerator())
	gens["ClusterProfile"] = gen.PtrOf(ClusterProfile_STATUSGenerator())
	gens["ConsoleProfile"] = gen.PtrOf(ConsoleProfile_STATUSGenerator())
	gens["IngressProfiles"] = gen.SliceOf(IngressProfile_STATUSGenerator())
	gens["MasterProfile"] = gen.PtrOf(MasterProfile_STATUSGenerator())
	gens["NetworkProfile"] = gen.PtrOf(NetworkProfile_STATUSGenerator())
	gens["ServicePrincipalProfile"] = gen.PtrOf(ServicePrincipalProfile_STATUSGenerator())
	gens["WorkerProfiles"] = gen.SliceOf(WorkerProfile_STATUSGenerator())
	gens["WorkerProfilesStatus"] = gen.SliceOf(WorkerProfile_STATUSGenerator())
}

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

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

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

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

	return ""
}

// Generator of OpenShiftCluster_STATUS instances for property testing - lazily instantiated by
// OpenShiftCluster_STATUSGenerator()
var openShiftCluster_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForOpenShiftCluster_STATUS(generators)
	AddRelatedPropertyGeneratorsForOpenShiftCluster_STATUS(generators)
	openShiftCluster_STATUSGenerator = gen.Struct(reflect.TypeOf(OpenShiftCluster_STATUS{}), generators)

	return openShiftCluster_STATUSGenerator
}

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

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

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

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

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

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

	return ""
}

// Generator of ServicePrincipalProfile_STATUS instances for property testing - lazily instantiated by
// ServicePrincipalProfile_STATUSGenerator()
var servicePrincipalProfile_STATUSGenerator gopter.Gen

// ServicePrincipalProfile_STATUSGenerator returns a generator of ServicePrincipalProfile_STATUS instances for property testing.
func ServicePrincipalProfile_STATUSGenerator() gopter.Gen {
	if servicePrincipalProfile_STATUSGenerator != nil {
		return servicePrincipalProfile_STATUSGenerator
	}

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

	return servicePrincipalProfile_STATUSGenerator
}

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

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

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

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

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

	return ""
}

// Generator of SystemData_STATUS instances for property testing - lazily instantiated by SystemData_STATUSGenerator()
var systemData_STATUSGenerator gopter.Gen

// SystemData_STATUSGenerator returns a generator of SystemData_STATUS instances for property testing.
func SystemData_STATUSGenerator() gopter.Gen {
	if systemData_STATUSGenerator != nil {
		return systemData_STATUSGenerator
	}

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

	return systemData_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSystemData_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSystemData_STATUS(gens map[string]gopter.Gen) {
	gens["CreatedAt"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedBy"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedByType"] = gen.PtrOf(gen.OneConstOf(
		SystemData_CreatedByType_STATUS_Application,
		SystemData_CreatedByType_STATUS_Key,
		SystemData_CreatedByType_STATUS_ManagedIdentity,
		SystemData_CreatedByType_STATUS_User))
	gens["LastModifiedAt"] = gen.PtrOf(gen.AlphaString())
	gens["LastModifiedBy"] = gen.PtrOf(gen.AlphaString())
	gens["LastModifiedByType"] = gen.PtrOf(gen.OneConstOf(
		SystemData_LastModifiedByType_STATUS_Application,
		SystemData_LastModifiedByType_STATUS_Key,
		SystemData_LastModifiedByType_STATUS_ManagedIdentity,
		SystemData_LastModifiedByType_STATUS_User))
}

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

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

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

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

	return ""
}

// Generator of WorkerProfile_STATUS instances for property testing - lazily instantiated by
// WorkerProfile_STATUSGenerator()
var workerProfile_STATUSGenerator gopter.Gen

// WorkerProfile_STATUSGenerator returns a generator of WorkerProfile_STATUS instances for property testing.
func WorkerProfile_STATUSGenerator() gopter.Gen {
	if workerProfile_STATUSGenerator != nil {
		return workerProfile_STATUSGenerator
	}

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

	return workerProfile_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForWorkerProfile_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForWorkerProfile_STATUS(gens map[string]gopter.Gen) {
	gens["Count"] = gen.PtrOf(gen.Int())
	gens["DiskEncryptionSetId"] = gen.PtrOf(gen.AlphaString())
	gens["DiskSizeGB"] = gen.PtrOf(gen.Int())
	gens["EncryptionAtHost"] = gen.PtrOf(gen.OneConstOf(EncryptionAtHost_STATUS_Disabled, EncryptionAtHost_STATUS_Enabled))
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["SubnetId"] = gen.PtrOf(gen.AlphaString())
	gens["VmSize"] = gen.PtrOf(gen.AlphaString())
}
