source: trunk/test/commandline_test.cc @ 1629

Last change on this file since 1629 was 1629, checked in by Peter, 13 years ago

made help output more flexible

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 10.4 KB
Line 
1// $Id: commandline_test.cc 1629 2008-11-17 21:53:16Z peter $
2
3/*
4  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
5
6  This file is part of the yat library, http://dev.thep.lu.se/yat
7
8  The yat library is free software; you can redistribute it and/or
9  modify it under the terms of the GNU General Public License as
10  published by the Free Software Foundation; either version 3 of the
11  License, or (at your option) any later version.
12
13  The yat library is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  General Public License for more details.
17
18  You should have received a copy of the GNU General Public License
19  along with yat. If not, see <http://www.gnu.org/licenses/>.
20*/
21
22#include "Suite.h"
23
24#include "yat/utility/CommandLine.h"
25#include "yat/utility/OptionArg.h"
26#include "yat/utility/OptionFile.h"
27#include "yat/utility/OptionHelp.h"
28#include "yat/utility/OptionSwitch.h"
29
30#include <fstream>
31#include <stdexcept>
32
33using namespace theplu;
34using namespace yat::utility;
35bool cmd_help(yat::test::Suite& error);
36bool test_switch(yat::test::Suite& error);
37bool test_arg(yat::test::Suite& error);
38bool test_file(yat::test::Suite& error);
39bool test_failures(yat::test::Suite& error);
40bool test_option_name_clash(yat::test::Suite& suite);
41bool test_free_arg(yat::test::Suite& suite);
42
43int main(int argc, char* argv[])
44{ 
45
46  yat::test::Suite suite(argc, argv);
47
48  suite.err() << "testing commandline" << std::endl;
49
50  try {
51    suite.add(cmd_help(suite));
52    suite.add(test_switch(suite));
53    suite.add(test_arg(suite));
54    suite.add(test_file(suite));
55    suite.add(test_failures(suite));
56    suite.add(test_option_name_clash(suite));
57    suite.add(test_free_arg(suite));
58  }
59  catch (std::runtime_error& e) {
60    suite.err() << "Error: unexpected exception thrown\n" << e.what() 
61                << std::endl;
62    suite.add(false);
63  }
64
65  CommandLine cmd;
66  OptionFile file(cmd, "f,file", "description");
67
68  return suite.return_value();
69}
70
71
72bool cmd_help(yat::test::Suite& suite)
73{
74  using namespace theplu::yat::utility;
75  CommandLine cmd;
76  OptionArg<std::string> dir(cmd, "d,dir", "output directory");
77  OptionHelp help(cmd);
78  OptionArg<std::string> target(cmd, "T,target", "treat DEST as a normal file", 
79                                true, "TARGET");
80  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
81  OptionSwitch version(cmd, "version", "output version and exit");
82
83  suite.err() << cmd;
84  return true;
85}
86
87bool test_switch(yat::test::Suite& suite)
88{
89  bool ok=true;
90  CommandLine cmd;
91  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
92  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done", true);
93
94  suite.err() << "Testing OptionSwitch -T...";
95  {
96    int ac = 2;
97    char* av[] = { "test_prog", "-T" };
98    cmd.parse(ac,av);
99    if (target.present() && !verbose.present())
100      suite.err() << "ok\n";
101    else {
102      suite.err() << "failed\n";
103      ok =false;
104    }
105  }
106
107
108  suite.err() << "Testing OptionSwitch --target...";
109  {
110    int ac = 2;
111    char* av[] = { "test_prog", "--target" };
112    cmd.parse(ac,av);
113    if (target.present() && !verbose.present())
114      suite.err() << "ok\n";
115    else {
116      suite.err() << "failed\n";
117      ok =false;
118    }
119  }
120
121  suite.err() << "Testing OptionSwitch -T -v...";
122  {
123    int ac = 3;
124    char* av[] = { "test_prog", "-T" , "-v"};
125    cmd.parse(ac,av);
126    if (target.present() && verbose.present())
127      suite.err() << "ok\n";
128    else {
129      suite.err() << "failed\n";
130      ok =false;
131    }
132  }
133
134  suite.err() << "Testing OptionSwitch -vT...";
135  {
136    int ac = 2;
137    char* av[] = { "test_prog", "-vT"};
138    cmd.parse(ac,av);
139    if (target.present() && verbose.present())
140      suite.err() << "ok\n";
141    else {
142      suite.err() << "failed\n";
143      ok =false;
144    }
145  }
146  return ok;
147}
148
149
150bool test_arg(yat::test::Suite& suite)
151{
152  bool ok=true;
153  CommandLine cmd;
154  OptionArg<std::string> input(cmd, "i,input", "input file");
155  OptionArg<unsigned int> n(cmd, "n", "number of lines");
156  OptionArg<double> x(cmd, "x,extra", "a float number");
157
158  suite.err() << "Testing OptionArg existence -i file...";
159  {
160    int ac = 3;
161    char* av[] = { "test_prog", "-i", "file" };
162    cmd.parse(ac,av);
163    if (input.present())
164      suite.err() << "ok\n";
165    else {
166      suite.err() << "failed\n";
167      ok =false;
168    }
169  }
170
171  suite.err() << "Testing OptionArg value -i file...";
172  {
173    int ac = 3;
174    char* av[] = { "test_prog", "-i", "file" };
175    cmd.parse(ac,av);
176    if (input.value()=="file")
177      suite.err() << "ok\n";
178    else {
179      suite.err() << "failed\n";
180      ok =false;
181    }
182  }
183
184  suite.err() << "Testing OptionArg existence --input file...";
185  {
186    int ac = 3;
187    char* av[] = { "test_prog", "--input", "file" };
188    cmd.parse(ac,av);
189    if (input.present())
190      suite.err() << "ok\n";
191    else {
192      suite.err() << "failed\n";
193      ok =false;
194    }
195  }
196
197  suite.err() << "Testing OptionArg value --input=file...";
198  {
199    int ac = 2;
200    char* av[] = { "test_prog", "--input=file" };
201    cmd.parse(ac,av);
202    if (input.value()=="file")
203      suite.err() << "ok\n";
204    else {
205      suite.err() << "failed\n";
206      ok =false;
207    }
208  }
209
210  suite.err() << "Testing OptionArg value --input=\"file called something\"...";
211  {
212    int ac = 2;
213    char* av[] = { "test_prog", "--input=\"file called something\"" };
214    cmd.parse(ac,av);
215    if (input.value()=="file called something")
216      suite.err() << "ok\n";
217    else {
218      suite.err() << "failed\n";
219      suite.err() << "value is `" << input.value() << "'\n"
220            << "expected `file called something'\n";
221      ok =false;
222    }
223  }
224
225  suite.err() << "Testing OptionArg unsigned int value -n 3...";
226  {
227    int ac = 3;
228    char* av[] = { "test_prog", "-n", "3" };
229    cmd.parse(ac,av);
230    if (n.value()==3)
231      suite.err() << "ok\n";
232    else {
233      suite.err() << "failed\n";
234      ok =false;
235    }
236  }
237
238
239  suite.err() << "Testing OptionArg 2 value --input file -n 3...";
240  {
241    int ac = 5;
242    char* av[] = { "test_prog", "--input", "file", "-n", "3" };
243    cmd.parse(ac,av);
244    if (input.value()=="file")
245      suite.err() << "ok\n";
246    else {
247      suite.err() << "failed\n";
248      ok =false;
249    }
250  }
251
252  suite.err() << "Testing OptionArg double value -x -6...";
253  try {
254    int ac = 3;
255    char* av[] = { "test_prog", "-x", "-6" };
256    cmd.parse(ac,av);
257    if (x.value()==-6)
258      suite.err() << "ok\n";
259    else {
260      suite.err() << "failed\n";
261      ok =false;
262    }
263  }
264  catch (std::runtime_error& e) {
265    ok = false;
266    suite.err() << "failed\nexception thrown with what(): " << e.what() << "\n";
267  }
268
269  suite.err() << "Testing OptionArg double value --extra -6...";
270  try {
271    int ac = 3;
272    char* av[] = { "test_prog", "--extra", "-6" };
273    cmd.parse(ac,av);
274    if (x.value()==-6)
275      suite.err() << "ok\n";
276    else {
277      suite.err() << "failed\n";
278      ok =false;
279    }
280  }
281  catch (std::runtime_error& e) {
282    ok=false;
283    suite.err() << "failed\nexception thrown with what(): " << e.what() << "\n";
284  }
285
286  suite.err() << "Testing OptionArg::value(T) ... ";
287  try {
288    int ac = 1;
289    char* av[] = { "test_prog"};
290    cmd.parse(ac,av);
291    n.value(5);
292    if (n.present()==false && n.value()==5)
293      suite.err() << "ok\n";
294    else {
295      suite.err() << "failed\n";
296      ok = false;
297    }
298  }
299  catch (std::runtime_error& e) {
300    suite.err() << "failed\n";
301    ok = false;
302  }
303
304  return ok;
305}
306
307bool test_failures(yat::test::Suite& suite)
308{
309  bool ok=true;
310  CommandLine cmd;
311  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
312  OptionArg<std::string> input(cmd, "i,input", "input file");
313  OptionArg<unsigned int> n(cmd, "n", "number of lines");
314
315  suite.err() << "Testing unknown option --peter...";
316  {
317    int ac = 2;
318    char* av[] = { "test_prog", "--peter"};
319    try{
320      cmd.parse(ac,av);
321      suite.err() << "failed\n";
322      ok =false;
323    }
324    catch (...) {
325      suite.err() << "ok\n";
326    }
327  }
328
329  suite.err() << "Testing unknown option -jvjhsgad...";
330  {
331    int ac = 2;
332    char* av[] = { "test_prog", "-vjhsgad"};
333    try{
334      cmd.parse(ac,av);
335      suite.err() << "failed\n";
336      ok =false;
337    }
338    catch (...) {
339      suite.err() << "ok\n";
340    }
341  }
342
343
344  suite.err() << "Testing invalid option -nv 3...";
345  {
346    int ac = 3;
347    char* av[] = { "test_prog", "-nv", "3"};
348    try{
349      cmd.parse(ac,av);
350      suite.err() << "failed\n";
351      ok =false;
352    }
353    catch (...) {
354      suite.err() << "ok\n";
355    }
356  }
357
358
359  suite.err() << "Testing 23.12 is not unsigned int...";
360  {
361    int ac = 3;
362    char* av[] = { "test_prog", "-n", "23.12"};
363    try{
364      cmd.parse(ac,av);
365      suite.err() << "failed\n";
366      ok =false;
367    }
368    catch (std::runtime_error& e) {
369      suite.err() << "ok\n";
370    }
371  }
372
373  suite.err() << "Testing -1 is not unsigned int...";
374  {
375    int ac = 3;
376    char* av[] = { "test_prog", "-n" "-1"};
377    try{
378      cmd.parse(ac,av);
379      suite.err() << "failed\n";
380      ok =false;
381    }
382    catch (...) {
383      suite.err() << "ok\n";
384    }
385  }
386
387
388  suite.err() << "Testing invalid: test_prog peter...";
389  {
390    int ac = 2;
391    char* av[] = { "test_prog", "peter" };
392    try{
393      cmd.parse(ac,av);
394      suite.err() << "failed\n";
395      ok =false;
396    }
397    catch (...) {
398      suite.err() << "ok\n";
399    }
400  }
401
402  suite.err() << "Testing OptionArg required ...";
403  {
404    OptionArg<std::string> required(cmd, "required", "required", true); 
405    int ac = 1;
406    char* av[] = { "test_prog" };
407    try{
408      cmd.parse(ac,av);
409      suite.err() << "failed\n";
410      ok =false;
411    }
412    catch (...) {
413      suite.err() << "ok\n";
414    }
415  }
416
417
418  return ok;
419}
420
421
422bool test_file(yat::test::Suite& suite)
423{
424  bool ok=true;
425  CommandLine cmd;
426  OptionFile inclones(cmd, "clones", "file containing clones");
427  OptionFile indata(cmd, "data", "data to merge");
428  OptionFile out(cmd, "o,out", "data to merge", true, false, "w");
429  OptionSwitch help(cmd, "h,help", "display this help and exit");
430
431  suite.err() << "Testing OptionFile... ";
432  {
433    int ac = 7;
434    char* av[] = { "test_prog", "--clones", "commandline_test.cc", 
435                   "--data", "commandline_test.cc", "-o", 
436                   "commandline_test.cc"};
437    cmd.parse(ac,av);
438    suite.err() << "ok\n";
439  }
440  return ok;
441}
442
443bool test_option_name_clash(yat::test::Suite& suite)
444{
445  bool ok=true;
446  suite.err() << "Testing long option name clash ...";
447  try {
448    CommandLine cmd;
449    OptionSwitch op1(cmd, "opt", "bla bla");
450    OptionSwitch op2(cmd, "o,opt", "other bla");
451    ok=false;
452    suite.err() << "failed\n";
453  }
454  catch (std::runtime_error& e) {
455    suite.err() << "ok\n";
456  }
457  suite.err() << "Testing short option name clash ...";
458  try {
459    CommandLine cmd;
460    OptionSwitch op1(cmd, "o", "bla bla");
461    OptionSwitch op2(cmd, "o,opt", "other bla");
462    ok=false;
463    suite.err() << "failed\n";
464  }
465  catch (std::runtime_error& e) {
466    suite.err() << "ok\n";
467  }
468
469  return ok;
470}
471
472bool test_free_arg(yat::test::Suite& suite)
473{
474  bool ok=true;
475  suite.err() << "Testing free arguments ...";
476
477  CommandLine cmd;
478  cmd.allow_free_args(2);
479  OptionHelp help(cmd);
480  int ac = 3;
481  char* av[] = { "test_prog", "file", "kl"};
482  cmd.parse(ac, av);
483  suite.err() << "ok\n";
484  return ok;
485}
486
487
488
Note: See TracBrowser for help on using the repository browser.