diff --git a/src/test/java/net/datafaker/providers/base/AbstractBasicProviderTest.java b/src/test/java/net/datafaker/providers/base/AbstractBasicProviderTest.java
deleted file mode 100644
index beaed7c6d..000000000
--- a/src/test/java/net/datafaker/providers/base/AbstractBasicProviderTest.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package net.datafaker.providers.base;
-
-
-
-import org.junit.jupiter.api.TestInstance;
-
-@TestInstance(TestInstance.Lifecycle.PER_CLASS)
-public abstract class AbstractBasicProviderTest<T extends BaseFaker> extends BaseFakerTest<BaseFaker> {
-
-}
diff --git a/src/test/java/net/datafaker/providers/base/AncientTest.java b/src/test/java/net/datafaker/providers/base/AncientTest.java
index 235404827..1665e7680 100644
--- a/src/test/java/net/datafaker/providers/base/AncientTest.java
+++ b/src/test/java/net/datafaker/providers/base/AncientTest.java
@@ -1,29 +1,16 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class AncientTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void god() {
-        assertThat(faker.ancient().god()).matches("\\w+");
-    }
-
-    @Test
-    void primordial() {
-        assertThat(faker.ancient().primordial()).matches("\\w+");
-    }
-
-    @Test
-    void titan() {
-        assertThat(faker.ancient().titan()).matches("\\w+");
-    }
-
-    @Test
-    void hero() {
-        assertThat(faker.ancient().hero()).matches("(?U)\\w+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Ancient ancient = faker.ancient();
+        return Arrays.asList(TestSpec.of(ancient::god, "ancient.god"),
+            TestSpec.of(ancient::primordial, "ancient.primordial"),
+            TestSpec.of(ancient::titan, "ancient.titan"),
+            TestSpec.of(ancient::hero, "ancient.hero"));
     }
-
 }
diff --git a/src/test/java/net/datafaker/providers/base/AnimalTest.java b/src/test/java/net/datafaker/providers/base/AnimalTest.java
index 5965d140e..c9c7e6e2f 100644
--- a/src/test/java/net/datafaker/providers/base/AnimalTest.java
+++ b/src/test/java/net/datafaker/providers/base/AnimalTest.java
@@ -1,29 +1,32 @@
 package net.datafaker.providers.base;
 
 import org.junit.jupiter.api.RepeatedTest;
