backcompat_test.go

// Code generated by Fern. DO NOT EDIT.

package generatorexec

import (
	json "encoding/json"
	assert "github.com/stretchr/testify/assert"
	require "github.com/stretchr/testify/require"
	testing "testing"
)

func TestSettersBackwardsCompatGeneratorPublishConfig(t *testing.T) {
	t.Run("SetRegistries", func(t *testing.T) {
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var fernTestValueRegistries *GeneratorRegistriesConfig
		obj.SetRegistries(fernTestValueRegistries)
		assert.Equal(t, fernTestValueRegistries, obj.Registries)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetRegistriesV2", func(t *testing.T) {
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var fernTestValueRegistriesV2 *BackwardsCompatibleRegistriesConfigV2
		obj.SetRegistriesV2(fernTestValueRegistriesV2)
		assert.Equal(t, fernTestValueRegistriesV2, obj.RegistriesV2)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPublishTarget", func(t *testing.T) {
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var fernTestValuePublishTarget *BackwardsCompatiblePublishTarget
		obj.SetPublishTarget(fernTestValuePublishTarget)
		assert.Equal(t, fernTestValuePublishTarget, obj.PublishTarget)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetVersion", func(t *testing.T) {
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var fernTestValueVersion string
		obj.SetVersion(fernTestValueVersion)
		assert.Equal(t, fernTestValueVersion, obj.Version)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersBackwardsCompatGeneratorPublishConfig(t *testing.T) {
	t.Run("GetRegistries", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var expected *GeneratorRegistriesConfig
		obj.Registries = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetRegistries(), "getter should return the property value")
	})

	t.Run("GetRegistries_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		obj.Registries = nil

		// Act & Assert
		assert.Nil(t, obj.GetRegistries(), "getter should return nil when property is nil")
	})

	t.Run("GetRegistries_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatGeneratorPublishConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetRegistries() // Should return zero value
	})

	t.Run("GetRegistriesV2", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var expected *BackwardsCompatibleRegistriesConfigV2
		obj.RegistriesV2 = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetRegistriesV2(), "getter should return the property value")
	})

	t.Run("GetRegistriesV2_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		obj.RegistriesV2 = nil

		// Act & Assert
		assert.Nil(t, obj.GetRegistriesV2(), "getter should return nil when property is nil")
	})

	t.Run("GetRegistriesV2_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatGeneratorPublishConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetRegistriesV2() // Should return zero value
	})

	t.Run("GetPublishTarget", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var expected *BackwardsCompatiblePublishTarget
		obj.PublishTarget = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetPublishTarget(), "getter should return the property value")
	})

	t.Run("GetPublishTarget_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		obj.PublishTarget = nil

		// Act & Assert
		assert.Nil(t, obj.GetPublishTarget(), "getter should return nil when property is nil")
	})

	t.Run("GetPublishTarget_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatGeneratorPublishConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetPublishTarget() // Should return zero value
	})

	t.Run("GetVersion", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var expected string
		obj.Version = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetVersion(), "getter should return the property value")
	})

	t.Run("GetVersion_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatGeneratorPublishConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetVersion() // Should return zero value
	})

}

