public TestOrbit(
        Vector3 _attractorPosition,
        Vector3 _satellitePosition,
        Vector3 _attractorVelocity,
        Vector3 _satelliteVelocity,
        float _attractorMass,
        float _gConstant)
    {
        attractorPosition = _attractorPosition;
        satellitePosition = _satellitePosition;
        attractorVelocity = _attractorVelocity;
        satelliteVelocity = _satelliteVelocity;
        attractorMass = _attractorMass;
        gConstant = _gConstant;

        /*###################################################

        All code past this point must be verified to be true or all tests are useless.

        Guide for test code verification:
        [Best]      //! This is established to be the most accurate method avaliable from a first hand source who is knowledgable on the subject (If you believe you qualify let us know. A username is required, no reference).
        [Good]      //* This is true and accurate based on second hand knowledge (Reference or reasoning must be provided, if your reference is wikipedia, random forum user or similar use //? instead).
        [ok]        //? This is most likely true and accurate(reference or reasoning required).
        [unusable]  //Todo: This is straight up not implemented properly and should not be used for testing purposes but is temporary.

        ###################################################*/

        relativePosition = satellitePosition - attractorPosition;
        relativeVelocity = satelliteVelocity - attractorVelocity;
        distance = relativePosition.magnitude;
        speed = relativeVelocity.magnitude;

        standardGravitationalParameter = attractorMass * gConstant;

        angularMomentumVector = Vector3.Cross(relativePosition, relativeVelocity);
        angularMomentum = angularMomentumVector.magnitude;

        inclination = Acos(angularMomentumVector.z/ angularMomentum);

        eccentricityVector = Vector3.Cross(relativeVelocity, angularMomentumVector) / standardGravitationalParameter - relativePosition.normalized;
        eccentricity = eccentricityVector.magnitude;

        accendingNodeVector = Vector3.Cross(new Vector3(0, 0, 1), angularMomentumVector);
        RAAN = Acos(accendingNodeVector.x / accendingNodeVector.magnitude);

        if(accendingNodeVector.y < 0)
            RAAN = 2 * PI - RAAN;

        argumentOfPeriapsis = Acos( Vector3.Dot(eccentricityVector, accendingNodeVector) / (eccentricity * accendingNodeVector.magnitude) );

        if(eccentricityVector.z < 0)
            argumentOfPeriapsis = 2 * PI - argumentOfPeriapsis;

        trueAnomaly = Acos( Vector3.Dot(eccentricityVector, relativePosition) / (eccentricity * distance) );

        if (Vector3.Dot(relativePosition, relativeVelocity) < 0)
            trueAnomaly = 2 * PI - trueAnomaly;

        acceleration = relativePosition.normalized * attractorMass * gConstant / relativePosition.sqrMagnitude;

        escapeSpeed = Sqrt((standardGravitationalParameter * 2) / distance);
        circleSpeed = Sqrt(standardGravitationalParameter / distance);

        perifocalFrame = angularMomentumVector.normalized;

        specificKineticEnergy = Pow(speed, 2) / 2;
        specificGravitationalPotentialEnergy = - standardGravitationalParameter / distance;

        switch (eccentricity)
        {
            case 0:
                Assert.AreApproximatelyEqual(speed, circleSpeed);

                meanAnomaly = trueAnomaly;
                eccentricAnomaly = trueAnomaly;

                semiMajorAxis = distance;
                semiMinorAxis = distance;
                periapsis = distance;
                apoapsis = distance;
                semiLatusRectum = distance;

                specificOrbitalEnergy = - standardGravitationalParameter / (2 * distance);
                areaOfOrbit = 2 * PI * distance;
                orbitalPeriod = (2 * areaOfOrbit) / angularMomentum;
                timeSincePerapsis = meanAnomaly / (2 * PI) * orbitalPeriod;

                flightPathAngle = PI / 2;
                turnAngle = PI;
                break;

            case var _ when eccentricity < 1:
                eccentricAnomaly = 2 * Atan( Sqrt( (1 - eccentricity) / (1 + eccentricity) ) * Tan(trueAnomaly/2) );
                meanAnomaly = eccentricAnomaly - eccentricity * Sin(eccentricAnomaly);

                semiMajorAxis = Pow(angularMomentum, 2) / standardGravitationalParameter * (1 / (1 - Pow(eccentricity, 2) ) );
                semiMinorAxis = semiMajorAxis * (1 - Pow(eccentricity, 2));
                semiLatusRectum = semiMajorAxis * (1 - Pow(eccentricity, 2));
                periapsis = semiMajorAxis * ( 1 - eccentricity );
                apoapsis = semiMajorAxis * ( 1 + eccentricity );

                specificOrbitalEnergy = - standardGravitationalParameter / (2 * semiMajorAxis);
                areaOfOrbit = PI * semiMajorAxis * semiMinorAxis;
                orbitalPeriod = (2 * areaOfOrbit) / angularMomentum;
                timeSincePerapsis = meanAnomaly / (2 * PI) * orbitalPeriod;

                flightPathAngle = Atan( (eccentricity * Sin(trueAnomaly)) / (1 + eccentricity * Sin(trueAnomaly)));
                turnAngle = PI;
                break;

            case 1:
                eccentricAnomaly = Tan(trueAnomaly/2);
                meanAnomaly = eccentricAnomaly + Pow(eccentricAnomaly, 3)/3;

                semiLatusRectum = Pow(angularMomentum, 2) / standardGravitationalParameter;
                semiMinorAxis = float.PositiveInfinity; //? not sure on this one https://math.stackexchange.com/questions/3366659/semi-minor-axis-of-a-parabola
                semiMajorAxis = float.PositiveInfinity;
                periapsis = semiLatusRectum / 2;
                apoapsis = float.PositiveInfinity;

                specificOrbitalEnergy = 0f;
                Assert.AreEqual(specificOrbitalEnergy, (Pow(speed,2)/2) - (standardGravitationalParameter/distance));
                areaOfOrbit = float.PositiveInfinity;
                orbitalPeriod = float.PositiveInfinity;
                timeSincePerapsis = meanAnomaly / (Pow(standardGravitationalParameter, 2) / Pow(angularMomentum, 3));


                flightPathAngle = trueAnomaly / 2;
                turnAngle = PI - Epsilon;
                break;

            default:
                eccentricAnomaly = 2 * Atanh( Sqrt( (eccentricity - 1) / (eccentricity + 1) ) * Tan(trueAnomaly/2) );
                meanAnomaly = eccentricity * Sinh(eccentricAnomaly) - eccentricAnomaly;

                apoapsis = Pow(angularMomentum, 2)/standardGravitationalParameter * (1 / (1 - eccentricity));
                periapsis = Pow(angularMomentum, 2)/standardGravitationalParameter * (1 / (1 + eccentricity));
                semiMajorAxis = 1 / (2 / distance - Pow(speed, 2)/standardGravitationalParameter);
                semiMinorAxis = - semiMajorAxis * Sqrt(Pow(eccentricity, 2) - 1);
                semiLatusRectum = semiMajorAxis * (Pow(eccentricity, 2) - 1);

                specificOrbitalEnergy = - standardGravitationalParameter / (2 * semiMajorAxis);
                areaOfOrbit = float.PositiveInfinity;
                orbitalPeriod = float.PositiveInfinity;
                timeSincePerapsis = Sqrt(Pow(-semiMajorAxis, 3) / standardGravitationalParameter) * meanAnomaly;

                turnAngle = 2 * Asin(1 / eccentricity);
                flightPathAngle = Atan( (eccentricity * Sin(trueAnomaly)) / (1 + eccentricity * Cos(trueAnomaly)));
                break;
        }

        Assert.AreApproximatelyEqual(specificOrbitalEnergy, specificGravitationalPotentialEnergy + specificKineticEnergy, $"Gravitational potential energy ({specificGravitationalPotentialEnergy}) + kinetic energy ({specificKineticEnergy}) should equal orbital energy.");

    }