NUnit.Framework.Is.EqualTo(object)

Here are the examples of the csharp api NUnit.Framework.Is.EqualTo(object) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

3601 Examples 7

19 Source : MSRFile.Test.cs
with MIT License
from Autodesk

[Test]
        public void MSRFileTwoStartsTogetherTest()
        {
            try
            {
                Geometry.MSRFile msrFile =
                    new Geometry.MSRFile(AppDomain.CurrentDomain.BaseDirectory +
                                         "\\..\\..\\TestFiles\\MSRTestFiles\\TwoStartsOK.msr",
                                         true);
                replacedert.That(msrFile.Points.Count, Is.EqualTo(6));
            }
            catch (Exception ex)
            {
                replacedert.Fail(ex.Message);
            }
            replacedert.Preplaced("File read ok");
        }

19 Source : MSRFile.Test.cs
with MIT License
from Autodesk

[Test]
        public void MSRFileTwoEndsTogetherTest()
        {
            try
            {
                Geometry.MSRFile msrFile =
                    new Geometry.MSRFile(AppDomain.CurrentDomain.BaseDirectory + "\\..\\..\\TestFiles\\MSRTestFiles\\TwoEndsOK.msr",
                                         true);
                replacedert.That(msrFile.Points.Count, Is.EqualTo(6));
            }
            catch (Exception ex)
            {
                replacedert.Fail(ex.Message);
            }
            replacedert.Preplaced("Failed to throw exception");
        }

19 Source : PMBoundariesCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void CreateSilhouetteBoundaryTest()
        {
            var before = _powerMill.ActiveProject.Boundaries.Count;
            _powerMill.ActiveProject.Models.CreateModel(TestFiles.SingleMesh);
            var importedModelName = _powerMill.ActiveProject.Models.Last().Name;
            var silhouette = _powerMill.ActiveProject.Boundaries.CreateSilhouetteBoundary(importedModelName, 10, 5, 0.1);

            replacedert.IsNotNull(silhouette, "A silhouette boundary wasn't not created, please fix it.");
            replacedert.AreEqual(before + 1, _powerMill.ActiveProject.Boundaries.Count);
            replacedert.That(silhouette.ToPolylines()[0].Length.Value, Is.EqualTo(391.312086465231).Within(TOLERANCE));
        }

19 Source : PMBoundariesCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void GetNewEnreplacedyNameTest()
        {
            //No enreplacedy exists, should return "1" and "NewName"
            replacedert.That(_powerMill.ActiveProject.Boundaries.GetNewEnreplacedyName(), Is.EqualTo("1"));
            replacedert.That(_powerMill.ActiveProject.Boundaries.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));

            //Create a new enreplacedy
            var boundary = _powerMill.ActiveProject.Boundaries.CreateEmptyBoundary();

            //1 enreplacedy exists, should return "2"
            replacedert.That(_powerMill.ActiveProject.Boundaries.GetNewEnreplacedyName(), Is.EqualTo("2"));

            //Rename the enreplacedy
            boundary.Name = "MyPrefix";

            //1 enreplacedy called "MyPrefix" exists, should return "NewName" and "MyPrefix_1"
            replacedert.That(_powerMill.ActiveProject.Boundaries.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));
            replacedert.That(_powerMill.ActiveProject.Boundaries.GetNewEnreplacedyName("MyPrefix"), Is.EqualTo("MyPrefix_1"));

            //Delete the enreplacedy
            _powerMill.ActiveProject.Boundaries.Remove(boundary);
        }

19 Source : PMFeatureGroupsCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void CollectionInitialisationTest()
        {
            if (_powerMill.Version.Major >= 2018)
            {
                var activeProject = _powerMill.LoadProject(TestFiles.FeatureGroupsProject);
                replacedert.That(activeProject.FeatureGroups.Count, Is.EqualTo(2));
            }
            else
            {
                var activeProject = _powerMill.LoadProject(TestFiles.SimplePmProject1);
                replacedert.That(activeProject.FeatureGroups.Count, Is.EqualTo(0));
            }
        }