func TestSettersMarkExplicitBackwardsCompatGeneratorPublishConfig(t *testing.T) {
	t.Run("SetRegistries_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var fernTestValueRegistries *GeneratorRegistriesConfig

		// Act
		obj.SetRegistries(fernTestValueRegistries)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetRegistriesV2_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var fernTestValueRegistriesV2 *BackwardsCompatibleRegistriesConfigV2

		// Act
		obj.SetRegistriesV2(fernTestValueRegistriesV2)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPublishTarget_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var fernTestValuePublishTarget *BackwardsCompatiblePublishTarget

		// Act
		obj.SetPublishTarget(fernTestValuePublishTarget)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetVersion_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}
		var fernTestValueVersion string

		// Act
		obj.SetVersion(fernTestValueVersion)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestSettersBackwardsCompatibleGeneratorConfig(t *testing.T) {
	t.Run("SetDryRun", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueDryRun bool
		obj.SetDryRun(fernTestValueDryRun)
		assert.Equal(t, fernTestValueDryRun, obj.DryRun)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetIrFilepath", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueIrFilepath string
		obj.SetIrFilepath(fernTestValueIrFilepath)
		assert.Equal(t, fernTestValueIrFilepath, obj.IrFilepath)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetOutput", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueOutput *BackwardsCompatibleGeneratorOutputConfig
		obj.SetOutput(fernTestValueOutput)
		assert.Equal(t, fernTestValueOutput, obj.Output)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPublish", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValuePublish *BackwardsCompatGeneratorPublishConfig
		obj.SetPublish(fernTestValuePublish)
		assert.Equal(t, fernTestValuePublish, obj.Publish)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetWorkspaceName", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueWorkspaceName string
		obj.SetWorkspaceName(fernTestValueWorkspaceName)
		assert.Equal(t, fernTestValueWorkspaceName, obj.WorkspaceName)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetOrganization", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueOrganization string
		obj.SetOrganization(fernTestValueOrganization)
		assert.Equal(t, fernTestValueOrganization, obj.Organization)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCustomConfig", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueCustomConfig any
		obj.SetCustomConfig(fernTestValueCustomConfig)
		assert.Equal(t, fernTestValueCustomConfig, obj.CustomConfig)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetEnvironment", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueEnvironment *GeneratorEnvironment
		obj.SetEnvironment(fernTestValueEnvironment)
		assert.Equal(t, fernTestValueEnvironment, obj.Environment)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersBackwardsCompatibleGeneratorConfig(t *testing.T) {
	t.Run("GetDryRun", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var expected bool
		obj.DryRun = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetDryRun(), "getter should return the property value")
	})

	t.Run("GetDryRun_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetDryRun() // Should return zero value
	})

	t.Run("GetIrFilepath", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var expected string
		obj.IrFilepath = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetIrFilepath(), "getter should return the property value")
	})

	t.Run("GetIrFilepath_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetIrFilepath() // Should return zero value
	})

	t.Run("GetOutput", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var expected *BackwardsCompatibleGeneratorOutputConfig
		obj.Output = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetOutput(), "getter should return the property value")
	})

	t.Run("GetOutput_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		obj.Output = nil

		// Act & Assert
		assert.Nil(t, obj.GetOutput(), "getter should return nil when property is nil")
	})

	t.Run("GetOutput_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetOutput() // Should return zero value
	})

	t.Run("GetPublish", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var expected *BackwardsCompatGeneratorPublishConfig
		obj.Publish = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetPublish(), "getter should return the property value")
	})

	t.Run("GetPublish_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		obj.Publish = nil

		// Act & Assert
		assert.Nil(t, obj.GetPublish(), "getter should return nil when property is nil")
	})

	t.Run("GetPublish_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetPublish() // Should return zero value
	})

	t.Run("GetWorkspaceName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var expected string
		obj.WorkspaceName = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetWorkspaceName(), "getter should return the property value")
	})

	t.Run("GetWorkspaceName_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetWorkspaceName() // Should return zero value
	})

	t.Run("GetOrganization", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var expected string
		obj.Organization = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetOrganization(), "getter should return the property value")
	})

	t.Run("GetOrganization_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetOrganization() // Should return zero value
	})

	t.Run("GetCustomConfig", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var expected any
		obj.CustomConfig = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetCustomConfig(), "getter should return the property value")
	})

	t.Run("GetCustomConfig_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetCustomConfig() // Should return zero value
	})

	t.Run("GetEnvironment", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var expected *GeneratorEnvironment
		obj.Environment = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetEnvironment(), "getter should return the property value")
	})

	t.Run("GetEnvironment_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		obj.Environment = nil

		// Act & Assert
		assert.Nil(t, obj.GetEnvironment(), "getter should return nil when property is nil")
	})

	t.Run("GetEnvironment_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetEnvironment() // Should return zero value
	})

}

