source: trunk/test/commandline_test.cc @ 1659

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

Fixed bug in CommandLine? how --no-switches are handled

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 10.9 KB
Line 
1// $Id: commandline_test.cc 1634 2008-11-19 22:37:11Z 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);
80  target.print_arg("=TARGET");
81  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
82  OptionSwitch version(cmd, "version", "output version and exit");
83
84  suite.err() << cmd;
85  return true;
86}
87
88bool test_switch(yat::test::Suite& suite)
89{
90  bool ok=true;
91  CommandLine cmd;
92  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
93  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done", true);
94
95  suite.err() << "Testing OptionSwitch -T...";
96  {
97    int ac = 2;
98    char* av[] = { "test_prog", "-T" };
99    cmd.parse(ac,av);
100    if (target.present() && !verbose.present())
101      suite.err() << "ok\n";
102    else {
103      suite.err() << "failed\n";
104      ok =false;
105    }
106  }
107
108
109  suite.err() << "Testing OptionSwitch --target...";
110  {
111    int ac = 2;
112    char* av[] = { "test_prog", "--target" };
113    cmd.parse(ac,av);
114    if (target.present() && target.value() && !verbose.present())
115      suite.err() << "ok\n";
116    else {
117      suite.err() << "failed\n";
118      ok =false;
119    }
120  }
121
122  suite.err() << "Testing OptionSwitch -T -v...";
123  {
124    int ac = 3;
125    char* av[] = { "test_prog", "-T" , "-v"};
126    cmd.parse(ac,av);
127    if (target.present() && verbose.present())
128      suite.err() << "ok\n";
129    else {
130      suite.err() << "failed\n";
131      ok =false;
132    }
133  }
134
135  suite.err() << "Testing OptionSwitch -vT...";
136  {
137    int ac = 2;
138    char* av[] = { "test_prog", "-vT"};
139    cmd.parse(ac,av);
140    if (target.present() && verbose.present())
141      suite.err() << "ok\n";
142    else {
143      suite.err() << "failed\n";
144      ok =false;
145    }
146  }
147
148  suite.err() << "Testing OptionSwitch --no-target...";
149  {
150    int ac = 2;
151    char* av[] = { "test_prog", "--no-target" };
152    cmd.parse(ac,av);
153    if (target.present() && !target.value())
154      suite.err() << "ok\n";
155    else {
156      suite.err() << "failed\n";
157      if (!target.present())
158        suite.err() << "target.present() returned false\n";
159      if (target.value())
160        suite.err() << "target.value() returned true\n";
161      ok =false;
162    }
163  }
164  return ok;
165}
166
167
168bool test_arg(yat::test::Suite& suite)
169{
170  bool ok=true;
171  CommandLine cmd;
172  OptionArg<std::string> input(cmd, "i,input", "input file");
173  OptionArg<unsigned int> n(cmd, "n", "number of lines");
174  OptionArg<double> x(cmd, "x,extra", "a float number");
175
176  suite.err() << "Testing OptionArg existence -i file...";
177  {
178    int ac = 3;
179    char* av[] = { "test_prog", "-i", "file" };
180    cmd.parse(ac,av);
181    if (input.present())
182      suite.err() << "ok\n";
183    else {
184      suite.err() << "failed\n";
185      ok =false;
186    }
187  }
188
189  suite.err() << "Testing OptionArg value -i file...";
190  {
191    int ac = 3;
192    char* av[] = { "test_prog", "-i", "file" };
193    cmd.parse(ac,av);
194    if (input.value()=="file")
195      suite.err() << "ok\n";
196    else {
197      suite.err() << "failed\n";
198      ok =false;
199    }
200  }
201
202  suite.err() << "Testing OptionArg existence --input file...";
203  {
204    int ac = 3;
205    char* av[] = { "test_prog", "--input", "file" };
206    cmd.parse(ac,av);
207    if (input.present())
208      suite.err() << "ok\n";
209    else {
210      suite.err() << "failed\n";
211      ok =false;
212    }
213  }
214
215  suite.err() << "Testing OptionArg value --input=file...";
216  {
217    int ac = 2;
218    char* av[] = { "test_prog", "--input=file" };
219    cmd.parse(ac,av);
220    if (input.value()=="file")
221      suite.err() << "ok\n";
222    else {
223      suite.err() << "failed\n";
224      ok =false;
225    }
226  }
227
228  suite.err() << "Testing OptionArg value --input=\"file called something\"...";
229  {
230    int ac = 2;
231    char* av[] = { "test_prog", "--input=\"file called something\"" };
232    cmd.parse(ac,av);
233    if (input.value()=="file called something")
234      suite.err() << "ok\n";
235    else {
236      suite.err() << "failed\n";
237      suite.err() << "value is `" << input.value() << "'\n"
238            << "expected `file called something'\n";
239      ok =false;
240    }
241  }
242
243  suite.err() << "Testing OptionArg unsigned int value -n 3...";
244  {
245    int ac = 3;
246    char* av[] = { "test_prog", "-n", "3" };
247    cmd.parse(ac,av);
248    if (n.value()==3)
249      suite.err() << "ok\n";
250    else {
251      suite.err() << "failed\n";
252      ok =false;
253    }
254  }
255
256
257  suite.err() << "Testing OptionArg 2 value --input file -n 3...";
258  {
259    int ac = 5;
260    char* av[] = { "test_prog", "--input", "file", "-n", "3" };
261    cmd.parse(ac,av);
262    if (input.value()=="file")
263      suite.err() << "ok\n";
264    else {
265      suite.err() << "failed\n";
266      ok =false;
267    }
268  }
269
270  suite.err() << "Testing OptionArg double value -x -6...";
271  try {
272    int ac = 3;
273    char* av[] = { "test_prog", "-x", "-6" };
274    cmd.parse(ac,av);
275    if (x.value()==-6)
276      suite.err() << "ok\n";
277    else {
278      suite.err() << "failed\n";
279      ok =false;
280    }
281  }
282  catch (std::runtime_error& e) {
283    ok = false;
284    suite.err() << "failed\nexception thrown with what(): " << e.what() << "\n";
285  }
286
287  suite.err() << "Testing OptionArg double value --extra -6...";
288  try {
289    int ac = 3;
290    char* av[] = { "test_prog", "--extra", "-6" };
291    cmd.parse(ac,av);
292    if (x.value()==-6)
293      suite.err() << "ok\n";
294    else {
295      suite.err() << "failed\n";
296      ok =false;
297    }
298  }
299  catch (std::runtime_error& e) {
300    ok=false;
301    suite.err() << "failed\nexception thrown with what(): " << e.what() << "\n";
302  }
303
304  suite.err() << "Testing OptionArg::value(T) ... ";
305  try {
306    int ac = 1;
307    char* av[] = { "test_prog"};
308    cmd.parse(ac,av);
309    n.value(5);
310    if (n.present()==false && n.value()==5)
311      suite.err() << "ok\n";
312    else {
313      suite.err() << "failed\n";
314      ok = false;
315    }
316  }
317  catch (std::runtime_error& e) {
318    suite.err() << "failed\n";
319    ok = false;
320  }
321
322  return ok;
323}
324
325bool test_failures(yat::test::Suite& suite)
326{
327  bool ok=true;
328  CommandLine cmd;
329  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
330  OptionArg<std::string> input(cmd, "i,input", "input file");
331  OptionArg<unsigned int> n(cmd, "n", "number of lines");
332
333  suite.err() << "Testing unknown option --peter...";
334  {
335    int ac = 2;
336    char* av[] = { "test_prog", "--peter"};
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  suite.err() << "Testing unknown option -jvjhsgad...";
348  {
349    int ac = 2;
350    char* av[] = { "test_prog", "-vjhsgad"};
351    try{
352      cmd.parse(ac,av);
353      suite.err() << "failed\n";
354      ok =false;
355    }
356    catch (...) {
357      suite.err() << "ok\n";
358    }
359  }
360
361
362  suite.err() << "Testing invalid option -nv 3...";
363  {
364    int ac = 3;
365    char* av[] = { "test_prog", "-nv", "3"};
366    try{
367      cmd.parse(ac,av);
368      suite.err() << "failed\n";
369      ok =false;
370    }
371    catch (...) {
372      suite.err() << "ok\n";
373    }
374  }
375
376
377  suite.err() << "Testing 23.12 is not unsigned int...";
378  {
379    int ac = 3;
380    char* av[] = { "test_prog", "-n", "23.12"};
381    try{
382      cmd.parse(ac,av);
383      suite.err() << "failed\n";
384      ok =false;
385    }
386    catch (std::runtime_error& e) {
387      suite.err() << "ok\n";
388    }
389  }
390
391  suite.err() << "Testing -1 is not unsigned int...";
392  {
393    int ac = 3;
394    char* av[] = { "test_prog", "-n" "-1"};
395    try{
396      cmd.parse(ac,av);
397      suite.err() << "failed\n";
398      ok =false;
399    }
400    catch (...) {
401      suite.err() << "ok\n";
402    }
403  }
404
405
406  suite.err() << "Testing invalid: test_prog peter...";
407  {
408    int ac = 2;
409    char* av[] = { "test_prog", "peter" };
410    try{
411      cmd.parse(ac,av);
412      suite.err() << "failed\n";
413      ok =false;
414    }
415    catch (...) {
416      suite.err() << "ok\n";
417    }
418  }
419
420  suite.err() << "Testing OptionArg required ...";
421  {
422    OptionArg<std::string> required(cmd, "required", "required", true); 
423    int ac = 1;
424    char* av[] = { "test_prog" };
425    try{
426      cmd.parse(ac,av);
427      suite.err() << "failed\n";
428      ok =false;
429    }
430    catch (...) {
431      suite.err() << "ok\n";
432    }
433  }
434
435
436  return ok;
437}
438
439
440bool test_file(yat::test::Suite& suite)
441{
442  bool ok=true;
443  CommandLine cmd;
444  OptionFile inclones(cmd, "clones", "file containing clones");
445  OptionFile indata(cmd, "data", "data to merge");
446  OptionFile out(cmd, "o,out", "data to merge", true, false, "w");
447  OptionSwitch help(cmd, "h,help", "display this help and exit");
448
449  suite.err() << "Testing OptionFile... ";
450  {
451    int ac = 7;
452    char* av[] = { "test_prog", "--clones", "commandline_test.cc", 
453                   "--data", "commandline_test.cc", "-o", 
454                   "commandline_test.cc"};
455    cmd.parse(ac,av);
456    suite.err() << "ok\n";
457  }
458  return ok;
459}
460
461bool test_option_name_clash(yat::test::Suite& suite)
462{
463  bool ok=true;
464  suite.err() << "Testing long option name clash ...";
465  try {
466    CommandLine cmd;
467    OptionSwitch op1(cmd, "opt", "bla bla");
468    OptionSwitch op2(cmd, "o,opt", "other bla");
469    ok=false;
470    suite.err() << "failed\n";
471  }
472  catch (std::runtime_error& e) {
473    suite.err() << "ok\n";
474  }
475  suite.err() << "Testing short option name clash ...";
476  try {
477    CommandLine cmd;
478    OptionSwitch op1(cmd, "o", "bla bla");
479    OptionSwitch op2(cmd, "o,opt", "other bla");
480    ok=false;
481    suite.err() << "failed\n";
482  }
483  catch (std::runtime_error& e) {
484    suite.err() << "ok\n";
485  }
486
487  return ok;
488}
489
490bool test_free_arg(yat::test::Suite& suite)
491{
492  bool ok=true;
493  suite.err() << "Testing free arguments ...";
494
495  CommandLine cmd;
496  cmd.allow_free_args(2);
497  OptionHelp help(cmd);
498  int ac = 3;
499  char* av[] = { "test_prog", "file", "kl"};
500  cmd.parse(ac, av);
501  suite.err() << "ok\n";
502  return ok;
503}
504
505
506
Note: See TracBrowser for help on using the repository browser.