test: test both binaryMode=true,false when creating connections in DatabaseMetaDataTest

build-logic/jvm/src/main/kotlin/build-logic.test-junit5.gradle.kts

@@ -38,6 +38,7 @@ tasks.configureEach<Test> {
         value?.let { systemProperty(name, it) }
     }
     passProperty("junit.jupiter.execution.parallel.enabled", "true")
+    passProperty("junit.jupiter.extensions.autodetection.enabled", "true")
     // TODO: remove when upgrade to JUnit 5.9+
     // See https://github.com/junit-team/junit5/commit/347e3119d36a5c226cddd7981452f11335fad422
     passProperty("junit.jupiter.execution.parallel.config.strategy", "DYNAMIC")

pgjdbc/build.gradle.kts

@@ -90,6 +90,9 @@ dependencies {
     testImplementation("se.jiderhamn:classloader-leak-test-framework:1.1.2")
     testFixturesImplementation("junit:junit:4.13.2")
     testFixturesImplementation("org.junit.jupiter:junit-jupiter-api:5.10.2")
+    testFixturesImplementation("org.junit.jupiter:junit-jupiter-engine:5.10.2") {
+        because("We use BeforeEachMethodAdapter to add parameters to beforeeach and aftereach methods")
+    }
     testFixturesImplementation("org.checkerframework:checker-qual:3.42.0")
 }
 

pgjdbc/reduced-pom.xml

@@ -105,6 +105,12 @@
                     <systemPropertyVariables>
                         <build.properties.relative.path>.</build.properties.relative.path>
                     </systemPropertyVariables>
+                    <properties>
+                        <configurationParameters>
+                            junit.jupiter.extensions.autodetection.enabled=true
+                            junit.jupiter.execution.timeout.default=5 m
+                        </configurationParameters>
+                    </properties>
                 </configuration>
             </plugin>
             <plugin>

pgjdbc/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension

@@ -0,0 +1 @@
+org.postgresql.test.impl.AfterBeforeParameterResolver

pgjdbc/src/testFixtures/java/org/postgresql/test/impl/AfterBeforeParameterResolver.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2024, PostgreSQL Global Development Group
+ * See the LICENSE file in the project root for more information.
+ */
+
+package org.postgresql.test.impl;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.junit.jupiter.engine.execution.BeforeEachMethodAdapter;
+import org.junit.jupiter.engine.extension.ExtensionRegistry;
+
+import java.lang.annotation.Annotation;
+import java.util.Optional;
+
+/**
+ * Passes JUnit5's {@code ParameterizedTest} parameters to {@code @BeforeEach} and {@code AfterEach}
+ * methods.
+ *
+ * @see <a href="https://github.com/junit-team/junit5/issues/3157">Parameterized BeforeEach or
+ * AfterEach only</a>
+ */
+public class AfterBeforeParameterResolver implements BeforeEachMethodAdapter, ParameterResolver {
+  private @Nullable ParameterResolver parameterisedTestParameterResolver;
+
+  @Override
+  public void invokeBeforeEachMethod(ExtensionContext context, ExtensionRegistry registry) {
+    Optional<ParameterResolver> resolverOptional = registry.getExtensions(ParameterResolver.class)
+        .stream()
+        .filter(parameterResolver -> parameterResolver.getClass().getName().contains(
+            "ParameterizedTestParameterResolver"))
+        .findFirst();
+    parameterisedTestParameterResolver = resolverOptional.orElse(null);
+  }
+
+  @Override
+  public boolean supportsParameter(ParameterContext parameterContext,
+      ExtensionContext extensionContext) throws ParameterResolutionException {
+    // JUnit asks us to resolve a parameter for "BeforeEach" method,
+    // and we delegate to the "parameterized test" implementation,
+    // however it expects to resolve a parameter on a "test method".
+    if (parameterisedTestParameterResolver != null
+        && isExecutedOnAfterOrBeforeMethod(parameterContext)) {
+      // pContext refers to a parameter on a test method
+      ParameterContext pContext = getTestMethodParameterContext(parameterContext, extensionContext);
+      return parameterisedTestParameterResolver.supportsParameter(pContext, extensionContext);
+    }
+    return false;
+  }
+
+  private DefaultParameterContext getTestMethodParameterContext(ParameterContext parameterContext,
+      ExtensionContext extensionContext) {
+    return new DefaultParameterContext(
+        parameterContext.getIndex(),
+        extensionContext.getRequiredTestMethod().getParameters()[parameterContext.getIndex()],
+        parameterContext.getTarget());
+  }
+
+  private boolean isExecutedOnAfterOrBeforeMethod(ParameterContext parameterContext) {
+    for (Annotation annotation : parameterContext.getDeclaringExecutable().getDeclaredAnnotations()) {
+      if (isAfterEachOrBeforeEachAnnotation(annotation)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private boolean isAfterEachOrBeforeEachAnnotation(Annotation annotation) {
+    return annotation.annotationType() == BeforeEach.class || annotation.annotationType() == AfterEach.class;
+  }
+
+  @Override
+  public Object resolveParameter(ParameterContext parameterContext,
+      ExtensionContext extensionContext) throws ParameterResolutionException {
+    return parameterisedTestParameterResolver.resolveParameter(
+        getTestMethodParameterContext(parameterContext, extensionContext),
+        extensionContext);
+  }
+}

pgjdbc/src/testFixtures/java/org/postgresql/test/impl/DefaultParameterContext.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2024, PostgreSQL Global Development Group
+ * See the LICENSE file in the project root for more information.
+ */
+
+package org.postgresql.test.impl;
+
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.platform.commons.util.AnnotationUtils;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Parameter;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Implements {@link ParameterContext} as JUnit does not provide default implementation.
+ */
+public class DefaultParameterContext implements ParameterContext {
+  private final int index;
+  private final Parameter parameter;
+  private final Optional<Object> target;
+
+  public DefaultParameterContext(int index, Parameter parameter,
+      Optional<Object> target) {
+    this.index = index;
+    this.parameter = parameter;
+    this.target = target;
+  }
+
+  @Override
+  public int getIndex() {
+    return index;
+  }
+
+  @Override
+  public Parameter getParameter() {
+    return parameter;
+  }
+
+  @Override
+  public Optional<Object> getTarget() {
+    return target;
+  }
+
+  @Override
+  public boolean isAnnotated(Class<? extends Annotation> annotationType) {
+    return AnnotationUtils.isAnnotated(parameter, index, annotationType);
+  }
+
+  @Override
+  public <A extends Annotation> Optional<A> findAnnotation(Class<A> annotationType) {
+    return AnnotationUtils.findAnnotation(parameter, index, annotationType);
+  }
+
+  @Override
+  public <A extends Annotation> List<A> findRepeatableAnnotations(Class<A> annotationType) {
+    return AnnotationUtils.findRepeatableAnnotations(parameter, index, annotationType);
+  }
+
+  @Override
+  public String toString() {
+    return "DefaultParameterContext[parameter=" + parameter + ", index=" + index + ", target=" + target + "]";
+  }
+}