Merge pull request '[Task-3]-updated java11 and junit5' (#5) from feature/issue-3/upgrade-java-11 into master

pom.xml

@@ -1,4 +1,5 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>net.forwardfire.tpquery</groupId>
@@ -30,13 +31,13 @@
 	</modules>
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<project.build.sourceVersion>1.8</project.build.sourceVersion>
+		<project.build.sourceVersion>11</project.build.sourceVersion>
 
 		<!-- workaround for: [WARNING] 'reporting.plugins.plugin.version' for ... -->
-		<jacoco-maven-plugin.version>0.7.4.201502262128</jacoco-maven-plugin.version><!-- 
+		<jacoco-maven-plugin.version>0.8.4</jacoco-maven-plugin.version><!-- 
 			invalid format 1007: <version>0.7.5.201505241946</version> -->
 		<maven-javadoc-plugin.version>2.10.3</maven-javadoc-plugin.version>
-		<maven-project-info-reports-plugin>2.8</maven-project-info-reports-plugin>
+		<maven-project-info-reports-plugin>3.0.0</maven-project-info-reports-plugin>
 	</properties>
 	<dependencyManagement>
 		<dependencies>
@@ -51,9 +52,9 @@
 				<version>3.5</version>
 			</dependency>
 			<dependency>
-				<groupId>junit</groupId>
-				<artifactId>junit</artifactId>
-				<version>4.12</version>
+				<groupId>org.junit.jupiter</groupId>
+				<artifactId>junit-jupiter-engine</artifactId>
+				<version>5.5.2</version>
 			</dependency>
 			<dependency>
 				<groupId>ch.qos.logback</groupId>
@@ -95,12 +96,27 @@
 				<artifactId>sonar-jacoco-listeners</artifactId>
 				<version>3.2</version>
 			</dependency>
+			<dependency>
+				<groupId>javax.xml.bind</groupId>
+				<artifactId>jaxb-api</artifactId>
+				<version>2.3.1</version>
+			</dependency>
+			<dependency>
+				<groupId>com.sun.xml.bind</groupId>
+				<artifactId>jaxb-impl</artifactId>
+				<version>2.3.1</version>
+			</dependency>
+			<dependency>
+				<groupId>com.sun.xml.bind</groupId>
+				<artifactId>jaxb-core</artifactId>
+				<version>2.3.0</version>
+			</dependency>
 		</dependencies>
 	</dependencyManagement>
 	<dependencies>
 		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-engine</artifactId>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
@@ -165,22 +181,6 @@
 			</plugins>
 		</pluginManagement>
 		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-jdeps-plugin</artifactId>
-				<version>3.0.0</version>
-				<executions>
-					<execution>
-						<phase>validate</phase>
-						<goals>
-							<goal>jdkinternals</goal> <!-- verify main classes -->
-							<goal>test-jdkinternals</goal> <!-- verify test classes -->
-						</goals>
-					</execution>
-				</executions>
-				<configuration>
-				</configuration>
-			</plugin>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-enforcer-plugin</artifactId>
@@ -198,9 +198,7 @@
 						<requireMavenVersion>
 							<version>(3.0,)</version>
 						</requireMavenVersion>
-						<!-- jdk9 check
-						<banDuplicateClasses></banDuplicateClasses>
-						 -->
+						<!-- jdk9 check <banDuplicateClasses></banDuplicateClasses> -->
 					</rules>
 				</configuration>
 			</plugin>
@@ -380,9 +378,12 @@
 								<configuration>
 									<target>
 										<echo>Copy project markdown to site.</echo>
-										<copy verbose="true" file="readme.md" toFile="src/site/markdown/index.md" />
-										<copy verbose="true" file="todo.md" todir="src/site/markdown" />
-										<copy verbose="true" file="build.md" todir="src/site/markdown" />
+										<copy verbose="true" file="readme.md"
+											toFile="src/site/markdown/index.md" />
+										<copy verbose="true" file="todo.md"
+											todir="src/site/markdown" />
+										<copy verbose="true" file="build.md"
+											todir="src/site/markdown" />
 									</target>
 								</configuration>
 							</execution>

tpquery-executor-jdbc/src/test/java/net/forwardfire/tpquery/store/executor/jdbc/TPQExecutorJdbcTest.java

@@ -1,7 +1,8 @@
 package net.forwardfire.tpquery.store.executor.jdbc;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.sql.Connection;
 import java.sql.DriverManager;
@@ -11,20 +12,17 @@ import java.sql.SQLException;
 import java.util.HashMap;
 import java.util.Map;
 
-import net.forwardfire.tpquery.TPQManager;
-import net.forwardfire.tpquery.TPQFactory;
-import net.forwardfire.tpquery.store.executor.jdbc.SQLExceptionRuntime;
-import net.forwardfire.tpquery.store.executor.jdbc.TPQExecutorJdbc;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.slf4j.LoggerFactory;
 
 import ch.qos.logback.classic.LoggerContext;
+import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
 
 public class TPQExecutorJdbcTest {
 	
-	@BeforeClass
+	@BeforeEach
 	public static void setupLogging() {
 		LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
 		lc.reset(); // disable logging
@@ -84,8 +82,9 @@ public class TPQExecutorJdbcTest {
 		}
 	}
 	
-	@Test(expected=SQLExceptionRuntime.class)
+	@Test
 	public void testExecuteUpdateFail() throws Exception {
+		assertThrows(SQLExceptionRuntime.class, () -> {
 			try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
 				TPQManager store = TPQFactory
 					.createManagerBuilder()
@@ -102,10 +101,12 @@ public class TPQExecutorJdbcTest {
 				exe.executeUpdate(connection, "junit.insertData");
 				exe.executeUpdate(connection, "junit.queryFail"); // runtime data failure, as prepared will go correctly
 		}
+	 });
 	}
 	
-	@Test(expected=SQLExceptionRuntime.class)
+	@Test
 	public void testExecuteSelectFail() throws Exception {
+		assertThrows(SQLExceptionRuntime.class, () -> {
 			try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
 				
 				TPQManager store = TPQFactory
@@ -123,10 +124,12 @@ public class TPQExecutorJdbcTest {
 				exe.executeUpdate(connection, "junit.insertData");
 				exe.execute(connection, "junit.queryFail"); // runtime data failure, as prepared will go correctly
 			}
+		});
 	}
 	
-	@Test(expected=SQLExceptionRuntime.class)
+	@Test
 	public void testExecuteSelectFailPrepare() throws Exception {
+		assertThrows(SQLExceptionRuntime.class, () -> {
 			try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
 				TPQManager store = TPQFactory.createManagerBuilder()
 						.createQuerySet("junit", "jar:junit:mem:testcaseFail")
@@ -137,10 +140,12 @@ public class TPQExecutorJdbcTest {
 				TPQExecutorJdbc exe = new TPQExecutorJdbc(store.getQueryExecutorContext());
 				exe.execute(connection, "junit.sql-fail");
 			}
+		});
 	}
 	
-	@Test(expected=SQLExceptionRuntime.class)
+	@Test
 	public void testTimeoutFail() throws Exception {
+		assertThrows(SQLExceptionRuntime.class, () -> {
 			try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
 				TPQManager store = TPQFactory.createManagerBuilder()
 						.createQuerySet("junit", "jar:junit:mem:test")
@@ -155,10 +160,12 @@ public class TPQExecutorJdbcTest {
 				ps.close();
 				exe.prepareTimeout(ps, 123);
 			}
+		});
 	}
 	
-	@Test(expected=SQLExceptionRuntime.class)
+	@Test
 	public void testParameterFail() throws Exception {
+		assertThrows(SQLExceptionRuntime.class, () -> {
 			try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:test;")) {
 				TPQManager store = TPQFactory.createManagerBuilder()
 						.createQuerySet("junit", "jar:junit:mem:test")
@@ -172,6 +179,7 @@ public class TPQExecutorJdbcTest {
 				PreparedStatement ps = exe.createPreparedStatement(connection, "junit.test", null);
 				exe.prepareParameterValue(ps, 1, 123);
 			}
+		});
 	}
 	
 	@Test

tpquery-executor-jpa/src/test/java/net/forwardfire/tpquery/store/executor/jpa/TPQExecutorJpaTest.java

@@ -1,8 +1,9 @@
 package net.forwardfire.tpquery.store.executor.jpa;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.HashMap;
 import java.util.List;
@@ -12,44 +13,42 @@ import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
 import javax.persistence.Persistence;
 
-import net.forwardfire.tpquery.TPQManager;
-import net.forwardfire.tpquery.TPQFactory;
-import net.forwardfire.tpquery.config.TPQConfig;
-import net.forwardfire.tpquery.statement.AbstractTPQStatementWriter;
-import net.forwardfire.tpquery.statement.TPQStatementWriter;
-import net.forwardfire.tpquery.statement.TPQStatementLanguage;
-import net.forwardfire.tpquery.store.executor.jpa.TPQExecutorJpa;
-import net.forwardfire.tpquery.store.proxy.TPQueryName;
-import net.forwardfire.tpquery.store.proxy.TPQueryProxyFactory;
-import net.forwardfire.tpquery.store.proxy.TPQueryParameterName;
-import net.forwardfire.tpquery.store.proxy.TPQueryProxy;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.slf4j.LoggerFactory;
 
 import ch.qos.logback.classic.LoggerContext;
+import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
+import net.forwardfire.tpquery.config.TPQConfig;
+import net.forwardfire.tpquery.statement.AbstractTPQStatementWriter;
+import net.forwardfire.tpquery.statement.TPQStatementLanguage;
+import net.forwardfire.tpquery.statement.TPQStatementWriter;
+import net.forwardfire.tpquery.store.proxy.TPQueryName;
+import net.forwardfire.tpquery.store.proxy.TPQueryParameterName;
+import net.forwardfire.tpquery.store.proxy.TPQueryProxy;
+import net.forwardfire.tpquery.store.proxy.TPQueryProxyFactory;
 
 public class TPQExecutorJpaTest {
 
 	private EntityManagerFactory emFactory;
 	private EntityManager em = null;
 	
-	@BeforeClass
+	@BeforeAll
 	public static void setupLogging() {
 		LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
 		lc.reset(); // disable logging
 	}
 	
-	@Before
+	@BeforeEach
 	public void before() {
 		emFactory = Persistence.createEntityManagerFactory("junit");
 		em = emFactory.createEntityManager();
 	}
 	
-	@After
+	@AfterEach
 	public void close() {
 		em.close();
 		emFactory.close();
@@ -116,8 +115,9 @@ public class TPQExecutorJpaTest {
 		//assertEquals("foobar",resultSingle.name);
 	}
 	
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testUnsupportedLanguage() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQConfig config = new TPQConfig();
 			config.addStatementLanguage(new TPQStatementLanguage() {
 				@Override
@@ -142,10 +142,12 @@ public class TPQExecutorJpaTest {
 						.build();
 			TPQExecutorJpa exe = new TPQExecutorJpa(store.getQueryExecutorContext());
 			exe.selectList(em, "junit.test", null);
+		});
 	}
 	
-	@Test()
+	@Test
 	public void testQueryProxy() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 		TPQManager store = TPQFactory.createManagerBuilder()
 				.createQuerySet("junit", "jar:junit:mem")
 					.setLanguage(TPQFactory.StatementLanguage.HQL)
@@ -196,6 +198,7 @@ public class TPQExecutorJpaTest {
 		
 		d = foobarService.testFoo();
 		assertNotNull(d);
+		});
 	}
 	
 	@TPQueryProxy(prefix="junit.")

tpquery-store/pom.xml

@@ -1,4 +1,5 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
 	<parent>
@@ -22,6 +23,21 @@
 			<artifactId>commons-lang3</artifactId>
 			<scope>compile</scope>
 		</dependency>
+		<dependency>
+			<groupId>javax.xml.bind</groupId>
+			<artifactId>jaxb-api</artifactId>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>com.sun.xml.bind</groupId>
+			<artifactId>jaxb-impl</artifactId>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>com.sun.xml.bind</groupId>
+			<artifactId>jaxb-core</artifactId>
+			<scope>compile</scope>
+		</dependency>
 	</dependencies>
 </project>
 

tpquery-store/src/test/java/net/forwardfire/tpquery/TPQFactoryTest.java

@@ -1,11 +1,10 @@
 package net.forwardfire.tpquery;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import net.forwardfire.tpquery.TPQFactory;
 import net.forwardfire.tpquery.config.TPQConfig;
 
 public class TPQFactoryTest {

tpquery-store/src/test/java/net/forwardfire/tpquery/TPQSpeedTest.java

@@ -11,15 +11,14 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 import org.slf4j.LoggerFactory;
 
 import ch.qos.logback.classic.LoggerContext;
-import net.forwardfire.tpquery.TPQFactory;
-import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
 import net.forwardfire.tpquery.store.TPQueryStoreStatement;
+import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
 import net.forwardfire.tpquery.store.manager.TPQStoreManagerExecutorContext;
 import net.forwardfire.tpquery.store.manager.TPQStoreManagerExecutorStatement;
 
@@ -28,17 +27,17 @@ public class TPQSpeedTest {
 	static int loopSize;
 	static int warmupSize;
 	static TPQManager queryManager;
-	static List<String> result;
+	static List<String> result = new ArrayList<>();;
 	
-	@BeforeClass
+	@BeforeAll
 	static public void initSpeedTest() throws Exception {
 		
 		LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
 		lc.reset(); // disable logging in speed tests.
 		
 		warmupSize = 10;
-		loopSize = 100000*new Integer(System.getProperty("junit.speedtest.factor", "1"));
-		result = new ArrayList<>();
+		loopSize = 100000 * Integer.parseInt(System.getProperty("junit.speedtest.factor", "1"));
+		
 		queryManager = TPQFactory.createManagerBuilder()
 				.createQuerySet("junit", "jar:junit:mem")
 				.setLanguage(TPQFactory.StatementLanguage.SQL)
@@ -122,7 +121,7 @@ public class TPQSpeedTest {
 		}
 	}
 	
-	@AfterClass
+	@AfterAll
 	public static void printResults() {
 		
 		TPQStoreManagerExecutorContext exeCtx = (TPQStoreManagerExecutorContext)queryManager.getQueryExecutorContext();

tpquery-store/src/test/java/net/forwardfire/tpquery/config/TPQueryStoreConfigBuilderTest.java

@@ -1,15 +1,16 @@
 package net.forwardfire.tpquery.config;
 
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
 
 public class TPQueryStoreConfigBuilderTest {
@@ -38,9 +39,9 @@ public class TPQueryStoreConfigBuilderTest {
 		assertNotNull(manager.getQueryStore().getQueryNames());
 	}
 	
-	@Test(expected=IllegalStateException.class)
+	@Test
 	public void testBuildTreeInvalid() throws Exception {
-		TPQFactory
+		assertThrows(IllegalStateException.class, () -> TPQFactory
 				.createManagerBuilder()
 					.createQuerySet("junit", "jar:mem:test")
 						.createQuery("test").parseStatement("select * from table $$inc:junit.inc.test$$ $$inc:junit.inc.inc.test$$").build()
@@ -56,7 +57,7 @@ public class TPQueryStoreConfigBuilderTest {
 								.buildTree()
 							// buildTree() should be here
 						.build()
-					.build();
+					.build());
 	}
 	
 	@Test
@@ -128,17 +129,17 @@ public class TPQueryStoreConfigBuilderTest {
 		assertNotNull(q.getName());
 	}
 	
-	@Test(expected=TPQConfigException.class)
+	@Test
 	public void testReadQuerySetFileNotFound() throws Exception {
-		TPQFactory.createManagerBuilder()
+		assertThrows(TPQConfigException.class, () -> TPQFactory.createManagerBuilder()
 				.readQuerySet(new File("./src/test/resources/net/forwardfire/tpquery/test-query.not-found"))
-				.build();
+				.build());
 	}
 	
-	@Test(expected=TPQConfigException.class)
+	@Test
 	public void testReadQuerySetInvalidContext() throws Exception {
-		TPQFactory.createManagerBuilder()
+		assertThrows(TPQConfigException.class, () -> TPQFactory.createManagerBuilder()
 				.readQuerySet(new File("./src/test/resources/net/forwardfire/tpquery/test-query-invalid.xml"))
-				.build();
+				.build());
 	}
 }

tpquery-store/src/test/java/net/forwardfire/tpquery/config/TPQueryStoreConfigTest.java

@@ -1,15 +1,15 @@
 package net.forwardfire.tpquery.config;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.TPQFactory;
-import net.forwardfire.tpquery.config.TPQConfig;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql;
 import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterValue;
 import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
@@ -40,32 +40,40 @@ public class TPQueryStoreConfigTest {
 	
 	// ---------
 	
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testTemplateTypeAdd() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQConfig c = TPQFactory.createConfig();
 			c.addStatementParameter(new TPQStatementParameterValue(TPQFactory.StatementParameter.VALUE));
+		});
 	}
 	
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testTemplateTypeRemove() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQConfig c = TPQFactory.createConfig();
 			c.removeStatementParameter(TPQFactory.StatementParameter.VALUE);
 			c.removeStatementParameter(TPQFactory.StatementParameter.VALUE);
+		});
 	}
 	
 	// ---------
 	
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testLanguageTypeAdd() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQConfig c = TPQFactory.createConfig();
 			c.addStatementLanguage(new TPQStatementLanguageSql(TPQFactory.StatementLanguage.SQL));
+		});
 	}
 	
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testLanguageTypeRemove() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQConfig c = TPQFactory.createConfig();
 			c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL);
 			c.removeStatementLanguage(TPQFactory.StatementLanguage.SQL);
