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

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

func Test_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.OneConstOf(AKS_Properties_ClusterPurpose_STATUS_DenseProd, AKS_Properties_ClusterPurpose_STATUS_DevTest, AKS_Properties_ClusterPurpose_STATUS_FastProd))
	gens["LoadBalancerSubnet"] = gen.PtrOf(gen.AlphaString())
	gens["LoadBalancerType"] = gen.PtrOf(gen.OneConstOf(AKS_Properties_LoadBalancerType_STATUS_InternalLoadBalancer, AKS_Properties_LoadBalancerType_STATUS_PublicIp))
}

// 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.OneConstOf(AKS_ComputeType_STATUS_AKS)
	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.OneConstOf(
		AKS_ProvisioningState_STATUS_Canceled,
		AKS_ProvisioningState_STATUS_Creating,
		AKS_ProvisioningState_STATUS_Deleting,
		AKS_ProvisioningState_STATUS_Failed,
		AKS_ProvisioningState_STATUS_Succeeded,
		AKS_ProvisioningState_STATUS_Unknown,
		AKS_ProvisioningState_STATUS_Updating))
	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_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_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.OneConstOf(AmlComputeProperties_AllocationState_STATUS_Resizing, AmlComputeProperties_AllocationState_STATUS_Steady))
	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.OneConstOf(AmlComputeProperties_OsType_STATUS_Linux, AmlComputeProperties_OsType_STATUS_Windows))
	gens["RemoteLoginPortPublicAccess"] = gen.PtrOf(gen.OneConstOf(AmlComputeProperties_RemoteLoginPortPublicAccess_STATUS_Disabled, AmlComputeProperties_RemoteLoginPortPublicAccess_STATUS_Enabled, AmlComputeProperties_RemoteLoginPortPublicAccess_STATUS_NotSpecified))
	gens["TargetNodeCount"] = gen.PtrOf(gen.Int())
	gens["VmPriority"] = gen.PtrOf(gen.OneConstOf(AmlComputeProperties_VmPriority_STATUS_Dedicated, AmlComputeProperties_VmPriority_STATUS_LowPriority))
	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.OneConstOf(AmlCompute_ComputeType_STATUS_AmlCompute)
	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.OneConstOf(
		AmlCompute_ProvisioningState_STATUS_Canceled,
		AmlCompute_ProvisioningState_STATUS_Creating,
		AmlCompute_ProvisioningState_STATUS_Deleting,
		AmlCompute_ProvisioningState_STATUS_Failed,
		AmlCompute_ProvisioningState_STATUS_Succeeded,
		AmlCompute_ProvisioningState_STATUS_Unknown,
		AmlCompute_ProvisioningState_STATUS_Updating))
	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_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_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_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_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_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_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.OneConstOf(
		ComputeInstanceLastOperation_OperationName_STATUS_Create,
		ComputeInstanceLastOperation_OperationName_STATUS_Delete,
		ComputeInstanceLastOperation_OperationName_STATUS_Reimage,
		ComputeInstanceLastOperation_OperationName_STATUS_Restart,
		ComputeInstanceLastOperation_OperationName_STATUS_Start,
		ComputeInstanceLastOperation_OperationName_STATUS_Stop))
	gens["OperationStatus"] = gen.PtrOf(gen.OneConstOf(
		ComputeInstanceLastOperation_OperationStatus_STATUS_CreateFailed,
		ComputeInstanceLastOperation_OperationStatus_STATUS_DeleteFailed,
		ComputeInstanceLastOperation_OperationStatus_STATUS_InProgress,
		ComputeInstanceLastOperation_OperationStatus_STATUS_ReimageFailed,
		ComputeInstanceLastOperation_OperationStatus_STATUS_RestartFailed,
		ComputeInstanceLastOperation_OperationStatus_STATUS_StartFailed,
		ComputeInstanceLastOperation_OperationStatus_STATUS_StopFailed,
		ComputeInstanceLastOperation_OperationStatus_STATUS_Succeeded))
	gens["OperationTime"] = gen.PtrOf(gen.AlphaString())
}

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.OneConstOf(ComputeInstanceProperties_ApplicationSharingPolicy_STATUS_Personal, ComputeInstanceProperties_ApplicationSharingPolicy_STATUS_Shared))
	gens["ComputeInstanceAuthorizationType"] = gen.PtrOf(gen.OneConstOf(ComputeInstanceProperties_ComputeInstanceAuthorizationType_STATUS_Personal))
	gens["State"] = gen.PtrOf(gen.OneConstOf(
		ComputeInstanceState_STATUS_CreateFailed,
		ComputeInstanceState_STATUS_Creating,
		ComputeInstanceState_STATUS_Deleting,
		ComputeInstanceState_STATUS_JobRunning,
		ComputeInstanceState_STATUS_Restarting,
		ComputeInstanceState_STATUS_Running,
		ComputeInstanceState_STATUS_SettingUp,
		ComputeInstanceState_STATUS_SetupFailed,
		ComputeInstanceState_STATUS_Starting,
		ComputeInstanceState_STATUS_Stopped,
		ComputeInstanceState_STATUS_Stopping,
		ComputeInstanceState_STATUS_Unknown,
		ComputeInstanceState_STATUS_Unusable,
		ComputeInstanceState_STATUS_UserSettingUp,
		ComputeInstanceState_STATUS_UserSetupFailed))
	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["CreatedBy"] = gen.PtrOf(ComputeInstanceCreatedBy_STATUSGenerator())
	gens["Errors"] = gen.SliceOf(ErrorResponse_STATUSGenerator())
	gens["LastOperation"] = gen.PtrOf(ComputeInstanceLastOperation_STATUSGenerator())
	gens["PersonalComputeInstanceSettings"] = gen.PtrOf(PersonalComputeInstanceSettings_STATUSGenerator())
	gens["SetupScripts"] = gen.PtrOf(SetupScripts_STATUSGenerator())
	gens["SshSettings"] = gen.PtrOf(ComputeInstanceSshSettings_STATUSGenerator())
	gens["Subnet"] = gen.PtrOf(ResourceId_STATUSGenerator())
}

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.OneConstOf(ComputeInstanceSshSettings_SshPublicAccess_STATUS_Disabled, ComputeInstanceSshSettings_SshPublicAccess_STATUS_Enabled))
}

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.OneConstOf(ComputeInstance_ComputeType_STATUS_ComputeInstance)
	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.OneConstOf(
		ComputeInstance_ProvisioningState_STATUS_Canceled,
		ComputeInstance_ProvisioningState_STATUS_Creating,
		ComputeInstance_ProvisioningState_STATUS_Deleting,
		ComputeInstance_ProvisioningState_STATUS_Failed,
		ComputeInstance_ProvisioningState_STATUS_Succeeded,
		ComputeInstance_ProvisioningState_STATUS_Unknown,
		ComputeInstance_ProvisioningState_STATUS_Updating))
	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_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_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.OneConstOf(DataFactory_ComputeType_STATUS_DataFactory)
	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.OneConstOf(
		DataFactory_ProvisioningState_STATUS_Canceled,
		DataFactory_ProvisioningState_STATUS_Creating,
		DataFactory_ProvisioningState_STATUS_Deleting,
		DataFactory_ProvisioningState_STATUS_Failed,
		DataFactory_ProvisioningState_STATUS_Succeeded,
		DataFactory_ProvisioningState_STATUS_Unknown,
		DataFactory_ProvisioningState_STATUS_Updating))
	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_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.OneConstOf(DataLakeAnalytics_ComputeType_STATUS_DataLakeAnalytics)
	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.OneConstOf(
		DataLakeAnalytics_ProvisioningState_STATUS_Canceled,
		DataLakeAnalytics_ProvisioningState_STATUS_Creating,
		DataLakeAnalytics_ProvisioningState_STATUS_Deleting,
		DataLakeAnalytics_ProvisioningState_STATUS_Failed,
		DataLakeAnalytics_ProvisioningState_STATUS_Succeeded,
		DataLakeAnalytics_ProvisioningState_STATUS_Unknown,
		DataLakeAnalytics_ProvisioningState_STATUS_Updating))
	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_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.OneConstOf(Databricks_ComputeType_STATUS_Databricks)
	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.OneConstOf(
		Databricks_ProvisioningState_STATUS_Canceled,
		Databricks_ProvisioningState_STATUS_Creating,
		Databricks_ProvisioningState_STATUS_Deleting,
		Databricks_ProvisioningState_STATUS_Failed,
		Databricks_ProvisioningState_STATUS_Succeeded,
		Databricks_ProvisioningState_STATUS_Unknown,
		Databricks_ProvisioningState_STATUS_Updating))
	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_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_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.OneConstOf(HDInsight_ComputeType_STATUS_HDInsight)
	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.OneConstOf(
		HDInsight_ProvisioningState_STATUS_Canceled,
		HDInsight_ProvisioningState_STATUS_Creating,
		HDInsight_ProvisioningState_STATUS_Deleting,
		HDInsight_ProvisioningState_STATUS_Failed,
		HDInsight_ProvisioningState_STATUS_Succeeded,
		HDInsight_ProvisioningState_STATUS_Unknown,
		HDInsight_ProvisioningState_STATUS_Updating))
	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_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_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.OneConstOf(Kubernetes_ComputeType_STATUS_Kubernetes)
	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.OneConstOf(
		Kubernetes_ProvisioningState_STATUS_Canceled,
		Kubernetes_ProvisioningState_STATUS_Creating,
		Kubernetes_ProvisioningState_STATUS_Deleting,
		Kubernetes_ProvisioningState_STATUS_Failed,
		Kubernetes_ProvisioningState_STATUS_Succeeded,
		Kubernetes_ProvisioningState_STATUS_Unknown,
		Kubernetes_ProvisioningState_STATUS_Updating))
	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_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_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_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_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_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_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_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.OneConstOf(SslConfiguration_Status_STATUS_Auto, SslConfiguration_Status_STATUS_Disabled, SslConfiguration_Status_STATUS_Enabled))
}

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.OneConstOf(SynapseSpark_ComputeType_STATUS_SynapseSpark)
	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.OneConstOf(
		SynapseSpark_ProvisioningState_STATUS_Canceled,
		SynapseSpark_ProvisioningState_STATUS_Creating,
		SynapseSpark_ProvisioningState_STATUS_Deleting,
		SynapseSpark_ProvisioningState_STATUS_Failed,
		SynapseSpark_ProvisioningState_STATUS_Succeeded,
		SynapseSpark_ProvisioningState_STATUS_Unknown,
		SynapseSpark_ProvisioningState_STATUS_Updating))
	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_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_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_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_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["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.OneConstOf(VirtualMachine_ComputeType_STATUS_VirtualMachine)
	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.OneConstOf(
		VirtualMachine_ProvisioningState_STATUS_Canceled,
		VirtualMachine_ProvisioningState_STATUS_Creating,
		VirtualMachine_ProvisioningState_STATUS_Deleting,
		VirtualMachine_ProvisioningState_STATUS_Failed,
		VirtualMachine_ProvisioningState_STATUS_Succeeded,
		VirtualMachine_ProvisioningState_STATUS_Unknown,
		VirtualMachine_ProvisioningState_STATUS_Updating))
	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_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(Identity_STATUSGenerator())
	gens["Properties"] = gen.PtrOf(Compute_STATUSGenerator())
	gens["Sku"] = gen.PtrOf(Sku_STATUSGenerator())
	gens["SystemData"] = gen.PtrOf(SystemData_STATUSGenerator())
}
