source: trunk/test/commandline_test.cc @ 1260

Last change on this file since 1260 was 1260, checked in by Jari Häkkinen, 13 years ago

Made the project to compile on my Intel Mac running Leopard.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 8.0 KB
Line 
1// $Id: commandline_test.cc 1260 2008-04-08 06:16:53Z jari $
2
3/*
4  Copyright (C) 2007 Peter Johansson
5  Copyright (C) 2008 Jari Häkkinen, Peter Johansson
6
7  This file is part of the yat library, http://trac.thep.lu.se/yat
8
9  The yat library is free software; you can redistribute it and/or
10  modify it under the terms of the GNU General Public License as
11  published by the Free Software Foundation; either version 2 of the
12  License, or (at your option) any later version.
13
14  The yat library is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  General Public License for more details.
18
19  You should have received a copy of the GNU General Public License
20  along with this program; if not, write to the Free Software
21  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
22  02111-1307, USA.
23*/
24
25#include "Suite.h"
26
27#include "yat/utility/CommandLine.h"
28#include "yat/utility/OptionArg.h"
29#include "yat/utility/OptionFile.h"
30#include "yat/utility/OptionHelp.h"
31#include "yat/utility/OptionSwitch.h"
32
33#include <fstream>
34#include <stdexcept>
35
36#include <sys/types.h>
37
38using namespace theplu;
39using namespace yat::utility;
40bool cmd_help(yat::test::Suite& error);
41bool test_switch(yat::test::Suite& error);
42bool test_arg(yat::test::Suite& error);
43bool test_file(yat::test::Suite& error);
44bool test_failures(yat::test::Suite& error);
45
46int main(int argc, char* argv[])
47{ 
48
49  yat::test::Suite suite(argc, argv);
50
51  suite.err() << "testing commandline" << std::endl;
52
53  try {
54    suite.add(cmd_help(suite));
55    suite.add(test_switch(suite));
56    suite.add(test_arg(suite));
57    suite.add(test_file(suite));
58    suite.add(test_failures(suite));
59  }
60  catch (std::runtime_error& e) {
61    suite.err() << "exception thrown\n" << e.what() << std::endl;
62  }
63
64  CommandLine cmd;
65  OptionFile file(cmd, "f,file", "description");
66
67  return suite.return_value();
68}
69
70
71bool cmd_help(yat::test::Suite& suite)
72{
73  using namespace theplu::yat::utility;
74  CommandLine cmd;
75  OptionArg<std::string> dir(cmd, "d,dir", "output directory");
76  OptionHelp help(cmd);
77  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
78  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
79  OptionSwitch version(cmd, "version", "output version and exit");
80
81  suite.err() << cmd;
82  return true;
83}
84
85bool test_switch(yat::test::Suite& suite)
86{
87  bool ok=true;
88  CommandLine cmd;
89  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
90  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done", true);
91
92  suite.err() << "Testing OptionSwitch -T...";
93  {
94    int ac = 2;
95    char* av[] = { "test_prog", "-T" };
96    cmd.parse(ac,av);
97    if (target.present() && !verbose.present())
98      suite.err() << "ok\n";
99    else {
100      suite.err() << "failed\n";
101      ok =false;
102    }
103  }
104
105
106  suite.err() << "Testing OptionSwitch --target...";
107  {
108    int ac = 2;
109    char* av[] = { "test_prog", "--target" };
110    cmd.parse(ac,av);
111    if (target.present() && !verbose.present())
112      suite.err() << "ok\n";
113    else {
114      suite.err() << "failed\n";
115      ok =false;
116    }
117  }
118
119  suite.err() << "Testing OptionSwitch -T -v...";
120  {
121    int ac = 3;
122    char* av[] = { "test_prog", "-T" , "-v"};
123    cmd.parse(ac,av);
124    if (target.present() && verbose.present())
125      suite.err() << "ok\n";
126    else {
127      suite.err() << "failed\n";
128      ok =false;
129    }
130  }
131
132  suite.err() << "Testing OptionSwitch -vT...";
133  {
134    int ac = 2;
135    char* av[] = { "test_prog", "-vT"};
136    cmd.parse(ac,av);
137    if (target.present() && verbose.present())
138      suite.err() << "ok\n";
139    else {
140      suite.err() << "failed\n";
141      ok =false;
142    }
143  }
144  return ok;
145}
146
147
148bool test_arg(yat::test::Suite& suite)
149{
150  bool ok=true;
151  CommandLine cmd;
152  OptionArg<std::string> input(cmd, "i,input", "input file");
153  OptionArg<u_int> n(cmd, "n", "number of lines");
154
155  suite.err() << "Testing OptionArg existence -i file...";
156  {
157    int ac = 3;
158    char* av[] = { "test_prog", "-i", "file" };
159    cmd.parse(ac,av);
160    if (input.present())
161      suite.err() << "ok\n";
162    else {
163      suite.err() << "failed\n";
164      ok =false;
165    }
166  }
167
168  suite.err() << "Testing OptionArg value -i file...";
169  {
170    int ac = 3;
171    char* av[] = { "test_prog", "-i", "file" };
172    cmd.parse(ac,av);
173    if (input.value()=="file")
174      suite.err() << "ok\n";
175    else {
176      suite.err() << "failed\n";
177      ok =false;
178    }
179  }
180
181  suite.err() << "Testing OptionArg existence --input file...";
182  {
183    int ac = 3;
184    char* av[] = { "test_prog", "--input", "file" };
185    cmd.parse(ac,av);
186    if (input.present())
187      suite.err() << "ok\n";
188    else {
189      suite.err() << "failed\n";
190      ok =false;
191    }
192  }
193
194  suite.err() << "Testing OptionArg value --input=file...";
195  {
196    int ac = 2;
197    char* av[] = { "test_prog", "--input=file" };
198    cmd.parse(ac,av);
199    if (input.value()=="file")
200      suite.err() << "ok\n";
201    else {
202      suite.err() << "failed\n";
203      ok =false;
204    }
205  }
206
207  suite.err() << "Testing OptionArg value --input=\"file called something\"...";
208  {
209    int ac = 2;
210    char* av[] = { "test_prog", "--input=\"file called something\"" };
211    cmd.parse(ac,av);
212    if (input.value()=="file called something")
213      suite.err() << "ok\n";
214    else {
215      suite.err() << "failed\n";
216      suite.err() << "value is `" << input.value() << "'\n"
217            << "expected `file called something'\n";
218      ok =false;
219    }
220  }
221
222  suite.err() << "Testing OptionArg u_int value -n 3...";
223  {
224    int ac = 3;
225    char* av[] = { "test_prog", "-n", "3" };
226    cmd.parse(ac,av);
227    if (n.value()==3)
228      suite.err() << "ok\n";
229    else {
230      suite.err() << "failed\n";
231      ok =false;
232    }
233  }
234
235
236  suite.err() << "Testing OptionArg 2 value --input file -n 3...";
237  {
238    int ac = 5;
239    char* av[] = { "test_prog", "--input", "file", "-n", "3" };
240    cmd.parse(ac,av);
241    if (input.value()=="file")
242      suite.err() << "ok\n";
243    else {
244      suite.err() << "failed\n";
245      ok =false;
246    }
247  }
248
249
250  return ok;
251}
252
253bool test_failures(yat::test::Suite& suite)
254{
255  bool ok=true;
256  CommandLine cmd;
257  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
258  OptionArg<std::string> input(cmd, "i,input", "input file");
259  OptionArg<u_int> n(cmd, "n", "number of lines");
260
261  suite.err() << "Testing unknown option --peter...";
262  {
263    int ac = 2;
264    char* av[] = { "test_prog", "--peter"};
265    try{
266      cmd.parse(ac,av);
267      suite.err() << "failed\n";
268      ok =false;
269    }
270    catch (...) {
271      suite.err() << "ok\n";
272    }
273  }
274
275  suite.err() << "Testing unknown option -jvjhsgad...";
276  {
277    int ac = 2;
278    char* av[] = { "test_prog", "-vjhsgad"};
279    try{
280      cmd.parse(ac,av);
281      suite.err() << "failed\n";
282      ok =false;
283    }
284    catch (...) {
285      suite.err() << "ok\n";
286    }
287  }
288
289
290  suite.err() << "Testing invalid option -nv 3...";
291  {
292    int ac = 3;
293    char* av[] = { "test_prog", "-nv", "3"};
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 23.12 is not u_int...";
306  {
307    int ac = 3;
308    char* av[] = { "test_prog", "-n", "23.12"};
309    try{
310      cmd.parse(ac,av);
311      suite.err() << "failed\n";
312      ok =false;
313    }
314    catch (std::runtime_error& e) {
315      suite.err() << "ok\n";
316    }
317  }
318
319  suite.err() << "Testing -1 is not u_int...";
320  {
321    int ac = 3;
322    char* av[] = { "test_prog", "-n" "-1"};
323    try{
324      cmd.parse(ac,av);
325      suite.err() << "failed\n";
326      ok =false;
327    }
328    catch (...) {
329      suite.err() << "ok\n";
330    }
331  }
332
333
334  suite.err() << "Testing OptionArg required ...";
335  {
336    OptionArg<std::string> required(cmd, "required", "required", true); 
337    int ac = 1;
338    char* av[] = { "test_prog" };
339    try{
340      cmd.parse(ac,av);
341      suite.err() << "failed\n";
342      ok =false;
343    }
344    catch (...) {
345      suite.err() << "ok\n";
346    }
347  }
348
349
350  return ok;
351}
352
353
354bool test_file(yat::test::Suite& suite)
355{
356  bool ok=true;
357  CommandLine cmd;
358  OptionFile inclones(cmd, "clones", "file containing clones");
359  OptionFile indata(cmd, "data", "data to merge");
360  OptionFile out(cmd, "o,out", "data to merge", true, false, "w");
361  OptionSwitch help(cmd, "h,help", "display this help and exit");
362
363  suite.err() << "Testing OptionFile... ";
364  {
365    int ac = 2;
366    char* av[] = { "test_prog", "--clones", "commandline_test.cc" 
367                   "--data", "commandline_test.cc", "-o", 
368                   "commandline_test.cc"};
369    cmd.parse(ac,av);
370    suite.err() << "ok\n";
371  }
372  return ok;
373}
374
375
376
377
378
Note: See TracBrowser for help on using the repository browser.