Test coverage

Increase test coverage

Change-Id: I43e3149d0d4b07dc8e260f3d5fac025197882f3a
Issue-ID: SDC-1673
Signed-off-by: siddharth0905 <siddharth.singh4@amdocs.com>

1 files changed, 302 insertions, 304 deletions

diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/CommonMethods.java b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/CommonMethods.java
index 5a4d3cbd0d..b2cc289676 100644
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/CommonMethods.java
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-utilities-lib/src/main/java/org/openecomp/core/utilities/CommonMethods.java
@@ -16,344 +16,342 @@
 
 package org.openecomp.core.utilities;
 
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+
 import org.apache.commons.collections4.MapUtils;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.StringUtils;
-import java.util.*;
-
-import java.lang.reflect.Array;
 
 /**
  * This class provides auxiliary static methods.
  */
 public class CommonMethods {
 
-  private static final char[] CHARS = new char[]{
-      '0', '1', '2', '3', '4', '5', '6', '7',
-      '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
-  };
-
-  /**
-   * Private default constructor to prevent instantiation of the class objects.
-   */
-  private CommonMethods() {
-  }
-
-  /**
-   * Checks whether the given collection is empty.
-   *
-   * @param collection A collection to be checked.
-   * @return <tt>true</tt> - if the collection is null or empty, <tt>false</tt> - otherwise.
-   */
-  public static boolean isEmpty(Collection<?> collection) {
-    return collection == null || collection.isEmpty();
-  }
-
-  /**
-   * Gets an universally unique identifier (UUID).
-   *
-   * @return String representation of generated UUID.
-   */
-  public static String nextUuId() {
-    UUID uuid = UUID.randomUUID();
-
-    StringBuilder buff = new StringBuilder(32);
-    long2string(uuid.getMostSignificantBits(), buff);
-    long2string(uuid.getLeastSignificantBits(), buff);
-
-    return buff.toString();
-  }
-
-  private static void long2string(long lng, StringBuilder buff) {
-    long value = lng;
-    for (int i = 0; i < 16; i++) {
-      long nextByte = value & 0xF000000000000000L;
-      value <<= 4;
-      boolean isNegative = nextByte < 0;
-      nextByte = nextByte >>> 60;
-
-      if (isNegative) {
-        nextByte |= 0x08;
-      }
-
-      buff.append(CHARS[(int) nextByte]);
+    private static final char[] CHARS = new char[] {
+            '0', '1', '2', '3', '4', '5', '6', '7',
+            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+    };
+
+    /**
+     * Private default constructor to prevent instantiation of the class objects.
+     */
+    private CommonMethods() {
     }
-  }
-
-  /**
-   * Concatenates two Java arrays. The method allocates a new array and copies
-   * all elements to it or returns one of input arrays if another one is
-   * empty.
-   *
-   * @param <T>   the type parameter
-   * @param left  Elements of this array will be copied to positions from 0 to <tt>left.length -
-   *              1</tt> in the target array.
-   * @param right Elements of this array will be copied to positions from <tt>left.length</tt> to
-   *              <tt>left.length + right.length</tt>
-   * @return A newly allocate Java array that accommodates elements of source (left/right) arrays
-    orone of source arrays if another is empty, <tt>null</tt> - otherwise.
-   */
-  @SuppressWarnings("unchecked")
-  public static <T> T[] concat(T[] left, T[] right) {
-    T[] res;
-
-    if (ArrayUtils.isEmpty(left)) {
-      res = right;
-    } else if (ArrayUtils.isEmpty(right)) {
-      res = left;
-    } else {
-      res = (T[]) Array.newInstance(left[0].getClass(), left.length + right.length);
-      System.arraycopy(left, 0, res, 0, left.length);
-      System.arraycopy(right, 0, res, left.length, right.length);
+
+    /**
+     * Gets an universally unique identifier (UUID).
+     *
+     * @return String representation of generated UUID.
+     */
+    public static String nextUuId() {
+        UUID uuid = UUID.randomUUID();
+
+        StringBuilder buff = new StringBuilder(32);
+        long2string(uuid.getMostSignificantBits(), buff);
+        long2string(uuid.getLeastSignificantBits(), buff);
+
+        return buff.toString();
     }
 
-    return res;
-  } // concat
-
-  /**
-   * New instance object.
-   *
-   * @param classname the classname
-   * @return the object
-   */
-  public static Object newInstance(String classname) {
-    return newInstance(classname, Object.class);
-  }
-
-  /**
-   * New instance t.
-   *
-   * @param <T>       the type parameter
-   * @param classname the classname
-   * @param cls       the cls
-   * @return the t
-   */
-  @SuppressWarnings("unchecked")
-  public static <T> T newInstance(String classname, Class<T> cls) {
-
-    if (StringUtils.isEmpty(classname)) {
-      throw new IllegalArgumentException();
+    private static void long2string(long lng, StringBuilder buff) {
+        long value = lng;
+        for (int i = 0; i < 16; i++) {
+            long nextByte = value & 0xF000000000000000L;
+            value <<= 4;
+            boolean isNegative = nextByte < 0;
+            nextByte = nextByte >>> 60;
+
+            if (isNegative) {
+                nextByte |= 0x08;
+            }
+
+            buff.append(CHARS[(int) nextByte]);
+        }
     }
 
-    if (cls == null) {
-      throw new IllegalArgumentException();
+    /**
+     * Concatenates two Java arrays. The method allocates a new array and copies
+     * all elements to it or returns one of input arrays if another one is
+     * empty.
+     *
+     * @param <T>   the type parameter
+     * @param left  Elements of this array will be copied to positions from 0 to <tt>left.length -
+     *              1</tt> in the target array.
+     * @param right Elements of this array will be copied to positions from <tt>left.length</tt> to
+     *              <tt>left.length + right.length</tt>
+     * @return A newly allocate Java array that accommodates elements of source (left/right) arrays
+     * or one of source arrays if another is empty, <tt>null</tt> - otherwise.
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T[] concat(T[] left, T[] right) {
+        T[] res;
+
+        if (ArrayUtils.isEmpty(left)) {
+            res = right;
+        } else if (ArrayUtils.isEmpty(right)) {
+            res = left;
+        } else {
+            res = (T[]) Array.newInstance(left[0].getClass(), left.length + right.length);
+            System.arraycopy(left, 0, res, 0, left.length);
+            System.arraycopy(right, 0, res, left.length, right.length);
+        }
+
+        return res;
+    } // concat
+
+    /**
+     * New instance object.
+     *
+     * @param classname the classname
+     * @return the object
+     */
+    public static Object newInstance(String classname) {
+        return newInstance(classname, Object.class);
     }
 
-    try {
-      Class<?> temp = Class.forName(classname);
+    /**
+     * New instance t.
+     *
+     * @param <T>       the type parameter
+     * @param classname the classname
+     * @param cls       the cls
+     * @return the t
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T newInstance(String classname, Class<T> cls) {
+
+        if (StringUtils.isEmpty(classname)) {
+            throw new IllegalArgumentException();
+        }
+
+        if (cls == null) {
+            throw new IllegalArgumentException();
+        }
+
+        try {
+            Class<?> temp = Class.forName(classname);
 
-      if (!cls.isAssignableFrom(temp)) {
-        throw new ClassCastException(
-            String.format("Failed to cast from '%s' to '%s'", classname, cls.getName()));
-      }
+            if (!cls.isAssignableFrom(temp)) {
+                throw new ClassCastException(
+                        String.format("Failed to cast from '%s' to '%s'", classname, cls.getName()));
+            }
 
-      Class<? extends T> impl = (Class<? extends T>) temp;
+            Class<? extends T> impl = (Class<? extends T>) temp;
 
-      return newInstance(impl);
-    } catch (ClassNotFoundException exception) {
-      throw new IllegalArgumentException(exception);
+            return newInstance(impl);
+        } catch (ClassNotFoundException exception) {
+            throw new IllegalArgumentException(exception);
+        }
     }
-  }
-
-  /**
-   * New instance t.
-   *
-   * @param <T> the type parameter
-   * @param cls the cls
-   * @return the t
-   */
-  public static <T> T newInstance(Class<T> cls) {
-    try {
-      return cls.newInstance();
-    } catch (InstantiationException | IllegalAccessException exception) {
-      throw new RuntimeException(exception);
+
+    /**
+     * New instance t.
+     *
+     * @param <T> the type parameter
+     * @param cls the cls
+     * @return the t
+     */
+    public static <T> T newInstance(Class<T> cls) {
+        try {
+            return cls.newInstance();
+        } catch (InstantiationException | IllegalAccessException exception) {
+            throw new RuntimeException(exception);
+        }
     }
-  }
-
-  /**
-   * Print stack trace string.
-   *
-   * @return the string
-   */
-  public static String printStackTrace() {
-    StringBuilder sb = new StringBuilder();
-    StackTraceElement[] trace = Thread.currentThread().getStackTrace();
-    for (StackTraceElement traceElement : trace) {
-      sb.append("\t  ").append(traceElement);
-      sb.append(System.lineSeparator());
+
+    /**
+     * Print stack trace string.
+     *
+     * @return the string
+     */
+    public static String printStackTrace() {
+        StringBuilder sb = new StringBuilder();
+        StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+        for (StackTraceElement traceElement : trace) {
+            sb.append("\t  ").append(traceElement);
+            sb.append(System.lineSeparator());
+        }
+        return sb.toString();
     }
-    return sb.toString();
-  }
-
-  /**
-   * Converts array of strings to comma-separated string.
-   *
-   * @param arr array of strings
-   * @return the string
-   */
-  public static String arrayToCommaSeparatedString(String[] arr) {
-    return arrayToSeparatedString(arr, ',');
-  }
-
-  /**
-   * Collection to comma separated string string.
-   *
-   * @param elementCollection the element collection
-   * @return the string
-   */
-  public static String collectionToCommaSeparatedString(Collection<String> elementCollection) {
-    return String.join(",", elementCollection);
-  }
-
-  /**
-   * Converts array of strings to string separated with specified character.
-   *
-   * @param arr       array of strings
-   * @param separator the separator
-   * @return the string
-   */
-  public static String arrayToSeparatedString(String[] arr, char separator) {
-    return String.join(Character.toString(separator), arr);
-  }
-
-  /**
-   * Converts array of strings to string separated with specified character.
-   *
-   * @param list      array of strings
-   * @param separator the separator
-   * @return the string
-   */
-  public static String listToSeparatedString(List<String> list, char separator) {
-    return String.join(Character.toString(separator), list);
-  }
-
-  /**
-   * Duplicate string with delimiter string.
-   *
-   * @param arg                  the arg
-   * @param separator            the separator
-   * @param numberOfDuplications the number of duplications
-   * @return the string
-   */
-  public static String duplicateStringWithDelimiter(String arg, char separator,
-                                                    int numberOfDuplications) {
-    StringBuilder sb = new StringBuilder();
-
-    for (int i = 0; i < numberOfDuplications; i++) {
-      if (i > 0) {
-        sb.append(separator);
-      }
-      sb.append(arg);
+
+    /**
+     * Converts array of strings to comma-separated string.
+     *
+     * @param arr array of strings
+     * @return the string
+     */
+    public static String arrayToCommaSeparatedString(String[] arr) {
+        return arrayToSeparatedString(arr, ',');
     }
-    return sb.toString();
-  }
-
-  /**
-   * To single element set set.
-   *
-   * @param <T>     the class of the objects in the set
-   * @param element the single element to be contained in the returned Set
-   * @return an immutable set containing only the specified object. The returned set is
-    serializable.
-   */
-  public static <T> Set<T> toSingleElementSet(T element) {
-    return Collections.singleton(element);
-
-  }
-
-  /**
-   * Merge lists of map list.
-   *
-   * @param <T>    the type parameter
-   * @param <S>    the type parameter
-   * @param target the target
-   * @param source the source
-   * @return the list
-   */
-  public static <T, S> List<Map<T, S>> mergeListsOfMap(List<Map<T, S>> target,
-                                                       List<Map<T, S>> source) {
-    List<Map<T, S>> retList = new ArrayList<>();
-    if (Objects.nonNull(target)) {
-      retList.addAll(target);
+
+    /**
+     * Collection to comma separated string string.
+     *
+     * @param elementCollection the element collection
+     * @return the string
+     */
+    public static String collectionToCommaSeparatedString(Collection<String> elementCollection) {
+        return String.join(",", elementCollection);
     }
 
-    if (Objects.nonNull(source)) {
-      for (Map<T, S> sourceMap : source) {
-        for (Map.Entry<T, S> entry : sourceMap.entrySet()) {
-          mergeEntryInList(entry.getKey(), entry.getValue(), retList);
-        }
-      }
+    /**
+     * Converts array of strings to string separated with specified character.
+     *
+     * @param arr       array of strings
+     * @param separator the separator
+     * @return the string
+     */
+    public static String arrayToSeparatedString(String[] arr, char separator) {
+        return String.join(Character.toString(separator), arr);
     }
-    return retList;
-  }
-
-  /**
-   * Merge lists list.
-   *
-   * @param <T>    the type parameter
-   * @param target the target
-   * @param source the source
-   * @return the list
-   */
-  public static <T> List<T> mergeLists(List<T> target, List<T> source) {
-    List<T> retList = new ArrayList<>();
-
-    if (Objects.nonNull(source)) {
-      retList.addAll(source);
+
+    /**
+     * Converts array of strings to string separated with specified character.
+     *
+     * @param list      array of strings
+     * @param separator the separator
+     * @return the string
+     */
+    public static String listToSeparatedString(List<String> list, char separator) {
+        return String.join(Character.toString(separator), list);
     }
-    if (Objects.nonNull(target)) {
-      retList.addAll(target);
+
+    /**
+     * Duplicate string with delimiter string.
+     *
+     * @param arg                  the arg
+     * @param separator            the separator
+     * @param numberOfDuplications the number of duplications
+     * @return the string
+     */
+    public static String duplicateStringWithDelimiter(String arg, char separator,
+                                                      int numberOfDuplications) {
+        StringBuilder sb = new StringBuilder();
+
+        for (int i = 0; i < numberOfDuplications; i++) {
+            if (i > 0) {
+                sb.append(separator);
+            }
+            sb.append(arg);
+        }
+        return sb.toString();
     }
 
-    return retList;
-  }
-
-  /**
-   * Merge entry in list.
-   *
-   * @param <T>    the type parameter
-   * @param <S>    the type parameter
-   * @param key    the key
-   * @param value  the value
-   * @param target the target
-   */
-  public static <T, S> void mergeEntryInList(T key, S value, List<Map<T, S>> target) {
-    boolean found = false;
-    for (Map<T, S> map : target) {
-      if (map.containsKey(key)) {
-        map.put(key, value);
-        found = true;
-      }
+    /**
+     * To single element set set.
+     *
+     * @param <T>     the class of the objects in the set
+     * @param element the single element to be contained in the returned Set
+     * @return an immutable set containing only the specified object. The returned set is
+     * serializable.
+     */
+    public static <T> Set<T> toSingleElementSet(T element) {
+        return Collections.singleton(element);
+
+    }
+
+    /**
+     * Merge lists of map list.
+     *
+     * @param <T>    the type parameter
+     * @param <S>    the type parameter
+     * @param target the target
+     * @param source the source
+     * @return the list
+     */
+    public static <T, S> List<Map<T, S>> mergeListsOfMap(List<Map<T, S>> target,
+                                                         List<Map<T, S>> source) {
+        List<Map<T, S>> retList = new ArrayList<>();
+        if (Objects.nonNull(target)) {
+            retList.addAll(target);
+        }
+
+        if (Objects.nonNull(source)) {
+            for (Map<T, S> sourceMap : source) {
+                for (Map.Entry<T, S> entry : sourceMap.entrySet()) {
+                    mergeEntryInList(entry.getKey(), entry.getValue(), retList);
+                }
+            }
+        }
+        return retList;
     }
 
-    if (!found) {
-      Map<T, S> newMap = new HashMap<>();
-      newMap.put(key, value);
-      target.add(newMap);
+    /**
+     * Merge lists list.
+     *
+     * @param <T>    the type parameter
+     * @param target the target
+     * @param source the source
+     * @return the list
+     */
+    public static <T> List<T> mergeLists(List<T> target, List<T> source) {
+        List<T> retList = new ArrayList<>();
+
+        if (Objects.nonNull(source)) {
+            retList.addAll(source);
+        }
+        if (Objects.nonNull(target)) {
+            retList.addAll(target);
+        }
+
+        return retList;
     }
-  }
-
-
-  /**
-   * Merge maps map.
-   *
-   * @param <T>    the type parameter
-   * @param <S>    the type parameter
-   * @param firstMap the firstMap
-   * @param secondMap the secondMap
-   * @return the map
-   * Second Map is overridden data from the first map
-   */
-  public static <T, S> Map<T, S> mergeMaps(Map<T, S> firstMap, Map<T, S> secondMap) {
-    Map<T, S> retMap = new HashMap<>();
-    if (MapUtils.isNotEmpty(firstMap)) {
-      retMap.putAll(firstMap);
+
+    /**
+     * Merge entry in list.
+     *
+     * @param <T>    the type parameter
+     * @param <S>    the type parameter
+     * @param key    the key
+     * @param value  the value
+     * @param target the target
+     */
+    public static <T, S> void mergeEntryInList(T key, S value, List<Map<T, S>> target) {
+        boolean found = false;
+        for (Map<T, S> map : target) {
+            if (map.containsKey(key)) {
+                map.put(key, value);
+                found = true;
+            }
+        }
+
+        if (!found) {
+            Map<T, S> newMap = new HashMap<>();
+            newMap.put(key, value);
+            target.add(newMap);
+        }
     }
-    if (MapUtils.isNotEmpty(secondMap)) {
-      retMap.putAll(secondMap);
+
+
+    /**
+     * Merge maps map.
+     *
+     * @param <T>       the type parameter
+     * @param <S>       the type parameter
+     * @param firstMap  the firstMap
+     * @param secondMap the secondMap
+     * @return the map
+     * Second Map is overridden data from the first map
+     */
+    public static <T, S> Map<T, S> mergeMaps(Map<T, S> firstMap, Map<T, S> secondMap) {
+        Map<T, S> retMap = new HashMap<>();
+        if (MapUtils.isNotEmpty(firstMap)) {
+            retMap.putAll(firstMap);
+        }
+        if (MapUtils.isNotEmpty(secondMap)) {
+            retMap.putAll(secondMap);
+        }
+        return retMap;
     }
-    return retMap;
-  }
 
 }