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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
package exif
//go:generate go run regen_regress.go -- regress_expected_test.go
//go:generate go fmt regress_expected_test.go
import (
"flag"
"fmt"
"math"
"os"
"path/filepath"
"strings"
"testing"
"github.com/rwcarlsen/goexif/tiff"
)
var dataDir = flag.String("test_data_dir", ".", "Directory where the data files for testing are located")
func TestDecode(t *testing.T) {
fpath := filepath.Join(*dataDir, "samples")
f, err := os.Open(fpath)
if err != nil {
t.Fatalf("Could not open sample directory '%s': %v", fpath, err)
}
names, err := f.Readdirnames(0)
if err != nil {
t.Fatalf("Could not read sample directory '%s': %v", fpath, err)
}
cnt := 0
for _, name := range names {
if !strings.HasSuffix(name, ".jpg") {
t.Logf("skipping non .jpg file %v", name)
continue
}
t.Logf("testing file %v", name)
f, err := os.Open(filepath.Join(fpath, name))
if err != nil {
t.Fatal(err)
}
x, err := Decode(f)
if err != nil {
t.Fatal(err)
} else if x == nil {
t.Fatalf("No error and yet %v was not decoded", name)
}
t.Logf("checking pic %v", name)
x.Walk(&walker{name, t})
cnt++
}
if cnt != len(regressExpected) {
t.Errorf("Did not process enough samples, got %d, want %d", cnt, len(regressExpected))
}
}
type walker struct {
picName string
t *testing.T
}
func (w *walker) Walk(field FieldName, tag *tiff.Tag) error {
// this needs to be commented out when regenerating regress expected vals
pic := regressExpected[w.picName]
if pic == nil {
w.t.Errorf(" regression data not found")
return nil
}
exp, ok := pic[field]
if !ok {
w.t.Errorf(" regression data does not have field %v", field)
return nil
}
s := tag.String()
if tag.Count == 1 && s != "\"\"" {
s = fmt.Sprintf("[%s]", s)
}
got := tag.String()
if exp != got {
fmt.Println("s: ", s)
fmt.Printf("len(s)=%v\n", len(s))
w.t.Errorf(" field %v bad tag: expected '%s', got '%s'", field, exp, got)
}
return nil
}
func TestMarshal(t *testing.T) {
name := filepath.Join(*dataDir, "sample1.jpg")
f, err := os.Open(name)
if err != nil {
t.Fatalf("%v\n", err)
}
defer f.Close()
x, err := Decode(f)
if err != nil {
t.Fatal(err)
}
if x == nil {
t.Fatal("bad err")
}
b, err := x.MarshalJSON()
if err != nil {
t.Fatal(err)
}
t.Logf("%s", b)
}
func testSingleParseDegreesString(t *testing.T, s string, w float64) {
g, err := parseTagDegreesString(s)
if err != nil {
t.Fatal(err)
}
if math.Abs(w-g) > 1e-10 {
t.Errorf("Wrong parsing result %s: Want %.12f, got %.12f", s, w, g)
}
}
func TestParseTagDegreesString(t *testing.T) {
// semicolon as decimal mark
testSingleParseDegreesString(t, "52,00000,50,00000,34,01180", 52.842781055556) // comma as separator
testSingleParseDegreesString(t, "52,00000;50,00000;34,01180", 52.842781055556) // semicolon as separator
// point as decimal mark
testSingleParseDegreesString(t, "14.00000,44.00000,34.01180", 14.742781055556) // comma as separator
testSingleParseDegreesString(t, "14.00000;44.00000;34.01180", 14.742781055556) // semicolon as separator
testSingleParseDegreesString(t, "14.00000;44.00000,34.01180", 14.742781055556) // mixed separators
testSingleParseDegreesString(t, "-008.0,30.0,03.6", -8.501) // leading zeros
// no decimal places
testSingleParseDegreesString(t, "-10,15,54", -10.265)
testSingleParseDegreesString(t, "-10;15;54", -10.265)
// incorrect mix of comma and point as decimal mark
s := "-17,00000,15.00000,04.80000"
if _, err := parseTagDegreesString(s); err == nil {
t.Error("parseTagDegreesString: false positive for " + s)
}
}
// Make sure we error out early when a tag had a count of MaxUint32
func TestMaxUint32CountError(t *testing.T) {
name := filepath.Join(*dataDir, "corrupt/max_uint32_exif.jpg")
f, err := os.Open(name)
if err != nil {
t.Fatalf("%v\n", err)
}
defer f.Close()
_, err = Decode(f)
if err == nil {
t.Fatal("no error on bad exif data")
}
if !strings.Contains(err.Error(), "invalid Count offset") {
t.Fatal("wrong error:", err.Error())
}
}
// Make sure we error out early with tag data sizes larger than the image file
func TestHugeTagError(t *testing.T) {
name := filepath.Join(*dataDir, "corrupt/huge_tag_exif.jpg")
f, err := os.Open(name)
if err != nil {
t.Fatalf("%v\n", err)
}
defer f.Close()
_, err = Decode(f)
if err == nil {
t.Fatal("no error on bad exif data")
}
if !strings.Contains(err.Error(), "short read") {
t.Fatal("wrong error:", err.Error())
}
}
// Check for a 0-length tag value
func TestZeroLengthTagError(t *testing.T) {
name := filepath.Join(*dataDir, "corrupt/infinite_loop_exif.jpg")
f, err := os.Open(name)
if err != nil {
t.Fatalf("%v\n", err)
}
defer f.Close()
_, err = Decode(f)
if err == nil {
t.Fatal("no error on bad exif data")
}
if !strings.Contains(err.Error(), "zero length tag value") {
t.Fatal("wrong error:", err.Error())
}
}
|
