Fix build

exporters/common/build.gradle.kts

@@ -66,6 +66,16 @@ testing {
 
         implementation("io.grpc:grpc-stub")
         implementation("io.grpc:grpc-netty")
+
+        // NOTE: this is a strange dependency. junit reflectively analyzes classes as part of its test discovery process, eventually encounters to jackson-databind classes, and fails with a NoClassDefFoundError:
+        // JUnit Jupiter > initializationError FAILED
+        //    org.junit.platform.launcher.core.DiscoveryIssueException: TestEngine with ID 'junit-jupiter' encountered a critical issue during test discovery:
+        //
+        //    (1) [ERROR] ClassSelector [className = 'io.opentelemetry.exporter.internal.grpc.GrpcExporterTest$DummyMarshaler', classLoader = jdk.internal.loader.ClassLoaders$AppClassLoader@2aae9190] resolution failed
+        //        Source: ClassSource [className = 'io.opentelemetry.exporter.internal.grpc.GrpcExporterTest$DummyMarshaler', filePosition = null]
+        //                at io.opentelemetry.exporter.internal.grpc.GrpcExporterTest$DummyMarshaler.<no-method>(SourceFile:0)
+        //        Cause: java.lang.NoClassDefFoundError: com/fasterxml/jackson/core/JsonGenerator
+        implementation("com.fasterxml.jackson.core:jackson-databind")
       }
     }
   }

exporters/otlp/common/src/test/java/io/opentelemetry/exporter/internal/otlp/metrics/LowAllocationMetricsRequestMarshalerTest.java

