1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *     http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.configuration.interpol;
18  
19  import java.awt.event.KeyEvent;
20  
21  import junit.framework.TestCase;
22  
23  /***
24   * Test class for ConstantLookup.
25   *
26   * @version $Id: TestConstantLookup.java 588329 2007-10-25 20:01:31Z oheger $
27   */
28  public class TestConstantLookup extends TestCase
29  {
30      /*** Constant for the name of the test class. */
31      private static final String CLS_NAME = ConfigurationInterpolator.class
32              .getName() + '.';
33  
34      /*** Constant for the name of the test field. */
35      private static final String FIELD = "PREFIX_CONSTANTS";
36  
37      /*** Constant for the test variable name. */
38      private static final String VARNAME = CLS_NAME + FIELD;
39  
40      /*** The lookup object to be tested. */
41      private ConstantLookup lookup;
42  
43      protected void setUp() throws Exception
44      {
45          super.setUp();
46          lookup = new ConstantLookup();
47      }
48  
49      /***
50       * Clears the test environment. Here the static cache of the constant lookup
51       * class is wiped out.
52       */
53      protected void tearDown() throws Exception
54      {
55          ConstantLookup.clear();
56          super.tearDown();
57      }
58  
59      /***
60       * Tests resolving a valid constant.
61       */
62      public void testLookupConstant()
63      {
64          assertEquals("Wrong value of constant",
65                  ConfigurationInterpolator.PREFIX_CONSTANTS, lookup
66                          .lookup(VARNAME));
67      }
68  
69      /***
70       * Tests resolving a non existing constant. Result should be null.
71       */
72      public void testLookupNonExisting()
73      {
74          assertNull("Non null return value for non existing constant", lookup
75                  .lookup(CLS_NAME + "NO_FIELD"));
76      }
77  
78      /***
79       * Tests resolving a private constant. Because a private field cannot be
80       * accessed this should again yield null.
81       */
82      public void testLookupPrivate()
83      {
84          assertNull("Non null return value for non accessable field", lookup
85                  .lookup(CLS_NAME + "PREFIX_SEPARATOR"));
86      }
87  
88      /***
89       * Tests resolving a field from an unknown class.
90       */
91      public void testLookupUnknownClass()
92      {
93          assertNull("Non null return value for unknown class", lookup
94                  .lookup("org.apache.commons.configuration.NonExistingConfig."
95                          + FIELD));
96      }
97  
98      /***
99       * Tries to resolve a variable with an invalid syntax: The name does not
100      * contain a dot as a field separator.
101      */
102     public void testLookupInvalidSyntax()
103     {
104         assertNull("Non null return value for invalid variable name", lookup
105                 .lookup("InvalidVariableName"));
106     }
107 
108     /***
109      * Tests looking up a null variable.
110      */
111     public void testLookupNull()
112     {
113         assertNull("Non null return value for null variable", lookup
114                 .lookup(null));
115     }
116 
117     /***
118      * Tests accessing the cache by querying a variable twice.
119      */
120     public void testLookupCache()
121     {
122         testLookupConstant();
123         testLookupConstant();
124     }
125 
126     /***
127      * Tests resolving a non string constant. Then looks the same variable up
128      * from the cache.
129      */
130     public void testLookupNonStringFromCache()
131     {
132         final String var = KeyEvent.class.getName() + ".VK_ESCAPE";
133         final String expected = String.valueOf(KeyEvent.VK_ESCAPE);
134         assertEquals("Wrong result of first lookup", expected, lookup
135                 .lookup(var));
136         assertEquals("Wrong result of 2nd lookup", expected, lookup.lookup(var));
137     }
138 }