// Code generated by azure-service-operator-codegen. DO NOT EDIT.
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
package storage

import (
	"encoding/json"
	v20240101s "github.com/Azure/azure-service-operator/v2/api/network/v1api20240101/storage"
	v20240301s "github.com/Azure/azure-service-operator/v2/api/network/v1api20240301/storage"
	"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_ApplicationGateway_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 20
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGateway via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGateway, ApplicationGatewayGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayGenerator returns a generator of ApplicationGateway instances for property testing.
func ApplicationGatewayGenerator() gopter.Gen {
	if applicationGatewayGenerator != nil {
		return applicationGatewayGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForApplicationGateway(generators)
	applicationGatewayGenerator = gen.Struct(reflect.TypeOf(ApplicationGateway{}), generators)

	return applicationGatewayGenerator
}

// AddRelatedPropertyGeneratorsForApplicationGateway is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGateway(gens map[string]gopter.Gen) {
	gens["Spec"] = ApplicationGateway_SpecGenerator()
	gens["Status"] = ApplicationGateway_STATUSGenerator()
}

func Test_ApplicationGatewayAuthenticationCertificate_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayAuthenticationCertificate via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayAuthenticationCertificate, ApplicationGatewayAuthenticationCertificateGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayAuthenticationCertificateGenerator returns a generator of ApplicationGatewayAuthenticationCertificate instances for property testing.
func ApplicationGatewayAuthenticationCertificateGenerator() gopter.Gen {
	if applicationGatewayAuthenticationCertificateGenerator != nil {
		return applicationGatewayAuthenticationCertificateGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayAuthenticationCertificate(generators)
	applicationGatewayAuthenticationCertificateGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayAuthenticationCertificate{}), generators)

	return applicationGatewayAuthenticationCertificateGenerator
}

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

func Test_ApplicationGatewayAuthenticationCertificate_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 ApplicationGatewayAuthenticationCertificate_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayAuthenticationCertificate_STATUS, ApplicationGatewayAuthenticationCertificate_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayAuthenticationCertificate_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 ApplicationGatewayAuthenticationCertificate_STATUS instances for property testing - lazily instantiated
// by ApplicationGatewayAuthenticationCertificate_STATUSGenerator()
var applicationGatewayAuthenticationCertificate_STATUSGenerator gopter.Gen

// ApplicationGatewayAuthenticationCertificate_STATUSGenerator returns a generator of ApplicationGatewayAuthenticationCertificate_STATUS instances for property testing.
func ApplicationGatewayAuthenticationCertificate_STATUSGenerator() gopter.Gen {
	if applicationGatewayAuthenticationCertificate_STATUSGenerator != nil {
		return applicationGatewayAuthenticationCertificate_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayAuthenticationCertificate_STATUS(generators)
	applicationGatewayAuthenticationCertificate_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayAuthenticationCertificate_STATUS{}), generators)

	return applicationGatewayAuthenticationCertificate_STATUSGenerator
}

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

func Test_ApplicationGatewayAutoscaleConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayAutoscaleConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayAutoscaleConfiguration, ApplicationGatewayAutoscaleConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayAutoscaleConfigurationGenerator returns a generator of ApplicationGatewayAutoscaleConfiguration instances for property testing.
func ApplicationGatewayAutoscaleConfigurationGenerator() gopter.Gen {
	if applicationGatewayAutoscaleConfigurationGenerator != nil {
		return applicationGatewayAutoscaleConfigurationGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayAutoscaleConfiguration(generators)
	applicationGatewayAutoscaleConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayAutoscaleConfiguration{}), generators)

	return applicationGatewayAutoscaleConfigurationGenerator
}

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

func Test_ApplicationGatewayAutoscaleConfiguration_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 ApplicationGatewayAutoscaleConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayAutoscaleConfiguration_STATUS, ApplicationGatewayAutoscaleConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayAutoscaleConfiguration_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 ApplicationGatewayAutoscaleConfiguration_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayAutoscaleConfiguration_STATUSGenerator()
var applicationGatewayAutoscaleConfiguration_STATUSGenerator gopter.Gen

// ApplicationGatewayAutoscaleConfiguration_STATUSGenerator returns a generator of ApplicationGatewayAutoscaleConfiguration_STATUS instances for property testing.
func ApplicationGatewayAutoscaleConfiguration_STATUSGenerator() gopter.Gen {
	if applicationGatewayAutoscaleConfiguration_STATUSGenerator != nil {
		return applicationGatewayAutoscaleConfiguration_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayAutoscaleConfiguration_STATUS(generators)
	applicationGatewayAutoscaleConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayAutoscaleConfiguration_STATUS{}), generators)

	return applicationGatewayAutoscaleConfiguration_STATUSGenerator
}

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

func Test_ApplicationGatewayBackendAddress_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayBackendAddress via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendAddress, ApplicationGatewayBackendAddressGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayBackendAddressGenerator returns a generator of ApplicationGatewayBackendAddress instances for property testing.
func ApplicationGatewayBackendAddressGenerator() gopter.Gen {
	if applicationGatewayBackendAddressGenerator != nil {
		return applicationGatewayBackendAddressGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendAddress(generators)
	applicationGatewayBackendAddressGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendAddress{}), generators)

	return applicationGatewayBackendAddressGenerator
}

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

func Test_ApplicationGatewayBackendAddressPool_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayBackendAddressPool via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendAddressPool, ApplicationGatewayBackendAddressPoolGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendAddressPool(generators)
	applicationGatewayBackendAddressPoolGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendAddressPool{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendAddressPool(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayBackendAddressPool(generators)
	applicationGatewayBackendAddressPoolGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendAddressPool{}), generators)

	return applicationGatewayBackendAddressPoolGenerator
}

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

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

func Test_ApplicationGatewayBackendAddressPool_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 ApplicationGatewayBackendAddressPool_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendAddressPool_STATUS, ApplicationGatewayBackendAddressPool_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayBackendAddressPool_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 ApplicationGatewayBackendAddressPool_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayBackendAddressPool_STATUSGenerator()
var applicationGatewayBackendAddressPool_STATUSGenerator gopter.Gen

// ApplicationGatewayBackendAddressPool_STATUSGenerator returns a generator of ApplicationGatewayBackendAddressPool_STATUS instances for property testing.
func ApplicationGatewayBackendAddressPool_STATUSGenerator() gopter.Gen {
	if applicationGatewayBackendAddressPool_STATUSGenerator != nil {
		return applicationGatewayBackendAddressPool_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendAddressPool_STATUS(generators)
	applicationGatewayBackendAddressPool_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendAddressPool_STATUS{}), generators)

	return applicationGatewayBackendAddressPool_STATUSGenerator
}

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

func Test_ApplicationGatewayBackendHttpSettings_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayBackendHttpSettings via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendHttpSettings, ApplicationGatewayBackendHttpSettingsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendHttpSettings(generators)
	applicationGatewayBackendHttpSettingsGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendHttpSettings{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendHttpSettings(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayBackendHttpSettings(generators)
	applicationGatewayBackendHttpSettingsGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendHttpSettings{}), generators)

	return applicationGatewayBackendHttpSettingsGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayBackendHttpSettings is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayBackendHttpSettings(gens map[string]gopter.Gen) {
	gens["AffinityCookieName"] = gen.PtrOf(gen.AlphaString())
	gens["CookieBasedAffinity"] = gen.PtrOf(gen.AlphaString())
	gens["HostName"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Path"] = gen.PtrOf(gen.AlphaString())
	gens["PickHostNameFromBackendAddress"] = gen.PtrOf(gen.Bool())
	gens["Port"] = gen.PtrOf(gen.Int())
	gens["ProbeEnabled"] = gen.PtrOf(gen.Bool())
	gens["Protocol"] = gen.PtrOf(gen.AlphaString())
	gens["RequestTimeout"] = gen.PtrOf(gen.Int())
}

// AddRelatedPropertyGeneratorsForApplicationGatewayBackendHttpSettings is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayBackendHttpSettings(gens map[string]gopter.Gen) {
	gens["AuthenticationCertificates"] = gen.SliceOf(SubResourceGenerator())
	gens["ConnectionDraining"] = gen.PtrOf(ApplicationGatewayConnectionDrainingGenerator())
	gens["Probe"] = gen.PtrOf(SubResourceGenerator())
	gens["TrustedRootCertificates"] = gen.SliceOf(SubResourceGenerator())
}

func Test_ApplicationGatewayBackendHttpSettings_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 ApplicationGatewayBackendHttpSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendHttpSettings_STATUS, ApplicationGatewayBackendHttpSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayBackendHttpSettings_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 ApplicationGatewayBackendHttpSettings_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayBackendHttpSettings_STATUSGenerator()
var applicationGatewayBackendHttpSettings_STATUSGenerator gopter.Gen

// ApplicationGatewayBackendHttpSettings_STATUSGenerator returns a generator of ApplicationGatewayBackendHttpSettings_STATUS instances for property testing.
func ApplicationGatewayBackendHttpSettings_STATUSGenerator() gopter.Gen {
	if applicationGatewayBackendHttpSettings_STATUSGenerator != nil {
		return applicationGatewayBackendHttpSettings_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendHttpSettings_STATUS(generators)
	applicationGatewayBackendHttpSettings_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendHttpSettings_STATUS{}), generators)

	return applicationGatewayBackendHttpSettings_STATUSGenerator
}

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

func Test_ApplicationGatewayBackendSettings_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayBackendSettings via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendSettings, ApplicationGatewayBackendSettingsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendSettings(generators)
	applicationGatewayBackendSettingsGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendSettings{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendSettings(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayBackendSettings(generators)
	applicationGatewayBackendSettingsGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendSettings{}), generators)

	return applicationGatewayBackendSettingsGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayBackendSettings is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayBackendSettings(gens map[string]gopter.Gen) {
	gens["HostName"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["PickHostNameFromBackendAddress"] = gen.PtrOf(gen.Bool())
	gens["Port"] = gen.PtrOf(gen.Int())
	gens["Protocol"] = gen.PtrOf(gen.AlphaString())
	gens["Timeout"] = gen.PtrOf(gen.Int())
}

// AddRelatedPropertyGeneratorsForApplicationGatewayBackendSettings is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayBackendSettings(gens map[string]gopter.Gen) {
	gens["Probe"] = gen.PtrOf(SubResourceGenerator())
	gens["TrustedRootCertificates"] = gen.SliceOf(SubResourceGenerator())
}

