// 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_BaseContainer_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 BaseContainer_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBaseContainer_STATUS, BaseContainer_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BaseContainer_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 BaseContainer_STATUS instances for property testing - lazily instantiated by
// BaseContainer_STATUSGenerator()
var baseContainer_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForBaseContainer_STATUS(generators)
	AddRelatedPropertyGeneratorsForBaseContainer_STATUS(generators)
	baseContainer_STATUSGenerator = gen.Struct(reflect.TypeOf(BaseContainer_STATUS{}), generators)

	return baseContainer_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForBaseContainer_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForBaseContainer_STATUS(gens map[string]gopter.Gen) {
	gens["Args"] = gen.SliceOf(gen.AlphaString())
	gens["Command"] = gen.SliceOf(gen.AlphaString())
	gens["Image"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForBaseContainer_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForBaseContainer_STATUS(gens map[string]gopter.Gen) {
	gens["Env"] = gen.SliceOf(EnvironmentVar_STATUSGenerator())
	gens["Resources"] = gen.PtrOf(ContainerResources_STATUSGenerator())
	gens["VolumeMounts"] = gen.SliceOf(VolumeMount_STATUSGenerator())
}

func Test_Configuration_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 Configuration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForConfiguration_STATUS, Configuration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Configuration_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 Configuration_STATUS instances for property testing - lazily instantiated by
// Configuration_STATUSGenerator()
var configuration_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForConfiguration_STATUS(generators)
	AddRelatedPropertyGeneratorsForConfiguration_STATUS(generators)
	configuration_STATUSGenerator = gen.Struct(reflect.TypeOf(Configuration_STATUS{}), generators)

	return configuration_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForConfiguration_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["ActiveRevisionsMode"] = gen.PtrOf(gen.OneConstOf(Configuration_ActiveRevisionsMode_STATUS_Multiple, Configuration_ActiveRevisionsMode_STATUS_Single))
	gens["MaxInactiveRevisions"] = gen.PtrOf(gen.Int())
}

// AddRelatedPropertyGeneratorsForConfiguration_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["Dapr"] = gen.PtrOf(Dapr_STATUSGenerator())
	gens["IdentitySettings"] = gen.SliceOf(IdentitySettings_STATUSGenerator())
	gens["Ingress"] = gen.PtrOf(Ingress_STATUSGenerator())
	gens["Registries"] = gen.SliceOf(RegistryCredentials_STATUSGenerator())
	gens["Runtime"] = gen.PtrOf(Runtime_STATUSGenerator())
	gens["Secrets"] = gen.SliceOf(Secret_STATUSGenerator())
	gens["Service"] = gen.PtrOf(Service_STATUSGenerator())
}

func Test_ContainerAppProbe_HttpGet_HttpHeaders_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 ContainerAppProbe_HttpGet_HttpHeaders_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerAppProbe_HttpGet_HttpHeaders_STATUS, ContainerAppProbe_HttpGet_HttpHeaders_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ContainerAppProbe_HttpGet_HttpHeaders_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 ContainerAppProbe_HttpGet_HttpHeaders_STATUS instances for property testing - lazily instantiated by
// ContainerAppProbe_HttpGet_HttpHeaders_STATUSGenerator()
var containerAppProbe_HttpGet_HttpHeaders_STATUSGenerator gopter.Gen

// ContainerAppProbe_HttpGet_HttpHeaders_STATUSGenerator returns a generator of ContainerAppProbe_HttpGet_HttpHeaders_STATUS instances for property testing.
func ContainerAppProbe_HttpGet_HttpHeaders_STATUSGenerator() gopter.Gen {
	if containerAppProbe_HttpGet_HttpHeaders_STATUSGenerator != nil {
		return containerAppProbe_HttpGet_HttpHeaders_STATUSGenerator
	}

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

	return containerAppProbe_HttpGet_HttpHeaders_STATUSGenerator
}

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

func Test_ContainerAppProbe_HttpGet_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 ContainerAppProbe_HttpGet_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerAppProbe_HttpGet_STATUS, ContainerAppProbe_HttpGet_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ContainerAppProbe_HttpGet_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 ContainerAppProbe_HttpGet_STATUS instances for property testing - lazily instantiated by
// ContainerAppProbe_HttpGet_STATUSGenerator()
var containerAppProbe_HttpGet_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainerAppProbe_HttpGet_STATUS(generators)
	AddRelatedPropertyGeneratorsForContainerAppProbe_HttpGet_STATUS(generators)
	containerAppProbe_HttpGet_STATUSGenerator = gen.Struct(reflect.TypeOf(ContainerAppProbe_HttpGet_STATUS{}), generators)

	return containerAppProbe_HttpGet_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForContainerAppProbe_HttpGet_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainerAppProbe_HttpGet_STATUS(gens map[string]gopter.Gen) {
	gens["Host"] = gen.PtrOf(gen.AlphaString())
	gens["Path"] = gen.PtrOf(gen.AlphaString())
	gens["Port"] = gen.PtrOf(gen.Int())
	gens["Scheme"] = gen.PtrOf(gen.OneConstOf(ContainerAppProbe_HttpGet_Scheme_STATUS_HTTP, ContainerAppProbe_HttpGet_Scheme_STATUS_HTTPS))
}

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

