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

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_AKS_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 AKS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAKS, AKSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAKS(generators)
	AddRelatedPropertyGeneratorsForAKS(generators)
	aksGenerator = gen.Struct(reflect.TypeOf(AKS{}), generators)

	return aksGenerator
}

// AddIndependentPropertyGeneratorsForAKS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAKS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

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

func Test_AKS_Properties_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 AKS_Properties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAKS_Properties, AKS_PropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAKS_Properties(generators)
	AddRelatedPropertyGeneratorsForAKS_Properties(generators)
	aks_PropertiesGenerator = gen.Struct(reflect.TypeOf(AKS_Properties{}), generators)

	return aks_PropertiesGenerator
}

// AddIndependentPropertyGeneratorsForAKS_Properties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAKS_Properties(gens map[string]gopter.Gen) {
	gens["AgentCount"] = gen.PtrOf(gen.Int())
	gens["AgentVmSize"] = gen.PtrOf(gen.AlphaString())
	gens["ClusterFqdn"] = gen.PtrOf(gen.AlphaString())
	gens["ClusterPurpose"] = gen.PtrOf(gen.AlphaString())
	gens["LoadBalancerType"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForAKS_Properties is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAKS_Properties(gens map[string]gopter.Gen) {
	gens["AksNetworkingConfiguration"] = gen.PtrOf(AksNetworkingConfigurationGenerator())
	gens["SslConfiguration"] = gen.PtrOf(SslConfigurationGenerator())
}

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

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

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

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

	return ""
}

// Generator of AKS_Properties_STATUS instances for property testing - lazily instantiated by
// AKS_Properties_STATUSGenerator()
var aks_Properties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAKS_Properties_STATUS(generators)
	AddRelatedPropertyGeneratorsForAKS_Properties_STATUS(generators)
	aks_Properties_STATUSGenerator = gen.Struct(reflect.TypeOf(AKS_Properties_STATUS{}), generators)

	return aks_Properties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAKS_Properties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAKS_Properties_STATUS(gens map[string]gopter.Gen) {
	gens["AgentCount"] = gen.PtrOf(gen.Int())
	gens["AgentVmSize"] = gen.PtrOf(gen.AlphaString())
	gens["ClusterFqdn"] = gen.PtrOf(gen.AlphaString())
	gens["ClusterPurpose"] = gen.PtrOf(gen.AlphaString())
	gens["LoadBalancerSubnet"] = gen.PtrOf(gen.AlphaString())
	gens["LoadBalancerType"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForAKS_Properties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAKS_Properties_STATUS(gens map[string]gopter.Gen) {
	gens["AksNetworkingConfiguration"] = gen.PtrOf(AksNetworkingConfiguration_STATUSGenerator())
	gens["SslConfiguration"] = gen.PtrOf(SslConfiguration_STATUSGenerator())
	gens["SystemServices"] = gen.SliceOf(SystemService_STATUSGenerator())
}

func Test_AKS_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 AKS_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAKS_STATUS, AKS_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AKS_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 AKS_STATUS instances for property testing - lazily instantiated by AKS_STATUSGenerator()
var aks_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAKS_STATUS(generators)
	AddRelatedPropertyGeneratorsForAKS_STATUS(generators)
	aks_STATUSGenerator = gen.Struct(reflect.TypeOf(AKS_STATUS{}), generators)

	return aks_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAKS_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAKS_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForAKS_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAKS_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(AKS_Properties_STATUSGenerator())
	gens["ProvisioningErrors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
}

func Test_AksNetworkingConfiguration_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 AksNetworkingConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAksNetworkingConfiguration, AksNetworkingConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// AksNetworkingConfigurationGenerator returns a generator of AksNetworkingConfiguration instances for property testing.
func AksNetworkingConfigurationGenerator() gopter.Gen {
	if aksNetworkingConfigurationGenerator != nil {
		return aksNetworkingConfigurationGenerator
	}

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

	return aksNetworkingConfigurationGenerator
}

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

func Test_AksNetworkingConfiguration_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 AksNetworkingConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAksNetworkingConfiguration_STATUS, AksNetworkingConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AksNetworkingConfiguration_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 AksNetworkingConfiguration_STATUS instances for property testing - lazily instantiated by
// AksNetworkingConfiguration_STATUSGenerator()
var aksNetworkingConfiguration_STATUSGenerator gopter.Gen

// AksNetworkingConfiguration_STATUSGenerator returns a generator of AksNetworkingConfiguration_STATUS instances for property testing.
func AksNetworkingConfiguration_STATUSGenerator() gopter.Gen {
	if aksNetworkingConfiguration_STATUSGenerator != nil {
		return aksNetworkingConfiguration_STATUSGenerator
	}

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

	return aksNetworkingConfiguration_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAksNetworkingConfiguration_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAksNetworkingConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["DnsServiceIP"] = gen.PtrOf(gen.AlphaString())
	gens["DockerBridgeCidr"] = gen.PtrOf(gen.AlphaString())
	gens["ServiceCidr"] = gen.PtrOf(gen.AlphaString())
	gens["SubnetId"] = gen.PtrOf(gen.AlphaString())
}

func Test_AmlCompute_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 AmlCompute via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAmlCompute, AmlComputeGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAmlCompute(generators)
	AddRelatedPropertyGeneratorsForAmlCompute(generators)
	amlComputeGenerator = gen.Struct(reflect.TypeOf(AmlCompute{}), generators)

	return amlComputeGenerator
}

// AddIndependentPropertyGeneratorsForAmlCompute is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAmlCompute(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

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

func Test_AmlComputeProperties_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 AmlComputeProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAmlComputeProperties, AmlComputePropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAmlComputeProperties(generators)
	AddRelatedPropertyGeneratorsForAmlComputeProperties(generators)
	amlComputePropertiesGenerator = gen.Struct(reflect.TypeOf(AmlComputeProperties{}), generators)

	return amlComputePropertiesGenerator
}