func Test_ApplicationGatewayBackendSettings_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 ApplicationGatewayBackendSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendSettings_STATUS, ApplicationGatewayBackendSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayBackendSettings_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 ApplicationGatewayBackendSettings_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayBackendSettings_STATUSGenerator()
var applicationGatewayBackendSettings_STATUSGenerator gopter.Gen

// ApplicationGatewayBackendSettings_STATUSGenerator returns a generator of ApplicationGatewayBackendSettings_STATUS instances for property testing.
func ApplicationGatewayBackendSettings_STATUSGenerator() gopter.Gen {
	if applicationGatewayBackendSettings_STATUSGenerator != nil {
		return applicationGatewayBackendSettings_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendSettings_STATUS(generators)
	applicationGatewayBackendSettings_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendSettings_STATUS{}), generators)

	return applicationGatewayBackendSettings_STATUSGenerator
}

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

func Test_ApplicationGatewayClientAuthConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayClientAuthConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayClientAuthConfiguration, ApplicationGatewayClientAuthConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayClientAuthConfigurationGenerator returns a generator of ApplicationGatewayClientAuthConfiguration instances for property testing.
func ApplicationGatewayClientAuthConfigurationGenerator() gopter.Gen {
	if applicationGatewayClientAuthConfigurationGenerator != nil {
		return applicationGatewayClientAuthConfigurationGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayClientAuthConfiguration(generators)
	applicationGatewayClientAuthConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayClientAuthConfiguration{}), generators)

	return applicationGatewayClientAuthConfigurationGenerator
}

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

func Test_ApplicationGatewayConnectionDraining_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayConnectionDraining via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayConnectionDraining, ApplicationGatewayConnectionDrainingGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayConnectionDrainingGenerator returns a generator of ApplicationGatewayConnectionDraining instances for property testing.
func ApplicationGatewayConnectionDrainingGenerator() gopter.Gen {
	if applicationGatewayConnectionDrainingGenerator != nil {
		return applicationGatewayConnectionDrainingGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayConnectionDraining(generators)
	applicationGatewayConnectionDrainingGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayConnectionDraining{}), generators)

	return applicationGatewayConnectionDrainingGenerator
}

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

func Test_ApplicationGatewayCustomError_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayCustomError via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayCustomError, ApplicationGatewayCustomErrorGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayCustomErrorGenerator returns a generator of ApplicationGatewayCustomError instances for property testing.
func ApplicationGatewayCustomErrorGenerator() gopter.Gen {
	if applicationGatewayCustomErrorGenerator != nil {
		return applicationGatewayCustomErrorGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayCustomError(generators)
	applicationGatewayCustomErrorGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayCustomError{}), generators)

	return applicationGatewayCustomErrorGenerator
}

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

func Test_ApplicationGatewayCustomError_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 ApplicationGatewayCustomError_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayCustomError_STATUS, ApplicationGatewayCustomError_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayCustomError_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 ApplicationGatewayCustomError_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayCustomError_STATUSGenerator()
var applicationGatewayCustomError_STATUSGenerator gopter.Gen

// ApplicationGatewayCustomError_STATUSGenerator returns a generator of ApplicationGatewayCustomError_STATUS instances for property testing.
func ApplicationGatewayCustomError_STATUSGenerator() gopter.Gen {
	if applicationGatewayCustomError_STATUSGenerator != nil {
		return applicationGatewayCustomError_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayCustomError_STATUS(generators)
	applicationGatewayCustomError_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayCustomError_STATUS{}), generators)

	return applicationGatewayCustomError_STATUSGenerator
}

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

func Test_ApplicationGatewayFirewallDisabledRuleGroup_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayFirewallDisabledRuleGroup via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFirewallDisabledRuleGroup, ApplicationGatewayFirewallDisabledRuleGroupGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayFirewallDisabledRuleGroupGenerator returns a generator of ApplicationGatewayFirewallDisabledRuleGroup instances for property testing.
func ApplicationGatewayFirewallDisabledRuleGroupGenerator() gopter.Gen {
	if applicationGatewayFirewallDisabledRuleGroupGenerator != nil {
		return applicationGatewayFirewallDisabledRuleGroupGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFirewallDisabledRuleGroup(generators)
	applicationGatewayFirewallDisabledRuleGroupGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFirewallDisabledRuleGroup{}), generators)

	return applicationGatewayFirewallDisabledRuleGroupGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayFirewallDisabledRuleGroup is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayFirewallDisabledRuleGroup(gens map[string]gopter.Gen) {
	gens["RuleGroupName"] = gen.PtrOf(gen.AlphaString())
	gens["Rules"] = gen.SliceOf(gen.Int())
}

func Test_ApplicationGatewayFirewallDisabledRuleGroup_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 ApplicationGatewayFirewallDisabledRuleGroup_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFirewallDisabledRuleGroup_STATUS, ApplicationGatewayFirewallDisabledRuleGroup_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayFirewallDisabledRuleGroup_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 ApplicationGatewayFirewallDisabledRuleGroup_STATUS instances for property testing - lazily instantiated
// by ApplicationGatewayFirewallDisabledRuleGroup_STATUSGenerator()
var applicationGatewayFirewallDisabledRuleGroup_STATUSGenerator gopter.Gen

// ApplicationGatewayFirewallDisabledRuleGroup_STATUSGenerator returns a generator of ApplicationGatewayFirewallDisabledRuleGroup_STATUS instances for property testing.
func ApplicationGatewayFirewallDisabledRuleGroup_STATUSGenerator() gopter.Gen {
	if applicationGatewayFirewallDisabledRuleGroup_STATUSGenerator != nil {
		return applicationGatewayFirewallDisabledRuleGroup_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFirewallDisabledRuleGroup_STATUS(generators)
	applicationGatewayFirewallDisabledRuleGroup_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFirewallDisabledRuleGroup_STATUS{}), generators)

	return applicationGatewayFirewallDisabledRuleGroup_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayFirewallDisabledRuleGroup_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayFirewallDisabledRuleGroup_STATUS(gens map[string]gopter.Gen) {
	gens["RuleGroupName"] = gen.PtrOf(gen.AlphaString())
	gens["Rules"] = gen.SliceOf(gen.Int())
}

func Test_ApplicationGatewayFirewallExclusion_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayFirewallExclusion via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFirewallExclusion, ApplicationGatewayFirewallExclusionGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayFirewallExclusionGenerator returns a generator of ApplicationGatewayFirewallExclusion instances for property testing.
func ApplicationGatewayFirewallExclusionGenerator() gopter.Gen {
	if applicationGatewayFirewallExclusionGenerator != nil {
		return applicationGatewayFirewallExclusionGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFirewallExclusion(generators)
	applicationGatewayFirewallExclusionGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFirewallExclusion{}), generators)

	return applicationGatewayFirewallExclusionGenerator
}

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

func Test_ApplicationGatewayFirewallExclusion_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 ApplicationGatewayFirewallExclusion_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFirewallExclusion_STATUS, ApplicationGatewayFirewallExclusion_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayFirewallExclusion_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 ApplicationGatewayFirewallExclusion_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayFirewallExclusion_STATUSGenerator()
var applicationGatewayFirewallExclusion_STATUSGenerator gopter.Gen

// ApplicationGatewayFirewallExclusion_STATUSGenerator returns a generator of ApplicationGatewayFirewallExclusion_STATUS instances for property testing.
func ApplicationGatewayFirewallExclusion_STATUSGenerator() gopter.Gen {
	if applicationGatewayFirewallExclusion_STATUSGenerator != nil {
		return applicationGatewayFirewallExclusion_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFirewallExclusion_STATUS(generators)
	applicationGatewayFirewallExclusion_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFirewallExclusion_STATUS{}), generators)

	return applicationGatewayFirewallExclusion_STATUSGenerator
}

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

func Test_ApplicationGatewayFrontendIPConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayFrontendIPConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFrontendIPConfiguration, ApplicationGatewayFrontendIPConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFrontendIPConfiguration(generators)
	applicationGatewayFrontendIPConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFrontendIPConfiguration{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFrontendIPConfiguration(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayFrontendIPConfiguration(generators)
	applicationGatewayFrontendIPConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFrontendIPConfiguration{}), generators)

	return applicationGatewayFrontendIPConfigurationGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewayFrontendIPConfiguration is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayFrontendIPConfiguration(gens map[string]gopter.Gen) {
	gens["PrivateLinkConfiguration"] = gen.PtrOf(SubResourceGenerator())
	gens["PublicIPAddress"] = gen.PtrOf(SubResourceGenerator())
	gens["Subnet"] = gen.PtrOf(SubResourceGenerator())
}

func Test_ApplicationGatewayFrontendIPConfiguration_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 ApplicationGatewayFrontendIPConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFrontendIPConfiguration_STATUS, ApplicationGatewayFrontendIPConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayFrontendIPConfiguration_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 ApplicationGatewayFrontendIPConfiguration_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayFrontendIPConfiguration_STATUSGenerator()
var applicationGatewayFrontendIPConfiguration_STATUSGenerator gopter.Gen

// ApplicationGatewayFrontendIPConfiguration_STATUSGenerator returns a generator of ApplicationGatewayFrontendIPConfiguration_STATUS instances for property testing.
func ApplicationGatewayFrontendIPConfiguration_STATUSGenerator() gopter.Gen {
	if applicationGatewayFrontendIPConfiguration_STATUSGenerator != nil {
		return applicationGatewayFrontendIPConfiguration_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFrontendIPConfiguration_STATUS(generators)
	applicationGatewayFrontendIPConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFrontendIPConfiguration_STATUS{}), generators)

	return applicationGatewayFrontendIPConfiguration_STATUSGenerator
}

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

func Test_ApplicationGatewayFrontendPort_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayFrontendPort via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFrontendPort, ApplicationGatewayFrontendPortGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayFrontendPortGenerator returns a generator of ApplicationGatewayFrontendPort instances for property testing.
func ApplicationGatewayFrontendPortGenerator() gopter.Gen {
	if applicationGatewayFrontendPortGenerator != nil {
		return applicationGatewayFrontendPortGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFrontendPort(generators)
	applicationGatewayFrontendPortGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFrontendPort{}), generators)

	return applicationGatewayFrontendPortGenerator
}

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

func Test_ApplicationGatewayFrontendPort_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 ApplicationGatewayFrontendPort_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFrontendPort_STATUS, ApplicationGatewayFrontendPort_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayFrontendPort_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 ApplicationGatewayFrontendPort_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayFrontendPort_STATUSGenerator()
var applicationGatewayFrontendPort_STATUSGenerator gopter.Gen