func TestSettersMarkExplicitBackwardsCompatibleGeneratorConfig(t *testing.T) {
	t.Run("SetDryRun_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueDryRun bool

		// Act
		obj.SetDryRun(fernTestValueDryRun)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetIrFilepath_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueIrFilepath string

		// Act
		obj.SetIrFilepath(fernTestValueIrFilepath)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetOutput_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueOutput *BackwardsCompatibleGeneratorOutputConfig

		// Act
		obj.SetOutput(fernTestValueOutput)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPublish_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValuePublish *BackwardsCompatGeneratorPublishConfig

		// Act
		obj.SetPublish(fernTestValuePublish)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetWorkspaceName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueWorkspaceName string

		// Act
		obj.SetWorkspaceName(fernTestValueWorkspaceName)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetOrganization_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueOrganization string

		// Act
		obj.SetOrganization(fernTestValueOrganization)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCustomConfig_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueCustomConfig any

		// Act
		obj.SetCustomConfig(fernTestValueCustomConfig)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetEnvironment_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}
		var fernTestValueEnvironment *GeneratorEnvironment

		// Act
		obj.SetEnvironment(fernTestValueEnvironment)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestSettersBackwardsCompatibleGeneratorOutputConfig(t *testing.T) {
	t.Run("SetPath", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorOutputConfig{}
		var fernTestValuePath string
		obj.SetPath(fernTestValuePath)
		assert.Equal(t, fernTestValuePath, obj.Path)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMode", func(t *testing.T) {
		obj := &BackwardsCompatibleGeneratorOutputConfig{}
		var fernTestValueMode *BackwardsCompatibleOutputMode
		obj.SetMode(fernTestValueMode)
		assert.Equal(t, fernTestValueMode, obj.Mode)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersBackwardsCompatibleGeneratorOutputConfig(t *testing.T) {
	t.Run("GetPath", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorOutputConfig{}
		var expected string
		obj.Path = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetPath(), "getter should return the property value")
	})

	t.Run("GetPath_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorOutputConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetPath() // Should return zero value
	})

	t.Run("GetMode", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorOutputConfig{}
		var expected *BackwardsCompatibleOutputMode
		obj.Mode = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetMode(), "getter should return the property value")
	})

	t.Run("GetMode_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorOutputConfig{}
		obj.Mode = nil

		// Act & Assert
		assert.Nil(t, obj.GetMode(), "getter should return nil when property is nil")
	})

	t.Run("GetMode_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorOutputConfig
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetMode() // Should return zero value
	})

}

func TestSettersMarkExplicitBackwardsCompatibleGeneratorOutputConfig(t *testing.T) {
	t.Run("SetPath_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorOutputConfig{}
		var fernTestValuePath string

		// Act
		obj.SetPath(fernTestValuePath)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetMode_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorOutputConfig{}
		var fernTestValueMode *BackwardsCompatibleOutputMode

		// Act
		obj.SetMode(fernTestValueMode)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestGettersBackwardsCompatibleOutputMode(t *testing.T) {
	t.Run("GetType", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleOutputMode{}
		var expected string
		obj.Type = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetType(), "getter should return the property value")
	})

	t.Run("GetType_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleOutputMode
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetType() // Should return zero value
	})

	t.Run("GetPublish", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleOutputMode{}
		var expected *BackwardsCompatGeneratorPublishConfig
		obj.Publish = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetPublish(), "getter should return the property value")
	})

	t.Run("GetPublish_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleOutputMode{}
		obj.Publish = nil

		// Act & Assert
		assert.Nil(t, obj.GetPublish(), "getter should return nil when property is nil")
	})

	t.Run("GetPublish_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleOutputMode
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetPublish() // Should return zero value
	})

	t.Run("GetDownloadFiles", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleOutputMode{}
		var expected interface{}
		obj.DownloadFiles = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetDownloadFiles(), "getter should return the property value")
	})

	t.Run("GetDownloadFiles_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleOutputMode
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetDownloadFiles() // Should return zero value
	})

	t.Run("GetGithub", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleOutputMode{}
		var expected *GithubOutputMode
		obj.Github = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetGithub(), "getter should return the property value")
	})

	t.Run("GetGithub_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleOutputMode{}
		obj.Github = nil

		// Act & Assert
		assert.Nil(t, obj.GetGithub(), "getter should return nil when property is nil")
	})

	t.Run("GetGithub_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleOutputMode
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetGithub() // Should return zero value
	})

}

func TestGettersBackwardsCompatiblePublishTarget(t *testing.T) {
	t.Run("GetType", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatiblePublishTarget{}
		var expected string
		obj.Type = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetType(), "getter should return the property value")
	})

	t.Run("GetType_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatiblePublishTarget
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetType() // Should return zero value
	})

	t.Run("GetNpm", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatiblePublishTarget{}
		var expected *NpmRegistryConfigV2
		obj.Npm = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetNpm(), "getter should return the property value")
	})

	t.Run("GetNpm_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatiblePublishTarget{}
		obj.Npm = nil

		// Act & Assert
		assert.Nil(t, obj.GetNpm(), "getter should return nil when property is nil")
	})

	t.Run("GetNpm_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatiblePublishTarget
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetNpm() // Should return zero value
	})

}

