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

import (
	"encoding/json"
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"github.com/kr/pretty"
	"github.com/kylelemons/godebug/diff"
	"github.com/leanovate/gopter"
	"github.com/leanovate/gopter/gen"
	"github.com/leanovate/gopter/prop"
	"os"
	"reflect"
	"testing"
)

func Test_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.
// We first initialize applicationGatewayAuthenticationCertificateGenerator 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 ApplicationGatewayAuthenticationCertificateGenerator() gopter.Gen {
	if applicationGatewayAuthenticationCertificateGenerator != nil {
		return applicationGatewayAuthenticationCertificateGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayAuthenticationCertificate(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayAuthenticationCertificate(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())
}

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

func Test_ApplicationGatewayAuthenticationCertificatePropertiesFormat_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 ApplicationGatewayAuthenticationCertificatePropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayAuthenticationCertificatePropertiesFormat, ApplicationGatewayAuthenticationCertificatePropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayAuthenticationCertificatePropertiesFormatGenerator returns a generator of ApplicationGatewayAuthenticationCertificatePropertiesFormat instances for property testing.
func ApplicationGatewayAuthenticationCertificatePropertiesFormatGenerator() gopter.Gen {
	if applicationGatewayAuthenticationCertificatePropertiesFormatGenerator != nil {
		return applicationGatewayAuthenticationCertificatePropertiesFormatGenerator
	}

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

	return applicationGatewayAuthenticationCertificatePropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayAuthenticationCertificatePropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayAuthenticationCertificatePropertiesFormat(gens map[string]gopter.Gen) {
	gens["Data"] = 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_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["Properties"] = gen.PtrOf(ApplicationGatewayBackendAddressPoolPropertiesFormatGenerator())
}

func Test_ApplicationGatewayBackendAddressPoolPropertiesFormat_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 ApplicationGatewayBackendAddressPoolPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendAddressPoolPropertiesFormat, ApplicationGatewayBackendAddressPoolPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayBackendAddressPoolPropertiesFormatGenerator returns a generator of ApplicationGatewayBackendAddressPoolPropertiesFormat instances for property testing.
func ApplicationGatewayBackendAddressPoolPropertiesFormatGenerator() gopter.Gen {
	if applicationGatewayBackendAddressPoolPropertiesFormatGenerator != nil {
		return applicationGatewayBackendAddressPoolPropertiesFormatGenerator
	}

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

	return applicationGatewayBackendAddressPoolPropertiesFormatGenerator
}

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

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["Name"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_ApplicationGatewayBackendHttpSettingsPropertiesFormat_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 ApplicationGatewayBackendHttpSettingsPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendHttpSettingsPropertiesFormat, ApplicationGatewayBackendHttpSettingsPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendHttpSettingsPropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayBackendHttpSettingsPropertiesFormat(generators)
	applicationGatewayBackendHttpSettingsPropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendHttpSettingsPropertiesFormat{}), generators)

	return applicationGatewayBackendHttpSettingsPropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayBackendHttpSettingsPropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayBackendHttpSettingsPropertiesFormat(gens map[string]gopter.Gen) {
	gens["AffinityCookieName"] = gen.PtrOf(gen.AlphaString())
	gens["CookieBasedAffinity"] = gen.PtrOf(gen.OneConstOf(ApplicationGatewayBackendHttpSettingsPropertiesFormat_CookieBasedAffinity_Disabled, ApplicationGatewayBackendHttpSettingsPropertiesFormat_CookieBasedAffinity_Enabled))
	gens["HostName"] = 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.OneConstOf(
		ApplicationGatewayProtocol_Http,
		ApplicationGatewayProtocol_Https,
		ApplicationGatewayProtocol_Tcp,
		ApplicationGatewayProtocol_Tls))
	gens["RequestTimeout"] = gen.PtrOf(gen.Int())
}

