// 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_AddressSpace_STATUS_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 80
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of AddressSpace_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAddressSpace_STATUS, AddressSpace_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of AddressSpace_STATUS instances for property testing - lazily instantiated by
// AddressSpace_STATUSGenerator()
var addressSpace_STATUSGenerator gopter.Gen

// AddressSpace_STATUSGenerator returns a generator of AddressSpace_STATUS instances for property testing.
func AddressSpace_STATUSGenerator() gopter.Gen {
	if addressSpace_STATUSGenerator != nil {
		return addressSpace_STATUSGenerator
	}

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

	return addressSpace_STATUSGenerator
}

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

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

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

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

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

	return ""
}

// Generator of BgpSettings_STATUS instances for property testing - lazily instantiated by BgpSettings_STATUSGenerator()
var bgpSettings_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForBgpSettings_STATUS(generators)
	AddRelatedPropertyGeneratorsForBgpSettings_STATUS(generators)
	bgpSettings_STATUSGenerator = gen.Struct(reflect.TypeOf(BgpSettings_STATUS{}), generators)

	return bgpSettings_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForBgpSettings_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForBgpSettings_STATUS(gens map[string]gopter.Gen) {
	gens["Asn"] = gen.PtrOf(gen.UInt32())
	gens["BgpPeeringAddress"] = gen.PtrOf(gen.AlphaString())
	gens["PeerWeight"] = gen.PtrOf(gen.Int())
}

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

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

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

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

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

	return ""
}

// Generator of IPConfigurationBgpPeeringAddress_STATUS instances for property testing - lazily instantiated by
// IPConfigurationBgpPeeringAddress_STATUSGenerator()
var ipConfigurationBgpPeeringAddress_STATUSGenerator gopter.Gen

// IPConfigurationBgpPeeringAddress_STATUSGenerator returns a generator of IPConfigurationBgpPeeringAddress_STATUS instances for property testing.
func IPConfigurationBgpPeeringAddress_STATUSGenerator() gopter.Gen {
	if ipConfigurationBgpPeeringAddress_STATUSGenerator != nil {
		return ipConfigurationBgpPeeringAddress_STATUSGenerator
	}

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

	return ipConfigurationBgpPeeringAddress_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIPConfigurationBgpPeeringAddress_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIPConfigurationBgpPeeringAddress_STATUS(gens map[string]gopter.Gen) {
	gens["CustomBgpIpAddresses"] = gen.SliceOf(gen.AlphaString())
	gens["DefaultBgpIpAddresses"] = gen.SliceOf(gen.AlphaString())
	gens["IpconfigurationId"] = gen.PtrOf(gen.AlphaString())
	gens["TunnelIpAddresses"] = gen.SliceOf(gen.AlphaString())
}

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

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

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

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

	return ""
}

// Generator of IpsecPolicy_STATUS instances for property testing - lazily instantiated by IpsecPolicy_STATUSGenerator()
var ipsecPolicy_STATUSGenerator gopter.Gen

