source: trunk/test/commandline_test.cc @ 1619

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

correcting constness

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