+		});
 	}
 	
 	// ---------
@@ -82,23 +90,29 @@ public class TPQueryStoreConfigTest {
 		c.addValueType(this.getClass().getName());
 	}
 	
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testAddValueTypeClassNameError() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQConfig c = TPQFactory.createConfig();
 			c.addValueType("net.foo.bar.NoneExcistingClassName");
+		});
 	}
 	
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testValueTypeAliasAdd() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQConfig c = TPQFactory.createConfig();
 			c.addValueTypeAlias("key", "v0");
 			c.addValueTypeAlias("key", "v1");
+		});
 	}
 	
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testValueTypeAliasRemoveIllegalKey() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQConfig c = TPQFactory.createConfig();
 			c.removeValueTypeAlias("unknown-key");
+		});
 	}
 	
 	@Test()
@@ -115,16 +129,20 @@ public class TPQueryStoreConfigTest {
 	
 	// ---------
 	
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testQuerySetRemoveIllegalKey() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQConfig c = TPQFactory.createConfig();
 			c.removeQuerySet("unknown-key");
+		});
 	}
 	
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testQuerySetRemoveNull() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQConfig c = TPQFactory.createConfig();
 			c.removeQuerySet(null);
+		});
 	}
 	
 	@Test()
@@ -204,8 +222,9 @@ public class TPQueryStoreConfigTest {
 		assertNotNull(q.getName());
 	}
 	