// IpsecPolicy_STATUSGenerator returns a generator of IpsecPolicy_STATUS instances for property testing.
func IpsecPolicy_STATUSGenerator() gopter.Gen {
	if ipsecPolicy_STATUSGenerator != nil {
		return ipsecPolicy_STATUSGenerator
	}

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

	return ipsecPolicy_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForIpsecPolicy_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForIpsecPolicy_STATUS(gens map[string]gopter.Gen) {
	gens["DhGroup"] = gen.PtrOf(gen.OneConstOf(
		DhGroup_STATUS_DHGroup1,
		DhGroup_STATUS_DHGroup14,
		DhGroup_STATUS_DHGroup2,
		DhGroup_STATUS_DHGroup2048,
		DhGroup_STATUS_DHGroup24,
		DhGroup_STATUS_ECP256,
		DhGroup_STATUS_ECP384,
		DhGroup_STATUS_None))
	gens["IkeEncryption"] = gen.PtrOf(gen.OneConstOf(
		IkeEncryption_STATUS_AES128,
		IkeEncryption_STATUS_AES192,
		IkeEncryption_STATUS_AES256,
		IkeEncryption_STATUS_DES,
		IkeEncryption_STATUS_DES3,
		IkeEncryption_STATUS_GCMAES128,
		IkeEncryption_STATUS_GCMAES256))
	gens["IkeIntegrity"] = gen.PtrOf(gen.OneConstOf(
		IkeIntegrity_STATUS_GCMAES128,
		IkeIntegrity_STATUS_GCMAES256,
		IkeIntegrity_STATUS_MD5,
		IkeIntegrity_STATUS_SHA1,
		IkeIntegrity_STATUS_SHA256,
		IkeIntegrity_STATUS_SHA384))
	gens["IpsecEncryption"] = gen.PtrOf(gen.OneConstOf(
		IpsecEncryption_STATUS_AES128,
		IpsecEncryption_STATUS_AES192,
		IpsecEncryption_STATUS_AES256,
		IpsecEncryption_STATUS_DES,
		IpsecEncryption_STATUS_DES3,
		IpsecEncryption_STATUS_GCMAES128,
		IpsecEncryption_STATUS_GCMAES192,
		IpsecEncryption_STATUS_GCMAES256,
		IpsecEncryption_STATUS_None))
	gens["IpsecIntegrity"] = gen.PtrOf(gen.OneConstOf(
		IpsecIntegrity_STATUS_GCMAES128,
		IpsecIntegrity_STATUS_GCMAES192,
		IpsecIntegrity_STATUS_GCMAES256,
		IpsecIntegrity_STATUS_MD5,
		IpsecIntegrity_STATUS_SHA1,
		IpsecIntegrity_STATUS_SHA256))
	gens["PfsGroup"] = gen.PtrOf(gen.OneConstOf(
		PfsGroup_STATUS_ECP256,
		PfsGroup_STATUS_ECP384,
		PfsGroup_STATUS_None,
		PfsGroup_STATUS_PFS1,
		PfsGroup_STATUS_PFS14,
		PfsGroup_STATUS_PFS2,
		PfsGroup_STATUS_PFS2048,
		PfsGroup_STATUS_PFS24,
		PfsGroup_STATUS_PFSMM))
	gens["SaDataSizeKilobytes"] = gen.PtrOf(gen.Int())
	gens["SaLifeTimeSeconds"] = gen.PtrOf(gen.Int())
}

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

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

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

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

	return ""
}

// Generator of RadiusServer_STATUS instances for property testing - lazily instantiated by
// RadiusServer_STATUSGenerator()
var radiusServer_STATUSGenerator gopter.Gen

