source: trunk/test/commandline_test.cc @ 1468

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

fixes #413

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 10.1 KB
Line 
1// $Id: commandline_test.cc 1468 2008-09-02 14:57:50Z 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 2 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 this program; if not, write to the Free Software
20  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21  02111-1307, USA.
22*/
23
24#include "Suite.h"
25
26#include "yat/utility/CommandLine.h"
27#include "yat/utility/OptionArg.h"
28#include "yat/utility/OptionFile.h"
29#include "yat/utility/OptionHelp.h"
30#include "yat/utility/OptionSwitch.h"
31
32#include <fstream>
33#include <stdexcept>
34
35using namespace theplu;
36using namespace yat::utility;
37bool cmd_help(yat::test::Suite& error);
38bool test_switch(yat::test::Suite& error);
39bool test_arg(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  }
61  catch (std::runtime_error& e) {
62    suite.err() << "Error: unexpected exception thrown\n" << e.what() 
63                << std::endl;
64    suite.add(false);
65  }
66
67  CommandLine cmd;
68  OptionFile file(cmd, "f,file", "description");
69
70  return suite.return_value();
71}
72
73
74bool cmd_help(yat::test::Suite& suite)
75{
76  using namespace theplu::yat::utility;
77  CommandLine cmd;
78  OptionArg<std::string> dir(cmd, "d,dir", "output directory");
79  OptionHelp help(cmd);
80  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
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() && !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  return ok;
148}
149
150
151bool test_arg(yat::test::Suite& suite)
152{
153  bool ok=true;
154  CommandLine cmd;
155  OptionArg<std::string> input(cmd, "i,input", "input file");
156  OptionArg<unsigned int> n(cmd, "n", "number of lines");
157  OptionArg<double> x(cmd, "x,extra", "a float number");
158
159  suite.err() << "Testing OptionArg existence -i file...";
160  {
161    int ac = 3;
162    char* av[] = { "test_prog", "-i", "file" };
163    cmd.parse(ac,av);
164    if (input.present())
165      suite.err() << "ok\n";
166    else {
167      suite.err() << "failed\n";
168      ok =false;
169    }
170  }
171
172  suite.err() << "Testing OptionArg value -i file...";
173  {
174    int ac = 3;
175    char* av[] = { "test_prog", "-i", "file" };
176    cmd.parse(ac,av);
177    if (input.value()=="file")
178      suite.err() << "ok\n";
179    else {
180      suite.err() << "failed\n";
181      ok =false;
182    }
183  }
184
185  suite.err() << "Testing OptionArg existence --input file...";
186  {
187    int ac = 3;
188    char* av[] = { "test_prog", "--input", "file" };
189    cmd.parse(ac,av);
190    if (input.present())
191      suite.err() << "ok\n";
192    else {
193      suite.err() << "failed\n";
194      ok =false;
195    }
196  }
197
198  suite.err() << "Testing OptionArg value --input=file...";
199  {
200    int ac = 2;
201    char* av[] = { "test_prog", "--input=file" };
202    cmd.parse(ac,av);
203    if (input.value()=="file")
204      suite.err() << "ok\n";
205    else {
206      suite.err() << "failed\n";
207      ok =false;
208    }
209  }
210
211  suite.err() << "Testing OptionArg value --input=\"file called something\"...";
212  {
213    int ac = 2;
214    char* av[] = { "test_prog", "--input=\"file called something\"" };
215    cmd.parse(ac,av);
216    if (input.value()=="file called something")
217      suite.err() << "ok\n";
218    else {
219      suite.err() << "failed\n";
220      suite.err() << "value is `" << input.value() << "'\n"
221            << "expected `file called something'\n";
222      ok =false;
223    }
224  }
225
226  suite.err() << "Testing OptionArg unsigned int value -n 3...";
227  {
228    int ac = 3;
229    char* av[] = { "test_prog", "-n", "3" };
230    cmd.parse(ac,av);
231    if (n.value()==3)
232      suite.err() << "ok\n";
233    else {
234      suite.err() << "failed\n";
235      ok =false;
236    }
237  }
238
239
240  suite.err() << "Testing OptionArg 2 value --input file -n 3...";
241  {
242    int ac = 5;
243    char* av[] = { "test_prog", "--input", "file", "-n", "3" };
244    cmd.parse(ac,av);
245    if (input.value()=="file")
246      suite.err() << "ok\n";
247    else {
248      suite.err() << "failed\n";
249      ok =false;
250    }
251  }
252
253  suite.err() << "Testing OptionArg double value -x -6...";
254  try {
255    int ac = 3;
256    char* av[] = { "test_prog", "-x", "-6" };
257    cmd.parse(ac,av);
258    if (x.value()==-6)
259      suite.err() << "ok\n";
260    else {
261      suite.err() << "failed\n";
262      ok =false;
263    }
264  }
265  catch (std::runtime_error& e) {
266    ok = false;
267    suite.err() << "failed\nexception thrown with what(): " << e.what() << "\n";
268  }
269
270  suite.err() << "Testing OptionArg double value --extra -6...";
271  try {
272    int ac = 3;
273    char* av[] = { "test_prog", "--extra", "-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  return ok;
288}
289
290bool test_failures(yat::test::Suite& suite)
291{
292  bool ok=true;
293  CommandLine cmd;
294  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
295  OptionArg<std::string> input(cmd, "i,input", "input file");
296  OptionArg<unsigned int> n(cmd, "n", "number of lines");
297
298  suite.err() << "Testing unknown option --peter...";
299  {
300    int ac = 2;
301    char* av[] = { "test_prog", "--peter"};
302    try{
303      cmd.parse(ac,av);
304      suite.err() << "failed\n";
305      ok =false;
306    }
307    catch (...) {
308      suite.err() << "ok\n";
309    }
310  }
311
312  suite.err() << "Testing unknown option -jvjhsgad...";
313  {
314    int ac = 2;
315    char* av[] = { "test_prog", "-vjhsgad"};
316    try{
317      cmd.parse(ac,av);
318      suite.err() << "failed\n";
319      ok =false;
320    }
321    catch (...) {
322      suite.err() << "ok\n";
323    }
324  }
325
326
327  suite.err() << "Testing invalid option -nv 3...";
328  {
329    int ac = 3;
330    char* av[] = { "test_prog", "-nv", "3"};
331    try{
332      cmd.parse(ac,av);
333      suite.err() << "failed\n";
334      ok =false;
335    }
336    catch (...) {
337      suite.err() << "ok\n";
338    }
339  }
340
341
342  suite.err() << "Testing 23.12 is not unsigned int...";
343  {
344    int ac = 3;
345    char* av[] = { "test_prog", "-n", "23.12"};
346    try{
347      cmd.parse(ac,av);
348      suite.err() << "failed\n";
349      ok =false;
350    }
351    catch (std::runtime_error& e) {
352      suite.err() << "ok\n";
353    }
354  }
355
356  suite.err() << "Testing -1 is not unsigned int...";
357  {
358    int ac = 3;
359    char* av[] = { "test_prog", "-n" "-1"};
360    try{
361      cmd.parse(ac,av);
362      suite.err() << "failed\n";
363      ok =false;
364    }
365    catch (...) {
366      suite.err() << "ok\n";
367    }
368  }
369
370
371  suite.err() << "Testing invalid: test_prog peter...";
372  {
373    int ac = 2;
374    char* av[] = { "test_prog", "peter" };
375    try{
376      cmd.parse(ac,av);
377      suite.err() << "failed\n";
378      ok =false;
379    }
380    catch (...) {
381      suite.err() << "ok\n";
382    }
383  }
384
385  suite.err() << "Testing OptionArg required ...";
386  {
387    OptionArg<std::string> required(cmd, "required", "required", true); 
388    int ac = 1;
389    char* av[] = { "test_prog" };
390    try{
391      cmd.parse(ac,av);
392      suite.err() << "failed\n";
393      ok =false;
394    }
395    catch (...) {
396      suite.err() << "ok\n";
397    }
398  }
399
400
401  return ok;
402}
403
404
405bool test_file(yat::test::Suite& suite)
406{
407  bool ok=true;
408  CommandLine cmd;
409  OptionFile inclones(cmd, "clones", "file containing clones");
410  OptionFile indata(cmd, "data", "data to merge");
411  OptionFile out(cmd, "o,out", "data to merge", true, false, "w");
412  OptionSwitch help(cmd, "h,help", "display this help and exit");
413
414  suite.err() << "Testing OptionFile... ";
415  {
416    int ac = 7;
417    char* av[] = { "test_prog", "--clones", "commandline_test.cc", 
418                   "--data", "commandline_test.cc", "-o", 
419                   "commandline_test.cc"};
420    cmd.parse(ac,av);
421    suite.err() << "ok\n";
422  }
423  return ok;
424}
425
426bool test_option_name_clash(yat::test::Suite& suite)
427{
428  bool ok=true;
429  suite.err() << "Testing long option name clash ...";
430  try {
431    CommandLine cmd;
432    OptionSwitch op1(cmd, "opt", "bla bla");
433    OptionSwitch op2(cmd, "o,opt", "other bla");
434    ok=false;
435    suite.err() << "failed\n";
436  }
437  catch (std::runtime_error& e) {
438    suite.err() << "ok\n";
439  }
440  suite.err() << "Testing short option name clash ...";
441  try {
442    CommandLine cmd;
443    OptionSwitch op1(cmd, "o", "bla bla");
444    OptionSwitch op2(cmd, "o,opt", "other bla");
445    ok=false;
446    suite.err() << "failed\n";
447  }
448  catch (std::runtime_error& e) {
449    suite.err() << "ok\n";
450  }
451
452  return ok;
453}
454
455bool test_free_arg(yat::test::Suite& suite)
456{
457  bool ok=true;
458  suite.err() << "Testing free arguments ...";
459
460  CommandLine cmd;
461  cmd.allow_free_args(2);
462  OptionHelp help(cmd);
463  int ac = 3;
464  char* av[] = { "test_prog", "file", "kl"};
465  cmd.parse(ac, av);
466  suite.err() << "ok\n";
467  return ok;
468}
469
470
471
Note: See TracBrowser for help on using the repository browser.