diff --git a/buildNumber.properties b/buildNumber.properties index a7af7434..8b7eeccf 100644 --- a/buildNumber.properties +++ b/buildNumber.properties @@ -1,3 +1,3 @@ #maven.buildNumber.plugin properties file -#Wed Aug 28 20:50:08 EDT 2024 -buildNumber=300 +#Thu Aug 29 20:24:54 EDT 2024 +buildNumber=301 diff --git a/pom.xml b/pom.xml index df9902e5..4c2db0b5 100644 --- a/pom.xml +++ b/pom.xml @@ -172,6 +172,17 @@ ${junit.version} + + + + + org.mockito + mockito-core + 5.12.0 + test + + + diff --git a/src/main/java/electrosphere/engine/signal/Signal.java b/src/main/java/electrosphere/engine/signal/Signal.java index 324803dc..0d9ffb5c 100644 --- a/src/main/java/electrosphere/engine/signal/Signal.java +++ b/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, } diff --git a/src/main/java/electrosphere/engine/signal/SignalSystem.java b/src/main/java/electrosphere/engine/signal/SignalSystem.java index f9db0470..70e22053 100644 --- a/src/main/java/electrosphere/engine/signal/SignalSystem.java +++ b/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 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 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 services = this.typeServiceMap.get(type); for(SignalService service : services){ diff --git a/src/test/java/annotations/BigDataTest.java b/src/test/java/annotations/BigDataTest.java new file mode 100644 index 00000000..089a032e --- /dev/null +++ b/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 { + +} \ No newline at end of file diff --git a/src/test/java/annotations/FastSetup.java b/src/test/java/annotations/FastSetup.java new file mode 100644 index 00000000..4eb093ae --- /dev/null +++ b/src/test/java/annotations/FastSetup.java @@ -0,0 +1,5 @@ +package annotations; + +public class FastSetup { + +} diff --git a/src/test/java/annotations/FastTest.java b/src/test/java/annotations/FastTest.java index c66b9a82..fb583f96 100644 --- a/src/test/java/annotations/FastTest.java +++ b/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 { } diff --git a/src/test/java/electrosphere/engine/service/ServiceManagerTests.java b/src/test/java/electrosphere/engine/service/ServiceManagerTests.java new file mode 100644 index 00000000..0f44691e --- /dev/null +++ b/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(); + } + +} diff --git a/src/test/java/electrosphere/engine/signal/SignalSystemTests.java b/src/test/java/electrosphere/engine/signal/SignalSystemTests.java new file mode 100644 index 00000000..62c96af5 --- /dev/null +++ b/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 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()); + } + +} diff --git a/src/test/java/electrosphere/util/ds/OctreeTests.java b/src/test/java/electrosphere/util/ds/OctreeTests.java index 8490334e..30d74bc5 100644 --- a/src/test/java/electrosphere/util/ds/OctreeTests.java +++ b/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 octree = new Octree(new Vector3d(0,0,0), new Vector3d(256,256,256));