// RadiusServer_STATUSGenerator returns a generator of RadiusServer_STATUS instances for property testing.
func RadiusServer_STATUSGenerator() gopter.Gen {
	if radiusServer_STATUSGenerator != nil {
		return radiusServer_STATUSGenerator
	}

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

	return radiusServer_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForRadiusServer_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForRadiusServer_STATUS(gens map[string]gopter.Gen) {
	gens["RadiusServerAddress"] = gen.PtrOf(gen.AlphaString())
	gens["RadiusServerScore"] = gen.PtrOf(gen.Int())
	gens["RadiusServerSecret"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayAutoScaleBounds_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkGatewayAutoScaleBounds_STATUSGenerator()
var virtualNetworkGatewayAutoScaleBounds_STATUSGenerator gopter.Gen

// VirtualNetworkGatewayAutoScaleBounds_STATUSGenerator returns a generator of VirtualNetworkGatewayAutoScaleBounds_STATUS instances for property testing.
func VirtualNetworkGatewayAutoScaleBounds_STATUSGenerator() gopter.Gen {
	if virtualNetworkGatewayAutoScaleBounds_STATUSGenerator != nil {
		return virtualNetworkGatewayAutoScaleBounds_STATUSGenerator
	}

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

	return virtualNetworkGatewayAutoScaleBounds_STATUSGenerator
}

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

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayAutoScaleConfiguration_STATUS instances for property testing - lazily instantiated
// by VirtualNetworkGatewayAutoScaleConfiguration_STATUSGenerator()
var virtualNetworkGatewayAutoScaleConfiguration_STATUSGenerator gopter.Gen

// VirtualNetworkGatewayAutoScaleConfiguration_STATUSGenerator returns a generator of VirtualNetworkGatewayAutoScaleConfiguration_STATUS instances for property testing.
func VirtualNetworkGatewayAutoScaleConfiguration_STATUSGenerator() gopter.Gen {
	if virtualNetworkGatewayAutoScaleConfiguration_STATUSGenerator != nil {
		return virtualNetworkGatewayAutoScaleConfiguration_STATUSGenerator
	}

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

	return virtualNetworkGatewayAutoScaleConfiguration_STATUSGenerator
}

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

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayIPConfigurationPropertiesFormat_STATUS instances for property testing - lazily
// instantiated by VirtualNetworkGatewayIPConfigurationPropertiesFormat_STATUSGenerator()
var virtualNetworkGatewayIPConfigurationPropertiesFormat_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualNetworkGatewayIPConfigurationPropertiesFormat_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualNetworkGatewayIPConfigurationPropertiesFormat_STATUS(generators)
	virtualNetworkGatewayIPConfigurationPropertiesFormat_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualNetworkGatewayIPConfigurationPropertiesFormat_STATUS{}), generators)

	return virtualNetworkGatewayIPConfigurationPropertiesFormat_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualNetworkGatewayIPConfigurationPropertiesFormat_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualNetworkGatewayIPConfigurationPropertiesFormat_STATUS(gens map[string]gopter.Gen) {
	gens["PrivateIPAddress"] = gen.PtrOf(gen.AlphaString())
	gens["PrivateIPAllocationMethod"] = gen.PtrOf(gen.OneConstOf(IPAllocationMethod_STATUS_Dynamic, IPAllocationMethod_STATUS_Static))
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ProvisioningState_STATUS_Deleting,
		ProvisioningState_STATUS_Failed,
		ProvisioningState_STATUS_Succeeded,
		ProvisioningState_STATUS_Updating))
}

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

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayIPConfiguration_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkGatewayIPConfiguration_STATUSGenerator()
var virtualNetworkGatewayIPConfiguration_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualNetworkGatewayIPConfiguration_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualNetworkGatewayIPConfiguration_STATUS(generators)
	virtualNetworkGatewayIPConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualNetworkGatewayIPConfiguration_STATUS{}), generators)

	return virtualNetworkGatewayIPConfiguration_STATUSGenerator
}

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

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

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayNatRuleProperties_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkGatewayNatRuleProperties_STATUSGenerator()
var virtualNetworkGatewayNatRuleProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualNetworkGatewayNatRuleProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualNetworkGatewayNatRuleProperties_STATUS(generators)
	virtualNetworkGatewayNatRuleProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualNetworkGatewayNatRuleProperties_STATUS{}), generators)

	return virtualNetworkGatewayNatRuleProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualNetworkGatewayNatRuleProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualNetworkGatewayNatRuleProperties_STATUS(gens map[string]gopter.Gen) {
	gens["IpConfigurationId"] = gen.PtrOf(gen.AlphaString())
	gens["Mode"] = gen.PtrOf(gen.OneConstOf(VirtualNetworkGatewayNatRuleProperties_Mode_STATUS_EgressSnat, VirtualNetworkGatewayNatRuleProperties_Mode_STATUS_IngressSnat))
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ProvisioningState_STATUS_Deleting,
		ProvisioningState_STATUS_Failed,
		ProvisioningState_STATUS_Succeeded,
		ProvisioningState_STATUS_Updating))
	gens["Type"] = gen.PtrOf(gen.OneConstOf(VirtualNetworkGatewayNatRuleProperties_Type_STATUS_Dynamic, VirtualNetworkGatewayNatRuleProperties_Type_STATUS_Static))
}

