diff --git a/RELEASE-CHECKLIST.md b/RELEASE-CHECKLIST.md new file mode 100644 index 0000000..01a6efd --- /dev/null +++ b/RELEASE-CHECKLIST.md @@ -0,0 +1,5 @@ +# TODO's before releasing a new java-api version + +- Update `CoreReporters` +- Update `Version`: knownVersions, LATEST +- Update `build.gradle.kts`: baseVersion diff --git a/src/main/java/org/utplsql/api/TestRunner.java b/src/main/java/org/utplsql/api/TestRunner.java index c330f0c..e4e8ef1 100644 --- a/src/main/java/org/utplsql/api/TestRunner.java +++ b/src/main/java/org/utplsql/api/TestRunner.java @@ -152,8 +152,12 @@ public void run(Connection conn) throws SQLException { DatabaseInformation databaseInformation = new DefaultDatabaseInformation(); - compatibilityProxy = new CompatibilityProxy(conn, options.skipCompatibilityCheck, databaseInformation); - logger.info("Running on utPLSQL {}", compatibilityProxy.getDatabaseVersion()); + if ( options.skipCompatibilityCheck ) { + compatibilityProxy = new CompatibilityProxy(conn, Version.LATEST, databaseInformation); + } else { + compatibilityProxy = new CompatibilityProxy(conn, databaseInformation); + } + logger.info("Running on utPLSQL {}", compatibilityProxy.getVersionDescription()); if (reporterFactory == null) { reporterFactory = ReporterFactory.createDefault(compatibilityProxy); @@ -236,7 +240,7 @@ private void validateReporter(Connection conn, Reporter reporter) throws SQLExce */ public Version getUsedDatabaseVersion() { if (compatibilityProxy != null) { - return compatibilityProxy.getDatabaseVersion(); + return compatibilityProxy.getUtPlsqlVersion(); } else { return null; } diff --git a/src/main/java/org/utplsql/api/Version.java b/src/main/java/org/utplsql/api/Version.java index cc2ef3e..ced1ed8 100644 --- a/src/main/java/org/utplsql/api/Version.java +++ b/src/main/java/org/utplsql/api/Version.java @@ -27,9 +27,14 @@ public class Version implements Comparable { 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); + public final static Version V3_1_3 = new Version("3.1.3", 3, 1, 3, null, true); + public final static Version V3_1_4 = new Version("3.1.4", 3, 1, 4, null, true); + public final static Version V3_1_5 = new Version("3.1.5", 3, 1, 5, null, true); + public final static Version V3_1_6 = new Version("3.1.6", 3, 1, 6, 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) + 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, V3_1_3, V3_1_4, V3_1_5, V3_1_6) .collect(toMap(Version::toString, Function.identity())); + public final static Version LATEST = V3_1_6; private final String origString; private final Integer major; diff --git a/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java b/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java index 0c184a0..5569f5b 100644 --- a/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java +++ b/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java @@ -11,6 +11,7 @@ import org.utplsql.api.testRunner.TestRunnerStatement; import org.utplsql.api.testRunner.TestRunnerStatementProvider; +import javax.annotation.Nullable; import java.sql.Connection; import java.sql.SQLException; import java.util.Objects; @@ -25,30 +26,42 @@ public class CompatibilityProxy { public static final String UTPLSQL_COMPATIBILITY_VERSION = "3"; - private static final String UTPLSQL_API_VERSION = "3.1.1"; private final DatabaseInformation databaseInformation; - private Version databaseVersion; + private Version utPlsqlVersion; + private Version realDbPlsqlVersion; private boolean compatible = false; public CompatibilityProxy(Connection conn) throws SQLException { - this(conn, false, null); + this(conn, null, null); } - public CompatibilityProxy(Connection conn, DatabaseInformation databaseInformation) throws SQLException { - this(conn, false, databaseInformation); + @Deprecated + public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck ) throws SQLException { + this(conn, skipCompatibilityCheck, null); } - public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck) throws SQLException { - this(conn, skipCompatibilityCheck, null); + @Deprecated + public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck, @Nullable DatabaseInformation databaseInformation ) throws SQLException { + this(conn, skipCompatibilityCheck ? Version.LATEST : null, databaseInformation); + } + + public CompatibilityProxy(Connection conn, @Nullable DatabaseInformation databaseInformation) throws SQLException { + this(conn, null, databaseInformation); } - public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck, DatabaseInformation databaseInformation) throws SQLException { + public CompatibilityProxy(Connection conn, @Nullable Version assumedUtPlsVersion) throws SQLException { + this(conn, assumedUtPlsVersion, null); + } + + public CompatibilityProxy(Connection conn, @Nullable Version assumedUtPlsqlVersion, @Nullable DatabaseInformation databaseInformation) throws SQLException { this.databaseInformation = (databaseInformation != null) ? databaseInformation : new DefaultDatabaseInformation(); - if (skipCompatibilityCheck) { - doExpectCompatibility(); + realDbPlsqlVersion = this.databaseInformation.getUtPlsqlFrameworkVersion(conn); + if ( assumedUtPlsqlVersion != null ) { + utPlsqlVersion = assumedUtPlsqlVersion; + compatible = utPlsqlVersion.getNormalizedString().startsWith(UTPLSQL_COMPATIBILITY_VERSION); } else { doCompatibilityCheckWithDatabase(conn); } @@ -62,18 +75,18 @@ public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck, Datab * @throws SQLException */ private void doCompatibilityCheckWithDatabase(Connection conn) throws SQLException { - databaseVersion = databaseInformation.getUtPlsqlFrameworkVersion(conn); + utPlsqlVersion = realDbPlsqlVersion; Version clientVersion = Version.create(UTPLSQL_COMPATIBILITY_VERSION); - if (databaseVersion == null) { + if (utPlsqlVersion == null) { throw new DatabaseNotCompatibleException("Could not get database version", clientVersion, null, null); } - if (databaseVersion.getMajor() == null) { - throw new DatabaseNotCompatibleException("Illegal database version: " + databaseVersion.toString(), clientVersion, databaseVersion, null); + if (utPlsqlVersion.getMajor() == null) { + throw new DatabaseNotCompatibleException("Illegal database version: " + utPlsqlVersion.toString(), clientVersion, utPlsqlVersion, null); } - if (OptionalFeatures.FRAMEWORK_COMPATIBILITY_CHECK.isAvailableFor(databaseVersion)) { + if (OptionalFeatures.FRAMEWORK_COMPATIBILITY_CHECK.isAvailableFor(utPlsqlVersion)) { try { compatible = versionCompatibilityCheck(conn, UTPLSQL_COMPATIBILITY_VERSION, null); } catch (SQLException e) { @@ -84,14 +97,6 @@ private void doCompatibilityCheckWithDatabase(Connection conn) throws SQLExcepti } } - /** - * Just prepare the proxy to expect compatibility, expecting the database framework to be the same version as the API - */ - private void doExpectCompatibility() { - databaseVersion = Version.create(UTPLSQL_API_VERSION); - compatible = true; - } - /** * Check the utPLSQL version compatibility. * @@ -121,10 +126,10 @@ private boolean versionCompatibilityCheck(Connection conn, String requested, Str private boolean versionCompatibilityCheckPre303(String requested) { Version requestedVersion = Version.create(requested); - Objects.requireNonNull(databaseVersion.getMajor(), "Illegal database Version: " + databaseVersion.toString()); - return databaseVersion.getMajor().equals(requestedVersion.getMajor()) + Objects.requireNonNull(utPlsqlVersion.getMajor(), "Illegal database Version: " + utPlsqlVersion.toString()); + return utPlsqlVersion.getMajor().equals(requestedVersion.getMajor()) && (requestedVersion.getMinor() == null - || requestedVersion.getMinor().equals(databaseVersion.getMinor())); + || requestedVersion.getMinor().equals(utPlsqlVersion.getMinor())); } /** @@ -133,7 +138,7 @@ private boolean versionCompatibilityCheckPre303(String requested) { */ public void failOnNotCompatible() throws DatabaseNotCompatibleException { if (!isCompatible()) { - throw new DatabaseNotCompatibleException(databaseVersion); + throw new DatabaseNotCompatibleException(utPlsqlVersion); } } @@ -141,8 +146,21 @@ public boolean isCompatible() { return compatible; } - public Version getDatabaseVersion() { - return databaseVersion; + @Deprecated + public Version getDatabaseVersion() { return utPlsqlVersion; } + + public Version getUtPlsqlVersion() { + return utPlsqlVersion; + } + + public Version getRealDbPlsqlVersion() { return realDbPlsqlVersion; } + + public String getVersionDescription() { + if ( utPlsqlVersion != realDbPlsqlVersion ) { + return realDbPlsqlVersion.toString() + " (Assumed: " + utPlsqlVersion.toString() + ")"; + } else { + return utPlsqlVersion.toString(); + } } /** @@ -154,7 +172,7 @@ public Version getDatabaseVersion() { * @throws SQLException */ public TestRunnerStatement getTestRunnerStatement(TestRunnerOptions options, Connection conn) throws SQLException { - return TestRunnerStatementProvider.getCompatibleTestRunnerStatement(databaseVersion, options, conn); + return TestRunnerStatementProvider.getCompatibleTestRunnerStatement(utPlsqlVersion, options, conn); } /** @@ -166,6 +184,6 @@ public TestRunnerStatement getTestRunnerStatement(TestRunnerOptions options, Con * @throws SQLException */ public OutputBuffer getOutputBuffer(Reporter reporter, Connection conn) throws SQLException { - return OutputBufferProvider.getCompatibleOutputBuffer(databaseVersion, reporter, conn); + return OutputBufferProvider.getCompatibleOutputBuffer(utPlsqlVersion, reporter, conn); } } diff --git a/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java b/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java index 629ec5b..353da38 100644 --- a/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java +++ b/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java @@ -10,7 +10,8 @@ public enum OptionalFeatures { FAIL_ON_ERROR("3.0.3.1266", null), FRAMEWORK_COMPATIBILITY_CHECK("3.0.3.1266", null), - CUSTOM_REPORTERS("3.1.0.1849", null); + CUSTOM_REPORTERS("3.1.0.1849", null), + CLIENT_CHARACTER_SET("3.1.2.2130", null); private final Version minVersion; private final Version maxVersion; @@ -32,6 +33,10 @@ public boolean isAvailableFor(Version version) { public boolean isAvailableFor(Connection conn) throws SQLException { CompatibilityProxy proxy = new CompatibilityProxy(conn); - return isAvailableFor(proxy.getDatabaseVersion()); + return isAvailableFor(proxy.getUtPlsqlVersion()); } + + public Version getMinVersion() { return minVersion; } + + public Version getMaxVersion() { return maxVersion; } } diff --git a/src/main/java/org/utplsql/api/reporter/CoreReporters.java b/src/main/java/org/utplsql/api/reporter/CoreReporters.java index 74c9dec..b459466 100644 --- a/src/main/java/org/utplsql/api/reporter/CoreReporters.java +++ b/src/main/java/org/utplsql/api/reporter/CoreReporters.java @@ -11,14 +11,18 @@ */ public enum CoreReporters { + UT_COVERAGE_COBERTURA_REPORTER(Version.V3_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_COVERALLS_REPORTER(Version.V3_0_0, null), + UT_DEBUG_REPORTER(Version.V3_1_4, null), + UT_DOCUMENTATION_REPORTER(Version.V3_0_0, null), + UT_JUNIT_REPORTER(Version.V3_1_0, null), + UT_REALTIME_REPORTER(Version.V3_1_4, null), UT_SONAR_TEST_REPORTER(Version.V3_0_0, null), - UT_COVERAGE_COBERTURA_REPORTER(Version.V3_1_0, null); + UT_TEAMCITY_REPORTER(Version.V3_0_0, null), + UT_TFS_JUNIT_REPORTER(Version.V3_1_0, null), + UT_XUNIT_REPORTER(Version.V3_0_0, null); private final Version since; private final Version until; 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 bf4c287..566356c 100644 --- a/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector.java +++ b/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector.java @@ -31,7 +31,7 @@ static ReporterInspector create(ReporterFactory reporterFactory, Connection conn CompatibilityProxy proxy = new CompatibilityProxy(conn); - if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_0)) { + if (proxy.getUtPlsqlVersion().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/reporter/inspect/ReporterInspectorPre310.java b/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspectorPre310.java index f188ac9..bbf36d6 100644 --- a/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspectorPre310.java +++ b/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspectorPre310.java @@ -21,7 +21,7 @@ class ReporterInspectorPre310 extends AbstractReporterInspector { registeredReporterFactoryMethods = reporterFactory.getRegisteredReporterInfo(); initDefaultDescriptions(); - Version databaseVersion = new CompatibilityProxy(connection).getDatabaseVersion(); + Version databaseVersion = new CompatibilityProxy(connection).getUtPlsqlVersion(); this.infos = Arrays.stream(CoreReporters.values()) .filter(r -> r.isAvailableFor(databaseVersion)) .map(this::getReporterInfo) diff --git a/src/test/java/org/utplsql/api/CompatibilityIT.java b/src/test/java/org/utplsql/api/CompatibilityIT.java index 118d386..948948a 100644 --- a/src/test/java/org/utplsql/api/CompatibilityIT.java +++ b/src/test/java/org/utplsql/api/CompatibilityIT.java @@ -19,9 +19,8 @@ void compatibleVersion() throws SQLException { @Test void skipCompatibilityCheck() throws SQLException { - CompatibilityProxy proxy = new CompatibilityProxy(getConnection(), true); + CompatibilityProxy proxy = new CompatibilityProxy(getConnection(), Version.LATEST); proxy.failOnNotCompatible(); assertTrue(proxy.isCompatible()); - } } diff --git a/src/test/java/org/utplsql/api/OptionalFeaturesIT.java b/src/test/java/org/utplsql/api/OptionalFeaturesIT.java index c7ce27e..6200870 100644 --- a/src/test/java/org/utplsql/api/OptionalFeaturesIT.java +++ b/src/test/java/org/utplsql/api/OptionalFeaturesIT.java @@ -1,6 +1,7 @@ package org.utplsql.api; import org.junit.jupiter.api.Test; +import org.omg.CORBA.DynAnyPackage.Invalid; import org.utplsql.api.compatibility.CompatibilityProxy; import org.utplsql.api.compatibility.OptionalFeatures; import org.utplsql.api.exception.InvalidVersionException; @@ -14,7 +15,7 @@ class OptionalFeaturesIT extends AbstractDatabaseTest { private Version getDatabaseVersion() throws SQLException { - return new CompatibilityProxy(getConnection()).getDatabaseVersion(); + return new CompatibilityProxy(getConnection()).getUtPlsqlVersion(); } @Test @@ -52,4 +53,15 @@ void customReporters() throws SQLException, InvalidVersionException { assertFalse(available); } } + + @Test + void clientCharset() throws SQLException, InvalidVersionException { + boolean available = OptionalFeatures.CLIENT_CHARACTER_SET.isAvailableFor(getConnection()); + + if (getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_2)) { + assertTrue(available); + } else { + assertFalse(available); + } + } } diff --git a/src/test/java/org/utplsql/api/OutputBufferIT.java b/src/test/java/org/utplsql/api/OutputBufferIT.java index c6fea1f..d9160be 100644 --- a/src/test/java/org/utplsql/api/OutputBufferIT.java +++ b/src/test/java/org/utplsql/api/OutputBufferIT.java @@ -131,7 +131,7 @@ void getOutputFromSonarReporter() throws SQLException { void sonarReporterHasEncodingSet() throws SQLException, InvalidVersionException { CompatibilityProxy proxy = new CompatibilityProxy(newConnection()); - if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_2)) { + if (proxy.getUtPlsqlVersion().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/ReporterInspectorIT.java b/src/test/java/org/utplsql/api/ReporterInspectorIT.java index 367d9d1..5df13e5 100644 --- a/src/test/java/org/utplsql/api/ReporterInspectorIT.java +++ b/src/test/java/org/utplsql/api/ReporterInspectorIT.java @@ -39,7 +39,7 @@ void testGetReporterInfo() throws SQLException, InvalidVersionException { assertEquals(infos.get(CoreReporters.UT_TEAMCITY_REPORTER.name()).getType(), ReporterInfo.Type.SQL); assertEquals(infos.get(CoreReporters.UT_XUNIT_REPORTER.name()).getType(), ReporterInfo.Type.SQL); - if (CoreReporters.UT_COVERAGE_COBERTURA_REPORTER.isAvailableFor(proxy.getDatabaseVersion())) { + if (CoreReporters.UT_COVERAGE_COBERTURA_REPORTER.isAvailableFor(proxy.getUtPlsqlVersion())) { assertEquals(infos.get(CoreReporters.UT_COVERAGE_COBERTURA_REPORTER.name()).getType(), ReporterInfo.Type.SQL); } } diff --git a/src/test/java/org/utplsql/api/TestRunnerIT.java b/src/test/java/org/utplsql/api/TestRunnerIT.java index 414b9f9..bf78190 100644 --- a/src/test/java/org/utplsql/api/TestRunnerIT.java +++ b/src/test/java/org/utplsql/api/TestRunnerIT.java @@ -3,6 +3,9 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.function.Executable; import org.utplsql.api.compatibility.CompatibilityProxy; +import org.utplsql.api.compatibility.OptionalFeatures; +import org.utplsql.api.db.DatabaseInformation; +import org.utplsql.api.db.DefaultDatabaseInformation; import org.utplsql.api.exception.InvalidVersionException; import org.utplsql.api.exception.SomeTestsFailedException; import org.utplsql.api.reporter.CoreReporters; @@ -31,9 +34,11 @@ void runWithDefaultParameters() throws SQLException { */ @Test void runWithoutCompatibilityCheck() throws SQLException, InvalidVersionException { - CompatibilityProxy proxy = new CompatibilityProxy(getConnection()); - if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_0_3)) { + DatabaseInformation databaseInformation = new DefaultDatabaseInformation(); + + // We can only test this for the versions of the latest TestRunnerStatement-Change + if ( OptionalFeatures.CLIENT_CHARACTER_SET.isAvailableFor(databaseInformation.getUtPlsqlFrameworkVersion(getConnection())) ) { new TestRunner() .skipCompatibilityCheck(true) .run(getConnection()); @@ -65,7 +70,7 @@ void failOnErrors() throws SQLException, InvalidVersionException { CompatibilityProxy proxy = new CompatibilityProxy(conn); - if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_0_3)) { + if (proxy.getUtPlsqlVersion().isGreaterOrEqualThan(Version.V3_0_3)) { Executable throwingTestRunner = () -> new TestRunner() .failOnErrors(true) .run(conn); diff --git a/src/test/java/org/utplsql/api/outputBuffer/OutputBufferProviderIT.java b/src/test/java/org/utplsql/api/outputBuffer/OutputBufferProviderIT.java new file mode 100644 index 0000000..463e0be --- /dev/null +++ b/src/test/java/org/utplsql/api/outputBuffer/OutputBufferProviderIT.java @@ -0,0 +1,49 @@ +package org.utplsql.api.outputBuffer; + +import org.junit.jupiter.api.Test; +import org.utplsql.api.AbstractDatabaseTest; +import org.utplsql.api.Version; +import org.utplsql.api.compatibility.CompatibilityProxy; +import org.utplsql.api.exception.InvalidVersionException; +import org.utplsql.api.reporter.CoreReporters; +import org.utplsql.api.reporter.Reporter; +import org.utplsql.api.reporter.ReporterFactory; + +import java.sql.SQLException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.core.IsInstanceOf.instanceOf; + +public class OutputBufferProviderIT extends AbstractDatabaseTest { + + @Test + void testGettingPre310Version() throws SQLException { + + CompatibilityProxy proxy = new CompatibilityProxy(getConnection(), Version.V3_0_4); + ReporterFactory reporterFactory = ReporterFactory.createDefault(proxy); + + Reporter r = reporterFactory.createReporter(CoreReporters.UT_DOCUMENTATION_REPORTER.name()); + r.init(getConnection(), proxy, reporterFactory); + + OutputBuffer buffer = proxy.getOutputBuffer(r, getConnection()); + + assertThat(buffer, instanceOf(CompatibilityOutputBufferPre310.class)); + } + + @Test + void testGettingActualVersion() throws SQLException, InvalidVersionException { + CompatibilityProxy proxy = new CompatibilityProxy(getConnection(), Version.LATEST); + + // We can only test new behaviour with DB-Version >= 3.1.0 + if ( proxy.getRealDbPlsqlVersion().isGreaterOrEqualThan(Version.V3_1_0)) { + ReporterFactory reporterFactory = ReporterFactory.createDefault(proxy); + + Reporter r = reporterFactory.createReporter(CoreReporters.UT_DOCUMENTATION_REPORTER.name()); + r.init(getConnection(), proxy, reporterFactory); + + OutputBuffer buffer = proxy.getOutputBuffer(r, getConnection()); + + assertThat(buffer, instanceOf(DefaultOutputBuffer.class)); + } + } +} diff --git a/src/test/java/org/utplsql/api/outputBuffer/PLSQLOutputBufferIT.java b/src/test/java/org/utplsql/api/outputBuffer/PLSQLOutputBufferIT.java deleted file mode 100644 index b4b6aa9..0000000 --- a/src/test/java/org/utplsql/api/outputBuffer/PLSQLOutputBufferIT.java +++ /dev/null @@ -1,12 +0,0 @@ -package org.utplsql.api.outputBuffer; - -import org.junit.jupiter.api.Test; -import org.utplsql.api.AbstractDatabaseTest; - -class PLSQLOutputBufferIT extends AbstractDatabaseTest { - - @Test - void getLines() { - - } -}