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

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

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

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

	return ""
}

// Generator of AutoPauseProperties instances for property testing - lazily instantiated by
// AutoPausePropertiesGenerator()
var autoPausePropertiesGenerator gopter.Gen

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

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

	return autoPausePropertiesGenerator
}

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

func Test_AutoScaleProperties_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of AutoScaleProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAutoScaleProperties, AutoScalePropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of AutoScaleProperties instances for property testing - lazily instantiated by
// AutoScalePropertiesGenerator()
var autoScalePropertiesGenerator gopter.Gen

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

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

	return autoScalePropertiesGenerator
}

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

func Test_BigDataPoolResourceProperties_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of BigDataPoolResourceProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForBigDataPoolResourceProperties, BigDataPoolResourcePropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of BigDataPoolResourceProperties instances for property testing - lazily instantiated by
// BigDataPoolResourcePropertiesGenerator()
var bigDataPoolResourcePropertiesGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForBigDataPoolResourceProperties(generators)
	AddRelatedPropertyGeneratorsForBigDataPoolResourceProperties(generators)
	bigDataPoolResourcePropertiesGenerator = gen.Struct(reflect.TypeOf(BigDataPoolResourceProperties{}), generators)

	return bigDataPoolResourcePropertiesGenerator
}

// AddIndependentPropertyGeneratorsForBigDataPoolResourceProperties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForBigDataPoolResourceProperties(gens map[string]gopter.Gen) {
	gens["CacheSize"] = gen.PtrOf(gen.Int())
	gens["DefaultSparkLogFolder"] = gen.PtrOf(gen.AlphaString())
	gens["IsAutotuneEnabled"] = gen.PtrOf(gen.Bool())
	gens["IsComputeIsolationEnabled"] = gen.PtrOf(gen.Bool())
	gens["NodeCount"] = gen.PtrOf(gen.Int())
	gens["NodeSize"] = gen.PtrOf(gen.OneConstOf(
		BigDataPoolResourceProperties_NodeSize_Large,
		BigDataPoolResourceProperties_NodeSize_Medium,
		BigDataPoolResourceProperties_NodeSize_None,
		BigDataPoolResourceProperties_NodeSize_Small,
		BigDataPoolResourceProperties_NodeSize_XLarge,
		BigDataPoolResourceProperties_NodeSize_XXLarge,
		BigDataPoolResourceProperties_NodeSize_XXXLarge))
	gens["NodeSizeFamily"] = gen.PtrOf(gen.OneConstOf(
		BigDataPoolResourceProperties_NodeSizeFamily_HardwareAcceleratedFPGA,
		BigDataPoolResourceProperties_NodeSizeFamily_HardwareAcceleratedGPU,
		BigDataPoolResourceProperties_NodeSizeFamily_MemoryOptimized,
		BigDataPoolResourceProperties_NodeSizeFamily_None))
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["SessionLevelPackagesEnabled"] = gen.PtrOf(gen.Bool())
	gens["SparkEventsFolder"] = gen.PtrOf(gen.AlphaString())
	gens["SparkVersion"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForBigDataPoolResourceProperties is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForBigDataPoolResourceProperties(gens map[string]gopter.Gen) {
	gens["AutoPause"] = gen.PtrOf(AutoPausePropertiesGenerator())
	gens["AutoScale"] = gen.PtrOf(AutoScalePropertiesGenerator())
	gens["CustomLibraries"] = gen.SliceOf(LibraryInfoGenerator())
	gens["DynamicExecutorAllocation"] = gen.PtrOf(DynamicExecutorAllocationGenerator())
	gens["LibraryRequirements"] = gen.PtrOf(LibraryRequirementsGenerator())
	gens["SparkConfigProperties"] = gen.PtrOf(SparkConfigPropertiesGenerator())
}

func Test_DynamicExecutorAllocation_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of DynamicExecutorAllocation via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDynamicExecutorAllocation, DynamicExecutorAllocationGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of DynamicExecutorAllocation instances for property testing - lazily instantiated by
// DynamicExecutorAllocationGenerator()
var dynamicExecutorAllocationGenerator gopter.Gen

// DynamicExecutorAllocationGenerator returns a generator of DynamicExecutorAllocation instances for property testing.
func DynamicExecutorAllocationGenerator() gopter.Gen {
	if dynamicExecutorAllocationGenerator != nil {
		return dynamicExecutorAllocationGenerator
	}

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

	return dynamicExecutorAllocationGenerator
}

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

func Test_LibraryInfo_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of LibraryInfo via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForLibraryInfo, LibraryInfoGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of LibraryInfo instances for property testing - lazily instantiated by LibraryInfoGenerator()
var libraryInfoGenerator gopter.Gen

// LibraryInfoGenerator returns a generator of LibraryInfo instances for property testing.
func LibraryInfoGenerator() gopter.Gen {
	if libraryInfoGenerator != nil {
		return libraryInfoGenerator
	}

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

	return libraryInfoGenerator
}

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

func Test_LibraryRequirements_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of LibraryRequirements via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForLibraryRequirements, LibraryRequirementsGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of LibraryRequirements instances for property testing - lazily instantiated by
// LibraryRequirementsGenerator()
var libraryRequirementsGenerator gopter.Gen

// LibraryRequirementsGenerator returns a generator of LibraryRequirements instances for property testing.
func LibraryRequirementsGenerator() gopter.Gen {
	if libraryRequirementsGenerator != nil {
		return libraryRequirementsGenerator
	}

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

	return libraryRequirementsGenerator
}

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

func Test_SparkConfigProperties_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 100
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of SparkConfigProperties via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSparkConfigProperties, SparkConfigPropertiesGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

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

	return ""
}

// Generator of SparkConfigProperties instances for property testing - lazily instantiated by
// SparkConfigPropertiesGenerator()
var sparkConfigPropertiesGenerator gopter.Gen

// SparkConfigPropertiesGenerator returns a generator of SparkConfigProperties instances for property testing.
func SparkConfigPropertiesGenerator() gopter.Gen {
	if sparkConfigPropertiesGenerator != nil {
		return sparkConfigPropertiesGenerator
	}

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

	return sparkConfigPropertiesGenerator
}

// AddIndependentPropertyGeneratorsForSparkConfigProperties is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSparkConfigProperties(gens map[string]gopter.Gen) {
	gens["ConfigurationType"] = gen.PtrOf(gen.OneConstOf(SparkConfigProperties_ConfigurationType_Artifact, SparkConfigProperties_ConfigurationType_File))
	gens["Content"] = gen.PtrOf(gen.AlphaString())
	gens["Filename"] = gen.PtrOf(gen.AlphaString())
}

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

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

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

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

	return ""
}

// Generator of WorkspacesBigDataPool_Spec instances for property testing - lazily instantiated by
// WorkspacesBigDataPool_SpecGenerator()
var workspacesBigDataPool_SpecGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForWorkspacesBigDataPool_Spec(generators)
	AddRelatedPropertyGeneratorsForWorkspacesBigDataPool_Spec(generators)
	workspacesBigDataPool_SpecGenerator = gen.Struct(reflect.TypeOf(WorkspacesBigDataPool_Spec{}), generators)

	return workspacesBigDataPool_SpecGenerator
}

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

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