-	@Test(expected=TPQConfigException.class)
+	@Test
 	public void testWrongClassParameterType() throws Exception {
+		assertThrows(TPQConfigException.class, () -> {
 			TPQManager manager = TPQFactory
 					.createManagerBuilder()
 						.createQuerySet("junit", "jar:mem:test")
@@ -217,6 +236,7 @@ public class TPQueryStoreConfigTest {
 							.build()
 						.build();
 			assertNotNull(manager);
+		});
 	}
 	
 	@Test

tpquery-store/src/test/java/net/forwardfire/tpquery/config/TPQueryStoreConfigValidatorTest.java

@@ -1,45 +1,32 @@
 package net.forwardfire.tpquery.config;
 
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.TPQFactory;
-import net.forwardfire.tpquery.config.validate.TPQConfigValidator;
-import net.forwardfire.tpquery.config.validate.TPQConfigValidatorCheck;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.config.validate.TPQCheckDescriptionNotBlank;
 import net.forwardfire.tpquery.config.validate.TPQCheckNamePattern;
 import net.forwardfire.tpquery.config.validate.TPQCheckParameterDefaultValueNotBlank;
 import net.forwardfire.tpquery.config.validate.TPQCheckParameterNamePattern;
 import net.forwardfire.tpquery.config.validate.TPQCheckParameterTypePattern;
 import net.forwardfire.tpquery.config.validate.TPQCheckParameterValueTypePattern;
+import net.forwardfire.tpquery.config.validate.TPQConfigValidator;
+import net.forwardfire.tpquery.config.validate.TPQConfigValidatorCheck;
 import net.forwardfire.tpquery.model.TPQuery;
 
 public class TPQueryStoreConfigValidatorTest {
 
 	@Test()
 	public void testPatternValidators() throws Exception {
-		TPQConfig config = TPQFactory
-				.createConfigBuilder()
-					.createQuerySet("junit", "jar:mem:test")
-						.createQuery("testCAPS").parseStatement("select * from table $$inc:junit.inc.test$$ $$inc:junit.inc.inc.test$$").build()
-						.createQuerySetTree("inc")
-							.setTemplate(true)
-							.createQuery("test")
-								.parseStatement("where a=$$a$$ ")
-								.createQueryParameter("a", Integer.class)
-									.setDefaultValue("1")
-									.build()
-								.build()
-							.createQuerySet("inc")
-								.createQuery("test")
-									.parseStatement("AND 2=2")
-									.build()
-								.build()
-							.buildTree()
-						.build()
-					.build();
+		TPQConfig config = TPQFactory.createConfigBuilder().createQuerySet("junit", "jar:mem:test")
+				.createQuery("testCAPS")
+				.parseStatement("select * from table $$inc:junit.inc.test$$ $$inc:junit.inc.inc.test$$").build()
+				.createQuerySetTree("inc").setTemplate(true).createQuery("test").parseStatement("where a=$$a$$ ")
+				.createQueryParameter("a", Integer.class).setDefaultValue("1").build().build().createQuerySet("inc")
+				.createQuery("test").parseStatement("AND 2=2").build().build().buildTree().build().build();
 
 		config.addConfigValidator(".*", new TPQCheckNamePattern(".*"));
 		config.addConfigValidator(".*", new TPQCheckParameterNamePattern(".*"));
@@ -54,8 +41,9 @@ public class TPQueryStoreConfigValidatorTest {
 		assertNotNull(manager);
 	}
 
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testDescriptionNotBlank() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQConfig config = TPQFactory
 					.createConfigBuilder()
 						.createQuerySet("junit", "jar:mem:test")
@@ -76,10 +64,12 @@ public class TPQueryStoreConfigValidatorTest {
 			config.addConfigValidator(".*", new TPQCheckDescriptionNotBlank());
 			TPQManager manager = TPQFactory.createManager(config);
 			assertNotNull(manager);
+		});
 	}
 
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testParameterDefaultValueNotBlank() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQConfig config = TPQFactory
 					.createConfigBuilder()
 						.createQuerySet("junit", "jar:mem:test")
@@ -101,10 +91,12 @@ public class TPQueryStoreConfigValidatorTest {
 			config.addConfigValidator(".*", new TPQCheckParameterDefaultValueNotBlank());
 			TPQManager manager = TPQFactory.createManager(config);
 			assertNotNull(manager);
+		});
 	}
 
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testDisableRAWExample() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQConfig config = TPQFactory
 					.createConfigBuilder()
 						.createQuerySet("junit", "jar:mem:test")
