From 9fbee996c6ae1f6b1f57c6ad22925ed05fcef2e8 Mon Sep 17 00:00:00 2001 From: Pazus Date: Sun, 10 Feb 2019 12:03:42 +0300 Subject: [PATCH 1/5] updated jUnit to 5.4 version made all possible properties final, others need additional refactoring narrowed availability of test methods down to package-private as public is not needed nor recommended for jUnit 5 tests --- pom.xml | 29 +------ src/main/java/org/utplsql/api/DBHelper.java | 39 +++------ src/main/java/org/utplsql/api/Version.java | 71 +++++++++++++--- .../api/compatibility/CompatibilityProxy.java | 8 +- .../api/compatibility/OptionalFeatures.java | 4 +- .../api/db/DefaultDatabaseInformation.java | 5 +- .../DatabaseNotCompatibleException.java | 4 +- .../outputBuffer/OutputBufferProvider.java | 2 +- .../utplsql/api/reporter/CoreReporters.java | 16 ++-- .../api/reporter/CoverageHTMLReporter.java | 5 +- .../reporter/inspect/ReporterInspector.java | 2 +- .../TestRunnerStatementProvider.java | 5 +- .../java/org/utplsql/api/CompatibilityIT.java | 12 +-- src/test/java/org/utplsql/api/DBHelperIT.java | 6 +- .../utplsql/api/DatabaseInformationIT.java | 6 +- .../api/EnvironmentVariableUtilTest.java | 8 +- .../java/org/utplsql/api/FileMapperIT.java | 4 +- .../org/utplsql/api/OptionalFeaturesIT.java | 29 +++---- .../java/org/utplsql/api/OutputBufferIT.java | 16 ++-- .../api/RegisterCustomReporterTest.java | 6 +- .../org/utplsql/api/ReporterFactoryIT.java | 4 +- .../org/utplsql/api/ReporterInspectorIT.java | 6 +- .../java/org/utplsql/api/TestRunnerIT.java | 20 +++-- .../org/utplsql/api/VersionObjectTest.java | 84 +++++++++---------- .../api/outputBuffer/PLSQLOutputBufferIT.java | 4 +- .../CoverageHTMLReporterAssetTest.java | 6 +- .../TestRunnerStatementProviderIT.java | 18 ++-- 27 files changed, 214 insertions(+), 205 deletions(-) diff --git a/pom.xml b/pom.xml index d9338dd..b2a27b2 100644 --- a/pom.xml +++ b/pom.xml @@ -14,8 +14,7 @@ UTF-8 1.8 1.8 - 1.0.3 - 5.0.3 + 5.4.0 ${basedir}/src/main/resources/CoverageHTMLReporter 1.0.1 utPLSQL-coverage-html-${coverage.resources.version} @@ -50,13 +49,7 @@ org.junit.jupiter - junit-jupiter-api - ${junit.jupiter.version} - test - - - org.junit.jupiter - junit-jupiter-engine + junit-jupiter ${junit.jupiter.version} test @@ -163,25 +156,18 @@ org.apache.maven.plugins maven-surefire-plugin - 2.19.1 + 2.22.0 **/*IT.java false - - - org.junit.platform - junit-platform-surefire-provider - ${junit.platform.version} - - org.apache.maven.plugins maven-failsafe-plugin - 2.19.1 + 2.22.0 @@ -190,13 +176,6 @@ - - - org.junit.platform - junit-platform-surefire-provider - ${junit.platform.version} - - diff --git a/src/main/java/org/utplsql/api/DBHelper.java b/src/main/java/org/utplsql/api/DBHelper.java index ce0a7f5..c9dfa52 100644 --- a/src/main/java/org/utplsql/api/DBHelper.java +++ b/src/main/java/org/utplsql/api/DBHelper.java @@ -1,10 +1,13 @@ package org.utplsql.api; import oracle.jdbc.OracleTypes; -import org.utplsql.api.exception.UtPLSQLNotInstalledException; +import org.utplsql.api.db.DatabaseInformation; +import org.utplsql.api.db.DefaultDatabaseInformation; -import java.sql.*; -import java.util.Objects; +import java.sql.CallableStatement; +import java.sql.Connection; +import java.sql.SQLException; +import java.sql.Types; /** * Database utility functions. @@ -53,23 +56,9 @@ public static String getCurrentSchema(Connection conn) throws SQLException { */ @Deprecated public static Version getDatabaseFrameworkVersion( Connection conn ) throws SQLException { - Version result = new Version(""); - try (PreparedStatement stmt = conn.prepareStatement("select ut_runner.version() from dual")) - { - ResultSet rs = stmt.executeQuery(); + DatabaseInformation databaseInformation = new DefaultDatabaseInformation(); + return databaseInformation.getUtPlsqlFrameworkVersion(conn); - if ( rs.next() ) - result = new Version(rs.getString(1)); - - rs.close(); - } catch ( SQLException e ) { - if ( e.getErrorCode() == UtPLSQLNotInstalledException.ERROR_CODE ) - throw new UtPLSQLNotInstalledException(e); - else - throw e; - } - - return result; } /** Returns the Oracle database Version from a given connection object @@ -81,16 +70,8 @@ public static Version getDatabaseFrameworkVersion( Connection conn ) throws SQLE */ @Deprecated public static String getOracleDatabaseVersion( Connection conn ) throws SQLException { - String result = null; - try (PreparedStatement stmt = conn.prepareStatement("select version from product_component_version where product like 'Oracle Database%'")) - { - ResultSet rs = stmt.executeQuery(); - - if ( rs.next() ) - result = rs.getString(1); - } - - return result; + DatabaseInformation databaseInformation = new DefaultDatabaseInformation(); + return databaseInformation.getOracleVersion(conn); } /** diff --git a/src/main/java/org/utplsql/api/Version.java b/src/main/java/org/utplsql/api/Version.java index e5edfa0..9eda344 100644 --- a/src/main/java/org/utplsql/api/Version.java +++ b/src/main/java/org/utplsql/api/Version.java @@ -3,14 +3,33 @@ import org.utplsql.api.exception.InvalidVersionException; import javax.annotation.Nullable; +import java.util.Map; +import java.util.Objects; +import java.util.function.Function; import java.util.regex.Matcher; import java.util.regex.Pattern; +import java.util.stream.Stream; + +import static java.util.stream.Collectors.toMap; /** Simple class to parse utPLSQL Version-information and provide the separate version-numbers * * @author pesse */ public class Version implements Comparable { + + public final static Version V3_0_0 = new Version("3.0.0", 3,0,0,null, true); + public final static Version V3_0_1 = new Version("3.0.1", 3,0,1,null, true); + public final static Version V3_0_2 = new Version("3.0.2", 3,0,2,null, true); + public final static Version V3_0_3 = new Version("3.0.3", 3,0,3,null, true); + public final static Version V3_0_4 = new Version("3.0.4", 3,0,4,null, true); + public final static Version V3_1_0 = new Version("3.1.0", 3,1,0,null, true); + public final static Version V3_1_1 = new Version("3.1.1", 3,1,1,null, true); + public final static Version V3_1_2 = new Version("3.1.2", 3,1,2,null, true); + private final static Map knownVersions = + Stream.of(V3_0_0, V3_0_1, V3_0_2, V3_0_3, V3_0_4, V3_1_0, V3_1_1, V3_1_2) + .collect(toMap(Version::toString, Function.identity())); + private final String origString; private final Integer major; private final Integer minor; @@ -18,19 +37,49 @@ public class Version implements Comparable { private final Integer build; private final boolean valid; - public Version( String versionString ) { + private Version(String origString, Integer major, Integer minor, Integer bugfix, Integer build, boolean valid) { + this.origString = origString; + this.major = major; + this.minor = minor; + this.bugfix = bugfix; + this.build = build; + this.valid = valid; + } + + /** + * Use {@link Version#create} factory method instead + * For removal + */ + @Deprecated() + public Version(String versionString) { assert versionString != null; - this.origString = versionString.trim(); + Version dummy = parseVersionString(versionString); + + this.origString = dummy.origString; + this.major = dummy.major; + this.minor =dummy.minor; + this.bugfix = dummy.bugfix; + this.build = dummy.build; + this.valid = dummy.valid; + } - Pattern p = Pattern.compile("([0-9]+)\\.?([0-9]+)?\\.?([0-9]+)?\\.?([0-9]+)?"); + public static Version create(final String versionString) { + String origString = Objects.requireNonNull(versionString); + Version version = knownVersions.get(origString); + return version != null ? version : parseVersionString(origString); + } - Matcher m = p.matcher(origString); + private static Version parseVersionString(String origString) + { Integer major = null; Integer minor = null; Integer bugfix = null; Integer build = null; boolean valid = false; + Pattern p = Pattern.compile("([0-9]+)\\.?([0-9]+)?\\.?([0-9]+)?\\.?([0-9]+)?"); + + Matcher m = p.matcher(origString); try { if (m.find()) { @@ -52,11 +101,7 @@ public Version( String versionString ) { valid = false; } - this.major = major; - this.minor = minor; - this.bugfix = bugfix; - this.build = build; - this.valid = valid; + return new Version(origString, major, minor, bugfix, build, valid); } @Override @@ -92,13 +137,13 @@ public String getNormalizedString() { if ( isValid() ) { StringBuilder sb = new StringBuilder(); - sb.append(String.valueOf(major)); + sb.append(major); if ( minor != null ) - sb.append(".").append(String.valueOf(minor)); + sb.append(".").append(minor); if ( bugfix != null ) - sb.append(".").append(String.valueOf(bugfix)); + sb.append(".").append(bugfix); if ( build != null ) - sb.append(".").append(String.valueOf(build)); + sb.append(".").append(build); return sb.toString(); } diff --git a/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java b/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java index 8ecc668..fd1450a 100644 --- a/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java +++ b/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java @@ -62,7 +62,7 @@ public CompatibilityProxy( Connection conn, boolean skipCompatibilityCheck, Data private void doCompatibilityCheckWithDatabase( Connection conn ) throws SQLException { databaseVersion = databaseInformation.getUtPlsqlFrameworkVersion(conn); - Version clientVersion = new Version(UTPLSQL_COMPATIBILITY_VERSION); + Version clientVersion = Version.create(UTPLSQL_COMPATIBILITY_VERSION); if ( databaseVersion == null ) throw new DatabaseNotCompatibleException("Could not get database version", clientVersion, null, null); @@ -74,7 +74,7 @@ private void doCompatibilityCheckWithDatabase( Connection conn ) throws SQLExcep try { compatible = versionCompatibilityCheck(conn, UTPLSQL_COMPATIBILITY_VERSION, null); } catch (SQLException e) { - throw new DatabaseNotCompatibleException("Compatibility-check failed with error. Aborting. Reason: " + e.getMessage(), clientVersion, new Version("Unknown"), e); + throw new DatabaseNotCompatibleException("Compatibility-check failed with error. Aborting. Reason: " + e.getMessage(), clientVersion, Version.create("Unknown"), e); } } else compatible = versionCompatibilityCheckPre303(UTPLSQL_COMPATIBILITY_VERSION); @@ -85,7 +85,7 @@ private void doCompatibilityCheckWithDatabase( Connection conn ) throws SQLExcep */ private void doExpectCompatibility() { - databaseVersion = new Version(UTPLSQL_API_VERSION); + databaseVersion = Version.create(UTPLSQL_API_VERSION); compatible = true; } @@ -114,7 +114,7 @@ private boolean versionCompatibilityCheck(Connection conn, String requested, Str */ private boolean versionCompatibilityCheckPre303(String requested ) { - Version requestedVersion = new Version(requested); + Version requestedVersion = Version.create(requested); Objects.requireNonNull(databaseVersion.getMajor(), "Illegal database Version: " + databaseVersion.toString()); return databaseVersion.getMajor().equals(requestedVersion.getMajor()) diff --git a/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java b/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java index 4e264cc..b2fed20 100644 --- a/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java +++ b/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java @@ -17,8 +17,8 @@ public enum OptionalFeatures { OptionalFeatures( String minVersion, String maxVersion ) { - this.minVersion = minVersion != null ? new Version(minVersion) : null; - this.maxVersion = maxVersion != null ? new Version(maxVersion) : null; + this.minVersion = minVersion != null ? Version.create(minVersion) : null; + this.maxVersion = maxVersion != null ? Version.create(maxVersion) : null; } public boolean isAvailableFor(Version version ) { diff --git a/src/main/java/org/utplsql/api/db/DefaultDatabaseInformation.java b/src/main/java/org/utplsql/api/db/DefaultDatabaseInformation.java index 4d7207c..4fabee7 100644 --- a/src/main/java/org/utplsql/api/db/DefaultDatabaseInformation.java +++ b/src/main/java/org/utplsql/api/db/DefaultDatabaseInformation.java @@ -5,19 +5,18 @@ import javax.annotation.Nullable; import java.sql.*; -import java.util.Objects; public class DefaultDatabaseInformation implements DatabaseInformation { @Override public Version getUtPlsqlFrameworkVersion(Connection conn) throws SQLException { - Version result = new Version(""); + Version result = Version.create(""); try (PreparedStatement stmt = conn.prepareStatement("select ut_runner.version() from dual")) { ResultSet rs = stmt.executeQuery(); if ( rs.next() ) - result = new Version(rs.getString(1)); + result = Version.create(rs.getString(1)); rs.close(); } catch ( SQLException e ) { diff --git a/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java b/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java index b3734ca..88a4322 100644 --- a/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java +++ b/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java @@ -35,12 +35,12 @@ public DatabaseNotCompatibleException( Version clientVersion, Version databaseVe public DatabaseNotCompatibleException( Version databaseVersion, Throwable cause ) { - this(new Version(CompatibilityProxy.UTPLSQL_COMPATIBILITY_VERSION), databaseVersion, cause ); + this(Version.create(CompatibilityProxy.UTPLSQL_COMPATIBILITY_VERSION), databaseVersion, cause ); } public DatabaseNotCompatibleException( Version databaseVersion ) { - this(new Version(CompatibilityProxy.UTPLSQL_COMPATIBILITY_VERSION), databaseVersion, null ); + this(Version.create(CompatibilityProxy.UTPLSQL_COMPATIBILITY_VERSION), databaseVersion, null ); } public Version getClientVersion() { diff --git a/src/main/java/org/utplsql/api/outputBuffer/OutputBufferProvider.java b/src/main/java/org/utplsql/api/outputBuffer/OutputBufferProvider.java index 54a2a0b..c4b1afe 100644 --- a/src/main/java/org/utplsql/api/outputBuffer/OutputBufferProvider.java +++ b/src/main/java/org/utplsql/api/outputBuffer/OutputBufferProvider.java @@ -25,7 +25,7 @@ public static OutputBuffer getCompatibleOutputBuffer(Version databaseVersion, Re OracleConnection oraConn = conn.unwrap(OracleConnection.class); try { - if (databaseVersion.isGreaterOrEqualThan(new Version("3.1.0"))) { + if (databaseVersion.isGreaterOrEqualThan(Version.V3_1_0)) { if ( hasOutput(reporter, oraConn) ) { return new DefaultOutputBuffer(reporter); } diff --git a/src/main/java/org/utplsql/api/reporter/CoreReporters.java b/src/main/java/org/utplsql/api/reporter/CoreReporters.java index c008fd5..3c0f7ff 100644 --- a/src/main/java/org/utplsql/api/reporter/CoreReporters.java +++ b/src/main/java/org/utplsql/api/reporter/CoreReporters.java @@ -10,14 +10,14 @@ */ public enum CoreReporters { - UT_COVERAGE_HTML_REPORTER(new Version("3.0.0"), null), - UT_DOCUMENTATION_REPORTER(new Version("3.0.0"), null), - UT_TEAMCITY_REPORTER(new Version("3.0.0"), null), - UT_XUNIT_REPORTER(new Version("3.0.0"), null), - UT_COVERALLS_REPORTER(new Version("3.0.0"), null), - UT_COVERAGE_SONAR_REPORTER(new Version("3.0.0"), null), - UT_SONAR_TEST_REPORTER(new Version("3.0.0"), null), - UT_COVERAGE_COBERTURA_REPORTER(new Version("3.1.0"), null); + UT_COVERAGE_HTML_REPORTER(Version.V3_0_0, null), + UT_DOCUMENTATION_REPORTER(Version.V3_0_0, null), + UT_TEAMCITY_REPORTER(Version.V3_0_0, null), + UT_XUNIT_REPORTER(Version.V3_0_0, null), + UT_COVERALLS_REPORTER(Version.V3_0_0, null), + UT_COVERAGE_SONAR_REPORTER(Version.V3_0_0, null), + UT_SONAR_TEST_REPORTER(Version.V3_0_0, null), + UT_COVERAGE_COBERTURA_REPORTER(Version.V3_1_0, null); private final Version since; private final Version until; diff --git a/src/main/java/org/utplsql/api/reporter/CoverageHTMLReporter.java b/src/main/java/org/utplsql/api/reporter/CoverageHTMLReporter.java index 9b13b9e..4168332 100644 --- a/src/main/java/org/utplsql/api/reporter/CoverageHTMLReporter.java +++ b/src/main/java/org/utplsql/api/reporter/CoverageHTMLReporter.java @@ -5,7 +5,10 @@ import java.io.IOException; import java.io.InputStream; import java.net.URISyntaxException; -import java.nio.file.*; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.StandardCopyOption; import java.util.List; import java.util.function.Consumer; diff --git a/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector.java b/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector.java index f539160..436b939 100644 --- a/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector.java +++ b/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector.java @@ -37,7 +37,7 @@ static ReporterInspector create(ReporterFactory reporterFactory, Connection conn CompatibilityProxy proxy = new CompatibilityProxy(conn); - if (proxy.getDatabaseVersion().isGreaterOrEqualThan(new Version("3.1.0"))) + if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_0)) return new ReporterInspector310(reporterFactory, conn); else return new ReporterInspectorPre310(reporterFactory, conn); diff --git a/src/main/java/org/utplsql/api/testRunner/TestRunnerStatementProvider.java b/src/main/java/org/utplsql/api/testRunner/TestRunnerStatementProvider.java index abe844c..eb8722f 100644 --- a/src/main/java/org/utplsql/api/testRunner/TestRunnerStatementProvider.java +++ b/src/main/java/org/utplsql/api/testRunner/TestRunnerStatementProvider.java @@ -25,9 +25,9 @@ public static TestRunnerStatement getCompatibleTestRunnerStatement(Version datab AbstractTestRunnerStatement stmt = null; try { - if (databaseVersion.isLessThan(new Version("3.0.3"))) + if (databaseVersion.isLessThan(Version.V3_0_3)) stmt = new Pre303TestRunnerStatement(options, conn); - else if (databaseVersion.isLessThan(new Version("3.1.2"))) + else if (databaseVersion.isLessThan(Version.V3_1_2)) stmt = new Pre312TestRunnerStatement(options, conn); } catch ( InvalidVersionException ignored ) {} @@ -39,5 +39,6 @@ else if (databaseVersion.isLessThan(new Version("3.1.2"))) } private TestRunnerStatementProvider() { + throw new UnsupportedOperationException(); } } diff --git a/src/test/java/org/utplsql/api/CompatibilityIT.java b/src/test/java/org/utplsql/api/CompatibilityIT.java index acdf644..118d386 100644 --- a/src/test/java/org/utplsql/api/CompatibilityIT.java +++ b/src/test/java/org/utplsql/api/CompatibilityIT.java @@ -5,23 +5,23 @@ import java.sql.SQLException; -import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; -public class CompatibilityIT extends AbstractDatabaseTest { +class CompatibilityIT extends AbstractDatabaseTest { @Test - public void compatibleVersion() throws SQLException { + void compatibleVersion() throws SQLException { CompatibilityProxy proxy = new CompatibilityProxy(getConnection()); proxy.failOnNotCompatible(); - assertEquals(true, proxy.isCompatible()); + assertTrue(proxy.isCompatible()); } @Test - public void skipCompatibilityCheck() throws SQLException { + void skipCompatibilityCheck() throws SQLException { CompatibilityProxy proxy = new CompatibilityProxy(getConnection(), true); proxy.failOnNotCompatible(); - assertEquals(true, proxy.isCompatible()); + assertTrue(proxy.isCompatible()); } } diff --git a/src/test/java/org/utplsql/api/DBHelperIT.java b/src/test/java/org/utplsql/api/DBHelperIT.java index 14f0efc..8b13a5e 100644 --- a/src/test/java/org/utplsql/api/DBHelperIT.java +++ b/src/test/java/org/utplsql/api/DBHelperIT.java @@ -7,17 +7,17 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; -public class DBHelperIT extends AbstractDatabaseTest { +class DBHelperIT extends AbstractDatabaseTest { @Test - public void getFrameworkVersion() throws SQLException { + void getFrameworkVersion() throws SQLException { Version v = DBHelper.getDatabaseFrameworkVersion(getConnection()); assertTrue(v.isValid()); System.out.println(v.getNormalizedString() + " - " + v.toString()); } @Test - public void getOracleDatabaseVersion() throws SQLException { + void getOracleDatabaseVersion() throws SQLException { String databaseVersion = DBHelper.getOracleDatabaseVersion(getConnection()); assertNotNull(databaseVersion); } diff --git a/src/test/java/org/utplsql/api/DatabaseInformationIT.java b/src/test/java/org/utplsql/api/DatabaseInformationIT.java index 3b7027f..8eb4317 100644 --- a/src/test/java/org/utplsql/api/DatabaseInformationIT.java +++ b/src/test/java/org/utplsql/api/DatabaseInformationIT.java @@ -9,10 +9,10 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; -public class DatabaseInformationIT extends AbstractDatabaseTest { +class DatabaseInformationIT extends AbstractDatabaseTest { @Test - public void getFrameworkVersion() throws SQLException { + void getFrameworkVersion() throws SQLException { DatabaseInformation databaseInformation = new DefaultDatabaseInformation(); Version v = databaseInformation.getUtPlsqlFrameworkVersion(getConnection()); @@ -21,7 +21,7 @@ public void getFrameworkVersion() throws SQLException { } @Test - public void getOracleDatabaseVersion() throws SQLException { + void getOracleDatabaseVersion() throws SQLException { DatabaseInformation databaseInformation = new DefaultDatabaseInformation(); String databaseVersion = databaseInformation.getOracleVersion(getConnection()); diff --git a/src/test/java/org/utplsql/api/EnvironmentVariableUtilTest.java b/src/test/java/org/utplsql/api/EnvironmentVariableUtilTest.java index 7c269b3..8a0487f 100644 --- a/src/test/java/org/utplsql/api/EnvironmentVariableUtilTest.java +++ b/src/test/java/org/utplsql/api/EnvironmentVariableUtilTest.java @@ -10,10 +10,10 @@ import static org.junit.jupiter.api.Assertions.fail; -public class EnvironmentVariableUtilTest { +class EnvironmentVariableUtilTest { @Test - public void testGetVariableFromEnvironment() { + void testGetVariableFromEnvironment() { // Let's find an environment variable which is not in Properties list and not empty Set props = System.getProperties().keySet(); Optional> envVariable = System.getenv().entrySet().stream() @@ -27,14 +27,14 @@ public void testGetVariableFromEnvironment() { } @Test - public void testGetVariableFromProperty() { + void testGetVariableFromProperty() { System.setProperty("PATH", "MyPath"); assertEquals("MyPath", EnvironmentVariableUtil.getEnvValue("PATH")); } @Test - public void testGetVariableFromDefault() { + void testGetVariableFromDefault() { assertEquals("defaultValue", EnvironmentVariableUtil.getEnvValue("RANDOM"+String.valueOf(System.currentTimeMillis()), "defaultValue")); } diff --git a/src/test/java/org/utplsql/api/FileMapperIT.java b/src/test/java/org/utplsql/api/FileMapperIT.java index ee1f4fd..0db0163 100644 --- a/src/test/java/org/utplsql/api/FileMapperIT.java +++ b/src/test/java/org/utplsql/api/FileMapperIT.java @@ -9,10 +9,10 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.fail; -public class FileMapperIT extends AbstractDatabaseTest { +class FileMapperIT extends AbstractDatabaseTest { @Test - public void testFileMapper() throws SQLException { + void testFileMapper() throws SQLException { List typeMappings = new ArrayList<>(); typeMappings.add(new KeyValuePair("procedures", "PROCEDURE")); typeMappings.add(new KeyValuePair("functions", "FUNCTION")); diff --git a/src/test/java/org/utplsql/api/OptionalFeaturesIT.java b/src/test/java/org/utplsql/api/OptionalFeaturesIT.java index 2115f52..dad6263 100644 --- a/src/test/java/org/utplsql/api/OptionalFeaturesIT.java +++ b/src/test/java/org/utplsql/api/OptionalFeaturesIT.java @@ -7,9 +7,10 @@ import java.sql.SQLException; -import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; -public class OptionalFeaturesIT extends AbstractDatabaseTest { +class OptionalFeaturesIT extends AbstractDatabaseTest { private Version getDatabaseVersion() throws SQLException { @@ -17,35 +18,35 @@ private Version getDatabaseVersion() throws SQLException { } @Test - public void failOnError() throws SQLException, InvalidVersionException { + void failOnError() throws SQLException, InvalidVersionException { boolean available = OptionalFeatures.FAIL_ON_ERROR.isAvailableFor(getConnection()); - if (getDatabaseVersion().isGreaterOrEqualThan(new Version("3.0.3"))) - assertEquals(true, available); + if (getDatabaseVersion().isGreaterOrEqualThan(Version.V3_0_3)) + assertTrue(available); else - assertEquals(false, available); + assertFalse(available); } @Test - public void frameworkCompatibilityCheck() throws SQLException, InvalidVersionException { + void frameworkCompatibilityCheck() throws SQLException, InvalidVersionException { boolean available = OptionalFeatures.FRAMEWORK_COMPATIBILITY_CHECK.isAvailableFor(getConnection()); - if (getDatabaseVersion().isGreaterOrEqualThan(new Version("3.0.3"))) - assertEquals(true, available); + if (getDatabaseVersion().isGreaterOrEqualThan(Version.V3_0_3)) + assertTrue(available); else - assertEquals(false, available); + assertFalse(available); } @Test - public void customReporters() throws SQLException, InvalidVersionException { + void customReporters() throws SQLException, InvalidVersionException { boolean available = OptionalFeatures.CUSTOM_REPORTERS.isAvailableFor(getConnection()); - if (getDatabaseVersion().isGreaterOrEqualThan(new Version("3.1.0"))) - assertEquals(true, available); + if (getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_0)) + assertTrue(available); else - assertEquals(false, available); + assertFalse(available); } } diff --git a/src/test/java/org/utplsql/api/OutputBufferIT.java b/src/test/java/org/utplsql/api/OutputBufferIT.java index 4298130..441a83a 100644 --- a/src/test/java/org/utplsql/api/OutputBufferIT.java +++ b/src/test/java/org/utplsql/api/OutputBufferIT.java @@ -17,9 +17,7 @@ import java.util.List; import java.util.concurrent.*; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.junit.jupiter.api.Assertions.fail; +import static org.junit.jupiter.api.Assertions.*; /** * Integration-test for OutputBuffers @@ -27,7 +25,7 @@ * @author viniciusam * @author pesse */ -public class OutputBufferIT extends AbstractDatabaseTest { +class OutputBufferIT extends AbstractDatabaseTest { public Reporter createReporter() throws SQLException { Reporter reporter = new DocumentationReporter().init(newConnection()); @@ -36,7 +34,7 @@ public Reporter createReporter() throws SQLException { } @Test - public void printAvailableLines() throws SQLException { + void printAvailableLines() throws SQLException { ExecutorService executorService = Executors.newFixedThreadPool(2); try { @@ -97,7 +95,7 @@ public void printAvailableLines() throws SQLException { } @Test - public void fetchAllLines() throws SQLException { + void fetchAllLines() throws SQLException { final Reporter reporter = createReporter(); new TestRunner() .addPath(getUser()) @@ -110,7 +108,7 @@ public void fetchAllLines() throws SQLException { } @Test - public void getOutputFromSonarReporter() throws SQLException { + void getOutputFromSonarReporter() throws SQLException { Reporter reporter = new DefaultReporter(CoreReporters.UT_SONAR_TEST_REPORTER.name(), null).init(newConnection()); new TestRunner() @@ -124,10 +122,10 @@ public void getOutputFromSonarReporter() throws SQLException { } @Test - public void sonarReporterHasEncodingSet() throws SQLException, InvalidVersionException { + void sonarReporterHasEncodingSet() throws SQLException, InvalidVersionException { CompatibilityProxy proxy = new CompatibilityProxy(newConnection()); - if ( proxy.getDatabaseVersion().isGreaterOrEqualThan(new Version("3.1.2"))) { + if ( proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_2)) { Reporter reporter = new DefaultReporter(CoreReporters.UT_SONAR_TEST_REPORTER.name(), null).init(getConnection()); TestRunner tr = new TestRunner() diff --git a/src/test/java/org/utplsql/api/RegisterCustomReporterTest.java b/src/test/java/org/utplsql/api/RegisterCustomReporterTest.java index 799b0fb..71f6f63 100644 --- a/src/test/java/org/utplsql/api/RegisterCustomReporterTest.java +++ b/src/test/java/org/utplsql/api/RegisterCustomReporterTest.java @@ -7,10 +7,10 @@ import static org.junit.jupiter.api.Assertions.assertEquals; -public class RegisterCustomReporterTest { +class RegisterCustomReporterTest { @Test - public void addCustomReporter() { + void addCustomReporter() { ReporterFactory reporterFactory = ReporterFactory.createEmpty(); reporterFactory.registerReporterFactoryMethod("ut_custom_reporter", @@ -23,7 +23,7 @@ public void addCustomReporter() { } @Test - public void createCustomDefaultReporter() { + void createCustomDefaultReporter() { ReporterFactory reporterFactory = ReporterFactory.createEmpty(); Reporter r = reporterFactory.createReporter("ut_custom_reporter"); diff --git a/src/test/java/org/utplsql/api/ReporterFactoryIT.java b/src/test/java/org/utplsql/api/ReporterFactoryIT.java index f7f8684..3a0ef32 100644 --- a/src/test/java/org/utplsql/api/ReporterFactoryIT.java +++ b/src/test/java/org/utplsql/api/ReporterFactoryIT.java @@ -11,11 +11,11 @@ import static org.junit.jupiter.api.Assertions.assertTrue; -public class ReporterFactoryIT extends AbstractDatabaseTest { +class ReporterFactoryIT extends AbstractDatabaseTest { @Test - public void createDefaultReporterFactoryMethod() throws SQLException { + void createDefaultReporterFactoryMethod() throws SQLException { CompatibilityProxy proxy = new CompatibilityProxy(getConnection()); ReporterFactory reporterFactory = ReporterFactory.createDefault(proxy); diff --git a/src/test/java/org/utplsql/api/ReporterInspectorIT.java b/src/test/java/org/utplsql/api/ReporterInspectorIT.java index c06dc52..b076351 100644 --- a/src/test/java/org/utplsql/api/ReporterInspectorIT.java +++ b/src/test/java/org/utplsql/api/ReporterInspectorIT.java @@ -14,7 +14,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; -public class ReporterInspectorIT extends AbstractDatabaseTest { +class ReporterInspectorIT extends AbstractDatabaseTest { private ReporterFactory getReporterFactory() throws SQLException { CompatibilityProxy proxy = new CompatibilityProxy(getConnection()); @@ -23,7 +23,7 @@ private ReporterFactory getReporterFactory() throws SQLException { } @Test - public void testGetReporterInfo() throws SQLException, InvalidVersionException { + void testGetReporterInfo() throws SQLException, InvalidVersionException { CompatibilityProxy proxy = new CompatibilityProxy(getConnection()); @@ -45,7 +45,7 @@ public void testGetReporterInfo() throws SQLException, InvalidVersionException { } @Test - public void printReporterInfos() throws SQLException, InvalidVersionException { + void printReporterInfos() throws SQLException, InvalidVersionException { ReporterInspector inspector = ReporterInspector.create(getReporterFactory(), getConnection()); diff --git a/src/test/java/org/utplsql/api/TestRunnerIT.java b/src/test/java/org/utplsql/api/TestRunnerIT.java index 0e3452c..95368ca 100644 --- a/src/test/java/org/utplsql/api/TestRunnerIT.java +++ b/src/test/java/org/utplsql/api/TestRunnerIT.java @@ -18,20 +18,21 @@ * @author viniciusam * @author pesse */ -public class TestRunnerIT extends AbstractDatabaseTest { +class TestRunnerIT extends AbstractDatabaseTest { @Test - public void runWithDefaultParameters() throws SQLException { + void runWithDefaultParameters() throws SQLException { new TestRunner().run(getConnection()); } - @Test + /** This can only be run against versions >= 3.0.3 */ - public void runWithoutCompatibilityCheck() throws SQLException, InvalidVersionException { + @Test + void runWithoutCompatibilityCheck() throws SQLException, InvalidVersionException { CompatibilityProxy proxy = new CompatibilityProxy(getConnection()); - if (proxy.getDatabaseVersion().isGreaterOrEqualThan(new Version("3.0.3"))) { + if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_0_3)) { new TestRunner() .skipCompatibilityCheck(true) .run(getConnection()); @@ -39,7 +40,7 @@ public void runWithoutCompatibilityCheck() throws SQLException, InvalidVersionEx } @Test - public void runWithManyReporters() throws SQLException { + void runWithManyReporters() throws SQLException { Connection conn = getConnection(); new TestRunner() .addPath(getUser()) @@ -53,15 +54,16 @@ public void runWithManyReporters() throws SQLException { .run(conn); } - @Test + /** This can only be tested on frameworks >= 3.0.3 */ - public void failOnErrors() throws SQLException, InvalidVersionException { + @Test + void failOnErrors() throws SQLException, InvalidVersionException { Connection conn = getConnection(); CompatibilityProxy proxy = new CompatibilityProxy(conn); - if (proxy.getDatabaseVersion().isGreaterOrEqualThan(new Version("3.0.3"))) { + if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_0_3)) { Executable throwingTestRunner = () -> new TestRunner() .failOnErrors(true) .run(conn); diff --git a/src/test/java/org/utplsql/api/VersionObjectTest.java b/src/test/java/org/utplsql/api/VersionObjectTest.java index 4550514..6dbd913 100644 --- a/src/test/java/org/utplsql/api/VersionObjectTest.java +++ b/src/test/java/org/utplsql/api/VersionObjectTest.java @@ -5,11 +5,11 @@ import static org.junit.jupiter.api.Assertions.*; -public class VersionObjectTest { +class VersionObjectTest { @Test - public void versionPatternRecognitionFull() { - Version v = new Version("v3.1.3.1234"); + void versionPatternRecognitionFull() { + Version v = Version.create("v3.1.3.1234"); assertEquals(3, (long)v.getMajor()); assertEquals(1, (long)v.getMinor()); @@ -20,8 +20,8 @@ public void versionPatternRecognitionFull() { } @Test - public void versionPatternRecognitionDevelop() { - Version v = new Version("v3.1.3.2140-develop"); + void versionPatternRecognitionDevelop() { + Version v = Version.create("v3.1.3.2140-develop"); assertEquals(3, (long)v.getMajor()); assertEquals(1, (long)v.getMinor()); @@ -32,8 +32,8 @@ public void versionPatternRecognitionDevelop() { } @Test - public void versionPatternRecognitionPartial() { - Version v = new Version("3.1.etc"); + void versionPatternRecognitionPartial() { + Version v = Version.create("3.1.etc"); assertEquals(3, (long)v.getMajor()); assertEquals(1, (long)v.getMinor()); @@ -44,8 +44,8 @@ public void versionPatternRecognitionPartial() { } @Test - public void versionPatternRecognitionInvalid() { - Version v = new Version("adseef"); + void versionPatternRecognitionInvalid() { + Version v = Version.create("adseef"); assertNull(v.getMajor()); assertNull(v.getMinor()); @@ -56,48 +56,48 @@ public void versionPatternRecognitionInvalid() { } @Test - public void versionCompareTo() + void versionCompareTo() { - Version base = new Version("2.3.4.5"); + Version base = Version.create("2.3.4.5"); // Less than - assertEquals(-1, base.compareTo(new Version("3"))); - assertEquals(-1, base.compareTo(new Version("3.2"))); - assertEquals(-1, base.compareTo(new Version("2.4.1"))); - assertEquals(-1, base.compareTo(new Version("2.3.9.1"))); - assertEquals(-1, base.compareTo(new Version("2.3.4.9"))); + assertEquals(-1, base.compareTo(Version.create("3"))); + assertEquals(-1, base.compareTo(Version.create("3.2"))); + assertEquals(-1, base.compareTo(Version.create("2.4.1"))); + assertEquals(-1, base.compareTo(Version.create("2.3.9.1"))); + assertEquals(-1, base.compareTo(Version.create("2.3.4.9"))); // Greater than - assertEquals(1, base.compareTo(new Version("1"))); - assertEquals(1, base.compareTo(new Version("1.6"))); - assertEquals(1, base.compareTo(new Version("2.2.4"))); - assertEquals(1, base.compareTo(new Version("2.3.3"))); - assertEquals(1, base.compareTo(new Version("2.3.4.1"))); - assertEquals(1, base.compareTo(new Version("2.3.4"))); + assertEquals(1, base.compareTo(Version.create("1"))); + assertEquals(1, base.compareTo(Version.create("1.6"))); + assertEquals(1, base.compareTo(Version.create("2.2.4"))); + assertEquals(1, base.compareTo(Version.create("2.3.3"))); + assertEquals(1, base.compareTo(Version.create("2.3.4.1"))); + assertEquals(1, base.compareTo(Version.create("2.3.4"))); // Equal - assertEquals(0, base.compareTo(new Version("2.3.4.5"))); + assertEquals(0, base.compareTo(Version.create("2.3.4.5"))); } @Test - public void isGreaterOrEqualThan() + void isGreaterOrEqualThan() { - Version base = new Version("2.3.4.5"); + Version base = Version.create("2.3.4.5"); try { - assertEquals(true, base.isGreaterOrEqualThan(new Version("1"))); - assertEquals(true, base.isGreaterOrEqualThan(new Version("2"))); - assertEquals(true, base.isGreaterOrEqualThan(new Version("2.3"))); - assertEquals(true, base.isGreaterOrEqualThan(new Version("2.2"))); - assertEquals(true, base.isGreaterOrEqualThan(new Version("2.3.4"))); - assertEquals(true, base.isGreaterOrEqualThan(new Version("2.3.3"))); - assertEquals(true, base.isGreaterOrEqualThan(new Version("2.3.4.5"))); - assertEquals(true, base.isGreaterOrEqualThan(new Version("2.3.4.4"))); - - assertEquals(false, base.isGreaterOrEqualThan(new Version("2.3.4.6"))); - assertEquals(false, base.isGreaterOrEqualThan(new Version("2.3.5"))); - assertEquals(false, base.isGreaterOrEqualThan(new Version("2.4"))); - assertEquals(false, base.isGreaterOrEqualThan(new Version("3"))); + assertEquals(true, base.isGreaterOrEqualThan(Version.create("1"))); + assertEquals(true, base.isGreaterOrEqualThan(Version.create("2"))); + assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3"))); + assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.2"))); + assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3.4"))); + assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3.3"))); + assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3.4.5"))); + assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3.4.4"))); + + assertEquals(false, base.isGreaterOrEqualThan(Version.create("2.3.4.6"))); + assertEquals(false, base.isGreaterOrEqualThan(Version.create("2.3.5"))); + assertEquals(false, base.isGreaterOrEqualThan(Version.create("2.4"))); + assertEquals(false, base.isGreaterOrEqualThan(Version.create("3"))); } catch ( InvalidVersionException e ) { @@ -106,11 +106,11 @@ public void isGreaterOrEqualThan() } @Test - public void isGreaterOrEqualThanFails() + void isGreaterOrEqualThanFails() { // Given version is invalid try { - new Version("2.3.4.5").isGreaterOrEqualThan(new Version("aerfvf")); + Version.create("2.3.4.5").isGreaterOrEqualThan(Version.create("aerfvf")); fail("Given Version is invalid - not recognized"); } catch ( InvalidVersionException e ) { @@ -118,7 +118,7 @@ public void isGreaterOrEqualThanFails() // Base version is invalid try { - new Version("erefs").isGreaterOrEqualThan(new Version("1.2.3")); + Version.create("erefs").isGreaterOrEqualThan(Version.create("1.2.3")); fail("Base version is invalid - not recognized"); } catch ( InvalidVersionException e ) { @@ -126,7 +126,7 @@ public void isGreaterOrEqualThanFails() // Both versions are invalid try { - new Version("erefs").isGreaterOrEqualThan(new Version("aerfvf")); + Version.create("erefs").isGreaterOrEqualThan(Version.create("aerfvf")); fail("Both versions are invalid - not recognized"); } catch ( InvalidVersionException e ) { diff --git a/src/test/java/org/utplsql/api/outputBuffer/PLSQLOutputBufferIT.java b/src/test/java/org/utplsql/api/outputBuffer/PLSQLOutputBufferIT.java index 5018d8e..b4b6aa9 100644 --- a/src/test/java/org/utplsql/api/outputBuffer/PLSQLOutputBufferIT.java +++ b/src/test/java/org/utplsql/api/outputBuffer/PLSQLOutputBufferIT.java @@ -3,10 +3,10 @@ import org.junit.jupiter.api.Test; import org.utplsql.api.AbstractDatabaseTest; -public class PLSQLOutputBufferIT extends AbstractDatabaseTest { +class PLSQLOutputBufferIT extends AbstractDatabaseTest { @Test - public void getLines() { + void getLines() { } } diff --git a/src/test/java/org/utplsql/api/reporter/CoverageHTMLReporterAssetTest.java b/src/test/java/org/utplsql/api/reporter/CoverageHTMLReporterAssetTest.java index 55a3793..31abc01 100644 --- a/src/test/java/org/utplsql/api/reporter/CoverageHTMLReporterAssetTest.java +++ b/src/test/java/org/utplsql/api/reporter/CoverageHTMLReporterAssetTest.java @@ -10,7 +10,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue; -public class CoverageHTMLReporterAssetTest { +class CoverageHTMLReporterAssetTest { private static final String TEST_FOLDER = "__testAssets"; @@ -21,7 +21,7 @@ private void testFileExists(Path filePath) { } @Test - public void writeReporterAssetsTo() throws RuntimeException { + void writeReporterAssetsTo() throws RuntimeException { Path targetPath = Paths.get(TEST_FOLDER); @@ -58,7 +58,7 @@ public void writeReporterAssetsTo() throws RuntimeException { } @AfterAll - public static void clearTestAssetsFolder() { + static void clearTestAssetsFolder() { try { Files.walkFileTree(Paths.get(TEST_FOLDER), new SimpleFileVisitor() { @Override diff --git a/src/test/java/org/utplsql/api/testRunner/TestRunnerStatementProviderIT.java b/src/test/java/org/utplsql/api/testRunner/TestRunnerStatementProviderIT.java index 7c2a1bb..e811102 100644 --- a/src/test/java/org/utplsql/api/testRunner/TestRunnerStatementProviderIT.java +++ b/src/test/java/org/utplsql/api/testRunner/TestRunnerStatementProviderIT.java @@ -9,30 +9,30 @@ import static org.junit.jupiter.api.Assertions.assertEquals; -public class TestRunnerStatementProviderIT extends AbstractDatabaseTest { +class TestRunnerStatementProviderIT extends AbstractDatabaseTest { @Test - public void testGettingPre303Version() throws SQLException { - TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(new Version("3.0.2"), new TestRunnerOptions(), getConnection()); + void testGettingPre303Version() throws SQLException { + TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(Version.V3_0_2, new TestRunnerOptions(), getConnection()); assertEquals(Pre303TestRunnerStatement.class, stmt.getClass()); } @Test - public void testGettingPre312Version_from_303() throws SQLException { - TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(new Version("3.0.3"), new TestRunnerOptions(), getConnection()); + void testGettingPre312Version_from_303() throws SQLException { + TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(Version.V3_0_3, new TestRunnerOptions(), getConnection()); assertEquals(Pre312TestRunnerStatement.class, stmt.getClass()); } @Test - public void testGettingPre312Version_from_311() throws SQLException { - TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(new Version("3.1.1"), new TestRunnerOptions(), getConnection()); + void testGettingPre312Version_from_311() throws SQLException { + TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(Version.V3_1_1, new TestRunnerOptions(), getConnection()); assertEquals(Pre312TestRunnerStatement.class, stmt.getClass()); } @Test - public void testGettingActualVersion() throws SQLException { - TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(new Version("3.1.2"), new TestRunnerOptions(), getConnection()); + void testGettingActualVersion() throws SQLException { + TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(Version.V3_1_2, new TestRunnerOptions(), getConnection()); assertEquals(ActualTestRunnerStatement.class, stmt.getClass()); } } From ec4d630741d2101614b287015bf3469d116d2396 Mon Sep 17 00:00:00 2001 From: Pazus Date: Sun, 10 Feb 2019 12:24:20 +0300 Subject: [PATCH 2/5] some more cleanup --- .../org/utplsql/api/VersionObjectTest.java | 47 +++++++++---------- 1 file changed, 21 insertions(+), 26 deletions(-) diff --git a/src/test/java/org/utplsql/api/VersionObjectTest.java b/src/test/java/org/utplsql/api/VersionObjectTest.java index 6dbd913..d0f4ed4 100644 --- a/src/test/java/org/utplsql/api/VersionObjectTest.java +++ b/src/test/java/org/utplsql/api/VersionObjectTest.java @@ -15,7 +15,7 @@ void versionPatternRecognitionFull() { assertEquals(1, (long)v.getMinor()); assertEquals(3, (long)v.getBugfix()); assertEquals(1234, (long)v.getBuild()); - assertEquals(true, v.isValid()); + assertTrue(v.isValid()); assertEquals("3.1.3.1234", v.getNormalizedString()); } @@ -39,7 +39,7 @@ void versionPatternRecognitionPartial() { assertEquals(1, (long)v.getMinor()); assertNull(v.getBugfix()); assertNull(v.getBuild()); - assertEquals(true, v.isValid()); + assertTrue(v.isValid()); assertEquals("3.1", v.getNormalizedString()); } @@ -51,7 +51,7 @@ void versionPatternRecognitionInvalid() { assertNull(v.getMinor()); assertNull(v.getBugfix()); assertNull(v.getBuild()); - assertEquals(false, v.isValid()); + assertFalse(v.isValid()); assertEquals("invalid", v.getNormalizedString()); } @@ -80,29 +80,24 @@ void versionCompareTo() } @Test - void isGreaterOrEqualThan() + void isGreaterOrEqualThan() throws InvalidVersionException { Version base = Version.create("2.3.4.5"); - try { - assertEquals(true, base.isGreaterOrEqualThan(Version.create("1"))); - assertEquals(true, base.isGreaterOrEqualThan(Version.create("2"))); - assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3"))); - assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.2"))); - assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3.4"))); - assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3.3"))); - assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3.4.5"))); - assertEquals(true, base.isGreaterOrEqualThan(Version.create("2.3.4.4"))); - - assertEquals(false, base.isGreaterOrEqualThan(Version.create("2.3.4.6"))); - assertEquals(false, base.isGreaterOrEqualThan(Version.create("2.3.5"))); - assertEquals(false, base.isGreaterOrEqualThan(Version.create("2.4"))); - assertEquals(false, base.isGreaterOrEqualThan(Version.create("3"))); - } - catch ( InvalidVersionException e ) - { - fail(e); - } + assertTrue(base.isGreaterOrEqualThan(Version.create("1"))); + assertTrue(base.isGreaterOrEqualThan(Version.create("2"))); + assertTrue(base.isGreaterOrEqualThan(Version.create("2.3"))); + assertTrue(base.isGreaterOrEqualThan(Version.create("2.2"))); + assertTrue(base.isGreaterOrEqualThan(Version.create("2.3.4"))); + assertTrue(base.isGreaterOrEqualThan(Version.create("2.3.3"))); + assertTrue(base.isGreaterOrEqualThan(Version.create("2.3.4.5"))); + assertTrue(base.isGreaterOrEqualThan(Version.create("2.3.4.4"))); + + assertFalse(base.isGreaterOrEqualThan(Version.create("2.3.4.6"))); + assertFalse(base.isGreaterOrEqualThan(Version.create("2.3.5"))); + assertFalse(base.isGreaterOrEqualThan(Version.create("2.4"))); + assertFalse(base.isGreaterOrEqualThan(Version.create("3"))); + } @Test @@ -113,7 +108,7 @@ void isGreaterOrEqualThanFails() Version.create("2.3.4.5").isGreaterOrEqualThan(Version.create("aerfvf")); fail("Given Version is invalid - not recognized"); } - catch ( InvalidVersionException e ) { + catch ( InvalidVersionException ignored ) { } // Base version is invalid @@ -121,7 +116,7 @@ void isGreaterOrEqualThanFails() Version.create("erefs").isGreaterOrEqualThan(Version.create("1.2.3")); fail("Base version is invalid - not recognized"); } - catch ( InvalidVersionException e ) { + catch ( InvalidVersionException ignored ) { } // Both versions are invalid @@ -129,7 +124,7 @@ void isGreaterOrEqualThanFails() Version.create("erefs").isGreaterOrEqualThan(Version.create("aerfvf")); fail("Both versions are invalid - not recognized"); } - catch ( InvalidVersionException e ) { + catch ( InvalidVersionException ignored ) { } } } From 724ddcd6aa1c7dd7a9621d8be7d4fea3e84da389 Mon Sep 17 00:00:00 2001 From: Pazus Date: Sun, 10 Feb 2019 12:25:37 +0300 Subject: [PATCH 3/5] some more cleanup --- src/main/java/org/utplsql/api/Version.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/utplsql/api/Version.java b/src/main/java/org/utplsql/api/Version.java index 9eda344..acf8385 100644 --- a/src/main/java/org/utplsql/api/Version.java +++ b/src/main/java/org/utplsql/api/Version.java @@ -64,7 +64,7 @@ public Version(String versionString) { } public static Version create(final String versionString) { - String origString = Objects.requireNonNull(versionString); + String origString = Objects.requireNonNull(versionString).trim(); Version version = knownVersions.get(origString); return version != null ? version : parseVersionString(origString); } From 99f38fbafd300e6df26bcd7eeb3bd6488a75d698 Mon Sep 17 00:00:00 2001 From: Pazus Date: Fri, 15 Feb 2019 08:41:36 +0300 Subject: [PATCH 4/5] address inspection warnings --- src/main/java/org/utplsql/api/JavaApiVersionInfo.java | 10 ++-------- src/main/java/org/utplsql/api/TestRunner.java | 1 - src/main/java/org/utplsql/api/Version.java | 6 +++++- .../utplsql/api/compatibility/CompatibilityProxy.java | 2 +- .../api/exception/DatabaseNotCompatibleException.java | 2 +- .../api/testRunner/AbstractTestRunnerStatement.java | 2 +- src/test/java/org/utplsql/api/JavaApiVersionTest.java | 2 +- src/test/java/org/utplsql/api/OutputBufferIT.java | 2 +- 8 files changed, 12 insertions(+), 15 deletions(-) diff --git a/src/main/java/org/utplsql/api/JavaApiVersionInfo.java b/src/main/java/org/utplsql/api/JavaApiVersionInfo.java index ace900c..03171e4 100644 --- a/src/main/java/org/utplsql/api/JavaApiVersionInfo.java +++ b/src/main/java/org/utplsql/api/JavaApiVersionInfo.java @@ -4,10 +4,6 @@ import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; -import java.net.URISyntaxException; -import java.nio.charset.Charset; -import java.nio.file.Files; -import java.nio.file.Paths; /** This class is getting updated automatically by the build process. * Please do not update its constants manually cause they will be overwritten. @@ -25,11 +21,9 @@ private JavaApiVersionInfo() { } static { try { - try ( InputStream in = JavaApiVersionInfo.class.getClassLoader().getResourceAsStream("utplsql-api.version")) { - BufferedReader reader = new BufferedReader(new InputStreamReader(in)); + try ( InputStream in = JavaApiVersionInfo.class.getClassLoader().getResourceAsStream("utplsql-api.version"); + BufferedReader reader = new BufferedReader(new InputStreamReader(in))) { MAVEN_PROJECT_VERSION = reader.readLine(); - - reader.close(); } } catch ( IOException e ) { diff --git a/src/main/java/org/utplsql/api/TestRunner.java b/src/main/java/org/utplsql/api/TestRunner.java index 033f67d..b56b772 100644 --- a/src/main/java/org/utplsql/api/TestRunner.java +++ b/src/main/java/org/utplsql/api/TestRunner.java @@ -5,7 +5,6 @@ import org.utplsql.api.compatibility.CompatibilityProxy; import org.utplsql.api.db.DatabaseInformation; import org.utplsql.api.db.DefaultDatabaseInformation; -import org.utplsql.api.exception.DatabaseNotCompatibleException; import org.utplsql.api.exception.SomeTestsFailedException; import org.utplsql.api.exception.UtPLSQLNotInstalledException; import org.utplsql.api.reporter.DocumentationReporter; diff --git a/src/main/java/org/utplsql/api/Version.java b/src/main/java/org/utplsql/api/Version.java index acf8385..f7f1cf4 100644 --- a/src/main/java/org/utplsql/api/Version.java +++ b/src/main/java/org/utplsql/api/Version.java @@ -37,7 +37,7 @@ public class Version implements Comparable { private final Integer build; private final boolean valid; - private Version(String origString, Integer major, Integer minor, Integer bugfix, Integer build, boolean valid) { + private Version(String origString, @Nullable Integer major, @Nullable Integer minor, @Nullable Integer bugfix, @Nullable Integer build, boolean valid) { this.origString = origString; this.major = major; this.minor = minor; @@ -109,18 +109,22 @@ public String toString() { return origString; } + @Nullable public Integer getMajor() { return major; } + @Nullable public Integer getMinor() { return minor; } + @Nullable public Integer getBugfix() { return bugfix; } + @Nullable public Integer getBuild() { return build; } diff --git a/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java b/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java index fd1450a..068bd31 100644 --- a/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java +++ b/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java @@ -28,7 +28,7 @@ public class CompatibilityProxy { private Version databaseVersion; private boolean compatible = false; - private DatabaseInformation databaseInformation; + private final DatabaseInformation databaseInformation; public CompatibilityProxy( Connection conn ) throws SQLException { this(conn, false, null); diff --git a/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java b/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java index 88a4322..a63e784 100644 --- a/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java +++ b/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java @@ -25,7 +25,7 @@ public DatabaseNotCompatibleException( String message, Version clientVersion, Ve public DatabaseNotCompatibleException( Version clientVersion, Version databaseVersion, Throwable cause ) { - this("utPLSQL API (" + String.valueOf(clientVersion) + ") not compatible with database (" + String.valueOf(databaseVersion) + ")", clientVersion, databaseVersion, cause); + this("utPLSQL API (" + clientVersion + ") not compatible with database (" + databaseVersion + ")", clientVersion, databaseVersion, cause); } public DatabaseNotCompatibleException( Version clientVersion, Version databaseVersion ) diff --git a/src/main/java/org/utplsql/api/testRunner/AbstractTestRunnerStatement.java b/src/main/java/org/utplsql/api/testRunner/AbstractTestRunnerStatement.java index a16437e..147065a 100644 --- a/src/main/java/org/utplsql/api/testRunner/AbstractTestRunnerStatement.java +++ b/src/main/java/org/utplsql/api/testRunner/AbstractTestRunnerStatement.java @@ -21,7 +21,7 @@ abstract class AbstractTestRunnerStatement implements TestRunnerStatement { protected final TestRunnerOptions options; - protected final Connection conn; + private final Connection conn; protected final CallableStatement callableStatement; public AbstractTestRunnerStatement(TestRunnerOptions options, Connection conn) throws SQLException { diff --git a/src/test/java/org/utplsql/api/JavaApiVersionTest.java b/src/test/java/org/utplsql/api/JavaApiVersionTest.java index 65f2220..bc100c4 100644 --- a/src/test/java/org/utplsql/api/JavaApiVersionTest.java +++ b/src/test/java/org/utplsql/api/JavaApiVersionTest.java @@ -4,7 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue; -public class JavaApiVersionTest { +class JavaApiVersionTest { @Test void getJavaApiVersion() { diff --git a/src/test/java/org/utplsql/api/OutputBufferIT.java b/src/test/java/org/utplsql/api/OutputBufferIT.java index 441a83a..f1bc155 100644 --- a/src/test/java/org/utplsql/api/OutputBufferIT.java +++ b/src/test/java/org/utplsql/api/OutputBufferIT.java @@ -27,7 +27,7 @@ */ class OutputBufferIT extends AbstractDatabaseTest { - public Reporter createReporter() throws SQLException { + private Reporter createReporter() throws SQLException { Reporter reporter = new DocumentationReporter().init(newConnection()); System.out.println("Reporter ID: " + reporter.getId()); return reporter; From 67326ce2c60ee9f81dde8d9ab23714dc596d6170 Mon Sep 17 00:00:00 2001 From: Pazus Date: Sun, 17 Feb 2019 16:04:40 +0300 Subject: [PATCH 5/5] refactor assertEquals to use assertThat whe appropriate --- pom.xml | 6 ++++++ src/test/java/org/utplsql/api/JavaApiVersionTest.java | 5 +++-- src/test/java/org/utplsql/api/OutputBufferIT.java | 10 +++++++--- src/test/java/org/utplsql/api/ReporterFactoryIT.java | 7 ++++--- 4 files changed, 20 insertions(+), 8 deletions(-) diff --git a/pom.xml b/pom.xml index b2a27b2..e53fade 100644 --- a/pom.xml +++ b/pom.xml @@ -53,6 +53,12 @@ ${junit.jupiter.version} test + + org.hamcrest + hamcrest + 2.1 + test + ch.qos.logback diff --git a/src/test/java/org/utplsql/api/JavaApiVersionTest.java b/src/test/java/org/utplsql/api/JavaApiVersionTest.java index bc100c4..820b71d 100644 --- a/src/test/java/org/utplsql/api/JavaApiVersionTest.java +++ b/src/test/java/org/utplsql/api/JavaApiVersionTest.java @@ -2,12 +2,13 @@ import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.startsWith; class JavaApiVersionTest { @Test void getJavaApiVersion() { - assertTrue(JavaApiVersionInfo.getVersion().startsWith("3.1")); + assertThat(JavaApiVersionInfo.getVersion(), startsWith("3.1")); } } diff --git a/src/test/java/org/utplsql/api/OutputBufferIT.java b/src/test/java/org/utplsql/api/OutputBufferIT.java index f1bc155..18ee3ee 100644 --- a/src/test/java/org/utplsql/api/OutputBufferIT.java +++ b/src/test/java/org/utplsql/api/OutputBufferIT.java @@ -17,7 +17,11 @@ import java.util.List; import java.util.concurrent.*; -import static org.junit.jupiter.api.Assertions.*; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.emptyIterable; +import static org.hamcrest.Matchers.not; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; /** * Integration-test for OutputBuffers @@ -104,7 +108,7 @@ void fetchAllLines() throws SQLException { List outputLines = reporter.getOutputBuffer().fetchAll(getConnection()); - assertTrue(outputLines.size() > 0); + assertThat(outputLines, not(emptyIterable())); } @Test @@ -118,7 +122,7 @@ void getOutputFromSonarReporter() throws SQLException { List outputLines = reporter.getOutputBuffer().fetchAll(getConnection()); - assertTrue(outputLines.size() > 0); + assertThat(outputLines, not(emptyIterable())); } @Test diff --git a/src/test/java/org/utplsql/api/ReporterFactoryIT.java b/src/test/java/org/utplsql/api/ReporterFactoryIT.java index 3a0ef32..512982c 100644 --- a/src/test/java/org/utplsql/api/ReporterFactoryIT.java +++ b/src/test/java/org/utplsql/api/ReporterFactoryIT.java @@ -1,5 +1,6 @@ package org.utplsql.api; +import org.hamcrest.Matchers; import org.junit.jupiter.api.Test; import org.utplsql.api.compatibility.CompatibilityProxy; import org.utplsql.api.reporter.CoreReporters; @@ -9,7 +10,7 @@ import java.sql.SQLException; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.hamcrest.MatcherAssert.assertThat; class ReporterFactoryIT extends AbstractDatabaseTest { @@ -20,7 +21,7 @@ void createDefaultReporterFactoryMethod() throws SQLException { ReporterFactory reporterFactory = ReporterFactory.createDefault(proxy); - assertTrue( reporterFactory.createReporter(CoreReporters.UT_DOCUMENTATION_REPORTER.name()) instanceof DocumentationReporter ); - assertTrue( reporterFactory.createReporter(CoreReporters.UT_COVERAGE_HTML_REPORTER.name()) instanceof CoverageHTMLReporter); + assertThat(reporterFactory.createReporter(CoreReporters.UT_DOCUMENTATION_REPORTER.name()), Matchers.isA(DocumentationReporter.class)); + assertThat(reporterFactory.createReporter(CoreReporters.UT_COVERAGE_HTML_REPORTER.name()), Matchers.isA(CoverageHTMLReporter.class)); } }