public virtual void Paths_cyclophanelike2()
        {
            int[][]         g   = Cyclophanelike2();
            EdgeShortCycles esc = new EdgeShortCycles(g);

            int[][] paths    = esc.GetPaths();
            int[][] expected = new int[][] { new[] { 5, 0, 1, 2, 3, 4, 5 }, new[] { 9, 8, 7, 6, 11, 10, 9 }, new[] { 15, 14, 13, 12, 17, 16, 15 },
                                             new[] { 21, 20, 19, 18, 23, 22, 21 }, new[] { 21, 2, 1, 0, 5, 6, 7, 8, 9, 12, 13, 14, 15, 18, 19, 20, 21 },
                                             new[] { 21, 2, 1, 0, 5, 6, 7, 8, 9, 12, 13, 14, 15, 18, 23, 22, 21 },
                                             new[] { 21, 2, 1, 0, 5, 6, 7, 8, 9, 12, 17, 16, 15, 18, 19, 20, 21 },
                                             new[] { 21, 2, 1, 0, 5, 6, 7, 8, 9, 12, 17, 16, 15, 18, 23, 22, 21 },
                                             new[] { 21, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 18, 19, 20, 21 },
                                             new[] { 21, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 18, 23, 22, 21 },
                                             new[] { 21, 2, 3, 4, 5, 6, 7, 8, 9, 12, 17, 16, 15, 18, 19, 20, 21 },
                                             new[] { 21, 2, 3, 4, 5, 6, 7, 8, 9, 12, 17, 16, 15, 18, 23, 22, 21 },
                                             new[] { 21, 2, 1, 0, 5, 6, 11, 10, 9, 12, 13, 14, 15, 18, 19, 20, 21 },
                                             new[] { 21, 2, 1, 0, 5, 6, 11, 10, 9, 12, 13, 14, 15, 18, 23, 22, 21 },
                                             new[] { 21, 2, 1, 0, 5, 6, 11, 10, 9, 12, 17, 16, 15, 18, 19, 20, 21 },
                                             new[] { 21, 2, 1, 0, 5, 6, 11, 10, 9, 12, 17, 16, 15, 18, 23, 22, 21 },
                                             new[] { 21, 2, 3, 4, 5, 6, 11, 10, 9, 12, 13, 14, 15, 18, 19, 20, 21 },
                                             new[] { 21, 2, 3, 4, 5, 6, 11, 10, 9, 12, 13, 14, 15, 18, 23, 22, 21 },
                                             new[] { 21, 2, 3, 4, 5, 6, 11, 10, 9, 12, 17, 16, 15, 18, 19, 20, 21 },
                                             new[] { 21, 2, 3, 4, 5, 6, 11, 10, 9, 12, 17, 16, 15, 18, 23, 22, 21 } };
            Assert.IsTrue(Compares.AreOrderLessDeepEqual(expected, paths));
        }
        public virtual void Size_cyclophane_odd()
        {
            int[][]         cyclophane_even = InitialCyclesTest.CyclophaneEven;
            EdgeShortCycles esc             = new EdgeShortCycles(cyclophane_even);

            Assert.AreEqual(3, esc.GetPaths().Count());
        }
        public virtual void Size_anthracene()
        {
            int[][]         anthracene = InitialCyclesTest.Anthracene;
            EdgeShortCycles esc        = new EdgeShortCycles(anthracene);

            Assert.AreEqual(3, esc.GetPaths().Count());
        }
        public virtual void Size_napthalene()
        {
            int[][]         napthalene = InitialCyclesTest.Naphthalene;
            EdgeShortCycles esc        = new EdgeShortCycles(napthalene);

            Assert.AreEqual(2, esc.GetPaths().Count());
        }
        public virtual void Size_bicyclo()
        {
            int[][]         bicyclo = InitialCyclesTest.Bicyclo;
            EdgeShortCycles esc     = new EdgeShortCycles(bicyclo);

            Assert.AreEqual(3, esc.GetPaths().Count());
        }
        public virtual void Size_norbornane()
        {
            int[][]         norbornane = InitialCyclesTest.Norbornane;
            EdgeShortCycles esc        = new EdgeShortCycles(norbornane);

            int[][] paths = esc.GetPaths();
            Assert.AreEqual(2, paths.Length);
        }
        public virtual void Paths_anthracene()
        {
            int[][]         anthracene = InitialCyclesTest.Anthracene;
            EdgeShortCycles esc        = new EdgeShortCycles(anthracene);

            int[][] paths    = esc.GetPaths();
            int[][] expected = new int[][] { new[] { 5, 0, 1, 2, 3, 4, 5 }, new[] { 9, 6, 5, 4, 7, 8, 9 }, new[] { 9, 8, 10, 11, 12, 13, 9 } };
            Assert.IsTrue(Compares.AreOrderLessDeepEqual(expected, paths));
        }
        public virtual void Paths_napthalene()
        {
            int[][]         napthalene = InitialCyclesTest.Naphthalene;
            EdgeShortCycles esc        = new EdgeShortCycles(napthalene);

            int[][] paths    = esc.GetPaths();
            int[][] expected = new int[][] { new[] { 5, 0, 1, 2, 3, 4, 5 }, new[] { 5, 4, 7, 8, 9, 6, 5 } };
            Assert.IsTrue(Compares.AreOrderLessDeepEqual(expected, paths));
        }
        public virtual void Paths_bicyclo()
        {
            int[][]         bicyclo = InitialCyclesTest.Bicyclo;
            EdgeShortCycles esc     = new EdgeShortCycles(bicyclo);

            int[][] paths    = esc.GetPaths();
            int[][] expected = new int[][] { new[] { 5, 0, 1, 2, 3, 4, 5 }, new[] { 5, 0, 1, 2, 7, 6, 5 }, new[] { 5, 4, 3, 2, 7, 6, 5 } };
            Assert.IsTrue(Compares.AreOrderLessDeepEqual(expected, paths));
        }
        public virtual void Paths_norbornane()
        {
            int[][]         norbornane = InitialCyclesTest.Norbornane;
            EdgeShortCycles esc        = new EdgeShortCycles(norbornane);

            int[][] paths    = esc.GetPaths();
            int[][] expected = new int[][] { new[] { 5, 6, 2, 1, 0, 5 }, new[] { 5, 6, 2, 3, 4, 5 } };
            Assert.IsTrue(Compares.AreOrderLessDeepEqual(expected, paths));
        }
        public virtual void Paths_cyclophane_odd()
        {
            int[][]         cyclophane_even = InitialCyclesTest.CyclophaneEven;
            EdgeShortCycles esc             = new EdgeShortCycles(cyclophane_even);

            int[][] paths    = esc.GetPaths();
            int[][] expected = new int[][] { new[] { 3, 2, 1, 0, 5, 4, 3 }, new[] { 3, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3 },
                                             new[] { 3, 6, 7, 8, 9, 10, 11, 0, 5, 4, 3 } };
            Assert.IsTrue(Compares.AreOrderLessDeepEqual(expected, paths));
        }