19 Source : PMNCProgramsCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void GetNewEnreplacedyNameTest()
        {
            //No enreplacedy exists, should return "1" and "NewName"
            replacedert.That(_powerMILL.ActiveProject.NCPrograms.GetNewEnreplacedyName(), Is.EqualTo("1"));
            replacedert.That(_powerMILL.ActiveProject.NCPrograms.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));

            //Create a new enreplacedy
            var ncProgram = _powerMILL.ActiveProject.NCPrograms.CreateNCProgram("1");

            //1 enreplacedy exists, should return "2"
            replacedert.That(_powerMILL.ActiveProject.NCPrograms.GetNewEnreplacedyName(), Is.EqualTo("2"));

            //Rename the enreplacedy
            ncProgram.Name = "MyPrefix";

            //1 enreplacedy called "MyPrefix" exists, should return "NewName" and "MyPrefix_1"
            replacedert.That(_powerMILL.ActiveProject.NCPrograms.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));
            replacedert.That(_powerMILL.ActiveProject.NCPrograms.GetNewEnreplacedyName("MyPrefix"), Is.EqualTo("MyPrefix_1"));

            //Delete the enreplacedy
            _powerMILL.ActiveProject.NCPrograms.Remove(ncProgram);
        }

19 Source : PMPatternsCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void GetNewEnreplacedyNameTest()
        {
            //No enreplacedy exists, should return "1" and "NewName"
            replacedert.That(_powerMILL.ActiveProject.Patterns.GetNewEnreplacedyName(), Is.EqualTo("1"));
            replacedert.That(_powerMILL.ActiveProject.Patterns.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));

            //Create a new enreplacedy
            var pattern = _powerMILL.ActiveProject.Patterns.CreateEmptyPattern();

            //1 enreplacedy exists, should return "2"
            replacedert.That(_powerMILL.ActiveProject.Patterns.GetNewEnreplacedyName(), Is.EqualTo("2"));

            //Rename the enreplacedy
            pattern.Name = "MyPrefix";

            //1 enreplacedy called "MyPrefix" exists, should return "NewName" and "MyPrefix_1"
            replacedert.That(_powerMILL.ActiveProject.Patterns.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));
            replacedert.That(_powerMILL.ActiveProject.Patterns.GetNewEnreplacedyName("MyPrefix"), Is.EqualTo("MyPrefix_1"));

            //Delete the enreplacedy
            _powerMILL.ActiveProject.Patterns.Remove(pattern);
        }

19 Source : PMSetupsCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void CollectionInitialisationTest()
        {
            if (_powerMill.Version.Major >= 2019)
            {
                var activeProject = _powerMill.LoadProject(TestFiles.SetupsProject);
                replacedert.That(activeProject.Setups.Count, Is.EqualTo(2));
            }
            else
            {
                var activeProject = _powerMill.LoadProject(TestFiles.SimplePmProject1);
                replacedert.That(activeProject.FeatureGroups.Count, Is.EqualTo(0));
            }
        }

19 Source : DMTModel.Test.cs
with MIT License
from Autodesk

[Test]
        public void WhenCoincidentPointsInATriangle_ThenStillAppendBinarySTLFile()
        {
            var mesh = new File(TestFiles.FetchTestFile("CoincidentPointsInATriangle.stl"));
            var importedModel = DMTModelReader.ReadFile(mesh);

            replacedert.That(importedModel.TotalNoOfTriangles, Is.EqualTo(3), "Failed expected number of triangles.");
            replacedert.That(importedModel.TotalNoOfVertices, Is.EqualTo(3), "Failed expected number of vertices.");

            var expectedOutput =
                DMTModelReader.ReadFile(new File(TestFiles.FetchTestFile("CoincidentPointsInATriangle_Expected.stl")));

            replacedert.IsTrue(importedModel.BoundingBox.XSize == expectedOutput.BoundingBox.XSize,
                          "It is not giving the expected bounding box xsize.");
            replacedert.IsTrue(importedModel.BoundingBox.YSize == expectedOutput.BoundingBox.YSize,
                          "It is not giving the expected bounding box xsize.");
            replacedert.IsTrue(importedModel.BoundingBox.ZSize == expectedOutput.BoundingBox.ZSize,
                          "It is not giving the expected bounding box xsize.");
        }

19 Source : Line.Test.cs
with MIT License
from Autodesk

[Test]
        public void WhenTestIntersection_GivenTwoLinesAreNotCoplaner_ThenItShouldReturnFalse()
        {
            // Given
            var line1 = new Line(new Point(-5, 0, 0), new Point(5, 0, 0));
            var line2 = new Line(new Point(0, -5, 2), new Point(0, 5, 2));

            // When
            var result = line1.Intersects(line2);

            // Then
            replacedert.That(result, Is.EqualTo(false));
        }

19 Source : MM.Test.cs
with MIT License
from Autodesk

