// 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_AdxDestination_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 AdxDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAdxDestination_STATUS, AdxDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AdxDestination_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 AdxDestination_STATUS instances for property testing - lazily instantiated by
// AdxDestination_STATUSGenerator()
var adxDestination_STATUSGenerator gopter.Gen

// AdxDestination_STATUSGenerator returns a generator of AdxDestination_STATUS instances for property testing.
func AdxDestination_STATUSGenerator() gopter.Gen {
	if adxDestination_STATUSGenerator != nil {
		return adxDestination_STATUSGenerator
	}

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

	return adxDestination_STATUSGenerator
}

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

func Test_AgentSetting_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 AgentSetting_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAgentSetting_STATUS, AgentSetting_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AgentSetting_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 AgentSetting_STATUS instances for property testing - lazily instantiated by
// AgentSetting_STATUSGenerator()
var agentSetting_STATUSGenerator gopter.Gen

// AgentSetting_STATUSGenerator returns a generator of AgentSetting_STATUS instances for property testing.
func AgentSetting_STATUSGenerator() gopter.Gen {
	if agentSetting_STATUSGenerator != nil {
		return agentSetting_STATUSGenerator
	}

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

	return agentSetting_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForAgentSetting_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForAgentSetting_STATUS(gens map[string]gopter.Gen) {
	gens["Name"] = gen.PtrOf(gen.OneConstOf(AgentSetting_Name_STATUS_MaxDiskQuotaInMB, AgentSetting_Name_STATUS_UseTimeReceivedForForwardedEvents))
	gens["Value"] = gen.PtrOf(gen.AlphaString())
}

func Test_AgentSettingsSpec_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 AgentSettingsSpec_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAgentSettingsSpec_STATUS, AgentSettingsSpec_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AgentSettingsSpec_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 AgentSettingsSpec_STATUS instances for property testing - lazily instantiated by
// AgentSettingsSpec_STATUSGenerator()
var agentSettingsSpec_STATUSGenerator gopter.Gen

// AgentSettingsSpec_STATUSGenerator returns a generator of AgentSettingsSpec_STATUS instances for property testing.
func AgentSettingsSpec_STATUSGenerator() gopter.Gen {
	if agentSettingsSpec_STATUSGenerator != nil {
		return agentSettingsSpec_STATUSGenerator
	}

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

	return agentSettingsSpec_STATUSGenerator
}

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

func Test_AzureMonitorMetricsDestination_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 AzureMonitorMetricsDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAzureMonitorMetricsDestination_STATUS, AzureMonitorMetricsDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AzureMonitorMetricsDestination_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 AzureMonitorMetricsDestination_STATUS instances for property testing - lazily instantiated by
// AzureMonitorMetricsDestination_STATUSGenerator()
var azureMonitorMetricsDestination_STATUSGenerator gopter.Gen

// AzureMonitorMetricsDestination_STATUSGenerator returns a generator of AzureMonitorMetricsDestination_STATUS instances for property testing.
func AzureMonitorMetricsDestination_STATUSGenerator() gopter.Gen {
	if azureMonitorMetricsDestination_STATUSGenerator != nil {
		return azureMonitorMetricsDestination_STATUSGenerator
	}

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

	return azureMonitorMetricsDestination_STATUSGenerator
}

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

func Test_ColumnDefinition_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 ColumnDefinition_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForColumnDefinition_STATUS, ColumnDefinition_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ColumnDefinition_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 ColumnDefinition_STATUS instances for property testing - lazily instantiated by
// ColumnDefinition_STATUSGenerator()
var columnDefinition_STATUSGenerator gopter.Gen

// ColumnDefinition_STATUSGenerator returns a generator of ColumnDefinition_STATUS instances for property testing.
func ColumnDefinition_STATUSGenerator() gopter.Gen {
	if columnDefinition_STATUSGenerator != nil {
		return columnDefinition_STATUSGenerator
	}

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

	return columnDefinition_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForColumnDefinition_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForColumnDefinition_STATUS(gens map[string]gopter.Gen) {
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Type"] = gen.PtrOf(gen.OneConstOf(
		ColumnDefinition_Type_STATUS_Boolean,
		ColumnDefinition_Type_STATUS_Datetime,
		ColumnDefinition_Type_STATUS_Dynamic,
		ColumnDefinition_Type_STATUS_Int,
		ColumnDefinition_Type_STATUS_Long,
		ColumnDefinition_Type_STATUS_Real,
		ColumnDefinition_Type_STATUS_String))
}

