// 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_AppLogsConfiguration_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 AppLogsConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAppLogsConfiguration_STATUS, AppLogsConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AppLogsConfiguration_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 AppLogsConfiguration_STATUS instances for property testing - lazily instantiated by
// AppLogsConfiguration_STATUSGenerator()
var appLogsConfiguration_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAppLogsConfiguration_STATUS(generators)
	AddRelatedPropertyGeneratorsForAppLogsConfiguration_STATUS(generators)
	appLogsConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(AppLogsConfiguration_STATUS{}), generators)

	return appLogsConfiguration_STATUSGenerator
}

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

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

func Test_CustomDomainConfiguration_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 CustomDomainConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCustomDomainConfiguration_STATUS, CustomDomainConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CustomDomainConfiguration_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 CustomDomainConfiguration_STATUS instances for property testing - lazily instantiated by
// CustomDomainConfiguration_STATUSGenerator()
var customDomainConfiguration_STATUSGenerator gopter.Gen

// CustomDomainConfiguration_STATUSGenerator returns a generator of CustomDomainConfiguration_STATUS instances for property testing.
func CustomDomainConfiguration_STATUSGenerator() gopter.Gen {
	if customDomainConfiguration_STATUSGenerator != nil {
		return customDomainConfiguration_STATUSGenerator
	}

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

	return customDomainConfiguration_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForCustomDomainConfiguration_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCustomDomainConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["CustomDomainVerificationId"] = gen.PtrOf(gen.AlphaString())
	gens["DnsSuffix"] = gen.PtrOf(gen.AlphaString())
	gens["ExpirationDate"] = gen.PtrOf(gen.AlphaString())
	gens["SubjectName"] = gen.PtrOf(gen.AlphaString())
	gens["Thumbprint"] = gen.PtrOf(gen.AlphaString())
}

func Test_DaprConfiguration_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 DaprConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDaprConfiguration_STATUS, DaprConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DaprConfiguration_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 DaprConfiguration_STATUS instances for property testing - lazily instantiated by
// DaprConfiguration_STATUSGenerator()
var daprConfiguration_STATUSGenerator gopter.Gen

// DaprConfiguration_STATUSGenerator returns a generator of DaprConfiguration_STATUS instances for property testing.
func DaprConfiguration_STATUSGenerator() gopter.Gen {
	if daprConfiguration_STATUSGenerator != nil {
		return daprConfiguration_STATUSGenerator
	}

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

	return daprConfiguration_STATUSGenerator
}

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

func Test_KedaConfiguration_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 KedaConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForKedaConfiguration_STATUS, KedaConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual KedaConfiguration_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 KedaConfiguration_STATUS instances for property testing - lazily instantiated by
// KedaConfiguration_STATUSGenerator()
var kedaConfiguration_STATUSGenerator gopter.Gen

// KedaConfiguration_STATUSGenerator returns a generator of KedaConfiguration_STATUS instances for property testing.
func KedaConfiguration_STATUSGenerator() gopter.Gen {
	if kedaConfiguration_STATUSGenerator != nil {
		return kedaConfiguration_STATUSGenerator
	}

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

	return kedaConfiguration_STATUSGenerator
}

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

func Test_LogAnalyticsConfiguration_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 LogAnalyticsConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForLogAnalyticsConfiguration_STATUS, LogAnalyticsConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual LogAnalyticsConfiguration_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 LogAnalyticsConfiguration_STATUS instances for property testing - lazily instantiated by
// LogAnalyticsConfiguration_STATUSGenerator()
var logAnalyticsConfiguration_STATUSGenerator gopter.Gen

// LogAnalyticsConfiguration_STATUSGenerator returns a generator of LogAnalyticsConfiguration_STATUS instances for property testing.
func LogAnalyticsConfiguration_STATUSGenerator() gopter.Gen {
	if logAnalyticsConfiguration_STATUSGenerator != nil {
		return logAnalyticsConfiguration_STATUSGenerator
	}

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

	return logAnalyticsConfiguration_STATUSGenerator
}

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

func Test_ManagedEnvironment_Properties_PeerAuthentication_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 ManagedEnvironment_Properties_PeerAuthentication_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedEnvironment_Properties_PeerAuthentication_STATUS, ManagedEnvironment_Properties_PeerAuthentication_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ManagedEnvironment_Properties_PeerAuthentication_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 ManagedEnvironment_Properties_PeerAuthentication_STATUS instances for property testing - lazily
// instantiated by ManagedEnvironment_Properties_PeerAuthentication_STATUSGenerator()
var managedEnvironment_Properties_PeerAuthentication_STATUSGenerator gopter.Gen

