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

import (
	"encoding/json"
	storage "github.com/Azure/azure-service-operator/v2/api/network/v1api20180501/storage"
	"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_ARecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from ARecord to ARecord via AssignProperties_To_ARecord & AssignProperties_From_ARecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForARecord, ARecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForARecord tests if a specific instance of ARecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForARecord(subject ARecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.ARecord
	err := copied.AssignProperties_To_ARecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual ARecord
	err = actual.AssignProperties_From_ARecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_ARecord_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 ARecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForARecord, ARecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// ARecordGenerator returns a generator of ARecord instances for property testing.
func ARecordGenerator() gopter.Gen {
	if aRecordGenerator != nil {
		return aRecordGenerator
	}

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

	return aRecordGenerator
}

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

func Test_ARecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from ARecord_STATUS to ARecord_STATUS via AssignProperties_To_ARecord_STATUS & AssignProperties_From_ARecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForARecord_STATUS, ARecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForARecord_STATUS tests if a specific instance of ARecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForARecord_STATUS(subject ARecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.ARecord_STATUS
	err := copied.AssignProperties_To_ARecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual ARecord_STATUS
	err = actual.AssignProperties_From_ARecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_ARecord_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 ARecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForARecord_STATUS, ARecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual ARecord_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 ARecord_STATUS instances for property testing - lazily instantiated by ARecord_STATUSGenerator()
var aRecord_STATUSGenerator gopter.Gen

// ARecord_STATUSGenerator returns a generator of ARecord_STATUS instances for property testing.
func ARecord_STATUSGenerator() gopter.Gen {
	if aRecord_STATUSGenerator != nil {
		return aRecord_STATUSGenerator
	}

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

	return aRecord_STATUSGenerator
}

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

func Test_AaaaRecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from AaaaRecord to AaaaRecord via AssignProperties_To_AaaaRecord & AssignProperties_From_AaaaRecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForAaaaRecord, AaaaRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForAaaaRecord tests if a specific instance of AaaaRecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForAaaaRecord(subject AaaaRecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.AaaaRecord
	err := copied.AssignProperties_To_AaaaRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual AaaaRecord
	err = actual.AssignProperties_From_AaaaRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_AaaaRecord_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 AaaaRecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAaaaRecord, AaaaRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// AaaaRecordGenerator returns a generator of AaaaRecord instances for property testing.
func AaaaRecordGenerator() gopter.Gen {
	if aaaaRecordGenerator != nil {
		return aaaaRecordGenerator
	}

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

	return aaaaRecordGenerator
}

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

func Test_AaaaRecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from AaaaRecord_STATUS to AaaaRecord_STATUS via AssignProperties_To_AaaaRecord_STATUS & AssignProperties_From_AaaaRecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForAaaaRecord_STATUS, AaaaRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForAaaaRecord_STATUS tests if a specific instance of AaaaRecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForAaaaRecord_STATUS(subject AaaaRecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.AaaaRecord_STATUS
	err := copied.AssignProperties_To_AaaaRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual AaaaRecord_STATUS
	err = actual.AssignProperties_From_AaaaRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_AaaaRecord_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 AaaaRecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForAaaaRecord_STATUS, AaaaRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual AaaaRecord_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 AaaaRecord_STATUS instances for property testing - lazily instantiated by AaaaRecord_STATUSGenerator()
var aaaaRecord_STATUSGenerator gopter.Gen

// AaaaRecord_STATUSGenerator returns a generator of AaaaRecord_STATUS instances for property testing.
func AaaaRecord_STATUSGenerator() gopter.Gen {
	if aaaaRecord_STATUSGenerator != nil {
		return aaaaRecord_STATUSGenerator
	}

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

	return aaaaRecord_STATUSGenerator
}

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

func Test_CaaRecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from CaaRecord to CaaRecord via AssignProperties_To_CaaRecord & AssignProperties_From_CaaRecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForCaaRecord, CaaRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForCaaRecord tests if a specific instance of CaaRecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForCaaRecord(subject CaaRecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.CaaRecord
	err := copied.AssignProperties_To_CaaRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual CaaRecord
	err = actual.AssignProperties_From_CaaRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_CaaRecord_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 CaaRecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCaaRecord, CaaRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// CaaRecordGenerator returns a generator of CaaRecord instances for property testing.
func CaaRecordGenerator() gopter.Gen {
	if caaRecordGenerator != nil {
		return caaRecordGenerator
	}

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

	return caaRecordGenerator
}

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

func Test_CaaRecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from CaaRecord_STATUS to CaaRecord_STATUS via AssignProperties_To_CaaRecord_STATUS & AssignProperties_From_CaaRecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForCaaRecord_STATUS, CaaRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForCaaRecord_STATUS tests if a specific instance of CaaRecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForCaaRecord_STATUS(subject CaaRecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.CaaRecord_STATUS
	err := copied.AssignProperties_To_CaaRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual CaaRecord_STATUS
	err = actual.AssignProperties_From_CaaRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_CaaRecord_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 CaaRecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCaaRecord_STATUS, CaaRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CaaRecord_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 CaaRecord_STATUS instances for property testing - lazily instantiated by CaaRecord_STATUSGenerator()
var caaRecord_STATUSGenerator gopter.Gen

// CaaRecord_STATUSGenerator returns a generator of CaaRecord_STATUS instances for property testing.
func CaaRecord_STATUSGenerator() gopter.Gen {
	if caaRecord_STATUSGenerator != nil {
		return caaRecord_STATUSGenerator
	}

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

	return caaRecord_STATUSGenerator
}

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

func Test_CnameRecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from CnameRecord to CnameRecord via AssignProperties_To_CnameRecord & AssignProperties_From_CnameRecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForCnameRecord, CnameRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForCnameRecord tests if a specific instance of CnameRecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForCnameRecord(subject CnameRecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.CnameRecord
	err := copied.AssignProperties_To_CnameRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual CnameRecord
	err = actual.AssignProperties_From_CnameRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_CnameRecord_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 CnameRecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCnameRecord, CnameRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// CnameRecordGenerator returns a generator of CnameRecord instances for property testing.
func CnameRecordGenerator() gopter.Gen {
	if cnameRecordGenerator != nil {
		return cnameRecordGenerator
	}

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

	return cnameRecordGenerator
}

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

func Test_CnameRecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from CnameRecord_STATUS to CnameRecord_STATUS via AssignProperties_To_CnameRecord_STATUS & AssignProperties_From_CnameRecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForCnameRecord_STATUS, CnameRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForCnameRecord_STATUS tests if a specific instance of CnameRecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForCnameRecord_STATUS(subject CnameRecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.CnameRecord_STATUS
	err := copied.AssignProperties_To_CnameRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual CnameRecord_STATUS
	err = actual.AssignProperties_From_CnameRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_CnameRecord_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 CnameRecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForCnameRecord_STATUS, CnameRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual CnameRecord_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 CnameRecord_STATUS instances for property testing - lazily instantiated by CnameRecord_STATUSGenerator()
var cnameRecord_STATUSGenerator gopter.Gen

// CnameRecord_STATUSGenerator returns a generator of CnameRecord_STATUS instances for property testing.
func CnameRecord_STATUSGenerator() gopter.Gen {
	if cnameRecord_STATUSGenerator != nil {
		return cnameRecord_STATUSGenerator
	}

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

	return cnameRecord_STATUSGenerator
}

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

func Test_DnsZonesAAAARecord_WhenConvertedToHub_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	parameters.MinSuccessfulTests = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from DnsZonesAAAARecord to hub returns original",
		prop.ForAll(RunResourceConversionTestForDnsZonesAAAARecord, DnsZonesAAAARecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunResourceConversionTestForDnsZonesAAAARecord tests if a specific instance of DnsZonesAAAARecord round trips to the hub storage version and back losslessly
func RunResourceConversionTestForDnsZonesAAAARecord(subject DnsZonesAAAARecord) string {
	// Copy subject to make sure conversion doesn't modify it
	copied := subject.DeepCopy()

	// Convert to our hub version
	var hub storage.DnsZonesAAAARecord
	err := copied.ConvertTo(&hub)
	if err != nil {
		return err.Error()
	}

	// Convert from our hub version
	var actual DnsZonesAAAARecord
	err = actual.ConvertFrom(&hub)
	if err != nil {
		return err.Error()
	}

	// Compare actual with what we started with
	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 ""
}

func Test_DnsZonesAAAARecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from DnsZonesAAAARecord to DnsZonesAAAARecord via AssignProperties_To_DnsZonesAAAARecord & AssignProperties_From_DnsZonesAAAARecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForDnsZonesAAAARecord, DnsZonesAAAARecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForDnsZonesAAAARecord tests if a specific instance of DnsZonesAAAARecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForDnsZonesAAAARecord(subject DnsZonesAAAARecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.DnsZonesAAAARecord
	err := copied.AssignProperties_To_DnsZonesAAAARecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual DnsZonesAAAARecord
	err = actual.AssignProperties_From_DnsZonesAAAARecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_DnsZonesAAAARecord_WhenSerializedToJson_DeserializesAsEqual(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MinSuccessfulTests = 20
	parameters.MaxSize = 3
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip of DnsZonesAAAARecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDnsZonesAAAARecord, DnsZonesAAAARecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// DnsZonesAAAARecordGenerator returns a generator of DnsZonesAAAARecord instances for property testing.
func DnsZonesAAAARecordGenerator() gopter.Gen {
	if dnsZonesAAAARecordGenerator != nil {
		return dnsZonesAAAARecordGenerator
	}

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

	return dnsZonesAAAARecordGenerator
}

// AddRelatedPropertyGeneratorsForDnsZonesAAAARecord is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDnsZonesAAAARecord(gens map[string]gopter.Gen) {
	gens["Spec"] = DnsZonesAAAARecord_SpecGenerator()
	gens["Status"] = DnsZonesAAAARecord_STATUSGenerator()
}

func Test_DnsZonesAAAARecordOperatorSpec_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from DnsZonesAAAARecordOperatorSpec to DnsZonesAAAARecordOperatorSpec via AssignProperties_To_DnsZonesAAAARecordOperatorSpec & AssignProperties_From_DnsZonesAAAARecordOperatorSpec returns original",
		prop.ForAll(RunPropertyAssignmentTestForDnsZonesAAAARecordOperatorSpec, DnsZonesAAAARecordOperatorSpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForDnsZonesAAAARecordOperatorSpec tests if a specific instance of DnsZonesAAAARecordOperatorSpec can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForDnsZonesAAAARecordOperatorSpec(subject DnsZonesAAAARecordOperatorSpec) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.DnsZonesAAAARecordOperatorSpec
	err := copied.AssignProperties_To_DnsZonesAAAARecordOperatorSpec(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual DnsZonesAAAARecordOperatorSpec
	err = actual.AssignProperties_From_DnsZonesAAAARecordOperatorSpec(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_DnsZonesAAAARecordOperatorSpec_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 DnsZonesAAAARecordOperatorSpec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDnsZonesAAAARecordOperatorSpec, DnsZonesAAAARecordOperatorSpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// DnsZonesAAAARecordOperatorSpecGenerator returns a generator of DnsZonesAAAARecordOperatorSpec instances for property testing.
func DnsZonesAAAARecordOperatorSpecGenerator() gopter.Gen {
	if dnsZonesAAAARecordOperatorSpecGenerator != nil {
		return dnsZonesAAAARecordOperatorSpecGenerator
	}

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

	return dnsZonesAAAARecordOperatorSpecGenerator
}

func Test_DnsZonesAAAARecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from DnsZonesAAAARecord_STATUS to DnsZonesAAAARecord_STATUS via AssignProperties_To_DnsZonesAAAARecord_STATUS & AssignProperties_From_DnsZonesAAAARecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForDnsZonesAAAARecord_STATUS, DnsZonesAAAARecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForDnsZonesAAAARecord_STATUS tests if a specific instance of DnsZonesAAAARecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForDnsZonesAAAARecord_STATUS(subject DnsZonesAAAARecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.DnsZonesAAAARecord_STATUS
	err := copied.AssignProperties_To_DnsZonesAAAARecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual DnsZonesAAAARecord_STATUS
	err = actual.AssignProperties_From_DnsZonesAAAARecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_DnsZonesAAAARecord_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 DnsZonesAAAARecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDnsZonesAAAARecord_STATUS, DnsZonesAAAARecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DnsZonesAAAARecord_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 DnsZonesAAAARecord_STATUS instances for property testing - lazily instantiated by
// DnsZonesAAAARecord_STATUSGenerator()
var dnsZonesAAAARecord_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForDnsZonesAAAARecord_STATUS(generators)
	AddRelatedPropertyGeneratorsForDnsZonesAAAARecord_STATUS(generators)
	dnsZonesAAAARecord_STATUSGenerator = gen.Struct(reflect.TypeOf(DnsZonesAAAARecord_STATUS{}), generators)

	return dnsZonesAAAARecord_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForDnsZonesAAAARecord_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDnsZonesAAAARecord_STATUS(gens map[string]gopter.Gen) {
	gens["Etag"] = gen.PtrOf(gen.AlphaString())
	gens["Fqdn"] = gen.PtrOf(gen.AlphaString())
	gens["Id"] = gen.PtrOf(gen.AlphaString())
	gens["Metadata"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["ProvisioningState"] = gen.PtrOf(gen.AlphaString())
	gens["TTL"] = gen.PtrOf(gen.Int())
	gens["Type"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForDnsZonesAAAARecord_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDnsZonesAAAARecord_STATUS(gens map[string]gopter.Gen) {
	gens["AAAARecords"] = gen.SliceOf(AaaaRecord_STATUSGenerator())
	gens["ARecords"] = gen.SliceOf(ARecord_STATUSGenerator())
	gens["CNAMERecord"] = gen.PtrOf(CnameRecord_STATUSGenerator())
	gens["CaaRecords"] = gen.SliceOf(CaaRecord_STATUSGenerator())
	gens["MXRecords"] = gen.SliceOf(MxRecord_STATUSGenerator())
	gens["NSRecords"] = gen.SliceOf(NsRecord_STATUSGenerator())
	gens["PTRRecords"] = gen.SliceOf(PtrRecord_STATUSGenerator())
	gens["SOARecord"] = gen.PtrOf(SoaRecord_STATUSGenerator())
	gens["SRVRecords"] = gen.SliceOf(SrvRecord_STATUSGenerator())
	gens["TXTRecords"] = gen.SliceOf(TxtRecord_STATUSGenerator())
	gens["TargetResource"] = gen.PtrOf(SubResource_STATUSGenerator())
}

func Test_DnsZonesAAAARecord_Spec_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from DnsZonesAAAARecord_Spec to DnsZonesAAAARecord_Spec via AssignProperties_To_DnsZonesAAAARecord_Spec & AssignProperties_From_DnsZonesAAAARecord_Spec returns original",
		prop.ForAll(RunPropertyAssignmentTestForDnsZonesAAAARecord_Spec, DnsZonesAAAARecord_SpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForDnsZonesAAAARecord_Spec tests if a specific instance of DnsZonesAAAARecord_Spec can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForDnsZonesAAAARecord_Spec(subject DnsZonesAAAARecord_Spec) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.DnsZonesAAAARecord_Spec
	err := copied.AssignProperties_To_DnsZonesAAAARecord_Spec(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual DnsZonesAAAARecord_Spec
	err = actual.AssignProperties_From_DnsZonesAAAARecord_Spec(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_DnsZonesAAAARecord_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 DnsZonesAAAARecord_Spec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForDnsZonesAAAARecord_Spec, DnsZonesAAAARecord_SpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual DnsZonesAAAARecord_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 DnsZonesAAAARecord_Spec instances for property testing - lazily instantiated by
// DnsZonesAAAARecord_SpecGenerator()
var dnsZonesAAAARecord_SpecGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForDnsZonesAAAARecord_Spec(generators)
	AddRelatedPropertyGeneratorsForDnsZonesAAAARecord_Spec(generators)
	dnsZonesAAAARecord_SpecGenerator = gen.Struct(reflect.TypeOf(DnsZonesAAAARecord_Spec{}), generators)

	return dnsZonesAAAARecord_SpecGenerator
}

// AddIndependentPropertyGeneratorsForDnsZonesAAAARecord_Spec is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForDnsZonesAAAARecord_Spec(gens map[string]gopter.Gen) {
	gens["AzureName"] = gen.AlphaString()
	gens["Metadata"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["TTL"] = gen.PtrOf(gen.Int())
}

// AddRelatedPropertyGeneratorsForDnsZonesAAAARecord_Spec is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForDnsZonesAAAARecord_Spec(gens map[string]gopter.Gen) {
	gens["AAAARecords"] = gen.SliceOf(AaaaRecordGenerator())
	gens["ARecords"] = gen.SliceOf(ARecordGenerator())
	gens["CNAMERecord"] = gen.PtrOf(CnameRecordGenerator())
	gens["CaaRecords"] = gen.SliceOf(CaaRecordGenerator())
	gens["MXRecords"] = gen.SliceOf(MxRecordGenerator())
	gens["NSRecords"] = gen.SliceOf(NsRecordGenerator())
	gens["OperatorSpec"] = gen.PtrOf(DnsZonesAAAARecordOperatorSpecGenerator())
	gens["PTRRecords"] = gen.SliceOf(PtrRecordGenerator())
	gens["SOARecord"] = gen.PtrOf(SoaRecordGenerator())
	gens["SRVRecords"] = gen.SliceOf(SrvRecordGenerator())
	gens["TXTRecords"] = gen.SliceOf(TxtRecordGenerator())
	gens["TargetResource"] = gen.PtrOf(SubResourceGenerator())
}

func Test_MxRecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from MxRecord to MxRecord via AssignProperties_To_MxRecord & AssignProperties_From_MxRecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForMxRecord, MxRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForMxRecord tests if a specific instance of MxRecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForMxRecord(subject MxRecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.MxRecord
	err := copied.AssignProperties_To_MxRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual MxRecord
	err = actual.AssignProperties_From_MxRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_MxRecord_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 MxRecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForMxRecord, MxRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// MxRecordGenerator returns a generator of MxRecord instances for property testing.
func MxRecordGenerator() gopter.Gen {
	if mxRecordGenerator != nil {
		return mxRecordGenerator
	}

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

	return mxRecordGenerator
}

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

func Test_MxRecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from MxRecord_STATUS to MxRecord_STATUS via AssignProperties_To_MxRecord_STATUS & AssignProperties_From_MxRecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForMxRecord_STATUS, MxRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForMxRecord_STATUS tests if a specific instance of MxRecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForMxRecord_STATUS(subject MxRecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.MxRecord_STATUS
	err := copied.AssignProperties_To_MxRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual MxRecord_STATUS
	err = actual.AssignProperties_From_MxRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_MxRecord_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 MxRecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForMxRecord_STATUS, MxRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual MxRecord_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 MxRecord_STATUS instances for property testing - lazily instantiated by MxRecord_STATUSGenerator()
var mxRecord_STATUSGenerator gopter.Gen

// MxRecord_STATUSGenerator returns a generator of MxRecord_STATUS instances for property testing.
func MxRecord_STATUSGenerator() gopter.Gen {
	if mxRecord_STATUSGenerator != nil {
		return mxRecord_STATUSGenerator
	}

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

	return mxRecord_STATUSGenerator
}

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

func Test_NsRecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from NsRecord to NsRecord via AssignProperties_To_NsRecord & AssignProperties_From_NsRecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForNsRecord, NsRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForNsRecord tests if a specific instance of NsRecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForNsRecord(subject NsRecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.NsRecord
	err := copied.AssignProperties_To_NsRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual NsRecord
	err = actual.AssignProperties_From_NsRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_NsRecord_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 NsRecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNsRecord, NsRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// NsRecordGenerator returns a generator of NsRecord instances for property testing.
func NsRecordGenerator() gopter.Gen {
	if nsRecordGenerator != nil {
		return nsRecordGenerator
	}

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

	return nsRecordGenerator
}

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

func Test_NsRecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from NsRecord_STATUS to NsRecord_STATUS via AssignProperties_To_NsRecord_STATUS & AssignProperties_From_NsRecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForNsRecord_STATUS, NsRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForNsRecord_STATUS tests if a specific instance of NsRecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForNsRecord_STATUS(subject NsRecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.NsRecord_STATUS
	err := copied.AssignProperties_To_NsRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual NsRecord_STATUS
	err = actual.AssignProperties_From_NsRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_NsRecord_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 NsRecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForNsRecord_STATUS, NsRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual NsRecord_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 NsRecord_STATUS instances for property testing - lazily instantiated by NsRecord_STATUSGenerator()
var nsRecord_STATUSGenerator gopter.Gen

// NsRecord_STATUSGenerator returns a generator of NsRecord_STATUS instances for property testing.
func NsRecord_STATUSGenerator() gopter.Gen {
	if nsRecord_STATUSGenerator != nil {
		return nsRecord_STATUSGenerator
	}

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

	return nsRecord_STATUSGenerator
}

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

func Test_PtrRecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from PtrRecord to PtrRecord via AssignProperties_To_PtrRecord & AssignProperties_From_PtrRecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForPtrRecord, PtrRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForPtrRecord tests if a specific instance of PtrRecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForPtrRecord(subject PtrRecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.PtrRecord
	err := copied.AssignProperties_To_PtrRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual PtrRecord
	err = actual.AssignProperties_From_PtrRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_PtrRecord_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 PtrRecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPtrRecord, PtrRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// PtrRecordGenerator returns a generator of PtrRecord instances for property testing.
func PtrRecordGenerator() gopter.Gen {
	if ptrRecordGenerator != nil {
		return ptrRecordGenerator
	}

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

	return ptrRecordGenerator
}

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

func Test_PtrRecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from PtrRecord_STATUS to PtrRecord_STATUS via AssignProperties_To_PtrRecord_STATUS & AssignProperties_From_PtrRecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForPtrRecord_STATUS, PtrRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForPtrRecord_STATUS tests if a specific instance of PtrRecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForPtrRecord_STATUS(subject PtrRecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.PtrRecord_STATUS
	err := copied.AssignProperties_To_PtrRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual PtrRecord_STATUS
	err = actual.AssignProperties_From_PtrRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_PtrRecord_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 PtrRecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPtrRecord_STATUS, PtrRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PtrRecord_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 PtrRecord_STATUS instances for property testing - lazily instantiated by PtrRecord_STATUSGenerator()
var ptrRecord_STATUSGenerator gopter.Gen

// PtrRecord_STATUSGenerator returns a generator of PtrRecord_STATUS instances for property testing.
func PtrRecord_STATUSGenerator() gopter.Gen {
	if ptrRecord_STATUSGenerator != nil {
		return ptrRecord_STATUSGenerator
	}

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

	return ptrRecord_STATUSGenerator
}

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

func Test_SoaRecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SoaRecord to SoaRecord via AssignProperties_To_SoaRecord & AssignProperties_From_SoaRecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForSoaRecord, SoaRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSoaRecord tests if a specific instance of SoaRecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSoaRecord(subject SoaRecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.SoaRecord
	err := copied.AssignProperties_To_SoaRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SoaRecord
	err = actual.AssignProperties_From_SoaRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_SoaRecord_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 SoaRecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSoaRecord, SoaRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// SoaRecordGenerator returns a generator of SoaRecord instances for property testing.
func SoaRecordGenerator() gopter.Gen {
	if soaRecordGenerator != nil {
		return soaRecordGenerator
	}

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

	return soaRecordGenerator
}

// AddIndependentPropertyGeneratorsForSoaRecord is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSoaRecord(gens map[string]gopter.Gen) {
	gens["Email"] = gen.PtrOf(gen.AlphaString())
	gens["ExpireTime"] = gen.PtrOf(gen.Int())
	gens["Host"] = gen.PtrOf(gen.AlphaString())
	gens["MinimumTTL"] = gen.PtrOf(gen.Int())
	gens["RefreshTime"] = gen.PtrOf(gen.Int())
	gens["RetryTime"] = gen.PtrOf(gen.Int())
	gens["SerialNumber"] = gen.PtrOf(gen.Int())
}

func Test_SoaRecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SoaRecord_STATUS to SoaRecord_STATUS via AssignProperties_To_SoaRecord_STATUS & AssignProperties_From_SoaRecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForSoaRecord_STATUS, SoaRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSoaRecord_STATUS tests if a specific instance of SoaRecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSoaRecord_STATUS(subject SoaRecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.SoaRecord_STATUS
	err := copied.AssignProperties_To_SoaRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SoaRecord_STATUS
	err = actual.AssignProperties_From_SoaRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_SoaRecord_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 SoaRecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSoaRecord_STATUS, SoaRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SoaRecord_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 SoaRecord_STATUS instances for property testing - lazily instantiated by SoaRecord_STATUSGenerator()
var soaRecord_STATUSGenerator gopter.Gen

// SoaRecord_STATUSGenerator returns a generator of SoaRecord_STATUS instances for property testing.
func SoaRecord_STATUSGenerator() gopter.Gen {
	if soaRecord_STATUSGenerator != nil {
		return soaRecord_STATUSGenerator
	}

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

	return soaRecord_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSoaRecord_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSoaRecord_STATUS(gens map[string]gopter.Gen) {
	gens["Email"] = gen.PtrOf(gen.AlphaString())
	gens["ExpireTime"] = gen.PtrOf(gen.Int())
	gens["Host"] = gen.PtrOf(gen.AlphaString())
	gens["MinimumTTL"] = gen.PtrOf(gen.Int())
	gens["RefreshTime"] = gen.PtrOf(gen.Int())
	gens["RetryTime"] = gen.PtrOf(gen.Int())
	gens["SerialNumber"] = gen.PtrOf(gen.Int())
}

func Test_SrvRecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SrvRecord to SrvRecord via AssignProperties_To_SrvRecord & AssignProperties_From_SrvRecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForSrvRecord, SrvRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSrvRecord tests if a specific instance of SrvRecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSrvRecord(subject SrvRecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.SrvRecord
	err := copied.AssignProperties_To_SrvRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SrvRecord
	err = actual.AssignProperties_From_SrvRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_SrvRecord_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 SrvRecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSrvRecord, SrvRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// SrvRecordGenerator returns a generator of SrvRecord instances for property testing.
func SrvRecordGenerator() gopter.Gen {
	if srvRecordGenerator != nil {
		return srvRecordGenerator
	}

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

	return srvRecordGenerator
}

// AddIndependentPropertyGeneratorsForSrvRecord is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSrvRecord(gens map[string]gopter.Gen) {
	gens["Port"] = gen.PtrOf(gen.Int())
	gens["Priority"] = gen.PtrOf(gen.Int())
	gens["Target"] = gen.PtrOf(gen.AlphaString())
	gens["Weight"] = gen.PtrOf(gen.Int())
}

func Test_SrvRecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from SrvRecord_STATUS to SrvRecord_STATUS via AssignProperties_To_SrvRecord_STATUS & AssignProperties_From_SrvRecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForSrvRecord_STATUS, SrvRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForSrvRecord_STATUS tests if a specific instance of SrvRecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForSrvRecord_STATUS(subject SrvRecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.SrvRecord_STATUS
	err := copied.AssignProperties_To_SrvRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual SrvRecord_STATUS
	err = actual.AssignProperties_From_SrvRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_SrvRecord_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 SrvRecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForSrvRecord_STATUS, SrvRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual SrvRecord_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 SrvRecord_STATUS instances for property testing - lazily instantiated by SrvRecord_STATUSGenerator()
var srvRecord_STATUSGenerator gopter.Gen

// SrvRecord_STATUSGenerator returns a generator of SrvRecord_STATUS instances for property testing.
func SrvRecord_STATUSGenerator() gopter.Gen {
	if srvRecord_STATUSGenerator != nil {
		return srvRecord_STATUSGenerator
	}

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

	return srvRecord_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForSrvRecord_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForSrvRecord_STATUS(gens map[string]gopter.Gen) {
	gens["Port"] = gen.PtrOf(gen.Int())
	gens["Priority"] = gen.PtrOf(gen.Int())
	gens["Target"] = gen.PtrOf(gen.AlphaString())
	gens["Weight"] = gen.PtrOf(gen.Int())
}

func Test_TxtRecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from TxtRecord to TxtRecord via AssignProperties_To_TxtRecord & AssignProperties_From_TxtRecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForTxtRecord, TxtRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForTxtRecord tests if a specific instance of TxtRecord can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForTxtRecord(subject TxtRecord) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.TxtRecord
	err := copied.AssignProperties_To_TxtRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual TxtRecord
	err = actual.AssignProperties_From_TxtRecord(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_TxtRecord_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 TxtRecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTxtRecord, TxtRecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// TxtRecordGenerator returns a generator of TxtRecord instances for property testing.
func TxtRecordGenerator() gopter.Gen {
	if txtRecordGenerator != nil {
		return txtRecordGenerator
	}

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

	return txtRecordGenerator
}

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

func Test_TxtRecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from TxtRecord_STATUS to TxtRecord_STATUS via AssignProperties_To_TxtRecord_STATUS & AssignProperties_From_TxtRecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForTxtRecord_STATUS, TxtRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForTxtRecord_STATUS tests if a specific instance of TxtRecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForTxtRecord_STATUS(subject TxtRecord_STATUS) string {
	// Copy subject to make sure assignment doesn't modify it
	copied := subject.DeepCopy()

	// Use AssignPropertiesTo() for the first stage of conversion
	var other storage.TxtRecord_STATUS
	err := copied.AssignProperties_To_TxtRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual TxtRecord_STATUS
	err = actual.AssignProperties_From_TxtRecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Check for a match
	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 ""
}

func Test_TxtRecord_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 TxtRecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForTxtRecord_STATUS, TxtRecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual TxtRecord_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 TxtRecord_STATUS instances for property testing - lazily instantiated by TxtRecord_STATUSGenerator()
var txtRecord_STATUSGenerator gopter.Gen

// TxtRecord_STATUSGenerator returns a generator of TxtRecord_STATUS instances for property testing.
func TxtRecord_STATUSGenerator() gopter.Gen {
	if txtRecord_STATUSGenerator != nil {
		return txtRecord_STATUSGenerator
	}

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

	return txtRecord_STATUSGenerator
}

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