// ApplicationGatewayFrontendPort_STATUSGenerator returns a generator of ApplicationGatewayFrontendPort_STATUS instances for property testing.
func ApplicationGatewayFrontendPort_STATUSGenerator() gopter.Gen {
	if applicationGatewayFrontendPort_STATUSGenerator != nil {
		return applicationGatewayFrontendPort_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFrontendPort_STATUS(generators)
	applicationGatewayFrontendPort_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFrontendPort_STATUS{}), generators)

	return applicationGatewayFrontendPort_STATUSGenerator
}

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

func Test_ApplicationGatewayGlobalConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayGlobalConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayGlobalConfiguration, ApplicationGatewayGlobalConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayGlobalConfigurationGenerator returns a generator of ApplicationGatewayGlobalConfiguration instances for property testing.
func ApplicationGatewayGlobalConfigurationGenerator() gopter.Gen {
	if applicationGatewayGlobalConfigurationGenerator != nil {
		return applicationGatewayGlobalConfigurationGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayGlobalConfiguration(generators)
	applicationGatewayGlobalConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayGlobalConfiguration{}), generators)

	return applicationGatewayGlobalConfigurationGenerator
}

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

func Test_ApplicationGatewayGlobalConfiguration_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 ApplicationGatewayGlobalConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayGlobalConfiguration_STATUS, ApplicationGatewayGlobalConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayGlobalConfiguration_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 ApplicationGatewayGlobalConfiguration_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayGlobalConfiguration_STATUSGenerator()
var applicationGatewayGlobalConfiguration_STATUSGenerator gopter.Gen

// ApplicationGatewayGlobalConfiguration_STATUSGenerator returns a generator of ApplicationGatewayGlobalConfiguration_STATUS instances for property testing.
func ApplicationGatewayGlobalConfiguration_STATUSGenerator() gopter.Gen {
	if applicationGatewayGlobalConfiguration_STATUSGenerator != nil {
		return applicationGatewayGlobalConfiguration_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayGlobalConfiguration_STATUS(generators)
	applicationGatewayGlobalConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayGlobalConfiguration_STATUS{}), generators)

	return applicationGatewayGlobalConfiguration_STATUSGenerator
}

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

func Test_ApplicationGatewayHeaderConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayHeaderConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayHeaderConfiguration, ApplicationGatewayHeaderConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayHeaderConfigurationGenerator returns a generator of ApplicationGatewayHeaderConfiguration instances for property testing.
func ApplicationGatewayHeaderConfigurationGenerator() gopter.Gen {
	if applicationGatewayHeaderConfigurationGenerator != nil {
		return applicationGatewayHeaderConfigurationGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayHeaderConfiguration(generators)
	applicationGatewayHeaderConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayHeaderConfiguration{}), generators)

	return applicationGatewayHeaderConfigurationGenerator
}

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

func Test_ApplicationGatewayHttpListener_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayHttpListener via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayHttpListener, ApplicationGatewayHttpListenerGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayHttpListener(generators)
	applicationGatewayHttpListenerGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayHttpListener{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayHttpListener(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayHttpListener(generators)
	applicationGatewayHttpListenerGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayHttpListener{}), generators)

	return applicationGatewayHttpListenerGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayHttpListener is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayHttpListener(gens map[string]gopter.Gen) {
	gens["HostName"] = gen.PtrOf(gen.AlphaString())
	gens["HostNames"] = gen.SliceOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Protocol"] = gen.PtrOf(gen.AlphaString())
	gens["RequireServerNameIndication"] = gen.PtrOf(gen.Bool())
}

// AddRelatedPropertyGeneratorsForApplicationGatewayHttpListener is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayHttpListener(gens map[string]gopter.Gen) {
	gens["CustomErrorConfigurations"] = gen.SliceOf(ApplicationGatewayCustomErrorGenerator())
	gens["FirewallPolicy"] = gen.PtrOf(SubResourceGenerator())
	gens["FrontendIPConfiguration"] = gen.PtrOf(SubResourceGenerator())
	gens["FrontendPort"] = gen.PtrOf(SubResourceGenerator())
	gens["SslCertificate"] = gen.PtrOf(SubResourceGenerator())
	gens["SslProfile"] = gen.PtrOf(SubResourceGenerator())
}

func Test_ApplicationGatewayHttpListener_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 ApplicationGatewayHttpListener_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayHttpListener_STATUS, ApplicationGatewayHttpListener_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayHttpListener_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 ApplicationGatewayHttpListener_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayHttpListener_STATUSGenerator()
var applicationGatewayHttpListener_STATUSGenerator gopter.Gen

// ApplicationGatewayHttpListener_STATUSGenerator returns a generator of ApplicationGatewayHttpListener_STATUS instances for property testing.
func ApplicationGatewayHttpListener_STATUSGenerator() gopter.Gen {
	if applicationGatewayHttpListener_STATUSGenerator != nil {
		return applicationGatewayHttpListener_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayHttpListener_STATUS(generators)
	applicationGatewayHttpListener_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayHttpListener_STATUS{}), generators)

	return applicationGatewayHttpListener_STATUSGenerator
}

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

func Test_ApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbedded_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbedded via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbedded, ApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbeddedGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbedded(generators)
	applicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbeddedGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbedded{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbedded(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbedded(generators)
	applicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbeddedGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbedded{}), generators)

	return applicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbeddedGenerator
}

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

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

func Test_ApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbedded_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 ApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbedded via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbedded, ApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbeddedGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbeddedGenerator returns a generator of ApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbedded instances for property testing.
func ApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbeddedGenerator() gopter.Gen {
	if applicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbeddedGenerator != nil {
		return applicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbeddedGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbedded(generators)
	applicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbeddedGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbedded{}), generators)

	return applicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbeddedGenerator
}

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

func Test_ApplicationGatewayListener_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayListener via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayListener, ApplicationGatewayListenerGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayListener(generators)
	applicationGatewayListenerGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayListener{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayListener(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayListener(generators)
	applicationGatewayListenerGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayListener{}), generators)

	return applicationGatewayListenerGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewayListener is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayListener(gens map[string]gopter.Gen) {
	gens["FrontendIPConfiguration"] = gen.PtrOf(SubResourceGenerator())
	gens["FrontendPort"] = gen.PtrOf(SubResourceGenerator())
	gens["SslCertificate"] = gen.PtrOf(SubResourceGenerator())
	gens["SslProfile"] = gen.PtrOf(SubResourceGenerator())
}

func Test_ApplicationGatewayListener_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 ApplicationGatewayListener_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayListener_STATUS, ApplicationGatewayListener_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayListener_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 ApplicationGatewayListener_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayListener_STATUSGenerator()
var applicationGatewayListener_STATUSGenerator gopter.Gen

// ApplicationGatewayListener_STATUSGenerator returns a generator of ApplicationGatewayListener_STATUS instances for property testing.
func ApplicationGatewayListener_STATUSGenerator() gopter.Gen {
	if applicationGatewayListener_STATUSGenerator != nil {
		return applicationGatewayListener_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayListener_STATUS(generators)
	applicationGatewayListener_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayListener_STATUS{}), generators)

	return applicationGatewayListener_STATUSGenerator
}

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

func Test_ApplicationGatewayLoadDistributionPolicy_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayLoadDistributionPolicy via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayLoadDistributionPolicy, ApplicationGatewayLoadDistributionPolicyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayLoadDistributionPolicy(generators)
	applicationGatewayLoadDistributionPolicyGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayLoadDistributionPolicy{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayLoadDistributionPolicy(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayLoadDistributionPolicy(generators)
	applicationGatewayLoadDistributionPolicyGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayLoadDistributionPolicy{}), generators)

	return applicationGatewayLoadDistributionPolicyGenerator
}

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

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

func Test_ApplicationGatewayLoadDistributionPolicy_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 ApplicationGatewayLoadDistributionPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayLoadDistributionPolicy_STATUS, ApplicationGatewayLoadDistributionPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayLoadDistributionPolicy_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 ApplicationGatewayLoadDistributionPolicy_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayLoadDistributionPolicy_STATUSGenerator()
var applicationGatewayLoadDistributionPolicy_STATUSGenerator gopter.Gen

// ApplicationGatewayLoadDistributionPolicy_STATUSGenerator returns a generator of ApplicationGatewayLoadDistributionPolicy_STATUS instances for property testing.
func ApplicationGatewayLoadDistributionPolicy_STATUSGenerator() gopter.Gen {
	if applicationGatewayLoadDistributionPolicy_STATUSGenerator != nil {
		return applicationGatewayLoadDistributionPolicy_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayLoadDistributionPolicy_STATUS(generators)
	applicationGatewayLoadDistributionPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayLoadDistributionPolicy_STATUS{}), generators)

	return applicationGatewayLoadDistributionPolicy_STATUSGenerator
}

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

func Test_ApplicationGatewayLoadDistributionTarget_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayLoadDistributionTarget via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayLoadDistributionTarget, ApplicationGatewayLoadDistributionTargetGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayLoadDistributionTargetGenerator returns a generator of ApplicationGatewayLoadDistributionTarget instances for property testing.
func ApplicationGatewayLoadDistributionTargetGenerator() gopter.Gen {
	if applicationGatewayLoadDistributionTargetGenerator != nil {
		return applicationGatewayLoadDistributionTargetGenerator
	}

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

	return applicationGatewayLoadDistributionTargetGenerator
}

func Test_ApplicationGatewayOperatorSpec_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayOperatorSpec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayOperatorSpec, ApplicationGatewayOperatorSpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayOperatorSpecGenerator returns a generator of ApplicationGatewayOperatorSpec instances for property testing.
func ApplicationGatewayOperatorSpecGenerator() gopter.Gen {
	if applicationGatewayOperatorSpecGenerator != nil {
		return applicationGatewayOperatorSpecGenerator
	}

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

	return applicationGatewayOperatorSpecGenerator
}