func TestSettersBackwardsCompatibleRegistriesConfigV2(t *testing.T) {
	t.Run("SetMaven", func(t *testing.T) {
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		var fernTestValueMaven *MavenRegistryConfigV2
		obj.SetMaven(fernTestValueMaven)
		assert.Equal(t, fernTestValueMaven, obj.Maven)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetNpm", func(t *testing.T) {
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		var fernTestValueNpm *NpmRegistryConfigV2
		obj.SetNpm(fernTestValueNpm)
		assert.Equal(t, fernTestValueNpm, obj.Npm)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPypi", func(t *testing.T) {
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		var fernTestValuePypi *PypiRegistryConfig
		obj.SetPypi(fernTestValuePypi)
		assert.Equal(t, fernTestValuePypi, obj.Pypi)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersBackwardsCompatibleRegistriesConfigV2(t *testing.T) {
	t.Run("GetMaven", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		var expected *MavenRegistryConfigV2
		obj.Maven = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetMaven(), "getter should return the property value")
	})

	t.Run("GetMaven_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		obj.Maven = nil

		// Act & Assert
		assert.Nil(t, obj.GetMaven(), "getter should return nil when property is nil")
	})

	t.Run("GetMaven_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleRegistriesConfigV2
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetMaven() // Should return zero value
	})

	t.Run("GetNpm", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		var expected *NpmRegistryConfigV2
		obj.Npm = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetNpm(), "getter should return the property value")
	})

	t.Run("GetNpm_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		obj.Npm = nil

		// Act & Assert
		assert.Nil(t, obj.GetNpm(), "getter should return nil when property is nil")
	})

	t.Run("GetNpm_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleRegistriesConfigV2
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetNpm() // Should return zero value
	})

	t.Run("GetPypi", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		var expected *PypiRegistryConfig
		obj.Pypi = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetPypi(), "getter should return the property value")
	})

	t.Run("GetPypi_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		obj.Pypi = nil

		// Act & Assert
		assert.Nil(t, obj.GetPypi(), "getter should return nil when property is nil")
	})

	t.Run("GetPypi_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleRegistriesConfigV2
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetPypi() // Should return zero value
	})

}

