common/onap-common-configuration-management/onap-configuration-management-core/src/test/java/org/onap/config/ConfigurationUtilsTest.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   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  * Modifications Copyright (c) 2019 Samsung
  17  *
  18  */
  19
  20 package org.onap.config;
  21
  22 import static java.util.stream.Collectors.toList;
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertNull;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.junit.Assert.assertFalse;
  28
  29 import java.lang.reflect.Array;
  30 import java.lang.reflect.Field;
  31 import java.util.ArrayDeque;
  32 import java.util.ArrayList;
  33 import java.util.Arrays;
  34 import java.util.Collection;
  35 import java.util.Deque;
  36 import java.util.HashSet;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Queue;
  40 import java.util.Set;
  41 import java.util.SortedSet;
  42 import java.util.TreeSet;
  43 import java.util.concurrent.BlockingQueue;
  44 import java.util.concurrent.ConcurrentLinkedQueue;
  45 import java.util.concurrent.LinkedBlockingQueue;
  46 import java.util.concurrent.LinkedTransferQueue;
  47 import java.util.concurrent.TransferQueue;
  48 import java.util.stream.Collectors;
  49 import java.util.stream.IntStream;
  50 import java.util.stream.Stream;
  51
  52 import org.junit.Test;
  53
  54 public class ConfigurationUtilsTest {
  55
  56     @Test
  57     public void testCommaList() {
  58         List<?> list = Arrays.asList("1", "2", 3);
  59         String commaSeparatedList = ConfigurationUtils.getCommaSeparatedList(list);
  60         list.forEach(o -> assertTrue(commaSeparatedList.contains(o.toString())));
  61     }
  62
  63     @Test
  64     public void testCommaListWithNullAndEmptyStrings() {
  65         List list = Arrays.asList(null, "", " ");
  66         String commaSeparatedList = ConfigurationUtils.getCommaSeparatedList(list);
  67         assertTrue(commaSeparatedList.isEmpty());
  68     }
  69
  70     @Test
  71     public void testGetArrayClassFunction() {
  72         assertEquals(String[].class, ConfigurationUtils.getArrayClass(String.class));
  73         assertNull(ConfigurationUtils.getArrayClass(ConfigurationUtilsTest.class));
  74     }
  75
  76     @Test
  77     public void testGetCollectionGenericType() throws NoSuchFieldException {
  78
  79         class DummyClass {
  80             public Map<String, String> testParameterizedTypeField;
  81         }
  82         Field field = DummyClass.class.getField("testParameterizedTypeField");
  83         assertEquals(String.class, ConfigurationUtils.getCollectionGenericType(field));
  84     }
  85
  86     @Test
  87     public void testCastingArray() {
  88         int arraySize = 2;
  89         final Class[] primitiveType = new Class[]{boolean.class, byte.class,
  90                 double.class, float.class, int.class, long.class, short.class};
  91
  92         for (Class clazz: primitiveType) {
  93             Class expectedResultClass = Array.newInstance(clazz, 0).getClass();
  94             List defaultCollection = IntStream.range(0, arraySize).mapToObj(i ->
  95                     ConfigurationUtils.getDefaultFor(clazz)).collect(toList());
  96
  97             Object resultArray = ConfigurationUtils.getPrimitiveArray(defaultCollection, clazz);
  98
  99             assertNotNull(resultArray);
 100             assertFalse(ConfigurationUtils.isZeroLengthArray(expectedResultClass, resultArray));
 101             assertNotNull(expectedResultClass.cast(resultArray));
 102         }
 103     }
 104
 105     @Test(expected = IllegalArgumentException.class)
 106     public void testGetCompatibleCollection() {
 107         final Map<Class, Class> testClasses = Stream.of(new Class[][] {
 108                 {BlockingQueue.class, LinkedBlockingQueue.class},
 109                 {TransferQueue.class, LinkedTransferQueue.class},
 110                 {Deque.class, ArrayDeque.class},
 111                 {Queue.class, ConcurrentLinkedQueue.class},
 112                 {SortedSet.class, TreeSet.class},
 113                 {Set.class, HashSet.class},
 114                 {List.class, ArrayList.class}
 115         }).collect(Collectors.toMap(data -> data[0], data -> data[1]));
 116
 117         testClasses.forEach((entryClass, expResultClass) -> {
 118                 Class resultClass = ConfigurationUtils.getCompatibleCollectionForAbstractDef(entryClass).getClass();
 119                 assertEquals(expResultClass, resultClass);
 120             }
 121         );
 122
 123         ConfigurationUtils.getCompatibleCollectionForAbstractDef(Collection.class);
 124
 125     }
 126 }