source: trunk/test/commandline_test.cc @ 1874

Last change on this file since 1874 was 1874, checked in by Peter, 14 years ago

merge patch release 0.5.2 into trunk. Delta 0.5.2 - 0.5.1

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