func Test_ApplicationGatewayPathRule_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayPathRule via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayPathRule, ApplicationGatewayPathRuleGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayPathRule(generators)
	applicationGatewayPathRuleGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayPathRule{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayPathRule(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayPathRule(generators)
	applicationGatewayPathRuleGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayPathRule{}), generators)

	return applicationGatewayPathRuleGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewayPathRule is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayPathRule(gens map[string]gopter.Gen) {
	gens["BackendAddressPool"] = gen.PtrOf(SubResourceGenerator())
	gens["BackendHttpSettings"] = gen.PtrOf(SubResourceGenerator())
	gens["FirewallPolicy"] = gen.PtrOf(SubResourceGenerator())
	gens["LoadDistributionPolicy"] = gen.PtrOf(SubResourceGenerator())
	gens["RedirectConfiguration"] = gen.PtrOf(SubResourceGenerator())
	gens["RewriteRuleSet"] = gen.PtrOf(SubResourceGenerator())
}

func Test_ApplicationGatewayPrivateEndpointConnection_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 ApplicationGatewayPrivateEndpointConnection_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayPrivateEndpointConnection_STATUS, ApplicationGatewayPrivateEndpointConnection_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayPrivateEndpointConnection_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 ApplicationGatewayPrivateEndpointConnection_STATUS instances for property testing - lazily instantiated
// by ApplicationGatewayPrivateEndpointConnection_STATUSGenerator()
var applicationGatewayPrivateEndpointConnection_STATUSGenerator gopter.Gen

// ApplicationGatewayPrivateEndpointConnection_STATUSGenerator returns a generator of ApplicationGatewayPrivateEndpointConnection_STATUS instances for property testing.
func ApplicationGatewayPrivateEndpointConnection_STATUSGenerator() gopter.Gen {
	if applicationGatewayPrivateEndpointConnection_STATUSGenerator != nil {
		return applicationGatewayPrivateEndpointConnection_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayPrivateEndpointConnection_STATUS(generators)
	applicationGatewayPrivateEndpointConnection_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayPrivateEndpointConnection_STATUS{}), generators)

	return applicationGatewayPrivateEndpointConnection_STATUSGenerator
}

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

func Test_ApplicationGatewayPrivateLinkConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayPrivateLinkConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayPrivateLinkConfiguration, ApplicationGatewayPrivateLinkConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayPrivateLinkConfiguration(generators)
	applicationGatewayPrivateLinkConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayPrivateLinkConfiguration{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayPrivateLinkConfiguration(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayPrivateLinkConfiguration(generators)
	applicationGatewayPrivateLinkConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayPrivateLinkConfiguration{}), generators)

	return applicationGatewayPrivateLinkConfigurationGenerator
}

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

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

func Test_ApplicationGatewayPrivateLinkConfiguration_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 ApplicationGatewayPrivateLinkConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayPrivateLinkConfiguration_STATUS, ApplicationGatewayPrivateLinkConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayPrivateLinkConfiguration_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 ApplicationGatewayPrivateLinkConfiguration_STATUS instances for property testing - lazily instantiated
// by ApplicationGatewayPrivateLinkConfiguration_STATUSGenerator()
var applicationGatewayPrivateLinkConfiguration_STATUSGenerator gopter.Gen

// ApplicationGatewayPrivateLinkConfiguration_STATUSGenerator returns a generator of ApplicationGatewayPrivateLinkConfiguration_STATUS instances for property testing.
func ApplicationGatewayPrivateLinkConfiguration_STATUSGenerator() gopter.Gen {
	if applicationGatewayPrivateLinkConfiguration_STATUSGenerator != nil {
		return applicationGatewayPrivateLinkConfiguration_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayPrivateLinkConfiguration_STATUS(generators)
	applicationGatewayPrivateLinkConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayPrivateLinkConfiguration_STATUS{}), generators)

	return applicationGatewayPrivateLinkConfiguration_STATUSGenerator
}

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

func Test_ApplicationGatewayPrivateLinkIpConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayPrivateLinkIpConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayPrivateLinkIpConfiguration, ApplicationGatewayPrivateLinkIpConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayPrivateLinkIpConfigurationGenerator returns a generator of ApplicationGatewayPrivateLinkIpConfiguration instances for property testing.
func ApplicationGatewayPrivateLinkIpConfigurationGenerator() gopter.Gen {
	if applicationGatewayPrivateLinkIpConfigurationGenerator != nil {
		return applicationGatewayPrivateLinkIpConfigurationGenerator
	}

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

	return applicationGatewayPrivateLinkIpConfigurationGenerator
}

func Test_ApplicationGatewayProbe_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayProbe via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayProbe, ApplicationGatewayProbeGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayProbe(generators)
	applicationGatewayProbeGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayProbe{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayProbe(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayProbe(generators)
	applicationGatewayProbeGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayProbe{}), generators)

	return applicationGatewayProbeGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayProbe is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayProbe(gens map[string]gopter.Gen) {
	gens["Host"] = gen.PtrOf(gen.AlphaString())
	gens["Interval"] = gen.PtrOf(gen.Int())
	gens["MinServers"] = gen.PtrOf(gen.Int())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Path"] = gen.PtrOf(gen.AlphaString())
	gens["PickHostNameFromBackendHttpSettings"] = gen.PtrOf(gen.Bool())
	gens["PickHostNameFromBackendSettings"] = gen.PtrOf(gen.Bool())
	gens["Port"] = gen.PtrOf(gen.Int())
	gens["Protocol"] = gen.PtrOf(gen.AlphaString())
	gens["Timeout"] = gen.PtrOf(gen.Int())
	gens["UnhealthyThreshold"] = gen.PtrOf(gen.Int())
}

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

func Test_ApplicationGatewayProbeHealthResponseMatch_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayProbeHealthResponseMatch via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayProbeHealthResponseMatch, ApplicationGatewayProbeHealthResponseMatchGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayProbeHealthResponseMatchGenerator returns a generator of ApplicationGatewayProbeHealthResponseMatch instances for property testing.
func ApplicationGatewayProbeHealthResponseMatchGenerator() gopter.Gen {
	if applicationGatewayProbeHealthResponseMatchGenerator != nil {
		return applicationGatewayProbeHealthResponseMatchGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayProbeHealthResponseMatch(generators)
	applicationGatewayProbeHealthResponseMatchGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayProbeHealthResponseMatch{}), generators)

	return applicationGatewayProbeHealthResponseMatchGenerator
}

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

func Test_ApplicationGatewayProbe_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 ApplicationGatewayProbe_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayProbe_STATUS, ApplicationGatewayProbe_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayProbe_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 ApplicationGatewayProbe_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayProbe_STATUSGenerator()
var applicationGatewayProbe_STATUSGenerator gopter.Gen

// ApplicationGatewayProbe_STATUSGenerator returns a generator of ApplicationGatewayProbe_STATUS instances for property testing.
func ApplicationGatewayProbe_STATUSGenerator() gopter.Gen {
	if applicationGatewayProbe_STATUSGenerator != nil {
		return applicationGatewayProbe_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayProbe_STATUS(generators)
	applicationGatewayProbe_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayProbe_STATUS{}), generators)

	return applicationGatewayProbe_STATUSGenerator
}

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

func Test_ApplicationGatewayRedirectConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayRedirectConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRedirectConfiguration, ApplicationGatewayRedirectConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRedirectConfiguration(generators)
	applicationGatewayRedirectConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRedirectConfiguration{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRedirectConfiguration(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayRedirectConfiguration(generators)
	applicationGatewayRedirectConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRedirectConfiguration{}), generators)

	return applicationGatewayRedirectConfigurationGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayRedirectConfiguration is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayRedirectConfiguration(gens map[string]gopter.Gen) {
	gens["IncludePath"] = gen.PtrOf(gen.Bool())
	gens["IncludeQueryString"] = gen.PtrOf(gen.Bool())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["RedirectType"] = gen.PtrOf(gen.AlphaString())
	gens["TargetUrl"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForApplicationGatewayRedirectConfiguration is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayRedirectConfiguration(gens map[string]gopter.Gen) {
	gens["PathRules"] = gen.SliceOf(SubResourceGenerator())
	gens["RequestRoutingRules"] = gen.SliceOf(SubResourceGenerator())
	gens["TargetListener"] = gen.PtrOf(SubResourceGenerator())
	gens["UrlPathMaps"] = gen.SliceOf(SubResourceGenerator())
}

func Test_ApplicationGatewayRedirectConfiguration_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 ApplicationGatewayRedirectConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRedirectConfiguration_STATUS, ApplicationGatewayRedirectConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayRedirectConfiguration_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 ApplicationGatewayRedirectConfiguration_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayRedirectConfiguration_STATUSGenerator()
var applicationGatewayRedirectConfiguration_STATUSGenerator gopter.Gen

// ApplicationGatewayRedirectConfiguration_STATUSGenerator returns a generator of ApplicationGatewayRedirectConfiguration_STATUS instances for property testing.
func ApplicationGatewayRedirectConfiguration_STATUSGenerator() gopter.Gen {
	if applicationGatewayRedirectConfiguration_STATUSGenerator != nil {
		return applicationGatewayRedirectConfiguration_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRedirectConfiguration_STATUS(generators)
	applicationGatewayRedirectConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRedirectConfiguration_STATUS{}), generators)

	return applicationGatewayRedirectConfiguration_STATUSGenerator
}

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

func Test_ApplicationGatewayRequestRoutingRule_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayRequestRoutingRule via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRequestRoutingRule, ApplicationGatewayRequestRoutingRuleGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRequestRoutingRule(generators)
	applicationGatewayRequestRoutingRuleGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRequestRoutingRule{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRequestRoutingRule(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayRequestRoutingRule(generators)
	applicationGatewayRequestRoutingRuleGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRequestRoutingRule{}), generators)

	return applicationGatewayRequestRoutingRuleGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewayRequestRoutingRule is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayRequestRoutingRule(gens map[string]gopter.Gen) {
	gens["BackendAddressPool"] = gen.PtrOf(SubResourceGenerator())
	gens["BackendHttpSettings"] = gen.PtrOf(SubResourceGenerator())
	gens["HttpListener"] = gen.PtrOf(SubResourceGenerator())
	gens["LoadDistributionPolicy"] = gen.PtrOf(SubResourceGenerator())
	gens["RedirectConfiguration"] = gen.PtrOf(SubResourceGenerator())
	gens["RewriteRuleSet"] = gen.PtrOf(SubResourceGenerator())
	gens["UrlPathMap"] = gen.PtrOf(SubResourceGenerator())
}

func Test_ApplicationGatewayRequestRoutingRule_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 ApplicationGatewayRequestRoutingRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRequestRoutingRule_STATUS, ApplicationGatewayRequestRoutingRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayRequestRoutingRule_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 ApplicationGatewayRequestRoutingRule_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayRequestRoutingRule_STATUSGenerator()
var applicationGatewayRequestRoutingRule_STATUSGenerator gopter.Gen

// ApplicationGatewayRequestRoutingRule_STATUSGenerator returns a generator of ApplicationGatewayRequestRoutingRule_STATUS instances for property testing.
func ApplicationGatewayRequestRoutingRule_STATUSGenerator() gopter.Gen {
	if applicationGatewayRequestRoutingRule_STATUSGenerator != nil {
		return applicationGatewayRequestRoutingRule_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRequestRoutingRule_STATUS(generators)
	applicationGatewayRequestRoutingRule_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRequestRoutingRule_STATUS{}), generators)

	return applicationGatewayRequestRoutingRule_STATUSGenerator
}

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