// AddIndependentPropertyGeneratorsForAmlComputeProperties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAmlComputeProperties(gens map[string]gopter.Gen) {
	gens["EnableNodePublicIp"] = gen.PtrOf(gen.Bool())
	gens["IsolatedNetwork"] = gen.PtrOf(gen.Bool())
	gens["OsType"] = gen.PtrOf(gen.AlphaString())
	gens["RemoteLoginPortPublicAccess"] = gen.PtrOf(gen.AlphaString())
	gens["VmPriority"] = gen.PtrOf(gen.AlphaString())
	gens["VmSize"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForAmlComputeProperties is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAmlComputeProperties(gens map[string]gopter.Gen) {
	gens["ScaleSettings"] = gen.PtrOf(ScaleSettingsGenerator())
	gens["Subnet"] = gen.PtrOf(ResourceIdGenerator())
	gens["UserAccountCredentials"] = gen.PtrOf(UserAccountCredentialsGenerator())
	gens["VirtualMachineImage"] = gen.PtrOf(VirtualMachineImageGenerator())
}

func Test_AmlComputeProperties_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 AmlComputeProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAmlComputeProperties_STATUS, AmlComputeProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AmlComputeProperties_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 AmlComputeProperties_STATUS instances for property testing - lazily instantiated by
// AmlComputeProperties_STATUSGenerator()
var amlComputeProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAmlComputeProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForAmlComputeProperties_STATUS(generators)
	amlComputeProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(AmlComputeProperties_STATUS{}), generators)

	return amlComputeProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAmlComputeProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAmlComputeProperties_STATUS(gens map[string]gopter.Gen) {
	gens["AllocationState"] = gen.PtrOf(gen.AlphaString())
	gens["AllocationStateTransitionTime"] = gen.PtrOf(gen.AlphaString())
	gens["CurrentNodeCount"] = gen.PtrOf(gen.Int())
	gens["EnableNodePublicIp"] = gen.PtrOf(gen.Bool())
	gens["IsolatedNetwork"] = gen.PtrOf(gen.Bool())
	gens["OsType"] = gen.PtrOf(gen.AlphaString())
	gens["RemoteLoginPortPublicAccess"] = gen.PtrOf(gen.AlphaString())
	gens["TargetNodeCount"] = gen.PtrOf(gen.Int())
	gens["VmPriority"] = gen.PtrOf(gen.AlphaString())
	gens["VmSize"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForAmlComputeProperties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAmlComputeProperties_STATUS(gens map[string]gopter.Gen) {
	gens["Errors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
	gens["NodeStateCounts"] = gen.PtrOf(NodeStateCounts_STATUSGenerator())
	gens["ScaleSettings"] = gen.PtrOf(ScaleSettings_STATUSGenerator())
	gens["Subnet"] = gen.PtrOf(ResourceId_STATUSGenerator())
	gens["UserAccountCredentials"] = gen.PtrOf(UserAccountCredentials_STATUSGenerator())
	gens["VirtualMachineImage"] = gen.PtrOf(VirtualMachineImage_STATUSGenerator())
}

func Test_AmlCompute_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 AmlCompute_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAmlCompute_STATUS, AmlCompute_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AmlCompute_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 AmlCompute_STATUS instances for property testing - lazily instantiated by AmlCompute_STATUSGenerator()
var amlCompute_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForAmlCompute_STATUS(generators)
	AddRelatedPropertyGeneratorsForAmlCompute_STATUS(generators)
	amlCompute_STATUSGenerator = gen.Struct(reflect.TypeOf(AmlCompute_STATUS{}), generators)

	return amlCompute_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAmlCompute_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAmlCompute_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForAmlCompute_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForAmlCompute_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(AmlComputeProperties_STATUSGenerator())
	gens["ProvisioningErrors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
}

func Test_AssignedUser_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 AssignedUser via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAssignedUser, AssignedUserGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// AssignedUserGenerator returns a generator of AssignedUser instances for property testing.
func AssignedUserGenerator() gopter.Gen {
	if assignedUserGenerator != nil {
		return assignedUserGenerator
	}

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

	return assignedUserGenerator
}

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

func Test_AssignedUser_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 AssignedUser_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAssignedUser_STATUS, AssignedUser_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AssignedUser_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 AssignedUser_STATUS instances for property testing - lazily instantiated by
// AssignedUser_STATUSGenerator()
var assignedUser_STATUSGenerator gopter.Gen

// AssignedUser_STATUSGenerator returns a generator of AssignedUser_STATUS instances for property testing.
func AssignedUser_STATUSGenerator() gopter.Gen {
	if assignedUser_STATUSGenerator != nil {
		return assignedUser_STATUSGenerator
	}

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

	return assignedUser_STATUSGenerator
}

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

func Test_AutoPauseProperties_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 AutoPauseProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAutoPauseProperties, AutoPausePropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// AutoPausePropertiesGenerator returns a generator of AutoPauseProperties instances for property testing.
func AutoPausePropertiesGenerator() gopter.Gen {
	if autoPausePropertiesGenerator != nil {
		return autoPausePropertiesGenerator
	}

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

	return autoPausePropertiesGenerator
}

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

func Test_AutoPauseProperties_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 AutoPauseProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAutoPauseProperties_STATUS, AutoPauseProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AutoPauseProperties_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 AutoPauseProperties_STATUS instances for property testing - lazily instantiated by
// AutoPauseProperties_STATUSGenerator()
var autoPauseProperties_STATUSGenerator gopter.Gen

// AutoPauseProperties_STATUSGenerator returns a generator of AutoPauseProperties_STATUS instances for property testing.
func AutoPauseProperties_STATUSGenerator() gopter.Gen {
	if autoPauseProperties_STATUSGenerator != nil {
		return autoPauseProperties_STATUSGenerator
	}

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

	return autoPauseProperties_STATUSGenerator
}

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

func Test_AutoScaleProperties_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 AutoScaleProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAutoScaleProperties, AutoScalePropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// AutoScalePropertiesGenerator returns a generator of AutoScaleProperties instances for property testing.
func AutoScalePropertiesGenerator() gopter.Gen {
	if autoScalePropertiesGenerator != nil {
		return autoScalePropertiesGenerator
	}

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

	return autoScalePropertiesGenerator
}

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

func Test_AutoScaleProperties_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 AutoScaleProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAutoScaleProperties_STATUS, AutoScaleProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AutoScaleProperties_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 AutoScaleProperties_STATUS instances for property testing - lazily instantiated by
// AutoScaleProperties_STATUSGenerator()
var autoScaleProperties_STATUSGenerator gopter.Gen

// AutoScaleProperties_STATUSGenerator returns a generator of AutoScaleProperties_STATUS instances for property testing.
func AutoScaleProperties_STATUSGenerator() gopter.Gen {
	if autoScaleProperties_STATUSGenerator != nil {
		return autoScaleProperties_STATUSGenerator
	}

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

	return autoScaleProperties_STATUSGenerator
}

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

func Test_BindOptions_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 BindOptions via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBindOptions, BindOptionsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// BindOptionsGenerator returns a generator of BindOptions instances for property testing.
func BindOptionsGenerator() gopter.Gen {
	if bindOptionsGenerator != nil {
		return bindOptionsGenerator
	}

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

	return bindOptionsGenerator
}

// AddIndependentPropertyGeneratorsForBindOptions is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForBindOptions(gens map[string]gopter.Gen) {
	gens["CreateHostPath"] = gen.PtrOf(gen.Bool())
	gens["Propagation"] = gen.PtrOf(gen.AlphaString())
	gens["Selinux"] = gen.PtrOf(gen.AlphaString())
}

func Test_BindOptions_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 BindOptions_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBindOptions_STATUS, BindOptions_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual BindOptions_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 BindOptions_STATUS instances for property testing - lazily instantiated by BindOptions_STATUSGenerator()
var bindOptions_STATUSGenerator gopter.Gen

// BindOptions_STATUSGenerator returns a generator of BindOptions_STATUS instances for property testing.
func BindOptions_STATUSGenerator() gopter.Gen {
	if bindOptions_STATUSGenerator != nil {
		return bindOptions_STATUSGenerator
	}

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

	return bindOptions_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForBindOptions_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForBindOptions_STATUS(gens map[string]gopter.Gen) {
	gens["CreateHostPath"] = gen.PtrOf(gen.Bool())
	gens["Propagation"] = gen.PtrOf(gen.AlphaString())
	gens["Selinux"] = gen.PtrOf(gen.AlphaString())
}

func Test_Compute_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 Compute via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCompute, ComputeGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ComputeGenerator returns a generator of Compute instances for property testing.
func ComputeGenerator() gopter.Gen {
	if computeGenerator != nil {
		return computeGenerator
	}

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

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

	return computeGenerator
}

// AddRelatedPropertyGeneratorsForCompute is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForCompute(gens map[string]gopter.Gen) {
	gens["AKS"] = AKSGenerator().Map(func(it AKS) *AKS {
		return &it
	}) // generate one case for OneOf type
	gens["AmlCompute"] = AmlComputeGenerator().Map(func(it AmlCompute) *AmlCompute {
		return &it
	}) // generate one case for OneOf type
	gens["ComputeInstance"] = ComputeInstanceGenerator().Map(func(it ComputeInstance) *ComputeInstance {
		return &it
	}) // generate one case for OneOf type
	gens["DataFactory"] = DataFactoryGenerator().Map(func(it DataFactory) *DataFactory {
		return &it
	}) // generate one case for OneOf type
	gens["DataLakeAnalytics"] = DataLakeAnalyticsGenerator().Map(func(it DataLakeAnalytics) *DataLakeAnalytics {
		return &it
	}) // generate one case for OneOf type
	gens["Databricks"] = DatabricksGenerator().Map(func(it Databricks) *Databricks {
		return &it
	}) // generate one case for OneOf type
	gens["HDInsight"] = HDInsightGenerator().Map(func(it HDInsight) *HDInsight {
		return &it
	}) // generate one case for OneOf type
	gens["Kubernetes"] = KubernetesGenerator().Map(func(it Kubernetes) *Kubernetes {
		return &it
	}) // generate one case for OneOf type
	gens["SynapseSpark"] = SynapseSparkGenerator().Map(func(it SynapseSpark) *SynapseSpark {
		return &it
	}) // generate one case for OneOf type
	gens["VirtualMachine"] = VirtualMachineGenerator().Map(func(it VirtualMachine) *VirtualMachine {
		return &it
	}) // generate one case for OneOf type
}

func Test_ComputeInstance_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 ComputeInstance via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstance, ComputeInstanceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForComputeInstance(generators)
	AddRelatedPropertyGeneratorsForComputeInstance(generators)
	computeInstanceGenerator = gen.Struct(reflect.TypeOf(ComputeInstance{}), generators)

	return computeInstanceGenerator
}

// AddIndependentPropertyGeneratorsForComputeInstance is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeInstance(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

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

func Test_ComputeInstanceApplication_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 ComputeInstanceApplication_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceApplication_STATUS, ComputeInstanceApplication_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceApplication_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 ComputeInstanceApplication_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceApplication_STATUSGenerator()
var computeInstanceApplication_STATUSGenerator gopter.Gen

// ComputeInstanceApplication_STATUSGenerator returns a generator of ComputeInstanceApplication_STATUS instances for property testing.
func ComputeInstanceApplication_STATUSGenerator() gopter.Gen {
	if computeInstanceApplication_STATUSGenerator != nil {
		return computeInstanceApplication_STATUSGenerator
	}

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

	return computeInstanceApplication_STATUSGenerator
}

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

func Test_ComputeInstanceConnectivityEndpoints_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 ComputeInstanceConnectivityEndpoints_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceConnectivityEndpoints_STATUS, ComputeInstanceConnectivityEndpoints_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceConnectivityEndpoints_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 ComputeInstanceConnectivityEndpoints_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceConnectivityEndpoints_STATUSGenerator()
var computeInstanceConnectivityEndpoints_STATUSGenerator gopter.Gen

// ComputeInstanceConnectivityEndpoints_STATUSGenerator returns a generator of ComputeInstanceConnectivityEndpoints_STATUS instances for property testing.
func ComputeInstanceConnectivityEndpoints_STATUSGenerator() gopter.Gen {
	if computeInstanceConnectivityEndpoints_STATUSGenerator != nil {
		return computeInstanceConnectivityEndpoints_STATUSGenerator
	}

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

	return computeInstanceConnectivityEndpoints_STATUSGenerator
}

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

func Test_ComputeInstanceContainer_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 ComputeInstanceContainer_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceContainer_STATUS, ComputeInstanceContainer_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceContainer_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 ComputeInstanceContainer_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceContainer_STATUSGenerator()
var computeInstanceContainer_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForComputeInstanceContainer_STATUS(generators)
	AddRelatedPropertyGeneratorsForComputeInstanceContainer_STATUS(generators)
	computeInstanceContainer_STATUSGenerator = gen.Struct(reflect.TypeOf(ComputeInstanceContainer_STATUS{}), generators)

	return computeInstanceContainer_STATUSGenerator
}

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

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

func Test_ComputeInstanceCreatedBy_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 ComputeInstanceCreatedBy_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceCreatedBy_STATUS, ComputeInstanceCreatedBy_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceCreatedBy_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 ComputeInstanceCreatedBy_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceCreatedBy_STATUSGenerator()
var computeInstanceCreatedBy_STATUSGenerator gopter.Gen

// ComputeInstanceCreatedBy_STATUSGenerator returns a generator of ComputeInstanceCreatedBy_STATUS instances for property testing.
func ComputeInstanceCreatedBy_STATUSGenerator() gopter.Gen {
	if computeInstanceCreatedBy_STATUSGenerator != nil {
		return computeInstanceCreatedBy_STATUSGenerator
	}

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

	return computeInstanceCreatedBy_STATUSGenerator
}

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

func Test_ComputeInstanceDataDisk_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 ComputeInstanceDataDisk_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceDataDisk_STATUS, ComputeInstanceDataDisk_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceDataDisk_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 ComputeInstanceDataDisk_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceDataDisk_STATUSGenerator()
var computeInstanceDataDisk_STATUSGenerator gopter.Gen