[Test]
        public void WhenSubtractIntFromMM_ThenResultShouldBeMM()
        {
            // When
            int left = 6;
            MM right = 3;
            var result = left - right;

            // Then
            replacedert.That(result.GetType(), Is.EqualTo(typeof(MM)));
            replacedert.That(result.Value, Is.EqualTo(3));
        }

19 Source : PMLevelOrSetsCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void AddLevelTest()
        {
            var itemName = "Tesreplacedem";
            var level = _powerMill.ActiveProject.LevelsAndSets.CreateLevel(itemName);

            replacedert.That(level, Is.Not.Null);
            replacedert.That(level.Name, Is.EqualTo(itemName));
            replacedert.That(level.Exists, Is.True);
        }

19 Source : PMModelsCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void GetNewEnreplacedyNameTest()
        {
            //No enreplacedy exists, should return "1" and "NewName"
            replacedert.That(_powerMill.ActiveProject.Models.GetNewEnreplacedyName(), Is.EqualTo("1"));
            replacedert.That(_powerMill.ActiveProject.Models.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));

            //Create a new enreplacedy
            var model = _powerMill.ActiveProject.Models.CreateModel(TestFiles.SingleMesh);
            model.Name = "1";

            //1 enreplacedy exists, should return "2"
            replacedert.That(_powerMill.ActiveProject.Models.GetNewEnreplacedyName(), Is.EqualTo("2"));

            //Rename the enreplacedy
            model.Name = "MyPrefix";

            //1 enreplacedy called "MyPrefix" exists, should return "NewName" and "MyPrefix_1"
            replacedert.That(_powerMill.ActiveProject.Models.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));
            replacedert.That(_powerMill.ActiveProject.Models.GetNewEnreplacedyName("MyPrefix"), Is.EqualTo("MyPrefix_1"));

            //Delete the enreplacedy
            _powerMill.ActiveProject.Models.Remove(model);
        }

19 Source : PMToolpathsCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void GetNewEnreplacedyNameTest()
        {
            //No enreplacedy exists, should return "1" and "NewName"
            replacedert.That(_powerMILL.ActiveProject.Toolpaths.GetNewEnreplacedyName(), Is.EqualTo("1"));
            replacedert.That(_powerMILL.ActiveProject.Toolpaths.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));

            //Create a new enreplacedy
            var toolpath = _powerMILL.ActiveProject.Toolpaths.Create3DOffsetFinishingToolpath();

            //1 enreplacedy exists, should return "2"
            replacedert.That(_powerMILL.ActiveProject.Toolpaths.GetNewEnreplacedyName(), Is.EqualTo("2"));

            //Rename the enreplacedy
            toolpath.Name = "MyPrefix";

            //1 enreplacedy called "MyPrefix" exists, should return "NewName" and "MyPrefix_1"
            replacedert.That(_powerMILL.ActiveProject.Toolpaths.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));
            replacedert.That(_powerMILL.ActiveProject.Toolpaths.GetNewEnreplacedyName("MyPrefix"), Is.EqualTo("MyPrefix_1"));

            //Delete the enreplacedy
            _powerMILL.ActiveProject.Toolpaths.Remove(toolpath);
        }

19 Source : PMToolsCollectionTest.cs
with MIT License
from Autodesk

[Test]
        public void GetNewEnreplacedyNameTest()
        {
            //No enreplacedy exists, should return "1" and "NewName"
            replacedert.That(_powerMILL.ActiveProject.Tools.GetNewEnreplacedyName(), Is.EqualTo("1"));
            replacedert.That(_powerMILL.ActiveProject.Tools.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));

            //Create a new enreplacedy
            var tool = _powerMILL.ActiveProject.Tools.CreateBallNosedTool();

            //1 enreplacedy exists, should return "2"
            replacedert.That(_powerMILL.ActiveProject.Tools.GetNewEnreplacedyName(), Is.EqualTo("2"));

            //Rename the enreplacedy
            tool.Name = "MyPrefix";

            //1 enreplacedy called "MyPrefix" exists, should return "NewName" and "MyPrefix_1"
            replacedert.That(_powerMILL.ActiveProject.Tools.GetNewEnreplacedyName("NewName"), Is.EqualTo("NewName"));
            replacedert.That(_powerMILL.ActiveProject.Tools.GetNewEnreplacedyName("MyPrefix"), Is.EqualTo("MyPrefix_1"));

            //Delete the enreplacedy
            _powerMILL.ActiveProject.Tools.Remove(tool);
        }

19 Source : PMToolpathTest.cs
with MIT License
from Autodesk

