C# PointBetween

Post Views: 793

Dark Mode

GeometryEngine_Solution (this link opens in a new window) by CatiaWidgets (this link opens in a new window)

In this section were going to finish the PointBetween class and create Unit Tests for it.

Let’ start of by defining a new Interface and Class for PointBetween.

//IPointBetween.cs
using GeometryCoreProject.WireframeBaseInterfaces;
namespace GeometryTypesProject.GeometryTypesInterfaces
{
    public interface IPointBetween : IPointBase3D
    {
        IPointBase3D RefPoint1 { get;}
        IPointBase3D RefPoint2 { get;}
        bool Orientation { get; }
        void SetRefPoint1(IPointBase3D iRefPoint);
        void SetRefPoint2(IPointBase3D iRefPoint);
        void SetRefPoints(IPointBase3D iRefPoint1, IPointBase3D iRefPoint2);
        void SetOrientation(bool iOrientation);
        void SetRatio(double iRatio);
        double GetRatio();
    }
}

C#
​x
 
//IPointBetween.cs
using GeometryCoreProject.WireframeBaseInterfaces;
namespace GeometryTypesProject.GeometryTypesInterfaces
{
    public interface IPointBetween : IPointBase3D
    {
        IPointBase3D RefPoint1 { get;}
        IPointBase3D RefPoint2 { get;}
        bool Orientation { get; }
        void SetRefPoint1(IPointBase3D iRefPoint);
        void SetRefPoint2(IPointBase3D iRefPoint);
        void SetRefPoints(IPointBase3D iRefPoint1, IPointBase3D iRefPoint2);
        void SetOrientation(bool iOrientation);
        void SetRatio(double iRatio);
        double GetRatio();
    }
}

Then implement the PointBetween Class.

//PointBetween.cs
using GeometryCoreProject.WireframeBaseClasses;
using GeometryCoreProject.WireframeBaseInterfaces;
using GeometryTypesProject.GeometryTypesInterfaces;
using System;
namespace GeometryTypesProject.GeometryTypesClasses
{
    public class PointBetween : PointBase3D, IPointBetween
    {
        double _Ratio = 0.5;
        IVectorBase3D _RefVector
        {
            get
            {
                IVectorBase3D ReturnVector = new VectorBase3D();
                ReturnVector.I = (this.RefPoint2.X - this.RefPoint1.X);
                ReturnVector.J = (this.RefPoint2.Y - this.RefPoint1.Y);
                ReturnVector.K = (this.RefPoint2.Z - this.RefPoint1.Z);
                return ReturnVector;
            }
        }
        public IPointBase3D RefPoint1 { get; private set; } = null;
        public IPointBase3D RefPoint2 { get; private set; } = null;
        public bool Orientation { get; private set; } = true;
        public PointBetween() { }
        public PointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2)
        {
            this.RefPoint1 = iPoint1;
            this.RefPoint2 = iPoint2;
            IPointBase3D TranslatedPoint = this.TranslatePointAlongVector(this.RefPoint1, this._RefVector, this._RefVector.Magnitude * this._Ratio);
            this.SetCoordinates(TranslatedPoint.GetCoordinates());
        }
        public PointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2, double iRatio)
        {
            this.RefPoint1 = iPoint1;
            this.RefPoint2 = iPoint2;
            this.SetRatio(iRatio);
            IPointBase3D TranslatedPoint = this.TranslatePointAlongVector(this.RefPoint1, this._RefVector, this._RefVector.Magnitude * this._Ratio);
            this.SetCoordinates(TranslatedPoint.GetCoordinates());
        }
        public PointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2, double iRatio, bool iOrientation)
        {
            this.RefPoint1 = iPoint1;
            this.RefPoint2 = iPoint2;
            this.SetRatio(iRatio);
            double CurrentRatio = (iOrientation == true) ? iRatio : 1 - iRatio;
            IPointBase3D TranslatedPoint = this.TranslatePointAlongVector(this.RefPoint1, this._RefVector, this._RefVector.Magnitude * CurrentRatio);
            this.SetCoordinates(TranslatedPoint.GetCoordinates());
        }
        public void SetRefPoint1(IPointBase3D iRefPoint)
        {
            this.RefPoint1 = iRefPoint;
            this.UpdateThis();
        }
        public void SetRefPoint2(IPointBase3D iRefPoint)
        {
            this.RefPoint2 = iRefPoint;
            this.UpdateThis();
        }
        public void SetRefPoints(IPointBase3D iRefPoint1, IPointBase3D iRefPoint2)
        {
            this.RefPoint1 = iRefPoint1;
            this.RefPoint2 = iRefPoint2;
            this.UpdateThis();
        }
        public void SetOrientation(bool iOrientation)
        {
            this.Orientation = iOrientation;
            this.UpdateThis();
        }
        public double GetRatio()
        {
            return this._Ratio;
        }
        public void SetRatio(double iRatio)
        {
            if (Math.Abs(iRatio) > 1 || iRatio < 0) { throw new Exception("Ratio Value Must be Between 0 and 1."); }
            this._Ratio = (this.Orientation == true) ? iRatio : 1 - iRatio;
            this.UpdateThis();
        }
        void UpdateThis()
        {
            IPointBase3D RefPoint = (this.Orientation == true) ? this.RefPoint1 : this.RefPoint2;
            IVectorBase3D RefVector = (this.Orientation == true) ? this._RefVector : this._RefVector.InverseVector;
            IPointBase3D TranslatedPoint = this.TranslatePointAlongVector(RefPoint, RefVector, this._RefVector.Magnitude * this._Ratio);
            this.SetCoordinates(TranslatedPoint.GetCoordinates());
        }
    }
}

