Example #1
0
        public void TestAddOne()
        {
            var db = new RestrictionsDb(1024);

            db.Add(1, 2, 3);

            var enumerator = db.GetEnumerator();

            Assert.IsTrue(enumerator.MoveTo(1));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsFalse(enumerator.MoveNext());

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(2));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsFalse(enumerator.MoveNext());

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(3));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsFalse(enumerator.MoveNext());
        }
Example #2
0
        public void TestAddMultipleSameStart()
        {
            var db = new RestrictionsDb(1024);

            db.Add(1, 2, 3);
            db.Add(1, 2, 3, 4);
            db.Add(1, 2, 3, 4, 5);

            var enumerator = db.GetEnumerator();

            Assert.IsTrue(enumerator.MoveTo(1));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.AreEqual(4, enumerator[3]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(5, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.AreEqual(4, enumerator[3]);
            Assert.AreEqual(5, enumerator[4]);
            Assert.IsFalse(enumerator.MoveNext());

            db.Switch(6, 1);

            Assert.IsTrue(enumerator.MoveTo(6));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(6, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(6, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.AreEqual(4, enumerator[3]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(5, enumerator.Count);
            Assert.AreEqual(6, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.AreEqual(4, enumerator[3]);
            Assert.AreEqual(5, enumerator[4]);
            Assert.IsFalse(enumerator.MoveNext());
        }
        public void TestNetwork12()
        {
            var routerDb = new RouterDb();

            routerDb.LoadTestNetwork(
                Assembly.GetExecutingAssembly().GetManifestResourceStream(
                    "Itinero.Test.test_data.networks.network12.geojson"));

            Assert.AreEqual(8, routerDb.Network.VertexCount);
            Assert.AreEqual(8, routerDb.Network.EdgeCount);

            var vertex0 = routerDb.Network.GetVertex(0);
            var vertex1 = routerDb.Network.GetVertex(1);
            var vertex2 = routerDb.Network.GetVertex(2);
            var vertex3 = routerDb.Network.GetVertex(3);
            var vertex4 = routerDb.Network.GetVertex(4);
            var vertex5 = routerDb.Network.GetVertex(5);
            var vertex6 = routerDb.Network.GetVertex(6);
            var vertex7 = routerDb.Network.GetVertex(7);
            var vertex8 = routerDb.Network.GetVertex(8);
            var vertex9 = routerDb.Network.GetVertex(9);

            var edge = routerDb.Network.GetEdgeEnumerator(0).First(x => x.To == 1);

            Assert.AreEqual(Coordinate.DistanceEstimateInMeter(vertex0, vertex1), edge.Data.Distance, 5);
            var profile = routerDb.EdgeProfiles.Get(edge.Data.Profile);

            Assert.AreEqual(1, profile.Count);
            Assert.IsTrue(profile.Contains("highway", "residential"));

            edge = routerDb.Network.GetEdgeEnumerator(1).First(x => x.To == 4);
            Assert.AreEqual(Coordinate.DistanceEstimateInMeter(vertex1, vertex4), edge.Data.Distance, 5);
            profile = routerDb.EdgeProfiles.Get(edge.Data.Profile);
            Assert.AreEqual(1, profile.Count);
            Assert.IsTrue(profile.Contains("highway", "residential"));

            edge = routerDb.Network.GetEdgeEnumerator(1).First(x => x.To == 2);
            Assert.AreEqual(Coordinate.DistanceEstimateInMeter(vertex1, vertex2), edge.Data.Distance, 5);
            profile = routerDb.EdgeProfiles.Get(edge.Data.Profile);
            Assert.AreEqual(1, profile.Count);
            Assert.IsTrue(profile.Contains("highway", "residential"));

            edge = routerDb.Network.GetEdgeEnumerator(2).First(x => x.To == 3);
            Assert.AreEqual(Coordinate.DistanceEstimateInMeter(vertex2, vertex3), edge.Data.Distance, 5);
            profile = routerDb.EdgeProfiles.Get(edge.Data.Profile);
            Assert.AreEqual(1, profile.Count);
            Assert.IsTrue(profile.Contains("highway", "residential"));

            edge = routerDb.Network.GetEdgeEnumerator(2).First(x => x.To == 5);
            Assert.AreEqual(Coordinate.DistanceEstimateInMeter(vertex2, vertex5), edge.Data.Distance, 5);
            profile = routerDb.EdgeProfiles.Get(edge.Data.Profile);
            Assert.AreEqual(1, profile.Count);
            Assert.IsTrue(profile.Contains("highway", "residential"));

            edge = routerDb.Network.GetEdgeEnumerator(4).First(x => x.To == 5);
            Assert.AreEqual(Coordinate.DistanceEstimateInMeter(vertex4, vertex5), edge.Data.Distance, 5);
            profile = routerDb.EdgeProfiles.Get(edge.Data.Profile);
            Assert.AreEqual(1, profile.Count);
            Assert.IsTrue(profile.Contains("highway", "residential"));

            edge = routerDb.Network.GetEdgeEnumerator(4).First(x => x.To == 6);
            Assert.AreEqual(Coordinate.DistanceEstimateInMeter(vertex4, vertex6), edge.Data.Distance, 5);
            profile = routerDb.EdgeProfiles.Get(edge.Data.Profile);
            Assert.AreEqual(1, profile.Count);
            Assert.IsTrue(profile.Contains("highway", "residential"));

            edge = routerDb.Network.GetEdgeEnumerator(5).First(x => x.To == 7);
            Assert.AreEqual(Coordinate.DistanceEstimateInMeter(vertex5, vertex7), edge.Data.Distance, 5);
            profile = routerDb.EdgeProfiles.Get(edge.Data.Profile);
            Assert.AreEqual(1, profile.Count);
            Assert.IsTrue(profile.Contains("highway", "residential"));

            RestrictionsDb restrictions = null;

            Assert.IsTrue(routerDb.TryGetRestrictions("motorcar", out restrictions));
            var enumerator = restrictions.GetEnumerator();

            Assert.IsTrue(enumerator.MoveTo(1));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(1, enumerator[0]);
        }
Example #4
0
        public void TestSerializeDeserializeNoCacheProfile()
        {
            var db = new RestrictionsDb(1024);

            db.Add(1, 2, 3);
            db.Add(10, 11, 12);
            db.Add(10, 111, 222);
            db.Add(12, 2, 3);

            var stream = new MemoryStream();
            var size   = db.Serialize(stream);

            Assert.AreEqual(stream.Position, size);

            stream.Seek(0, SeekOrigin.Begin);
            db = RestrictionsDb.Deserialize(stream, RestrictionsDbProfile.NoCache);

            var enumerator = db.GetEnumerator();

            Assert.IsTrue(enumerator.MoveTo(12));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(11, enumerator[1]);
            Assert.AreEqual(12, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(12, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(3));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(12, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);

            db = new RestrictionsDb(1024);
            db.Add(1, 2, 3);
            db.Add(1, 2, 3, 4);

            stream.Dispose();
            stream = new MemoryStream();
            size   = db.Serialize(stream);
            Assert.AreEqual(stream.Position, size);

            stream.Seek(0, SeekOrigin.Begin);
            db = RestrictionsDb.Deserialize(stream, RestrictionsDbProfile.NoCache);

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(1));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.AreEqual(4, enumerator[3]);
            Assert.IsFalse(enumerator.MoveNext());
        }
Example #5
0
        public void TestSwitch()
        {
            var db = new RestrictionsDb(1024);

            db.Add(2, 1, 3);
            db.Switch(2, 1);

            var enumerator = db.GetEnumerator();

            Assert.IsTrue(enumerator.MoveTo(1));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsFalse(enumerator.MoveNext());

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(3));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(1, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsFalse(enumerator.MoveNext());

            db = new RestrictionsDb(1024);
            db.Add(1, 2, 3);
            db.Add(1, 2, 3, 4);
            db.Switch(1, 10);

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(10));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(2, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.AreEqual(4, enumerator[3]);

            db.Switch(2, 20);

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(10));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.AreEqual(4, enumerator[3]);

            db.Switch(3, 30);

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(10));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(30, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(30, enumerator[2]);
            Assert.AreEqual(4, enumerator[3]);

            db.Switch(4, 40);

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(10));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(30, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(30, enumerator[2]);
            Assert.AreEqual(40, enumerator[3]);
            Assert.IsFalse(enumerator.MoveNext());

            db = new RestrictionsDb(1024);
            db.Add(1, 2, 3);
            db.Add(3, 2, 1);
            db.Add(3, 2, 1, 4);
            db.Add(1, 2, 3, 4);
            db.Switch(1, 10);
            db.Switch(2, 20);
            db.Switch(3, 30);
            db.Switch(4, 40);

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(10));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(30, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(30, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(10, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(30, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(10, enumerator[2]);
            Assert.AreEqual(40, enumerator[3]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(30, enumerator[2]);
            Assert.AreEqual(40, enumerator[3]);
            Assert.IsFalse(enumerator.MoveNext());

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(30));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(30, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(30, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(10, enumerator[2]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(30, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(10, enumerator[2]);
            Assert.AreEqual(40, enumerator[3]);
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(4, enumerator.Count);
            Assert.AreEqual(10, enumerator[0]);
            Assert.AreEqual(20, enumerator[1]);
            Assert.AreEqual(30, enumerator[2]);
            Assert.AreEqual(40, enumerator[3]);
            Assert.IsFalse(enumerator.MoveNext());

            db = new RestrictionsDb(1024);
            db.Add(2, 1, 3);
            db.Switch(4, 1);
            db.Switch(4, 8);

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(2));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(2, enumerator[0]);
            Assert.AreEqual(8, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsFalse(enumerator.MoveNext());

            enumerator = db.GetEnumerator();
            Assert.IsTrue(enumerator.MoveTo(3));
            Assert.IsTrue(enumerator.MoveNext());
            Assert.AreEqual(3, enumerator.Count);
            Assert.AreEqual(2, enumerator[0]);
            Assert.AreEqual(8, enumerator[1]);
            Assert.AreEqual(3, enumerator[2]);
            Assert.IsFalse(enumerator.MoveNext());
        }