[Test]
        public void ToleranceTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var toolpath = _powerMill.ActiveProject.Toolpaths.First();
            replacedert.That(toolpath.Tolerance, Is.EqualTo((MM)0.1));
            toolpath.MakeInvalid();
            toolpath.Tolerance = 0.2;
            replacedert.That(toolpath.Tolerance, Is.EqualTo((MM)0.2));
        }

19 Source : PMToolpathTest.cs
with MIT License
from Autodesk

[Test]
        public void ToolNameTest()
        {
            _powerMill.LoadProject(TestFiles.SimplePmProject1);
            var toolpath = _powerMill.ActiveProject.Toolpaths["brava"];
            replacedert.That(toolpath.ToolName, Is.EqualTo("12 ball"));
        }

19 Source : PMToolpathTest.cs
with MIT License
from Autodesk

[Test]
        public void ToolTest()
        {
            _powerMill.LoadProject(TestFiles.SimplePmProject1);
            var toolpath = _powerMill.ActiveProject.Toolpaths["brava"];
            replacedert.That(toolpath.Tool, Is.EqualTo(_powerMill.ActiveProject.Tools["12 ball"]));
        }

19 Source : PMToolpathTest.cs
with MIT License
from Autodesk

[Test]
        public void ToolNameWhenNoToolSet()
        {
            _powerMill.Reset();
            var toolpath = _powerMill.ActiveProject.Toolpaths.CreateRasterFinishingToolpath();
            replacedert.That(toolpath.ToolName, Is.EqualTo(string.Empty));
        }

19 Source : PMToolpathTest.cs
with MIT License
from Autodesk

[Test]
        public void LeadsAndLinksOthersTimeTest()
        {
            _powerMill.LoadProject(TestFiles.SimplePmProject1);
            replacedert.That(_powerMill.ActiveProject.Toolpaths[0].LeadsAndLinksOthersTime, Is.EqualTo(TimeSpan.Parse("00:00:00")));
        }

19 Source : PMToolpathTest.cs
with MIT License
from Autodesk

[Test]
        public void ArcCuttingTimeTest()
        {
            _powerMill.LoadProject(TestFiles.SimplePmProject1);
            replacedert.That(_powerMill.ActiveProject.Toolpaths[0].ArcCuttingTime, Is.EqualTo(TimeSpan.Parse("00:00:00")));
        }

19 Source : PMToolpathTest.cs
with MIT License
from Autodesk

[Test]
        public void TotalCuttingTimeTest()
        {
            _powerMill.LoadProject(TestFiles.SimplePmProject1);
            replacedert.That(_powerMill.ActiveProject.Toolpaths[0].TotalCuttingTime, Is.EqualTo(TimeSpan.Parse("00:39:55.8900000")));
        }

19 Source : PMToolpathTest.cs
with MIT License
from Autodesk

[Test]
        public void BlockBoundingBoxTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var boundingBoxToFind = new BoundingBox(-20, 20, -20, 20, -10, 10);
            replacedert.That(_powerMill.ActiveProject.Toolpaths[0].BlockBoundingBox, Is.EqualTo(boundingBoxToFind));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void EndPointApproachAlongWhileToolPathIsCalculatedTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var toolpath = _powerMill.ActiveProject.Toolpaths.First();
            foreach (var item in typeof(PointApproach).GetEnumValues())
            {
                toolpath.EndPointApproachAlong = (PointApproach) item;
                replacedert.That(toolpath.EndPointApproachAlong, Is.EqualTo(item));
            }
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void EndPointMethodWhileToolPathIsCalculatedTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var toolpath = _powerMill.ActiveProject.Toolpaths.First();
            foreach (var item in typeof(EndPointMethod).GetEnumValues())
            {
                toolpath.EndPointMethod = (EndPointMethod) item;
                replacedert.That(toolpath.EndPointMethod, Is.EqualTo(item));
            }
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LeadInTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadIn;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LeadIn));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LeadInTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadIn;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LeadIn));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void MoveTypeOnLeadInTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadIn;
            foreach (var moveType in typeof(MoveType).GetEnumValues())
            {
                lead.MoveType = (MoveType) moveType;
                replacedert.That(lead.MoveType, Is.EqualTo(moveType));
            }
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