// AddRelatedPropertyGeneratorsForVirtualNetworkGatewayNatRuleProperties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForVirtualNetworkGatewayNatRuleProperties_STATUS(gens map[string]gopter.Gen) {
	gens["ExternalMappings"] = gen.SliceOf(VpnNatRuleMapping_STATUSGenerator())
	gens["InternalMappings"] = gen.SliceOf(VpnNatRuleMapping_STATUSGenerator())
}

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayNatRule_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkGatewayNatRule_STATUSGenerator()
var virtualNetworkGatewayNatRule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualNetworkGatewayNatRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualNetworkGatewayNatRule_STATUS(generators)
	virtualNetworkGatewayNatRule_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualNetworkGatewayNatRule_STATUS{}), generators)

	return virtualNetworkGatewayNatRule_STATUSGenerator
}

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

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

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayPolicyGroupMember_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkGatewayPolicyGroupMember_STATUSGenerator()
var virtualNetworkGatewayPolicyGroupMember_STATUSGenerator gopter.Gen

// VirtualNetworkGatewayPolicyGroupMember_STATUSGenerator returns a generator of VirtualNetworkGatewayPolicyGroupMember_STATUS instances for property testing.
func VirtualNetworkGatewayPolicyGroupMember_STATUSGenerator() gopter.Gen {
	if virtualNetworkGatewayPolicyGroupMember_STATUSGenerator != nil {
		return virtualNetworkGatewayPolicyGroupMember_STATUSGenerator
	}

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

	return virtualNetworkGatewayPolicyGroupMember_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualNetworkGatewayPolicyGroupMember_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualNetworkGatewayPolicyGroupMember_STATUS(gens map[string]gopter.Gen) {
	gens["AttributeType"] = gen.PtrOf(gen.OneConstOf(VirtualNetworkGatewayPolicyGroupMember_AttributeType_STATUS_AADGroupId, VirtualNetworkGatewayPolicyGroupMember_AttributeType_STATUS_CertificateGroupId, VirtualNetworkGatewayPolicyGroupMember_AttributeType_STATUS_RadiusAzureGroupId))
	gens["AttributeValue"] = gen.PtrOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayPolicyGroupProperties_STATUS instances for property testing - lazily instantiated
// by VirtualNetworkGatewayPolicyGroupProperties_STATUSGenerator()
var virtualNetworkGatewayPolicyGroupProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualNetworkGatewayPolicyGroupProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualNetworkGatewayPolicyGroupProperties_STATUS(generators)
	virtualNetworkGatewayPolicyGroupProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualNetworkGatewayPolicyGroupProperties_STATUS{}), generators)

	return virtualNetworkGatewayPolicyGroupProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualNetworkGatewayPolicyGroupProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualNetworkGatewayPolicyGroupProperties_STATUS(gens map[string]gopter.Gen) {
	gens["IsDefault"] = gen.PtrOf(gen.Bool())
	gens["Priority"] = gen.PtrOf(gen.Int())
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ProvisioningState_STATUS_Deleting,
		ProvisioningState_STATUS_Failed,
		ProvisioningState_STATUS_Succeeded,
		ProvisioningState_STATUS_Updating))
}

