source: trunk/test/commandline_test.cc @ 1437

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

merge patch release 0.4.2 to trunk. Delta 0.4.2-0.4.1

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 9.5 KB
Line 
1// $Id: commandline_test.cc 1437 2008-08-25 17:55:00Z 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", "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    suite.err() << "failed\nexception thrown with what(): " << e.what() << "\n";
267    suite.err() << "Error: this is an expected error; see ticket:418\n";
268  }
269
270
271  return ok;
272}
273
274bool test_failures(yat::test::Suite& suite)
275{
276  bool ok=true;
277  CommandLine cmd;
278  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
279  OptionArg<std::string> input(cmd, "i,input", "input file");
280  OptionArg<unsigned int> n(cmd, "n", "number of lines");
281
282  suite.err() << "Testing unknown option --peter...";
283  {
284    int ac = 2;
285    char* av[] = { "test_prog", "--peter"};
286    try{
287      cmd.parse(ac,av);
288      suite.err() << "failed\n";
289      ok =false;
290    }
291    catch (...) {
292      suite.err() << "ok\n";
293    }
294  }
295
296  suite.err() << "Testing unknown option -jvjhsgad...";
297  {
298    int ac = 2;
299    char* av[] = { "test_prog", "-vjhsgad"};
300    try{
301      cmd.parse(ac,av);
302      suite.err() << "failed\n";
303      ok =false;
304    }
305    catch (...) {
306      suite.err() << "ok\n";
307    }
308  }
309
310
311  suite.err() << "Testing invalid option -nv 3...";
312  {
313    int ac = 3;
314    char* av[] = { "test_prog", "-nv", "3"};
315    try{
316      cmd.parse(ac,av);
317      suite.err() << "failed\n";
318      ok =false;
319    }
320    catch (...) {
321      suite.err() << "ok\n";
322    }
323  }
324
325
326  suite.err() << "Testing 23.12 is not unsigned int...";
327  {
328    int ac = 3;
329    char* av[] = { "test_prog", "-n", "23.12"};
330    try{
331      cmd.parse(ac,av);
332      suite.err() << "failed\n";
333      ok =false;
334    }
335    catch (std::runtime_error& e) {
336      suite.err() << "ok\n";
337    }
338  }
339
340  suite.err() << "Testing -1 is not unsigned int...";
341  {
342    int ac = 3;
343    char* av[] = { "test_prog", "-n" "-1"};
344    try{
345      cmd.parse(ac,av);
346      suite.err() << "failed\n";
347      ok =false;
348    }
349    catch (...) {
350      suite.err() << "ok\n";
351    }
352  }
353
354
355  suite.err() << "Testing OptionArg required ...";
356  {
357    OptionArg<std::string> required(cmd, "required", "required", true); 
358    int ac = 1;
359    char* av[] = { "test_prog" };
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  return ok;
372}
373
374
375bool test_file(yat::test::Suite& suite)
376{
377  bool ok=true;
378  CommandLine cmd;
379  OptionFile inclones(cmd, "clones", "file containing clones");
380  OptionFile indata(cmd, "data", "data to merge");
381  OptionFile out(cmd, "o,out", "data to merge", true, false, "w");
382  OptionSwitch help(cmd, "h,help", "display this help and exit");
383
384  suite.err() << "Testing OptionFile... ";
385  {
386    int ac = 7;
387    char* av[] = { "test_prog", "--clones", "commandline_test.cc", 
388                   "--data", "commandline_test.cc", "-o", 
389                   "commandline_test.cc"};
390    cmd.parse(ac,av);
391    suite.err() << "ok\n";
392  }
393  return ok;
394}
395
396bool test_option_name_clash(yat::test::Suite& suite)
397{
398  bool ok=true;
399  suite.err() << "Testing long option name clash ...";
400  try {
401    CommandLine cmd;
402    OptionSwitch op1(cmd, "opt", "bla bla");
403    OptionSwitch op2(cmd, "o,opt", "other bla");
404    ok=false;
405    suite.err() << "failed\n";
406  }
407  catch (std::runtime_error& e) {
408    suite.err() << "ok\n";
409  }
410  suite.err() << "Testing short option name clash ...";
411  try {
412    CommandLine cmd;
413    OptionSwitch op1(cmd, "o", "bla bla");
414    OptionSwitch op2(cmd, "o,opt", "other bla");
415    ok=false;
416    suite.err() << "failed\n";
417  }
418  catch (std::runtime_error& e) {
419    suite.err() << "ok\n";
420  }
421
422  return ok;
423}
424
425bool test_free_arg(yat::test::Suite& suite)
426{
427  bool ok=true;
428  suite.err() << "Testing free arguments ...";
429
430  CommandLine cmd;
431  OptionHelp help(cmd);
432  int ac = 3;
433  char* av[] = { "test_prog", "file", "kl"};
434  cmd.parse(ac, av);
435  suite.err() << "ok\n";
436  return ok;
437}
438
439
440
Note: See TracBrowser for help on using the repository browser.