C#
 
//PointBetween.cs
using GeometryCoreProject.WireframeBaseClasses;
using GeometryCoreProject.WireframeBaseInterfaces;
using GeometryTypesProject.GeometryTypesInterfaces;
using System;
namespace GeometryTypesProject.GeometryTypesClasses
{
    public class PointBetween : PointBase3D, IPointBetween
    {
        double _Ratio = 0.5;
        IVectorBase3D _RefVector
        {
            get
            {
                IVectorBase3D ReturnVector = new VectorBase3D();
                ReturnVector.I = (this.RefPoint2.X - this.RefPoint1.X);
                ReturnVector.J = (this.RefPoint2.Y - this.RefPoint1.Y);
                ReturnVector.K = (this.RefPoint2.Z - this.RefPoint1.Z);
                return ReturnVector;
            }
        }
        public IPointBase3D RefPoint1 { get; private set; } = null;
        public IPointBase3D RefPoint2 { get; private set; } = null;
        public bool Orientation { get; private set; } = true;
        public PointBetween() { }
        public PointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2)
        {
            this.RefPoint1 = iPoint1;
            this.RefPoint2 = iPoint2;
            IPointBase3D TranslatedPoint = this.TranslatePointAlongVector(this.RefPoint1, this._RefVector, this._RefVector.Magnitude * this._Ratio);
            this.SetCoordinates(TranslatedPoint.GetCoordinates());
        }
        public PointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2, double iRatio)
        {
            this.RefPoint1 = iPoint1;
            this.RefPoint2 = iPoint2;
            this.SetRatio(iRatio);
            IPointBase3D TranslatedPoint = this.TranslatePointAlongVector(this.RefPoint1, this._RefVector, this._RefVector.Magnitude * this._Ratio);
            this.SetCoordinates(TranslatedPoint.GetCoordinates());
        }
        public PointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2, double iRatio, bool iOrientation)
        {
            this.RefPoint1 = iPoint1;
            this.RefPoint2 = iPoint2;
            this.SetRatio(iRatio);
            double CurrentRatio = (iOrientation == true) ? iRatio : 1 - iRatio;
            IPointBase3D TranslatedPoint = this.TranslatePointAlongVector(this.RefPoint1, this._RefVector, this._RefVector.Magnitude * CurrentRatio);
            this.SetCoordinates(TranslatedPoint.GetCoordinates());
        }
        public void SetRefPoint1(IPointBase3D iRefPoint)
        {
            this.RefPoint1 = iRefPoint;
            this.UpdateThis();
        }
        public void SetRefPoint2(IPointBase3D iRefPoint)
        {
            this.RefPoint2 = iRefPoint;
            this.UpdateThis();
        }
        public void SetRefPoints(IPointBase3D iRefPoint1, IPointBase3D iRefPoint2)
        {
            this.RefPoint1 = iRefPoint1;
            this.RefPoint2 = iRefPoint2;
            this.UpdateThis();
        }
        public void SetOrientation(bool iOrientation)
        {
            this.Orientation = iOrientation;
            this.UpdateThis();
        }
        public double GetRatio()
        {
            return this._Ratio;
        }
        public void SetRatio(double iRatio)
        {
            if (Math.Abs(iRatio) > 1 || iRatio < 0) { throw new Exception("Ratio Value Must be Between 0 and 1."); }
            this._Ratio = (this.Orientation == true) ? iRatio : 1 - iRatio;
            this.UpdateThis();
        }
        void UpdateThis()
        {
            IPointBase3D RefPoint = (this.Orientation == true) ? this.RefPoint1 : this.RefPoint2;
            IVectorBase3D RefVector = (this.Orientation == true) ? this._RefVector : this._RefVector.InverseVector;
            IPointBase3D TranslatedPoint = this.TranslatePointAlongVector(RefPoint, RefVector, this._RefVector.Magnitude * this._Ratio);
            this.SetCoordinates(TranslatedPoint.GetCoordinates());
        }
    }
}
​

