1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/version.h"
6
7 #include <stddef.h>
8 #include <stdint.h>
9
10 #include "base/macros.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12
13 namespace {
14
TEST(VersionTest,DefaultConstructor)15 TEST(VersionTest, DefaultConstructor) {
16 Version v;
17 EXPECT_FALSE(v.IsValid());
18 }
19
TEST(VersionTest,ValueSemantics)20 TEST(VersionTest, ValueSemantics) {
21 Version v1("1.2.3.4");
22 EXPECT_TRUE(v1.IsValid());
23 Version v3;
24 EXPECT_FALSE(v3.IsValid());
25 {
26 Version v2(v1);
27 v3 = v2;
28 EXPECT_TRUE(v2.IsValid());
29 EXPECT_EQ(v1, v2);
30 }
31 EXPECT_EQ(v3, v1);
32 }
33
TEST(VersionTest,GetVersionFromString)34 TEST(VersionTest, GetVersionFromString) {
35 static const struct version_string {
36 const char* input;
37 size_t parts;
38 uint32_t firstpart;
39 bool success;
40 } cases[] = {
41 {"", 0, 0, false},
42 {" ", 0, 0, false},
43 {"\t", 0, 0, false},
44 {"\n", 0, 0, false},
45 {" ", 0, 0, false},
46 {".", 0, 0, false},
47 {" . ", 0, 0, false},
48 {"0", 1, 0, true},
49 {"0.", 0, 0, false},
50 {"0.0", 2, 0, true},
51 {"4294967295.0", 2, 4294967295, true},
52 {"4294967296.0", 0, 0, false},
53 {"-1.0", 0, 0, false},
54 {"1.-1.0", 0, 0, false},
55 {"1,--1.0", 0, 0, false},
56 {"+1.0", 0, 0, false},
57 {"1.+1.0", 0, 0, false},
58 {"1+1.0", 0, 0, false},
59 {"++1.0", 0, 0, false},
60 {"1.0a", 0, 0, false},
61 {"1.2.3.4.5.6.7.8.9.0", 10, 1, true},
62 {"02.1", 0, 0, false},
63 {"0.01", 2, 0, true},
64 {"f.1", 0, 0, false},
65 {"15.007.20011", 3, 15, true},
66 {"15.5.28.130162", 4, 15, true},
67 };
68
69 for (size_t i = 0; i < arraysize(cases); ++i) {
70 Version version(cases[i].input);
71 EXPECT_EQ(cases[i].success, version.IsValid());
72 if (cases[i].success) {
73 EXPECT_EQ(cases[i].parts, version.components().size());
74 EXPECT_EQ(cases[i].firstpart, version.components()[0]);
75 }
76 }
77 }
78
TEST(VersionTest,Compare)79 TEST(VersionTest, Compare) {
80 static const struct version_compare {
81 const char* lhs;
82 const char* rhs;
83 int expected;
84 } cases[] = {
85 {"1.0", "1.0", 0},
86 {"1.0", "0.0", 1},
87 {"1.0", "2.0", -1},
88 {"1.0", "1.1", -1},
89 {"1.1", "1.0", 1},
90 {"1.0", "1.0.1", -1},
91 {"1.1", "1.0.1", 1},
92 {"1.1", "1.0.1", 1},
93 {"1.0.0", "1.0", 0},
94 {"1.0.3", "1.0.20", -1},
95 {"11.0.10", "15.007.20011", -1},
96 {"11.0.10", "15.5.28.130162", -1},
97 };
98 for (size_t i = 0; i < arraysize(cases); ++i) {
99 Version lhs(cases[i].lhs);
100 Version rhs(cases[i].rhs);
101 EXPECT_EQ(lhs.CompareTo(rhs), cases[i].expected) <<
102 cases[i].lhs << " ? " << cases[i].rhs;
103
104 // Test comparison operators
105 switch (cases[i].expected) {
106 case -1:
107 EXPECT_LT(lhs, rhs);
108 EXPECT_LE(lhs, rhs);
109 EXPECT_NE(lhs, rhs);
110 EXPECT_FALSE(lhs == rhs);
111 EXPECT_FALSE(lhs >= rhs);
112 EXPECT_FALSE(lhs > rhs);
113 break;
114 case 0:
115 EXPECT_FALSE(lhs < rhs);
116 EXPECT_LE(lhs, rhs);
117 EXPECT_FALSE(lhs != rhs);
118 EXPECT_EQ(lhs, rhs);
119 EXPECT_GE(lhs, rhs);
120 EXPECT_FALSE(lhs > rhs);
121 break;
122 case 1:
123 EXPECT_FALSE(lhs < rhs);
124 EXPECT_FALSE(lhs <= rhs);
125 EXPECT_NE(lhs, rhs);
126 EXPECT_FALSE(lhs == rhs);
127 EXPECT_GE(lhs, rhs);
128 EXPECT_GT(lhs, rhs);
129 break;
130 }
131 }
132 }
133
TEST(VersionTest,CompareToWildcardString)134 TEST(VersionTest, CompareToWildcardString) {
135 static const struct version_compare {
136 const char* lhs;
137 const char* rhs;
138 int expected;
139 } cases[] = {
140 {"1.0", "1.*", 0},
141 {"1.0", "0.*", 1},
142 {"1.0", "2.*", -1},
143 {"1.2.3", "1.2.3.*", 0},
144 {"10.0", "1.0.*", 1},
145 {"1.0", "3.0.*", -1},
146 {"1.4", "1.3.0.*", 1},
147 {"1.3.9", "1.3.*", 0},
148 {"1.4.1", "1.3.*", 1},
149 {"1.3", "1.4.5.*", -1},
150 {"1.5", "1.4.5.*", 1},
151 {"1.3.9", "1.3.*", 0},
152 {"1.2.0.0.0.0", "1.2.*", 0},
153 };
154 for (size_t i = 0; i < arraysize(cases); ++i) {
155 const Version version(cases[i].lhs);
156 const int result = version.CompareToWildcardString(cases[i].rhs);
157 EXPECT_EQ(result, cases[i].expected) << cases[i].lhs << "?" << cases[i].rhs;
158 }
159 }
160
TEST(VersionTest,IsValidWildcardString)161 TEST(VersionTest, IsValidWildcardString) {
162 static const struct version_compare {
163 const char* version;
164 bool expected;
165 } cases[] = {
166 {"1.0", true},
167 {"", false},
168 {"1.2.3.4.5.6", true},
169 {"1.2.3.*", true},
170 {"1.2.3.5*", false},
171 {"1.2.3.56*", false},
172 {"1.*.3", false},
173 {"20.*", true},
174 {"+2.*", false},
175 {"*", false},
176 {"*.2", false},
177 };
178 for (size_t i = 0; i < arraysize(cases); ++i) {
179 EXPECT_EQ(Version::IsValidWildcardString(cases[i].version),
180 cases[i].expected) << cases[i].version << "?" << cases[i].expected;
181 }
182 }
183
184 } // namespace
185