    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;
    18
    19  import java.util.ArrayList;
    20  import java.util.Collection;
    21  import java.util.HashMap;
    22  import java.util.Iterator;
    23  import java.util.Map;
    24
    25  import junit.framework.TestCase;
    26
    27  /***
    28   * Test class for EnvironmentConfiguration.
    29   *
    30   * @author Oliver Heger
    31   * @version $Id: TestEnvironmentConfiguration.java 587636 2007-10-23 20:03:47Z oheger $
    32   */
    33  public class TestEnvironmentConfiguration extends TestCase
    34  {
    35      /*** Stores the configuration to be tested. */
    36      private EnvironmentConfiguration config;
    37
    38      protected void setUp() throws Exception
    39      {
    40          super.setUp();
    41          config = new EnvironmentConfiguration();
    42      }
    43
    44      /***
    45       * Helper method for checking that the configuration contains some
    46       * environment properties. (We expect that at least some properties are set
    47       * in each environment.)
    48       */
    49      private void checkProperties()
    50      {
    51          boolean found = false;
    52          assertFalse("No properties found", config.isEmpty());
    53          for (Iterator it = config.getKeys(); it.hasNext();)
    54          {
    55              String key = (String) it.next();
    56              assertTrue("Key not found: " + key, config.containsKey(key));
    57              assertNotNull("No value for property " + key, config.getString(key));
    58              found = true;
    59          }
    60          assertTrue("No property keys returned", found);
    61      }
    62
    63      /***
    64       * Tests whether a newly created configuration contains some properties. (We
    65       * expect that at least some properties are set in each environment.)
    66       */
    67      public void testInit()
    68      {
    69          checkProperties();
    70      }
    71
    72      /***
    73       * Tests extracting properties for JDK before 1.5. This method should work
    74       * on later JDKs, too, so we can test it always.
    75       */
    76      public void testExtractProperties14()
    77      {
    78          config.extractProperties14();
    79          checkProperties();
    80      }
    81
    82      /***
    83       * Tests whether a collection with properties is correctly processed.
    84       */
    85      public void testExtractPropertiesFromCollection()
    86      {
    87          final int count = 8;
    88          final String prop = "property";
    89          final String value = "value";
    90
    91          Collection env = new ArrayList(count);
    92          for (int i = 0; i < count; i++)
    93          {
    94              env.add(prop + i + "=" + value + i);
    95          }
    96          env.add("irregularProperty");
    97          config.extractPropertiesFromCollection(env);
    98
    99          Map props = new HashMap();
    100         for (Iterator it = config.getKeys(); it.hasNext();)
    101         {
    102             String key = (String) it.next();
    103             props.put(key, config.getString(key));
    104         }
    105         assertEquals("Wrong number of properties", count, props.size());
    106         for (int i = 0; i < count; i++)
    107         {
    108             assertEquals("Wrong value for property " + i, value + i, props
    109                     .get(prop + i));
    110         }
    111         assertFalse("Irregular property found", config
    112                 .containsKey("irregularProperty"));
    113     }
    114
    115     /***
    116      * Tests removing properties. This should not be possible.
    117      */
    118     public void testClearProperty()
    119     {
    120         String key = (String) config.getKeys().next();
    121         try
    122         {
    123             config.clearProperty(key);
    124             fail("Could remove a property!");
    125         }
    126         catch (UnsupportedOperationException uoex)
    127         {
    128             // ok
    129         }
    130     }
    131
    132     /***
    133      * Tests removing all properties. This should not be possible.
    134      */
    135     public void testClear()
    136     {
    137         try
    138         {
    139             config.clear();
    140             fail("Could remove properties!");
    141         }
    142         catch (UnsupportedOperationException uoex)
    143         {
    144             // ok
    145         }
    146     }
    147
    148     /***
    149      * Tries to add another property. This should cause an exception.
    150      */
    151     public void testAddProperty()
    152     {
    153         try
    154         {
    155             config.addProperty("JAVA_HOME", "C://java");
    156             fail("Could add a property!");
    157         }
    158         catch (UnsupportedOperationException uoex)
    159         {
    160             // ok
    161         }
    162     }
    163
    164     /***
    165      * Tries to set the value of a property. This should cause an exception.
    166      */
    167     public void testSetProperty()
    168     {
    169         try
    170         {
    171             config.setProperty("JAVA_HOME", "C://java");
    172             fail("Could set a property!");
    173         }
    174         catch (UnsupportedOperationException uoex)
    175         {
    176             // ok
    177         }
    178     }
    179 }