// AddRelatedPropertyGeneratorsForVirtualNetworkGatewayPolicyGroupProperties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForVirtualNetworkGatewayPolicyGroupProperties_STATUS(gens map[string]gopter.Gen) {
	gens["PolicyMembers"] = gen.SliceOf(VirtualNetworkGatewayPolicyGroupMember_STATUSGenerator())
	gens["VngClientConnectionConfigurations"] = gen.SliceOf(SubResource_STATUSGenerator())
}

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayPolicyGroup_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkGatewayPolicyGroup_STATUSGenerator()
var virtualNetworkGatewayPolicyGroup_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualNetworkGatewayPolicyGroup_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualNetworkGatewayPolicyGroup_STATUS(generators)
	virtualNetworkGatewayPolicyGroup_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualNetworkGatewayPolicyGroup_STATUS{}), generators)

	return virtualNetworkGatewayPolicyGroup_STATUSGenerator
}

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

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

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewayPropertiesFormat_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkGatewayPropertiesFormat_STATUSGenerator()
var virtualNetworkGatewayPropertiesFormat_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualNetworkGatewayPropertiesFormat_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualNetworkGatewayPropertiesFormat_STATUS(generators)
	virtualNetworkGatewayPropertiesFormat_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualNetworkGatewayPropertiesFormat_STATUS{}), generators)

	return virtualNetworkGatewayPropertiesFormat_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualNetworkGatewayPropertiesFormat_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualNetworkGatewayPropertiesFormat_STATUS(gens map[string]gopter.Gen) {
	gens["ActiveActive"] = gen.PtrOf(gen.Bool())
	gens["AdminState"] = gen.PtrOf(gen.OneConstOf(VirtualNetworkGatewayPropertiesFormat_AdminState_STATUS_Disabled, VirtualNetworkGatewayPropertiesFormat_AdminState_STATUS_Enabled))
	gens["AllowRemoteVnetTraffic"] = gen.PtrOf(gen.Bool())
	gens["AllowVirtualWanTraffic"] = gen.PtrOf(gen.Bool())
	gens["DisableIPSecReplayProtection"] = gen.PtrOf(gen.Bool())
	gens["EnableBgp"] = gen.PtrOf(gen.Bool())
	gens["EnableBgpRouteTranslationForNat"] = gen.PtrOf(gen.Bool())
	gens["EnableDnsForwarding"] = gen.PtrOf(gen.Bool())
	gens["EnablePrivateIpAddress"] = gen.PtrOf(gen.Bool())
	gens["GatewayType"] = gen.PtrOf(gen.OneConstOf(VirtualNetworkGatewayPropertiesFormat_GatewayType_STATUS_ExpressRoute, VirtualNetworkGatewayPropertiesFormat_GatewayType_STATUS_LocalGateway, VirtualNetworkGatewayPropertiesFormat_GatewayType_STATUS_Vpn))
	gens["InboundDnsForwardingEndpoint"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ProvisioningState_STATUS_Deleting,
		ProvisioningState_STATUS_Failed,
		ProvisioningState_STATUS_Succeeded,
		ProvisioningState_STATUS_Updating))
	gens["ResiliencyModel"] = gen.PtrOf(gen.OneConstOf(VirtualNetworkGatewayPropertiesFormat_ResiliencyModel_STATUS_MultiHomed, VirtualNetworkGatewayPropertiesFormat_ResiliencyModel_STATUS_SingleHomed))
	gens["ResourceGuid"] = gen.PtrOf(gen.AlphaString())
	gens["VNetExtendedLocationResourceId"] = gen.PtrOf(gen.AlphaString())
	gens["VpnGatewayGeneration"] = gen.PtrOf(gen.OneConstOf(VirtualNetworkGatewayPropertiesFormat_VpnGatewayGeneration_STATUS_Generation1, VirtualNetworkGatewayPropertiesFormat_VpnGatewayGeneration_STATUS_Generation2, VirtualNetworkGatewayPropertiesFormat_VpnGatewayGeneration_STATUS_None))
	gens["VpnType"] = gen.PtrOf(gen.OneConstOf(VirtualNetworkGatewayPropertiesFormat_VpnType_STATUS_PolicyBased, VirtualNetworkGatewayPropertiesFormat_VpnType_STATUS_RouteBased))
}

