source: branches/0.4-stable/test/commandline_test.cc @ 1431

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

refs #418 - added a test for this bug. The test is not active in the sense it does not affect the retunred value, but in verbose mode there is some output.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 8.4 KB
Line 
1// $Id: commandline_test.cc 1431 2008-08-21 20:29:49Z 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);
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  }
57  catch (std::runtime_error& e) {
58    suite.err() << "exception thrown\n" << e.what() << std::endl;
59  }
60
61  CommandLine cmd;
62  OptionFile file(cmd, "f,file", "description");
63
64  return suite.return_value();
65}
66
67
68bool cmd_help(yat::test::Suite& suite)
69{
70  using namespace theplu::yat::utility;
71  CommandLine cmd;
72  OptionArg<std::string> dir(cmd, "d,dir", "output directory");
73  OptionHelp help(cmd);
74  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
75  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
76  OptionSwitch version(cmd, "version", "output version and exit");
77
78  suite.err() << cmd;
79  return true;
80}
81
82bool test_switch(yat::test::Suite& suite)
83{
84  bool ok=true;
85  CommandLine cmd;
86  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
87  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done", true);
88
89  suite.err() << "Testing OptionSwitch -T...";
90  {
91    int ac = 2;
92    char* av[] = { "test_prog", "-T" };
93    cmd.parse(ac,av);
94    if (target.present() && !verbose.present())
95      suite.err() << "ok\n";
96    else {
97      suite.err() << "failed\n";
98      ok =false;
99    }
100  }
101
102
103  suite.err() << "Testing OptionSwitch --target...";
104  {
105    int ac = 2;
106    char* av[] = { "test_prog", "--target" };
107    cmd.parse(ac,av);
108    if (target.present() && !verbose.present())
109      suite.err() << "ok\n";
110    else {
111      suite.err() << "failed\n";
112      ok =false;
113    }
114  }
115
116  suite.err() << "Testing OptionSwitch -T -v...";
117  {
118    int ac = 3;
119    char* av[] = { "test_prog", "-T" , "-v"};
120    cmd.parse(ac,av);
121    if (target.present() && verbose.present())
122      suite.err() << "ok\n";
123    else {
124      suite.err() << "failed\n";
125      ok =false;
126    }
127  }
128
129  suite.err() << "Testing OptionSwitch -vT...";
130  {
131    int ac = 2;
132    char* av[] = { "test_prog", "-vT"};
133    cmd.parse(ac,av);
134    if (target.present() && verbose.present())
135      suite.err() << "ok\n";
136    else {
137      suite.err() << "failed\n";
138      ok =false;
139    }
140  }
141  return ok;
142}
143
144
145bool test_arg(yat::test::Suite& suite)
146{
147  bool ok=true;
148  CommandLine cmd;
149  OptionArg<std::string> input(cmd, "i,input", "input file");
150  OptionArg<unsigned int> n(cmd, "n", "number of lines");
151  OptionArg<double> x(cmd, "x", "a float number");
152
153  suite.err() << "Testing OptionArg existence -i file...";
154  {
155    int ac = 3;
156    char* av[] = { "test_prog", "-i", "file" };
157    cmd.parse(ac,av);
158    if (input.present())
159      suite.err() << "ok\n";
160    else {
161      suite.err() << "failed\n";
162      ok =false;
163    }
164  }
165
166  suite.err() << "Testing OptionArg value -i file...";
167  {
168    int ac = 3;
169    char* av[] = { "test_prog", "-i", "file" };
170    cmd.parse(ac,av);
171    if (input.value()=="file")
172      suite.err() << "ok\n";
173    else {
174      suite.err() << "failed\n";
175      ok =false;
176    }
177  }
178
179  suite.err() << "Testing OptionArg existence --input file...";
180  {
181    int ac = 3;
182    char* av[] = { "test_prog", "--input", "file" };
183    cmd.parse(ac,av);
184    if (input.present())
185      suite.err() << "ok\n";
186    else {
187      suite.err() << "failed\n";
188      ok =false;
189    }
190  }
191
192  suite.err() << "Testing OptionArg value --input=file...";
193  {
194    int ac = 2;
195    char* av[] = { "test_prog", "--input=file" };
196    cmd.parse(ac,av);
197    if (input.value()=="file")
198      suite.err() << "ok\n";
199    else {
200      suite.err() << "failed\n";
201      ok =false;
202    }
203  }
204
205  suite.err() << "Testing OptionArg value --input=\"file called something\"...";
206  {
207    int ac = 2;
208    char* av[] = { "test_prog", "--input=\"file called something\"" };
209    cmd.parse(ac,av);
210    if (input.value()=="file called something")
211      suite.err() << "ok\n";
212    else {
213      suite.err() << "failed\n";
214      suite.err() << "value is `" << input.value() << "'\n"
215            << "expected `file called something'\n";
216      ok =false;
217    }
218  }
219
220  suite.err() << "Testing OptionArg unsigned int value -n 3...";
221  {
222    int ac = 3;
223    char* av[] = { "test_prog", "-n", "3" };
224    cmd.parse(ac,av);
225    if (n.value()==3)
226      suite.err() << "ok\n";
227    else {
228      suite.err() << "failed\n";
229      ok =false;
230    }
231  }
232
233
234  suite.err() << "Testing OptionArg 2 value --input file -n 3...";
235  {
236    int ac = 5;
237    char* av[] = { "test_prog", "--input", "file", "-n", "3" };
238    cmd.parse(ac,av);
239    if (input.value()=="file")
240      suite.err() << "ok\n";
241    else {
242      suite.err() << "failed\n";
243      ok =false;
244    }
245  }
246
247  suite.err() << "Testing OptionArg double value -x -6...";
248  try {
249    int ac = 3;
250    char* av[] = { "test_prog", "-x", "-6" };
251    cmd.parse(ac,av);
252    if (x.value()==-6)
253      suite.err() << "ok\n";
254    else {
255      suite.err() << "failed\n";
256      ok =false;
257    }
258  }
259  catch (std::runtime_error& e) {
260    suite.err() << "failed\nexception thrown with what(): " << e.what() << "\n";
261    suite.err() << "Error: this is an expected error; see ticket:418\n";
262  }
263
264
265  return ok;
266}
267
268bool test_failures(yat::test::Suite& suite)
269{
270  bool ok=true;
271  CommandLine cmd;
272  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
273  OptionArg<std::string> input(cmd, "i,input", "input file");
274  OptionArg<unsigned int> n(cmd, "n", "number of lines");
275
276  suite.err() << "Testing unknown option --peter...";
277  {
278    int ac = 2;
279    char* av[] = { "test_prog", "--peter"};
280    try{
281      cmd.parse(ac,av);
282      suite.err() << "failed\n";
283      ok =false;
284    }
285    catch (...) {
286      suite.err() << "ok\n";
287    }
288  }
289
290  suite.err() << "Testing unknown option -jvjhsgad...";
291  {
292    int ac = 2;
293    char* av[] = { "test_prog", "-vjhsgad"};
294    try{
295      cmd.parse(ac,av);
296      suite.err() << "failed\n";
297      ok =false;
298    }
299    catch (...) {
300      suite.err() << "ok\n";
301    }
302  }
303
304
305  suite.err() << "Testing invalid option -nv 3...";
306  {
307    int ac = 3;
308    char* av[] = { "test_prog", "-nv", "3"};
309    try{
310      cmd.parse(ac,av);
311      suite.err() << "failed\n";
312      ok =false;
313    }
314    catch (...) {
315      suite.err() << "ok\n";
316    }
317  }
318
319
320  suite.err() << "Testing 23.12 is not unsigned int...";
321  {
322    int ac = 3;
323    char* av[] = { "test_prog", "-n", "23.12"};
324    try{
325      cmd.parse(ac,av);
326      suite.err() << "failed\n";
327      ok =false;
328    }
329    catch (std::runtime_error& e) {
330      suite.err() << "ok\n";
331    }
332  }
333
334  suite.err() << "Testing -1 is not unsigned int...";
335  {
336    int ac = 3;
337    char* av[] = { "test_prog", "-n" "-1"};
338    try{
339      cmd.parse(ac,av);
340      suite.err() << "failed\n";
341      ok =false;
342    }
343    catch (...) {
344      suite.err() << "ok\n";
345    }
346  }
347
348
349  suite.err() << "Testing OptionArg required ...";
350  {
351    OptionArg<std::string> required(cmd, "required", "required", true); 
352    int ac = 1;
353    char* av[] = { "test_prog" };
354    try{
355      cmd.parse(ac,av);
356      suite.err() << "failed\n";
357      ok =false;
358    }
359    catch (...) {
360      suite.err() << "ok\n";
361    }
362  }
363
364
365  return ok;
366}
367
368
369bool test_file(yat::test::Suite& suite)
370{
371  bool ok=true;
372  CommandLine cmd;
373  OptionFile inclones(cmd, "clones", "file containing clones");
374  OptionFile indata(cmd, "data", "data to merge");
375  OptionFile out(cmd, "o,out", "data to merge", true, false, "w");
376  OptionSwitch help(cmd, "h,help", "display this help and exit");
377
378  suite.err() << "Testing OptionFile... ";
379  {
380    int ac = 2;
381    char* av[] = { "test_prog", "--clones", "commandline_test.cc" 
382                   "--data", "commandline_test.cc", "-o", 
383                   "commandline_test.cc"};
384    cmd.parse(ac,av);
385    suite.err() << "ok\n";
386  }
387  return ok;
388}
389
390
391
392
393
Note: See TracBrowser for help on using the repository browser.