-import org.junit.jupiter.api.Test;
-
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class AnimalTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void name() {
-        assertThat(faker.animal().name()).matches("[A-Za-z ]+");
+    private Animal animal = faker.animal();
+
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(animal::name, "creature.animal.name"));
     }
 
     @RepeatedTest(100)
     void scientificName() {
-        assertThat(faker.animal().scientificName()).matches("[A-Z][a-z]+ [a-z]+");
+        assertThat(animal.scientificName()).matches("[A-Z][a-z]+ [a-z]+");
     }
 
     @RepeatedTest(100)
     void genus() {
-        assertThat(faker.animal().genus()).matches("[A-Z][a-z]+");
+        assertThat(animal.genus()).matches("[A-Z][a-z]+");
     }
 
     @RepeatedTest(100)
     void species() {
-        assertThat(faker.animal().species()).matches("[a-z]+");
+        assertThat(animal.species()).matches("[a-z]+");
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/AppTest.java b/src/test/java/net/datafaker/providers/base/AppTest.java
index 859e14cac..1e1b7d6ef 100644
--- a/src/test/java/net/datafaker/providers/base/AppTest.java
+++ b/src/test/java/net/datafaker/providers/base/AppTest.java
@@ -5,20 +5,25 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class AppTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testName() {
-        assertThat(faker.app().name()).matches("([\\w-]+ ?)+");
-    }
+    private App app = faker.app();
 
     @Test
     void testVersion() {
-        assertThat(faker.app().version()).matches("\\d\\.(\\d){1,2}(\\.\\d)?");
+        assertThat(app.version()).matches("\\d\\.(\\d){1,2}(\\.\\d)?");
     }
 
     @Test
     void testAuthor() {
-        assertThat(faker.app().author()).matches("([\\w']+[-&,.]? ?){2,9}");
+        assertThat(app.author()).matches("([\\w']+[-&,.]? ?){2,9}");
+    }
+
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(app::name, "app.name", "([\\w-]+ ?)+"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ApplianceTest.java b/src/test/java/net/datafaker/providers/base/ApplianceTest.java
index eb4a75e1b..2f8c83cd9 100644
--- a/src/test/java/net/datafaker/providers/base/ApplianceTest.java
+++ b/src/test/java/net/datafaker/providers/base/ApplianceTest.java
@@ -1,21 +1,14 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
 import java.util.Arrays;
 import java.util.Collection;
 
-class ApplianceTest extends AbstractBasicProviderTest<BaseFaker> {
-
-    @Test
-    void brand() {
-        assertThat(faker.appliance().brand()).matches("[A-Za-z .-]+");
-    }
+class ApplianceTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.appliance().equipment(), "appliance.equipment"));
+        Appliance appliance = faker.appliance();
+        return Arrays.asList(TestSpec.of(appliance::brand, "appliance.brand", "[A-Za-z .-]+"),
+                TestSpec.of(appliance::equipment, "appliance.equipment"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ArtistTest.java b/src/test/java/net/datafaker/providers/base/ArtistTest.java
index 9c0c3f43f..065f5e14e 100644
--- a/src/test/java/net/datafaker/providers/base/ArtistTest.java
+++ b/src/test/java/net/datafaker/providers/base/ArtistTest.java
@@ -1,13 +1,13 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class ArtistTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void name() {
-        assertThat(faker.artist().name()).matches("(\\w+ ?){1,2}");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Artist artist = faker.artist();
+        return Arrays.asList(TestSpec.of(artist::name, "artist.names", "(\\w+ ?){1,2}"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/AustraliaTest.java b/src/test/java/net/datafaker/providers/base/AustraliaTest.java
index e957d49be..3f7dd2d2a 100644
--- a/src/test/java/net/datafaker/providers/base/AustraliaTest.java
+++ b/src/test/java/net/datafaker/providers/base/AustraliaTest.java
@@ -3,13 +3,14 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class AustraliaTest extends AbstractBasicProviderTest<BaseFaker> {
+class AustraliaTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.australia().locations(), "australia.locations"),
-            TestSpec.of(() -> faker.australia().animals(), "australia.animals"),
-            TestSpec.of(() -> faker.australia().states(), "australia.states"));
+        Australia astralia = faker.australia();
+        return Arrays.asList(TestSpec.of(astralia::locations, "australia.locations"),
+            TestSpec.of(astralia::animals, "australia.animals"),
+            TestSpec.of(astralia::states, "australia.states"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/AviationTest.java b/src/test/java/net/datafaker/providers/base/AviationTest.java
index 116a40614..192042a0b 100644
--- a/src/test/java/net/datafaker/providers/base/AviationTest.java
+++ b/src/test/java/net/datafaker/providers/base/AviationTest.java
@@ -7,32 +7,30 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class AviationTest extends AbstractBasicProviderTest<BaseFaker> {
+class AviationTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void airport() {
-        assertThat(faker.aviation().airport()).matches("\\w{4}");
-    }
+    private Aviation aviation = faker.aviation();
 
     @Test
     void flight_ICAO() {
-        assertThat(faker.aviation().flight("ICAO")).matches("[A-Z]{3}[0-9]+");
+        assertThat(aviation.flight("ICAO")).matches("[A-Z]{3}[0-9]+");
     }
 
     @Test
     void flight_IATA() {
-        assertThat(faker.aviation().flight("IATA")).matches("[A-Z]{2}[0-9]+");
+        assertThat(aviation.flight("IATA")).matches("[A-Z]{2}[0-9]+");
     }
 
     @Test
     void flight_default() {
-        assertThat(faker.aviation().flight()).matches("[A-Z]{2}[0-9]+");
+        assertThat(aviation.flight()).matches("[A-Z]{2}[0-9]+");
     }
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.aviation().aircraft(), "aviation.aircraft"),
-            TestSpec.of(() -> faker.aviation().METAR(), "aviation.metar"),
-            TestSpec.of(() -> faker.aviation().airline(), "aviation.airline"));
+        return Arrays.asList(TestSpec.of(aviation::airport, "aviation.airport", "\\w{4}"),
+            TestSpec.of(aviation::aircraft, "aviation.aircraft"),
+            TestSpec.of(aviation::METAR, "aviation.metar"),
+            TestSpec.of(aviation::airline, "aviation.airline"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/BaseFakerTest.java b/src/test/java/net/datafaker/providers/base/BaseFakerTest.java
index 48882e9f0..c0f62ee26 100644
--- a/src/test/java/net/datafaker/providers/base/BaseFakerTest.java
+++ b/src/test/java/net/datafaker/providers/base/BaseFakerTest.java
@@ -15,6 +15,7 @@
 import java.util.logging.Level;
 import java.util.logging.LogManager;
 import java.util.logging.Logger;
+import java.util.regex.Pattern;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -25,6 +26,7 @@ public class BaseFakerTest<T extends BaseFaker> {
     protected final T faker = getFaker();
 
     @BeforeEach
+    @SuppressWarnings("unchecked")
     protected void before() {
         try (AutoCloseable ignored = MockitoAnnotations.openMocks(this)) {
 
@@ -39,6 +41,7 @@ protected void before() {
         }
     }
 
+    @SuppressWarnings("unchecked")
     protected T getFaker() {
         return (T) new BaseFaker();
     }
@@ -68,26 +71,36 @@ protected void testProviderList(TestSpec testSpec, TestInfo testInfo) {
         assertThat(item).as("Check item isn't empty").isNotEmpty();
         assertThat(actual).as("Check actual list isn't empty and contains the item for the key \"" + testSpec.key + "\"").isNotEmpty()
             .anyMatch(item::equals);
+        if (!testSpec.regex.isEmpty()) {
+            assertThat(item).as("Check item matches regex").matches(Pattern.compile(testSpec.regex));
+        }
     }
 
     protected Collection<TestSpec> providerListTest() {
         // dummy test since parameterized test requires non-empty collection
-        return Collections.singleton(new TestSpec(null, null));
+        return Collections.singleton(new TestSpec(null, null, null));
     }
 
     protected static class TestSpec {
         private final Supplier<?> supplier;
         private final String key;
         private final boolean isDummy;
+        @SuppressWarnings("unused")
+        private final String regex;
 
-        private TestSpec(Supplier<?> supplier, String key) {
+        private TestSpec(Supplier<?> supplier, String key, String regex) {
             this.supplier = supplier;
             this.key = key;
             this.isDummy = key == null || supplier == null;
+            this.regex = regex;
         }
 
         public static TestSpec of(Supplier<?> supplier, String key) {
-            return new TestSpec(supplier, key);
+            return new TestSpec(supplier, key, "");
+        }
+
+        public static TestSpec of(Supplier<?> supplier, String key, String regex) {
+            return new TestSpec(supplier, key, regex);
         }
 
         @Override
diff --git a/src/test/java/net/datafaker/providers/base/BloodTypeTest.java b/src/test/java/net/datafaker/providers/base/BloodTypeTest.java
index 18c8ed72b..9eb710f97 100644
--- a/src/test/java/net/datafaker/providers/base/BloodTypeTest.java
+++ b/src/test/java/net/datafaker/providers/base/BloodTypeTest.java
@@ -1,29 +1,16 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class BloodTypeTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void aboTypes() {
-        assertThat(faker.bloodtype().aboTypes()).matches("[A-Za-z]+");
-    }
-
-    @Test
-    void rhTypes() {
-        assertThat(faker.bloodtype().rhTypes()).matches("[A-Za-z+-]+");
-    }
-
-    @Test
-    void pTypes() {
-        assertThat(faker.bloodtype().pTypes()).matches("[A-Za-z\\d]+");
-    }
-
-    @Test
-    void testBloodGroup() {
-        assertThat(faker.bloodtype().bloodGroup()).matches("(A|B|AB|O)[+-]");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        BloodType bloodType = faker.bloodtype();
+        return Arrays.asList(TestSpec.of(bloodType::aboTypes, "blood_type.abo_types", "[A-Za-z]+"),
+            TestSpec.of(bloodType::rhTypes, "blood_type.rh_types", "[A-Za-z+-]+"),
+            TestSpec.of(bloodType::pTypes, "blood_type.p_types", "[A-Za-z\\d]+"),
+            TestSpec.of(bloodType::bloodGroup, "blood_type.blood_group", "(A|B|AB|O)[+-]"));
     }
-
 }
diff --git a/src/test/java/net/datafaker/providers/base/BookTest.java b/src/test/java/net/datafaker/providers/base/BookTest.java
index be176faa3..17fccffca 100644
--- a/src/test/java/net/datafaker/providers/base/BookTest.java
+++ b/src/test/java/net/datafaker/providers/base/BookTest.java
@@ -4,25 +4,22 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class BookTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testTitle() {
-        assertThat(faker.book().title()).matches("([\\p{L}'\\-?]+[!,]? ?){2,9}");
-    }
+    private Book book = faker.book();
 
     @Test
     void testAuthor() {
-        assertThat(faker.book().author()).matches("([\\w']+\\.? ?){2,3}");
+        assertThat(book.author()).matches("([\\w']+\\.? ?){2,3}");
     }
 
-    @Test
-    void testPublisher() {
-        assertThat(faker.book().publisher()).matches("([\\p{L}'&\\-]+[,.]? ?){1,5}");
-    }
-
-    @Test
-    void testGenre() {
-        assertThat(faker.book().genre()).matches("([\\w/]+ ?){2,4}");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(() -> faker.book().title(), "book.title", "([\\p{L}'\\-?]+[!,]? ?){2,9}"),
+            TestSpec.of(() -> faker.book().publisher(), "book.publisher", "([\\p{L}'&\\-]+[,.]? ?){1,5}"),
+            TestSpec.of(() -> faker.book().genre(), "book.genre", "([\\w/]+ ?){2,4}"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/BrandTest.java b/src/test/java/net/datafaker/providers/base/BrandTest.java
index e6d547eab..1d866365b 100644
--- a/src/test/java/net/datafaker/providers/base/BrandTest.java
+++ b/src/test/java/net/datafaker/providers/base/BrandTest.java
@@ -3,14 +3,15 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class BrandTest extends AbstractBasicProviderTest<BaseFaker> {
+class BrandTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
+        Brand brand = faker.brand();
         return Arrays.asList(
-            TestSpec.of(() -> faker.brand().sport(), "brand.sport"),
-            TestSpec.of(() -> faker.brand().car(), "vehicle.makes"),
-            TestSpec.of(() -> faker.brand().watch(), "brand.watch")
+            TestSpec.of(brand::sport, "brand.sport"),
+            TestSpec.of(brand::car, "vehicle.makes"),
+            TestSpec.of(brand::watch, "brand.watch")
         );
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/BusinessTest.java b/src/test/java/net/datafaker/providers/base/BusinessTest.java
index eca5255b2..697a08b55 100644
--- a/src/test/java/net/datafaker/providers/base/BusinessTest.java
+++ b/src/test/java/net/datafaker/providers/base/BusinessTest.java
@@ -7,17 +7,19 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class BusinessTest extends AbstractBasicProviderTest<BaseFaker> {
+class BusinessTest extends BaseFakerTest<BaseFaker> {
+
+    private Business business = faker.business();
 
     @Test
     void creditCardNumber() {
-        assertThat(faker.business().creditCardNumber()).isNotEmpty();
+        assertThat(business.creditCardNumber()).isNotEmpty();
     }
 
     @Test
     void creditCardExpiry() {
         // Given / When
-        String date = faker.business().creditCardExpiry();
+        String date = business.creditCardExpiry();
         // Then
         assertThat(date).isNotEmpty();
         assertThat(date).matches("\\d{4}-\\d{2}-\\d{2}");
@@ -25,11 +27,11 @@ void creditCardExpiry() {
 
     @Test
     void securityCode() {
-        assertThat(faker.business().securityCode()).isNotEmpty();
+        assertThat(business.securityCode()).isNotEmpty();
     }
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.business().creditCardType(), "business.credit_card_types"));
+        return Arrays.asList(TestSpec.of(business::creditCardType, "business.credit_card_types"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/CameraTest.java b/src/test/java/net/datafaker/providers/base/CameraTest.java
index 285cb85f9..fe38d1d7f 100644
--- a/src/test/java/net/datafaker/providers/base/CameraTest.java
+++ b/src/test/java/net/datafaker/providers/base/CameraTest.java
@@ -1,23 +1,15 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class CameraTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testBrand() {
-        assertThat(faker.camera().brand()).matches("^[a-zA-Z0-9 -]+$");
-    }
-
-    @Test
-    void testModel() {
-        assertThat(faker.camera().model()).matches("^[a-zA-Z0-9 -]+$");
-    }
-
-    @Test
-    void testBrandWithModel() {
-        assertThat(faker.camera().brandWithModel()).matches("^[a-zA-Z0-9 -]+$");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Camera camera = faker.camera();
+        return Arrays.asList(TestSpec.of(camera::brand, "camera.brand", "^[a-zA-Z0-9 -]+$"),
+            TestSpec.of(camera::model, "camera.model", "^[a-zA-Z0-9 -]+$"),
+            TestSpec.of(camera::brandWithModel, "camera.brand_with_model", "^[a-zA-Z0-9 -]+$"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/CannabisTest.java b/src/test/java/net/datafaker/providers/base/CannabisTest.java
index c23896c92..7b10fce30 100644
--- a/src/test/java/net/datafaker/providers/base/CannabisTest.java
+++ b/src/test/java/net/datafaker/providers/base/CannabisTest.java
@@ -3,20 +3,21 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class CannabisTest extends AbstractBasicProviderTest<BaseFaker> {
+class CannabisTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.cannabis().strains(), "cannabis.strains"),
-                TestSpec.of(() -> faker.cannabis().cannabinoidAbbreviations(), "cannabis.cannabinoid_abbreviations"),
-                TestSpec.of(() -> faker.cannabis().cannabinoids(), "cannabis.cannabinoids"),
-                TestSpec.of(() -> faker.cannabis().terpenes(), "cannabis.terpenes"),
-                TestSpec.of(() -> faker.cannabis().medicalUses(), "cannabis.medical_uses"),
-                TestSpec.of(() -> faker.cannabis().healthBenefits(), "cannabis.health_benefits"),
-                TestSpec.of(() -> faker.cannabis().categories(), "cannabis.categories"),
-                TestSpec.of(() -> faker.cannabis().types(), "cannabis.types"),
-                TestSpec.of(() -> faker.cannabis().buzzwords(), "cannabis.buzzwords"),
-                TestSpec.of(() -> faker.cannabis().brands(), "cannabis.brands"));
+        Cannabis cannabis = faker.cannabis();
+        return Arrays.asList(TestSpec.of(cannabis::strains, "cannabis.strains"),
+                TestSpec.of(cannabis::cannabinoidAbbreviations, "cannabis.cannabinoid_abbreviations"),
+                TestSpec.of(cannabis::cannabinoids, "cannabis.cannabinoids"),
+                TestSpec.of(cannabis::terpenes, "cannabis.terpenes"),
+                TestSpec.of(cannabis::medicalUses, "cannabis.medical_uses"),
+                TestSpec.of(cannabis::healthBenefits, "cannabis.health_benefits"),
+                TestSpec.of(cannabis::categories, "cannabis.categories"),
+                TestSpec.of(cannabis::types, "cannabis.types"),
+                TestSpec.of(cannabis::buzzwords, "cannabis.buzzwords"),
+                TestSpec.of(cannabis::brands, "cannabis.brands"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/CatTest.java b/src/test/java/net/datafaker/providers/base/CatTest.java
index e8ff0d754..35b0a571a 100644
--- a/src/test/java/net/datafaker/providers/base/CatTest.java
+++ b/src/test/java/net/datafaker/providers/base/CatTest.java
@@ -1,23 +1,15 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class CatTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void name() {
-        assertThat(faker.cat().name()).matches("[A-Za-z'() 0-9-]+");
-    }
-
-    @Test
-    void breed() {
-        assertThat(faker.cat().breed()).matches("[A-Za-z'() 0-9-,]+");
-    }
-
-    @Test
-    void registry() {
-        assertThat(faker.cat().registry()).matches("[A-Za-zé'() 0-9-]+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Cat cat = faker.cat();
+        return Arrays.asList(TestSpec.of(cat::name, "creature.cat.name"),
+            TestSpec.of(cat::breed, "creature.cat.breed"),
+            TestSpec.of(cat::registry, "creature.cat.registry"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ChiquitoTest.java b/src/test/java/net/datafaker/providers/base/ChiquitoTest.java
index ae31b1dfc..0eeb47263 100644
--- a/src/test/java/net/datafaker/providers/base/ChiquitoTest.java
+++ b/src/test/java/net/datafaker/providers/base/ChiquitoTest.java
@@ -3,14 +3,15 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class ChiquitoTest extends AbstractBasicProviderTest<BaseFaker> {
+class ChiquitoTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.chiquito().expressions(), "chiquito.expressions"),
-            TestSpec.of(() -> faker.chiquito().terms(), "chiquito.terms"),
-            TestSpec.of(() -> faker.chiquito().sentences(), "chiquito.sentences"),
-            TestSpec.of(() -> faker.chiquito().jokes(), "chiquito.jokes"));
+        Chiquito chiquito = faker.chiquito();
+        return Arrays.asList(TestSpec.of(chiquito::expressions, "chiquito.expressions"),
+            TestSpec.of(chiquito::terms, "chiquito.terms"),
+            TestSpec.of(chiquito::sentences, "chiquito.sentences"),
+            TestSpec.of(chiquito::jokes, "chiquito.jokes"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/CoinTest.java b/src/test/java/net/datafaker/providers/base/CoinTest.java
index 8f22bc047..4dde70013 100644
--- a/src/test/java/net/datafaker/providers/base/CoinTest.java
+++ b/src/test/java/net/datafaker/providers/base/CoinTest.java
@@ -1,13 +1,13 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class CoinTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void coinFlip() {
-        assertThat(faker.coin().flip()).matches("\\w+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Coin coin = faker.coin();
+        return Arrays.asList(TestSpec.of(coin::flip, "coin.flip"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ColorTest.java b/src/test/java/net/datafaker/providers/base/ColorTest.java
index 10294dfab..fb57db094 100644
--- a/src/test/java/net/datafaker/providers/base/ColorTest.java
+++ b/src/test/java/net/datafaker/providers/base/ColorTest.java
@@ -4,20 +4,25 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class ColorTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testName() {
-        assertThat(faker.color().name()).matches("(\\w+ ?){1,2}");
+    private Color color = faker.color();
+
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(color::name, "color.name", "(\\w+ ?){1,2}"));
     }
 
     @Test
     void testHex() {
-        assertThat(faker.color().hex()).matches("^#[0-9A-F]{6}$");
+        assertThat(color.hex()).matches("^#[0-9A-F]{6}$");
     }
 
     @Test
     void testHexNoHashSign() {
-        assertThat(faker.color().hex(false)).matches("^[0-9A-F]{6}$");
+        assertThat(color.hex(false)).matches("^[0-9A-F]{6}$");
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/CommerceTest.java b/src/test/java/net/datafaker/providers/base/CommerceTest.java
index 9653f35d9..fa428f198 100644
--- a/src/test/java/net/datafaker/providers/base/CommerceTest.java
+++ b/src/test/java/net/datafaker/providers/base/CommerceTest.java
@@ -3,6 +3,8 @@
 import org.junit.jupiter.api.Test;
 
 import java.text.DecimalFormatSymbols;
+import java.util.Arrays;
+import java.util.Collection;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -14,48 +16,42 @@ class CommerceTest extends BaseFakerTest<BaseFaker> {
 
     private static final String PROMOTION_CODE_REGEX = CAPITALIZED_WORD_REGEX + "(-" + CAPITALIZED_WORD_REGEX + ")*";
 
+    private Commerce commerce = faker.commerce();
+
     @Test
     void testDepartment() {
-        assertThat(faker.commerce().department()).matches("(\\w+(, | & )?){1,3}");
+        assertThat(commerce.department()).matches("(\\w+(, | & )?){1,3}");
     }
 
     @Test
     void testProductName() {
-        assertThat(faker.commerce().productName()).matches("(\\w+ ?){3,4}");
-    }
-
-    @Test
-    void testMaterial() {
-        assertThat(faker.commerce().material()).matches("\\w+");
+        assertThat(commerce.productName()).matches("(\\w+ ?){3,4}");
     }
 
-    @Test
-    void testBrand() {
-        assertThat(faker.commerce().brand()).matches("\\w+");
-    }
-
-    @Test
-    void testVendor() {
-        assertThat(faker.commerce().vendor()).matches("[A-Za-z'() 0-9-,]+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(commerce::material, "commerce.product_name.material"),
+            TestSpec.of(commerce::brand, "commerce.brand"),
+            TestSpec.of(commerce::vendor, "commerce.vendor"));
     }
 
     @Test
     void testPrice() {
-        assertThat(faker.commerce().price()).matches("\\d{1,3}\\" + decimalSeparator + "\\d{2}");
+        assertThat(commerce.price()).matches("\\d{1,3}\\" + decimalSeparator + "\\d{2}");
     }
 
     @Test
     void testPriceMinMax() {
-        assertThat(faker.commerce().price(100, 1000)).matches("\\d{3,4}\\" + decimalSeparator + "\\d{2}");
+        assertThat(commerce.price(100, 1000)).matches("\\d{3,4}\\" + decimalSeparator + "\\d{2}");
     }
 
     @Test
     void testPromotionCode() {
-        assertThat(faker.commerce().promotionCode()).matches(PROMOTION_CODE_REGEX + PROMOTION_CODE_REGEX + "\\d{6}");
+        assertThat(commerce.promotionCode()).matches(PROMOTION_CODE_REGEX + PROMOTION_CODE_REGEX + "\\d{6}");
     }
 
     @Test
     void testPromotionCodeDigits() {
-        assertThat(faker.commerce().promotionCode(3)).matches(PROMOTION_CODE_REGEX + PROMOTION_CODE_REGEX + "\\d{3}");
+        assertThat(commerce.promotionCode(3)).matches(PROMOTION_CODE_REGEX + PROMOTION_CODE_REGEX + "\\d{3}");
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/CommunityTest.java b/src/test/java/net/datafaker/providers/base/CommunityTest.java
index bcab62b40..8a316218e 100644
--- a/src/test/java/net/datafaker/providers/base/CommunityTest.java
+++ b/src/test/java/net/datafaker/providers/base/CommunityTest.java
@@ -3,11 +3,12 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-public class CommunityTest extends AbstractBasicProviderTest<BaseFaker> {
+public class CommunityTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.community().character(), "community.characters"),
-                TestSpec.of(() -> faker.community().quote(), "community.quotes"));
+        Community community = faker.community();
+        return Arrays.asList(TestSpec.of(community::character, "community.characters"),
+                TestSpec.of(community::quote, "community.quotes"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/CompanyTest.java b/src/test/java/net/datafaker/providers/base/CompanyTest.java
index 8ef65309a..b71311306 100644
--- a/src/test/java/net/datafaker/providers/base/CompanyTest.java
+++ b/src/test/java/net/datafaker/providers/base/CompanyTest.java
@@ -5,51 +5,48 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class CompanyTest extends BaseFakerTest<BaseFaker> {
 
+    private Company company = faker.company();
+
     @Test
     void testName() {
-        assertThat(faker.company().name()).matches("[A-Za-z\\-&', ]+");
+        assertThat(company.name()).matches("[A-Za-z\\-&', ]+");
     }
 
-    @Test
-    void testSuffix() {
-        assertThat(faker.company().suffix()).matches("[A-Za-z ]+");
-    }
-
-    @Test
-    void testIndustry() {
-        assertThat(faker.company().industry()).matches("(\\w+([ ,&/-]{1,3})?){1,4}+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(company::suffix, "company.suffix", "[A-Za-z ]+"),
+            TestSpec.of(company::industry, "company.industry", "(\\w+([ ,&/-]{1,3})?){1,4}+"),
+            TestSpec.of(company::profession, "company.profession"));
     }
 
     @Test
     void testBuzzword() {
-        assertThat(faker.company().buzzword()).matches("(\\w+[ /-]?){1,3}");
+        assertThat(company.buzzword()).matches("(\\w+[ /-]?){1,3}");
     }
 
     @Test
     void testCatchPhrase() {
-        assertThat(faker.company().catchPhrase()).matches("(\\w+[ /-]?){1,9}");
+        assertThat(company.catchPhrase()).matches("(\\w+[ /-]?){1,9}");
     }
 
     @Test
     void testBs() {
-        assertThat(faker.company().bs()).matches("(\\w+[ /-]?){1,9}");
+        assertThat(company.bs()).matches("(\\w+[ /-]?){1,9}");
     }
 
     @Test
     void testLogo() {
-        assertThat(faker.company().logo()).matches("https://pigment.github.io/fake-logos/logos/medium/color/\\d+\\.png");
-    }
-
-    @Test
-    void testProfession() {
-        assertThat(faker.company().profession()).matches("[a-z ]+");
+        assertThat(company.logo()).matches("https://pigment.github.io/fake-logos/logos/medium/color/\\d+\\.png");
     }
 
     @RepeatedTest(100)
     void testUrl() {
         String regexp = "(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])";
-        assertThat(faker.company().url()).matches(regexp);
+        assertThat(company.url()).matches(regexp);
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ComputerTest.java b/src/test/java/net/datafaker/providers/base/ComputerTest.java
index b061008bf..9ae101e2e 100644
--- a/src/test/java/net/datafaker/providers/base/ComputerTest.java
+++ b/src/test/java/net/datafaker/providers/base/ComputerTest.java
@@ -7,20 +7,22 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class ComputerTest extends AbstractBasicProviderTest<BaseFaker> {
+class ComputerTest extends BaseFakerTest<BaseFaker> {
+
+    Computer computer = faker.computer();
 
     @Test
     void testOperatingSystem() {
-        assertThat(faker.computer().operatingSystem()).isNotEmpty();
+        assertThat(computer.operatingSystem()).isNotEmpty();
     }
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.computer().type(), "computer.type"),
-                TestSpec.of(() -> faker.computer().platform(), "computer.platform"),
-                TestSpec.of(() -> faker.computer().linux(), "computer.os.linux"),
-                TestSpec.of(() -> faker.computer().macos(), "computer.os.macos"),
-                TestSpec.of(() -> faker.computer().windows(), "computer.os.windows"),
-                TestSpec.of(() -> faker.computer().brand(), "computer.brand"));
+        return Arrays.asList(TestSpec.of(computer::type, "computer.type"),
+                TestSpec.of(computer::platform, "computer.platform"),
+                TestSpec.of(computer::linux, "computer.os.linux"),
+                TestSpec.of(computer::macos, "computer.os.macos"),
+                TestSpec.of(computer::windows, "computer.os.windows"),
+                TestSpec.of(computer::brand, "computer.brand"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ConstructionTest.java b/src/test/java/net/datafaker/providers/base/ConstructionTest.java
index 5fc67db90..a5d50e45a 100644
--- a/src/test/java/net/datafaker/providers/base/ConstructionTest.java
+++ b/src/test/java/net/datafaker/providers/base/ConstructionTest.java
@@ -3,15 +3,16 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class ConstructionTest extends AbstractBasicProviderTest<BaseFaker> {
+class ConstructionTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.construction().heavyEquipment(), "construction.heavy_equipment"),
-                TestSpec.of(() -> faker.construction().materials(), "construction.materials"),
-                TestSpec.of(() -> faker.construction().subcontractCategories(), "construction.subcontract_categories"),
-                TestSpec.of(() -> faker.construction().roles(), "construction.roles"),
-                TestSpec.of(() -> faker.construction().trades(), "construction.trades"),
-                TestSpec.of(() -> faker.construction().standardCostCodes(), "construction.standard_cost_codes"));
+        Construction construction = faker.construction();
+        return Arrays.asList(TestSpec.of(construction::heavyEquipment, "construction.heavy_equipment"),
+                TestSpec.of(construction::materials, "construction.materials"),
+                TestSpec.of(construction::subcontractCategories, "construction.subcontract_categories"),
+                TestSpec.of(construction::roles, "construction.roles"),
+                TestSpec.of(construction::trades, "construction.trades"),
+                TestSpec.of(construction::standardCostCodes, "construction.standard_cost_codes"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/CosmereTest.java b/src/test/java/net/datafaker/providers/base/CosmereTest.java
index d5cedaecd..fb286cc0f 100644
--- a/src/test/java/net/datafaker/providers/base/CosmereTest.java
+++ b/src/test/java/net/datafaker/providers/base/CosmereTest.java
@@ -4,20 +4,21 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class CosmereTest extends AbstractBasicProviderTest<BaseFaker> {
+class CosmereTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.cosmere().aons(), "cosmere.aons"),
-                TestSpec.of(() -> faker.cosmere().shardWorlds(), "cosmere.shard_worlds"),
-                TestSpec.of(() -> faker.cosmere().shards(), "cosmere.shards"),
-                TestSpec.of(() -> faker.cosmere().surges(), "cosmere.surges"),
-                TestSpec.of(() -> faker.cosmere().knightsRadiant(), "cosmere.knights_radiant"),
-                TestSpec.of(() -> faker.cosmere().metals(), "cosmere.metals"),
-                TestSpec.of(() -> faker.cosmere().allomancers(), "cosmere.allomancers"),
-                TestSpec.of(() -> faker.cosmere().feruchemists(), "cosmere.feruchemists"),
-                TestSpec.of(() -> faker.cosmere().heralds(), "cosmere.heralds"),
-                TestSpec.of(() -> faker.cosmere().sprens(), "cosmere.sprens")
+        Cosmere cosmere = faker.cosmere();
+        return Arrays.asList(TestSpec.of(cosmere::aons, "cosmere.aons"),
+                TestSpec.of(cosmere::shardWorlds, "cosmere.shard_worlds"),
+                TestSpec.of(cosmere::shards, "cosmere.shards"),
+                TestSpec.of(cosmere::surges, "cosmere.surges"),
+                TestSpec.of(cosmere::knightsRadiant, "cosmere.knights_radiant"),
+                TestSpec.of(cosmere::metals, "cosmere.metals"),
+                TestSpec.of(cosmere::allomancers, "cosmere.allomancers"),
+                TestSpec.of(cosmere::feruchemists, "cosmere.feruchemists"),
+                TestSpec.of(cosmere::heralds, "cosmere.heralds"),
+                TestSpec.of(cosmere::sprens, "cosmere.sprens")
                 );
     }
 
diff --git a/src/test/java/net/datafaker/providers/base/CountryTest.java b/src/test/java/net/datafaker/providers/base/CountryTest.java
index e10a579c4..1ef459af9 100644
--- a/src/test/java/net/datafaker/providers/base/CountryTest.java
+++ b/src/test/java/net/datafaker/providers/base/CountryTest.java
@@ -1,48 +1,28 @@
 package net.datafaker.providers.base;
 
 import org.junit.jupiter.api.RepeatedTest;
-import org.junit.jupiter.api.Test;
-
 import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.Arrays;
 import java.util.Collection;
 
-class CountryTest extends AbstractBasicProviderTest<BaseFaker> {
+class CountryTest extends BaseFakerTest<BaseFaker> {
+
+    Country country = faker.country();
 
     @RepeatedTest(10)
     void testFlag() {
-        String flag = faker.country().flag();
+        String flag = country.flag();
         assertThat(flag).matches("^https://flags.fmcdn\\.net/data/flags/w580/[a-zA-Z0-9_]+\\.png$");
     }
 
-    @Test
-    void testCode2() {
-        assertThat(faker.country().countryCode2()).matches("([a-z]{2})");
-    }
-
-    @Test
-    void testCode3() {
-        assertThat(faker.country().countryCode3()).matches("([a-z]{3})");
-    }
-
-    @Test
-    void testCapital() {
-        assertThat(faker.country().capital()).matches("([\\p{L}0-9+,. '-])+");
-    }
-
-    @Test
-    void testCurrency() {
-        assertThat(faker.country().currency()).matches("([A-Za-zÀ-ÿ'’()-]+ ?)+");
-    }
-
-    @Test
-    void testCurrencyCode() {
-        assertThat(faker.country().currencyCode()).matches("([\\w-’í]+ ?)+");
-    }
-
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.country().name(), "country.name"));
+        return Arrays.asList(TestSpec.of(country::countryCode2, "country.code2", "[a-z]{2}"),
+                TestSpec.of(country::countryCode3, "country.code3", "[a-z]{3}"),
+                TestSpec.of(country::capital, "country.capital", "([\\p{L}0-9+,. '-])+"),
+                TestSpec.of(country::currency, "country.currency", "([A-Za-zÀ-ÿ'’()-]+ ?)+"),
+                TestSpec.of(country::currencyCode, "country.currency_code", "([\\w-’í]+ ?)+"),
+                TestSpec.of(country::name, "country.name"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/CryptoCoinTest.java b/src/test/java/net/datafaker/providers/base/CryptoCoinTest.java
index 95b8e6b2f..b3c0a6bde 100644
--- a/src/test/java/net/datafaker/providers/base/CryptoCoinTest.java
+++ b/src/test/java/net/datafaker/providers/base/CryptoCoinTest.java
@@ -3,10 +3,11 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class CryptoCoinTest extends AbstractBasicProviderTest<BaseFaker> {
+class CryptoCoinTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.cryptoCoin().coin(), "crypto_coin.coin"));
+        CryptoCoin cryptoCoin = faker.cryptoCoin();
+        return Arrays.asList(TestSpec.of(cryptoCoin::coin, "crypto_coin.coin"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/CultureSeriesTest.java b/src/test/java/net/datafaker/providers/base/CultureSeriesTest.java
index e08dbe279..576eaff9f 100644
--- a/src/test/java/net/datafaker/providers/base/CultureSeriesTest.java
+++ b/src/test/java/net/datafaker/providers/base/CultureSeriesTest.java
@@ -3,16 +3,17 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class CultureSeriesTest extends AbstractBasicProviderTest<BaseFaker> {
+class CultureSeriesTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.cultureSeries().books(), "culture_series.books"),
-                TestSpec.of(() -> faker.cultureSeries().cultureShips(), "culture_series.culture_ships"),
-                TestSpec.of(() -> faker.cultureSeries().cultureShipClasses(), "culture_series.culture_ship_classes"),
-                TestSpec.of(() -> faker.cultureSeries().cultureShipClassAbvs(), "culture_series.culture_ship_class_abvs"),
-                TestSpec.of(() -> faker.cultureSeries().civs(), "culture_series.civs"),
-                TestSpec.of(() -> faker.cultureSeries().planets(), "culture_series.planets"));
+        CultureSeries cultureSeries = faker.cultureSeries();
+        return Arrays.asList(TestSpec.of(cultureSeries::books, "culture_series.books"),
+                TestSpec.of(cultureSeries::cultureShips, "culture_series.culture_ships"),
+                TestSpec.of(cultureSeries::cultureShipClasses, "culture_series.culture_ship_classes"),
+                TestSpec.of(cultureSeries::cultureShipClassAbvs, "culture_series.culture_ship_class_abvs"),
+                TestSpec.of(cultureSeries::civs, "culture_series.civs"),
+                TestSpec.of(cultureSeries::planets, "culture_series.planets"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/CurrencyTest.java b/src/test/java/net/datafaker/providers/base/CurrencyTest.java
index 12c111fd4..a022adfdf 100644
--- a/src/test/java/net/datafaker/providers/base/CurrencyTest.java
+++ b/src/test/java/net/datafaker/providers/base/CurrencyTest.java
@@ -1,19 +1,14 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class CurrencyTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testName() {
-        assertThat(faker.currency().name()).matches("[\\w'.\\-() ]+");
-    }
-
-    @Test
-    void testCode() {
-        final Currency currency = faker.currency();
-        assertThat(currency.code()).matches("[A-Z]{3}");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Currency currency = faker.currency();
+        return Arrays.asList(TestSpec.of(currency::name, "currency.name", "[\\w'.\\-() ]+"),
+            TestSpec.of(currency::code, "currency.code", "[A-Z]{3}"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/DcComicsTest.java b/src/test/java/net/datafaker/providers/base/DcComicsTest.java
index 232ec95a5..15033da13 100644
--- a/src/test/java/net/datafaker/providers/base/DcComicsTest.java
+++ b/src/test/java/net/datafaker/providers/base/DcComicsTest.java
@@ -3,15 +3,16 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-public class DcComicsTest extends AbstractBasicProviderTest<BaseFaker> {
+public class DcComicsTest extends BaseFakerTest<BaseFaker> {
 
     @Override
-    protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.dcComics().hero(), "dc_comics.hero"),
-                TestSpec.of(() -> faker.dcComics().heroine(), "dc_comics.heroine"),
-                TestSpec.of(() -> faker.dcComics().villain(), "dc_comics.villain"),
-                TestSpec.of(() -> faker.dcComics().name(), "dc_comics.name"),
-                TestSpec.of(() -> faker.dcComics().title(), "dc_comics.title"));
+protected Collection<TestSpec> providerListTest() { 
+        DcComics dcComics = faker.dcComics();
+        return Arrays.asList(TestSpec.of(dcComics::hero, "dc_comics.hero"),
+                TestSpec.of(dcComics::heroine, "dc_comics.heroine"),
+                TestSpec.of(dcComics::villain, "dc_comics.villain"),
+                TestSpec.of(dcComics::name, "dc_comics.name"),
+                TestSpec.of(dcComics::title, "dc_comics.title"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/DemographicTest.java b/src/test/java/net/datafaker/providers/base/DemographicTest.java
index 7b791ae45..fc9f0c993 100644
--- a/src/test/java/net/datafaker/providers/base/DemographicTest.java
+++ b/src/test/java/net/datafaker/providers/base/DemographicTest.java
@@ -1,33 +1,17 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class DemographicTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void race() {
-        assertThat(faker.demographic().race()).matches("(\\w+ ?)+");
-    }
-
-    @Test
-    void educationalAttainment() {
-        assertThat(faker.demographic().educationalAttainment()).matches("(?U)([\\w'-]+ ?)+");
-    }
-
-    @Test
-    void demonym() {
-        assertThat(faker.demographic().demonym()).matches("(?U)([\\w'-]+ ?)+");
-    }
-
-    @Test
-    void maritalStatus() {
-        assertThat(faker.demographic().maritalStatus()).matches("(\\w+ ?)+");
-    }
-
-    @Test
-    void sex() {
-        assertThat(faker.demographic().sex()).matches("\\w+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Demographic demographic = faker.demographic();
+        return Arrays.asList(TestSpec.of(demographic::race, "demographic.race", "(\\w+ ?)+"),
+            TestSpec.of(demographic::educationalAttainment, "demographic.educational_attainment", "(?U)([\\w'-]+ ?)+"),
+            TestSpec.of(demographic::demonym, "demographic.demonym", "(?U)([\\w'-]+ ?)+"),
+            TestSpec.of(demographic::maritalStatus, "demographic.marital_status", "(\\w+ ?)+"),
+            TestSpec.of(demographic::sex, "demographic.sex"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/DeviceTest.java b/src/test/java/net/datafaker/providers/base/DeviceTest.java
index 6014413d3..c83f2204b 100644
--- a/src/test/java/net/datafaker/providers/base/DeviceTest.java
+++ b/src/test/java/net/datafaker/providers/base/DeviceTest.java
@@ -3,14 +3,15 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class DeviceTest extends AbstractBasicProviderTest<BaseFaker> {
+class DeviceTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.device().modelName(), "device.model_name"),
-                TestSpec.of(() -> faker.device().platform(), "device.platform"),
-                TestSpec.of(() -> faker.device().manufacturer(), "device.manufacturer"),
-                TestSpec.of(() -> faker.device().serial(), "device.serial"));
+        Device device = faker.device();
+        return Arrays.asList(TestSpec.of(device::modelName, "device.model_name"),
+                TestSpec.of(device::platform, "device.platform"),
+                TestSpec.of(device::manufacturer, "device.manufacturer"),
+                TestSpec.of(device::serial, "device.serial"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/DiseaseTest.java b/src/test/java/net/datafaker/providers/base/DiseaseTest.java
index 719f65089..f92ac0d3a 100644
--- a/src/test/java/net/datafaker/providers/base/DiseaseTest.java
+++ b/src/test/java/net/datafaker/providers/base/DiseaseTest.java
@@ -1,52 +1,26 @@
 package net.datafaker.providers.base;
 
 import org.junit.jupiter.api.RepeatedTest;
-import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.Arrays;
 import java.util.Collection;
 
-class DiseaseTest extends AbstractBasicProviderTest<BaseFaker> {
+class DiseaseTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testInternalDisease() {
-        assertThat(faker.disease().internalDisease()).matches("[\\p{L}'()., 0-9-’]+");
-    }
-
-    @Test
-    void testNeurology() {
-        assertThat(faker.disease().neurology()).matches("[\\p{L}'()., 0-9-’]+");
-    }
-
-    @Test
-    void testSurgery() {
-        assertThat(faker.disease().surgery()).matches("[\\p{L}'()., 0-9-’]+");
-    }
-
-    @Test
-    void testPaediatrics() {
-        assertThat(faker.disease().paediatrics()).matches("[\\p{L}'()., 0-9-’]+");
-    }
-
-    @Test
-    void testGynecologyAndObstetrics() {
-        assertThat(faker.disease().gynecologyAndObstetrics()).matches("[\\p{L}'()., 0-9-’]+");
-    }
-
-    @Test
-    void testOphthalmologyAndOtorhinolaryngology() {
-        assertThat(faker.disease().ophthalmologyAndOtorhinolaryngology()).matches("[\\p{L}'()., 0-9-’]+");
-    }
-
-    @Test
-    void testDermatology() {
-        assertThat(faker.disease().dermatology()).matches("[\\p{L}'()., 0-9-’]+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Disease disease = faker.disease();
+        return Arrays.asList(TestSpec.of(disease::internalDisease, "disease.internal_disease", "[\\p{L}'()., 0-9-’]+"),
+                TestSpec.of(disease::neurology, "disease.neurology", "[\\p{L}'()., 0-9-’]+"),
+                TestSpec.of(disease::surgery, "disease.surgery", "[\\p{L}'()., 0-9-’]+"),
+                TestSpec.of(disease::paediatrics, "disease.paediatrics", "[\\p{L}'()., 0-9-’]+"),
+                TestSpec.of(disease::gynecologyAndObstetrics, "disease.gynecology_and_obstetrics", "[\\p{L}'()., 0-9-’]+"),
+                TestSpec.of(disease::ophthalmologyAndOtorhinolaryngology, "disease.ophthalmology_and_otorhinolaryngology", "[\\p{L}'()., 0-9-’]+"),
+                TestSpec.of(disease::dermatology, "disease.dermatology", "[\\p{L}'()., 0-9-’]+"));
     }
 
-
-    @Test
     void testInternalDiseaseWith10000Times() {
         boolean isExist = false;
         for (int i = 0; i < 10000; i++) {
@@ -87,14 +61,4 @@ void testOphthalmologyAndOtorhinolaryngologyWith1000Times() {
     void testDermatoloryWith10000Times() {
         assertThat(faker.disease().dermatology()).isNotEmpty();
     }
-
-    @Override
-    protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.disease().neurology(), "disease.neurology"),
-                TestSpec.of(() -> faker.disease().surgery(), "disease.surgery"),
-                TestSpec.of(() -> faker.disease().paediatrics(), "disease.paediatrics"),
-                TestSpec.of(() -> faker.disease().gynecologyAndObstetrics(), "disease.gynecology_and_obstetrics"),
-                TestSpec.of(() -> faker.disease().ophthalmologyAndOtorhinolaryngology(), "disease.ophthalmology_and_otorhinolaryngology"),
-                TestSpec.of(() -> faker.disease().dermatology(), "disease.dermatology"));
-    }
 }
diff --git a/src/test/java/net/datafaker/providers/base/DogTest.java b/src/test/java/net/datafaker/providers/base/DogTest.java
index 09a070397..c1412b5b6 100644
--- a/src/test/java/net/datafaker/providers/base/DogTest.java
+++ b/src/test/java/net/datafaker/providers/base/DogTest.java
@@ -1,48 +1,20 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class DogTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void name() {
-        assertThat(faker.dog().name()).matches("[A-Za-z ]+");
-    }
-
-    @Test
-    void breed() {
-        assertThat(faker.dog().breed()).matches("[A-Za-z ]+");
-    }
-
-    @Test
-    void sound() {
-        assertThat(faker.dog().sound()).matches("[A-Za-z ]+");
-    }
-
-    @Test
-    void memePhrase() {
-        assertThat(faker.dog().memePhrase()).matches("[A-Za-z0-9'/ ]+");
-    }
-
-    @Test
-    void age() {
-        assertThat(faker.dog().age()).matches("[A-Za-z ]+");
-    }
-
-    @Test
-    void gender() {
-        assertThat(faker.dog().gender()).matches("[A-Za-z ]+");
-    }
-
-    @Test
-    void coatLength() {
-        assertThat(faker.dog().coatLength()).matches("[A-Za-z ]+");
-    }
-
-    @Test
-    void size() {
-        assertThat(faker.dog().size()).matches("[A-Za-z ]+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Dog dog = faker.dog();
+        return Arrays.asList(TestSpec.of(dog::name, "creature.dog.name"),
+            TestSpec.of(dog::breed, "creature.dog.breed"),
+            TestSpec.of(dog::sound, "creature.dog.sound"),
+            TestSpec.of(dog::memePhrase, "creature.dog.meme_phrase"),
+            TestSpec.of(dog::age, "creature.dog.age"),
+            TestSpec.of(dog::gender, "creature.dog.gender"),
+            TestSpec.of(dog::coatLength, "creature.dog.coat_length"),
+            TestSpec.of(dog::size, "creature.dog.size"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/DroneTest.java b/src/test/java/net/datafaker/providers/base/DroneTest.java
index 595838194..8fccc0f09 100644
--- a/src/test/java/net/datafaker/providers/base/DroneTest.java
+++ b/src/test/java/net/datafaker/providers/base/DroneTest.java
@@ -8,103 +8,105 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class DroneTest extends AbstractBasicProviderTest<BaseFaker> {
+class DroneTest extends BaseFakerTest<BaseFaker> {
+
+    private Drone drone = faker.drone();
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.drone().name(), "drone.name"),
-                TestSpec.of(() -> faker.drone().batteryType(), "drone.battery_type"),
-                TestSpec.of(() -> faker.drone().iso(), "drone.iso"),
-                TestSpec.of(() -> faker.drone().photoFormat(), "drone.photo_format"),
-                TestSpec.of(() -> faker.drone().videoFormat(), "drone.video_format"),
-                TestSpec.of(() -> faker.drone().maxShutterSpeed(), "drone.max_shutter_speed"),
-                TestSpec.of(() -> faker.drone().minShutterSpeed(), "drone.min_shutter_speed"),
-                TestSpec.of(() -> faker.drone().shutterSpeedUnits(), "drone.shutter_speed_units"));
+        return Arrays.asList(TestSpec.of(drone::name, "drone.name"),
+                TestSpec.of(drone::batteryType, "drone.battery_type"),
+                TestSpec.of(drone::iso, "drone.iso"),
+                TestSpec.of(drone::photoFormat, "drone.photo_format"),
+                TestSpec.of(drone::videoFormat, "drone.video_format"),
+                TestSpec.of(drone::maxShutterSpeed, "drone.max_shutter_speed"),
+                TestSpec.of(drone::minShutterSpeed, "drone.min_shutter_speed"),
+                TestSpec.of(drone::shutterSpeedUnits, "drone.shutter_speed_units"));
     }
 
     @Test
     void weight() {
-        assertThat(faker.drone().weight()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.weight()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxAscentSpeed() {
-        assertThat(faker.drone().maxAscentSpeed()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxAscentSpeed()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxDescentSpeed() {
-        assertThat(faker.drone().maxDescentSpeed()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxDescentSpeed()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void flightTime() {
-        assertThat(faker.drone().flightTime()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.flightTime()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxAltitude() {
-        assertThat(faker.drone().maxAltitude()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxAltitude()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxFlightDistance() {
-        assertThat(faker.drone().maxFlightDistance()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxFlightDistance()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxSpeed() {
-        assertThat(faker.drone().maxSpeed()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxSpeed()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxWindResistance() {
-        assertThat(faker.drone().maxWindResistance()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxWindResistance()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxAngularVelocity() {
-        assertThat(faker.drone().maxAngularVelocity()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxAngularVelocity()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxTiltAngle() {
-        assertThat(faker.drone().maxTiltAngle()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxTiltAngle()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void operatingTemperature() {
-        assertThat(faker.drone().operatingTemperature()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.operatingTemperature()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void batteryCapacity() {
-        assertThat(faker.drone().batteryCapacity()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.batteryCapacity()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void batteryVoltage() {
-        assertThat(faker.drone().batteryVoltage()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.batteryVoltage()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void batteryWeight() {
-        assertThat(faker.drone().batteryWeight()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.batteryWeight()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void chargingTemperature() {
-        assertThat(faker.drone().chargingTemperature()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.chargingTemperature()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxChargingPower() {
-        assertThat(faker.drone().maxChargingPower()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxChargingPower()).isNotEmpty().doesNotContain("#");
     }
 
     @Test
     void maxResolution() {
-        assertThat(faker.drone().maxResolution()).isNotEmpty().doesNotContain("#");
+        assertThat(drone.maxResolution()).isNotEmpty().doesNotContain("#");
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/DungeonsAndDragonsTest.java b/src/test/java/net/datafaker/providers/base/DungeonsAndDragonsTest.java
index 40e525589..0eda2c82b 100644
--- a/src/test/java/net/datafaker/providers/base/DungeonsAndDragonsTest.java
+++ b/src/test/java/net/datafaker/providers/base/DungeonsAndDragonsTest.java
@@ -1,55 +1,21 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
+import java.util.Arrays;
+import java.util.Collection;
 
 class DungeonsAndDragonsTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void alignments() {
-        assertThat(faker.dungeonsAndDragons().alignments()).isNotEmpty();
-    }
-
-    @Test
-    void backgrounds() {
-        assertThat(faker.dungeonsAndDragons().backgrounds()).isNotEmpty();
-    }
-
-    @Test
-    void cities() {
-        assertThat(faker.dungeonsAndDragons().cities()).isNotEmpty();
-    }
-
-    @Test
-    void klasses() {
-        assertThat(faker.dungeonsAndDragons().klasses()).isNotEmpty();
-    }
-
-    @Test
-    void languages() {
-        assertThat(faker.dungeonsAndDragons().languages()).isNotEmpty();
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        DungeonsAndDragons dnd = faker.dungeonsAndDragons();
+        return Arrays.asList(TestSpec.of(dnd::alignments, "dnd.alignments"),
+            TestSpec.of(dnd::backgrounds, "dnd.backgrounds"),
+            TestSpec.of(dnd::cities, "dnd.cities"),
+            TestSpec.of(dnd::klasses, "dnd.klasses"),
+            TestSpec.of(dnd::languages, "dnd.languages"),
+            TestSpec.of(dnd::meleeWeapons, "dnd.melee_weapons"),
+            TestSpec.of(dnd::monsters, "dnd.monsters"),
+            TestSpec.of(dnd::races, "dnd.races"),
+            TestSpec.of(dnd::rangedWeapons, "dnd.ranged_weapons"));
     }
-
-    @Test
-    void meleeWeapons() {
-        assertThat(faker.dungeonsAndDragons().meleeWeapons()).isNotEmpty();
-    }
-
-    @Test
-    void monsters() {
-        assertThat(faker.dungeonsAndDragons().monsters()).isNotEmpty();
-    }
-
-    @Test
-    void races() {
-        assertThat(faker.dungeonsAndDragons().races()).isNotEmpty();
-    }
-
-    @Test
-    void rangedWeapons() {
-        assertThat(faker.dungeonsAndDragons().rangedWeapons()).isNotEmpty();
-    }
-
 }
diff --git a/src/test/java/net/datafaker/providers/base/ElectricalComponentsTest.java b/src/test/java/net/datafaker/providers/base/ElectricalComponentsTest.java
index ea8c88e7f..e54b775bc 100644
--- a/src/test/java/net/datafaker/providers/base/ElectricalComponentsTest.java
+++ b/src/test/java/net/datafaker/providers/base/ElectricalComponentsTest.java
@@ -1,26 +1,15 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class ElectricalComponentsTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testActive() {
-        String activeComponent = faker.electricalComponents().active();
-        assertThat(activeComponent).isNotEmpty();
-    }
-
-    @Test
-    void testPassive() {
-        String passiveComponent = faker.electricalComponents().passive();
-        assertThat(passiveComponent).isNotEmpty();
-    }
-
-    @Test
-    void testElectromechanical() {
-        String electromechanicalComponent = faker.electricalComponents().electromechanical();
-        assertThat(electromechanicalComponent).isNotEmpty();
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        ElectricalComponents electricalComponents = faker.electricalComponents();
+        return Arrays.asList(TestSpec.of(electricalComponents::active, "electrical_components.active"),
+            TestSpec.of(electricalComponents::passive, "electrical_components.passive"),
+            TestSpec.of(electricalComponents::electromechanical, "electrical_components.electromechanical"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/EmojiTest.java b/src/test/java/net/datafaker/providers/base/EmojiTest.java
index 05ad6a1ec..a207108b0 100644
--- a/src/test/java/net/datafaker/providers/base/EmojiTest.java
+++ b/src/test/java/net/datafaker/providers/base/EmojiTest.java
@@ -1,19 +1,15 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class EmojiTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void smiley() {
-        assertThat(faker.emoji().smiley()).isNotEmpty();
-    }
-
-    @Test
-    void cat() {
-        assertThat(faker.emoji().cat()).isNotEmpty();
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Emoji emoji = faker.emoji();
+        
+        return Arrays.asList(TestSpec.of(emoji::smiley, "emoji.smileys"),
+            TestSpec.of(emoji::cat, "emoji.cats"));
     }
-
 }
diff --git a/src/test/java/net/datafaker/providers/base/FinanceTest.java b/src/test/java/net/datafaker/providers/base/FinanceTest.java
index 5f5253892..bbe940239 100644
--- a/src/test/java/net/datafaker/providers/base/FinanceTest.java
+++ b/src/test/java/net/datafaker/providers/base/FinanceTest.java
@@ -6,11 +6,16 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class FinanceTest extends BaseFakerTest<BaseFaker> {
 
+    private Finance finance = faker.finance();
+
     @RepeatedTest(100)
     void creditCard() {
-        final String creditCard = faker.finance().creditCard();
+        final String creditCard = finance.creditCard();
         assertCardLuhnDigit(creditCard);
     }
 
@@ -21,39 +26,38 @@ private void assertCardLuhnDigit(String creditCard) {
 
     @RepeatedTest(10)
     void nasdaqTicker() {
-        assertThat(faker.finance().nasdaqTicker()).matches("[A-Z.-]+");
+        assertThat(finance.nasdaqTicker()).matches("[A-Z.-]+");
     }
 
     @RepeatedTest(10)
     void nyseTicker() {
-        assertThat(faker.finance().nyseTicker()).matches("[A-Z.-]+");
+        assertThat(finance.nyseTicker()).matches("[A-Z.-]+");
     }
 
-    @Test
-    void stockMarket() {
-        assertThat(faker.finance().stockMarket()).matches("[A-Z.-]+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(finance::stockMarket, "finance.stock_market"));
     }
 
-
     @Test
     void bic() {
-        assertThat(faker.finance().bic()).matches("([A-Z]){4}([A-Z]){2}([0-9A-Z]){2}([0-9A-Z]{3})?");
+        assertThat(finance.bic()).matches("([A-Z]){4}([A-Z]){2}([0-9A-Z]){2}([0-9A-Z]{3})?");
     }
 
     @RepeatedTest(100)
     void iban() {
-        assertThat(faker.finance().iban()).matches("[A-Z]{2}\\p{Alnum}{13,30}");
+        assertThat(finance.iban()).matches("[A-Z]{2}\\p{Alnum}{13,30}");
     }
 
     @Test
     void ibanWithCountryCode() {
-        assertThat(faker.finance().iban("DE")).matches("DE\\d{20}");
+        assertThat(finance.iban("DE")).matches("DE\\d{20}");
     }
 
     @Test
     void creditCardWithType() {
         for (CreditCardType type : CreditCardType.values()) {
-            final String creditCard = faker.finance().creditCard(type);
+            final String creditCard = finance.creditCard(type);
             assertCardLuhnDigit(creditCard);
         }
     }
@@ -62,19 +66,19 @@ void creditCardWithType() {
     void costaRicaIbanMustBeValid() {
         final String givenCountryCode = "CR";
         final BaseFaker faker = new BaseFaker();
-        final String ibanFaker = faker.finance().iban(givenCountryCode).toUpperCase(faker.getContext().getLocale());
+        final String ibanFaker = finance.iban(givenCountryCode).toUpperCase(faker.getContext().getLocale());
         assertThat(fr.marcwrobel.jbanking.iban.Iban.isValid(ibanFaker)).isTrue();
     }
 
     @RepeatedTest(100)
     void visaCard() {
-        String creditCard = faker.finance().creditCard(CreditCardType.VISA).replace("-", "");
+        String creditCard = finance.creditCard(CreditCardType.VISA).replace("-", "");
         assertThat(creditCard).startsWith("4").hasSize(16);
     }
 
     @RepeatedTest(100)
     void discoverCard() {
-        String creditCard = faker.finance().creditCard(CreditCardType.DISCOVER).replace("-", "");
+        String creditCard = finance.creditCard(CreditCardType.DISCOVER).replace("-", "");
         assertThat(creditCard).startsWith("6").hasSize(16);
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/FunnyNameTest.java b/src/test/java/net/datafaker/providers/base/FunnyNameTest.java
index 4048412cc..df8e533d6 100644
--- a/src/test/java/net/datafaker/providers/base/FunnyNameTest.java
+++ b/src/test/java/net/datafaker/providers/base/FunnyNameTest.java
@@ -1,13 +1,13 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class FunnyNameTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void name() {
-        assertThat(faker.funnyName().name()).matches("^(\\w+\\.?\\s?'?-?)+$");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        FunnyName funnyName = faker.funnyName();
+        return Arrays.asList(TestSpec.of(funnyName::name, "funny_name.name", "^(\\w+\\.?\\s?'?-?)+$"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/GarmentSizeTest.java b/src/test/java/net/datafaker/providers/base/GarmentSizeTest.java
index c61964c50..87ebfb25d 100644
--- a/src/test/java/net/datafaker/providers/base/GarmentSizeTest.java
+++ b/src/test/java/net/datafaker/providers/base/GarmentSizeTest.java
@@ -4,11 +4,12 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-public class GarmentSizeTest extends AbstractBasicProviderTest<BaseFaker> {
+public class GarmentSizeTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of((() -> faker.garmentSize().size()), "garments_sizes.sizes"));
+        GarmentSize garmetSize = faker.garmentSize();
+        return Arrays.asList(TestSpec.of(garmetSize::size, "garments_sizes.sizes"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/GenderTest.java b/src/test/java/net/datafaker/providers/base/GenderTest.java
index a63ff7fab..c1f847a20 100644
--- a/src/test/java/net/datafaker/providers/base/GenderTest.java
+++ b/src/test/java/net/datafaker/providers/base/GenderTest.java
@@ -1,24 +1,16 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class GenderTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void types() {
-        assertThat(faker.gender().types()).matches("(\\w+ ?){1,2}");
-    }
-
-    @Test
-    void binaryTypes() {
-        assertThat(faker.gender().binaryTypes()).matches("[A-Za-z ]+");
-    }
-
-    @Test
-    void shortBinaryTypes() {
-        assertThat(faker.gender().shortBinaryTypes()).matches("[fm]");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Gender gender = faker.gender();
+        return Arrays.asList(TestSpec.of(gender::types, "gender.types", "(\\w+ ?){1,2}"),
+            TestSpec.of(gender::binaryTypes, "gender.binary_types"),
+            TestSpec.of(gender::shortBinaryTypes, "gender.short_binary_types", "[fm]"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/HackerTest.java b/src/test/java/net/datafaker/providers/base/HackerTest.java
index b526d6693..51adf70a2 100644
--- a/src/test/java/net/datafaker/providers/base/HackerTest.java
+++ b/src/test/java/net/datafaker/providers/base/HackerTest.java
@@ -1,33 +1,17 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class HackerTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testAbbreviation() {
-        assertThat(faker.hacker().abbreviation()).matches("[A-Z]{2,4}");
-    }
-
-    @Test
-    void testAdjective() {
-        assertThat(faker.hacker().adjective()).matches("(\\w+[- ]?){1,2}");
-    }
-
-    @Test
-    void testNoun() {
-        assertThat(faker.hacker().noun()).matches("\\w+( \\w+)?");
-    }
-
-    @Test
-    void testVerb() {
-        assertThat(faker.hacker().verb()).matches("\\w+( \\w+)?");
-    }
-
-    @Test
-    void testIngverb() {
-        assertThat(faker.hacker().ingverb()).matches("\\w+ing( \\w+)?");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Hacker hacker = faker.hacker();
+        return Arrays.asList(TestSpec.of(hacker::abbreviation, "hacker.abbreviation", "[A-Z]{2,4}"),
+            TestSpec.of(hacker::adjective, "hacker.adjective", "(:?\\w+[- ]?){1,2}"),
+            TestSpec.of(hacker::noun, "hacker.noun"),
+            TestSpec.of(hacker::verb, "hacker.verb"),
+            TestSpec.of(hacker::ingverb, "hacker.ingverb", "\\w+ing(:? \\w+)?"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/HipsterTest.java b/src/test/java/net/datafaker/providers/base/HipsterTest.java
index 3d5948bb7..e51d9cc4c 100644
--- a/src/test/java/net/datafaker/providers/base/HipsterTest.java
+++ b/src/test/java/net/datafaker/providers/base/HipsterTest.java
@@ -1,13 +1,13 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class HipsterTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void word() {
-        assertThat(faker.hipster().word()).matches("^([\\w-+&']+ ?)+$");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Hipster hipster = faker.hipster();
+        return Arrays.asList(TestSpec.of(hipster::word, "hipster.words", "^([\\w-+&']+ ?)+$"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/HobbyTest.java b/src/test/java/net/datafaker/providers/base/HobbyTest.java
index 3eca00ffa..0d93c711b 100644
--- a/src/test/java/net/datafaker/providers/base/HobbyTest.java
+++ b/src/test/java/net/datafaker/providers/base/HobbyTest.java
@@ -3,10 +3,11 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class HobbyTest extends AbstractBasicProviderTest<BaseFaker> {
+class HobbyTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.hobby().activity(), "hobby.activity"));
+        Hobby hobby = faker.hobby();
+        return Arrays.asList(TestSpec.of(hobby::activity, "hobby.activity"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/HololiveTest.java b/src/test/java/net/datafaker/providers/base/HololiveTest.java
index c22c026f5..ab2f8d029 100644
--- a/src/test/java/net/datafaker/providers/base/HololiveTest.java
+++ b/src/test/java/net/datafaker/providers/base/HololiveTest.java
@@ -2,17 +2,20 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Locale;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class HololiveTest extends BaseFakerTest<BaseFaker> {
+class HololiveTest extends BaseFakerTest<BaseFaker> {
 
     private static final BaseFaker JA_FAKER = new BaseFaker(new Locale("ja"));
 
-    @Test
-    void talent() {
-        assertThat(faker.hololive().talent()).matches("^[A-Za-z '+-]+$");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Hololive hl = faker.hololive();
+        return Arrays.asList(TestSpec.of(hl::talent, "hololive.talent", "^[A-Za-z '+-]+$"));
     }
 
     @Test
diff --git a/src/test/java/net/datafaker/providers/base/HorseTest.java b/src/test/java/net/datafaker/providers/base/HorseTest.java
index 7f2a6106a..7a616393f 100644
--- a/src/test/java/net/datafaker/providers/base/HorseTest.java
+++ b/src/test/java/net/datafaker/providers/base/HorseTest.java
@@ -3,12 +3,13 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class HorseTest extends AbstractBasicProviderTest<BaseFaker> {
+class HorseTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.horse().name(), "creature.horse.name"),
-                TestSpec.of(() -> faker.horse().breed(), "creature.horse.breed"));
+        Horse horse = faker.horse();
+        return Arrays.asList(TestSpec.of(horse::name, "creature.horse.name"),
+                TestSpec.of(horse::breed, "creature.horse.breed"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/HouseTest.java b/src/test/java/net/datafaker/providers/base/HouseTest.java
index bfbcf0787..e5d588bc8 100644
--- a/src/test/java/net/datafaker/providers/base/HouseTest.java
+++ b/src/test/java/net/datafaker/providers/base/HouseTest.java
@@ -1,18 +1,14 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class HouseTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testFurniture() {
-        assertThat(faker.house().furniture()).matches("^[a-zA-Z ]+$");
-    }
-
-    @Test
-    void testRoom() {
-        assertThat(faker.house().room()).matches("^[a-zA-Z ]+$");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        House house = faker.house();
+        return Arrays.asList(TestSpec.of(house::furniture, "house.furniture"),
+            TestSpec.of(house::room, "house.rooms"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/IndustrySegmentsTest.java b/src/test/java/net/datafaker/providers/base/IndustrySegmentsTest.java
index 815886de8..e912ec43f 100644
--- a/src/test/java/net/datafaker/providers/base/IndustrySegmentsTest.java
+++ b/src/test/java/net/datafaker/providers/base/IndustrySegmentsTest.java
@@ -3,13 +3,14 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-public class IndustrySegmentsTest extends AbstractBasicProviderTest<BaseFaker> {
+public class IndustrySegmentsTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.industrySegments().industry(), "industry_segments.industry"),
-                TestSpec.of(() -> faker.industrySegments().superSector(), "industry_segments.super_sector"),
-                TestSpec.of(() -> faker.industrySegments().sector(), "industry_segments.sector"),
-                TestSpec.of(() -> faker.industrySegments().subSector(), "industry_segments.sub_sector"));
+        IndustrySegments industrySegment = faker.industrySegments();
+        return Arrays.asList(TestSpec.of(industrySegment::industry, "industry_segments.industry"),
+                TestSpec.of(industrySegment::superSector, "industry_segments.super_sector"),
+                TestSpec.of(industrySegment::sector, "industry_segments.sector"),
+                TestSpec.of(industrySegment::subSector, "industry_segments.sub_sector"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/JobTest.java b/src/test/java/net/datafaker/providers/base/JobTest.java
index 3ffc2b7a1..dcf684a26 100644
--- a/src/test/java/net/datafaker/providers/base/JobTest.java
+++ b/src/test/java/net/datafaker/providers/base/JobTest.java
@@ -1,33 +1,16 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class JobTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void field() {
-        assertThat(faker.job().field()).matches("^[A-Z][A-Za-z-]+$");
-    }
-
-    @Test
-    void seniority() {
-        assertThat(faker.job().seniority()).matches("^[A-Z][a-z]+$");
-    }
-
-    @Test
-    void position() {
-        assertThat(faker.job().position()).matches("^[A-Z][a-z]+$");
-    }
-
-    @Test
-    void keySkills() {
-        assertThat(faker.job().keySkills()).matches("([A-Za-z-]+ ?){1,3}");
-    }
-
-    @Test
-    void title() {
-        assertThat(faker.job().title()).matches("([A-Za-z-]+ ?){2,3}");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Job job = faker.job();
+        return Arrays.asList(TestSpec.of(job::field, "job.field"),
+            TestSpec.of(job::seniority, "job.seniority"),
+            TestSpec.of(job::position, "job.position"),
+            TestSpec.of(job::keySkills, "job.key_skills", "(:?[A-Za-z-]+ ?){1,3}"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/KpopTest.java b/src/test/java/net/datafaker/providers/base/KpopTest.java
index 0678965da..5eecec3f0 100644
--- a/src/test/java/net/datafaker/providers/base/KpopTest.java
+++ b/src/test/java/net/datafaker/providers/base/KpopTest.java
@@ -4,15 +4,16 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class KpopTest extends AbstractBasicProviderTest<BaseFaker> {
+class KpopTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.kpop().iGroups(), "kpop.i_groups"),
-                TestSpec.of(() -> faker.kpop().iiGroups(), "kpop.ii_groups"),
-                TestSpec.of(() -> faker.kpop().iiiGroups(), "kpop.iii_groups"),
-                TestSpec.of(() -> faker.kpop().girlGroups(), "kpop.girl_groups"),
-                TestSpec.of(() -> faker.kpop().boyBands(), "kpop.boy_bands"),
-                TestSpec.of(() -> faker.kpop().solo(), "kpop.solo"));
+        Kpop kpop = faker.kpop();
+        return Arrays.asList(TestSpec.of(kpop::iGroups, "kpop.i_groups"),
+                TestSpec.of(kpop::iiGroups, "kpop.ii_groups"),
+                TestSpec.of(kpop::iiiGroups, "kpop.iii_groups"),
+                TestSpec.of(kpop::girlGroups, "kpop.girl_groups"),
+                TestSpec.of(kpop::boyBands, "kpop.boy_bands"),
+                TestSpec.of(kpop::solo, "kpop.solo"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/LoremTest.java b/src/test/java/net/datafaker/providers/base/LoremTest.java
index 76df25392..2fd0e054a 100644
--- a/src/test/java/net/datafaker/providers/base/LoremTest.java
+++ b/src/test/java/net/datafaker/providers/base/LoremTest.java
@@ -13,37 +13,39 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-class LoremTest extends AbstractBasicProviderTest<BaseFaker> {
+class LoremTest extends BaseFakerTest<BaseFaker> {
+
+    private Lorem lorem = faker.lorem();
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.lorem().word(), "lorem.words"));
+        return Arrays.asList(TestSpec.of(lorem::word, "lorem.words"));
     }
 
     @Test
     void shouldCreateFixedLengthString() {
-        assertThat(faker.lorem().fixedString(10)).hasSize(10);
-        assertThat(faker.lorem().fixedString(50)).hasSize(50);
-        assertThat(faker.lorem().fixedString(0)).isEmpty();
-        assertThat(faker.lorem().fixedString(-1)).isEmpty();
+        assertThat(lorem.fixedString(10)).hasSize(10);
+        assertThat(lorem.fixedString(50)).hasSize(50);
+        assertThat(lorem.fixedString(0)).isEmpty();
+        assertThat(lorem.fixedString(-1)).isEmpty();
     }
 
     @Test
     void testCharacter() {
-        assertThat(String.valueOf(faker.lorem().character())).matches("[a-z\\d]");
+        assertThat(String.valueOf(lorem.character())).matches("[a-z\\d]");
     }
 
     @Test
     void testCharacterIncludeUpperCase() {
-        assertThat(String.valueOf(faker.lorem().character(false))).matches("[a-z\\d]");
-        assertThat(String.valueOf(faker.lorem().character(true))).matches("[a-zA-Z\\d]");
+        assertThat(String.valueOf(lorem.character(false))).matches("[a-z\\d]");
+        assertThat(String.valueOf(lorem.character(true))).matches("[a-zA-Z\\d]");
     }
 
     @Test
     void testCharactersShouldIncludeMinAndMaxLenght() {
         List<String> results = new ArrayList<>();
         for (int i = 0; i < 300; i++) {
-            results.add(faker.lorem().characters(1, 10));
+            results.add(lorem.characters(1, 10));
         }
 
         final List<String> min = results.stream().filter(x -> x.length() == 1).collect(Collectors.toList());
@@ -55,77 +57,77 @@ void testCharactersShouldIncludeMinAndMaxLenght() {
 
     @Test
     void testCharacters() {
-        assertThat(faker.lorem().characters()).matches("[a-z\\d]{255}");
+        assertThat(lorem.characters()).matches("[a-z\\d]{255}");
     }
 
     @Test
     void testCharactersIncludeUpperCase() {
-        assertThat(faker.lorem().characters(false)).matches("[a-z\\d]{255}");
-        assertThat(faker.lorem().characters(true)).matches("[a-zA-Z\\d]{255}");
+        assertThat(lorem.characters(false)).matches("[a-z\\d]{255}");
+        assertThat(lorem.characters(true)).matches("[a-zA-Z\\d]{255}");
     }
 
     @Test
     void testCharactersWithLength() {
-        assertThat(faker.lorem().characters(2)).matches("[a-z\\d]{2}");
-        assertThat(faker.lorem().characters(500)).matches("[a-z\\d]{500}");
-        assertThat(faker.lorem().characters(0)).isEmpty();
-        assertThat(faker.lorem().characters(-1)).isEmpty();
+        assertThat(lorem.characters(2)).matches("[a-z\\d]{2}");
+        assertThat(lorem.characters(500)).matches("[a-z\\d]{500}");
+        assertThat(lorem.characters(0)).isEmpty();
+        assertThat(lorem.characters(-1)).isEmpty();
     }
 
     @Test
     void testCharactersWithLengthIncludeUppercase() {
-        assertThat(faker.lorem().characters(2, false)).matches("[a-z\\d]{2}");
-        assertThat(faker.lorem().characters(500, false)).matches("[a-z\\d]{500}");
-        assertThat(faker.lorem().characters(2, true)).matches("[a-zA-Z\\d]{2}");
-        assertThat(faker.lorem().characters(500, true)).matches("[a-zA-Z\\d]{500}");
-        assertThat(faker.lorem().characters(0, false)).isEmpty();
-        assertThat(faker.lorem().characters(-1, true)).isEmpty();
+        assertThat(lorem.characters(2, false)).matches("[a-z\\d]{2}");
+        assertThat(lorem.characters(500, false)).matches("[a-z\\d]{500}");
+        assertThat(lorem.characters(2, true)).matches("[a-zA-Z\\d]{2}");
+        assertThat(lorem.characters(500, true)).matches("[a-zA-Z\\d]{500}");
+        assertThat(lorem.characters(0, false)).isEmpty();
+        assertThat(lorem.characters(-1, true)).isEmpty();
     }
 
     @Test
     void testCharactersMinimumMaximumLength() {
-        assertThat(faker.lorem().characters(1, 10)).matches("[a-z\\d]{1,10}");
+        assertThat(lorem.characters(1, 10)).matches("[a-z\\d]{1,10}");
     }
 
     @RepeatedTest(10)
     void testCharactersMinimumMaximumLengthEquals() {
-        assertThat(faker.lorem().characters(5, 5)).matches("[a-z\\d]{5}");
+        assertThat(lorem.characters(5, 5)).matches("[a-z\\d]{5}");
     }
 
     @RepeatedTest(10)
     void testCharactersMinimumMaximumLengthEqualsIncludingUppercaseAndIncludingDigit() {
-        assertThat(faker.lorem().characters(6, 10, true, true)).matches("[a-zA-Z\\d]{6,10}");
+        assertThat(lorem.characters(6, 10, true, true)).matches("[a-zA-Z\\d]{6,10}");
     }
 
     @RepeatedTest(10)
     void testCharactersFixedLengthIncludingUppercaseAndIncludingDigit() {
-        assertThat(faker.lorem().characters(10, true, true)).matches("[a-zA-Z\\d]{10}");
+        assertThat(lorem.characters(10, true, true)).matches("[a-zA-Z\\d]{10}");
     }
 
     @Test
     void testFixedNumberOfCharactersEmpty() {
-        assertThat(faker.lorem().characters(-1)).isEmpty();
-        assertThat(faker.lorem().characters(0)).isEmpty();
+        assertThat(lorem.characters(-1)).isEmpty();
+        assertThat(lorem.characters(0)).isEmpty();
 
-        assertThat(faker.lorem().characters(-1, true, true, true)).isEmpty();
-        assertThat(faker.lorem().characters(0, false, false, false)).isEmpty();
+        assertThat(lorem.characters(-1, true, true, true)).isEmpty();
+        assertThat(lorem.characters(0, false, false, false)).isEmpty();
     }
 
 
     @Test
     void testCharactersMinimumMaximumLengthIncludeUppercase() {
-        assertThat(faker.lorem().characters(1, 10, true)).matches("[a-zA-Z\\d]{1,10}");
+        assertThat(lorem.characters(1, 10, true)).matches("[a-zA-Z\\d]{1,10}");
     }
 
     @Test
     void testCharactersMinimumMaximumLengthIncludeUppercaseIncludeDigit() {
-        assertThat(faker.lorem().characters(1, 10, false, false)).matches("[a-zA-Z]{1,10}");
-        assertThat(faker.lorem().characters(2, 10, true, true)).matches("[a-zA-Z\\d]{1,10}");
+        assertThat(lorem.characters(1, 10, false, false)).matches("[a-zA-Z]{1,10}");
+        assertThat(lorem.characters(2, 10, true, true)).matches("[a-zA-Z\\d]{1,10}");
     }
 
     @Test
     void testSentence() {
-        String sentence = faker.lorem().sentence();
+        String sentence = lorem.sentence();
         String[] words = sentence.split(" ");
 
         assertThat(words.length).isBetween(3, 9);
@@ -134,7 +136,7 @@ void testSentence() {
 
     @Test
     void testSentenceWithWordCount() {
-        String sentence = faker.lorem().sentence(10);
+        String sentence = lorem.sentence(10);
         String[] words = sentence.split(" ");
 
         assertThat(words.length).isBetween(9, 15);
@@ -143,17 +145,17 @@ void testSentenceWithWordCount() {
 
     @RepeatedTest(10)
     void testSentenceWithWordCountAndRandomWordsToAdd() {
-        assertThat(faker.lorem().sentence(10, 10)).matches("(\\w+\\s?){10,20}\\.");
+        assertThat(lorem.sentence(10, 10)).matches("(\\w+\\s?){10,20}\\.");
     }
 
     @RepeatedTest(10)
     void testSentenceFixedNumberOfWords() {
-        assertThat(faker.lorem().sentence(10, 0)).matches("(\\w+\\s?){10}\\.");
+        assertThat(lorem.sentence(10, 0)).matches("(\\w+\\s?){10}\\.");
     }
 
     @Test
     void testWords() {
-        assertThat(faker.lorem().words()).isNotEmpty();
+        assertThat(lorem.words()).isNotEmpty();
     }
 
     @RepeatedTest(10)
@@ -161,32 +163,32 @@ void testMaxLengthSentence() {
         Random rand = new Random();
         // Test different lengths over 10 runs
         int length = Math.abs(rand.nextInt(10000));
-        String s = faker.lorem().maxLengthSentence(length);
+        String s = lorem.maxLengthSentence(length);
         assertThat(s).hasSize(length);
     }
 
     @Test
     void testMaxLengthWithEmptySentence() {
-        String s = faker.lorem().maxLengthSentence(0);
+        String s = lorem.maxLengthSentence(0);
         assertThat(s).isEmpty();
     }
 
     @Test
     void testMaxLengthWithNegativeLengthSentence() {
-        String s = faker.lorem().maxLengthSentence(-1);
+        String s = lorem.maxLengthSentence(-1);
         assertThat(s).isEmpty();
     }
 
     @RepeatedTest(10)
     void testSentences() {
-        String paragraph = faker.lorem().paragraph();
+        String paragraph = lorem.paragraph();
         int matches = StringUtils.countMatches(paragraph, ".");
         assertThat(matches).isBetween(3, 6);
     }
 
     @RepeatedTest(10)
     void testSentencesWithCount() {
-        String paragraph = faker.lorem().paragraph(1);
+        String paragraph = lorem.paragraph(1);
         int matches = StringUtils.countMatches(paragraph, ".");
         assertThat(matches).isBetween(1, 3);
     }
diff --git a/src/test/java/net/datafaker/providers/base/MarketingTest.java b/src/test/java/net/datafaker/providers/base/MarketingTest.java
index dccd469a8..2a4ffae8a 100644
--- a/src/test/java/net/datafaker/providers/base/MarketingTest.java
+++ b/src/test/java/net/datafaker/providers/base/MarketingTest.java
@@ -3,11 +3,12 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class MarketingTest extends AbstractBasicProviderTest<BaseFaker> {
+class MarketingTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.marketing().buzzwords(), "marketing.buzzwords"));
+        Marketing marketing = faker.marketing();
+        return Arrays.asList(TestSpec.of(marketing::buzzwords, "marketing.buzzwords"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/MatzTest.java b/src/test/java/net/datafaker/providers/base/MatzTest.java
index ab040f009..7064e3d5e 100644
--- a/src/test/java/net/datafaker/providers/base/MatzTest.java
+++ b/src/test/java/net/datafaker/providers/base/MatzTest.java
@@ -3,10 +3,11 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class MatzTest extends AbstractBasicProviderTest<BaseFaker> {
+class MatzTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.matz().quote(), "matz.quotes"));
+        Matz matz = faker.matz();
+        return Arrays.asList(TestSpec.of(matz::quote, "matz.quotes"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/MbtiTest.java b/src/test/java/net/datafaker/providers/base/MbtiTest.java
index 57c5c6af1..f2004a2ea 100644
--- a/src/test/java/net/datafaker/providers/base/MbtiTest.java
+++ b/src/test/java/net/datafaker/providers/base/MbtiTest.java
@@ -7,37 +7,39 @@
 
 class MbtiTest extends BaseFakerTest<BaseFaker> {
 
+    private Mbti mbti = faker.mbti();
+
     @Test
     void type() {
-        assertThat(isNullOrEmpty(faker.mbti().type())).isFalse();
-        assertThat(faker.mbti().type()).matches("[A-Za-z,\\-.() ]+");
+        assertThat(isNullOrEmpty(mbti.type())).isFalse();
+        assertThat(mbti.type()).matches("[A-Za-z,\\-.() ]+");
     }
 
     @Test
     void name() {
-        assertThat(isNullOrEmpty(faker.mbti().name())).isFalse();
-        assertThat(faker.mbti().name()).matches("[A-Za-z,\\-.();:'$ ]+");
+        assertThat(isNullOrEmpty(mbti.name())).isFalse();
+        assertThat(mbti.name()).matches("[A-Za-z,\\-.();:'$ ]+");
     }
 
     @Test
     void characteristic() {
-        assertThat(isNullOrEmpty(faker.mbti().characteristic())).isFalse();
+        assertThat(isNullOrEmpty(mbti.characteristic())).isFalse();
     }
 
     @Test
     void personage() {
-        assertThat(isNullOrEmpty(faker.mbti().personage())).isFalse();
-        assertThat(faker.mbti().personage()).matches("[A-Za-z,\\-.()';:$ ]+");
+        assertThat(isNullOrEmpty(mbti.personage())).isFalse();
+        assertThat(mbti.personage()).matches("[A-Za-z,\\-.()';:$ ]+");
     }
 
     @Test
     void merit() {
-        assertThat(isNullOrEmpty(faker.mbti().merit())).isFalse();
+        assertThat(isNullOrEmpty(mbti.merit())).isFalse();
     }
 
     @Test
     void weakness() {
-        assertThat(isNullOrEmpty(faker.mbti().weakness())).isFalse();
+        assertThat(isNullOrEmpty(mbti.weakness())).isFalse();
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/MeasurementTest.java b/src/test/java/net/datafaker/providers/base/MeasurementTest.java
index 63662146e..b86bc8809 100644
--- a/src/test/java/net/datafaker/providers/base/MeasurementTest.java
+++ b/src/test/java/net/datafaker/providers/base/MeasurementTest.java
@@ -1,50 +1,22 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.RepeatedTest;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class MeasurementTest extends BaseFakerTest<BaseFaker> {
 
     public static final String WORDS = "^[a-z ]+$";
 
-    @RepeatedTest(10)
-    void testHeight() {
-        assertThat(faker.measurement().height()).matches(WORDS);
-    }
-
-    @RepeatedTest(10)
-    void testLength() {
-        assertThat(faker.measurement().length()).matches(WORDS);
-    }
-
-    @RepeatedTest(10)
-    void testVolume() {
-        assertThat(faker.measurement().volume()).matches(WORDS);
-    }
-
-    @RepeatedTest(10)
-    void testWeight() {
-        assertThat(faker.measurement().weight()).matches(WORDS);
-    }
-
-    @RepeatedTest(10)
-    void testMetricHeight() {
-        assertThat(faker.measurement().metricHeight()).matches(WORDS);
-    }
-
-    @RepeatedTest(10)
-    void testMetricLength() {
-        assertThat(faker.measurement().metricLength()).matches(WORDS);
-    }
-
-    @RepeatedTest(10)
-    void testMetricVolume() {
-        assertThat(faker.measurement().metricVolume()).matches(WORDS);
-    }
-
-    @RepeatedTest(10)
-    void testMetricWeight() {
-        assertThat(faker.measurement().metricWeight()).matches(WORDS);
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Measurement measurement = faker.measurement();
+        return Arrays.asList(TestSpec.of(measurement::height, "measurement.height"),
+            TestSpec.of(measurement::length, "measurement.length"),
+            TestSpec.of(measurement::volume, "measurement.volume"),
+            TestSpec.of(measurement::weight, "measurement.weight"),
+            TestSpec.of(measurement::metricLength, "measurement.metric_length"),
+            TestSpec.of(measurement::metricHeight, "measurement.metric_height"),
+            TestSpec.of(measurement::metricVolume, "measurement.metric_volume"),
+            TestSpec.of(measurement::metricWeight, "measurement.metric_weight"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/MedicalTest.java b/src/test/java/net/datafaker/providers/base/MedicalTest.java
index 7d67dc583..86121d71f 100644
--- a/src/test/java/net/datafaker/providers/base/MedicalTest.java
+++ b/src/test/java/net/datafaker/providers/base/MedicalTest.java
@@ -9,14 +9,15 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-class MedicalTest extends AbstractBasicProviderTest<BaseFaker> {
+class MedicalTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.medical().medicineName(), "medical.medicine_name"),
-                TestSpec.of(() -> faker.medical().diseaseName(), "medical.disease_name"),
-                TestSpec.of(() -> faker.medical().hospitalName(), "medical.hospital_name"),
-                TestSpec.of(() -> faker.medical().symptoms(), "medical.symptoms"));
+        Medical medical = faker.medical();
+        return Arrays.asList(TestSpec.of(medical::medicineName, "medical.medicine_name"),
+                TestSpec.of(medical::diseaseName, "medical.disease_name"),
+                TestSpec.of(medical::hospitalName, "medical.hospital_name"),
+                TestSpec.of(medical::symptoms, "medical.symptoms"));
     }
 
     @Test
diff --git a/src/test/java/net/datafaker/providers/base/MilitaryTest.java b/src/test/java/net/datafaker/providers/base/MilitaryTest.java
index 180948236..64b4661aa 100644
--- a/src/test/java/net/datafaker/providers/base/MilitaryTest.java
+++ b/src/test/java/net/datafaker/providers/base/MilitaryTest.java
@@ -3,15 +3,16 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class MilitaryTest extends AbstractBasicProviderTest<BaseFaker> {
+class MilitaryTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.military().armyRank(), "military.army_rank"),
-                TestSpec.of(() -> faker.military().marinesRank(), "military.marines_rank"),
-                TestSpec.of(() -> faker.military().navyRank(), "military.navy_rank"),
-                TestSpec.of(() -> faker.military().airForceRank(), "military.air_force_rank"),
-                TestSpec.of(() -> faker.military().dodPaygrade(), "military.dod_paygrade"));
+        Military military = faker.military();
+        return Arrays.asList(TestSpec.of(military::armyRank, "military.army_rank"),
+                TestSpec.of(military::marinesRank, "military.marines_rank"),
+                TestSpec.of(military::navyRank, "military.navy_rank"),
+                TestSpec.of(military::airForceRank, "military.air_force_rank"),
+                TestSpec.of(military::dodPaygrade, "military.dod_paygrade"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/MoneyTest.java b/src/test/java/net/datafaker/providers/base/MoneyTest.java
index df56c2ab6..15355d0e5 100644
--- a/src/test/java/net/datafaker/providers/base/MoneyTest.java
+++ b/src/test/java/net/datafaker/providers/base/MoneyTest.java
@@ -1,19 +1,14 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.util.Strings.isNullOrEmpty;
+import java.util.Arrays;
+import java.util.Collection;
 
 class MoneyTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testCurrency() {
-        assertThat(isNullOrEmpty(faker.money().currency())).isFalse();
-    }
-
-    @Test
-    void testCurrencyCode() {
-        assertThat(isNullOrEmpty(faker.money().currencyCode())).isFalse();
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Money money = faker.money();
+        return Arrays.asList(TestSpec.of(money::currency, "money.currency"),
+            TestSpec.of(money::currencyCode, "money.code"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/MoodTest.java b/src/test/java/net/datafaker/providers/base/MoodTest.java
index 22648bdf5..3cfd5a44c 100644
--- a/src/test/java/net/datafaker/providers/base/MoodTest.java
+++ b/src/test/java/net/datafaker/providers/base/MoodTest.java
@@ -1,24 +1,16 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class MoodTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void feeling() {
-        assertThat(faker.mood().feeling()).matches("[a-zA-Z]+");
-    }
-
-    @Test
-    void emotion() {
-        assertThat(faker.mood().emotion()).matches("[a-zA-Z]+");
-    }
-
-    @Test
-    void tone() {
-        assertThat(faker.mood().tone()).matches("[a-zA-Z]+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Mood mood = faker.mood();
+        return Arrays.asList(TestSpec.of(mood::feeling, "mood.feeling"),
+            TestSpec.of(mood::emotion, "mood.emotion"),
+            TestSpec.of(mood::tone, "mood.tone"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/MountainTest.java b/src/test/java/net/datafaker/providers/base/MountainTest.java
index 2dfbba7f1..b05d0cef1 100644
--- a/src/test/java/net/datafaker/providers/base/MountainTest.java
+++ b/src/test/java/net/datafaker/providers/base/MountainTest.java
@@ -3,11 +3,12 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class MountainTest extends AbstractBasicProviderTest<BaseFaker> {
+class MountainTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.mountain().name(), "mountain.name"),
-                TestSpec.of(() -> faker.mountain().range(), "mountain.range"));
+        Mountain mountain = faker.mountain();
+        return Arrays.asList(TestSpec.of(mountain::name, "mountain.name"),
+                TestSpec.of(mountain::range, "mountain.range"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/MountaineeringTest.java b/src/test/java/net/datafaker/providers/base/MountaineeringTest.java
index c31101214..8f969819f 100644
--- a/src/test/java/net/datafaker/providers/base/MountaineeringTest.java
+++ b/src/test/java/net/datafaker/providers/base/MountaineeringTest.java
@@ -3,10 +3,11 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class MountaineeringTest extends AbstractBasicProviderTest<BaseFaker> {
+class MountaineeringTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.mountaineering().mountaineer(), "mountaineering.mountaineer"));
+        Mountaineering mountaineering = faker.mountaineering();
+        return Arrays.asList(TestSpec.of(mountaineering::mountaineer, "mountaineering.mountaineer"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/MusicTest.java b/src/test/java/net/datafaker/providers/base/MusicTest.java
index e87e65416..cc2425ed6 100644
--- a/src/test/java/net/datafaker/providers/base/MusicTest.java
+++ b/src/test/java/net/datafaker/providers/base/MusicTest.java
@@ -5,11 +5,15 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class MusicTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void instrument() {
-        assertThat(faker.music().instrument()).matches("\\w+ ?\\w+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Music music = faker.music();
+        return Arrays.asList(TestSpec.of(music::instrument, "music.instruments", "\\w+ ?\\w+"));
     }
 
     @Test
diff --git a/src/test/java/net/datafaker/providers/base/NameTest.java b/src/test/java/net/datafaker/providers/base/NameTest.java
index d22fcbc59..d8a9c01ca 100644
--- a/src/test/java/net/datafaker/providers/base/NameTest.java
+++ b/src/test/java/net/datafaker/providers/base/NameTest.java
@@ -14,15 +14,16 @@ class NameTest extends BaseFakerTest<BaseFaker> {
 
     @Spy
     private BaseFaker mockedFaker;
+    private Name name = faker.name();
 
     @Test
     void testName() {
-        assertThat(faker.name().name()).matches("([\\w']+\\.?( )?){2,3}");
+        assertThat(name.name()).matches("([\\w']+\\.?( )?){2,3}");
     }
 
     @Test
     void testNameWithMiddle() {
-        assertThat(faker.name().nameWithMiddle()).matches("([\\w']+\\.?( )?){3,4}");
+        assertThat(name.nameWithMiddle()).matches("([\\w']+\\.?( )?){3,4}");
     }
 
     @Test
@@ -30,7 +31,7 @@ void testNameWithMiddleDoesNotHaveRepeatedName() {
         int theSameNameCnt = 0;
         int total = 100;
         for (int i = 0; i < total; i++) {
-            String nameWithMiddle = faker.name().nameWithMiddle();
+            String nameWithMiddle = name.nameWithMiddle();
             String[] splitNames = nameWithMiddle.split(" ");
             if (splitNames[0].equals(splitNames[1])) {
                 theSameNameCnt++;
@@ -41,7 +42,7 @@ void testNameWithMiddleDoesNotHaveRepeatedName() {
 
     @Test
     void testFullName() {
-        assertThat(faker.name().fullName()).matches("([\\w']+\\.?( )?){2,4}");
+        assertThat(name.fullName()).matches("([\\w']+\\.?( )?){2,4}");
     }
 
     @Test
@@ -55,32 +56,32 @@ void testFullNameArabic() {
 
     @Test
     void testFirstName() {
-        assertThat(faker.name().firstName()).matches("\\w+");
+        assertThat(name.firstName()).matches("\\w+");
     }
 
     @Test
     void testLastName() {
-        assertThat(faker.name().lastName()).matches("[A-Za-z']+");
+        assertThat(name.lastName()).matches("[A-Za-z']+");
     }
 
     @Test
     void testPrefix() {
-        assertThat(faker.name().prefix()).matches("\\w+\\.?");
+        assertThat(name.prefix()).matches("\\w+\\.?");
     }
 
     @Test
     void testSuffix() {
-        assertThat(faker.name().suffix()).matches("\\w+\\.?");
+        assertThat(name.suffix()).matches("\\w+\\.?");
     }
 
     @Test
     void testTitle() {
-        assertThat(faker.name().title()).matches("(\\w+\\.?( )?){3}");
+        assertThat(name.title()).matches("(\\w+\\.?( )?){3}");
     }
 
     @RepeatedTest(100)
     void testUsername() {
-        assertThat(faker.name().username()).matches("^(\\w+)\\.(\\w+)$");
+        assertThat(name.username()).matches("^(\\w+)\\.(\\w+)$");
     }
 
     @Test
diff --git a/src/test/java/net/datafaker/providers/base/NationTest.java b/src/test/java/net/datafaker/providers/base/NationTest.java
index a398273e1..27fc9b008 100644
--- a/src/test/java/net/datafaker/providers/base/NationTest.java
+++ b/src/test/java/net/datafaker/providers/base/NationTest.java
@@ -6,24 +6,26 @@
 
 class NationTest extends BaseFakerTest<BaseFaker> {
 
+    Nation nation = faker.nation();
+
     @Test
     void nationality() {
-        assertThat(faker.nation().nationality()).matches("\\P{Cc}+");
+        assertThat(nation.nationality()).matches("\\P{Cc}+");
     }
 
     @Test
     void language() {
-        assertThat(faker.nation().language()).matches("[A-Za-z ]+");
+        assertThat(nation.language()).matches("[A-Za-z ]+");
     }
 
     @Test
     void capitalCity() {
-        assertThat(faker.nation().capitalCity()).matches("[A-Za-z .'()-]+");
+        assertThat(nation.capitalCity()).matches("[A-Za-z .'()-]+");
     }
 
     @Test
     void flag() {
-        String flag = faker.nation().flag();
+        String flag = nation.flag();
 
         // all utf8 emoji flags are at least 4 characters long and start with the same char
         assertThat(flag).hasSizeGreaterThanOrEqualTo(4);
@@ -32,11 +34,11 @@ void flag() {
 
     @Test
     void isoLanguage() {
-        assertThat(faker.nation().isoLanguage()).matches("[a-z]{2}");
+        assertThat(nation.isoLanguage()).matches("[a-z]{2}");
     }
 
     @Test
     void isoCountry() {
-        assertThat(faker.nation().isoCountry()).matches("[A-Z]{2}");
+        assertThat(nation.isoCountry()).matches("[A-Z]{2}");
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/NatoPhoneticAlphabetTest.java b/src/test/java/net/datafaker/providers/base/NatoPhoneticAlphabetTest.java
index d0afa361a..a27141077 100644
--- a/src/test/java/net/datafaker/providers/base/NatoPhoneticAlphabetTest.java
+++ b/src/test/java/net/datafaker/providers/base/NatoPhoneticAlphabetTest.java
@@ -3,11 +3,12 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class NatoPhoneticAlphabetTest extends AbstractBasicProviderTest<BaseFaker> {
+class NatoPhoneticAlphabetTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.natoPhoneticAlphabet().codeWord(), "nato_phonetic_alphabet.code_word"));
+        NatoPhoneticAlphabet natoAlpha = faker.natoPhoneticAlphabet();
+        return Arrays.asList(TestSpec.of(natoAlpha::codeWord, "nato_phonetic_alphabet.code_word"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/NigeriaTest.java b/src/test/java/net/datafaker/providers/base/NigeriaTest.java
index 4dfabab37..a68edf741 100644
--- a/src/test/java/net/datafaker/providers/base/NigeriaTest.java
+++ b/src/test/java/net/datafaker/providers/base/NigeriaTest.java
@@ -3,14 +3,15 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class NigeriaTest extends AbstractBasicProviderTest<BaseFaker> {
+class NigeriaTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.nigeria().places(), "nigeria.places"),
-                TestSpec.of(() -> faker.nigeria().food(), "nigeria.food"),
-                TestSpec.of(() -> faker.nigeria().name(), "nigeria.name"),
-                TestSpec.of(() -> faker.nigeria().schools(), "nigeria.schools"),
-                TestSpec.of(() -> faker.nigeria().celebrities(), "nigeria.celebrities"));
+        Nigeria nigeria = faker.nigeria();
+        return Arrays.asList(TestSpec.of(nigeria::places, "nigeria.places"),
+                TestSpec.of(nigeria::food, "nigeria.food"),
+                TestSpec.of(nigeria::name, "nigeria.name"),
+                TestSpec.of(nigeria::schools, "nigeria.schools"),
+                TestSpec.of(nigeria::celebrities, "nigeria.celebrities"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/OlympicSportTest.java b/src/test/java/net/datafaker/providers/base/OlympicSportTest.java
index 0c36c675a..1f587f0e7 100644
--- a/src/test/java/net/datafaker/providers/base/OlympicSportTest.java
+++ b/src/test/java/net/datafaker/providers/base/OlympicSportTest.java
@@ -3,16 +3,17 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class OlympicSportTest extends AbstractBasicProviderTest<BaseFaker> {
+class OlympicSportTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.olympicSport().summerOlympics(), "olympic_sport.summer_olympics"),
-                TestSpec.of(() -> faker.olympicSport().winterOlympics(), "olympic_sport.winter_olympics"),
-                TestSpec.of(() -> faker.olympicSport().summerParalympics(), "olympic_sport.summer_paralympics"),
-                TestSpec.of(() -> faker.olympicSport().winterParalympics(), "olympic_sport.winter_paralympics"),
-                TestSpec.of(() -> faker.olympicSport().ancientOlympics(), "olympic_sport.ancient_olympics"),
-                TestSpec.of(() -> faker.olympicSport().unusual(), "olympic_sport.unusual"));
+        OlympicSport olympicSport = faker.olympicSport();
+        return Arrays.asList(TestSpec.of(olympicSport::summerOlympics, "olympic_sport.summer_olympics"),
+                TestSpec.of(olympicSport::winterOlympics, "olympic_sport.winter_olympics"),
+                TestSpec.of(olympicSport::summerParalympics, "olympic_sport.summer_paralympics"),
+                TestSpec.of(olympicSport::winterParalympics, "olympic_sport.winter_paralympics"),
+                TestSpec.of(olympicSport::ancientOlympics, "olympic_sport.ancient_olympics"),
+                TestSpec.of(olympicSport::unusual, "olympic_sport.unusual"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/OptionsTest.java b/src/test/java/net/datafaker/providers/base/OptionsTest.java
index 21ad5b696..7217b506c 100644
--- a/src/test/java/net/datafaker/providers/base/OptionsTest.java
+++ b/src/test/java/net/datafaker/providers/base/OptionsTest.java
@@ -1,6 +1,5 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import java.math.BigDecimal;
@@ -13,70 +12,66 @@
 
 class OptionsTest extends BaseFakerTest<BaseFaker> {
 
-    private String[] options;
-
-    @BeforeEach
-    void setupOptions() {
-        options = new String[]{"A", "B", "C"};
-    }
+    private String[] options = {"A", "B", "C"};
+    private Options opt = faker.options();
 
     @Test
     void testOptionWithArray() {
-        assertThat(faker.options().option(options)).isIn((Object[]) options);
+        assertThat(opt.option(options)).isIn((Object[]) options);
     }
 
     @Test
     void testOptionWithVarargsString() {
-        assertThat(faker.options().option("A", "B", "C")).isIn((Object[]) options);
+        assertThat(opt.option("A", "B", "C")).isIn((Object[]) options);
     }
 
     @Test
     void testOptionWithVarargs() {
         Integer[] integerOptions = new Integer[]{1, 3, 4, 5};
-        assertThat(faker.options().option(1, 3, 4, 5)).isIn((Object[]) integerOptions);
+        assertThat(opt.option(1, 3, 4, 5)).isIn((Object[]) integerOptions);
         Long[] longOptions = new Long[]{1L, 3L, 4L, 5L};
-        assertThat(faker.options().option(longOptions)).isIn((Object[]) longOptions);
+        assertThat(opt.option(longOptions)).isIn((Object[]) longOptions);
         Short[] shortOptions = new Short[]{1, 3, 4};
-        assertThat(faker.options().option(shortOptions)).isIn((Object[]) shortOptions);
+        assertThat(opt.option(shortOptions)).isIn((Object[]) shortOptions);
         Byte[] byteOptions = new Byte[]{(byte) 11, (byte) 13, (byte) 14};
-        assertThat(faker.options().option(byteOptions)).isIn((Object[]) byteOptions);
+        assertThat(opt.option(byteOptions)).isIn((Object[]) byteOptions);
         Double[] doubleOptions = new Double[]{1.1d, 13d, 14.2d};
-        assertThat(faker.options().option(doubleOptions)).isIn((Object[]) doubleOptions);
+        assertThat(opt.option(doubleOptions)).isIn((Object[]) doubleOptions);
         Float[] floatOptions = new Float[]{1.2f, 13f, 14.2f};
-        assertThat(faker.options().option(floatOptions)).isIn((Object[]) floatOptions);
+        assertThat(opt.option(floatOptions)).isIn((Object[]) floatOptions);
         BigInteger[] bigIntegerOptions = new BigInteger[]{BigInteger.ONE, BigInteger.TEN, BigInteger.ZERO};
-        assertThat(faker.options().option(bigIntegerOptions)).isIn((Object[]) bigIntegerOptions);
+        assertThat(opt.option(bigIntegerOptions)).isIn((Object[]) bigIntegerOptions);
         BigDecimal[] bigDecimalOptions = new BigDecimal[]{BigDecimal.ONE, BigDecimal.TEN, BigDecimal.ZERO};
-        assertThat(faker.options().option(bigDecimalOptions)).isIn((Object[]) bigDecimalOptions);
+        assertThat(opt.option(bigDecimalOptions)).isIn((Object[]) bigDecimalOptions);
         Boolean[] booleanOptions = new Boolean[]{true, false};
-        assertThat(faker.options().option(booleanOptions)).isIn((Object[]) booleanOptions);
+        assertThat(opt.option(booleanOptions)).isIn((Object[]) booleanOptions);
     }
 
     @Test
     void testSubset() {
         Integer[] integerOptions = new Integer[]{1, 3, 4, 5};
-        assertThat(faker.options().subset(1, integerOptions))
+        assertThat(opt.subset(1, integerOptions))
             .doesNotContainAnyElementsOf(Arrays.asList(2, 6))
             .containsAnyElementsOf(Arrays.asList(integerOptions));
         Long[] longOptions = new Long[]{1L, 3L, 4L, 5L};
-        assertThat(faker.options().subset(1, longOptions))
+        assertThat(opt.subset(1, longOptions))
             .doesNotContainAnyElementsOf(Arrays.asList(2L, 6L))
             .containsAnyElementsOf(Arrays.asList(longOptions));
 
-        assertThat(faker.options().subset(longOptions.length, longOptions))
+        assertThat(opt.subset(longOptions.length, longOptions))
             .doesNotContainAnyElementsOf(Arrays.asList(2L, 6L))
             .containsAnyElementsOf(Arrays.asList(longOptions)).hasSameSizeAs(longOptions);
 
-        assertThat(faker.options().subset(longOptions.length + 1, longOptions))
+        assertThat(opt.subset(longOptions.length + 1, longOptions))
             .doesNotContainAnyElementsOf(Arrays.asList(2L, 6L))
             .containsAnyElementsOf(Arrays.asList(longOptions)).hasSameSizeAs(longOptions);
 
         String[] strOptions = new String[]{"1", "2", "3"};
-        assertThat(faker.options().subset(strOptions.length + 1, strOptions))
+        assertThat(opt.subset(strOptions.length + 1, strOptions))
             .doesNotContainAnyElementsOf(Arrays.asList("q", "w"))
             .containsAnyElementsOf(Arrays.asList(strOptions)).hasSameSizeAs(strOptions);
 
-        assertThat(faker.options().subset(1, strOptions))
+        assertThat(opt.subset(1, strOptions))
             .doesNotContainAnyElementsOf(Arrays.asList("q", "w"))
             .containsAnyElementsOf(Arrays.asList(strOptions))
             .hasSize(1);
@@ -86,25 +81,25 @@ void testSubset() {
     @Test
     void testSubsetWithDuplicate() {
         Object[] array = new Object[]{1, 1, 2, 2};
-        assertThat(faker.options().subset(5, array)).hasSize(2);
+        assertThat(opt.subset(5, array)).hasSize(2);
         String[] strArray = new String[]{"a", "s", "s", "a"};
-        assertThat(faker.options().subset(Integer.MAX_VALUE, strArray)).hasSize(2);
+        assertThat(opt.subset(Integer.MAX_VALUE, strArray)).hasSize(2);
     }
 
     @Test
     void testEmptySubset() {
         Object[] array = new Object[]{1, 2, 3};
-        assertThat(faker.options().subset(0, array)).isEmpty();
-        assertThatThrownBy(() -> faker.options().subset(-1, array))
+        assertThat(opt.subset(0, array)).isEmpty();
+        assertThatThrownBy(() -> opt.subset(-1, array))
             .isInstanceOf(IllegalArgumentException.class);
         String[] strArray = new String[]{"1", "2", "3"};
-        assertThat(faker.options().subset(0, strArray)).isEmpty();
-        assertThatThrownBy(() -> faker.options().subset(-1, strArray)).isInstanceOf(IllegalArgumentException.class);
+        assertThat(opt.subset(0, strArray)).isEmpty();
+        assertThatThrownBy(() -> opt.subset(-1, strArray)).isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     void testOptionWithEnum() {
-        assertThat(faker.options().option(Day.class)).isIn((Object[]) Day.values());
+        assertThat(opt.option(Day.class)).isIn((Object[]) Day.values());
     }
 
     @Test
@@ -112,7 +107,7 @@ void testNextArrayElement() {
         Integer[] array = new Integer[]{1, 2, 3, 5, 8, 13, 21};
 
         for (int i = 1; i < 10; i++) {
-            assertThat(faker.options().nextElement(array)).isIn((Object[]) array);
+            assertThat(opt.nextElement(array)).isIn((Object[]) array);
         }
     }
 
@@ -120,7 +115,7 @@ void testNextArrayElement() {
     void testNextListElement() {
         List<Integer> list = Arrays.asList(1, 2, 3, 5, 8, 13, 21);
         for (int i = 1; i < 10; i++) {
-            assertThat(faker.options().nextElement(list)).isIn(list);
+            assertThat(opt.nextElement(list)).isIn(list);
         }
     }
 
diff --git a/src/test/java/net/datafaker/providers/base/PhotographyTest.java b/src/test/java/net/datafaker/providers/base/PhotographyTest.java
index 05798948f..08df20ae0 100644
--- a/src/test/java/net/datafaker/providers/base/PhotographyTest.java
+++ b/src/test/java/net/datafaker/providers/base/PhotographyTest.java
@@ -1,68 +1,21 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.RepeatedTest;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class PhotographyTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testAperture() {
-        final String value = faker.photography().aperture();
-        assertThat(value).startsWith("f");
-    }
-
-    @Test
-    void testTerm() {
-        final String value = faker.photography().term();
-        assertNonNullOrEmpty(value);
-    }
-
-    @Test
-    void brand() {
-        final String value = faker.photography().brand();
-        assertNonNullOrEmpty(value);
-    }
-
-    @Test
-    void camera() {
-        final String value = faker.photography().camera();
-        assertNonNullOrEmpty(value);
-    }
-
-    @Test
-    void lens() {
-        final String value = faker.photography().lens();
-        assertNonNullOrEmpty(value);
-    }
-
-    @Test
-    void genre() {
-        final String value = faker.photography().genre();
-        assertNonNullOrEmpty(value);
-    }
-
-    @Test
-    void imageTag() {
-        final String value = faker.photography().imageTag();
-        assertNonNullOrEmpty(value);
-    }
-
-    @RepeatedTest(7)
-    void shutter() {
-        final String value = faker.photography().shutter();
-        assertThat(value).matches("\\d+/?\\d*");
-    }
-
-    @RepeatedTest(7)
-    void iso() {
-        final String value = faker.photography().iso();
-        assertThat(value).matches("\\d+");
-    }
-
-    private void assertNonNullOrEmpty(String value) {
-        assertThat(value)
-            .isNotEmpty();
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Photography photo = faker.photography();
+        return Arrays.asList(TestSpec.of(photo::aperture, "photography.aperture"),
+            TestSpec.of(photo::term, "photography.term"),
+            TestSpec.of(photo::brand, "photography.brand"),
+            TestSpec.of(photo::camera, "photography.camera"),
+            TestSpec.of(photo::lens, "photography.lens"),
+            TestSpec.of(photo::genre, "photography.genre"),
+            TestSpec.of(photo::imageTag, "photography.imagetag"),
+            TestSpec.of(photo::shutter, "photography.shutter", "\\d+/?\\d*"),
+            TestSpec.of(photo::iso, "photography.iso", "\\d+"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ProgrammingLanguageTest.java b/src/test/java/net/datafaker/providers/base/ProgrammingLanguageTest.java
index 3d9f5c641..41bf18846 100644
--- a/src/test/java/net/datafaker/providers/base/ProgrammingLanguageTest.java
+++ b/src/test/java/net/datafaker/providers/base/ProgrammingLanguageTest.java
@@ -1,18 +1,14 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class ProgrammingLanguageTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void name() {
-        assertThat(faker.programmingLanguage().name()).matches("[A-Za-z\\d :,.+*()#/–\\-@πéöü'′!]+");
-    }
-
-    @Test
-    void creator() {
-        assertThat(faker.programmingLanguage().creator()).matches("[A-Za-z .,\\-]+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        ProgrammingLanguage lang = faker.programmingLanguage();
+        return Arrays.asList(TestSpec.of(lang::name, "programming_language.name", "[A-Za-z\\d :,.+*()#/–\\-@πéöü'′!]+"),
+            TestSpec.of(lang::creator, "programming_language.creator", "[A-Za-z .,\\-]+"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/RelationshipTest.java b/src/test/java/net/datafaker/providers/base/RelationshipTest.java
index cac8111c7..a87dfcb9c 100644
--- a/src/test/java/net/datafaker/providers/base/RelationshipTest.java
+++ b/src/test/java/net/datafaker/providers/base/RelationshipTest.java
@@ -13,9 +13,10 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.when;
 
-class RelationshipTest extends AbstractBasicProviderTest<BaseFaker> {
+class RelationshipTest extends BaseFakerTest<BaseFaker> {
 
     private BaseFaker mockFaker;
+    private Relationship relationship = faker.relationships();
 
     @BeforeEach
     protected void before() {
@@ -25,17 +26,17 @@ protected void before() {
 
     @RepeatedTest(100)
     void anyTest() {
-        assertThat(faker.relationships().any()).isNotEmpty();
+        assertThat(relationship.any()).isNotEmpty();
     }
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.relationships().direct(), "relationship.familial.direct"),
-                TestSpec.of(() -> faker.relationships().extended(), "relationship.familial.extended"),
-                TestSpec.of(() -> faker.relationships().inLaw(), "relationship.in_law"),
-                TestSpec.of(() -> faker.relationships().spouse(), "relationship.spouse"),
-                TestSpec.of(() -> faker.relationships().parent(), "relationship.parent"),
-                TestSpec.of(() -> faker.relationships().sibling(), "relationship.sibling"));
+        return Arrays.asList(TestSpec.of(relationship::direct, "relationship.familial.direct"),
+                TestSpec.of(relationship::extended, "relationship.familial.extended"),
+                TestSpec.of(relationship::inLaw, "relationship.in_law"),
+                TestSpec.of(relationship::spouse, "relationship.spouse"),
+                TestSpec.of(relationship::parent, "relationship.parent"),
+                TestSpec.of(relationship::sibling, "relationship.sibling"));
     }
 
     @Test
diff --git a/src/test/java/net/datafaker/providers/base/RestaurantTest.java b/src/test/java/net/datafaker/providers/base/RestaurantTest.java
index 692d00c7a..d61c7f7a6 100644
--- a/src/test/java/net/datafaker/providers/base/RestaurantTest.java
+++ b/src/test/java/net/datafaker/providers/base/RestaurantTest.java
@@ -6,18 +6,21 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class RestaurantTest extends AbstractBasicProviderTest<BaseFaker> {
+class RestaurantTest extends BaseFakerTest<BaseFaker> {
+
+    private Restaurant restaurant = faker.restaurant();
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.restaurant().nameSuffix(), "restaurant.name_suffix"),
-                TestSpec.of(() -> faker.restaurant().type(), "restaurant.type"),
-                TestSpec.of(() -> faker.restaurant().description(), "restaurant.description"),
-                TestSpec.of(() -> faker.restaurant().review(), "restaurant.review"));
+        return Arrays.asList(TestSpec.of(restaurant::nameSuffix, "restaurant.name_suffix"),
+                TestSpec.of(restaurant::type, "restaurant.type"),
+                TestSpec.of(restaurant::description, "restaurant.description"),
+                TestSpec.of(restaurant::review, "restaurant.review"));
     }
+
     @RepeatedTest(100)
     void namePrefix() {
-        assertThat(faker.restaurant().namePrefix())
+        assertThat(restaurant.namePrefix())
             .isNotEmpty()
             .doesNotContain("#", "?") // make sure bothify is applied
             .matches("[A-Z0-9].*");   // and that bothify only uses uppercase characters
@@ -25,7 +28,7 @@ void namePrefix() {
 
     @RepeatedTest(100)
     void name() {
-        assertThat(faker.restaurant().name())
+        assertThat(restaurant.name())
             .isNotEmpty()
             .doesNotContain("#", "?") // make sure bothify is applied
             .matches("[A-Z0-9].*");   // and that bothify only uses uppercase characters
diff --git a/src/test/java/net/datafaker/providers/base/RobinTest.java b/src/test/java/net/datafaker/providers/base/RobinTest.java
index 7999705bf..6147b12a1 100644
--- a/src/test/java/net/datafaker/providers/base/RobinTest.java
+++ b/src/test/java/net/datafaker/providers/base/RobinTest.java
@@ -1,13 +1,13 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class RobinTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void quote() {
-        assertThat(faker.robin().quote()).matches("^(\\w+\\.?-?'?\\s?)+(\\(?)?(\\w+\\s?\\.?)+(\\))?$");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Robin robin = faker.robin();
+        return Arrays.asList(TestSpec.of(robin::quote, "robin.quotes", "^(\\w+\\.?-?'?\\s?)+(\\(?)?(\\w+\\s?\\.?)+(\\))?$"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/RockBandTest.java b/src/test/java/net/datafaker/providers/base/RockBandTest.java
index f5b321b77..75844ee38 100644
--- a/src/test/java/net/datafaker/providers/base/RockBandTest.java
+++ b/src/test/java/net/datafaker/providers/base/RockBandTest.java
@@ -1,13 +1,13 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class RockBandTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void name() {
-        assertThat(faker.rockBand().name()).matches("([\\w'/.,&]+ ?)+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        RockBand band = faker.rockBand();
+        return Arrays.asList(TestSpec.of(band::name, "rock_band.name", "([\\w'/.,&]+ ?)+"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ScienceTest.java b/src/test/java/net/datafaker/providers/base/ScienceTest.java
index 41a7cd4ad..4e2b63a63 100644
--- a/src/test/java/net/datafaker/providers/base/ScienceTest.java
+++ b/src/test/java/net/datafaker/providers/base/ScienceTest.java
@@ -7,44 +7,47 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class ScienceTest extends AbstractBasicProviderTest<BaseFaker> {
+class ScienceTest extends BaseFakerTest<BaseFaker> {
+
+    Science science = faker.science();
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.science().unit(), "science.unit"));
+        return Arrays.asList(TestSpec.of(science::unit, "science.unit"));
     }
+
     @RepeatedTest(10)
     void element() {
-        assertThat(faker.science().element()).matches("[A-Za-z ]+");
+        assertThat(science.element()).matches("[A-Za-z ]+");
     }
 
     @RepeatedTest(10)
     void elementSymbol() {
-        assertThat(faker.science().elementSymbol()).matches("[A-Za-z]{1,2}");
+        assertThat(science.elementSymbol()).matches("[A-Za-z]{1,2}");
     }
 
     @RepeatedTest(10)
     void scientist() {
-        assertThat(faker.science().scientist()).matches("[A-Za-z. -]+");
+        assertThat(science.scientist()).matches("[A-Za-z. -]+");
     }
 
     @RepeatedTest(10)
     void tool() {
-        assertThat(faker.science().tool()).matches("[0-9A-Za-z. -]+");
+        assertThat(science.tool()).matches("[0-9A-Za-z. -]+");
     }
 
     @RepeatedTest(10)
     void quark() {
-        assertThat(faker.science().quark()).matches("[A-Za-z]+");
+        assertThat(science.quark()).matches("[A-Za-z]+");
     }
 
     @RepeatedTest(10)
     void leptons() {
-        assertThat(faker.science().leptons()).matches("[A-Za-z ]+");
+        assertThat(science.leptons()).matches("[A-Za-z ]+");
     }
 
     @RepeatedTest(10)
     void bosons() {
-        assertThat(faker.science().bosons()).matches("[A-Za-z ]+");
+        assertThat(science.bosons()).matches("[A-Za-z ]+");
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ShakespeareTest.java b/src/test/java/net/datafaker/providers/base/ShakespeareTest.java
index c04f506fb..7807cce02 100644
--- a/src/test/java/net/datafaker/providers/base/ShakespeareTest.java
+++ b/src/test/java/net/datafaker/providers/base/ShakespeareTest.java
@@ -6,23 +6,25 @@
 
 class ShakespeareTest extends BaseFakerTest<BaseFaker> {
 
+    private Shakespeare shakespeare = faker.shakespeare();
+
     @Test
     void testHamletQuote() {
-        assertThat(faker.shakespeare().hamletQuote()).isNotEmpty();
+        assertThat(shakespeare.hamletQuote()).isNotEmpty();
     }
 
     @Test
     void testAsYouLikeItQuote() {
-        assertThat(faker.shakespeare().asYouLikeItQuote()).isNotEmpty();
+        assertThat(shakespeare.asYouLikeItQuote()).isNotEmpty();
     }
 
     @Test
     void testKingRichardIIIQuote() {
-        assertThat(faker.shakespeare().kingRichardIIIQuote()).isNotEmpty();
+        assertThat(shakespeare.kingRichardIIIQuote()).isNotEmpty();
     }
 
     @Test
     void testRomeoAndJulietQuote() {
-        assertThat(faker.shakespeare().romeoAndJulietQuote()).isNotEmpty();
+        assertThat(shakespeare.romeoAndJulietQuote()).isNotEmpty();
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/SipTest.java b/src/test/java/net/datafaker/providers/base/SipTest.java
index 0b462198b..46b40479e 100644
--- a/src/test/java/net/datafaker/providers/base/SipTest.java
+++ b/src/test/java/net/datafaker/providers/base/SipTest.java
@@ -6,91 +6,93 @@
 
 class SipTest extends BaseFakerTest<BaseFaker> {
 
+    Sip sip = faker.sip();
+
     @Test
     void method_returnUpperCaseWithMinimum3Chars() {
-        assertThat(faker.sip().method()).matches("^[A-Z]{3,}$");
+        assertThat(sip.method()).matches("^[A-Z]{3,}$");
     }
 
     @Test
     void contentType_returnLowerCaseTwoWordsSepereatedBySlashMinimum3And4Chars() {
-        assertThat(faker.sip().contentType()).matches("^[a-z]{4,}/+[a-z\\d-]{3,}$");
+        assertThat(sip.contentType()).matches("^[a-z]{4,}/+[a-z\\d-]{3,}$");
     }
 
     @Test
     void messagingPort_return4DigitIntBetween1000And9999() {
-        assertThat(faker.sip().messagingPort()).isBetween(1000, 10000);
+        assertThat(sip.messagingPort()).isBetween(1000, 10000);
     }
 
     @Test
     void rtpPort_returnPositiveEvenInt() {
-        int sut = faker.sip().rtpPort();
+        int sut = sip.rtpPort();
         assertThat(sut).isGreaterThanOrEqualTo(2);
         assertThat(sut % 2).isZero();
     }
 
     @Test
     void provisionalResponseCode_return3DigitIntBetween100And199() {
-        assertThat(faker.sip().provisionalResponseCode()).isBetween(100, 200);
+        assertThat(sip.provisionalResponseCode()).isBetween(100, 200);
     }
 
     @Test
     void successResponse_Codereturn3DigitIntBetween200And299() {
-        assertThat(faker.sip().successResponseCode()).isBetween(200, 300);
+        assertThat(sip.successResponseCode()).isBetween(200, 300);
     }
 
     @Test
     void redirectResponseCode_Codereturn3DigitIntBetween300And399() {
-        assertThat(faker.sip().redirectResponseCode()).isBetween(300, 400);
+        assertThat(sip.redirectResponseCode()).isBetween(300, 400);
     }
 
     @Test
     void clientErrorResponseCode_Codereturn3DigitIntBetween400And499() {
-        assertThat(faker.sip().clientErrorResponseCode()).isBetween(400, 500);
+        assertThat(sip.clientErrorResponseCode()).isBetween(400, 500);
     }
 
     @Test
     void serverErrorResponseCode_Codereturn3DigitIntBetween500And599() {
-        assertThat(faker.sip().serverErrorResponseCode()).isBetween(500, 600);
+        assertThat(sip.serverErrorResponseCode()).isBetween(500, 600);
     }
 
     @Test
     void globalErrorResponseCode_Codereturn3DigitIntBetween600And699() {
-        assertThat(faker.sip().globalErrorResponseCode()).isBetween(600, 700);
+        assertThat(sip.globalErrorResponseCode()).isBetween(600, 700);
     }
 
     @Test
     void provisionalResponsePhrase_returnAnyNonDigitString() {
-        assertThat(faker.sip().provisionalResponsePhrase()).matches("\\D+");
+        assertThat(sip.provisionalResponsePhrase()).matches("\\D+");
     }
 
     @Test
     void successResponsePhrase_returnAnyNonDigitString() {
-        assertThat(faker.sip().successResponsePhrase()).matches("\\D+");
+        assertThat(sip.successResponsePhrase()).matches("\\D+");
     }
 
     @Test
     void redirectResponsePhrase_returnAnyNonDigitString() {
-        assertThat(faker.sip().redirectResponsePhrase()).matches("\\D+");
+        assertThat(sip.redirectResponsePhrase()).matches("\\D+");
     }
 
     @Test
     void clientErrorResponsePhrase_returnAnyNonDigitString() {
-        assertThat(faker.sip().clientErrorResponsePhrase()).matches("\\D+");
+        assertThat(sip.clientErrorResponsePhrase()).matches("\\D+");
     }
 
     @Test
     void serverErrorResponsePhrase_returnAnyNonDigitString() {
-        assertThat(faker.sip().serverErrorResponsePhrase()).matches("\\D+");
+        assertThat(sip.serverErrorResponsePhrase()).matches("\\D+");
     }
 
     @Test
     void globalErrorResponsePhrase_returnAnyNonDigitString() {
-        assertThat(faker.sip().globalErrorResponsePhrase()).matches("\\D+");
+        assertThat(sip.globalErrorResponsePhrase()).matches("\\D+");
     }
 
     @Test
     void bodyString_returnAValidSdpBodyString() {
-        String[] sut = faker.sip().bodyString().split("\n");
+        String[] sut = sip.bodyString().split("\n");
 
         assertThat(sut).hasSize(7);
 
@@ -119,14 +121,14 @@ void bodyString_returnAValidSdpBodyString() {
 
     @Test
     void bodyBytes_isNotNull() {
-        byte[] sut = faker.sip().bodyBytes();
+        byte[] sut = sip.bodyBytes();
 
         assertThat(sut.length).isNotNull();
     }
 
     @Test
     void nameAddress_returnValidNameAddressString() {
-        String[] sut = faker.sip().nameAddress().split("@");
+        String[] sut = sip.nameAddress().split("@");
 
         assertThat(sut[0].split(":")[1]).matches("\\w+");
         assertThat(sut[1].split(":")[0]).matches("^\\d{1,3}.\\d{1,3}.\\d{1,3}.\\d{1,3}$");
diff --git a/src/test/java/net/datafaker/providers/base/SizeTest.java b/src/test/java/net/datafaker/providers/base/SizeTest.java
index 902b30109..b0f18124a 100644
--- a/src/test/java/net/datafaker/providers/base/SizeTest.java
+++ b/src/test/java/net/datafaker/providers/base/SizeTest.java
@@ -1,13 +1,13 @@
 package net.datafaker.providers.base;
 
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
 
 class SizeTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void adjective() {
-        assertThat(faker.size().adjective()).matches("[a-zA-Z]+(-[a-zA-Z]+)?");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Size size = faker.size();
+        return Arrays.asList(TestSpec.of(size::adjective, "size.adjective", "[a-zA-Z]+(-[a-zA-Z]+)?"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/SlackEmojiTest.java b/src/test/java/net/datafaker/providers/base/SlackEmojiTest.java
index ffb447ded..7d09f7166 100644
--- a/src/test/java/net/datafaker/providers/base/SlackEmojiTest.java
+++ b/src/test/java/net/datafaker/providers/base/SlackEmojiTest.java
@@ -6,50 +6,51 @@
 
 class SlackEmojiTest extends BaseFakerTest<BaseFaker> {
 
-    private static final String EMOTICON_REGEX = ":([\\w-]+):";
+    private static final String EMOTICON_REGEX = ":(:?[\\w-]+):";
+    private SlackEmoji slackEmoji = faker.slackEmoji();
 
     @Test
     void people() {
-        assertThat(faker.slackEmoji().people()).matches(EMOTICON_REGEX);
+        assertThat(slackEmoji.people()).matches(EMOTICON_REGEX);
     }
 
     @Test
     void nature() {
-        assertThat(faker.slackEmoji().nature()).matches(EMOTICON_REGEX);
+        assertThat(slackEmoji.nature()).matches(EMOTICON_REGEX);
     }
 
     @Test
     void food_and_drink() {
-        assertThat(faker.slackEmoji().foodAndDrink()).matches(EMOTICON_REGEX);
+        assertThat(slackEmoji.foodAndDrink()).matches(EMOTICON_REGEX);
     }
 
     @Test
     void celebration() {
-        assertThat(faker.slackEmoji().celebration()).matches(EMOTICON_REGEX);
+        assertThat(slackEmoji.celebration()).matches(EMOTICON_REGEX);
     }
 
     @Test
     void activity() {
-        assertThat(faker.slackEmoji().activity()).matches(EMOTICON_REGEX);
+        assertThat(slackEmoji.activity()).matches(EMOTICON_REGEX);
     }
 
     @Test
     void travel_and_places() {
-        assertThat(faker.slackEmoji().travelAndPlaces()).matches(EMOTICON_REGEX);
+        assertThat(slackEmoji.travelAndPlaces()).matches(EMOTICON_REGEX);
     }
 
     @Test
     void objects_and_symbols() {
-        assertThat(faker.slackEmoji().objectsAndSymbols()).matches(EMOTICON_REGEX);
+        assertThat(slackEmoji.objectsAndSymbols()).matches(EMOTICON_REGEX);
     }
 
     @Test
     void custom() {
-        assertThat(faker.slackEmoji().custom()).matches(EMOTICON_REGEX);
+        assertThat(slackEmoji.custom()).matches(EMOTICON_REGEX);
     }
 
     @Test
     void emoji() {
-        assertThat(faker.slackEmoji().emoji()).matches(EMOTICON_REGEX);
+        assertThat(slackEmoji.emoji()).matches(EMOTICON_REGEX);
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/SpaceTest.java b/src/test/java/net/datafaker/providers/base/SpaceTest.java
index f5a413dfa..0350b98ea 100644
--- a/src/test/java/net/datafaker/providers/base/SpaceTest.java
+++ b/src/test/java/net/datafaker/providers/base/SpaceTest.java
@@ -4,70 +4,31 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-class SpaceTest extends BaseFakerTest<BaseFaker> {
-
-    @Test
-    void planet() {
-        assertThat(faker.space().planet()).matches("(\\w+ ?){2,3}");
-    }
-
-    @Test
-    void moon() {
-        assertThat(faker.space().moon()).matches("(\\w+ ?){2,3}");
-    }
-
-    @Test
-    void galaxy() {
-        assertThat(faker.space().galaxy()).matches("(\\w+ ?){2,3}");
-    }
+import java.util.Arrays;
+import java.util.Collection;
 
-    @Test
-    void nebula() {
-        assertThat(faker.space().nebula()).matches("(\\w+ ?){2,3}");
-    }
-
-    @Test
-    void starCluster() {
-        assertThat(faker.space().starCluster()).matches("(\\w+[ -]?){1,3}");
-    }
-
-    @Test
-    void constellation() {
-        assertThat(faker.space().constellation()).matches("(\\w+ ?){2,3}");
-    }
-
-    @Test
-    void star() {
-        assertThat(faker.space().star()).matches("(\\w+[ -]?){2,3}");
-    }
-
-    @Test
-    void agency() {
-        assertThat(faker.space().agency()).matches("(\\w+ ?){2,5}");
-    }
-
-    @Test
-    void agencyAbbreviation() {
-        assertThat(faker.space().agencyAbbreviation()).matches("(\\w+ ?){2,3}");
-    }
-
-    @Test
-    void nasaSpaceCraft() {
-        assertThat(faker.space().nasaSpaceCraft()).matches("(\\w+ ?){2,3}");
-    }
+class SpaceTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void company() {
-        assertThat(faker.space().company()).matches("((\\w|')+ ?){2,4}");
+    private static String SPACE_REGEX = "(\\w+ ?){2,3}";
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Space space = faker.space();
+        return Arrays.asList(TestSpec.of(space::planet, "space.planet", SPACE_REGEX),
+            TestSpec.of(space::moon, "space.moon", SPACE_REGEX),
+            TestSpec.of(space::galaxy, "space.galaxy", SPACE_REGEX),
+            TestSpec.of(space::nebula, "space.nebula", SPACE_REGEX),
+            TestSpec.of(space::starCluster, "space.star_cluster", "(:?\\w+[ -]?){1,3}"),
+            TestSpec.of(space::constellation, "space.constellation", SPACE_REGEX),
+            TestSpec.of(space::star, "space.star", "(\\w+[ -]?){2,3}"),
+            TestSpec.of(space::agency, "space.agency", "(:?\\w+ ?){2,5}"),
+            TestSpec.of(space::agencyAbbreviation, "space.agency_abv", SPACE_REGEX),
+            TestSpec.of(space::nasaSpaceCraft, "space.nasa_space_craft", SPACE_REGEX),
+            TestSpec.of(space::company, "space.company", "(:?(:?\\w|')+ ?){2,4}"),
+            TestSpec.of(space::meteorite, "space.meteorite", "(?U)(:?[\\w()]+[ -–]?){1,4}"));
     }
 
     @Test
     void distanceMeasurement() {
-        assertThat(faker.space().distanceMeasurement()).matches("(\\w+ ?){2,3}");
-    }
-
-    @Test
-    void meteorite() {
-        assertThat(faker.space().meteorite()).matches("(?U)([\\w()]+[ -–]?){1,4}");
+        assertThat(faker.space().distanceMeasurement()).matches("(:?\\w+ ?){2,3}");
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/StockTest.java b/src/test/java/net/datafaker/providers/base/StockTest.java
index b49998d28..202e7ff45 100644
--- a/src/test/java/net/datafaker/providers/base/StockTest.java
+++ b/src/test/java/net/datafaker/providers/base/StockTest.java
@@ -3,12 +3,13 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class StockTest extends AbstractBasicProviderTest<BaseFaker> {
+class StockTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.stock().nsdqSymbol(), "stock.symbol_nsdq"),
-                TestSpec.of(() -> faker.stock().nyseSymbol(), "stock.symbol_nyse"));
+        Stock stock = faker.stock();
+        return Arrays.asList(TestSpec.of(stock::nsdqSymbol, "stock.symbol_nsdq"),
+                TestSpec.of(stock::nyseSymbol, "stock.symbol_nyse"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/SubscriptionTest.java b/src/test/java/net/datafaker/providers/base/SubscriptionTest.java
index 5257e4d81..ed260459c 100644
--- a/src/test/java/net/datafaker/providers/base/SubscriptionTest.java
+++ b/src/test/java/net/datafaker/providers/base/SubscriptionTest.java
@@ -3,15 +3,16 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class SubscriptionTest extends AbstractBasicProviderTest<BaseFaker> {
+class SubscriptionTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.subscription().plans(), "subscription.plans"),
-                TestSpec.of(() -> faker.subscription().statuses(), "subscription.statuses"),
-                TestSpec.of(() -> faker.subscription().paymentMethods(), "subscription.payment_methods"),
-                TestSpec.of(() -> faker.subscription().subscriptionTerms(), "subscription.subscription_terms"),
-                TestSpec.of(() -> faker.subscription().paymentTerms(), "subscription.payment_terms"));
+        Subscription subscription = faker.subscription();
+        return Arrays.asList(TestSpec.of(subscription::plans, "subscription.plans"),
+                TestSpec.of(subscription::statuses, "subscription.statuses"),
+                TestSpec.of(subscription::paymentMethods, "subscription.payment_methods"),
+                TestSpec.of(subscription::subscriptionTerms, "subscription.subscription_terms"),
+                TestSpec.of(subscription::paymentTerms, "subscription.payment_terms"));
     }
 
 }
diff --git a/src/test/java/net/datafaker/providers/base/SuperheroTest.java b/src/test/java/net/datafaker/providers/base/SuperheroTest.java
index 4cd306021..be500cee4 100644
--- a/src/test/java/net/datafaker/providers/base/SuperheroTest.java
+++ b/src/test/java/net/datafaker/providers/base/SuperheroTest.java
@@ -4,6 +4,9 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class SuperheroTest extends BaseFakerTest<BaseFaker> {
 
     @Test
@@ -11,23 +14,12 @@ void testName() {
         assertThat(faker.superhero().name()).matches("[A-Za-z' -/]+");
     }
 
-    @Test
-    void testPrefix() {
-        assertThat(faker.superhero().prefix()).matches("[A-Za-z -]+");
-    }
-
-    @Test
-    void testSuffix() {
-        assertThat(faker.superhero().suffix()).matches("[A-Za-z -]+");
-    }
-
-    @Test
-    void testPower() {
-        assertThat(faker.superhero().power()).matches("[A-Za-z/ -]+");
-    }
-
-    @Test
-    void testDescriptor() {
-        assertThat(faker.superhero().descriptor()).matches("[A-Za-z' -]+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        Superhero superhero = faker.superhero();
+        return Arrays.asList(TestSpec.of(superhero::prefix, "superhero.prefix"),
+            TestSpec.of(superhero::suffix, "superhero.suffix"),
+            TestSpec.of(superhero::power, "superhero.power"),
+            TestSpec.of(superhero::descriptor, "superhero.descriptor"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/TeamTest.java b/src/test/java/net/datafaker/providers/base/TeamTest.java
index e7b5d4d0f..f1f4d3c3a 100644
--- a/src/test/java/net/datafaker/providers/base/TeamTest.java
+++ b/src/test/java/net/datafaker/providers/base/TeamTest.java
@@ -2,20 +2,19 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Locale;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 class TeamTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testName() {
-        assertThat(faker.team().name()).matches("(\\w+( )?){2,4}");
-    }
+    private Team team = faker.team();
 
     @Test
-    void testCreature() {
-        assertThat(faker.team().creature()).matches("\\w+( \\w+)?");
+    void testName() {
+        assertThat(team.name()).matches("(\\w+( )?){2,4}");
     }
 
     @Test
@@ -23,14 +22,15 @@ void testState() {
         assertThat(faker.team().state()).matches("(\\w+( )?){1,2}");
     }
 
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(team::creature, "team.creature"),
+            TestSpec.of(team::sport, "team.sport", "(:?\\p{L}|\\s)+"));
+    }
+
     @Test
     void testStateWithZaLocale() {
         BaseFaker zaFaker = new BaseFaker(new Locale("en", "ZA"));
         assertThat(zaFaker.team().state()).isNotEmpty();
     }
-
-    @Test
-    void testSport() {
-        assertThat(faker.team().sport()).matches("(\\p{L}|\\s)+");
-    }
 }
diff --git a/src/test/java/net/datafaker/providers/base/UniversityTest.java b/src/test/java/net/datafaker/providers/base/UniversityTest.java
index 962d36fbd..48b20733d 100644
--- a/src/test/java/net/datafaker/providers/base/UniversityTest.java
+++ b/src/test/java/net/datafaker/providers/base/UniversityTest.java
@@ -4,20 +4,21 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class UniversityTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void testName() {
-        assertThat(faker.university().name()).matches("[A-Za-z'() ]+");
-    }
+    private University university = faker.university();
 
     @Test
-    void testPrefix() {
-        assertThat(faker.university().prefix()).matches("\\w+");
+    void testName() {
+        assertThat(university.name()).matches("[A-Za-z'() ]+");
     }
 
-    @Test
-    void testSuffix() {
-        assertThat(faker.university().suffix()).matches("\\w+");
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(university::prefix, "university.prefix"),
+            TestSpec.of(university::suffix, "university.suffix"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/WeatherTest.java b/src/test/java/net/datafaker/providers/base/WeatherTest.java
index 5f4164da2..67c7d6590 100644
--- a/src/test/java/net/datafaker/providers/base/WeatherTest.java
+++ b/src/test/java/net/datafaker/providers/base/WeatherTest.java
@@ -4,34 +4,39 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Arrays;
+import java.util.Collection;
+
 class WeatherTest extends BaseFakerTest<BaseFaker> {
 
-    @Test
-    void description() {
-        assertThat(faker.weather().description()).isNotEmpty();
+    private Weather weather = faker.weather();
+
+    @Override
+    protected Collection<TestSpec> providerListTest() {
+        return Arrays.asList(TestSpec.of(weather::description, "weather.description"));
     }
 
     @Test
     void temperatureCelsius() {
-        assertThat(faker.weather().temperatureCelsius()).matches("-?\\d+°C");
+        assertThat(weather.temperatureCelsius()).matches("-?\\d+°C");
     }
 
     @Test
     void temperatureFahrenheit() {
-        assertThat(faker.weather().temperatureFahrenheit()).matches("-?\\d+°F");
+        assertThat(weather.temperatureFahrenheit()).matches("-?\\d+°F");
     }
 
     @Test
     void temperatureCelsiusInRange() {
         for (int i = 1; i < 100; i++) {
-            assertThat(faker.weather().temperatureCelsius(-5, 5)).matches("-?[0-5]°C");
+            assertThat(weather.temperatureCelsius(-5, 5)).matches("-?[0-5]°C");
         }
     }
 
     @Test
     void temperatureFahrenheitInRange() {
         for (int i = 1; i < 100; i++) {
-            assertThat(faker.weather().temperatureFahrenheit(-5, 5)).matches("-?[0-5]°F");
+            assertThat(weather.temperatureFahrenheit(-5, 5)).matches("-?[0-5]°F");
         }
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/YodaTest.java b/src/test/java/net/datafaker/providers/base/YodaTest.java
index b4b9b924b..2d4f94605 100644
--- a/src/test/java/net/datafaker/providers/base/YodaTest.java
+++ b/src/test/java/net/datafaker/providers/base/YodaTest.java
@@ -6,10 +6,11 @@
 /**
  * @author Luka Obradovic (luka@vast.com)
  */
-class YodaTest extends AbstractBasicProviderTest<BaseFaker> {
+class YodaTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of(() -> faker.yoda().quote(), "yoda.quotes"));
+        Yoda yoda = faker.yoda();
+        return Arrays.asList(TestSpec.of(yoda::quote, "yoda.quotes"));
     }
 }
diff --git a/src/test/java/net/datafaker/providers/base/ZodiacTest.java b/src/test/java/net/datafaker/providers/base/ZodiacTest.java
index 0c85187fb..85fc90f94 100644
--- a/src/test/java/net/datafaker/providers/base/ZodiacTest.java
+++ b/src/test/java/net/datafaker/providers/base/ZodiacTest.java
@@ -3,10 +3,11 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-class ZodiacTest extends AbstractBasicProviderTest<BaseFaker> {
+class ZodiacTest extends BaseFakerTest<BaseFaker> {
 
     @Override
     protected Collection<TestSpec> providerListTest() {
-        return Arrays.asList(TestSpec.of((() -> faker.zodiac().sign()), "zodiac.signs"));
+        Zodiac zodiac = faker.zodiac();
+        return Arrays.asList(TestSpec.of(zodiac::sign, "zodiac.signs"));
     }
 }