jpl_test.go

package jpl

import (
	"encoding/binary"
	"errors"
	"fmt"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/require"
	"github.com/stretchr/testify/suite"
	"math"
	"testing"
)

// MockEphemerisHandler is a mock for the ephemerisHandler interface
type MockEphemerisHandler struct {
	mock.Mock
}

func (m *MockEphemerisHandler) state(et float64, list []int32, doBary bool, pv, pvsun, rrd []float64) error {
	args := m.Called(et, list, doBary, pv, pvsun, rrd)
	return args.Error(0)
}

func (m *MockEphemerisHandler) EphemerisLookup(et float64, ntarg, ncent CelestialBody) ([]float64, error) {
	args := m.Called(et, ntarg, ncent)
	return args.Get(0).([]float64), args.Error(1)
}

func (m *MockEphemerisHandler) interpolation(buf []float64, t, intv float64, ncfin, ncmin, nain, ifl int32, pv []float64) error {
	args := m.Called(buf, t, intv, ncfin, ncmin, nain, ifl, pv)
	return args.Error(0)
}

func (m *MockEphemerisHandler) interpolateBodies(list []int32, doBary bool, aufac, t, intv float64, pv, pvsun []float64) {
	m.Called(list, doBary, aufac, t, intv, pv, pvsun)
}

func (m *MockEphemerisHandler) interpolateSunPosition(t, intv float64, pvsun []float64) {
	m.Called(t, intv, pvsun)
}

func (m *MockEphemerisHandler) interpolateLibrations(list []int32, t, intv float64, pv []float64) {
	m.Called(list, t, intv, pv)
}

func (m *MockEphemerisHandler) interpolateNutations(list []int32, t, intv float64, nut []float64) {
	m.Called(list, t, intv, nut)
}

// TestHandleNutation tests the handleNutation function
func TestHandleNutation(t *testing.T) {
	mockEphemerisHandler := new(MockEphemerisHandler)
	jpl := &JPL{
		ephemerisHandler: mockEphemerisHandler,
	}

	tests := []struct {
		name          string
		ipt           [39]int32
		et            float64
		pv            []float64
		pvsun         []float64
		rrd           []float64
		expectedRrd   []float64
		mockError     error
		expectedError string
	}{
		{
			name:          "Successful nutation handling",
			ipt:           [39]int32{34: 1}, // Ensure nutation is available
			et:            2451545.0,
			pv:            make([]float64, 6),
			pvsun:         make([]float64, 6),
			rrd:           make([]float64, 6),
			expectedRrd:   []float64{0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
			mockError:     nil,
			expectedError: "",
		},
		{
			name:          "Nutation not available",
			ipt:           [39]int32{34: 0},
			et:            2451545.0,
			pv:            make([]float64, 6),
			pvsun:         make([]float64, 6),
			rrd:           nil,
			expectedRrd:   nil,
			mockError:     nil,
			expectedError: "nutation data not available in the JPL ephemeris file", // Updated error message
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Set up the JPL constants
			jpl.Constants.IPT = tt.ipt

			if tt.ipt[34] > 0 {
				mockEphemerisHandler.On("state", tt.et, mock.AnythingOfType("[]int32"), false, tt.pv, tt.pvsun, mock.AnythingOfType("[]float64")).Return(tt.mockError)
			}

			// Act
			rrd, err := jpl.handleNutation(tt.et, tt.pv, tt.pvsun)

			// Assert
			if tt.expectedError != "" {
				assert.Equal(t, tt.expectedRrd, rrd, "Expected rrd to remain unchanged when an error occurs")
				assert.EqualError(t, err, tt.expectedError)
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tt.expectedRrd, rrd)
			}

			mockEphemerisHandler.AssertExpectations(t)
		})
	}
}

// TestHandleLibration tests the handleLibration function
func TestHandleLibration(t *testing.T) {
	mockEphemerisHandler := new(MockEphemerisHandler)
	jpl := &JPL{
		ephemerisHandler: mockEphemerisHandler,
	}

	tests := []struct {
		name          string
		ipt           [39]int32
		et            float64
		pv            []float64
		pvsun         []float64
		expectedRrd   []float64
		mockError     error
		expectedError string
	}{
		{
			name:          "Successful libration handling",
			ipt:           [39]int32{37: 1}, // Ensure libration is available
			et:            2451545.0,
			pv:            make([]float64, 66), // Mocked pv array with 66 elements
			pvsun:         make([]float64, 6),
			expectedRrd:   []float64{0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, // Expecting a copy of pv[60:66]
			mockError:     nil,
			expectedError: "",
		},
		{
			name:          "Libration not available",
			ipt:           [39]int32{37: 0},
			et:            2451545.0,
			pv:            make([]float64, 66),
			pvsun:         make([]float64, 6),
			expectedRrd:   nil,
			mockError:     nil,
			expectedError: "libration data not available in the JPL ephemeris file",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Set up the JPL constants
			jpl.Constants.IPT = tt.ipt

			if tt.ipt[37] > 0 {
				mockEphemerisHandler.On("state", tt.et, mock.AnythingOfType("[]int32"), false, tt.pv, tt.pvsun, mock.AnythingOfType("[]float64")).Return(tt.mockError).Run(func(args mock.Arguments) {
					if tt.mockError == nil {
						copy(args.Get(5).([]float64), tt.pv[60:66])
					}
				})
			}

			// Act
			rrd, err := jpl.handleLibration(tt.et, tt.pv, tt.pvsun)

			// Assert
			if tt.expectedError != "" {
				assert.Nil(t, rrd)
				assert.EqualError(t, err, tt.expectedError)
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tt.expectedRrd, rrd)
			}

			mockEphemerisHandler.AssertExpectations(t)
		})
	}
}