// ManagedEnvironment_Properties_PeerAuthentication_STATUSGenerator returns a generator of ManagedEnvironment_Properties_PeerAuthentication_STATUS instances for property testing.
func ManagedEnvironment_Properties_PeerAuthentication_STATUSGenerator() gopter.Gen {
	if managedEnvironment_Properties_PeerAuthentication_STATUSGenerator != nil {
		return managedEnvironment_Properties_PeerAuthentication_STATUSGenerator
	}

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

	return managedEnvironment_Properties_PeerAuthentication_STATUSGenerator
}

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

func Test_ManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_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 ManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUS, ManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_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 ManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUS instances for property testing
// - lazily instantiated by ManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUSGenerator()
var managedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUSGenerator gopter.Gen

// ManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUSGenerator returns a generator of ManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUS instances for property testing.
func ManagedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUSGenerator() gopter.Gen {
	if managedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUSGenerator != nil {
		return managedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUSGenerator
	}

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

	return managedEnvironment_Properties_PeerTrafficConfiguration_Encryption_STATUSGenerator
}

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

func Test_ManagedEnvironment_Properties_PeerTrafficConfiguration_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 ManagedEnvironment_Properties_PeerTrafficConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedEnvironment_Properties_PeerTrafficConfiguration_STATUS, ManagedEnvironment_Properties_PeerTrafficConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ManagedEnvironment_Properties_PeerTrafficConfiguration_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 ManagedEnvironment_Properties_PeerTrafficConfiguration_STATUS instances for property testing - lazily
// instantiated by ManagedEnvironment_Properties_PeerTrafficConfiguration_STATUSGenerator()
var managedEnvironment_Properties_PeerTrafficConfiguration_STATUSGenerator gopter.Gen

// ManagedEnvironment_Properties_PeerTrafficConfiguration_STATUSGenerator returns a generator of ManagedEnvironment_Properties_PeerTrafficConfiguration_STATUS instances for property testing.
func ManagedEnvironment_Properties_PeerTrafficConfiguration_STATUSGenerator() gopter.Gen {
	if managedEnvironment_Properties_PeerTrafficConfiguration_STATUSGenerator != nil {
		return managedEnvironment_Properties_PeerTrafficConfiguration_STATUSGenerator
	}

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

	return managedEnvironment_Properties_PeerTrafficConfiguration_STATUSGenerator
}

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

func Test_ManagedEnvironment_Properties_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 ManagedEnvironment_Properties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedEnvironment_Properties_STATUS, ManagedEnvironment_Properties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ManagedEnvironment_Properties_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 ManagedEnvironment_Properties_STATUS instances for property testing - lazily instantiated by
// ManagedEnvironment_Properties_STATUSGenerator()
var managedEnvironment_Properties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedEnvironment_Properties_STATUS(generators)
	AddRelatedPropertyGeneratorsForManagedEnvironment_Properties_STATUS(generators)
	managedEnvironment_Properties_STATUSGenerator = gen.Struct(reflect.TypeOf(ManagedEnvironment_Properties_STATUS{}), generators)

	return managedEnvironment_Properties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForManagedEnvironment_Properties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForManagedEnvironment_Properties_STATUS(gens map[string]gopter.Gen) {
	gens["DefaultDomain"] = gen.PtrOf(gen.AlphaString())
	gens["DeploymentErrors"] = gen.PtrOf(gen.AlphaString())
	gens["EventStreamEndpoint"] = gen.PtrOf(gen.AlphaString())
	gens["InfrastructureResourceGroup"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ManagedEnvironment_Properties_ProvisioningState_STATUS_Canceled,
		ManagedEnvironment_Properties_ProvisioningState_STATUS_Failed,
		ManagedEnvironment_Properties_ProvisioningState_STATUS_InfrastructureSetupComplete,
		ManagedEnvironment_Properties_ProvisioningState_STATUS_InfrastructureSetupInProgress,
		ManagedEnvironment_Properties_ProvisioningState_STATUS_InitializationInProgress,
		ManagedEnvironment_Properties_ProvisioningState_STATUS_ScheduledForDelete,
		ManagedEnvironment_Properties_ProvisioningState_STATUS_Succeeded,
		ManagedEnvironment_Properties_ProvisioningState_STATUS_UpgradeFailed,
		ManagedEnvironment_Properties_ProvisioningState_STATUS_UpgradeRequested,
		ManagedEnvironment_Properties_ProvisioningState_STATUS_Waiting))
	gens["StaticIp"] = gen.PtrOf(gen.AlphaString())
	gens["ZoneRedundant"] = gen.PtrOf(gen.Bool())
}