func Test_ApplicationGatewayRewriteRule_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayRewriteRule via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRewriteRule, ApplicationGatewayRewriteRuleGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRewriteRule(generators)
	applicationGatewayRewriteRuleGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRewriteRule{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRewriteRule(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayRewriteRule(generators)
	applicationGatewayRewriteRuleGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRewriteRule{}), generators)

	return applicationGatewayRewriteRuleGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewayRewriteRule is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayRewriteRule(gens map[string]gopter.Gen) {
	gens["ActionSet"] = gen.PtrOf(ApplicationGatewayRewriteRuleActionSetGenerator())
	gens["Conditions"] = gen.SliceOf(ApplicationGatewayRewriteRuleConditionGenerator())
}

func Test_ApplicationGatewayRewriteRuleActionSet_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayRewriteRuleActionSet via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRewriteRuleActionSet, ApplicationGatewayRewriteRuleActionSetGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayRewriteRuleActionSetGenerator returns a generator of ApplicationGatewayRewriteRuleActionSet instances for property testing.
func ApplicationGatewayRewriteRuleActionSetGenerator() gopter.Gen {
	if applicationGatewayRewriteRuleActionSetGenerator != nil {
		return applicationGatewayRewriteRuleActionSetGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddRelatedPropertyGeneratorsForApplicationGatewayRewriteRuleActionSet(generators)
	applicationGatewayRewriteRuleActionSetGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRewriteRuleActionSet{}), generators)

	return applicationGatewayRewriteRuleActionSetGenerator
}

// AddRelatedPropertyGeneratorsForApplicationGatewayRewriteRuleActionSet is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayRewriteRuleActionSet(gens map[string]gopter.Gen) {
	gens["RequestHeaderConfigurations"] = gen.SliceOf(ApplicationGatewayHeaderConfigurationGenerator())
	gens["ResponseHeaderConfigurations"] = gen.SliceOf(ApplicationGatewayHeaderConfigurationGenerator())
	gens["UrlConfiguration"] = gen.PtrOf(ApplicationGatewayUrlConfigurationGenerator())
}

func Test_ApplicationGatewayRewriteRuleCondition_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayRewriteRuleCondition via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRewriteRuleCondition, ApplicationGatewayRewriteRuleConditionGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayRewriteRuleConditionGenerator returns a generator of ApplicationGatewayRewriteRuleCondition instances for property testing.
func ApplicationGatewayRewriteRuleConditionGenerator() gopter.Gen {
	if applicationGatewayRewriteRuleConditionGenerator != nil {
		return applicationGatewayRewriteRuleConditionGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRewriteRuleCondition(generators)
	applicationGatewayRewriteRuleConditionGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRewriteRuleCondition{}), generators)

	return applicationGatewayRewriteRuleConditionGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayRewriteRuleCondition is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayRewriteRuleCondition(gens map[string]gopter.Gen) {
	gens["IgnoreCase"] = gen.PtrOf(gen.Bool())
	gens["Negate"] = gen.PtrOf(gen.Bool())
	gens["Pattern"] = gen.PtrOf(gen.AlphaString())
	gens["Variable"] = gen.PtrOf(gen.AlphaString())
}

func Test_ApplicationGatewayRewriteRuleSet_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayRewriteRuleSet via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRewriteRuleSet, ApplicationGatewayRewriteRuleSetGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRewriteRuleSet(generators)
	applicationGatewayRewriteRuleSetGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRewriteRuleSet{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRewriteRuleSet(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayRewriteRuleSet(generators)
	applicationGatewayRewriteRuleSetGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRewriteRuleSet{}), generators)

	return applicationGatewayRewriteRuleSetGenerator
}

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

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

func Test_ApplicationGatewayRewriteRuleSet_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 ApplicationGatewayRewriteRuleSet_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRewriteRuleSet_STATUS, ApplicationGatewayRewriteRuleSet_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayRewriteRuleSet_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 ApplicationGatewayRewriteRuleSet_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayRewriteRuleSet_STATUSGenerator()
var applicationGatewayRewriteRuleSet_STATUSGenerator gopter.Gen

// ApplicationGatewayRewriteRuleSet_STATUSGenerator returns a generator of ApplicationGatewayRewriteRuleSet_STATUS instances for property testing.
func ApplicationGatewayRewriteRuleSet_STATUSGenerator() gopter.Gen {
	if applicationGatewayRewriteRuleSet_STATUSGenerator != nil {
		return applicationGatewayRewriteRuleSet_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRewriteRuleSet_STATUS(generators)
	applicationGatewayRewriteRuleSet_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRewriteRuleSet_STATUS{}), generators)

	return applicationGatewayRewriteRuleSet_STATUSGenerator
}

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

func Test_ApplicationGatewayRoutingRule_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayRoutingRule via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRoutingRule, ApplicationGatewayRoutingRuleGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRoutingRule(generators)
	applicationGatewayRoutingRuleGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRoutingRule{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRoutingRule(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayRoutingRule(generators)
	applicationGatewayRoutingRuleGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRoutingRule{}), generators)

	return applicationGatewayRoutingRuleGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewayRoutingRule is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayRoutingRule(gens map[string]gopter.Gen) {
	gens["BackendAddressPool"] = gen.PtrOf(SubResourceGenerator())
	gens["BackendSettings"] = gen.PtrOf(SubResourceGenerator())
	gens["Listener"] = gen.PtrOf(SubResourceGenerator())
}

func Test_ApplicationGatewayRoutingRule_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 ApplicationGatewayRoutingRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRoutingRule_STATUS, ApplicationGatewayRoutingRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayRoutingRule_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 ApplicationGatewayRoutingRule_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayRoutingRule_STATUSGenerator()
var applicationGatewayRoutingRule_STATUSGenerator gopter.Gen

// ApplicationGatewayRoutingRule_STATUSGenerator returns a generator of ApplicationGatewayRoutingRule_STATUS instances for property testing.
func ApplicationGatewayRoutingRule_STATUSGenerator() gopter.Gen {
	if applicationGatewayRoutingRule_STATUSGenerator != nil {
		return applicationGatewayRoutingRule_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRoutingRule_STATUS(generators)
	applicationGatewayRoutingRule_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRoutingRule_STATUS{}), generators)

	return applicationGatewayRoutingRule_STATUSGenerator
}

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

func Test_ApplicationGatewaySku_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewaySku via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySku, ApplicationGatewaySkuGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewaySkuGenerator returns a generator of ApplicationGatewaySku instances for property testing.
func ApplicationGatewaySkuGenerator() gopter.Gen {
	if applicationGatewaySkuGenerator != nil {
		return applicationGatewaySkuGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySku(generators)
	applicationGatewaySkuGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewaySku{}), generators)

	return applicationGatewaySkuGenerator
}

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

func Test_ApplicationGatewaySku_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 ApplicationGatewaySku_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySku_STATUS, ApplicationGatewaySku_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewaySku_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 ApplicationGatewaySku_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewaySku_STATUSGenerator()
var applicationGatewaySku_STATUSGenerator gopter.Gen

// ApplicationGatewaySku_STATUSGenerator returns a generator of ApplicationGatewaySku_STATUS instances for property testing.
func ApplicationGatewaySku_STATUSGenerator() gopter.Gen {
	if applicationGatewaySku_STATUSGenerator != nil {
		return applicationGatewaySku_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySku_STATUS(generators)
	applicationGatewaySku_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewaySku_STATUS{}), generators)

	return applicationGatewaySku_STATUSGenerator
}

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

func Test_ApplicationGatewaySslCertificate_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewaySslCertificate via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySslCertificate, ApplicationGatewaySslCertificateGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewaySslCertificateGenerator returns a generator of ApplicationGatewaySslCertificate instances for property testing.
func ApplicationGatewaySslCertificateGenerator() gopter.Gen {
	if applicationGatewaySslCertificateGenerator != nil {
		return applicationGatewaySslCertificateGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySslCertificate(generators)
	applicationGatewaySslCertificateGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewaySslCertificate{}), generators)

	return applicationGatewaySslCertificateGenerator
}

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

func Test_ApplicationGatewaySslCertificate_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 ApplicationGatewaySslCertificate_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySslCertificate_STATUS, ApplicationGatewaySslCertificate_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewaySslCertificate_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 ApplicationGatewaySslCertificate_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewaySslCertificate_STATUSGenerator()
var applicationGatewaySslCertificate_STATUSGenerator gopter.Gen

// ApplicationGatewaySslCertificate_STATUSGenerator returns a generator of ApplicationGatewaySslCertificate_STATUS instances for property testing.
func ApplicationGatewaySslCertificate_STATUSGenerator() gopter.Gen {
	if applicationGatewaySslCertificate_STATUSGenerator != nil {
		return applicationGatewaySslCertificate_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySslCertificate_STATUS(generators)
	applicationGatewaySslCertificate_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewaySslCertificate_STATUS{}), generators)

	return applicationGatewaySslCertificate_STATUSGenerator
}

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

func Test_ApplicationGatewaySslPolicy_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewaySslPolicy via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySslPolicy, ApplicationGatewaySslPolicyGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewaySslPolicyGenerator returns a generator of ApplicationGatewaySslPolicy instances for property testing.
func ApplicationGatewaySslPolicyGenerator() gopter.Gen {
	if applicationGatewaySslPolicyGenerator != nil {
		return applicationGatewaySslPolicyGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySslPolicy(generators)
	applicationGatewaySslPolicyGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewaySslPolicy{}), generators)

	return applicationGatewaySslPolicyGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewaySslPolicy is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewaySslPolicy(gens map[string]gopter.Gen) {
	gens["CipherSuites"] = gen.SliceOf(gen.AlphaString())
	gens["DisabledSslProtocols"] = gen.SliceOf(gen.AlphaString())
	gens["MinProtocolVersion"] = gen.PtrOf(gen.AlphaString())
	gens["PolicyName"] = gen.PtrOf(gen.AlphaString())
	gens["PolicyType"] = gen.PtrOf(gen.AlphaString())
}