func Test_DataCollectionRuleResource_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 DataCollectionRuleResource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataCollectionRuleResource_STATUS, DataCollectionRuleResource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DataCollectionRuleResource_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 DataCollectionRuleResource_STATUS instances for property testing - lazily instantiated by
// DataCollectionRuleResource_STATUSGenerator()
var dataCollectionRuleResource_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForDataCollectionRuleResource_STATUS(generators)
	AddRelatedPropertyGeneratorsForDataCollectionRuleResource_STATUS(generators)
	dataCollectionRuleResource_STATUSGenerator = gen.Struct(reflect.TypeOf(DataCollectionRuleResource_STATUS{}), generators)

	return dataCollectionRuleResource_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForDataCollectionRuleResource_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDataCollectionRuleResource_STATUS(gens map[string]gopter.Gen) {
	gens["Etag"] = gen.PtrOf(gen.AlphaString())
	gens["Id"] = gen.PtrOf(gen.AlphaString())
	gens["Kind"] = gen.PtrOf(gen.OneConstOf(DataCollectionRuleResource_Kind_STATUS_Linux, DataCollectionRuleResource_Kind_STATUS_Windows))
	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())
}

// AddRelatedPropertyGeneratorsForDataCollectionRuleResource_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDataCollectionRuleResource_STATUS(gens map[string]gopter.Gen) {
	gens["Identity"] = gen.PtrOf(ManagedServiceIdentity_STATUSGenerator())
	gens["Properties"] = gen.PtrOf(DataCollectionRule_STATUSGenerator())
	gens["SystemData"] = gen.PtrOf(SystemData_STATUSGenerator())
}

func Test_DataCollectionRule_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 DataCollectionRule_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataCollectionRule_STATUS, DataCollectionRule_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DataCollectionRule_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 DataCollectionRule_STATUS instances for property testing - lazily instantiated by
// DataCollectionRule_STATUSGenerator()
var dataCollectionRule_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForDataCollectionRule_STATUS(generators)
	AddRelatedPropertyGeneratorsForDataCollectionRule_STATUS(generators)
	dataCollectionRule_STATUSGenerator = gen.Struct(reflect.TypeOf(DataCollectionRule_STATUS{}), generators)

	return dataCollectionRule_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForDataCollectionRule_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDataCollectionRule_STATUS(gens map[string]gopter.Gen) {
	gens["DataCollectionEndpointId"] = gen.PtrOf(gen.AlphaString())
	gens["Description"] = gen.PtrOf(gen.AlphaString())
	gens["ImmutableId"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.OneConstOf(
		DataCollectionRule_ProvisioningState_STATUS_Canceled,
		DataCollectionRule_ProvisioningState_STATUS_Creating,
		DataCollectionRule_ProvisioningState_STATUS_Deleting,
		DataCollectionRule_ProvisioningState_STATUS_Failed,
		DataCollectionRule_ProvisioningState_STATUS_Succeeded,
		DataCollectionRule_ProvisioningState_STATUS_Updating))
}

// AddRelatedPropertyGeneratorsForDataCollectionRule_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDataCollectionRule_STATUS(gens map[string]gopter.Gen) {
	gens["AgentSettings"] = gen.PtrOf(AgentSettingsSpec_STATUSGenerator())
	gens["DataFlows"] = gen.SliceOf(DataFlow_STATUSGenerator())
	gens["DataSources"] = gen.PtrOf(DataSourcesSpec_STATUSGenerator())
	gens["Destinations"] = gen.PtrOf(DestinationsSpec_STATUSGenerator())
	gens["Endpoints"] = gen.PtrOf(EndpointsSpec_STATUSGenerator())
	gens["Metadata"] = gen.PtrOf(Metadata_STATUSGenerator())
	gens["References"] = gen.PtrOf(ReferencesSpec_STATUSGenerator())
	gens["StreamDeclarations"] = gen.MapOf(
		gen.AlphaString(),
		StreamDeclaration_STATUSGenerator())
}

func Test_DataFlow_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 DataFlow_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataFlow_STATUS, DataFlow_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DataFlow_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 DataFlow_STATUS instances for property testing - lazily instantiated by DataFlow_STATUSGenerator()
var dataFlow_STATUSGenerator gopter.Gen

