public void GetHorizontalFace_returns_face_with_correct_Edges_directed_counterclockwise_in_counterclockwise_order
            ([Values(VerticalPrismalSurface.BaseSide.Bottom, VerticalPrismalSurface.BaseSide.Top)] VerticalPrismalSurface.BaseSide side,
            [Values(false, true)] bool isOrientedOutside)
        {
            var surface = CreateSurface(isClosedBase: true, isClosedSurface: true, isCounterclockwise: isOrientedOutside);

            Expect(surface.Order, Is.EqualTo(5)); // internal sanity

            var v1 = surface.GetVertex(index: 0, baseSide: side);
            var v2 = surface.GetVertex(index: 1, baseSide: side);
            var v3 = surface.GetVertex(index: 2, baseSide: side);
            var v4 = surface.GetVertex(index: 3, baseSide: side);
            var v5 = surface.GetVertex(index: 4, baseSide: side);

            var e1 = surface.GetEdge(v1, v2);
            var e2 = surface.GetEdge(v2, v3);
            var e3 = surface.GetEdge(v3, v4);
            var e4 = surface.GetEdge(v4, v5);
            var e5 = surface.GetEdge(v5, v1);

            var edges = new List <IPolysurfaceEdge> {
                e1, e2, e3, e4, e5
            };

            if (side == VerticalPrismalSurface.BaseSide.Bottom)
            {
                edges = edges.Select(e => e.Reversed).Reverse().ToList();
            }

            var face = surface.GetHorizontalFace(side);

            ExpectListsAreEqualUpToCyclicPermuation(face.Edges.ToReadOnlyList(), edges.ToReadOnlyList());
        }
        public void Horizontal_edge_has_correct_LeftFace_and_RightFace
            ([Values(false, true)] bool isClosedSurface,
            [Values(false, true)] bool isForwardEdge,
            [Values(VerticalPrismalSurface.BaseSide.Bottom, VerticalPrismalSurface.BaseSide.Top)] VerticalPrismalSurface.BaseSide side)
        {
            var surface = CreateSurface(isClosedBase: true, isClosedSurface: isClosedSurface);

            var v1 = surface.GetVertex(2, side);
            var v2 = surface.GetVertex(3, side);

            var edge = isForwardEdge ? surface.GetEdge(v1, v2) : surface.GetEdge(v2, v1);

            var leftFace  = edge.LeftFace;
            var rightFace = edge.RightFace;

            if (isClosedSurface)
            {
                Expect(leftFace, Is.Not.Null);
                Expect(rightFace, Is.Not.Null);
            }
            else
            {
                Expect(leftFace == null ^ rightFace == null);
            }

            if (leftFace != null)
            {
                Expect(leftFace.Edges, Has.Exactly(1).EqualTo(edge));
            }

            if (rightFace != null)
            {
                Expect(rightFace.Edges, Has.Exactly(1).EqualTo(edge.Reversed));
            }
        }