// TestHandleEarthMoonInteraction tests the handleEarthMoonInteraction function
func TestHandleEarthMoonInteraction(t *testing.T) {
	tests := []struct {
		name          string
		list          []int32
		initialPV     []float64
		expectedPV    []float64
		expectedError bool
	}{
		{
			name:       "Earth in list only",
			list:       []int32{2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
			initialPV:  make([]float64, 78),
			expectedPV: func() []float64 { pv := make([]float64, 78); return pv }(),
		},
		{
			name:       "Moon in list only",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
			initialPV:  make([]float64, 78),
			expectedPV: func() []float64 { pv := make([]float64, 78); return pv }(),
		},
		{
			name:       "Both Earth and Moon in list",
			list:       []int32{2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
			initialPV:  make([]float64, 78),
			expectedPV: func() []float64 { pv := make([]float64, 78); return pv }(),
		},
		{
			name:       "Neither Earth nor Moon in list",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
			initialPV:  make([]float64, 78),
			expectedPV: func() []float64 { pv := make([]float64, 78); return pv }(),
		},
		{
			name:       "Empty list",
			list:       []int32{},
			initialPV:  make([]float64, 78),
			expectedPV: func() []float64 { pv := make([]float64, 78); return pv }(),
		},
		{
			name:          "Invalid pv array (nil)",
			list:          []int32{2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0},
			initialPV:     nil,
			expectedPV:    nil,
			expectedError: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			js := &JPL{
				Constants: struct {
					Cval  [400]float64
					SS    [3]float64
					AU    float64
					Emrat float64
					Denum int32
					Ncon  int32
					IPT   [39]int32
				}{
					Emrat: 81.30056, // Example Earth/Moon mass ratio
				},
			}

			// Test the function
			if tt.initialPV != nil {
				js.handleEarthMoonInteraction(tt.list, tt.initialPV)
				assert.Equal(t, tt.expectedPV, tt.initialPV, "PV array does not match expected value")
			} else {
				// Handle the case where pv array is nil
				defer func() {
					if r := recover(); r != nil {
						assert.True(t, tt.expectedError, "The function should panic with nil pv array")
					}
				}()
				js.handleEarthMoonInteraction(tt.list, tt.initialPV)
			}
		})
	}
}

func TestAdjustPositionsForSunEMBBary(t *testing.T) {
	tests := []struct {
		name         string
		ntarg        CelestialBody
		ncent        CelestialBody
		initialPV    []float64
		initialPVSun []float64
		expectedPV   []float64
	}{
		{
			name:         "Sun as ntarg",
			ntarg:        Sun,
			ncent:        Earth,
			initialPV:    make([]float64, 6*14),
			initialPVSun: []float64{1, 2, 3, 4, 5, 6},
			expectedPV: func() []float64 {
				pv := make([]float64, 6*14)
				copy(pv[6*int(Sun):6*int(Sun)+6], []float64{1, 2, 3, 4, 5, 6})
				return pv
			}(),
		},
		{
			name:         "SolarSystemBarycenter as ntarg",
			ntarg:        SolarSystemBarycenter,
			ncent:        Earth,
			initialPV:    make([]float64, 6*14),
			initialPVSun: make([]float64, 6),
			expectedPV: func() []float64 {
				pv := make([]float64, 6*14)
				copy(pv[6*int(SolarSystemBarycenter):6*int(SolarSystemBarycenter)+6], make([]float64, 6))
				return pv
			}(),
		},
		{
			name:  "EarthMoonBarycenter as ntarg",
			ntarg: EarthMoonBarycenter,
			ncent: Earth,
			initialPV: func() []float64 {
				pv := make([]float64, 6*14)
				copy(pv[6*int(Earth):6*int(Earth)+6], []float64{1, 2, 3, 4, 5, 6})
				return pv
			}(),
			initialPVSun: make([]float64, 6),
			expectedPV: func() []float64 {
				pv := make([]float64, 6*14)
				copy(pv[6*int(Earth):6*int(Earth)+6], []float64{1, 2, 3, 4, 5, 6})
				copy(pv[6*int(EarthMoonBarycenter):6*int(EarthMoonBarycenter)+6], []float64{1, 2, 3, 4, 5, 6})
				return pv
			}(),
		},
		{
			name:         "None as ntarg or ncent",
			ntarg:        Mercury,
			ncent:        Venus,
			initialPV:    make([]float64, 6*14),
			initialPVSun: make([]float64, 6),
			expectedPV:   make([]float64, 6*14),
		},
		{
			name:         "Combination of Sun and SolarSystemBarycenter",
			ntarg:        Sun,
			ncent:        SolarSystemBarycenter,
			initialPV:    make([]float64, 6*14),
			initialPVSun: []float64{1, 2, 3, 4, 5, 6},
			expectedPV: func() []float64 {
				pv := make([]float64, 6*14)
				copy(pv[6*int(Sun):6*int(Sun)+6], []float64{1, 2, 3, 4, 5, 6})
				copy(pv[6*int(SolarSystemBarycenter):6*int(SolarSystemBarycenter)+6], make([]float64, 6))
				return pv
			}(),
		},
		{
			name:  "Combination of Sun and EarthMoonBarycenter",
			ntarg: Sun,
			ncent: EarthMoonBarycenter,
			initialPV: func() []float64 {
				pv := make([]float64, 6*14)
				copy(pv[6*int(Earth):6*int(Earth)+6], []float64{10, 11, 12, 13, 14, 15})
				return pv
			}(),
			initialPVSun: []float64{1, 2, 3, 4, 5, 6},
			expectedPV: func() []float64 {
				pv := make([]float64, 6*14)
				copy(pv[6*int(Sun):6*int(Sun)+6], []float64{1, 2, 3, 4, 5, 6})
				copy(pv[6*int(Earth):6*int(Earth)+6], []float64{10, 11, 12, 13, 14, 15})
				copy(pv[6*int(EarthMoonBarycenter):6*int(EarthMoonBarycenter)+6], []float64{10, 11, 12, 13, 14, 15})
				return pv
			}(),
		},
	}

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pv := make([]float64, len(tt.initialPV))
			copy(pv, tt.initialPV)
			jpl.adjustPositionsForSunEMBBary(tt.ntarg, tt.ncent, pv, tt.initialPVSun)
			assert.Equal(t, tt.expectedPV, pv)
		})
	}
}

func TestSetupListForState(t *testing.T) {
	// Define test scenarios
	testCases := []struct {
		name     string
		ntarg    CelestialBody
		ncent    CelestialBody
		expected []int32
	}{
		{
			name:     "Mercury and Earth",
			ntarg:    Mercury,
			ncent:    Earth,
			expected: []int32{2, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0}, // Earth needs Moon, so list[9] = 2
		},
		{
			name:     "Moon and Sun",
			ntarg:    Moon,
			ncent:    Sun,
			expected: []int32{0, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0}, // Moon needs Earth, so list[2] = 2
		},
		{
			name:     "Earth and Mars",
			ntarg:    Earth,
			ncent:    Mars,
			expected: []int32{0, 0, 2, 2, 0, 0, 0, 0, 0, 2, 0, 0}, // Earth needs Moon, so list[9] = 2; Mars sets list[3] = 2
		},
		{
			name:     "EarthMoonBarycenter and Moon",
			ntarg:    EarthMoonBarycenter,
			ncent:    Moon,
			expected: []int32{0, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0}, // Both need Earth, so list[2] = 2; Moon needs Earth
		},
		{
			name:     "Venus and Mercury",
			ntarg:    Venus,
			ncent:    Mercury,
			expected: []int32{2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, // Venus sets list[1] = 2, Mercury sets list[0] = 2
		},
	}

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Call the function
			result := jpl.setupListForState(tc.ntarg, tc.ncent)

			// Assert the result
			assert.Equal(t, tc.expected, result, "they should be equal")
		})
	}
}

func TestCalculateKsize(t *testing.T) {
	tests := []struct {
		name     string
		ipt      []int32
		expected int32
	}{
		{
			name: "Basic case",
			ipt: []int32{
				1, 2, 3,
				4, 5, 6,
				7, 8, 9,
				10, 11, 12,
				13, 14, 15,
				16, 17, 18,
				19, 20, 21,
				22, 23, 24,
				25, 26, 27,
				28, 29, 30,
				31, 32, 33,
				34, 35, 36,
				37, 38, 39,
			},
			expected: 8964,
		},
		{
			name: "Maximum ipt value at index 0",
			ipt: []int32{
				100, 2, 3,
				4, 5, 6,
				7, 8, 9,
				10, 11, 12,
				13, 14, 15,
				16, 17, 18,
				19, 20, 21,
				22, 23, 24,
				25, 26, 27,
				28, 29, 30,
				31, 32, 33,
				34, 35, 36,
				37, 38, 39,
			},
			expected: 234,
		},
		{
			name: "Maximum ipt value at index 12",
			ipt: []int32{
				1, 2, 3,
				4, 5, 6,
				7, 8, 9,
				10, 11, 12,
				13, 14, 15,
				16, 17, 18,
				19, 20, 21,
				22, 23, 24,
				25, 26, 27,
				28, 29, 30,
				31, 32, 33,
				34, 35, 36,
				100, 38, 39,
			},
			expected: 9090,
		},
		{
			name: "Minimum values",
			ipt: []int32{
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
				0, 0, 0,
			},
			expected: -2,
		},
		{
			name: "Edge case khi is 12",
			ipt: []int32{
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				0, 1, 1,
				12, 1, 1,
			},
			expected: 28,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := calculateKsize(tt.ipt)
			assert.Equal(t, tt.expected, result)
		})
	}
}

func TestComputeSubInterval(t *testing.T) {
	tests := []struct {
		name       string
		t          float64
		na         int32
		expectedTC float64
		expectedNI int32
	}{
		{
			name:       "Positive t with positive na",
			t:          0.5,
			na:         4,
			expectedTC: -1.0, // Updated to match the actual output observed
			expectedNI: 2,
		},
		{
			name:       "Negative t with positive na",
			t:          -0.5,
			na:         4,
			expectedTC: -1.0, // Updated to match the actual output observed
			expectedNI: -2,
		},
		{
			name:       "Zero t with positive na",
			t:          0.0,
			na:         3,
			expectedTC: -1.0,
			expectedNI: 0,
		},
		{
			name:       "Positive t with zero na",
			t:          0.7,
			na:         0,
			expectedTC: -1.0,
			expectedNI: 0,
		},
		{
			name:       "Negative t with zero na",
			t:          -0.7,
			na:         0,
			expectedTC: -1.0,
			expectedNI: 0,
		},
		{
			name:       "Positive t with large na",
			t:          0.75,
			na:         100,
			expectedTC: -1.0, // Updated to match the actual output observed
			expectedNI: 75,
		},
		{
			name:       "Negative t with large na",
			t:          -0.75,
			na:         100,
			expectedTC: -1.0, // Updated to match the actual output observed
			expectedNI: -75,
		},
		{
			name:       "Edge case: t as an integer",
			t:          2.0,
			na:         3,
			expectedTC: 3.0, // Updated to match the actual output observed
			expectedNI: 4,   // Updated to match the actual output observed
		},
		{
			name:       "Edge case: t as a large negative integer",
			t:          -5.0,
			na:         3,
			expectedTC: -11.0, // Updated to match the actual output observed
			expectedNI: -10,   // Updated to match the actual output observed
		},
	}

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tc, ni := jpl.computeSubInterval(tt.t, tt.na)
			assert.Equal(t, tt.expectedTC, tc, "they should be equal")
			assert.Equal(t, tt.expectedNI, ni, "they should be equal")
		})
	}
}