// DataFlow_STATUSGenerator returns a generator of DataFlow_STATUS instances for property testing.
func DataFlow_STATUSGenerator() gopter.Gen {
	if dataFlow_STATUSGenerator != nil {
		return dataFlow_STATUSGenerator
	}

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

	return dataFlow_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForDataFlow_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDataFlow_STATUS(gens map[string]gopter.Gen) {
	gens["BuiltInTransform"] = gen.PtrOf(gen.AlphaString())
	gens["CaptureOverflow"] = gen.PtrOf(gen.Bool())
	gens["Destinations"] = gen.SliceOf(gen.AlphaString())
	gens["OutputStream"] = gen.PtrOf(gen.AlphaString())
	gens["Streams"] = gen.SliceOf(gen.OneConstOf(
		DataFlow_Streams_STATUS_MicrosoftEvent,
		DataFlow_Streams_STATUS_MicrosoftInsightsMetrics,
		DataFlow_Streams_STATUS_MicrosoftPerf,
		DataFlow_Streams_STATUS_MicrosoftSyslog,
		DataFlow_Streams_STATUS_MicrosoftWindowsEvent))
	gens["TransformKql"] = gen.PtrOf(gen.AlphaString())
}

func Test_DataImportSources_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 DataImportSources_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataImportSources_STATUS, DataImportSources_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DataImportSources_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 DataImportSources_STATUS instances for property testing - lazily instantiated by
// DataImportSources_STATUSGenerator()
var dataImportSources_STATUSGenerator gopter.Gen

// DataImportSources_STATUSGenerator returns a generator of DataImportSources_STATUS instances for property testing.
func DataImportSources_STATUSGenerator() gopter.Gen {
	if dataImportSources_STATUSGenerator != nil {
		return dataImportSources_STATUSGenerator
	}

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

	return dataImportSources_STATUSGenerator
}

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

func Test_DataSourcesSpec_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 DataSourcesSpec_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDataSourcesSpec_STATUS, DataSourcesSpec_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DataSourcesSpec_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 DataSourcesSpec_STATUS instances for property testing - lazily instantiated by
// DataSourcesSpec_STATUSGenerator()
var dataSourcesSpec_STATUSGenerator gopter.Gen

// DataSourcesSpec_STATUSGenerator returns a generator of DataSourcesSpec_STATUS instances for property testing.
func DataSourcesSpec_STATUSGenerator() gopter.Gen {
	if dataSourcesSpec_STATUSGenerator != nil {
		return dataSourcesSpec_STATUSGenerator
	}

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

	return dataSourcesSpec_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForDataSourcesSpec_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDataSourcesSpec_STATUS(gens map[string]gopter.Gen) {
	gens["DataImports"] = gen.PtrOf(DataImportSources_STATUSGenerator())
	gens["Extensions"] = gen.SliceOf(ExtensionDataSource_STATUSGenerator())
	gens["IisLogs"] = gen.SliceOf(IisLogsDataSource_STATUSGenerator())
	gens["LogFiles"] = gen.SliceOf(LogFilesDataSource_STATUSGenerator())
	gens["PerformanceCounters"] = gen.SliceOf(PerfCounterDataSource_STATUSGenerator())
	gens["PlatformTelemetry"] = gen.SliceOf(PlatformTelemetryDataSource_STATUSGenerator())
	gens["PrometheusForwarder"] = gen.SliceOf(PrometheusForwarderDataSource_STATUSGenerator())
	gens["Syslog"] = gen.SliceOf(SyslogDataSource_STATUSGenerator())
	gens["WindowsEventLogs"] = gen.SliceOf(WindowsEventLogDataSource_STATUSGenerator())
	gens["WindowsFirewallLogs"] = gen.SliceOf(WindowsFirewallLogsDataSource_STATUSGenerator())
}

func Test_DestinationsSpec_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 DestinationsSpec_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDestinationsSpec_STATUS, DestinationsSpec_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DestinationsSpec_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 DestinationsSpec_STATUS instances for property testing - lazily instantiated by
// DestinationsSpec_STATUSGenerator()
var destinationsSpec_STATUSGenerator gopter.Gen

// DestinationsSpec_STATUSGenerator returns a generator of DestinationsSpec_STATUS instances for property testing.
func DestinationsSpec_STATUSGenerator() gopter.Gen {
	if destinationsSpec_STATUSGenerator != nil {
		return destinationsSpec_STATUSGenerator
	}

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

	return destinationsSpec_STATUSGenerator
}

// AddRelatedPropertyGeneratorsForDestinationsSpec_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDestinationsSpec_STATUS(gens map[string]gopter.Gen) {
	gens["AzureDataExplorer"] = gen.SliceOf(AdxDestination_STATUSGenerator())
	gens["AzureMonitorMetrics"] = gen.PtrOf(AzureMonitorMetricsDestination_STATUSGenerator())
	gens["EventHubs"] = gen.SliceOf(EventHubDestination_STATUSGenerator())
	gens["EventHubsDirect"] = gen.SliceOf(EventHubDirectDestination_STATUSGenerator())
	gens["LogAnalytics"] = gen.SliceOf(LogAnalyticsDestination_STATUSGenerator())
	gens["MicrosoftFabric"] = gen.SliceOf(MicrosoftFabricDestination_STATUSGenerator())
	gens["MonitoringAccounts"] = gen.SliceOf(MonitoringAccountDestination_STATUSGenerator())
	gens["StorageAccounts"] = gen.SliceOf(StorageBlobDestination_STATUSGenerator())
	gens["StorageBlobsDirect"] = gen.SliceOf(StorageBlobDestination_STATUSGenerator())
	gens["StorageTablesDirect"] = gen.SliceOf(StorageTableDestination_STATUSGenerator())
}

func Test_EndpointsSpec_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 EndpointsSpec_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEndpointsSpec_STATUS, EndpointsSpec_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EndpointsSpec_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 EndpointsSpec_STATUS instances for property testing - lazily instantiated by
// EndpointsSpec_STATUSGenerator()
var endpointsSpec_STATUSGenerator gopter.Gen

// EndpointsSpec_STATUSGenerator returns a generator of EndpointsSpec_STATUS instances for property testing.
func EndpointsSpec_STATUSGenerator() gopter.Gen {
	if endpointsSpec_STATUSGenerator != nil {
		return endpointsSpec_STATUSGenerator
	}

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

	return endpointsSpec_STATUSGenerator
}

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

func Test_EnrichmentData_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 EnrichmentData_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEnrichmentData_STATUS, EnrichmentData_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EnrichmentData_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 EnrichmentData_STATUS instances for property testing - lazily instantiated by
// EnrichmentData_STATUSGenerator()
var enrichmentData_STATUSGenerator gopter.Gen

// EnrichmentData_STATUSGenerator returns a generator of EnrichmentData_STATUS instances for property testing.
func EnrichmentData_STATUSGenerator() gopter.Gen {
	if enrichmentData_STATUSGenerator != nil {
		return enrichmentData_STATUSGenerator
	}

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

	return enrichmentData_STATUSGenerator
}

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

func Test_EventHubDataSource_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 EventHubDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEventHubDataSource_STATUS, EventHubDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EventHubDataSource_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 EventHubDataSource_STATUS instances for property testing - lazily instantiated by
// EventHubDataSource_STATUSGenerator()
var eventHubDataSource_STATUSGenerator gopter.Gen

// EventHubDataSource_STATUSGenerator returns a generator of EventHubDataSource_STATUS instances for property testing.
func EventHubDataSource_STATUSGenerator() gopter.Gen {
	if eventHubDataSource_STATUSGenerator != nil {
		return eventHubDataSource_STATUSGenerator
	}

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

	return eventHubDataSource_STATUSGenerator
}

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

func Test_EventHubDestination_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 EventHubDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEventHubDestination_STATUS, EventHubDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EventHubDestination_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 EventHubDestination_STATUS instances for property testing - lazily instantiated by
// EventHubDestination_STATUSGenerator()
var eventHubDestination_STATUSGenerator gopter.Gen

// EventHubDestination_STATUSGenerator returns a generator of EventHubDestination_STATUS instances for property testing.
func EventHubDestination_STATUSGenerator() gopter.Gen {
	if eventHubDestination_STATUSGenerator != nil {
		return eventHubDestination_STATUSGenerator
	}

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

	return eventHubDestination_STATUSGenerator
}

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

func Test_EventHubDirectDestination_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 EventHubDirectDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForEventHubDirectDestination_STATUS, EventHubDirectDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual EventHubDirectDestination_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 EventHubDirectDestination_STATUS instances for property testing - lazily instantiated by
// EventHubDirectDestination_STATUSGenerator()
var eventHubDirectDestination_STATUSGenerator gopter.Gen

// EventHubDirectDestination_STATUSGenerator returns a generator of EventHubDirectDestination_STATUS instances for property testing.
func EventHubDirectDestination_STATUSGenerator() gopter.Gen {
	if eventHubDirectDestination_STATUSGenerator != nil {
		return eventHubDirectDestination_STATUSGenerator
	}

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

	return eventHubDirectDestination_STATUSGenerator
}

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

func Test_ExtensionDataSource_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 ExtensionDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForExtensionDataSource_STATUS, ExtensionDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ExtensionDataSource_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 ExtensionDataSource_STATUS instances for property testing - lazily instantiated by
// ExtensionDataSource_STATUSGenerator()
var extensionDataSource_STATUSGenerator gopter.Gen

// ExtensionDataSource_STATUSGenerator returns a generator of ExtensionDataSource_STATUS instances for property testing.
func ExtensionDataSource_STATUSGenerator() gopter.Gen {
	if extensionDataSource_STATUSGenerator != nil {
		return extensionDataSource_STATUSGenerator
	}

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

	return extensionDataSource_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForExtensionDataSource_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForExtensionDataSource_STATUS(gens map[string]gopter.Gen) {
	gens["ExtensionName"] = gen.PtrOf(gen.AlphaString())
	gens["InputDataSources"] = gen.SliceOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Streams"] = gen.SliceOf(gen.OneConstOf(
		ExtensionDataSource_Streams_STATUS_MicrosoftEvent,
		ExtensionDataSource_Streams_STATUS_MicrosoftInsightsMetrics,
		ExtensionDataSource_Streams_STATUS_MicrosoftPerf,
		ExtensionDataSource_Streams_STATUS_MicrosoftSyslog,
		ExtensionDataSource_Streams_STATUS_MicrosoftWindowsEvent))
}