func Test_ApplicationGatewaySslPolicy_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 ApplicationGatewaySslPolicy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySslPolicy_STATUS, ApplicationGatewaySslPolicy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewaySslPolicy_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 ApplicationGatewaySslPolicy_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewaySslPolicy_STATUSGenerator()
var applicationGatewaySslPolicy_STATUSGenerator gopter.Gen

// ApplicationGatewaySslPolicy_STATUSGenerator returns a generator of ApplicationGatewaySslPolicy_STATUS instances for property testing.
func ApplicationGatewaySslPolicy_STATUSGenerator() gopter.Gen {
	if applicationGatewaySslPolicy_STATUSGenerator != nil {
		return applicationGatewaySslPolicy_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySslPolicy_STATUS(generators)
	applicationGatewaySslPolicy_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewaySslPolicy_STATUS{}), generators)

	return applicationGatewaySslPolicy_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewaySslPolicy_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewaySslPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["CipherSuites"] = gen.SliceOf(gen.AlphaString())
	gens["DisabledSslProtocols"] = gen.SliceOf(gen.AlphaString())
	gens["MinProtocolVersion"] = gen.PtrOf(gen.AlphaString())
	gens["PolicyName"] = gen.PtrOf(gen.AlphaString())
	gens["PolicyType"] = gen.PtrOf(gen.AlphaString())
}

func Test_ApplicationGatewaySslProfile_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewaySslProfile via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySslProfile, ApplicationGatewaySslProfileGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySslProfile(generators)
	applicationGatewaySslProfileGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewaySslProfile{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySslProfile(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewaySslProfile(generators)
	applicationGatewaySslProfileGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewaySslProfile{}), generators)

	return applicationGatewaySslProfileGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewaySslProfile is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewaySslProfile(gens map[string]gopter.Gen) {
	gens["ClientAuthConfiguration"] = gen.PtrOf(ApplicationGatewayClientAuthConfigurationGenerator())
	gens["SslPolicy"] = gen.PtrOf(ApplicationGatewaySslPolicyGenerator())
	gens["TrustedClientCertificates"] = gen.SliceOf(SubResourceGenerator())
}

func Test_ApplicationGatewaySslProfile_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 ApplicationGatewaySslProfile_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySslProfile_STATUS, ApplicationGatewaySslProfile_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewaySslProfile_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 ApplicationGatewaySslProfile_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewaySslProfile_STATUSGenerator()
var applicationGatewaySslProfile_STATUSGenerator gopter.Gen

// ApplicationGatewaySslProfile_STATUSGenerator returns a generator of ApplicationGatewaySslProfile_STATUS instances for property testing.
func ApplicationGatewaySslProfile_STATUSGenerator() gopter.Gen {
	if applicationGatewaySslProfile_STATUSGenerator != nil {
		return applicationGatewaySslProfile_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySslProfile_STATUS(generators)
	applicationGatewaySslProfile_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewaySslProfile_STATUS{}), generators)

	return applicationGatewaySslProfile_STATUSGenerator
}

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

func Test_ApplicationGatewayTrustedClientCertificate_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayTrustedClientCertificate via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayTrustedClientCertificate, ApplicationGatewayTrustedClientCertificateGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayTrustedClientCertificateGenerator returns a generator of ApplicationGatewayTrustedClientCertificate instances for property testing.
func ApplicationGatewayTrustedClientCertificateGenerator() gopter.Gen {
	if applicationGatewayTrustedClientCertificateGenerator != nil {
		return applicationGatewayTrustedClientCertificateGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayTrustedClientCertificate(generators)
	applicationGatewayTrustedClientCertificateGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayTrustedClientCertificate{}), generators)

	return applicationGatewayTrustedClientCertificateGenerator
}

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

func Test_ApplicationGatewayTrustedClientCertificate_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 ApplicationGatewayTrustedClientCertificate_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayTrustedClientCertificate_STATUS, ApplicationGatewayTrustedClientCertificate_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayTrustedClientCertificate_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 ApplicationGatewayTrustedClientCertificate_STATUS instances for property testing - lazily instantiated
// by ApplicationGatewayTrustedClientCertificate_STATUSGenerator()
var applicationGatewayTrustedClientCertificate_STATUSGenerator gopter.Gen

// ApplicationGatewayTrustedClientCertificate_STATUSGenerator returns a generator of ApplicationGatewayTrustedClientCertificate_STATUS instances for property testing.
func ApplicationGatewayTrustedClientCertificate_STATUSGenerator() gopter.Gen {
	if applicationGatewayTrustedClientCertificate_STATUSGenerator != nil {
		return applicationGatewayTrustedClientCertificate_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayTrustedClientCertificate_STATUS(generators)
	applicationGatewayTrustedClientCertificate_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayTrustedClientCertificate_STATUS{}), generators)

	return applicationGatewayTrustedClientCertificate_STATUSGenerator
}

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

func Test_ApplicationGatewayTrustedRootCertificate_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayTrustedRootCertificate via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayTrustedRootCertificate, ApplicationGatewayTrustedRootCertificateGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayTrustedRootCertificateGenerator returns a generator of ApplicationGatewayTrustedRootCertificate instances for property testing.
func ApplicationGatewayTrustedRootCertificateGenerator() gopter.Gen {
	if applicationGatewayTrustedRootCertificateGenerator != nil {
		return applicationGatewayTrustedRootCertificateGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayTrustedRootCertificate(generators)
	applicationGatewayTrustedRootCertificateGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayTrustedRootCertificate{}), generators)

	return applicationGatewayTrustedRootCertificateGenerator
}

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

func Test_ApplicationGatewayTrustedRootCertificate_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 ApplicationGatewayTrustedRootCertificate_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayTrustedRootCertificate_STATUS, ApplicationGatewayTrustedRootCertificate_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayTrustedRootCertificate_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 ApplicationGatewayTrustedRootCertificate_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayTrustedRootCertificate_STATUSGenerator()
var applicationGatewayTrustedRootCertificate_STATUSGenerator gopter.Gen

// ApplicationGatewayTrustedRootCertificate_STATUSGenerator returns a generator of ApplicationGatewayTrustedRootCertificate_STATUS instances for property testing.
func ApplicationGatewayTrustedRootCertificate_STATUSGenerator() gopter.Gen {
	if applicationGatewayTrustedRootCertificate_STATUSGenerator != nil {
		return applicationGatewayTrustedRootCertificate_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayTrustedRootCertificate_STATUS(generators)
	applicationGatewayTrustedRootCertificate_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayTrustedRootCertificate_STATUS{}), generators)

	return applicationGatewayTrustedRootCertificate_STATUSGenerator
}

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

func Test_ApplicationGatewayUrlConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayUrlConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayUrlConfiguration, ApplicationGatewayUrlConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayUrlConfigurationGenerator returns a generator of ApplicationGatewayUrlConfiguration instances for property testing.
func ApplicationGatewayUrlConfigurationGenerator() gopter.Gen {
	if applicationGatewayUrlConfigurationGenerator != nil {
		return applicationGatewayUrlConfigurationGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayUrlConfiguration(generators)
	applicationGatewayUrlConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayUrlConfiguration{}), generators)

	return applicationGatewayUrlConfigurationGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayUrlConfiguration is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayUrlConfiguration(gens map[string]gopter.Gen) {
	gens["ModifiedPath"] = gen.PtrOf(gen.AlphaString())
	gens["ModifiedQueryString"] = gen.PtrOf(gen.AlphaString())
	gens["Reroute"] = gen.PtrOf(gen.Bool())
}

func Test_ApplicationGatewayUrlPathMap_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayUrlPathMap via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayUrlPathMap, ApplicationGatewayUrlPathMapGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayUrlPathMap(generators)
	applicationGatewayUrlPathMapGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayUrlPathMap{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayUrlPathMap(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayUrlPathMap(generators)
	applicationGatewayUrlPathMapGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayUrlPathMap{}), generators)

	return applicationGatewayUrlPathMapGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewayUrlPathMap is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayUrlPathMap(gens map[string]gopter.Gen) {
	gens["DefaultBackendAddressPool"] = gen.PtrOf(SubResourceGenerator())
	gens["DefaultBackendHttpSettings"] = gen.PtrOf(SubResourceGenerator())
	gens["DefaultLoadDistributionPolicy"] = gen.PtrOf(SubResourceGenerator())
	gens["DefaultRedirectConfiguration"] = gen.PtrOf(SubResourceGenerator())
	gens["DefaultRewriteRuleSet"] = gen.PtrOf(SubResourceGenerator())
	gens["PathRules"] = gen.SliceOf(ApplicationGatewayPathRuleGenerator())
}

func Test_ApplicationGatewayUrlPathMap_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 ApplicationGatewayUrlPathMap_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayUrlPathMap_STATUS, ApplicationGatewayUrlPathMap_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayUrlPathMap_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 ApplicationGatewayUrlPathMap_STATUS instances for property testing - lazily instantiated by
// ApplicationGatewayUrlPathMap_STATUSGenerator()
var applicationGatewayUrlPathMap_STATUSGenerator gopter.Gen

// ApplicationGatewayUrlPathMap_STATUSGenerator returns a generator of ApplicationGatewayUrlPathMap_STATUS instances for property testing.
func ApplicationGatewayUrlPathMap_STATUSGenerator() gopter.Gen {
	if applicationGatewayUrlPathMap_STATUSGenerator != nil {
		return applicationGatewayUrlPathMap_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayUrlPathMap_STATUS(generators)
	applicationGatewayUrlPathMap_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayUrlPathMap_STATUS{}), generators)

	return applicationGatewayUrlPathMap_STATUSGenerator
}

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