Then in the IWireframeFactory Interface and Class, we’ll add a new method for AddNewPointBetween

//IWireframeFactory.cs
using GeometryCoreProject.WireframeBaseInterfaces;
using GeometryTypesProject.GeometryTypesInterfaces;
namespace GeometryFactoriesProject.FactoryBaseInterfaces
{
    public interface IWireframeFactory
    {
        IPointBetween AddNewPointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2, double iRatio = 0.5, bool Orientation = true);
        IPointByCoordinates AddNewPointCoord(double iX, double iY, double iZ);
        IPointByCoordinates AddNewPointCoordWithReference(double iX, double iY, double iZ, IPointBase3D iRefPoint = null, IAxisSystemBase3D iRefAxisSystem = null);
    }
}

C#
 
//IWireframeFactory.cs
using GeometryCoreProject.WireframeBaseInterfaces;
using GeometryTypesProject.GeometryTypesInterfaces;
namespace GeometryFactoriesProject.FactoryBaseInterfaces
{
    public interface IWireframeFactory
    {
        IPointBetween AddNewPointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2, double iRatio = 0.5, bool Orientation = true);
        IPointByCoordinates AddNewPointCoord(double iX, double iY, double iZ);
        IPointByCoordinates AddNewPointCoordWithReference(double iX, double iY, double iZ, IPointBase3D iRefPoint = null, IAxisSystemBase3D iRefAxisSystem = null);
    }
}

Then in the WireframeFactory Class we will define the new method for AddNewPointBetween

//WireframeFactory.cs
using GeometryCoreProject.WireframeBaseInterfaces;
using GeometryFactoriesProject.FactoryBaseInterfaces;
using GeometryTypesProject.GeometryTypesClasses;
using GeometryTypesProject.GeometryTypesInterfaces;
namespace GeometryFactoriesProject.FactoryBaseClasses
{
    public class WireframeFactory : IWireframeFactory
    {
        public IPointBetween AddNewPointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2, double iRatio = 0.5, bool iOrientation = true)
        {
            return new PointBetween(iPoint1, iPoint2, iRatio, iOrientation);
        }
        public IPointByCoordinates AddNewPointCoord(double iX, double iY, double iZ)
        {
            return new PointByCoordinates(iX,iY,iZ);
        }
        public IPointByCoordinates AddNewPointCoordWithReference(double iX, double iY, double iZ, IPointBase3D iRefPoint = null, IAxisSystemBase3D iRefAxisSystem = null)
        {
            if(iRefPoint == null && iRefAxisSystem ==null)
            {
                return new PointByCoordinates(iX, iY, iZ);
            }
            else
            {
                if (iRefPoint == null)
                {
                    return new PointByCoordinates(iX, iY, iZ, iRefAxisSystem);
                }
                else if (iRefAxisSystem == null)
                {
                    return new PointByCoordinates(iX, iY, iZ, iRefPoint);
                }
                else
                {
                    return new PointByCoordinates(iX, iY, iZ, iRefPoint, iRefAxisSystem);
                }
            }
        }
    }
}

C#
 
