1 package exifcommon
2
3 import (
4 "fmt"
5 "reflect"
6 "sort"
7 "testing"
8
9 "github.com/dsoprea/go-logging"
10 )
11
12 func TestIfdMapping_Add(t *testing.T) {
13 im := NewIfdMapping()
14
15 err := im.Add([]uint16{}, 0x1111, "ifd0")
16 log.PanicIf(err)
17
18 err = im.Add([]uint16{0x1111}, 0x4444, "ifd00")
19 log.PanicIf(err)
20
21 err = im.Add([]uint16{0x1111, 0x4444}, 0x5555, "ifd000")
22 log.PanicIf(err)
23
24 err = im.Add([]uint16{}, 0x2222, "ifd1")
25 log.PanicIf(err)
26
27 err = im.Add([]uint16{}, 0x3333, "ifd2")
28 log.PanicIf(err)
29
30 lineages, err := im.DumpLineages()
31 log.PanicIf(err)
32
33 sort.Strings(lineages)
34
35 expected := []string{
36 "ifd0",
37 "ifd0/ifd00",
38 "ifd0/ifd00/ifd000",
39 "ifd1",
40 "ifd2",
41 }
42
43 if reflect.DeepEqual(lineages, expected) != true {
44 fmt.Printf("Actual:\n")
45 fmt.Printf("\n")
46
47 for i, line := range lineages {
48 fmt.Printf("(%d) %s\n", i, line)
49 }
50
51 fmt.Printf("\n")
52
53 fmt.Printf("Expected:\n")
54 fmt.Printf("\n")
55
56 for i, line := range expected {
57 fmt.Printf("(%d) %s\n", i, line)
58 }
59
60 t.Fatalf("IFD-mapping dump not correct.")
61 }
62 }
63
64 func TestIfdMapping_LoadStandardIfds(t *testing.T) {
65 im := NewIfdMapping()
66
67 err := LoadStandardIfds(im)
68 log.PanicIf(err)
69
70 lineages, err := im.DumpLineages()
71 log.PanicIf(err)
72
73 sort.Strings(lineages)
74
75 expected := []string{
76 "IFD",
77 "IFD/Exif",
78 "IFD/Exif/Iop",
79 "IFD/GPSInfo",
80 }
81
82 if reflect.DeepEqual(lineages, expected) != true {
83 fmt.Printf("Actual:\n")
84 fmt.Printf("\n")
85
86 for i, line := range lineages {
87 fmt.Printf("(%d) %s\n", i, line)
88 }
89
90 fmt.Printf("\n")
91
92 fmt.Printf("Expected:\n")
93 fmt.Printf("\n")
94
95 for i, line := range expected {
96 fmt.Printf("(%d) %s\n", i, line)
97 }
98
99 t.Fatalf("IFD-mapping dump not correct.")
100 }
101 }
102
103 func TestIfdMapping_Get(t *testing.T) {
104 im := NewIfdMapping()
105
106 err := LoadStandardIfds(im)
107 log.PanicIf(err)
108
109 mi, err := im.Get([]uint16{
110 IfdStandardIfdIdentity.TagId(),
111 IfdExifStandardIfdIdentity.TagId(),
112 IfdExifIopStandardIfdIdentity.TagId(),
113 })
114
115 log.PanicIf(err)
116
117 if mi.ParentTagId != IfdExifStandardIfdIdentity.TagId() {
118 t.Fatalf("Parent tag-ID not correct")
119 } else if mi.TagId != IfdExifIopStandardIfdIdentity.TagId() {
120 t.Fatalf("Tag-ID not correct")
121 } else if mi.Name != "Iop" {
122 t.Fatalf("name not correct")
123 } else if mi.PathPhrase() != "IFD/Exif/Iop" {
124 t.Fatalf("path not correct")
125 }
126 }
127
128 func TestIfdMapping_GetWithPath(t *testing.T) {
129 im := NewIfdMapping()
130
131 err := LoadStandardIfds(im)
132 log.PanicIf(err)
133
134 mi, err := im.GetWithPath("IFD/Exif/Iop")
135 log.PanicIf(err)
136
137 if mi.ParentTagId != IfdExifStandardIfdIdentity.TagId() {
138 t.Fatalf("Parent tag-ID not correct")
139 } else if mi.TagId != IfdExifIopStandardIfdIdentity.TagId() {
140 t.Fatalf("Tag-ID not correct")
141 } else if mi.Name != "Iop" {
142 t.Fatalf("name not correct")
143 } else if mi.PathPhrase() != "IFD/Exif/Iop" {
144 t.Fatalf("path not correct")
145 }
146 }
147
148 func TestIfdMapping_ResolvePath__Regular(t *testing.T) {
149 im := NewIfdMapping()
150
151 err := LoadStandardIfds(im)
152 log.PanicIf(err)
153
154 lineage, err := im.ResolvePath("IFD/Exif/Iop")
155 log.PanicIf(err)
156
157 expected := []IfdTagIdAndIndex{
158 {Name: "IFD", TagId: 0, Index: 0},
159 {Name: "Exif", TagId: 0x8769, Index: 0},
160 {Name: "Iop", TagId: 0xa005, Index: 0},
161 }
162
163 if reflect.DeepEqual(lineage, expected) != true {
164 t.Fatalf("Lineage not correct.")
165 }
166 }
167
168 func TestIfdMapping_ResolvePath__WithIndices(t *testing.T) {
169 im := NewIfdMapping()
170
171 err := LoadStandardIfds(im)
172 log.PanicIf(err)
173
174 lineage, err := im.ResolvePath("IFD/Exif1/Iop")
175 log.PanicIf(err)
176
177 expected := []IfdTagIdAndIndex{
178 {Name: "IFD", TagId: 0, Index: 0},
179 {Name: "Exif", TagId: 0x8769, Index: 1},
180 {Name: "Iop", TagId: 0xa005, Index: 0},
181 }
182
183 if reflect.DeepEqual(lineage, expected) != true {
184 t.Fatalf("Lineage not correct.")
185 }
186 }
187
188 func TestIfdMapping_ResolvePath__Miss(t *testing.T) {
189 im := NewIfdMapping()
190
191 err := LoadStandardIfds(im)
192 log.PanicIf(err)
193
194 _, err = im.ResolvePath("IFD/Exif/Invalid")
195 if err == nil {
196 t.Fatalf("Expected failure for invalid IFD path.")
197 } else if err.Error() != "ifd child with name [Invalid] not registered: [IFD/Exif/Invalid]" {
198 log.Panic(err)
199 }
200 }
201
202 func TestIfdMapping_FqPathPhraseFromLineage(t *testing.T) {
203 lineage := []IfdTagIdAndIndex{
204 {Name: "IFD", Index: 0},
205 {Name: "Exif", Index: 1},
206 {Name: "Iop", Index: 0},
207 }
208
209 im := NewIfdMapping()
210
211 fqPathPhrase := im.FqPathPhraseFromLineage(lineage)
212 if fqPathPhrase != "IFD/Exif1/Iop" {
213 t.Fatalf("path-phrase not correct: [%s]", fqPathPhrase)
214 }
215 }
216
217 func TestIfdMapping_PathPhraseFromLineage(t *testing.T) {
218 lineage := []IfdTagIdAndIndex{
219 {Name: "IFD", Index: 0},
220 {Name: "Exif", Index: 1},
221 {Name: "Iop", Index: 0},
222 }
223
224 im := NewIfdMapping()
225
226 fqPathPhrase := im.PathPhraseFromLineage(lineage)
227 if fqPathPhrase != "IFD/Exif/Iop" {
228 t.Fatalf("path-phrase not correct: [%s]", fqPathPhrase)
229 }
230 }
231
232 func TestIfdMapping_NewIfdMappingWithStandard(t *testing.T) {
233 imWith, err := NewIfdMappingWithStandard()
234 log.PanicIf(err)
235
236 imWithout := NewIfdMapping()
237
238 err = LoadStandardIfds(imWithout)
239 log.PanicIf(err)
240
241 outputWith, err := imWith.DumpLineages()
242 log.PanicIf(err)
243
244 sort.Strings(outputWith)
245
246 outputWithout, err := imWithout.DumpLineages()
247 log.PanicIf(err)
248
249 sort.Strings(outputWithout)
250
251 if reflect.DeepEqual(outputWith, outputWithout) != true {
252 fmt.Printf("WITH:\n")
253 fmt.Printf("\n")
254
255 for _, line := range outputWith {
256 fmt.Printf("%s\n", line)
257 }
258
259 fmt.Printf("\n")
260
261 fmt.Printf("WITHOUT:\n")
262 fmt.Printf("\n")
263
264 for _, line := range outputWithout {
265 fmt.Printf("%s\n", line)
266 }
267
268 fmt.Printf("\n")
269
270 t.Fatalf("Standard IFDs not loaded correctly.")
271 }
272 }
273
274 func TestNewIfdIdentityFromString_Valid_WithoutIndexes(t *testing.T) {
275 im := NewIfdMapping()
276
277 err := LoadStandardIfds(im)
278 log.PanicIf(err)
279
280 fqIfdPath := "IFD/Exif"
281
282 ii, err := NewIfdIdentityFromString(im, fqIfdPath)
283 log.PanicIf(err)
284
285 if ii.String() != fqIfdPath {
286 t.Fatalf("'%s' IFD-path was not parsed correctly: [%s]", fqIfdPath, ii.String())
287 }
288 }
289
290 func TestNewIfdIdentityFromString_Valid_WithIndexes(t *testing.T) {
291 im := NewIfdMapping()
292
293 err := LoadStandardIfds(im)
294 log.PanicIf(err)
295
296 fqIfdPath := "IFD2/Exif4"
297
298 ii, err := NewIfdIdentityFromString(im, fqIfdPath)
299 log.PanicIf(err)
300
301 if ii.String() != fqIfdPath {
302 t.Fatalf("'%s' IFD-path was not parsed correctly: [%s]", fqIfdPath, ii.String())
303 }
304 }
305
306 func TestNewIfdIdentityFromString_Invalid_IfdPathJustRoot(t *testing.T) {
307 im := NewIfdMapping()
308
309 err := LoadStandardIfds(im)
310 log.PanicIf(err)
311
312 fqIfdPath := "XYZ"
313
314 _, err = NewIfdIdentityFromString(im, fqIfdPath)
315 if err == nil {
316 t.Fatalf("Expected error from invalid path.")
317 } else if err.Error() != "ifd child with name [XYZ] not registered: [XYZ]" {
318 log.Panic(err)
319 }
320 }
321
322 func TestNewIfdIdentityFromString_Invalid_IfdPathWithSubdirectory(t *testing.T) {
323 im := NewIfdMapping()
324
325 err := LoadStandardIfds(im)
326 log.PanicIf(err)
327
328 fqIfdPath := "IFD/XYZ"
329
330 _, err = NewIfdIdentityFromString(im, fqIfdPath)
331 if err == nil {
332 t.Fatalf("Expected error from invalid path.")
333 } else if err.Error() != "ifd child with name [XYZ] not registered: [IFD/XYZ]" {
334 log.Panic(err)
335 }
336 }
337
View as plain text