Cross Reference: /libcore/dom/src/test/java/org/w3c/domts/DOMTestCase.java

Lines Matching refs:expected
206    * Asserts that actual and expected are the same object
213   public void assertSame(String assertID, Object expected, Object actual) {
214     framework.assertSame(this, assertID, expected, actual);
232    * Asserts that the length of the collection is the expected size.
237    *            expected size
249    * Asserts that the length of the collection is the expected size.
254    *            expected size
266    * Asserts that the length of the collection is the expected size.
271    *            expected size
283    * Asserts that expected.equalsIgnoreCase(actual) is true
289    * @param expected
294       String expected,
296     framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
300    * Asserts that each entry in actual is matched with an entry in expected
307    * @param expected
312       Collection expected,
314     framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
318    * Asserts that each entry in actual is matched with an entry in expected
325    * @param expected
330       List expected,
332     framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
336    * Asserts that expected.equalsIgnoreCase(actual) is true
342    * @param expected
348       String expected,
359         framework.assertEqualsIgnoreCase(this, assertID, expected, actual);
364         framework.assertEquals(this, assertID, expected.toUpperCase(), actual);
368       framework.assertEquals(this, assertID, expected, actual);
377   private List toUpperCase(Collection expected) {
378     List upperd = new ArrayList(expected.size());
379     Iterator iter = expected.iterator();
387    * Asserts that each entry in actual is matched with an entry in expected
394    * @param expected
400       Collection expected,
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
425    * @param expected
431       List expected,
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
455    * @param expected
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.
469    * @param expected
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.
483    * @param expected
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.
497    * @param expected
502       boolean expected,
504     framework.assertEquals(this, assertID, expected, actual);
509    * expected. Order is not significant.
515    * @param expected
520       Collection expected,
527     framework.assertEquals(this, assertID, expected, actualList);
532    * expected. Order is not significant.
538    * @param expected
543       Collection expected,
545     framework.assertEquals(this, assertID, expected, actual);
549    * Asserts that expected.equalsIgnoreCase(actual) is false
555    * @param expected
560       String expected,
562     framework.assertNotEqualsIgnoreCase(this, assertID, expected, actual);
566    * Asserts that expected.equalsIgnoreCase(actual) is false
572    * @param expected
578       String expected,
583         framework.assertNotEqualsIgnoreCase(this, assertID, expected, actual);
586         framework.assertNotEquals(this, assertID, expected.toUpperCase(),
590     framework.assertNotEquals(this, assertID, expected, actual);
594    * Asserts that values of expected and actual are not equal.
600    * @param expected
605       String expected,
607     framework.assertNotEquals(this, assertID, expected, actual);
611    * Asserts that values of expected and actual are not equal.
617    * @param expected
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.
631    * @param expected
636       double expected,
638     framework.assertNotEquals(this, assertID, expected, actual);
770    * Compares the identity of actual and expected.
772    * @param expected
773    *            expected
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.
785    * @param expected
786    *            expected
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.
798    * @param expected
799    *            expected
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.
811    * @param expected
812    *            expected
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.
824    * @param expected
825    *            expected
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.
845    * @param expected
846    *            expected
849    * @return true if actual and expected are equal ignoring case.
851   public boolean equalsAutoCase(String context, Collection expected,
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.
867    * @param expected
868    *            expected
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.
888    * @param expected
889    *            expected
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.
901    * @param expected
902    *            expected
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.
914    * @param expected
915    *            expected
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.
927    * @param expected
928    *            expected
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.
940    * @param expected
941    *            expected
944    * @return true if actual and expected are equal.
946   public boolean equals(List expected, List actual) {
947     return framework.equals(expected, actual);