@@ -50,16 +50,14 @@ import java.util.List;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ArgumentsSource;
 
 class LowAllocationMetricsRequestMarshalerTest {
 
   @ParameterizedTest
-  @ArgumentsSource(MetricsProvider.class)
+  @MethodSource("metricsArgs")
   void validateOutput(Collection<MetricData> metrics) throws Exception {
     byte[] result;
     {
@@ -85,7 +83,7 @@ class LowAllocationMetricsRequestMarshalerTest {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(MetricsProvider.class)
+  @MethodSource("metricsArgs")
   void validateJsonOutput(Collection<MetricData> metrics) throws Exception {
     String result;
     {
@@ -110,8 +108,164 @@ class LowAllocationMetricsRequestMarshalerTest {
     assertThat(lowAllocationResult).isEqualTo(result);
   }
 
+  private static Stream<Arguments> metricsArgs() {
+    return Stream.of(
+        arguments(
+            named(
+                "long gauge",
+                metrics(
+                    meterProvider ->
+                        meterProvider
+                            .get("long gauge")
+                            .gaugeBuilder("gauge")
+                            .setDescription("gauge description")
+                            .setUnit("unit")
+                            .ofLongs()
+                            .buildWithCallback(
+                                measurement ->
+                                    measurement.record(
+                                        5,
+                                        Attributes.of(AttributeKey.stringKey("key"), "value")))))),
+        arguments(
+            named(
+                "long counter",
+                metrics(
+                    meterProvider -> {
+                      LongCounter longCounter =
+                          meterProvider
+                              .get("long counter")
+                              .counterBuilder("counter")
+                              .setDescription("counter description")
+                              .setUnit("unit")
+                              .build();
+                      longCounter.add(1);
+                      longCounter.add(2, Attributes.of(AttributeKey.longKey("lives"), 9L));
+                      longCounter.add(3);
+                    }))),
+        arguments(
+            named(
+                "long updowncounter",
+                metrics(
+                    meterProvider -> {
+                      LongUpDownCounter longUpDownCounter =
+                          meterProvider
+                              .get("long updowncounter")
+                              .upDownCounterBuilder("updowncounter")
+                              .setDescription("updowncounter description")
+                              .setUnit("unit")
+                              .build();
+                      longUpDownCounter.add(1);
+                      longUpDownCounter.add(-1, Attributes.of(AttributeKey.booleanKey("on"), true));
+                      longUpDownCounter.add(1);
+                    }))),
+        arguments(
+            named(
+                "double gauge",
+                metrics(
+                    meterProvider ->
+                        meterProvider
+                            .get("double gauge")
+                            .gaugeBuilder("doublegauge")
+                            .setDescription("doublegauge")
+                            .setUnit("unit")
+                            .buildWithCallback(measurement -> measurement.record(5.0))))),
+        arguments(
+            named(
+                "double counter",
+                metrics(
+                    meterProvider -> {
+                      DoubleCounter doubleCounter =
+                          meterProvider
+                              .get("double counter")
+                              .counterBuilder("doublecounter")
+                              .ofDoubles()
+                              .build();
+                      doubleCounter.add(1.0);
+                      doubleCounter.add(2.0);
+                    }))),
+        arguments(
+            named(
+                "double updowncounter",
+                metrics(
+                    meterProvider -> {
+                      DoubleUpDownCounter doubleUpDownCounter =
+                          meterProvider
+                              .get("double updowncounter")
+                              .upDownCounterBuilder("doubleupdown")
+                              .ofDoubles()
+                              .build();
+                      doubleUpDownCounter.add(1.0);
+                      doubleUpDownCounter.add(-1.0);
+                    }))),
+        arguments(
+            named(
+                "double histogram",
+                metrics(
+                    meterProvider -> {
+                      DoubleHistogram histogram =
+                          meterProvider
+                              .get("double histogram")
+                              .histogramBuilder("histogram")
+                              .build();
+                      histogram.record(1.0);
+                      histogram.record(2.0);
+                      histogram.record(3.0);
+                      histogram.record(4.0);
+                      histogram.record(5.0);
+                    }))),
+        arguments(
+            named(
+                "long histogram",
+                metrics(
+                    meterProvider -> {
+                      LongHistogram histogram =
+                          meterProvider
+                              .get("long histogram")
+                              .histogramBuilder("histogram")
+                              .ofLongs()
+                              .build();
+                      histogram.record(1);
+                      histogram.record(2);
+                      histogram.record(3);
+                      histogram.record(4);
+                      histogram.record(5);
+                    }))),
+        arguments(
+            named(
+                "double exponential histogram",
+                metrics(
+                    meterProvider -> {
+                      DoubleHistogram histogram =
+                          meterProvider
+                              .get("double exponential histogram")
+                              .histogramBuilder("exponentialhistogram")
+                              .build();
+                      histogram.record(1.0);
+                      histogram.record(2.0);
+                      histogram.record(3.0);
+                      histogram.record(4.0);
+                      histogram.record(5.0);
+                    }))),
+        arguments(
+            named(
+                "long exponential histogram",
+                metrics(
+                    meterProvider -> {
+                      DoubleHistogram histogram =
+                          meterProvider
+                              .get("long exponential histogram")
+                              .histogramBuilder("exponentialhistogram")
+                              .build();
+                      histogram.record(1);
+                      histogram.record(2);
+                      histogram.record(3);
+                      histogram.record(4);
+                      histogram.record(5);
+                    }))));
+  }
+
   @ParameterizedTest
-  @ArgumentsSource(ExemplarProvider.class)
+  @MethodSource("exemplarArgs")
   void validateExemplar(ExemplarData exemplar) throws Exception {
     byte[] result;
     {
@@ -146,6 +300,25 @@ class LowAllocationMetricsRequestMarshalerTest {
     assertThat(lowAllocationResult).isEqualTo(result);
   }
 
+  private static Stream<Arguments> exemplarArgs() {
+    SpanContext spanContext =
+        SpanContext.create(
+            "7b2e170db4df2d593ddb4ddf2ddf2d59",
+            "170d3ddb4d23e81f",
+            TraceFlags.getSampled(),
+            TraceState.getDefault());
+
+    return Stream.of(
+        arguments(
+            named(
+                "double exemplar",
+                ImmutableDoubleExemplarData.create(Attributes.empty(), 12345, spanContext, 5.0))),
+        arguments(
+            named(
+                "long exemplar",
+                ImmutableLongExemplarData.create(Attributes.empty(), 12345, spanContext, 5))));
+  }
+
   @Test
   void validateSummary() throws Exception {
     List<ValueAtQuantile> percentileValues =
@@ -222,187 +395,4 @@ class LowAllocationMetricsRequestMarshalerTest {
 
     return metricReader.collectAllMetrics();
   }
-
-  private static class MetricsProvider implements ArgumentsProvider {
-    @Override
-    public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
-      return Stream.of(
-          arguments(
-              named(
-                  "long gauge",
-                  metrics(
-                      meterProvider ->
-                          meterProvider
-                              .get("long gauge")
-                              .gaugeBuilder("gauge")
-                              .setDescription("gauge description")
-                              .setUnit("unit")
-                              .ofLongs()
-                              .buildWithCallback(
-                                  measurement ->
-                                      measurement.record(
-                                          5,
-                                          Attributes.of(
-                                              AttributeKey.stringKey("key"), "value")))))),
-          arguments(
-              named(
-                  "long counter",
-                  metrics(
-                      meterProvider -> {
-                        LongCounter longCounter =
-                            meterProvider
-                                .get("long counter")
-                                .counterBuilder("counter")
-                                .setDescription("counter description")
-                                .setUnit("unit")
-                                .build();
-                        longCounter.add(1);
-                        longCounter.add(2, Attributes.of(AttributeKey.longKey("lives"), 9L));
-                        longCounter.add(3);
-                      }))),
-          arguments(
-              named(
-                  "long updowncounter",
-                  metrics(
-                      meterProvider -> {
-                        LongUpDownCounter longUpDownCounter =
-                            meterProvider
-                                .get("long updowncounter")
-                                .upDownCounterBuilder("updowncounter")
-                                .setDescription("updowncounter description")
-                                .setUnit("unit")
-                                .build();
-                        longUpDownCounter.add(1);
-                        longUpDownCounter.add(
-                            -1, Attributes.of(AttributeKey.booleanKey("on"), true));
-                        longUpDownCounter.add(1);
-                      }))),
-          arguments(
-              named(
-                  "double gauge",
-                  metrics(
-                      meterProvider ->
-                          meterProvider
-                              .get("double gauge")
-                              .gaugeBuilder("doublegauge")
-                              .setDescription("doublegauge")
-                              .setUnit("unit")
-                              .buildWithCallback(measurement -> measurement.record(5.0))))),
-          arguments(
-              named(
-                  "double counter",
-                  metrics(
-                      meterProvider -> {
-                        DoubleCounter doubleCounter =
-                            meterProvider
-                                .get("double counter")
-                                .counterBuilder("doublecounter")
-                                .ofDoubles()
-                                .build();
-                        doubleCounter.add(1.0);
-                        doubleCounter.add(2.0);
-                      }))),
-          arguments(
-              named(
-                  "double updowncounter",
-                  metrics(
-                      meterProvider -> {
-                        DoubleUpDownCounter doubleUpDownCounter =
-                            meterProvider
-                                .get("double updowncounter")
-                                .upDownCounterBuilder("doubleupdown")
-                                .ofDoubles()
-                                .build();
-                        doubleUpDownCounter.add(1.0);
-                        doubleUpDownCounter.add(-1.0);
-                      }))),
-          arguments(
-              named(
-                  "double histogram",
-                  metrics(
-                      meterProvider -> {
-                        DoubleHistogram histogram =
-                            meterProvider
-                                .get("double histogram")
-                                .histogramBuilder("histogram")
-                                .build();
-                        histogram.record(1.0);
-                        histogram.record(2.0);
-                        histogram.record(3.0);
-                        histogram.record(4.0);
-                        histogram.record(5.0);
-                      }))),
-          arguments(
-              named(
-                  "long histogram",
-                  metrics(
-                      meterProvider -> {
-                        LongHistogram histogram =
-                            meterProvider
-                                .get("long histogram")
-                                .histogramBuilder("histogram")
-                                .ofLongs()
-                                .build();
-                        histogram.record(1);
-                        histogram.record(2);
-                        histogram.record(3);
-                        histogram.record(4);
-                        histogram.record(5);
-                      }))),
-          arguments(
-              named(
-                  "double exponential histogram",
-                  metrics(
-                      meterProvider -> {
-                        DoubleHistogram histogram =
-                            meterProvider
-                                .get("double exponential histogram")
-                                .histogramBuilder("exponentialhistogram")
-                                .build();
-                        histogram.record(1.0);
-                        histogram.record(2.0);
-                        histogram.record(3.0);
-                        histogram.record(4.0);
-                        histogram.record(5.0);
-                      }))),
-          arguments(
-              named(
-                  "long exponential histogram",
-                  metrics(
-                      meterProvider -> {
-                        DoubleHistogram histogram =
-                            meterProvider
-                                .get("long exponential histogram")
-                                .histogramBuilder("exponentialhistogram")
-                                .build();
-                        histogram.record(1);
-                        histogram.record(2);
-                        histogram.record(3);
-                        histogram.record(4);
-                        histogram.record(5);
-                      }))));
-    }
-  }
-
-  private static class ExemplarProvider implements ArgumentsProvider {
-    @Override
-    public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
-      SpanContext spanContext =
-          SpanContext.create(
-              "7b2e170db4df2d593ddb4ddf2ddf2d59",
-              "170d3ddb4d23e81f",
-              TraceFlags.getSampled(),
-              TraceState.getDefault());
-
-      return Stream.of(
-          arguments(
-              named(
-                  "double exemplar",
-                  ImmutableDoubleExemplarData.create(Attributes.empty(), 12345, spanContext, 5.0))),
-          arguments(
-              named(
-                  "long exemplar",
-                  ImmutableLongExemplarData.create(Attributes.empty(), 12345, spanContext, 5))));
-    }
-  }
 }

exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/AbstractGrpcTelemetryExporterTest.java

@@ -91,12 +91,10 @@ import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInstance;
-import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ArgumentsSource;
 import org.junit.jupiter.params.provider.ValueSource;
 import org.slf4j.event.Level;
 import org.slf4j.event.LoggingEvent;
@@ -462,7 +460,7 @@ public abstract class AbstractGrpcTelemetryExporterTest<T, U extends Message> {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(ClientPrivateKeyProvider.class)
+  @MethodSource("clientPrivateKeyArgs")
   void clientTls(byte[] privateKey) throws Exception {
     TelemetryExporter<T> exporter =
         exporterBuilder()
@@ -480,14 +478,10 @@ public abstract class AbstractGrpcTelemetryExporterTest<T, U extends Message> {
     }
   }
 
-  private static class ClientPrivateKeyProvider implements ArgumentsProvider {
+  private static Stream<Arguments> clientPrivateKeyArgs() throws Exception {
-    @Override
+    return Stream.of(
-    @SuppressWarnings("PrimitiveArrayPassedToVarargsMethod")
+        arguments(named("PEM", Files.readAllBytes(clientCertificate.privateKeyFile().toPath()))),
-    public Stream<? extends Arguments> provideArguments(ExtensionContext context) throws Exception {
+        arguments(named("DER", clientCertificate.privateKey().getEncoded())));
-      return Stream.of(
-          arguments(named("PEM", Files.readAllBytes(clientCertificate.privateKeyFile().toPath()))),
-          arguments(named("DER", clientCertificate.privateKey().getEncoded())));
-    }
   }
 
   @Test

exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/AbstractHttpTelemetryExporterTest.java

@@ -92,12 +92,10 @@ import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInstance;
-import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ArgumentsSource;
 import org.junit.jupiter.params.provider.ValueSource;
 import org.mockserver.integration.ClientAndServer;
 import org.slf4j.event.Level;
@@ -477,7 +475,7 @@ public abstract class AbstractHttpTelemetryExporterTest<T, U extends Message> {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(ClientPrivateKeyProvider.class)
+  @MethodSource("clientPrivateKeyArgs")
   void clientTls(byte[] privateKey) throws Exception {
     TelemetryExporter<T> exporter =
         exporterBuilder()
@@ -495,14 +493,10 @@ public abstract class AbstractHttpTelemetryExporterTest<T, U extends Message> {
     }
   }
 
-  private static class ClientPrivateKeyProvider implements ArgumentsProvider {
+  private static Stream<Arguments> clientPrivateKeyArgs() throws Exception {
-    @Override
+    return Stream.of(
-    @SuppressWarnings("PrimitiveArrayPassedToVarargsMethod")
+        arguments(named("PEM", Files.readAllBytes(clientCertificate.privateKeyFile().toPath()))),
-    public Stream<? extends Arguments> provideArguments(ExtensionContext context) throws Exception {
+        arguments(named("DER", clientCertificate.privateKey().getEncoded())));
-      return Stream.of(
-          arguments(named("PEM", Files.readAllBytes(clientCertificate.privateKeyFile().toPath()))),
-          arguments(named("DER", clientCertificate.privateKey().getEncoded())));
-    }
   }
 
   @Test

exporters/sender/jdk/build.gradle.kts

@@ -11,6 +11,16 @@ dependencies {
   implementation(project(":sdk:common"))
 
   compileOnly("com.fasterxml.jackson.core:jackson-core")
+
+  // NOTE: this is a strange dependency. junit reflectively analyzes classes as part of its test discovery process, eventually encounters to jackson-databind classes, and fails with a NoClassDefFoundError:
+  // JUnit Jupiter > initializationError FAILED
+  //    org.junit.platform.launcher.core.DiscoveryIssueException: TestEngine with ID 'junit-jupiter' encountered a critical issue during test discovery:
+  //
+  //    (1) [ERROR] ClassSelector [className = 'io.opentelemetry.exporter.sender.jdk.internal.JdkHttpSenderTest$NoOpMarshaler', classLoader = jdk.internal.loader.ClassLoaders$AppClassLoader@2aae9190] resolution failed
+  //        Source: ClassSource [className = 'io.opentelemetry.exporter.sender.jdk.internal.JdkHttpSenderTest$NoOpMarshaler', filePosition = null]
+  //                at io.opentelemetry.exporter.sender.jdk.internal.JdkHttpSenderTest$NoOpMarshaler.<no-method>(SourceFile:0)
+  //        Cause: java.lang.NoClassDefFoundError: com/fasterxml/jackson/core/JsonGenerator
+  testImplementation("com.fasterxml.jackson.core:jackson-databind")
 }
 
 tasks {

integration-tests/src/test/java/io/opentelemetry/B3PropagationIntegrationTest.java

@@ -38,12 +38,10 @@ import java.util.stream.Stream;
 import javax.annotation.Nullable;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ArgumentsSource;
 
 /** Integration tests for the B3 propagators, in various configurations. */
 class B3PropagationIntegrationTest {
@@ -160,7 +158,7 @@ class B3PropagationIntegrationTest {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(WebClientArgumentSupplier.class)
+  @MethodSource("webClientArgs")
   void propagation(String testType, WebClient client) throws IOException {
     OpenTelemetrySdk clientSdk = setupClient();
 
@@ -181,7 +179,7 @@ class B3PropagationIntegrationTest {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(WebClientArgumentSupplier.class)
+  @MethodSource("webClientArgs")
   void noClientTracing(String testType, WebClient client) throws IOException {
     assertThat(client.get("/frontend").aggregate().join().contentUtf8()).isEqualTo("OK");
 
@@ -194,6 +192,11 @@ class B3PropagationIntegrationTest {
         .allSatisfy(spanData -> assertThat(spanData.getTraceId()).isEqualTo(traceId));
   }
 
+  private static Stream<Arguments> webClientArgs() {
+    return Stream.of(
+        Arguments.of("b3multi", b3MultiClient), Arguments.of("b3single", b3SingleClient));
+  }
+
   private static WebClient createPropagatingClient(URI uri, TextMapPropagator propagator) {
     return WebClient.builder(uri)
         .decorator(
@@ -234,12 +237,4 @@ class B3PropagationIntegrationTest {
               }
             });
   }
-
-  public static class WebClientArgumentSupplier implements ArgumentsProvider {
-    @Override
-    public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
-      return Stream.of(
-          Arguments.of("b3multi", b3MultiClient), Arguments.of("b3single", b3SingleClient));
-    }
-  }
 }

sdk-extensions/jaeger-remote-sampler/src/test/java/io/opentelemetry/sdk/extension/trace/jaeger/sampler/JaegerRemoteSamplerTest.java

@@ -45,12 +45,10 @@ import org.awaitility.core.ThrowingRunnable;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ArgumentsSource;
 import org.slf4j.event.Level;
 import org.slf4j.event.LoggingEvent;
 
@@ -169,7 +167,7 @@ class JaegerRemoteSamplerTest {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(ClientPrivateKeyProvider.class)
+  @MethodSource("clientPrivateKeyArgs")
   void clientTlsConnectionWorks(byte[] privateKey) throws IOException {
     try (JaegerRemoteSampler sampler =
         JaegerRemoteSampler.builder()
@@ -189,14 +187,10 @@ class JaegerRemoteSamplerTest {
     }
   }
 
-  private static class ClientPrivateKeyProvider implements ArgumentsProvider {
+  private static Stream<Arguments> clientPrivateKeyArgs() throws IOException {
-    @Override
+    return Stream.of(
-    @SuppressWarnings("PrimitiveArrayPassedToVarargsMethod")
+        arguments(named("PEM", Files.readAllBytes(clientCertificate.privateKeyFile().toPath()))),
-    public Stream<? extends Arguments> provideArguments(ExtensionContext context) throws Exception {
+        arguments(named("DER", clientCertificate.privateKey().getEncoded())));
-      return Stream.of(
-          arguments(named("PEM", Files.readAllBytes(clientCertificate.privateKeyFile().toPath()))),
-          arguments(named("DER", clientCertificate.privateKey().getEncoded())));
-    }
   }
 
   @Test

sdk/metrics/src/testIncubating/java/io/opentelemetry/sdk/metrics/AttributesAdviceTest.java

@@ -51,11 +51,9 @@ import java.util.function.Consumer;
 import java.util.stream.Stream;
 import javax.annotation.Nullable;
 import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.ArgumentsSource;
 
 class AttributesAdviceTest {
 
@@ -74,7 +72,7 @@ class AttributesAdviceTest {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(InstrumentsProvider.class)
+  @MethodSource("instrumentProviderArgs")
   void instrumentWithoutAdvice(
       InstrumentFactory instrumentFactory, PointsAssert<AbstractPointAssert<?, ?>> pointsAssert) {
     InMemoryMetricReader reader = InMemoryMetricReader.create();
@@ -91,7 +89,7 @@ class AttributesAdviceTest {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(InstrumentsProvider.class)
+  @MethodSource("instrumentProviderArgs")
   void instrumentWithAdvice(
       InstrumentFactory instrumentFactory, PointsAssert<AbstractPointAssert<?, ?>> pointsAssert) {
     InMemoryMetricReader reader = InMemoryMetricReader.create();
@@ -113,7 +111,7 @@ class AttributesAdviceTest {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(InstrumentsProvider.class)
+  @MethodSource("instrumentProviderArgs")
   void instrumentWithAdviceAndViews(
       InstrumentFactory instrumentFactory, PointsAssert<AbstractPointAssert<?, ?>> pointsAssert) {
     InMemoryMetricReader reader = InMemoryMetricReader.create();
@@ -143,7 +141,7 @@ class AttributesAdviceTest {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(InstrumentsProvider.class)
+  @MethodSource("instrumentProviderArgs")
   void instrumentWithAdviceAndDescriptionViews(
       InstrumentFactory instrumentFactory, PointsAssert<AbstractPointAssert<?, ?>> pointsAssert) {
     InMemoryMetricReader reader = InMemoryMetricReader.create();
@@ -175,7 +173,7 @@ class AttributesAdviceTest {
   }
 
   @ParameterizedTest
-  @ArgumentsSource(InstrumentsProvider.class)
+  @MethodSource("instrumentProviderArgs")
   void instrumentWithAdviceAndBaggage(
       InstrumentFactory instrumentFactory, PointsAssert<AbstractPointAssert<?, ?>> pointsAssert) {
     InMemoryMetricReader reader = InMemoryMetricReader.create();
@@ -217,148 +215,142 @@ class AttributesAdviceTest {
                             equalTo(stringKey("baggage1"), "value1"))));
   }
 
-  static final class InstrumentsProvider implements ArgumentsProvider {
+  private static Stream<Arguments> instrumentProviderArgs() {
-
+    return Stream.of(
-    @Override
+        // double counter
-    public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
+        arguments(
-      return Stream.of(
+            (InstrumentFactory)
-          // double counter
+                (meterProvider, name, attributesAdvice) -> {
-          arguments(
+                  DoubleCounterBuilder doubleCounterBuilder =
-              (InstrumentFactory)
+                      meterProvider.get("meter").counterBuilder(name).ofDoubles();
-                  (meterProvider, name, attributesAdvice) -> {
+                  if (attributesAdvice != null) {
-                    DoubleCounterBuilder doubleCounterBuilder =
+                    ((ExtendedDoubleCounterBuilder) doubleCounterBuilder)
-                        meterProvider.get("meter").counterBuilder(name).ofDoubles();
+                        .setAttributesAdvice(attributesAdvice);
-                    if (attributesAdvice != null) {
+                  }
-                      ((ExtendedDoubleCounterBuilder) doubleCounterBuilder)
+                  DoubleCounter counter = doubleCounterBuilder.build();
-                          .setAttributesAdvice(attributesAdvice);
+                  return counter::add;
-                    }
+                },
-                    DoubleCounter counter = doubleCounterBuilder.build();
+            (PointsAssert<DoublePointAssert>)
-                    return counter::add;
+                (metricAssert, assertions) ->
-                  },
+                    metricAssert.hasDoubleSumSatisfying(
-              (PointsAssert<DoublePointAssert>)
+                        sum -> sum.hasPointsSatisfying(assertions))),
-                  (metricAssert, assertions) ->
+        // long counter
-                      metricAssert.hasDoubleSumSatisfying(
+        arguments(
-                          sum -> sum.hasPointsSatisfying(assertions))),
+            (InstrumentFactory)
-          // long counter
+                (meterProvider, name, attributesAdvice) -> {
-          arguments(
+                  LongCounterBuilder doubleCounterBuilder =
-              (InstrumentFactory)
+                      meterProvider.get("meter").counterBuilder(name);
-                  (meterProvider, name, attributesAdvice) -> {
+                  if (attributesAdvice != null) {
-                    LongCounterBuilder doubleCounterBuilder =
+                    ((ExtendedLongCounterBuilder) doubleCounterBuilder)
-                        meterProvider.get("meter").counterBuilder(name);
+                        .setAttributesAdvice(attributesAdvice);
-                    if (attributesAdvice != null) {
+                  }
-                      ((ExtendedLongCounterBuilder) doubleCounterBuilder)
+                  LongCounter counter = doubleCounterBuilder.build();
-                          .setAttributesAdvice(attributesAdvice);
+                  return counter::add;
-                    }
+                },
-                    LongCounter counter = doubleCounterBuilder.build();
+            (PointsAssert<LongPointAssert>)
-                    return counter::add;
+                (metricAssert, assertions) ->
-                  },
+                    metricAssert.hasLongSumSatisfying(sum -> sum.hasPointsSatisfying(assertions))),
-              (PointsAssert<LongPointAssert>)
+        // double gauge
-                  (metricAssert, assertions) ->
+        arguments(
-                      metricAssert.hasLongSumSatisfying(
+            (InstrumentFactory)
-                          sum -> sum.hasPointsSatisfying(assertions))),
+                (meterProvider, name, attributesAdvice) -> {
-          // double gauge
+                  DoubleGaugeBuilder doubleGaugeBuilder =
-          arguments(
+                      meterProvider.get("meter").gaugeBuilder(name);
-              (InstrumentFactory)
+                  if (attributesAdvice != null) {
-                  (meterProvider, name, attributesAdvice) -> {
+                    ((ExtendedDoubleGaugeBuilder) doubleGaugeBuilder)
-                    DoubleGaugeBuilder doubleGaugeBuilder =
+                        .setAttributesAdvice(attributesAdvice);
-                        meterProvider.get("meter").gaugeBuilder(name);
+                  }
-                    if (attributesAdvice != null) {
+                  DoubleGauge gauge = doubleGaugeBuilder.build();
-                      ((ExtendedDoubleGaugeBuilder) doubleGaugeBuilder)
+                  return gauge::set;
-                          .setAttributesAdvice(attributesAdvice);
+                },
-                    }
+            (PointsAssert<DoublePointAssert>)
-                    DoubleGauge gauge = doubleGaugeBuilder.build();
+                (metricAssert, assertions) ->
-                    return gauge::set;
+                    metricAssert.hasDoubleGaugeSatisfying(
-                  },
+                        sum -> sum.hasPointsSatisfying(assertions))),
-              (PointsAssert<DoublePointAssert>)
+        // long gauge
-                  (metricAssert, assertions) ->
+        arguments(
-                      metricAssert.hasDoubleGaugeSatisfying(
+            (InstrumentFactory)
-                          sum -> sum.hasPointsSatisfying(assertions))),
+                (meterProvider, name, attributesAdvice) -> {
-          // long gauge
+                  LongGaugeBuilder longGaugeBuilder =
-          arguments(
+                      meterProvider.get("meter").gaugeBuilder(name).ofLongs();
-              (InstrumentFactory)
+                  if (attributesAdvice != null) {
-                  (meterProvider, name, attributesAdvice) -> {
+                    ((ExtendedLongGaugeBuilder) longGaugeBuilder)
-                    LongGaugeBuilder longGaugeBuilder =
+                        .setAttributesAdvice(attributesAdvice);
-                        meterProvider.get("meter").gaugeBuilder(name).ofLongs();
+                  }
-                    if (attributesAdvice != null) {
+                  LongGauge gauge = longGaugeBuilder.build();
-                      ((ExtendedLongGaugeBuilder) longGaugeBuilder)
+                  return gauge::set;
-                          .setAttributesAdvice(attributesAdvice);
+                },
-                    }
+            (PointsAssert<LongPointAssert>)
-                    LongGauge gauge = longGaugeBuilder.build();
+                (metricAssert, assertions) ->
-                    return gauge::set;
+                    metricAssert.hasLongGaugeSatisfying(
-                  },
+                        sum -> sum.hasPointsSatisfying(assertions))),
-              (PointsAssert<LongPointAssert>)
+        // double histogram
-                  (metricAssert, assertions) ->
+        arguments(
-                      metricAssert.hasLongGaugeSatisfying(
+            (InstrumentFactory)
-                          sum -> sum.hasPointsSatisfying(assertions))),
+                (meterProvider, name, attributesAdvice) -> {
-          // double histogram
+                  DoubleHistogramBuilder doubleHistogramBuilder =
-          arguments(
+                      meterProvider.get("meter").histogramBuilder(name);
-              (InstrumentFactory)
+                  if (attributesAdvice != null) {
-                  (meterProvider, name, attributesAdvice) -> {
+                    ((ExtendedDoubleHistogramBuilder) doubleHistogramBuilder)
-                    DoubleHistogramBuilder doubleHistogramBuilder =
+                        .setAttributesAdvice(attributesAdvice);
-                        meterProvider.get("meter").histogramBuilder(name);
+                  }
-                    if (attributesAdvice != null) {
+                  DoubleHistogram histogram = doubleHistogramBuilder.build();
-                      ((ExtendedDoubleHistogramBuilder) doubleHistogramBuilder)
+                  return histogram::record;
-                          .setAttributesAdvice(attributesAdvice);
+                },
-                    }
+            (PointsAssert<HistogramPointAssert>)
-                    DoubleHistogram histogram = doubleHistogramBuilder.build();
+                (metricAssert, assertions) ->
-                    return histogram::record;
+                    metricAssert.hasHistogramSatisfying(
-                  },
+                        sum -> sum.hasPointsSatisfying(assertions))),
-              (PointsAssert<HistogramPointAssert>)
+        // long histogram
-                  (metricAssert, assertions) ->
+        arguments(
-                      metricAssert.hasHistogramSatisfying(
+            (InstrumentFactory)
-                          sum -> sum.hasPointsSatisfying(assertions))),
+                (meterProvider, name, attributesAdvice) -> {
-          // long histogram
+                  LongHistogramBuilder doubleHistogramBuilder =
-          arguments(
+                      meterProvider.get("meter").histogramBuilder(name).ofLongs();
-              (InstrumentFactory)
+                  if (attributesAdvice != null) {
-                  (meterProvider, name, attributesAdvice) -> {
+                    ((ExtendedLongHistogramBuilder) doubleHistogramBuilder)
-                    LongHistogramBuilder doubleHistogramBuilder =
+                        .setAttributesAdvice(attributesAdvice);
-                        meterProvider.get("meter").histogramBuilder(name).ofLongs();
+                  }
-                    if (attributesAdvice != null) {
+                  LongHistogram histogram = doubleHistogramBuilder.build();
-                      ((ExtendedLongHistogramBuilder) doubleHistogramBuilder)
+                  return histogram::record;
-                          .setAttributesAdvice(attributesAdvice);
+                },
-                    }
+            (PointsAssert<HistogramPointAssert>)
-                    LongHistogram histogram = doubleHistogramBuilder.build();
+                (metricAssert, assertions) ->
-                    return histogram::record;
+                    metricAssert.hasHistogramSatisfying(
-                  },
+                        sum -> sum.hasPointsSatisfying(assertions))),
-              (PointsAssert<HistogramPointAssert>)
+        // double up down counter
-                  (metricAssert, assertions) ->
+        arguments(
-                      metricAssert.hasHistogramSatisfying(
+            (InstrumentFactory)
-                          sum -> sum.hasPointsSatisfying(assertions))),
+                (meterProvider, name, attributesAdvice) -> {
-          // double up down counter
+                  DoubleUpDownCounterBuilder doubleUpDownCounterBuilder =
-          arguments(
+                      meterProvider.get("meter").upDownCounterBuilder(name).ofDoubles();
-              (InstrumentFactory)
+                  if (attributesAdvice != null) {
-                  (meterProvider, name, attributesAdvice) -> {
+                    ((ExtendedDoubleUpDownCounterBuilder) doubleUpDownCounterBuilder)
-                    DoubleUpDownCounterBuilder doubleUpDownCounterBuilder =
+                        .setAttributesAdvice(attributesAdvice);
-                        meterProvider.get("meter").upDownCounterBuilder(name).ofDoubles();
+                  }
-                    if (attributesAdvice != null) {
+                  DoubleUpDownCounter upDownCounter = doubleUpDownCounterBuilder.build();
-                      ((ExtendedDoubleUpDownCounterBuilder) doubleUpDownCounterBuilder)
+                  return upDownCounter::add;
-                          .setAttributesAdvice(attributesAdvice);
+                },
-                    }
+            (PointsAssert<DoublePointAssert>)
-                    DoubleUpDownCounter upDownCounter = doubleUpDownCounterBuilder.build();
+                (metricAssert, assertions) ->
-                    return upDownCounter::add;
+                    metricAssert.hasDoubleSumSatisfying(
-                  },
+                        sum -> sum.hasPointsSatisfying(assertions))),
-              (PointsAssert<DoublePointAssert>)
+        // long up down counter
-                  (metricAssert, assertions) ->
+        arguments(
-                      metricAssert.hasDoubleSumSatisfying(
+            (InstrumentFactory)
-                          sum -> sum.hasPointsSatisfying(assertions))),
+                (meterProvider, name, attributesAdvice) -> {
-          // long up down counter
+                  LongUpDownCounterBuilder doubleUpDownCounterBuilder =
-          arguments(
+                      meterProvider.get("meter").upDownCounterBuilder(name);
-              (InstrumentFactory)
+                  if (attributesAdvice != null) {
-                  (meterProvider, name, attributesAdvice) -> {
+                    ((ExtendedLongUpDownCounterBuilder) doubleUpDownCounterBuilder)
-                    LongUpDownCounterBuilder doubleUpDownCounterBuilder =
+                        .setAttributesAdvice(attributesAdvice);
-                        meterProvider.get("meter").upDownCounterBuilder(name);
+                  }
-                    if (attributesAdvice != null) {
+                  LongUpDownCounter upDownCounter = doubleUpDownCounterBuilder.build();
-                      ((ExtendedLongUpDownCounterBuilder) doubleUpDownCounterBuilder)
+                  return upDownCounter::add;
-                          .setAttributesAdvice(attributesAdvice);
+                },
-                    }
+            (PointsAssert<LongPointAssert>)
-                    LongUpDownCounter upDownCounter = doubleUpDownCounterBuilder.build();
+                (metricAssert, assertions) ->
-                    return upDownCounter::add;
+                    metricAssert.hasLongSumSatisfying(sum -> sum.hasPointsSatisfying(assertions))));
-                  },
-              (PointsAssert<LongPointAssert>)
-                  (metricAssert, assertions) ->
-                      metricAssert.hasLongSumSatisfying(
-                          sum -> sum.hasPointsSatisfying(assertions))));
-    }
   }
 
   @FunctionalInterface