Test coverage

microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/MethodUtils.java

@@ -35,11 +35,12 @@
 import static io.microsphere.annotation.processor.util.MemberUtils.matchParameterTypes;
 import static io.microsphere.annotation.processor.util.TypeUtils.getHierarchicalTypes;
 import static io.microsphere.annotation.processor.util.TypeUtils.ofDeclaredType;
+import static io.microsphere.collection.CollectionUtils.addAll;
 import static io.microsphere.filter.FilterUtils.filter;
 import static io.microsphere.lang.function.Predicates.EMPTY_PREDICATE_ARRAY;
 import static io.microsphere.lang.function.Streams.filterAll;
 import static io.microsphere.lang.function.Streams.filterFirst;
-import static java.util.Arrays.asList;
+import static io.microsphere.collection.Lists.ofList;
 import static java.util.Collections.emptyList;
 import static javax.lang.model.element.ElementKind.METHOD;
 import static javax.lang.model.util.ElementFilter.methodsIn;
@@ -106,7 +107,7 @@ static ExecutableElement findMethod(TypeElement type, String methodName, Type on
     static ExecutableElement findMethod(TypeMirror type, String methodName, Type oneParameterType, Type... otherParameterTypes) {
         List<Type> parameterTypes = new LinkedList<>();
         parameterTypes.add(oneParameterType);
-        parameterTypes.addAll(asList(otherParameterTypes));
+        addAll(parameterTypes, otherParameterTypes);
         return findMethod(type, methodName, parameterTypes.stream().map(Type::getTypeName).toArray(String[]::new));
     }
 

microsphere-annotation-processor/src/main/java/io/microsphere/annotation/processor/util/TypeUtils.java

@@ -43,7 +43,7 @@
 import static io.microsphere.lang.function.Streams.filterFirst;
 import static io.microsphere.reflect.MethodUtils.invokeMethod;
 import static java.lang.String.valueOf;
-import static java.util.Arrays.asList;
+import static io.microsphere.collection.Lists.ofList;
 import static java.util.Collections.emptyList;
 import static java.util.Collections.emptySet;
 import static java.util.stream.Collectors.toSet;
@@ -61,7 +61,7 @@
  */
 public interface TypeUtils {
 
-    List<String> SIMPLE_TYPES = asList(
+    List<String> SIMPLE_TYPES = ofList(
             ClassUtils.SIMPLE_TYPES
                     .stream()
                     .map(Class::getName)

microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/Compiler.java

@@ -29,7 +29,8 @@
 import java.util.LinkedHashSet;
 import java.util.Set;
 
-import static java.util.Arrays.asList;
+import static io.microsphere.collection.CollectionUtils.addAll;
+import static io.microsphere.collection.Lists.ofList;
 
 /**
  * The Java Compiler
@@ -84,7 +85,7 @@ private static File detectClassPath(Class<?> targetClass) {
     }
 
     public Compiler processors(Processor... processors) {
-        this.processors.addAll(asList(processors));
+        addAll(this.processors, processors);
         return this;
     }
 
@@ -105,7 +106,7 @@ private File javaSourceFile(String sourceClassName) {
 
     public boolean compile(Class<?>... sourceClasses) {
         JavaCompiler.CompilationTask task = javaCompiler.getTask(null, this.javaFileManager, null,
-                asList("-parameters", "-Xlint:unchecked", "-nowarn", "-Xlint:deprecation"),
+                ofList("-parameters", "-Xlint:unchecked", "-nowarn", "-Xlint:deprecation"),
 //                null,
                 null, getJavaFileObjects(sourceClasses));
         if (!processors.isEmpty()) {

microsphere-annotation-processor/src/test/java/io/microsphere/annotation/processor/util/TypeUtilsTest.java

@@ -68,7 +68,7 @@
 import static io.microsphere.annotation.processor.util.TypeUtils.ofDeclaredType;
 import static io.microsphere.annotation.processor.util.TypeUtils.ofDeclaredTypes;
 import static io.microsphere.annotation.processor.util.TypeUtils.ofTypeElement;
-import static java.util.Arrays.asList;
+import static io.microsphere.collection.Lists.ofList;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -415,7 +415,7 @@ public void testOfTypeElement() {
 
     @Test
     public void testOfDeclaredTypes() {
-        Set<DeclaredType> declaredTypes = ofDeclaredTypes(asList(getType(String.class), getType(TestServiceImpl.class), getType(Color.class)));
+        Set<DeclaredType> declaredTypes = ofDeclaredTypes(ofList(getType(String.class), getType(TestServiceImpl.class), getType(Color.class)));
         assertTrue(declaredTypes.contains(getType(String.class).asType()));
         assertTrue(declaredTypes.contains(getType(TestServiceImpl.class).asType()));
         assertTrue(declaredTypes.contains(getType(Color.class).asType()));
@@ -425,24 +425,24 @@ public void testOfDeclaredTypes() {
 
     @Test
     public void testListDeclaredTypes() {
-        List<DeclaredType> types = listDeclaredTypes(asList(testType, testType, testType));
+        List<DeclaredType> types = listDeclaredTypes(ofList(testType, testType, testType));
         assertEquals(1, types.size());
         assertEquals(ofDeclaredType(testType), types.get(0));
 
-        types = listDeclaredTypes(asList(new Element[]{null}));
+        types = listDeclaredTypes(ofList(new Element[]{null}));
         assertTrue(types.isEmpty());
     }
 
     @Test
     public void testListTypeElements() {
-        List<TypeElement> typeElements = listTypeElements(asList(testType.asType(), ofDeclaredType(testType)));
+        List<TypeElement> typeElements = listTypeElements(ofList(testType.asType(), ofDeclaredType(testType)));
         assertEquals(1, typeElements.size());
         assertEquals(testType, typeElements.get(0));
 
-        typeElements = listTypeElements(asList(types.getPrimitiveType(TypeKind.BYTE), types.getNullType(), types.getNoType(TypeKind.NONE)));
+        typeElements = listTypeElements(ofList(types.getPrimitiveType(TypeKind.BYTE), types.getNullType(), types.getNoType(TypeKind.NONE)));
         assertTrue(typeElements.isEmpty());
 
-        typeElements = listTypeElements(asList(new TypeMirror[]{null}));
+        typeElements = listTypeElements(ofList(new TypeMirror[]{null}));
         assertTrue(typeElements.isEmpty());
 
         typeElements = listTypeElements(null);

microsphere-java-core/src/main/java/io/microsphere/classloading/WindowsRedefinedClassLoader.java

@@ -11,7 +11,6 @@
 import java.net.URLClassLoader;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
 import java.util.Enumeration;
 import java.util.LinkedList;
 import java.util.List;
@@ -20,6 +19,7 @@
 import java.util.TreeMap;
 import java.util.TreeSet;
 
+import static io.microsphere.collection.CollectionUtils.addAll;
 import static io.microsphere.collection.MapUtils.isEmpty;
 import static io.microsphere.constants.SeparatorConstants.LINE_SEPARATOR;
 import static io.microsphere.io.IOUtils.toByteArray;
@@ -162,7 +162,7 @@ private static SortedSet<String> loadRedefinedClassNames(ClassLoader classLoader
                 try (InputStream inputStream = resource.openStream()) {
                     String configContent = IOUtils.toString(inputStream, charset);
                     String[] classNames = split(configContent, LINE_SEPARATOR);
-                    redefinedClassNames.addAll(Arrays.asList(classNames));
+                    addAll(redefinedClassNames, classNames);
                 }
             }
         } catch (IOException e) {

microsphere-java-core/src/main/java/io/microsphere/collection/ListUtils.java

@@ -54,6 +54,14 @@ public static <E> List<E> of(E... elements) {
         return unmodifiableList(asList(elements));
     }
 
+    /**
+     * Create a {@link List} from the specified array
+     *
+     * @param elements
+     * @param <E>
+     * @return
+     * @see {@link Lists#ofList} as recommended
+     */
     public static <E> List<E> ofList(E... elements) {
         return of(elements);
     }

microsphere-java-core/src/main/java/io/microsphere/collection/MapUtils.java

@@ -35,6 +35,7 @@
 import java.util.function.Function;
 
 import static io.microsphere.collection.CollectionUtils.size;
+import static io.microsphere.util.ArrayUtils.length;
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.singletonMap;
 import static java.util.Collections.unmodifiableMap;
@@ -51,7 +52,12 @@ public abstract class MapUtils extends BaseUtils {
     /**
      * The min load factor for {@link HashMap} or {@link Hashtable}
      */
-    public static final float MIN_LOAD_FACTOR = 1.0f;
+    public static final float MIN_LOAD_FACTOR = Float.MIN_VALUE;
+
+    /**
+     * The fixed load factor for {@link HashMap} or {@link Hashtable} = 1.00
+     */
+    protected static final float FIXED_LOAD_FACTOR = 1.00f;
 
     public static boolean isEmpty(Map<?, ?> map) {
         return map == null || map.isEmpty();
@@ -62,7 +68,7 @@ public static boolean isNotEmpty(Map<?, ?> map) {
     }
 
     public static <K, V> Map<K, V> of(K key, V value) {
-        return singletonMap(key, value);
+        return ofMap(key, value);
     }
 
     public static <K, V> Map<K, V> of(K key1, V value1, K key2, V value2) {
@@ -85,9 +91,17 @@ public static Map of(Object... values) {
         return ofMap(values);
     }
 
+    public static <K, V> Map<K, V> ofMap(K key, V value) {
+        return singletonMap(key, value);
+    }
+
     public static Map ofMap(Object... keyValuePairs) {
-        int length = keyValuePairs.length;
-        Map map = new HashMap(length / 2, MIN_LOAD_FACTOR);
+        int length = length(keyValuePairs);
+        if (length < 1) {
+            return emptyMap();
+        }
+        int size = length / 2;
+        Map map = newFixedLinkedHashMap(size);
         for (int i = 0; i < length; ) {
             map.put(keyValuePairs[i++], keyValuePairs[i++]);
         }
@@ -191,14 +205,22 @@ public static <K, V> Map<K, V> shallowCloneMap(@Nonnull Map<K, V> source) {
         }
     }
 
+    public static <K, V> Map<K, V> newFixedHashMap(int size) {
+        return newHashMap(size, FIXED_LOAD_FACTOR);
+    }
+
+    public static <K, V> Map<K, V> newFixedLinkedHashMap(int size) {
+        return newLinkedHashMap(size, FIXED_LOAD_FACTOR);
+    }
+
     public static <K, V, E> Map<K, V> toFixedMap(Collection<E> values,
                                                  Function<E, Map.Entry<K, V>> entryMapper) {
         int size = size(values);
         if (size < 1) {
             return emptyMap();
         }
 
-        Map<K, V> fixedMap = newHashMap(size, MIN_LOAD_FACTOR);
+        Map<K, V> fixedMap = newFixedLinkedHashMap(size);
 
         for (E value : values) {
             Map.Entry<K, V> entry = entryMapper.apply(value);

microsphere-java-core/src/main/java/io/microsphere/collection/SetUtils.java

@@ -28,7 +28,7 @@
 import java.util.Set;
 
 import static io.microsphere.collection.CollectionUtils.size;
-import static io.microsphere.collection.MapUtils.MIN_LOAD_FACTOR;
+import static io.microsphere.collection.MapUtils.FIXED_LOAD_FACTOR;
 import static io.microsphere.util.ArrayUtils.length;
 import static java.util.Collections.emptySet;
 import static java.util.Collections.singleton;
@@ -55,14 +55,25 @@ public static boolean isSet(@Nullable Iterable<?> elements) {
      * @return read-only {@link Set}
      */
     public static <E> Set<E> of(E... elements) {
+        return ofSet(elements);
+    }
+
+    /**
+     * Convert to multiple elements to be {@link LinkedHashSet}
+     *
+     * @param elements one or more elements
+     * @param <E>      the type of <code>elements</code>
+     * @return read-only {@link Set}
+     */
+    public static <E> Set<E> ofSet(E... elements) {
         int size = length(elements);
         if (size < 1) {
             return emptySet();
         } else if (size == 1) {
             return singleton(elements[0]);
         }
 
-        Set<E> set = new LinkedHashSet<>(size);
+        Set<E> set = new LinkedHashSet<>(size, FIXED_LOAD_FACTOR);
 
         for (int i = 0; i < size; i++) {
             set.add(elements[i]);
@@ -108,31 +119,6 @@ public static <E> Set<E> ofSet(Iterable<E> elements) {
         return unmodifiableSet(newLinkedHashSet(elements));
     }
 
-    /**
-     * Convert to one or more elements to be a read-only {@link Set}
-     *
-     * @param one    one element
-     * @param others others elements
-     * @param <E>    the type of <code>elements</code>
-     * @return read-only {@link Set}
-     */
-    public static <E> Set<E> ofSet(E one, E... others) {
-        int othersSize = length(others);
-        if (othersSize < 1) {
-            return singleton(one);
-        }
-
-        Set<E> elements = new LinkedHashSet<>(othersSize + 1, MIN_LOAD_FACTOR);
-
-        elements.add(one);
-
-        for (int i = 0; i < othersSize; i++) {
-            elements.add(others[i]);
-        }
-
-        return unmodifiableSet(elements);
-    }
-
     public static <T> Set<T> ofSet(Collection<T> elements) {
         return ofSet(elements, null);
     }
@@ -148,7 +134,7 @@ public static <T> Set<T> ofSet(Collection<T> elements, T... others) {
 
         int size = valuesSize + othersSize;
 
-        Set<T> set = newLinkedHashSet(size, MIN_LOAD_FACTOR);
+        Set<T> set = newLinkedHashSet(size, FIXED_LOAD_FACTOR);
         // add elements
         set.addAll(elements);
 

microsphere-java-core/src/main/java/io/microsphere/event/Listenable.java

@@ -18,9 +18,9 @@
 
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
+import static io.microsphere.collection.CollectionUtils.addAll;
 import static java.util.stream.StreamSupport.stream;
 
 /**
@@ -73,7 +73,7 @@ default void addEventListeners(E listener, E... others) throws NullPointerExcept
             IllegalArgumentException {
         List<E> listeners = new ArrayList<>(1 + others.length);
         listeners.add(listener);
-        listeners.addAll(Arrays.asList(others));
+        addAll(listeners,others);
         addEventListeners(listeners);
     }
 

microsphere-java-core/src/main/java/io/microsphere/filter/FilterOperator.java

@@ -1,6 +1,6 @@
 package io.microsphere.filter;
 
-import java.lang.reflect.Array;
+import static io.microsphere.util.ArrayUtils.length;
 
 /**
  * {@link Filter} Operator enumeration , which contains {@link #AND}��{@link #OR}��{@link #XOR}
@@ -21,7 +21,7 @@ public enum FilterOperator {
     AND {
         @Override
         public <T> boolean accept(T filteredObject, Filter<T>... filters) {
-            int length = Array.getLength(filters);
+            int length = length(filters);
             if (length == 0)
                 return true;
             boolean success = true;
@@ -38,7 +38,7 @@ public <T> boolean accept(T filteredObject, Filter<T>... filters) {
     OR {
         @Override
         public <T> boolean accept(T filteredObject, Filter<T>... filters) {
-            int length = Array.getLength(filters);
+            int length = length(filters);
             if (length == 0)
                 return true;
             boolean success = false;
@@ -54,7 +54,7 @@ public <T> boolean accept(T filteredObject, Filter<T>... filters) {
     XOR {
         @Override
         public <T> boolean accept(T filteredObject, Filter<T>... filters) {
-            int length = Array.getLength(filters);
+            int length = length(filters);
             if (length == 0)
                 return true;
             boolean success = true;

microsphere-java-core/src/main/java/io/microsphere/net/CompositeURLStreamHandlerFactory.java

@@ -112,8 +112,6 @@ private void sortFactories(List<URLStreamHandlerFactory> factories) {
 
     @Override
     public String toString() {
-        String sb = "CompositeURLStreamHandlerFactory{" + "factories=" + factories +
-                '}';
-        return sb;
+        return "CompositeURLStreamHandlerFactory{" + "factories=" + factories + '}';
     }
 }

microsphere-java-core/src/main/java/io/microsphere/net/DelegatingURLStreamHandlerFactory.java

@@ -19,6 +19,8 @@
 import java.net.URLStreamHandler;
 import java.net.URLStreamHandlerFactory;
 
+import static io.microsphere.util.Assert.assertNotNull;
+
 /**
  * Delegating {@link URLStreamHandlerFactory}
  *
@@ -30,9 +32,7 @@ public class DelegatingURLStreamHandlerFactory implements URLStreamHandlerFactor
     private final URLStreamHandlerFactory delegate;
 
     public DelegatingURLStreamHandlerFactory(URLStreamHandlerFactory delegate) {
-        if (delegate == null) {
-            throw new NullPointerException("The 'delegate' argument must not be null!");
-        }
+        assertNotNull(delegate, () -> "The 'delegate' argument must not be null!");
         this.delegate = delegate;
     }