Testing

- Removed Cucumber
+ Add unit tests (not the best and sometimes fail because threading but
will work for now)
* TODO: Redocument methods as a few have changed and a number were never
documented in the first place

Author: ShadowLordAlpha

build.gradle

@@ -1,28 +1,26 @@
 apply plugin: 'java-library'
 apply plugin: 'eclipse'
 
-version = '0.5.0'
+version = '0.6.0'
 
 // Repositories, where to find dependencies
 repositories {
-    jcenter()
+	jcenter()
 }
 
 // Dependencies
 dependencies {
 
-    // The production code uses the SLF4J logging API at compile time
-    implementation 'org.slf4j:slf4j-api:1.7.21'
+	// The production code uses the SLF4J logging API at compile time
+	implementation 'org.slf4j:slf4j-api:1.7.21'
 
 	// Caffeine high performance cache library
 	implementation 'com.github.ben-manes.caffeine:caffeine:2.4.0'
 
-    // Testing stuff
-    testImplementation 'junit:junit:4.12'
-    testImplementation 'info.cukes:cucumber-junit:1.2.5'
-    testImplementation 'info.cukes:cucumber-java:1.2.5'
+	// Testing stuff
+	testImplementation 'junit:junit:4.12'
 }
 
 task wrapper(type: Wrapper) {
-    gradleVersion = '4.2.1'
+	gradleVersion = '4.2.1'
 }

settings.gradle

@@ -1,19 +1 @@
-/*
- * This settings file was auto generated by the Gradle buildInit task
- * by 'Josh' at '1/19/17 9:12 AM' with Gradle 2.14.1
- *
- * The settings file is used to specify which projects to include in your build.
- * In a single project build this file can be empty or even removed.
- *
- * Detailed information about configuring a multi-project build in Gradle can be found
- * in the user guide at https://docs.gradle.org/2.14.1/userguide/multi_project_builds.html
- */
-
-/*
-// To declare projects as part of a multi-project build use the 'include' method
-include 'shared'
-include 'api'
-include 'services:webservice'
-*/
-
 rootProject.name = 'Themis'

src/main/java/com/shadowcs/themis/EventManager.java

@@ -26,7 +26,9 @@ public EventManager(ExecutorService eService) {
 	}
 
 	public <V> EventManager addListener(Consumer<V> listener, Class<V> klass) {
-		lCache.get(klass).add(listener);
+		if(listener != null && klass != null) {
+			lCache.get(klass).add(listener);
+		}
 		return this;
 	}
 

src/main/java/com/shadowcs/themis/util/concurrent/ProcedureThreadFactory.java

@@ -29,9 +29,12 @@
 public class ProcedureThreadFactory extends DefaultThreadFactory {
 
 	private Runnable procedure;
+	
+	public ProcedureThreadFactory() {
+		this(null);
+	}
 
 	public ProcedureThreadFactory(Runnable procedure) {
-		super();
 		this.procedure = procedure;
 	}
 
@@ -40,7 +43,9 @@ public Thread newThread(Runnable r) {
 			if(procedure != null) {
 				procedure.run();
 			}
-			r.run();
+			if(r != null) {
+				r.run();
+			}
 		});
 	}
 }

src/main/java/com/shadowcs/themis/util/concurrent/ProvidedThreadFactory.java

