131    * Asserts that actual==true
135    * @param actual
136    *            actual value
138   public void assertTrue(String assertID, boolean actual) {
139     framework.assertTrue(this, assertID, actual);
143    * Asserts that actual==true
147    * @param actual
148    *            actual value
150   public void assertTrue(String assertID, Object actual) {
151     framework.assertTrue(this, assertID, ( (Boolean) actual).booleanValue());
155    * Asserts that actual==false
159    * @param actual
160    *            actual value
162   public void assertFalse(String assertID, boolean actual) {
163     framework.assertFalse(this, assertID, actual);
167    * Asserts that actual==false
171    * @param actual
172    *            actual value
174   public void assertFalse(String assertID, Object actual) {
178         ( (Boolean) actual).booleanValue());
182    * Asserts that actual == null
186    * @param actual
187    *            actual value
189   public void assertNull(String assertID, Object actual) {
190     framework.assertNull(this, assertID, actual);
194    * Asserts that actual != null
198    * @param actual
199    *            actual value
201   public void assertNotNull(String assertID, Object actual) {
202     framework.assertNotNull(this, assertID, actual);
206    * Asserts that actual and expected are the same object
210    * @param actual
211    *            actual value
213   public void assertSame(String assertID, Object expected, Object actual) {
214     framework.assertSame(this, assertID, expected, actual);
283    * Asserts that expected.equalsIgnoreCase(actual) is true
287    * @param actual
288    *            actual value
295       String actual) {
296     framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
300    * Asserts that each entry in actual is matched with an entry in expected
305    * @param actual
306    *            actual value
313       Collection actual) {
314     framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
318    * Asserts that each entry in actual is matched with an entry in expected
323    * @param actual
324    *            actual value
331       List actual) {
332     framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
336    * Asserts that expected.equalsIgnoreCase(actual) is true
340    * @param actual
341    *            actual value
349       String actual) {
359         framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
364         framework.assertEquals(this, assertID, expected.toUpperCase(), actual);
368       framework.assertEquals(this, assertID, expected, actual);
387    * Asserts that each entry in actual is matched with an entry in expected
392    * @param actual
393    *            actual value
401       Collection actual) {
405         assertEqualsIgnoreCase(assertID, expected, actual);
408         framework.assertEquals(this, assertID, toUpperCase(expected), actual);
413       framework.assertEquals(this, assertID, expected, actual);
418    * Asserts that each entry in actual is matched with an entry in expected
423    * @param actual
424    *            actual value
432       List actual) {
436         assertEqualsIgnoreCase(assertID, expected, actual);
439         framework.assertEquals(this, assertID, toUpperCase(expected), actual);
444       framework.assertEquals(this, assertID, expected, actual);
449    * Asserts that expected.equals(actual) is true
453    * @param actual
454    *            actual value
458   public void assertEquals(String assertID, String expected, String actual) {
459     framework.assertEquals(this, assertID, expected, actual);
463    * Asserts that values of expected and actual are equal.
467    * @param actual
468    *            actual value
472   public void assertEquals(String assertID, int expected, int actual) {
473     framework.assertEquals(this, assertID, expected, actual);
477    * Asserts that values of expected and actual are equal.
481    * @param actual
482    *            actual value
486   public void assertEquals(String assertID, double expected, double actual) {
487     framework.assertEquals(this, assertID, expected, actual);
491    * Asserts that values of expected and actual are equal.
495    * @param actual
496    *            actual value
503       boolean actual) {
504     framework.assertEquals(this, assertID, expected, actual);
508    * Asserts that each entry in actual exactly matches with an entry in
513    * @param actual
514    *            actual value
521       NodeList actual) {
523     int actualLen = actual.getLength();
525       actualList.add(actual.item(i));
531    * Asserts that each entry in actual exactly matches with an entry in
536    * @param actual
537    *            actual value
544       Collection actual) {
545     framework.assertEquals(this, assertID, expected, actual);
549    * Asserts that expected.equalsIgnoreCase(actual) is false
553    * @param actual
554    *            actual value
561       String actual) {
562     framework.assertNotEqualsIgnoreCase(this, assertID, expected, actual);
566    * Asserts that expected.equalsIgnoreCase(actual) is false
570    * @param actual
571    *            actual value
579       String actual) {
583         framework.assertNotEqualsIgnoreCase(this, assertID, expected, actual);
587                                   actual);
590     framework.assertNotEquals(this, assertID, expected, actual);
594    * Asserts that values of expected and actual are not equal.
598    * @param actual
599    *            actual value
606       String actual) {
607     framework.assertNotEquals(this, assertID, expected, actual);
611    * Asserts that values of expected and actual are not equal.
615    * @param actual
616    *            actual value
620   public void assertNotEquals(String assertID, int expected, int actual) {
621     framework.assertNotEquals(this, assertID, expected, actual);
625    * Asserts that values of expected and actual are not equal.
629    * @param actual
630    *            actual value
637       double actual) {
638     framework.assertNotEquals(this, assertID, expected, actual);
667    * @param actual
680       String actual) {
683     assertNotNull(assertID, actual);
685     String uri = actual;
687     int lastPound = actual.lastIndexOf("#");
693       uri = actual.substring(0, lastPound);
694       actualFragment = actual.substring(lastPound + 1);
706       uri = actual.substring(0, lastQuestion);
707       actualQuery = actual.substring(lastQuestion + 1);
761       //   Jar URL's will have any actual path like file:/c:/somedrive...
770    * Compares the identity of actual and expected.
774    * @param actual
775    *            actual
776    * @return true if actual and expected are the same object.
778   public boolean same(Object expected, Object actual) {
779     return framework.same(expected, actual);
783    * Compares the value of actual and expected ignoring case.
787    * @param actual
788    *            actual
789    * @return true if actual and expected are equal ignoring case.
791   public boolean equalsIgnoreCase(String expected, String actual) {
792     return framework.equalsIgnoreCase(expected, actual);
796    * Compares the values in actual and expected ignoring case and order.
800    * @param actual
801    *            actual
802    * @return true if actual and expected are equal ignoring case.
804   public boolean equalsIgnoreCase(Collection expected, Collection actual) {
805     return framework.equalsIgnoreCase(expected, actual);
809    * Compares the values in actual and expected ignoring case.
813    * @param actual
814    *            actual
815    * @return true if actual and expected are equal ignoring case.
817   public boolean equalsIgnoreCase(List expected, List actual) {
818     return framework.equalsIgnoreCase(expected, actual);
822    * Compares the value of actual and expected ignoring case.
826    * @param actual
827    *            actual
828    * @return true if actual and expected are equal ignoring case.
830   public boolean equalsAutoCase(String context, String expected, String actual) {
833         return framework.equalsIgnoreCase(expected, actual);
836         return framework.equals(expected.toUpperCase(), actual);
839     return framework.equals(expected, actual);
843    * Compares the values in actual and expected ignoring case and order.
847    * @param actual
848    *            actual
849    * @return true if actual and expected are equal ignoring case.
852                                 Collection actual) {
855         return framework.equalsIgnoreCase(expected, actual);
858         return framework.equals(toUpperCase(expected), actual);
861     return framework.equals(expected, actual);
865    * Compares the values in actual and expected ignoring case.
869    * @param actual
870    *            actual
871    * @return true if actual and expected are equal ignoring case.
873   public boolean equalsAutoCase(String context, List expected, List actual) {
876         return framework.equalsIgnoreCase(expected, actual);
879         return framework.equals(toUpperCase(expected), actual);
882     return framework.equals(expected, actual);
886    * Compares the values of actual and expected.
890    * @param actual
891    *            actual
892    * @return true if actual and expected are equal.
894   public boolean equals(String expected, String actual) {
895     return framework.equals(expected, actual);
899    * Compares the values of actual and expected.
903    * @param actual
904    *            actual
905    * @return true if actual and expected are equal.
907   public boolean equals(int expected, int actual) {
908     return framework.equals(expected, actual);
912    * Compares the values of actual and expected.
916    * @param actual
917    *            actual
918    * @return true if actual and expected are equal.
920   public boolean equals(double expected, double actual) {
921     return framework.equals(expected, actual);
925    * Compares the values in actual and expected ignoring order.
929    * @param actual
930    *            actual
931    * @return true if actual and expected are equal.
933   public boolean equals(Collection expected, Collection actual) {
934     return framework.equals(expected, actual);
938    * Compares the values in actual and expected.
942    * @param actual
943    *            actual
944    * @return true if actual and expected are equal.
946   public boolean equals(List expected, List actual) {
947     return framework.equals(expected, actual);

Indexes created Thu Feb 14 23:00:39 CET 2013