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

import (
	"encoding/json"
	v20200601s "github.com/Azure/azure-service-operator/v2/api/network/v1api20200601/storage"
	v20240601s "github.com/Azure/azure-service-operator/v2/api/network/v1api20240601/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 v20200601s.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 v20200601s.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 v20200601s.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 v20200601s.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_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 v20200601s.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 v20200601s.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_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 v20200601s.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 v20200601s.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_PrivateDnsZonesAAAARecord_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 PrivateDnsZonesAAAARecord to hub returns original",
		prop.ForAll(RunResourceConversionTestForPrivateDnsZonesAAAARecord, PrivateDnsZonesAAAARecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

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

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

	// Convert from our hub version
	var actual PrivateDnsZonesAAAARecord
	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_PrivateDnsZonesAAAARecord_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from PrivateDnsZonesAAAARecord to PrivateDnsZonesAAAARecord via AssignProperties_To_PrivateDnsZonesAAAARecord & AssignProperties_From_PrivateDnsZonesAAAARecord returns original",
		prop.ForAll(RunPropertyAssignmentTestForPrivateDnsZonesAAAARecord, PrivateDnsZonesAAAARecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

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

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

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual PrivateDnsZonesAAAARecord
	err = actual.AssignProperties_From_PrivateDnsZonesAAAARecord(&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_PrivateDnsZonesAAAARecord_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 PrivateDnsZonesAAAARecord via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrivateDnsZonesAAAARecord, PrivateDnsZonesAAAARecordGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// PrivateDnsZonesAAAARecordGenerator returns a generator of PrivateDnsZonesAAAARecord instances for property testing.
func PrivateDnsZonesAAAARecordGenerator() gopter.Gen {
	if privateDnsZonesAAAARecordGenerator != nil {
		return privateDnsZonesAAAARecordGenerator
	}

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

	return privateDnsZonesAAAARecordGenerator
}

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

func Test_PrivateDnsZonesAAAARecordOperatorSpec_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from PrivateDnsZonesAAAARecordOperatorSpec to PrivateDnsZonesAAAARecordOperatorSpec via AssignProperties_To_PrivateDnsZonesAAAARecordOperatorSpec & AssignProperties_From_PrivateDnsZonesAAAARecordOperatorSpec returns original",
		prop.ForAll(RunPropertyAssignmentTestForPrivateDnsZonesAAAARecordOperatorSpec, PrivateDnsZonesAAAARecordOperatorSpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

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

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

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual PrivateDnsZonesAAAARecordOperatorSpec
	err = actual.AssignProperties_From_PrivateDnsZonesAAAARecordOperatorSpec(&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_PrivateDnsZonesAAAARecordOperatorSpec_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 PrivateDnsZonesAAAARecordOperatorSpec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrivateDnsZonesAAAARecordOperatorSpec, PrivateDnsZonesAAAARecordOperatorSpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

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

// PrivateDnsZonesAAAARecordOperatorSpecGenerator returns a generator of PrivateDnsZonesAAAARecordOperatorSpec instances for property testing.
func PrivateDnsZonesAAAARecordOperatorSpecGenerator() gopter.Gen {
	if privateDnsZonesAAAARecordOperatorSpecGenerator != nil {
		return privateDnsZonesAAAARecordOperatorSpecGenerator
	}

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

	return privateDnsZonesAAAARecordOperatorSpecGenerator
}

func Test_PrivateDnsZonesAAAARecord_STATUS_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from PrivateDnsZonesAAAARecord_STATUS to PrivateDnsZonesAAAARecord_STATUS via AssignProperties_To_PrivateDnsZonesAAAARecord_STATUS & AssignProperties_From_PrivateDnsZonesAAAARecord_STATUS returns original",
		prop.ForAll(RunPropertyAssignmentTestForPrivateDnsZonesAAAARecord_STATUS, PrivateDnsZonesAAAARecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForPrivateDnsZonesAAAARecord_STATUS tests if a specific instance of PrivateDnsZonesAAAARecord_STATUS can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForPrivateDnsZonesAAAARecord_STATUS(subject PrivateDnsZonesAAAARecord_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 v20200601s.PrivateDnsZonesAAAARecord_STATUS
	err := copied.AssignProperties_To_PrivateDnsZonesAAAARecord_STATUS(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual PrivateDnsZonesAAAARecord_STATUS
	err = actual.AssignProperties_From_PrivateDnsZonesAAAARecord_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_PrivateDnsZonesAAAARecord_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 PrivateDnsZonesAAAARecord_STATUS via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrivateDnsZonesAAAARecord_STATUS, PrivateDnsZonesAAAARecord_STATUSGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PrivateDnsZonesAAAARecord_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 PrivateDnsZonesAAAARecord_STATUS instances for property testing - lazily instantiated by
// PrivateDnsZonesAAAARecord_STATUSGenerator()
var privateDnsZonesAAAARecord_STATUSGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForPrivateDnsZonesAAAARecord_STATUS(generators)
	AddRelatedPropertyGeneratorsForPrivateDnsZonesAAAARecord_STATUS(generators)
	privateDnsZonesAAAARecord_STATUSGenerator = gen.Struct(reflect.TypeOf(PrivateDnsZonesAAAARecord_STATUS{}), generators)

	return privateDnsZonesAAAARecord_STATUSGenerator
}

// AddIndependentPropertyGeneratorsForPrivateDnsZonesAAAARecord_STATUS is a factory method for creating gopter generators
func AddIndependentPropertyGeneratorsForPrivateDnsZonesAAAARecord_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["IsAutoRegistered"] = gen.PtrOf(gen.Bool())
	gens["Metadata"] = gen.MapOf(
		gen.AlphaString(),
		gen.AlphaString())
	gens["Name"] = gen.PtrOf(gen.AlphaString())
	gens["Ttl"] = gen.PtrOf(gen.Int())
	gens["Type"] = gen.PtrOf(gen.AlphaString())
}

// AddRelatedPropertyGeneratorsForPrivateDnsZonesAAAARecord_STATUS is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForPrivateDnsZonesAAAARecord_STATUS(gens map[string]gopter.Gen) {
	gens["ARecords"] = gen.SliceOf(ARecord_STATUSGenerator())
	gens["AaaaRecords"] = gen.SliceOf(AaaaRecord_STATUSGenerator())
	gens["CnameRecord"] = gen.PtrOf(CnameRecord_STATUSGenerator())
	gens["MxRecords"] = gen.SliceOf(MxRecord_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())
}

func Test_PrivateDnsZonesAAAARecord_Spec_WhenPropertiesConverted_RoundTripsWithoutLoss(t *testing.T) {
	t.Parallel()
	parameters := gopter.DefaultTestParameters()
	parameters.MaxSize = 10
	properties := gopter.NewProperties(parameters)
	properties.Property(
		"Round trip from PrivateDnsZonesAAAARecord_Spec to PrivateDnsZonesAAAARecord_Spec via AssignProperties_To_PrivateDnsZonesAAAARecord_Spec & AssignProperties_From_PrivateDnsZonesAAAARecord_Spec returns original",
		prop.ForAll(RunPropertyAssignmentTestForPrivateDnsZonesAAAARecord_Spec, PrivateDnsZonesAAAARecord_SpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(false, 240, os.Stdout))
}

// RunPropertyAssignmentTestForPrivateDnsZonesAAAARecord_Spec tests if a specific instance of PrivateDnsZonesAAAARecord_Spec can be assigned to storage and back losslessly
func RunPropertyAssignmentTestForPrivateDnsZonesAAAARecord_Spec(subject PrivateDnsZonesAAAARecord_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 v20200601s.PrivateDnsZonesAAAARecord_Spec
	err := copied.AssignProperties_To_PrivateDnsZonesAAAARecord_Spec(&other)
	if err != nil {
		return err.Error()
	}

	// Use AssignPropertiesFrom() to convert back to our original type
	var actual PrivateDnsZonesAAAARecord_Spec
	err = actual.AssignProperties_From_PrivateDnsZonesAAAARecord_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_PrivateDnsZonesAAAARecord_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 PrivateDnsZonesAAAARecord_Spec via JSON returns original",
		prop.ForAll(RunJSONSerializationTestForPrivateDnsZonesAAAARecord_Spec, PrivateDnsZonesAAAARecord_SpecGenerator()))
	properties.TestingRun(t, gopter.NewFormatedReporter(true, 240, os.Stdout))
}

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

	// Deserialize back into memory
	var actual PrivateDnsZonesAAAARecord_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 PrivateDnsZonesAAAARecord_Spec instances for property testing - lazily instantiated by
// PrivateDnsZonesAAAARecord_SpecGenerator()
var privateDnsZonesAAAARecord_SpecGenerator gopter.Gen

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

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

	// The above call to gen.Struct() captures the map, so create a new one
	generators = make(map[string]gopter.Gen)
	AddIndependentPropertyGeneratorsForPrivateDnsZonesAAAARecord_Spec(generators)
	AddRelatedPropertyGeneratorsForPrivateDnsZonesAAAARecord_Spec(generators)
	privateDnsZonesAAAARecord_SpecGenerator = gen.Struct(reflect.TypeOf(PrivateDnsZonesAAAARecord_Spec{}), generators)

	return privateDnsZonesAAAARecord_SpecGenerator
}

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

// AddRelatedPropertyGeneratorsForPrivateDnsZonesAAAARecord_Spec is a factory method for creating gopter generators
func AddRelatedPropertyGeneratorsForPrivateDnsZonesAAAARecord_Spec(gens map[string]gopter.Gen) {
	gens["ARecords"] = gen.SliceOf(ARecordGenerator())
	gens["AaaaRecords"] = gen.SliceOf(AaaaRecordGenerator())
	gens["CnameRecord"] = gen.PtrOf(CnameRecordGenerator())
	gens["MxRecords"] = gen.SliceOf(MxRecordGenerator())
	gens["OperatorSpec"] = gen.PtrOf(PrivateDnsZonesAAAARecordOperatorSpecGenerator())
	gens["PtrRecords"] = gen.SliceOf(PtrRecordGenerator())
	gens["SoaRecord"] = gen.PtrOf(SoaRecordGenerator())
	gens["SrvRecords"] = gen.SliceOf(SrvRecordGenerator())
	gens["TxtRecords"] = gen.SliceOf(TxtRecordGenerator())
}

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 v20200601s.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 v20200601s.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 v20200601s.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 v20200601s.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 v20200601s.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 v20200601s.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 v20200601s.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 v20200601s.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())
}
