File size: 4,315 Bytes
fab29d7
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
using System.Xml.Linq;
using VersOne.Epub.Schema;

namespace VersOne.Epub.Test.Comparers
{
    internal static class SmilComparers
    {
        public static void CompareSmilLists(List<Smil> expected, List<Smil> actual)
        {
            Assert.NotNull(actual);
            CollectionComparer.CompareCollections(expected, actual, CompareSmils);
        }

        public static void CompareSmils(Smil expected, Smil actual)
        {
            Assert.NotNull(actual);
            Assert.Equal(expected.Id, actual.Id);
            Assert.Equal(expected.Version, actual.Version);
            Assert.Equal(expected.EpubPrefix, actual.EpubPrefix);
            CompareSmilHeads(expected.Head, actual.Head);
            CompareSmilBodies(expected.Body, actual.Body);
        }

        public static void CompareSmilHeads(SmilHead? expected, SmilHead? actual)
        {
            if (expected == null)
            {
                Assert.Null(actual);
            }
            else
            {
                Assert.NotNull(actual);
                CompareSmilMetadatas(expected.Metadata, actual.Metadata);
            }
        }

        public static void CompareSmilMetadatas(SmilMetadata? expected, SmilMetadata? actual)
        {
            if (expected == null)
            {
                Assert.Null(actual);
            }
            else
            {
                Assert.NotNull(actual);
                CompareSmilMetadataItems(expected.Items, actual.Items);
            }
        }

        public static void CompareSmilMetadataItems(List<XElement> expected, List<XElement> actual)
        {
            CollectionComparer.CompareCollections(expected, actual, CompareXElements);
        }

        public static void CompareSmilBodies(SmilBody expected, SmilBody actual)
        {
            Assert.NotNull(actual);
            Assert.Equal(expected.Id, actual.Id);
            Assert.Equal(expected.EpubTypes, actual.EpubTypes);
            Assert.Equal(expected.EpubTextRef, actual.EpubTextRef);
            CompareSmilSeqLists(expected.Seqs, actual.Seqs);
            CompareSmilParLists(expected.Pars, actual.Pars);
        }

        public static void CompareSmilSeqLists(List<SmilSeq> expected, List<SmilSeq> actual)
        {
            CollectionComparer.CompareCollections(expected, actual, CompareSmilSeqs);
        }

        public static void CompareSmilSeqs(SmilSeq expected, SmilSeq actual)
        {
            Assert.NotNull(actual);
            Assert.Equal(expected.Id, actual.Id);
            Assert.Equal(expected.EpubTypes, actual.EpubTypes);
            Assert.Equal(expected.EpubTextRef, actual.EpubTextRef);
            CompareSmilSeqLists(expected.Seqs, actual.Seqs);
            CompareSmilParLists(expected.Pars, actual.Pars);
        }

        public static void CompareSmilParLists(List<SmilPar> expected, List<SmilPar> actual)
        {
            CollectionComparer.CompareCollections(expected, actual, CompareSmilPars);
        }

        public static void CompareSmilPars(SmilPar expected, SmilPar actual)
        {
            Assert.NotNull(actual);
            Assert.Equal(expected.Id, actual.Id);
            Assert.Equal(expected.EpubTypes, actual.EpubTypes);
            CompareSmilTexts(expected.Text, actual.Text);
            CompareSmilAudios(expected.Audio, actual.Audio);
        }

        public static void CompareSmilTexts(SmilText expected, SmilText actual)
        {
            Assert.NotNull(actual);
            Assert.Equal(expected.Id, actual.Id);
            Assert.Equal(expected.Src, actual.Src);
        }

        public static void CompareSmilAudios(SmilAudio? expected, SmilAudio? actual)
        {
            if (expected == null)
            {
                Assert.Null(actual);
            }
            else
            {
                Assert.NotNull(actual);
                Assert.Equal(expected.Id, actual.Id);
                Assert.Equal(expected.Src, actual.Src);
                Assert.Equal(expected.ClipBegin, actual.ClipBegin);
                Assert.Equal(expected.ClipEnd, actual.ClipEnd);
            }
        }

        private static void CompareXElements(XElement expected, XElement actual)
        {
            Assert.Equal(expected.ToString(), actual.ToString());
        }
    }
}