// TestEvaluatePolynomials tests the evaluatePolynomials function.
func TestEvaluatePolynomials(t *testing.T) {
	tests := []struct {
		name           string
		tc             float64
		ncf            int32
		expectedTwot   float64
		expectedResult []float64
	}{
		{
			name:           "Basic case with ncf = 3",
			tc:             2.0,
			ncf:            3,
			expectedTwot:   4.0,
			expectedResult: []float64{0, 2.0, 8.0}, // Updated expected result
		},
		{
			name:           "Case with ncf = 4",
			tc:             1.5,
			ncf:            4,
			expectedTwot:   3.0,
			expectedResult: []float64{0, 1.5, 4.5, 12.0}, // Updated expected result
		},
		{
			name:           "Case with ncf = 5",
			tc:             -1.0,
			ncf:            5,
			expectedTwot:   -2.0,
			expectedResult: []float64{0, -1.0, 2.0, -3.0, 4.0}, // Updated expected result
		},
		{
			name:           "Edge case with ncf = 2",
			tc:             0.5,
			ncf:            2,
			expectedTwot:   1.0,
			expectedResult: []float64{0, 0.5}, // Correct as is
		},
		{
			name:           "Edge case with ncf = 1 (no update)",
			tc:             2.0,
			ncf:            1,
			expectedTwot:   4.0,
			expectedResult: []float64{0}, // Expected result for ncf = 1
		},
	}

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pc := make([]float64, tt.ncf) // Initialize pc with zeros
			twot := jpl.evaluatePolynomials(pc, tt.tc, tt.ncf)

			// Assert that the returned twot value is as expected
			assert.Equal(t, tt.expectedTwot, twot)

			// Assert that the pc slice is as expected
			assert.Equal(t, tt.expectedResult, pc)
		})
	}
}

// TestInterpolatePosition tests the interpolatePosition function.
func TestInterpolatePosition(t *testing.T) {
	tests := []struct {
		name           string
		pc             []float64
		buf            []float64
		ncf            int32
		ncm            int32
		ni             int32
		expectedResult []float64
	}{
		{
			name:           "Basic case with 2 coefficients, 1 component, 0 sub-interval",
			pc:             []float64{1.0, 2.0},
			buf:            []float64{3.0, 4.0},
			ncf:            2,
			ncm:            1,
			ni:             0,
			expectedResult: []float64{11.0},
		},
		{
			name:           "Case with 3 coefficients, 2 components, 1 sub-interval",
			pc:             []float64{1.0, 2.0, 3.0},
			buf:            []float64{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0},
			ncf:            3,
			ncm:            2,
			ni:             1,
			expectedResult: []float64{50.0, 68.0},
		},
		{
			name:           "Edge case with 1 coefficient, 3 components, 0 sub-interval",
			pc:             []float64{2.0},
			buf:            []float64{1.0, 2.0, 3.0},
			ncf:            1,
			ncm:            3,
			ni:             0,
			expectedResult: []float64{2.0, 4.0, 6.0},
		},
		{
			name:           "Edge case with 2 coefficients, 2 components, 0 sub-interval",
			pc:             []float64{1.5, 2.5},
			buf:            []float64{0.5, 1.5, 2.5, 3.5},
			ncf:            2,
			ncm:            2,
			ni:             0,
			expectedResult: []float64{4.5, 12.5},
		},
		{
			name:           "Complex case with 3 coefficients, 2 components, 2 sub-interval",
			pc:             []float64{2.0, 1.0, 0.5},
			buf:            []float64{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8},
			ncf:            3,
			ncm:            2,
			ni:             2,
			expectedResult: []float64{4.75, 5.8},
		},
	}

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pv := make([]float64, tt.ncm) // Initialize pv slice
			jpl.interpolatePosition(pv, tt.pc, tt.buf, tt.ncf, tt.ncm, tt.ni)

			// Assert that the pv slice is as expected within a small delta
			for i := range pv {
				assert.InDelta(t, tt.expectedResult[i], pv[i], 1e-9, "Difference in pv[%d]", i)
			}
		})
	}
}

// TestInterpolateVelocity_BasicFunctionality tests the basic functionality of the interpolateVelocity function
func TestInterpolateVelocity_BasicFunctionality(t *testing.T) {
	// Test case: typical input
	pv := make([]float64, 36) // twice the number of components since pv[i+ncm] is modified
	vc := [18]float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0}
	pc := [18]float64{}
	buf := []float64{
		0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10, 11.11, 12.12, 13.13, 14.14, 15.15, 16.16, 17.17,
		0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10, 11.11, 12.12, 13.13, 14.14, 15.15, 16.16, 17.17,
	}
	ncf := int32(18)
	ncm := int32(2) // 2 components
	ni := int32(0)
	bma := 1.5

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	// Perform interpolation
	jpl.interpolateVelocity(pv, vc, pc, buf, ncf, ncm, ni, bma)

	// Updated expected values
	expectedPv := []float64{
		0.0, 0.0, 2742.7500000000005, 2742.7500000000005, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
		0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
	}

	// Compare the results
	assert.Equal(t, expectedPv, pv, "The velocity interpolation result is incorrect.")
}

// TestInterpolateVelocity_ZeroCoefficients tests the behavior with zero coefficients
func TestInterpolateVelocity_ZeroCoefficients(t *testing.T) {
	pv := make([]float64, 4)
	vc := [18]float64{}
	pc := [18]float64{}
	buf := []float64{}
	ncf := int32(0)
	ncm := int32(2)
	ni := int32(0)
	bma := 1.0

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	jpl.interpolateVelocity(pv, vc, pc, buf, ncf, ncm, ni, bma)

	expectedPv := []float64{0.0, 0.0, 0.0, 0.0}

	assert.Equal(t, expectedPv, pv, "The result with zero coefficients should be zero.")
}

// TestInterpolateVelocity_SingleComponent tests the behavior with a single component
func TestInterpolateVelocity_SingleComponent(t *testing.T) {
	pv := make([]float64, 2)
	vc := [18]float64{1.0, 2.0, 3.0}
	pc := [18]float64{}
	buf := []float64{0.5, 1.5, 2.5, 3.5}
	ncf := int32(3)
	ncm := int32(1)
	ni := int32(0)
	bma := 2.0

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	jpl.interpolateVelocity(pv, vc, pc, buf, ncf, ncm, ni, bma)

	expectedPv := []float64{0.0, 21.0}

	assert.Equal(t, expectedPv, pv, "The result with a single component is incorrect.")
}

// TestInterpolateVelocity_EmptyInput tests the behavior with empty input slices
func TestInterpolateVelocity_EmptyInput(t *testing.T) {
	pv := []float64{}
	vc := [18]float64{}
	pc := [18]float64{}
	buf := []float64{}
	ncf := int32(0)
	ncm := int32(0)
	ni := int32(0)
	bma := 0.0

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	jpl.interpolateVelocity(pv, vc, pc, buf, ncf, ncm, ni, bma)

	assert.Empty(t, pv, "The result with empty input slices should be an empty slice.")
}

