1 /*
2 * test-sid.cc: Part of GNU CSSC.
3 *
4 * Copyright (C) 2010, 2011, 2014, 2019 Free Software Foundation, Inc.
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 *
19 * Unit tests for sid.h.
20 *
21 */
22
23 #include "sid.h"
24 #include "release.h"
25 #include <gtest/gtest.h>
26
27
TEST(SidTest,NullConstructor)28 TEST(SidTest, NullConstructor)
29 {
30 const sid none;
31 EXPECT_TRUE(none.is_null());
32 EXPECT_FALSE(none.valid());
33 }
34
TEST(SidTest,StringConstructor)35 TEST(SidTest, StringConstructor)
36 {
37 const sid s("1.2.3.4");
38 EXPECT_FALSE(s.is_null());
39 EXPECT_TRUE(s.valid());
40 EXPECT_EQ(4, s.components());
41 EXPECT_FALSE(s.on_trunk());
42 }
43
TEST(SidTest,ConstructTrunkSid)44 TEST(SidTest, ConstructTrunkSid)
45 {
46 const sid s("1.2");
47 EXPECT_FALSE(s.is_null());
48 EXPECT_EQ(2, s.components());
49 EXPECT_TRUE(s.valid());
50 EXPECT_FALSE(s.partial_sid());
51 EXPECT_TRUE(s.on_trunk());
52 }
53
TEST(SidTest,ConstructFromRelease)54 TEST(SidTest, ConstructFromRelease)
55 {
56 const release rel(4);
57 const sid s(rel);
58 EXPECT_EQ(1, s.components());
59 EXPECT_EQ("4.0", s.as_string());
60 }
61
TEST(SidTest,PartialSid)62 TEST(SidTest, PartialSid)
63 {
64 const sid one("1");
65 EXPECT_FALSE(one.is_null());
66 EXPECT_EQ(1, one.components());
67 EXPECT_TRUE(one.valid());
68 EXPECT_TRUE(one.partial_sid());
69 EXPECT_FALSE(one.on_trunk());
70
71 const sid three("1.2.3");
72 EXPECT_FALSE(three.is_null());
73 EXPECT_EQ(3, three.components());
74 EXPECT_TRUE(three.valid());
75 EXPECT_TRUE(three.partial_sid());
76 EXPECT_FALSE(three.on_trunk());
77 }
78
TEST(SidTest,StringConversion)79 TEST(SidTest, StringConversion)
80 {
81 const sid one("1");
82 const sid two("1.2");
83 const sid three("1.2.3");
84 const sid four("1.2.3.4");
85
86 EXPECT_EQ("1.0", one.as_string());
87 EXPECT_EQ("1.2", two.as_string());
88 EXPECT_EQ("1.2.3.0", three.as_string());
89 EXPECT_EQ("1.2.3.4", four.as_string());
90 }
91
TEST(SidTest,Assignment)92 TEST(SidTest, Assignment)
93 {
94 const sid a("1.2.3.4");
95 EXPECT_EQ("1.2.3.4", a.as_string());
96 sid b("1.2.3.5");
97 EXPECT_EQ("1.2.3.5", b.as_string());
98 b = a;
99 EXPECT_EQ("1.2.3.4", b.as_string());
100 // Now make sure that all fields can be changed in an assignment.
101 b = sid("4.3.2.1");
102 EXPECT_EQ("4.3.2.1", b.as_string());
103 }
104
TEST(SidTest,Greater)105 TEST(SidTest, Greater)
106 {
107 const sid a("1.2.3.4");
108 const sid b("1.2.3.5");
109 EXPECT_GT(b, a);
110 EXPECT_FALSE(a > b);
111 EXPECT_FALSE(a > a);
112 EXPECT_FALSE(b > b);
113 }
114
TEST(SidTest,GreaterEqual)115 TEST(SidTest, GreaterEqual)
116 {
117 const sid a("1.2.3.4");
118 const sid b("1.2.3.5");
119 const sid c("1.2.3.5");
120 EXPECT_GE(b, a);
121 EXPECT_GE(b, c);
122 EXPECT_GE(c, b);
123 EXPECT_FALSE(a >= b);
124 }
125
TEST(SidTest,Less)126 TEST(SidTest, Less)
127 {
128 const sid a("1.2.3.4");
129 const sid b("1.2.3.5");
130 EXPECT_FALSE(b < a);
131 EXPECT_LT(a, b);
132 EXPECT_FALSE(a < a);
133 EXPECT_FALSE(b < b);
134 }
135
TEST(SidTest,LessEqual)136 TEST(SidTest, LessEqual)
137 {
138 const sid a("1.2.3.4");
139 const sid b("1.2.3.5");
140 const sid c("1.2.3.5");
141 EXPECT_FALSE(b <= a);
142 EXPECT_LE(a, b);
143 EXPECT_LE(b, c);
144 EXPECT_LE(c, b);
145 }
146
TEST(SidTest,Equality)147 TEST(SidTest, Equality)
148 {
149 const sid a("1.2.3.4");
150 const sid b("1.2.3.4");
151 EXPECT_EQ(a, b);
152 EXPECT_EQ(b, a);
153
154 const sid c("1.2.3.5");
155 EXPECT_NE(a, c);
156 EXPECT_FALSE(a == c);
157 }
158
159
TEST(SidTest,Inequality)160 TEST(SidTest, Inequality)
161 {
162 const sid a("1.2.3.4");
163 const sid b("1.2.3.5");
164 EXPECT_NE(a, b);
165 EXPECT_NE(b, a);
166
167 const sid c("1.2.3.4");
168 EXPECT_EQ(a, c);
169 EXPECT_FALSE(a != c);
170 }
171
TEST(SidTest,Successor)172 TEST(SidTest, Successor)
173 {
174 const sid a("1.2.3.4");
175 ASSERT_EQ(a.successor(), sid("1.2.3.5"));
176
177 const sid b("5.6");
178 ASSERT_EQ(b.successor(), sid("5.7"));
179
180 const sid nullsid;
181 ASSERT_EQ(nullsid.successor(), sid("1.1"));
182 }
183
TEST(SidTest,NextBranch)184 TEST(SidTest, NextBranch)
185 {
186 sid a("1.2.3.4");
187 a.next_branch();
188 ASSERT_EQ(a, sid("1.2.4.1"));
189
190 sid b("5.6");
191 b.next_branch();
192 ASSERT_EQ(b, sid("5.6.1.1"));
193 }
194
TEST(SidTest,NextLevel)195 TEST(SidTest, NextLevel)
196 {
197 sid a("1.2.3.4");
198 a.next_level();
199 ASSERT_EQ(a.as_string(), "1.3");
200
201 sid b("5.6");
202 b.next_level();
203 ASSERT_EQ(b.as_string(), "5.7");
204 }
205
TEST(SidTest,Increment)206 TEST(SidTest, Increment)
207 {
208 sid a("1.2.3.4");
209 ++a;
210 ASSERT_EQ(a.as_string(), "1.2.3.5");
211
212 sid b("5.6");
213 ++b;
214 ASSERT_EQ(b.as_string(), "5.7");
215
216 sid c("8");
217 ++c;
218 ASSERT_EQ(c.as_string(), "9.0");
219 }
220
TEST(SidTest,Decrement)221 TEST(SidTest, Decrement)
222 {
223 sid a("1.2.3.4");
224 --a;
225 ASSERT_EQ(a.as_string(), "1.2.3.3");
226
227 sid b("5.6");
228 --b;
229 ASSERT_EQ(b.as_string(), "5.5");
230
231 sid c("8");
232 --c;
233 ASSERT_EQ(c.as_string(), "7.0");
234 }
235
TEST(SidTest,TrunkSuccessor)236 TEST(SidTest, TrunkSuccessor)
237 {
238 sid a("5.4");
239 sid b("5.6");
240 // b is a trunk successor of a.
241 ASSERT_TRUE(a.is_trunk_successor(b));
242
243 // c is not a trunk successor of a since c is not on the trunk.
244 sid c("5.7.1.1");
245 ASSERT_FALSE(a.is_trunk_successor(c));
246 }
247
TEST(SidTest,BranchGreaterThan)248 TEST(SidTest, BranchGreaterThan)
249 {
250 sid a("5.4.3.2");
251 sid b("5.4.4.1");
252 ASSERT_TRUE(b.branch_greater_than(a));
253 ASSERT_FALSE(a.branch_greater_than(b));
254 ASSERT_FALSE(a.branch_greater_than(a));
255
256 sid c("5.4");
257 ASSERT_TRUE(a.branch_greater_than(c));
258 ASSERT_TRUE(b.branch_greater_than(c));
259 ASSERT_FALSE(c.branch_greater_than(a));
260 ASSERT_FALSE(c.branch_greater_than(b));
261 }
262
TEST(SidTest,PartialMatch)263 TEST(SidTest, PartialMatch)
264 {
265 // Non-comparable SIDs cannot be a partial match.
266 sid a("5.4");
267 sid b("1.2.3.4");
268 ASSERT_FALSE(a.partial_match(b));
269 ASSERT_FALSE(b.partial_match(a));
270
271 // The null SID is not comparable with anything.
272 const sid null = sid::null_sid();
273 ASSERT_FALSE(null.partial_match(null));
274 ASSERT_FALSE(null.partial_match(a));
275 ASSERT_FALSE(b.partial_match(null));
276
277 // Identical SIDs are also partial_matches.
278 ASSERT_TRUE(a.partial_match(a));
279 // FIXME: figure out if b should be a partial match for itself.
280 //ASSERT_TRUE(b.partial_match(b));
281
282 // A release mismatch will cause a partial_match to fail.
283 ASSERT_FALSE(sid("1.2").partial_match(sid("5.6")));
284 }
285
TEST(SidTest,Matches)286 TEST(SidTest, Matches)
287 {
288 sid a("1.2.3.4");
289 sid b("1.2.3.5");
290
291 // SIDs always match themselves.
292 ASSERT_TRUE(a.matches(a, 4));
293 ASSERT_TRUE(b.matches(b, 4));
294
295 ASSERT_TRUE(a.matches(a, 3));
296 ASSERT_TRUE(b.matches(b, 3));
297
298 ASSERT_TRUE(a.matches(a, 2));
299 ASSERT_TRUE(b.matches(b, 2));
300
301 ASSERT_TRUE(a.matches(a, 1));
302 ASSERT_TRUE(b.matches(b, 1));
303
304 // Mismatched SIDs match to zero components.
305 ASSERT_TRUE(a.matches(sid("5.6"), 0));
306 // But we should detect a mismatch at the release.
307 ASSERT_FALSE(a.matches(sid("5.6"), 1));
308
309 // Check mismatch detection at the level.
310 a = sid("1.2.3.4");
311 b = sid("1.3.3.4");
312 ASSERT_TRUE(a.matches(b, 1));
313 ASSERT_FALSE(a.matches(b, 2));
314
315 // Check mismatch detection at the branch.
316 a = sid("1.2.3.4");
317 b = sid("1.2.4.4");
318 ASSERT_TRUE(a.matches(b, 1));
319 ASSERT_TRUE(a.matches(b, 2));
320 ASSERT_FALSE(a.matches(b, 3));
321 ASSERT_FALSE(a.matches(b, 4));
322
323 // Check mismatch detection at the sequence.
324 a = sid("1.2.3.4");
325 b = sid("1.2.3.5");
326 ASSERT_TRUE(a.matches(b, 1));
327 ASSERT_TRUE(a.matches(b, 2));
328 ASSERT_TRUE(a.matches(b, 3));
329 ASSERT_FALSE(a.matches(b, 4));
330 }
331
TEST(SidTest,ReleaseOnly)332 TEST(SidTest, ReleaseOnly)
333 {
334 const sid a("1.2.3.4");
335 ASSERT_FALSE(a.release_only());
336
337 const sid b("1.2");
338 ASSERT_FALSE(b.release_only());
339
340 const sid c("1.0");
341 ASSERT_TRUE(c.release_only());
342
343 const sid d("0.0");
344 ASSERT_FALSE(d.release_only());
345 }
346
347
348 // trunk_match
TEST(SidTest,TrunkMatch)349 TEST(SidTest, TrunkMatch)
350 {
351 ASSERT_TRUE(sid("1.2").trunk_match("1.2"));
352 ASSERT_TRUE(sid("1.2").trunk_match("1.2.3.4"));
353 ASSERT_FALSE(sid("1.2").trunk_match("1.3.3.4"));
354 ASSERT_FALSE(sid("1.3").trunk_match("1.2"));
355
356 // Different branches can still be trunk matches.
357 ASSERT_TRUE(sid("1.2.7.8").trunk_match("1.2.3.4"));
358 }
359
360
361 #if 0
362 // sid::sid(relvbr) is declared but not implemented.
363 TEST(SidTest, ConstructFromRelvbr)
364 {
365 const relvbr r("1.2.3");
366 const sid s(r);
367 EXPECT_EQ("1.2.3.0", s.as_string());
368 }
369 #endif
370