// AddRelatedPropertyGeneratorsForApplicationGatewayBackendHttpSettingsPropertiesFormat is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayBackendHttpSettingsPropertiesFormat(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_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["Name"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_ApplicationGatewayBackendSettingsPropertiesFormat_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 ApplicationGatewayBackendSettingsPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayBackendSettingsPropertiesFormat, ApplicationGatewayBackendSettingsPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayBackendSettingsPropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayBackendSettingsPropertiesFormat(generators)
	applicationGatewayBackendSettingsPropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayBackendSettingsPropertiesFormat{}), generators)

	return applicationGatewayBackendSettingsPropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayBackendSettingsPropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayBackendSettingsPropertiesFormat(gens map[string]gopter.Gen) {
	gens["HostName"] = gen.PtrOf(gen.AlphaString())
	gens["PickHostNameFromBackendAddress"] = gen.PtrOf(gen.Bool())
	gens["Port"] = gen.PtrOf(gen.Int())
	gens["Protocol"] = gen.PtrOf(gen.OneConstOf(
		ApplicationGatewayProtocol_Http,
		ApplicationGatewayProtocol_Https,
		ApplicationGatewayProtocol_Tcp,
		ApplicationGatewayProtocol_Tls))
	gens["Timeout"] = gen.PtrOf(gen.Int())
}

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

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.OneConstOf(ApplicationGatewayClientAuthConfiguration_VerifyClientRevocation_None, ApplicationGatewayClientAuthConfiguration_VerifyClientRevocation_OCSP))
}

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.OneConstOf(ApplicationGatewayCustomError_StatusCode_HttpStatus403, ApplicationGatewayCustomError_StatusCode_HttpStatus502))
}

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_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_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())
}

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

func Test_ApplicationGatewayFrontendIPConfigurationPropertiesFormat_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 ApplicationGatewayFrontendIPConfigurationPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFrontendIPConfigurationPropertiesFormat, ApplicationGatewayFrontendIPConfigurationPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFrontendIPConfigurationPropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayFrontendIPConfigurationPropertiesFormat(generators)
	applicationGatewayFrontendIPConfigurationPropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayFrontendIPConfigurationPropertiesFormat{}), generators)

	return applicationGatewayFrontendIPConfigurationPropertiesFormatGenerator
}

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

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

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.
// We first initialize applicationGatewayFrontendPortGenerator 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 ApplicationGatewayFrontendPortGenerator() gopter.Gen {
	if applicationGatewayFrontendPortGenerator != nil {
		return applicationGatewayFrontendPortGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayFrontendPort(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayFrontendPort(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())
}

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

func Test_ApplicationGatewayFrontendPortPropertiesFormat_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 ApplicationGatewayFrontendPortPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayFrontendPortPropertiesFormat, ApplicationGatewayFrontendPortPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayFrontendPortPropertiesFormatGenerator returns a generator of ApplicationGatewayFrontendPortPropertiesFormat instances for property testing.
func ApplicationGatewayFrontendPortPropertiesFormatGenerator() gopter.Gen {
	if applicationGatewayFrontendPortPropertiesFormatGenerator != nil {
		return applicationGatewayFrontendPortPropertiesFormatGenerator
	}

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

	return applicationGatewayFrontendPortPropertiesFormatGenerator
}

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

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_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["Name"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_ApplicationGatewayHttpListenerPropertiesFormat_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 ApplicationGatewayHttpListenerPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayHttpListenerPropertiesFormat, ApplicationGatewayHttpListenerPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayHttpListenerPropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayHttpListenerPropertiesFormat(generators)
	applicationGatewayHttpListenerPropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayHttpListenerPropertiesFormat{}), generators)

	return applicationGatewayHttpListenerPropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayHttpListenerPropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayHttpListenerPropertiesFormat(gens map[string]gopter.Gen) {
	gens["HostName"] = gen.PtrOf(gen.AlphaString())
	gens["HostNames"] = gen.SliceOf(gen.AlphaString())
	gens["Protocol"] = gen.PtrOf(gen.OneConstOf(
		ApplicationGatewayProtocol_Http,
		ApplicationGatewayProtocol_Https,
		ApplicationGatewayProtocol_Tcp,
		ApplicationGatewayProtocol_Tls))
	gens["RequireServerNameIndication"] = gen.PtrOf(gen.Bool())
}

