reference_test.go

// Code generated by Fern. DO NOT EDIT.

package generatorcli

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

func TestSettersEndpointReference(t *testing.T) {
	t.Run("SetTitle", func(t *testing.T) {
		obj := &EndpointReference{}
		var fernTestValueTitle *MethodInvocationSnippet
		obj.SetTitle(fernTestValueTitle)
		assert.Equal(t, fernTestValueTitle, obj.Title)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDescription", func(t *testing.T) {
		obj := &EndpointReference{}
		var fernTestValueDescription *string
		obj.SetDescription(fernTestValueDescription)
		assert.Equal(t, fernTestValueDescription, obj.Description)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSnippet", func(t *testing.T) {
		obj := &EndpointReference{}
		var fernTestValueSnippet string
		obj.SetSnippet(fernTestValueSnippet)
		assert.Equal(t, fernTestValueSnippet, obj.Snippet)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetParameters", func(t *testing.T) {
		obj := &EndpointReference{}
		var fernTestValueParameters []*ParameterReference
		obj.SetParameters(fernTestValueParameters)
		assert.Equal(t, fernTestValueParameters, obj.Parameters)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersEndpointReference(t *testing.T) {
	t.Run("GetTitle", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		var expected *MethodInvocationSnippet
		obj.Title = expected

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

	t.Run("GetTitle_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		obj.Title = nil

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

	t.Run("GetTitle_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *EndpointReference
		// 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.GetTitle() // Should return zero value
	})

	t.Run("GetDescription", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		var expected *string
		obj.Description = expected

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

	t.Run("GetDescription_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		obj.Description = nil

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

	t.Run("GetDescription_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *EndpointReference
		// 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.GetDescription() // Should return zero value
	})

	t.Run("GetSnippet", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		var expected string
		obj.Snippet = expected

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

	t.Run("GetSnippet_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *EndpointReference
		// 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.GetSnippet() // Should return zero value
	})

	t.Run("GetParameters", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		var expected []*ParameterReference
		obj.Parameters = expected

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

	t.Run("GetParameters_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		obj.Parameters = nil

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

	t.Run("GetParameters_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *EndpointReference
		// 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.GetParameters() // Should return zero value
	})

}

func TestSettersMarkExplicitEndpointReference(t *testing.T) {
	t.Run("SetTitle_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		var fernTestValueTitle *MethodInvocationSnippet

		// Act
		obj.SetTitle(fernTestValueTitle)

		// 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("SetDescription_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		var fernTestValueDescription *string

		// Act
		obj.SetDescription(fernTestValueDescription)

		// 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("SetSnippet_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		var fernTestValueSnippet string

		// Act
		obj.SetSnippet(fernTestValueSnippet)

		// 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("SetParameters_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}
		var fernTestValueParameters []*ParameterReference

		// Act
		obj.SetParameters(fernTestValueParameters)

		// 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 TestSettersLinkedText(t *testing.T) {
	t.Run("SetText", func(t *testing.T) {
		obj := &LinkedText{}
		var fernTestValueText string
		obj.SetText(fernTestValueText)
		assert.Equal(t, fernTestValueText, obj.Text)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLocation", func(t *testing.T) {
		obj := &LinkedText{}
		var fernTestValueLocation *RelativeLocation
		obj.SetLocation(fernTestValueLocation)
		assert.Equal(t, fernTestValueLocation, obj.Location)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersLinkedText(t *testing.T) {
	t.Run("GetText", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LinkedText{}
		var expected string
		obj.Text = expected

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

	t.Run("GetText_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *LinkedText
		// 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.GetText() // Should return zero value
	})

	t.Run("GetLocation", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LinkedText{}
		var expected *RelativeLocation
		obj.Location = expected

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

	t.Run("GetLocation_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LinkedText{}
		obj.Location = nil

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

	t.Run("GetLocation_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *LinkedText
		// 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.GetLocation() // Should return zero value
	})

}

func TestSettersMarkExplicitLinkedText(t *testing.T) {
	t.Run("SetText_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LinkedText{}
		var fernTestValueText string

		// Act
		obj.SetText(fernTestValueText)

		// 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("SetLocation_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LinkedText{}
		var fernTestValueLocation *RelativeLocation

		// Act
		obj.SetLocation(fernTestValueLocation)

		// 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 TestSettersMethodInvocationSnippet(t *testing.T) {
	t.Run("SetSnippetParts", func(t *testing.T) {
		obj := &MethodInvocationSnippet{}
		var fernTestValueSnippetParts []*LinkedText
		obj.SetSnippetParts(fernTestValueSnippetParts)
		assert.Equal(t, fernTestValueSnippetParts, obj.SnippetParts)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetReturnValue", func(t *testing.T) {
		obj := &MethodInvocationSnippet{}
		var fernTestValueReturnValue *LinkedText
		obj.SetReturnValue(fernTestValueReturnValue)
		assert.Equal(t, fernTestValueReturnValue, obj.ReturnValue)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersMethodInvocationSnippet(t *testing.T) {
	t.Run("GetSnippetParts", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MethodInvocationSnippet{}
		var expected []*LinkedText
		obj.SnippetParts = expected

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

	t.Run("GetSnippetParts_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MethodInvocationSnippet{}
		obj.SnippetParts = nil

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

	t.Run("GetSnippetParts_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *MethodInvocationSnippet
		// 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.GetSnippetParts() // Should return zero value
	})

	t.Run("GetReturnValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MethodInvocationSnippet{}
		var expected *LinkedText
		obj.ReturnValue = expected

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

	t.Run("GetReturnValue_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MethodInvocationSnippet{}
		obj.ReturnValue = nil

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

	t.Run("GetReturnValue_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *MethodInvocationSnippet
		// 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.GetReturnValue() // Should return zero value
	})

}

func TestSettersMarkExplicitMethodInvocationSnippet(t *testing.T) {
	t.Run("SetSnippetParts_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MethodInvocationSnippet{}
		var fernTestValueSnippetParts []*LinkedText

		// Act
		obj.SetSnippetParts(fernTestValueSnippetParts)

		// 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("SetReturnValue_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MethodInvocationSnippet{}
		var fernTestValueReturnValue *LinkedText

		// Act
		obj.SetReturnValue(fernTestValueReturnValue)

		// 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 TestSettersParameterReference(t *testing.T) {
	t.Run("SetName", func(t *testing.T) {
		obj := &ParameterReference{}
		var fernTestValueName string
		obj.SetName(fernTestValueName)
		assert.Equal(t, fernTestValueName, obj.Name)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDescription", func(t *testing.T) {
		obj := &ParameterReference{}
		var fernTestValueDescription *string
		obj.SetDescription(fernTestValueDescription)
		assert.Equal(t, fernTestValueDescription, obj.Description)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLocation", func(t *testing.T) {
		obj := &ParameterReference{}
		var fernTestValueLocation *RelativeLocation
		obj.SetLocation(fernTestValueLocation)
		assert.Equal(t, fernTestValueLocation, obj.Location)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetType", func(t *testing.T) {
		obj := &ParameterReference{}
		var fernTestValueType string
		obj.SetType(fernTestValueType)
		assert.Equal(t, fernTestValueType, obj.Type)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetRequired", func(t *testing.T) {
		obj := &ParameterReference{}
		var fernTestValueRequired bool
		obj.SetRequired(fernTestValueRequired)
		assert.Equal(t, fernTestValueRequired, obj.Required)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersParameterReference(t *testing.T) {
	t.Run("GetName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		var expected string
		obj.Name = expected

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

	t.Run("GetName_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ParameterReference
		// 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.GetName() // Should return zero value
	})

	t.Run("GetDescription", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		var expected *string
		obj.Description = expected

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

	t.Run("GetDescription_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		obj.Description = nil

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

	t.Run("GetDescription_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ParameterReference
		// 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.GetDescription() // Should return zero value
	})

	t.Run("GetLocation", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		var expected *RelativeLocation
		obj.Location = expected

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

	t.Run("GetLocation_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		obj.Location = nil

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

	t.Run("GetLocation_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ParameterReference
		// 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.GetLocation() // Should return zero value
	})

	t.Run("GetType", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		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 *ParameterReference
		// 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("GetRequired", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		var expected bool
		obj.Required = expected

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

	t.Run("GetRequired_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ParameterReference
		// 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.GetRequired() // Should return zero value
	})

}

func TestSettersMarkExplicitParameterReference(t *testing.T) {
	t.Run("SetName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		var fernTestValueName string

		// Act
		obj.SetName(fernTestValueName)

		// 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("SetDescription_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		var fernTestValueDescription *string

		// Act
		obj.SetDescription(fernTestValueDescription)

		// 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("SetLocation_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		var fernTestValueLocation *RelativeLocation

		// Act
		obj.SetLocation(fernTestValueLocation)

		// 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("SetType_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		var fernTestValueType string

		// Act
		obj.SetType(fernTestValueType)

		// 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("SetRequired_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ParameterReference{}
		var fernTestValueRequired bool

		// Act
		obj.SetRequired(fernTestValueRequired)

		// 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 TestSettersReferenceConfig(t *testing.T) {
	t.Run("SetRootSection", func(t *testing.T) {
		obj := &ReferenceConfig{}
		var fernTestValueRootSection *RootPackageReferenceSection
		obj.SetRootSection(fernTestValueRootSection)
		assert.Equal(t, fernTestValueRootSection, obj.RootSection)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSections", func(t *testing.T) {
		obj := &ReferenceConfig{}
		var fernTestValueSections []*ReferenceSection
		obj.SetSections(fernTestValueSections)
		assert.Equal(t, fernTestValueSections, obj.Sections)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLanguage", func(t *testing.T) {
		obj := &ReferenceConfig{}
		var fernTestValueLanguage Language
		obj.SetLanguage(fernTestValueLanguage)
		assert.Equal(t, fernTestValueLanguage, obj.Language)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersReferenceConfig(t *testing.T) {
	t.Run("GetRootSection", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceConfig{}
		var expected *RootPackageReferenceSection
		obj.RootSection = expected

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

	t.Run("GetRootSection_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceConfig{}
		obj.RootSection = nil

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

	t.Run("GetRootSection_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ReferenceConfig
		// 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.GetRootSection() // Should return zero value
	})

	t.Run("GetSections", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceConfig{}
		var expected []*ReferenceSection
		obj.Sections = expected

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

	t.Run("GetSections_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceConfig{}
		obj.Sections = nil

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

	t.Run("GetSections_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ReferenceConfig
		// 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.GetSections() // Should return zero value
	})

	t.Run("GetLanguage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceConfig{}
		var expected Language
		obj.Language = expected

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

	t.Run("GetLanguage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ReferenceConfig
		// 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.GetLanguage() // Should return zero value
	})

}

func TestSettersMarkExplicitReferenceConfig(t *testing.T) {
	t.Run("SetRootSection_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceConfig{}
		var fernTestValueRootSection *RootPackageReferenceSection

		// Act
		obj.SetRootSection(fernTestValueRootSection)

		// 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("SetSections_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceConfig{}
		var fernTestValueSections []*ReferenceSection

		// Act
		obj.SetSections(fernTestValueSections)

		// 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("SetLanguage_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceConfig{}
		var fernTestValueLanguage Language

		// Act
		obj.SetLanguage(fernTestValueLanguage)

		// 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 TestSettersReferenceSection(t *testing.T) {
	t.Run("SetTitle", func(t *testing.T) {
		obj := &ReferenceSection{}
		var fernTestValueTitle string
		obj.SetTitle(fernTestValueTitle)
		assert.Equal(t, fernTestValueTitle, obj.Title)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDescription", func(t *testing.T) {
		obj := &ReferenceSection{}
		var fernTestValueDescription *string
		obj.SetDescription(fernTestValueDescription)
		assert.Equal(t, fernTestValueDescription, obj.Description)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetEndpoints", func(t *testing.T) {
		obj := &ReferenceSection{}
		var fernTestValueEndpoints []*EndpointReference
		obj.SetEndpoints(fernTestValueEndpoints)
		assert.Equal(t, fernTestValueEndpoints, obj.Endpoints)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersReferenceSection(t *testing.T) {
	t.Run("GetTitle", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceSection{}
		var expected string
		obj.Title = expected

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

	t.Run("GetTitle_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ReferenceSection
		// 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.GetTitle() // Should return zero value
	})

	t.Run("GetDescription", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceSection{}
		var expected *string
		obj.Description = expected

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

	t.Run("GetDescription_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceSection{}
		obj.Description = nil

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

	t.Run("GetDescription_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ReferenceSection
		// 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.GetDescription() // Should return zero value
	})

	t.Run("GetEndpoints", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceSection{}
		var expected []*EndpointReference
		obj.Endpoints = expected

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

	t.Run("GetEndpoints_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceSection{}
		obj.Endpoints = nil

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

	t.Run("GetEndpoints_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ReferenceSection
		// 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.GetEndpoints() // Should return zero value
	})

}

func TestSettersMarkExplicitReferenceSection(t *testing.T) {
	t.Run("SetTitle_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceSection{}
		var fernTestValueTitle string

		// Act
		obj.SetTitle(fernTestValueTitle)

		// 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("SetDescription_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceSection{}
		var fernTestValueDescription *string

		// Act
		obj.SetDescription(fernTestValueDescription)

		// 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("SetEndpoints_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReferenceSection{}
		var fernTestValueEndpoints []*EndpointReference

		// Act
		obj.SetEndpoints(fernTestValueEndpoints)

		// 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 TestSettersRelativeLocation(t *testing.T) {
	t.Run("SetPath", func(t *testing.T) {
		obj := &RelativeLocation{}
		var fernTestValuePath string
		obj.SetPath(fernTestValuePath)
		assert.Equal(t, fernTestValuePath, obj.Path)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersRelativeLocation(t *testing.T) {
	t.Run("GetPath", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RelativeLocation{}
		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 *RelativeLocation
		// 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
	})

}

func TestSettersMarkExplicitRelativeLocation(t *testing.T) {
	t.Run("SetPath_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RelativeLocation{}
		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
	})

}

func TestSettersRootPackageReferenceSection(t *testing.T) {
	t.Run("SetDescription", func(t *testing.T) {
		obj := &RootPackageReferenceSection{}
		var fernTestValueDescription *string
		obj.SetDescription(fernTestValueDescription)
		assert.Equal(t, fernTestValueDescription, obj.Description)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetEndpoints", func(t *testing.T) {
		obj := &RootPackageReferenceSection{}
		var fernTestValueEndpoints []*EndpointReference
		obj.SetEndpoints(fernTestValueEndpoints)
		assert.Equal(t, fernTestValueEndpoints, obj.Endpoints)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersRootPackageReferenceSection(t *testing.T) {
	t.Run("GetDescription", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RootPackageReferenceSection{}
		var expected *string
		obj.Description = expected

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

	t.Run("GetDescription_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RootPackageReferenceSection{}
		obj.Description = nil

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

	t.Run("GetDescription_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *RootPackageReferenceSection
		// 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.GetDescription() // Should return zero value
	})

	t.Run("GetEndpoints", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RootPackageReferenceSection{}
		var expected []*EndpointReference
		obj.Endpoints = expected

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

	t.Run("GetEndpoints_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RootPackageReferenceSection{}
		obj.Endpoints = nil

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

	t.Run("GetEndpoints_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *RootPackageReferenceSection
		// 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.GetEndpoints() // Should return zero value
	})

}

func TestSettersMarkExplicitRootPackageReferenceSection(t *testing.T) {
	t.Run("SetDescription_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RootPackageReferenceSection{}
		var fernTestValueDescription *string

		// Act
		obj.SetDescription(fernTestValueDescription)

		// 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("SetEndpoints_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RootPackageReferenceSection{}
		var fernTestValueEndpoints []*EndpointReference

		// Act
		obj.SetEndpoints(fernTestValueEndpoints)

		// 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 TestJSONMarshalingEndpointReference(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &EndpointReference{}

		// 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 EndpointReference
		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 EndpointReference
		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 EndpointReference
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

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

		// 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 LinkedText
		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 LinkedText
		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 LinkedText
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

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

		// 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 MethodInvocationSnippet
		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 MethodInvocationSnippet
		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 MethodInvocationSnippet
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

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

		// 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 ParameterReference
		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 ParameterReference
		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 ParameterReference
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

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

		// 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 ReferenceConfig
		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 ReferenceConfig
		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 ReferenceConfig
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

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

		// 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 ReferenceSection
		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 ReferenceSection
		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 ReferenceSection
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

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

		// 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 RelativeLocation
		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 RelativeLocation
		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 RelativeLocation
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

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

		// 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 RootPackageReferenceSection
		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 RootPackageReferenceSection
		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 RootPackageReferenceSection
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestStringEndpointReference(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &EndpointReference{}
		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 *EndpointReference
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringLinkedText(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &LinkedText{}
		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 *LinkedText
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringMethodInvocationSnippet(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &MethodInvocationSnippet{}
		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 *MethodInvocationSnippet
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringParameterReference(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &ParameterReference{}
		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 *ParameterReference
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringReferenceConfig(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &ReferenceConfig{}
		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 *ReferenceConfig
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringReferenceSection(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &ReferenceSection{}
		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 *ReferenceSection
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringRelativeLocation(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &RelativeLocation{}
		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 *RelativeLocation
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringRootPackageReferenceSection(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &RootPackageReferenceSection{}
		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 *RootPackageReferenceSection
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestEnumLanguage(t *testing.T) {
	t.Run("NewFromString_JAVA", func(t *testing.T) {
		t.Parallel()
		val, err := NewLanguageFromString("JAVA")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, Language("JAVA"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_PYTHON", func(t *testing.T) {
		t.Parallel()
		val, err := NewLanguageFromString("PYTHON")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, Language("PYTHON"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_GO", func(t *testing.T) {
		t.Parallel()
		val, err := NewLanguageFromString("GO")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, Language("GO"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_RUBY", func(t *testing.T) {
		t.Parallel()
		val, err := NewLanguageFromString("RUBY")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, Language("RUBY"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_CSHARP", func(t *testing.T) {
		t.Parallel()
		val, err := NewLanguageFromString("CSHARP")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, Language("CSHARP"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_TYPESCRIPT", func(t *testing.T) {
		t.Parallel()
		val, err := NewLanguageFromString("TYPESCRIPT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, Language("TYPESCRIPT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_PHP", func(t *testing.T) {
		t.Parallel()
		val, err := NewLanguageFromString("PHP")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, Language("PHP"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_RUST", func(t *testing.T) {
		t.Parallel()
		val, err := NewLanguageFromString("RUST")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, Language("RUST"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_SWIFT", func(t *testing.T) {
		t.Parallel()
		val, err := NewLanguageFromString("SWIFT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, Language("SWIFT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_Invalid", func(t *testing.T) {
		_, err := NewLanguageFromString("invalid_value_that_does_not_exist")
		assert.Error(t, err)
	})

	t.Run("Ptr", func(t *testing.T) {
		val, err := NewLanguageFromString("JAVA")
		assert.NoError(t, err)
		ptr := val.Ptr()
		assert.NotNil(t, ptr)
		assert.Equal(t, val, *ptr)
	})
}

func TestExtraPropertiesEndpointReference(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &EndpointReference{}
		// 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 *EndpointReference
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesLinkedText(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &LinkedText{}
		// 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 *LinkedText
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesMethodInvocationSnippet(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &MethodInvocationSnippet{}
		// 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 *MethodInvocationSnippet
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesParameterReference(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &ParameterReference{}
		// 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 *ParameterReference
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesReferenceConfig(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &ReferenceConfig{}
		// 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 *ReferenceConfig
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesReferenceSection(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &ReferenceSection{}
		// 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 *ReferenceSection
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesRelativeLocation(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &RelativeLocation{}
		// 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 *RelativeLocation
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesRootPackageReferenceSection(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &RootPackageReferenceSection{}
		// 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 *RootPackageReferenceSection
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}