    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.ri.compiler;
    17
    18  import org.apache.commons.jxpath.JXPathContext;
    19  import org.apache.commons.jxpath.JXPathTestCase;
    20  import org.apache.commons.jxpath.Variables;
    21
    22  /***
    23   * Test basic functionality of JXPath - infoset types,
    24   * operations.
    25   *
    26   * @author Dmitri Plotnikov
    27   * @version $Revision: 1.5 $ $Date: 2004/02/29 14:17:42 $
    28   */
    29
    30  public class VariableTest extends JXPathTestCase {
    31      private JXPathContext context;
    32
    33      /***
    34       * Construct a new instance of this test case.
    35       *
    36       * @param name Name of the test case
    37       */
    38      public VariableTest(String name) {
    39          super(name);
    40      }
    41
    42      public void setUp() {
    43          if (context == null) {
    44              context = JXPathContext.newContext(null);
    45              context.setFactory(new VariableFactory());
    46
    47              Variables vars = context.getVariables();
    48              vars.declareVariable("a", new Double(1));
    49              vars.declareVariable("b", new Double(1));
    50              vars.declareVariable("c", null);
    51              vars.declareVariable("d", new String[] { "a", "b" });
    52              vars.declareVariable("integer", new Integer(1));
    53              vars.declareVariable("nan", new Double(Double.NaN));
    54              vars.declareVariable("x", null);
    55          }
    56      }
    57
    58      public void testVariables() {
    59          // Variables
    60          assertXPathValueAndPointer(context, "$a", new Double(1), "$a");
    61      }
    62
    63      public void testVariablesInExpressions() {
    64          assertXPathValue(context, "$a = $b", Boolean.TRUE);
    65
    66          assertXPathValue(context, "$a = $nan", Boolean.FALSE);
    67
    68          assertXPathValue(context, "$a + 1", new Double(2));
    69
    70          assertXPathValue(context, "$c", null);
    71
    72          assertXPathValue(context, "$d[2]", "b");
    73      }
    74
    75      public void testInvalidVariableName() {
    76          boolean exception = false;
    77          try {
    78              context.getValue("$none");
    79          }
    80          catch (Exception ex) {
    81              exception = true;
    82          }
    83          assertTrue(
    84              "Evaluating '$none', expected exception - did not get it",
    85              exception);
    86
    87          exception = false;
    88          try {
    89              context.setValue("$none", new Integer(1));
    90          }
    91          catch (Exception ex) {
    92              exception = true;
    93          }
    94          assertTrue(
    95              "Setting '$none = 1', expected exception - did not get it",
    96              exception);
    97      }
    98
    99      public void testNestedContext() {
    100         JXPathContext nestedContext = JXPathContext.newContext(context, null);
    101
    102         assertXPathValue(nestedContext, "$a", new Double(1));
    103     }
    104
    105     public void testSetValue() {
    106         assertXPathSetValue(context, "$x", new Integer(1));
    107     }
    108
    109     public void testCreatePathDeclareVariable() {
    110         // Calls factory.declareVariable("string")
    111         assertXPathCreatePath(context, "$string", null, "$string");
    112     }
    113
    114     public void testCreatePathAndSetValueDeclareVariable() {
    115         // Calls factory.declareVariable("string")
    116         assertXPathCreatePathAndSetValue(
    117             context,
    118             "$string",
    119             "Value",
    120             "$string");
    121     }
    122
    123     public void testCreatePathDeclareVariableSetCollectionElement() {
    124         // Calls factory.declareVariable("stringArray").
    125         // The factory needs to create a collection
    126         assertXPathCreatePath(
    127             context,
    128             "$stringArray[2]",
    129             "",
    130             "$stringArray[2]");
    131
    132         // See if the factory populated the first element as well
    133         assertEquals(
    134             "Created <" + "$stringArray[1]" + ">",
    135             "Value1",
    136             context.getValue("$stringArray[1]"));
    137     }
    138
    139     public void testCreateAndSetValuePathDeclareVariableSetCollectionElement() {
    140         // Calls factory.declareVariable("stringArray").
    141         // The factory needs to create a collection
    142         assertXPathCreatePathAndSetValue(
    143             context,
    144             "$stringArray[2]",
    145             "Value2",
    146             "$stringArray[2]");
    147
    148         // See if the factory populated the first element as well
    149         assertEquals(
    150             "Created <" + "$stringArray[1]" + ">",
    151             "Value1",
    152             context.getValue("$stringArray[1]"));
    153     }
    154
    155     public void testCreatePathExpandCollection() {
    156         context.getVariables().declareVariable(
    157             "array",
    158             new String[] { "Value1" });
    159
    160         // Does not involve factory at all - just expands the collection
    161         assertXPathCreatePath(context, "$array[2]", "", "$array[2]");
    162
    163         // Make sure it is still the same array
    164         assertEquals(
    165             "Created <" + "$array[1]" + ">",
    166             "Value1",
    167             context.getValue("$array[1]"));
    168     }
    169
    170     public void testCreatePathAndSetValueExpandCollection() {
    171         context.getVariables().declareVariable(
    172             "array",
    173             new String[] { "Value1" });
    174
    175         // Does not involve factory at all - just expands the collection
    176         assertXPathCreatePathAndSetValue(
    177             context,
    178             "$array[2]",
    179             "Value2",
    180             "$array[2]");
    181
    182         // Make sure it is still the same array
    183         assertEquals(
    184             "Created <" + "$array[1]" + ">",
    185             "Value1",
    186             context.getValue("$array[1]"));
    187     }
    188
    189     public void testCreatePathDeclareVariableSetProperty() {
    190         // Calls factory.declareVariable("test").
    191         // The factory should create a TestBean
    192         assertXPathCreatePath(
    193             context,
    194             "$test/boolean",
    195             Boolean.FALSE,
    196             "$test/boolean");
    197
    198     }
    199
    200     public void testCreatePathAndSetValueDeclareVariableSetProperty() {
    201         // Calls factory.declareVariable("test").
    202         // The factory should create a TestBean
    203         assertXPathCreatePathAndSetValue(
    204             context,
    205             "$test/boolean",
    206             Boolean.TRUE,
    207             "$test/boolean");
    208
    209     }
    210
    211     public void testCreatePathDeclareVariableSetCollectionElementProperty() {
    212         // Calls factory.declareVariable("testArray").
    213         // The factory should create a collection of TestBeans.
    214         // Then calls factory.createObject(..., collection, "testArray", 1).
    215         // That one should produce an instance of TestBean and
    216         // put it in the collection at index 1.
    217         assertXPathCreatePath(
    218             context,
    219             "$testArray[2]/boolean",
    220             Boolean.FALSE,
    221             "$testArray[2]/boolean");
    222     }
    223
    224     public void testCreatePathAndSetValueDeclVarSetCollectionElementProperty() {
    225         // Calls factory.declareVariable("testArray").
    226         // The factory should create a collection of TestBeans.
    227         // Then calls factory.createObject(..., collection, "testArray", 1).
    228         // That one should produce an instance of TestBean and
    229         // put it in the collection at index 1.
    230         assertXPathCreatePathAndSetValue(
    231             context,
    232             "$testArray[2]/boolean",
    233             Boolean.TRUE,
    234             "$testArray[2]/boolean");
    235     }
    236
    237     public void testRemovePathUndeclareVariable() {
    238         // Undeclare variable
    239         context.getVariables().declareVariable("temp", "temp");
    240         context.removePath("$temp");
    241         assertTrue(
    242             "Undeclare variable",
    243             !context.getVariables().isDeclaredVariable("temp"));
    244
    245     }
    246
    247     public void testRemovePathArrayElement() {
    248         // Remove array element - reassigns the new array to the var
    249         context.getVariables().declareVariable(
    250             "temp",
    251             new String[] { "temp1", "temp2" });
    252         context.removePath("$temp[1]");
    253         assertEquals(
    254             "Remove array element",
    255             "temp2",
    256             context.getValue("$temp[1]"));
    257     }
    258
    259     public void testRemovePathCollectionElement() {
    260         // Remove list element - does not create a new list
    261         context.getVariables().declareVariable("temp", list("temp1", "temp2"));
    262         context.removePath("$temp[1]");
    263         assertEquals(
    264             "Remove collection element",
    265             "temp2",
    266             context.getValue("$temp[1]"));
    267     }
    268 }