func TestSettersMarkExplicitBackwardsCompatibleRegistriesConfigV2(t *testing.T) {
	t.Run("SetMaven_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		var fernTestValueMaven *MavenRegistryConfigV2

		// Act
		obj.SetMaven(fernTestValueMaven)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetNpm_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		var fernTestValueNpm *NpmRegistryConfigV2

		// Act
		obj.SetNpm(fernTestValueNpm)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPypi_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		var fernTestValuePypi *PypiRegistryConfig

		// Act
		obj.SetPypi(fernTestValuePypi)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestJSONMarshalingBackwardsCompatGeneratorPublishConfig(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatGeneratorPublishConfig{}

		// Act - Marshal to JSON
		data, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed")
		assert.NotNil(t, data, "marshaled data should not be nil")
		assert.NotEmpty(t, data, "marshaled data should not be empty")

		// Unmarshal back and verify round-trip
		var unmarshaled BackwardsCompatGeneratorPublishConfig
		err = json.Unmarshal(data, &unmarshaled)
		assert.NoError(t, err, "round-trip unmarshal should succeed")
	})

	t.Run("UnmarshalInvalidJSON", func(t *testing.T) {
		t.Parallel()
		var obj BackwardsCompatGeneratorPublishConfig
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

	t.Run("UnmarshalEmptyObject", func(t *testing.T) {
		t.Parallel()
		var obj BackwardsCompatGeneratorPublishConfig
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestJSONMarshalingBackwardsCompatibleGeneratorConfig(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorConfig{}

		// Act - Marshal to JSON
		data, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed")
		assert.NotNil(t, data, "marshaled data should not be nil")
		assert.NotEmpty(t, data, "marshaled data should not be empty")

		// Unmarshal back and verify round-trip
		var unmarshaled BackwardsCompatibleGeneratorConfig
		err = json.Unmarshal(data, &unmarshaled)
		assert.NoError(t, err, "round-trip unmarshal should succeed")
	})

	t.Run("UnmarshalInvalidJSON", func(t *testing.T) {
		t.Parallel()
		var obj BackwardsCompatibleGeneratorConfig
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

	t.Run("UnmarshalEmptyObject", func(t *testing.T) {
		t.Parallel()
		var obj BackwardsCompatibleGeneratorConfig
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestJSONMarshalingBackwardsCompatibleGeneratorOutputConfig(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleGeneratorOutputConfig{}

		// Act - Marshal to JSON
		data, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed")
		assert.NotNil(t, data, "marshaled data should not be nil")
		assert.NotEmpty(t, data, "marshaled data should not be empty")

		// Unmarshal back and verify round-trip
		var unmarshaled BackwardsCompatibleGeneratorOutputConfig
		err = json.Unmarshal(data, &unmarshaled)
		assert.NoError(t, err, "round-trip unmarshal should succeed")
	})

	t.Run("UnmarshalInvalidJSON", func(t *testing.T) {
		t.Parallel()
		var obj BackwardsCompatibleGeneratorOutputConfig
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

	t.Run("UnmarshalEmptyObject", func(t *testing.T) {
		t.Parallel()
		var obj BackwardsCompatibleGeneratorOutputConfig
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestJSONMarshalingBackwardsCompatibleRegistriesConfigV2(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BackwardsCompatibleRegistriesConfigV2{}

		// Act - Marshal to JSON
		data, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed")
		assert.NotNil(t, data, "marshaled data should not be nil")
		assert.NotEmpty(t, data, "marshaled data should not be empty")

		// Unmarshal back and verify round-trip
		var unmarshaled BackwardsCompatibleRegistriesConfigV2
		err = json.Unmarshal(data, &unmarshaled)
		assert.NoError(t, err, "round-trip unmarshal should succeed")
	})

	t.Run("UnmarshalInvalidJSON", func(t *testing.T) {
		t.Parallel()
		var obj BackwardsCompatibleRegistriesConfigV2
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

	t.Run("UnmarshalEmptyObject", func(t *testing.T) {
		t.Parallel()
		var obj BackwardsCompatibleRegistriesConfigV2
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestStringBackwardsCompatGeneratorPublishConfig(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &BackwardsCompatGeneratorPublishConfig{}
		result := obj.String()
		assert.NotEmpty(t, result, "String() should return a non-empty representation")
	})

	t.Run("StringMethod_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatGeneratorPublishConfig
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringBackwardsCompatibleGeneratorConfig(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &BackwardsCompatibleGeneratorConfig{}
		result := obj.String()
		assert.NotEmpty(t, result, "String() should return a non-empty representation")
	})

	t.Run("StringMethod_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringBackwardsCompatibleGeneratorOutputConfig(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &BackwardsCompatibleGeneratorOutputConfig{}
		result := obj.String()
		assert.NotEmpty(t, result, "String() should return a non-empty representation")
	})

	t.Run("StringMethod_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorOutputConfig
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringBackwardsCompatibleRegistriesConfigV2(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		result := obj.String()
		assert.NotEmpty(t, result, "String() should return a non-empty representation")
	})

	t.Run("StringMethod_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleRegistriesConfigV2
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestExtraPropertiesBackwardsCompatGeneratorPublishConfig(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &BackwardsCompatGeneratorPublishConfig{}
		// Should not panic when calling GetExtraProperties()
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("GetExtraProperties() panicked: %v", r)
			}
		}()
		extraProps := obj.GetExtraProperties()
		// Result can be nil or an empty/non-empty map
		_ = extraProps
	})

	t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatGeneratorPublishConfig
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesBackwardsCompatibleGeneratorConfig(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &BackwardsCompatibleGeneratorConfig{}
		// Should not panic when calling GetExtraProperties()
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("GetExtraProperties() panicked: %v", r)
			}
		}()
		extraProps := obj.GetExtraProperties()
		// Result can be nil or an empty/non-empty map
		_ = extraProps
	})

	t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorConfig
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesBackwardsCompatibleGeneratorOutputConfig(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &BackwardsCompatibleGeneratorOutputConfig{}
		// Should not panic when calling GetExtraProperties()
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("GetExtraProperties() panicked: %v", r)
			}
		}()
		extraProps := obj.GetExtraProperties()
		// Result can be nil or an empty/non-empty map
		_ = extraProps
	})

	t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleGeneratorOutputConfig
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesBackwardsCompatibleRegistriesConfigV2(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &BackwardsCompatibleRegistriesConfigV2{}
		// Should not panic when calling GetExtraProperties()
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("GetExtraProperties() panicked: %v", r)
			}
		}()
		extraProps := obj.GetExtraProperties()
		// Result can be nil or an empty/non-empty map
		_ = extraProps
	})

	t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *BackwardsCompatibleRegistriesConfigV2
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}