func Test_ContainerAppProbe_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 ContainerAppProbe_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerAppProbe_STATUS, ContainerAppProbe_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ContainerAppProbe_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 ContainerAppProbe_STATUS instances for property testing - lazily instantiated by
// ContainerAppProbe_STATUSGenerator()
var containerAppProbe_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainerAppProbe_STATUS(generators)
	AddRelatedPropertyGeneratorsForContainerAppProbe_STATUS(generators)
	containerAppProbe_STATUSGenerator = gen.Struct(reflect.TypeOf(ContainerAppProbe_STATUS{}), generators)

	return containerAppProbe_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForContainerAppProbe_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainerAppProbe_STATUS(gens map[string]gopter.Gen) {
	gens["FailureThreshold"] = gen.PtrOf(gen.Int())
	gens["InitialDelaySeconds"] = gen.PtrOf(gen.Int())
	gens["PeriodSeconds"] = gen.PtrOf(gen.Int())
	gens["SuccessThreshold"] = gen.PtrOf(gen.Int())
	gens["TerminationGracePeriodSeconds"] = gen.PtrOf(gen.Int())
	gens["TimeoutSeconds"] = gen.PtrOf(gen.Int())
	gens["Type"] = gen.PtrOf(gen.OneConstOf(ContainerAppProbe_Type_STATUS_Liveness, ContainerAppProbe_Type_STATUS_Readiness, ContainerAppProbe_Type_STATUS_Startup))
}

// AddRelatedPropertyGeneratorsForContainerAppProbe_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForContainerAppProbe_STATUS(gens map[string]gopter.Gen) {
	gens["HttpGet"] = gen.PtrOf(ContainerAppProbe_HttpGet_STATUSGenerator())
	gens["TcpSocket"] = gen.PtrOf(ContainerAppProbe_TcpSocket_STATUSGenerator())
}

func Test_ContainerAppProbe_TcpSocket_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 ContainerAppProbe_TcpSocket_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerAppProbe_TcpSocket_STATUS, ContainerAppProbe_TcpSocket_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ContainerAppProbe_TcpSocket_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 ContainerAppProbe_TcpSocket_STATUS instances for property testing - lazily instantiated by
// ContainerAppProbe_TcpSocket_STATUSGenerator()
var containerAppProbe_TcpSocket_STATUSGenerator gopter.Gen

// ContainerAppProbe_TcpSocket_STATUSGenerator returns a generator of ContainerAppProbe_TcpSocket_STATUS instances for property testing.
func ContainerAppProbe_TcpSocket_STATUSGenerator() gopter.Gen {
	if containerAppProbe_TcpSocket_STATUSGenerator != nil {
		return containerAppProbe_TcpSocket_STATUSGenerator
	}

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

	return containerAppProbe_TcpSocket_STATUSGenerator
}

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