//WireframeFactory.cs
using GeometryCoreProject.WireframeBaseInterfaces;
using GeometryFactoriesProject.FactoryBaseInterfaces;
using GeometryTypesProject.GeometryTypesClasses;
using GeometryTypesProject.GeometryTypesInterfaces;
namespace GeometryFactoriesProject.FactoryBaseClasses
{
    public class WireframeFactory : IWireframeFactory
    {
        public IPointBetween AddNewPointBetween(IPointBase3D iPoint1, IPointBase3D iPoint2, double iRatio = 0.5, bool iOrientation = true)
        {
            return new PointBetween(iPoint1, iPoint2, iRatio, iOrientation);
        }
        public IPointByCoordinates AddNewPointCoord(double iX, double iY, double iZ)
        {
            return new PointByCoordinates(iX,iY,iZ);
        }
        public IPointByCoordinates AddNewPointCoordWithReference(double iX, double iY, double iZ, IPointBase3D iRefPoint = null, IAxisSystemBase3D iRefAxisSystem = null)
        {
            if(iRefPoint == null && iRefAxisSystem ==null)
            {
                return new PointByCoordinates(iX, iY, iZ);
            }
            else
            {
                if (iRefPoint == null)
                {
                    return new PointByCoordinates(iX, iY, iZ, iRefAxisSystem);
                }
                else if (iRefAxisSystem == null)
                {
                    return new PointByCoordinates(iX, iY, iZ, iRefPoint);
                }
                else
                {
                    return new PointByCoordinates(iX, iY, iZ, iRefPoint, iRefAxisSystem);
                }
            }
        }
    }
}
​

And finally we need to define a Unit Test Class, to do this we need to add a new Class to the existing PointConstructors Unit Test Folder.

We can now fully define the unit tests for PointBetween

//PointBetweenUnitTest.cs
using GeometryFactoriesProject.FactoryBaseClasses;
using GeometryTypesProject.GeometryTypesInterfaces;
using System;
using Xunit;
using FluentAssertions;
namespace GeometryUnitTestsProject.PointConstructors
{
    public class PointBetweenUnitTest
    {
        // Create an Instance of the Factory
        WireframeFactory _WireframeFactory = new WireframeFactory();
        IPointByCoordinates _PointByCoordinates1 = null;
        IPointByCoordinates _PointByCoordinates2 = null;
        // Constructor
        public PointBetweenUnitTest()
        {
            this._PointByCoordinates1 = this._WireframeFactory.AddNewPointCoord(10,10,10);
            this._PointByCoordinates2 = this._WireframeFactory.AddNewPointCoord(100, 100, 100);
        }
        [Fact]
        // Create Point at 55,55,55
        public void PointBetweenTest1()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(55);
            PointBetween.Y.Should().Be(55);
            PointBetween.Z.Should().Be(55);
        }
        [Fact]
        // Create Point at 32.5,32.5,32.5
        public void PointBetweenTest2()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(32.5);
            PointBetween.Y.Should().Be(32.5);
            PointBetween.Z.Should().Be(32.5);
        }
        [Fact]
        // Create Point at 77.5,77.5,77.5 by Inverting the Ratio
        public void PointBetweenTest3()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25,false);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(77.5);
            PointBetween.Y.Should().Be(77.5);
            PointBetween.Z.Should().Be(77.5);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Invert Orientation*/
        public void PointBetweenTest4()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            PointBetween.SetOrientation(false);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(77.5);
            PointBetween.Y.Should().Be(77.5);
            PointBetween.Z.Should().Be(77.5);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Change the Ratio to 0.75*/
        public void PointBetweenTest5()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            PointBetween.SetRatio(0.75);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(77.5);
            PointBetween.Y.Should().Be(77.5);
            PointBetween.Z.Should().Be(77.5);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Change the Ratio to 0.75*/
        public void PointBetweenTest6()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            PointBetween.SetRatio(0.75);
            PointBetween.SetOrientation(false);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(32.5);
            PointBetween.Y.Should().Be(32.5);
            PointBetween.Z.Should().Be(32.5);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Replace Point 1*/
        public void PointBetweenTest7()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            // Create a New Point to Replace Point 1
            IPointByCoordinates PointByCoordinates1New = this._WireframeFactory.AddNewPointCoord(25, 250, 2.5);
            PointBetween.SetRefPoint1(PointByCoordinates1New);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(43.75);
            PointBetween.Y.Should().Be(212.5);
            PointBetween.Z.Should().Be(26.875);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Replace Point 1
        Then Repalce Point 2
        Change the Ratio to .75
        Invert the Orientation*/
        public void PointBetweenTest8()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            // Create a New Point to Replace Point 1
            IPointByCoordinates PointByCoordinates1New = this._WireframeFactory.AddNewPointCoord(25, 250, 2.5);
            PointBetween.SetRefPoint1(PointByCoordinates1New);
            // Create a New Point to Replace Point 2
            PointBetween.SetRefPoint2(this._PointByCoordinates1);
            // Change the Ratio
            PointBetween.SetRatio(0.75);
            // Change the Orientation
            PointBetween.SetOrientation(false);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(21.25);
            PointBetween.Y.Should().Be(190);
            PointBetween.Z.Should().Be(4.375);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Change the Ratio to 1.5 to throw an Error*/
        public void PointBetweenTest9()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            //Set the ReferencePoint
            Action comparison = () => { PointBetween.SetRatio(1.5); };
            comparison.Should().Throw<Exception>();
        }
    }
}

