示例#1
0
        public void TestInvalidation()
        {
            var path = new JuiceStreamPath();

            Assert.That(path.InvalidationID, Is.EqualTo(1));
            int previousId = path.InvalidationID;

            path.InsertVertex(10);
            checkNewId();

            path.SetVertexPosition(1, 5);
            checkNewId();

            path.Add(20, 0);
            checkNewId();

            path.RemoveVertices((v, _) => v.Distance == 20);
            checkNewId();

            path.ResampleVertices(new double[] { 5, 10, 15 });
            checkNewId();

            path.Clear();
            checkNewId();

            path.ConvertFromSliderPath(new SliderPath());
            checkNewId();

            void checkNewId()
            {
                Assert.That(path.InvalidationID, Is.Not.EqualTo(previousId));
                previousId = path.InvalidationID;
            }
        }
示例#2
0
        public void TestResampleVertices()
        {
            var path = new JuiceStreamPath();

            path.Add(-100, -10);
            path.Add(100, 50);
            path.ResampleVertices(new double[]
            {
                -50,
                0,
                70,
                120
            });
            Assert.That(path.Vertices, Is.EqualTo(new[]
            {
                new JuiceStreamPathVertex(-100, -10),
                new JuiceStreamPathVertex(-50, -5),
                new JuiceStreamPathVertex(0, 0),
                new JuiceStreamPathVertex(70, 35),
                new JuiceStreamPathVertex(100, 50),
                new JuiceStreamPathVertex(100, 50),
            }));

            path.Clear();
            path.SetVertexPosition(0, 10);
            path.ResampleVertices(Array.Empty <double>());
            Assert.That(path.Vertices, Is.EqualTo(new[]
            {
                new JuiceStreamPathVertex(0, 10)
            }));
        }
示例#3
0
        public void TestRandomInsertSetPosition(double scale, bool checkSlope, bool integralValues)
        {
            var rng  = new Random(1);
            var path = new JuiceStreamPath();

            for (int iteration = 0; iteration < 100000; iteration++)
            {
                if (rng.Next(10) == 0)
                {
                    path.Clear();
                }

                int vertexCount = path.Vertices.Count;

                switch (rng.Next(2))
                {
                case 0:
                {
                    double distance = rng.NextDouble() * scale * 2 - scale;
                    if (integralValues)
                    {
                        distance = Math.Round(distance);
                    }

                    float oldX  = path.PositionAtDistance(distance);
                    int   index = path.InsertVertex(distance);
                    Assert.That(path.Vertices.Count, Is.EqualTo(vertexCount + 1));
                    Assert.That(path.Vertices[index].Distance, Is.EqualTo(distance));
                    Assert.That(path.Vertices[index].X, Is.EqualTo(oldX));
                    break;
                }

                case 1:
                {
                    int    index    = rng.Next(path.Vertices.Count);
                    double distance = path.Vertices[index].Distance;
                    float  newX     = (float)(rng.NextDouble() * scale * 2 - scale);
                    if (integralValues)
                    {
                        newX = MathF.Round(newX);
                    }

                    path.SetVertexPosition(index, newX);
                    Assert.That(path.Vertices.Count, Is.EqualTo(vertexCount));
                    Assert.That(path.Vertices[index].Distance, Is.EqualTo(distance));
                    Assert.That(path.Vertices[index].X, Is.EqualTo(newX));
                    break;
                }
                }

                assertInvariants(path.Vertices, checkSlope);
            }
        }