func Test_IisLogsDataSource_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 IisLogsDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForIisLogsDataSource_STATUS, IisLogsDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual IisLogsDataSource_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 IisLogsDataSource_STATUS instances for property testing - lazily instantiated by
// IisLogsDataSource_STATUSGenerator()
var iisLogsDataSource_STATUSGenerator gopter.Gen

// IisLogsDataSource_STATUSGenerator returns a generator of IisLogsDataSource_STATUS instances for property testing.
func IisLogsDataSource_STATUSGenerator() gopter.Gen {
	if iisLogsDataSource_STATUSGenerator != nil {
		return iisLogsDataSource_STATUSGenerator
	}

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

	return iisLogsDataSource_STATUSGenerator
}

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

func Test_LogAnalyticsDestination_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 LogAnalyticsDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForLogAnalyticsDestination_STATUS, LogAnalyticsDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual LogAnalyticsDestination_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 LogAnalyticsDestination_STATUS instances for property testing - lazily instantiated by
// LogAnalyticsDestination_STATUSGenerator()
var logAnalyticsDestination_STATUSGenerator gopter.Gen

// LogAnalyticsDestination_STATUSGenerator returns a generator of LogAnalyticsDestination_STATUS instances for property testing.
func LogAnalyticsDestination_STATUSGenerator() gopter.Gen {
	if logAnalyticsDestination_STATUSGenerator != nil {
		return logAnalyticsDestination_STATUSGenerator
	}

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

	return logAnalyticsDestination_STATUSGenerator
}

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

