486
|
1 /* |
|
2 * main.cpp -- main test file for OptionParser |
|
3 * |
|
4 * Copyright (c) 2013-2015 David Demelier <markand@malikania.fr> |
|
5 * |
|
6 * Permission to use, copy, modify, and/or distribute this software for any |
|
7 * purpose with or without fee is hereby granted, provided that the above |
|
8 * copyright notice and this permission notice appear in all copies. |
|
9 * |
|
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
|
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
17 */ |
|
18 |
|
19 #include <gtest/gtest.h> |
|
20 |
|
21 #include <options.h> |
|
22 |
|
23 /* -------------------------------------------------------- |
|
24 * Short options |
|
25 * -------------------------------------------------------- */ |
|
26 |
|
27 TEST(Short, simpleNoArg) |
|
28 { |
|
29 std::vector<std::string> args{"-a", "-b"}; |
|
30 |
|
31 option::Options options{ |
|
32 { "-a", false }, |
|
33 { "-b", false } |
|
34 }; |
|
35 |
|
36 option::Result pack = option::read(args, options); |
|
37 |
|
38 ASSERT_EQ(2U, pack.size()); |
|
39 ASSERT_EQ(0U, args.size()); |
|
40 |
|
41 ASSERT_TRUE(pack.count("-a") != 0); |
|
42 ASSERT_TRUE(pack.count("-b") != 0); |
|
43 } |
|
44 |
|
45 TEST(Short, simpleArg) |
|
46 { |
|
47 std::vector<std::string> args{"-v", "-cfoo.conf"}; |
|
48 |
|
49 option::Options options{ |
|
50 { "-v", false }, |
|
51 { "-c", true } |
|
52 }; |
|
53 |
|
54 option::Result pack = option::read(args, options); |
|
55 |
|
56 ASSERT_EQ(2U, pack.size()); |
|
57 ASSERT_EQ(0U, args.size()); |
|
58 |
|
59 ASSERT_TRUE(pack.count("-v") != 0); |
|
60 ASSERT_EQ("foo.conf", pack.find("-c")->second); |
|
61 } |
|
62 |
|
63 TEST(Short, spacedArg) |
|
64 { |
|
65 std::vector<std::string> args{"-v", "-c", "foo.conf"}; |
|
66 |
|
67 option::Options options{ |
|
68 { "-v", false }, |
|
69 { "-c", true } |
|
70 }; |
|
71 |
|
72 option::Result pack = option::read(args, options); |
|
73 |
|
74 ASSERT_EQ(2U, pack.size()); |
|
75 ASSERT_EQ(0U, args.size()); |
|
76 |
|
77 ASSERT_TRUE(pack.count("-v") != 0); |
|
78 ASSERT_EQ("foo.conf", pack.find("-c")->second); |
|
79 } |
|
80 |
|
81 TEST(Short, compacted) |
|
82 { |
|
83 std::vector<std::string> args{"-abc"}; |
|
84 |
|
85 option::Options options{ |
|
86 { "-a", false }, |
|
87 { "-b", false }, |
|
88 { "-c", false }, |
|
89 }; |
|
90 |
|
91 option::Result pack = option::read(args, options); |
|
92 |
|
93 ASSERT_EQ(3U, pack.size()); |
|
94 ASSERT_EQ(0U, args.size()); |
|
95 |
|
96 ASSERT_TRUE(pack.count("-a") != 0); |
|
97 ASSERT_TRUE(pack.count("-b") != 0); |
|
98 ASSERT_TRUE(pack.count("-c") != 0); |
|
99 } |
|
100 |
|
101 TEST(Short, compactedArg) |
|
102 { |
|
103 std::vector<std::string> args{"-vdcfoo.conf"}; |
|
104 |
|
105 option::Options options{ |
|
106 { "-v", false }, |
|
107 { "-d", false }, |
|
108 { "-c", true }, |
|
109 }; |
|
110 |
|
111 option::Result pack = option::read(args, options); |
|
112 |
|
113 ASSERT_EQ(3U, pack.size()); |
|
114 ASSERT_EQ(0U, args.size()); |
|
115 |
|
116 ASSERT_TRUE(pack.count("-v") != 0); |
|
117 ASSERT_TRUE(pack.count("-d") != 0); |
|
118 ASSERT_EQ("foo.conf", pack.find("-c")->second); |
|
119 } |
|
120 |
|
121 /* -------------------------------------------------------- |
|
122 * Long options |
|
123 * -------------------------------------------------------- */ |
|
124 |
|
125 TEST(Long, simple) |
|
126 { |
|
127 std::vector<std::string> args{"--fullscreen"}; |
|
128 |
|
129 option::Options options{ |
|
130 { "--verbose", false }, |
|
131 { "--fullscreen", false } |
|
132 }; |
|
133 |
|
134 option::Result pack = option::read(args, options); |
|
135 |
|
136 ASSERT_EQ(1U, pack.size()); |
|
137 ASSERT_EQ(0U, args.size()); |
|
138 |
|
139 ASSERT_TRUE(pack.count("--fullscreen") != 0); |
|
140 } |
|
141 |
|
142 TEST(Long, simpleArg) |
|
143 { |
|
144 std::vector<std::string> args{"--config", "config.conf", "--level", "2"}; |
|
145 |
|
146 option::Options options{ |
|
147 { "--config", true }, |
|
148 { "--level", true } |
|
149 }; |
|
150 |
|
151 option::Result pack = option::read(args, options); |
|
152 |
|
153 ASSERT_EQ(2U, pack.size()); |
|
154 ASSERT_EQ(0U, args.size()); |
|
155 |
|
156 ASSERT_EQ("config.conf", pack.find("--config")->second); |
|
157 ASSERT_EQ("2", pack.find("--level")->second); |
|
158 } |
|
159 |
|
160 /* -------------------------------------------------------- |
|
161 * Errors |
|
162 * -------------------------------------------------------- */ |
|
163 |
|
164 TEST(Errors, stop) |
|
165 { |
|
166 std::vector<std::string> args{"-v", "install", "-y", "irccd"}; |
|
167 std::vector<std::string> expected{"install", "-y", "irccd"}; |
|
168 |
|
169 option::Options options{ |
|
170 { "-v", false } |
|
171 }; |
|
172 |
|
173 option::Result pack = option::read(args, options); |
|
174 |
|
175 ASSERT_EQ(1U, pack.size()); |
|
176 ASSERT_EQ(3U, args.size()); |
|
177 |
|
178 ASSERT_TRUE(pack.count("-v") != 0); |
|
179 ASSERT_EQ(expected, args); |
|
180 } |
|
181 |
|
182 TEST(Errors, missingShortArg) |
|
183 { |
|
184 std::vector<std::string> args{"-c"}; |
|
185 |
|
186 option::Options options{ |
|
187 { "-c", true } |
|
188 }; |
|
189 |
|
190 try { |
|
191 option::Result pack = option::read(args, options); |
|
192 |
|
193 FAIL() << "exception expected"; |
|
194 } catch (const option::MissingValue &) { |
|
195 } |
|
196 } |
|
197 |
|
198 TEST(Errors, missingShortArg2) |
|
199 { |
|
200 std::vector<std::string> args{"-vc"}; |
|
201 |
|
202 option::Options options{ |
|
203 { "-v", false }, |
|
204 { "-c", true } |
|
205 }; |
|
206 |
|
207 try { |
|
208 option::Result pack = option::read(args, options); |
|
209 |
|
210 FAIL() << "exception expected"; |
|
211 } catch (const option::MissingValue &) { |
|
212 } |
|
213 } |
|
214 |
|
215 TEST(Errors, missingLongArg) |
|
216 { |
|
217 std::vector<std::string> args{"--config"}; |
|
218 |
|
219 option::Options options{ |
|
220 { "--config", true } |
|
221 }; |
|
222 |
|
223 try { |
|
224 option::Result pack = option::read(args, options); |
|
225 |
|
226 FAIL() << "exception expected"; |
|
227 } catch (const option::MissingValue &) { |
|
228 } |
|
229 } |
|
230 |
|
231 TEST(Errors, invalidOption) |
|
232 { |
|
233 std::vector<std::string> args{"-x"}; |
|
234 |
|
235 option::Options options{ |
|
236 { "-v", true } |
|
237 }; |
|
238 |
|
239 try { |
|
240 option::Result pack = option::read(args, options); |
|
241 |
|
242 FAIL() << "exception expected"; |
|
243 } catch (const option::InvalidOption &) { |
|
244 } |
|
245 } |
|
246 |
|
247 TEST(Errors, invalidOption2) |
|
248 { |
|
249 std::vector<std::string> args{"--destroy"}; |
|
250 |
|
251 option::Options options{ |
|
252 { "--verbose", true } |
|
253 }; |
|
254 |
|
255 try { |
|
256 option::Result pack = option::read(args, options); |
|
257 |
|
258 FAIL() << "exception expected"; |
|
259 } catch (const option::InvalidOption &) { |
|
260 } |
|
261 } |
|
262 |
|
263 TEST(Errors, invalidOption3) |
|
264 { |
|
265 std::vector<std::string> args{"-vx"}; |
|
266 |
|
267 option::Options options{ |
|
268 { "-x", true } |
|
269 }; |
|
270 |
|
271 try { |
|
272 option::Result pack = option::read(args, options); |
|
273 |
|
274 FAIL() << "exception expected"; |
|
275 } catch (const option::InvalidOption &) { |
|
276 } |
|
277 } |
|
278 |
|
279 int main(int argc, char **argv) |
|
280 { |
|
281 testing::InitGoogleTest(&argc, argv); |
|
282 |
|
283 return RUN_ALL_TESTS(); |
|
284 } |