Adding assertions to tests to eliminate issues where tests need to be checked manually;

Author: LamGC

src/test/java/net/lamgc/utils/base/ArgumentsPropertiesTest.java

@@ -1,21 +1,45 @@
 package net.lamgc.utils.base;
 
 import net.lamgc.utils.base.ArgumentsProperties;
+import org.junit.Assert;
 import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.Arrays;
+import java.util.HashMap;
 
 public class ArgumentsPropertiesTest{
 
     private final String[] argsList = {"/a", "233", "/b : 12", "-c", "34", "-d:56", "--EF", "78", "--GH:90", "/IJ", "--KL", "-MN"};
 
+    private final static HashMap<String, String> valueList = new HashMap<>();
+
+    static {
+        valueList.put("a", "233");
+        valueList.put("b", "12");
+        valueList.put("c", "34");
+        valueList.put("d", "56");
+        valueList.put("EF", "78");
+        valueList.put("GH", "90");
+        valueList.put("IJ", "");
+        valueList.put("KL", "");
+        valueList.put("MN", "");
+    }
+
+
     @Test
     public void loadTest(){
+        Logger log = LoggerFactory.getLogger(ArgumentsPropertiesTest.class.getSimpleName());
         //解析参数
         ArgumentsProperties argsProperties = new ArgumentsProperties(argsList);
         System.out.println(Arrays.toString(argsProperties.getKeysWithFlag().toArray(new String[0])));
+        int count = 0;
         for(String key : argsProperties.keySet().toArray(new String[0])){
-            System.out.println(key + ": " + argsProperties.get(key));
+            String value =  argsProperties.get(key);
+            log.info("{}: {}", key, value);
+            Assert.assertEquals(value, valueList.get(key));
+
         }
     }
 

src/test/java/net/lamgc/utils/event/EventExecutorTest.java

@@ -2,14 +2,19 @@
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class EventExecutorTest {
 
+    private final Logger log = LoggerFactory.getLogger(EventExecutorTest.class.getSimpleName());
+
     @Test
     public void executorTest() throws IllegalAccessException, InterruptedException {
         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
@@ -25,19 +30,26 @@ public void executorTest() throws IllegalAccessException, InterruptedException {
                 throw new RuntimeException(e);
             }
         });
+        AtomicInteger invokeCount = new AtomicInteger();
         EventExecutor executor = new EventExecutor(threadPoolExecutor);
         SimpleEventHandler handler = new SimpleEventHandler("handler1");
         SimpleEventHandler handler2 = new SimpleEventHandler("handler2");
         executor.addHandler(handler);
         executor.addHandler(handler2);
-        executor.executor(new SimpleEventObject(1, "HelloWorld"));
+        executor.executor(new SimpleEventObject(1, "HelloWorld", invokeCount));
         Thread.sleep(500L);
-        System.out.println("OnlyHandlerTest-----");
-        System.out.println("Execute Count: " + executor.executor(handler2, new SimpleEventObject(1, "HelloWorld")));
+        Assert.assertEquals(invokeCount.get(), 2);
+        invokeCount.set(0);
+        log.info("SingleHandlerTest-----");
+        log.info("Execute Count: {}", executor.executor(handler2, new SimpleEventObject(1, "HelloWorld", invokeCount)));
         Thread.sleep(500L);
+        Assert.assertEquals(invokeCount.get(), 1);
+        invokeCount.set(0);
         executor.removeHandler(handler);
-        System.out.println("deleted Handler");
-        executor.executor(new SimpleEventObject(2, "HelloWorld123"));
+        log.info("deleted Handler");
+        executor.executor(new SimpleEventObject(2, "HelloWorld123", invokeCount));
+        Thread.sleep(500L);
+        Assert.assertEquals(invokeCount.get(), 1);
     }
 
     @Test
@@ -59,12 +71,14 @@ public void caughtExceptionTest() throws IllegalAccessException, InterruptedExce
 
         AtomicBoolean handlerException = new AtomicBoolean(false);
         executor.setEventUncaughtExceptionHandler((t, handler, handlerMethod, event, cause) -> {
-            System.out.println(
-                      "Thread: [" + t.getId() + "] " + t.getName() +
-                    ", Handler: " + handler.toString() +
-                    ", MethodName: " + handlerMethod.getName() +
-                    ", Event: " + event.getClass().getSimpleName() +
-                     " throw Exception: " + cause.getMessage());
+            log.info("Thread: [{}] {}, Handler: {}, MethodName: {}, Event: {} - throw Exception: {}",
+                    t.getId(),
+                    t.getName(),
+                    handler.toString(),
+                    handlerMethod.getName(),
+                    event.getClass().getSimpleName(),
+                    cause.getMessage()
+            );
             cause.printStackTrace();
             handlerException.set(true);
         });

src/test/java/net/lamgc/utils/event/SimpleEventHandler.java

@@ -10,6 +10,7 @@ public SimpleEventHandler(String flag){
 
     public void simpleEventHandler(SimpleEventObject event){
         System.out.println(this.toString() + "." + flag + " - [" + event.errorCode + "] " + event.msg);
+        event.invokeCount.incrementAndGet();
     }
 
     public void throwExceptionEvent(ExceptionThrowEvent event){

src/test/java/net/lamgc/utils/event/SimpleEventObject.java

@@ -1,13 +1,18 @@
 package net.lamgc.utils.event;
 
+import java.util.concurrent.atomic.AtomicInteger;
+
 public class SimpleEventObject implements EventObject {
 
     public int errorCode;
 
     public String msg;
 
-    public SimpleEventObject(int errorCode, String msg){
+    public AtomicInteger invokeCount;
+
+    public SimpleEventObject(int errorCode, String msg, AtomicInteger invokeCount){
         this.errorCode = errorCode;
         this.msg = msg;
+        this.invokeCount = invokeCount;
     }
 }