source: trunk/test/commandline_test.cc @ 1427

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

refs #413 seems like those args are just ignored now. Commandline should store those strings in a vector<string> that one can access.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 9.1 KB
Line 
1// $Id: commandline_test.cc 1427 2008-08-20 23:54:24Z peter $
2
3/*
4  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
5
6  This file is part of the yat library, http://trac.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
158  suite.err() << "Testing OptionArg existence -i file...";
159  {
160    int ac = 3;
161    char* av[] = { "test_prog", "-i", "file" };
162    cmd.parse(ac,av);
163    if (input.present())
164      suite.err() << "ok\n";
165    else {
166      suite.err() << "failed\n";
167      ok =false;
168    }
169  }
170
171  suite.err() << "Testing OptionArg value -i file...";
172  {
173    int ac = 3;
174    char* av[] = { "test_prog", "-i", "file" };
175    cmd.parse(ac,av);
176    if (input.value()=="file")
177      suite.err() << "ok\n";
178    else {
179      suite.err() << "failed\n";
180      ok =false;
181    }
182  }
183
184  suite.err() << "Testing OptionArg existence --input file...";
185  {
186    int ac = 3;
187    char* av[] = { "test_prog", "--input", "file" };
188    cmd.parse(ac,av);
189    if (input.present())
190      suite.err() << "ok\n";
191    else {
192      suite.err() << "failed\n";
193      ok =false;
194    }
195  }
196
197  suite.err() << "Testing OptionArg value --input=file...";
198  {
199    int ac = 2;
200    char* av[] = { "test_prog", "--input=file" };
201    cmd.parse(ac,av);
202    if (input.value()=="file")
203      suite.err() << "ok\n";
204    else {
205      suite.err() << "failed\n";
206      ok =false;
207    }
208  }
209
210  suite.err() << "Testing OptionArg value --input=\"file called something\"...";
211  {
212    int ac = 2;
213    char* av[] = { "test_prog", "--input=\"file called something\"" };
214    cmd.parse(ac,av);
215    if (input.value()=="file called something")
216      suite.err() << "ok\n";
217    else {
218      suite.err() << "failed\n";
219      suite.err() << "value is `" << input.value() << "'\n"
220            << "expected `file called something'\n";
221      ok =false;
222    }
223  }
224
225  suite.err() << "Testing OptionArg unsigned int value -n 3...";
226  {
227    int ac = 3;
228    char* av[] = { "test_prog", "-n", "3" };
229    cmd.parse(ac,av);
230    if (n.value()==3)
231      suite.err() << "ok\n";
232    else {
233      suite.err() << "failed\n";
234      ok =false;
235    }
236  }
237
238
239  suite.err() << "Testing OptionArg 2 value --input file -n 3...";
240  {
241    int ac = 5;
242    char* av[] = { "test_prog", "--input", "file", "-n", "3" };
243    cmd.parse(ac,av);
244    if (input.value()=="file")
245      suite.err() << "ok\n";
246    else {
247      suite.err() << "failed\n";
248      ok =false;
249    }
250  }
251
252
253  return ok;
254}
255
256bool test_failures(yat::test::Suite& suite)
257{
258  bool ok=true;
259  CommandLine cmd;
260  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
261  OptionArg<std::string> input(cmd, "i,input", "input file");
262  OptionArg<unsigned int> n(cmd, "n", "number of lines");
263
264  suite.err() << "Testing unknown option --peter...";
265  {
266    int ac = 2;
267    char* av[] = { "test_prog", "--peter"};
268    try{
269      cmd.parse(ac,av);
270      suite.err() << "failed\n";
271      ok =false;
272    }
273    catch (...) {
274      suite.err() << "ok\n";
275    }
276  }
277
278  suite.err() << "Testing unknown option -jvjhsgad...";
279  {
280    int ac = 2;
281    char* av[] = { "test_prog", "-vjhsgad"};
282    try{
283      cmd.parse(ac,av);
284      suite.err() << "failed\n";
285      ok =false;
286    }
287    catch (...) {
288      suite.err() << "ok\n";
289    }
290  }
291
292
293  suite.err() << "Testing invalid option -nv 3...";
294  {
295    int ac = 3;
296    char* av[] = { "test_prog", "-nv", "3"};
297    try{
298      cmd.parse(ac,av);
299      suite.err() << "failed\n";
300      ok =false;
301    }
302    catch (...) {
303      suite.err() << "ok\n";
304    }
305  }
306
307
308  suite.err() << "Testing 23.12 is not unsigned int...";
309  {
310    int ac = 3;
311    char* av[] = { "test_prog", "-n", "23.12"};
312    try{
313      cmd.parse(ac,av);
314      suite.err() << "failed\n";
315      ok =false;
316    }
317    catch (std::runtime_error& e) {
318      suite.err() << "ok\n";
319    }
320  }
321
322  suite.err() << "Testing -1 is not unsigned int...";
323  {
324    int ac = 3;
325    char* av[] = { "test_prog", "-n" "-1"};
326    try{
327      cmd.parse(ac,av);
328      suite.err() << "failed\n";
329      ok =false;
330    }
331    catch (...) {
332      suite.err() << "ok\n";
333    }
334  }
335
336
337  suite.err() << "Testing OptionArg required ...";
338  {
339    OptionArg<std::string> required(cmd, "required", "required", true); 
340    int ac = 1;
341    char* av[] = { "test_prog" };
342    try{
343      cmd.parse(ac,av);
344      suite.err() << "failed\n";
345      ok =false;
346    }
347    catch (...) {
348      suite.err() << "ok\n";
349    }
350  }
351
352
353  return ok;
354}
355
356
357bool test_file(yat::test::Suite& suite)
358{
359  bool ok=true;
360  CommandLine cmd;
361  OptionFile inclones(cmd, "clones", "file containing clones");
362  OptionFile indata(cmd, "data", "data to merge");
363  OptionFile out(cmd, "o,out", "data to merge", true, false, "w");
364  OptionSwitch help(cmd, "h,help", "display this help and exit");
365
366  suite.err() << "Testing OptionFile... ";
367  {
368    int ac = 7;
369    char* av[] = { "test_prog", "--clones", "commandline_test.cc", 
370                   "--data", "commandline_test.cc", "-o", 
371                   "commandline_test.cc"};
372    cmd.parse(ac,av);
373    suite.err() << "ok\n";
374  }
375  return ok;
376}
377
378bool test_option_name_clash(yat::test::Suite& suite)
379{
380  bool ok=true;
381  suite.err() << "Testing long option name clash ...";
382  try {
383    CommandLine cmd;
384    OptionSwitch op1(cmd, "opt", "bla bla");
385    OptionSwitch op2(cmd, "o,opt", "other bla");
386    ok=false;
387    suite.err() << "failed\n";
388  }
389  catch (std::runtime_error& e) {
390    suite.err() << "ok\n";
391  }
392  suite.err() << "Testing short option name clash ...";
393  try {
394    CommandLine cmd;
395    OptionSwitch op1(cmd, "o", "bla bla");
396    OptionSwitch op2(cmd, "o,opt", "other bla");
397    ok=false;
398    suite.err() << "failed\n";
399  }
400  catch (std::runtime_error& e) {
401    suite.err() << "ok\n";
402  }
403
404  return ok;
405}
406
407bool test_free_arg(yat::test::Suite& suite)
408{
409  bool ok=true;
410  suite.err() << "Testing free arguments ...";
411
412  CommandLine cmd;
413  OptionHelp help(cmd);
414  int ac = 3;
415  char* av[] = { "test_prog", "file", "kl"};
416  cmd.parse(ac, av);
417  suite.err() << "ok\n";
418  return ok;
419}
420
421
422
Note: See TracBrowser for help on using the repository browser.