@@ -126,5 +118,6 @@ public class TPQueryStoreConfigValidatorTest {
 			config.addConfigValidator("junit.test-f.*", new TPQCheckParameterTypePattern("!RAW"));
 			TPQManager manager = TPQFactory.createManager(config);
 			assertNotNull(manager);
+		});
 	}
 }

tpquery-store/src/test/java/net/forwardfire/tpquery/executor/TQueryExecutorTest.java

@@ -5,12 +5,12 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
+import org.junit.jupiter.api.Test;
+
 import net.forwardfire.tpquery.store.executor.AbstractTPQExecutor;
 import net.forwardfire.tpquery.store.executor.TPQExecutorContext;
 import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
 
-import org.junit.Test;
-
 public class TQueryExecutorTest {
 	
 	class TestExecutorConnection {

tpquery-store/src/test/java/net/forwardfire/tpquery/model/ModelXMLMarshallerTest.java

@@ -1,8 +1,9 @@
 package net.forwardfire.tpquery.model;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -12,15 +13,10 @@ import java.util.Map;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlElementWrapper;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import net.forwardfire.tpquery.TPQFactory;
 import net.forwardfire.tpquery.TPQManager;
-import net.forwardfire.tpquery.model.TPQuery;
-import net.forwardfire.tpquery.model.TPQueryParameter;
-import net.forwardfire.tpquery.model.TPQuerySet;
-import net.forwardfire.tpquery.model.ModelXMLInfoSet;
-import net.forwardfire.tpquery.model.ModelXMLMarshaller;
 import net.forwardfire.tpquery.statement.TPQStatementPartInclude;
 import net.forwardfire.tpquery.statement.TPQStatementPartParameter;
 import net.forwardfire.tpquery.statement.TPQStatementPartText;
@@ -117,9 +113,9 @@ public class ModelXMLMarshallerTest {
 		assertEquals("false",q.getQueryHints().get("junit"));
 	}
 	
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testContextException() throws Exception {
-		new ModelXMLMarshaller(JaxbContextError.class);
+		assertThrows(IllegalArgumentException.class, () -> new ModelXMLMarshaller(JaxbContextError.class));
 	}
 	
 	private static class JaxbContextError {

tpquery-store/src/test/java/net/forwardfire/tpquery/model/TPQueryPropertyTest.java

@@ -1,14 +1,14 @@
 package net.forwardfire.tpquery.model;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
 
 public class TPQueryPropertyTest {

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/TPQueryStatementMarshallerAdapterTest.java

@@ -1,10 +1,9 @@
 package net.forwardfire.tpquery.statement;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import net.forwardfire.tpquery.statement.TPQStatementMarshallerAdapter;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 
 public class TPQueryStatementMarshallerAdapterTest {

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/TPQueryStatementMarshallerTest.java

@@ -1,27 +1,24 @@
 package net.forwardfire.tpquery.statement;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import net.forwardfire.tpquery.statement.TPQStatement;
-import net.forwardfire.tpquery.statement.TPQStatementMarshaller;
-import net.forwardfire.tpquery.statement.TPQStatementPartInclude;
-import net.forwardfire.tpquery.statement.TPQStatementPartParameter;
-import net.forwardfire.tpquery.statement.TPQStatementPartText;
-
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class TPQueryStatementMarshallerTest {
 
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testParseNull() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQStatementMarshaller parser = new TPQStatementMarshaller();
 			parser.unmarshal(null);
+		});
 	}
 
 	@Test()
@@ -54,14 +51,14 @@ public class TPQueryStatementMarshallerTest {
 		assertTrue(result.get(0) instanceof TPQStatementPartParameter);
 	}
 
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testParseTemplateNoEnd() throws Exception {
-		new TPQStatementMarshaller().unmarshal("$$foobar");
+		assertThrows(IllegalArgumentException.class, () -> new TPQStatementMarshaller().unmarshal("$$foobar"));
 	}
 
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testParseTemplateEmpty() throws Exception {
-		new TPQStatementMarshaller().unmarshal("$$$$");
+		assertThrows(IllegalArgumentException.class, () -> new TPQStatementMarshaller().unmarshal("$$$$"));
 	}
 
 	@Test()
@@ -75,12 +72,12 @@ public class TPQueryStatementMarshallerTest {
 		assertTrue(result.get(0) instanceof TPQStatementPartInclude);
 	}
 
-	
-	
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testPrintNull() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQStatementMarshaller parser = new TPQStatementMarshaller();
 			parser.marshal(null);
+		});
 	}
 
 	@Test()
