Clover coverage report - JFCUnit Test Coverage
Coverage timestamp: Mon Dec 20 2004 23:38:10 MST
file stats: LOC: 415   Methods: 27
NCLOC: 267   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
OperatorT.java - 100% 100% 100%
coverage
 1   
 package junit.extensions.jfcunit.tools;
 2   
 
 3   
 import junit.framework.TestCase;
 4   
 
 5   
 /**
 6   
  * <p>Title: test the class Opeartor.</p>
 7   
  * <p>Description: </p>
 8   
  * <p>Copyright: Copyright (c) 2003</p>
 9   
  * <p>Company: </p>
 10   
  * @author Kevin Wilson not attributable
 11   
  * @version 1.0
 12   
  */
 13   
 
 14   
 public class OperatorT
 15   
     extends TestCase {
 16   
 
 17   
 
 18   
   /**
 19   
    * Setup the test.
 20   
    * @throws Exception may be thrown.
 21   
    */
 22  25
   protected void setUp() throws Exception {
 23  25
     super.setUp();
 24   
   }
 25   
 
 26   
   /**
 27   
    * Tear down the test.
 28   
    * @throws Exception may be thrown.
 29   
    */
 30  25
   protected void tearDown() throws Exception {
 31  25
     super.tearDown();
 32   
   }
 33   
 
 34   
   /**
 35   
    * Test equals true.
 36   
    */
 37  1
   public void testEvaluateEqualsString() {
 38  1
     String leftside = "ABC";
 39  1
     String rightside = "ABC";
 40  1
     int operation = Operator.Operation.EQUALS;
 41   
 
 42  1
     boolean ignoreCase = false;
 43  1
     boolean expectedReturn = true;
 44  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 45   
                                              ignoreCase);
 46  1
     assertEquals("return value", expectedReturn, actualReturn);
 47   
   }
 48   
 
 49   
   /**
 50   
    * Test equals ignore case.
 51   
    */
 52  1
   public void testEvaluateEqualsString2() {
 53  1
     String leftside = "ABC";
 54  1
     String rightside = "abc";
 55  1
     int operation = Operator.Operation.EQUALS;
 56   
 
 57  1
     boolean ignoreCase = true;
 58  1
     boolean expectedReturn = true;
 59  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 60   
                                              ignoreCase);
 61  1
     assertEquals("return value", expectedReturn, actualReturn);
 62   
   }
 63   
 
 64   
   /**
 65   
    * Test equals false.
 66   
    */
 67  1
   public void testEvaluateEqualsString3() {
 68  1
     String leftside = "ABC";
 69  1
     String rightside = "abc";
 70  1
     int operation = Operator.Operation.EQUALS;
 71   
 
 72  1
     boolean ignoreCase = false;
 73  1
     boolean expectedReturn = false;
 74  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 75   
                                              ignoreCase);
 76  1
     assertEquals("return value", expectedReturn, actualReturn);
 77   
   }
 78   
 
 79   
   /**
 80   
    * Test equals ignore case false.
 81   
    */
 82  1
   public void testEvaluateEqualsString4() {
 83  1
     String leftside = "ABC";
 84  1
     String rightside = "abd";
 85  1
     int operation = Operator.Operation.EQUALS;
 86   
 
 87  1
     boolean ignoreCase = true;
 88  1
     boolean expectedReturn = false;
 89  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 90   
                                              ignoreCase);
 91  1
     assertEquals("return value", expectedReturn, actualReturn);
 92   
   }
 93   
 
 94   
   /**
 95   
    * Test startswith true.
 96   
    */
 97  1
   public void testEvaluateStartsString() {
 98  1
     String leftside = "ABC";
 99  1
     String rightside = "AB";
 100  1
     int operation = Operator.Operation.STARTSWITH;
 101   
 
 102  1
     boolean ignoreCase = false;
 103  1
     boolean expectedReturn = true;
 104  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 105   
                                              ignoreCase);
 106  1
     assertEquals("return value", expectedReturn, actualReturn);
 107   
   }
 108   
 
 109   
   /**
 110   
    * Test startswith ignore case true.
 111   
    */
 112  1
   public void testEvaluateStartsString2() {
 113  1
     String leftside = "ABC";
 114  1
     String rightside = "ab";
 115  1
     int operation = Operator.Operation.STARTSWITH;
 116   
 
 117  1
     boolean ignoreCase = true;
 118  1
     boolean expectedReturn = true;
 119  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 120   
                                              ignoreCase);
 121  1
     assertEquals("return value", expectedReturn, actualReturn);
 122   
   }
 123   
 
 124   
   /**
 125   
    * Test startswith false.
 126   
    */
 127  1
   public void testEvaluateStartsString3() {
 128  1
     String leftside = "ABC";
 129  1
     String rightside = "BC";
 130  1
     int operation = Operator.Operation.STARTSWITH;
 131   
 
 132  1
     boolean ignoreCase = false;
 133  1
     boolean expectedReturn = false;
 134  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 135   
                                              ignoreCase);
 136  1
     assertEquals("return value", expectedReturn, actualReturn);
 137   
   }
 138   
 
 139   
   /**
 140   
    * Test startswith ignore case false.
 141   
    */
 142  1
   public void testEvaluateStartsString4() {
 143  1
     String leftside = "ABC";
 144  1
     String rightside = "bc";
 145  1
     int operation = Operator.Operation.STARTSWITH;
 146   
 
 147  1
     boolean ignoreCase = true;
 148  1
     boolean expectedReturn = false;
 149  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 150   
                                              ignoreCase);
 151  1
     assertEquals("return value", expectedReturn, actualReturn);
 152   
   }
 153   
 
 154   
   /**
 155   
    * Test endswith true.
 156   
    */
 157  1
   public void testEvaluateEndsString() {
 158  1
     String leftside = "ABC";
 159  1
     String rightside = "BC";
 160  1
     int operation = Operator.Operation.ENDSWITH;
 161   
 
 162  1
     boolean ignoreCase = false;
 163  1
     boolean expectedReturn = true;
 164  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 165   
                                              ignoreCase);
 166  1
     assertEquals("return value", expectedReturn, actualReturn);
 167   
   }
 168   
 
 169   
   /**
 170   
    * Test endswith ignore case true.
 171   
    */
 172  1
   public void testEvaluateEndsString2() {
 173  1
     String leftside = "ABC";
 174  1
     String rightside = "bc";
 175  1
     int operation = Operator.Operation.ENDSWITH;
 176   
 
 177  1
     boolean ignoreCase = true;
 178  1
     boolean expectedReturn = true;
 179  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 180   
                                              ignoreCase);
 181  1
     assertEquals("return value", expectedReturn, actualReturn);
 182   
   }
 183   
 
 184   
   /**
 185   
    * Test endswith false.
 186   
    */
 187  1
   public void testEvaluateEndsString3() {
 188  1
     String leftside = "ABC";
 189  1
     String rightside = "AB";
 190  1
     int operation = Operator.Operation.ENDSWITH;
 191   
 
 192  1
     boolean ignoreCase = false;
 193  1
     boolean expectedReturn = false;
 194  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 195   
                                              ignoreCase);
 196  1
     assertEquals("return value", expectedReturn, actualReturn);
 197   
   }
 198   
 
 199   
   /**
 200   
    * Test endswith ignorecase false.
 201   
    */
 202  1
   public void testEvaluateEndsString4() {
 203  1
     String leftside = "ABC";
 204  1
     String rightside = "ab";
 205  1
     int operation = Operator.Operation.ENDSWITH;
 206   
 
 207  1
     boolean ignoreCase = true;
 208  1
     boolean expectedReturn = false;
 209  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 210   
                                              ignoreCase);
 211  1
     assertEquals("return value", expectedReturn, actualReturn);
 212   
   }
 213   
 
 214   
   /**
 215   
    * Test contains true.
 216   
    */
 217  1
   public void testEvaluateContainsString() {
 218  1
     String leftside = "ABCD";
 219  1
     String rightside = "BC";
 220  1
     int operation = Operator.Operation.CONTAINS;
 221   
 
 222  1
     boolean ignoreCase = false;
 223  1
     boolean expectedReturn = true;
 224  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 225   
                                              ignoreCase);
 226  1
     assertEquals("return value", expectedReturn, actualReturn);
 227   
   }
 228   
 
 229   
   /**
 230   
    * Test contains ignore case true.
 231   
    */
 232  1
   public void testEvaluateContainsString2() {
 233  1
     String leftside = "ABCD";
 234  1
     String rightside = "bc";
 235  1
     int operation = Operator.Operation.CONTAINS;
 236   
 
 237  1
     boolean ignoreCase = true;
 238  1
     boolean expectedReturn = true;
 239  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 240   
                                              ignoreCase);
 241  1
     assertEquals("return value", expectedReturn, actualReturn);
 242   
   }
 243   
 
 244   
   /**
 245   
    * Test contains false.
 246   
    */
 247  1
   public void testEvaluateContainsString3() {
 248  1
     String leftside = "ABCD";
 249  1
     String rightside = "BA";
 250  1
     int operation = Operator.Operation.CONTAINS;
 251   
 
 252  1
     boolean ignoreCase = false;
 253  1
     boolean expectedReturn = false;
 254  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 255   
                                              ignoreCase);
 256  1
     assertEquals("return value", expectedReturn, actualReturn);
 257   
   }
 258   
 
 259   
   /**
 260   
    * Test contains ignore case false.
 261   
    */
 262  1
   public void testEvaluateContainsString4() {
 263  1
     String leftside = "ABCD";
 264  1
     String rightside = "ba";
 265  1
     int operation = Operator.Operation.CONTAINS;
 266   
 
 267  1
     boolean ignoreCase = true;
 268  1
     boolean expectedReturn = false;
 269  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 270   
                                              ignoreCase);
 271  1
     assertEquals("return value", expectedReturn, actualReturn);
 272   
   }
 273   
 
 274   
   /**
 275   
    * Test match true.
 276   
    */
 277  1
   public void testEvaluateMatchesString() {
 278  1
     String leftside = "ABCD";
 279  1
     String rightside = "BC";
 280  1
     int operation = Operator.Operation.MATCH;
 281   
 
 282  1
     boolean ignoreCase = false;
 283  1
     boolean expectedReturn = true;
 284  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 285   
                                              ignoreCase);
 286  1
     assertEquals("return value", expectedReturn, actualReturn);
 287   
   }
 288   
 
 289   
   /**
 290   
    * Test match ignore case.
 291   
    */
 292  1
   public void testEvaluateMatchesString2() {
 293  1
     String leftside = "ABCD";
 294  1
     String rightside = "bc";
 295  1
     int operation = Operator.Operation.MATCH;
 296   
 
 297  1
     boolean ignoreCase = true;
 298  1
     boolean expectedReturn = true;
 299  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 300   
                                              ignoreCase);
 301  1
     assertEquals("return value", expectedReturn, actualReturn);
 302   
   }
 303   
 
 304   
   /**
 305   
    * Test match false.
 306   
    */
 307  1
   public void testEvaluateMatchesString3() {
 308  1
     String leftside = "ABCD";
 309  1
     String rightside = "BA";
 310  1
     int operation = Operator.Operation.MATCH;
 311   
 
 312  1
     boolean ignoreCase = false;
 313  1
     boolean expectedReturn = false;
 314  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 315   
                                              ignoreCase);
 316  1
     assertEquals("return value", expectedReturn, actualReturn);
 317   
   }
 318   
 
 319   
   /**
 320   
    * Test match ignore case false.
 321   
    */
 322  1
   public void testEvaluateMatchesString4() {
 323  1
     String leftside = "ABCD";
 324  1
     String rightside = "ba";
 325  1
     int operation = Operator.Operation.MATCH;
 326   
 
 327  1
     boolean ignoreCase = true;
 328  1
     boolean expectedReturn = false;
 329  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 330   
                                              ignoreCase);
 331  1
     assertEquals("return value", expectedReturn, actualReturn);
 332   
   }
 333   
 
 334   
   /**
 335   
    * Test match with RE true.
 336   
    */
 337  1
   public void testEvaluateMatchesString5() {
 338  1
     String leftside = "ABAD";
 339  1
     String rightside = "A[BC]";
 340  1
     int operation = Operator.Operation.MATCH;
 341   
 
 342  1
     boolean ignoreCase = false;
 343  1
     boolean expectedReturn = true;
 344  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 345   
                                              ignoreCase);
 346  1
     assertEquals("return value", expectedReturn, actualReturn);
 347   
   }
 348   
 
 349   
   /**
 350   
    * Test match ignore case with RE.
 351   
    */
 352  1
   public void testEvaluateMatchesString6() {
 353  1
     String leftside = "ACAD";
 354  1
     String rightside = "A[BC]";
 355  1
     int operation = Operator.Operation.MATCH;
 356   
 
 357  1
     boolean ignoreCase = true;
 358  1
     boolean expectedReturn = true;
 359  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 360   
                                              ignoreCase);
 361  1
     assertEquals("return value", expectedReturn, actualReturn);
 362   
   }
 363   
 
 364   
   /**
 365   
    * Test match with RE false.
 366   
    */
 367  1
   public void testEvaluateMatchesString7() {
 368  1
     String leftside = "ADAD";
 369  1
     String rightside = "A[BC]";
 370  1
     int operation = Operator.Operation.MATCH;
 371   
 
 372  1
     boolean ignoreCase = false;
 373  1
     boolean expectedReturn = false;
 374  1
     boolean actualReturn = Operator.evaluate(leftside, rightside, operation,
 375   
                                              ignoreCase);
 376  1
     assertEquals("return value", expectedReturn, actualReturn);
 377   
   }
 378   
 
 379   
   /**
 380   
    * Test toString.
 381   
    */
 382  1
   public void testToString() {
 383  1
     String str = null;
 384  1
     str = Operator.Operation.toString(Operator.Operation.CONTAINS);
 385  1
     assertEquals("contains", str);
 386  1
     str = Operator.Operation.toString(Operator.Operation.ENDSWITH);
 387  1
     assertEquals("endswith", str);
 388  1
     str = Operator.Operation.toString(Operator.Operation.EQUALS);
 389  1
     assertEquals("equals", str);
 390  1
     str = Operator.Operation.toString(Operator.Operation.MATCH);
 391  1
     assertEquals("match", str);
 392  1
     str = Operator.Operation.toString(Operator.Operation.STARTSWITH);
 393  1
     assertEquals("startswith", str);
 394   
   }
 395   
 
 396   
   /**
 397   
    * Test get operation.
 398   
    */
 399  1
   public void testGetOperation() {
 400  1
     int op;
 401  1
     op = Operator.Operation.getOperation("contains");
 402  1
     assertEquals(Operator.Operation.CONTAINS, op);
 403  1
     op = Operator.Operation.getOperation("endswith");
 404  1
     assertEquals(Operator.Operation.ENDSWITH, op);
 405  1
     op = Operator.Operation.getOperation("equals");
 406  1
     assertEquals(Operator.Operation.EQUALS, op);
 407  1
     op = Operator.Operation.getOperation("match");
 408  1
     assertEquals(Operator.Operation.MATCH, op);
 409  1
     op = Operator.Operation.getOperation("startswith");
 410  1
     assertEquals(Operator.Operation.STARTSWITH, op);
 411   
 
 412   
   }
 413   
 
 414   
 }
 415