@@ -23,7 +23,6 @@
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * An object that takes already started and provided threads and allows them to be used as part of a thread pool without
@@ -38,16 +37,17 @@
  */
 public class ProvidedThreadFactory implements ThreadFactory, AutoCloseable {
 
-	private AtomicInteger count = new AtomicInteger();
-	private Queue<ThreadWork> queue = new LinkedBlockingQueue<ThreadWork>();
+	private volatile Queue<ThreadWork> queue = new LinkedBlockingQueue<ThreadWork>();
+	private volatile Queue<ThreadWork> workQueue = queue;
 
 	public ProvidedThreadFactory() {
 
 	}
 
+	// TODO: document and maybe throw Interrupt as a different type?
 	// just a cleaner cede
 	public void cede() {
-		cede(null); // does nothing
+		cede(null);
 	}
 
 	/**
@@ -63,45 +63,31 @@ public void cede() {
 	 * @throws InterruptedException
 	 */
 	public void cede(Runnable procedure) {
-		count.incrementAndGet();
+		
 		ThreadWork work = new ThreadWork();
-		if(queue.offer(work)) {
-			if(procedure != null) {
-				new Thread(procedure, "procedure-cede").start(); // TODO: probably not name the thread
+		new Thread(procedure).start();
+		
+		while(queue != null && queue.offer(work)) {
+			try {
+				work.await();
+			} catch(InterruptedException e) {
+				return;
 			}
-			
-			do {
-				try {
-					work.await();
-				} catch(InterruptedException e) {
-					// Thread interrupted so we simply leave
-					// This is expected to be proper behavior
-					// e.printStackTrace();
-					count.decrementAndGet();
-					return;
-				}
-			} while(queue.offer(work));
 		}
-
-		count.decrementAndGet();
-		throw new RuntimeException("Failed to cede/recycle thread!");
 	}
 
 	public Thread newThread(Runnable r) {
-		ThreadWork work = queue.poll();
+		ThreadWork work = workQueue.poll();
 		if(work != null) { return new Thread(() -> work.submit(r)); }
 
 		return null;
 	}
 
 	@Override
 	public void close() {
-		Runnable work = () -> Thread.currentThread().interrupt();
 
-		// I might not need count but it works well for now
-		for(int i = 0; i < count.get(); i++) {
-			newThread(work).start();
-		}
+		queue = null;
+		workQueue.forEach(work -> work.submit(null));
 	}
 
 	private class ThreadWork {
@@ -115,7 +101,9 @@ public ThreadWork() {
 
 		public void await() throws InterruptedException {
 			sema.acquire();
-			rWork.run();
+			if(rWork != null) {
+				rWork.run();
+			}
 		}
 
 		public void submit(Runnable r) {

src/main/java/com/shadowcs/themis/util/concurrent/package-info.java

@@ -19,7 +19,7 @@
  */
 
 /**
- * Utility classes useful in assisting with the concurrent nature of the event framwork.
+ * Utility classes useful in assisting with the concurrent nature of the event framework.
  * 
  * @author Josh "ShadowLordAlpha"
  */

src/test/java/com/shadowcs/themis/test/CucumberRunner.java

@@ -0,0 +1,44 @@
+package com.shadowcs.themis.test;
+
+import static org.junit.Assert.assertEquals;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Test;
+import com.shadowcs.themis.util.concurrent.DefaultThreadFactory;
+import com.shadowcs.themis.util.concurrent.SimpleThreadFactory;
+
+
+public class DefaultThreadFactoryTest {
+
+	@Test
+	public void objectCreation() {
+		new SimpleThreadFactory();
+	}
+	
+	@Test
+	public void threadCreation() throws InterruptedException {
+		
+		ThreadFactory sThreadFactory = new DefaultThreadFactory();
+		for(int i = 0; i < 100; i++) {
+			Thread t = sThreadFactory.newThread(null);
+			t.start();
+			t.join(1000);
+		}
+	}
+	
+	@Test
+	public void threadWork() throws InterruptedException {
+		
+		AtomicInteger integer = new AtomicInteger();
+
+		ThreadFactory sThreadFactory = new DefaultThreadFactory();
+		for(int i = 0; i < 100; i++) {
+			Thread t = sThreadFactory.newThread(() -> integer.incrementAndGet());
+			t.start();
+			t.join(1000);
+		}
+		
+		assertEquals(100, integer.get());
+	}
+
+}

src/test/java/com/shadowcs/themis/test/CucumberStepDef.java

@@ -0,0 +1,76 @@
+package com.shadowcs.themis.test;
+
+import static org.junit.Assert.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Test;
+import com.shadowcs.themis.EventManager;
+import com.shadowcs.themis.util.concurrent.SimpleThreadFactory;
+
+
+public class EventManagerTest {
+
+	@Test
+	public void objectCreation() {
+		new EventManager().close();;
+	}
+	
+	@Test
+	public void threadCreationNull() throws InterruptedException {
+		
+		AtomicInteger integer = new AtomicInteger();
+		
+		EventManager eventManager = new EventManager();
+		eventManager.addListener(null, Runnable.class);
+		for(int i = 0; i < 100; i++) {
+			eventManager.execute((Runnable) () -> integer.incrementAndGet());
+		}
+		
+		for(int i = 0; i < 100; i++) {
+			try {
+				eventManager.submit((Runnable) () -> integer.incrementAndGet()).get();
+			} catch(ExecutionException e) {
+				e.printStackTrace();
+			}
+		}
+		
+		for(int i = 0; i < 100; i++) {
+			eventManager.invoke((Runnable) () -> integer.incrementAndGet());
+		}
+		
+		assertEquals(0, integer.get());
+	}
+	
+	@Test
+	public void threadCreationListener() throws InterruptedException {
+		
+		AtomicInteger integer = new AtomicInteger();
+		AtomicInteger expected = new AtomicInteger();
+		
+		EventManager eventManager = new EventManager();
+		eventManager.addListener((run) -> run.run(), Runnable.class);
+		for(int i = 0; i < 100; i++) {
+			expected.incrementAndGet();
+			eventManager.execute((Runnable) () -> integer.incrementAndGet());
+		}
+		
+		for(int i = 0; i < 100; i++) {
+			try {
+				expected.incrementAndGet();
+				eventManager.submit((Runnable) () -> integer.incrementAndGet()).get();
+			} catch(ExecutionException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
+		
+		for(int i = 0; i < 100; i++) {
+			expected.incrementAndGet();
+			eventManager.invoke((Runnable) () -> integer.incrementAndGet());
+		}
+		
+		assertEquals(300, integer.get());
+	}
+
+}

src/test/java/com/shadowcs/themis/test/DefaultThreadFactoryTest.java

@@ -0,0 +1,56 @@
+package com.shadowcs.themis.test;
+
+import static org.junit.Assert.assertEquals;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Test;
+import com.shadowcs.themis.util.concurrent.ProcedureThreadFactory;
+import com.shadowcs.themis.util.concurrent.SimpleThreadFactory;
+
+
+public class ProcedureThreadFactoryTest {
+
+	@Test
+	public void objectCreation() {
+		new SimpleThreadFactory();
+	}
+	
+	@Test
+	public void threadCreationNull() throws InterruptedException {
+		
+		ThreadFactory sThreadFactory = new ProcedureThreadFactory();
+		for(int i = 0; i < 100; i++) {
+			Thread t = sThreadFactory.newThread(null);
+			t.start();
+			t.join(1000);
+		}
+	}
+	
+	@Test
+	public void threadCreationProc() throws InterruptedException {
+		
+		// TODO: text output is not the best testing
+		ThreadFactory sThreadFactory = new ProcedureThreadFactory(() -> System.out.println("Proc run"));
+		for(int i = 0; i < 100; i++) {
+			Thread t = sThreadFactory.newThread(null);
+			t.start();
+			t.join(1000);
+		}
+	}
+	
+	@Test
+	public void threadWork() throws InterruptedException {
+		
+		AtomicInteger integer = new AtomicInteger();
+
+		ThreadFactory sThreadFactory = new ProcedureThreadFactory();
+		for(int i = 0; i < 100; i++) {
+			Thread t = sThreadFactory.newThread(() -> integer.incrementAndGet());
+			t.start();
+			t.join(1000);
+		}
+		
+		assertEquals(100, integer.get());
+	}
+
+}

src/test/java/com/shadowcs/themis/test/EventManagerTest.java

@@ -0,0 +1,155 @@
+package com.shadowcs.themis.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Test;
+import com.shadowcs.themis.util.concurrent.ProvidedThreadFactory;
+
+public class ProvidedThreadFactoryTest {
+
+	@Test
+	public void objectCreation() {
+		new ProvidedThreadFactory().close();
+	}
+	
+	@Test
+	public void threadCreationBlank() throws InterruptedException {
+		
+		ProvidedThreadFactory pThreadFactory = new ProvidedThreadFactory();
+		new Thread(() -> pThreadFactory.cede()).start();
+		Thread.sleep(1000);
+		for(int i = 0; i < 100; i++) {
+			Thread t = pThreadFactory.newThread(null);
+			if(t != null) {
+				t.start();
+				t.join();
+			}
+		}
+		
+		pThreadFactory.close();
+	}
+	
+	@Test
+	public void threadCreationCede() throws InterruptedException {
+		
+		ProvidedThreadFactory pThreadFactory = new ProvidedThreadFactory();
+		new Thread(() -> pThreadFactory.cede(() -> System.out.println("Test"))).start(); // TODO: replace this with a boolean or something
+		Thread.sleep(500); // sleeps are bad for tests but I can't think of a better way atm
+		for(int i = 0; i < 100; i++) {
+			Thread t = pThreadFactory.newThread(null);
+			if(t != null) {
+				t.start();
+				t.join();
+			}
+		}
+		
+		Thread.sleep(500);
+		pThreadFactory.close();
+	}
+	
+	@Test
+	public void threadWorkSingle() throws InterruptedException {
+		
+		AtomicInteger expected = new AtomicInteger();
+		AtomicInteger integer = new AtomicInteger();
+
+		ProvidedThreadFactory pThreadFactory = new ProvidedThreadFactory();
+		Thread thread = new Thread(() -> pThreadFactory.cede());
+		thread.start();
+		
+		Thread.sleep(500); // TODO: this one is an even worse test
+		
+		for(int i = 0; i < 100; i++) {
+			Thread t = pThreadFactory.newThread(() -> integer.incrementAndGet());
+			if(t != null) {
+				expected.incrementAndGet();
+				t.start();
+			}
+		}
+		
+		Thread.sleep(500);
+		pThreadFactory.close();
+		thread.join();
+		
+		System.out.println(expected.get());
+		assertEquals(expected.get(), integer.get());
+	}
+	
+	@Test
+	public void threadWorkInterrupt() throws InterruptedException {
+
+		ProvidedThreadFactory pThreadFactory = new ProvidedThreadFactory();
+		Thread thread = new Thread(() -> pThreadFactory.cede());
+		thread.start();
+		
+		Thread.sleep(500); // TODO: this one is an even worse test
+		
+		for(int i = 0; i < 100; i++) {
+			Thread t = pThreadFactory.newThread(() -> {
+				
+				Thread.currentThread().interrupt();
+			});
+			
+			if(t != null) {
+				t.start();
+			}
+		}
+		
+		thread.join(5000);
+		pThreadFactory.close();
+	}
+
+	@Test
+	public void threadWorkMulti() throws InterruptedException {
+		
+		AtomicInteger expected = new AtomicInteger();
+		AtomicInteger integer = new AtomicInteger();
+
+		ProvidedThreadFactory pThreadFactory = new ProvidedThreadFactory();
+		Thread thread0 = new Thread(() -> pThreadFactory.cede());
+		Thread thread1 = new Thread(() -> pThreadFactory.cede());
+		Thread thread2 = new Thread(() -> pThreadFactory.cede());
+		Thread thread3 = new Thread(() -> pThreadFactory.cede());
+		Thread thread4 = new Thread(() -> pThreadFactory.cede());
+		Thread thread5 = new Thread(() -> pThreadFactory.cede());
+		Thread thread6 = new Thread(() -> pThreadFactory.cede());
+		Thread thread7 = new Thread(() -> pThreadFactory.cede());
+		Thread thread8 = new Thread(() -> pThreadFactory.cede());
+		Thread thread9 = new Thread(() -> pThreadFactory.cede());
+		thread0.start();
+		thread1.start();
+		thread2.start();
+		thread3.start();
+		thread4.start();
+		thread5.start();
+		thread6.start();
+		thread7.start();
+		thread8.start();
+		thread9.start();
+		
+		for(int i = 0; i < 100; i++) {
+			Thread t = pThreadFactory.newThread(() -> integer.incrementAndGet());
+			if(t != null) {
+				expected.incrementAndGet();
+				t.start();
+			}
+		}
+		
+		pThreadFactory.close();
+		thread0.join();
+		thread1.join();
+		thread2.join();
+		thread3.join();
+		thread4.join();
+		thread5.join();
+		thread6.join();
+		thread7.join();
+		thread8.join();
+		thread9.join(); // need to find a better way than this
+		
+		System.out.println(expected.get());
+		assertTrue(expected.get() > 0); // TODO: need a better way than this
+		assertEquals(expected.get(), integer.get());
+	}
+}

src/test/java/com/shadowcs/themis/test/ProcedureThreadFactoryTest.java

@@ -0,0 +1,43 @@
+package com.shadowcs.themis.test;
+
+import static org.junit.Assert.*;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Test;
+import com.shadowcs.themis.util.concurrent.SimpleThreadFactory;
+
+
+public class SimpleThreadFactoryTest {
+
+	@Test
+	public void objectCreation() {
+		new SimpleThreadFactory();
+	}
+	
+	@Test
+	public void threadCreation() throws InterruptedException {
+		
+		ThreadFactory sThreadFactory = new SimpleThreadFactory();
+		for(int i = 0; i < 100; i++) {
+			Thread t = sThreadFactory.newThread(null);
+			t.start();
+			t.join(1000);
+		}
+	}
+	
+	@Test
+	public void threadWork() throws InterruptedException {
+		
+		AtomicInteger integer = new AtomicInteger();
+
+		ThreadFactory sThreadFactory = new SimpleThreadFactory();
+		for(int i = 0; i < 100; i++) {
+			Thread t = sThreadFactory.newThread(() -> integer.incrementAndGet());
+			t.start();
+			t.join(1000);
+		}
+		
+		assertEquals(100, integer.get());
+	}
+
+}