unit testing for signal system & service manager

buildNumber.properties

@@ -1,3 +1,3 @@
 #maven.buildNumber.plugin properties file
-#Wed Aug 28 20:50:08 EDT 2024
+#Thu Aug 29 20:24:54 EDT 2024
-buildNumber=300
+buildNumber=301

pom.xml

@@ -172,6 +172,17 @@
             <version>${junit.version}</version>
         </dependency>
 
+        <!--Mockito-->
+        <!--License: MIT-->
+        <!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.12.0</version>
+            <scope>test</scope>
+        </dependency>
+
+
         <!--GraalVM-->
         <!--License: GPLv2 w/ classpath exception-->
         <!--apparently maybe classpath exception allows use in eg game engine??-->

src/main/java/electrosphere/engine/signal/Signal.java

@@ -12,8 +12,14 @@ public class Signal {
      */
     public static enum SignalType {
 
+        //
+        //CORE ENGINE
+        //
+        ENGINE_SHUTDOWN,
 
+        //
         //UI
+        //
         APPLY_YOGA,
 
     }

src/main/java/electrosphere/engine/signal/SignalSystem.java

@@ -8,6 +8,7 @@ import java.util.concurrent.Semaphore;
 
 import electrosphere.engine.service.Service;
 import electrosphere.engine.signal.Signal.SignalType;
+import electrosphere.logger.LoggerInterface;
 
 /**
  * The core messaging system
@@ -52,6 +53,7 @@ public class SignalSystem implements Service {
      */
     public void registerService(SignalType signalType, SignalService service){
         systemLock.acquireUninterruptibly();
+        LoggerInterface.loggerEngine.DEBUG("[SignalSystem] Register signal service " + service.getName());
         if(typeServiceMap.containsKey(signalType)){
             Set<SignalService> services = this.typeServiceMap.get(signalType);
             if(!services.contains(service)){
@@ -72,6 +74,7 @@ public class SignalSystem implements Service {
      */
     public void deregisterService(SignalType signalType, SignalService service){
         systemLock.acquireUninterruptibly();
+        LoggerInterface.loggerEngine.DEBUG("[SignalSystem] Deregister signal service " + service.getName());
         if(typeServiceMap.containsKey(signalType)){
             Set<SignalService> services = this.typeServiceMap.get(signalType);
             services.remove(service);
@@ -89,6 +92,7 @@ public class SignalSystem implements Service {
     public void post(SignalType type, Object data){
         systemLock.acquireUninterruptibly();
         if(typeServiceMap.containsKey(type)){
+            LoggerInterface.loggerEngine.DEBUG("[SignalSystem] Post signal " + type);
             Signal signal = Signal.create(type, data);
             Set<SignalService> services = this.typeServiceMap.get(type);
             for(SignalService service : services){

src/test/java/annotations/BigDataTest.java

@@ -0,0 +1,26 @@
+package annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.ElementType;
+
+import java.util.concurrent.TimeUnit;
+
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.api.Timeout.ThreadMode;
+
+/**
+ * A fast test that does not depend on setup/shutdown -- A unit test
+ */
+
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Tag("fast")
+@Test
+@Timeout( value = 100, unit = TimeUnit.MILLISECONDS, threadMode = ThreadMode.SAME_THREAD )
+public @interface BigDataTest {
+    
+}

src/test/java/annotations/FastSetup.java

@@ -0,0 +1,5 @@
+package annotations;
+
+public class FastSetup {
+    
+}

src/test/java/annotations/FastTest.java

@@ -20,7 +20,7 @@ import org.junit.jupiter.api.Timeout.ThreadMode;
 @Retention(RetentionPolicy.RUNTIME)
 @Tag("fast")
 @Test
-@Timeout( value = 20, unit = TimeUnit.MILLISECONDS, threadMode = ThreadMode.SAME_THREAD )
+@Timeout( value = 10, unit = TimeUnit.MILLISECONDS, threadMode = ThreadMode.SAME_THREAD )
 public @interface FastTest {
     
 }

src/test/java/electrosphere/engine/service/ServiceManagerTests.java

@@ -0,0 +1,102 @@
+package electrosphere.engine.service;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.mockito.Mockito;
+
+import annotations.BigDataTest;
+import annotations.FastTest;
+import electrosphere.logger.Logger;
+import electrosphere.logger.LoggerInterface;
+
+/**
+ * Service manager tests
+ */
+public class ServiceManagerTests {
+
+    @BeforeEach
+    public void init(){
+        LoggerInterface.loggerEngine = Mockito.mock(Logger.class);
+    }
+
+    @FastTest
+    public void testInit(){
+        ServiceManager serviceManager = new ServiceManager();
+        serviceManager.init();
+    }
+
+    @FastTest
+    public void testRegisterService(){
+        ServiceManager serviceManager = new ServiceManager();
+        serviceManager.init();
+        Service service1Mock = Mockito.mock(Service.class);
+        Service service1 = serviceManager.registerService(service1Mock);
+        assertEquals(service1Mock,service1);
+    }
+
+    @FastTest
+    public void testRegisterTwoServices(){
+        ServiceManager serviceManager = new ServiceManager();
+        serviceManager.init();
+        Service service1Mock = Mockito.mock(Service.class);
+        Service service1 = serviceManager.registerService(service1Mock);
+        Service service2Mock = Mockito.mock(Service.class);
+        Service service2 = serviceManager.registerService(service2Mock);
+        assertEquals(service1Mock,service1);
+        assertEquals(service2Mock,service2);
+    }
+
+    @BigDataTest
+    public void testRegisterManyServices(){
+        ServiceManager serviceManager = new ServiceManager();
+        serviceManager.init();
+        for(int i = 0; i < 10; i++){
+            serviceManager.registerService(Mockito.mock(Service.class));
+        }
+        Service lastMock = Mockito.mock(Service.class);
+        Service lastService = serviceManager.registerService(lastMock);
+        assertEquals(lastMock,lastService);
+    }
+
+    @FastTest
+    public void testInstantiate(){
+        ServiceManager serviceManager = new ServiceManager();
+        serviceManager.init();
+
+        //register service
+        Service service1Mock = Mockito.spy(Service.class);
+        Service service1 = serviceManager.registerService(service1Mock);
+        assertEquals(service1Mock,service1);
+
+        //instantiate all services
+        serviceManager.instantiate();
+
+        //verify init was called
+        Mockito.verify(service1Mock, Mockito.calls(1)).init();
+    }
+
+    @FastTest
+    public void testDestroy(){
+        ServiceManager serviceManager = new ServiceManager();
+        serviceManager.init();
+
+        //register service
+        Service service1Mock = Mockito.spy(Service.class);
+        Service service1 = serviceManager.registerService(service1Mock);
+        assertEquals(service1Mock,service1);
+
+        //instantiate all services
+        serviceManager.instantiate();
+
+        //verify init was called
+        Mockito.verify(service1Mock, Mockito.calls(1)).init();
+
+        //destroy
+        serviceManager.destroy();
+
+        //verify destroy was called
+        Mockito.verify(service1Mock, Mockito.calls(1)).destroy();
+    }
+    
+}

src/test/java/electrosphere/engine/signal/SignalSystemTests.java

@@ -0,0 +1,105 @@
+package electrosphere.engine.signal;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import electrosphere.engine.signal.Signal.SignalType;
+import electrosphere.logger.Logger;
+import electrosphere.logger.LoggerInterface;
+
+/**
+ * Testing the signal system
+ */
+public class SignalSystemTests {
+
+    ArgumentCaptor<Signal> signalCaptor;
+
+    @BeforeEach
+    public void init(){
+        LoggerInterface.loggerEngine = Mockito.mock(Logger.class);
+        signalCaptor = ArgumentCaptor.forClass(Signal.class);
+    }
+    
+
+    @Test
+    public void testInit(){
+        SignalSystem signalSystem = new SignalSystem();
+        signalSystem.init();
+    }
+
+    @Test
+    public void testRegister(){
+        SignalSystem signalSystem = new SignalSystem();
+        signalSystem.init();
+
+        SignalService service = Mockito.mock(SignalService.class);
+
+        signalSystem.registerService(SignalType.APPLY_YOGA, service);
+    }
+
+    
+    @Test
+    public void testPost(){
+        SignalSystem signalSystem = new SignalSystem();
+        signalSystem.init();
+
+        SignalService service = Mockito.mock(SignalService.class);
+        signalSystem.registerService(SignalType.APPLY_YOGA, service);
+
+        signalSystem.post(SignalType.APPLY_YOGA);
+
+        Mockito.verify(service, Mockito.times(1)).post(signalCaptor.capture());
+    }
+
+    @Test
+    public void testMultiPost(){
+        SignalSystem signalSystem = new SignalSystem();
+        signalSystem.init();
+
+        SignalService service = Mockito.mock(SignalService.class);
+        SignalService service2 = Mockito.mock(SignalService.class);
+        signalSystem.registerService(SignalType.APPLY_YOGA, service);
+        signalSystem.registerService(SignalType.APPLY_YOGA, service2);
+
+        signalSystem.post(SignalType.APPLY_YOGA);
+
+        Mockito.verify(service, Mockito.times(1)).post(signalCaptor.capture());
+        Mockito.verify(service2, Mockito.times(1)).post(signalCaptor.capture());
+    }
+
+    @Test
+    public void testPostFiltering(){
+        SignalSystem signalSystem = new SignalSystem();
+        signalSystem.init();
+
+        SignalService service = Mockito.mock(SignalService.class);
+        SignalService service2 = Mockito.mock(SignalService.class);
+        SignalService service3 = Mockito.mock(SignalService.class);
+        signalSystem.registerService(SignalType.APPLY_YOGA, service);
+        signalSystem.registerService(SignalType.APPLY_YOGA, service2);
+        signalSystem.registerService(SignalType.ENGINE_SHUTDOWN, service3);
+
+        signalSystem.post(SignalType.APPLY_YOGA);
+
+        Mockito.verify(service, Mockito.times(1)).post(signalCaptor.capture());
+        Mockito.verify(service2, Mockito.times(1)).post(signalCaptor.capture());
+        Mockito.verify(service3, Mockito.never()).post(signalCaptor.capture());
+    }
+
+
+    @Test
+    public void testDeregister(){
+        SignalSystem signalSystem = new SignalSystem();
+        signalSystem.init();
+
+        SignalService service = Mockito.mock(SignalService.class);
+        signalSystem.registerService(SignalType.APPLY_YOGA, service);
+        signalSystem.deregisterService(SignalType.APPLY_YOGA, service);
+        signalSystem.post(SignalType.APPLY_YOGA);
+
+        Mockito.verify(service, Mockito.never()).post(signalCaptor.capture());
+    }
+
+}

src/test/java/electrosphere/util/ds/OctreeTests.java

@@ -12,6 +12,7 @@ import java.util.Random;
 
 import org.joml.Vector3d;
 
+import annotations.BigDataTest;
 import annotations.FastTest;
 import electrosphere.util.ds.Octree.OctreeNode;
 
@@ -265,7 +266,7 @@ public class OctreeTests {
     /**
      * Adds lots of (random) points
      */
-    @FastTest
+    @BigDataTest
     public void testAddManyPoints(){
         Octree<Integer> octree = new Octree<Integer>(new Vector3d(0,0,0), new Vector3d(256,256,256));