// AddRelatedPropertyGeneratorsForApplicationGatewayHttpListenerPropertiesFormat is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayHttpListenerPropertiesFormat(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_ApplicationGatewayIPConfigurationPropertiesFormat_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 ApplicationGatewayIPConfigurationPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayIPConfigurationPropertiesFormat, ApplicationGatewayIPConfigurationPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayIPConfigurationPropertiesFormatGenerator returns a generator of ApplicationGatewayIPConfigurationPropertiesFormat instances for property testing.
func ApplicationGatewayIPConfigurationPropertiesFormatGenerator() gopter.Gen {
	if applicationGatewayIPConfigurationPropertiesFormatGenerator != nil {
		return applicationGatewayIPConfigurationPropertiesFormatGenerator
	}

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

	return applicationGatewayIPConfigurationPropertiesFormatGenerator
}

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

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["Properties"] = gen.PtrOf(ApplicationGatewayIPConfigurationPropertiesFormatGenerator())
}

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())
}

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

func Test_ApplicationGatewayListenerPropertiesFormat_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 ApplicationGatewayListenerPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayListenerPropertiesFormat, ApplicationGatewayListenerPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayListenerPropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayListenerPropertiesFormat(generators)
	applicationGatewayListenerPropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayListenerPropertiesFormat{}), generators)

	return applicationGatewayListenerPropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayListenerPropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayListenerPropertiesFormat(gens map[string]gopter.Gen) {
	gens["Protocol"] = gen.PtrOf(gen.OneConstOf(
		ApplicationGatewayProtocol_Http,
		ApplicationGatewayProtocol_Https,
		ApplicationGatewayProtocol_Tcp,
		ApplicationGatewayProtocol_Tls))
}

// AddRelatedPropertyGeneratorsForApplicationGatewayListenerPropertiesFormat is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayListenerPropertiesFormat(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_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["Name"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_ApplicationGatewayLoadDistributionPolicyPropertiesFormat_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 ApplicationGatewayLoadDistributionPolicyPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayLoadDistributionPolicyPropertiesFormat, ApplicationGatewayLoadDistributionPolicyPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayLoadDistributionPolicyPropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayLoadDistributionPolicyPropertiesFormat(generators)
	applicationGatewayLoadDistributionPolicyPropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayLoadDistributionPolicyPropertiesFormat{}), generators)

	return applicationGatewayLoadDistributionPolicyPropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayLoadDistributionPolicyPropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayLoadDistributionPolicyPropertiesFormat(gens map[string]gopter.Gen) {
	gens["LoadDistributionAlgorithm"] = gen.PtrOf(gen.OneConstOf(ApplicationGatewayLoadDistributionAlgorithmEnum_IpHash, ApplicationGatewayLoadDistributionAlgorithmEnum_LeastConnections, ApplicationGatewayLoadDistributionAlgorithmEnum_RoundRobin))
}

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

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)
	AddIndependentPropertyGeneratorsForApplicationGatewayLoadDistributionTarget(generators)
	applicationGatewayLoadDistributionTargetGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayLoadDistributionTarget{}), generators)

	return applicationGatewayLoadDistributionTargetGenerator
}

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

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())
}

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

func Test_ApplicationGatewayPathRulePropertiesFormat_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 ApplicationGatewayPathRulePropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayPathRulePropertiesFormat, ApplicationGatewayPathRulePropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayPathRulePropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayPathRulePropertiesFormat(generators)
	applicationGatewayPathRulePropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayPathRulePropertiesFormat{}), generators)

	return applicationGatewayPathRulePropertiesFormatGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewayPathRulePropertiesFormat is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayPathRulePropertiesFormat(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_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["Properties"] = gen.PtrOf(ApplicationGatewayPrivateLinkConfigurationPropertiesGenerator())
}