func Test_ContainerApp_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 ContainerApp_Properties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerApp_Properties_STATUS, ContainerApp_Properties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ContainerApp_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 ContainerApp_Properties_STATUS instances for property testing - lazily instantiated by
// ContainerApp_Properties_STATUSGenerator()
var containerApp_Properties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainerApp_Properties_STATUS(generators)
	AddRelatedPropertyGeneratorsForContainerApp_Properties_STATUS(generators)
	containerApp_Properties_STATUSGenerator = gen.Struct(reflect.TypeOf(ContainerApp_Properties_STATUS{}), generators)

	return containerApp_Properties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForContainerApp_Properties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainerApp_Properties_STATUS(gens map[string]gopter.Gen) {
	gens["CustomDomainVerificationId"] = gen.PtrOf(gen.AlphaString())
	gens["EnvironmentId"] = gen.PtrOf(gen.AlphaString())
	gens["EventStreamEndpoint"] = gen.PtrOf(gen.AlphaString())
	gens["LatestReadyRevisionName"] = gen.PtrOf(gen.AlphaString())
	gens["LatestRevisionFqdn"] = gen.PtrOf(gen.AlphaString())
	gens["LatestRevisionName"] = gen.PtrOf(gen.AlphaString())
	gens["ManagedEnvironmentId"] = gen.PtrOf(gen.AlphaString())
	gens["OutboundIpAddresses"] = gen.SliceOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ContainerApp_Properties_ProvisioningState_STATUS_Canceled,
		ContainerApp_Properties_ProvisioningState_STATUS_Deleting,
		ContainerApp_Properties_ProvisioningState_STATUS_Failed,
		ContainerApp_Properties_ProvisioningState_STATUS_InProgress,
		ContainerApp_Properties_ProvisioningState_STATUS_Succeeded))
	gens["RunningStatus"] = gen.PtrOf(gen.OneConstOf(
		ContainerApp_Properties_RunningStatus_STATUS_Progressing,
		ContainerApp_Properties_RunningStatus_STATUS_Ready,
		ContainerApp_Properties_RunningStatus_STATUS_Running,
		ContainerApp_Properties_RunningStatus_STATUS_Stopped,
		ContainerApp_Properties_RunningStatus_STATUS_Suspended))
	gens["WorkloadProfileName"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForContainerApp_Properties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForContainerApp_Properties_STATUS(gens map[string]gopter.Gen) {
	gens["Configuration"] = gen.PtrOf(Configuration_STATUSGenerator())
	gens["Template"] = gen.PtrOf(Template_STATUSGenerator())
}

func Test_ContainerApp_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 ContainerApp_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerApp_STATUS, ContainerApp_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ContainerApp_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 ContainerApp_STATUS instances for property testing - lazily instantiated by
// ContainerApp_STATUSGenerator()
var containerApp_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainerApp_STATUS(generators)
	AddRelatedPropertyGeneratorsForContainerApp_STATUS(generators)
	containerApp_STATUSGenerator = gen.Struct(reflect.TypeOf(ContainerApp_STATUS{}), generators)

	return containerApp_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForContainerApp_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForContainerApp_STATUS(gens map[string]gopter.Gen) {
	gens["ExtendedLocation"] = gen.PtrOf(ExtendedLocation_STATUSGenerator())
	gens["Identity"] = gen.PtrOf(ManagedServiceIdentity_STATUSGenerator())
	gens["Properties"] = gen.PtrOf(ContainerApp_Properties_STATUSGenerator())
	gens["SystemData"] = gen.PtrOf(SystemData_STATUSGenerator())
}

func Test_ContainerResources_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 ContainerResources_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainerResources_STATUS, ContainerResources_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ContainerResources_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 ContainerResources_STATUS instances for property testing - lazily instantiated by
// ContainerResources_STATUSGenerator()
var containerResources_STATUSGenerator gopter.Gen

// ContainerResources_STATUSGenerator returns a generator of ContainerResources_STATUS instances for property testing.
func ContainerResources_STATUSGenerator() gopter.Gen {
	if containerResources_STATUSGenerator != nil {
		return containerResources_STATUSGenerator
	}

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

	return containerResources_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForContainerResources_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainerResources_STATUS(gens map[string]gopter.Gen) {
	gens["Cpu"] = gen.PtrOf(gen.Float64())
	gens["EphemeralStorage"] = gen.PtrOf(gen.AlphaString())
	gens["Memory"] = gen.PtrOf(gen.AlphaString())
}

func Test_Container_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 Container_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForContainer_STATUS, Container_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Container_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 Container_STATUS instances for property testing - lazily instantiated by Container_STATUSGenerator()
var container_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForContainer_STATUS(generators)
	AddRelatedPropertyGeneratorsForContainer_STATUS(generators)
	container_STATUSGenerator = gen.Struct(reflect.TypeOf(Container_STATUS{}), generators)

	return container_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForContainer_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForContainer_STATUS(gens map[string]gopter.Gen) {
	gens["Args"] = gen.SliceOf(gen.AlphaString())
	gens["Command"] = gen.SliceOf(gen.AlphaString())
	gens["Image"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForContainer_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForContainer_STATUS(gens map[string]gopter.Gen) {
	gens["Env"] = gen.SliceOf(EnvironmentVar_STATUSGenerator())
	gens["Probes"] = gen.SliceOf(ContainerAppProbe_STATUSGenerator())
	gens["Resources"] = gen.PtrOf(ContainerResources_STATUSGenerator())
	gens["VolumeMounts"] = gen.SliceOf(VolumeMount_STATUSGenerator())
}

func Test_CorsPolicy_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 CorsPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCorsPolicy_STATUS, CorsPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CorsPolicy_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 CorsPolicy_STATUS instances for property testing - lazily instantiated by CorsPolicy_STATUSGenerator()
var corsPolicy_STATUSGenerator gopter.Gen

// CorsPolicy_STATUSGenerator returns a generator of CorsPolicy_STATUS instances for property testing.
func CorsPolicy_STATUSGenerator() gopter.Gen {
	if corsPolicy_STATUSGenerator != nil {
		return corsPolicy_STATUSGenerator
	}

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

	return corsPolicy_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForCorsPolicy_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCorsPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["AllowCredentials"] = gen.PtrOf(gen.Bool())
	gens["AllowedHeaders"] = gen.SliceOf(gen.AlphaString())
	gens["AllowedMethods"] = gen.SliceOf(gen.AlphaString())
	gens["AllowedOrigins"] = gen.SliceOf(gen.AlphaString())
	gens["ExposeHeaders"] = gen.SliceOf(gen.AlphaString())
	gens["MaxAge"] = gen.PtrOf(gen.Int())
}

func Test_CustomDomain_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 CustomDomain_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCustomDomain_STATUS, CustomDomain_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CustomDomain_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 CustomDomain_STATUS instances for property testing - lazily instantiated by
// CustomDomain_STATUSGenerator()
var customDomain_STATUSGenerator gopter.Gen

// CustomDomain_STATUSGenerator returns a generator of CustomDomain_STATUS instances for property testing.
func CustomDomain_STATUSGenerator() gopter.Gen {
	if customDomain_STATUSGenerator != nil {
		return customDomain_STATUSGenerator
	}

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

	return customDomain_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForCustomDomain_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCustomDomain_STATUS(gens map[string]gopter.Gen) {
	gens["BindingType"] = gen.PtrOf(gen.OneConstOf(CustomDomain_BindingType_STATUS_Disabled, CustomDomain_BindingType_STATUS_SniEnabled))
	gens["CertificateId"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
}

func Test_CustomScaleRule_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 CustomScaleRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCustomScaleRule_STATUS, CustomScaleRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CustomScaleRule_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 CustomScaleRule_STATUS instances for property testing - lazily instantiated by
// CustomScaleRule_STATUSGenerator()
var customScaleRule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForCustomScaleRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForCustomScaleRule_STATUS(generators)
	customScaleRule_STATUSGenerator = gen.Struct(reflect.TypeOf(CustomScaleRule_STATUS{}), generators)

	return customScaleRule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForCustomScaleRule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForCustomScaleRule_STATUS(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(gen.AlphaString())
	gens["Metadata"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["Type"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_Dapr_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 Dapr_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDapr_STATUS, Dapr_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Dapr_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 Dapr_STATUS instances for property testing - lazily instantiated by Dapr_STATUSGenerator()
var dapr_STATUSGenerator gopter.Gen

// Dapr_STATUSGenerator returns a generator of Dapr_STATUS instances for property testing.
func Dapr_STATUSGenerator() gopter.Gen {
	if dapr_STATUSGenerator != nil {
		return dapr_STATUSGenerator
	}

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

	return dapr_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForDapr_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDapr_STATUS(gens map[string]gopter.Gen) {
	gens["AppId"] = gen.PtrOf(gen.AlphaString())
	gens["AppPort"] = gen.PtrOf(gen.Int())
	gens["AppProtocol"] = gen.PtrOf(gen.OneConstOf(Dapr_AppProtocol_STATUS_Grpc, Dapr_AppProtocol_STATUS_Http))
	gens["EnableApiLogging"] = gen.PtrOf(gen.Bool())
	gens["Enabled"] = gen.PtrOf(gen.Bool())
	gens["HttpMaxRequestSize"] = gen.PtrOf(gen.Int())
	gens["HttpReadBufferSize"] = gen.PtrOf(gen.Int())
	gens["LogLevel"] = gen.PtrOf(gen.OneConstOf(
		Dapr_LogLevel_STATUS_Debug,
		Dapr_LogLevel_STATUS_Error,
		Dapr_LogLevel_STATUS_Info,
		Dapr_LogLevel_STATUS_Warn))
}

func Test_EnvironmentVar_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 EnvironmentVar_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEnvironmentVar_STATUS, EnvironmentVar_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EnvironmentVar_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 EnvironmentVar_STATUS instances for property testing - lazily instantiated by
// EnvironmentVar_STATUSGenerator()
var environmentVar_STATUSGenerator gopter.Gen

// EnvironmentVar_STATUSGenerator returns a generator of EnvironmentVar_STATUS instances for property testing.
func EnvironmentVar_STATUSGenerator() gopter.Gen {
	if environmentVar_STATUSGenerator != nil {
		return environmentVar_STATUSGenerator
	}

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

	return environmentVar_STATUSGenerator
}

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

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

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

	// Deserialize back into memory
	var actual ExtendedLocation_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 ExtendedLocation_STATUS instances for property testing - lazily instantiated by
// ExtendedLocation_STATUSGenerator()
var extendedLocation_STATUSGenerator gopter.Gen

// ExtendedLocation_STATUSGenerator returns a generator of ExtendedLocation_STATUS instances for property testing.
func ExtendedLocation_STATUSGenerator() gopter.Gen {
	if extendedLocation_STATUSGenerator != nil {
		return extendedLocation_STATUSGenerator
	}

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

	return extendedLocation_STATUSGenerator
}

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

func Test_HttpScaleRule_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 HttpScaleRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForHttpScaleRule_STATUS, HttpScaleRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual HttpScaleRule_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 HttpScaleRule_STATUS instances for property testing - lazily instantiated by
// HttpScaleRule_STATUSGenerator()
var httpScaleRule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForHttpScaleRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForHttpScaleRule_STATUS(generators)
	httpScaleRule_STATUSGenerator = gen.Struct(reflect.TypeOf(HttpScaleRule_STATUS{}), generators)

	return httpScaleRule_STATUSGenerator
}

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

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

func Test_IdentitySettings_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 IdentitySettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIdentitySettings_STATUS, IdentitySettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual IdentitySettings_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 IdentitySettings_STATUS instances for property testing - lazily instantiated by
// IdentitySettings_STATUSGenerator()
var identitySettings_STATUSGenerator gopter.Gen

// IdentitySettings_STATUSGenerator returns a generator of IdentitySettings_STATUS instances for property testing.
func IdentitySettings_STATUSGenerator() gopter.Gen {
	if identitySettings_STATUSGenerator != nil {
		return identitySettings_STATUSGenerator
	}

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

	return identitySettings_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIdentitySettings_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIdentitySettings_STATUS(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(gen.AlphaString())
	gens["Lifecycle"] = gen.PtrOf(gen.OneConstOf(
		IdentitySettings_Lifecycle_STATUS_All,
		IdentitySettings_Lifecycle_STATUS_Init,
		IdentitySettings_Lifecycle_STATUS_Main,
		IdentitySettings_Lifecycle_STATUS_None))
}

func Test_IngressPortMapping_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 IngressPortMapping_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIngressPortMapping_STATUS, IngressPortMapping_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual IngressPortMapping_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 IngressPortMapping_STATUS instances for property testing - lazily instantiated by
// IngressPortMapping_STATUSGenerator()
var ingressPortMapping_STATUSGenerator gopter.Gen

// IngressPortMapping_STATUSGenerator returns a generator of IngressPortMapping_STATUS instances for property testing.
func IngressPortMapping_STATUSGenerator() gopter.Gen {
	if ingressPortMapping_STATUSGenerator != nil {
		return ingressPortMapping_STATUSGenerator
	}

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

	return ingressPortMapping_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIngressPortMapping_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIngressPortMapping_STATUS(gens map[string]gopter.Gen) {
	gens["ExposedPort"] = gen.PtrOf(gen.Int())
	gens["External"] = gen.PtrOf(gen.Bool())
	gens["TargetPort"] = gen.PtrOf(gen.Int())
}

func Test_Ingress_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 Ingress_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIngress_STATUS, Ingress_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Ingress_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 Ingress_STATUS instances for property testing - lazily instantiated by Ingress_STATUSGenerator()
var ingress_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForIngress_STATUS(generators)
	AddRelatedPropertyGeneratorsForIngress_STATUS(generators)
	ingress_STATUSGenerator = gen.Struct(reflect.TypeOf(Ingress_STATUS{}), generators)

	return ingress_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIngress_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIngress_STATUS(gens map[string]gopter.Gen) {
	gens["AllowInsecure"] = gen.PtrOf(gen.Bool())
	gens["ClientCertificateMode"] = gen.PtrOf(gen.OneConstOf(Ingress_ClientCertificateMode_STATUS_Accept, Ingress_ClientCertificateMode_STATUS_Ignore, Ingress_ClientCertificateMode_STATUS_Require))
	gens["ExposedPort"] = gen.PtrOf(gen.Int())
	gens["External"] = gen.PtrOf(gen.Bool())
	gens["Fqdn"] = gen.PtrOf(gen.AlphaString())
	gens["TargetPort"] = gen.PtrOf(gen.Int())
	gens["Transport"] = gen.PtrOf(gen.OneConstOf(
		Ingress_Transport_STATUS_Auto,
		Ingress_Transport_STATUS_Http,
		Ingress_Transport_STATUS_Http2,
		Ingress_Transport_STATUS_Tcp))
}

// AddRelatedPropertyGeneratorsForIngress_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForIngress_STATUS(gens map[string]gopter.Gen) {
	gens["AdditionalPortMappings"] = gen.SliceOf(IngressPortMapping_STATUSGenerator())
	gens["CorsPolicy"] = gen.PtrOf(CorsPolicy_STATUSGenerator())
	gens["CustomDomains"] = gen.SliceOf(CustomDomain_STATUSGenerator())
	gens["IpSecurityRestrictions"] = gen.SliceOf(IpSecurityRestrictionRule_STATUSGenerator())
	gens["StickySessions"] = gen.PtrOf(Ingress_StickySessions_STATUSGenerator())
	gens["Traffic"] = gen.SliceOf(TrafficWeight_STATUSGenerator())
}

func Test_Ingress_StickySessions_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 Ingress_StickySessions_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIngress_StickySessions_STATUS, Ingress_StickySessions_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Ingress_StickySessions_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 Ingress_StickySessions_STATUS instances for property testing - lazily instantiated by
// Ingress_StickySessions_STATUSGenerator()
var ingress_StickySessions_STATUSGenerator gopter.Gen

// Ingress_StickySessions_STATUSGenerator returns a generator of Ingress_StickySessions_STATUS instances for property testing.
func Ingress_StickySessions_STATUSGenerator() gopter.Gen {
	if ingress_StickySessions_STATUSGenerator != nil {
		return ingress_StickySessions_STATUSGenerator
	}

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

	return ingress_StickySessions_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIngress_StickySessions_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIngress_StickySessions_STATUS(gens map[string]gopter.Gen) {
	gens["Affinity"] = gen.PtrOf(gen.OneConstOf(Ingress_StickySessions_Affinity_STATUS_None, Ingress_StickySessions_Affinity_STATUS_Sticky))
}

func Test_IpSecurityRestrictionRule_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 IpSecurityRestrictionRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIpSecurityRestrictionRule_STATUS, IpSecurityRestrictionRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual IpSecurityRestrictionRule_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 IpSecurityRestrictionRule_STATUS instances for property testing - lazily instantiated by
// IpSecurityRestrictionRule_STATUSGenerator()
var ipSecurityRestrictionRule_STATUSGenerator gopter.Gen

// IpSecurityRestrictionRule_STATUSGenerator returns a generator of IpSecurityRestrictionRule_STATUS instances for property testing.
func IpSecurityRestrictionRule_STATUSGenerator() gopter.Gen {
	if ipSecurityRestrictionRule_STATUSGenerator != nil {
		return ipSecurityRestrictionRule_STATUSGenerator
	}

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

	return ipSecurityRestrictionRule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIpSecurityRestrictionRule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIpSecurityRestrictionRule_STATUS(gens map[string]gopter.Gen) {
	gens["Action"] = gen.PtrOf(gen.OneConstOf(IpSecurityRestrictionRule_Action_STATUS_Allow, IpSecurityRestrictionRule_Action_STATUS_Deny))
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["IpAddressRange"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

	return ""
}

// Generator of ManagedServiceIdentity_STATUS instances for property testing - lazily instantiated by
// ManagedServiceIdentity_STATUSGenerator()
var managedServiceIdentity_STATUSGenerator gopter.Gen

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

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

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

	return managedServiceIdentity_STATUSGenerator
}

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

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

func Test_QueueScaleRule_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 QueueScaleRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForQueueScaleRule_STATUS, QueueScaleRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual QueueScaleRule_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 QueueScaleRule_STATUS instances for property testing - lazily instantiated by
// QueueScaleRule_STATUSGenerator()
var queueScaleRule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForQueueScaleRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForQueueScaleRule_STATUS(generators)
	queueScaleRule_STATUSGenerator = gen.Struct(reflect.TypeOf(QueueScaleRule_STATUS{}), generators)

	return queueScaleRule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForQueueScaleRule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForQueueScaleRule_STATUS(gens map[string]gopter.Gen) {
	gens["AccountName"] = gen.PtrOf(gen.AlphaString())
	gens["Identity"] = gen.PtrOf(gen.AlphaString())
	gens["QueueLength"] = gen.PtrOf(gen.Int())
	gens["QueueName"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_RegistryCredentials_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 RegistryCredentials_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRegistryCredentials_STATUS, RegistryCredentials_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual RegistryCredentials_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 RegistryCredentials_STATUS instances for property testing - lazily instantiated by
// RegistryCredentials_STATUSGenerator()
var registryCredentials_STATUSGenerator gopter.Gen

// RegistryCredentials_STATUSGenerator returns a generator of RegistryCredentials_STATUS instances for property testing.
func RegistryCredentials_STATUSGenerator() gopter.Gen {
	if registryCredentials_STATUSGenerator != nil {
		return registryCredentials_STATUSGenerator
	}

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

	return registryCredentials_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForRegistryCredentials_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForRegistryCredentials_STATUS(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(gen.AlphaString())
	gens["PasswordSecretRef"] = gen.PtrOf(gen.AlphaString())
	gens["Server"] = gen.PtrOf(gen.AlphaString())
	gens["Username"] = gen.PtrOf(gen.AlphaString())
}

func Test_Runtime_Java_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 Runtime_Java_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRuntime_Java_STATUS, Runtime_Java_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Runtime_Java_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 Runtime_Java_STATUS instances for property testing - lazily instantiated by
// Runtime_Java_STATUSGenerator()
var runtime_Java_STATUSGenerator gopter.Gen

// Runtime_Java_STATUSGenerator returns a generator of Runtime_Java_STATUS instances for property testing.
func Runtime_Java_STATUSGenerator() gopter.Gen {
	if runtime_Java_STATUSGenerator != nil {
		return runtime_Java_STATUSGenerator
	}

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

	return runtime_Java_STATUSGenerator
}

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

func Test_Runtime_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 Runtime_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRuntime_STATUS, Runtime_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Runtime_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 Runtime_STATUS instances for property testing - lazily instantiated by Runtime_STATUSGenerator()
var runtime_STATUSGenerator gopter.Gen

// Runtime_STATUSGenerator returns a generator of Runtime_STATUS instances for property testing.
func Runtime_STATUSGenerator() gopter.Gen {
	if runtime_STATUSGenerator != nil {
		return runtime_STATUSGenerator
	}

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

	return runtime_STATUSGenerator
}

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

func Test_ScaleRuleAuth_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 ScaleRuleAuth_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScaleRuleAuth_STATUS, ScaleRuleAuth_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ScaleRuleAuth_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 ScaleRuleAuth_STATUS instances for property testing - lazily instantiated by
// ScaleRuleAuth_STATUSGenerator()
var scaleRuleAuth_STATUSGenerator gopter.Gen

// ScaleRuleAuth_STATUSGenerator returns a generator of ScaleRuleAuth_STATUS instances for property testing.
func ScaleRuleAuth_STATUSGenerator() gopter.Gen {
	if scaleRuleAuth_STATUSGenerator != nil {
		return scaleRuleAuth_STATUSGenerator
	}

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

	return scaleRuleAuth_STATUSGenerator
}

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

func Test_ScaleRule_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 ScaleRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScaleRule_STATUS, ScaleRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ScaleRule_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 ScaleRule_STATUS instances for property testing - lazily instantiated by ScaleRule_STATUSGenerator()
var scaleRule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForScaleRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForScaleRule_STATUS(generators)
	scaleRule_STATUSGenerator = gen.Struct(reflect.TypeOf(ScaleRule_STATUS{}), generators)

	return scaleRule_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForScaleRule_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForScaleRule_STATUS(gens map[string]gopter.Gen) {
	gens["AzureQueue"] = gen.PtrOf(QueueScaleRule_STATUSGenerator())
	gens["Custom"] = gen.PtrOf(CustomScaleRule_STATUSGenerator())
	gens["Http"] = gen.PtrOf(HttpScaleRule_STATUSGenerator())
	gens["Tcp"] = gen.PtrOf(TcpScaleRule_STATUSGenerator())
}

func Test_Scale_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 Scale_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScale_STATUS, Scale_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Scale_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 Scale_STATUS instances for property testing - lazily instantiated by Scale_STATUSGenerator()
var scale_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForScale_STATUS(generators)
	AddRelatedPropertyGeneratorsForScale_STATUS(generators)
	scale_STATUSGenerator = gen.Struct(reflect.TypeOf(Scale_STATUS{}), generators)

	return scale_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForScale_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForScale_STATUS(gens map[string]gopter.Gen) {
	gens["CooldownPeriod"] = gen.PtrOf(gen.Int())
	gens["MaxReplicas"] = gen.PtrOf(gen.Int())
	gens["MinReplicas"] = gen.PtrOf(gen.Int())
	gens["PollingInterval"] = gen.PtrOf(gen.Int())
}

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

func Test_SecretVolumeItem_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 SecretVolumeItem_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSecretVolumeItem_STATUS, SecretVolumeItem_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SecretVolumeItem_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 SecretVolumeItem_STATUS instances for property testing - lazily instantiated by
// SecretVolumeItem_STATUSGenerator()
var secretVolumeItem_STATUSGenerator gopter.Gen

// SecretVolumeItem_STATUSGenerator returns a generator of SecretVolumeItem_STATUS instances for property testing.
func SecretVolumeItem_STATUSGenerator() gopter.Gen {
	if secretVolumeItem_STATUSGenerator != nil {
		return secretVolumeItem_STATUSGenerator
	}

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

	return secretVolumeItem_STATUSGenerator
}

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

func Test_Secret_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 Secret_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSecret_STATUS, Secret_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Secret_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 Secret_STATUS instances for property testing - lazily instantiated by Secret_STATUSGenerator()
var secret_STATUSGenerator gopter.Gen

// Secret_STATUSGenerator returns a generator of Secret_STATUS instances for property testing.
func Secret_STATUSGenerator() gopter.Gen {
	if secret_STATUSGenerator != nil {
		return secret_STATUSGenerator
	}

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

	return secret_STATUSGenerator
}

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

func Test_ServiceBind_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 ServiceBind_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServiceBind_STATUS, ServiceBind_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ServiceBind_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 ServiceBind_STATUS instances for property testing - lazily instantiated by ServiceBind_STATUSGenerator()
var serviceBind_STATUSGenerator gopter.Gen

// ServiceBind_STATUSGenerator returns a generator of ServiceBind_STATUS instances for property testing.
func ServiceBind_STATUSGenerator() gopter.Gen {
	if serviceBind_STATUSGenerator != nil {
		return serviceBind_STATUSGenerator
	}

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

	return serviceBind_STATUSGenerator
}

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

func Test_Service_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 Service_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForService_STATUS, Service_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Service_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 Service_STATUS instances for property testing - lazily instantiated by Service_STATUSGenerator()
var service_STATUSGenerator gopter.Gen

// Service_STATUSGenerator returns a generator of Service_STATUS instances for property testing.
func Service_STATUSGenerator() gopter.Gen {
	if service_STATUSGenerator != nil {
		return service_STATUSGenerator
	}

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

	return service_STATUSGenerator
}

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

func Test_TcpScaleRule_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 TcpScaleRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTcpScaleRule_STATUS, TcpScaleRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual TcpScaleRule_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 TcpScaleRule_STATUS instances for property testing - lazily instantiated by
// TcpScaleRule_STATUSGenerator()
var tcpScaleRule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForTcpScaleRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForTcpScaleRule_STATUS(generators)
	tcpScaleRule_STATUSGenerator = gen.Struct(reflect.TypeOf(TcpScaleRule_STATUS{}), generators)

	return tcpScaleRule_STATUSGenerator
}

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

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

func Test_Template_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 Template_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTemplate_STATUS, Template_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Template_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 Template_STATUS instances for property testing - lazily instantiated by Template_STATUSGenerator()
var template_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForTemplate_STATUS(generators)
	AddRelatedPropertyGeneratorsForTemplate_STATUS(generators)
	template_STATUSGenerator = gen.Struct(reflect.TypeOf(Template_STATUS{}), generators)

	return template_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForTemplate_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForTemplate_STATUS(gens map[string]gopter.Gen) {
	gens["Containers"] = gen.SliceOf(Container_STATUSGenerator())
	gens["InitContainers"] = gen.SliceOf(BaseContainer_STATUSGenerator())
	gens["Scale"] = gen.PtrOf(Scale_STATUSGenerator())
	gens["ServiceBinds"] = gen.SliceOf(ServiceBind_STATUSGenerator())
	gens["Volumes"] = gen.SliceOf(Volume_STATUSGenerator())
}

func Test_TrafficWeight_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 TrafficWeight_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTrafficWeight_STATUS, TrafficWeight_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual TrafficWeight_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 TrafficWeight_STATUS instances for property testing - lazily instantiated by
// TrafficWeight_STATUSGenerator()
var trafficWeight_STATUSGenerator gopter.Gen

// TrafficWeight_STATUSGenerator returns a generator of TrafficWeight_STATUS instances for property testing.
func TrafficWeight_STATUSGenerator() gopter.Gen {
	if trafficWeight_STATUSGenerator != nil {
		return trafficWeight_STATUSGenerator
	}

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

	return trafficWeight_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForTrafficWeight_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForTrafficWeight_STATUS(gens map[string]gopter.Gen) {
	gens["Label"] = gen.PtrOf(gen.AlphaString())
	gens["LatestRevision"] = gen.PtrOf(gen.Bool())
	gens["RevisionName"] = gen.PtrOf(gen.AlphaString())
	gens["Weight"] = gen.PtrOf(gen.Int())
}

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

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

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

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

	return ""
}

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

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

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

	return userAssignedIdentity_STATUSGenerator
}

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

func Test_VolumeMount_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 VolumeMount_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVolumeMount_STATUS, VolumeMount_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual VolumeMount_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 VolumeMount_STATUS instances for property testing - lazily instantiated by VolumeMount_STATUSGenerator()
var volumeMount_STATUSGenerator gopter.Gen

// VolumeMount_STATUSGenerator returns a generator of VolumeMount_STATUS instances for property testing.
func VolumeMount_STATUSGenerator() gopter.Gen {
	if volumeMount_STATUSGenerator != nil {
		return volumeMount_STATUSGenerator
	}

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

	return volumeMount_STATUSGenerator
}

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

func Test_Volume_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 Volume_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVolume_STATUS, Volume_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Volume_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 Volume_STATUS instances for property testing - lazily instantiated by Volume_STATUSGenerator()
var volume_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVolume_STATUS(generators)
	AddRelatedPropertyGeneratorsForVolume_STATUS(generators)
	volume_STATUSGenerator = gen.Struct(reflect.TypeOf(Volume_STATUS{}), generators)

	return volume_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVolume_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVolume_STATUS(gens map[string]gopter.Gen) {
	gens["MountOptions"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["StorageName"] = gen.PtrOf(gen.AlphaString())
	gens["StorageType"] = gen.PtrOf(gen.OneConstOf(
		Volume_StorageType_STATUS_AzureFile,
		Volume_StorageType_STATUS_EmptyDir,
		Volume_StorageType_STATUS_NfsAzureFile,
		Volume_StorageType_STATUS_Secret))
}

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