wibble 1.1
engine.test.h
Go to the documentation of this file.
1/* -*- C++ -*- (c) 2007 Petr Rockai <me@mornfall.net>
2 (c) 2007 Enrico Zini <enrico@enricozini.org> */
4
5#include <wibble/test.h>
6#include <string>
7
8using namespace wibble::commandline;
9using namespace std;
10
11// Happy trick to get access to protected methods we need to use for the tests
12template<typename T>
13class Public : public T
14{
15public:
16 Public(MemoryManager* mman = 0, const std::string& name = std::string(),
17 const std::string& usage = std::string(),
18 const std::string& description = std::string(),
19 const std::string& longDescription = std::string())
20 : T(mman, name, usage, description, longDescription) {}
21
22 ArgList::iterator parseList(ArgList& list) { return T::parseList(list); }
23 ArgList::iterator parse(ArgList& list, ArgList::iterator begin)
24 {
25 return T::parse(list, begin);
26 }
27};
28
29class Engine1 : public Public<Engine>
30{
31 MemoryManager mman;
32
33public:
34 Engine1() : Public<Engine>(&mman)
35 {
36 antani = add<BoolOption>("antani", 'a', "antani");
37 blinda = add<StringOption>("blinda", 'b', "blinda");
38
39 antani->addAlias("an-tani");
40 }
41
44};
45
46class Engine2 : public Public<Engine>
47{
48 MemoryManager mman;
49
50public:
51 Engine2() : Public<Engine>(&mman)
52 {
53 help = add<BoolOption>("help", 'h', "help", "get help");
54
55 scramble = addEngine("scramble");
56 scramble_random = scramble->add<BoolOption>("random", 'r', "random");
57 scramble_yell = scramble->add<StringOption>("yell", 0, "yell");
58 scramble->aliases.push_back("mess");
59
60 fix = addEngine("fix");
61 fix_quick = fix->add<BoolOption>("quick", 'Q', "quick");
62 fix_yell = fix->add<StringOption>("yell", 0, "yell");
63 }
64
72};
73
77 opts.push_back("ciaps");
78 opts.push_back("-b");
79 opts.push_back("cippo");
80 opts.push_back("foobar");
81
83 ArgList::iterator i = engine.parseList(opts);
84 assert(i == opts.begin());
85 assert_eq(opts.size(), 2u);
86 assert_eq(string(*opts.begin()), string("ciaps"));
87 assert_eq(string(*opts.rbegin()), string("foobar"));
88 assert_eq(engine.antani->boolValue(), false);
89 assert_eq(engine.blinda->stringValue(), "cippo");
90 }
91
94 opts.push_back("-b");
95 opts.push_back("cippo");
96 opts.push_back("foobar");
97 opts.push_back("--cabal");
98
100 engine.no_switches_after_first_arg = true;
101 ArgList::iterator i = engine.parseList(opts);
102 assert(i == opts.begin());
103 assert_eq(opts.size(), 2u);
104 assert_eq(string(*opts.begin()), string("foobar"));
105 assert_eq(string(*opts.rbegin()), string("--cabal"));
106 assert_eq(engine.antani->boolValue(), false);
107 assert_eq(engine.blinda->stringValue(), "cippo");
108 }
109
112 opts.push_back("-a");
113 opts.push_back("foobar");
114
116 ArgList::iterator i = engine.parseList(opts);
117 assert(i == opts.begin());
118 assert_eq(opts.size(), 1u);
119 assert_eq(string(*opts.begin()), string("foobar"));
120 assert_eq(engine.antani->boolValue(), true);
121 assert_eq(engine.blinda->boolValue(), false);
122 }
123
126 opts.push_back("-ab");
127 opts.push_back("cippo");
128
130 ArgList::iterator i = engine.parseList(opts);
131 assert(i == opts.end());
132 assert_eq(opts.size(), 0u);
133 assert_eq(engine.antani->boolValue(), true);
134 assert_eq(engine.blinda->stringValue(), "cippo");
135 }
136
139 opts.push_back("--an-tani");
140 opts.push_back("foobar");
141
143 ArgList::iterator i = engine.parseList(opts);
144 assert(i == opts.begin());
145 assert_eq(opts.size(), 1u);
146 assert_eq(string(*opts.begin()), string("foobar"));
147 assert_eq(engine.antani->boolValue(), true);
148 assert_eq(engine.blinda->boolValue(), false);
149 }
150
151// Test long options with arguments
154 opts.push_back("--blinda=cippo");
155 opts.push_back("foobar");
156 opts.push_back("--antani");
157
159 ArgList::iterator i = engine.parseList(opts);
160 assert(i == opts.begin());
161 assert_eq(opts.size(), 1u);
162 assert_eq(string(*opts.begin()), string("foobar"));
163 assert_eq(engine.antani->boolValue(), true);
164 assert_eq(engine.blinda->stringValue(), "cippo");
165 }
166
169 opts.push_back("--yell=foo");
170 opts.push_back("mess");
171 opts.push_back("-r");
172
174 ArgList::iterator i = engine.parseList(opts);
175 assert(i == opts.end());
176 assert_eq(opts.size(), 0u);
177 assert_eq(engine.foundCommand(), engine.scramble);
178 assert_eq(engine.scramble_yell->stringValue(), "foo");
179 assert_eq(engine.scramble_random->boolValue(), true);
180 assert_eq(engine.fix_yell->stringValue(), string());
181 assert_eq(engine.fix_quick->boolValue(), false);
182 assert_eq(engine.help->boolValue(), false);
183 }
184
185// Test the other command, with overlapping arguments
188 opts.push_back("--yell=foo");
189 opts.push_back("fix");
190 opts.push_back("--help");
191 opts.push_back("-Q");
192
194 ArgList::iterator i = engine.parseList(opts);
195 assert(i == opts.end());
196 assert_eq(opts.size(), 0u);
197 assert_eq(engine.foundCommand(), engine.fix);
198 assert_eq(engine.scramble_yell->stringValue(), string());
199 assert_eq(engine.scramble_random->boolValue(), false);
200 assert_eq(engine.fix_yell->stringValue(), "foo");
201 assert_eq(engine.fix_quick->boolValue(), true);
202 assert_eq(engine.help->boolValue(), true);
203 }
204
205// Test invocation without command
208 opts.push_back("--help");
209
211 ArgList::iterator i = engine.parseList(opts);
212 assert(i == opts.end());
213 assert_eq(opts.size(), 0u);
214 assert_eq(engine.foundCommand(), static_cast<Engine*>(0));
215 assert_eq(engine.scramble_yell->stringValue(), string());
216 assert_eq(engine.scramble_random->boolValue(), false);
217 assert_eq(engine.fix_yell->stringValue(), string());
218 assert_eq(engine.fix_quick->boolValue(), false);
219 assert_eq(engine.help->boolValue(), true);
220 }
221
222// Test creation shortcuts
224 MemoryManager mman;
225 Public<Engine> engine(&mman, "test", "[options]", "test engine", "this is the long description of a test engine");
226 OptionGroup* group = engine.addGroup("test option group");
227 BoolOption* testBool = group->add<BoolOption>("tbool", 0, "testbool", "<val>", "a test bool switch");
228 IntOption* testInt = group->add<IntOption>("tint", 0, "testint", "<val>", "a test int switch");
229 StringOption* testString = group->add<StringOption>("tstring", 0, "teststring", "<val>", "a test string switch");
230 BoolOption* testBool1 = engine.add<BoolOption>("tbool", 0, "testbool1", "<val>", "a test bool switch");
231 IntOption* testInt1 = engine.add<IntOption>("tint", 0, "testint1", "<val>", "a test int switch");
232 StringOption* testString1 = engine.add<StringOption>("tstring", 0, "teststring1", "<val>", "a test string switch");
233
235 opts.push_back("--testbool=true");
236 opts.push_back("--testint=3");
237 opts.push_back("--teststring=antani");
238 opts.push_back("--testbool1=true");
239 opts.push_back("--testint1=5");
240 opts.push_back("--teststring1=blinda");
241
242 ArgList::iterator i = engine.parseList(opts);
243 assert(i == opts.end());
244 assert_eq(opts.size(), 0u);
245 assert_eq(testBool->boolValue(), true);
246 assert_eq(testInt->intValue(), 3);
247 assert_eq(testString->stringValue(), "antani");
248 assert_eq(testBool1->boolValue(), true);
249 assert_eq(testInt1->intValue(), 5);
250 assert_eq(testString1->stringValue(), "blinda");
251 }
252
253};
254
255// vim:set ts=4 sw=4:
Definition engine.test.h:30
Engine1()
Definition engine.test.h:34
StringOption * blinda
Definition engine.test.h:43
BoolOption * antani
Definition engine.test.h:42
Definition engine.test.h:47
StringOption * scramble_yell
Definition engine.test.h:68
BoolOption * help
Definition engine.test.h:65
Engine * scramble
Definition engine.test.h:66
Engine * fix
Definition engine.test.h:69
StringOption * fix_yell
Definition engine.test.h:71
Engine2()
Definition engine.test.h:51
BoolOption * fix_quick
Definition engine.test.h:70
BoolOption * scramble_random
Definition engine.test.h:67
Definition engine.test.h:14
Public(MemoryManager *mman=0, const std::string &name=std::string(), const std::string &usage=std::string(), const std::string &description=std::string(), const std::string &longDescription=std::string())
Definition engine.test.h:16
ArgList::iterator parseList(ArgList &list)
Definition engine.test.h:22
ArgList::iterator parse(ArgList &list, ArgList::iterator begin)
Definition engine.test.h:23
Definition core.h:30
Boolean option.
Definition options.h:135
Parse commandline options.
Definition engine.h:39
Engine * addEngine(const std::string &name, const std::string &usage=std::string(), const std::string &description=std::string(), const std::string &longDescription=std::string())
Create a Engine and add it to this engine as a command.
Definition engine.h:182
std::vector< std::string > aliases
Definition engine.h:221
void add(const std::string &alias, Engine *o)
Definition engine.cpp:39
Keep track of various wibble::commandline components, and deallocate them at object destruction.
Definition core.h:63
Group related commandline options.
Definition options.h:360
Option * add(Option *o)
Definition options.h:368
void addAlias(char c)
Definition options.h:113
void usage(ostream &out, const string &argv0)
Definition commandline-demo.cpp:75
Definition core.cpp:6
Definition engine.test.h:74
Test longOptsWithArgs()
Definition engine.test.h:152
Test optsOnly()
Definition engine.test.h:110
Test commandWithArg()
Definition engine.test.h:167
Test optsAndArgs()
Definition engine.test.h:75
Test noSwitchesAfterFirstArg()
Definition engine.test.h:92
Test creationShortcuts()
Definition engine.test.h:223
Test longOptsWithDashes()
Definition engine.test.h:137
Test clusteredShortOpts()
Definition engine.test.h:124
Test commandsWithoutCommand()
Definition engine.test.h:206
Test commandsWithOverlappingArgs()
Definition engine.test.h:186
Definition amorph.h:30
#define assert_eq(x, y)
Definition test.h:33
#define assert(x)
Definition test.h:30