source: trunk/test/commandline_test.cc @ 965

Last change on this file since 965 was 965, checked in by Peter, 15 years ago

Adding CommandLine? class. finishes #240

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 6.9 KB
Line 
1// $Id: commandline_test.cc 965 2007-10-11 16:58:45Z peter $
2
3/*
4  Copyright (C) 2007 Peter Johansson
5
6  This file is part of the yat library, http://trac.thep.lu.se/trac/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 "yat/utility/CommandLine.h"
25#include "yat/utility/OptionArg.h"
26#include "yat/utility/OptionSwitch.h"
27
28#include <fstream>
29#include <stdexcept>
30
31using namespace theplu::yat::utility;
32bool cmd_help(std::ostream& error);
33bool test_switch(std::ostream& error);
34bool test_arg(std::ostream& error);
35bool test_failures(std::ostream& error);
36
37int main(const int argc,const char* argv[])
38{ 
39
40  std::ostream* error;
41  if (argc>1 && argv[1]==std::string("-v"))
42    error = &std::cerr;
43  else {
44    error = new std::ofstream("/dev/null");
45    if (argc>1)
46      std::cout << "commandline_test -v : for printing extra " 
47                << "information\n";
48  }
49  *error << "testing commandline" << std::endl;
50  bool ok = true;
51
52  try {
53    ok &= cmd_help(*error);
54 
55    ok &= test_switch(*error);
56    ok &= test_arg(*error);
57    ok &= test_failures(*error);
58  }
59  catch (std::runtime_error& e) {
60    *error << "exception thrown\n" << e.what() << std::endl;
61  }
62
63  if (!ok)
64    *error << "commandline test failed" << std::endl;
65  else
66    *error << "All tests are OK." << std::endl;
67 
68  if (error!=&std::cerr)
69    delete error;
70
71  return (ok ? 0 : -1);
72}
73
74
75bool cmd_help(std::ostream& error)
76{
77  using namespace theplu::yat::utility;
78  CommandLine cmd;
79  OptionArg<std::string> dir(cmd, "d,dir", "output directory");
80  OptionSwitch help(cmd, "h,help", "display this help and exit");
81  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
82  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
83  OptionSwitch version(cmd, "version", "output version and exit");
84
85  error << cmd;
86  return true;
87}
88
89bool test_switch(std::ostream& error)
90{
91  bool ok=true;
92  CommandLine cmd;
93  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
94  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done", true);
95
96  error << "Testing OptionSwitch -T...";
97  {
98    int ac = 2;
99    char* av[] = { "test_prog", "-T" };
100    cmd.parse(ac,av);
101    if (target.present() && !verbose.present())
102      error << "ok\n";
103    else {
104      error << "failed\n";
105      ok =false;
106    }
107  }
108
109
110  error << "Testing OptionSwitch --target...";
111  {
112    int ac = 2;
113    char* av[] = { "test_prog", "--target" };
114    cmd.parse(ac,av);
115    if (target.present() && !verbose.present())
116      error << "ok\n";
117    else {
118      error << "failed\n";
119      ok =false;
120    }
121  }
122
123  error << "Testing OptionSwitch -T -v...";
124  {
125    int ac = 3;
126    char* av[] = { "test_prog", "-T" , "-v"};
127    cmd.parse(ac,av);
128    if (target.present() && verbose.present())
129      error << "ok\n";
130    else {
131      error << "failed\n";
132      ok =false;
133    }
134  }
135
136  error << "Testing OptionSwitch -vT...";
137  {
138    int ac = 2;
139    char* av[] = { "test_prog", "-vT"};
140    cmd.parse(ac,av);
141    if (target.present() && verbose.present())
142      error << "ok\n";
143    else {
144      error << "failed\n";
145      ok =false;
146    }
147  }
148  return ok;
149}
150
151
152bool test_arg(std::ostream& error)
153{
154  bool ok=true;
155  CommandLine cmd;
156  OptionArg<std::string> input(cmd, "i,input", "input file");
157  OptionArg<u_int> n(cmd, "n", "number of lines");
158
159  error << "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      error << "ok\n";
166    else {
167      error << "failed\n";
168      ok =false;
169    }
170  }
171
172  error << "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      error << "ok\n";
179    else {
180      error << "failed\n";
181      ok =false;
182    }
183  }
184
185  error << "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      error << "ok\n";
192    else {
193      error << "failed\n";
194      ok =false;
195    }
196  }
197
198  error << "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      error << "ok\n";
205    else {
206      error << "failed\n";
207      ok =false;
208    }
209  }
210
211  error << "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      error << "ok\n";
218    else {
219      error << "failed\n";
220      error << "value is `" << input.value() << "'\n"
221            << "expected `file called something'\n";
222      ok =false;
223    }
224  }
225
226  error << "Testing OptionArg u_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      error << "ok\n";
233    else {
234      error << "failed\n";
235      ok =false;
236    }
237  }
238
239
240  error << "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      error << "ok\n";
247    else {
248      error << "failed\n";
249      ok =false;
250    }
251  }
252
253
254  return ok;
255}
256
257bool test_failures(std::ostream& error)
258{
259  bool ok=true;
260  CommandLine cmd;
261  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
262  OptionArg<std::string> input(cmd, "i,input", "input file");
263  OptionArg<u_int> n(cmd, "n", "number of lines");
264
265  error << "Testing unknown option --peter...";
266  {
267    int ac = 2;
268    char* av[] = { "test_prog", "--peter"};
269    try{
270      cmd.parse(ac,av);
271      error << "failed\n";
272      ok =false;
273    }
274    catch (...) {
275      error << "ok\n";
276    }
277  }
278
279  error << "Testing unknown option -jvjhsgad...";
280  {
281    int ac = 2;
282    char* av[] = { "test_prog", "-vjhsgad"};
283    try{
284      cmd.parse(ac,av);
285      error << "failed\n";
286      ok =false;
287    }
288    catch (...) {
289      error << "ok\n";
290    }
291  }
292
293
294  error << "Testing invalid option -nv 3...";
295  {
296    int ac = 3;
297    char* av[] = { "test_prog", "-nv", "3"};
298    try{
299      cmd.parse(ac,av);
300      error << "failed\n";
301      ok =false;
302    }
303    catch (...) {
304      error << "ok\n";
305    }
306  }
307
308
309  error << "Testing 23.12 is not u_int...";
310  {
311    int ac = 3;
312    char* av[] = { "test_prog", "-n", "23.12"};
313    try{
314      cmd.parse(ac,av);
315      error << "failed\n";
316      ok =false;
317    }
318    catch (std::runtime_error& e) {
319      error << "ok\n";
320    }
321  }
322
323  error << "Testing -1 is not u_int...";
324  {
325    int ac = 3;
326    char* av[] = { "test_prog", "-n" "-1"};
327    try{
328      cmd.parse(ac,av);
329      error << "failed\n";
330      ok =false;
331    }
332    catch (...) {
333      error << "ok\n";
334    }
335  }
336  return ok;
337}
338
339
340
341
342
343
Note: See TracBrowser for help on using the repository browser.