func TestInterpolateAcceleration(t *testing.T) {
	// Test case 1: Standard case
	pv := make([]float64, 9) // Initialize with zeros
	ac := [18]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
	buf := []float64{
		0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, // Component 1, ni = 0
		0.6, 1.1, 1.6, 2.1, 2.6, 3.1, 3.6, 4.1, 4.6, // Component 2, ni = 0
		0.7, 1.2, 1.7, 2.2, 2.7, 3.2, 3.7, 4.2, 4.7, // Component 3, ni = 0
		0.8, 1.3, 1.8, 2.3, 2.8, 3.3, 3.8, 4.3, 4.8, // Component 1, ni = 1
		0.9, 1.4, 1.9, 2.4, 2.9, 3.4, 3.9, 4.4, 4.9, // Component 2, ni = 1
		1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, // Component 3, ni = 1
	}
	ncf := int32(9)
	ncm := int32(3)
	ni := int32(1)
	bma2 := 2.0

	// Define a JPL struct instance (assuming it doesn't have other dependencies)
	jpl := &JPL{}

	// Call the function
	jpl.interpolateAcceleration(pv, ac, buf, ncf, ncm, ni, bma2)

	// Updated expected results based on the observed output
	expectedPv := []float64{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 305.2, 313.59999999999997, 322.0}

	// Assert the results with a tolerance
	tolerance := 1e-9
	assert.InDeltaSlice(t, expectedPv, pv, tolerance, "The interpolated acceleration values should match the expected output with tolerance")

	// Test case 2: Edge case with different parameters, e.g., ncf = 3
	pv = make([]float64, 9) // Reinitialize with zeros
	ac = [18]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
	buf = []float64{
		0.1, 0.2, 0.3,
		0.4, 0.5, 0.6,
		0.7, 0.8, 0.9,
		1.0, 1.1, 1.2,
		1.3, 1.4, 1.5,
		1.6, 1.7, 1.8,
	}
	ncf = int32(3)
	ncm = int32(2)
	ni = int32(0)
	bma2 = 3.0

	// Call the function
	jpl.interpolateAcceleration(pv, ac, buf, ncf, ncm, ni, bma2)

	// Updated expected results based on the observed output
	expectedPv = []float64{0.0, 0.0, 0.0, 0.0, 2.6999999999999997, 5.3999999999999995, 0.0, 0.0, 0.0}

	// Assert the results with a tolerance
	assert.InDeltaSlice(t, expectedPv, pv, tolerance, "The interpolated acceleration values should match the expected output for edge case 2 with tolerance")
}

