    1   /*
    2    * Copyright 1999-2004 The Apache Software Foundation
    3    *
    4    * Licensed under the Apache License, Version 2.0 (the "License");
    5    * you may not use this file except in compliance with the License.
    6    * You may obtain a copy of the License at
    7    *
    8    *     http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  package org.apache.commons.jxpath;
    17
    18  import java.util.ArrayList;
    19  import java.util.Collection;
    20  import java.util.Collections;
    21  import java.util.HashSet;
    22  import java.util.Iterator;
    23  import java.util.List;
    24  import java.util.Locale;
    25  import java.util.Set;
    26
    27  import junit.framework.TestCase;
    28
    29  import org.apache.commons.jxpath.ri.model.NodePointer;
    30
    31  /***
    32   * Abstract superclass for various JXPath tests.
    33   *
    34   * @author Dmitri Plotnikov
    35   * @version $Revision: 1.36 $ $Date: 2004/07/16 22:52:32 $
    36   */
    37
    38  public abstract class JXPathTestCase extends TestCase {
    39      /***
    40       * Construct a new instance of this test case.
    41       *
    42       * @param name Name of the test case
    43       */
    44      public JXPathTestCase(String name) {
    45          super(name);
    46          Locale.setDefault(Locale.US);
    47      }
    48
    49      protected void assertXPathValue(JXPathContext ctx,
    50                  String xpath, Object expected)
    51      {
    52          ctx.setLenient(false);
    53          Object actual = ctx.getValue(xpath);
    54          assertEquals("Evaluating <" + xpath + ">", expected, actual);
    55      }
    56
    57      protected void assertXPathValue(JXPathContext ctx,
    58                  String xpath, Object expected, Class resultType)
    59      {
    60          ctx.setLenient(false);
    61          Object actual = ctx.getValue(xpath, resultType);
    62          assertEquals("Evaluating <" + xpath + ">", expected, actual);
    63      }
    64
    65      protected void assertXPathValueLenient(JXPathContext ctx,
    66                  String xpath, Object expected)
    67      {
    68          ctx.setLenient(true);
    69          Object actual = ctx.getValue(xpath);
    70          ctx.setLenient(false);
    71          assertEquals("Evaluating lenient <" + xpath + ">", expected, actual);
    72      }
    73
    74      protected void assertXPathSetValue(JXPathContext ctx,
    75                  String xpath, Object value)
    76      {
    77          assertXPathSetValue(ctx, xpath, value, value);
    78      }
    79
    80      protected void assertXPathSetValue(JXPathContext ctx,
    81                  String xpath, Object value, Object expected)
    82      {
    83          ctx.setValue(xpath, value);
    84          Object actual = ctx.getValue(xpath);
    85          assertEquals("Modifying <" + xpath + ">", expected, actual);
    86      }
    87
    88      protected void assertXPathCreatePath(JXPathContext ctx,
    89                  String xpath,
    90                  Object expectedValue, String expectedPath)
    91      {
    92          Pointer pointer = ctx.createPath(xpath);
    93          assertEquals("Creating path <" + xpath + ">",
    94                  expectedPath, pointer.asPath());
    95
    96          assertEquals("Creating path (pointer value) <" + xpath + ">",
    97                  expectedValue, pointer.getValue());
    98
    99          assertEquals("Creating path (context value) <" + xpath + ">",
    100                 expectedValue, ctx.getValue(pointer.asPath()));
    101     }
    102
    103     protected void assertXPathCreatePathAndSetValue(JXPathContext ctx,
    104                 String xpath, Object value,
    105                 String expectedPath)
    106     {
    107         Pointer pointer = ctx.createPathAndSetValue(xpath, value);
    108         assertEquals("Creating path <" + xpath + ">",
    109                 expectedPath, pointer.asPath());
    110
    111         assertEquals("Creating path (pointer value) <" + xpath + ">",
    112                 value, pointer.getValue());
    113
    114         assertEquals("Creating path (context value) <" + xpath + ">",
    115                 value, ctx.getValue(pointer.asPath()));
    116     }
    117
    118     protected void assertXPathPointer(JXPathContext ctx,
    119                 String xpath, String expected)
    120     {
    121         ctx.setLenient(false);
    122         Pointer pointer = ctx.getPointer(xpath);
    123         String actual = pointer.toString();
    124         assertEquals("Evaluating pointer <" + xpath + ">", expected, actual);
    125     }
    126
    127     protected void assertXPathPointerLenient(JXPathContext ctx,
    128                 String xpath, String expected)
    129     {
    130         ctx.setLenient(true);
    131         Pointer pointer = ctx.getPointer(xpath);
    132         String actual = pointer.toString();
    133         assertEquals("Evaluating pointer <" + xpath + ">", expected, actual);
    134     }
    135
    136     protected void assertXPathValueAndPointer(JXPathContext ctx,
    137                 String xpath, Object expectedValue, String expectedPointer)
    138     {
    139         assertXPathValue(ctx, xpath, expectedValue);
    140         assertXPathPointer(ctx, xpath, expectedPointer);
    141     }
    142
    143     protected void assertXPathValueIterator(JXPathContext ctx,
    144                 String xpath, Collection expected)
    145     {
    146         Collection actual;
    147         if (expected instanceof List) {
    148             actual = new ArrayList();
    149         }
    150         else {
    151             actual = new HashSet();
    152         }
    153         Iterator it = ctx.iterate(xpath);
    154         while (it.hasNext()) {
    155             actual.add(it.next());
    156         }
    157         assertEquals("Evaluating value iterator <" + xpath + ">",
    158                 expected, actual);
    159     }
    160
    161     protected void assertXPathPointerIterator(
    162         JXPathContext ctx,
    163         String xpath,
    164         Collection expected)
    165     {
    166         Collection actual;
    167         if (expected instanceof List) {
    168             actual = new ArrayList();
    169         }
    170         else {
    171             actual = new HashSet();
    172         }
    173         Iterator it = ctx.iteratePointers(xpath);
    174         while (it.hasNext()) {
    175             Pointer pointer = (Pointer) it.next();
    176             actual.add(pointer.toString());
    177         }
    178         assertEquals(
    179             "Evaluating pointer iterator <" + xpath + ">",
    180             expected,
    181             actual);
    182     }
    183
    184     protected void assertDocumentOrder(
    185         JXPathContext context,
    186         String path1,
    187         String path2,
    188         int expected)
    189     {
    190         NodePointer np1 = (NodePointer) context.getPointer(path1);
    191         NodePointer np2 = (NodePointer) context.getPointer(path2);
    192         int res = np1.compareTo(np2);
    193         if (res < 0) {
    194             res = -1;
    195         }
    196         else if (res > 0) {
    197             res = 1;
    198         }
    199         assertEquals(
    200             "Comparing paths '" + path1 + "' and '" + path2 + "'",
    201             expected,
    202             res);
    203     }
    204
    205     protected void assertXPathValueType(
    206             JXPathContext ctx,
    207             String xpath,
    208             Class clazz)
    209     {
    210         ctx.setLenient(false);
    211         Object actual = ctx.getValue(xpath);
    212         assertTrue("Evaluating <" + xpath + "> = " + actual.getClass(),
    213                 clazz.isAssignableFrom(actual.getClass()));
    214     }
    215
    216     protected void assertXPathNodeType(
    217             JXPathContext ctx,
    218             String xpath,
    219             Class clazz)
    220     {
    221         ctx.setLenient(false);
    222         Pointer actual = ctx.getPointer(xpath);
    223         assertTrue("Evaluating <" + xpath + "> = " + actual.getNode().getClass(),
    224                 clazz.isAssignableFrom(actual.getNode().getClass()));
    225     }
    226
    227     protected static List list() {
    228         return Collections.EMPTY_LIST;
    229     }
    230
    231     protected static List list(Object o1) {
    232         List list = new ArrayList();
    233         list.add(o1);
    234         return list;
    235     }
    236
    237     protected static List list(Object o1, Object o2) {
    238         List list = new ArrayList();
    239         list.add(o1);
    240         list.add(o2);
    241         return list;
    242     }
    243
    244     protected static List list(Object o1, Object o2, Object o3) {
    245         List list = new ArrayList();
    246         list.add(o1);
    247         list.add(o2);
    248         list.add(o3);
    249         return list;
    250     }
    251
    252     protected static Set set(Object o1, Object o2, Object o3) {
    253         Set list = new HashSet();
    254         list.add(o1);
    255         list.add(o2);
    256         list.add(o3);
    257         return list;
    258     }
    259
    260     protected static List list(Object o1, Object o2, Object o3, Object o4) {
    261         List list = new ArrayList();
    262         list.add(o1);
    263         list.add(o2);
    264         list.add(o3);
    265         list.add(o4);
    266         return list;
    267     }
    268
    269     protected static Set set(Object o1, Object o2, Object o3, Object o4) {
    270         Set list = new HashSet();
    271         list.add(o1);
    272         list.add(o2);
    273         list.add(o3);
    274         list.add(o4);
    275         return list;
    276     }
    277
    278     protected static List list(Object o1, Object o2, Object o3,
    279                 Object o4, Object o5)
    280     {
    281         List list = new ArrayList();
    282         list.add(o1);
    283         list.add(o2);
    284         list.add(o3);
    285         list.add(o4);
    286         list.add(o5);
    287         return list;
    288     }
    289
    290     protected static Set set(Object o1, Object o2, Object o3,
    291                 Object o4, Object o5)
    292     {
    293         Set list = new HashSet();
    294         list.add(o1);
    295         list.add(o2);
    296         list.add(o3);
    297         list.add(o4);
    298         list.add(o5);
    299         return list;
    300     }
    301
    302     protected static List list(Object o1, Object o2, Object o3,
    303                 Object o4, Object o5, Object o6)
    304     {
    305         List list = new ArrayList();
    306         list.add(o1);
    307         list.add(o2);
    308         list.add(o3);
    309         list.add(o4);
    310         list.add(o5);
    311         list.add(o6);
    312         return list;
    313     }
    314
    315     protected static Set set(Object o1, Object o2, Object o3,
    316                 Object o4, Object o5, Object o6)
    317     {
    318         Set list = new HashSet();
    319         list.add(o1);
    320         list.add(o2);
    321         list.add(o3);
    322         list.add(o4);
    323         list.add(o5);
    324         list.add(o6);
    325         return list;
    326     }
    327
    328     protected static List list(Object o1, Object o2, Object o3,
    329                 Object o4, Object o5, Object o6, Object o7)
    330     {
    331         List list = new ArrayList();
    332         list.add(o1);
    333         list.add(o2);
    334         list.add(o3);
    335         list.add(o4);
    336         list.add(o5);
    337         list.add(o6);
    338         list.add(o7);
    339         return list;
    340     }
    341
    342     protected static Set set(Object o1, Object o2, Object o3,
    343                 Object o4, Object o5, Object o6, Object o7)
    344     {
    345         Set list = new HashSet();
    346         list.add(o1);
    347         list.add(o2);
    348         list.add(o3);
    349         list.add(o4);
    350         list.add(o5);
    351         list.add(o6);
    352         list.add(o7);
    353         return list;
    354     }
    355
    356 }