View Javadoc

    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
    18  package org.apache.any23.configuration;
    19
    20  import org.junit.Test;
    21
    22  import java.lang.reflect.ParameterizedType;
    23  import java.lang.reflect.Type;
    24  import java.util.Collections;
    25  import java.util.List;
    26  import java.util.Map;
    27  import java.util.Optional;
    28
    29  import static org.junit.Assert.assertEquals;
    30  import static org.junit.Assert.assertFalse;
    31  import static org.junit.Assert.assertNotSame;
    32  import static org.junit.Assert.assertNull;
    33  import static org.junit.Assert.assertSame;
    34  import static org.junit.Assert.assertTrue;
    35  import static org.junit.Assert.fail;
    36
    37  @SuppressWarnings("ResultOfMethodCallIgnored")
    38  public class SettingsTest {
    39
    40      @Test
    41      public void testNonNullSetting() {
    42          Setting<String> nonNull = Setting.create("nulltest", "A nonnull string");
    43          try {
    44              nonNull.withValue(null);
    45              fail();
    46          } catch (IllegalArgumentException e) {
    47              // test passes; ignore
    48          }
    49      }
    50
    51      @Test
    52      public void testNullableSetting() {
    53          Setting<String> nullable = Setting.create("nulltest", (String) null);
    54          assertNull(nullable.withValue(null).getValue());
    55      }
    56
    57      @Test
    58      public void testDuplicateIdentifiers() {
    59          try {
    60              Setting<String> first = Setting.create("foo", "");
    61              Setting<String> second = Setting.create("foo", "");
    62
    63              Settings.of(first, second);
    64
    65              fail();
    66          } catch (IllegalArgumentException e) {
    67              // test passes; ignore
    68          }
    69      }
    70
    71      @Test
    72      public void testFind() {
    73          Setting<String> key = Setting.create("foo", "key");
    74          Setting<String> element = key.withValue("element");
    75
    76          Settings settings = Settings.of(element);
    77
    78          Optional<Setting<String>> actual = settings.find(key);
    79
    80          assertTrue(actual.isPresent());
    81
    82          assertSame(element, actual.get());
    83
    84          assertTrue(settings.contains(element));
    85          assertFalse(settings.contains(key));
    86      }
    87
    88      @Test
    89      public void testGetPresentSetting() {
    90          Setting<String> key = Setting.create("foo", "key");
    91
    92          Setting<String> actual = key.withValue("actual");
    93          Settings settings = Settings.of(actual);
    94
    95          assertSame(actual.getValue(), settings.get(key));
    96      }
    97
    98      @Test
    99      public void testGetAbsentSetting() {
    100         Setting<String> key = Setting.create("foo", "key");
    101
    102         Setting<String> actual = Setting.create("foo", "actual");
    103         Settings settings = Settings.of(actual);
    104
    105         assertSame(key.getValue(), settings.get(key));
    106     }
    107
    108     @Test
    109     public void testGetNullSetting() {
    110         Setting<String> baseKey = Setting.create("foo", (String) null);
    111
    112         Settings settings = Settings.of(baseKey);
    113         assertNull(settings.get(baseKey.withValue("not null")));
    114
    115         // make sure we can go back to null
    116         baseKey.withValue("not null").withValue(null);
    117     }
    118
    119     @Test
    120     public void testSettingType() {
    121         assertEquals(CharSequence.class, Setting.create("foo", CharSequence.class, "").getValueType());
    122         assertEquals(CharSequence.class, new Setting<CharSequence>("foo", "") {
    123         }.getValueType());
    124
    125         Type mapType = new Setting<Map<String, Integer>>("foo", Collections.emptyMap()) {
    126         }.getValueType();
    127
    128         assertTrue(mapType instanceof ParameterizedType);
    129         assertEquals("java.util.Map<java.lang.String, java.lang.Integer>", mapType.getTypeName());
    130
    131         class Key0<Bar, V> extends Setting<V> {
    132             Key0() {
    133                 super("foo", null);
    134             }
    135         }
    136
    137         class Key2<Baz, V, Bar> extends Key0<V, Bar> {
    138         }
    139
    140         class Key3<V> extends Key2<Boolean, Integer, List<Optional<String>>> {
    141         }
    142
    143         class Key4 extends Key3<Boolean> {
    144         }
    145
    146         Type complicatedType = new Key4().withValue(Collections.emptyList()).getValueType();
    147
    148         assertTrue(complicatedType instanceof ParameterizedType);
    149         assertEquals("java.util.List<java.util.Optional<java.lang.String>>", complicatedType.getTypeName());
    150
    151         class Key3Simple<V> extends Key2<Boolean, Integer, String> {
    152         }
    153
    154         class Key4Simple extends Key3Simple<Boolean> {
    155         }
    156
    157         Type simpleType = new Key4Simple().withValue("").getValueType();
    158
    159         assertEquals(String.class, simpleType);
    160     }
    161
    162     @Test
    163     public void testCustomValueChecking() {
    164         class PositiveIntegerSetting extends Setting<Integer> {
    165             private PositiveIntegerSetting(String identifier, Integer defaultValue) {
    166                 super(identifier, defaultValue);
    167             }
    168
    169             @Override
    170             protected void checkValue(Integer newValue) throws Exception {
    171                 if (newValue < 0) {
    172                     throw new NumberFormatException();
    173                 }
    174             }
    175
    176             @Override
    177             public String toString() {
    178                 return getValue().toString();
    179             }
    180         }
    181
    182         Setting<Integer> setting = new PositiveIntegerSetting("foo", 0);
    183
    184         assertNotSame(setting, setting.withValue(0));
    185         assertEquals(setting, setting.withValue(0));
    186
    187         setting = setting.withValue(5).withValue(6).withValue(7);
    188
    189         assertEquals(setting.getClass(), PositiveIntegerSetting.class);
    190         assertEquals(setting.toString(), "7");
    191
    192         try {
    193             setting.withValue(-1);
    194             fail();
    195         } catch (IllegalArgumentException e) {
    196             assertTrue(e.getCause() instanceof NumberFormatException);
    197         }
    198     }
    199
    200     @Test
    201     @SuppressWarnings("unchecked")
    202     public void testBadSetting() {
    203         try {
    204             new Setting("foo", null) {
    205             };
    206             fail();
    207         } catch (IllegalArgumentException e) {
    208             // test passes; ignore
    209         }
    210
    211         try {
    212             new Setting<Integer>(null, null) {
    213             };
    214             fail();
    215         } catch (IllegalArgumentException e) {
    216             // test passes; ignore
    217         }
    218
    219         try {
    220             Setting.create(null, 0);
    221             fail();
    222         } catch (IllegalArgumentException e) {
    223             // test passes; ignore
    224         }
    225
    226         try {
    227             new Setting<Integer>(" ", null) {
    228             };
    229             fail();
    230         } catch (IllegalArgumentException e) {
    231             // test passes; ignore
    232         }
    233
    234         try {
    235             Setting.create(" ", 0);
    236             fail();
    237         } catch (IllegalArgumentException e) {
    238             // test passes; ignore
    239         }
    240
    241         try {
    242             Setting.create("foo", List.class, null);
    243             fail();
    244         } catch (IllegalArgumentException e) {
    245             // test passes; ignore
    246         }
    247
    248         try {
    249             Setting.create("foo", boolean.class, null);
    250             fail();
    251         } catch (IllegalArgumentException e) {
    252             // test passes; ignore
    253         }
    254
    255         try {
    256             Setting.create("foo", Integer[].class, null);
    257             fail();
    258         } catch (IllegalArgumentException e) {
    259             // test passes; ignore
    260         }
    261
    262         try {
    263             new Setting<Integer[]>("foo", null) {
    264             };
    265             fail();
    266         } catch (IllegalArgumentException e) {
    267             // test passes; ignore
    268         }
    269
    270         try {
    271             new Setting<List<Integer>[]>("foo", null) {
    272             };
    273             fail();
    274         } catch (IllegalArgumentException e) {
    275             // test passes; ignore
    276         }
    277
    278         class BadKeyCreator {
    279             private <V> void badKey() {
    280                 new Setting<V>("foo", null) {
    281                 };
    282             }
    283         }
    284
    285         try {
    286             new BadKeyCreator().badKey();
    287             fail();
    288         } catch (IllegalArgumentException e) {
    289             // test passes; ignore
    290         }
    291     }
    292
    293 }