// AddRelatedPropertyGeneratorsForVirtualNetworkGatewayPropertiesFormat_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForVirtualNetworkGatewayPropertiesFormat_STATUS(gens map[string]gopter.Gen) {
	gens["AutoScaleConfiguration"] = gen.PtrOf(VirtualNetworkGatewayAutoScaleConfiguration_STATUSGenerator())
	gens["BgpSettings"] = gen.PtrOf(BgpSettings_STATUSGenerator())
	gens["CustomRoutes"] = gen.PtrOf(AddressSpace_STATUSGenerator())
	gens["GatewayDefaultSite"] = gen.PtrOf(SubResource_STATUSGenerator())
	gens["IpConfigurations"] = gen.SliceOf(VirtualNetworkGatewayIPConfiguration_STATUSGenerator())
	gens["NatRules"] = gen.SliceOf(VirtualNetworkGatewayNatRule_STATUSGenerator())
	gens["Sku"] = gen.PtrOf(VirtualNetworkGatewaySku_STATUSGenerator())
	gens["VirtualNetworkGatewayPolicyGroups"] = gen.SliceOf(VirtualNetworkGatewayPolicyGroup_STATUSGenerator())
	gens["VpnClientConfiguration"] = gen.PtrOf(VpnClientConfiguration_STATUSGenerator())
}

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGatewaySku_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkGatewaySku_STATUSGenerator()
var virtualNetworkGatewaySku_STATUSGenerator gopter.Gen

// VirtualNetworkGatewaySku_STATUSGenerator returns a generator of VirtualNetworkGatewaySku_STATUS instances for property testing.
func VirtualNetworkGatewaySku_STATUSGenerator() gopter.Gen {
	if virtualNetworkGatewaySku_STATUSGenerator != nil {
		return virtualNetworkGatewaySku_STATUSGenerator
	}

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

	return virtualNetworkGatewaySku_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualNetworkGatewaySku_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualNetworkGatewaySku_STATUS(gens map[string]gopter.Gen) {
	gens["Capacity"] = gen.PtrOf(gen.Int())
	gens["Name"] = gen.PtrOf(gen.OneConstOf(
		VirtualNetworkGatewaySku_Name_STATUS_Basic,
		VirtualNetworkGatewaySku_Name_STATUS_ErGw1AZ,
		VirtualNetworkGatewaySku_Name_STATUS_ErGw2AZ,
		VirtualNetworkGatewaySku_Name_STATUS_ErGw3AZ,
		VirtualNetworkGatewaySku_Name_STATUS_ErGwScale,
		VirtualNetworkGatewaySku_Name_STATUS_HighPerformance,
		VirtualNetworkGatewaySku_Name_STATUS_Standard,
		VirtualNetworkGatewaySku_Name_STATUS_UltraPerformance,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw1,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw1AZ,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw2,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw2AZ,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw3,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw3AZ,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw4,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw4AZ,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw5,
		VirtualNetworkGatewaySku_Name_STATUS_VpnGw5AZ))
	gens["Tier"] = gen.PtrOf(gen.OneConstOf(
		VirtualNetworkGatewaySku_Tier_STATUS_Basic,
		VirtualNetworkGatewaySku_Tier_STATUS_ErGw1AZ,
		VirtualNetworkGatewaySku_Tier_STATUS_ErGw2AZ,
		VirtualNetworkGatewaySku_Tier_STATUS_ErGw3AZ,
		VirtualNetworkGatewaySku_Tier_STATUS_ErGwScale,
		VirtualNetworkGatewaySku_Tier_STATUS_HighPerformance,
		VirtualNetworkGatewaySku_Tier_STATUS_Standard,
		VirtualNetworkGatewaySku_Tier_STATUS_UltraPerformance,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw1,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw1AZ,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw2,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw2AZ,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw3,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw3AZ,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw4,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw4AZ,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw5,
		VirtualNetworkGatewaySku_Tier_STATUS_VpnGw5AZ))
}

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

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

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

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

	return ""
}