// AddRelatedPropertyGeneratorsForManagedEnvironment_Properties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForManagedEnvironment_Properties_STATUS(gens map[string]gopter.Gen) {
	gens["AppLogsConfiguration"] = gen.PtrOf(AppLogsConfiguration_STATUSGenerator())
	gens["CustomDomainConfiguration"] = gen.PtrOf(CustomDomainConfiguration_STATUSGenerator())
	gens["DaprConfiguration"] = gen.PtrOf(DaprConfiguration_STATUSGenerator())
	gens["KedaConfiguration"] = gen.PtrOf(KedaConfiguration_STATUSGenerator())
	gens["PeerAuthentication"] = gen.PtrOf(ManagedEnvironment_Properties_PeerAuthentication_STATUSGenerator())
	gens["PeerTrafficConfiguration"] = gen.PtrOf(ManagedEnvironment_Properties_PeerTrafficConfiguration_STATUSGenerator())
	gens["VnetConfiguration"] = gen.PtrOf(VnetConfiguration_STATUSGenerator())
	gens["WorkloadProfiles"] = gen.SliceOf(WorkloadProfile_STATUSGenerator())
}

func Test_ManagedEnvironment_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 ManagedEnvironment_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedEnvironment_STATUS, ManagedEnvironment_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ManagedEnvironment_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 ManagedEnvironment_STATUS instances for property testing - lazily instantiated by
// ManagedEnvironment_STATUSGenerator()
var managedEnvironment_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedEnvironment_STATUS(generators)
	AddRelatedPropertyGeneratorsForManagedEnvironment_STATUS(generators)
	managedEnvironment_STATUSGenerator = gen.Struct(reflect.TypeOf(ManagedEnvironment_STATUS{}), generators)

	return managedEnvironment_STATUSGenerator
}

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

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

func Test_Mtls_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 Mtls_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForMtls_STATUS, Mtls_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Mtls_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 Mtls_STATUS instances for property testing - lazily instantiated by Mtls_STATUSGenerator()
var mtls_STATUSGenerator gopter.Gen

// Mtls_STATUSGenerator returns a generator of Mtls_STATUS instances for property testing.
func Mtls_STATUSGenerator() gopter.Gen {
	if mtls_STATUSGenerator != nil {
		return mtls_STATUSGenerator
	}

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

	return mtls_STATUSGenerator
}

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

func Test_VnetConfiguration_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 VnetConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVnetConfiguration_STATUS, VnetConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual VnetConfiguration_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 VnetConfiguration_STATUS instances for property testing - lazily instantiated by
// VnetConfiguration_STATUSGenerator()
var vnetConfiguration_STATUSGenerator gopter.Gen

// VnetConfiguration_STATUSGenerator returns a generator of VnetConfiguration_STATUS instances for property testing.
func VnetConfiguration_STATUSGenerator() gopter.Gen {
	if vnetConfiguration_STATUSGenerator != nil {
		return vnetConfiguration_STATUSGenerator
	}

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

	return vnetConfiguration_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVnetConfiguration_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVnetConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["DockerBridgeCidr"] = gen.PtrOf(gen.AlphaString())
	gens["InfrastructureSubnetId"] = gen.PtrOf(gen.AlphaString())
	gens["Internal"] = gen.PtrOf(gen.Bool())
	gens["PlatformReservedCidr"] = gen.PtrOf(gen.AlphaString())
	gens["PlatformReservedDnsIP"] = gen.PtrOf(gen.AlphaString())
}

func Test_WorkloadProfile_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 WorkloadProfile_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWorkloadProfile_STATUS, WorkloadProfile_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual WorkloadProfile_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 WorkloadProfile_STATUS instances for property testing - lazily instantiated by
// WorkloadProfile_STATUSGenerator()
var workloadProfile_STATUSGenerator gopter.Gen

// WorkloadProfile_STATUSGenerator returns a generator of WorkloadProfile_STATUS instances for property testing.
func WorkloadProfile_STATUSGenerator() gopter.Gen {
	if workloadProfile_STATUSGenerator != nil {
		return workloadProfile_STATUSGenerator
	}

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

	return workloadProfile_STATUSGenerator
}

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