// ComputeInstanceDataDisk_STATUSGenerator returns a generator of ComputeInstanceDataDisk_STATUS instances for property testing.
func ComputeInstanceDataDisk_STATUSGenerator() gopter.Gen {
	if computeInstanceDataDisk_STATUSGenerator != nil {
		return computeInstanceDataDisk_STATUSGenerator
	}

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

	return computeInstanceDataDisk_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForComputeInstanceDataDisk_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeInstanceDataDisk_STATUS(gens map[string]gopter.Gen) {
	gens["Caching"] = gen.PtrOf(gen.AlphaString())
	gens["DiskSizeGB"] = gen.PtrOf(gen.Int())
	gens["Lun"] = gen.PtrOf(gen.Int())
	gens["StorageAccountType"] = gen.PtrOf(gen.AlphaString())
}

func Test_ComputeInstanceDataMount_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 ComputeInstanceDataMount_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceDataMount_STATUS, ComputeInstanceDataMount_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceDataMount_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 ComputeInstanceDataMount_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceDataMount_STATUSGenerator()
var computeInstanceDataMount_STATUSGenerator gopter.Gen

// ComputeInstanceDataMount_STATUSGenerator returns a generator of ComputeInstanceDataMount_STATUS instances for property testing.
func ComputeInstanceDataMount_STATUSGenerator() gopter.Gen {
	if computeInstanceDataMount_STATUSGenerator != nil {
		return computeInstanceDataMount_STATUSGenerator
	}

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

	return computeInstanceDataMount_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForComputeInstanceDataMount_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeInstanceDataMount_STATUS(gens map[string]gopter.Gen) {
	gens["CreatedBy"] = gen.PtrOf(gen.AlphaString())
	gens["Error"] = gen.PtrOf(gen.AlphaString())
	gens["MountAction"] = gen.PtrOf(gen.AlphaString())
	gens["MountName"] = gen.PtrOf(gen.AlphaString())
	gens["MountPath"] = gen.PtrOf(gen.AlphaString())
	gens["MountState"] = gen.PtrOf(gen.AlphaString())
	gens["MountedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Source"] = gen.PtrOf(gen.AlphaString())
	gens["SourceType"] = gen.PtrOf(gen.AlphaString())
}

func Test_ComputeInstanceEnvironmentInfo_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 ComputeInstanceEnvironmentInfo_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceEnvironmentInfo_STATUS, ComputeInstanceEnvironmentInfo_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceEnvironmentInfo_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 ComputeInstanceEnvironmentInfo_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceEnvironmentInfo_STATUSGenerator()
var computeInstanceEnvironmentInfo_STATUSGenerator gopter.Gen

// ComputeInstanceEnvironmentInfo_STATUSGenerator returns a generator of ComputeInstanceEnvironmentInfo_STATUS instances for property testing.
func ComputeInstanceEnvironmentInfo_STATUSGenerator() gopter.Gen {
	if computeInstanceEnvironmentInfo_STATUSGenerator != nil {
		return computeInstanceEnvironmentInfo_STATUSGenerator
	}

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

	return computeInstanceEnvironmentInfo_STATUSGenerator
}

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

func Test_ComputeInstanceLastOperation_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 ComputeInstanceLastOperation_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceLastOperation_STATUS, ComputeInstanceLastOperation_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceLastOperation_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 ComputeInstanceLastOperation_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceLastOperation_STATUSGenerator()
var computeInstanceLastOperation_STATUSGenerator gopter.Gen

// ComputeInstanceLastOperation_STATUSGenerator returns a generator of ComputeInstanceLastOperation_STATUS instances for property testing.
func ComputeInstanceLastOperation_STATUSGenerator() gopter.Gen {
	if computeInstanceLastOperation_STATUSGenerator != nil {
		return computeInstanceLastOperation_STATUSGenerator
	}

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

	return computeInstanceLastOperation_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForComputeInstanceLastOperation_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeInstanceLastOperation_STATUS(gens map[string]gopter.Gen) {
	gens["OperationName"] = gen.PtrOf(gen.AlphaString())
	gens["OperationStatus"] = gen.PtrOf(gen.AlphaString())
	gens["OperationTime"] = gen.PtrOf(gen.AlphaString())
	gens["OperationTrigger"] = gen.PtrOf(gen.AlphaString())
}

func Test_ComputeInstanceProperties_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 ComputeInstanceProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceProperties, ComputeInstancePropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForComputeInstanceProperties(generators)
	AddRelatedPropertyGeneratorsForComputeInstanceProperties(generators)
	computeInstancePropertiesGenerator = gen.Struct(reflect.TypeOf(ComputeInstanceProperties{}), generators)

	return computeInstancePropertiesGenerator
}

// AddIndependentPropertyGeneratorsForComputeInstanceProperties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeInstanceProperties(gens map[string]gopter.Gen) {
	gens["ApplicationSharingPolicy"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeInstanceAuthorizationType"] = gen.PtrOf(gen.AlphaString())
	gens["EnableNodePublicIp"] = gen.PtrOf(gen.Bool())
	gens["VmSize"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForComputeInstanceProperties is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForComputeInstanceProperties(gens map[string]gopter.Gen) {
	gens["CustomServices"] = gen.SliceOf(CustomServiceGenerator())
	gens["PersonalComputeInstanceSettings"] = gen.PtrOf(PersonalComputeInstanceSettingsGenerator())
	gens["Schedules"] = gen.PtrOf(ComputeSchedulesGenerator())
	gens["SetupScripts"] = gen.PtrOf(SetupScriptsGenerator())
	gens["SshSettings"] = gen.PtrOf(ComputeInstanceSshSettingsGenerator())
	gens["Subnet"] = gen.PtrOf(ResourceIdGenerator())
}

func Test_ComputeInstanceProperties_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 ComputeInstanceProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceProperties_STATUS, ComputeInstanceProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceProperties_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 ComputeInstanceProperties_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceProperties_STATUSGenerator()
var computeInstanceProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForComputeInstanceProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForComputeInstanceProperties_STATUS(generators)
	computeInstanceProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(ComputeInstanceProperties_STATUS{}), generators)

	return computeInstanceProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForComputeInstanceProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeInstanceProperties_STATUS(gens map[string]gopter.Gen) {
	gens["ApplicationSharingPolicy"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeInstanceAuthorizationType"] = gen.PtrOf(gen.AlphaString())
	gens["EnableNodePublicIp"] = gen.PtrOf(gen.Bool())
	gens["State"] = gen.PtrOf(gen.AlphaString())
	gens["VmSize"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForComputeInstanceProperties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForComputeInstanceProperties_STATUS(gens map[string]gopter.Gen) {
	gens["Applications"] = gen.SliceOf(ComputeInstanceApplication_STATUSGenerator())
	gens["ConnectivityEndpoints"] = gen.PtrOf(ComputeInstanceConnectivityEndpoints_STATUSGenerator())
	gens["Containers"] = gen.SliceOf(ComputeInstanceContainer_STATUSGenerator())
	gens["CreatedBy"] = gen.PtrOf(ComputeInstanceCreatedBy_STATUSGenerator())
	gens["CustomServices"] = gen.SliceOf(CustomService_STATUSGenerator())
	gens["DataDisks"] = gen.SliceOf(ComputeInstanceDataDisk_STATUSGenerator())
	gens["DataMounts"] = gen.SliceOf(ComputeInstanceDataMount_STATUSGenerator())
	gens["Errors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
	gens["LastOperation"] = gen.PtrOf(ComputeInstanceLastOperation_STATUSGenerator())
	gens["OsImageMetadata"] = gen.PtrOf(ImageMetadata_STATUSGenerator())
	gens["PersonalComputeInstanceSettings"] = gen.PtrOf(PersonalComputeInstanceSettings_STATUSGenerator())
	gens["Schedules"] = gen.PtrOf(ComputeSchedules_STATUSGenerator())
	gens["SetupScripts"] = gen.PtrOf(SetupScripts_STATUSGenerator())
	gens["SshSettings"] = gen.PtrOf(ComputeInstanceSshSettings_STATUSGenerator())
	gens["Subnet"] = gen.PtrOf(ResourceId_STATUSGenerator())
	gens["Versions"] = gen.PtrOf(ComputeInstanceVersion_STATUSGenerator())
}

func Test_ComputeInstanceSshSettings_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 ComputeInstanceSshSettings via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceSshSettings, ComputeInstanceSshSettingsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ComputeInstanceSshSettingsGenerator returns a generator of ComputeInstanceSshSettings instances for property testing.
func ComputeInstanceSshSettingsGenerator() gopter.Gen {
	if computeInstanceSshSettingsGenerator != nil {
		return computeInstanceSshSettingsGenerator
	}

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

	return computeInstanceSshSettingsGenerator
}

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

func Test_ComputeInstanceSshSettings_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 ComputeInstanceSshSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceSshSettings_STATUS, ComputeInstanceSshSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceSshSettings_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 ComputeInstanceSshSettings_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceSshSettings_STATUSGenerator()
var computeInstanceSshSettings_STATUSGenerator gopter.Gen

// ComputeInstanceSshSettings_STATUSGenerator returns a generator of ComputeInstanceSshSettings_STATUS instances for property testing.
func ComputeInstanceSshSettings_STATUSGenerator() gopter.Gen {
	if computeInstanceSshSettings_STATUSGenerator != nil {
		return computeInstanceSshSettings_STATUSGenerator
	}

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

	return computeInstanceSshSettings_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForComputeInstanceSshSettings_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeInstanceSshSettings_STATUS(gens map[string]gopter.Gen) {
	gens["AdminPublicKey"] = gen.PtrOf(gen.AlphaString())
	gens["AdminUserName"] = gen.PtrOf(gen.AlphaString())
	gens["SshPort"] = gen.PtrOf(gen.Int())
	gens["SshPublicAccess"] = gen.PtrOf(gen.AlphaString())
}

func Test_ComputeInstanceVersion_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 ComputeInstanceVersion_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstanceVersion_STATUS, ComputeInstanceVersion_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstanceVersion_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 ComputeInstanceVersion_STATUS instances for property testing - lazily instantiated by
// ComputeInstanceVersion_STATUSGenerator()
var computeInstanceVersion_STATUSGenerator gopter.Gen

// ComputeInstanceVersion_STATUSGenerator returns a generator of ComputeInstanceVersion_STATUS instances for property testing.
func ComputeInstanceVersion_STATUSGenerator() gopter.Gen {
	if computeInstanceVersion_STATUSGenerator != nil {
		return computeInstanceVersion_STATUSGenerator
	}

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

	return computeInstanceVersion_STATUSGenerator
}

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

func Test_ComputeInstance_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 ComputeInstance_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeInstance_STATUS, ComputeInstance_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeInstance_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 ComputeInstance_STATUS instances for property testing - lazily instantiated by
// ComputeInstance_STATUSGenerator()
var computeInstance_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForComputeInstance_STATUS(generators)
	AddRelatedPropertyGeneratorsForComputeInstance_STATUS(generators)
	computeInstance_STATUSGenerator = gen.Struct(reflect.TypeOf(ComputeInstance_STATUS{}), generators)

	return computeInstance_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForComputeInstance_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeInstance_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForComputeInstance_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForComputeInstance_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(ComputeInstanceProperties_STATUSGenerator())
	gens["ProvisioningErrors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
}

func Test_ComputeRecurrenceSchedule_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 ComputeRecurrenceSchedule via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeRecurrenceSchedule, ComputeRecurrenceScheduleGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ComputeRecurrenceScheduleGenerator returns a generator of ComputeRecurrenceSchedule instances for property testing.
func ComputeRecurrenceScheduleGenerator() gopter.Gen {
	if computeRecurrenceScheduleGenerator != nil {
		return computeRecurrenceScheduleGenerator
	}

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

	return computeRecurrenceScheduleGenerator
}

// AddIndependentPropertyGeneratorsForComputeRecurrenceSchedule is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeRecurrenceSchedule(gens map[string]gopter.Gen) {
	gens["Hours"] = gen.SliceOf(gen.Int())
	gens["Minutes"] = gen.SliceOf(gen.Int())
	gens["MonthDays"] = gen.SliceOf(gen.Int())
	gens["WeekDays"] = gen.SliceOf(gen.AlphaString())
}

func Test_ComputeRecurrenceSchedule_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 ComputeRecurrenceSchedule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeRecurrenceSchedule_STATUS, ComputeRecurrenceSchedule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeRecurrenceSchedule_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 ComputeRecurrenceSchedule_STATUS instances for property testing - lazily instantiated by
// ComputeRecurrenceSchedule_STATUSGenerator()
var computeRecurrenceSchedule_STATUSGenerator gopter.Gen

// ComputeRecurrenceSchedule_STATUSGenerator returns a generator of ComputeRecurrenceSchedule_STATUS instances for property testing.
func ComputeRecurrenceSchedule_STATUSGenerator() gopter.Gen {
	if computeRecurrenceSchedule_STATUSGenerator != nil {
		return computeRecurrenceSchedule_STATUSGenerator
	}

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

	return computeRecurrenceSchedule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForComputeRecurrenceSchedule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForComputeRecurrenceSchedule_STATUS(gens map[string]gopter.Gen) {
	gens["Hours"] = gen.SliceOf(gen.Int())
	gens["Minutes"] = gen.SliceOf(gen.Int())
	gens["MonthDays"] = gen.SliceOf(gen.Int())
	gens["WeekDays"] = gen.SliceOf(gen.AlphaString())
}

func Test_ComputeSchedules_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 ComputeSchedules via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeSchedules, ComputeSchedulesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ComputeSchedulesGenerator returns a generator of ComputeSchedules instances for property testing.
func ComputeSchedulesGenerator() gopter.Gen {
	if computeSchedulesGenerator != nil {
		return computeSchedulesGenerator
	}

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

	return computeSchedulesGenerator
}

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

func Test_ComputeSchedules_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 ComputeSchedules_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeSchedules_STATUS, ComputeSchedules_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeSchedules_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 ComputeSchedules_STATUS instances for property testing - lazily instantiated by
// ComputeSchedules_STATUSGenerator()
var computeSchedules_STATUSGenerator gopter.Gen

// ComputeSchedules_STATUSGenerator returns a generator of ComputeSchedules_STATUS instances for property testing.
func ComputeSchedules_STATUSGenerator() gopter.Gen {
	if computeSchedules_STATUSGenerator != nil {
		return computeSchedules_STATUSGenerator
	}

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

	return computeSchedules_STATUSGenerator
}

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

func Test_ComputeStartStopSchedule_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 ComputeStartStopSchedule via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeStartStopSchedule, ComputeStartStopScheduleGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForComputeStartStopSchedule(generators)
	AddRelatedPropertyGeneratorsForComputeStartStopSchedule(generators)
	computeStartStopScheduleGenerator = gen.Struct(reflect.TypeOf(ComputeStartStopSchedule{}), generators)

	return computeStartStopScheduleGenerator
}

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

// AddRelatedPropertyGeneratorsForComputeStartStopSchedule is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForComputeStartStopSchedule(gens map[string]gopter.Gen) {
	gens["Cron"] = gen.PtrOf(CronGenerator())
	gens["Recurrence"] = gen.PtrOf(RecurrenceGenerator())
	gens["Schedule"] = gen.PtrOf(ScheduleBaseGenerator())
}

func Test_ComputeStartStopSchedule_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 ComputeStartStopSchedule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForComputeStartStopSchedule_STATUS, ComputeStartStopSchedule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ComputeStartStopSchedule_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 ComputeStartStopSchedule_STATUS instances for property testing - lazily instantiated by
// ComputeStartStopSchedule_STATUSGenerator()
var computeStartStopSchedule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForComputeStartStopSchedule_STATUS(generators)
	AddRelatedPropertyGeneratorsForComputeStartStopSchedule_STATUS(generators)
	computeStartStopSchedule_STATUSGenerator = gen.Struct(reflect.TypeOf(ComputeStartStopSchedule_STATUS{}), generators)

	return computeStartStopSchedule_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForComputeStartStopSchedule_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForComputeStartStopSchedule_STATUS(gens map[string]gopter.Gen) {
	gens["Cron"] = gen.PtrOf(Cron_STATUSGenerator())
	gens["Recurrence"] = gen.PtrOf(Recurrence_STATUSGenerator())
	gens["Schedule"] = gen.PtrOf(ScheduleBase_STATUSGenerator())
}

func Test_Compute_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 Compute_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCompute_STATUS, Compute_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Compute_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 Compute_STATUS instances for property testing - lazily instantiated by Compute_STATUSGenerator()
var compute_STATUSGenerator gopter.Gen

// Compute_STATUSGenerator returns a generator of Compute_STATUS instances for property testing.
func Compute_STATUSGenerator() gopter.Gen {
	if compute_STATUSGenerator != nil {
		return compute_STATUSGenerator
	}

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

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

	return compute_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForCompute_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForCompute_STATUS(gens map[string]gopter.Gen) {
	gens["AKS"] = AKS_STATUSGenerator().Map(func(it AKS_STATUS) *AKS_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["AmlCompute"] = AmlCompute_STATUSGenerator().Map(func(it AmlCompute_STATUS) *AmlCompute_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["ComputeInstance"] = ComputeInstance_STATUSGenerator().Map(func(it ComputeInstance_STATUS) *ComputeInstance_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["DataFactory"] = DataFactory_STATUSGenerator().Map(func(it DataFactory_STATUS) *DataFactory_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["DataLakeAnalytics"] = DataLakeAnalytics_STATUSGenerator().Map(func(it DataLakeAnalytics_STATUS) *DataLakeAnalytics_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["Databricks"] = Databricks_STATUSGenerator().Map(func(it Databricks_STATUS) *Databricks_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["HDInsight"] = HDInsight_STATUSGenerator().Map(func(it HDInsight_STATUS) *HDInsight_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["Kubernetes"] = Kubernetes_STATUSGenerator().Map(func(it Kubernetes_STATUS) *Kubernetes_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["SynapseSpark"] = SynapseSpark_STATUSGenerator().Map(func(it SynapseSpark_STATUS) *SynapseSpark_STATUS {
		return &it
	}) // generate one case for OneOf type
	gens["VirtualMachine"] = VirtualMachine_STATUSGenerator().Map(func(it VirtualMachine_STATUS) *VirtualMachine_STATUS {
		return &it
	}) // generate one case for OneOf type
}

func Test_Cron_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 Cron via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCron, CronGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// CronGenerator returns a generator of Cron instances for property testing.
func CronGenerator() gopter.Gen {
	if cronGenerator != nil {
		return cronGenerator
	}

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

	return cronGenerator
}

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

func Test_Cron_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 Cron_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCron_STATUS, Cron_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Cron_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 Cron_STATUS instances for property testing - lazily instantiated by Cron_STATUSGenerator()
var cron_STATUSGenerator gopter.Gen

// Cron_STATUSGenerator returns a generator of Cron_STATUS instances for property testing.
func Cron_STATUSGenerator() gopter.Gen {
	if cron_STATUSGenerator != nil {
		return cron_STATUSGenerator
	}

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

	return cron_STATUSGenerator
}

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

func Test_CustomService_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 CustomService via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCustomService, CustomServiceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForCustomService(generators)
	AddRelatedPropertyGeneratorsForCustomService(generators)
	customServiceGenerator = gen.Struct(reflect.TypeOf(CustomService{}), generators)

	return customServiceGenerator
}

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

// AddRelatedPropertyGeneratorsForCustomService is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForCustomService(gens map[string]gopter.Gen) {
	gens["Docker"] = gen.PtrOf(DockerGenerator())
	gens["Endpoints"] = gen.SliceOf(EndpointGenerator())
	gens["EnvironmentVariables"] = gen.MapOf(
		gen.AlphaString(),
		EnvironmentVariableGenerator())
	gens["Image"] = gen.PtrOf(ImageGenerator())
	gens["Volumes"] = gen.SliceOf(VolumeDefinitionGenerator())
}

func Test_CustomService_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 CustomService_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCustomService_STATUS, CustomService_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CustomService_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 CustomService_STATUS instances for property testing - lazily instantiated by
// CustomService_STATUSGenerator()
var customService_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForCustomService_STATUS(generators)
	AddRelatedPropertyGeneratorsForCustomService_STATUS(generators)
	customService_STATUSGenerator = gen.Struct(reflect.TypeOf(CustomService_STATUS{}), generators)

	return customService_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForCustomService_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForCustomService_STATUS(gens map[string]gopter.Gen) {
	gens["Docker"] = gen.PtrOf(Docker_STATUSGenerator())
	gens["Endpoints"] = gen.SliceOf(Endpoint_STATUSGenerator())
	gens["EnvironmentVariables"] = gen.MapOf(
		gen.AlphaString(),
		EnvironmentVariable_STATUSGenerator())
	gens["Image"] = gen.PtrOf(Image_STATUSGenerator())
	gens["Volumes"] = gen.SliceOf(VolumeDefinition_STATUSGenerator())
}

func Test_DataFactory_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 DataFactory via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataFactory, DataFactoryGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// DataFactoryGenerator returns a generator of DataFactory instances for property testing.
func DataFactoryGenerator() gopter.Gen {
	if dataFactoryGenerator != nil {
		return dataFactoryGenerator
	}

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

	return dataFactoryGenerator
}

// AddIndependentPropertyGeneratorsForDataFactory is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDataFactory(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

func Test_DataFactory_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 DataFactory_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataFactory_STATUS, DataFactory_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DataFactory_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 DataFactory_STATUS instances for property testing - lazily instantiated by DataFactory_STATUSGenerator()
var dataFactory_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForDataFactory_STATUS(generators)
	AddRelatedPropertyGeneratorsForDataFactory_STATUS(generators)
	dataFactory_STATUSGenerator = gen.Struct(reflect.TypeOf(DataFactory_STATUS{}), generators)

	return dataFactory_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForDataFactory_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDataFactory_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_DataLakeAnalytics_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 DataLakeAnalytics via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataLakeAnalytics, DataLakeAnalyticsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForDataLakeAnalytics(generators)
	AddRelatedPropertyGeneratorsForDataLakeAnalytics(generators)
	dataLakeAnalyticsGenerator = gen.Struct(reflect.TypeOf(DataLakeAnalytics{}), generators)

	return dataLakeAnalyticsGenerator
}

// AddIndependentPropertyGeneratorsForDataLakeAnalytics is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDataLakeAnalytics(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

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

func Test_DataLakeAnalytics_Properties_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 DataLakeAnalytics_Properties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataLakeAnalytics_Properties, DataLakeAnalytics_PropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// DataLakeAnalytics_PropertiesGenerator returns a generator of DataLakeAnalytics_Properties instances for property testing.
func DataLakeAnalytics_PropertiesGenerator() gopter.Gen {
	if dataLakeAnalytics_PropertiesGenerator != nil {
		return dataLakeAnalytics_PropertiesGenerator
	}

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

	return dataLakeAnalytics_PropertiesGenerator
}

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

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

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

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

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

	return ""
}

// Generator of DataLakeAnalytics_Properties_STATUS instances for property testing - lazily instantiated by
// DataLakeAnalytics_Properties_STATUSGenerator()
var dataLakeAnalytics_Properties_STATUSGenerator gopter.Gen

// DataLakeAnalytics_Properties_STATUSGenerator returns a generator of DataLakeAnalytics_Properties_STATUS instances for property testing.
func DataLakeAnalytics_Properties_STATUSGenerator() gopter.Gen {
	if dataLakeAnalytics_Properties_STATUSGenerator != nil {
		return dataLakeAnalytics_Properties_STATUSGenerator
	}

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

	return dataLakeAnalytics_Properties_STATUSGenerator
}

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

func Test_DataLakeAnalytics_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 DataLakeAnalytics_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataLakeAnalytics_STATUS, DataLakeAnalytics_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DataLakeAnalytics_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 DataLakeAnalytics_STATUS instances for property testing - lazily instantiated by
// DataLakeAnalytics_STATUSGenerator()
var dataLakeAnalytics_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForDataLakeAnalytics_STATUS(generators)
	AddRelatedPropertyGeneratorsForDataLakeAnalytics_STATUS(generators)
	dataLakeAnalytics_STATUSGenerator = gen.Struct(reflect.TypeOf(DataLakeAnalytics_STATUS{}), generators)

	return dataLakeAnalytics_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForDataLakeAnalytics_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDataLakeAnalytics_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForDataLakeAnalytics_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDataLakeAnalytics_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(DataLakeAnalytics_Properties_STATUSGenerator())
	gens["ProvisioningErrors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
}

func Test_Databricks_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 Databricks via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDatabricks, DatabricksGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForDatabricks(generators)
	AddRelatedPropertyGeneratorsForDatabricks(generators)
	databricksGenerator = gen.Struct(reflect.TypeOf(Databricks{}), generators)

	return databricksGenerator
}

// AddIndependentPropertyGeneratorsForDatabricks is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDatabricks(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

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

func Test_DatabricksProperties_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 DatabricksProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDatabricksProperties, DatabricksPropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// DatabricksPropertiesGenerator returns a generator of DatabricksProperties instances for property testing.
func DatabricksPropertiesGenerator() gopter.Gen {
	if databricksPropertiesGenerator != nil {
		return databricksPropertiesGenerator
	}

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

	return databricksPropertiesGenerator
}

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

func Test_DatabricksProperties_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 DatabricksProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDatabricksProperties_STATUS, DatabricksProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DatabricksProperties_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 DatabricksProperties_STATUS instances for property testing - lazily instantiated by
// DatabricksProperties_STATUSGenerator()
var databricksProperties_STATUSGenerator gopter.Gen

// DatabricksProperties_STATUSGenerator returns a generator of DatabricksProperties_STATUS instances for property testing.
func DatabricksProperties_STATUSGenerator() gopter.Gen {
	if databricksProperties_STATUSGenerator != nil {
		return databricksProperties_STATUSGenerator
	}

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

	return databricksProperties_STATUSGenerator
}

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

func Test_Databricks_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 Databricks_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDatabricks_STATUS, Databricks_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Databricks_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 Databricks_STATUS instances for property testing - lazily instantiated by Databricks_STATUSGenerator()
var databricks_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForDatabricks_STATUS(generators)
	AddRelatedPropertyGeneratorsForDatabricks_STATUS(generators)
	databricks_STATUSGenerator = gen.Struct(reflect.TypeOf(Databricks_STATUS{}), generators)

	return databricks_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForDatabricks_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDatabricks_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForDatabricks_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDatabricks_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(DatabricksProperties_STATUSGenerator())
	gens["ProvisioningErrors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
}

func Test_Docker_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 Docker via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDocker, DockerGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// DockerGenerator returns a generator of Docker instances for property testing.
func DockerGenerator() gopter.Gen {
	if dockerGenerator != nil {
		return dockerGenerator
	}

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

	return dockerGenerator
}

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

func Test_Docker_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 Docker_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDocker_STATUS, Docker_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Docker_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 Docker_STATUS instances for property testing - lazily instantiated by Docker_STATUSGenerator()
var docker_STATUSGenerator gopter.Gen

// Docker_STATUSGenerator returns a generator of Docker_STATUS instances for property testing.
func Docker_STATUSGenerator() gopter.Gen {
	if docker_STATUSGenerator != nil {
		return docker_STATUSGenerator
	}

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

	return docker_STATUSGenerator
}

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

func Test_Endpoint_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 Endpoint via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEndpoint, EndpointGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// EndpointGenerator returns a generator of Endpoint instances for property testing.
func EndpointGenerator() gopter.Gen {
	if endpointGenerator != nil {
		return endpointGenerator
	}

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

	return endpointGenerator
}

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

func Test_Endpoint_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 Endpoint_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEndpoint_STATUS, Endpoint_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Endpoint_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 Endpoint_STATUS instances for property testing - lazily instantiated by Endpoint_STATUSGenerator()
var endpoint_STATUSGenerator gopter.Gen

// Endpoint_STATUSGenerator returns a generator of Endpoint_STATUS instances for property testing.
func Endpoint_STATUSGenerator() gopter.Gen {
	if endpoint_STATUSGenerator != nil {
		return endpoint_STATUSGenerator
	}

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

	return endpoint_STATUSGenerator
}

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

func Test_EnvironmentVariable_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 EnvironmentVariable via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEnvironmentVariable, EnvironmentVariableGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// EnvironmentVariableGenerator returns a generator of EnvironmentVariable instances for property testing.
func EnvironmentVariableGenerator() gopter.Gen {
	if environmentVariableGenerator != nil {
		return environmentVariableGenerator
	}

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

	return environmentVariableGenerator
}

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

func Test_EnvironmentVariable_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 EnvironmentVariable_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEnvironmentVariable_STATUS, EnvironmentVariable_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EnvironmentVariable_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 EnvironmentVariable_STATUS instances for property testing - lazily instantiated by
// EnvironmentVariable_STATUSGenerator()
var environmentVariable_STATUSGenerator gopter.Gen

// EnvironmentVariable_STATUSGenerator returns a generator of EnvironmentVariable_STATUS instances for property testing.
func EnvironmentVariable_STATUSGenerator() gopter.Gen {
	if environmentVariable_STATUSGenerator != nil {
		return environmentVariable_STATUSGenerator
	}

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

	return environmentVariable_STATUSGenerator
}

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

func Test_ErrorAdditionalInfo_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 ErrorAdditionalInfo_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForErrorAdditionalInfo_STATUS, ErrorAdditionalInfo_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ErrorAdditionalInfo_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 ErrorAdditionalInfo_STATUS instances for property testing - lazily instantiated by
// ErrorAdditionalInfo_STATUSGenerator()
var errorAdditionalInfo_STATUSGenerator gopter.Gen

// ErrorAdditionalInfo_STATUSGenerator returns a generator of ErrorAdditionalInfo_STATUS instances for property testing.
func ErrorAdditionalInfo_STATUSGenerator() gopter.Gen {
	if errorAdditionalInfo_STATUSGenerator != nil {
		return errorAdditionalInfo_STATUSGenerator
	}

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

	return errorAdditionalInfo_STATUSGenerator
}

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

func Test_ErrorDetail_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 ErrorDetail_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForErrorDetail_STATUS, ErrorDetail_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ErrorDetail_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 ErrorDetail_STATUS instances for property testing - lazily instantiated by ErrorDetail_STATUSGenerator()
var errorDetail_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForErrorDetail_STATUS(generators)
	AddRelatedPropertyGeneratorsForErrorDetail_STATUS(generators)
	errorDetail_STATUSGenerator = gen.Struct(reflect.TypeOf(ErrorDetail_STATUS{}), generators)

	return errorDetail_STATUSGenerator
}

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

// AddRelatedPropertyGeneratorsForErrorDetail_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForErrorDetail_STATUS(gens map[string]gopter.Gen) {
	gens["AdditionalInfo"] = gen.SliceOf(ErrorAdditionalInfo_STATUSGenerator())
	gens["Details"] = gen.SliceOf(ErrorDetail_STATUS_UnrolledGenerator())
}

func Test_ErrorDetail_STATUS_Unrolled_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 ErrorDetail_STATUS_Unrolled via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForErrorDetail_STATUS_Unrolled, ErrorDetail_STATUS_UnrolledGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForErrorDetail_STATUS_Unrolled(generators)
	AddRelatedPropertyGeneratorsForErrorDetail_STATUS_Unrolled(generators)
	errorDetail_STATUS_UnrolledGenerator = gen.Struct(reflect.TypeOf(ErrorDetail_STATUS_Unrolled{}), generators)

	return errorDetail_STATUS_UnrolledGenerator
}

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

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

func Test_ErrorResponse_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 ErrorResponse_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForErrorResponse_STATUS, ErrorResponse_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ErrorResponse_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 ErrorResponse_STATUS instances for property testing - lazily instantiated by
// ErrorResponse_STATUSGenerator()
var errorResponse_STATUSGenerator gopter.Gen

// ErrorResponse_STATUSGenerator returns a generator of ErrorResponse_STATUS instances for property testing.
func ErrorResponse_STATUSGenerator() gopter.Gen {
	if errorResponse_STATUSGenerator != nil {
		return errorResponse_STATUSGenerator
	}

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

	return errorResponse_STATUSGenerator
}

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

func Test_HDInsight_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 HDInsight via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForHDInsight, HDInsightGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForHDInsight(generators)
	AddRelatedPropertyGeneratorsForHDInsight(generators)
	hdInsightGenerator = gen.Struct(reflect.TypeOf(HDInsight{}), generators)

	return hdInsightGenerator
}

// AddIndependentPropertyGeneratorsForHDInsight is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForHDInsight(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

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

func Test_HDInsightProperties_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 HDInsightProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForHDInsightProperties, HDInsightPropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForHDInsightProperties(generators)
	AddRelatedPropertyGeneratorsForHDInsightProperties(generators)
	hdInsightPropertiesGenerator = gen.Struct(reflect.TypeOf(HDInsightProperties{}), generators)

	return hdInsightPropertiesGenerator
}

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

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

func Test_HDInsightProperties_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 HDInsightProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForHDInsightProperties_STATUS, HDInsightProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual HDInsightProperties_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 HDInsightProperties_STATUS instances for property testing - lazily instantiated by
// HDInsightProperties_STATUSGenerator()
var hdInsightProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForHDInsightProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForHDInsightProperties_STATUS(generators)
	hdInsightProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(HDInsightProperties_STATUS{}), generators)

	return hdInsightProperties_STATUSGenerator
}

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

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

func Test_HDInsight_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 HDInsight_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForHDInsight_STATUS, HDInsight_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual HDInsight_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 HDInsight_STATUS instances for property testing - lazily instantiated by HDInsight_STATUSGenerator()
var hdInsight_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForHDInsight_STATUS(generators)
	AddRelatedPropertyGeneratorsForHDInsight_STATUS(generators)
	hdInsight_STATUSGenerator = gen.Struct(reflect.TypeOf(HDInsight_STATUS{}), generators)

	return hdInsight_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForHDInsight_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForHDInsight_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForHDInsight_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForHDInsight_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(HDInsightProperties_STATUSGenerator())
	gens["ProvisioningErrors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
}

func Test_Image_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 Image via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForImage, ImageGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ImageGenerator returns a generator of Image instances for property testing.
func ImageGenerator() gopter.Gen {
	if imageGenerator != nil {
		return imageGenerator
	}

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

	return imageGenerator
}

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

func Test_ImageMetadata_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 ImageMetadata_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForImageMetadata_STATUS, ImageMetadata_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ImageMetadata_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 ImageMetadata_STATUS instances for property testing - lazily instantiated by
// ImageMetadata_STATUSGenerator()
var imageMetadata_STATUSGenerator gopter.Gen

// ImageMetadata_STATUSGenerator returns a generator of ImageMetadata_STATUS instances for property testing.
func ImageMetadata_STATUSGenerator() gopter.Gen {
	if imageMetadata_STATUSGenerator != nil {
		return imageMetadata_STATUSGenerator
	}

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

	return imageMetadata_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForImageMetadata_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForImageMetadata_STATUS(gens map[string]gopter.Gen) {
	gens["CurrentImageVersion"] = gen.PtrOf(gen.AlphaString())
	gens["IsLatestOsImageVersion"] = gen.PtrOf(gen.Bool())
	gens["LatestImageVersion"] = gen.PtrOf(gen.AlphaString())
}

func Test_Image_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 Image_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForImage_STATUS, Image_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Image_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 Image_STATUS instances for property testing - lazily instantiated by Image_STATUSGenerator()
var image_STATUSGenerator gopter.Gen

// Image_STATUSGenerator returns a generator of Image_STATUS instances for property testing.
func Image_STATUSGenerator() gopter.Gen {
	if image_STATUSGenerator != nil {
		return image_STATUSGenerator
	}

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

	return image_STATUSGenerator
}

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

func Test_InstanceTypeSchema_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 InstanceTypeSchema via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForInstanceTypeSchema, InstanceTypeSchemaGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForInstanceTypeSchema(generators)
	AddRelatedPropertyGeneratorsForInstanceTypeSchema(generators)
	instanceTypeSchemaGenerator = gen.Struct(reflect.TypeOf(InstanceTypeSchema{}), generators)

	return instanceTypeSchemaGenerator
}

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

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

func Test_InstanceTypeSchema_Resources_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 InstanceTypeSchema_Resources via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForInstanceTypeSchema_Resources, InstanceTypeSchema_ResourcesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// InstanceTypeSchema_ResourcesGenerator returns a generator of InstanceTypeSchema_Resources instances for property testing.
func InstanceTypeSchema_ResourcesGenerator() gopter.Gen {
	if instanceTypeSchema_ResourcesGenerator != nil {
		return instanceTypeSchema_ResourcesGenerator
	}

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

	return instanceTypeSchema_ResourcesGenerator
}

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

func Test_InstanceTypeSchema_Resources_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 InstanceTypeSchema_Resources_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForInstanceTypeSchema_Resources_STATUS, InstanceTypeSchema_Resources_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual InstanceTypeSchema_Resources_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 InstanceTypeSchema_Resources_STATUS instances for property testing - lazily instantiated by
// InstanceTypeSchema_Resources_STATUSGenerator()
var instanceTypeSchema_Resources_STATUSGenerator gopter.Gen

// InstanceTypeSchema_Resources_STATUSGenerator returns a generator of InstanceTypeSchema_Resources_STATUS instances for property testing.
func InstanceTypeSchema_Resources_STATUSGenerator() gopter.Gen {
	if instanceTypeSchema_Resources_STATUSGenerator != nil {
		return instanceTypeSchema_Resources_STATUSGenerator
	}

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

	return instanceTypeSchema_Resources_STATUSGenerator
}

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

func Test_InstanceTypeSchema_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 InstanceTypeSchema_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForInstanceTypeSchema_STATUS, InstanceTypeSchema_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual InstanceTypeSchema_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 InstanceTypeSchema_STATUS instances for property testing - lazily instantiated by
// InstanceTypeSchema_STATUSGenerator()
var instanceTypeSchema_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForInstanceTypeSchema_STATUS(generators)
	AddRelatedPropertyGeneratorsForInstanceTypeSchema_STATUS(generators)
	instanceTypeSchema_STATUSGenerator = gen.Struct(reflect.TypeOf(InstanceTypeSchema_STATUS{}), generators)

	return instanceTypeSchema_STATUSGenerator
}

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

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

func Test_Kubernetes_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 Kubernetes via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForKubernetes, KubernetesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForKubernetes(generators)
	AddRelatedPropertyGeneratorsForKubernetes(generators)
	kubernetesGenerator = gen.Struct(reflect.TypeOf(Kubernetes{}), generators)

	return kubernetesGenerator
}

// AddIndependentPropertyGeneratorsForKubernetes is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForKubernetes(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

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

func Test_KubernetesProperties_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 KubernetesProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForKubernetesProperties, KubernetesPropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForKubernetesProperties(generators)
	AddRelatedPropertyGeneratorsForKubernetesProperties(generators)
	kubernetesPropertiesGenerator = gen.Struct(reflect.TypeOf(KubernetesProperties{}), generators)

	return kubernetesPropertiesGenerator
}