func Test_ApplicationGatewayPrivateLinkConfigurationProperties_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 ApplicationGatewayPrivateLinkConfigurationProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayPrivateLinkConfigurationProperties, ApplicationGatewayPrivateLinkConfigurationPropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayPrivateLinkConfigurationPropertiesGenerator returns a generator of ApplicationGatewayPrivateLinkConfigurationProperties instances for property testing.
func ApplicationGatewayPrivateLinkConfigurationPropertiesGenerator() gopter.Gen {
	if applicationGatewayPrivateLinkConfigurationPropertiesGenerator != nil {
		return applicationGatewayPrivateLinkConfigurationPropertiesGenerator
	}

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

	return applicationGatewayPrivateLinkConfigurationPropertiesGenerator
}

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

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)
	AddIndependentPropertyGeneratorsForApplicationGatewayPrivateLinkIpConfiguration(generators)
	applicationGatewayPrivateLinkIpConfigurationGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayPrivateLinkIpConfiguration{}), generators)

	return applicationGatewayPrivateLinkIpConfigurationGenerator
}

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

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["Name"] = gen.PtrOf(gen.AlphaString())
}

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

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_ApplicationGatewayProbePropertiesFormat_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 ApplicationGatewayProbePropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayProbePropertiesFormat, ApplicationGatewayProbePropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayProbePropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayProbePropertiesFormat(generators)
	applicationGatewayProbePropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayProbePropertiesFormat{}), generators)

	return applicationGatewayProbePropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayProbePropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayProbePropertiesFormat(gens map[string]gopter.Gen) {
	gens["Host"] = gen.PtrOf(gen.AlphaString())
	gens["Interval"] = gen.PtrOf(gen.Int())
	gens["MinServers"] = gen.PtrOf(gen.Int())
	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.OneConstOf(
		ApplicationGatewayProtocol_Http,
		ApplicationGatewayProtocol_Https,
		ApplicationGatewayProtocol_Tcp,
		ApplicationGatewayProtocol_Tls))
	gens["Timeout"] = gen.PtrOf(gen.Int())
	gens["UnhealthyThreshold"] = gen.PtrOf(gen.Int())
}

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

func Test_ApplicationGatewayPropertiesFormat_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 ApplicationGatewayPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayPropertiesFormat, ApplicationGatewayPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayPropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayPropertiesFormat(generators)
	applicationGatewayPropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayPropertiesFormat{}), generators)

	return applicationGatewayPropertiesFormatGenerator
}

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

// AddRelatedPropertyGeneratorsForApplicationGatewayPropertiesFormat is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayPropertiesFormat(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["Listeners"] = gen.SliceOf(ApplicationGatewayListenerGenerator())
	gens["LoadDistributionPolicies"] = gen.SliceOf(ApplicationGatewayLoadDistributionPolicyGenerator())
	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_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["Name"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_ApplicationGatewayRedirectConfigurationPropertiesFormat_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 ApplicationGatewayRedirectConfigurationPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRedirectConfigurationPropertiesFormat, ApplicationGatewayRedirectConfigurationPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRedirectConfigurationPropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayRedirectConfigurationPropertiesFormat(generators)
	applicationGatewayRedirectConfigurationPropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRedirectConfigurationPropertiesFormat{}), generators)

	return applicationGatewayRedirectConfigurationPropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayRedirectConfigurationPropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayRedirectConfigurationPropertiesFormat(gens map[string]gopter.Gen) {
	gens["IncludePath"] = gen.PtrOf(gen.Bool())
	gens["IncludeQueryString"] = gen.PtrOf(gen.Bool())
	gens["RedirectType"] = gen.PtrOf(gen.OneConstOf(
		RedirectTypeEnum_Found,
		RedirectTypeEnum_Permanent,
		RedirectTypeEnum_SeeOther,
		RedirectTypeEnum_Temporary))
	gens["TargetUrl"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForApplicationGatewayRedirectConfigurationPropertiesFormat is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayRedirectConfigurationPropertiesFormat(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_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())
}

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

func Test_ApplicationGatewayRequestRoutingRulePropertiesFormat_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 ApplicationGatewayRequestRoutingRulePropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRequestRoutingRulePropertiesFormat, ApplicationGatewayRequestRoutingRulePropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRequestRoutingRulePropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayRequestRoutingRulePropertiesFormat(generators)
	applicationGatewayRequestRoutingRulePropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRequestRoutingRulePropertiesFormat{}), generators)

	return applicationGatewayRequestRoutingRulePropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayRequestRoutingRulePropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayRequestRoutingRulePropertiesFormat(gens map[string]gopter.Gen) {
	gens["Priority"] = gen.PtrOf(gen.Int())
	gens["RuleType"] = gen.PtrOf(gen.OneConstOf(ApplicationGatewayRequestRoutingRulePropertiesFormat_RuleType_Basic, ApplicationGatewayRequestRoutingRulePropertiesFormat_RuleType_PathBasedRouting))
}