// Generator of VirtualNetworkGateway_STATUS instances for property testing - lazily instantiated by
// VirtualNetworkGateway_STATUSGenerator()
var virtualNetworkGateway_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualNetworkGateway_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualNetworkGateway_STATUS(generators)
	virtualNetworkGateway_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualNetworkGateway_STATUS{}), generators)

	return virtualNetworkGateway_STATUSGenerator
}

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

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

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

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

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

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

	return ""
}

// Generator of VngClientConnectionConfiguration_STATUS instances for property testing - lazily instantiated by
// VngClientConnectionConfiguration_STATUSGenerator()
var vngClientConnectionConfiguration_STATUSGenerator gopter.Gen

// VngClientConnectionConfiguration_STATUSGenerator returns a generator of VngClientConnectionConfiguration_STATUS instances for property testing.
func VngClientConnectionConfiguration_STATUSGenerator() gopter.Gen {
	if vngClientConnectionConfiguration_STATUSGenerator != nil {
		return vngClientConnectionConfiguration_STATUSGenerator
	}

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

	return vngClientConnectionConfiguration_STATUSGenerator
}

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

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

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

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

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

	return ""
}

// Generator of VpnClientConfiguration_STATUS instances for property testing - lazily instantiated by
// VpnClientConfiguration_STATUSGenerator()
var vpnClientConfiguration_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVpnClientConfiguration_STATUS(generators)
	AddRelatedPropertyGeneratorsForVpnClientConfiguration_STATUS(generators)
	vpnClientConfiguration_STATUSGenerator = gen.Struct(reflect.TypeOf(VpnClientConfiguration_STATUS{}), generators)

	return vpnClientConfiguration_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVpnClientConfiguration_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVpnClientConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["AadAudience"] = gen.PtrOf(gen.AlphaString())
	gens["AadIssuer"] = gen.PtrOf(gen.AlphaString())
	gens["AadTenant"] = gen.PtrOf(gen.AlphaString())
	gens["RadiusServerAddress"] = gen.PtrOf(gen.AlphaString())
	gens["RadiusServerSecret"] = gen.PtrOf(gen.AlphaString())
	gens["VpnAuthenticationTypes"] = gen.SliceOf(gen.OneConstOf(VpnClientConfiguration_VpnAuthenticationTypes_STATUS_AAD, VpnClientConfiguration_VpnAuthenticationTypes_STATUS_Certificate, VpnClientConfiguration_VpnAuthenticationTypes_STATUS_Radius))
	gens["VpnClientProtocols"] = gen.SliceOf(gen.OneConstOf(VpnClientConfiguration_VpnClientProtocols_STATUS_IkeV2, VpnClientConfiguration_VpnClientProtocols_STATUS_OpenVPN, VpnClientConfiguration_VpnClientProtocols_STATUS_SSTP))
}

// AddRelatedPropertyGeneratorsForVpnClientConfiguration_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForVpnClientConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["RadiusServers"] = gen.SliceOf(RadiusServer_STATUSGenerator())
	gens["VngClientConnectionConfigurations"] = gen.SliceOf(VngClientConnectionConfiguration_STATUSGenerator())
	gens["VpnClientAddressPool"] = gen.PtrOf(AddressSpace_STATUSGenerator())
	gens["VpnClientIpsecPolicies"] = gen.SliceOf(IpsecPolicy_STATUSGenerator())
	gens["VpnClientRevokedCertificates"] = gen.SliceOf(VpnClientRevokedCertificate_STATUSGenerator())
	gens["VpnClientRootCertificates"] = gen.SliceOf(VpnClientRootCertificate_STATUSGenerator())
}

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

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

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

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

	return ""
}

// Generator of VpnClientRevokedCertificatePropertiesFormat_STATUS instances for property testing - lazily instantiated
// by VpnClientRevokedCertificatePropertiesFormat_STATUSGenerator()
var vpnClientRevokedCertificatePropertiesFormat_STATUSGenerator gopter.Gen

