diff --git a/all/src/test/java/io/opentelemetry/all/NoSharedInternalCodeTest.java b/all/src/test/java/io/opentelemetry/all/NoSharedInternalCodeTest.java
index ec10e2eb172..1029239b65a 100644
--- a/all/src/test/java/io/opentelemetry/all/NoSharedInternalCodeTest.java
+++ b/all/src/test/java/io/opentelemetry/all/NoSharedInternalCodeTest.java
@@ -114,7 +114,7 @@ private static Stream<Arguments> artifactsAndJars() throws IOException {
         .map(
             line -> {
               String[] parts = line.split(":", 2);
-              return Arguments.of(parts[0], parts[1]);
+              return Arguments.argumentSet(parts[0], parts[0], parts[1]);
             });
   }
 }
diff --git a/api/all/src/test/java/io/opentelemetry/api/baggage/propagation/W3CBaggagePropagatorTest.java b/api/all/src/test/java/io/opentelemetry/api/baggage/propagation/W3CBaggagePropagatorTest.java
index 93f4e25f1a6..b7b0b59cc1d 100644
--- a/api/all/src/test/java/io/opentelemetry/api/baggage/propagation/W3CBaggagePropagatorTest.java
+++ b/api/all/src/test/java/io/opentelemetry/api/baggage/propagation/W3CBaggagePropagatorTest.java
@@ -612,12 +612,16 @@ void extract_limit_maxEntries(List<String> headers, Baggage expectedBaggage) {
 
   static Stream<Arguments> extract_limit_maxEntries() {
     return Stream.of(
-        // Exactly at the limit — all 64 entries extracted
-        Arguments.of(ImmutableList.of(baggageHeader(0, 64)), baggageWithEntries(0, 64)),
-        // One over the limit — only the first 64 extracted
-        Arguments.of(ImmutableList.of(baggageHeader(0, 65)), baggageWithEntries(0, 64)),
-        // Split across two headers — only the first 64 total extracted
-        Arguments.of(
+        Arguments.argumentSet(
+            "exactly at limit, all 64 extracted",
+            ImmutableList.of(baggageHeader(0, 64)),
+            baggageWithEntries(0, 64)),
+        Arguments.argumentSet(
+            "one over limit, only first 64 extracted",
+            ImmutableList.of(baggageHeader(0, 65)),
+            baggageWithEntries(0, 64)),
+        Arguments.argumentSet(
+            "split across two headers, first 64 total extracted",
             ImmutableList.of(baggageHeader(0, 32), baggageHeader(32, 33)),
             baggageWithEntries(0, 64)));
   }
diff --git a/api/all/src/test/java/io/opentelemetry/api/common/ValueAsStringTest.java b/api/all/src/test/java/io/opentelemetry/api/common/ValueAsStringTest.java
index a5919d2269c..996333edbd5 100644
--- a/api/all/src/test/java/io/opentelemetry/api/common/ValueAsStringTest.java
+++ b/api/all/src/test/java/io/opentelemetry/api/common/ValueAsStringTest.java
@@ -26,13 +26,13 @@ void valueString(String input, String expectedJson) {
 
   private static Stream<Arguments> stringValueProvider() {
     return Stream.of(
-        Arguments.of("hello", "hello"),
-        Arguments.of("", ""),
-        Arguments.of("line1\nline2\ttab", "line1\nline2\ttab"),
-        Arguments.of("say \"hello\"", "say \"hello\""),
-        Arguments.of("path\\to\\file", "path\\to\\file"),
-        Arguments.of("\u0000\u0001\u001F", "\u0000\u0001\u001F"),
-        Arguments.of("Hello 世界 🌍", "Hello 世界 🌍"));
+        Arguments.argumentSet("hello", "hello", "hello"),
+        Arguments.argumentSet("empty string", "", ""),
+        Arguments.argumentSet("newline and tab", "line1\nline2\ttab", "line1\nline2\ttab"),
+        Arguments.argumentSet("double quotes", "say \"hello\"", "say \"hello\""),
+        Arguments.argumentSet("backslash path", "path\\to\\file", "path\\to\\file"),
+        Arguments.argumentSet("control chars", "\u0000\u0001\u001F", "\u0000\u0001\u001F"),
+        Arguments.argumentSet("unicode", "Hello 世界 🌍", "Hello 世界 🌍"));
   }
 
   @ParameterizedTest
@@ -42,7 +42,9 @@ void valueBoolean(boolean input, String expectedJson) {
   }
 
   private static Stream<Arguments> booleanValueProvider() {
-    return Stream.of(Arguments.of(true, "true"), Arguments.of(false, "false"));
+    return Stream.of(
+        Arguments.argumentSet("true", true, "true"),
+        Arguments.argumentSet("false", false, "false"));
   }
 
   @ParameterizedTest
@@ -53,11 +55,11 @@ void valueLong(long input, String expectedJson) {
 
   private static Stream<Arguments> longValueProvider() {
     return Stream.of(
-        Arguments.of(42L, "42"),
-        Arguments.of(-123L, "-123"),
-        Arguments.of(0L, "0"),
-        Arguments.of(Long.MAX_VALUE, "9223372036854775807"),
-        Arguments.of(Long.MIN_VALUE, "-9223372036854775808"));
+        Arguments.argumentSet("Positive value", 42L, "42"),
+        Arguments.argumentSet("Negative value", -123L, "-123"),
+        Arguments.argumentSet("Zero case", 0L, "0"),
+        Arguments.argumentSet("Maximum possible", Long.MAX_VALUE, "9223372036854775807"),
+        Arguments.argumentSet("Minimum possible", Long.MIN_VALUE, "-9223372036854775808"));
   }
 
   @ParameterizedTest
@@ -68,15 +70,15 @@ void valueDouble(double input, String expectedJson) {
 
   private static Stream<Arguments> doubleValueProvider() {
     return Stream.of(
-        Arguments.of(3.14, "3.14"),
-        Arguments.of(-2.5, "-2.5"),
-        Arguments.of(0.0, "0.0"),
-        Arguments.of(-0.0, "-0.0"),
-        Arguments.of(Double.NaN, "NaN"),
-        Arguments.of(Double.POSITIVE_INFINITY, "Infinity"),
-        Arguments.of(Double.NEGATIVE_INFINITY, "-Infinity"),
-        Arguments.of(1.23e10, "1.23E10"),
-        Arguments.of(1.23e-10, "1.23E-10"));
+        Arguments.argumentSet("Positive value", 3.14, "3.14"),
+        Arguments.argumentSet("Negative value", -2.5, "-2.5"),
+        Arguments.argumentSet("Zero", 0.0, "0.0"),
+        Arguments.argumentSet("Negative zero", -0.0, "-0.0"),
+        Arguments.argumentSet("NaN", Double.NaN, "NaN"),
+        Arguments.argumentSet("Positive infinity", Double.POSITIVE_INFINITY, "Infinity"),
+        Arguments.argumentSet("Negative infinity", Double.NEGATIVE_INFINITY, "-Infinity"),
+        Arguments.argumentSet("Scientific notation positive exponent", 1.23e10, "1.23E10"),
+        Arguments.argumentSet("Scientific notation negative exponent", 1.23e-10, "1.23E-10"));
   }
 
   @ParameterizedTest
@@ -88,8 +90,9 @@ void valueBytes(byte[] input, String expectedJson) {
   private static Stream<Arguments> bytesValueProvider() {
     byte[] regularBytes = new byte[] {0, 1, 2, Byte.MAX_VALUE, Byte.MIN_VALUE};
     return Stream.of(
-        Arguments.of(new byte[] {}, ""),
-        Arguments.of(regularBytes, Base64.getEncoder().encodeToString(regularBytes)));
+        Arguments.argumentSet("empty bytes", new byte[] {}, ""),
+        Arguments.argumentSet(
+            "regular bytes", regularBytes, Base64.getEncoder().encodeToString(regularBytes)));
   }
 
   @Test
@@ -107,11 +110,16 @@ void valueArray(Value<?> input, String expectedJson) {
   @SuppressWarnings("ExplicitArrayForVarargs")
   private static Stream<Arguments> arrayValueProvider() {
     return Stream.of(
-        Arguments.of(Value.of(new Value<?>[] {}), "[]"),
-        Arguments.of(Value.of(Value.of("test")), "[\"test\"]"),
-        Arguments.of(Value.of(Value.of("a"), Value.of("b"), Value.of("c")), "[\"a\",\"b\",\"c\"]"),
-        Arguments.of(Value.of(Value.of(1L), Value.of(2L), Value.of(3L)), "[1,2,3]"),
-        Arguments.of(
+        Arguments.argumentSet("empty array", Value.of(new Value<?>[] {}), "[]"),
+        Arguments.argumentSet("single string", Value.of(Value.of("test")), "[\"test\"]"),
+        Arguments.argumentSet(
+            "string array",
+            Value.of(Value.of("a"), Value.of("b"), Value.of("c")),
+            "[\"a\",\"b\",\"c\"]"),
+        Arguments.argumentSet(
+            "long array", Value.of(Value.of(1L), Value.of(2L), Value.of(3L)), "[1,2,3]"),
+        Arguments.argumentSet(
+            "mixed types",
             Value.of(
                 Value.of("string"),
                 Value.of(42L),
@@ -120,11 +128,13 @@ private static Stream<Arguments> arrayValueProvider() {
                 Value.of(false),
                 Value.empty()),
             "[\"string\",42,3.14,true,false,null]"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "nested array",
             Value.of(
                 Value.of("outer"), Value.of(Value.of("inner1"), Value.of("inner2")), Value.of(42L)),
             "[\"outer\",[\"inner1\",\"inner2\"],42]"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "deeply nested",
             Value.of(Value.of(Value.of(Value.of(Value.of(Value.of("deep"))))), Value.of("shallow")),
             "[[[[[\"deep\"]]]],\"shallow\"]"));
   }
@@ -143,15 +153,18 @@ private static Stream<Arguments> keyValueListValueProvider() {
     map.put("key2", Value.of(42L));
 
     return Stream.of(
-        Arguments.of(Value.of(new KeyValue[] {}), "{}"),
-        Arguments.of(Value.of(KeyValue.of("key", Value.of("value"))), "{\"key\":\"value\"}"),
-        Arguments.of(
+        Arguments.argumentSet("empty kvlist", Value.of(new KeyValue[] {}), "{}"),
+        Arguments.argumentSet(
+            "single kv", Value.of(KeyValue.of("key", Value.of("value"))), "{\"key\":\"value\"}"),
+        Arguments.argumentSet(
+            "kv with mixed types",
             Value.of(
                 KeyValue.of("name", Value.of("Alice")),
                 KeyValue.of("age", Value.of(30L)),
                 KeyValue.of("active", Value.of(true))),
             "{\"name\":\"Alice\",\"age\":30,\"active\":true}"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "nested kvlist",
             Value.of(
                 KeyValue.of("outer", Value.of("value")),
                 KeyValue.of(
@@ -160,12 +173,14 @@ private static Stream<Arguments> keyValueListValueProvider() {
                         KeyValue.of("nested1", Value.of("a")),
                         KeyValue.of("nested2", Value.of("b"))))),
             "{\"outer\":\"value\",\"inner\":{\"nested1\":\"a\",\"nested2\":\"b\"}}"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "kv with array value",
             Value.of(
                 KeyValue.of("name", Value.of("test")),
                 KeyValue.of("items", Value.of(Value.of(1L), Value.of(2L), Value.of(3L)))),
             "{\"name\":\"test\",\"items\":[1,2,3]}"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "all value types",
             Value.of(
                 KeyValue.of("string", Value.of("text")),
                 KeyValue.of("long", Value.of(42L)),
@@ -176,8 +191,9 @@ private static Stream<Arguments> keyValueListValueProvider() {
                 KeyValue.of("array", Value.of(Value.of("a"), Value.of("b")))),
             "{\"string\":\"text\",\"long\":42,\"double\":3.14,\"bool\":true,"
                 + "\"empty\":null,\"bytes\":\"AQI=\",\"array\":[\"a\",\"b\"]}"),
-        Arguments.of(Value.of(map), "{\"key1\":\"value1\",\"key2\":42}"),
-        Arguments.of(
+        Arguments.argumentSet("map value", Value.of(map), "{\"key1\":\"value1\",\"key2\":42}"),
+        Arguments.argumentSet(
+            "keys with special chars",
             Value.of(
                 KeyValue.of("key with spaces", Value.of("value1")),
                 KeyValue.of("key\"with\"quotes", Value.of("value2")),
@@ -229,20 +245,27 @@ void edgeCases(Value<?> input, String expectedJson) {
   @SuppressWarnings("ExplicitArrayForVarargs")
   private static Stream<Arguments> edgeCaseProvider() {
     return Stream.of(
-        Arguments.of(Value.of(KeyValue.of("", Value.of("value"))), "{\"\":\"value\"}"),
-        Arguments.of(Value.of(Value.empty(), Value.empty(), Value.empty()), "[null,null,null]"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "empty key", Value.of(KeyValue.of("", Value.of("value"))), "{\"\":\"value\"}"),
+        Arguments.argumentSet(
+            "null values",
+            Value.of(Value.empty(), Value.empty(), Value.empty()),
+            "[null,null,null]"),
+        Arguments.argumentSet(
+            "array of kvlists",
             Value.of(
                 Value.of(KeyValue.of("id", Value.of(1L)), KeyValue.of("name", Value.of("A"))),
                 Value.of(KeyValue.of("id", Value.of(2L)), KeyValue.of("name", Value.of("B"))),
                 Value.of(KeyValue.of("id", Value.of(3L)), KeyValue.of("name", Value.of("C")))),
             "[{\"id\":1,\"name\":\"A\"},{\"id\":2,\"name\":\"B\"},{\"id\":3,\"name\":\"C\"}]"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "kv with empty array",
             Value.of(
                 KeyValue.of("data", Value.of("test")),
                 KeyValue.of("items", Value.of(new Value<?>[] {}))),
             "{\"data\":\"test\",\"items\":[]}"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "kv with empty kvlist",
             Value.of(
                 KeyValue.of("data", Value.of("test")),
                 KeyValue.of("metadata", Value.of(new KeyValue[] {}))),
diff --git a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/TlsUtilTest.java b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/TlsUtilTest.java
index 0134fd46f2d..1d25cc6cf9d 100644
--- a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/TlsUtilTest.java
+++ b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/TlsUtilTest.java
@@ -106,8 +106,11 @@ void keyManager_CertWithExplanatoryText(SelfSignedCertificate selfSignedCertific
   private static Stream<Arguments> keyManagerArgs() throws CertificateException {
     Instant now = Instant.now();
     return Stream.of(
-        Arguments.of(
-            new SelfSignedCertificate(Date.from(now), Date.from(now), "RSA", 2048),
+        Arguments.argumentSet(
+            "RSA certificate",
+            new SelfSignedCertificate(Date.from(now), Date.from(now), "RSA", 2048)),
+        Arguments.argumentSet(
+            "EC certificate",
             new SelfSignedCertificate(Date.from(now), Date.from(now), "EC", 256)));
   }
 }
diff --git a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/marshal/MarshalerTest.java b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/marshal/MarshalerTest.java
index a89ea217cc1..6ea83a5ce0a 100644
--- a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/marshal/MarshalerTest.java
+++ b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/marshal/MarshalerTest.java
@@ -99,7 +99,8 @@ private static Stream<Arguments> writeToArgs() {
         new ThrowingMarshaler2<>(new IOException("error"));
 
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "repeated message collection",
             asWriter(
                 output ->
                     output.serializeRepeatedMessageWithContext(
@@ -108,7 +109,8 @@ private static Stream<Arguments> writeToArgs() {
                         throwingMarshaler,
                         context,
                         MarshalerContext.key()))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "repeated message map",
             asWriter(
                 output ->
                     output.serializeRepeatedMessageWithContext(
@@ -117,7 +119,8 @@ private static Stream<Arguments> writeToArgs() {
                         throwingMarshaler2,
                         context,
                         MarshalerContext.key()))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "repeated message attributes",
             asWriter(
                 output ->
                     output.serializeRepeatedMessageWithContext(
diff --git a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/AbstractOtlpStdoutExporterTest.java b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/AbstractOtlpStdoutExporterTest.java
index 87b2a14c1aa..dd6d3eb3de2 100644
--- a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/AbstractOtlpStdoutExporterTest.java
+++ b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/AbstractOtlpStdoutExporterTest.java
@@ -133,30 +133,6 @@ enum OutputType {
     FILE_AND_BUFFERED_WRITER
   }
 
-  public static class TestCase {
-    private final MemoryMode memoryMode;
-    private final boolean wrapperJsonObject;
-    private final OutputType outputType;
-
-    public TestCase(OutputType outputType, MemoryMode memoryMode, boolean wrapperJsonObject) {
-      this.outputType = outputType;
-      this.memoryMode = memoryMode;
-      this.wrapperJsonObject = wrapperJsonObject;
-    }
-
-    public OutputType getOutputType() {
-      return outputType;
-    }
-
-    public boolean isWrapperJsonObject() {
-      return wrapperJsonObject;
-    }
-
-    public MemoryMode getMemoryMode() {
-      return memoryMode;
-    }
-  }
-
   static Stream<Arguments> exportTestCases() {
     return ImmutableList.of(
         testCase(OutputType.SYSTEM_OUT, MemoryMode.IMMUTABLE_DATA, /* wrapperJsonObject= */ true),
@@ -192,23 +168,24 @@ static Stream<Arguments> exportTestCases() {
 
   private static Arguments testCase(
       OutputType type, MemoryMode memoryMode, boolean wrapperJsonObject) {
-    return Arguments.of(
+    String name =
         "output="
             + type
             + ", wrapperJsonObject="
             + wrapperJsonObject
             + ", memoryMode="
-            + memoryMode,
-        new TestCase(type, memoryMode, wrapperJsonObject));
+            + memoryMode;
+    return Arguments.argumentSet(name, type, memoryMode, wrapperJsonObject);
   }
 
   @SuppressWarnings("SystemOut")
-  @ParameterizedTest(name = "{0}")
+  @ParameterizedTest
   @MethodSource("exportTestCases")
-  void exportWithProgrammaticConfig(String name, TestCase testCase) throws Exception {
+  void exportWithProgrammaticConfig(
+      OutputType outputType, MemoryMode memoryMode, boolean wrapperJsonObject) throws Exception {
     OutputStream outputStream;
     Path file = null;
-    switch (testCase.getOutputType()) {
+    switch (outputType) {
       case LOGGER:
         outputStream = null;
         break;
@@ -224,14 +201,12 @@ void exportWithProgrammaticConfig(String name, TestCase testCase) throws Excepti
         outputStream = new BufferedOutputStream(Files.newOutputStream(file));
         break;
       default:
-        throw new IllegalStateException("Unexpected value: " + testCase.getOutputType());
+        throw new IllegalStateException("Unexpected value: " + outputType);
     }
 
-    Supplier<T> exporter =
-        () ->
-            createExporter(outputStream, testCase.getMemoryMode(), testCase.isWrapperJsonObject());
+    Supplier<T> exporter = () -> createExporter(outputStream, memoryMode, wrapperJsonObject);
 
-    if (testCase.getMemoryMode() == MemoryMode.REUSABLE_DATA && !testCase.isWrapperJsonObject()) {
+    if (memoryMode == MemoryMode.REUSABLE_DATA && !wrapperJsonObject) {
       assertThatExceptionOfType(IllegalArgumentException.class)
           .isThrownBy(exporter::get)
           .withMessage("Reusable data mode is not supported without wrapperJsonObject");
@@ -241,10 +216,10 @@ void exportWithProgrammaticConfig(String name, TestCase testCase) throws Excepti
     testDataExporter.export(exporter.get());
 
     String output = output(outputStream, file);
-    String expectedJson = testDataExporter.getExpectedJson(testCase.isWrapperJsonObject());
+    String expectedJson = testDataExporter.getExpectedJson(wrapperJsonObject);
     JSONAssert.assertEquals("Got \n" + output, expectedJson, output, false);
 
-    if (testCase.isWrapperJsonObject()) {
+    if (wrapperJsonObject) {
       assertThat(output).doesNotContain("\n");
     }
 
diff --git a/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtilTest.java b/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtilTest.java
index 420c2f57e1e..35e4a1647f6 100644
--- a/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtilTest.java
+++ b/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtilTest.java
@@ -156,17 +156,22 @@ void configureOtlpExporterBuilder_MisalignedOtlpPort(
 
   private static Stream<Arguments> misalignedOtlpPortArgs() {
     return Stream.of(
-        Arguments.of("http/protobuf", "http://localhost:4318/path", null),
-        Arguments.of("http/protobuf", "http://localhost:8080/path", null),
-        Arguments.of("http/protobuf", "http://localhost/path", null),
-        Arguments.of(
+        Arguments.argumentSet(
+            "http/protobuf port 4318 no warn", "http/protobuf", "http://localhost:4318/path", null),
+        Arguments.argumentSet(
+            "http/protobuf port 8080 no warn", "http/protobuf", "http://localhost:8080/path", null),
+        Arguments.argumentSet(
+            "http/protobuf no port no warn", "http/protobuf", "http://localhost/path", null),
+        Arguments.argumentSet(
+            "http/protobuf port 4317 warn",
             "http/protobuf",
             "http://localhost:4317/path",
             "OTLP exporter endpoint port is likely incorrect for protocol version \"http/protobuf\". The endpoint http://localhost:4317/path has port 4317. Typically, the \"http/protobuf\" version of OTLP uses port 4318."),
-        Arguments.of("grpc", "http://localhost:4317/", null),
-        Arguments.of("grpc", "http://localhost:8080/", null),
-        Arguments.of("grpc", "http://localhost/", null),
-        Arguments.of(
+        Arguments.argumentSet("grpc port 4317 no warn", "grpc", "http://localhost:4317/", null),
+        Arguments.argumentSet("grpc port 8080 no warn", "grpc", "http://localhost:8080/", null),
+        Arguments.argumentSet("grpc no port no warn", "grpc", "http://localhost/", null),
+        Arguments.argumentSet(
+            "grpc port 4318 warn",
             "grpc",
             "http://localhost:4318/",
             "OTLP exporter endpoint port is likely incorrect for protocol version \"grpc\". The endpoint http://localhost:4318/ has port 4318. Typically, the \"grpc\" version of OTLP uses port 4317."));
diff --git a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/Otel2PrometheusConverterTest.java b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/Otel2PrometheusConverterTest.java
index b48ab67faca..210b3f54eed 100644
--- a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/Otel2PrometheusConverterTest.java
+++ b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/Otel2PrometheusConverterTest.java
@@ -61,7 +61,6 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import javax.annotation.Nullable;
-import org.junit.jupiter.api.Named;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
@@ -106,93 +105,100 @@ void metricMetadata(
 
   private static Stream<Arguments> metricMetadataArgs() {
     return Stream.of(
-        // the unity unit "1" is unitless - no suffix added
-        Arguments.of(
+        Arguments.argumentSet(
+            "gauge unitless 1",
             createSampleMetricData("sample", "1", MetricDataType.LONG_GAUGE),
             "sample gauge",
             "sample description",
             "sample"),
-        // unit is appended to metric name
-        Arguments.of(
+        Arguments.argumentSet(
+            "gauge with unit",
             createSampleMetricData("sample", "unit", MetricDataType.LONG_GAUGE),
             "sample_unit gauge",
             "sample_unit description",
             "sample_unit"),
-        // units in curly braces are dropped, "1" is unitless
-        Arguments.of(
+        Arguments.argumentSet(
+            "gauge curly braces dropped",
             createSampleMetricData("sample", "1{dropped}", MetricDataType.LONG_GAUGE),
             "sample gauge",
             "sample description",
             "sample"),
-        // monotonic sums always include _total suffix
-        Arguments.of(
+        Arguments.argumentSet(
+            "sum with unit total suffix",
             createSampleMetricData("sample", "unit", MetricDataType.LONG_SUM),
             "sample_unit_total counter",
             "sample_unit_total description",
             "sample_unit_total"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "sum unitless 1 total suffix",
             createSampleMetricData("sample", "1", MetricDataType.LONG_SUM),
             "sample_total counter",
             "sample_total description",
             "sample_total"),
-        // units expressed as numbers other than 1 are retained
-        Arguments.of(
+        Arguments.argumentSet(
+            "sum numeric unit 2",
             createSampleMetricData("sample", "2", MetricDataType.LONG_SUM),
             "sample_2_total counter",
             "sample_2_total description",
             "sample_2_total"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "summary numeric unit 2",
             createSampleMetricData("metric_name", "2", MetricDataType.SUMMARY),
             "metric_name_2 summary",
             "metric_name_2 description",
             "metric_name_2_count"),
         // unsupported characters are translated to "_", repeated "_" are dropped
-        Arguments.of(
+        Arguments.argumentSet(
+            "summary special chars translated",
             createSampleMetricData("s%%ple", "%/min", MetricDataType.SUMMARY),
             "s_ple_percent_per_minute summary",
             "s_ple_percent_per_minute description",
             "s_ple_percent_per_minute_count"),
-        // metric unit is not appended if the name already contains the unit
-        Arguments.of(
+        Arguments.argumentSet(
+            "sum name contains unit",
             createSampleMetricData("metric_name_total", "total", MetricDataType.LONG_SUM),
             "metric_name_total counter",
             "metric_name_total description",
             "metric_name_total"),
         // total suffix is stripped because total is a reserved suffixed for monotonic sums
-        Arguments.of(
+        Arguments.argumentSet(
+            "summary total suffix stripped",
             createSampleMetricData("metric_name_total", "total", MetricDataType.SUMMARY),
             "metric_name summary",
             "metric_name description",
             "metric_name_count"),
-        // if metric name ends with unit the unit is omitted
-        Arguments.of(
+        Arguments.argumentSet(
+            "gauge name ends with ratio unit omitted",
             createSampleMetricData("metric_name_ratio", "1", MetricDataType.LONG_GAUGE),
             "metric_name_ratio gauge",
             "metric_name_ratio description",
             "metric_name_ratio"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "summary name ends with ratio unit omitted",
             createSampleMetricData("metric_name_ratio", "1", MetricDataType.SUMMARY),
             "metric_name_ratio summary",
             "metric_name_ratio description",
             "metric_name_ratio_count"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "gauge name ends with hertz unit omitted",
             createSampleMetricData("metric_hertz", "hertz", MetricDataType.LONG_GAUGE),
             "metric_hertz gauge",
             "metric_hertz description",
             "metric_hertz"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "sum name ends with hertz unit omitted",
             createSampleMetricData("metric_hertz", "hertz", MetricDataType.LONG_SUM),
             "metric_hertz_total counter",
             "metric_hertz_total description",
             "metric_hertz_total"),
-        // if metric name ends with unit the unit is omitted - order matters
-        Arguments.of(
+        Arguments.argumentSet(
+            "sum name total hertz order matters",
             createSampleMetricData("metric_total_hertz", "hertz_total", MetricDataType.LONG_SUM),
             "metric_total_hertz_total counter",
             "metric_total_hertz_total description",
             "metric_total_hertz_total"),
-        // metric name cannot start with a number
-        Arguments.of(
+        Arguments.argumentSet(
+            "summary name starts with number",
             createSampleMetricData("2_metric_name", "By", MetricDataType.SUMMARY),
             "_metric_name_bytes summary",
             "_metric_name_bytes description",
@@ -238,7 +244,8 @@ private static Stream<Arguments> resourceAttributesAdditionArgs() {
     for (MetricDataType metricDataType : MetricDataType.values()) {
       // Check that resource attributes are added as labels, according to allowed pattern
       arguments.add(
-          Arguments.of(
+          Arguments.argumentSet(
+              "resource attribute added " + metricDataType,
               createSampleMetricData(
                   "my.metric",
                   "units",
@@ -260,7 +267,8 @@ private static Stream<Arguments> resourceAttributesAdditionArgs() {
 
     // Resource attributes which also exists in the metric labels are not added twice
     arguments.add(
-        Arguments.of(
+        Arguments.argumentSet(
+            "resource attribute not duplicated",
             createSampleMetricData(
                 "my.metric",
                 "units",
@@ -278,7 +286,8 @@ private static Stream<Arguments> resourceAttributesAdditionArgs() {
 
     // Empty attributes
     arguments.add(
-        Arguments.of(
+        Arguments.argumentSet(
+            "empty metric attributes",
             createSampleMetricData(
                 "my.metric",
                 "units",
@@ -341,31 +350,41 @@ void labelValueSerialization(Attributes attributes, String expectedValue) {
 
   private static Stream<Arguments> labelValueSerializationArgs() {
     return Stream.of(
-        Arguments.of(Attributes.of(stringKey("key"), "stringValue"), "stringValue"),
-        Arguments.of(Attributes.of(booleanKey("key"), true), "true"),
-        Arguments.of(Attributes.of(longKey("key"), Long.MAX_VALUE), "9223372036854775807"),
-        Arguments.of(Attributes.of(doubleKey("key"), 0.12345), "0.12345"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "string value", Attributes.of(stringKey("key"), "stringValue"), "stringValue"),
+        Arguments.argumentSet("boolean value", Attributes.of(booleanKey("key"), true), "true"),
+        Arguments.argumentSet(
+            "long value", Attributes.of(longKey("key"), Long.MAX_VALUE), "9223372036854775807"),
+        Arguments.argumentSet("double value", Attributes.of(doubleKey("key"), 0.12345), "0.12345"),
+        Arguments.argumentSet(
+            "string array value",
             Attributes.of(
                 stringArrayKey("key"),
                 Arrays.asList("stringValue1", "\"+\\\\\\+\b+\f+\n+\r+\t+" + (char) 0)),
             "[\"stringValue1\",\"\\\"+\\\\\\\\\\\\+\\b+\\f+\\n+\\r+\\t+\\u0000\"]"),
-        Arguments.of(
-            Attributes.of(booleanArrayKey("key"), Arrays.asList(true, false)), "[true,false]"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "boolean array value",
+            Attributes.of(booleanArrayKey("key"), Arrays.asList(true, false)),
+            "[true,false]"),
+        Arguments.argumentSet(
+            "long array value",
             Attributes.of(longArrayKey("key"), Arrays.asList(Long.MIN_VALUE, Long.MAX_VALUE)),
             "[-9223372036854775808,9223372036854775807]"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "double array value",
             Attributes.of(doubleArrayKey("key"), Arrays.asList(Double.MIN_VALUE, Double.MAX_VALUE)),
             "[4.9E-324,1.7976931348623157E308]"),
-        Arguments.of(Attributes.of(valueKey("key"), Value.of(new byte[] {1, 2, 3})), "AQID"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "bytes value", Attributes.of(valueKey("key"), Value.of(new byte[] {1, 2, 3})), "AQID"),
+        Arguments.argumentSet(
+            "nested key-value value",
             Attributes.of(valueKey("key"), Value.of(KeyValue.of("nested", Value.of("value")))),
             "{\"nested\":\"value\"}"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "list value",
             Attributes.of(valueKey("key"), Value.of(Value.of("string"), Value.of(123L))),
             "[\"string\",123]"),
-        Arguments.of(Attributes.of(valueKey("key"), Value.empty()), ""));
+        Arguments.argumentSet("empty value", Attributes.of(valueKey("key"), Value.empty()), ""));
   }
 
   static MetricData createSampleMetricData(
@@ -614,23 +633,27 @@ private static Stream<Arguments> exemplarLabelLimitArgs() {
     String longValue150 = new String(chars);
 
     return Stream.of(
-        Arguments.of(
-            Named.of("withSpanContext_withinLimit", validSpanContext),
+        Arguments.argumentSet(
+            "withSpanContext withinLimit",
+            validSpanContext,
             Attributes.of(stringKey("short_attr"), "val"),
             new String[] {"trace_id", "span_id", "short_attr"},
             new String[] {}),
-        Arguments.of(
-            Named.of("withSpanContext_exceedingLimit", validSpanContext),
+        Arguments.argumentSet(
+            "withSpanContext exceedingLimit",
+            validSpanContext,
             Attributes.of(stringKey("long_attr"), longValue100),
             new String[] {"trace_id", "span_id"},
             new String[] {"long_attr"}),
-        Arguments.of(
-            Named.of("withoutSpanContext_exceedingLimit", SpanContext.getInvalid()),
+        Arguments.argumentSet(
+            "withoutSpanContext exceedingLimit",
+            SpanContext.getInvalid(),
             Attributes.of(stringKey("long_attr"), longValue150),
             new String[] {},
             new String[] {"long_attr"}),
-        Arguments.of(
-            Named.of("withoutSpanContext_withinLimit", SpanContext.getInvalid()),
+        Arguments.argumentSet(
+            "withoutSpanContext withinLimit",
+            SpanContext.getInvalid(),
             Attributes.of(stringKey("short_attr"), "val"),
             new String[] {"short_attr"},
             new String[] {}));
diff --git a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/PrometheusUnitsHelperTest.java b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/PrometheusUnitsHelperTest.java
index f9454ce837c..e6ffa0fb760 100644
--- a/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/PrometheusUnitsHelperTest.java
+++ b/exporters/prometheus/src/test/java/io/opentelemetry/exporter/prometheus/PrometheusUnitsHelperTest.java
@@ -29,75 +29,40 @@ public void testPrometheusUnitEquivalency(String otlpUnit, String expectedPromet
 
   private static Stream<Arguments> providePrometheusOTelUnitEquivalentPairs() {
     return Stream.of(
-        // Simple expansion - storage Bytes
-        Arguments.of("By", "bytes"),
-        // Simple expansion - storage KBy
-        Arguments.of("KBy", "kilobytes"),
-        // Simple expansion - storage MBy
-        Arguments.of("MBy", "megabytes"),
-        // Simple expansion - storage GBy
-        Arguments.of("GBy", "gigabytes"),
-        // Simple expansion - storage TBy
-        Arguments.of("TBy", "terabytes"),
-        // Simple expansion - storage KiBy
-        Arguments.of("KiBy", "kibibytes"),
-        // Simple expansion - storage MiBy
-        Arguments.of("MiBy", "mebibytes"),
-        // Simple expansion - storage GiBy
-        Arguments.of("GiBy", "gibibytes"),
-        // Simple expansion - storage TiBy
-        Arguments.of("TiBy", "tibibytes"),
-        // Simple expansion - Time unit d
-        Arguments.of("d", "days"),
-        // Simple expansion - Time unit h
-        Arguments.of("h", "hours"),
-        // Simple expansion - Time unit s
-        Arguments.of("s", "seconds"),
-        // Simple expansion - Time unit ms
-        Arguments.of("ms", "milliseconds"),
-        // Simple expansion - Time unit us
-        Arguments.of("us", "microseconds"),
-        // Simple expansion - Time unit ns
-        Arguments.of("ns", "nanoseconds"),
-        // Simple expansion - Time unit min
-        Arguments.of("min", "minutes"),
-        // Simple expansion - special symbol - %
-        Arguments.of("%", "percent"),
-        // Simple expansion - frequency
-        Arguments.of("Hz", "hertz"),
-        // Simple expansion - temperature
-        Arguments.of("Cel", "celsius"),
-        // Unit not found - Case sensitive
-        Arguments.of("S", "S"),
-        // Special case - 1 is unitless
-        Arguments.of("1", null),
-        // Special Case - Drop metric units in {}
-        Arguments.of("{packets}", null),
-        // Special Case - Dropped metric units only in {}
-        Arguments.of("{packets}V", "volts"),
-        // Special Case - Dropped metric units with 'per' unit handling applicable
-        Arguments.of("{scanned}/{returned}", null),
-        // Special Case - Dropped metric units with 'per' unit handling applicable
-        Arguments.of("{objects}/s", "per_second"),
-        // Units expressing rate - 'per' units, both units expanded
-        Arguments.of("m/s", "meters_per_second"),
-        // Units expressing rate - per minute
-        Arguments.of("m/min", "meters_per_minute"),
-        // Units expressing rate - per day
-        Arguments.of("A/d", "amperes_per_day"),
-        // Units expressing rate - per week
-        Arguments.of("W/wk", "watts_per_week"),
-        // Units expressing rate - per month
-        Arguments.of("J/mo", "joules_per_month"),
-        // Units expressing rate - per year
-        Arguments.of("TBy/a", "terabytes_per_year"),
-        // Units expressing rate - 'per' units, both units unknown
-        Arguments.of("v/v", "v_per_v"),
-        // Units expressing rate - 'per' units, first unit unknown
-        Arguments.of("km/h", "km_per_hour"),
-        // Units expressing rate - 'per' units, 'per' unit unknown
-        Arguments.of("g/x", "grams_per_x"),
-        // Misc - unit containing known abbreviations improperly formatted
-        Arguments.of("watts_W", "watts_W"));
+        Arguments.argumentSet("bytes", "By", "bytes"),
+        Arguments.argumentSet("kilobytes", "KBy", "kilobytes"),
+        Arguments.argumentSet("megabytes", "MBy", "megabytes"),
+        Arguments.argumentSet("gigabytes", "GBy", "gigabytes"),
+        Arguments.argumentSet("terabytes", "TBy", "terabytes"),
+        Arguments.argumentSet("kibibytes", "KiBy", "kibibytes"),
+        Arguments.argumentSet("mebibytes", "MiBy", "mebibytes"),
+        Arguments.argumentSet("gibibytes", "GiBy", "gibibytes"),
+        Arguments.argumentSet("tibibytes", "TiBy", "tibibytes"),
+        Arguments.argumentSet("days", "d", "days"),
+        Arguments.argumentSet("hours", "h", "hours"),
+        Arguments.argumentSet("seconds", "s", "seconds"),
+        Arguments.argumentSet("milliseconds", "ms", "milliseconds"),
+        Arguments.argumentSet("microseconds", "us", "microseconds"),
+        Arguments.argumentSet("nanoseconds", "ns", "nanoseconds"),
+        Arguments.argumentSet("minutes", "min", "minutes"),
+        Arguments.argumentSet("percent", "%", "percent"),
+        Arguments.argumentSet("hertz", "Hz", "hertz"),
+        Arguments.argumentSet("celsius", "Cel", "celsius"),
+        Arguments.argumentSet("unknown unit S (case sensitive)", "S", "S"),
+        Arguments.argumentSet("unitless 1", "1", null),
+        Arguments.argumentSet("curly braces dropped", "{packets}", null),
+        Arguments.argumentSet("curly braces with suffix", "{packets}V", "volts"),
+        Arguments.argumentSet("both units in curly braces", "{scanned}/{returned}", null),
+        Arguments.argumentSet("curly braces per second", "{objects}/s", "per_second"),
+        Arguments.argumentSet("meters per second", "m/s", "meters_per_second"),
+        Arguments.argumentSet("meters per minute", "m/min", "meters_per_minute"),
+        Arguments.argumentSet("amperes per day", "A/d", "amperes_per_day"),
+        Arguments.argumentSet("watts per week", "W/wk", "watts_per_week"),
+        Arguments.argumentSet("joules per month", "J/mo", "joules_per_month"),
+        Arguments.argumentSet("terabytes per year", "TBy/a", "terabytes_per_year"),
+        Arguments.argumentSet("unknown per unknown", "v/v", "v_per_v"),
+        Arguments.argumentSet("km per hour (first unit unknown)", "km/h", "km_per_hour"),
+        Arguments.argumentSet("grams per unknown", "g/x", "grams_per_x"),
+        Arguments.argumentSet("improperly formatted", "watts_W", "watts_W"));
   }
 }
diff --git a/exporters/sender/okhttp/src/test/java/io/opentelemetry/exporter/sender/okhttp/internal/RetryInterceptorTest.java b/exporters/sender/okhttp/src/test/java/io/opentelemetry/exporter/sender/okhttp/internal/RetryInterceptorTest.java
index e80c2e65c6d..eeff92abf3d 100644
--- a/exporters/sender/okhttp/src/test/java/io/opentelemetry/exporter/sender/okhttp/internal/RetryInterceptorTest.java
+++ b/exporters/sender/okhttp/src/test/java/io/opentelemetry/exporter/sender/okhttp/internal/RetryInterceptorTest.java
@@ -254,24 +254,36 @@ void isRetryableException(IOException exception, boolean expectedRetryResult) {
 
   private static Stream<Arguments> isRetryableExceptionArgs() {
     return Stream.of(
-        // Should retry on SocketTimeoutExceptions
-        Arguments.of(new SocketTimeoutException("Connect timed out"), true),
-        Arguments.of(new SocketTimeoutException("connect timed out"), true),
-        Arguments.of(new SocketTimeoutException("timeout"), true),
-        Arguments.of(new SocketTimeoutException("Read timed out"), true),
-        Arguments.of(new SocketTimeoutException(), true),
-        // Should retry on UnknownHostExceptions
-        Arguments.of(new UnknownHostException("host"), true),
-        // Should retry on SocketException
-        Arguments.of(new SocketException("closed"), true),
-        // Should retry on ConnectException
-        Arguments.of(
-            new ConnectException("Failed to connect to localhost/[0:0:0:0:0:0:0:1]:62611"), true),
-        // Shouldn't retry other IOException
-        Arguments.of(new IOException("error"), false),
+        Arguments.argumentSet(
+            "SocketTimeoutException Connect timed out",
+            new SocketTimeoutException("Connect timed out"),
+            true),
+        Arguments.argumentSet(
+            "SocketTimeoutException connect timed out",
+            new SocketTimeoutException("connect timed out"),
+            true),
+        Arguments.argumentSet(
+            "SocketTimeoutException timeout", new SocketTimeoutException("timeout"), true),
+        Arguments.argumentSet(
+            "SocketTimeoutException Read timed out",
+            new SocketTimeoutException("Read timed out"),
+            true),
+        Arguments.argumentSet(
+            "SocketTimeoutException no message", new SocketTimeoutException(), true),
+        Arguments.argumentSet("UnknownHostException", new UnknownHostException("host"), true),
+        Arguments.argumentSet("SocketException closed", new SocketException("closed"), true),
+        Arguments.argumentSet(
+            "ConnectException localhost",
+            new ConnectException("Failed to connect to localhost/[0:0:0:0:0:0:0:1]:62611"),
+            true),
+        Arguments.argumentSet("IOException not retryable", new IOException("error"), false),
         // Testing configured predicate
-        Arguments.of(new HttpRetryException("error", 400), false),
-        Arguments.of(new HttpRetryException("timeout retry", 400), true));
+        Arguments.argumentSet(
+            "HttpRetryException not retryable", new HttpRetryException("error", 400), false),
+        Arguments.argumentSet(
+            "HttpRetryException timeout retry",
+            new HttpRetryException("timeout retry", 400),
+            true));
   }
 
   @Test
diff --git a/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/JaegerPropagatorTest.java b/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/JaegerPropagatorTest.java
index b0b79195e70..20bb2b7f13d 100644
--- a/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/JaegerPropagatorTest.java
+++ b/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/JaegerPropagatorTest.java
@@ -512,12 +512,11 @@ static Stream<Arguments> extract_baggageLimit() {
     Map<String, String> bigValueCarrier = new LinkedHashMap<>();
     bigValueCarrier.put(BAGGAGE_PREFIX + "k", fillChars('v', 8192));
     return Stream.of(
-        // 65 uberctx- prefix keys — only first 64 extracted
-        Arguments.of(prefixCarrier, baggageWithEntries(0, 64)),
-        // 65 entries in jaeger-baggage header — only first 64 extracted
-        Arguments.of(headerCarrier, baggageWithEntries(0, 64)),
-        // single entry whose value exceeds the byte limit — not extracted
-        Arguments.of(bigValueCarrier, Baggage.empty()));
+        Arguments.argumentSet(
+            "65 prefix keys truncated to 64", prefixCarrier, baggageWithEntries(0, 64)),
+        Arguments.argumentSet(
+            "65 header entries truncated to 64", headerCarrier, baggageWithEntries(0, 64)),
+        Arguments.argumentSet("large value exceeds byte limit", bigValueCarrier, Baggage.empty()));
   }
 
   /**
diff --git a/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/OtTracePropagatorTest.java b/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/OtTracePropagatorTest.java
index 3e3b211a502..c2b7f67200e 100644
--- a/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/OtTracePropagatorTest.java
+++ b/extensions/trace-propagators/src/test/java/io/opentelemetry/extension/trace/propagation/OtTracePropagatorTest.java
@@ -463,10 +463,9 @@ static Stream<Arguments> extract_baggageLimit() {
     Map<String, String> bigValueCarrier = carrierWithSpanContext();
     bigValueCarrier.put(OtTracePropagator.PREFIX_BAGGAGE_HEADER + "k", fillChars('v', 8192));
     return Stream.of(
-        // 65 ot-baggage- keys — only first 64 extracted
-        Arguments.of(manyEntriesCarrier, baggageWithEntries(0, 64)),
-        // single entry whose value exceeds the byte limit — not extracted
-        Arguments.of(bigValueCarrier, Baggage.empty()));
+        Arguments.argumentSet(
+            "65 baggage keys truncated to 64", manyEntriesCarrier, baggageWithEntries(0, 64)),
+        Arguments.argumentSet("large value exceeds byte limit", bigValueCarrier, Baggage.empty()));
   }
 
   /**
diff --git a/integration-tests/src/test/java/io/opentelemetry/B3PropagationIntegrationTest.java b/integration-tests/src/test/java/io/opentelemetry/B3PropagationIntegrationTest.java
index 967b39760e4..5b05b68d5cd 100644
--- a/integration-tests/src/test/java/io/opentelemetry/B3PropagationIntegrationTest.java
+++ b/integration-tests/src/test/java/io/opentelemetry/B3PropagationIntegrationTest.java
@@ -240,7 +240,8 @@ public static class WebClientArgumentSupplier implements ArgumentsProvider {
     public Stream<? extends Arguments> provideArguments(
         ParameterDeclarations parameters, ExtensionContext context) {
       return Stream.of(
-          Arguments.of("b3multi", b3MultiClient), Arguments.of("b3single", b3SingleClient));
+          Arguments.argumentSet("b3multi", "b3multi", b3MultiClient),
+          Arguments.argumentSet("b3single", "b3single", b3SingleClient));
     }
   }
 }
diff --git a/opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/DelegatingSpanTest.java b/opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/DelegatingSpanTest.java
index 55bb1a58d82..da361e0f3c2 100644
--- a/opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/DelegatingSpanTest.java
+++ b/opencensus-shim/src/test/java/io/opentelemetry/opencensusshim/DelegatingSpanTest.java
@@ -87,46 +87,110 @@ static List<Method> allInterfaceMethods(Class<?> clazz) {
 
   static Stream<Arguments> delegateMethodsProvider() {
     return Stream.of(
-        Arguments.of("end", new Class<?>[] {}, times(1)),
-        Arguments.of("end", new Class<?>[] {long.class, TimeUnit.class}, times(1)),
-        Arguments.of("end", new Class<?>[] {Instant.class}, times(1)),
-        Arguments.of("setAttribute", new Class<?>[] {String.class, String.class}, times(1)),
-        Arguments.of("setAttribute", new Class<?>[] {AttributeKey.class, int.class}, times(1)),
-        Arguments.of("setAttribute", new Class<?>[] {AttributeKey.class, Object.class}, times(1)),
-        Arguments.of("setAttribute", new Class<?>[] {String.class, long.class}, times(1)),
-        Arguments.of("setAttribute", new Class<?>[] {String.class, double.class}, times(1)),
-        Arguments.of("setAttribute", new Class<?>[] {String.class, boolean.class}, times(1)),
-        Arguments.of("setAttribute", new Class<?>[] {String.class, Value.class}, times(1)),
-        Arguments.of(
-            "recordException", new Class<?>[] {Throwable.class, Attributes.class}, times(1)),
-        Arguments.of("recordException", new Class<?>[] {Throwable.class}, times(1)),
-        Arguments.of("setAllAttributes", new Class<?>[] {Attributes.class}, times(1)),
-        Arguments.of("updateName", new Class<?>[] {String.class}, times(1)),
-        Arguments.of("storeInContext", new Class<?>[] {Context.class}, times(1)),
-        Arguments.of("addEvent", new Class<?>[] {String.class, Instant.class}, times(1)),
-        Arguments.of(
-            "addEvent", new Class<?>[] {String.class, long.class, TimeUnit.class}, times(1)),
-        Arguments.of(
-            "addEvent", new Class<?>[] {String.class, Attributes.class, Instant.class}, times(1)),
-        Arguments.of("addEvent", new Class<?>[] {String.class}, times(1)),
-        Arguments.of(
+        Arguments.argumentSet("end no-args", "end", new Class<?>[] {}, times(1)),
+        Arguments.argumentSet(
+            "end long TimeUnit", "end", new Class<?>[] {long.class, TimeUnit.class}, times(1)),
+        Arguments.argumentSet("end Instant", "end", new Class<?>[] {Instant.class}, times(1)),
+        Arguments.argumentSet(
+            "setAttribute String String",
+            "setAttribute",
+            new Class<?>[] {String.class, String.class},
+            times(1)),
+        Arguments.argumentSet(
+            "setAttribute AttributeKey int",
+            "setAttribute",
+            new Class<?>[] {AttributeKey.class, int.class},
+            times(1)),
+        Arguments.argumentSet(
+            "setAttribute AttributeKey Object",
+            "setAttribute",
+            new Class<?>[] {AttributeKey.class, Object.class},
+            times(1)),
+        Arguments.argumentSet(
+            "setAttribute String long",
+            "setAttribute",
+            new Class<?>[] {String.class, long.class},
+            times(1)),
+        Arguments.argumentSet(
+            "setAttribute String double",
+            "setAttribute",
+            new Class<?>[] {String.class, double.class},
+            times(1)),
+        Arguments.argumentSet(
+            "setAttribute String boolean",
+            "setAttribute",
+            new Class<?>[] {String.class, boolean.class},
+            times(1)),
+        Arguments.argumentSet(
+            "setAttribute String Value",
+            "setAttribute",
+            new Class<?>[] {String.class, Value.class},
+            times(1)),
+        Arguments.argumentSet(
+            "recordException with Attributes",
+            "recordException",
+            new Class<?>[] {Throwable.class, Attributes.class},
+            times(1)),
+        Arguments.argumentSet(
+            "recordException no Attributes",
+            "recordException",
+            new Class<?>[] {Throwable.class},
+            times(1)),
+        Arguments.argumentSet(
+            "setAllAttributes", "setAllAttributes", new Class<?>[] {Attributes.class}, times(1)),
+        Arguments.argumentSet("updateName", "updateName", new Class<?>[] {String.class}, times(1)),
+        Arguments.argumentSet(
+            "storeInContext", "storeInContext", new Class<?>[] {Context.class}, times(1)),
+        Arguments.argumentSet(
+            "addEvent String Instant",
+            "addEvent",
+            new Class<?>[] {String.class, Instant.class},
+            times(1)),
+        Arguments.argumentSet(
+            "addEvent String long TimeUnit",
+            "addEvent",
+            new Class<?>[] {String.class, long.class, TimeUnit.class},
+            times(1)),
+        Arguments.argumentSet(
+            "addEvent String Attributes Instant",
+            "addEvent",
+            new Class<?>[] {String.class, Attributes.class, Instant.class},
+            times(1)),
+        Arguments.argumentSet(
+            "addEvent String", "addEvent", new Class<?>[] {String.class}, times(1)),
+        Arguments.argumentSet(
+            "addEvent String Attributes long TimeUnit",
             "addEvent",
             new Class<?>[] {String.class, Attributes.class, long.class, TimeUnit.class},
             times(1)),
-        Arguments.of("addEvent", new Class<?>[] {String.class, Attributes.class}, times(1)),
-        Arguments.of("setStatus", new Class<?>[] {StatusCode.class, String.class}, times(1)),
-        Arguments.of("setStatus", new Class<?>[] {StatusCode.class}, times(1)),
+        Arguments.argumentSet(
+            "addEvent String Attributes",
+            "addEvent",
+            new Class<?>[] {String.class, Attributes.class},
+            times(1)),
+        Arguments.argumentSet(
+            "setStatus StatusCode String",
+            "setStatus",
+            new Class<?>[] {StatusCode.class, String.class},
+            times(1)),
+        Arguments.argumentSet(
+            "setStatus StatusCode", "setStatus", new Class<?>[] {StatusCode.class}, times(1)),
         //
         // special cases
         //
         // called never -- it's shared between OC and Otel Span types and is always true, so returns
         // `true`
-        Arguments.of("isRecording", new Class<?>[] {}, times(0)),
+        Arguments.argumentSet("isRecording", "isRecording", new Class<?>[] {}, times(0)),
         // called twice: once in constructor, then once during delegation
-        Arguments.of("getSpanContext", new Class<?>[] {}, times(2)),
+        Arguments.argumentSet("getSpanContext", "getSpanContext", new Class<?>[] {}, times(2)),
         // addLink is never called
-        Arguments.of("addLink", new Class<?>[] {SpanContext.class}, times(0)),
-        Arguments.of("addLink", new Class<?>[] {SpanContext.class, Attributes.class}, times(0)));
+        Arguments.argumentSet(
+            "addLink SpanContext", "addLink", new Class<?>[] {SpanContext.class}, times(0)),
+        Arguments.argumentSet(
+            "addLink SpanContext Attributes",
+            "addLink",
+            new Class<?>[] {SpanContext.class, Attributes.class},
+            times(0)));
   }
 
   // gets default values for all cases, as mockito can't mock wrappers or primitives, including
diff --git a/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/ResourceConfigurationTest.java b/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/ResourceConfigurationTest.java
index b07f7c98f20..d8e97e382ca 100644
--- a/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/ResourceConfigurationTest.java
+++ b/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/ResourceConfigurationTest.java
@@ -68,20 +68,13 @@ void decodeResourceAttributes(String input, String expectedKey, String expectedV
 
   private static Stream<Arguments> decodeResourceAttributesArgs() {
     return Stream.of(
-        // Plus sign preserved
-        Arguments.of("food=cheese+cake", "food", "cheese+cake"),
-        // Percent-encoded space in resource attribute value decoded to space
-        Arguments.of("key=hello%20world", "key", "hello world"),
-        // Invalid percent encoding preserved
-        Arguments.of("key=abc%2Gdef", "key", "abc%2Gdef"),
-        // Incomplete percent encoding preserved
-        Arguments.of("key=abc%2", "key", "abc%2"),
-        // Percent at end preserved
-        Arguments.of("key=abc%", "key", "abc%"),
-        // Multiple percent encodings
-        Arguments.of("key=a%20b%2Bc%3Dd", "key", "a b+c=d"),
-        // No percent encoding
-        Arguments.of("key=plain-value", "key", "plain-value"));
+        Arguments.argumentSet("plus sign preserved", "food=cheese+cake", "food", "cheese+cake"),
+        Arguments.argumentSet("percent-encoded space", "key=hello%20world", "key", "hello world"),
+        Arguments.argumentSet("invalid percent encoding", "key=abc%2Gdef", "key", "abc%2Gdef"),
+        Arguments.argumentSet("incomplete percent encoding", "key=abc%2", "key", "abc%2"),
+        Arguments.argumentSet("percent at end", "key=abc%", "key", "abc%"),
+        Arguments.argumentSet("multiple percent encodings", "key=a%20b%2Bc%3Dd", "key", "a b+c=d"),
+        Arguments.argumentSet("no percent encoding", "key=plain-value", "key", "plain-value"));
   }
 
   @Test
diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/MetricExporterConfigurationTest.java b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/MetricExporterConfigurationTest.java
index c8bd0937e63..7a3e9518784 100644
--- a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/MetricExporterConfigurationTest.java
+++ b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/MetricExporterConfigurationTest.java
@@ -120,9 +120,9 @@ void configureExporter_KnownSpiExportersOnClasspath(
 
   private static Stream<Arguments> knownExporters() {
     return Stream.of(
-        Arguments.of("logging", LoggingMetricExporter.class),
-        Arguments.of("logging-otlp", OtlpJsonLoggingMetricExporter.class),
-        Arguments.of("otlp", OtlpGrpcMetricExporter.class));
+        Arguments.argumentSet("logging", "logging", LoggingMetricExporter.class),
+        Arguments.argumentSet("logging-otlp", "logging-otlp", OtlpJsonLoggingMetricExporter.class),
+        Arguments.argumentSet("otlp", "otlp", OtlpGrpcMetricExporter.class));
   }
 
   @ParameterizedTest
@@ -140,7 +140,7 @@ void configureMetricReader_KnownSpiExportersOnClasspath(
   }
 
   private static Stream<Arguments> knownReaders() {
-    return Stream.of(Arguments.of("prometheus", PrometheusHttpServer.class));
+    return Stream.of(Arguments.argumentSet("prometheus", "prometheus", PrometheusHttpServer.class));
   }
 
   @Test
diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ResourceConfigurationTest.java b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ResourceConfigurationTest.java
index f2133e11b1d..d3f4c85145e 100644
--- a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ResourceConfigurationTest.java
+++ b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ResourceConfigurationTest.java
@@ -76,14 +76,14 @@ void configureResource(
 
   private static Stream<Arguments> configureResourceArgs() {
     return Stream.of(
-        // default
-        Arguments.of(
+        Arguments.argumentSet(
+            "default",
             null,
             null,
             attributeConsumer(
                 attr -> attr.containsEntry("service.name", "test").containsEntry("cat", "meow"))),
-        // only enabled
-        Arguments.of(
+        Arguments.argumentSet(
+            "only enabled animal provider",
             "io.opentelemetry.sdk.autoconfigure.provider.TestAnimalResourceProvider",
             null,
             attributeConsumer(
@@ -92,8 +92,8 @@ private static Stream<Arguments> configureResourceArgs() {
                         .doesNotContainKey("cat")
                         .containsEntry("animal", "cat")
                         .doesNotContainKey("color"))),
-        // only disabled
-        Arguments.of(
+        Arguments.argumentSet(
+            "only disabled color provider",
             null,
             "io.opentelemetry.sdk.autoconfigure.provider.TestColorResourceProvider",
             attributeConsumer(
@@ -102,8 +102,8 @@ private static Stream<Arguments> configureResourceArgs() {
                         .containsEntry("cat", "meow")
                         .containsEntry("animal", "cat")
                         .doesNotContainKey("color"))),
-        // enabled and disabled
-        Arguments.of(
+        Arguments.argumentSet(
+            "enabled animal disabled color",
             "io.opentelemetry.sdk.autoconfigure.provider.TestAnimalResourceProvider",
             "io.opentelemetry.sdk.autoconfigure.provider.TestColorResourceProvider",
             attributeConsumer(
@@ -112,7 +112,8 @@ private static Stream<Arguments> configureResourceArgs() {
                         .doesNotContainKey("cat")
                         .containsEntry("animal", "cat")
                         .doesNotContainKey("color"))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "enabled animal disabled color and animal",
             "io.opentelemetry.sdk.autoconfigure.provider.TestAnimalResourceProvider",
             "io.opentelemetry.sdk.autoconfigure.provider.TestColorResourceProvider,io.opentelemetry.sdk.autoconfigure.provider.TestAnimalResourceProvider",
             attributeConsumer(
@@ -121,8 +122,8 @@ private static Stream<Arguments> configureResourceArgs() {
                         .doesNotContainKey("cat")
                         .doesNotContainKey("animal")
                         .doesNotContainKey("color"))),
-        // environment resource provider
-        Arguments.of(
+        Arguments.argumentSet(
+            "only environment provider enabled",
             "io.opentelemetry.sdk.autoconfigure.EnvironmentResourceProvider",
             null,
             attributeConsumer(
@@ -131,7 +132,8 @@ private static Stream<Arguments> configureResourceArgs() {
                         .containsEntry("cat", "meow")
                         .doesNotContainKey("animal")
                         .doesNotContainKey("color"))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "environment provider disabled",
             null,
             "io.opentelemetry.sdk.autoconfigure.EnvironmentResourceProvider",
             attributeConsumer(
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/AggregationFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/AggregationFactoryTest.java
index 15821175c8c..1b9949976ad 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/AggregationFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/AggregationFactoryTest.java
@@ -35,19 +35,25 @@ void create(AggregationModel model, Aggregation expectedResult) {
 
   private static Stream<Arguments> createTestCases() {
     return Stream.of(
-        Arguments.of(new AggregationModel(), Aggregation.defaultAggregation()),
-        Arguments.of(
-            new AggregationModel().withDrop(new DropAggregationModel()), Aggregation.drop()),
-        Arguments.of(new AggregationModel().withSum(new SumAggregationModel()), Aggregation.sum()),
-        Arguments.of(
+        Arguments.argumentSet("default", new AggregationModel(), Aggregation.defaultAggregation()),
+        Arguments.argumentSet(
+            "drop",
+            new AggregationModel().withDrop(new DropAggregationModel()),
+            Aggregation.drop()),
+        Arguments.argumentSet(
+            "sum", new AggregationModel().withSum(new SumAggregationModel()), Aggregation.sum()),
+        Arguments.argumentSet(
+            "last_Value",
             new AggregationModel().withLastValue(new LastValueAggregationModel()),
             Aggregation.lastValue()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "base2_exponential_bucket_histogram defaults",
             new AggregationModel()
                 .withBase2ExponentialBucketHistogram(
                     new Base2ExponentialBucketHistogramAggregationModel()),
             Aggregation.base2ExponentialBucketHistogram()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "base2_exponential_bucket_histogram with options",
             new AggregationModel()
                 .withBase2ExponentialBucketHistogram(
                     new Base2ExponentialBucketHistogramAggregationModel()
@@ -58,12 +64,14 @@ private static Stream<Arguments> createTestCases() {
                     .setMaxBuckets(2)
                     .setMaxScale(2)
                     .build())),
-        Arguments.of(
+        Arguments.argumentSet(
+            "explicit_bucket_histogram null boundaries",
             new AggregationModel()
                 .withExplicitBucketHistogram(
                     new ExplicitBucketHistogramAggregationModel().withBoundaries(null)),
             Aggregation.explicitBucketHistogram()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "explicit_bucket_histogram with boundaries",
             new AggregationModel()
                 .withExplicitBucketHistogram(
                     new ExplicitBucketHistogramAggregationModel()
@@ -72,8 +80,8 @@ private static Stream<Arguments> createTestCases() {
                 ExplicitBucketHistogramOptions.builder()
                     .setBucketBoundaries(Arrays.asList(1.0, 2.0))
                     .build())),
-        // Test recordMinMax parameter for explicit bucket histogram
-        Arguments.of(
+        Arguments.argumentSet(
+            "explicit_bucket_histogram record_min_max true",
             new AggregationModel()
                 .withExplicitBucketHistogram(
                     new ExplicitBucketHistogramAggregationModel()
@@ -84,7 +92,8 @@ private static Stream<Arguments> createTestCases() {
                     .setBucketBoundaries(Arrays.asList(1.0, 2.0))
                     .setRecordMinMax(true)
                     .build())),
-        Arguments.of(
+        Arguments.argumentSet(
+            "explicit_bucket_histogram record_min_max false",
             new AggregationModel()
                 .withExplicitBucketHistogram(
                     new ExplicitBucketHistogramAggregationModel()
@@ -95,7 +104,8 @@ private static Stream<Arguments> createTestCases() {
                     .setBucketBoundaries(Arrays.asList(1.0, 2.0))
                     .setRecordMinMax(false)
                     .build())),
-        Arguments.of(
+        Arguments.argumentSet(
+            "explicit_bucket_histogram null boundaries record_min_max false",
             new AggregationModel()
                 .withExplicitBucketHistogram(
                     new ExplicitBucketHistogramAggregationModel()
@@ -103,8 +113,8 @@ private static Stream<Arguments> createTestCases() {
                         .withRecordMinMax(false)),
             Aggregation.explicitBucketHistogram(
                 ExplicitBucketHistogramOptions.builder().setRecordMinMax(false).build())),
-        // Test recordMinMax parameter for exponential bucket histogram
-        Arguments.of(
+        Arguments.argumentSet(
+            "base2_exponential_bucket_histogram record_min_max true",
             new AggregationModel()
                 .withBase2ExponentialBucketHistogram(
                     new Base2ExponentialBucketHistogramAggregationModel()
@@ -117,7 +127,8 @@ private static Stream<Arguments> createTestCases() {
                     .setMaxScale(2)
                     .setRecordMinMax(true)
                     .build())),
-        Arguments.of(
+        Arguments.argumentSet(
+            "base2_exponential_bucket_histogram record_min_max false",
             new AggregationModel()
                 .withBase2ExponentialBucketHistogram(
                     new Base2ExponentialBucketHistogramAggregationModel()
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/AttributeListFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/AttributeListFactoryTest.java
index b1de9633291..9a81a28de6c 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/AttributeListFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/AttributeListFactoryTest.java
@@ -36,21 +36,25 @@ void create_InvalidAttributes(List<AttributeNameValueModel> model, String expect
 
   private static Stream<Arguments> invalidAttributes() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "null value",
             Collections.singletonList(new AttributeNameValueModel().withName("key")),
             "attribute value is required but is null"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "wrong type string",
             Collections.singletonList(
                 new AttributeNameValueModel().withName("key").withValue(new Object())),
             "Error processing attribute with name \"key\": value did not match type STRING"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "wrong type int list",
             Collections.singletonList(
                 new AttributeNameValueModel()
                     .withName("key")
                     .withType(AttributeNameValueModel.AttributeType.INT)
                     .withValue(Arrays.asList(1L, 1))),
             "Error processing attribute with name \"key\": value did not match type INT"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "wrong type int boolean",
             Collections.singletonList(
                 new AttributeNameValueModel()
                     .withName("key")
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/CardinalityLimitsFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/CardinalityLimitsFactoryTest.java
index 2d1be6ce68c..64a40171ea9 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/CardinalityLimitsFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/CardinalityLimitsFactoryTest.java
@@ -33,10 +33,12 @@ void create(CardinalityLimitsModel model, CardinalityLimitSelector expectedResul
 
   private static Stream<Arguments> createTestCases() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "defaults",
             new CardinalityLimitsModel(),
             CardinalityLimitSelector.defaultCardinalityLimitSelector()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "default and counter",
             new CardinalityLimitsModel().withDefault(10).withCounter(1),
             (CardinalityLimitSelector)
                 instrumentType -> {
@@ -45,7 +47,8 @@ private static Stream<Arguments> createTestCases() {
                   }
                   return 10;
                 }),
-        Arguments.of(
+        Arguments.argumentSet(
+            "all instrument types",
             new CardinalityLimitsModel()
                 .withCounter(1)
                 .withUpDownCounter(2)
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ComposableRuleBasedSamplerFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ComposableRuleBasedSamplerFactoryTest.java
index f97cd2e9dec..04addf2a6f4 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ComposableRuleBasedSamplerFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ComposableRuleBasedSamplerFactoryTest.java
@@ -70,7 +70,8 @@ void createInvalid(ExperimentalComposableRuleBasedSamplerModel model, String exp
 
   private static Stream<Arguments> createInvalidTestCases() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "attribute_patterns included empty",
             new ExperimentalComposableRuleBasedSamplerModel()
                 .withRules(
                     Collections.singletonList(
@@ -85,7 +86,8 @@ private static Stream<Arguments> createInvalidTestCases() {
                                     .withAlwaysOn(
                                         new ExperimentalComposableAlwaysOnSamplerModel())))),
             "included must not be empty"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "attribute_patterns excluded empty",
             new ExperimentalComposableRuleBasedSamplerModel()
                 .withRules(
                     Collections.singletonList(
@@ -100,7 +102,8 @@ private static Stream<Arguments> createInvalidTestCases() {
                                     .withAlwaysOn(
                                         new ExperimentalComposableAlwaysOnSamplerModel())))),
             "excluded must not be empty"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "attribute_values null values",
             new ExperimentalComposableRuleBasedSamplerModel()
                 .withRules(
                     Collections.singletonList(
@@ -114,7 +117,8 @@ private static Stream<Arguments> createInvalidTestCases() {
                                     .withAlwaysOn(
                                         new ExperimentalComposableAlwaysOnSamplerModel())))),
             ".values is required and must be non-empty"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "attribute_values empty values",
             new ExperimentalComposableRuleBasedSamplerModel()
                 .withRules(
                     Collections.singletonList(
@@ -132,12 +136,13 @@ private static Stream<Arguments> createInvalidTestCases() {
 
   private static Stream<Arguments> createTestCases() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "empty model",
             new ExperimentalComposableRuleBasedSamplerModel(),
             ComposableSampler.ruleBasedBuilder().build()),
-        // attributePatterns with only included (no excluded) - analogous to
         // https://github.com/open-telemetry/opentelemetry-java/issues/8337
-        Arguments.of(
+        Arguments.argumentSet(
+            "attribute_patterns included only",
             new ExperimentalComposableRuleBasedSamplerModel()
                 .withRules(
                     Collections.singletonList(
@@ -162,8 +167,8 @@ private static Stream<Arguments> createTestCases() {
                         null),
                     ComposableSampler.alwaysOn())
                 .build()),
-        // Recreate example
-        Arguments.of(
+        Arguments.argumentSet(
+            "full example",
             new ExperimentalComposableRuleBasedSamplerModel()
                 .withRules(
                     Arrays.asList(
@@ -315,66 +320,153 @@ private static Stream<Arguments> declarativeConfigSamplingPredicateArgs() {
             Collections.singleton(CLIENT));
 
     return Stream.of(
-        // match all
-        Arguments.of(matchAll, noParent, sk, Attributes.empty(), true),
-        Arguments.of(matchAll, noParent, sk, Attributes.of(HTTP_ROUTE, "/healthz"), true),
-        Arguments.of(
-            matchAll, noParent, sk, Attributes.of(HTTP_PATH, "/internal/admin/users"), true),
-        Arguments.of(matchAll, noParent, SERVER, Attributes.empty(), true),
-        Arguments.of(matchAll, remoteParent, sk, Attributes.empty(), true),
-        // value matcher
-        Arguments.of(valuesMatcher, noParent, sk, Attributes.of(HTTP_ROUTE, "/healthz"), true),
-        Arguments.of(valuesMatcher, noParent, sk, Attributes.of(HTTP_ROUTE, "/livez"), true),
-        Arguments.of(valuesMatcher, noParent, sk, Attributes.of(HTTP_ROUTE, "/foo"), false),
-        Arguments.of(valuesMatcher, noParent, sk, Attributes.empty(), false),
-        // pattern matcher
-        Arguments.of(
-            patternsMatcher, noParent, sk, Attributes.of(HTTP_PATH, "/internal/admin/users"), true),
-        Arguments.of(
+        Arguments.argumentSet(
+            "matchAll no parent empty", matchAll, noParent, sk, Attributes.empty(), true),
+        Arguments.argumentSet(
+            "matchAll no parent route",
+            matchAll,
+            noParent,
+            sk,
+            Attributes.of(HTTP_ROUTE, "/healthz"),
+            true),
+        Arguments.argumentSet(
+            "matchAll no parent path",
+            matchAll,
+            noParent,
+            sk,
+            Attributes.of(HTTP_PATH, "/internal/admin/users"),
+            true),
+        Arguments.argumentSet(
+            "matchAll no parent server kind", matchAll, noParent, SERVER, Attributes.empty(), true),
+        Arguments.argumentSet(
+            "matchAll remote parent", matchAll, remoteParent, sk, Attributes.empty(), true),
+        Arguments.argumentSet(
+            "valuesMatcher healthz",
+            valuesMatcher,
+            noParent,
+            sk,
+            Attributes.of(HTTP_ROUTE, "/healthz"),
+            true),
+        Arguments.argumentSet(
+            "valuesMatcher livez",
+            valuesMatcher,
+            noParent,
+            sk,
+            Attributes.of(HTTP_ROUTE, "/livez"),
+            true),
+        Arguments.argumentSet(
+            "valuesMatcher foo no match",
+            valuesMatcher,
+            noParent,
+            sk,
+            Attributes.of(HTTP_ROUTE, "/foo"),
+            false),
+        Arguments.argumentSet(
+            "valuesMatcher empty no match", valuesMatcher, noParent, sk, Attributes.empty(), false),
+        Arguments.argumentSet(
+            "patternsMatcher internal admin",
+            patternsMatcher,
+            noParent,
+            sk,
+            Attributes.of(HTTP_PATH, "/internal/admin/users"),
+            true),
+        Arguments.argumentSet(
+            "patternsMatcher internal management",
             patternsMatcher,
             noParent,
             sk,
             Attributes.of(HTTP_PATH, "/internal/management/config"),
             true),
-        Arguments.of(
-            patternsMatcher, noParent, sk, Attributes.of(HTTP_PATH, "/users/profile/123"), false),
-        Arguments.of(
+        Arguments.argumentSet(
+            "patternsMatcher users no match",
+            patternsMatcher,
+            noParent,
+            sk,
+            Attributes.of(HTTP_PATH, "/users/profile/123"),
+            false),
+        Arguments.argumentSet(
+            "patternsMatcher internal special excluded",
             patternsMatcher,
             noParent,
             sk,
             Attributes.of(HTTP_PATH, "/internal/special/foo"),
             false),
-        // parent matcher
-        Arguments.of(parentMatcher, noParent, sk, Attributes.empty(), true),
-        Arguments.of(parentMatcher, localParent, sk, Attributes.empty(), false),
-        Arguments.of(parentMatcher, remoteParent, sk, Attributes.empty(), false),
-        // span kind matcher
-        Arguments.of(spanKindMatcher, noParent, CLIENT, Attributes.empty(), true),
-        Arguments.of(spanKindMatcher, noParent, SERVER, Attributes.empty(), false),
-        Arguments.of(spanKindMatcher, noParent, INTERNAL, Attributes.empty(), false),
-        Arguments.of(spanKindMatcher, noParent, PRODUCER, Attributes.empty(), false),
-        Arguments.of(spanKindMatcher, noParent, CONSUMER, Attributes.empty(), false),
-        // multi matcher
-        Arguments.of(
+        Arguments.argumentSet(
+            "parentMatcher no parent", parentMatcher, noParent, sk, Attributes.empty(), true),
+        Arguments.argumentSet(
+            "parentMatcher local parent no match",
+            parentMatcher,
+            localParent,
+            sk,
+            Attributes.empty(),
+            false),
+        Arguments.argumentSet(
+            "parentMatcher remote parent no match",
+            parentMatcher,
+            remoteParent,
+            sk,
+            Attributes.empty(),
+            false),
+        Arguments.argumentSet(
+            "spanKindMatcher CLIENT", spanKindMatcher, noParent, CLIENT, Attributes.empty(), true),
+        Arguments.argumentSet(
+            "spanKindMatcher SERVER no match",
+            spanKindMatcher,
+            noParent,
+            SERVER,
+            Attributes.empty(),
+            false),
+        Arguments.argumentSet(
+            "spanKindMatcher INTERNAL no match",
+            spanKindMatcher,
+            noParent,
+            INTERNAL,
+            Attributes.empty(),
+            false),
+        Arguments.argumentSet(
+            "spanKindMatcher PRODUCER no match",
+            spanKindMatcher,
+            noParent,
+            PRODUCER,
+            Attributes.empty(),
+            false),
+        Arguments.argumentSet(
+            "spanKindMatcher CONSUMER no match",
+            spanKindMatcher,
+            noParent,
+            CONSUMER,
+            Attributes.empty(),
+            false),
+        Arguments.argumentSet(
+            "multiMatcher all conditions match",
             multiMatcher,
             noParent,
             CLIENT,
             Attributes.of(HTTP_ROUTE, "/livez", HTTP_PATH, "/internal/admin/users"),
             true),
-        Arguments.of(multiMatcher, noParent, CLIENT, Attributes.of(HTTP_ROUTE, "/livez"), false),
-        Arguments.of(
+        Arguments.argumentSet(
+            "multiMatcher missing path no match",
+            multiMatcher,
+            noParent,
+            CLIENT,
+            Attributes.of(HTTP_ROUTE, "/livez"),
+            false),
+        Arguments.argumentSet(
+            "multiMatcher missing route no match",
             multiMatcher,
             noParent,
             CLIENT,
             Attributes.of(HTTP_PATH, "/internal/admin/users"),
             false),
-        Arguments.of(
+        Arguments.argumentSet(
+            "multiMatcher wrong kind no match",
             multiMatcher,
             noParent,
             SERVER,
             Attributes.of(HTTP_ROUTE, "/livez", HTTP_PATH, "/internal/admin/users"),
             false),
-        Arguments.of(
+        Arguments.argumentSet(
+            "multiMatcher local parent no match",
             multiMatcher,
             localParent,
             CLIENT,
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/DeclarativeConfigurationParseTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/DeclarativeConfigurationParseTest.java
index 9a928f8648e..9e7ed50a1f9 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/DeclarativeConfigurationParseTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/DeclarativeConfigurationParseTest.java
@@ -171,10 +171,12 @@ void coreSchemaValues(String rawYaml, Object expectedYamlResult) {
   @SuppressWarnings("unchecked")
   private static Stream<Arguments> coreSchemaValuesArgs() {
     return Stream.of(
-        Arguments.of("key1: 0o123\n", mapOf(entry("key1", 83))),
-        Arguments.of("key1: 0123\n", mapOf(entry("key1", 123))),
-        Arguments.of("key1: 0xdeadbeef\n", mapOf(entry("key1", 3735928559L))),
-        Arguments.of("key1: \"0xdeadbeef\"\n", mapOf(entry("key1", "0xdeadbeef"))));
+        Arguments.argumentSet("octal with o", "key1: 0o123\n", mapOf(entry("key1", 83))),
+        Arguments.argumentSet("octal without o", "key1: 0123\n", mapOf(entry("key1", 123))),
+        Arguments.argumentSet(
+            "unquoted hex string", "key1: 0xdeadbeef\n", mapOf(entry("key1", 3735928559L))),
+        Arguments.argumentSet(
+            "quoted hex string", "key1: \"0xdeadbeef\"\n", mapOf(entry("key1", "0xdeadbeef"))));
   }
 
   @ParameterizedTest
@@ -202,86 +204,149 @@ void envSubstituteAndLoadYaml(String rawYaml, Object expectedYamlResult) {
   @SuppressWarnings("unchecked")
   private static Stream<Arguments> envVarSubstitutionArgs() {
     return Stream.of(
-        // Simple cases
-        Arguments.of("key1: ${STR_1}\n", mapOf(entry("key1", "value1"))),
-        Arguments.of("key1: ${BOOL}\n", mapOf(entry("key1", true))),
-        Arguments.of("key1: ${INT}\n", mapOf(entry("key1", 1))),
-        Arguments.of("key1: ${FLOAT}\n", mapOf(entry("key1", 1.1))),
-        Arguments.of("key1: ${HEX}\n", mapOf(entry("key1", 3735928559L))),
-        Arguments.of(
+        Arguments.argumentSet("STR_1 string", "key1: ${STR_1}\n", mapOf(entry("key1", "value1"))),
+        Arguments.argumentSet("BOOL boolean", "key1: ${BOOL}\n", mapOf(entry("key1", true))),
+        Arguments.argumentSet("INT integer", "key1: ${INT}\n", mapOf(entry("key1", 1))),
+        Arguments.argumentSet("FLOAT float", "key1: ${FLOAT}\n", mapOf(entry("key1", 1.1))),
+        Arguments.argumentSet("HEX hex", "key1: ${HEX}\n", mapOf(entry("key1", 3735928559L))),
+        Arguments.argumentSet(
+            "STR_1 with literal key2",
             "key1: ${STR_1}\n" + "key2: value2\n",
             mapOf(entry("key1", "value1"), entry("key2", "value2"))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "STR_1 concatenated with literal",
             "key1: ${STR_1} value1\n" + "key2: value2\n",
             mapOf(entry("key1", "value1 value1"), entry("key2", "value2"))),
-        // Default cases
-        Arguments.of("key1: ${NOT_SET:-value1}\n", mapOf(entry("key1", "value1"))),
-        Arguments.of("key1: ${NOT_SET:-true}\n", mapOf(entry("key1", true))),
-        Arguments.of("key1: ${NOT_SET:-1}\n", mapOf(entry("key1", 1))),
-        Arguments.of("key1: ${NOT_SET:-1.1}\n", mapOf(entry("key1", 1.1))),
-        Arguments.of("key1: ${NOT_SET:-0xdeadbeef}\n", mapOf(entry("key1", 3735928559L))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "default string", "key1: ${NOT_SET:-value1}\n", mapOf(entry("key1", "value1"))),
+        Arguments.argumentSet(
+            "default boolean", "key1: ${NOT_SET:-true}\n", mapOf(entry("key1", true))),
+        Arguments.argumentSet("default integer", "key1: ${NOT_SET:-1}\n", mapOf(entry("key1", 1))),
+        Arguments.argumentSet(
+            "default float", "key1: ${NOT_SET:-1.1}\n", mapOf(entry("key1", 1.1))),
+        Arguments.argumentSet(
+            "default hex", "key1: ${NOT_SET:-0xdeadbeef}\n", mapOf(entry("key1", 3735928559L))),
+        Arguments.argumentSet(
+            "default concatenated with literal",
             "key1: ${NOT_SET:-value1} value2\n" + "key2: value2\n",
             mapOf(entry("key1", "value1 value2"), entry("key2", "value2"))),
-        // Multiple environment variables referenced
-        Arguments.of("key1: ${STR_1}${STR_2}\n", mapOf(entry("key1", "value1value2"))),
-        Arguments.of("key1: ${STR_1} ${STR_2}\n", mapOf(entry("key1", "value1 value2"))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "two vars concatenated",
+            "key1: ${STR_1}${STR_2}\n",
+            mapOf(entry("key1", "value1value2"))),
+        Arguments.argumentSet(
+            "two vars with space",
+            "key1: ${STR_1} ${STR_2}\n",
+            mapOf(entry("key1", "value1 value2"))),
+        Arguments.argumentSet(
+            "two vars with default",
             "key1: ${STR_1} ${NOT_SET:-default} ${STR_2}\n",
             mapOf(entry("key1", "value1 default value2"))),
-        // Undefined / empty environment variable
-        Arguments.of("key1: ${EMPTY_STR}\n", mapOf(entry("key1", null))),
-        Arguments.of("key1: ${STR_3}\n", mapOf(entry("key1", null))),
-        Arguments.of("key1: ${STR_1} ${STR_3}\n", mapOf(entry("key1", "value1 "))),
+        Arguments.argumentSet("empty var null", "key1: ${EMPTY_STR}\n", mapOf(entry("key1", null))),
+        Arguments.argumentSet("undefined var null", "key1: ${STR_3}\n", mapOf(entry("key1", null))),
+        Arguments.argumentSet(
+            "set and undefined vars", "key1: ${STR_1} ${STR_3}\n", mapOf(entry("key1", "value1 "))),
         // Environment variable keys must match pattern: [a-zA-Z_]+[a-zA-Z0-9_]*
-        Arguments.of("key1: ${VAR&}\n", mapOf(entry("key1", "${VAR&}"))),
+        Arguments.argumentSet(
+            "invalid var syntax literal", "key1: ${VAR&}\n", mapOf(entry("key1", "${VAR&}"))),
         // Environment variable substitution only takes place in scalar values of maps
-        Arguments.of("${STR_1}: value1\n", mapOf(entry("${STR_1}", "value1"))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "var in map key not substituted",
+            "${STR_1}: value1\n",
+            mapOf(entry("${STR_1}", "value1"))),
+        Arguments.argumentSet(
+            "var in nested map key not substituted",
             "key1:\n  ${STR_1}: value1\n",
             mapOf(entry("key1", mapOf(entry("${STR_1}", "value1"))))),
-        Arguments.of(
-            "key1:\n - ${STR_1}\n", mapOf(entry("key1", Collections.singletonList("${STR_1}")))),
-        // Double-quoted environment variables
-        Arguments.of("key1: \"${HEX}\"\n", mapOf(entry("key1", "0xdeadbeef"))),
-        Arguments.of("key1: \"${STR_1}\"\n", mapOf(entry("key1", "value1"))),
-        Arguments.of("key1: \"${EMPTY_STR}\"\n", mapOf(entry("key1", ""))),
-        Arguments.of("key1: \"${BOOL}\"\n", mapOf(entry("key1", "true"))),
-        Arguments.of("key1: \"${INT}\"\n", mapOf(entry("key1", "1"))),
-        Arguments.of("key1: \"${FLOAT}\"\n", mapOf(entry("key1", "1.1"))),
-        Arguments.of(
-            "key1: \"${HEX} ${BOOL} ${INT}\"\n", mapOf(entry("key1", "0xdeadbeef true 1"))),
-        // Single-quoted environment variables
-        Arguments.of("key1: '${HEX}'\n", mapOf(entry("key1", "0xdeadbeef"))),
-        Arguments.of("key1: '${STR_1}'\n", mapOf(entry("key1", "value1"))),
-        Arguments.of("key1: '${EMPTY_STR}'\n", mapOf(entry("key1", ""))),
-        Arguments.of("key1: '${BOOL}'\n", mapOf(entry("key1", "true"))),
-        Arguments.of("key1: '${INT}'\n", mapOf(entry("key1", "1"))),
-        Arguments.of("key1: '${FLOAT}'\n", mapOf(entry("key1", "1.1"))),
-        Arguments.of("key1: '${HEX} ${BOOL} ${INT}'\n", mapOf(entry("key1", "0xdeadbeef true 1"))),
-        // Escaped
-        Arguments.of("key1: ${FOO}\n", mapOf(entry("key1", "BAR"))),
-        Arguments.of("key1: $${FOO}\n", mapOf(entry("key1", "${FOO}"))),
-        Arguments.of("key1: $$${FOO}\n", mapOf(entry("key1", "$BAR"))),
-        Arguments.of("key1: $$$${FOO}\n", mapOf(entry("key1", "$${FOO}"))),
-        Arguments.of("key1: a $$ b\n", mapOf(entry("key1", "a $ b"))),
-        Arguments.of("key1: $$ b\n", mapOf(entry("key1", "$ b"))),
-        Arguments.of("key1: a $$\n", mapOf(entry("key1", "a $"))),
-        Arguments.of("key1: a $ b\n", mapOf(entry("key1", "a $ b"))),
-        Arguments.of("key1: $${STR_1}\n", mapOf(entry("key1", "${STR_1}"))),
-        Arguments.of("key1: $${STR_1}$${STR_1}\n", mapOf(entry("key1", "${STR_1}${STR_1}"))),
-        Arguments.of("key1: $${STR_1}$$\n", mapOf(entry("key1", "${STR_1}$"))),
-        Arguments.of("key1: $$${STR_1}\n", mapOf(entry("key1", "$value1"))),
-        Arguments.of("key1: \"$${STR_1}\"\n", mapOf(entry("key1", "${STR_1}"))),
-        Arguments.of("key1: $${STR_1} ${STR_2}\n", mapOf(entry("key1", "${STR_1} value2"))),
-        Arguments.of("key1: $${STR_1} $${STR_2}\n", mapOf(entry("key1", "${STR_1} ${STR_2}"))),
-        Arguments.of("key1: $${NOT_SET:-value1}\n", mapOf(entry("key1", "${NOT_SET:-value1}"))),
-        Arguments.of("key1: $${STR_1:-fallback}\n", mapOf(entry("key1", "${STR_1:-fallback}"))),
-        Arguments.of("key1: $${STR_1:-${STR_1}}\n", mapOf(entry("key1", "${STR_1:-value1}"))),
-        Arguments.of("key1: ${NOT_SET:-${FALLBACK}}\n", mapOf(entry("key1", "${FALLBACK}"))),
-        Arguments.of(
-            "key1: ${NOT_SET:-$${FALLBACK}}\n", mapOf(entry("key1", "${NOT_SET:-${FALLBACK}}"))),
-        Arguments.of("key1: ${VALUE_WITH_ESCAPE}\n", mapOf(entry("key1", "value$$"))));
+        Arguments.argumentSet(
+            "var in list not substituted",
+            "key1:\n - ${STR_1}\n",
+            mapOf(entry("key1", Collections.singletonList("${STR_1}")))),
+        Arguments.argumentSet(
+            "double-quoted hex string", "key1: \"${HEX}\"\n", mapOf(entry("key1", "0xdeadbeef"))),
+        Arguments.argumentSet(
+            "double-quoted string", "key1: \"${STR_1}\"\n", mapOf(entry("key1", "value1"))),
+        Arguments.argumentSet(
+            "double-quoted empty string", "key1: \"${EMPTY_STR}\"\n", mapOf(entry("key1", ""))),
+        Arguments.argumentSet(
+            "double-quoted boolean string", "key1: \"${BOOL}\"\n", mapOf(entry("key1", "true"))),
+        Arguments.argumentSet(
+            "double-quoted integer string", "key1: \"${INT}\"\n", mapOf(entry("key1", "1"))),
+        Arguments.argumentSet(
+            "double-quoted float string", "key1: \"${FLOAT}\"\n", mapOf(entry("key1", "1.1"))),
+        Arguments.argumentSet(
+            "double-quoted multiple vars",
+            "key1: \"${HEX} ${BOOL} ${INT}\"\n",
+            mapOf(entry("key1", "0xdeadbeef true 1"))),
+        Arguments.argumentSet(
+            "single-quoted hex string", "key1: '${HEX}'\n", mapOf(entry("key1", "0xdeadbeef"))),
+        Arguments.argumentSet(
+            "single-quoted string", "key1: '${STR_1}'\n", mapOf(entry("key1", "value1"))),
+        Arguments.argumentSet(
+            "single-quoted empty string", "key1: '${EMPTY_STR}'\n", mapOf(entry("key1", ""))),
+        Arguments.argumentSet(
+            "single-quoted boolean string", "key1: '${BOOL}'\n", mapOf(entry("key1", "true"))),
+        Arguments.argumentSet(
+            "single-quoted integer string", "key1: '${INT}'\n", mapOf(entry("key1", "1"))),
+        Arguments.argumentSet(
+            "single-quoted float string", "key1: '${FLOAT}'\n", mapOf(entry("key1", "1.1"))),
+        Arguments.argumentSet(
+            "single-quoted multiple vars",
+            "key1: '${HEX} ${BOOL} ${INT}'\n",
+            mapOf(entry("key1", "0xdeadbeef true 1"))),
+        Arguments.argumentSet("FOO var", "key1: ${FOO}\n", mapOf(entry("key1", "BAR"))),
+        Arguments.argumentSet(
+            "double-dollar escape", "key1: $${FOO}\n", mapOf(entry("key1", "${FOO}"))),
+        Arguments.argumentSet("triple-dollar", "key1: $$${FOO}\n", mapOf(entry("key1", "$BAR"))),
+        Arguments.argumentSet(
+            "quad-dollar escape", "key1: $$$${FOO}\n", mapOf(entry("key1", "$${FOO}"))),
+        Arguments.argumentSet(
+            "double-dollar in middle", "key1: a $$ b\n", mapOf(entry("key1", "a $ b"))),
+        Arguments.argumentSet("double-dollar prefix", "key1: $$ b\n", mapOf(entry("key1", "$ b"))),
+        Arguments.argumentSet("double-dollar suffix", "key1: a $$\n", mapOf(entry("key1", "a $"))),
+        Arguments.argumentSet(
+            "single dollar literal", "key1: a $ b\n", mapOf(entry("key1", "a $ b"))),
+        Arguments.argumentSet("escape var", "key1: $${STR_1}\n", mapOf(entry("key1", "${STR_1}"))),
+        Arguments.argumentSet(
+            "escape two vars",
+            "key1: $${STR_1}$${STR_1}\n",
+            mapOf(entry("key1", "${STR_1}${STR_1}"))),
+        Arguments.argumentSet(
+            "escape var with dollar", "key1: $${STR_1}$$\n", mapOf(entry("key1", "${STR_1}$"))),
+        Arguments.argumentSet(
+            "triple-dollar var", "key1: $$${STR_1}\n", mapOf(entry("key1", "$value1"))),
+        Arguments.argumentSet(
+            "double-quoted escape var", "key1: \"$${STR_1}\"\n", mapOf(entry("key1", "${STR_1}"))),
+        Arguments.argumentSet(
+            "escape var then real var",
+            "key1: $${STR_1} ${STR_2}\n",
+            mapOf(entry("key1", "${STR_1} value2"))),
+        Arguments.argumentSet(
+            "two escape vars",
+            "key1: $${STR_1} $${STR_2}\n",
+            mapOf(entry("key1", "${STR_1} ${STR_2}"))),
+        Arguments.argumentSet(
+            "escape default",
+            "key1: $${NOT_SET:-value1}\n",
+            mapOf(entry("key1", "${NOT_SET:-value1}"))),
+        Arguments.argumentSet(
+            "escape var with fallback",
+            "key1: $${STR_1:-fallback}\n",
+            mapOf(entry("key1", "${STR_1:-fallback}"))),
+        Arguments.argumentSet(
+            "escape var with nested default",
+            "key1: $${STR_1:-${STR_1}}\n",
+            mapOf(entry("key1", "${STR_1:-value1}"))),
+        Arguments.argumentSet(
+            "nested var in default",
+            "key1: ${NOT_SET:-${FALLBACK}}\n",
+            mapOf(entry("key1", "${FALLBACK}"))),
+        Arguments.argumentSet(
+            "escape in default",
+            "key1: ${NOT_SET:-$${FALLBACK}}\n",
+            mapOf(entry("key1", "${NOT_SET:-${FALLBACK}}"))),
+        Arguments.argumentSet(
+            "value with escape", "key1: ${VALUE_WITH_ESCAPE}\n", mapOf(entry("key1", "value$$"))));
   }
 
   private static <K, V> Map.Entry<K, V> entry(K key, @Nullable V value) {
@@ -322,37 +387,65 @@ void sysPropertySubstituteAndLoadYaml(String rawYaml, Object expectedYamlResult)
   @SuppressWarnings("unchecked")
   private static Stream<Arguments> sysPropertySubstitutionArgs() {
     return Stream.of(
-        // Simple cases with sys: prefix
-        Arguments.of("key1: ${sys:str.1}\n", mapOf(entry("key1", "value1"))),
-        Arguments.of("key1: ${sys:bool.prop}\n", mapOf(entry("key1", true))),
-        Arguments.of("key1: ${sys:int.prop}\n", mapOf(entry("key1", 1))),
-        Arguments.of("key1: ${sys:float.prop}\n", mapOf(entry("key1", 1.1))),
-        Arguments.of("key1: ${sys:hex.prop}\n", mapOf(entry("key1", 3735928559L))),
-        // Default values
-        Arguments.of("key1: ${sys:not.set:-value1}\n", mapOf(entry("key1", "value1"))),
-        Arguments.of("key1: ${sys:not.set:-true}\n", mapOf(entry("key1", true))),
-        Arguments.of("key1: ${sys:not.set:-1}\n", mapOf(entry("key1", 1))),
-        // Multiple property references
-        Arguments.of("key1: ${sys:str.1}${sys:str.2}\n", mapOf(entry("key1", "value1value2"))),
-        Arguments.of("key1: ${sys:str.1} ${sys:str.2}\n", mapOf(entry("key1", "value1 value2"))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "sys str.1 string", "key1: ${sys:str.1}\n", mapOf(entry("key1", "value1"))),
+        Arguments.argumentSet(
+            "sys bool.prop boolean", "key1: ${sys:bool.prop}\n", mapOf(entry("key1", true))),
+        Arguments.argumentSet(
+            "sys int.prop integer", "key1: ${sys:int.prop}\n", mapOf(entry("key1", 1))),
+        Arguments.argumentSet(
+            "sys float.prop float", "key1: ${sys:float.prop}\n", mapOf(entry("key1", 1.1))),
+        Arguments.argumentSet(
+            "sys hex.prop hex", "key1: ${sys:hex.prop}\n", mapOf(entry("key1", 3735928559L))),
+        Arguments.argumentSet(
+            "sys default string", "key1: ${sys:not.set:-value1}\n", mapOf(entry("key1", "value1"))),
+        Arguments.argumentSet(
+            "sys default boolean", "key1: ${sys:not.set:-true}\n", mapOf(entry("key1", true))),
+        Arguments.argumentSet(
+            "sys default integer", "key1: ${sys:not.set:-1}\n", mapOf(entry("key1", 1))),
+        Arguments.argumentSet(
+            "sys two props concatenated",
+            "key1: ${sys:str.1}${sys:str.2}\n",
+            mapOf(entry("key1", "value1value2"))),
+        Arguments.argumentSet(
+            "sys two props with space",
+            "key1: ${sys:str.1} ${sys:str.2}\n",
+            mapOf(entry("key1", "value1 value2"))),
+        Arguments.argumentSet(
+            "sys two props with default",
             "key1: ${sys:str.1} ${sys:not.set:-default} ${sys:str.2}\n",
             mapOf(entry("key1", "value1 default value2"))),
-        // Undefined / empty system property
-        Arguments.of("key1: ${sys:empty.str}\n", mapOf(entry("key1", null))),
-        Arguments.of("key1: ${sys:str.3}\n", mapOf(entry("key1", null))),
-        Arguments.of("key1: ${sys:str.1} ${sys:str.3}\n", mapOf(entry("key1", "value1 "))),
-        // Quoted system properties
-        Arguments.of("key1: \"${sys:hex.prop}\"\n", mapOf(entry("key1", "0xdeadbeef"))),
-        Arguments.of("key1: \"${sys:str.1}\"\n", mapOf(entry("key1", "value1"))),
-        Arguments.of("key1: '${sys:str.1}'\n", mapOf(entry("key1", "value1"))),
-        // Escaped
-        Arguments.of("key1: ${sys:foo.bar}\n", mapOf(entry("key1", "BAR"))),
-        Arguments.of("key1: $${sys:foo.bar}\n", mapOf(entry("key1", "${sys:foo.bar}"))),
-        Arguments.of("key1: $$${sys:foo.bar}\n", mapOf(entry("key1", "$BAR"))),
-        Arguments.of("key1: $$$${sys:foo.bar}\n", mapOf(entry("key1", "$${sys:foo.bar}"))),
-        // Mixed env and sys
-        Arguments.of("key1: ${sys:value.with.escape}\n", mapOf(entry("key1", "value$$"))));
+        Arguments.argumentSet(
+            "sys empty.str null", "key1: ${sys:empty.str}\n", mapOf(entry("key1", null))),
+        Arguments.argumentSet(
+            "sys undefined null", "key1: ${sys:str.3}\n", mapOf(entry("key1", null))),
+        Arguments.argumentSet(
+            "sys set and undefined",
+            "key1: ${sys:str.1} ${sys:str.3}\n",
+            mapOf(entry("key1", "value1 "))),
+        Arguments.argumentSet(
+            "sys double-quoted hex string",
+            "key1: \"${sys:hex.prop}\"\n",
+            mapOf(entry("key1", "0xdeadbeef"))),
+        Arguments.argumentSet(
+            "sys double-quoted string", "key1: \"${sys:str.1}\"\n", mapOf(entry("key1", "value1"))),
+        Arguments.argumentSet(
+            "sys single-quoted string", "key1: '${sys:str.1}'\n", mapOf(entry("key1", "value1"))),
+        Arguments.argumentSet("sys foo.bar", "key1: ${sys:foo.bar}\n", mapOf(entry("key1", "BAR"))),
+        Arguments.argumentSet(
+            "sys double-dollar escape",
+            "key1: $${sys:foo.bar}\n",
+            mapOf(entry("key1", "${sys:foo.bar}"))),
+        Arguments.argumentSet(
+            "sys triple-dollar", "key1: $$${sys:foo.bar}\n", mapOf(entry("key1", "$BAR"))),
+        Arguments.argumentSet(
+            "sys quad-dollar escape",
+            "key1: $$$${sys:foo.bar}\n",
+            mapOf(entry("key1", "$${sys:foo.bar}"))),
+        Arguments.argumentSet(
+            "sys value with escape",
+            "key1: ${sys:value.with.escape}\n",
+            mapOf(entry("key1", "value$$"))));
   }
 
   @Test
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ExemplarFilterFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ExemplarFilterFactoryTest.java
index 46740e02791..3bc25741efd 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ExemplarFilterFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ExemplarFilterFactoryTest.java
@@ -27,8 +27,13 @@ void create(MeterProviderModel.ExemplarFilter model, ExemplarFilter expectedResu
 
   private static Stream<Arguments> createTestCases() {
     return Stream.of(
-        Arguments.of(MeterProviderModel.ExemplarFilter.ALWAYS_ON, ExemplarFilter.alwaysOn()),
-        Arguments.of(MeterProviderModel.ExemplarFilter.ALWAYS_OFF, ExemplarFilter.alwaysOff()),
-        Arguments.of(MeterProviderModel.ExemplarFilter.TRACE_BASED, ExemplarFilter.traceBased()));
+        Arguments.argumentSet(
+            "always_on", MeterProviderModel.ExemplarFilter.ALWAYS_ON, ExemplarFilter.alwaysOn()),
+        Arguments.argumentSet(
+            "always_off", MeterProviderModel.ExemplarFilter.ALWAYS_OFF, ExemplarFilter.alwaysOff()),
+        Arguments.argumentSet(
+            "trace_based",
+            MeterProviderModel.ExemplarFilter.TRACE_BASED,
+            ExemplarFilter.traceBased()));
   }
 }
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/IncludeExcludeFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/IncludeExcludeFactoryTest.java
index 06ae1c3da78..8beefb19036 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/IncludeExcludeFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/IncludeExcludeFactoryTest.java
@@ -34,22 +34,22 @@ void create(IncludeExcludeModel model, Predicate<String> expectedPredicate) {
 
   private static Stream<Arguments> createArguments() {
     return Stream.of(
-        // included null, excluded null
-        Arguments.of(
+        Arguments.argumentSet(
+            "both null",
             new IncludeExcludeModel().withIncluded(null).withExcluded(null),
             IncludeExcludePredicate.createPatternMatching(null, null)),
-        // included present, excluded null
-        Arguments.of(
+        Arguments.argumentSet(
+            "included present excluded null",
             new IncludeExcludeModel().withIncluded(Arrays.asList("foo", "bar")).withExcluded(null),
             IncludeExcludePredicate.createPatternMatching(Arrays.asList("foo", "bar"), null)),
-        // included null, excluded present
-        Arguments.of(
+        Arguments.argumentSet(
+            "included null excluded present",
             new IncludeExcludeModel()
                 .withIncluded(null)
                 .withExcluded(Collections.singletonList("baz")),
             IncludeExcludePredicate.createPatternMatching(null, Collections.singletonList("baz"))),
-        // both included and excluded present
-        Arguments.of(
+        Arguments.argumentSet(
+            "both present",
             new IncludeExcludeModel()
                 .withIncluded(Arrays.asList("foo", "bar"))
                 .withExcluded(Collections.singletonList("baz")),
@@ -67,10 +67,12 @@ void createInvalid(IncludeExcludeModel model, String expectedMessage) {
 
   private static Stream<Arguments> createInvalidArguments() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "included empty",
             new IncludeExcludeModel().withIncluded(Collections.emptyList()).withExcluded(null),
             "included must not be empty"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "excluded empty",
             new IncludeExcludeModel().withIncluded(null).withExcluded(Collections.emptyList()),
             "excluded must not be empty"));
   }
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LogLimitsFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LogLimitsFactoryTest.java
index fbb8b006db6..9eb4e6e6a59 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LogLimitsFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LogLimitsFactoryTest.java
@@ -27,20 +27,25 @@ void create(LogRecordLimitsAndAttributeLimits model, LogLimits expectedLogLimits
 
   private static Stream<Arguments> createArguments() {
     return Stream.of(
-        Arguments.of(
-            LogRecordLimitsAndAttributeLimits.create(null, null), LogLimits.builder().build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "null limits",
+            LogRecordLimitsAndAttributeLimits.create(null, null),
+            LogLimits.builder().build()),
+        Arguments.argumentSet(
+            "empty models",
             LogRecordLimitsAndAttributeLimits.create(
                 new AttributeLimitsModel(), new LogRecordLimitsModel()),
             LogLimits.builder().build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "attribute limits only",
             LogRecordLimitsAndAttributeLimits.create(
                 new AttributeLimitsModel()
                     .withAttributeValueLengthLimit(1)
                     .withAttributeCountLimit(2),
                 new LogRecordLimitsModel()),
             LogLimits.builder().setMaxAttributeValueLength(1).setMaxNumberOfAttributes(2).build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "log record limits override attribute limits",
             LogRecordLimitsAndAttributeLimits.create(
                 new AttributeLimitsModel()
                     .withAttributeValueLengthLimit(1)
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LogRecordProcessorFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LogRecordProcessorFactoryTest.java
index ffe85a928fe..9e2c313a5d7 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LogRecordProcessorFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LogRecordProcessorFactoryTest.java
@@ -55,7 +55,8 @@ void create(LogRecordProcessorModel model, LogRecordProcessor expectedProcessor)
 
   private static Stream<Arguments> createTestCases() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "batch otlp_http defaults",
             new LogRecordProcessorModel()
                 .withBatch(
                     new BatchLogRecordProcessorModel()
@@ -65,7 +66,8 @@ private static Stream<Arguments> createTestCases() {
             BatchLogRecordProcessor.builder(
                     OtlpHttpLogRecordExporter.builder().setComponentLoader(context).build())
                 .build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "batch otlp_http with options",
             new LogRecordProcessorModel()
                 .withBatch(
                     new BatchLogRecordProcessorModel()
@@ -80,7 +82,8 @@ private static Stream<Arguments> createTestCases() {
                 .setMaxExportBatchSize(2)
                 .setExporterTimeout(Duration.ofMillis(3))
                 .build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "simple otlp_http",
             new LogRecordProcessorModel()
                 .withSimple(
                     new SimpleLogRecordProcessorModel()
@@ -89,13 +92,15 @@ private static Stream<Arguments> createTestCases() {
                                 .withOtlpHttp(new OtlpHttpExporterModel()))),
             SimpleLogRecordProcessor.create(
                 OtlpHttpLogRecordExporter.builder().setComponentLoader(context).build())),
-        Arguments.of(
+        Arguments.argumentSet(
+            "event_to_span_event_bridge/development",
             new LogRecordProcessorModel()
                 .withAdditionalProperty(
                     "event_to_span_event_bridge/development",
                     new LogRecordProcessorPropertyModel()),
             EventToSpanEventBridge.create()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "spi test processor",
             new LogRecordProcessorModel()
                 .withAdditionalProperty("test", new LogRecordProcessorPropertyModel()),
             LogRecordProcessorComponentProvider.TestLogRecordProcessor.create()));
@@ -111,13 +116,16 @@ void create_Invalid(LogRecordProcessorModel model, String expectedMessage) {
 
   private static Stream<Arguments> createInvalidTestCases() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "batch missing exporter",
             new LogRecordProcessorModel().withBatch(new BatchLogRecordProcessorModel()),
             "batch log record processor exporter is required but is null"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "simple missing exporter",
             new LogRecordProcessorModel().withSimple(new SimpleLogRecordProcessorModel()),
             "simple log record processor exporter is required but is null"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "unknown component provider",
             new LogRecordProcessorModel()
                 .withAdditionalProperty(
                     "unknown_key",
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LoggerProviderFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LoggerProviderFactoryTest.java
index 12faa1bb108..91c1f1e2a70 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LoggerProviderFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/LoggerProviderFactoryTest.java
@@ -68,14 +68,17 @@ void create(LoggerProviderAndAttributeLimits model, SdkLoggerProvider expectedPr
 
   private static Stream<Arguments> createArguments() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "null limits",
             LoggerProviderAndAttributeLimits.create(null, null),
             SdkLoggerProvider.builder().build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "empty models",
             LoggerProviderAndAttributeLimits.create(
                 new AttributeLimitsModel(), new LoggerProviderModel()),
             SdkLoggerProvider.builder().build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "full configuration",
             LoggerProviderAndAttributeLimits.create(
                 new AttributeLimitsModel(),
                 new LoggerProviderModel()
@@ -137,29 +140,29 @@ void severityNumber(SeverityNumber model, Severity expectedSeverity) {
 
   private static Stream<Arguments> severityNumberArguments() {
     return Stream.of(
-        Arguments.of(SeverityNumber.TRACE, Severity.TRACE),
-        Arguments.of(SeverityNumber.TRACE_2, Severity.TRACE2),
-        Arguments.of(SeverityNumber.TRACE_3, Severity.TRACE3),
-        Arguments.of(SeverityNumber.TRACE_4, Severity.TRACE4),
-        Arguments.of(SeverityNumber.DEBUG, Severity.DEBUG),
-        Arguments.of(SeverityNumber.DEBUG_2, Severity.DEBUG2),
-        Arguments.of(SeverityNumber.DEBUG_3, Severity.DEBUG3),
-        Arguments.of(SeverityNumber.DEBUG_4, Severity.DEBUG4),
-        Arguments.of(SeverityNumber.INFO, Severity.INFO),
-        Arguments.of(SeverityNumber.INFO_2, Severity.INFO2),
-        Arguments.of(SeverityNumber.INFO_3, Severity.INFO3),
-        Arguments.of(SeverityNumber.INFO_4, Severity.INFO4),
-        Arguments.of(SeverityNumber.WARN, Severity.WARN),
-        Arguments.of(SeverityNumber.WARN_2, Severity.WARN2),
-        Arguments.of(SeverityNumber.WARN_3, Severity.WARN3),
-        Arguments.of(SeverityNumber.WARN_4, Severity.WARN4),
-        Arguments.of(SeverityNumber.ERROR, Severity.ERROR),
-        Arguments.of(SeverityNumber.ERROR_2, Severity.ERROR2),
-        Arguments.of(SeverityNumber.ERROR_3, Severity.ERROR3),
-        Arguments.of(SeverityNumber.ERROR_4, Severity.ERROR4),
-        Arguments.of(SeverityNumber.FATAL, Severity.FATAL),
-        Arguments.of(SeverityNumber.FATAL_2, Severity.FATAL2),
-        Arguments.of(SeverityNumber.FATAL_3, Severity.FATAL3),
-        Arguments.of(SeverityNumber.FATAL_4, Severity.FATAL4));
+        Arguments.argumentSet("TRACE", SeverityNumber.TRACE, Severity.TRACE),
+        Arguments.argumentSet("TRACE_2", SeverityNumber.TRACE_2, Severity.TRACE2),
+        Arguments.argumentSet("TRACE_3", SeverityNumber.TRACE_3, Severity.TRACE3),
+        Arguments.argumentSet("TRACE_4", SeverityNumber.TRACE_4, Severity.TRACE4),
+        Arguments.argumentSet("DEBUG", SeverityNumber.DEBUG, Severity.DEBUG),
+        Arguments.argumentSet("DEBUG_2", SeverityNumber.DEBUG_2, Severity.DEBUG2),
+        Arguments.argumentSet("DEBUG_3", SeverityNumber.DEBUG_3, Severity.DEBUG3),
+        Arguments.argumentSet("DEBUG_4", SeverityNumber.DEBUG_4, Severity.DEBUG4),
+        Arguments.argumentSet("INFO", SeverityNumber.INFO, Severity.INFO),
+        Arguments.argumentSet("INFO_2", SeverityNumber.INFO_2, Severity.INFO2),
+        Arguments.argumentSet("INFO_3", SeverityNumber.INFO_3, Severity.INFO3),
+        Arguments.argumentSet("INFO_4", SeverityNumber.INFO_4, Severity.INFO4),
+        Arguments.argumentSet("WARN", SeverityNumber.WARN, Severity.WARN),
+        Arguments.argumentSet("WARN_2", SeverityNumber.WARN_2, Severity.WARN2),
+        Arguments.argumentSet("WARN_3", SeverityNumber.WARN_3, Severity.WARN3),
+        Arguments.argumentSet("WARN_4", SeverityNumber.WARN_4, Severity.WARN4),
+        Arguments.argumentSet("ERROR", SeverityNumber.ERROR, Severity.ERROR),
+        Arguments.argumentSet("ERROR_2", SeverityNumber.ERROR_2, Severity.ERROR2),
+        Arguments.argumentSet("ERROR_3", SeverityNumber.ERROR_3, Severity.ERROR3),
+        Arguments.argumentSet("ERROR_4", SeverityNumber.ERROR_4, Severity.ERROR4),
+        Arguments.argumentSet("FATAL", SeverityNumber.FATAL, Severity.FATAL),
+        Arguments.argumentSet("FATAL_2", SeverityNumber.FATAL_2, Severity.FATAL2),
+        Arguments.argumentSet("FATAL_3", SeverityNumber.FATAL_3, Severity.FATAL3),
+        Arguments.argumentSet("FATAL_4", SeverityNumber.FATAL_4, Severity.FATAL4));
   }
 }
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/MeterProviderFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/MeterProviderFactoryTest.java
index 2b842be6f24..a49c88f3e8f 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/MeterProviderFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/MeterProviderFactoryTest.java
@@ -69,8 +69,10 @@ void create(MeterProviderModel model, SdkMeterProvider expectedProvider) {
 
   private static Stream<Arguments> createArguments() {
     return Stream.of(
-        Arguments.of(new MeterProviderModel(), SdkMeterProvider.builder().build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "defaults", new MeterProviderModel(), SdkMeterProvider.builder().build()),
+        Arguments.argumentSet(
+            "with reader view and meter configurator",
             new MeterProviderModel()
                 .withReaders(
                     Collections.singletonList(
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/OpenTelemetryConfigurationFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/OpenTelemetryConfigurationFactoryTest.java
index e821ca587f8..8ea38490d67 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/OpenTelemetryConfigurationFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/OpenTelemetryConfigurationFactoryTest.java
@@ -119,22 +119,20 @@ void create_FileFormat(String fileFormat, boolean isValid) {
 
   private static Stream<Arguments> fileFormatArgs() {
     return Stream.of(
-        // Invalid file formats
-        Arguments.of(null, false),
-        Arguments.of("0.3", false),
-        Arguments.of("a0.4", false),
-        Arguments.of("0.4a", false),
-        Arguments.of("foo", false),
-        Arguments.of("1.0-rc.a", false),
-        Arguments.of("1.0.0", false),
-        Arguments.of("1.0.3", false),
-        Arguments.of("1.0.0-rc.3", false),
-        // Valid file formats
-        Arguments.of("0.4", true),
-        Arguments.of("1.0-rc.1", true),
-        Arguments.of("1.0-rc.2", true),
-        Arguments.of("1.0-rc.3", true),
-        Arguments.of("1.0", true));
+        Arguments.argumentSet("null invalid", null, false),
+        Arguments.argumentSet("0.3 invalid", "0.3", false),
+        Arguments.argumentSet("a0.4 invalid", "a0.4", false),
+        Arguments.argumentSet("0.4a invalid", "0.4a", false),
+        Arguments.argumentSet("foo invalid", "foo", false),
+        Arguments.argumentSet("1.0-rc.a invalid", "1.0-rc.a", false),
+        Arguments.argumentSet("1.0.0 invalid", "1.0.0", false),
+        Arguments.argumentSet("1.0.3 invalid", "1.0.3", false),
+        Arguments.argumentSet("1.0.0-rc.3 invalid", "1.0.0-rc.3", false),
+        Arguments.argumentSet("0.4 valid", "0.4", true),
+        Arguments.argumentSet("1.0-rc.1 valid", "1.0-rc.1", true),
+        Arguments.argumentSet("1.0-rc.2 valid", "1.0-rc.2", true),
+        Arguments.argumentSet("1.0-rc.3 valid", "1.0-rc.3", true),
+        Arguments.argumentSet("1.0 valid", "1.0", true));
   }
 
   @Test
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/PropagatorFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/PropagatorFactoryTest.java
index 6c351c4fb12..cea489ee45b 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/PropagatorFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/PropagatorFactoryTest.java
@@ -46,8 +46,8 @@ void create(PropagatorModel model, ContextPropagators expectedPropagators) {
 
   private static Stream<Arguments> createArguments() {
     return Stream.of(
-        // structured list
-        Arguments.of(
+        Arguments.argumentSet(
+            "structured list",
             new PropagatorModel()
                 .withComposite(
                     Arrays.asList(
@@ -62,8 +62,8 @@ private static Stream<Arguments> createArguments() {
                     W3CBaggagePropagator.getInstance(),
                     B3Propagator.injectingMultiHeaders(),
                     B3Propagator.injectingSingleHeader()))),
-        // string list
-        Arguments.of(
+        Arguments.argumentSet(
+            "string list",
             new PropagatorModel().withCompositeList("tracecontext,baggage,b3multi,b3 ,none"),
             ContextPropagators.create(
                 TextMapPropagator.composite(
@@ -71,8 +71,8 @@ private static Stream<Arguments> createArguments() {
                     W3CBaggagePropagator.getInstance(),
                     B3Propagator.injectingMultiHeaders(),
                     B3Propagator.injectingSingleHeader()))),
-        // structured list and string list
-        Arguments.of(
+        Arguments.argumentSet(
+            "structured list and string list",
             new PropagatorModel()
                 .withComposite(
                     Arrays.asList(
@@ -86,8 +86,8 @@ private static Stream<Arguments> createArguments() {
                     W3CBaggagePropagator.getInstance(),
                     B3Propagator.injectingMultiHeaders(),
                     B3Propagator.injectingSingleHeader()))),
-        // structured list and string list with overlap
-        Arguments.of(
+        Arguments.argumentSet(
+            "structured list and string list with overlap",
             new PropagatorModel()
                 .withComposite(
                     Arrays.asList(
@@ -101,8 +101,8 @@ private static Stream<Arguments> createArguments() {
                     W3CBaggagePropagator.getInstance(),
                     B3Propagator.injectingMultiHeaders(),
                     B3Propagator.injectingSingleHeader()))),
-        // spi
-        Arguments.of(
+        Arguments.argumentSet(
+            "spi structured list",
             new PropagatorModel()
                 .withComposite(
                     Collections.singletonList(
@@ -111,7 +111,8 @@ private static Stream<Arguments> createArguments() {
                 TextMapPropagator.composite(
                     new TextMapPropagatorComponentProvider.TestTextMapPropagator(
                         DeclarativeConfigProperties.empty())))),
-        Arguments.of(
+        Arguments.argumentSet(
+            "spi string list",
             new PropagatorModel().withCompositeList("test"),
             ContextPropagators.create(
                 TextMapPropagator.composite(
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ResourceFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ResourceFactoryTest.java
index a3877112bca..201382ccd85 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ResourceFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ResourceFactoryTest.java
@@ -38,7 +38,8 @@ void create(ResourceModel model, Resource expectedResource) {
 
   private static Stream<Arguments> createArgs() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "with attributes",
             new ResourceModel()
                 .withAttributes(
                     Arrays.asList(
@@ -52,10 +53,12 @@ private static Stream<Arguments> createArgs() {
                 .put("service.name", "my-service")
                 .put("key", "val")
                 .build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "with schema url",
             new ResourceModel().withSchemaUrl("http://foo"),
             Resource.getDefault().toBuilder().setSchemaUrl("http://foo").build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "with attributes list",
             new ResourceModel().withAttributesList("key1=val1,key2=val2"),
             Resource.getDefault().toBuilder().put("key1", "val1").put("key2", "val2").build()));
   }
@@ -84,7 +87,8 @@ void createWithDetectors(
 
   private static Stream<Arguments> createWithDetectorsArgs() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "no filters",
             null,
             null,
             Resource.getDefault().toBuilder()
@@ -92,60 +96,72 @@ private static Stream<Arguments> createWithDetectorsArgs() {
                 .put("shape", "square")
                 .put("order", "second")
                 .build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "include color",
             Collections.singletonList("color"),
             null,
             Resource.getDefault().toBuilder().put("color", "red").build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "include color shape",
             Arrays.asList("color", "shape"),
             null,
             Resource.getDefault().toBuilder().put("color", "red").put("shape", "square").build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "exclude color",
             null,
             Collections.singletonList("color"),
             Resource.getDefault().toBuilder()
                 .put("shape", "square")
                 .put("order", "second")
                 .build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "exclude color shape",
             null,
             Arrays.asList("color", "shape"),
             Resource.getDefault().toBuilder().put("order", "second").build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "include and exclude same",
             Collections.singletonList("color"),
             Collections.singletonList("color"),
             Resource.getDefault().toBuilder().build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "include color shape exclude color",
             Arrays.asList("color", "shape"),
             Collections.singletonList("color"),
             Resource.getDefault().toBuilder().put("shape", "square").build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "include c* glob",
             Collections.singletonList("c*"),
             null,
             Resource.getDefault().toBuilder().put("color", "red").build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "include c?lor glob",
             Collections.singletonList("c?lor"),
             null,
             Resource.getDefault().toBuilder().put("color", "red").build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "exclude c* glob",
             null,
             Collections.singletonList("c*"),
             Resource.getDefault().toBuilder()
                 .put("shape", "square")
                 .put("order", "second")
                 .build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "exclude c?lor glob",
             null,
             Collections.singletonList("c?lor"),
             Resource.getDefault().toBuilder()
                 .put("shape", "square")
                 .put("order", "second")
                 .build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "include *o* exclude order",
             Collections.singletonList("*o*"),
             Collections.singletonList("order"),
             Resource.getDefault().toBuilder().put("color", "red").build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "exclude order",
             null,
             Collections.singletonList("order"),
             Resource.getDefault().toBuilder().put("color", "red").put("shape", "square").build()));
@@ -161,7 +177,8 @@ void createWithDetectors_Invalid(ResourceModel model, String expectedMessage) {
 
   private static Stream<Arguments> createInvalidDetectorsArgs() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "unknown detector",
             new ResourceModel()
                 .withDetectionDevelopment(
                     new ExperimentalResourceDetectionModel()
@@ -170,7 +187,8 @@ private static Stream<Arguments> createInvalidDetectorsArgs() {
                                 new ExperimentalResourceDetectorModel()
                                     .withAdditionalProperty("foo", null)))),
             "No component provider detected for io.opentelemetry.sdk.resources.Resource with name \"foo\"."),
-        Arguments.of(
+        Arguments.argumentSet(
+            "detector multiple entries",
             new ResourceModel()
                 .withDetectionDevelopment(
                     new ExperimentalResourceDetectionModel()
@@ -180,14 +198,16 @@ private static Stream<Arguments> createInvalidDetectorsArgs() {
                                     .withAdditionalProperty("foo", null)
                                     .withAdditionalProperty("bar", null)))),
             "resource detector must have exactly one entry but has 2: [foo,bar]"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "detector no entries",
             new ResourceModel()
                 .withDetectionDevelopment(
                     new ExperimentalResourceDetectionModel()
                         .withDetectors(
                             Collections.singletonList(new ExperimentalResourceDetectorModel()))),
             "resource detector must have exactly one entry but has 0"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "included empty list",
             new ResourceModel()
                 .withDetectionDevelopment(
                     new ExperimentalResourceDetectionModel()
@@ -196,7 +216,8 @@ private static Stream<Arguments> createInvalidDetectorsArgs() {
                                 .withIncluded(Collections.emptyList())
                                 .withExcluded(null))),
             "included must not be empty"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "excluded empty list",
             new ResourceModel()
                 .withDetectionDevelopment(
                     new ExperimentalResourceDetectionModel()
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/SpanLimitsFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/SpanLimitsFactoryTest.java
index 17728942e3e..7bd5a85f2b6 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/SpanLimitsFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/SpanLimitsFactoryTest.java
@@ -27,18 +27,24 @@ void create(SpanLimitsAndAttributeLimits model, SpanLimits expectedSpanLimits) {
 
   private static Stream<Arguments> createArguments() {
     return Stream.of(
-        Arguments.of(SpanLimitsAndAttributeLimits.create(null, null), SpanLimits.getDefault()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "null limits",
+            SpanLimitsAndAttributeLimits.create(null, null),
+            SpanLimits.getDefault()),
+        Arguments.argumentSet(
+            "empty models",
             SpanLimitsAndAttributeLimits.create(new AttributeLimitsModel(), new SpanLimitsModel()),
             SpanLimits.getDefault()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "attribute limits only",
             SpanLimitsAndAttributeLimits.create(
                 new AttributeLimitsModel()
                     .withAttributeCountLimit(1)
                     .withAttributeValueLengthLimit(2),
                 new SpanLimitsModel()),
             SpanLimits.builder().setMaxNumberOfAttributes(1).setMaxAttributeValueLength(2).build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "span limits override attribute limits",
             SpanLimitsAndAttributeLimits.create(
                 new AttributeLimitsModel()
                     .withAttributeCountLimit(1)
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/TracerProviderFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/TracerProviderFactoryTest.java
index 64878d5c9d4..9ea52a7ebc1 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/TracerProviderFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/TracerProviderFactoryTest.java
@@ -70,14 +70,17 @@ void create(TracerProviderAndAttributeLimits model, SdkTracerProvider expectedPr
 
   private static Stream<Arguments> createArguments() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "null limits",
             TracerProviderAndAttributeLimits.create(null, null),
             SdkTracerProvider.builder().build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "empty models",
             TracerProviderAndAttributeLimits.create(
                 new AttributeLimitsModel(), new TracerProviderModel()),
             SdkTracerProvider.builder().build()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "full configuration",
             TracerProviderAndAttributeLimits.create(
                 new AttributeLimitsModel(),
                 new TracerProviderModel()
diff --git a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ViewFactoryTest.java b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ViewFactoryTest.java
index a8c69e1c444..35904d23bf8 100644
--- a/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ViewFactoryTest.java
+++ b/sdk-extensions/declarative-config/src/test/java/io/opentelemetry/sdk/autoconfigure/declarativeconfig/ViewFactoryTest.java
@@ -34,11 +34,11 @@ void create(ViewStreamModel model, View expectedView) {
 
   private static Stream<Arguments> createArguments() {
     return Stream.of(
-        // defaults
-        Arguments.of(new ViewStreamModel().withAttributeKeys(null), View.builder().build()),
-        // attribute_keys with only included (no excluded) - reproduces
+        Arguments.argumentSet(
+            "defaults", new ViewStreamModel().withAttributeKeys(null), View.builder().build()),
         // https://github.com/open-telemetry/opentelemetry-java/issues/8337
-        Arguments.of(
+        Arguments.argumentSet(
+            "included only no excluded",
             new ViewStreamModel()
                 .withAttributeKeys(
                     new IncludeExcludeModel()
@@ -52,8 +52,8 @@ private static Stream<Arguments> createArguments() {
                             "url.full", "http.request.method", "http.response.status_code"),
                         null))
                 .build()),
-        // full configuration
-        Arguments.of(
+        Arguments.argumentSet(
+            "full configuration",
             new ViewStreamModel()
                 .withName("name")
                 .withDescription("description")
diff --git a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/resources/ServiceInstanceIdResourceProviderTest.java b/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/resources/ServiceInstanceIdResourceProviderTest.java
index 59acb29e2dd..b359b9fbcf0 100644
--- a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/resources/ServiceInstanceIdResourceProviderTest.java
+++ b/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/resources/ServiceInstanceIdResourceProviderTest.java
@@ -15,57 +15,38 @@
 import java.util.Collections;
 import java.util.Map;
 import java.util.stream.Stream;
-import org.junit.jupiter.api.DynamicTest;
-import org.junit.jupiter.api.TestFactory;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class ServiceInstanceIdResourceProviderTest {
 
-  private static class TestCase {
-    private final String name;
-    final String expectedValue;
-    final Map<String, String> attributes;
-
-    TestCase(String name, String expectedValue, Map<String, String> attributes) {
-      this.name = name;
-      this.expectedValue = expectedValue;
-      this.attributes = attributes;
+  @ParameterizedTest
+  @MethodSource("createResourceTestCases")
+  void createResource(String expectedValue, Map<String, String> attributes) {
+    ServiceInstanceIdResourceProvider provider = new ServiceInstanceIdResourceProvider();
+    DefaultConfigProperties config = DefaultConfigProperties.createFromMap(Collections.emptyMap());
+    AttributesBuilder builder = Attributes.builder();
+    attributes.forEach(builder::put);
+    Resource existing = Resource.create(builder.build());
+    Resource resource =
+        provider.shouldApply(config, existing) ? provider.createResource(config) : Resource.empty();
+
+    String actual =
+        resource.getAttributes().get(ServiceInstanceIdResourceProvider.SERVICE_INSTANCE_ID);
+    if ("random".equals(expectedValue)) {
+      assertThat(actual).isNotNull();
+    } else {
+      assertThat(actual).isEqualTo(expectedValue);
     }
   }
 
-  @TestFactory
-  Stream<DynamicTest> createResource() {
+  static Stream<Arguments> createResourceTestCases() {
     return Stream.of(
-            new TestCase(
-                "user provided service.instance.id",
-                null,
-                ImmutableMap.of("service.instance.id", "custom")),
-            new TestCase("random value", "random", Collections.emptyMap()))
-        .map(
-            testCase ->
-                DynamicTest.dynamicTest(
-                    testCase.name,
-                    () -> {
-                      ServiceInstanceIdResourceProvider provider =
-                          new ServiceInstanceIdResourceProvider();
-                      DefaultConfigProperties config =
-                          DefaultConfigProperties.createFromMap(Collections.emptyMap());
-                      AttributesBuilder builder = Attributes.builder();
-                      testCase.attributes.forEach(builder::put);
-                      Resource existing = Resource.create(builder.build());
-                      Resource resource =
-                          provider.shouldApply(config, existing)
-                              ? provider.createResource(config)
-                              : Resource.empty();
-
-                      String actual =
-                          resource
-                              .getAttributes()
-                              .get(ServiceInstanceIdResourceProvider.SERVICE_INSTANCE_ID);
-                      if ("random".equals(testCase.expectedValue)) {
-                        assertThat(actual).isNotNull();
-                      } else {
-                        assertThat(actual).isEqualTo(testCase.expectedValue);
-                      }
-                    }));
+        Arguments.argumentSet(
+            "user provided service.instance.id",
+            null,
+            ImmutableMap.of("service.instance.id", "custom")),
+        Arguments.argumentSet("random value", "random", Collections.emptyMap()));
   }
 }
diff --git a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/trace/samplers/AlwaysRecordSamplerTest.java b/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/trace/samplers/AlwaysRecordSamplerTest.java
index 3def58d5e77..3f362946a23 100644
--- a/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/trace/samplers/AlwaysRecordSamplerTest.java
+++ b/sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/trace/samplers/AlwaysRecordSamplerTest.java
@@ -54,9 +54,14 @@ void getDescription() {
 
   private static Stream<Arguments> expectedSamplingDecisionArgs() {
     return Stream.of(
-        Arguments.of(SamplingDecision.RECORD_AND_SAMPLE, SamplingDecision.RECORD_AND_SAMPLE),
-        Arguments.of(SamplingDecision.RECORD_ONLY, SamplingDecision.RECORD_ONLY),
-        Arguments.of(SamplingDecision.DROP, SamplingDecision.RECORD_ONLY));
+        Arguments.argumentSet(
+            "RECORD_AND_SAMPLE",
+            SamplingDecision.RECORD_AND_SAMPLE,
+            SamplingDecision.RECORD_AND_SAMPLE),
+        Arguments.argumentSet(
+            "RECORD_ONLY", SamplingDecision.RECORD_ONLY, SamplingDecision.RECORD_ONLY),
+        Arguments.argumentSet(
+            "DROP becomes RECORD_ONLY", SamplingDecision.DROP, SamplingDecision.RECORD_ONLY));
   }
 
   @ParameterizedTest
diff --git a/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/DefaultExceptionAttributeResolverTest.java b/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/DefaultExceptionAttributeResolverTest.java
index 167e650ed24..266a3904225 100644
--- a/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/DefaultExceptionAttributeResolverTest.java
+++ b/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/DefaultExceptionAttributeResolverTest.java
@@ -52,16 +52,16 @@ public <T> void setAttribute(AttributeKey<T> key, @Nullable T value) {
 
   private static Stream<Arguments> setExceptionAttributesArgs() {
     return Stream.of(
-        // When jvmStacktraceEnabled=true, limit is ignored
-        Arguments.of(
+        Arguments.argumentSet(
+            "jvm stacktrace enabled limit ignored",
             true,
             new Exception("error"),
             10,
             "error",
             "java.lang.Exception",
             predicate(stacktrace -> stacktrace.length() > 10)),
-        // When jvmStacktraceEnabled=false, limit is adhered
-        Arguments.of(
+        Arguments.argumentSet(
+            "jvm stacktrace disabled limit adhered",
             false,
             new Exception("error"),
             10,
diff --git a/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/GlobUtilTest.java b/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/GlobUtilTest.java
index 1d8fb2a9bd8..c6daefba602 100644
--- a/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/GlobUtilTest.java
+++ b/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/GlobUtilTest.java
@@ -23,37 +23,38 @@ void matchesName(String globPattern, String testString, boolean isMatchExpected)
 
   private static Stream<Arguments> globPatternPredicateArgs() {
     return Stream.of(
-        Arguments.of("foo", "foo", true),
-        Arguments.of("foo", "Foo", false),
-        Arguments.of("foo", "bar", false),
-        Arguments.of("fo?", "foo", true),
-        Arguments.of("fo??", "fooo", true),
-        Arguments.of("fo?", "fob", true),
-        Arguments.of("fo?", "fooo", false),
-        Arguments.of("*", "foo", true),
-        Arguments.of("*", "bar", true),
-        Arguments.of("*", "baz", true),
-        Arguments.of("*", "foo.bar.baz", true),
-        Arguments.of("*", null, true),
-        Arguments.of("*", "", true),
-        Arguments.of("fo*", "fo", true),
-        Arguments.of("fo*", "foo", true),
-        Arguments.of("fo*", "foO", true),
-        Arguments.of("fo*", "FOO", false),
-        Arguments.of("fo*", "fooo", true),
-        Arguments.of("fo*", "foo.bar.baz", true),
-        Arguments.of("*bar", "sandbar", true),
-        Arguments.of("fo*b*", "foobar", true),
-        Arguments.of("fo*b*", "foob", true),
-        Arguments.of("fo*b*", "foo bar", true),
-        Arguments.of("fo? b??", "foo bar", true),
-        Arguments.of("fo? b??", "foO bAR", true),
-        Arguments.of("fo? b??", "FOO BAR", false),
-        Arguments.of("fo? b??", "fooo bar", false),
-        Arguments.of("fo* ba?", "foo is not bar", true),
-        Arguments.of("fo? b*", "fox beetles for lunch", true),
-        Arguments.of("f()[]$^.{}|", "f()[]$^.{}|", true),
-        Arguments.of("f()[]$^.{}|?", "f()[]$^.{}|o", true),
-        Arguments.of("f()[]$^.{}|*", "f()[]$^.{}|ooo", true));
+        Arguments.argumentSet("foo matches foo", "foo", "foo", true),
+        Arguments.argumentSet("foo no match Foo", "foo", "Foo", false),
+        Arguments.argumentSet("foo no match bar", "foo", "bar", false),
+        Arguments.argumentSet("fo? matches foo", "fo?", "foo", true),
+        Arguments.argumentSet("fo?? matches fooo", "fo??", "fooo", true),
+        Arguments.argumentSet("fo? matches fob", "fo?", "fob", true),
+        Arguments.argumentSet("fo? no match fooo", "fo?", "fooo", false),
+        Arguments.argumentSet("* matches foo", "*", "foo", true),
+        Arguments.argumentSet("* matches bar", "*", "bar", true),
+        Arguments.argumentSet("* matches baz", "*", "baz", true),
+        Arguments.argumentSet("* matches foo.bar.baz", "*", "foo.bar.baz", true),
+        Arguments.argumentSet("* matches null", "*", null, true),
+        Arguments.argumentSet("* matches empty", "*", "", true),
+        Arguments.argumentSet("fo* matches fo", "fo*", "fo", true),
+        Arguments.argumentSet("fo* matches foo", "fo*", "foo", true),
+        Arguments.argumentSet("fo* matches foO", "fo*", "foO", true),
+        Arguments.argumentSet("fo* no match FOO", "fo*", "FOO", false),
+        Arguments.argumentSet("fo* matches fooo", "fo*", "fooo", true),
+        Arguments.argumentSet("fo* matches foo.bar.baz", "fo*", "foo.bar.baz", true),
+        Arguments.argumentSet("*bar matches sandbar", "*bar", "sandbar", true),
+        Arguments.argumentSet("fo*b* matches foobar", "fo*b*", "foobar", true),
+        Arguments.argumentSet("fo*b* matches foob", "fo*b*", "foob", true),
+        Arguments.argumentSet("fo*b* matches foo bar", "fo*b*", "foo bar", true),
+        Arguments.argumentSet("fo? b?? matches foo bar", "fo? b??", "foo bar", true),
+        Arguments.argumentSet("fo? b?? matches foO bAR", "fo? b??", "foO bAR", true),
+        Arguments.argumentSet("fo? b?? no match FOO BAR", "fo? b??", "FOO BAR", false),
+        Arguments.argumentSet("fo? b?? no match fooo bar", "fo? b??", "fooo bar", false),
+        Arguments.argumentSet("fo* ba? matches foo is not bar", "fo* ba?", "foo is not bar", true),
+        Arguments.argumentSet(
+            "fo? b* matches fox beetles for lunch", "fo? b*", "fox beetles for lunch", true),
+        Arguments.argumentSet("special chars literal", "f()[]$^.{}|", "f()[]$^.{}|", true),
+        Arguments.argumentSet("special chars with ?", "f()[]$^.{}|?", "f()[]$^.{}|o", true),
+        Arguments.argumentSet("special chars with *", "f()[]$^.{}|*", "f()[]$^.{}|ooo", true));
   }
 }
diff --git a/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/IncludeExcludePredicateTest.java b/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/IncludeExcludePredicateTest.java
index d1d0859cb34..0d4e0376501 100644
--- a/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/IncludeExcludePredicateTest.java
+++ b/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/IncludeExcludePredicateTest.java
@@ -48,63 +48,62 @@ void test(Predicate<String> predicate, String testCase, boolean expectedResult)
 
   private static Stream<Arguments> testArgs() {
     return Stream.of(
-        // exact matching
-        // include only
-        Arguments.of(EXACT_INCLUDE, "foo", true),
-        Arguments.of(EXACT_INCLUDE, "bar", false),
-        Arguments.of(EXACT_INCLUDE, "baz", false),
-        Arguments.of(EXACT_INCLUDE, "Foo", false),
-        Arguments.of(EXACT_INCLUDE, "FOO", false),
-        // exclude only
-        Arguments.of(EXACT_EXCLUDE, "foo", true),
-        Arguments.of(EXACT_EXCLUDE, "bar", false),
-        Arguments.of(EXACT_EXCLUDE, "baz", true),
-        Arguments.of(EXACT_EXCLUDE, "Bar", true),
-        Arguments.of(EXACT_EXCLUDE, "BAR", true),
-        // include and exclude
-        Arguments.of(EXACT_INCLUDE_AND_EXCLUDE, "foo", true),
-        Arguments.of(EXACT_INCLUDE_AND_EXCLUDE, "Foo", false),
-        Arguments.of(EXACT_INCLUDE_AND_EXCLUDE, "FOO", false),
-        Arguments.of(EXACT_INCLUDE_AND_EXCLUDE, "bar", false),
-        Arguments.of(EXACT_INCLUDE_AND_EXCLUDE, "baz", false),
-        // multi
-        Arguments.of(EXACT_MULTI, "foo", true),
-        Arguments.of(EXACT_MULTI, "fooo", true),
-        Arguments.of(EXACT_MULTI, "Foo", false),
-        Arguments.of(EXACT_MULTI, "FOO", false),
-        Arguments.of(EXACT_MULTI, "bar", false),
-        Arguments.of(EXACT_MULTI, "barr", false),
-        Arguments.of(EXACT_MULTI, "baz", false),
-        // pattern matching
-        // include only
-        Arguments.of(PATTERN_INCLUDE, "foo", true),
-        Arguments.of(PATTERN_INCLUDE, "fOo", true),
-        Arguments.of(PATTERN_INCLUDE, "Foo", false),
-        Arguments.of(PATTERN_INCLUDE, "bar", false),
-        Arguments.of(PATTERN_INCLUDE, "baz", false),
-        // exclude only
-        Arguments.of(PATTERN_EXCLUDE, "foo", true),
-        Arguments.of(PATTERN_EXCLUDE, "bar", false),
-        Arguments.of(PATTERN_EXCLUDE, "bAr", false),
-        Arguments.of(PATTERN_EXCLUDE, "Bar", true),
-        Arguments.of(PATTERN_EXCLUDE, "BAR", true),
-        Arguments.of(PATTERN_EXCLUDE, "baz", true),
-        // include and exclude
-        Arguments.of(PATTERN_INCLUDE_AND_EXCLUDE, "foo", true),
-        Arguments.of(PATTERN_INCLUDE_AND_EXCLUDE, "fOo", true),
-        Arguments.of(PATTERN_INCLUDE_AND_EXCLUDE, "FOO", false),
-        Arguments.of(PATTERN_INCLUDE_AND_EXCLUDE, "bar", false),
-        Arguments.of(PATTERN_INCLUDE_AND_EXCLUDE, "baz", false),
-        // multi
-        Arguments.of(PATTERN_MULTI, "foo", true),
-        Arguments.of(PATTERN_MULTI, "fooo", true),
-        Arguments.of(PATTERN_MULTI, "fOo", true),
-        Arguments.of(PATTERN_MULTI, "FOO", false),
-        Arguments.of(PATTERN_MULTI, "bar", false),
-        Arguments.of(PATTERN_MULTI, "bAr", false),
-        Arguments.of(PATTERN_MULTI, "barr", false),
-        Arguments.of(PATTERN_MULTI, "bArr", false),
-        Arguments.of(PATTERN_MULTI, "baz", false));
+        Arguments.argumentSet("exact include foo", EXACT_INCLUDE, "foo", true),
+        Arguments.argumentSet("exact include bar no match", EXACT_INCLUDE, "bar", false),
+        Arguments.argumentSet("exact include baz no match", EXACT_INCLUDE, "baz", false),
+        Arguments.argumentSet("exact include Foo no match", EXACT_INCLUDE, "Foo", false),
+        Arguments.argumentSet("exact include FOO no match", EXACT_INCLUDE, "FOO", false),
+        Arguments.argumentSet("exact exclude foo", EXACT_EXCLUDE, "foo", true),
+        Arguments.argumentSet("exact exclude bar no match", EXACT_EXCLUDE, "bar", false),
+        Arguments.argumentSet("exact exclude baz", EXACT_EXCLUDE, "baz", true),
+        Arguments.argumentSet("exact exclude Bar", EXACT_EXCLUDE, "Bar", true),
+        Arguments.argumentSet("exact exclude BAR", EXACT_EXCLUDE, "BAR", true),
+        Arguments.argumentSet("exact include+exclude foo", EXACT_INCLUDE_AND_EXCLUDE, "foo", true),
+        Arguments.argumentSet(
+            "exact include+exclude Foo no match", EXACT_INCLUDE_AND_EXCLUDE, "Foo", false),
+        Arguments.argumentSet(
+            "exact include+exclude FOO no match", EXACT_INCLUDE_AND_EXCLUDE, "FOO", false),
+        Arguments.argumentSet(
+            "exact include+exclude bar no match", EXACT_INCLUDE_AND_EXCLUDE, "bar", false),
+        Arguments.argumentSet(
+            "exact include+exclude baz no match", EXACT_INCLUDE_AND_EXCLUDE, "baz", false),
+        Arguments.argumentSet("exact multi foo", EXACT_MULTI, "foo", true),
+        Arguments.argumentSet("exact multi fooo", EXACT_MULTI, "fooo", true),
+        Arguments.argumentSet("exact multi Foo no match", EXACT_MULTI, "Foo", false),
+        Arguments.argumentSet("exact multi FOO no match", EXACT_MULTI, "FOO", false),
+        Arguments.argumentSet("exact multi bar no match", EXACT_MULTI, "bar", false),
+        Arguments.argumentSet("exact multi barr no match", EXACT_MULTI, "barr", false),
+        Arguments.argumentSet("exact multi baz no match", EXACT_MULTI, "baz", false),
+        Arguments.argumentSet("pattern include foo", PATTERN_INCLUDE, "foo", true),
+        Arguments.argumentSet("pattern include fOo", PATTERN_INCLUDE, "fOo", true),
+        Arguments.argumentSet("pattern include Foo no match", PATTERN_INCLUDE, "Foo", false),
+        Arguments.argumentSet("pattern include bar no match", PATTERN_INCLUDE, "bar", false),
+        Arguments.argumentSet("pattern include baz no match", PATTERN_INCLUDE, "baz", false),
+        Arguments.argumentSet("pattern exclude foo", PATTERN_EXCLUDE, "foo", true),
+        Arguments.argumentSet("pattern exclude bar no match", PATTERN_EXCLUDE, "bar", false),
+        Arguments.argumentSet("pattern exclude bAr no match", PATTERN_EXCLUDE, "bAr", false),
+        Arguments.argumentSet("pattern exclude Bar", PATTERN_EXCLUDE, "Bar", true),
+        Arguments.argumentSet("pattern exclude BAR", PATTERN_EXCLUDE, "BAR", true),
+        Arguments.argumentSet("pattern exclude baz", PATTERN_EXCLUDE, "baz", true),
+        Arguments.argumentSet(
+            "pattern include+exclude foo", PATTERN_INCLUDE_AND_EXCLUDE, "foo", true),
+        Arguments.argumentSet(
+            "pattern include+exclude fOo", PATTERN_INCLUDE_AND_EXCLUDE, "fOo", true),
+        Arguments.argumentSet(
+            "pattern include+exclude FOO no match", PATTERN_INCLUDE_AND_EXCLUDE, "FOO", false),
+        Arguments.argumentSet(
+            "pattern include+exclude bar no match", PATTERN_INCLUDE_AND_EXCLUDE, "bar", false),
+        Arguments.argumentSet(
+            "pattern include+exclude baz no match", PATTERN_INCLUDE_AND_EXCLUDE, "baz", false),
+        Arguments.argumentSet("pattern multi foo", PATTERN_MULTI, "foo", true),
+        Arguments.argumentSet("pattern multi fooo", PATTERN_MULTI, "fooo", true),
+        Arguments.argumentSet("pattern multi fOo", PATTERN_MULTI, "fOo", true),
+        Arguments.argumentSet("pattern multi FOO no match", PATTERN_MULTI, "FOO", false),
+        Arguments.argumentSet("pattern multi bar no match", PATTERN_MULTI, "bar", false),
+        Arguments.argumentSet("pattern multi bAr no match", PATTERN_MULTI, "bAr", false),
+        Arguments.argumentSet("pattern multi barr no match", PATTERN_MULTI, "barr", false),
+        Arguments.argumentSet("pattern multi bArr no match", PATTERN_MULTI, "bArr", false),
+        Arguments.argumentSet("pattern multi baz no match", PATTERN_MULTI, "baz", false));
   }
 
   @ParameterizedTest
@@ -115,24 +114,36 @@ void stringRepresentation(Predicate<String> predicate, String exepectedString) {
 
   private static Stream<Arguments> stringRepresentationArgs() {
     return Stream.of(
-        Arguments.of(
-            EXACT_INCLUDE, "IncludeExcludePredicate{globMatchingEnabled=false, included=[foo]}"),
-        Arguments.of(
-            EXACT_EXCLUDE, "IncludeExcludePredicate{globMatchingEnabled=false, excluded=[bar]}"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "exact include",
+            EXACT_INCLUDE,
+            "IncludeExcludePredicate{globMatchingEnabled=false, included=[foo]}"),
+        Arguments.argumentSet(
+            "exact exclude",
+            EXACT_EXCLUDE,
+            "IncludeExcludePredicate{globMatchingEnabled=false, excluded=[bar]}"),
+        Arguments.argumentSet(
+            "exact include and exclude",
             EXACT_INCLUDE_AND_EXCLUDE,
             "IncludeExcludePredicate{globMatchingEnabled=false, included=[foo], excluded=[bar]}"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "exact multi",
             EXACT_MULTI,
             "IncludeExcludePredicate{globMatchingEnabled=false, included=[foo, fooo], excluded=[bar, barr]}"),
-        Arguments.of(
-            PATTERN_INCLUDE, "IncludeExcludePredicate{globMatchingEnabled=true, included=[f?o]}"),
-        Arguments.of(
-            PATTERN_EXCLUDE, "IncludeExcludePredicate{globMatchingEnabled=true, excluded=[b?r]}"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "pattern include",
+            PATTERN_INCLUDE,
+            "IncludeExcludePredicate{globMatchingEnabled=true, included=[f?o]}"),
+        Arguments.argumentSet(
+            "pattern exclude",
+            PATTERN_EXCLUDE,
+            "IncludeExcludePredicate{globMatchingEnabled=true, excluded=[b?r]}"),
+        Arguments.argumentSet(
+            "pattern include and exclude",
             PATTERN_INCLUDE_AND_EXCLUDE,
             "IncludeExcludePredicate{globMatchingEnabled=true, included=[f?o], excluded=[b?r]}"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "pattern multi",
             PATTERN_MULTI,
             "IncludeExcludePredicate{globMatchingEnabled=true, included=[f?o, f?oo], excluded=[b?r, b?rr]}"));
   }
diff --git a/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/StackTraceRendererTest.java b/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/StackTraceRendererTest.java
index d0b61374d73..108f70dff29 100644
--- a/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/StackTraceRendererTest.java
+++ b/sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/StackTraceRendererTest.java
@@ -64,14 +64,12 @@ private static Stream<Arguments> renderStacktraceArgs() {
     withKitchenSink.addSuppressed(withNestedSuppressed);
 
     return Stream.of(
-        // simple
-        Arguments.of(new Exception()),
-        Arguments.of(new Exception("error")),
-        // with cause
-        Arguments.of(new Exception(new Exception("cause"))),
-        Arguments.of(new Exception("error", new Exception("cause"))),
-        // with nested causes
-        Arguments.of(
+        Arguments.argumentSet("no message", new Exception()),
+        Arguments.argumentSet("with message", new Exception("error")),
+        Arguments.argumentSet("cause only", new Exception(new Exception("cause"))),
+        Arguments.argumentSet("message and cause", new Exception("error", new Exception("cause"))),
+        Arguments.argumentSet(
+            "nested causes",
             new Exception(
                 "error",
                 new Exception(
@@ -80,14 +78,12 @@ private static Stream<Arguments> renderStacktraceArgs() {
                         "cause2",
                         new Exception(
                             "cause3", new Exception("cause4", new Exception("cause5"))))))),
-        // with cause with circular reference
-        Arguments.of(withCycle),
-        // with suppressed
-        Arguments.of(withSuppressed),
-        Arguments.of(withMultipleSuppressed),
-        Arguments.of(withNestedSuppressed),
+        Arguments.argumentSet("circular reference", withCycle),
+        Arguments.argumentSet("with suppressed", withSuppressed),
+        Arguments.argumentSet("with multiple suppressed", withMultipleSuppressed),
+        Arguments.argumentSet("with nested suppressed", withNestedSuppressed),
         // with cause, cycle, and suppressed!
-        Arguments.of(withKitchenSink));
+        Arguments.argumentSet("kitchen sink", withKitchenSink));
   }
 
   private static String jdkStackTrace(Throwable exception, int limit) {
diff --git a/sdk/logs/src/testIncubating/java/io/opentelemetry/sdk/logs/LoggerConfigTest.java b/sdk/logs/src/testIncubating/java/io/opentelemetry/sdk/logs/LoggerConfigTest.java
index 83cd76affa2..b0665c29917 100644
--- a/sdk/logs/src/testIncubating/java/io/opentelemetry/sdk/logs/LoggerConfigTest.java
+++ b/sdk/logs/src/testIncubating/java/io/opentelemetry/sdk/logs/LoggerConfigTest.java
@@ -132,26 +132,23 @@ private static Stream<Arguments> loggerConfiguratorArgs() {
             .build();
 
     return Stream.of(
-        // default
-        Arguments.of(defaultConfigurator, scopeCat, defaultConfig()),
-        Arguments.of(defaultConfigurator, scopeDog, defaultConfig()),
-        Arguments.of(defaultConfigurator, scopeDuck, defaultConfig()),
-        // default enabled, disable cat
-        Arguments.of(disableCat, scopeCat, disabled()),
-        Arguments.of(disableCat, scopeDog, enabled()),
-        Arguments.of(disableCat, scopeDuck, enabled()),
-        // default enabled, disable pattern
-        Arguments.of(disableStartsWithD, scopeCat, enabled()),
-        Arguments.of(disableStartsWithD, scopeDog, disabled()),
-        Arguments.of(disableStartsWithD, scopeDuck, disabled()),
-        // default disabled, enable cat
-        Arguments.of(enableCat, scopeCat, enabled()),
-        Arguments.of(enableCat, scopeDog, disabled()),
-        Arguments.of(enableCat, scopeDuck, disabled()),
-        // default disabled, enable pattern
-        Arguments.of(enableStartsWithD, scopeCat, disabled()),
-        Arguments.of(enableStartsWithD, scopeDog, enabled()),
-        Arguments.of(enableStartsWithD, scopeDuck, enabled()));
+        Arguments.argumentSet("default cat", defaultConfigurator, scopeCat, defaultConfig()),
+        Arguments.argumentSet("default dog", defaultConfigurator, scopeDog, defaultConfig()),
+        Arguments.argumentSet("default duck", defaultConfigurator, scopeDuck, defaultConfig()),
+        Arguments.argumentSet("disable cat - cat disabled", disableCat, scopeCat, disabled()),
+        Arguments.argumentSet("disable cat - dog enabled", disableCat, scopeDog, enabled()),
+        Arguments.argumentSet("disable cat - duck enabled", disableCat, scopeDuck, enabled()),
+        Arguments.argumentSet("disable d* - cat enabled", disableStartsWithD, scopeCat, enabled()),
+        Arguments.argumentSet(
+            "disable d* - dog disabled", disableStartsWithD, scopeDog, disabled()),
+        Arguments.argumentSet(
+            "disable d* - duck disabled", disableStartsWithD, scopeDuck, disabled()),
+        Arguments.argumentSet("enable cat - cat enabled", enableCat, scopeCat, enabled()),
+        Arguments.argumentSet("enable cat - dog disabled", enableCat, scopeDog, disabled()),
+        Arguments.argumentSet("enable cat - duck disabled", enableCat, scopeDuck, disabled()),
+        Arguments.argumentSet("enable d* - cat disabled", enableStartsWithD, scopeCat, disabled()),
+        Arguments.argumentSet("enable d* - dog enabled", enableStartsWithD, scopeDog, enabled()),
+        Arguments.argumentSet("enable d* - duck enabled", enableStartsWithD, scopeDuck, enabled()));
   }
 
   @Test
diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/ExplicitBucketBoundariesAdviceTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/ExplicitBucketBoundariesAdviceTest.java
index c35864e1cef..5a6c68bd229 100644
--- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/ExplicitBucketBoundariesAdviceTest.java
+++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/ExplicitBucketBoundariesAdviceTest.java
@@ -210,14 +210,16 @@ void histogramWithInvalidAdvice(
 
   private static Stream<Arguments> histogramsWithoutAdvice() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "double histogram",
             (Function<SdkMeterProvider, Consumer<Long>>)
                 meterProvider -> {
                   DoubleHistogram histogram =
                       meterProvider.get("meter").histogramBuilder("histogram").build();
                   return histogram::record;
                 }),
-        Arguments.of(
+        Arguments.argumentSet(
+            "long histogram",
             (Function<SdkMeterProvider, Consumer<Long>>)
                 meterProvider -> {
                   LongHistogram histogram =
@@ -228,7 +230,8 @@ private static Stream<Arguments> histogramsWithoutAdvice() {
 
   private static Stream<Arguments> histogramsWithAdvice() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "double histogram with advice",
             (Function<SdkMeterProvider, Consumer<Long>>)
                 meterProvider -> {
                   DoubleHistogram histogram =
@@ -239,7 +242,8 @@ private static Stream<Arguments> histogramsWithAdvice() {
                           .build();
                   return histogram::record;
                 }),
-        Arguments.of(
+        Arguments.argumentSet(
+            "long histogram with advice",
             (Function<SdkMeterProvider, Consumer<Long>>)
                 meterProvider -> {
                   LongHistogram histogram =
@@ -255,7 +259,8 @@ private static Stream<Arguments> histogramsWithAdvice() {
 
   private static Stream<Arguments> histogramsWithInvalidAdvice() {
     return Stream.of(
-        Arguments.of(
+        Arguments.argumentSet(
+            "double histogram unsorted advice",
             (Function<SdkMeterProvider, Consumer<Long>>)
                 meterProvider -> {
                   DoubleHistogram histogram =
@@ -267,7 +272,8 @@ private static Stream<Arguments> histogramsWithInvalidAdvice() {
                   return histogram::record;
                 },
             "Error setting explicit bucket boundaries advice"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "long histogram unsorted advice",
             (Function<SdkMeterProvider, Consumer<Long>>)
                 meterProvider -> {
                   LongHistogram histogram =
@@ -280,7 +286,8 @@ private static Stream<Arguments> histogramsWithInvalidAdvice() {
                   return histogram::record;
                 },
             "Error setting explicit bucket boundaries advice"),
-        Arguments.of(
+        Arguments.argumentSet(
+            "double histogram null advice",
             (Function<SdkMeterProvider, Consumer<Long>>)
                 meterProvider -> {
                   DoubleHistogram histogram =
diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentStressTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentStressTest.java
index dd03d1a7df5..a9dd40677df 100644
--- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentStressTest.java
+++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/SynchronousInstrumentStressTest.java
@@ -299,7 +299,14 @@ private static Stream<Arguments> stressTestArgs() {
         for (MemoryMode memoryMode : MemoryMode.values()) {
           for (InstrumentValueType instrumentValueType : InstrumentValueType.values()) {
             argumentsList.add(
-                Arguments.of(
+                Arguments.argumentSet(
+                    aggregationTemporality
+                        + " "
+                        + instrumentTypeAndAggregation.instrumentType
+                        + " "
+                        + memoryMode
+                        + " "
+                        + instrumentValueType,
                     aggregationTemporality,
                     instrumentTypeAndAggregation.instrumentType,
                     instrumentTypeAndAggregation.aggregation,
diff --git a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/view/FilteredAttributesTest.java b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/view/FilteredAttributesTest.java
index b8bc0d10932..ebbcb744460 100644
--- a/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/view/FilteredAttributesTest.java
+++ b/sdk/metrics/src/test/java/io/opentelemetry/sdk/metrics/internal/view/FilteredAttributesTest.java
@@ -99,16 +99,23 @@ void toBuilder(Attributes filteredAttributes, Map<AttributeKey<?>, Object> expec
 
   private static Stream<Arguments> mapArgs() {
     return Stream.of(
-        Arguments.of(FILTERED_ATTRIBUTES_ONE, ImmutableMap.of(KEY1, "value1")),
-        Arguments.of(FILTERED_ATTRIBUTES_TWO, ImmutableMap.of(KEY1, "value1", KEY2_LONG, 222L)),
-        Arguments.of(
+        Arguments.argumentSet(
+            "one attribute", FILTERED_ATTRIBUTES_ONE, ImmutableMap.of(KEY1, "value1")),
+        Arguments.argumentSet(
+            "two attributes",
+            FILTERED_ATTRIBUTES_TWO,
+            ImmutableMap.of(KEY1, "value1", KEY2_LONG, 222L)),
+        Arguments.argumentSet(
+            "three attributes",
             FILTERED_ATTRIBUTES_THREE,
             ImmutableMap.of(KEY1, "value1", KEY2_LONG, 222L, KEY3, "value3")),
-        Arguments.of(
+        Arguments.argumentSet(
+            "four attributes filtered to three",
             FILTERED_ATTRIBUTES_FOUR,
             ImmutableMap.of(KEY1, "value1", KEY2_LONG, 222L, KEY3, "value3")),
-        Arguments.of(FILTERED_ATTRIBUTES_EMPTY_SOURCE, Collections.emptyMap()),
-        Arguments.of(FILTERED_ATTRIBUTES_EMPTY, Collections.emptyMap()));
+        Arguments.argumentSet(
+            "empty source", FILTERED_ATTRIBUTES_EMPTY_SOURCE, Collections.emptyMap()),
+        Arguments.argumentSet("empty filtered", FILTERED_ATTRIBUTES_EMPTY, Collections.emptyMap()));
   }
 
   @Test
diff --git a/sdk/metrics/src/testIncubating/java/io/opentelemetry/sdk/metrics/MeterConfigTest.java b/sdk/metrics/src/testIncubating/java/io/opentelemetry/sdk/metrics/MeterConfigTest.java
index f1a82fb809e..ba264081799 100644
--- a/sdk/metrics/src/testIncubating/java/io/opentelemetry/sdk/metrics/MeterConfigTest.java
+++ b/sdk/metrics/src/testIncubating/java/io/opentelemetry/sdk/metrics/MeterConfigTest.java
@@ -219,26 +219,27 @@ private static Stream<Arguments> meterConfiguratorArgs() {
             .build();
 
     return Stream.of(
-        // default
-        Arguments.of(defaultConfigurator, scopeCat, defaultConfig()),
-        Arguments.of(defaultConfigurator, scopeDog, defaultConfig()),
-        Arguments.of(defaultConfigurator, scopeDuck, defaultConfig()),
-        // default enabled, disable cat
-        Arguments.of(disableCat, scopeCat, MeterConfig.disabled()),
-        Arguments.of(disableCat, scopeDog, enabled()),
-        Arguments.of(disableCat, scopeDuck, enabled()),
-        // default enabled, disable pattern
-        Arguments.of(disableStartsWithD, scopeCat, enabled()),
-        Arguments.of(disableStartsWithD, scopeDog, MeterConfig.disabled()),
-        Arguments.of(disableStartsWithD, scopeDuck, MeterConfig.disabled()),
-        // default disabled, enable cat
-        Arguments.of(enableCat, scopeCat, enabled()),
-        Arguments.of(enableCat, scopeDog, MeterConfig.disabled()),
-        Arguments.of(enableCat, scopeDuck, MeterConfig.disabled()),
-        // default disabled, enable pattern
-        Arguments.of(enableStartsWithD, scopeCat, MeterConfig.disabled()),
-        Arguments.of(enableStartsWithD, scopeDog, enabled()),
-        Arguments.of(enableStartsWithD, scopeDuck, enabled()));
+        Arguments.argumentSet("default cat", defaultConfigurator, scopeCat, defaultConfig()),
+        Arguments.argumentSet("default dog", defaultConfigurator, scopeDog, defaultConfig()),
+        Arguments.argumentSet("default duck", defaultConfigurator, scopeDuck, defaultConfig()),
+        Arguments.argumentSet(
+            "disable cat - cat disabled", disableCat, scopeCat, MeterConfig.disabled()),
+        Arguments.argumentSet("disable cat - dog enabled", disableCat, scopeDog, enabled()),
+        Arguments.argumentSet("disable cat - duck enabled", disableCat, scopeDuck, enabled()),
+        Arguments.argumentSet("disable d* - cat enabled", disableStartsWithD, scopeCat, enabled()),
+        Arguments.argumentSet(
+            "disable d* - dog disabled", disableStartsWithD, scopeDog, MeterConfig.disabled()),
+        Arguments.argumentSet(
+            "disable d* - duck disabled", disableStartsWithD, scopeDuck, MeterConfig.disabled()),
+        Arguments.argumentSet("enable cat - cat enabled", enableCat, scopeCat, enabled()),
+        Arguments.argumentSet(
+            "enable cat - dog disabled", enableCat, scopeDog, MeterConfig.disabled()),
+        Arguments.argumentSet(
+            "enable cat - duck disabled", enableCat, scopeDuck, MeterConfig.disabled()),
+        Arguments.argumentSet(
+            "enable d* - cat disabled", enableStartsWithD, scopeCat, MeterConfig.disabled()),
+        Arguments.argumentSet("enable d* - dog enabled", enableStartsWithD, scopeDog, enabled()),
+        Arguments.argumentSet("enable d* - duck enabled", enableStartsWithD, scopeDuck, enabled()));
   }
 
   @Test
diff --git a/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanTest.java b/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanTest.java
index 207bcaebf07..bd98d601d95 100644
--- a/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanTest.java
+++ b/sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanTest.java
@@ -1429,41 +1429,48 @@ void setStatus(Consumer<Span> spanConsumer, StatusData expectedSpanData) {
 
   private static Stream<Arguments> setStatusArgs() {
     return Stream.of(
-        // Default status is UNSET
-        Arguments.of(spanConsumer(span -> {}), StatusData.unset()),
-        // Simple cases
-        Arguments.of(spanConsumer(span -> span.setStatus(StatusCode.OK)), StatusData.ok()),
-        Arguments.of(spanConsumer(span -> span.setStatus(StatusCode.ERROR)), StatusData.error()),
-        // UNSET is ignored
-        Arguments.of(
+        Arguments.argumentSet("default UNSET", spanConsumer(span -> {}), StatusData.unset()),
+        Arguments.argumentSet(
+            "setStatus OK", spanConsumer(span -> span.setStatus(StatusCode.OK)), StatusData.ok()),
+        Arguments.argumentSet(
+            "setStatus ERROR",
+            spanConsumer(span -> span.setStatus(StatusCode.ERROR)),
+            StatusData.error()),
+        Arguments.argumentSet(
+            "OK then UNSET ignored",
             spanConsumer(span -> span.setStatus(StatusCode.OK).setStatus(StatusCode.UNSET)),
             StatusData.ok()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "ERROR then UNSET ignored",
             spanConsumer(span -> span.setStatus(StatusCode.ERROR).setStatus(StatusCode.UNSET)),
             StatusData.error()),
-        // Description is ignored unless status is ERROR
-        Arguments.of(
+        Arguments.argumentSet(
+            "UNSET description ignored",
             spanConsumer(span -> span.setStatus(StatusCode.UNSET, "description")),
             StatusData.unset()),
-        Arguments.of(
-            spanConsumer(span -> span.setStatus(StatusCode.OK, "description")), StatusData.ok()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "OK description ignored",
+            spanConsumer(span -> span.setStatus(StatusCode.OK, "description")),
+            StatusData.ok()),
+        Arguments.argumentSet(
+            "ERROR with description",
             spanConsumer(span -> span.setStatus(StatusCode.ERROR, "description")),
             StatusData.create(StatusCode.ERROR, "description")),
-        // ERROR is ignored if status is OK
-        Arguments.of(
+        Arguments.argumentSet(
+            "ERROR ignored after OK",
             spanConsumer(
                 span -> span.setStatus(StatusCode.OK).setStatus(StatusCode.ERROR, "description")),
             StatusData.ok()),
-        // setStatus ignored after span is ended
-        Arguments.of(
+        Arguments.argumentSet(
+            "setStatus OK after end ignored",
             spanConsumer(
                 span -> {
                   span.end();
                   span.setStatus(StatusCode.OK);
                 }),
             StatusData.unset()),
-        Arguments.of(
+        Arguments.argumentSet(
+            "setStatus ERROR after end ignored",
             spanConsumer(
                 span -> {
                   span.end();
diff --git a/sdk/trace/src/testIncubating/java/io/opentelemetry/sdk/trace/ExtendedTracerTest.java b/sdk/trace/src/testIncubating/java/io/opentelemetry/sdk/trace/ExtendedTracerTest.java
index 75173251e25..f1e3869b71b 100644
--- a/sdk/trace/src/testIncubating/java/io/opentelemetry/sdk/trace/ExtendedTracerTest.java
+++ b/sdk/trace/src/testIncubating/java/io/opentelemetry/sdk/trace/ExtendedTracerTest.java
@@ -53,15 +53,16 @@ private static Stream<Arguments> spanBuilderArgs() {
     tracerProvider2.shutdown();
 
     return Stream.of(
-        // Simple case
-        Arguments.of(spanBuilderSupplier(() -> tracerA.spanBuilder("span"))),
-        // Disabled tracer
-        Arguments.of(spanBuilderSupplier(() -> tracerB.spanBuilder("span"))),
-        // Invalid span name
-        Arguments.of(spanBuilderSupplier(() -> tracerB.spanBuilder(null))),
-        Arguments.of(spanBuilderSupplier(() -> tracerB.spanBuilder(" "))),
-        // Shutdown tracer provider
-        Arguments.of(spanBuilderSupplier(() -> tracerC.spanBuilder("span"))));
+        Arguments.argumentSet(
+            "enabled tracer", spanBuilderSupplier(() -> tracerA.spanBuilder("span"))),
+        Arguments.argumentSet(
+            "disabled tracer", spanBuilderSupplier(() -> tracerB.spanBuilder("span"))),
+        Arguments.argumentSet(
+            "null span name", spanBuilderSupplier(() -> tracerB.spanBuilder(null))),
+        Arguments.argumentSet(
+            "blank span name", spanBuilderSupplier(() -> tracerB.spanBuilder(" "))),
+        Arguments.argumentSet(
+            "shutdown provider", spanBuilderSupplier(() -> tracerC.spanBuilder("span"))));
   }
 
   private static Supplier<ExtendedSpanBuilder> spanBuilderSupplier(
diff --git a/sdk/trace/src/testIncubating/java/io/opentelemetry/sdk/trace/TracerConfigTest.java b/sdk/trace/src/testIncubating/java/io/opentelemetry/sdk/trace/TracerConfigTest.java
index c8b46758731..58dea7b4476 100644
--- a/sdk/trace/src/testIncubating/java/io/opentelemetry/sdk/trace/TracerConfigTest.java
+++ b/sdk/trace/src/testIncubating/java/io/opentelemetry/sdk/trace/TracerConfigTest.java
@@ -135,26 +135,23 @@ private static Stream<Arguments> tracerConfiguratorArgs() {
             .build();
 
     return Stream.of(
-        // default
-        Arguments.of(defaultConfigurator, scopeCat, defaultConfig()),
-        Arguments.of(defaultConfigurator, scopeDog, defaultConfig()),
-        Arguments.of(defaultConfigurator, scopeDuck, defaultConfig()),
-        // default enabled, disable cat
-        Arguments.of(disableCat, scopeCat, disabled()),
-        Arguments.of(disableCat, scopeDog, enabled()),
-        Arguments.of(disableCat, scopeDuck, enabled()),
-        // default enabled, disable pattern
-        Arguments.of(disableStartsWithD, scopeCat, enabled()),
-        Arguments.of(disableStartsWithD, scopeDog, disabled()),
-        Arguments.of(disableStartsWithD, scopeDuck, disabled()),
-        // default disabled, enable cat
-        Arguments.of(enableCat, scopeCat, enabled()),
-        Arguments.of(enableCat, scopeDog, disabled()),
-        Arguments.of(enableCat, scopeDuck, disabled()),
-        // default disabled, enable pattern
-        Arguments.of(enableStartsWithD, scopeCat, disabled()),
-        Arguments.of(enableStartsWithD, scopeDog, enabled()),
-        Arguments.of(enableStartsWithD, scopeDuck, enabled()));
+        Arguments.argumentSet("default cat", defaultConfigurator, scopeCat, defaultConfig()),
+        Arguments.argumentSet("default dog", defaultConfigurator, scopeDog, defaultConfig()),
+        Arguments.argumentSet("default duck", defaultConfigurator, scopeDuck, defaultConfig()),
+        Arguments.argumentSet("disable cat - cat disabled", disableCat, scopeCat, disabled()),
+        Arguments.argumentSet("disable cat - dog enabled", disableCat, scopeDog, enabled()),
+        Arguments.argumentSet("disable cat - duck enabled", disableCat, scopeDuck, enabled()),
+        Arguments.argumentSet("disable d* - cat enabled", disableStartsWithD, scopeCat, enabled()),
+        Arguments.argumentSet(
+            "disable d* - dog disabled", disableStartsWithD, scopeDog, disabled()),
+        Arguments.argumentSet(
+            "disable d* - duck disabled", disableStartsWithD, scopeDuck, disabled()),
+        Arguments.argumentSet("enable cat - cat enabled", enableCat, scopeCat, enabled()),
+        Arguments.argumentSet("enable cat - dog disabled", enableCat, scopeDog, disabled()),
+        Arguments.argumentSet("enable cat - duck disabled", enableCat, scopeDuck, disabled()),
+        Arguments.argumentSet("enable d* - cat disabled", enableStartsWithD, scopeCat, disabled()),
+        Arguments.argumentSet("enable d* - dog enabled", enableStartsWithD, scopeDog, enabled()),
+        Arguments.argumentSet("enable d* - duck enabled", enableStartsWithD, scopeDuck, enabled()));
   }
 
   @Test