func Test_ApplicationGatewayWebApplicationFirewallConfiguration_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ApplicationGatewayWebApplicationFirewallConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayWebApplicationFirewallConfiguration, ApplicationGatewayWebApplicationFirewallConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration(generators)
	applicationGatewayWebApplicationFirewallConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayWebApplicationFirewallConfiguration{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration(generators)
	applicationGatewayWebApplicationFirewallConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayWebApplicationFirewallConfiguration{}), generators)

	return applicationGatewayWebApplicationFirewallConfigurationGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration(gens map[string]gopter.Gen) {
	gens["Enabled"] = gen.PtrOf(gen.Bool())
	gens["FileUploadLimitInMb"] = gen.PtrOf(gen.Int())
	gens["FirewallMode"] = gen.PtrOf(gen.AlphaString())
	gens["MaxRequestBodySize"] = gen.PtrOf(gen.Int())
	gens["MaxRequestBodySizeInKb"] = gen.PtrOf(gen.Int())
	gens["RequestBodyCheck"] = gen.PtrOf(gen.Bool())
	gens["RuleSetType"] = gen.PtrOf(gen.AlphaString())
	gens["RuleSetVersion"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration(gens map[string]gopter.Gen) {
	gens["DisabledRuleGroups"] = gen.SliceOf(ApplicationGatewayFirewallDisabledRuleGroupGenerator())
	gens["Exclusions"] = gen.SliceOf(ApplicationGatewayFirewallExclusionGenerator())
}

func Test_ApplicationGatewayWebApplicationFirewallConfiguration_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 ApplicationGatewayWebApplicationFirewallConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayWebApplicationFirewallConfiguration_STATUS, ApplicationGatewayWebApplicationFirewallConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGatewayWebApplicationFirewallConfiguration_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 ApplicationGatewayWebApplicationFirewallConfiguration_STATUS instances for property testing - lazily
// instantiated by ApplicationGatewayWebApplicationFirewallConfiguration_STATUSGenerator()
var applicationGatewayWebApplicationFirewallConfiguration_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration_STATUS(generators)
	applicationGatewayWebApplicationFirewallConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayWebApplicationFirewallConfiguration_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration_STATUS(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration_STATUS(generators)
	applicationGatewayWebApplicationFirewallConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayWebApplicationFirewallConfiguration_STATUS{}), generators)

	return applicationGatewayWebApplicationFirewallConfiguration_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["Enabled"] = gen.PtrOf(gen.Bool())
	gens["FileUploadLimitInMb"] = gen.PtrOf(gen.Int())
	gens["FirewallMode"] = gen.PtrOf(gen.AlphaString())
	gens["MaxRequestBodySize"] = gen.PtrOf(gen.Int())
	gens["MaxRequestBodySizeInKb"] = gen.PtrOf(gen.Int())
	gens["RequestBodyCheck"] = gen.PtrOf(gen.Bool())
	gens["RuleSetType"] = gen.PtrOf(gen.AlphaString())
	gens["RuleSetVersion"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayWebApplicationFirewallConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["DisabledRuleGroups"] = gen.SliceOf(ApplicationGatewayFirewallDisabledRuleGroup_STATUSGenerator())
	gens["Exclusions"] = gen.SliceOf(ApplicationGatewayFirewallExclusion_STATUSGenerator())
}

func Test_ApplicationGateway_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 ApplicationGateway_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGateway_STATUS, ApplicationGateway_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ApplicationGateway_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 ApplicationGateway_STATUS instances for property testing - lazily instantiated by
// ApplicationGateway_STATUSGenerator()
var applicationGateway_STATUSGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGateway_STATUS(generators)
	applicationGateway_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGateway_STATUS{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGateway_STATUS(generators)
	AddRelatedPropertyGeneratorsForApplicationGateway_STATUS(generators)
	applicationGateway_STATUSGenerator = gen.Struct(reflect.TypeOf(ApplicationGateway_STATUS{}), generators)

	return applicationGateway_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGateway_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGateway_STATUS(gens map[string]gopter.Gen) {
	gens["EnableFips"] = gen.PtrOf(gen.Bool())
	gens["EnableHttp2"] = gen.PtrOf(gen.Bool())
	gens["Etag"] = gen.PtrOf(gen.AlphaString())
	gens["ForceFirewallPolicyAssociation"] = gen.PtrOf(gen.Bool())
	gens["Id"] = gen.PtrOf(gen.AlphaString())
	gens["Location"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["OperationalState"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceGuid"] = gen.PtrOf(gen.AlphaString())
	gens["Tags"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["Type"] = gen.PtrOf(gen.AlphaString())
	gens["Zones"] = gen.SliceOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForApplicationGateway_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGateway_STATUS(gens map[string]gopter.Gen) {
	gens["AuthenticationCertificates"] = gen.SliceOf(ApplicationGatewayAuthenticationCertificate_STATUSGenerator())
	gens["AutoscaleConfiguration"] = gen.PtrOf(ApplicationGatewayAutoscaleConfiguration_STATUSGenerator())
	gens["BackendAddressPools"] = gen.SliceOf(ApplicationGatewayBackendAddressPool_STATUSGenerator())
	gens["BackendHttpSettingsCollection"] = gen.SliceOf(ApplicationGatewayBackendHttpSettings_STATUSGenerator())
	gens["BackendSettingsCollection"] = gen.SliceOf(ApplicationGatewayBackendSettings_STATUSGenerator())
	gens["CustomErrorConfigurations"] = gen.SliceOf(ApplicationGatewayCustomError_STATUSGenerator())
	gens["FirewallPolicy"] = gen.PtrOf(SubResource_STATUSGenerator())
	gens["FrontendIPConfigurations"] = gen.SliceOf(ApplicationGatewayFrontendIPConfiguration_STATUSGenerator())
	gens["FrontendPorts"] = gen.SliceOf(ApplicationGatewayFrontendPort_STATUSGenerator())
	gens["GatewayIPConfigurations"] = gen.SliceOf(ApplicationGatewayIPConfiguration_STATUS_ApplicationGateway_SubResourceEmbeddedGenerator())
	gens["GlobalConfiguration"] = gen.PtrOf(ApplicationGatewayGlobalConfiguration_STATUSGenerator())
	gens["HttpListeners"] = gen.SliceOf(ApplicationGatewayHttpListener_STATUSGenerator())
	gens["Identity"] = gen.PtrOf(ManagedServiceIdentity_STATUSGenerator())
	gens["Listeners"] = gen.SliceOf(ApplicationGatewayListener_STATUSGenerator())
	gens["LoadDistributionPolicies"] = gen.SliceOf(ApplicationGatewayLoadDistributionPolicy_STATUSGenerator())
	gens["PrivateEndpointConnections"] = gen.SliceOf(ApplicationGatewayPrivateEndpointConnection_STATUSGenerator())
	gens["PrivateLinkConfigurations"] = gen.SliceOf(ApplicationGatewayPrivateLinkConfiguration_STATUSGenerator())
	gens["Probes"] = gen.SliceOf(ApplicationGatewayProbe_STATUSGenerator())
	gens["RedirectConfigurations"] = gen.SliceOf(ApplicationGatewayRedirectConfiguration_STATUSGenerator())
	gens["RequestRoutingRules"] = gen.SliceOf(ApplicationGatewayRequestRoutingRule_STATUSGenerator())
	gens["RewriteRuleSets"] = gen.SliceOf(ApplicationGatewayRewriteRuleSet_STATUSGenerator())
	gens["RoutingRules"] = gen.SliceOf(ApplicationGatewayRoutingRule_STATUSGenerator())
	gens["Sku"] = gen.PtrOf(ApplicationGatewaySku_STATUSGenerator())
	gens["SslCertificates"] = gen.SliceOf(ApplicationGatewaySslCertificate_STATUSGenerator())
	gens["SslPolicy"] = gen.PtrOf(ApplicationGatewaySslPolicy_STATUSGenerator())
	gens["SslProfiles"] = gen.SliceOf(ApplicationGatewaySslProfile_STATUSGenerator())
	gens["TrustedClientCertificates"] = gen.SliceOf(ApplicationGatewayTrustedClientCertificate_STATUSGenerator())
	gens["TrustedRootCertificates"] = gen.SliceOf(ApplicationGatewayTrustedRootCertificate_STATUSGenerator())
	gens["UrlPathMaps"] = gen.SliceOf(ApplicationGatewayUrlPathMap_STATUSGenerator())
	gens["WebApplicationFirewallConfiguration"] = gen.PtrOf(ApplicationGatewayWebApplicationFirewallConfiguration_STATUSGenerator())
}

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

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

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

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

	return ""
}

// Generator of ApplicationGateway_Spec instances for property testing - lazily instantiated by
// ApplicationGateway_SpecGenerator()
var applicationGateway_SpecGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGateway_Spec(generators)
	applicationGateway_SpecGenerator = gen.Struct(reflect.TypeOf(ApplicationGateway_Spec{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGateway_Spec(generators)
	AddRelatedPropertyGeneratorsForApplicationGateway_Spec(generators)
	applicationGateway_SpecGenerator = gen.Struct(reflect.TypeOf(ApplicationGateway_Spec{}), generators)

	return applicationGateway_SpecGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGateway_Spec is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGateway_Spec(gens map[string]gopter.Gen) {
	gens["AzureName"] = gen.AlphaString()
	gens["EnableFips"] = gen.PtrOf(gen.Bool())
	gens["EnableHttp2"] = gen.PtrOf(gen.Bool())
	gens["ForceFirewallPolicyAssociation"] = gen.PtrOf(gen.Bool())
	gens["Location"] = gen.PtrOf(gen.AlphaString())
	gens["OriginalVersion"] = gen.AlphaString()
	gens["Tags"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["Zones"] = gen.SliceOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForApplicationGateway_Spec is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGateway_Spec(gens map[string]gopter.Gen) {
	gens["AuthenticationCertificates"] = gen.SliceOf(ApplicationGatewayAuthenticationCertificateGenerator())
	gens["AutoscaleConfiguration"] = gen.PtrOf(ApplicationGatewayAutoscaleConfigurationGenerator())
	gens["BackendAddressPools"] = gen.SliceOf(ApplicationGatewayBackendAddressPoolGenerator())
	gens["BackendHttpSettingsCollection"] = gen.SliceOf(ApplicationGatewayBackendHttpSettingsGenerator())
	gens["BackendSettingsCollection"] = gen.SliceOf(ApplicationGatewayBackendSettingsGenerator())
	gens["CustomErrorConfigurations"] = gen.SliceOf(ApplicationGatewayCustomErrorGenerator())
	gens["FirewallPolicy"] = gen.PtrOf(SubResourceGenerator())
	gens["FrontendIPConfigurations"] = gen.SliceOf(ApplicationGatewayFrontendIPConfigurationGenerator())
	gens["FrontendPorts"] = gen.SliceOf(ApplicationGatewayFrontendPortGenerator())
	gens["GatewayIPConfigurations"] = gen.SliceOf(ApplicationGatewayIPConfiguration_ApplicationGateway_SubResourceEmbeddedGenerator())
	gens["GlobalConfiguration"] = gen.PtrOf(ApplicationGatewayGlobalConfigurationGenerator())
	gens["HttpListeners"] = gen.SliceOf(ApplicationGatewayHttpListenerGenerator())
	gens["Identity"] = gen.PtrOf(ManagedServiceIdentityGenerator())
	gens["Listeners"] = gen.SliceOf(ApplicationGatewayListenerGenerator())
	gens["LoadDistributionPolicies"] = gen.SliceOf(ApplicationGatewayLoadDistributionPolicyGenerator())
	gens["OperatorSpec"] = gen.PtrOf(ApplicationGatewayOperatorSpecGenerator())
	gens["PrivateLinkConfigurations"] = gen.SliceOf(ApplicationGatewayPrivateLinkConfigurationGenerator())
	gens["Probes"] = gen.SliceOf(ApplicationGatewayProbeGenerator())
	gens["RedirectConfigurations"] = gen.SliceOf(ApplicationGatewayRedirectConfigurationGenerator())
	gens["RequestRoutingRules"] = gen.SliceOf(ApplicationGatewayRequestRoutingRuleGenerator())
	gens["RewriteRuleSets"] = gen.SliceOf(ApplicationGatewayRewriteRuleSetGenerator())
	gens["RoutingRules"] = gen.SliceOf(ApplicationGatewayRoutingRuleGenerator())
	gens["Sku"] = gen.PtrOf(ApplicationGatewaySkuGenerator())
	gens["SslCertificates"] = gen.SliceOf(ApplicationGatewaySslCertificateGenerator())
	gens["SslPolicy"] = gen.PtrOf(ApplicationGatewaySslPolicyGenerator())
	gens["SslProfiles"] = gen.SliceOf(ApplicationGatewaySslProfileGenerator())
	gens["TrustedClientCertificates"] = gen.SliceOf(ApplicationGatewayTrustedClientCertificateGenerator())
	gens["TrustedRootCertificates"] = gen.SliceOf(ApplicationGatewayTrustedRootCertificateGenerator())
	gens["UrlPathMaps"] = gen.SliceOf(ApplicationGatewayUrlPathMapGenerator())
	gens["WebApplicationFirewallConfiguration"] = gen.PtrOf(ApplicationGatewayWebApplicationFirewallConfigurationGenerator())
}

func Test_ManagedServiceIdentity_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from ManagedServiceIdentity to ManagedServiceIdentity via AssignProperties_To_ManagedServiceIdentity & AssignProperties_From_ManagedServiceIdentity returns original",
		prop.ForAll(RunPropertyAssignmentTestForManagedServiceIdentity, ManagedServiceIdentityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForManagedServiceIdentity tests if a specific instance of ManagedServiceIdentity can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForManagedServiceIdentity(subject ManagedServiceIdentity) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other v20240301s.ManagedServiceIdentity
	err := copied.AssignProperties_To_ManagedServiceIdentity(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual ManagedServiceIdentity
	err = actual.AssignProperties_From_ManagedServiceIdentity(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_ManagedServiceIdentity_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of ManagedServiceIdentity via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForManagedServiceIdentity, ManagedServiceIdentityGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of ManagedServiceIdentity instances for property testing - lazily instantiated by
// ManagedServiceIdentityGenerator()
var managedServiceIdentityGenerator gopter.Gen

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

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedServiceIdentity(generators)
	managedServiceIdentityGenerator = gen.Struct(reflect.TypeOf(ManagedServiceIdentity{}), generators)

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedServiceIdentity(generators)
	AddRelatedPropertyGeneratorsForManagedServiceIdentity(generators)
	managedServiceIdentityGenerator = gen.Struct(reflect.TypeOf(ManagedServiceIdentity{}), generators)

	return managedServiceIdentityGenerator
}

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

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

func Test_ManagedServiceIdentity_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from ManagedServiceIdentity_STATUS to ManagedServiceIdentity_STATUS via AssignProperties_To_ManagedServiceIdentity_STATUS & AssignProperties_From_ManagedServiceIdentity_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForManagedServiceIdentity_STATUS, ManagedServiceIdentity_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForManagedServiceIdentity_STATUS tests if a specific instance of ManagedServiceIdentity_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForManagedServiceIdentity_STATUS(subject ManagedServiceIdentity_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other v20240301s.ManagedServiceIdentity_STATUS
	err := copied.AssignProperties_To_ManagedServiceIdentity_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual ManagedServiceIdentity_STATUS
	err = actual.AssignProperties_From_ManagedServiceIdentity_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

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

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

	return ""
}

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

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

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

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

	return managedServiceIdentity_STATUSGenerator
}

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

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

func Test_ManagedServiceIdentity_UserAssignedIdentities_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from ManagedServiceIdentity_UserAssignedIdentities_STATUS to ManagedServiceIdentity_UserAssignedIdentities_STATUS via AssignProperties_To_ManagedServiceIdentity_UserAssignedIdentities_STATUS & AssignProperties_From_ManagedServiceIdentity_UserAssignedIdentities_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForManagedServiceIdentity_UserAssignedIdentities_STATUS, ManagedServiceIdentity_UserAssignedIdentities_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForManagedServiceIdentity_UserAssignedIdentities_STATUS tests if a specific instance of ManagedServiceIdentity_UserAssignedIdentities_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForManagedServiceIdentity_UserAssignedIdentities_STATUS(subject ManagedServiceIdentity_UserAssignedIdentities_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other v20240301s.ManagedServiceIdentity_UserAssignedIdentities_STATUS
	err := copied.AssignProperties_To_ManagedServiceIdentity_UserAssignedIdentities_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual ManagedServiceIdentity_UserAssignedIdentities_STATUS
	err = actual.AssignProperties_From_ManagedServiceIdentity_UserAssignedIdentities_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

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

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

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

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

	return ""
}

// Generator of ManagedServiceIdentity_UserAssignedIdentities_STATUS instances for property testing - lazily
// instantiated by ManagedServiceIdentity_UserAssignedIdentities_STATUSGenerator()
var managedServiceIdentity_UserAssignedIdentities_STATUSGenerator gopter.Gen

// ManagedServiceIdentity_UserAssignedIdentities_STATUSGenerator returns a generator of ManagedServiceIdentity_UserAssignedIdentities_STATUS instances for property testing.
func ManagedServiceIdentity_UserAssignedIdentities_STATUSGenerator() gopter.Gen {
	if managedServiceIdentity_UserAssignedIdentities_STATUSGenerator != nil {
		return managedServiceIdentity_UserAssignedIdentities_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForManagedServiceIdentity_UserAssignedIdentities_STATUS(generators)
	managedServiceIdentity_UserAssignedIdentities_STATUSGenerator = gen.Struct(reflect.TypeOf(ManagedServiceIdentity_UserAssignedIdentities_STATUS{}), generators)

	return managedServiceIdentity_UserAssignedIdentities_STATUSGenerator
}

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

func Test_SubResource_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SubResource to SubResource via AssignProperties_To_SubResource & AssignProperties_From_SubResource returns original",
		prop.ForAll(RunPropertyAssignmentTestForSubResource, SubResourceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSubResource tests if a specific instance of SubResource can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSubResource(subject SubResource) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other v20240301s.SubResource
	err := copied.AssignProperties_To_SubResource(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SubResource
	err = actual.AssignProperties_From_SubResource(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_SubResource_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SubResource via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSubResource, SubResourceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// SubResourceGenerator returns a generator of SubResource instances for property testing.
func SubResourceGenerator() gopter.Gen {
	if subResourceGenerator != nil {
		return subResourceGenerator
	}

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

	return subResourceGenerator
}

func Test_SubResource_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SubResource_STATUS to SubResource_STATUS via AssignProperties_To_SubResource_STATUS & AssignProperties_From_SubResource_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForSubResource_STATUS, SubResource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSubResource_STATUS tests if a specific instance of SubResource_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSubResource_STATUS(subject SubResource_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other v20240101s.SubResource_STATUS
	err := copied.AssignProperties_To_SubResource_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SubResource_STATUS
	err = actual.AssignProperties_From_SubResource_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_SubResource_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 SubResource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSubResource_STATUS, SubResource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SubResource_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 SubResource_STATUS instances for property testing - lazily instantiated by SubResource_STATUSGenerator()
var subResource_STATUSGenerator gopter.Gen

// SubResource_STATUSGenerator returns a generator of SubResource_STATUS instances for property testing.
func SubResource_STATUSGenerator() gopter.Gen {
	if subResource_STATUSGenerator != nil {
		return subResource_STATUSGenerator
	}

	generators := make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSubResource_STATUS(generators)
	subResource_STATUSGenerator = gen.Struct(reflect.TypeOf(SubResource_STATUS{}), generators)

	return subResource_STATUSGenerator
}

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

func Test_UserAssignedIdentityDetails_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from UserAssignedIdentityDetails to UserAssignedIdentityDetails via AssignProperties_To_UserAssignedIdentityDetails & AssignProperties_From_UserAssignedIdentityDetails returns original",
		prop.ForAll(RunPropertyAssignmentTestForUserAssignedIdentityDetails, UserAssignedIdentityDetailsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForUserAssignedIdentityDetails tests if a specific instance of UserAssignedIdentityDetails can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForUserAssignedIdentityDetails(subject UserAssignedIdentityDetails) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other v20240301s.UserAssignedIdentityDetails
	err := copied.AssignProperties_To_UserAssignedIdentityDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual UserAssignedIdentityDetails
	err = actual.AssignProperties_From_UserAssignedIdentityDetails(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_UserAssignedIdentityDetails_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of UserAssignedIdentityDetails via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUserAssignedIdentityDetails, UserAssignedIdentityDetailsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of UserAssignedIdentityDetails instances for property testing - lazily instantiated by
// UserAssignedIdentityDetailsGenerator()
var userAssignedIdentityDetailsGenerator gopter.Gen

// UserAssignedIdentityDetailsGenerator returns a generator of UserAssignedIdentityDetails instances for property testing.
func UserAssignedIdentityDetailsGenerator() gopter.Gen {
	if userAssignedIdentityDetailsGenerator != nil {
		return userAssignedIdentityDetailsGenerator
	}

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

	return userAssignedIdentityDetailsGenerator
}
