source: trunk/test/commandline_test.cc @ 1273

Last change on this file since 1273 was 1273, checked in by Jari Häkkinen, 15 years ago

Some more uint, u_int, and u_long fixes.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 8.0 KB
Line 
1// $Id: commandline_test.cc 1273 2008-04-10 07:59:23Z jari $
2
3/*
4  Copyright (C) 2007 Peter Johansson
5  Copyright (C) 2008 Jari Häkkinen, Peter Johansson
6
7  This file is part of the yat library, http://trac.thep.lu.se/yat
8
9  The yat library is free software; you can redistribute it and/or
10  modify it under the terms of the GNU General Public License as
11  published by the Free Software Foundation; either version 2 of the
12  License, or (at your option) any later version.
13
14  The yat library is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  General Public License for more details.
18
19  You should have received a copy of the GNU General Public License
20  along with this program; if not, write to the Free Software
21  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22  02111-1307, USA.
23*/
24
25#include "Suite.h"
26
27#include "yat/utility/CommandLine.h"
28#include "yat/utility/OptionArg.h"
29#include "yat/utility/OptionFile.h"
30#include "yat/utility/OptionHelp.h"
31#include "yat/utility/OptionSwitch.h"
32
33#include <fstream>
34#include <stdexcept>
35
36using namespace theplu;
37using namespace yat::utility;
38bool cmd_help(yat::test::Suite& error);
39bool test_switch(yat::test::Suite& error);
40bool test_arg(yat::test::Suite& error);
41bool test_file(yat::test::Suite& error);
42bool test_failures(yat::test::Suite& error);
43
44int main(int argc, char* argv[])
45{ 
46
47  yat::test::Suite suite(argc, argv);
48
49  suite.err() << "testing commandline" << std::endl;
50
51  try {
52    suite.add(cmd_help(suite));
53    suite.add(test_switch(suite));
54    suite.add(test_arg(suite));
55    suite.add(test_file(suite));
56    suite.add(test_failures(suite));
57  }
58  catch (std::runtime_error& e) {
59    suite.err() << "exception thrown\n" << e.what() << std::endl;
60  }
61
62  CommandLine cmd;
63  OptionFile file(cmd, "f,file", "description");
64
65  return suite.return_value();
66}
67
68
69bool cmd_help(yat::test::Suite& suite)
70{
71  using namespace theplu::yat::utility;
72  CommandLine cmd;
73  OptionArg<std::string> dir(cmd, "d,dir", "output directory");
74  OptionHelp help(cmd);
75  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
76  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
77  OptionSwitch version(cmd, "version", "output version and exit");
78
79  suite.err() << cmd;
80  return true;
81}
82
83bool test_switch(yat::test::Suite& suite)
84{
85  bool ok=true;
86  CommandLine cmd;
87  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
88  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done", true);
89
90  suite.err() << "Testing OptionSwitch -T...";
91  {
92    int ac = 2;
93    char* av[] = { "test_prog", "-T" };
94    cmd.parse(ac,av);
95    if (target.present() && !verbose.present())
96      suite.err() << "ok\n";
97    else {
98      suite.err() << "failed\n";
99      ok =false;
100    }
101  }
102
103
104  suite.err() << "Testing OptionSwitch --target...";
105  {
106    int ac = 2;
107    char* av[] = { "test_prog", "--target" };
108    cmd.parse(ac,av);
109    if (target.present() && !verbose.present())
110      suite.err() << "ok\n";
111    else {
112      suite.err() << "failed\n";
113      ok =false;
114    }
115  }
116
117  suite.err() << "Testing OptionSwitch -T -v...";
118  {
119    int ac = 3;
120    char* av[] = { "test_prog", "-T" , "-v"};
121    cmd.parse(ac,av);
122    if (target.present() && verbose.present())
123      suite.err() << "ok\n";
124    else {
125      suite.err() << "failed\n";
126      ok =false;
127    }
128  }
129
130  suite.err() << "Testing OptionSwitch -vT...";
131  {
132    int ac = 2;
133    char* av[] = { "test_prog", "-vT"};
134    cmd.parse(ac,av);
135    if (target.present() && verbose.present())
136      suite.err() << "ok\n";
137    else {
138      suite.err() << "failed\n";
139      ok =false;
140    }
141  }
142  return ok;
143}
144
145
146bool test_arg(yat::test::Suite& suite)
147{
148  bool ok=true;
149  CommandLine cmd;
150  OptionArg<std::string> input(cmd, "i,input", "input file");
151  OptionArg<unsigned int> n(cmd, "n", "number of lines");
152
153  suite.err() << "Testing OptionArg existence -i file...";
154  {
155    int ac = 3;
156    char* av[] = { "test_prog", "-i", "file" };
157    cmd.parse(ac,av);
158    if (input.present())
159      suite.err() << "ok\n";
160    else {
161      suite.err() << "failed\n";
162      ok =false;
163    }
164  }
165
166  suite.err() << "Testing OptionArg value -i file...";
167  {
168    int ac = 3;
169    char* av[] = { "test_prog", "-i", "file" };
170    cmd.parse(ac,av);
171    if (input.value()=="file")
172      suite.err() << "ok\n";
173    else {
174      suite.err() << "failed\n";
175      ok =false;
176    }
177  }
178
179  suite.err() << "Testing OptionArg existence --input file...";
180  {
181    int ac = 3;
182    char* av[] = { "test_prog", "--input", "file" };
183    cmd.parse(ac,av);
184    if (input.present())
185      suite.err() << "ok\n";
186    else {
187      suite.err() << "failed\n";
188      ok =false;
189    }
190  }
191
192  suite.err() << "Testing OptionArg value --input=file...";
193  {
194    int ac = 2;
195    char* av[] = { "test_prog", "--input=file" };
196    cmd.parse(ac,av);
197    if (input.value()=="file")
198      suite.err() << "ok\n";
199    else {
200      suite.err() << "failed\n";
201      ok =false;
202    }
203  }
204
205  suite.err() << "Testing OptionArg value --input=\"file called something\"...";
206  {
207    int ac = 2;
208    char* av[] = { "test_prog", "--input=\"file called something\"" };
209    cmd.parse(ac,av);
210    if (input.value()=="file called something")
211      suite.err() << "ok\n";
212    else {
213      suite.err() << "failed\n";
214      suite.err() << "value is `" << input.value() << "'\n"
215            << "expected `file called something'\n";
216      ok =false;
217    }
218  }
219
220  suite.err() << "Testing OptionArg unsigned int value -n 3...";
221  {
222    int ac = 3;
223    char* av[] = { "test_prog", "-n", "3" };
224    cmd.parse(ac,av);
225    if (n.value()==3)
226      suite.err() << "ok\n";
227    else {
228      suite.err() << "failed\n";
229      ok =false;
230    }
231  }
232
233
234  suite.err() << "Testing OptionArg 2 value --input file -n 3...";
235  {
236    int ac = 5;
237    char* av[] = { "test_prog", "--input", "file", "-n", "3" };
238    cmd.parse(ac,av);
239    if (input.value()=="file")
240      suite.err() << "ok\n";
241    else {
242      suite.err() << "failed\n";
243      ok =false;
244    }
245  }
246
247
248  return ok;
249}
250
251bool test_failures(yat::test::Suite& suite)
252{
253  bool ok=true;
254  CommandLine cmd;
255  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
256  OptionArg<std::string> input(cmd, "i,input", "input file");
257  OptionArg<unsigned int> n(cmd, "n", "number of lines");
258
259  suite.err() << "Testing unknown option --peter...";
260  {
261    int ac = 2;
262    char* av[] = { "test_prog", "--peter"};
263    try{
264      cmd.parse(ac,av);
265      suite.err() << "failed\n";
266      ok =false;
267    }
268    catch (...) {
269      suite.err() << "ok\n";
270    }
271  }
272
273  suite.err() << "Testing unknown option -jvjhsgad...";
274  {
275    int ac = 2;
276    char* av[] = { "test_prog", "-vjhsgad"};
277    try{
278      cmd.parse(ac,av);
279      suite.err() << "failed\n";
280      ok =false;
281    }
282    catch (...) {
283      suite.err() << "ok\n";
284    }
285  }
286
287
288  suite.err() << "Testing invalid option -nv 3...";
289  {
290    int ac = 3;
291    char* av[] = { "test_prog", "-nv", "3"};
292    try{
293      cmd.parse(ac,av);
294      suite.err() << "failed\n";
295      ok =false;
296    }
297    catch (...) {
298      suite.err() << "ok\n";
299    }
300  }
301
302
303  suite.err() << "Testing 23.12 is not unsigned int...";
304  {
305    int ac = 3;
306    char* av[] = { "test_prog", "-n", "23.12"};
307    try{
308      cmd.parse(ac,av);
309      suite.err() << "failed\n";
310      ok =false;
311    }
312    catch (std::runtime_error& e) {
313      suite.err() << "ok\n";
314    }
315  }
316
317  suite.err() << "Testing -1 is not unsigned int...";
318  {
319    int ac = 3;
320    char* av[] = { "test_prog", "-n" "-1"};
321    try{
322      cmd.parse(ac,av);
323      suite.err() << "failed\n";
324      ok =false;
325    }
326    catch (...) {
327      suite.err() << "ok\n";
328    }
329  }
330
331
332  suite.err() << "Testing OptionArg required ...";
333  {
334    OptionArg<std::string> required(cmd, "required", "required", true); 
335    int ac = 1;
336    char* av[] = { "test_prog" };
337    try{
338      cmd.parse(ac,av);
339      suite.err() << "failed\n";
340      ok =false;
341    }
342    catch (...) {
343      suite.err() << "ok\n";
344    }
345  }
346
347
348  return ok;
349}
350
351
352bool test_file(yat::test::Suite& suite)
353{
354  bool ok=true;
355  CommandLine cmd;
356  OptionFile inclones(cmd, "clones", "file containing clones");
357  OptionFile indata(cmd, "data", "data to merge");
358  OptionFile out(cmd, "o,out", "data to merge", true, false, "w");
359  OptionSwitch help(cmd, "h,help", "display this help and exit");
360
361  suite.err() << "Testing OptionFile... ";
362  {
363    int ac = 2;
364    char* av[] = { "test_prog", "--clones", "commandline_test.cc" 
365                   "--data", "commandline_test.cc", "-o", 
366                   "commandline_test.cc"};
367    cmd.parse(ac,av);
368    suite.err() << "ok\n";
369  }
370  return ok;
371}
372
373
374
375
376
Note: See TracBrowser for help on using the repository browser.