C#
 
//PointBetweenUnitTest.cs
using GeometryFactoriesProject.FactoryBaseClasses;
using GeometryTypesProject.GeometryTypesInterfaces;
using System;
using Xunit;
using FluentAssertions;
namespace GeometryUnitTestsProject.PointConstructors
{
    public class PointBetweenUnitTest
    {
        // Create an Instance of the Factory
        WireframeFactory _WireframeFactory = new WireframeFactory();
        IPointByCoordinates _PointByCoordinates1 = null;
        IPointByCoordinates _PointByCoordinates2 = null;
        // Constructor
        public PointBetweenUnitTest()
        {
            this._PointByCoordinates1 = this._WireframeFactory.AddNewPointCoord(10,10,10);
            this._PointByCoordinates2 = this._WireframeFactory.AddNewPointCoord(100, 100, 100);
        }
        [Fact]
        // Create Point at 55,55,55
        public void PointBetweenTest1()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(55);
            PointBetween.Y.Should().Be(55);
            PointBetween.Z.Should().Be(55);
        }
        [Fact]
        // Create Point at 32.5,32.5,32.5
        public void PointBetweenTest2()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(32.5);
            PointBetween.Y.Should().Be(32.5);
            PointBetween.Z.Should().Be(32.5);
        }
        [Fact]
        // Create Point at 77.5,77.5,77.5 by Inverting the Ratio
        public void PointBetweenTest3()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25,false);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(77.5);
            PointBetween.Y.Should().Be(77.5);
            PointBetween.Z.Should().Be(77.5);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Invert Orientation*/
        public void PointBetweenTest4()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            PointBetween.SetOrientation(false);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(77.5);
            PointBetween.Y.Should().Be(77.5);
            PointBetween.Z.Should().Be(77.5);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Change the Ratio to 0.75*/
        public void PointBetweenTest5()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            PointBetween.SetRatio(0.75);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(77.5);
            PointBetween.Y.Should().Be(77.5);
            PointBetween.Z.Should().Be(77.5);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Change the Ratio to 0.75*/
        public void PointBetweenTest6()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            PointBetween.SetRatio(0.75);
            PointBetween.SetOrientation(false);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(32.5);
            PointBetween.Y.Should().Be(32.5);
            PointBetween.Z.Should().Be(32.5);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Replace Point 1*/
        public void PointBetweenTest7()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            // Create a New Point to Replace Point 1
            IPointByCoordinates PointByCoordinates1New = this._WireframeFactory.AddNewPointCoord(25, 250, 2.5);
            PointBetween.SetRefPoint1(PointByCoordinates1New);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(43.75);
            PointBetween.Y.Should().Be(212.5);
            PointBetween.Z.Should().Be(26.875);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Replace Point 1
        Then Repalce Point 2
        Change the Ratio to .75
        Invert the Orientation*/
        public void PointBetweenTest8()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            // Create a New Point to Replace Point 1
            IPointByCoordinates PointByCoordinates1New = this._WireframeFactory.AddNewPointCoord(25, 250, 2.5);
            PointBetween.SetRefPoint1(PointByCoordinates1New);
            // Create a New Point to Replace Point 2
            PointBetween.SetRefPoint2(this._PointByCoordinates1);
            // Change the Ratio
            PointBetween.SetRatio(0.75);
            // Change the Orientation
            PointBetween.SetOrientation(false);
            // Test the Point X,Y,Z Values
            PointBetween.X.Should().Be(21.25);
            PointBetween.Y.Should().Be(190);
            PointBetween.Z.Should().Be(4.375);
        }
        [Fact]
        /* Create Point at 32.5,32.5,32.5
        Then Change the Ratio to 1.5 to throw an Error*/
        public void PointBetweenTest9()
        {
            // Create an Instance of the IPointByCoordinates
            IPointBetween PointBetween = this._WireframeFactory.AddNewPointBetween(this._PointByCoordinates1, this._PointByCoordinates2, 0.25);
            //Set the ReferencePoint
            Action comparison = () => { PointBetween.SetRatio(1.5); };
            comparison.Should().Throw<Exception>();
        }
    }
}
​