Refactor some Dagger tests to improve code clarity and modernize exception testing.

This change updates specific tests in the Dagger project to:
- Prefer `assertThrows` to `ExpectedException`.
- Refactor test cases for better readability by extracting variables.
- Remove unnecessary warnings suppressions.

RELNOTES=Refactor some Dagger tests for code clarity and modernize exception testing.
PiperOrigin-RevId: 905251628

Author: garabais

dagger-runtime/test/javatests/dagger/internal/MapProviderFactoryTest.java

@@ -17,35 +17,33 @@
 package dagger.internal;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
 @RunWith(JUnit4.class)
-@SuppressWarnings("unchecked")
 public class MapProviderFactoryTest {
-  @Rule
-  public ExpectedException thrown = ExpectedException.none();
 
   @Test
   public void nullKey() {
-    thrown.expect(NullPointerException.class);
-    MapProviderFactory.<String, Integer>builder(1).put(null, incrementingIntegerProvider(1));
+    MapProviderFactory.Builder<String, Integer> builder =
+        MapProviderFactory.<String, Integer>builder(1);
+    Provider<Integer> providerOfValue = incrementingIntegerProvider(1);
+    assertThrows(NullPointerException.class, () -> builder.put(null, providerOfValue));
   }
 
   @Test
   public void nullValue() {
-    thrown.expect(NullPointerException.class);
-    MapProviderFactory.<String, Integer>builder(1).put("Hello", null);
+    MapProviderFactory.Builder<String, Integer> builder =
+        MapProviderFactory.<String, Integer>builder(1);
+    assertThrows(NullPointerException.class, () -> builder.put("Hello", null));
   }
 
-
   @Test
   public void iterationOrder() {
     Provider<Integer> p1 = incrementingIntegerProvider(10);
@@ -54,14 +52,14 @@ public void iterationOrder() {
     Provider<Integer> p4 = incrementingIntegerProvider(40);
     Provider<Integer> p5 = incrementingIntegerProvider(50);
 
-    Factory<Map<String, Provider<Integer>>> factory = MapProviderFactory
-        .<String, Integer>builder(4)
-        .put("two", p2)
-        .put("one", p1)
-        .put("three", p3)
-        .put("one", p5)
-        .put("four", p4)
-        .build();
+    Factory<Map<String, Provider<Integer>>> factory =
+        MapProviderFactory.<String, Integer>builder(4)
+            .put("two", p2)
+            .put("one", p1)
+            .put("three", p3)
+            .put("one", p5)
+            .put("four", p4)
+            .build();
 
     Map<String, Provider<Integer>> expectedMap = new LinkedHashMap<>();
     expectedMap.put("two", p2);
@@ -74,7 +72,6 @@ public void iterationOrder() {
         .inOrder();
   }
 
-
   private static Provider<Integer> incrementingIntegerProvider(int seed) {
     return new AtomicInteger(seed)::getAndIncrement;
   }

dagger-runtime/test/javatests/dagger/internal/SetFactoryTest.java

@@ -17,46 +17,40 @@
 package dagger.internal;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
 
 import com.google.common.collect.ImmutableSet;
 import java.util.Arrays;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
 @RunWith(JUnit4.class)
-@SuppressWarnings("unchecked")
 public class SetFactoryTest {
-  @Rule public ExpectedException thrown = ExpectedException.none();
 
   @Test
   public void providerReturnsNull() {
     Factory<Set<Integer>> factory =
         SetFactory.<Integer>builder(0, 1).addCollectionProvider(() -> null).build();
-    thrown.expect(NullPointerException.class);
-    factory.get();
+    assertThrows(NullPointerException.class, () -> factory.get());
   }
 
   @Test
   public void providerReturnsNullSet() {
     Factory<Set<Integer>> factory =
         SetFactory.<Integer>builder(1, 0).addProvider(() -> null).build();
-    thrown.expect(NullPointerException.class);
-    factory.get();
+    assertThrows(NullPointerException.class, () -> factory.get());
   }
 
   @Test
   public void providerReturnsSetWithNullElement() {
     Set<Integer> set = new LinkedHashSet<>(Arrays.asList(1, null, 3));
     Factory<Set<Integer>> factory =
         SetFactory.<Integer>builder(0, 1).addCollectionProvider(() -> set).build();
-    thrown.expect(NullPointerException.class);
-    factory.get();
+    assertThrows(NullPointerException.class, () -> factory.get());
   }
 
   @Test