// VpnClientRevokedCertificatePropertiesFormat_STATUSGenerator returns a generator of VpnClientRevokedCertificatePropertiesFormat_STATUS instances for property testing.
func VpnClientRevokedCertificatePropertiesFormat_STATUSGenerator() gopter.Gen {
	if vpnClientRevokedCertificatePropertiesFormat_STATUSGenerator != nil {
		return vpnClientRevokedCertificatePropertiesFormat_STATUSGenerator
	}

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

	return vpnClientRevokedCertificatePropertiesFormat_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVpnClientRevokedCertificatePropertiesFormat_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVpnClientRevokedCertificatePropertiesFormat_STATUS(gens map[string]gopter.Gen) {
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ProvisioningState_STATUS_Deleting,
		ProvisioningState_STATUS_Failed,
		ProvisioningState_STATUS_Succeeded,
		ProvisioningState_STATUS_Updating))
	gens["Thumbprint"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

	return ""
}

// Generator of VpnClientRevokedCertificate_STATUS instances for property testing - lazily instantiated by
// VpnClientRevokedCertificate_STATUSGenerator()
var vpnClientRevokedCertificate_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVpnClientRevokedCertificate_STATUS(generators)
	AddRelatedPropertyGeneratorsForVpnClientRevokedCertificate_STATUS(generators)
	vpnClientRevokedCertificate_STATUSGenerator = gen.Struct(reflect.TypeOf(VpnClientRevokedCertificate_STATUS{}), generators)

	return vpnClientRevokedCertificate_STATUSGenerator
}

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

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

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

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

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

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

	return ""
}

// Generator of VpnClientRootCertificatePropertiesFormat_STATUS instances for property testing - lazily instantiated by
// VpnClientRootCertificatePropertiesFormat_STATUSGenerator()
var vpnClientRootCertificatePropertiesFormat_STATUSGenerator gopter.Gen

// VpnClientRootCertificatePropertiesFormat_STATUSGenerator returns a generator of VpnClientRootCertificatePropertiesFormat_STATUS instances for property testing.
func VpnClientRootCertificatePropertiesFormat_STATUSGenerator() gopter.Gen {
	if vpnClientRootCertificatePropertiesFormat_STATUSGenerator != nil {
		return vpnClientRootCertificatePropertiesFormat_STATUSGenerator
	}

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

	return vpnClientRootCertificatePropertiesFormat_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVpnClientRootCertificatePropertiesFormat_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVpnClientRootCertificatePropertiesFormat_STATUS(gens map[string]gopter.Gen) {
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		ProvisioningState_STATUS_Deleting,
		ProvisioningState_STATUS_Failed,
		ProvisioningState_STATUS_Succeeded,
		ProvisioningState_STATUS_Updating))
	gens["PublicCertData"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

	return ""
}

// Generator of VpnClientRootCertificate_STATUS instances for property testing - lazily instantiated by
// VpnClientRootCertificate_STATUSGenerator()
var vpnClientRootCertificate_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVpnClientRootCertificate_STATUS(generators)
	AddRelatedPropertyGeneratorsForVpnClientRootCertificate_STATUS(generators)
	vpnClientRootCertificate_STATUSGenerator = gen.Struct(reflect.TypeOf(VpnClientRootCertificate_STATUS{}), generators)

	return vpnClientRootCertificate_STATUSGenerator
}

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

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

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

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

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

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

	return ""
}

// Generator of VpnNatRuleMapping_STATUS instances for property testing - lazily instantiated by
// VpnNatRuleMapping_STATUSGenerator()
var vpnNatRuleMapping_STATUSGenerator gopter.Gen

// VpnNatRuleMapping_STATUSGenerator returns a generator of VpnNatRuleMapping_STATUS instances for property testing.
func VpnNatRuleMapping_STATUSGenerator() gopter.Gen {
	if vpnNatRuleMapping_STATUSGenerator != nil {
		return vpnNatRuleMapping_STATUSGenerator
	}

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

	return vpnNatRuleMapping_STATUSGenerator
}

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