PageRenderTime 38ms CodeModel.GetById 10ms RepoModel.GetById 0ms app.codeStats 0ms

/test/Getopt_Test.php

http://github.com/ethna/ethna
PHP | 428 lines | 319 code | 60 blank | 49 comment | 0 complexity | 2450748a69004f7a21f84618f48b71cb MD5 | raw file
Possible License(s): BSD-3-Clause
  1. <?php
  2. // vim: foldmethod=marker
  3. /**
  4. * Getopt_Test.php
  5. *
  6. * @author Yoshinari Takaoka <takaoka@beatcraft.com>
  7. * @version $Id: 4e7f3bd66b9615955c30d58ddd902810326c706d $
  8. */
  9. require_once ETHNA_BASE . '/class/Getopt.php';
  10. /**
  11. * Test Case For Ethna_Getopt
  12. *
  13. * @access public
  14. */
  15. class Ethna_Getopt_Test extends Ethna_UnitTestBase
  16. {
  17. var $opt;
  18. function setUp()
  19. {
  20. $this->opt = new Ethna_Getopt();
  21. }
  22. // {{{ readPHPArgv
  23. function test_readPHPArgv()
  24. {
  25. global $argv;
  26. $argv = array('test.php', 'a', '-b=c', '--c=d', 'e');
  27. $r = $this->opt->readPHPArgv();
  28. $this->assertEqual('test.php', $argv[0]);
  29. $this->assertEqual('a', $argv[1]);
  30. $this->assertEqual('-b=c', $argv[2]);
  31. $this->assertEqual('--c=d', $argv[3]);
  32. $this->assertEqual('e', $argv[4]);
  33. }
  34. // }}}
  35. //{{{ short option test
  36. function test_shortopt_required()
  37. {
  38. // no args
  39. $args = array();
  40. $shortopt = 'a:';
  41. $r = $this->opt->getopt($args, $shortopt);
  42. $this->assertFalse(Ethna::isError($r));
  43. // option -a is defined, but no args.
  44. $args = array('-a');
  45. $shortopt = 'a:';
  46. $r = $this->opt->getopt($args, $shortopt);
  47. $this->assertTrue(Ethna::isError($r));
  48. $this->assertEqual('option -a requires an argument', $r->getMessage());
  49. // unknown option
  50. $args = array('-c'); // -c is unknown.
  51. $shortopt = 'a:';
  52. $r = $this->opt->getopt($args, $shortopt);
  53. $this->assertTrue(Ethna::isError($r));
  54. $this->assertEqual('unrecognized option -c', $r->getMessage());
  55. // unknown option part 2.
  56. $args = array('--foo'); // -foo is unknown.
  57. $shortopt = 'a:';
  58. $r = $this->opt->getopt($args, $shortopt);
  59. $this->assertTrue(Ethna::isError($r));
  60. $this->assertEqual('unrecognized option --foo', $r->getMessage());
  61. // -a option value is b. c is nonparsed.
  62. $args = array('-a', 'b', 'c');
  63. $shortopt = 'a:';
  64. $r = $this->opt->getopt($args, $shortopt);
  65. $this->assertFalse(Ethna::isError($r));
  66. $parsed_arg = array_shift($r);
  67. $this->assertEqual('a', $parsed_arg[0][0]);
  68. $this->assertEqual('b', $parsed_arg[0][1]);
  69. $nonparsed_arg = array_shift($r);
  70. $this->assertEqual('c', $nonparsed_arg[0]);
  71. // -a value is bcd, e is nonparsed.
  72. $args = array('-abcd', 'e');
  73. $shortopt = 'a:';
  74. $r = $this->opt->getopt($args, $shortopt);
  75. $this->assertFalse(Ethna::isError($r));
  76. $parsed_arg = array_shift($r);
  77. $this->assertEqual('a', $parsed_arg[0][0]);
  78. $this->assertEqual('bcd', $parsed_arg[0][1]);
  79. $nonparsed_arg = array_shift($r);
  80. $this->assertEqual('e', $nonparsed_arg[0]);
  81. }
  82. function test_shortopt_optional()
  83. {
  84. // no args
  85. $args = array();
  86. $shortopt = 'a::';
  87. $r = $this->opt->getopt($args, $shortopt);
  88. $this->assertFalse(Ethna::isError($r));
  89. // option -a is defined, but no args.
  90. $args = array('-a');
  91. $shortopt = 'a::';
  92. $r = $this->opt->getopt($args, $shortopt);
  93. $this->assertFalse(Ethna::isError($r));
  94. // -a value is bcd, e is nonparsed arg.
  95. $args = array('-abcd', 'e');
  96. $shortopt = 'a::';
  97. $r = $this->opt->getopt($args, $shortopt);
  98. $this->assertFalse(Ethna::isError($r));
  99. $parsed_arg = array_shift($r);
  100. $this->assertEqual('a', $parsed_arg[0][0]);
  101. $this->assertEqual('bcd', $parsed_arg[0][1]);
  102. $nonparsed_arg = array_shift($r);
  103. $this->assertEqual('e', $nonparsed_arg[0]);
  104. // -a option value is none. b, c is nonparsed.
  105. $args = array('-a', 'b', 'c');
  106. $shortopt = 'a::';
  107. $r = $this->opt->getopt($args, $shortopt);
  108. $this->assertFalse(Ethna::isError($r));
  109. $parsed_arg = array_shift($r);
  110. $this->assertEqual('a', $parsed_arg[0][0]);
  111. $this->assertNULL($parsed_arg[0][1]);
  112. $nonparsed_arg = array_shift($r);
  113. $this->assertEqual('b', $nonparsed_arg[0]);
  114. $this->assertEqual('c', $nonparsed_arg[1]);
  115. }
  116. function test_shortopt_disabled()
  117. {
  118. // no args
  119. $args = array();
  120. $shortopt = 'a';
  121. $r = $this->opt->getopt($args, $shortopt);
  122. $this->assertFalse(Ethna::isError($r));
  123. // option -a is defined, but no args.
  124. $args = array('-a');
  125. $shortopt = 'a';
  126. $r = $this->opt->getopt($args, $shortopt);
  127. $this->assertFalse(Ethna::isError($r));
  128. $parsed_arg = array_shift($r);
  129. $this->assertEqual('a', $parsed_arg[0][0]);
  130. $this->assertNULL($parsed_arg[0][1]);
  131. // option -a is defined, but value is disabled.
  132. // value will be NEVER interpreted.
  133. $args = array('-a', 'b', 'c');
  134. $shortopt = 'a';
  135. $r = $this->opt->getopt($args, $shortopt);
  136. $this->assertFalse(Ethna::isError($r));
  137. $parsed_arg = array_shift($r);
  138. $this->assertEqual('a', $parsed_arg[0][0]);
  139. $this->assertNULL($parsed_arg[0][1]);
  140. $nonparsed_arg = array_shift($r);
  141. $this->assertEqual('b', $nonparsed_arg[0]);
  142. $this->assertEqual('c', $nonparsed_arg[1]);
  143. // successive option definition, but unrecognized option. :)
  144. $args = array('-ab');
  145. $shortopt = 'a';
  146. $r = $this->opt->getopt($args, $shortopt);
  147. $this->assertTrue(Ethna::isError($r));
  148. $this->assertEqual("unrecognized option -b", $r->getMessage());
  149. // option setting will be refrected even when after values. :)
  150. $args = array('-a', 'b', '-c', 'd', '-e', 'f');
  151. $shortopt = 'ac:e::';
  152. $r = $this->opt->getopt($args, $shortopt);
  153. $this->assertFalse(Ethna::isError($r));
  154. $parsed_arg = array_shift($r);
  155. $this->assertEqual('a', $parsed_arg[0][0]);
  156. $this->assertNULL($parsed_arg[0][1]);
  157. $nonparsed_arg = array_shift($r);
  158. $this->assertEqual('b', $nonparsed_arg[0]);
  159. $this->assertEqual('-c', $nonparsed_arg[1]);
  160. $this->assertEqual('d', $nonparsed_arg[2]);
  161. $this->assertEqual('-e', $nonparsed_arg[3]);
  162. $this->assertEqual('f', $nonparsed_arg[4]);
  163. }
  164. function test_shortopt_complex()
  165. {
  166. // complex option part 1.
  167. $args = array();
  168. $shortopt = 'ab:c::';
  169. $args = array('-abcd', '-cd');
  170. $r = $this->opt->getopt($args, $shortopt);
  171. $this->assertFalse(Ethna::isError($r));
  172. $parsed_arg = array_shift($r);
  173. $this->assertEqual('a', $parsed_arg[0][0]);
  174. $this->assertNULL($parsed_arg[0][1]);
  175. $this->assertEqual('b', $parsed_arg[1][0]);
  176. $this->assertEqual('cd', $parsed_arg[1][1]);
  177. $this->assertEqual('c', $parsed_arg[2][0]);
  178. $this->assertEqual('d', $parsed_arg[2][1]);
  179. // complex option part 2.
  180. $args = array('-a', '-c', 'd', 'e');
  181. $r = $this->opt->getopt($args, $shortopt);
  182. $this->assertFalse(Ethna::isError($r));
  183. $parsed_arg = array_shift($r);
  184. $this->assertEqual('a', $parsed_arg[0][0]);
  185. $this->assertNULL($parsed_arg[0][1]);
  186. $this->assertEqual('c', $parsed_arg[1][0]);
  187. $this->assertNULL($parsed_arg[1][1]);
  188. $nonparsed_arg = array_shift($r);
  189. $this->assertEqual('d', $nonparsed_arg[0]);
  190. $this->assertEqual('e', $nonparsed_arg[1]);
  191. $args = array('-cd', '-ad');
  192. $r = $this->opt->getopt($args, $shortopt);
  193. $this->assertTrue(Ethna::isError($r));
  194. $this->assertEqual("unrecognized option -d", $r->getMessage());
  195. }
  196. // }}}
  197. // {{{ long option test
  198. function test_longopt_required()
  199. {
  200. // no args
  201. $args = array();
  202. $shortopt = NULL;
  203. $longopt = array("foo=");
  204. $r = $this->opt->getopt($args, $shortopt, $longopt);
  205. $this->assertFalse(Ethna::isError($r));
  206. // option -a is defined, but no args.
  207. $args = array('--foo');
  208. $shortopt = NULL;
  209. $longopt = array("foo=");
  210. $r = $this->opt->getopt($args, $shortopt, $longopt);
  211. $this->assertTrue(Ethna::isError($r));
  212. $this->assertEqual('option --foo requires an argument', $r->getMessage());
  213. // unknown option.
  214. $args = array('--bar'); // -bar is unknown.
  215. $shortopt = NULL;
  216. $longopt = array("foo=");
  217. $r = $this->opt->getopt($args, $shortopt);
  218. $this->assertTrue(Ethna::isError($r));
  219. $this->assertEqual('unrecognized option --bar', $r->getMessage());
  220. // unknown option part 1.
  221. $args = array('--bar'); // -bar is unknown.
  222. $shortopt = NULL;
  223. $longopt = array("foo=");
  224. $r = $this->opt->getopt($args, $shortopt);
  225. $this->assertTrue(Ethna::isError($r));
  226. $this->assertEqual('unrecognized option --bar', $r->getMessage());
  227. // unknown option part 2.
  228. $args = array('-a'); // -a is unknown.
  229. $shortopt = NULL;
  230. $longopt = array("foo=");
  231. $r = $this->opt->getopt($args, $shortopt);
  232. $this->assertTrue(Ethna::isError($r));
  233. $this->assertEqual('unrecognized option -a', $r->getMessage());
  234. // --foo option value is bar. hoge is nonparsed.
  235. $args = array('--foo=bar', 'hoge');
  236. $shortopt = NULL;
  237. $longopt = array("foo=");
  238. $r = $this->opt->getopt($args, $shortopt, $longopt);
  239. $this->assertFalse(Ethna::isError($r));
  240. $parsed_arg = array_shift($r);
  241. $this->assertEqual('--foo', $parsed_arg[0][0]);
  242. $this->assertEqual('bar', $parsed_arg[0][1]);
  243. $nonparsed_arg = array_shift($r);
  244. $this->assertEqual('hoge', $nonparsed_arg[0]);
  245. // --foo option value is bar. hoge, -fuga is nonparsed.
  246. $args = array('--foo', 'bar', 'hoge', '-fuga');
  247. $shortopt = NULL;
  248. $longopt = array("foo=");
  249. $r = $this->opt->getopt($args, $shortopt, $longopt);
  250. $this->assertFalse(Ethna::isError($r));
  251. $parsed_arg = array_shift($r);
  252. $this->assertEqual('--foo', $parsed_arg[0][0]);
  253. $this->assertEqual('bar', $parsed_arg[0][1]);
  254. $nonparsed_arg = array_shift($r);
  255. $this->assertEqual('hoge', $nonparsed_arg[0]);
  256. $this->assertEqual('-fuga', $nonparsed_arg[1]);
  257. }
  258. function test_longopt_optional()
  259. {
  260. // no args
  261. $args = array();
  262. $shortopt = NULL;
  263. $longopt = array("foo==");
  264. $r = $this->opt->getopt($args, $shortopt, $longopt);
  265. $this->assertFalse(Ethna::isError($r));
  266. // option --foo is defined, but no args.
  267. $args = array('--foo');
  268. $shortopt = NULL;
  269. $longopt = array("foo==");
  270. $r = $this->opt->getopt($args, $shortopt, $longopt);
  271. $this->assertFalse(Ethna::isError($r));
  272. // -foo value is bar, hoge is nonparsed arg.
  273. $args = array('--foo', 'bar', 'hoge');
  274. $shortopt = NULL;
  275. $longopt = array("foo==");
  276. $r = $this->opt->getopt($args, $shortopt, $longopt);
  277. $this->assertFalse(Ethna::isError($r));
  278. $parsed_arg = array_shift($r);
  279. $this->assertEqual('--foo', $parsed_arg[0][0]);
  280. $this->assertNULL($parsed_arg[0][1]);
  281. $nonparsed_arg = array_shift($r);
  282. $this->assertEqual('bar', $nonparsed_arg[0]);
  283. $this->assertEqual('hoge', $nonparsed_arg[1]);
  284. // -foo value is bar, hoge, moge is nonparsed arg.
  285. $args = array('--foo=bar', 'hoge', 'moge');
  286. $shortopt = NULL;
  287. $longopt = array("foo==");
  288. $r = $this->opt->getopt($args, $shortopt, $longopt);
  289. $this->assertFalse(Ethna::isError($r));
  290. $parsed_arg = array_shift($r);
  291. $this->assertEqual('--foo', $parsed_arg[0][0]);
  292. $this->assertEqual('bar', $parsed_arg[0][1]);
  293. $nonparsed_arg = array_shift($r);
  294. $this->assertEqual('hoge', $nonparsed_arg[0]);
  295. $this->assertEqual('moge', $nonparsed_arg[1]);
  296. }
  297. function test_longopt_disabled()
  298. {
  299. // no args
  300. $args = array();
  301. $shortopt = NULL;
  302. $longopt = array("foo");
  303. $r = $this->opt->getopt($args, $shortopt, $longopt);
  304. $this->assertFalse(Ethna::isError($r));
  305. // option -foo is defined, but no args.
  306. $args = array('--foo');
  307. $shortopt = null;
  308. $longopt = array("foo");
  309. $r = $this->opt->getopt($args, $shortopt, $longopt);
  310. $this->assertfalse(Ethna::isError($r));
  311. $parsed_arg = array_shift($r);
  312. $this->assertequal('--foo', $parsed_arg[0][0]);
  313. $this->assertnull($parsed_arg[0][1]);
  314. // option -foo is defined, but value is disabled.
  315. $args = array('--foo=bar');
  316. $shortopt = null;
  317. $longopt = array("foo");
  318. $r = $this->opt->getopt($args, $shortopt, $longopt);
  319. $this->assertTrue(Ethna::isError($r));
  320. $this->assertEqual("option --foo doesn't allow an argument", $r->getMessage());
  321. $args = array('--foo', 'hoge', 'bar');
  322. $shortopt = null;
  323. $longopt = array("foo");
  324. $r = $this->opt->getopt($args, $shortopt, $longopt);
  325. $this->assertFalse(Ethna::isError($r));
  326. $parsed_arg = array_shift($r);
  327. $this->assertequal('--foo', $parsed_arg[0][0]);
  328. $this->assertNull($parsed_arg[0][1]);
  329. $nonparsed_arg = array_shift($r);
  330. $this->assertEqual('hoge', $nonparsed_arg[0]);
  331. $this->assertEqual('bar', $nonparsed_arg[1]);
  332. }
  333. // }}}
  334. // {{{ short option, long option mixed.
  335. function test_mixed_option()
  336. {
  337. // no args
  338. $shortopt = 'ab:c::';
  339. $longopt = array('foo=', 'bar==', 'hoge');
  340. $args = array();
  341. $r = $this->opt->getopt($args, $shortopt, $longopt);
  342. $this->assertFalse(Ethna::isError($r));
  343. $args = array('-a', '--foo', 'bar', '--bar=moge', 'hoge', '--hoge');
  344. $r = $this->opt->getopt($args, $shortopt, $longopt);
  345. $this->assertFalse(Ethna::isError($r));
  346. $parsed_arg = array_shift($r);
  347. $this->assertequal('a', $parsed_arg[0][0]);
  348. $this->assertNull($parsed_arg[0][1]);
  349. $this->assertequal('--foo', $parsed_arg[1][0]);
  350. $this->assertEqual('bar', $parsed_arg[1][1]);
  351. $this->assertequal('--bar', $parsed_arg[2][0]);
  352. $this->assertEqual('moge', $parsed_arg[2][1]);
  353. $nonparsed_arg = array_shift($r);
  354. $this->assertEqual('hoge', $nonparsed_arg[0]);
  355. $this->assertEqual('--hoge', $nonparsed_arg[1]);
  356. }
  357. // }}}
  358. }