1 /* 2 * StringParam_UT.java 3 * 4 * jcmdline Rel. @VERSION@ $Id: StringParam_UT.java,v 1.4 2009/08/06 14:31:35 lglawrence Exp $ 5 * 6 * Classes: 7 * public StringParam_UT 8 * 9 * ***** BEGIN LICENSE BLOCK ***** 10 * Version: MPL 1.1 11 * 12 * The contents of this file are subject to the Mozilla Public License Version 13 * 1.1 (the "License"); you may not use this file except in compliance with 14 * the License. You may obtain a copy of the License at 15 * http://www.mozilla.org/MPL/ 16 * 17 * Software distributed under the License is distributed on an "AS IS" basis, 18 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 19 * for the specific language governing rights and limitations under the 20 * License. 21 * 22 * The Original Code is the Java jcmdline (command line management) package. 23 * 24 * The Initial Developer of the Original Code is Lynne Lawrence. 25 * 26 * Portions created by the Initial Developer are Copyright (C) 2002 27 * the Initial Developer. All Rights Reserved. 28 * 29 * Contributor(s): Lynne Lawrence <lgl@visuallink.com> 30 * 31 * ***** END LICENSE BLOCK ***** 32 */ 33 34 package jcmdline; 35 36 import java.util.ArrayList; 37 import java.util.List; 38 39 /** 40 * Unit test code for StringParam 41 * 42 * @author Lynne Lawrence 43 * @version jcmdline Rel. @VERSION@ $Id: StringParam_UT.java,v 1.3 2005/02/06 44 * 23:41:14 lglawrence Exp $ 45 */ 46 public class StringParam_UT extends BetterTestCase { 47 48 private List<String> acceptVals; 49 private static final String desc = "this is the desc"; 50 private static final String tag = "mytag"; 51 52 /** 53 * @see junit.framework.TestCase#setUp() 54 */ 55 @Override setUp()56 protected void setUp() throws Exception { 57 super.setUp(); 58 acceptVals = new ArrayList<String>(); 59 acceptVals.add("value 1"); 60 acceptVals.add("value 2"); 61 } 62 63 /** 64 * constructor takes name of test method 65 * 66 * @param name 67 * The name of the test method to be run. 68 */ StringParam_UT(String name)69 public StringParam_UT(String name) { 70 super(name); 71 } 72 73 /** 74 * Runs all tests using junit.textui.TestRunner 75 */ main(String[] args)76 public static void main(String[] args) { 77 doMain(args, StringParam_UT.class); 78 } 79 80 /** 81 * Test a StringParam with acceptableValues 82 */ testAcceptableValues()83 public void testAcceptableValues() throws CmdLineException { 84 debug("Starting testAcceptableValues()"); 85 StringParam sp = new StringParam("myTag", "myDesc", new String[] { 86 "val1", "val2" }, StringParam.OPTIONAL, 87 StringParam.MULTI_VALUED); 88 sp.addValue("val1"); 89 sp.addValue("val2"); 90 try { 91 sp.addValue(""); 92 fail("addValue(\"\") did not fail"); 93 } catch (CmdLineException e) { 94 } 95 try { 96 sp.addValue("val3"); 97 fail("addValue(\"val3\") did not fail"); 98 } catch (CmdLineException e) { 99 debug("Bad value error message: " + e.getMessage()); 100 } 101 List<String> vals = sp.getValues(); 102 assertEquals("StringParam contains wrong # of values", 2, vals.size()); 103 } 104 105 /** 106 * Test ctor w/params tag, desc 107 */ testCtor1()108 public void testCtor1() { 109 StringParam sp = new StringParam(tag, desc); 110 assertEquals("tag set wrong", tag, sp.getTag()); 111 assertEquals("desc set wrong", desc, sp.getDesc()); 112 assertTrue("optional flag not set true by default", sp.isOptional()); 113 assertTrue("multiValued flag not set false by default", !sp 114 .isMultiValued()); 115 assertTrue("hidden flag not set false by default", !sp.isHidden()); 116 } 117 118 /** 119 * Test ctor w/params tag, desc, acceptableValues, optional, multiValued, 120 * hidden 121 */ testCtor10()122 public void testCtor10() { 123 StringParam sp = new StringParam(tag, desc, acceptVals.toArray(new String[] {}), 124 StringParam.OPTIONAL, StringParam.MULTI_VALUED, 125 StringParam.HIDDEN); 126 assertEquals("tag set wrong", tag, sp.getTag()); 127 assertEquals("desc set wrong", desc, sp.getDesc()); 128 assertTrue("optional flag not set to true", sp.isOptional()); 129 assertTrue("multiValued flag not set to true", sp.isMultiValued()); 130 assertTrue("hidden flag not set to true", sp.isHidden()); 131 assertEquals("acceptableValues set wrong", acceptVals, sp 132 .getAcceptableValues()); 133 134 sp = new StringParam(tag, desc, acceptVals.toArray(new String[] {}), StringParam.REQUIRED, 135 StringParam.SINGLE_VALUED, StringParam.PUBLIC); 136 assertTrue("optional flag not set to false", !sp.isOptional()); 137 assertTrue("multiValued flag not set to false", !sp.isMultiValued()); 138 assertTrue("hidden flag not set to false", !sp.isHidden()); 139 } 140 141 /** 142 * Test ctor w/params tag, desc, optional 143 */ testCtor2()144 public void testCtor2() { 145 StringParam sp = new StringParam(tag, desc, StringParam.OPTIONAL); 146 assertEquals("tag set wrong", tag, sp.getTag()); 147 assertEquals("desc set wrong", desc, sp.getDesc()); 148 assertTrue("multiValued flag not set false by default", !sp 149 .isMultiValued()); 150 assertTrue("hidden flag not set false by default", !sp.isHidden()); 151 assertTrue("optional flag not set to true", sp.isOptional()); 152 153 sp = new StringParam(tag, desc, StringParam.REQUIRED); 154 assertTrue("optional flag not set to false", !sp.isOptional()); 155 } 156 157 /** 158 * Test ctor w/params tag, desc, minValLen, maxValLen 159 */ testCtor3()160 public void testCtor3() { 161 int min = 1; 162 int max = 100; 163 StringParam sp = new StringParam(tag, desc, min, max); 164 assertEquals("tag set wrong", tag, sp.getTag()); 165 assertEquals("desc set wrong", desc, sp.getDesc()); 166 assertEquals("minValLen set wrong", min, sp.getMinValLen()); 167 assertEquals("maxValLen set wrong", max, sp.getMaxValLen()); 168 assertTrue("optional flag not set true by default", sp.isOptional()); 169 assertTrue("multiValued flag not set false by default", !sp 170 .isMultiValued()); 171 assertTrue("hidden flag not set false by default", !sp.isHidden()); 172 } 173 174 /** 175 * Test ctor w/params tag, desc, minValLen, maxValLen, optional 176 */ testCtor4()177 public void testCtor4() { 178 int min = 1; 179 int max = 100; 180 StringParam sp = new StringParam(tag, desc, min, max, 181 StringParam.OPTIONAL); 182 assertEquals("tag set wrong", tag, sp.getTag()); 183 assertEquals("desc not set to true", desc, sp.getDesc()); 184 assertTrue("optional flag set wrong", sp.isOptional()); 185 assertEquals("minValLen set wrong", min, sp.getMinValLen()); 186 assertEquals("maxValLen set wrong", max, sp.getMaxValLen()); 187 assertTrue("multiValued flag not set false by default", !sp 188 .isMultiValued()); 189 assertTrue("hidden flag not set false by default", !sp.isHidden()); 190 191 sp = new StringParam(tag, desc, min, max, StringParam.REQUIRED); 192 assertTrue("optional flag not set to false", !sp.isOptional()); 193 } 194 195 /** 196 * Test ctor w/params tag, desc, minValLen, maxValLen, optional, and 197 * multi-valued 198 */ testCtor5()199 public void testCtor5() { 200 int min = 1; 201 int max = 100; 202 StringParam sp = new StringParam(tag, desc, min, max, 203 StringParam.OPTIONAL, StringParam.MULTI_VALUED); 204 assertEquals("tag set wrong", tag, sp.getTag()); 205 assertEquals("desc set wrong", desc, sp.getDesc()); 206 assertTrue("optional flag not set to true", sp.isOptional()); 207 assertTrue("multiValued flag not set to true", sp.isMultiValued()); 208 assertEquals("minValLen set wrong", min, sp.getMinValLen()); 209 assertEquals("maxValLen set wrong", max, sp.getMaxValLen()); 210 assertTrue("hidden flag not set false by default", !sp.isHidden()); 211 212 sp = new StringParam(tag, desc, min, max, StringParam.REQUIRED, 213 StringParam.SINGLE_VALUED); 214 assertTrue("optional flag not set to false", !sp.isOptional()); 215 assertTrue("multiValued flag not set to false", !sp.isMultiValued()); 216 } 217 218 /** 219 * Test ctor w/params tag, desc, minValLen, maxValLen, optional multiValued, 220 * and hidden 221 */ testCtor6()222 public void testCtor6() { 223 int min = 1; 224 int max = 100; 225 StringParam sp = new StringParam(tag, desc, min, max, 226 StringParam.OPTIONAL, StringParam.MULTI_VALUED, 227 StringParam.HIDDEN); 228 assertEquals("tag set wrong", tag, sp.getTag()); 229 assertEquals("desc set wrong", desc, sp.getDesc()); 230 assertTrue("optional flag not set to true", sp.isOptional()); 231 assertTrue("multiValued flag not set to true", sp.isMultiValued()); 232 assertTrue("hidden flag not set to true", sp.isHidden()); 233 assertEquals("minValLen set wrong", min, sp.getMinValLen()); 234 assertEquals("maxValLen set wrong", max, sp.getMaxValLen()); 235 236 sp = new StringParam(tag, desc, min, max, StringParam.REQUIRED, 237 StringParam.SINGLE_VALUED, StringParam.PUBLIC); 238 assertTrue("optional flag not set to false", !sp.isOptional()); 239 assertTrue("multiValued flag not set to false", !sp.isMultiValued()); 240 assertTrue("hidden flag not set to false", !sp.isHidden()); 241 } 242 243 /** 244 * Test ctor w/params tag, desc, acceptableValues 245 */ testCtor7()246 public void testCtor7() { 247 StringParam sp = new StringParam(tag, desc, acceptVals.toArray(new String[] {})); 248 assertEquals("tag set wrong", tag, sp.getTag()); 249 assertEquals("desc set wrong", desc, sp.getDesc()); 250 assertEquals("acceptableValues set wrong", acceptVals, sp 251 .getAcceptableValues()); 252 assertTrue("optional flag not set true by default", sp.isOptional()); 253 assertTrue("multiValued flag not set false by default", !sp 254 .isMultiValued()); 255 assertTrue("hidden flag not set false by default", !sp.isHidden()); 256 } 257 258 /** 259 * Test ctor w/params tag, desc, acceptableValues, optional 260 */ testCtor8()261 public void testCtor8() { 262 StringParam sp = new StringParam(tag, desc, acceptVals.toArray(new String[] {}), 263 StringParam.OPTIONAL); 264 assertEquals("tag set wrong", tag, sp.getTag()); 265 assertEquals("desc set wrong", desc, sp.getDesc()); 266 assertTrue("optional flag not set to true", sp.isOptional()); 267 assertEquals("acceptableValues set wrong", acceptVals, sp 268 .getAcceptableValues()); 269 assertTrue("multiValued flag not set false by default", !sp 270 .isMultiValued()); 271 assertTrue("hidden flag not set false by default", !sp.isHidden()); 272 273 sp = new StringParam(tag, desc, acceptVals.toArray(new String[] {}), StringParam.REQUIRED); 274 assertTrue("optional flag not set to false", !sp.isOptional()); 275 } 276 277 /** 278 * Test ctor w/params tag, desc, acceptableValues, optional, multiValued 279 */ testCtor9()280 public void testCtor9() { 281 StringParam sp = new StringParam(tag, desc, acceptVals.toArray(new String[] {}), 282 StringParam.OPTIONAL, StringParam.MULTI_VALUED); 283 assertEquals("tag set wrong", tag, sp.getTag()); 284 assertEquals("desc set wrong", desc, sp.getDesc()); 285 assertTrue("optional flag not set to true", sp.isOptional()); 286 assertTrue("multiValued flag not set to true", sp.isMultiValued()); 287 assertEquals("acceptableValues set wrong", acceptVals, sp 288 .getAcceptableValues()); 289 assertTrue("hidden flag not set false by default", !sp.isHidden()); 290 291 sp = new StringParam(tag, desc, acceptVals.toArray(new String[] {}), StringParam.REQUIRED, 292 StringParam.SINGLE_VALUED); 293 assertTrue("optional flag not set to false", !sp.isOptional()); 294 assertTrue("multiValued flag not set to false", !sp.isMultiValued()); 295 } 296 297 /** 298 * Test a StringParam with specified value length more than maxValLen 299 */ testMaxLength()300 public void testMaxLength() { 301 StringParam sp = new StringParam("mytag", "mydesc", 2, 10, 302 StringParam.OPTIONAL, StringParam.MULTI_VALUED); 303 try { 304 sp.addValue("12345678901"); 305 fail("addValue() did not fail with string of length > max"); 306 } catch (CmdLineException e) { 307 checkForMissingString(e.getMessage()); 308 } 309 } 310 311 /** 312 * Test a StringParam with specified value length less than minValLen 313 */ testMinLength()314 public void testMinLength() { 315 StringParam sp = new StringParam("mytag", "mydesc", 2, 10, 316 StringParam.OPTIONAL, StringParam.MULTI_VALUED); 317 try { 318 sp.addValue("1"); 319 fail("addValue() did not fail with string of length < min"); 320 } catch (CmdLineException e) { 321 checkForMissingString(e.getMessage()); 322 } 323 } 324 325 /** 326 * Test a StringParam with min/max values set and specified values in range 327 */ testMinMaxLength()328 public void testMinMaxLength() throws CmdLineException { 329 StringParam sp = new StringParam("mytag", "mydesc", 2, 10, 330 StringParam.OPTIONAL, StringParam.MULTI_VALUED); 331 sp.addValue("12"); 332 sp.addValue("1234567890"); 333 } 334 335 /** 336 * Test testMinMaxUnspec() - tests that getMinValLen() and getMaxVlLen() 337 * return 0 and StringParam.UNSPECIFIED_LENGTH, respectively, if they had 338 * not been set. 339 */ testMinMaxUnspec()340 public void testMinMaxUnspec() { 341 StringParam sp = new StringParam("mytag", "mydesc"); 342 assertEquals("getMinValLen() did not return 0 when not set", 0, sp 343 .getMinValLen()); 344 assertEquals( 345 "getMaxValLen() did not return UNSPECIFIED_LENGTH when not set", 346 StringParam.UNSPECIFIED_LENGTH, sp.getMaxValLen()); 347 } 348 349 /** 350 * Tests that a multivalued StringParam contains the correct values 351 */ testMultiValued()352 public void testMultiValued() throws CmdLineException { 353 StringParam sp = new StringParam("mytag", "mydesc", 1, -1, 354 StringParam.OPTIONAL, StringParam.MULTI_VALUED); 355 String s1 = "value 1"; 356 String s2 = "value 2"; 357 sp.addValue(s1); 358 sp.addValue(s2); 359 List<String> vals = sp.getValues(); 360 assertEquals("Multi-valued StringParam contains wrong # of values", 2, 361 vals.size()); 362 assertEquals("First value is not correct", s1, vals.get(0)); 363 assertEquals("Second value is not correct", s2, vals.get(1)); 364 } 365 366 /** 367 * Test setMaxValLen(). Tests that: 368 * <ul> 369 * <li>getMinValLen() returns the correct value after setMaxValLen().</li> 370 * <li>setMaxValLen() works when max value set same as min.</li> 371 * <li>setMaxValLen() throws an IllegalArgumentException when value set less 372 * than min.</li> 373 * <li>setMaxValLen() throws an IllegalArgumentException when value is 374 * negative.</li> 375 * </ul> 376 */ testSetMaxValLen()377 public void testSetMaxValLen() { 378 StringParam sp = new StringParam("mytag", "mydesc", 2, 10, 379 StringParam.OPTIONAL, StringParam.MULTI_VALUED); 380 sp.setMaxValLen(5); 381 assertEquals("Max value not set correctly after call", 5, sp 382 .getMaxValLen()); 383 sp.setMaxValLen(2); 384 assertEquals("Max value not set correctly when set same as min", 2, sp 385 .getMaxValLen()); 386 try { 387 sp.setMaxValLen(1); 388 fail("setMaxValLen() did not fail with val < min"); 389 } catch (IllegalArgumentException e) { 390 checkForMissingString(e.getMessage()); 391 } 392 try { 393 sp.setMaxValLen(-1); 394 fail("setMaxValLen() did not fail with val = -1"); 395 } catch (IllegalArgumentException e) { 396 checkForMissingString(e.getMessage()); 397 } 398 } 399 400 /** 401 * Test setMinValLen(). Tests that: 402 * <ul> 403 * <li>getMinValLen() returns the correct value after setMinValLen().</li> 404 * <li>setMinValLen() works when min value set same as max.</li> 405 * <li>setMinValLen() throws an IllegalArgumentException when value set 406 * greater than max.</li> 407 * <li>setMinValLen() throws an IllegalArgumentException when value is 408 * negative.</li> 409 * </ul> 410 */ testSetMinValLen()411 public void testSetMinValLen() { 412 StringParam sp = new StringParam("mytag", "mydesc", 2, 10, 413 StringParam.OPTIONAL, StringParam.MULTI_VALUED); 414 sp.setMinValLen(5); 415 assertEquals("Min value not set correctly after call", 5, sp 416 .getMinValLen()); 417 sp.setMinValLen(10); 418 assertEquals("Min value not set correctly when set same as max", 10, sp 419 .getMinValLen()); 420 try { 421 sp.setMinValLen(11); 422 fail("setMinValLen() did not fail with val > max"); 423 } catch (IllegalArgumentException e) { 424 checkForMissingString(e.getMessage()); 425 } 426 try { 427 sp.setMinValLen(-1); 428 fail("setMinValLen() did not fail with val = -1"); 429 } catch (IllegalArgumentException e) { 430 checkForMissingString(e.getMessage()); 431 } 432 } 433 } 434