// 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_AdvancedFilter_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 AdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAdvancedFilter_STATUS, AdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AdvancedFilter_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 AdvancedFilter_STATUS instances for property testing - lazily instantiated by
// AdvancedFilter_STATUSGenerator()
var advancedFilter_STATUSGenerator gopter.Gen

// AdvancedFilter_STATUSGenerator returns a generator of AdvancedFilter_STATUS instances for property testing.
func AdvancedFilter_STATUSGenerator() gopter.Gen {
	if advancedFilter_STATUSGenerator != nil {
		return advancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForAdvancedFilter_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(AdvancedFilter_STATUS{}), props))
	}
	advancedFilter_STATUSGenerator = gen.OneGenOf(gens...)

	return advancedFilter_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["BoolEquals"] = BoolEqualsAdvancedFilter_STATUSGenerator().Map(func(it BoolEqualsAdvancedFilter_STATUS) *BoolEqualsAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["NumberGreaterThan"] = NumberGreaterThanAdvancedFilter_STATUSGenerator().Map(func(it NumberGreaterThanAdvancedFilter_STATUS) *NumberGreaterThanAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["NumberGreaterThanOrEquals"] = NumberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator().Map(func(it NumberGreaterThanOrEqualsAdvancedFilter_STATUS) *NumberGreaterThanOrEqualsAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["NumberIn"] = NumberInAdvancedFilter_STATUSGenerator().Map(func(it NumberInAdvancedFilter_STATUS) *NumberInAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["NumberLessThan"] = NumberLessThanAdvancedFilter_STATUSGenerator().Map(func(it NumberLessThanAdvancedFilter_STATUS) *NumberLessThanAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["NumberLessThanOrEquals"] = NumberLessThanOrEqualsAdvancedFilter_STATUSGenerator().Map(func(it NumberLessThanOrEqualsAdvancedFilter_STATUS) *NumberLessThanOrEqualsAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["NumberNotIn"] = NumberNotInAdvancedFilter_STATUSGenerator().Map(func(it NumberNotInAdvancedFilter_STATUS) *NumberNotInAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["StringBeginsWith"] = StringBeginsWithAdvancedFilter_STATUSGenerator().Map(func(it StringBeginsWithAdvancedFilter_STATUS) *StringBeginsWithAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["StringContains"] = StringContainsAdvancedFilter_STATUSGenerator().Map(func(it StringContainsAdvancedFilter_STATUS) *StringContainsAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["StringEndsWith"] = StringEndsWithAdvancedFilter_STATUSGenerator().Map(func(it StringEndsWithAdvancedFilter_STATUS) *StringEndsWithAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["StringIn"] = StringInAdvancedFilter_STATUSGenerator().Map(func(it StringInAdvancedFilter_STATUS) *StringInAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["StringNotIn"] = StringNotInAdvancedFilter_STATUSGenerator().Map(func(it StringNotInAdvancedFilter_STATUS) *StringNotInAdvancedFilter_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_AzureFunctionEventSubscriptionDestinationProperties_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 AzureFunctionEventSubscriptionDestinationProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAzureFunctionEventSubscriptionDestinationProperties_STATUS, AzureFunctionEventSubscriptionDestinationProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AzureFunctionEventSubscriptionDestinationProperties_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 AzureFunctionEventSubscriptionDestinationProperties_STATUS instances for property testing - lazily
// instantiated by AzureFunctionEventSubscriptionDestinationProperties_STATUSGenerator()
var azureFunctionEventSubscriptionDestinationProperties_STATUSGenerator gopter.Gen

// AzureFunctionEventSubscriptionDestinationProperties_STATUSGenerator returns a generator of AzureFunctionEventSubscriptionDestinationProperties_STATUS instances for property testing.
func AzureFunctionEventSubscriptionDestinationProperties_STATUSGenerator() gopter.Gen {
	if azureFunctionEventSubscriptionDestinationProperties_STATUSGenerator != nil {
		return azureFunctionEventSubscriptionDestinationProperties_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAzureFunctionEventSubscriptionDestinationProperties_STATUS(generators)
	azureFunctionEventSubscriptionDestinationProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(AzureFunctionEventSubscriptionDestinationProperties_STATUS{}), generators)

	return azureFunctionEventSubscriptionDestinationProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAzureFunctionEventSubscriptionDestinationProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAzureFunctionEventSubscriptionDestinationProperties_STATUS(gens map[string]gopter.Gen) {
	gens["MaxEventsPerBatch"] = gen.PtrOf(gen.Int())
	gens["PreferredBatchSizeInKilobytes"] = gen.PtrOf(gen.Int())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

func Test_AzureFunctionEventSubscriptionDestination_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 AzureFunctionEventSubscriptionDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAzureFunctionEventSubscriptionDestination_STATUS, AzureFunctionEventSubscriptionDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AzureFunctionEventSubscriptionDestination_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 AzureFunctionEventSubscriptionDestination_STATUS instances for property testing - lazily instantiated by
// AzureFunctionEventSubscriptionDestination_STATUSGenerator()
var azureFunctionEventSubscriptionDestination_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAzureFunctionEventSubscriptionDestination_STATUS(generators)
	azureFunctionEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(AzureFunctionEventSubscriptionDestination_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAzureFunctionEventSubscriptionDestination_STATUS(generators)
	AddRelatedPropertyGeneratorsForAzureFunctionEventSubscriptionDestination_STATUS(generators)
	azureFunctionEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(AzureFunctionEventSubscriptionDestination_STATUS{}), generators)

	return azureFunctionEventSubscriptionDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAzureFunctionEventSubscriptionDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAzureFunctionEventSubscriptionDestination_STATUS(gens map[string]gopter.Gen) {
	gens["EndpointType"] = gen.OneConstOf(AzureFunctionEventSubscriptionDestination_EndpointType_STATUS_AzureFunction)
}

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

func Test_BoolEqualsAdvancedFilter_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 BoolEqualsAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBoolEqualsAdvancedFilter_STATUS, BoolEqualsAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BoolEqualsAdvancedFilter_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 BoolEqualsAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// BoolEqualsAdvancedFilter_STATUSGenerator()
var boolEqualsAdvancedFilter_STATUSGenerator gopter.Gen

// BoolEqualsAdvancedFilter_STATUSGenerator returns a generator of BoolEqualsAdvancedFilter_STATUS instances for property testing.
func BoolEqualsAdvancedFilter_STATUSGenerator() gopter.Gen {
	if boolEqualsAdvancedFilter_STATUSGenerator != nil {
		return boolEqualsAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForBoolEqualsAdvancedFilter_STATUS(generators)
	boolEqualsAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(BoolEqualsAdvancedFilter_STATUS{}), generators)

	return boolEqualsAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForBoolEqualsAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForBoolEqualsAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(BoolEqualsAdvancedFilter_OperatorType_STATUS_BoolEquals)
	gens["Value"] = gen.PtrOf(gen.Bool())
}

func Test_DeadLetterDestination_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 DeadLetterDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDeadLetterDestination_STATUS, DeadLetterDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DeadLetterDestination_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 DeadLetterDestination_STATUS instances for property testing - lazily instantiated by
// DeadLetterDestination_STATUSGenerator()
var deadLetterDestination_STATUSGenerator gopter.Gen

// DeadLetterDestination_STATUSGenerator returns a generator of DeadLetterDestination_STATUS instances for property testing.
func DeadLetterDestination_STATUSGenerator() gopter.Gen {
	if deadLetterDestination_STATUSGenerator != nil {
		return deadLetterDestination_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForDeadLetterDestination_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(DeadLetterDestination_STATUS{}), props))
	}
	deadLetterDestination_STATUSGenerator = gen.OneGenOf(gens...)

	return deadLetterDestination_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForDeadLetterDestination_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDeadLetterDestination_STATUS(gens map[string]gopter.Gen) {
	gens["StorageBlob"] = StorageBlobDeadLetterDestination_STATUSGenerator().Map(func(it StorageBlobDeadLetterDestination_STATUS) *StorageBlobDeadLetterDestination_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_EventHubEventSubscriptionDestinationProperties_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 EventHubEventSubscriptionDestinationProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEventHubEventSubscriptionDestinationProperties_STATUS, EventHubEventSubscriptionDestinationProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EventHubEventSubscriptionDestinationProperties_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 EventHubEventSubscriptionDestinationProperties_STATUS instances for property testing - lazily
// instantiated by EventHubEventSubscriptionDestinationProperties_STATUSGenerator()
var eventHubEventSubscriptionDestinationProperties_STATUSGenerator gopter.Gen

// EventHubEventSubscriptionDestinationProperties_STATUSGenerator returns a generator of EventHubEventSubscriptionDestinationProperties_STATUS instances for property testing.
func EventHubEventSubscriptionDestinationProperties_STATUSGenerator() gopter.Gen {
	if eventHubEventSubscriptionDestinationProperties_STATUSGenerator != nil {
		return eventHubEventSubscriptionDestinationProperties_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEventHubEventSubscriptionDestinationProperties_STATUS(generators)
	eventHubEventSubscriptionDestinationProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(EventHubEventSubscriptionDestinationProperties_STATUS{}), generators)

	return eventHubEventSubscriptionDestinationProperties_STATUSGenerator
}

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

func Test_EventHubEventSubscriptionDestination_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 EventHubEventSubscriptionDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEventHubEventSubscriptionDestination_STATUS, EventHubEventSubscriptionDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EventHubEventSubscriptionDestination_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 EventHubEventSubscriptionDestination_STATUS instances for property testing - lazily instantiated by
// EventHubEventSubscriptionDestination_STATUSGenerator()
var eventHubEventSubscriptionDestination_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEventHubEventSubscriptionDestination_STATUS(generators)
	eventHubEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(EventHubEventSubscriptionDestination_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEventHubEventSubscriptionDestination_STATUS(generators)
	AddRelatedPropertyGeneratorsForEventHubEventSubscriptionDestination_STATUS(generators)
	eventHubEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(EventHubEventSubscriptionDestination_STATUS{}), generators)

	return eventHubEventSubscriptionDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForEventHubEventSubscriptionDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForEventHubEventSubscriptionDestination_STATUS(gens map[string]gopter.Gen) {
	gens["EndpointType"] = gen.OneConstOf(EventHubEventSubscriptionDestination_EndpointType_STATUS_EventHub)
}

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

func Test_EventSubscriptionDestination_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 EventSubscriptionDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEventSubscriptionDestination_STATUS, EventSubscriptionDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EventSubscriptionDestination_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 EventSubscriptionDestination_STATUS instances for property testing - lazily instantiated by
// EventSubscriptionDestination_STATUSGenerator()
var eventSubscriptionDestination_STATUSGenerator gopter.Gen

// EventSubscriptionDestination_STATUSGenerator returns a generator of EventSubscriptionDestination_STATUS instances for property testing.
func EventSubscriptionDestination_STATUSGenerator() gopter.Gen {
	if eventSubscriptionDestination_STATUSGenerator != nil {
		return eventSubscriptionDestination_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForEventSubscriptionDestination_STATUS(generators)

	// handle OneOf by choosing only one field to instantiate
	var gens []gopter.Gen
	for propName, propGen := range generators {
		props := map[string]gopter.Gen{propName: propGen}
		gens = append(gens, gen.Struct(reflect.TypeOf(EventSubscriptionDestination_STATUS{}), props))
	}
	eventSubscriptionDestination_STATUSGenerator = gen.OneGenOf(gens...)

	return eventSubscriptionDestination_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForEventSubscriptionDestination_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForEventSubscriptionDestination_STATUS(gens map[string]gopter.Gen) {
	gens["AzureFunction"] = AzureFunctionEventSubscriptionDestination_STATUSGenerator().Map(func(it AzureFunctionEventSubscriptionDestination_STATUS) *AzureFunctionEventSubscriptionDestination_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["EventHub"] = EventHubEventSubscriptionDestination_STATUSGenerator().Map(func(it EventHubEventSubscriptionDestination_STATUS) *EventHubEventSubscriptionDestination_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["HybridConnection"] = HybridConnectionEventSubscriptionDestination_STATUSGenerator().Map(func(it HybridConnectionEventSubscriptionDestination_STATUS) *HybridConnectionEventSubscriptionDestination_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["ServiceBusQueue"] = ServiceBusQueueEventSubscriptionDestination_STATUSGenerator().Map(func(it ServiceBusQueueEventSubscriptionDestination_STATUS) *ServiceBusQueueEventSubscriptionDestination_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["ServiceBusTopic"] = ServiceBusTopicEventSubscriptionDestination_STATUSGenerator().Map(func(it ServiceBusTopicEventSubscriptionDestination_STATUS) *ServiceBusTopicEventSubscriptionDestination_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["StorageQueue"] = StorageQueueEventSubscriptionDestination_STATUSGenerator().Map(func(it StorageQueueEventSubscriptionDestination_STATUS) *StorageQueueEventSubscriptionDestination_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["WebHook"] = WebHookEventSubscriptionDestination_STATUSGenerator().Map(func(it WebHookEventSubscriptionDestination_STATUS) *WebHookEventSubscriptionDestination_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_EventSubscriptionFilter_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 EventSubscriptionFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEventSubscriptionFilter_STATUS, EventSubscriptionFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EventSubscriptionFilter_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 EventSubscriptionFilter_STATUS instances for property testing - lazily instantiated by
// EventSubscriptionFilter_STATUSGenerator()
var eventSubscriptionFilter_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEventSubscriptionFilter_STATUS(generators)
	eventSubscriptionFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(EventSubscriptionFilter_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEventSubscriptionFilter_STATUS(generators)
	AddRelatedPropertyGeneratorsForEventSubscriptionFilter_STATUS(generators)
	eventSubscriptionFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(EventSubscriptionFilter_STATUS{}), generators)

	return eventSubscriptionFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForEventSubscriptionFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForEventSubscriptionFilter_STATUS(gens map[string]gopter.Gen) {
	gens["IncludedEventTypes"] = gen.SliceOf(gen.AlphaString())
	gens["IsSubjectCaseSensitive"] = gen.PtrOf(gen.Bool())
	gens["SubjectBeginsWith"] = gen.PtrOf(gen.AlphaString())
	gens["SubjectEndsWith"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_EventSubscriptionProperties_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 EventSubscriptionProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEventSubscriptionProperties_STATUS, EventSubscriptionProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EventSubscriptionProperties_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 EventSubscriptionProperties_STATUS instances for property testing - lazily instantiated by
// EventSubscriptionProperties_STATUSGenerator()
var eventSubscriptionProperties_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEventSubscriptionProperties_STATUS(generators)
	eventSubscriptionProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(EventSubscriptionProperties_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEventSubscriptionProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForEventSubscriptionProperties_STATUS(generators)
	eventSubscriptionProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(EventSubscriptionProperties_STATUS{}), generators)

	return eventSubscriptionProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForEventSubscriptionProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForEventSubscriptionProperties_STATUS(gens map[string]gopter.Gen) {
	gens["EventDeliverySchema"] = gen.PtrOf(gen.OneConstOf(EventSubscriptionProperties_EventDeliverySchema_STATUS_CloudEventSchemaV1_0, EventSubscriptionProperties_EventDeliverySchema_STATUS_CustomInputSchema, EventSubscriptionProperties_EventDeliverySchema_STATUS_EventGridSchema))
	gens["ExpirationTimeUtc"] = gen.PtrOf(gen.AlphaString())
	gens["Labels"] = gen.SliceOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		EventSubscriptionProperties_ProvisioningState_STATUS_AwaitingManualAction,
		EventSubscriptionProperties_ProvisioningState_STATUS_Canceled,
		EventSubscriptionProperties_ProvisioningState_STATUS_Creating,
		EventSubscriptionProperties_ProvisioningState_STATUS_Deleting,
		EventSubscriptionProperties_ProvisioningState_STATUS_Failed,
		EventSubscriptionProperties_ProvisioningState_STATUS_Succeeded,
		EventSubscriptionProperties_ProvisioningState_STATUS_Updating))
	gens["Topic"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForEventSubscriptionProperties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForEventSubscriptionProperties_STATUS(gens map[string]gopter.Gen) {
	gens["DeadLetterDestination"] = gen.PtrOf(DeadLetterDestination_STATUSGenerator())
	gens["Destination"] = gen.PtrOf(EventSubscriptionDestination_STATUSGenerator())
	gens["Filter"] = gen.PtrOf(EventSubscriptionFilter_STATUSGenerator())
	gens["RetryPolicy"] = gen.PtrOf(RetryPolicy_STATUSGenerator())
}

func Test_EventSubscription_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 EventSubscription_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEventSubscription_STATUS, EventSubscription_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EventSubscription_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 EventSubscription_STATUS instances for property testing - lazily instantiated by
// EventSubscription_STATUSGenerator()
var eventSubscription_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEventSubscription_STATUS(generators)
	eventSubscription_STATUSGenerator = gen.Struct(reflect.TypeOf(EventSubscription_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForEventSubscription_STATUS(generators)
	AddRelatedPropertyGeneratorsForEventSubscription_STATUS(generators)
	eventSubscription_STATUSGenerator = gen.Struct(reflect.TypeOf(EventSubscription_STATUS{}), generators)

	return eventSubscription_STATUSGenerator
}

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

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

func Test_HybridConnectionEventSubscriptionDestinationProperties_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 HybridConnectionEventSubscriptionDestinationProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForHybridConnectionEventSubscriptionDestinationProperties_STATUS, HybridConnectionEventSubscriptionDestinationProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual HybridConnectionEventSubscriptionDestinationProperties_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 HybridConnectionEventSubscriptionDestinationProperties_STATUS instances for property testing - lazily
// instantiated by HybridConnectionEventSubscriptionDestinationProperties_STATUSGenerator()
var hybridConnectionEventSubscriptionDestinationProperties_STATUSGenerator gopter.Gen

// HybridConnectionEventSubscriptionDestinationProperties_STATUSGenerator returns a generator of HybridConnectionEventSubscriptionDestinationProperties_STATUS instances for property testing.
func HybridConnectionEventSubscriptionDestinationProperties_STATUSGenerator() gopter.Gen {
	if hybridConnectionEventSubscriptionDestinationProperties_STATUSGenerator != nil {
		return hybridConnectionEventSubscriptionDestinationProperties_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForHybridConnectionEventSubscriptionDestinationProperties_STATUS(generators)
	hybridConnectionEventSubscriptionDestinationProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(HybridConnectionEventSubscriptionDestinationProperties_STATUS{}), generators)

	return hybridConnectionEventSubscriptionDestinationProperties_STATUSGenerator
}

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

func Test_HybridConnectionEventSubscriptionDestination_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 HybridConnectionEventSubscriptionDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForHybridConnectionEventSubscriptionDestination_STATUS, HybridConnectionEventSubscriptionDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual HybridConnectionEventSubscriptionDestination_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 HybridConnectionEventSubscriptionDestination_STATUS instances for property testing - lazily instantiated
// by HybridConnectionEventSubscriptionDestination_STATUSGenerator()
var hybridConnectionEventSubscriptionDestination_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForHybridConnectionEventSubscriptionDestination_STATUS(generators)
	hybridConnectionEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(HybridConnectionEventSubscriptionDestination_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForHybridConnectionEventSubscriptionDestination_STATUS(generators)
	AddRelatedPropertyGeneratorsForHybridConnectionEventSubscriptionDestination_STATUS(generators)
	hybridConnectionEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(HybridConnectionEventSubscriptionDestination_STATUS{}), generators)

	return hybridConnectionEventSubscriptionDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForHybridConnectionEventSubscriptionDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForHybridConnectionEventSubscriptionDestination_STATUS(gens map[string]gopter.Gen) {
	gens["EndpointType"] = gen.OneConstOf(HybridConnectionEventSubscriptionDestination_EndpointType_STATUS_HybridConnection)
}

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

func Test_NumberGreaterThanAdvancedFilter_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 NumberGreaterThanAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNumberGreaterThanAdvancedFilter_STATUS, NumberGreaterThanAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NumberGreaterThanAdvancedFilter_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 NumberGreaterThanAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// NumberGreaterThanAdvancedFilter_STATUSGenerator()
var numberGreaterThanAdvancedFilter_STATUSGenerator gopter.Gen

// NumberGreaterThanAdvancedFilter_STATUSGenerator returns a generator of NumberGreaterThanAdvancedFilter_STATUS instances for property testing.
func NumberGreaterThanAdvancedFilter_STATUSGenerator() gopter.Gen {
	if numberGreaterThanAdvancedFilter_STATUSGenerator != nil {
		return numberGreaterThanAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNumberGreaterThanAdvancedFilter_STATUS(generators)
	numberGreaterThanAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(NumberGreaterThanAdvancedFilter_STATUS{}), generators)

	return numberGreaterThanAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNumberGreaterThanAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNumberGreaterThanAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(NumberGreaterThanAdvancedFilter_OperatorType_STATUS_NumberGreaterThan)
	gens["Value"] = gen.PtrOf(gen.Float64())
}

func Test_NumberGreaterThanOrEqualsAdvancedFilter_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 NumberGreaterThanOrEqualsAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNumberGreaterThanOrEqualsAdvancedFilter_STATUS, NumberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NumberGreaterThanOrEqualsAdvancedFilter_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 NumberGreaterThanOrEqualsAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// NumberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator()
var numberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator gopter.Gen

// NumberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator returns a generator of NumberGreaterThanOrEqualsAdvancedFilter_STATUS instances for property testing.
func NumberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator() gopter.Gen {
	if numberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator != nil {
		return numberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNumberGreaterThanOrEqualsAdvancedFilter_STATUS(generators)
	numberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(NumberGreaterThanOrEqualsAdvancedFilter_STATUS{}), generators)

	return numberGreaterThanOrEqualsAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNumberGreaterThanOrEqualsAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNumberGreaterThanOrEqualsAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(NumberGreaterThanOrEqualsAdvancedFilter_OperatorType_STATUS_NumberGreaterThanOrEquals)
	gens["Value"] = gen.PtrOf(gen.Float64())
}

func Test_NumberInAdvancedFilter_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 NumberInAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNumberInAdvancedFilter_STATUS, NumberInAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NumberInAdvancedFilter_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 NumberInAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// NumberInAdvancedFilter_STATUSGenerator()
var numberInAdvancedFilter_STATUSGenerator gopter.Gen

// NumberInAdvancedFilter_STATUSGenerator returns a generator of NumberInAdvancedFilter_STATUS instances for property testing.
func NumberInAdvancedFilter_STATUSGenerator() gopter.Gen {
	if numberInAdvancedFilter_STATUSGenerator != nil {
		return numberInAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNumberInAdvancedFilter_STATUS(generators)
	numberInAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(NumberInAdvancedFilter_STATUS{}), generators)

	return numberInAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNumberInAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNumberInAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(NumberInAdvancedFilter_OperatorType_STATUS_NumberIn)
	gens["Values"] = gen.SliceOf(gen.Float64())
}

func Test_NumberLessThanAdvancedFilter_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 NumberLessThanAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNumberLessThanAdvancedFilter_STATUS, NumberLessThanAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NumberLessThanAdvancedFilter_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 NumberLessThanAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// NumberLessThanAdvancedFilter_STATUSGenerator()
var numberLessThanAdvancedFilter_STATUSGenerator gopter.Gen

// NumberLessThanAdvancedFilter_STATUSGenerator returns a generator of NumberLessThanAdvancedFilter_STATUS instances for property testing.
func NumberLessThanAdvancedFilter_STATUSGenerator() gopter.Gen {
	if numberLessThanAdvancedFilter_STATUSGenerator != nil {
		return numberLessThanAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNumberLessThanAdvancedFilter_STATUS(generators)
	numberLessThanAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(NumberLessThanAdvancedFilter_STATUS{}), generators)

	return numberLessThanAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNumberLessThanAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNumberLessThanAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(NumberLessThanAdvancedFilter_OperatorType_STATUS_NumberLessThan)
	gens["Value"] = gen.PtrOf(gen.Float64())
}

func Test_NumberLessThanOrEqualsAdvancedFilter_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 NumberLessThanOrEqualsAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNumberLessThanOrEqualsAdvancedFilter_STATUS, NumberLessThanOrEqualsAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NumberLessThanOrEqualsAdvancedFilter_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 NumberLessThanOrEqualsAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// NumberLessThanOrEqualsAdvancedFilter_STATUSGenerator()
var numberLessThanOrEqualsAdvancedFilter_STATUSGenerator gopter.Gen

// NumberLessThanOrEqualsAdvancedFilter_STATUSGenerator returns a generator of NumberLessThanOrEqualsAdvancedFilter_STATUS instances for property testing.
func NumberLessThanOrEqualsAdvancedFilter_STATUSGenerator() gopter.Gen {
	if numberLessThanOrEqualsAdvancedFilter_STATUSGenerator != nil {
		return numberLessThanOrEqualsAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNumberLessThanOrEqualsAdvancedFilter_STATUS(generators)
	numberLessThanOrEqualsAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(NumberLessThanOrEqualsAdvancedFilter_STATUS{}), generators)

	return numberLessThanOrEqualsAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNumberLessThanOrEqualsAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNumberLessThanOrEqualsAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(NumberLessThanOrEqualsAdvancedFilter_OperatorType_STATUS_NumberLessThanOrEquals)
	gens["Value"] = gen.PtrOf(gen.Float64())
}

func Test_NumberNotInAdvancedFilter_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 NumberNotInAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNumberNotInAdvancedFilter_STATUS, NumberNotInAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NumberNotInAdvancedFilter_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 NumberNotInAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// NumberNotInAdvancedFilter_STATUSGenerator()
var numberNotInAdvancedFilter_STATUSGenerator gopter.Gen

// NumberNotInAdvancedFilter_STATUSGenerator returns a generator of NumberNotInAdvancedFilter_STATUS instances for property testing.
func NumberNotInAdvancedFilter_STATUSGenerator() gopter.Gen {
	if numberNotInAdvancedFilter_STATUSGenerator != nil {
		return numberNotInAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForNumberNotInAdvancedFilter_STATUS(generators)
	numberNotInAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(NumberNotInAdvancedFilter_STATUS{}), generators)

	return numberNotInAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNumberNotInAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNumberNotInAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(NumberNotInAdvancedFilter_OperatorType_STATUS_NumberNotIn)
	gens["Values"] = gen.SliceOf(gen.Float64())
}

func Test_RetryPolicy_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 RetryPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRetryPolicy_STATUS, RetryPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual RetryPolicy_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 RetryPolicy_STATUS instances for property testing - lazily instantiated by RetryPolicy_STATUSGenerator()
var retryPolicy_STATUSGenerator gopter.Gen

// RetryPolicy_STATUSGenerator returns a generator of RetryPolicy_STATUS instances for property testing.
func RetryPolicy_STATUSGenerator() gopter.Gen {
	if retryPolicy_STATUSGenerator != nil {
		return retryPolicy_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForRetryPolicy_STATUS(generators)
	retryPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(RetryPolicy_STATUS{}), generators)

	return retryPolicy_STATUSGenerator
}

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

func Test_ServiceBusQueueEventSubscriptionDestinationProperties_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 ServiceBusQueueEventSubscriptionDestinationProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServiceBusQueueEventSubscriptionDestinationProperties_STATUS, ServiceBusQueueEventSubscriptionDestinationProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ServiceBusQueueEventSubscriptionDestinationProperties_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 ServiceBusQueueEventSubscriptionDestinationProperties_STATUS instances for property testing - lazily
// instantiated by ServiceBusQueueEventSubscriptionDestinationProperties_STATUSGenerator()
var serviceBusQueueEventSubscriptionDestinationProperties_STATUSGenerator gopter.Gen

// ServiceBusQueueEventSubscriptionDestinationProperties_STATUSGenerator returns a generator of ServiceBusQueueEventSubscriptionDestinationProperties_STATUS instances for property testing.
func ServiceBusQueueEventSubscriptionDestinationProperties_STATUSGenerator() gopter.Gen {
	if serviceBusQueueEventSubscriptionDestinationProperties_STATUSGenerator != nil {
		return serviceBusQueueEventSubscriptionDestinationProperties_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForServiceBusQueueEventSubscriptionDestinationProperties_STATUS(generators)
	serviceBusQueueEventSubscriptionDestinationProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(ServiceBusQueueEventSubscriptionDestinationProperties_STATUS{}), generators)

	return serviceBusQueueEventSubscriptionDestinationProperties_STATUSGenerator
}

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

func Test_ServiceBusQueueEventSubscriptionDestination_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 ServiceBusQueueEventSubscriptionDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServiceBusQueueEventSubscriptionDestination_STATUS, ServiceBusQueueEventSubscriptionDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ServiceBusQueueEventSubscriptionDestination_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 ServiceBusQueueEventSubscriptionDestination_STATUS instances for property testing - lazily instantiated
// by ServiceBusQueueEventSubscriptionDestination_STATUSGenerator()
var serviceBusQueueEventSubscriptionDestination_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForServiceBusQueueEventSubscriptionDestination_STATUS(generators)
	serviceBusQueueEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(ServiceBusQueueEventSubscriptionDestination_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForServiceBusQueueEventSubscriptionDestination_STATUS(generators)
	AddRelatedPropertyGeneratorsForServiceBusQueueEventSubscriptionDestination_STATUS(generators)
	serviceBusQueueEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(ServiceBusQueueEventSubscriptionDestination_STATUS{}), generators)

	return serviceBusQueueEventSubscriptionDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForServiceBusQueueEventSubscriptionDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForServiceBusQueueEventSubscriptionDestination_STATUS(gens map[string]gopter.Gen) {
	gens["EndpointType"] = gen.OneConstOf(ServiceBusQueueEventSubscriptionDestination_EndpointType_STATUS_ServiceBusQueue)
}

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

func Test_ServiceBusTopicEventSubscriptionDestinationProperties_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 ServiceBusTopicEventSubscriptionDestinationProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServiceBusTopicEventSubscriptionDestinationProperties_STATUS, ServiceBusTopicEventSubscriptionDestinationProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ServiceBusTopicEventSubscriptionDestinationProperties_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 ServiceBusTopicEventSubscriptionDestinationProperties_STATUS instances for property testing - lazily
// instantiated by ServiceBusTopicEventSubscriptionDestinationProperties_STATUSGenerator()
var serviceBusTopicEventSubscriptionDestinationProperties_STATUSGenerator gopter.Gen

// ServiceBusTopicEventSubscriptionDestinationProperties_STATUSGenerator returns a generator of ServiceBusTopicEventSubscriptionDestinationProperties_STATUS instances for property testing.
func ServiceBusTopicEventSubscriptionDestinationProperties_STATUSGenerator() gopter.Gen {
	if serviceBusTopicEventSubscriptionDestinationProperties_STATUSGenerator != nil {
		return serviceBusTopicEventSubscriptionDestinationProperties_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForServiceBusTopicEventSubscriptionDestinationProperties_STATUS(generators)
	serviceBusTopicEventSubscriptionDestinationProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(ServiceBusTopicEventSubscriptionDestinationProperties_STATUS{}), generators)

	return serviceBusTopicEventSubscriptionDestinationProperties_STATUSGenerator
}

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

func Test_ServiceBusTopicEventSubscriptionDestination_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 ServiceBusTopicEventSubscriptionDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForServiceBusTopicEventSubscriptionDestination_STATUS, ServiceBusTopicEventSubscriptionDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ServiceBusTopicEventSubscriptionDestination_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 ServiceBusTopicEventSubscriptionDestination_STATUS instances for property testing - lazily instantiated
// by ServiceBusTopicEventSubscriptionDestination_STATUSGenerator()
var serviceBusTopicEventSubscriptionDestination_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForServiceBusTopicEventSubscriptionDestination_STATUS(generators)
	serviceBusTopicEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(ServiceBusTopicEventSubscriptionDestination_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForServiceBusTopicEventSubscriptionDestination_STATUS(generators)
	AddRelatedPropertyGeneratorsForServiceBusTopicEventSubscriptionDestination_STATUS(generators)
	serviceBusTopicEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(ServiceBusTopicEventSubscriptionDestination_STATUS{}), generators)

	return serviceBusTopicEventSubscriptionDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForServiceBusTopicEventSubscriptionDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForServiceBusTopicEventSubscriptionDestination_STATUS(gens map[string]gopter.Gen) {
	gens["EndpointType"] = gen.OneConstOf(ServiceBusTopicEventSubscriptionDestination_EndpointType_STATUS_ServiceBusTopic)
}

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

func Test_StorageBlobDeadLetterDestinationProperties_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 StorageBlobDeadLetterDestinationProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStorageBlobDeadLetterDestinationProperties_STATUS, StorageBlobDeadLetterDestinationProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StorageBlobDeadLetterDestinationProperties_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 StorageBlobDeadLetterDestinationProperties_STATUS instances for property testing - lazily instantiated
// by StorageBlobDeadLetterDestinationProperties_STATUSGenerator()
var storageBlobDeadLetterDestinationProperties_STATUSGenerator gopter.Gen

// StorageBlobDeadLetterDestinationProperties_STATUSGenerator returns a generator of StorageBlobDeadLetterDestinationProperties_STATUS instances for property testing.
func StorageBlobDeadLetterDestinationProperties_STATUSGenerator() gopter.Gen {
	if storageBlobDeadLetterDestinationProperties_STATUSGenerator != nil {
		return storageBlobDeadLetterDestinationProperties_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStorageBlobDeadLetterDestinationProperties_STATUS(generators)
	storageBlobDeadLetterDestinationProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(StorageBlobDeadLetterDestinationProperties_STATUS{}), generators)

	return storageBlobDeadLetterDestinationProperties_STATUSGenerator
}

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

func Test_StorageBlobDeadLetterDestination_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 StorageBlobDeadLetterDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStorageBlobDeadLetterDestination_STATUS, StorageBlobDeadLetterDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StorageBlobDeadLetterDestination_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 StorageBlobDeadLetterDestination_STATUS instances for property testing - lazily instantiated by
// StorageBlobDeadLetterDestination_STATUSGenerator()
var storageBlobDeadLetterDestination_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStorageBlobDeadLetterDestination_STATUS(generators)
	storageBlobDeadLetterDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(StorageBlobDeadLetterDestination_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStorageBlobDeadLetterDestination_STATUS(generators)
	AddRelatedPropertyGeneratorsForStorageBlobDeadLetterDestination_STATUS(generators)
	storageBlobDeadLetterDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(StorageBlobDeadLetterDestination_STATUS{}), generators)

	return storageBlobDeadLetterDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForStorageBlobDeadLetterDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForStorageBlobDeadLetterDestination_STATUS(gens map[string]gopter.Gen) {
	gens["EndpointType"] = gen.OneConstOf(StorageBlobDeadLetterDestination_EndpointType_STATUS_StorageBlob)
}

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

func Test_StorageQueueEventSubscriptionDestinationProperties_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 StorageQueueEventSubscriptionDestinationProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStorageQueueEventSubscriptionDestinationProperties_STATUS, StorageQueueEventSubscriptionDestinationProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StorageQueueEventSubscriptionDestinationProperties_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 StorageQueueEventSubscriptionDestinationProperties_STATUS instances for property testing - lazily
// instantiated by StorageQueueEventSubscriptionDestinationProperties_STATUSGenerator()
var storageQueueEventSubscriptionDestinationProperties_STATUSGenerator gopter.Gen

// StorageQueueEventSubscriptionDestinationProperties_STATUSGenerator returns a generator of StorageQueueEventSubscriptionDestinationProperties_STATUS instances for property testing.
func StorageQueueEventSubscriptionDestinationProperties_STATUSGenerator() gopter.Gen {
	if storageQueueEventSubscriptionDestinationProperties_STATUSGenerator != nil {
		return storageQueueEventSubscriptionDestinationProperties_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStorageQueueEventSubscriptionDestinationProperties_STATUS(generators)
	storageQueueEventSubscriptionDestinationProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(StorageQueueEventSubscriptionDestinationProperties_STATUS{}), generators)

	return storageQueueEventSubscriptionDestinationProperties_STATUSGenerator
}

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

func Test_StorageQueueEventSubscriptionDestination_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 StorageQueueEventSubscriptionDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStorageQueueEventSubscriptionDestination_STATUS, StorageQueueEventSubscriptionDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StorageQueueEventSubscriptionDestination_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 StorageQueueEventSubscriptionDestination_STATUS instances for property testing - lazily instantiated by
// StorageQueueEventSubscriptionDestination_STATUSGenerator()
var storageQueueEventSubscriptionDestination_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStorageQueueEventSubscriptionDestination_STATUS(generators)
	storageQueueEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(StorageQueueEventSubscriptionDestination_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStorageQueueEventSubscriptionDestination_STATUS(generators)
	AddRelatedPropertyGeneratorsForStorageQueueEventSubscriptionDestination_STATUS(generators)
	storageQueueEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(StorageQueueEventSubscriptionDestination_STATUS{}), generators)

	return storageQueueEventSubscriptionDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForStorageQueueEventSubscriptionDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForStorageQueueEventSubscriptionDestination_STATUS(gens map[string]gopter.Gen) {
	gens["EndpointType"] = gen.OneConstOf(StorageQueueEventSubscriptionDestination_EndpointType_STATUS_StorageQueue)
}

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

func Test_StringBeginsWithAdvancedFilter_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 StringBeginsWithAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStringBeginsWithAdvancedFilter_STATUS, StringBeginsWithAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StringBeginsWithAdvancedFilter_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 StringBeginsWithAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// StringBeginsWithAdvancedFilter_STATUSGenerator()
var stringBeginsWithAdvancedFilter_STATUSGenerator gopter.Gen

// StringBeginsWithAdvancedFilter_STATUSGenerator returns a generator of StringBeginsWithAdvancedFilter_STATUS instances for property testing.
func StringBeginsWithAdvancedFilter_STATUSGenerator() gopter.Gen {
	if stringBeginsWithAdvancedFilter_STATUSGenerator != nil {
		return stringBeginsWithAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStringBeginsWithAdvancedFilter_STATUS(generators)
	stringBeginsWithAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(StringBeginsWithAdvancedFilter_STATUS{}), generators)

	return stringBeginsWithAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForStringBeginsWithAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForStringBeginsWithAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(StringBeginsWithAdvancedFilter_OperatorType_STATUS_StringBeginsWith)
	gens["Values"] = gen.SliceOf(gen.AlphaString())
}

func Test_StringContainsAdvancedFilter_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 StringContainsAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStringContainsAdvancedFilter_STATUS, StringContainsAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StringContainsAdvancedFilter_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 StringContainsAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// StringContainsAdvancedFilter_STATUSGenerator()
var stringContainsAdvancedFilter_STATUSGenerator gopter.Gen

// StringContainsAdvancedFilter_STATUSGenerator returns a generator of StringContainsAdvancedFilter_STATUS instances for property testing.
func StringContainsAdvancedFilter_STATUSGenerator() gopter.Gen {
	if stringContainsAdvancedFilter_STATUSGenerator != nil {
		return stringContainsAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStringContainsAdvancedFilter_STATUS(generators)
	stringContainsAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(StringContainsAdvancedFilter_STATUS{}), generators)

	return stringContainsAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForStringContainsAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForStringContainsAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(StringContainsAdvancedFilter_OperatorType_STATUS_StringContains)
	gens["Values"] = gen.SliceOf(gen.AlphaString())
}

func Test_StringEndsWithAdvancedFilter_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 StringEndsWithAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStringEndsWithAdvancedFilter_STATUS, StringEndsWithAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StringEndsWithAdvancedFilter_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 StringEndsWithAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// StringEndsWithAdvancedFilter_STATUSGenerator()
var stringEndsWithAdvancedFilter_STATUSGenerator gopter.Gen

// StringEndsWithAdvancedFilter_STATUSGenerator returns a generator of StringEndsWithAdvancedFilter_STATUS instances for property testing.
func StringEndsWithAdvancedFilter_STATUSGenerator() gopter.Gen {
	if stringEndsWithAdvancedFilter_STATUSGenerator != nil {
		return stringEndsWithAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStringEndsWithAdvancedFilter_STATUS(generators)
	stringEndsWithAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(StringEndsWithAdvancedFilter_STATUS{}), generators)

	return stringEndsWithAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForStringEndsWithAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForStringEndsWithAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(StringEndsWithAdvancedFilter_OperatorType_STATUS_StringEndsWith)
	gens["Values"] = gen.SliceOf(gen.AlphaString())
}

func Test_StringInAdvancedFilter_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 StringInAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStringInAdvancedFilter_STATUS, StringInAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StringInAdvancedFilter_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 StringInAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// StringInAdvancedFilter_STATUSGenerator()
var stringInAdvancedFilter_STATUSGenerator gopter.Gen

// StringInAdvancedFilter_STATUSGenerator returns a generator of StringInAdvancedFilter_STATUS instances for property testing.
func StringInAdvancedFilter_STATUSGenerator() gopter.Gen {
	if stringInAdvancedFilter_STATUSGenerator != nil {
		return stringInAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStringInAdvancedFilter_STATUS(generators)
	stringInAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(StringInAdvancedFilter_STATUS{}), generators)

	return stringInAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForStringInAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForStringInAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(StringInAdvancedFilter_OperatorType_STATUS_StringIn)
	gens["Values"] = gen.SliceOf(gen.AlphaString())
}

func Test_StringNotInAdvancedFilter_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 StringNotInAdvancedFilter_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStringNotInAdvancedFilter_STATUS, StringNotInAdvancedFilter_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StringNotInAdvancedFilter_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 StringNotInAdvancedFilter_STATUS instances for property testing - lazily instantiated by
// StringNotInAdvancedFilter_STATUSGenerator()
var stringNotInAdvancedFilter_STATUSGenerator gopter.Gen

// StringNotInAdvancedFilter_STATUSGenerator returns a generator of StringNotInAdvancedFilter_STATUS instances for property testing.
func StringNotInAdvancedFilter_STATUSGenerator() gopter.Gen {
	if stringNotInAdvancedFilter_STATUSGenerator != nil {
		return stringNotInAdvancedFilter_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForStringNotInAdvancedFilter_STATUS(generators)
	stringNotInAdvancedFilter_STATUSGenerator = gen.Struct(reflect.TypeOf(StringNotInAdvancedFilter_STATUS{}), generators)

	return stringNotInAdvancedFilter_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForStringNotInAdvancedFilter_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForStringNotInAdvancedFilter_STATUS(gens map[string]gopter.Gen) {
	gens["Key"] = gen.PtrOf(gen.AlphaString())
	gens["OperatorType"] = gen.OneConstOf(StringNotInAdvancedFilter_OperatorType_STATUS_StringNotIn)
	gens["Values"] = gen.SliceOf(gen.AlphaString())
}

func Test_WebHookEventSubscriptionDestinationProperties_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 WebHookEventSubscriptionDestinationProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWebHookEventSubscriptionDestinationProperties_STATUS, WebHookEventSubscriptionDestinationProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual WebHookEventSubscriptionDestinationProperties_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 WebHookEventSubscriptionDestinationProperties_STATUS instances for property testing - lazily
// instantiated by WebHookEventSubscriptionDestinationProperties_STATUSGenerator()
var webHookEventSubscriptionDestinationProperties_STATUSGenerator gopter.Gen

// WebHookEventSubscriptionDestinationProperties_STATUSGenerator returns a generator of WebHookEventSubscriptionDestinationProperties_STATUS instances for property testing.
func WebHookEventSubscriptionDestinationProperties_STATUSGenerator() gopter.Gen {
	if webHookEventSubscriptionDestinationProperties_STATUSGenerator != nil {
		return webHookEventSubscriptionDestinationProperties_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForWebHookEventSubscriptionDestinationProperties_STATUS(generators)
	webHookEventSubscriptionDestinationProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(WebHookEventSubscriptionDestinationProperties_STATUS{}), generators)

	return webHookEventSubscriptionDestinationProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForWebHookEventSubscriptionDestinationProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForWebHookEventSubscriptionDestinationProperties_STATUS(gens map[string]gopter.Gen) {
	gens["AzureActiveDirectoryApplicationIdOrUri"] = gen.PtrOf(gen.AlphaString())
	gens["AzureActiveDirectoryTenantId"] = gen.PtrOf(gen.AlphaString())
	gens["EndpointBaseUrl"] = gen.PtrOf(gen.AlphaString())
	gens["MaxEventsPerBatch"] = gen.PtrOf(gen.Int())
	gens["PreferredBatchSizeInKilobytes"] = gen.PtrOf(gen.Int())
}

func Test_WebHookEventSubscriptionDestination_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 WebHookEventSubscriptionDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWebHookEventSubscriptionDestination_STATUS, WebHookEventSubscriptionDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual WebHookEventSubscriptionDestination_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 WebHookEventSubscriptionDestination_STATUS instances for property testing - lazily instantiated by
// WebHookEventSubscriptionDestination_STATUSGenerator()
var webHookEventSubscriptionDestination_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForWebHookEventSubscriptionDestination_STATUS(generators)
	webHookEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(WebHookEventSubscriptionDestination_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForWebHookEventSubscriptionDestination_STATUS(generators)
	AddRelatedPropertyGeneratorsForWebHookEventSubscriptionDestination_STATUS(generators)
	webHookEventSubscriptionDestination_STATUSGenerator = gen.Struct(reflect.TypeOf(WebHookEventSubscriptionDestination_STATUS{}), generators)

	return webHookEventSubscriptionDestination_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForWebHookEventSubscriptionDestination_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForWebHookEventSubscriptionDestination_STATUS(gens map[string]gopter.Gen) {
	gens["EndpointType"] = gen.OneConstOf(WebHookEventSubscriptionDestination_EndpointType_STATUS_WebHook)
}

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