~mdw / dpkg / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
dpkg (1.18.25) stretch; urgency=medium
[dpkg] / lib / dpkg / t / t-version.c
CommitLineData
1479465f
GJ		 1/*
2 * libdpkg - Debian packaging suite library routines
3 * t-version.c - test version handling
4 *
5 * Copyright © 2009-2014 Guillem Jover <guillem@debian.org>
6 *
7 * This is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
19 */
20
21#include <config.h>
22#include <compat.h>
23
24#include <stdlib.h>
25
26#include <dpkg/test.h>
27#include <dpkg/dpkg.h>
28#include <dpkg/dpkg-db.h>
29
30static void
31test_version_blank(void)
32{
33 struct dpkg_version a;
34
35 dpkg_version_blank(&a);
36 test_pass(a.epoch == 0);
37 test_pass(a.version == NULL);
38 test_pass(a.revision == NULL);
39}
40
41static void
42test_version_is_informative(void)
43{
44 struct dpkg_version a;
45
46 dpkg_version_blank(&a);
47 test_fail(dpkg_version_is_informative(&a));
48
49 a.epoch = 1;
50 test_pass(dpkg_version_is_informative(&a));
51
52 dpkg_version_blank(&a);
53 a.version = "1";
54 test_pass(dpkg_version_is_informative(&a));
55
56 dpkg_version_blank(&a);
57 a.revision = "1";
58 test_pass(dpkg_version_is_informative(&a));
59}
60
61static void
62test_version_compare(void)
63{
64 struct dpkg_version a, b;
65
66 dpkg_version_blank(&a);
67 dpkg_version_blank(&b);
68 test_pass(dpkg_version_compare(&a, &b) == 0);
69
70 a.epoch = 1;
71 b.epoch = 2;
72 test_fail(dpkg_version_compare(&a, &b) == 0);
73
74 a = DPKG_VERSION_OBJECT(0, "1", "1");
75 b = DPKG_VERSION_OBJECT(0, "2", "1");
76 test_fail(dpkg_version_compare(&a, &b) == 0);
77
78 a = DPKG_VERSION_OBJECT(0, "1", "1");
79 b = DPKG_VERSION_OBJECT(0, "1", "2");
80 test_fail(dpkg_version_compare(&a, &b) == 0);
81
82 /* Test for version equality. */
83 a = b = DPKG_VERSION_OBJECT(0, "0", "0");
84 test_pass(dpkg_version_compare(&a, &b) == 0);
85
86 a = DPKG_VERSION_OBJECT(0, "0", "00");
87 b = DPKG_VERSION_OBJECT(0, "00", "0");
88 test_pass(dpkg_version_compare(&a, &b) == 0);
89
90 a = b = DPKG_VERSION_OBJECT(1, "2", "3");
91 test_pass(dpkg_version_compare(&a, &b) == 0);
92
93 /* Test for epoch difference. */
94 a = DPKG_VERSION_OBJECT(0, "0", "0");
95 b = DPKG_VERSION_OBJECT(1, "0", "0");
96 test_pass(dpkg_version_compare(&a, &b) < 0);
97 test_pass(dpkg_version_compare(&b, &a) > 0);
98
99 /* Test for version component difference. */
100 a = DPKG_VERSION_OBJECT(0, "a", "0");
101 b = DPKG_VERSION_OBJECT(0, "b", "0");
102 test_pass(dpkg_version_compare(&a, &b) < 0);
103 test_pass(dpkg_version_compare(&b, &a) > 0);
104
105 /* Test for revision component difference. */
106 a = DPKG_VERSION_OBJECT(0, "0", "a");
107 b = DPKG_VERSION_OBJECT(0, "0", "b");
108 test_pass(dpkg_version_compare(&a, &b) < 0);
109 test_pass(dpkg_version_compare(&b, &a) > 0);
110
111 /* FIXME: Complete. */
112}
113
114static void
115test_version_relate(void)
116{
117 struct dpkg_version a, b;
118
119 dpkg_version_blank(&a);
120 dpkg_version_blank(&b);
121 test_pass(dpkg_version_relate(&a, DPKG_RELATION_NONE, &b));
122
123 a = DPKG_VERSION_OBJECT(0, "1", "1");
124 b = DPKG_VERSION_OBJECT(0, "1", "1");
125 test_pass(dpkg_version_relate(&a, DPKG_RELATION_EQ, &b));
126 test_fail(dpkg_version_relate(&a, DPKG_RELATION_LT, &b));
127 test_pass(dpkg_version_relate(&a, DPKG_RELATION_LE, &b));
128 test_fail(dpkg_version_relate(&a, DPKG_RELATION_GT, &b));
129 test_pass(dpkg_version_relate(&a, DPKG_RELATION_GE, &b));
130
131 a = DPKG_VERSION_OBJECT(0, "1", "1");
132 b = DPKG_VERSION_OBJECT(0, "2", "1");
133 test_fail(dpkg_version_relate(&a, DPKG_RELATION_EQ, &b));
134 test_pass(dpkg_version_relate(&a, DPKG_RELATION_LT, &b));
135 test_pass(dpkg_version_relate(&a, DPKG_RELATION_LE, &b));
136 test_fail(dpkg_version_relate(&a, DPKG_RELATION_GT, &b));
137 test_fail(dpkg_version_relate(&a, DPKG_RELATION_GE, &b));
138
139 a = DPKG_VERSION_OBJECT(0, "2", "1");
140 b = DPKG_VERSION_OBJECT(0, "1", "1");
141 test_fail(dpkg_version_relate(&a, DPKG_RELATION_EQ, &b));
142 test_fail(dpkg_version_relate(&a, DPKG_RELATION_LT, &b));
143 test_fail(dpkg_version_relate(&a, DPKG_RELATION_LE, &b));
144 test_pass(dpkg_version_relate(&a, DPKG_RELATION_GT, &b));
145 test_pass(dpkg_version_relate(&a, DPKG_RELATION_GE, &b));
146}
147
148static void
149test_version_parse(void)
150{
151 struct dpkg_error err;
152 struct dpkg_version a, b;
153 const char *p;
154 char *verstr;
155
156 /* Test 0 versions. */
157 dpkg_version_blank(&a);
158 b = DPKG_VERSION_OBJECT(0, "0", "");
159
160 test_pass(parseversion(&a, "0", NULL) == 0);
161 test_pass(dpkg_version_compare(&a, &b) == 0);
162
163 test_pass(parseversion(&a, "0:0", NULL) == 0);
164 test_pass(dpkg_version_compare(&a, &b) == 0);
165
166 b = DPKG_VERSION_OBJECT(0, "0", "0");
167 test_pass(parseversion(&a, "0:0-0", NULL) == 0);
168 test_pass(dpkg_version_compare(&a, &b) == 0);
169
170 b = DPKG_VERSION_OBJECT(0, "0.0", "0.0");
171 test_pass(parseversion(&a, "0:0.0-0.0", NULL) == 0);
172 test_pass(dpkg_version_compare(&a, &b) == 0);
173
174 /* Test epoched versions. */
175 b = DPKG_VERSION_OBJECT(1, "0", "");
176 test_pass(parseversion(&a, "1:0", NULL) == 0);
177 test_pass(dpkg_version_compare(&a, &b) == 0);
178
179 b = DPKG_VERSION_OBJECT(5, "1", "");
180 test_pass(parseversion(&a, "5:1", NULL) == 0);
181 test_pass(dpkg_version_compare(&a, &b) == 0);
182
183 /* Test multiple hyphens. */
184 b = DPKG_VERSION_OBJECT(0, "0-0", "0");
185 test_pass(parseversion(&a, "0:0-0-0", NULL) == 0);
186 test_pass(dpkg_version_compare(&a, &b) == 0);
187
188 b = DPKG_VERSION_OBJECT(0, "0-0-0", "0");
189 test_pass(parseversion(&a, "0:0-0-0-0", NULL) == 0);
190 test_pass(dpkg_version_compare(&a, &b) == 0);
191
192 /* Test multiple colons. */
193 b = DPKG_VERSION_OBJECT(0, "0:0", "0");
194 test_pass(parseversion(&a, "0:0:0-0", NULL) == 0);
195 test_pass(dpkg_version_compare(&a, &b) == 0);
196
197 b = DPKG_VERSION_OBJECT(0, "0:0:0", "0");
198 test_pass(parseversion(&a, "0:0:0:0-0", NULL) == 0);
199 test_pass(dpkg_version_compare(&a, &b) == 0);
200
201 /* Test multiple hyphens and colons. */
202 b = DPKG_VERSION_OBJECT(0, "0:0-0", "0");
203 test_pass(parseversion(&a, "0:0:0-0-0", NULL) == 0);
204 test_pass(dpkg_version_compare(&a, &b) == 0);
205
206 b = DPKG_VERSION_OBJECT(0, "0-0:0", "0");
207 test_pass(parseversion(&a, "0:0-0:0-0", NULL) == 0);
208 test_pass(dpkg_version_compare(&a, &b) == 0);
209
210 /* Test valid characters in upstream version. */
211 b = DPKG_VERSION_OBJECT(0, "09azAZ.-+~:", "0");
212 test_pass(parseversion(&a, "0:09azAZ.-+~:-0", NULL) == 0);
213 test_pass(dpkg_version_compare(&a, &b) == 0);
214
215 /* Test valid characters in revision. */
216 b = DPKG_VERSION_OBJECT(0, "0", "azAZ09.+~");
217 test_pass(parseversion(&a, "0:0-azAZ09.+~", NULL) == 0);
218 test_pass(dpkg_version_compare(&a, &b) == 0);
219
220 /* Test version with leading and trailing spaces. */
221 b = DPKG_VERSION_OBJECT(0, "0", "1");
222 test_pass(parseversion(&a, " 0:0-1", &err) == 0);
223 test_pass(dpkg_version_compare(&a, &b) == 0);
224 test_pass(parseversion(&a, "0:0-1 ", &err) == 0);
225 test_pass(dpkg_version_compare(&a, &b) == 0);
226 test_pass(parseversion(&a, " 0:0-1 ", &err) == 0);
227 test_pass(dpkg_version_compare(&a, &b) == 0);
228
229 /* Test empty version. */
230 test_pass(parseversion(&a, "", &err) != 0);
231 test_error(err);
232 test_pass(parseversion(&a, " ", &err) != 0);
233 test_error(err);
234
235 /* Test empty upstream version after epoch. */
236 test_fail(parseversion(&a, "0:", &err) == 0);
237 test_error(err);
238
239 /* Test empty epoch in version. */
240 test_fail(parseversion(&a, ":1.0", &err) == 0);
241 test_error(err);
242
243 /* Test empty revision in version. */
244 test_fail(parseversion(&a, "1.0-", &err) == 0);
245 test_error(err);
246
247 /* Test version with embedded spaces. */
248 test_fail(parseversion(&a, "0:0 0-1", &err) == 0);
249 test_error(err);
250
251 /* Test version with negative epoch. */
252 test_fail(parseversion(&a, "-1:0-1", &err) == 0);
253 test_error(err);
254
255 /* Test version with huge epoch. */
256 test_fail(parseversion(&a, "999999999999999999999999:0-1", &err) == 0);
257 test_error(err);
258
259 /* Test invalid characters in epoch. */
260 test_fail(parseversion(&a, "a:0-0", &err) == 0);
261 test_error(err);
262 test_fail(parseversion(&a, "A:0-0", &err) == 0);
263 test_error(err);
264
265 /* Test invalid empty upstream version. */
266 test_fail(parseversion(&a, "-0", &err) == 0);
267 test_error(err);
268 test_fail(parseversion(&a, "0:-0", &err) == 0);
269 test_error(err);
270
271 /* Test upstream version not starting with a digit */
272 test_fail(parseversion(&a, "0:abc3-0", &err) == 0);
273 test_warn(err);
274
275 /* Test invalid characters in upstream version. */
276 verstr = test_alloc(strdup("0:0a-0"));
277 for (p = "!#@$%&/|\\<>()[]{};,_=*^'"; *p; p++) {
278 verstr[3] = *p;
279 test_fail(parseversion(&a, verstr, &err) == 0);
280 test_warn(err);
281 }
282 free(verstr);
283
284 /* Test invalid characters in revision. */
285 test_fail(parseversion(&a, "0:0-0:0", &err) == 0);
286 test_warn(err);
287
288 verstr = test_alloc(strdup("0:0-0"));
289 for (p = "!#@$%&/|\\<>()[]{}:;,_=*^'"; *p; p++) {
290 verstr[4] = *p;
291 test_fail(parseversion(&a, verstr, &err) == 0);
292 test_warn(err);
293 }
294 free(verstr);
295
296 /* FIXME: Complete. */
297}
298
299TEST_ENTRY(test)
300{
301 test_plan(196);
302
303 test_version_blank();
304 test_version_is_informative();
305 test_version_compare();
306 test_version_relate();
307 test_version_parse();
308}
Debian package manager -- local hacks