|
236
|
1 #include <gtest/gtest.h> |
|
|
2 |
|
|
3 #include <OptionParser.h> |
|
|
4 |
|
|
5 #define LENGTH(x) (sizeof (x) / sizeof (x[0])) |
|
|
6 |
|
|
7 /* |
|
|
8 * -a hello -a ok -v -c -p test |
|
|
9 */ |
|
|
10 TEST(OptionParser, simple) |
|
|
11 { |
|
|
12 OptionParser parser; |
|
|
13 const char *argv[] = { "-a", "hello", "-a", "ok", "-v", "-c", "-p", "test" }; |
|
|
14 |
|
|
15 parser.add(Option("a", "attribute", Option::Argument)); |
|
|
16 parser.add(Option("v", "verbose")); |
|
|
17 parser.add(Option("c", "check")); |
|
|
18 parser.add(Option("p", "plugin", Option::Argument)); |
|
|
19 |
|
|
20 auto result = parser.parse(LENGTH(argv), argv, OptionParser::Strict); |
|
|
21 auto begin = result.cbegin(); |
|
|
22 |
|
|
23 ASSERT_EQ(5, result.count()); |
|
|
24 ASSERT_EQ(8, result.total()); |
|
|
25 |
|
|
26 // -a hello |
|
|
27 ASSERT_EQ("a", begin->name()); |
|
|
28 ASSERT_EQ("hello", begin->value()); |
|
|
29 |
|
|
30 // -a ok |
|
|
31 std::advance(begin, 1); |
|
|
32 ASSERT_EQ("a", begin->name()); |
|
|
33 ASSERT_EQ("ok", begin->value()); |
|
|
34 |
|
|
35 // -v |
|
|
36 std::advance(begin, 1); |
|
|
37 ASSERT_EQ("v", begin->name()); |
|
|
38 ASSERT_EQ("", begin->value()); |
|
|
39 |
|
|
40 // -c |
|
|
41 std::advance(begin, 1); |
|
|
42 ASSERT_EQ("c", begin->name()); |
|
|
43 ASSERT_EQ("", begin->value()); |
|
|
44 |
|
|
45 // -p test |
|
|
46 std::advance(begin, 1); |
|
|
47 ASSERT_EQ("p", begin->name()); |
|
|
48 ASSERT_EQ("test", begin->value()); |
|
|
49 } |
|
|
50 |
|
|
51 /* |
|
|
52 * -v install -y -x -p package |
|
|
53 * |
|
|
54 * Split as two kind of groups, |
|
|
55 * -v are general options |
|
|
56 * -y, -x -p are dedicated to install |
|
|
57 */ |
|
|
58 TEST(OptionParser, group) |
|
|
59 { |
|
|
60 OptionParser parser; |
|
|
61 const char *argv[] = { "-v", "install", "-y", "-x", "-p", "irccd" }; |
|
|
62 |
|
|
63 parser.add(Option("v", "verbose")); |
|
|
64 parser.add(Option("y", "auto answer yes")); |
|
|
65 parser.add(Option("x", "use regex")); |
|
|
66 parser.add(Option("p", "package", Option::Argument)); |
|
|
67 |
|
|
68 /* |
|
|
69 * First part: -v install |
|
|
70 */ |
|
|
71 |
|
|
72 auto result = parser.parse(LENGTH(argv), argv, OptionParser::BreakNonOption); |
|
|
73 auto option = result.cbegin(); |
|
|
74 |
|
|
75 ASSERT_EQ(1, result.count()); |
|
|
76 ASSERT_EQ(1, result.total()); |
|
|
77 |
|
|
78 // "-v" |
|
|
79 ASSERT_EQ("v", option->name()); |
|
|
80 ASSERT_EQ("", option->value()); |
|
|
81 |
|
|
82 /* |
|
|
83 * Second part: -y -x package |
|
|
84 */ |
|
|
85 |
|
|
86 result = parser.parse(LENGTH(argv) - 2, argv + 2, OptionParser::Strict); |
|
|
87 option = result.cbegin(); |
|
|
88 |
|
|
89 ASSERT_EQ(3, result.count()); |
|
|
90 ASSERT_EQ(4, result.total()); |
|
|
91 |
|
|
92 // -y |
|
|
93 ASSERT_EQ("y", option->name()); |
|
|
94 ASSERT_EQ("", option->value()); |
|
|
95 |
|
|
96 // -x |
|
|
97 std::advance(option, 1); |
|
|
98 ASSERT_EQ("x", option->name()); |
|
|
99 ASSERT_EQ("", option->value()); |
|
|
100 |
|
|
101 // -p irccd |
|
|
102 std::advance(option, 1); |
|
|
103 ASSERT_EQ("p", option->name()); |
|
|
104 ASSERT_EQ("irccd", option->value()); |
|
|
105 } |
|
|
106 |
|
|
107 /* |
|
|
108 * Compact |
|
|
109 * |
|
|
110 * -abc -> -a -b -c |
|
|
111 */ |
|
|
112 TEST(OptionParser, compact) |
|
|
113 { |
|
|
114 OptionParser parser; |
|
|
115 const char *argv[] = { "-abc" }; |
|
|
116 |
|
|
117 parser.add(Option("a", "")); |
|
|
118 parser.add(Option("b", "")); |
|
|
119 parser.add(Option("c", "")); |
|
|
120 |
|
|
121 auto result = parser.parse(LENGTH(argv), argv); |
|
|
122 auto option = result.cbegin(); |
|
|
123 |
|
|
124 ASSERT_EQ(3, result.count()); |
|
|
125 ASSERT_EQ(3, result.total()); |
|
|
126 |
|
|
127 // -a |
|
|
128 ASSERT_EQ("a", option->name()); |
|
|
129 ASSERT_EQ("", option->value()); |
|
|
130 |
|
|
131 // -b |
|
|
132 std::advance(option, 1); |
|
|
133 ASSERT_EQ("b", option->name()); |
|
|
134 ASSERT_EQ("", option->value()); |
|
|
135 |
|
|
136 // -c |
|
|
137 std::advance(option, 1); |
|
|
138 ASSERT_EQ("c", option->name()); |
|
|
139 ASSERT_EQ("", option->value()); |
|
|
140 } |
|
|
141 |
|
|
142 /* |
|
|
143 * -o readonly -o loop -v -v -f true -f false |
|
|
144 */ |
|
|
145 TEST(OptionParser, numbered) |
|
|
146 { |
|
|
147 OptionParser parser; |
|
|
148 const char *argv[] = { "-o", "readonly", "-o", "loop", "-v", "-v", "-f", "true", "-f", "false" }; |
|
|
149 |
|
|
150 parser.add(Option("o", "option", Option::Argument)); |
|
|
151 parser.add(Option("v", "verbose")); |
|
|
152 parser.add(Option("f", "fullscreen", Option::Argument, Option::Single)); |
|
|
153 |
|
|
154 auto result = parser.parse(LENGTH(argv), argv, OptionParser::Silent); |
|
|
155 auto option = result.cbegin(); |
|
|
156 |
|
|
157 ASSERT_EQ(6, result.count()); |
|
|
158 ASSERT_EQ(10, result.total()); |
|
|
159 |
|
|
160 // -o readonly |
|
|
161 ASSERT_EQ("o", option->name()); |
|
|
162 ASSERT_EQ("readonly", option->value()); |
|
|
163 |
|
|
164 // -o loop |
|
|
165 std::advance(option, 1); |
|
|
166 ASSERT_EQ("o", option->name()); |
|
|
167 ASSERT_EQ("loop", option->value()); |
|
|
168 |
|
|
169 // -v |
|
|
170 std::advance(option, 1); |
|
|
171 ASSERT_EQ("v", option->name()); |
|
|
172 ASSERT_EQ("", option->value()); |
|
|
173 |
|
|
174 // -v |
|
|
175 std::advance(option, 1); |
|
|
176 ASSERT_EQ("v", option->name()); |
|
|
177 ASSERT_EQ("", option->value()); |
|
|
178 |
|
|
179 // -f true |
|
|
180 std::advance(option, 1); |
|
|
181 ASSERT_EQ("f", option->name()); |
|
|
182 ASSERT_EQ("true", option->value()); |
|
|
183 |
|
|
184 // -f false |
|
|
185 std::advance(option, 1); |
|
|
186 ASSERT_EQ("f", option->name()); |
|
|
187 ASSERT_EQ("false", option->value()); |
|
|
188 } |
|
|
189 |
|
|
190 int main(int argc, char **argv) |
|
|
191 { |
|
|
192 testing::InitGoogleTest(&argc, argv); |
|
|
193 |
|
|
194 return RUN_ALL_TESTS(); |
|
|
195 } |