// AddIndependentPropertyGeneratorsForKubernetesProperties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForKubernetesProperties(gens map[string]gopter.Gen) {
	gens["DefaultInstanceType"] = gen.PtrOf(gen.AlphaString())
	gens["ExtensionInstanceReleaseTrain"] = gen.PtrOf(gen.AlphaString())
	gens["ExtensionPrincipalId"] = gen.PtrOf(gen.AlphaString())
	gens["Namespace"] = gen.PtrOf(gen.AlphaString())
	gens["VcName"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_KubernetesProperties_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 KubernetesProperties_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForKubernetesProperties_STATUS, KubernetesProperties_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual KubernetesProperties_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 KubernetesProperties_STATUS instances for property testing - lazily instantiated by
// KubernetesProperties_STATUSGenerator()
var kubernetesProperties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForKubernetesProperties_STATUS(generators)
	AddRelatedPropertyGeneratorsForKubernetesProperties_STATUS(generators)
	kubernetesProperties_STATUSGenerator = gen.Struct(reflect.TypeOf(KubernetesProperties_STATUS{}), generators)

	return kubernetesProperties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForKubernetesProperties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForKubernetesProperties_STATUS(gens map[string]gopter.Gen) {
	gens["DefaultInstanceType"] = gen.PtrOf(gen.AlphaString())
	gens["ExtensionInstanceReleaseTrain"] = gen.PtrOf(gen.AlphaString())
	gens["ExtensionPrincipalId"] = gen.PtrOf(gen.AlphaString())
	gens["Namespace"] = gen.PtrOf(gen.AlphaString())
	gens["VcName"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_Kubernetes_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 Kubernetes_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForKubernetes_STATUS, Kubernetes_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Kubernetes_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 Kubernetes_STATUS instances for property testing - lazily instantiated by Kubernetes_STATUSGenerator()
var kubernetes_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForKubernetes_STATUS(generators)
	AddRelatedPropertyGeneratorsForKubernetes_STATUS(generators)
	kubernetes_STATUSGenerator = gen.Struct(reflect.TypeOf(Kubernetes_STATUS{}), generators)

	return kubernetes_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForKubernetes_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForKubernetes_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForKubernetes_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForKubernetes_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(KubernetesProperties_STATUSGenerator())
	gens["ProvisioningErrors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
}

func Test_NodeStateCounts_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 NodeStateCounts_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNodeStateCounts_STATUS, NodeStateCounts_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NodeStateCounts_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 NodeStateCounts_STATUS instances for property testing - lazily instantiated by
// NodeStateCounts_STATUSGenerator()
var nodeStateCounts_STATUSGenerator gopter.Gen

// NodeStateCounts_STATUSGenerator returns a generator of NodeStateCounts_STATUS instances for property testing.
func NodeStateCounts_STATUSGenerator() gopter.Gen {
	if nodeStateCounts_STATUSGenerator != nil {
		return nodeStateCounts_STATUSGenerator
	}

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

	return nodeStateCounts_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForNodeStateCounts_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForNodeStateCounts_STATUS(gens map[string]gopter.Gen) {
	gens["IdleNodeCount"] = gen.PtrOf(gen.Int())
	gens["LeavingNodeCount"] = gen.PtrOf(gen.Int())
	gens["PreemptedNodeCount"] = gen.PtrOf(gen.Int())
	gens["PreparingNodeCount"] = gen.PtrOf(gen.Int())
	gens["RunningNodeCount"] = gen.PtrOf(gen.Int())
	gens["UnusableNodeCount"] = gen.PtrOf(gen.Int())
}

func Test_PersonalComputeInstanceSettings_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 PersonalComputeInstanceSettings via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPersonalComputeInstanceSettings, PersonalComputeInstanceSettingsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// PersonalComputeInstanceSettingsGenerator returns a generator of PersonalComputeInstanceSettings instances for property testing.
func PersonalComputeInstanceSettingsGenerator() gopter.Gen {
	if personalComputeInstanceSettingsGenerator != nil {
		return personalComputeInstanceSettingsGenerator
	}

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

	return personalComputeInstanceSettingsGenerator
}

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

func Test_PersonalComputeInstanceSettings_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 PersonalComputeInstanceSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPersonalComputeInstanceSettings_STATUS, PersonalComputeInstanceSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PersonalComputeInstanceSettings_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 PersonalComputeInstanceSettings_STATUS instances for property testing - lazily instantiated by
// PersonalComputeInstanceSettings_STATUSGenerator()
var personalComputeInstanceSettings_STATUSGenerator gopter.Gen

// PersonalComputeInstanceSettings_STATUSGenerator returns a generator of PersonalComputeInstanceSettings_STATUS instances for property testing.
func PersonalComputeInstanceSettings_STATUSGenerator() gopter.Gen {
	if personalComputeInstanceSettings_STATUSGenerator != nil {
		return personalComputeInstanceSettings_STATUSGenerator
	}

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

	return personalComputeInstanceSettings_STATUSGenerator
}

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

func Test_Recurrence_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 Recurrence via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRecurrence, RecurrenceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForRecurrence(generators)
	AddRelatedPropertyGeneratorsForRecurrence(generators)
	recurrenceGenerator = gen.Struct(reflect.TypeOf(Recurrence{}), generators)

	return recurrenceGenerator
}

// AddIndependentPropertyGeneratorsForRecurrence is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForRecurrence(gens map[string]gopter.Gen) {
	gens["Frequency"] = gen.PtrOf(gen.AlphaString())
	gens["Interval"] = gen.PtrOf(gen.Int())
	gens["StartTime"] = gen.PtrOf(gen.AlphaString())
	gens["TimeZone"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_Recurrence_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 Recurrence_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForRecurrence_STATUS, Recurrence_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual Recurrence_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 Recurrence_STATUS instances for property testing - lazily instantiated by Recurrence_STATUSGenerator()
var recurrence_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForRecurrence_STATUS(generators)
	AddRelatedPropertyGeneratorsForRecurrence_STATUS(generators)
	recurrence_STATUSGenerator = gen.Struct(reflect.TypeOf(Recurrence_STATUS{}), generators)

	return recurrence_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForRecurrence_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForRecurrence_STATUS(gens map[string]gopter.Gen) {
	gens["Frequency"] = gen.PtrOf(gen.AlphaString())
	gens["Interval"] = gen.PtrOf(gen.Int())
	gens["StartTime"] = gen.PtrOf(gen.AlphaString())
	gens["TimeZone"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_ResourceId_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 ResourceId via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForResourceId, ResourceIdGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ResourceIdGenerator returns a generator of ResourceId instances for property testing.
func ResourceIdGenerator() gopter.Gen {
	if resourceIdGenerator != nil {
		return resourceIdGenerator
	}

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

	return resourceIdGenerator
}

func Test_ResourceId_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 ResourceId_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForResourceId_STATUS, ResourceId_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ResourceId_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 ResourceId_STATUS instances for property testing - lazily instantiated by ResourceId_STATUSGenerator()
var resourceId_STATUSGenerator gopter.Gen

// ResourceId_STATUSGenerator returns a generator of ResourceId_STATUS instances for property testing.
func ResourceId_STATUSGenerator() gopter.Gen {
	if resourceId_STATUSGenerator != nil {
		return resourceId_STATUSGenerator
	}

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

	return resourceId_STATUSGenerator
}

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

func Test_ScaleSettings_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 ScaleSettings via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScaleSettings, ScaleSettingsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ScaleSettingsGenerator returns a generator of ScaleSettings instances for property testing.
func ScaleSettingsGenerator() gopter.Gen {
	if scaleSettingsGenerator != nil {
		return scaleSettingsGenerator
	}

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

	return scaleSettingsGenerator
}

// AddIndependentPropertyGeneratorsForScaleSettings is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForScaleSettings(gens map[string]gopter.Gen) {
	gens["MaxNodeCount"] = gen.PtrOf(gen.Int())
	gens["MinNodeCount"] = gen.PtrOf(gen.Int())
	gens["NodeIdleTimeBeforeScaleDown"] = gen.PtrOf(gen.AlphaString())
}

func Test_ScaleSettings_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 ScaleSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScaleSettings_STATUS, ScaleSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ScaleSettings_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 ScaleSettings_STATUS instances for property testing - lazily instantiated by
// ScaleSettings_STATUSGenerator()
var scaleSettings_STATUSGenerator gopter.Gen

// ScaleSettings_STATUSGenerator returns a generator of ScaleSettings_STATUS instances for property testing.
func ScaleSettings_STATUSGenerator() gopter.Gen {
	if scaleSettings_STATUSGenerator != nil {
		return scaleSettings_STATUSGenerator
	}

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

	return scaleSettings_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForScaleSettings_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForScaleSettings_STATUS(gens map[string]gopter.Gen) {
	gens["MaxNodeCount"] = gen.PtrOf(gen.Int())
	gens["MinNodeCount"] = gen.PtrOf(gen.Int())
	gens["NodeIdleTimeBeforeScaleDown"] = gen.PtrOf(gen.AlphaString())
}

func Test_ScheduleBase_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 ScheduleBase via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScheduleBase, ScheduleBaseGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ScheduleBaseGenerator returns a generator of ScheduleBase instances for property testing.
func ScheduleBaseGenerator() gopter.Gen {
	if scheduleBaseGenerator != nil {
		return scheduleBaseGenerator
	}

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

	return scheduleBaseGenerator
}

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

func Test_ScheduleBase_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 ScheduleBase_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScheduleBase_STATUS, ScheduleBase_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ScheduleBase_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 ScheduleBase_STATUS instances for property testing - lazily instantiated by
// ScheduleBase_STATUSGenerator()
var scheduleBase_STATUSGenerator gopter.Gen

// ScheduleBase_STATUSGenerator returns a generator of ScheduleBase_STATUS instances for property testing.
func ScheduleBase_STATUSGenerator() gopter.Gen {
	if scheduleBase_STATUSGenerator != nil {
		return scheduleBase_STATUSGenerator
	}

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

	return scheduleBase_STATUSGenerator
}

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

func Test_ScriptReference_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 ScriptReference via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScriptReference, ScriptReferenceGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ScriptReferenceGenerator returns a generator of ScriptReference instances for property testing.
func ScriptReferenceGenerator() gopter.Gen {
	if scriptReferenceGenerator != nil {
		return scriptReferenceGenerator
	}

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

	return scriptReferenceGenerator
}

// AddIndependentPropertyGeneratorsForScriptReference is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForScriptReference(gens map[string]gopter.Gen) {
	gens["ScriptArguments"] = gen.PtrOf(gen.AlphaString())
	gens["ScriptData"] = gen.PtrOf(gen.AlphaString())
	gens["ScriptSource"] = gen.PtrOf(gen.AlphaString())
	gens["Timeout"] = gen.PtrOf(gen.AlphaString())
}

func Test_ScriptReference_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 ScriptReference_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScriptReference_STATUS, ScriptReference_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ScriptReference_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 ScriptReference_STATUS instances for property testing - lazily instantiated by
// ScriptReference_STATUSGenerator()
var scriptReference_STATUSGenerator gopter.Gen

// ScriptReference_STATUSGenerator returns a generator of ScriptReference_STATUS instances for property testing.
func ScriptReference_STATUSGenerator() gopter.Gen {
	if scriptReference_STATUSGenerator != nil {
		return scriptReference_STATUSGenerator
	}

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

	return scriptReference_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForScriptReference_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForScriptReference_STATUS(gens map[string]gopter.Gen) {
	gens["ScriptArguments"] = gen.PtrOf(gen.AlphaString())
	gens["ScriptData"] = gen.PtrOf(gen.AlphaString())
	gens["ScriptSource"] = gen.PtrOf(gen.AlphaString())
	gens["Timeout"] = gen.PtrOf(gen.AlphaString())
}

func Test_ScriptsToExecute_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 ScriptsToExecute via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScriptsToExecute, ScriptsToExecuteGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ScriptsToExecuteGenerator returns a generator of ScriptsToExecute instances for property testing.
func ScriptsToExecuteGenerator() gopter.Gen {
	if scriptsToExecuteGenerator != nil {
		return scriptsToExecuteGenerator
	}

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

	return scriptsToExecuteGenerator
}

// AddRelatedPropertyGeneratorsForScriptsToExecute is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForScriptsToExecute(gens map[string]gopter.Gen) {
	gens["CreationScript"] = gen.PtrOf(ScriptReferenceGenerator())
	gens["StartupScript"] = gen.PtrOf(ScriptReferenceGenerator())
}

func Test_ScriptsToExecute_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 ScriptsToExecute_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForScriptsToExecute_STATUS, ScriptsToExecute_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ScriptsToExecute_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 ScriptsToExecute_STATUS instances for property testing - lazily instantiated by
// ScriptsToExecute_STATUSGenerator()
var scriptsToExecute_STATUSGenerator gopter.Gen

// ScriptsToExecute_STATUSGenerator returns a generator of ScriptsToExecute_STATUS instances for property testing.
func ScriptsToExecute_STATUSGenerator() gopter.Gen {
	if scriptsToExecute_STATUSGenerator != nil {
		return scriptsToExecute_STATUSGenerator
	}

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

	return scriptsToExecute_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForScriptsToExecute_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForScriptsToExecute_STATUS(gens map[string]gopter.Gen) {
	gens["CreationScript"] = gen.PtrOf(ScriptReference_STATUSGenerator())
	gens["StartupScript"] = gen.PtrOf(ScriptReference_STATUSGenerator())
}

func Test_SetupScripts_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 SetupScripts via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSetupScripts, SetupScriptsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// SetupScriptsGenerator returns a generator of SetupScripts instances for property testing.
func SetupScriptsGenerator() gopter.Gen {
	if setupScriptsGenerator != nil {
		return setupScriptsGenerator
	}

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

	return setupScriptsGenerator
}

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

func Test_SetupScripts_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 SetupScripts_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSetupScripts_STATUS, SetupScripts_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SetupScripts_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 SetupScripts_STATUS instances for property testing - lazily instantiated by
// SetupScripts_STATUSGenerator()
var setupScripts_STATUSGenerator gopter.Gen

// SetupScripts_STATUSGenerator returns a generator of SetupScripts_STATUS instances for property testing.
func SetupScripts_STATUSGenerator() gopter.Gen {
	if setupScripts_STATUSGenerator != nil {
		return setupScripts_STATUSGenerator
	}

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

	return setupScripts_STATUSGenerator
}

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

func Test_SslConfiguration_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 SslConfiguration via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSslConfiguration, SslConfigurationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// SslConfigurationGenerator returns a generator of SslConfiguration instances for property testing.
func SslConfigurationGenerator() gopter.Gen {
	if sslConfigurationGenerator != nil {
		return sslConfigurationGenerator
	}

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

	return sslConfigurationGenerator
}

// AddIndependentPropertyGeneratorsForSslConfiguration is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSslConfiguration(gens map[string]gopter.Gen) {
	gens["Cname"] = gen.PtrOf(gen.AlphaString())
	gens["LeafDomainLabel"] = gen.PtrOf(gen.AlphaString())
	gens["OverwriteExistingDomain"] = gen.PtrOf(gen.Bool())
	gens["Status"] = gen.PtrOf(gen.AlphaString())
}

func Test_SslConfiguration_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 SslConfiguration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSslConfiguration_STATUS, SslConfiguration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SslConfiguration_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 SslConfiguration_STATUS instances for property testing - lazily instantiated by
// SslConfiguration_STATUSGenerator()
var sslConfiguration_STATUSGenerator gopter.Gen

// SslConfiguration_STATUSGenerator returns a generator of SslConfiguration_STATUS instances for property testing.
func SslConfiguration_STATUSGenerator() gopter.Gen {
	if sslConfiguration_STATUSGenerator != nil {
		return sslConfiguration_STATUSGenerator
	}

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

	return sslConfiguration_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSslConfiguration_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSslConfiguration_STATUS(gens map[string]gopter.Gen) {
	gens["Cname"] = gen.PtrOf(gen.AlphaString())
	gens["LeafDomainLabel"] = gen.PtrOf(gen.AlphaString())
	gens["OverwriteExistingDomain"] = gen.PtrOf(gen.Bool())
	gens["Status"] = gen.PtrOf(gen.AlphaString())
}

func Test_SynapseSpark_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 SynapseSpark via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSynapseSpark, SynapseSparkGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSynapseSpark(generators)
	AddRelatedPropertyGeneratorsForSynapseSpark(generators)
	synapseSparkGenerator = gen.Struct(reflect.TypeOf(SynapseSpark{}), generators)

	return synapseSparkGenerator
}

// AddIndependentPropertyGeneratorsForSynapseSpark is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSynapseSpark(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

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

func Test_SynapseSpark_Properties_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 SynapseSpark_Properties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSynapseSpark_Properties, SynapseSpark_PropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSynapseSpark_Properties(generators)
	AddRelatedPropertyGeneratorsForSynapseSpark_Properties(generators)
	synapseSpark_PropertiesGenerator = gen.Struct(reflect.TypeOf(SynapseSpark_Properties{}), generators)

	return synapseSpark_PropertiesGenerator
}

// AddIndependentPropertyGeneratorsForSynapseSpark_Properties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSynapseSpark_Properties(gens map[string]gopter.Gen) {
	gens["NodeCount"] = gen.PtrOf(gen.Int())
	gens["NodeSize"] = gen.PtrOf(gen.AlphaString())
	gens["NodeSizeFamily"] = gen.PtrOf(gen.AlphaString())
	gens["PoolName"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceGroup"] = gen.PtrOf(gen.AlphaString())
	gens["SparkVersion"] = gen.PtrOf(gen.AlphaString())
	gens["SubscriptionId"] = gen.PtrOf(gen.AlphaString())
	gens["WorkspaceName"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForSynapseSpark_Properties is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForSynapseSpark_Properties(gens map[string]gopter.Gen) {
	gens["AutoPauseProperties"] = gen.PtrOf(AutoPausePropertiesGenerator())
	gens["AutoScaleProperties"] = gen.PtrOf(AutoScalePropertiesGenerator())
}

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

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

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

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

	return ""
}

// Generator of SynapseSpark_Properties_STATUS instances for property testing - lazily instantiated by
// SynapseSpark_Properties_STATUSGenerator()
var synapseSpark_Properties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSynapseSpark_Properties_STATUS(generators)
	AddRelatedPropertyGeneratorsForSynapseSpark_Properties_STATUS(generators)
	synapseSpark_Properties_STATUSGenerator = gen.Struct(reflect.TypeOf(SynapseSpark_Properties_STATUS{}), generators)

	return synapseSpark_Properties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSynapseSpark_Properties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSynapseSpark_Properties_STATUS(gens map[string]gopter.Gen) {
	gens["NodeCount"] = gen.PtrOf(gen.Int())
	gens["NodeSize"] = gen.PtrOf(gen.AlphaString())
	gens["NodeSizeFamily"] = gen.PtrOf(gen.AlphaString())
	gens["PoolName"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceGroup"] = gen.PtrOf(gen.AlphaString())
	gens["SparkVersion"] = gen.PtrOf(gen.AlphaString())
	gens["SubscriptionId"] = gen.PtrOf(gen.AlphaString())
	gens["WorkspaceName"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForSynapseSpark_Properties_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForSynapseSpark_Properties_STATUS(gens map[string]gopter.Gen) {
	gens["AutoPauseProperties"] = gen.PtrOf(AutoPauseProperties_STATUSGenerator())
	gens["AutoScaleProperties"] = gen.PtrOf(AutoScaleProperties_STATUSGenerator())
}

func Test_SynapseSpark_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 SynapseSpark_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSynapseSpark_STATUS, SynapseSpark_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SynapseSpark_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 SynapseSpark_STATUS instances for property testing - lazily instantiated by
// SynapseSpark_STATUSGenerator()
var synapseSpark_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForSynapseSpark_STATUS(generators)
	AddRelatedPropertyGeneratorsForSynapseSpark_STATUS(generators)
	synapseSpark_STATUSGenerator = gen.Struct(reflect.TypeOf(SynapseSpark_STATUS{}), generators)

	return synapseSpark_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSynapseSpark_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSynapseSpark_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForSynapseSpark_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForSynapseSpark_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(SynapseSpark_Properties_STATUSGenerator())
	gens["ProvisioningErrors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
}

func Test_SystemService_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 SystemService_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSystemService_STATUS, SystemService_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SystemService_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 SystemService_STATUS instances for property testing - lazily instantiated by
// SystemService_STATUSGenerator()
var systemService_STATUSGenerator gopter.Gen

// SystemService_STATUSGenerator returns a generator of SystemService_STATUS instances for property testing.
func SystemService_STATUSGenerator() gopter.Gen {
	if systemService_STATUSGenerator != nil {
		return systemService_STATUSGenerator
	}

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

	return systemService_STATUSGenerator
}

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

func Test_TmpfsOptions_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 TmpfsOptions via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTmpfsOptions, TmpfsOptionsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// TmpfsOptionsGenerator returns a generator of TmpfsOptions instances for property testing.
func TmpfsOptionsGenerator() gopter.Gen {
	if tmpfsOptionsGenerator != nil {
		return tmpfsOptionsGenerator
	}

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

	return tmpfsOptionsGenerator
}

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

func Test_TmpfsOptions_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 TmpfsOptions_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTmpfsOptions_STATUS, TmpfsOptions_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual TmpfsOptions_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 TmpfsOptions_STATUS instances for property testing - lazily instantiated by
// TmpfsOptions_STATUSGenerator()
var tmpfsOptions_STATUSGenerator gopter.Gen

// TmpfsOptions_STATUSGenerator returns a generator of TmpfsOptions_STATUS instances for property testing.
func TmpfsOptions_STATUSGenerator() gopter.Gen {
	if tmpfsOptions_STATUSGenerator != nil {
		return tmpfsOptions_STATUSGenerator
	}

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

	return tmpfsOptions_STATUSGenerator
}

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

func Test_UserAccountCredentials_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 UserAccountCredentials via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUserAccountCredentials, UserAccountCredentialsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// UserAccountCredentialsGenerator returns a generator of UserAccountCredentials instances for property testing.
func UserAccountCredentialsGenerator() gopter.Gen {
	if userAccountCredentialsGenerator != nil {
		return userAccountCredentialsGenerator
	}

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

	return userAccountCredentialsGenerator
}

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

func Test_UserAccountCredentials_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 UserAccountCredentials_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForUserAccountCredentials_STATUS, UserAccountCredentials_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual UserAccountCredentials_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 UserAccountCredentials_STATUS instances for property testing - lazily instantiated by
// UserAccountCredentials_STATUSGenerator()
var userAccountCredentials_STATUSGenerator gopter.Gen

// UserAccountCredentials_STATUSGenerator returns a generator of UserAccountCredentials_STATUS instances for property testing.
func UserAccountCredentials_STATUSGenerator() gopter.Gen {
	if userAccountCredentials_STATUSGenerator != nil {
		return userAccountCredentials_STATUSGenerator
	}

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

	return userAccountCredentials_STATUSGenerator
}

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

func Test_VirtualMachine_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 VirtualMachine via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVirtualMachine, VirtualMachineGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualMachine(generators)
	AddRelatedPropertyGeneratorsForVirtualMachine(generators)
	virtualMachineGenerator = gen.Struct(reflect.TypeOf(VirtualMachine{}), generators)

	return virtualMachineGenerator
}

// AddIndependentPropertyGeneratorsForVirtualMachine is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualMachine(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
}

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

func Test_VirtualMachineImage_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 VirtualMachineImage via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVirtualMachineImage, VirtualMachineImageGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// VirtualMachineImageGenerator returns a generator of VirtualMachineImage instances for property testing.
func VirtualMachineImageGenerator() gopter.Gen {
	if virtualMachineImageGenerator != nil {
		return virtualMachineImageGenerator
	}

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

	return virtualMachineImageGenerator
}

func Test_VirtualMachineImage_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 VirtualMachineImage_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVirtualMachineImage_STATUS, VirtualMachineImage_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual VirtualMachineImage_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 VirtualMachineImage_STATUS instances for property testing - lazily instantiated by
// VirtualMachineImage_STATUSGenerator()
var virtualMachineImage_STATUSGenerator gopter.Gen

// VirtualMachineImage_STATUSGenerator returns a generator of VirtualMachineImage_STATUS instances for property testing.
func VirtualMachineImage_STATUSGenerator() gopter.Gen {
	if virtualMachineImage_STATUSGenerator != nil {
		return virtualMachineImage_STATUSGenerator
	}

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

	return virtualMachineImage_STATUSGenerator
}

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

func Test_VirtualMachineSshCredentials_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 VirtualMachineSshCredentials via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVirtualMachineSshCredentials, VirtualMachineSshCredentialsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// VirtualMachineSshCredentialsGenerator returns a generator of VirtualMachineSshCredentials instances for property testing.
func VirtualMachineSshCredentialsGenerator() gopter.Gen {
	if virtualMachineSshCredentialsGenerator != nil {
		return virtualMachineSshCredentialsGenerator
	}

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

	return virtualMachineSshCredentialsGenerator
}

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

func Test_VirtualMachineSshCredentials_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 VirtualMachineSshCredentials_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVirtualMachineSshCredentials_STATUS, VirtualMachineSshCredentials_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual VirtualMachineSshCredentials_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 VirtualMachineSshCredentials_STATUS instances for property testing - lazily instantiated by
// VirtualMachineSshCredentials_STATUSGenerator()
var virtualMachineSshCredentials_STATUSGenerator gopter.Gen

// VirtualMachineSshCredentials_STATUSGenerator returns a generator of VirtualMachineSshCredentials_STATUS instances for property testing.
func VirtualMachineSshCredentials_STATUSGenerator() gopter.Gen {
	if virtualMachineSshCredentials_STATUSGenerator != nil {
		return virtualMachineSshCredentials_STATUSGenerator
	}

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

	return virtualMachineSshCredentials_STATUSGenerator
}

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

func Test_VirtualMachine_Properties_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 VirtualMachine_Properties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVirtualMachine_Properties, VirtualMachine_PropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualMachine_Properties(generators)
	AddRelatedPropertyGeneratorsForVirtualMachine_Properties(generators)
	virtualMachine_PropertiesGenerator = gen.Struct(reflect.TypeOf(VirtualMachine_Properties{}), generators)

	return virtualMachine_PropertiesGenerator
}

// AddIndependentPropertyGeneratorsForVirtualMachine_Properties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualMachine_Properties(gens map[string]gopter.Gen) {
	gens["Address"] = gen.PtrOf(gen.AlphaString())
	gens["IsNotebookInstanceCompute"] = gen.PtrOf(gen.Bool())
	gens["NotebookServerPort"] = gen.PtrOf(gen.Int())
	gens["SshPort"] = gen.PtrOf(gen.Int())
	gens["VirtualMachineSize"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

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

	return ""
}

// Generator of VirtualMachine_Properties_STATUS instances for property testing - lazily instantiated by
// VirtualMachine_Properties_STATUSGenerator()
var virtualMachine_Properties_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualMachine_Properties_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualMachine_Properties_STATUS(generators)
	virtualMachine_Properties_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualMachine_Properties_STATUS{}), generators)

	return virtualMachine_Properties_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualMachine_Properties_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualMachine_Properties_STATUS(gens map[string]gopter.Gen) {
	gens["Address"] = gen.PtrOf(gen.AlphaString())
	gens["IsNotebookInstanceCompute"] = gen.PtrOf(gen.Bool())
	gens["NotebookServerPort"] = gen.PtrOf(gen.Int())
	gens["SshPort"] = gen.PtrOf(gen.Int())
	gens["VirtualMachineSize"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_VirtualMachine_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 VirtualMachine_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVirtualMachine_STATUS, VirtualMachine_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual VirtualMachine_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 VirtualMachine_STATUS instances for property testing - lazily instantiated by
// VirtualMachine_STATUSGenerator()
var virtualMachine_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVirtualMachine_STATUS(generators)
	AddRelatedPropertyGeneratorsForVirtualMachine_STATUS(generators)
	virtualMachine_STATUSGenerator = gen.Struct(reflect.TypeOf(VirtualMachine_STATUS{}), generators)

	return virtualMachine_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVirtualMachine_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVirtualMachine_STATUS(gens map[string]gopter.Gen) {
	gens["ComputeLocation"] = gen.PtrOf(gen.AlphaString())
	gens["ComputeType"] = gen.PtrOf(gen.AlphaString())
	gens["CreatedOn"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["DisableLocalAuth"] = gen.PtrOf(gen.Bool())
	gens["IsAttachedCompute"] = gen.PtrOf(gen.Bool())
	gens["ModifiedOn"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForVirtualMachine_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForVirtualMachine_STATUS(gens map[string]gopter.Gen) {
	gens["Properties"] = gen.PtrOf(VirtualMachine_Properties_STATUSGenerator())
	gens["ProvisioningErrors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
}

func Test_VolumeDefinition_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 VolumeDefinition via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVolumeDefinition, VolumeDefinitionGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVolumeDefinition(generators)
	AddRelatedPropertyGeneratorsForVolumeDefinition(generators)
	volumeDefinitionGenerator = gen.Struct(reflect.TypeOf(VolumeDefinition{}), generators)

	return volumeDefinitionGenerator
}

// AddIndependentPropertyGeneratorsForVolumeDefinition is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVolumeDefinition(gens map[string]gopter.Gen) {
	gens["Consistency"] = gen.PtrOf(gen.AlphaString())
	gens["ReadOnly"] = gen.PtrOf(gen.Bool())
	gens["Source"] = gen.PtrOf(gen.AlphaString())
	gens["Target"] = gen.PtrOf(gen.AlphaString())
	gens["Type"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForVolumeDefinition is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForVolumeDefinition(gens map[string]gopter.Gen) {
	gens["Bind"] = gen.PtrOf(BindOptionsGenerator())
	gens["Tmpfs"] = gen.PtrOf(TmpfsOptionsGenerator())
	gens["Volume"] = gen.PtrOf(VolumeOptionsGenerator())
}

func Test_VolumeDefinition_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 VolumeDefinition_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVolumeDefinition_STATUS, VolumeDefinition_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual VolumeDefinition_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 VolumeDefinition_STATUS instances for property testing - lazily instantiated by
// VolumeDefinition_STATUSGenerator()
var volumeDefinition_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForVolumeDefinition_STATUS(generators)
	AddRelatedPropertyGeneratorsForVolumeDefinition_STATUS(generators)
	volumeDefinition_STATUSGenerator = gen.Struct(reflect.TypeOf(VolumeDefinition_STATUS{}), generators)

	return volumeDefinition_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForVolumeDefinition_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForVolumeDefinition_STATUS(gens map[string]gopter.Gen) {
	gens["Consistency"] = gen.PtrOf(gen.AlphaString())
	gens["ReadOnly"] = gen.PtrOf(gen.Bool())
	gens["Source"] = gen.PtrOf(gen.AlphaString())
	gens["Target"] = gen.PtrOf(gen.AlphaString())
	gens["Type"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForVolumeDefinition_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForVolumeDefinition_STATUS(gens map[string]gopter.Gen) {
	gens["Bind"] = gen.PtrOf(BindOptions_STATUSGenerator())
	gens["Tmpfs"] = gen.PtrOf(TmpfsOptions_STATUSGenerator())
	gens["Volume"] = gen.PtrOf(VolumeOptions_STATUSGenerator())
}

func Test_VolumeOptions_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 VolumeOptions via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVolumeOptions, VolumeOptionsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// VolumeOptionsGenerator returns a generator of VolumeOptions instances for property testing.
func VolumeOptionsGenerator() gopter.Gen {
	if volumeOptionsGenerator != nil {
		return volumeOptionsGenerator
	}

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

	return volumeOptionsGenerator
}

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

func Test_VolumeOptions_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 VolumeOptions_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForVolumeOptions_STATUS, VolumeOptions_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual VolumeOptions_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 VolumeOptions_STATUS instances for property testing - lazily instantiated by
// VolumeOptions_STATUSGenerator()
var volumeOptions_STATUSGenerator gopter.Gen

// VolumeOptions_STATUSGenerator returns a generator of VolumeOptions_STATUS instances for property testing.
func VolumeOptions_STATUSGenerator() gopter.Gen {
	if volumeOptions_STATUSGenerator != nil {
		return volumeOptions_STATUSGenerator
	}

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

	return volumeOptions_STATUSGenerator
}

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

func Test_WorkspacesCompute_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 20
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of WorkspacesCompute via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWorkspacesCompute, WorkspacesComputeGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// WorkspacesComputeGenerator returns a generator of WorkspacesCompute instances for property testing.
func WorkspacesComputeGenerator() gopter.Gen {
	if workspacesComputeGenerator != nil {
		return workspacesComputeGenerator
	}

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

	return workspacesComputeGenerator
}

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

func Test_WorkspacesComputeOperatorSpec_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 WorkspacesComputeOperatorSpec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWorkspacesComputeOperatorSpec, WorkspacesComputeOperatorSpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// WorkspacesComputeOperatorSpecGenerator returns a generator of WorkspacesComputeOperatorSpec instances for property testing.
func WorkspacesComputeOperatorSpecGenerator() gopter.Gen {
	if workspacesComputeOperatorSpecGenerator != nil {
		return workspacesComputeOperatorSpecGenerator
	}

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

	return workspacesComputeOperatorSpecGenerator
}

func Test_WorkspacesCompute_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 WorkspacesCompute_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWorkspacesCompute_STATUS, WorkspacesCompute_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual WorkspacesCompute_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 WorkspacesCompute_STATUS instances for property testing - lazily instantiated by
// WorkspacesCompute_STATUSGenerator()
var workspacesCompute_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForWorkspacesCompute_STATUS(generators)
	AddRelatedPropertyGeneratorsForWorkspacesCompute_STATUS(generators)
	workspacesCompute_STATUSGenerator = gen.Struct(reflect.TypeOf(WorkspacesCompute_STATUS{}), generators)

	return workspacesCompute_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForWorkspacesCompute_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForWorkspacesCompute_STATUS(gens map[string]gopter.Gen) {
	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())
}

// AddRelatedPropertyGeneratorsForWorkspacesCompute_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForWorkspacesCompute_STATUS(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(ManagedServiceIdentity_STATUSGenerator())
	gens["Properties"] = gen.PtrOf(Compute_STATUSGenerator())
	gens["Sku"] = gen.PtrOf(Sku_STATUSGenerator())
	gens["SystemData"] = gen.PtrOf(SystemData_STATUSGenerator())
}

func Test_WorkspacesCompute_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 WorkspacesCompute_Spec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWorkspacesCompute_Spec, WorkspacesCompute_SpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual WorkspacesCompute_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 WorkspacesCompute_Spec instances for property testing - lazily instantiated by
// WorkspacesCompute_SpecGenerator()
var workspacesCompute_SpecGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForWorkspacesCompute_Spec(generators)
	AddRelatedPropertyGeneratorsForWorkspacesCompute_Spec(generators)
	workspacesCompute_SpecGenerator = gen.Struct(reflect.TypeOf(WorkspacesCompute_Spec{}), generators)

	return workspacesCompute_SpecGenerator
}

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

// AddRelatedPropertyGeneratorsForWorkspacesCompute_Spec is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForWorkspacesCompute_Spec(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(ManagedServiceIdentityGenerator())
	gens["OperatorSpec"] = gen.PtrOf(WorkspacesComputeOperatorSpecGenerator())
	gens["Properties"] = gen.PtrOf(ComputeGenerator())
	gens["Sku"] = gen.PtrOf(SkuGenerator())
}