@@ -105,4 +102,3 @@ public class TPQueryStatementMarshallerTest {
 		assertEquals("p0p1p2", result);
 	}
 }
-

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/TPQueryStatementPartIncludeTest.java

@@ -1,18 +1,20 @@
 package net.forwardfire.tpquery.statement;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import net.forwardfire.tpquery.TPQManager;
-import net.forwardfire.tpquery.TPQFactory;
-import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
+import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
 
 public class TPQueryStatementPartIncludeTest {
 
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testFailInclude() throws Exception {
-		TPQFactory.createManagerBuilder()
+		assertThrows(NullPointerException.class, () -> TPQFactory.createManagerBuilder()
 				.createQuerySet("junit", "jar:junit:mem:test")
 				.setLanguage(TPQFactory.StatementLanguage.SQL)
 				.createQuery("include-missing")
@@ -20,33 +22,34 @@ public class TPQueryStatementPartIncludeTest {
 					.appendInclude("include-missing-query")
 					.build()
 			.build()
-			.build();
+		.build());
 	}
 
 	@Test
 	public void testIncludeMultple() throws Exception {
-		TPQManager store = TPQFactory
-				.createManagerBuilder()
-					.readQuerySet("net/forwardfire/tpquery/test-include-multiple.xml")
-				.build();
+		TPQManager store = TPQFactory.createManagerBuilder()
+				.readQuerySet("net/forwardfire/tpquery/test-include-multiple.xml").build();
 		TPQExecutorStatement q = store.getQueryExecutorContext().prepareQuery("test.multipleInclude", null);
 		assertNotNull(q.getName());
 		assertTrue(q.getStatement().contains("price_list"));
 		assertTrue(q.getStatement().contains("key='stats_correction') AS mrt"));
 	}
 
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testIncludeLoop() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQManager store = TPQFactory
 					.createManagerBuilder()
 						.readQuerySet("net/forwardfire/tpquery/test-include-loop.xml")
 					.build();
 			store.getQueryExecutorContext().prepareQuery("test.loopInclude", null);
+		});
 	}
 
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testQueryChecked() throws Exception {
-		TPQFactory.createManagerBuilder()
+		assertThrows(IllegalArgumentException.class,
+				() -> TPQFactory.createManagerBuilder()
 				.createQuerySet("junit", "jar:junit:mem:test")
 				.setLanguage(TPQFactory.StatementLanguage.SQL)
 				.createQuery("test")
@@ -56,6 +59,6 @@ public class TPQueryStatementPartIncludeTest {
 					.appendInclude("junit.test")
 					.build()
 			.build()
-			.build();
+		.build());
 	}
 }

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/TPQueryStatementWriterTest.java

@@ -1,21 +1,20 @@
 package net.forwardfire.tpquery.statement;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import java.util.HashMap;
 import java.util.Map;
 
+import org.junit.jupiter.api.Test;
+
 import net.forwardfire.tpquery.TPQFactory;
 import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.config.TPQConfig;