// AddRelatedPropertyGeneratorsForApplicationGatewayRequestRoutingRulePropertiesFormat is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayRequestRoutingRulePropertiesFormat(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_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["Properties"] = gen.PtrOf(ApplicationGatewayRewriteRuleSetPropertiesFormatGenerator())
}

func Test_ApplicationGatewayRewriteRuleSetPropertiesFormat_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 ApplicationGatewayRewriteRuleSetPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRewriteRuleSetPropertiesFormat, ApplicationGatewayRewriteRuleSetPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayRewriteRuleSetPropertiesFormatGenerator returns a generator of ApplicationGatewayRewriteRuleSetPropertiesFormat instances for property testing.
func ApplicationGatewayRewriteRuleSetPropertiesFormatGenerator() gopter.Gen {
	if applicationGatewayRewriteRuleSetPropertiesFormatGenerator != nil {
		return applicationGatewayRewriteRuleSetPropertiesFormatGenerator
	}

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

	return applicationGatewayRewriteRuleSetPropertiesFormatGenerator
}

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

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())
}

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

func Test_ApplicationGatewayRoutingRulePropertiesFormat_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 ApplicationGatewayRoutingRulePropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayRoutingRulePropertiesFormat, ApplicationGatewayRoutingRulePropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayRoutingRulePropertiesFormat(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayRoutingRulePropertiesFormat(generators)
	applicationGatewayRoutingRulePropertiesFormatGenerator = gen.Struct(reflect.TypeOf(ApplicationGatewayRoutingRulePropertiesFormat{}), generators)

	return applicationGatewayRoutingRulePropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayRoutingRulePropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayRoutingRulePropertiesFormat(gens map[string]gopter.Gen) {
	gens["Priority"] = gen.PtrOf(gen.Int())
	gens["RuleType"] = gen.PtrOf(gen.OneConstOf(ApplicationGatewayRoutingRulePropertiesFormat_RuleType_Basic, ApplicationGatewayRoutingRulePropertiesFormat_RuleType_PathBasedRouting))
}

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

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.OneConstOf(
		ApplicationGatewaySku_Name_Standard_Large,
		ApplicationGatewaySku_Name_Standard_Medium,
		ApplicationGatewaySku_Name_Standard_Small,
		ApplicationGatewaySku_Name_Standard_V2,
		ApplicationGatewaySku_Name_WAF_Large,
		ApplicationGatewaySku_Name_WAF_Medium,
		ApplicationGatewaySku_Name_WAF_V2))
	gens["Tier"] = gen.PtrOf(gen.OneConstOf(
		ApplicationGatewaySku_Tier_Standard,
		ApplicationGatewaySku_Tier_Standard_V2,
		ApplicationGatewaySku_Tier_WAF,
		ApplicationGatewaySku_Tier_WAF_V2))
}

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.
// We first initialize applicationGatewaySslCertificateGenerator 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 ApplicationGatewaySslCertificateGenerator() gopter.Gen {
	if applicationGatewaySslCertificateGenerator != nil {
		return applicationGatewaySslCertificateGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewaySslCertificate(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewaySslCertificate(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["Name"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_ApplicationGatewaySslCertificatePropertiesFormat_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 ApplicationGatewaySslCertificatePropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySslCertificatePropertiesFormat, ApplicationGatewaySslCertificatePropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewaySslCertificatePropertiesFormatGenerator returns a generator of ApplicationGatewaySslCertificatePropertiesFormat instances for property testing.
func ApplicationGatewaySslCertificatePropertiesFormatGenerator() gopter.Gen {
	if applicationGatewaySslCertificatePropertiesFormatGenerator != nil {
		return applicationGatewaySslCertificatePropertiesFormatGenerator
	}

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

	return applicationGatewaySslCertificatePropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewaySslCertificatePropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewaySslCertificatePropertiesFormat(gens map[string]gopter.Gen) {
	gens["Data"] = gen.PtrOf(gen.AlphaString())
	gens["KeyVaultSecretId"] = gen.PtrOf(gen.AlphaString())
	gens["Password"] = 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.OneConstOf(
		CipherSuitesEnum_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA,
		CipherSuitesEnum_TLS_DHE_DSS_WITH_AES_128_CBC_SHA,
		CipherSuitesEnum_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256,
		CipherSuitesEnum_TLS_DHE_DSS_WITH_AES_256_CBC_SHA,
		CipherSuitesEnum_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256,
		CipherSuitesEnum_TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
		CipherSuitesEnum_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
		CipherSuitesEnum_TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
		CipherSuitesEnum_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
		CipherSuitesEnum_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
		CipherSuitesEnum_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
		CipherSuitesEnum_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
		CipherSuitesEnum_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
		CipherSuitesEnum_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
		CipherSuitesEnum_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
		CipherSuitesEnum_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
		CipherSuitesEnum_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
		CipherSuitesEnum_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
		CipherSuitesEnum_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
		CipherSuitesEnum_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
		CipherSuitesEnum_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
		CipherSuitesEnum_TLS_RSA_WITH_3DES_EDE_CBC_SHA,
		CipherSuitesEnum_TLS_RSA_WITH_AES_128_CBC_SHA,
		CipherSuitesEnum_TLS_RSA_WITH_AES_128_CBC_SHA256,
		CipherSuitesEnum_TLS_RSA_WITH_AES_128_GCM_SHA256,
		CipherSuitesEnum_TLS_RSA_WITH_AES_256_CBC_SHA,
		CipherSuitesEnum_TLS_RSA_WITH_AES_256_CBC_SHA256,
		CipherSuitesEnum_TLS_RSA_WITH_AES_256_GCM_SHA384))
	gens["DisabledSslProtocols"] = gen.SliceOf(gen.OneConstOf(
		ProtocolsEnum_TLSv1_0,
		ProtocolsEnum_TLSv1_1,
		ProtocolsEnum_TLSv1_2,
		ProtocolsEnum_TLSv1_3))
	gens["MinProtocolVersion"] = gen.PtrOf(gen.OneConstOf(
		ProtocolsEnum_TLSv1_0,
		ProtocolsEnum_TLSv1_1,
		ProtocolsEnum_TLSv1_2,
		ProtocolsEnum_TLSv1_3))
	gens["PolicyName"] = gen.PtrOf(gen.OneConstOf(
		PolicyNameEnum_AppGwSslPolicy20150501,
		PolicyNameEnum_AppGwSslPolicy20170401,
		PolicyNameEnum_AppGwSslPolicy20170401S,
		PolicyNameEnum_AppGwSslPolicy20220101,
		PolicyNameEnum_AppGwSslPolicy20220101S))
	gens["PolicyType"] = gen.PtrOf(gen.OneConstOf(ApplicationGatewaySslPolicy_PolicyType_Custom, ApplicationGatewaySslPolicy_PolicyType_CustomV2, ApplicationGatewaySslPolicy_PolicyType_Predefined))
}

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["Properties"] = gen.PtrOf(ApplicationGatewaySslProfilePropertiesFormatGenerator())
}

func Test_ApplicationGatewaySslProfilePropertiesFormat_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 ApplicationGatewaySslProfilePropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewaySslProfilePropertiesFormat, ApplicationGatewaySslProfilePropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewaySslProfilePropertiesFormatGenerator returns a generator of ApplicationGatewaySslProfilePropertiesFormat instances for property testing.
func ApplicationGatewaySslProfilePropertiesFormatGenerator() gopter.Gen {
	if applicationGatewaySslProfilePropertiesFormatGenerator != nil {
		return applicationGatewaySslProfilePropertiesFormatGenerator
	}

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

	return applicationGatewaySslProfilePropertiesFormatGenerator
}

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

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.
// We first initialize applicationGatewayTrustedClientCertificateGenerator 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 ApplicationGatewayTrustedClientCertificateGenerator() gopter.Gen {
	if applicationGatewayTrustedClientCertificateGenerator != nil {
		return applicationGatewayTrustedClientCertificateGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayTrustedClientCertificate(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayTrustedClientCertificate(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())
}

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

func Test_ApplicationGatewayTrustedClientCertificatePropertiesFormat_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 ApplicationGatewayTrustedClientCertificatePropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayTrustedClientCertificatePropertiesFormat, ApplicationGatewayTrustedClientCertificatePropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayTrustedClientCertificatePropertiesFormatGenerator returns a generator of ApplicationGatewayTrustedClientCertificatePropertiesFormat instances for property testing.
func ApplicationGatewayTrustedClientCertificatePropertiesFormatGenerator() gopter.Gen {
	if applicationGatewayTrustedClientCertificatePropertiesFormatGenerator != nil {
		return applicationGatewayTrustedClientCertificatePropertiesFormatGenerator
	}

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

	return applicationGatewayTrustedClientCertificatePropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayTrustedClientCertificatePropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayTrustedClientCertificatePropertiesFormat(gens map[string]gopter.Gen) {
	gens["Data"] = 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.
// We first initialize applicationGatewayTrustedRootCertificateGenerator 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 ApplicationGatewayTrustedRootCertificateGenerator() gopter.Gen {
	if applicationGatewayTrustedRootCertificateGenerator != nil {
		return applicationGatewayTrustedRootCertificateGenerator
	}

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForApplicationGatewayTrustedRootCertificate(generators)
	AddRelatedPropertyGeneratorsForApplicationGatewayTrustedRootCertificate(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["Name"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_ApplicationGatewayTrustedRootCertificatePropertiesFormat_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 ApplicationGatewayTrustedRootCertificatePropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayTrustedRootCertificatePropertiesFormat, ApplicationGatewayTrustedRootCertificatePropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayTrustedRootCertificatePropertiesFormatGenerator returns a generator of ApplicationGatewayTrustedRootCertificatePropertiesFormat instances for property testing.
func ApplicationGatewayTrustedRootCertificatePropertiesFormatGenerator() gopter.Gen {
	if applicationGatewayTrustedRootCertificatePropertiesFormatGenerator != nil {
		return applicationGatewayTrustedRootCertificatePropertiesFormatGenerator
	}

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

	return applicationGatewayTrustedRootCertificatePropertiesFormatGenerator
}

// AddIndependentPropertyGeneratorsForApplicationGatewayTrustedRootCertificatePropertiesFormat is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForApplicationGatewayTrustedRootCertificatePropertiesFormat(gens map[string]gopter.Gen) {
	gens["Data"] = gen.PtrOf(gen.AlphaString())
	gens["KeyVaultSecretId"] = 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["Properties"] = gen.PtrOf(ApplicationGatewayUrlPathMapPropertiesFormatGenerator())
}

func Test_ApplicationGatewayUrlPathMapPropertiesFormat_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 ApplicationGatewayUrlPathMapPropertiesFormat via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForApplicationGatewayUrlPathMapPropertiesFormat, ApplicationGatewayUrlPathMapPropertiesFormatGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ApplicationGatewayUrlPathMapPropertiesFormatGenerator returns a generator of ApplicationGatewayUrlPathMapPropertiesFormat instances for property testing.
func ApplicationGatewayUrlPathMapPropertiesFormatGenerator() gopter.Gen {
	if applicationGatewayUrlPathMapPropertiesFormatGenerator != nil {
		return applicationGatewayUrlPathMapPropertiesFormatGenerator
	}

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

	return applicationGatewayUrlPathMapPropertiesFormatGenerator
}

// AddRelatedPropertyGeneratorsForApplicationGatewayUrlPathMapPropertiesFormat is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForApplicationGatewayUrlPathMapPropertiesFormat(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_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.OneConstOf(ApplicationGatewayWebApplicationFirewallConfiguration_FirewallMode_Detection, ApplicationGatewayWebApplicationFirewallConfiguration_FirewallMode_Prevention))
	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_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["Location"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = 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["Identity"] = gen.PtrOf(ManagedServiceIdentityGenerator())
	gens["Properties"] = gen.PtrOf(ApplicationGatewayPropertiesFormatGenerator())
}

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.OneConstOf(
		ManagedServiceIdentity_Type_None,
		ManagedServiceIdentity_Type_SystemAssigned,
		ManagedServiceIdentity_Type_SystemAssignedUserAssigned,
		ManagedServiceIdentity_Type_UserAssigned))
}

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

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)
	AddIndependentPropertyGeneratorsForSubResource(generators)
	subResourceGenerator = gen.Struct(reflect.TypeOf(SubResource{}), generators)

	return subResourceGenerator
}

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

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
}