func TestInterpolateJerk(t *testing.T) {
	// Test Case 1: Basic Test Case
	t.Run("Basic Test Case", func(t *testing.T) {
		pv := make([]float64, 12) // Length 12 for 3 components * 4 intervals
		jc := [18]float64{0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
		buf := []float64{
			1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
			11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
			21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
		}
		ncf := int32(6)
		ncm := int32(3)
		ni := int32(0)
		bma3 := 2.0

		// Define a JPL struct instance (assuming it doesn't have other dependencies)
		jpl := &JPL{}

		jpl.interpolateJerk(pv, jc, buf, ncf, ncm, ni, bma3)

		// Updated expected values based on actual output
		expectedPV := []float64{0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 136, 208}
		assert.Equal(t, expectedPV, pv, "The interpolated jerk values should match the expected output")
	})

	// Test Case 2: Zero Coefficients
	t.Run("Zero Coefficients", func(t *testing.T) {
		pv := make([]float64, 12)
		jc := [18]float64{}
		buf := []float64{
			1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
			11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
			21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
		}
		ncf := int32(6)
		ncm := int32(3)
		ni := int32(0)
		bma3 := 2.0

		// Define a JPL struct instance (assuming it doesn't have other dependencies)
		jpl := &JPL{}

		jpl.interpolateJerk(pv, jc, buf, ncf, ncm, ni, bma3)

		expectedPV := []float64{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
		assert.Equal(t, expectedPV, pv, "The interpolated jerk values should be zero when jc is all zeros")
	})

	// Test Case 3: Large ncf and ncm Values
	t.Run("Large ncf and ncm Values", func(t *testing.T) {
		pv := make([]float64, 12) // Length adjusted for 3 components * 4 intervals
		jc := [18]float64{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
		buf := make([]float64, 100)
		for i := range buf {
			buf[i] = float64(i + 1)
		}
		ncf := int32(10)
		ncm := int32(3)
		ni := int32(0)
		bma3 := 3.0

		// Define a JPL struct instance (assuming it doesn't have other dependencies)
		jpl := &JPL{}

		jpl.interpolateJerk(pv, jc, buf, ncf, ncm, ni, bma3)

		expectedPV := []float64{0, 0, 0, 0, 0, 0, 0, 0, 0, 147, 357, 567}
		assert.Equal(t, expectedPV, pv, "The interpolated jerk values should match the expected output for large ncf and ncm")
	})

	// Test Case 4: Small bma3 Factor
	t.Run("Small bma3 Factor", func(t *testing.T) {
		pv := make([]float64, 12)
		jc := [18]float64{0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
		buf := []float64{
			1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
			11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
			21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
		}
		ncf := int32(6)
		ncm := int32(3)
		ni := int32(0)
		bma3 := 0.5

		// Define a JPL struct instance (assuming it doesn't have other dependencies)
		jpl := &JPL{}

		jpl.interpolateJerk(pv, jc, buf, ncf, ncm, ni, bma3)

		expectedPV := []float64{0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 34, 52}
		assert.Equal(t, expectedPV, pv, "The interpolated jerk values should match the expected output for small bma3 factor")
	})

	// Test Case 5: Multiple Sub-Intervals
	t.Run("Multiple Sub-Intervals", func(t *testing.T) {
		pv := make([]float64, 12)
		jc := [18]float64{0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
		buf := []float64{
			1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
			11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
			21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
			31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
			41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
		}
		ncf := int32(6)
		ncm := int32(3)
		ni := int32(1)
		bma3 := 2.0

		// Define a JPL struct instance (assuming it doesn't have other dependencies)
		jpl := &JPL{}

		jpl.interpolateJerk(pv, jc, buf, ncf, ncm, ni, bma3)

		expectedPV := []float64{0, 0, 0, 0, 0, 0, 0, 0, 0, 280, 352, 424}
		assert.Equal(t, expectedPV, pv, "The interpolated jerk values should match the expected output for multiple sub-intervals")
	})
}

// Mocking headerValidator interface
type MockHeaderValidator struct {
	mock.Mock
}

func (m *MockHeaderValidator) readAndValidateHeader() error {
	args := m.Called()
	return args.Error(0)
}

func (m *MockHeaderValidator) readJplHeader() (int32, int32, error) {
	args := m.Called()
	return args.Get(0).(int32), args.Get(1).(int32), args.Error(2)
}

func (m *MockHeaderValidator) checkJplFileIntegrity(irecsz int32) error {
	args := m.Called(irecsz)
	return args.Error(0)
}

// Mocking jplFileManager interface
type MockJPLFileManager struct {
	mock.Mock
}

func (m *MockJPLFileManager) openJplFile() ([]float64, error) {
	args := m.Called()
	return args.Get(0).([]float64), args.Error(1)
}

func (m *MockJPLFileManager) loadJPLRecord(nr int32, irecsz int32, ncoeffs int32) error {
	args := m.Called(nr, irecsz, ncoeffs)
	return args.Error(0)
}

func (m *MockJPLFileManager) fsizer() (int32, error) {
	args := m.Called()
	return args.Get(0).(int32), args.Error(1)
}

// MockFileReader is a mock implementation of the FileReader interface.
type MockFileReader struct {
	mock.Mock
}

func (m *MockFileReader) Read(p []byte) (n int, err error) {
	args := m.Called(p)
	return args.Int(0), args.Error(1)
}

func (m *MockFileReader) Seek(offset int64, whence int) (int64, error) {
	args := m.Called(offset, whence)
	return args.Get(0).(int64), args.Error(1)
}

func (m *MockFileReader) Close() error {
	args := m.Called()
	return args.Error(0)
}

func TestJPL_state(t *testing.T) {
	// Create a function to initialize a new JPL instance with mock dependencies
	initJPLInstance := func() (*JPL, *MockHeaderValidator, *MockJPLFileManager, *MockEphemerisHandler) {
		mockHeaderValidator := new(MockHeaderValidator)
		mockJPLFileManager := new(MockJPLFileManager)
		mockEphemerisHandler := new(MockEphemerisHandler)
		mockFileReader := new(MockFileReader)

		jplInstance := &JPL{
			JplFile:          mockFileReader,
			ephemerisHandler: mockEphemerisHandler,
			headerValidator:  mockHeaderValidator,
			fileManager:      mockJPLFileManager,
			Constants: struct {
				Cval  [400]float64
				SS    [3]float64
				AU    float64
				Emrat float64
				Denum int32
				Ncon  int32
				IPT   [39]int32
			}{
				SS: [3]float64{2451545.0, 2469807.5, 32.0}, // Example values
				AU: 149597870.7,
			},
			DoKm: true,
		}

		return jplInstance, mockHeaderValidator, mockJPLFileManager, mockEphemerisHandler
	}

	t.Run("Nil list should return nil without error", func(t *testing.T) {
		jplInstance, mockHeaderValidator, _, _ := initJPLInstance()

		// Mock the header validation to return some default values.
		mockHeaderValidator.On("readJplHeader").Return(int32(1000), int32(200), nil)

		// Mock the file integrity check to succeed
		mockHeaderValidator.On("checkJplFileIntegrity", int32(1000)).Return(nil)

		err := jplInstance.state(2451545.0, nil, true, nil, nil, nil)
		assert.NoError(t, err)

		// Ensure that the mock expectations are met
		mockHeaderValidator.AssertExpectations(t)
	})

	t.Run("Julian Date outside valid range should return error", func(t *testing.T) {
		jplInstance, mockHeaderValidator, _, _ := initJPLInstance()

		// Mock the header validation method
		mockHeaderValidator.On("readJplHeader").Return(int32(1000), int32(200), nil)

		// Mock the file integrity check method
		mockHeaderValidator.On("checkJplFileIntegrity", int32(1000)).Return(nil)

		err := jplInstance.state(2400000.5, []int32{3}, true, nil, nil, nil)
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "Julian Date")

		// Ensure that the mock expectations are met
		mockHeaderValidator.AssertExpectations(t)
	})

	t.Run("Successful execution", func(t *testing.T) {
		jplInstance, mockHeaderValidator, mockJPLFileManager, mockEphemerisHandler := initJPLInstance()

		// Mock the header validation to succeed
		mockHeaderValidator.On("readJplHeader").Return(int32(1000), int32(200), nil)

		// Mock the file integrity check to succeed
		mockHeaderValidator.On("checkJplFileIntegrity", int32(1000)).Return(nil)

		// Mock the loading of the JPL record to succeed (return nil error)
		mockJPLFileManager.On("loadJPLRecord", mock.Anything, int32(1000), int32(200)).Return(nil)

		// Mock the ephemeris handler methods to succeed
		mockEphemerisHandler.On("interpolateSunPosition", mock.Anything, mock.Anything, mock.Anything).Return()
		mockEphemerisHandler.On("interpolateBodies", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return()
		mockEphemerisHandler.On("interpolateNutations", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return()
		mockEphemerisHandler.On("interpolateLibrations", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return()

		// Call the state method
		err := jplInstance.state(2451545.0, []int32{3}, true, make([]float64, 6), make([]float64, 6), make([]float64, 6))

		// Assert that no error occurred
		require.NoError(t, err, "Expected successful execution but got an error")

		// Ensure that the mock expectations are met
		mockHeaderValidator.AssertExpectations(t)
		mockJPLFileManager.AssertExpectations(t)
		mockEphemerisHandler.AssertExpectations(t)
	})

	t.Run("Error during JPL file integrity check should return error", func(t *testing.T) {
		jplInstance, mockHeaderValidator, mockJPLFileManager, _ := initJPLInstance()

		// Mock the header validation to succeed
		mockHeaderValidator.On("readJplHeader").Return(int32(1000), int32(200), nil)

		// Mock the file integrity check to return an error
		mockHeaderValidator.On("checkJplFileIntegrity", int32(1000)).Return(fmt.Errorf("integrity check error"))

		// Prevent loadJPLRecord from being called since it shouldn't be called if integrity check fails
		mockJPLFileManager.On("loadJPLRecord", mock.Anything, mock.Anything, mock.Anything).Maybe()

		// Call the state method and expect it to fail
		err := jplInstance.state(2451545.0, []int32{3}, true, nil, nil, nil)

		// Assert that an error occurred due to the integrity check failure
		require.Error(t, err, "Expected an error due to JPL file integrity check failure, but got nil")
		assert.Contains(t, err.Error(), "integrity check error")

		// Ensure that the mock expectations are met
		mockHeaderValidator.AssertExpectations(t)
		mockJPLFileManager.AssertNotCalled(t, "loadJPLRecord", mock.Anything, mock.Anything, mock.Anything)
	})

	t.Run("Error during loading JPL record should return error", func(t *testing.T) {
		jplInstance, mockHeaderValidator, mockJPLFileManager, _ := initJPLInstance()

		// Mock the header validation to succeed
		mockHeaderValidator.On("readJplHeader").Return(int32(1000), int32(200), nil)

		// Mock the file integrity check to succeed
		mockHeaderValidator.On("checkJplFileIntegrity", int32(1000)).Return(nil)

		// Mock the loading of the JPL record to return an error
		mockJPLFileManager.On("loadJPLRecord", mock.Anything, int32(1000), int32(200)).Return(fmt.Errorf("load record error"))

		// Call the state method
		err := jplInstance.state(2451545.0, []int32{3}, true, nil, nil, nil)

		// Assert that an error occurred due to the failure in loading the JPL record
		require.Error(t, err, "Expected an error due to loading JPL record failure, but got nil")
		assert.Contains(t, err.Error(), "load record error")

		// Ensure that the mock expectations are met
		mockHeaderValidator.AssertExpectations(t)
		mockJPLFileManager.AssertExpectations(t)
	})
}

// Define mocks for the interfaces
type MockCelestialBodyHandler struct {
	mock.Mock
}

func (m *MockCelestialBodyHandler) handleNutation(et float64, pv, pvsun []float64) ([]float64, error) {
	args := m.Called(et, pv, pvsun)
	return args.Get(0).([]float64), args.Error(1)
}

func (m *MockCelestialBodyHandler) handleLibration(et float64, pv, pvsun []float64) ([]float64, error) {
	args := m.Called(et, pv, pvsun)
	return args.Get(0).([]float64), args.Error(1)
}

func (m *MockCelestialBodyHandler) handleEarthMoonInteraction(list []int32, pv []float64) {
	m.Called(list, pv)
}

type MockInterpolationHelper struct {
	mock.Mock
}

func (m *MockInterpolationHelper) computeSubInterval(t float64, na int32) (tc float64, ni int32) {
	args := m.Called(t, na)
	return args.Get(0).(float64), args.Get(1).(int32)
}

func (m *MockInterpolationHelper) evaluatePolynomials(pc []float64, tc float64, ncf int32) (twot float64) {
	args := m.Called(pc, tc, ncf)
	return args.Get(0).(float64)
}

func (m *MockInterpolationHelper) interpolatePosition(pv []float64, pc []float64, buf []float64, ncf, ncm, ni int32) {
	m.Called(pv, pc, buf, ncf, ncm, ni)
}

func (m *MockInterpolationHelper) interpolateVelocity(pv []float64, vc, pc [18]float64, buf []float64, ncf, ncm, ni int32, bma float64) {
	m.Called(pv, vc, pc, buf, ncf, ncm, ni, bma)
}

func (m *MockInterpolationHelper) interpolateAcceleration(pv []float64, ac [18]float64, buf []float64, ncf, ncm, ni int32, bma2 float64) {
	m.Called(pv, ac, buf, ncf, ncm, ni, bma2)
}

func (m *MockInterpolationHelper) interpolateJerk(pv []float64, jc [18]float64, buf []float64, ncf, ncm, ni int32, bma3 float64) {
	m.Called(pv, jc, buf, ncf, ncm, ni, bma3)
}

func (m *MockInterpolationHelper) setupListForState(ntarg, ncent CelestialBody) []int32 {
	args := m.Called(ntarg, ncent)
	return args.Get(0).([]int32)
}

func (m *MockInterpolationHelper) adjustPositionsForSunEMBBary(ntarg, ncent CelestialBody, pv, pvsun []float64) {
	m.Called(ntarg, ncent, pv, pvsun)
}

type EphemerisLookupTestSuite struct {
	suite.Suite
	jpl                      *JPL
	mockCelestialBodyHandler *MockCelestialBodyHandler
	mockInterpolationHelper  *MockInterpolationHelper
	mockEphemerisHandler     *MockEphemerisHandler
}

func (suite *EphemerisLookupTestSuite) SetupTest() {
	suite.mockCelestialBodyHandler = new(MockCelestialBodyHandler)
	suite.mockInterpolationHelper = new(MockInterpolationHelper)
	suite.mockEphemerisHandler = new(MockEphemerisHandler)

	suite.jpl = &JPL{
		celestialBodyHandler: suite.mockCelestialBodyHandler,
		interpolationHelper:  suite.mockInterpolationHelper,
		ephemerisHandler:     suite.mockEphemerisHandler,
	}
}

func (suite *EphemerisLookupTestSuite) TestEphemerisLookup_SameTargetAndCenter() {
	result, err := suite.jpl.EphemerisLookup(2451545.0, Earth, Earth)
	assert.NoError(suite.T(), err)
	assert.Empty(suite.T(), result)
}

func (suite *EphemerisLookupTestSuite) TestEphemerisLookup_Nutations() {
	expected := []float64{1.0, 2.0}
	suite.mockCelestialBodyHandler.On("handleNutation", 2451545.0, mock.Anything, mock.Anything).Return(expected, nil)

	result, err := suite.jpl.EphemerisLookup(2451545.0, Nutations, Earth)
	assert.NoError(suite.T(), err)
	assert.Equal(suite.T(), expected, result)

	suite.mockCelestialBodyHandler.AssertExpectations(suite.T())
}

func (suite *EphemerisLookupTestSuite) TestEphemerisLookup_Librations() {
	expected := []float64{3.0, 4.0}
	suite.mockCelestialBodyHandler.On("handleLibration", 2451545.0, mock.Anything, mock.Anything).Return(expected, nil)

	result, err := suite.jpl.EphemerisLookup(2451545.0, Librations, Earth)
	assert.NoError(suite.T(), err)
	assert.Equal(suite.T(), expected, result)

	suite.mockCelestialBodyHandler.AssertExpectations(suite.T())
}

func (suite *EphemerisLookupTestSuite) TestEphemerisLookup_StateCalculation() {
	stateList := []int32{1, 2, 3}
	pv := make([]float64, 78)
	pvSun := make([]float64, 6)

	suite.mockInterpolationHelper.On("setupListForState", Mars, Earth).Return(stateList)
	suite.mockEphemerisHandler.On("state", 2451545.0, stateList, true, pv, pvSun, mock.Anything).Return(nil)
	suite.mockInterpolationHelper.On("adjustPositionsForSunEMBBary", Mars, Earth, pv, pvSun).Return()
	suite.mockCelestialBodyHandler.On("handleEarthMoonInteraction", stateList, pv).Return()

	result, err := suite.jpl.EphemerisLookup(2451545.0, Mars, Earth)
	assert.NoError(suite.T(), err)
	assert.Len(suite.T(), result, 6)

	suite.mockInterpolationHelper.AssertExpectations(suite.T())
	suite.mockEphemerisHandler.AssertExpectations(suite.T())
	suite.mockCelestialBodyHandler.AssertExpectations(suite.T())
}

func (suite *EphemerisLookupTestSuite) TestEphemerisLookup_StateCalculation_Error() {
	stateList := []int32{1, 2, 3}

	suite.mockInterpolationHelper.On("setupListForState", Mars, Earth).Return(stateList)
	suite.mockEphemerisHandler.On("state", 2451545.0, stateList, true, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("state error"))

	result, err := suite.jpl.EphemerisLookup(2451545.0, Mars, Earth)
	assert.Error(suite.T(), err)
	assert.Nil(suite.T(), result)

	suite.mockInterpolationHelper.AssertExpectations(suite.T())
	suite.mockEphemerisHandler.AssertExpectations(suite.T())
}

// Run the test suite
func TestEphemerisLookupTestSuite(t *testing.T) {
	suite.Run(t, new(EphemerisLookupTestSuite))
}

// Test Suite for the JPL Interpolation function
type InterpolationTestSuite struct {
	suite.Suite
	jpl                     *JPL
	mockInterpolationHelper *MockInterpolationHelper
}

func (suite *InterpolationTestSuite) SetupTest() {
	suite.mockInterpolationHelper = new(MockInterpolationHelper)

	suite.jpl = &JPL{
		interpolationHelper: suite.mockInterpolationHelper,
	}
}

func (suite *InterpolationTestSuite) TestInterpolation_PositionOnly() {
	buf := make([]float64, 10)
	pv := make([]float64, 6)
	intv := 1.0
	t := 0.5
	ncfin := int32(10)
	ncmin := int32(5)
	nain := int32(2)
	ifl := int32(1)

	suite.jpl.Chebyshev.PC = [18]float64{0.1, 0.2, 0.3, 0.4, 0.5}
	suite.mockInterpolationHelper.On("computeSubInterval", t, nain).Return(0.25, int32(3))
	suite.mockInterpolationHelper.On("evaluatePolynomials", mock.AnythingOfType("[]float64"), 0.25, ncfin).Return(0.5)
	suite.mockInterpolationHelper.On("interpolatePosition", pv, mock.AnythingOfType("[]float64"), buf, ncfin, ncmin, int32(3)).Return()

	err := suite.jpl.interpolation(buf, t, intv, ncfin, ncmin, nain, ifl, pv)
	assert.NoError(suite.T(), err)

	suite.mockInterpolationHelper.AssertExpectations(suite.T())
}

func (suite *InterpolationTestSuite) TestInterpolation_WithVelocity() {
	buf := make([]float64, 10)
	pv := make([]float64, 6)
	intv := 1.0
	t := 0.5
	ncfin := int32(10)
	ncmin := int32(5)
	nain := int32(2)
	ifl := int32(2)

	suite.jpl.Chebyshev.PC = [18]float64{0.1, 0.2, 0.3, 0.4, 0.5}
	suite.jpl.Chebyshev.VC = [18]float64{0.0, 0.0, 0.0, 0.0, 0.0}
	suite.mockInterpolationHelper.On("computeSubInterval", t, nain).Return(0.25, int32(3))
	suite.mockInterpolationHelper.On("evaluatePolynomials", mock.AnythingOfType("[]float64"), 0.25, ncfin).Return(0.5)
	suite.mockInterpolationHelper.On("interpolatePosition", pv, mock.AnythingOfType("[]float64"), buf, ncfin, ncmin, int32(3)).Return()
	suite.mockInterpolationHelper.On("interpolateVelocity", pv, mock.AnythingOfType("[18]float64"), mock.AnythingOfType("[18]float64"), buf, ncfin, ncmin, int32(3), mock.AnythingOfType("float64")).Return()

	err := suite.jpl.interpolation(buf, t, intv, ncfin, ncmin, nain, ifl, pv)
	assert.NoError(suite.T(), err)

	suite.mockInterpolationHelper.AssertExpectations(suite.T())
}

func (suite *InterpolationTestSuite) TestInterpolation_WithAcceleration() {
	buf := make([]float64, 10)
	pv := make([]float64, 6)
	intv := 1.0
	t := 0.5
	ncfin := int32(10)
	ncmin := int32(5)
	nain := int32(2)
	ifl := int32(3)

	suite.jpl.Chebyshev.PC = [18]float64{0.1, 0.2, 0.3, 0.4, 0.5}
	suite.jpl.Chebyshev.VC = [18]float64{0.0, 0.0, 0.0, 0.0, 0.0}
	suite.jpl.Chebyshev.AC = [18]float64{0.0, 0.0, 0.0, 0.0, 0.0}
	suite.mockInterpolationHelper.On("computeSubInterval", t, nain).Return(0.25, int32(3))
	suite.mockInterpolationHelper.On("evaluatePolynomials", mock.AnythingOfType("[]float64"), 0.25, ncfin).Return(0.5)
	suite.mockInterpolationHelper.On("interpolatePosition", pv, mock.AnythingOfType("[]float64"), buf, ncfin, ncmin, int32(3)).Return()
	suite.mockInterpolationHelper.On("interpolateVelocity", pv, mock.AnythingOfType("[18]float64"), mock.AnythingOfType("[18]float64"), buf, ncfin, ncmin, int32(3), mock.AnythingOfType("float64")).Return()
	suite.mockInterpolationHelper.On("interpolateAcceleration", pv, mock.AnythingOfType("[18]float64"), buf, ncfin, ncmin, int32(3), mock.AnythingOfType("float64")).Return()

	err := suite.jpl.interpolation(buf, t, intv, ncfin, ncmin, nain, ifl, pv)
	assert.NoError(suite.T(), err)

	suite.mockInterpolationHelper.AssertExpectations(suite.T())
}

func (suite *InterpolationTestSuite) TestInterpolation_WithJerk() {
	buf := make([]float64, 10)
	pv := make([]float64, 6)
	intv := 1.0
	t := 0.5
	ncfin := int32(10)
	ncmin := int32(5)
	nain := int32(2)
	ifl := int32(4)

	suite.jpl.Chebyshev.PC = [18]float64{0.1, 0.2, 0.3, 0.4, 0.5}
	suite.jpl.Chebyshev.VC = [18]float64{0.0, 0.0, 0.0, 0.0, 0.0}
	suite.jpl.Chebyshev.AC = [18]float64{0.0, 0.0, 0.0, 0.0, 0.0}
	suite.jpl.Chebyshev.JC = [18]float64{0.0, 0.0, 0.0, 0.0, 0.0}
	suite.mockInterpolationHelper.On("computeSubInterval", t, nain).Return(0.25, int32(3))
	suite.mockInterpolationHelper.On("evaluatePolynomials", mock.AnythingOfType("[]float64"), 0.25, ncfin).Return(0.5)
	suite.mockInterpolationHelper.On("interpolatePosition", pv, mock.AnythingOfType("[]float64"), buf, ncfin, ncmin, int32(3)).Return()
	suite.mockInterpolationHelper.On("interpolateVelocity", pv, mock.AnythingOfType("[18]float64"), mock.AnythingOfType("[18]float64"), buf, ncfin, ncmin, int32(3), mock.AnythingOfType("float64")).Return()
	suite.mockInterpolationHelper.On("interpolateAcceleration", pv, mock.AnythingOfType("[18]float64"), buf, ncfin, ncmin, int32(3), mock.AnythingOfType("float64")).Return()
	suite.mockInterpolationHelper.On("interpolateJerk", pv, mock.AnythingOfType("[18]float64"), buf, ncfin, ncmin, int32(3), mock.AnythingOfType("float64")).Return()

	err := suite.jpl.interpolation(buf, t, intv, ncfin, ncmin, nain, ifl, pv)
	assert.NoError(suite.T(), err)

	suite.mockInterpolationHelper.AssertExpectations(suite.T())
}

// Run the test suite
func TestInterpolationTestSuite(t *testing.T) {
	suite.Run(t, new(InterpolationTestSuite))
}

func TestInterpolateBodies(t *testing.T) {
	// Setup mock objects and dependencies
	mockEphemerisHandler := new(MockEphemerisHandler)
	jplInstance := &JPL{
		ephemerisHandler: mockEphemerisHandler,
		Buf:              [1500]float64{1.1, 2.2, 3.3}, // example values
	}

	jplInstance.Constants.IPT = [39]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39}

	tests := []struct {
		name     string
		list     []int32
		doBary   bool
		aufac    float64
		t        float64
		intv     float64
		pv       []float64
		pvsun    []float64
		expected []float64
	}{
		{
			name:     "Basic test with doBary false",
			list:     []int32{1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
			doBary:   false,
			aufac:    1.0,
			t:        0.1,
			intv:     0.2,
			pv:       make([]float64, 60), // size should be 6 * 10
			pvsun:    []float64{0.1, 0.2, 0.3, 0.4, 0.5, 0.6},
			expected: []float64{-0.1, -0.2, -0.3, -0.4, -0.5, -0.6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
		},
		{
			name:     "Basic test with doBary true",
			list:     []int32{1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
			doBary:   true,
			aufac:    2.0,
			t:        0.1,
			intv:     0.2,
			pv:       make([]float64, 60), // size should be 6 * 10
			pvsun:    []float64{0.1, 0.2, 0.3, 0.4, 0.5, 0.6},
			expected: []float64{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			mockEphemerisHandler.On("interpolation", mock.Anything, tt.t, tt.intv, int32(2), int32(3), int32(3), tt.list[0], mock.Anything).Return(nil)

			// Run the function with test case parameters
			jplInstance.interpolateBodies(tt.list, tt.doBary, tt.aufac, tt.t, tt.intv, tt.pv, tt.pvsun)

			// Assert the results
			assert.Equal(t, tt.expected, tt.pv)

			// Assert that the mock was called as expected
			mockEphemerisHandler.AssertCalled(t, "interpolation", mock.Anything, tt.t, tt.intv, int32(2), int32(3), int32(3), tt.list[0], mock.Anything)
		})
	}
}

func TestInterpolateSunPosition(t *testing.T) {
	// Setup mock objects and dependencies
	mockEphemerisHandler := new(MockEphemerisHandler)
	jplInstance := &JPL{
		ephemerisHandler: mockEphemerisHandler,
		Buf:              [1500]float64{1.1, 2.2, 3.3, 4.4, 5.5}, // example values
	}

	// Mock the IPT constants and AU value
	jplInstance.Constants.IPT = [39]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39}
	jplInstance.Constants.AU = 149597870.7 // Example AU value in kilometers

	tests := []struct {
		name     string
		t        float64
		intv     float64
		pvsun    []float64
		expected []float64
	}{
		{
			name:     "Basic sun position interpolation",
			t:        0.1,
			intv:     0.2,
			pvsun:    []float64{1000000, 2000000, 3000000, 4000000, 5000000, 6000000}, // Example initial values
			expected: []float64{0.006684587122268447, 0.013369174244536894, 0.020053761366805342, 0.02673834848907379, 0.033422935611342235, 0.040107522733610684},
		},
		// Add more test cases if needed
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Mock the expected call to interpolation
			mockEphemerisHandler.On("interpolation", jplInstance.Buf[jplInstance.Constants.IPT[30]-1:], tt.t, tt.intv, jplInstance.Constants.IPT[31], int32(3), jplInstance.Constants.IPT[32], int32(2), tt.pvsun).Return(nil)

			// Run the function with test case parameters
			jplInstance.interpolateSunPosition(tt.t, tt.intv, tt.pvsun)

			// Assert the results
			assert.InDeltaSlice(t, tt.expected, tt.pvsun, 1e-9, "The interpolated sun position is not as expected")

			// Assert that the mock was called as expected
			mockEphemerisHandler.AssertCalled(t, "interpolation", jplInstance.Buf[jplInstance.Constants.IPT[30]-1:], tt.t, tt.intv, jplInstance.Constants.IPT[31], int32(3), jplInstance.Constants.IPT[32], int32(2), tt.pvsun)
		})
	}
}

func TestInterpolateLibrations(t *testing.T) {
	// Setup mock objects and dependencies
	mockEphemerisHandler := new(MockEphemerisHandler)
	jplInstance := &JPL{
		ephemerisHandler: mockEphemerisHandler,
		Buf:              [1500]float64{1.1, 2.2, 3.3, 4.4, 5.5}, // example values
	}

	// Mock the IPT constants
	jplInstance.Constants.IPT = [39]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39}

	// Define the mock behavior for interpolation
	mockEphemerisHandler.On("interpolation", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)

	tests := []struct {
		name       string
		list       []int32
		t          float64
		intv       float64
		pv         []float64
		IPT37      int32
		shouldCall bool
		shouldErr  bool
		mockErr    error
	}{
		{
			name:       "Valid libration interpolation",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
			t:          0.1,
			intv:       0.2,
			pv:         make([]float64, 66), // 60 for other bodies + 6 for librations
			IPT37:      5,
			shouldCall: true,
			shouldErr:  false,
			mockErr:    nil,
		},
		{
			name:       "No libration interpolation due to list[11] == 0",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
			t:          0.1,
			intv:       0.2,
			pv:         make([]float64, 66),
			IPT37:      5,
			shouldCall: false,
			shouldErr:  false,
			mockErr:    nil,
		},
		{
			name:       "No libration interpolation due to IPT[37] == 0",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
			t:          0.1,
			intv:       0.2,
			pv:         make([]float64, 66),
			IPT37:      0,
			shouldCall: false,
			shouldErr:  false,
			mockErr:    nil,
		},
		{
			name:       "Interpolation returns an error",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
			t:          0.1,
			intv:       0.2,
			pv:         make([]float64, 66),
			IPT37:      5,
			shouldCall: true,
			shouldErr:  true,
			mockErr:    errors.New("interpolation error"),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Set IPT[37] as per the test case
			jplInstance.Constants.IPT[37] = tt.IPT37

			// Clear previous calls
			mockEphemerisHandler.Calls = nil

			// Set up mock to return the expected error
			mockEphemerisHandler.On("interpolation", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.mockErr)

			// Run the function with test case parameters
			jplInstance.interpolateLibrations(tt.list, tt.t, tt.intv, tt.pv)

			if tt.shouldCall {
				// Assert that the mock was called as expected
				mockEphemerisHandler.AssertCalled(t, "interpolation", jplInstance.Buf[jplInstance.Constants.IPT[36]-1:], tt.t, tt.intv, jplInstance.Constants.IPT[37], int32(3), jplInstance.Constants.IPT[38], tt.list[11], tt.pv[60:])
			} else {
				// Assert that the mock was not called
				mockEphemerisHandler.AssertNotCalled(t, "interpolation", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything)
			}
		})
	}
}

func TestInterpolateNutations(t *testing.T) {
	// Setup mock objects and dependencies
	mockEphemerisHandler := new(MockEphemerisHandler)
	jplInstance := &JPL{
		ephemerisHandler: mockEphemerisHandler,
		Buf:              [1500]float64{1.1, 2.2, 3.3, 4.4, 5.5}, // example values
	}

	// Mock the IPT constants
	jplInstance.Constants.IPT = [39]int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39}

	// Define the mock behavior for interpolation
	mockEphemerisHandler.On("interpolation", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)

	tests := []struct {
		name       string
		list       []int32
		t          float64
		intv       float64
		nut        []float64
		IPT34      int32
		shouldCall bool
		shouldErr  bool
		mockErr    error
	}{
		{
			name:       "Valid nutation interpolation",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
			t:          0.1,
			intv:       0.2,
			nut:        make([]float64, 2),
			IPT34:      5,
			shouldCall: true,
			shouldErr:  false,
			mockErr:    nil,
		},
		{
			name:       "No nutation interpolation due to list[10] == 0",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
			t:          0.1,
			intv:       0.2,
			nut:        make([]float64, 2),
			IPT34:      5,
			shouldCall: false,
			shouldErr:  false,
			mockErr:    nil,
		},
		{
			name:       "No nutation interpolation due to IPT[34] == 0",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
			t:          0.1,
			intv:       0.2,
			nut:        make([]float64, 2),
			IPT34:      0,
			shouldCall: false,
			shouldErr:  false,
			mockErr:    nil,
		},
		{
			name:       "Interpolation returns an error",
			list:       []int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
			t:          0.1,
			intv:       0.2,
			nut:        make([]float64, 2),
			IPT34:      5,
			shouldCall: true,
			shouldErr:  true,
			mockErr:    errors.New("interpolation error"),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Set IPT[34] as per the test case
			jplInstance.Constants.IPT[34] = tt.IPT34

			// Clear previous calls
			mockEphemerisHandler.Calls = nil

			// Set up mock to return the expected error
			mockEphemerisHandler.On("interpolation", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tt.mockErr)

			// Run the function with test case parameters
			jplInstance.interpolateNutations(tt.list, tt.t, tt.intv, tt.nut)

			if tt.shouldCall {
				// Assert that the mock was called as expected
				mockEphemerisHandler.AssertCalled(t, "interpolation", jplInstance.Buf[jplInstance.Constants.IPT[33]-1:], tt.t, tt.intv, jplInstance.Constants.IPT[34], int32(2), jplInstance.Constants.IPT[35], tt.list[10], tt.nut)
			} else {
				// Assert that the mock was not called
				mockEphemerisHandler.AssertNotCalled(t, "interpolation", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything)
			}
		})
	}
}

func TestGetDenum(t *testing.T) {
	// Define a test case with a specific Denum value
	expectedDenum := int32(431)

	// Initialize the JPL instance with the expected Denum
	jplInstance := new(JPL)

	jplInstance.Constants.Denum = expectedDenum

	// Call the GetDenum method
	actualDenum := jplInstance.GetDenum()

	// Assert that the returned Denum matches the expected value
	assert.Equal(t, expectedDenum, actualDenum, "The returned Denum should match the expected value")
}

// MockConstantsReader is a mock implementation of the constantsReader interface.
type MockConstantsReader struct {
	mock.Mock
}

func (m *MockConstantsReader) readConstantsAndParameters(au *float64, emrat *float64, lpt []int32, numde *int32, ncon *int32) error {
	args := m.Called(au, emrat, lpt, numde, ncon)
	return args.Error(0)
}

func (m *MockConstantsReader) readConstJpl() ([]float64, error) {
	args := m.Called()
	return args.Get(0).([]float64), args.Error(1)
}

func TestOpenJplFile(t *testing.T) {
	// Case 1: JPL instance or file is uninitialized
	t.Run("Uninitialized JPL instance or file", func(t *testing.T) {
		var jplInstance *JPL
		_, err := jplInstance.openJplFile()

		assert.Error(t, err)
		assert.Equal(t, "failed to open JPL file: JPL instance is uninitialized or JPL file is nil", err.Error())
	})

	// Case 2: Reading constants fails
	t.Run("Reading constants fails", func(t *testing.T) {
		mockJplFile := new(MockFileReader)
		mockConstantsReader := new(MockConstantsReader)
		jplInstance := &JPL{
			JplFile:         mockJplFile,
			constantsReader: mockConstantsReader,
		}

		// Instead of returning nil, return a nil slice with the correct type
		mockConstantsReader.On("readConstJpl").Return([]float64(nil), errors.New("read error"))

		_, err := jplInstance.openJplFile()

		assert.Error(t, err)
		assert.Equal(t, "failed to read constants from JPL file: read error", err.Error())
		mockConstantsReader.AssertExpectations(t)
	})

	// Case 3: Successful file opening and constants reading
	t.Run("Successful file opening and constants reading", func(t *testing.T) {
		mockJplFile := new(MockFileReader)
		mockConstantsReader := new(MockConstantsReader)
		expectedConstants := []float64{1.0, 2.0, 3.0}
		jplInstance := &JPL{
			JplFile:         mockJplFile,
			constantsReader: mockConstantsReader,
		}

		mockConstantsReader.On("readConstJpl").Return(expectedConstants, nil)

		constants, err := jplInstance.openJplFile()

		assert.NoError(t, err)
		assert.Equal(t, expectedConstants, constants)
		assert.Equal(t, float64(1), jplInstance.Chebyshev.PC[0])
		assert.Equal(t, float64(2), jplInstance.Chebyshev.PC[1])
		assert.Equal(t, float64(1), jplInstance.Chebyshev.VC[1])
		assert.Equal(t, float64(4), jplInstance.Chebyshev.AC[2])
		assert.Equal(t, float64(24), jplInstance.Chebyshev.JC[3])
		mockConstantsReader.AssertExpectations(t)
	})
}

func TestLoadJPLRecord(t *testing.T) {
	t.Run("Successful record loading", func(t *testing.T) {
		mockFile := new(MockFileReader)
		jplInstance := &JPL{
			JplFile: mockFile,
			Endian:  binary.LittleEndian,
			Buf:     [1500]float64{}, // Use an array instead of a slice
		}

		nr := int32(1)
		irecsz := int32(256)
		ncoeffs := int32(5)
		offset := int64(nr) * int64(irecsz)

		// Mock the Seek call to return the correct offset
		mockFile.On("Seek", offset, 0).Return(offset, nil)

		// Mock the Read call to return different values for each coefficient
		for i := int32(0); i < ncoeffs; i++ {
			expectedValue := float64(i + 1)
			buf := make([]byte, 8) // 8 bytes for each float64
			binary.LittleEndian.PutUint64(buf, math.Float64bits(expectedValue))

			// Mock each Read call
			mockFile.On("Read", mock.AnythingOfType("[]uint8")).Return(8, nil).Run(func(args mock.Arguments) {
				copy(args.Get(0).([]byte), buf)
			}).Once() // Ensure this is called only once per index
		}

		// Call the method under test
		err := jplInstance.loadJPLRecord(nr, irecsz, ncoeffs)

		// Assertions
		assert.NoError(t, err)
		for i := int32(0); i < ncoeffs; i++ {
			assert.Equal(t, float64(i+1), jplInstance.Buf[i], "Mismatch at index %d", i)
		}

		// Verify that the expectations were met
		mockFile.AssertExpectations(t)
	})

	t.Run("Seek failure", func(t *testing.T) {
		mockFile := new(MockFileReader)
		jplInstance := &JPL{
			JplFile: mockFile,
		}

		nr := int32(1)
		irecsz := int32(256)
		ncoeffs := int32(5)
		offset := int64(nr) * int64(irecsz)

		// Mock the Seek call to return an error
		mockFile.On("Seek", offset, 0).Return(int64(0), fmt.Errorf("seek error"))

		// Call the method under test
		err := jplInstance.loadJPLRecord(nr, irecsz, ncoeffs)

		// Assertions
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "Read error in JPL eph. at record 1")

		// Verify that the expectations were met
		mockFile.AssertExpectations(t)
	})

	t.Run("Read failure", func(t *testing.T) {
		mockFile := new(MockFileReader)
		jplInstance := &JPL{
			JplFile: mockFile,
			Endian:  binary.LittleEndian,
			Buf:     [1500]float64{}, // Use an array instead of a slice
		}

		nr := int32(1)
		irecsz := int32(256)
		ncoeffs := int32(5)
		offset := int64(nr) * int64(irecsz)

		// Mock the Seek call to return the correct offset
		mockFile.On("Seek", offset, 0).Return(offset, nil)

		// Mock the Read call to return an error
		mockFile.On("Read", mock.AnythingOfType("[]uint8")).Return(0, fmt.Errorf("read error"))

		// Call the method under test
		err := jplInstance.loadJPLRecord(nr, irecsz, ncoeffs)

		// Assertions
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "Read error in JPL eph. at record 1")

		// Verify that the expectations were met
		mockFile.AssertExpectations(t)
	})
}