func Test_LogFileSettings_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 LogFileSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForLogFileSettings_STATUS, LogFileSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual LogFileSettings_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 LogFileSettings_STATUS instances for property testing - lazily instantiated by
// LogFileSettings_STATUSGenerator()
var logFileSettings_STATUSGenerator gopter.Gen

// LogFileSettings_STATUSGenerator returns a generator of LogFileSettings_STATUS instances for property testing.
func LogFileSettings_STATUSGenerator() gopter.Gen {
	if logFileSettings_STATUSGenerator != nil {
		return logFileSettings_STATUSGenerator
	}

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

	return logFileSettings_STATUSGenerator
}

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

func Test_LogFileTextSettings_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 LogFileTextSettings_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForLogFileTextSettings_STATUS, LogFileTextSettings_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual LogFileTextSettings_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 LogFileTextSettings_STATUS instances for property testing - lazily instantiated by
// LogFileTextSettings_STATUSGenerator()
var logFileTextSettings_STATUSGenerator gopter.Gen

// LogFileTextSettings_STATUSGenerator returns a generator of LogFileTextSettings_STATUS instances for property testing.
func LogFileTextSettings_STATUSGenerator() gopter.Gen {
	if logFileTextSettings_STATUSGenerator != nil {
		return logFileTextSettings_STATUSGenerator
	}

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

	return logFileTextSettings_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForLogFileTextSettings_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForLogFileTextSettings_STATUS(gens map[string]gopter.Gen) {
	gens["RecordStartTimestampFormat"] = gen.PtrOf(gen.OneConstOf(
		LogFileTextSettings_RecordStartTimestampFormat_STATUS_DdMMMYyyyHHMmSsZzz,
		LogFileTextSettings_RecordStartTimestampFormat_STATUS_DdMMyyHHMmSs,
		LogFileTextSettings_RecordStartTimestampFormat_STATUS_ISO8601,
		LogFileTextSettings_RecordStartTimestampFormat_STATUS_MDYYYYHHMMSSAMPM,
		LogFileTextSettings_RecordStartTimestampFormat_STATUS_MMMDHhMmSs,
		LogFileTextSettings_RecordStartTimestampFormat_STATUS_MonDDYYYYHHMMSS,
		LogFileTextSettings_RecordStartTimestampFormat_STATUS_YYYYMMDDHHMMSS,
		LogFileTextSettings_RecordStartTimestampFormat_STATUS_YyMMddHHMmSs,
		LogFileTextSettings_RecordStartTimestampFormat_STATUS_YyyyMMDdTHHMmSsK))
}

func Test_LogFilesDataSource_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 LogFilesDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForLogFilesDataSource_STATUS, LogFilesDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual LogFilesDataSource_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 LogFilesDataSource_STATUS instances for property testing - lazily instantiated by
// LogFilesDataSource_STATUSGenerator()
var logFilesDataSource_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForLogFilesDataSource_STATUS(generators)
	AddRelatedPropertyGeneratorsForLogFilesDataSource_STATUS(generators)
	logFilesDataSource_STATUSGenerator = gen.Struct(reflect.TypeOf(LogFilesDataSource_STATUS{}), generators)

	return logFilesDataSource_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForLogFilesDataSource_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForLogFilesDataSource_STATUS(gens map[string]gopter.Gen) {
	gens["FilePatterns"] = gen.SliceOf(gen.AlphaString())
	gens["Format"] = gen.PtrOf(gen.OneConstOf(LogFilesDataSource_Format_STATUS_Json, LogFilesDataSource_Format_STATUS_Text))
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Streams"] = gen.SliceOf(gen.AlphaString())
	gens["TransformKql"] = gen.PtrOf(gen.AlphaString())
}

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

func Test_MicrosoftFabricDestination_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 MicrosoftFabricDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForMicrosoftFabricDestination_STATUS, MicrosoftFabricDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual MicrosoftFabricDestination_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 MicrosoftFabricDestination_STATUS instances for property testing - lazily instantiated by
// MicrosoftFabricDestination_STATUSGenerator()
var microsoftFabricDestination_STATUSGenerator gopter.Gen

// MicrosoftFabricDestination_STATUSGenerator returns a generator of MicrosoftFabricDestination_STATUS instances for property testing.
func MicrosoftFabricDestination_STATUSGenerator() gopter.Gen {
	if microsoftFabricDestination_STATUSGenerator != nil {
		return microsoftFabricDestination_STATUSGenerator
	}

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

	return microsoftFabricDestination_STATUSGenerator
}

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

func Test_MonitoringAccountDestination_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 MonitoringAccountDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForMonitoringAccountDestination_STATUS, MonitoringAccountDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual MonitoringAccountDestination_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 MonitoringAccountDestination_STATUS instances for property testing - lazily instantiated by
// MonitoringAccountDestination_STATUSGenerator()
var monitoringAccountDestination_STATUSGenerator gopter.Gen

// MonitoringAccountDestination_STATUSGenerator returns a generator of MonitoringAccountDestination_STATUS instances for property testing.
func MonitoringAccountDestination_STATUSGenerator() gopter.Gen {
	if monitoringAccountDestination_STATUSGenerator != nil {
		return monitoringAccountDestination_STATUSGenerator
	}

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

	return monitoringAccountDestination_STATUSGenerator
}

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

func Test_PerfCounterDataSource_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 PerfCounterDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPerfCounterDataSource_STATUS, PerfCounterDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PerfCounterDataSource_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 PerfCounterDataSource_STATUS instances for property testing - lazily instantiated by
// PerfCounterDataSource_STATUSGenerator()
var perfCounterDataSource_STATUSGenerator gopter.Gen

// PerfCounterDataSource_STATUSGenerator returns a generator of PerfCounterDataSource_STATUS instances for property testing.
func PerfCounterDataSource_STATUSGenerator() gopter.Gen {
	if perfCounterDataSource_STATUSGenerator != nil {
		return perfCounterDataSource_STATUSGenerator
	}

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

	return perfCounterDataSource_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForPerfCounterDataSource_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForPerfCounterDataSource_STATUS(gens map[string]gopter.Gen) {
	gens["CounterSpecifiers"] = gen.SliceOf(gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["SamplingFrequencyInSeconds"] = gen.PtrOf(gen.Int())
	gens["Streams"] = gen.SliceOf(gen.OneConstOf(PerfCounterDataSource_Streams_STATUS_MicrosoftInsightsMetrics, PerfCounterDataSource_Streams_STATUS_MicrosoftPerf))
	gens["TransformKql"] = gen.PtrOf(gen.AlphaString())
}

func Test_PlatformTelemetryDataSource_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 PlatformTelemetryDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPlatformTelemetryDataSource_STATUS, PlatformTelemetryDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PlatformTelemetryDataSource_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 PlatformTelemetryDataSource_STATUS instances for property testing - lazily instantiated by
// PlatformTelemetryDataSource_STATUSGenerator()
var platformTelemetryDataSource_STATUSGenerator gopter.Gen

// PlatformTelemetryDataSource_STATUSGenerator returns a generator of PlatformTelemetryDataSource_STATUS instances for property testing.
func PlatformTelemetryDataSource_STATUSGenerator() gopter.Gen {
	if platformTelemetryDataSource_STATUSGenerator != nil {
		return platformTelemetryDataSource_STATUSGenerator
	}

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

	return platformTelemetryDataSource_STATUSGenerator
}

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

func Test_PrometheusForwarderDataSource_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 PrometheusForwarderDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrometheusForwarderDataSource_STATUS, PrometheusForwarderDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PrometheusForwarderDataSource_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 PrometheusForwarderDataSource_STATUS instances for property testing - lazily instantiated by
// PrometheusForwarderDataSource_STATUSGenerator()
var prometheusForwarderDataSource_STATUSGenerator gopter.Gen

// PrometheusForwarderDataSource_STATUSGenerator returns a generator of PrometheusForwarderDataSource_STATUS instances for property testing.
func PrometheusForwarderDataSource_STATUSGenerator() gopter.Gen {
	if prometheusForwarderDataSource_STATUSGenerator != nil {
		return prometheusForwarderDataSource_STATUSGenerator
	}

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

	return prometheusForwarderDataSource_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForPrometheusForwarderDataSource_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForPrometheusForwarderDataSource_STATUS(gens map[string]gopter.Gen) {
	gens["LabelIncludeFilter"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Streams"] = gen.SliceOf(gen.OneConstOf(PrometheusForwarderDataSource_Streams_STATUS_MicrosoftPrometheusMetrics))
}

func Test_ReferencesSpec_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 ReferencesSpec_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForReferencesSpec_STATUS, ReferencesSpec_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ReferencesSpec_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 ReferencesSpec_STATUS instances for property testing - lazily instantiated by
// ReferencesSpec_STATUSGenerator()
var referencesSpec_STATUSGenerator gopter.Gen

// ReferencesSpec_STATUSGenerator returns a generator of ReferencesSpec_STATUS instances for property testing.
func ReferencesSpec_STATUSGenerator() gopter.Gen {
	if referencesSpec_STATUSGenerator != nil {
		return referencesSpec_STATUSGenerator
	}

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

	return referencesSpec_STATUSGenerator
}

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

func Test_StorageBlobDestination_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 StorageBlobDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStorageBlobDestination_STATUS, StorageBlobDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StorageBlobDestination_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 StorageBlobDestination_STATUS instances for property testing - lazily instantiated by
// StorageBlobDestination_STATUSGenerator()
var storageBlobDestination_STATUSGenerator gopter.Gen

// StorageBlobDestination_STATUSGenerator returns a generator of StorageBlobDestination_STATUS instances for property testing.
func StorageBlobDestination_STATUSGenerator() gopter.Gen {
	if storageBlobDestination_STATUSGenerator != nil {
		return storageBlobDestination_STATUSGenerator
	}

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

	return storageBlobDestination_STATUSGenerator
}

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

func Test_StorageBlob_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 StorageBlob_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStorageBlob_STATUS, StorageBlob_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StorageBlob_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 StorageBlob_STATUS instances for property testing - lazily instantiated by StorageBlob_STATUSGenerator()
var storageBlob_STATUSGenerator gopter.Gen

// StorageBlob_STATUSGenerator returns a generator of StorageBlob_STATUS instances for property testing.
func StorageBlob_STATUSGenerator() gopter.Gen {
	if storageBlob_STATUSGenerator != nil {
		return storageBlob_STATUSGenerator
	}

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

	return storageBlob_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForStorageBlob_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForStorageBlob_STATUS(gens map[string]gopter.Gen) {
	gens["BlobUrl"] = gen.PtrOf(gen.AlphaString())
	gens["LookupType"] = gen.PtrOf(gen.OneConstOf(StorageBlob_LookupType_STATUS_Cidr, StorageBlob_LookupType_STATUS_String))
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["ResourceId"] = gen.PtrOf(gen.AlphaString())
}

func Test_StorageTableDestination_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 StorageTableDestination_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStorageTableDestination_STATUS, StorageTableDestination_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StorageTableDestination_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 StorageTableDestination_STATUS instances for property testing - lazily instantiated by
// StorageTableDestination_STATUSGenerator()
var storageTableDestination_STATUSGenerator gopter.Gen

// StorageTableDestination_STATUSGenerator returns a generator of StorageTableDestination_STATUS instances for property testing.
func StorageTableDestination_STATUSGenerator() gopter.Gen {
	if storageTableDestination_STATUSGenerator != nil {
		return storageTableDestination_STATUSGenerator
	}

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

	return storageTableDestination_STATUSGenerator
}

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

func Test_StreamDeclaration_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 StreamDeclaration_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForStreamDeclaration_STATUS, StreamDeclaration_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual StreamDeclaration_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 StreamDeclaration_STATUS instances for property testing - lazily instantiated by
// StreamDeclaration_STATUSGenerator()
var streamDeclaration_STATUSGenerator gopter.Gen

// StreamDeclaration_STATUSGenerator returns a generator of StreamDeclaration_STATUS instances for property testing.
func StreamDeclaration_STATUSGenerator() gopter.Gen {
	if streamDeclaration_STATUSGenerator != nil {
		return streamDeclaration_STATUSGenerator
	}

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

	return streamDeclaration_STATUSGenerator
}

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

func Test_SyslogDataSource_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 SyslogDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSyslogDataSource_STATUS, SyslogDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SyslogDataSource_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 SyslogDataSource_STATUS instances for property testing - lazily instantiated by
// SyslogDataSource_STATUSGenerator()
var syslogDataSource_STATUSGenerator gopter.Gen

// SyslogDataSource_STATUSGenerator returns a generator of SyslogDataSource_STATUS instances for property testing.
func SyslogDataSource_STATUSGenerator() gopter.Gen {
	if syslogDataSource_STATUSGenerator != nil {
		return syslogDataSource_STATUSGenerator
	}

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

	return syslogDataSource_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSyslogDataSource_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSyslogDataSource_STATUS(gens map[string]gopter.Gen) {
	gens["FacilityNames"] = gen.SliceOf(gen.OneConstOf(
		SyslogDataSource_FacilityNames_STATUS_Alert,
		SyslogDataSource_FacilityNames_STATUS_Audit,
		SyslogDataSource_FacilityNames_STATUS_Auth,
		SyslogDataSource_FacilityNames_STATUS_Authpriv,
		SyslogDataSource_FacilityNames_STATUS_Clock,
		SyslogDataSource_FacilityNames_STATUS_Cron,
		SyslogDataSource_FacilityNames_STATUS_Daemon,
		SyslogDataSource_FacilityNames_STATUS_Ftp,
		SyslogDataSource_FacilityNames_STATUS_Kern,
		SyslogDataSource_FacilityNames_STATUS_Local0,
		SyslogDataSource_FacilityNames_STATUS_Local1,
		SyslogDataSource_FacilityNames_STATUS_Local2,
		SyslogDataSource_FacilityNames_STATUS_Local3,
		SyslogDataSource_FacilityNames_STATUS_Local4,
		SyslogDataSource_FacilityNames_STATUS_Local5,
		SyslogDataSource_FacilityNames_STATUS_Local6,
		SyslogDataSource_FacilityNames_STATUS_Local7,
		SyslogDataSource_FacilityNames_STATUS_Lpr,
		SyslogDataSource_FacilityNames_STATUS_Mail,
		SyslogDataSource_FacilityNames_STATUS_Mark,
		SyslogDataSource_FacilityNames_STATUS_News,
		SyslogDataSource_FacilityNames_STATUS_Nopri,
		SyslogDataSource_FacilityNames_STATUS_Ntp,
		SyslogDataSource_FacilityNames_STATUS_Star,
		SyslogDataSource_FacilityNames_STATUS_Syslog,
		SyslogDataSource_FacilityNames_STATUS_User,
		SyslogDataSource_FacilityNames_STATUS_Uucp))
	gens["LogLevels"] = gen.SliceOf(gen.OneConstOf(
		SyslogDataSource_LogLevels_STATUS_Alert,
		SyslogDataSource_LogLevels_STATUS_Critical,
		SyslogDataSource_LogLevels_STATUS_Debug,
		SyslogDataSource_LogLevels_STATUS_Emergency,
		SyslogDataSource_LogLevels_STATUS_Error,
		SyslogDataSource_LogLevels_STATUS_Info,
		SyslogDataSource_LogLevels_STATUS_Notice,
		SyslogDataSource_LogLevels_STATUS_Star,
		SyslogDataSource_LogLevels_STATUS_Warning))
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Streams"] = gen.SliceOf(gen.OneConstOf(SyslogDataSource_Streams_STATUS_MicrosoftSyslog))
	gens["TransformKql"] = gen.PtrOf(gen.AlphaString())
}

func Test_WindowsEventLogDataSource_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 WindowsEventLogDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWindowsEventLogDataSource_STATUS, WindowsEventLogDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual WindowsEventLogDataSource_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 WindowsEventLogDataSource_STATUS instances for property testing - lazily instantiated by
// WindowsEventLogDataSource_STATUSGenerator()
var windowsEventLogDataSource_STATUSGenerator gopter.Gen

// WindowsEventLogDataSource_STATUSGenerator returns a generator of WindowsEventLogDataSource_STATUS instances for property testing.
func WindowsEventLogDataSource_STATUSGenerator() gopter.Gen {
	if windowsEventLogDataSource_STATUSGenerator != nil {
		return windowsEventLogDataSource_STATUSGenerator
	}

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

	return windowsEventLogDataSource_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForWindowsEventLogDataSource_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForWindowsEventLogDataSource_STATUS(gens map[string]gopter.Gen) {
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Streams"] = gen.SliceOf(gen.OneConstOf(WindowsEventLogDataSource_Streams_STATUS_MicrosoftEvent, WindowsEventLogDataSource_Streams_STATUS_MicrosoftWindowsEvent))
	gens["TransformKql"] = gen.PtrOf(gen.AlphaString())
	gens["XPathQueries"] = gen.SliceOf(gen.AlphaString())
}

func Test_WindowsFirewallLogsDataSource_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 WindowsFirewallLogsDataSource_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForWindowsFirewallLogsDataSource_STATUS, WindowsFirewallLogsDataSource_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual WindowsFirewallLogsDataSource_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 WindowsFirewallLogsDataSource_STATUS instances for property testing - lazily instantiated by
// WindowsFirewallLogsDataSource_STATUSGenerator()
var windowsFirewallLogsDataSource_STATUSGenerator gopter.Gen

// WindowsFirewallLogsDataSource_STATUSGenerator returns a generator of WindowsFirewallLogsDataSource_STATUS instances for property testing.
func WindowsFirewallLogsDataSource_STATUSGenerator() gopter.Gen {
	if windowsFirewallLogsDataSource_STATUSGenerator != nil {
		return windowsFirewallLogsDataSource_STATUSGenerator
	}

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

	return windowsFirewallLogsDataSource_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForWindowsFirewallLogsDataSource_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForWindowsFirewallLogsDataSource_STATUS(gens map[string]gopter.Gen) {
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["ProfileFilter"] = gen.SliceOf(gen.OneConstOf(WindowsFirewallLogsDataSource_ProfileFilter_STATUS_Domain, WindowsFirewallLogsDataSource_ProfileFilter_STATUS_Private, WindowsFirewallLogsDataSource_ProfileFilter_STATUS_Public))
	gens["Streams"] = gen.SliceOf(gen.AlphaString())
}