-import net.forwardfire.tpquery.statement.TPQStatementWriter;
 import net.forwardfire.tpquery.statement.language.AbstractTPQStatementLanguage;
 import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql;
 import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
 
-import org.junit.Test;
-
 public class TPQueryStatementWriterTest {
 
 	private TPQStatementWriter createWriter() {

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/language/TPQStatementLanguageHqlTest.java

@@ -1,20 +1,19 @@
 package net.forwardfire.tpquery.statement.language;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.HashMap;
 import java.util.Map;
 
+import org.junit.jupiter.api.Test;
+
 import net.forwardfire.tpquery.TPQFactory;
 import net.forwardfire.tpquery.statement.TPQStatementWriter;
-import net.forwardfire.tpquery.statement.language.TPQStatementLanguageHql;
 import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
 
-import org.junit.Test;
-
 public class TPQStatementLanguageHqlTest {
 
 	private TPQStatementWriter createWriter() {

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/language/TPQStatementLanguageSqlTest.java

@@ -1,16 +1,15 @@
 package net.forwardfire.tpquery.statement.language;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import net.forwardfire.tpquery.TPQFactory;
 import net.forwardfire.tpquery.statement.TPQStatementWriter;
-import net.forwardfire.tpquery.statement.language.TPQStatementLanguageSql;
 import net.forwardfire.tpquery.store.TPQueryStoreStatementMapper;
 
 public class TPQStatementLanguageSqlTest {

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/parameter/TPQueryParameterDefaultValueTest.java

@@ -1,21 +1,22 @@
 package net.forwardfire.tpquery.statement.parameter;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import net.forwardfire.tpquery.TPQManager;
+import org.junit.jupiter.api.Test;
+
 import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.config.TPQConfig;
 import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
 
-import org.junit.Test;
-
 public class TPQueryParameterDefaultValueTest {
 
-	@Test()
+	@Test
 	public void testRawString() throws Exception {
 		TPQConfig config = TPQFactory
 			.createConfigBuilder()
@@ -44,7 +45,7 @@ public class TPQueryParameterDefaultValueTest {
 					.setLanguage(TPQFactory.StatementLanguage.SQL)
 					.createQuery("test")
 						.parseStatement("select * from foobar where a=$$a$$")
-						.createQueryParameter("a", TPQFactory.ParameterValueType.LONG)
+						.createQueryParameter("a", TPQFactory.ParameterValueType.DOUBLE)
 							.setDefaultValue("js:epoch()")
 							.build()
 						.build()
@@ -54,7 +55,7 @@ public class TPQueryParameterDefaultValueTest {
 		TPQExecutorStatement prepared = store.getQueryExecutorContext().prepareQuery("junit.test", para);
 		assertTrue(!prepared.getParameters().isEmpty());
 		assertTrue(prepared.getParameters().get(0) != null);
-		assertTrue(prepared.getParameters().get(0) instanceof Long);
+		assertTrue(prepared.getParameters().get(0) instanceof Double);
 	}
 	
 	@Test()
@@ -121,8 +122,9 @@ public class TPQueryParameterDefaultValueTest {
 		assertTrue(prepared.getParameters().get(0) instanceof java.lang.Integer);
 	}
 	
-	@Test(expected=Exception.class)
+	@Test
 	public void testCreateObjectConstructorWrongClass() throws Exception {
+		assertThrows(Exception.class, () -> {
 			TPQManager store = TPQFactory
 				.createManagerBuilder()
 					.createQuerySet("junit", "jar:junit:mem")
@@ -136,5 +138,6 @@ public class TPQueryParameterDefaultValueTest {
 					.build()
 				.build();
 			store.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
+		});
 	}
 }

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/parameter/TPQueryParameterTypeListTest.java

@@ -1,6 +1,7 @@
 package net.forwardfire.tpquery.statement.parameter;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -8,10 +9,10 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.model.TPQuery;
 import net.forwardfire.tpquery.model.TPQueryParameter;
 import net.forwardfire.tpquery.model.TPQuerySet;
@@ -20,8 +21,9 @@ import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
 
 public class TPQueryParameterTypeListTest {
 	
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testNullValue() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQuery q = new TPQuery();
 			q.setName("test");
 			q.addQueryPart(new TPQStatementPartParameter("param"));
@@ -39,10 +41,12 @@ public class TPQueryParameterTypeListTest {
 			
 			Map<String,Object> para = new HashMap<String,Object>();
 			store.getQueryExecutorContext().prepareQuery("junit.test", para);
+		});
 	}
 	
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testEmptyValue() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQuery q = new TPQuery();
 			q.setName("test");
 			q.addQueryPart(new TPQStatementPartParameter("param"));
@@ -60,10 +64,12 @@ public class TPQueryParameterTypeListTest {
 			Map<String,Object> para = new HashMap<String,Object>();
 			para.put("param", new ArrayList<String>());
 			store.getQueryExecutorContext().prepareQuery("junit.test", para);
+		});
 	}
 	
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testWrongValue() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQuery q = new TPQuery();
 			q.setName("test");
 			q.addQueryPart(new TPQStatementPartParameter("param"));
@@ -81,6 +87,7 @@ public class TPQueryParameterTypeListTest {
 			Map<String,Object> para = new HashMap<String,Object>();
 			para.put("param", new HashMap<String,String>());
 			store.getQueryExecutorContext().prepareQuery("junit.test", para);
+		});
 	}
 	
 	@Test()

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/parameter/TPQueryParameterTypeRawTest.java

@@ -1,16 +1,16 @@
 package net.forwardfire.tpquery.statement.parameter;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.model.TPQuery;
 import net.forwardfire.tpquery.model.TPQueryParameter;
 import net.forwardfire.tpquery.model.TPQuerySet;
@@ -19,7 +19,7 @@ import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
 
 public class TPQueryParameterTypeRawTest {
 	
-	@Test()
+	@Test
 	public void testTypeRaw() throws Exception {
 		TPQuery q = new TPQuery();
 		q.setName("test");
@@ -49,7 +49,7 @@ public class TPQueryParameterTypeRawTest {
 		assertEquals(0,queryPreparedValue.getParameters().size());
 	}
 	
-	@Test()
+	@Test
 	public void testTypeRawNull() throws Exception {
 		TPQManager store = TPQFactory.createManagerBuilder()
 				.createQuerySet("junit", "jar:junit:mem:test")

tpquery-store/src/test/java/net/forwardfire/tpquery/statement/parameter/TPQueryParameterTypeValueTest.java

@@ -1,14 +1,15 @@
 package net.forwardfire.tpquery.statement.parameter;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.model.TPQuery;
 import net.forwardfire.tpquery.model.TPQueryParameter;
 import net.forwardfire.tpquery.model.TPQuerySet;
@@ -17,8 +18,9 @@ import net.forwardfire.tpquery.store.executor.TPQExecutorStatement;
 
 public class TPQueryParameterTypeValueTest {
 	
-	@Test(expected=NullPointerException.class)
+	@Test
 	public void testMissingParameter() throws Exception {
+		assertThrows(NullPointerException.class, () -> {
 			TPQuery q = new TPQuery();
 			q.setName("test");
 			q.addQueryPart(new TPQStatementPartParameter("missing-param"));
@@ -27,10 +29,12 @@ public class TPQueryParameterTypeValueTest {
 			qs.addQuery(q);
 			TPQManager store = TPQFactory.createManagerBuilder().addQuerySet("jar:junit:mem:testMissingParameter",qs).build();
 			store.getQueryExecutorContext().prepareQuery("junit.test", null);
+		});
 	}
 	
-	@Test(expected=IllegalArgumentException.class)
+	@Test
 	public void testTypeParamWrongType() throws Exception {
+		assertThrows(IllegalArgumentException.class, () -> {
 			TPQuery q = new TPQuery();
 			q.setName("test");
 			q.addQueryPart(new TPQStatementPartParameter("param"));
@@ -47,6 +51,7 @@ public class TPQueryParameterTypeValueTest {
 			Map<String,Object> paraValue = new HashMap<String,Object>();
 			paraValue.put("param", "test");
 			store.getQueryExecutorContext().prepareQuery("junit.test", paraValue);
+		});
 	}
 	
 	@Test()

tpquery-store/src/test/java/net/forwardfire/tpquery/store/TPQueryStoreTest.java

@@ -1,17 +1,17 @@
 package net.forwardfire.tpquery.store;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Map;
 
-import net.forwardfire.tpquery.TPQManager;
-import net.forwardfire.tpquery.TPQFactory;
-import net.forwardfire.tpquery.config.TPQConfig;
+import org.junit.jupiter.api.Test;
 
-import org.junit.Test;
+import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
+import net.forwardfire.tpquery.config.TPQConfig;
 
 public class TPQueryStoreTest {
 	

tpquery-store/src/test/java/net/forwardfire/tpquery/store/manager/TPQStoreManagerStatementCacheTest.java

@@ -1,7 +1,8 @@
 package net.forwardfire.tpquery.store.manager;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -15,15 +16,15 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.locks.Lock;
 
-import net.forwardfire.tpquery.TPQManager;
+import org.junit.jupiter.api.Test;
+
 import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.config.TPQConfig;
 import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterListMapper;
 import net.forwardfire.tpquery.statement.parameter.TPQStatementParameterValueMapper;
 import net.forwardfire.tpquery.store.TPQueryStoreStatement;
 
-import org.junit.Test;
-
 public class TPQStoreManagerStatementCacheTest {
 
 	private Lock createFailingLock(boolean lockOke) {
@@ -40,8 +41,9 @@ public class TPQStoreManagerStatementCacheTest {
 	}
 	
 	@SuppressWarnings("serial")
-	@Test(expected=IllegalStateException.class)
+	@Test
 	public void testCacheFailPut() throws Exception {
+		assertThrows(IllegalStateException.class, () -> {
 			TPQConfig config = TPQFactory.createConfig();
 			Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() {
 				@Override
@@ -61,10 +63,12 @@ public class TPQStoreManagerStatementCacheTest {
 							.build()
 						.build();
 			queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
+		});
 	}
 	
-	@Test(expected=IllegalStateException.class)
+	@Test
 	public void testCacheFailPutLock() throws Exception {
+		assertThrows(IllegalStateException.class, () -> {
 			TPQConfig config = TPQFactory.createConfig();
 			config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
 				@Override
@@ -83,10 +87,12 @@ public class TPQStoreManagerStatementCacheTest {
 							.build()
 						.build();
 			queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
+		});
 	}
 	
-	@Test(expected=IllegalStateException.class)
+	@Test
 	public void testCacheFailPutUnlock() throws Exception {
+		assertThrows(IllegalStateException.class, () -> {
 			TPQConfig config = TPQFactory.createConfig();
 			config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
 				@Override
@@ -105,11 +111,13 @@ public class TPQStoreManagerStatementCacheTest {
 							.build()
 						.build();
 			queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
+		});
 	}
 	
 	@SuppressWarnings("serial")
-	@Test(expected=IllegalStateException.class)
+	@Test
 	public void testCacheFailGet() throws Exception {
+		assertThrows(IllegalStateException.class, () -> {
 			TPQConfig config = TPQFactory.createConfig();
 			Map<String,TPQueryStoreStatement> cc = new HashMap<String,TPQueryStoreStatement>() {
 				@Override
@@ -130,10 +138,12 @@ public class TPQStoreManagerStatementCacheTest {
 						.build();
 			
 			queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
+		});
 	}
 	
-	@Test(expected=IllegalStateException.class)
+	@Test
 	public void testCacheFailGetLock() throws Exception {
+		assertThrows(IllegalStateException.class, () -> {
 			TPQConfig config = TPQFactory.createConfig();
 			config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
 				@Override
@@ -152,10 +162,12 @@ public class TPQStoreManagerStatementCacheTest {
 							.build()
 						.build();
 			queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
+		});
 	}
 	
-	@Test(expected=IllegalStateException.class)
+	@Test
 	public void testCacheFailGetUnlock() throws Exception {
+		assertThrows(IllegalStateException.class, () -> {
 			TPQConfig config = TPQFactory.createConfig();
 			config.setStatementCache(new TPQStoreManagerStatementCache(new HashMap<String,TPQueryStoreStatement>()) {
 				@Override
@@ -174,6 +186,7 @@ public class TPQStoreManagerStatementCacheTest {
 							.build()
 						.build();
 			queryManager.getQueryExecutorContext().prepareQuery("junit.test", null);
+		});
 	}
 	
 
@@ -217,8 +230,9 @@ public class TPQStoreManagerStatementCacheTest {
 		assertEquals(cache.size(),cache2.size());
 	}
 	
-	@Test(expected=Exception.class)
+	@Test
 	public void testCacheStatementReadObjectNoData() throws Exception {
+		assertThrows(Exception.class, () -> {
 			Map<String,TPQueryStoreStatement> cache = new HashMap<>();
 			TPQConfig config = TPQFactory.createConfig();
 			config.setStatementCache(new TPQStoreManagerStatementCache(cache));
@@ -238,10 +252,12 @@ public class TPQStoreManagerStatementCacheTest {
 			Method m = TPQueryStoreStatement.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
 			m.setAccessible(true);
 			m.invoke(c, new Object[]{});
+		});
 	}
 	
-	@Test(expected=Exception.class)
+	@Test
 	public void testCacheValueMapperReadObjectNoData() throws Exception {
+		assertThrows(Exception.class, () -> {
 			Map<String,TPQueryStoreStatement> cache = new HashMap<>();
 			TPQConfig config = TPQFactory.createConfig();
 			config.setStatementCache(new TPQStoreManagerStatementCache(cache));
@@ -261,10 +277,12 @@ public class TPQStoreManagerStatementCacheTest {
 			Method m = TPQStatementParameterValueMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
 			m.setAccessible(true);
 			m.invoke(c.getValueMapping().get(0), new Object[]{});
+		});
 	}
 	
-	@Test(expected=Exception.class)
+	@Test
 	public void testCacheListMapperReadObjectNoData() throws Exception {
+		assertThrows(Exception.class, () -> {
 			Map<String,TPQueryStoreStatement> cache = new HashMap<>();
 			TPQConfig config = TPQFactory.createConfig();
 			config.setStatementCache(new TPQStoreManagerStatementCache(cache));
@@ -284,5 +302,6 @@ public class TPQStoreManagerStatementCacheTest {
 			Method m = TPQStatementParameterListMapper.class.getDeclaredMethod("readObjectNoData", new Class<?>[]{});
 			m.setAccessible(true);
 			m.invoke(c.getValueMapping().get(0), new Object[]{});
+		});
 	}
 }

tpquery-store/src/test/java/net/forwardfire/tpquery/store/manager/TPQStoreManagerTest.java

@@ -1,19 +1,22 @@
 package net.forwardfire.tpquery.store.manager;
 
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 import java.util.HashMap;
 
-import net.forwardfire.tpquery.TPQManager;
+import org.junit.jupiter.api.Test;
+
 import net.forwardfire.tpquery.TPQFactory;
+import net.forwardfire.tpquery.TPQManager;
 import net.forwardfire.tpquery.config.TPQConfig;
 import net.forwardfire.tpquery.config.TPQConfigException;
 import net.forwardfire.tpquery.store.TPQueryStoreScriptEngineException;
 
-import org.junit.Test;
-
 public class TPQStoreManagerTest {
 
-	@Test(expected=TPQueryStoreScriptEngineException.class)
+	@Test
 	public void testParameterValueScriptError() throws Exception {
+		assertThrows(TPQueryStoreScriptEngineException.class, () -> {
 			TPQConfig config = TPQFactory.createConfig();
 			config.addParameterValueScript("throw 'error'");
 			TPQFactory
@@ -28,10 +31,12 @@ public class TPQStoreManagerTest {
 							.build()
 					.build()
 				.build();
+		});
 	}
 	
-	@Test(expected=TPQueryStoreScriptEngineException.class)
+	@Test
 	public void testCompileScriptError() throws Exception {
+		assertThrows(TPQueryStoreScriptEngineException.class, () -> {
 			TPQManager manager = TPQFactory
 				.createManagerBuilder()
 					.createQuerySet("junit", "jar:junit:mem")
@@ -45,10 +50,12 @@ public class TPQStoreManagerTest {
 					.build()
 				.build();
 			manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
+		});
 	}
 	
-	@Test(expected=Exception.class)
+	@Test
 	public void testRuntimeScriptError() throws Exception {
+		assertThrows(Exception.class, () -> {
 			TPQManager manager = TPQFactory
 				.createManagerBuilder()
 					.createQuerySet("junit", "jar:junit:mem")
@@ -62,10 +69,12 @@ public class TPQStoreManagerTest {
 					.build()
 				.build();
 			manager.getQueryExecutorContext().prepareQuery("junit.test", new HashMap<String,Object>());
+		});
 	}
 	
-	@Test(expected=TPQConfigException.class)
+	@Test
 	public void testConfigErrorByTPQStoreManagerConfig() throws Exception {
+		assertThrows(TPQConfigException.class, () ->
 		TPQFactory.createManagerBuilder()
 					.createQuerySet("junit", "jar:junit:mem")
 						.setLanguage(TPQFactory.StatementLanguage.SQL)
@@ -75,12 +84,12 @@ public class TPQStoreManagerTest {
 							.build()
 						.build()
 					.build()
-				.build();
+				.build());
 	}
 	
-	@Test(expected=TPQConfigException.class)
+	@Test
 	public void testConfigErrorByTPQStoreManager() throws Exception {
-		
+		assertThrows(TPQConfigException.class, () -> {
 			TPQConfig c = TPQFactory.createConfigBuilder()
 						.createQuerySet("junit", "jar:junit:mem")
 							.setLanguage(TPQFactory.StatementLanguage.SQL)
@@ -96,5 +105,6 @@ public class TPQStoreManagerTest {
 			smc.getEntries().get("junit.test").getQuery().getQueryParameters().get(0).setValueType("net.foo.bar.NoneExcistingClass");
 			
 			new TPQStoreManager(smc);
+		});
 	}
 }

tpquery-store/src/test/java/net/forwardfire/tpquery/store/proxy/TPQueryProxyFactoryTest.java

@@ -1,15 +1,15 @@
 package net.forwardfire.tpquery.store.proxy;
 
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import org.junit.jupiter.api.Test;
+
 import net.forwardfire.tpquery.TPQFactory;
 import net.forwardfire.tpquery.TPQManager;
 
-import org.junit.Test;
-
 public class TPQueryProxyFactoryTest {
 
 	@Test()