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 
8 using namespace wibble::commandline;
9 using namespace std;
10 
11 // Happy trick to get access to protected methods we need to use for the tests
12 template<typename T>
13 class Public : public T
14 {
15 public:
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); }
24  {
25  return T::parse(list, begin);
26  }
27 };
28 
29 class Engine1 : public Public<Engine>
30 {
31  MemoryManager mman;
32 
33 public:
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 
46 class Engine2 : public Public<Engine>
47 {
48  MemoryManager mman;
49 
50 public:
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 
76  ArgList opts;
77  opts.push_back("ciaps");
78  opts.push_back("-b");
79  opts.push_back("cippo");
80  opts.push_back("foobar");
81 
82  Engine1 engine;
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 
93  ArgList opts;
94  opts.push_back("-b");
95  opts.push_back("cippo");
96  opts.push_back("foobar");
97  opts.push_back("--cabal");
98 
99  Engine1 engine;
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 
111  ArgList opts;
112  opts.push_back("-a");
113  opts.push_back("foobar");
114 
115  Engine1 engine;
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 
125  ArgList opts;
126  opts.push_back("-ab");
127  opts.push_back("cippo");
128 
129  Engine1 engine;
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 
138  ArgList opts;
139  opts.push_back("--an-tani");
140  opts.push_back("foobar");
141 
142  Engine1 engine;
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
153  ArgList opts;
154  opts.push_back("--blinda=cippo");
155  opts.push_back("foobar");
156  opts.push_back("--antani");
157 
158  Engine1 engine;
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 
168  ArgList opts;
169  opts.push_back("--yell=foo");
170  opts.push_back("mess");
171  opts.push_back("-r");
172 
173  Engine2 engine;
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
187  ArgList opts;
188  opts.push_back("--yell=foo");
189  opts.push_back("fix");
190  opts.push_back("--help");
191  opts.push_back("-Q");
192 
193  Engine2 engine;
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
207  ArgList opts;
208  opts.push_back("--help");
209 
210  Engine2 engine;
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 
234  ArgList opts;
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
bool boolValue() const
Definition: options.h:153
Parse commandline options.
Definition: engine.h: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
Definition: options.h:162
std::string stringValue() const
Definition: options.h:212
bool boolValue() const
Definition: options.h:210
void usage(ostream &out, const string &argv0)
Definition: commandline-demo.cpp:75
Definition: core.cpp:6
ListIterator< List > begin(List l)
Definition: list.h:420
Iterator< typename I::value_type > iterator(I i)
Definition: iterator.h:123
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
void Test
Definition: test.h:178
#define assert_eq(x, y)
Definition: test.h:33
#define assert(x)
Definition: test.h:30