public void RampFollowOnLeadInTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadIn;
            foreach (var rampFollow in typeof(RampFollow).GetEnumValues())
            {
                lead.Ramp.Follow = (RampFollow) rampFollow;
                replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            }
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void RampHeightOnLeadInTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadIn;
            foreach (var rampHeight in typeof(RampHeight).GetEnumValues())
            {
                lead.Ramp.RampHeight = (RampHeight) rampHeight;
                replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            }
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LeadInSecondTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadInSecond;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LeadInSecond));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LeadInSecondTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadInSecond;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LeadInSecond));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LeadOutTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadOut;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LeadOut));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LeadOutTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadOut;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LeadOut));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LeadOutSecondTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadOutSecond;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LeadOutSecond));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LeadOutSecondTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadOutSecond;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LeadOutSecond));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void FirstLeadInTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.FirstLeadIn;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.FirstLeadIn));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void FirstLeadInTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.FirstLeadIn;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.FirstLeadIn));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LastLeadOutTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            var diameter = _random.Next();
            var rampFollow = (RampFollow) _random.Next(typeof(RampFollow).GetEnumValues().Length);
            var rampHeight = (RampHeight) _random.Next(typeof(RampHeight).GetEnumValues().Length);
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LastLeadOut;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;
            lead.Ramp.CircleDiameter = diameter;
            lead.Ramp.ClosedSegments = true;
            lead.Ramp.Extend = true;
            lead.Ramp.FiniteRamp = true;
            lead.Ramp.FiniteRampLenght = distance;
            lead.Ramp.Follow = rampFollow;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.RampHeight = rampHeight;
            lead.Ramp.RampHeightValue = distance;
            lead.Ramp.MaxZigAngle = angle;
            lead.Ramp.ZagAngle = true;
            lead.Ramp.ZagAngleMaximum = angle;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LastLeadOut));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
            replacedert.That(lead.Ramp.CircleDiameter.Value, Is.EqualTo(diameter).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ClosedSegments, Is.True);
            replacedert.That(lead.Ramp.Extend, Is.True);
            replacedert.That(lead.Ramp.FiniteRamp, Is.True);
            replacedert.That(lead.Ramp.FiniteRampLenght.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            replacedert.That(lead.Ramp.RampHeightValue.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Ramp.MaxZigAngle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Ramp.ZagAngle, Is.True);
            replacedert.That(lead.Ramp.ZagAngleMaximum.Value, Is.EqualTo(angle).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void MoveTypeOnLastLeadOutTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LastLeadOut;
            foreach (var moveType in typeof(MoveType).GetEnumValues())
            {
                lead.MoveType = (MoveType) moveType;
                replacedert.That(lead.MoveType, Is.EqualTo(moveType));
            }
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

public void RampFollowOnLastLeadOutTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadIn;
            foreach (var rampFollow in typeof(RampFollow).GetEnumValues())
            {
                lead.Ramp.Follow = (RampFollow) rampFollow;
                replacedert.That(lead.Ramp.Follow, Is.EqualTo(rampFollow));
            }
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void RampHeightOnLastLeadOutTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LastLeadOut;
            foreach (var rampHeight in typeof(RampHeight).GetEnumValues())
            {
                lead.Ramp.RampHeight = (RampHeight) rampHeight;
                replacedert.That(lead.Ramp.RampHeight, Is.EqualTo(rampHeight));
            }
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void LeadOutExtensionTest()
        {
            var angle = _random.NextDouble();
            var distance = _random.Next();
            var radius = _random.NextDouble();
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadOutExtension;

            lead.Angle = angle;
            lead.Distance = distance;
            lead.Radius = radius;

            replacedert.That(lead.LeadType, Is.EqualTo(LeadTypes.LeadOutExtension));
            replacedert.That(lead.Angle.Value, Is.EqualTo(angle).Within(TOLERANCE));
            replacedert.That(lead.Distance.Value, Is.EqualTo(distance).Within(TOLERANCE));
            replacedert.That(lead.Radius.Value, Is.EqualTo(radius).Within(TOLERANCE));
        }

19 Source : PMToolPathTestGenerator.cs
with MIT License
from Autodesk

[Test]
        public void MoveTypeOnLeadOutExtensionTest()
        {
            _powerMill.LoadProject(TestFiles.BasicToolpath);
            var lead = _powerMill.ActiveProject.Toolpaths.First().Connections.LeadOutExtension;
            foreach (var moveType in typeof(ExtensionLeadMoveTypes).GetEnumValues())
            {
                lead.MoveType = (ExtensionLeadMoveTypes) moveType;
                replacedert.That(lead.MoveType, Is.EqualTo(moveType));
            }
        }

19 Source : Line.Test.cs
with MIT License
from Autodesk

[Test]
        public void WhenTestIntersection_GivenTwoLinesAreParallel_ThenItShouldReturnFalse()
        {
            // Given
            var line1 = new Line(new Point(0, 0, 0), new Point(0, 5, 0));
            var line2 = new Line(new Point(2, 0, 0), new Point(2, 5, 0));

            // When
            var result = line1.Intersects(line2);

            // Then
            replacedert.That(result, Is.EqualTo(false));
        }

19 Source : Point.Test.cs
with MIT License
from Autodesk

[Test]
        public void WhenTestRayInterceptTriangle_GivenProjectedPointLiesOnSide_ThenItShouldReturnTrue()
        {
            // Given project point lies between v1 & v2
            var vertex1 = new Point(-1, 0, 0);
            var vertex2 = new Point(1, 0, 0);
            var vertex3 = new Point(0, 1, 0);

            var point = new Point(0.5, 0, 1);
            var rayDirection = new Vector(0, 0, -1);

            var projectedPoint = new Point(0.5, 0, 0);

            var pv1 = projectedPoint - vertex1;
            var v2v1 = vertex2 - vertex1;

            // Align
            replacedert.That(Vector.CrossProduct(pv1, v2v1).Magnitude, Is.EqualTo((MM) 0));

            // P between v1 v2
            var x = Vector.DotProduct(pv1, v2v1);
            replacedert.That(x, Is.GreaterThan((MM) 0));
            replacedert.That(x, Is.LessThan((MM) (v2v1.Magnitude * v2v1.Magnitude)));

            // When
            var result = point.IsRayInterceptTriangleTest(rayDirection, vertex1, vertex2, vertex3);

            // Then
            replacedert.IsTrue(result);
        }

19 Source : Polyline.Test.cs
with MIT License
from Autodesk

[Test]
        public void DensifyTest()
        {
            var spline = Spline.ReadFromDUCTPictureFile(new FileSystem.File(AppDomain.CurrentDomain.BaseDirectory +
                                                                            "\\..\\..\\TestFiles\\SplineTestFiles\\FreedByPowershape.pic"))[0];
            var polyline = new Polyline(spline, 0.1);
            polyline.Densify(1);
            replacedert.That(polyline.Count, Is.EqualTo(1103));
        }

19 Source : Surface.Test.cs
with MIT License
from Autodesk

[Test]
        public void WhenGettingSurfaceNormal_ThenCheckItMatchesNormalInPowerShape()
        {
            var lateralsFile = Path.Combine(_testDirectory, "Laterals.pic");
            var laterals = Spline.ReadFromDUCTPictureFile(new FileSystem.File(lateralsFile));
            var longitudinalsFile = Path.Combine(_testDirectory, "Longitudinals.pic");
            var longitudinals = Spline.ReadFromDUCTPictureFile(new FileSystem.File(longitudinalsFile));
            var surface = new Surface(laterals, longitudinals);
            var normal = surface.GetNormal(1, 1);

            // It is enough to compare till 1 micro, usually the accuracies that we work are 10 micros
            // The normal also matches surface at 2 and 2
            var normalInPowerShape = new Vector(0.0, -0.138196, 0.990405);
            replacedert.That(normal.I.Value, Is.EqualTo(normalInPowerShape.I.Value).Within(0.001));
            replacedert.That(normal.J.Value, Is.EqualTo(normalInPowerShape.J.Value).Within(0.001));
            replacedert.That(normal.K.Value, Is.EqualTo(normalInPowerShape.K.Value).Within(0.001));
        }

19 Source : Workplane.Test.cs
with MIT License
from Autodesk

[Test]
        public void CreateWorkplaneFromVectors()
        {
            // Create single workplane
            var xAxis = new Vector(1, 0, 0);
            var yAxis = new Vector(0.00000000000000000000000001, 1, 0);
            var Wp = new Workplane(new Point(0, 10, 20), xAxis, yAxis);

            replacedert.That(Wp, Is.Not.Null);
            replacedert.That(Wp.XAxis, Is.EqualTo(xAxis));
            replacedert.That(Wp.YAxis, Is.EqualTo(yAxis));
        }

19 Source : MM.Test.cs
with MIT License
from Autodesk

[Test]
        public void WhenAddMMWithInt_ThenResultShouldBeMM()
        {
            // When
            MM left = 3;
            int right = 6;
            var result = left + right;

            // Then
            replacedert.That(result.GetType(), Is.EqualTo(typeof(MM)));
            replacedert.That(result.Value, Is.EqualTo(9));
        }

See More Examples