From 382e039a4f5d936abbf727334f5a62c106d93bd2 Mon Sep 17 00:00:00 2001 From: kingthorin Date: Sat, 27 Jun 2026 11:59:00 -0400 Subject: [PATCH 1/8] Use simplified toList() Signed-off-by: kingthorin --- docs/documentation/schemas.md | 8 ++++---- .../datafaker/transformations/JavaObjectTransformer.java | 2 +- src/test/java/net/datafaker/formats/TomlTest.java | 3 +-- src/test/java/net/datafaker/formats/XmlTest.java | 9 ++++----- src/test/java/net/datafaker/formats/YamlTest.java | 3 +-- .../java/net/datafaker/providers/base/InternetTest.java | 5 ++--- src/test/java/net/datafaker/sequence/FakeStreamTest.java | 5 ++--- 7 files changed, 15 insertions(+), 20 deletions(-) diff --git a/docs/documentation/schemas.md b/docs/documentation/schemas.md index b7f6dbd48..9fc957582 100644 --- a/docs/documentation/schemas.md +++ b/docs/documentation/schemas.md @@ -356,9 +356,9 @@ The following is an example on how to use it: field("lastname", () -> faker.name().lastName()), field("phones", () -> Schema.of( field("worknumbers", () -> ((Stream) faker.stream().suppliers(() -> faker.phoneNumber().phoneNumber()).maxLen(2).build().get()) - .collect(Collectors.toList())), + .toList()), field("cellphones", () -> ((Stream) faker.stream().suppliers(() -> faker.phoneNumber().cellPhone()).maxLen(3).build().get()) - .collect(Collectors.toList())) + .toList()) )), field("address", () -> Schema.of( field("city", () -> faker.address().city()), @@ -549,9 +549,9 @@ The following is an example on how to use it: field("lastname", () -> faker.name().lastName()), field("phones", () -> Schema.of( field("worknumbers", () -> ((Stream) faker.stream().suppliers(() -> faker.phoneNumber().phoneNumber()).maxLen(2).build().get()) - .collect(Collectors.toList())), + .toList()), field("cellphones", () -> ((Stream) faker.stream().suppliers(() -> faker.phoneNumber().cellPhone()).maxLen(3).build().get()) - .collect(Collectors.toList())) + .toList()) )), field("address", () -> Schema.of( field("city", () -> faker.address().city()), diff --git a/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java b/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java index 683b10741..3e7ec85e2 100644 --- a/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java +++ b/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java @@ -150,7 +150,7 @@ public void writeToOutputStream(OutputStream outputStream, Schema sch @Override public Collection generate(Schema schema, int limit) { - return this.generateStream(schema, limit).collect(Collectors.toList()); + return this.generateStream(schema, limit).toList(); } @Override diff --git a/src/test/java/net/datafaker/formats/TomlTest.java b/src/test/java/net/datafaker/formats/TomlTest.java index 2d1a4f52c..021c00c12 100644 --- a/src/test/java/net/datafaker/formats/TomlTest.java +++ b/src/test/java/net/datafaker/formats/TomlTest.java @@ -12,7 +12,6 @@ import java.math.BigDecimal; import java.util.Collections; import java.util.List; -import java.util.stream.Collectors; import java.util.stream.IntStream; import java.util.stream.Stream; @@ -112,7 +111,7 @@ void generateFromFakeSequenceWithCollection(int limit) { final BaseFaker faker = new BaseFaker(); Schema> schema = Schema.of(field("firstNames", name -> IntStream.rangeClosed(1, limit) .mapToObj(it -> name.firstName()) - .collect(Collectors.toList()))); + .toList())); TomlTransformer transformer = new TomlTransformer<>(); diff --git a/src/test/java/net/datafaker/formats/XmlTest.java b/src/test/java/net/datafaker/formats/XmlTest.java index 30a3e9e8c..839c8f71f 100644 --- a/src/test/java/net/datafaker/formats/XmlTest.java +++ b/src/test/java/net/datafaker/formats/XmlTest.java @@ -14,7 +14,6 @@ import java.util.Collections; import java.util.List; -import java.util.stream.Collectors; import java.util.stream.Stream; import static net.datafaker.transformations.Field.compositeField; @@ -120,12 +119,12 @@ void generateXMLWithThreeNestedLevels() { () -> List.of( field("firstname", () -> faker.name().firstName()), field("lastname", () -> faker.name().lastName()), - field("addresses", () -> address.get().collect(Collectors.toList()))))) + field("addresses", () -> address.get().toList())))) .maxLen(3).build(); XmlTransformer xmlTransformer = new XmlTransformer.XmlTransformerBuilder<>().pretty(true).build(); - String xml = xmlTransformer.generate(Schema.of(field("persons", () -> persons.get().collect(Collectors.toList()))), 1).toString(); + String xml = xmlTransformer.generate(Schema.of(field("persons", () -> persons.get().toList())), 1).toString(); assertThat(xml).isNotEmpty(); int numberOfLines = getNumberOfLines(xml); assertThat(numberOfLines).isEqualTo(65); @@ -151,11 +150,11 @@ void generateXMLWithThreeNestedLevelsAndAttributes() { new Field[]{ field("firstname", () -> faker.name().firstName()), field("lastname", () -> faker.name().lastName()), - field(null, () -> List.of(field("addresses", () -> address.get().collect(Collectors.toList()))))})) + field(null, () -> List.of(field("addresses", () -> address.get().toList())))})) .maxLen(3).build(); XmlTransformer xmlTransformer = new XmlTransformer.XmlTransformerBuilder<>().pretty(true).build(); - String xml = xmlTransformer.generate(Schema.of(field("persons", () -> persons.get().collect(Collectors.toList()))), 1).toString(); + String xml = xmlTransformer.generate(Schema.of(field("persons", () -> persons.get().toList())), 1).toString(); assertThat(xml).isNotEmpty(); int numberOfLines = getNumberOfLines(xml); assertThat(numberOfLines).isEqualTo(23); diff --git a/src/test/java/net/datafaker/formats/YamlTest.java b/src/test/java/net/datafaker/formats/YamlTest.java index f0c4c3742..90bca7ea3 100644 --- a/src/test/java/net/datafaker/formats/YamlTest.java +++ b/src/test/java/net/datafaker/formats/YamlTest.java @@ -15,7 +15,6 @@ import java.util.List; import java.util.Map; import java.util.function.Supplier; -import java.util.stream.Collectors; import java.util.stream.IntStream; import java.util.stream.Stream; @@ -99,7 +98,7 @@ void generateFromFakeSequence(int limit) { void generateFromFakeSequenceWithCollection(int limit) { final BaseFaker faker = new BaseFaker(); Schema> schema = Schema.of(field("firstNames", name -> IntStream.rangeClosed(1, limit) - .mapToObj(it -> name.firstName()).collect(Collectors.toList()))); + .mapToObj(it -> name.firstName()).toList())); YamlTransformer transformer = new YamlTransformer<>(); String yaml = diff --git a/src/test/java/net/datafaker/providers/base/InternetTest.java b/src/test/java/net/datafaker/providers/base/InternetTest.java index 2070f36b2..5dc7c1a2b 100644 --- a/src/test/java/net/datafaker/providers/base/InternetTest.java +++ b/src/test/java/net/datafaker/providers/base/InternetTest.java @@ -18,7 +18,6 @@ import java.util.Locale; import java.util.Random; import java.util.regex.Pattern; -import java.util.stream.Collectors; import java.util.stream.Stream; import static java.lang.Integer.parseInt; @@ -161,7 +160,7 @@ void testSafeEmailAddress() { } final String safeDomain = faker.internet().resolve("internet.safe_email"); - assertThat(emails.stream().filter(t -> t.endsWith("@" + safeDomain)).collect(Collectors.toList())) + assertThat(emails.stream().filter(t -> t.endsWith("@" + safeDomain)).toList()) .isNotEmpty(); } @@ -176,7 +175,7 @@ void testSafeEmailAddressWithNameParameter() { } final String safeDomain = faker.internet().resolve("internet.safe_email"); - assertThat(emails.stream().filter(t -> t.endsWith("@" + safeDomain)).collect(Collectors.toList())) + assertThat(emails.stream().filter(t -> t.endsWith("@" + safeDomain)).toList()) .isNotEmpty(); } diff --git a/src/test/java/net/datafaker/sequence/FakeStreamTest.java b/src/test/java/net/datafaker/sequence/FakeStreamTest.java index 576f7e310..e872debf1 100644 --- a/src/test/java/net/datafaker/sequence/FakeStreamTest.java +++ b/src/test/java/net/datafaker/sequence/FakeStreamTest.java @@ -28,7 +28,6 @@ import java.util.List; import java.util.Random; import java.util.function.Supplier; -import java.util.stream.Collectors; import java.util.stream.Stream; import static net.datafaker.transformations.Field.compositeField; @@ -101,7 +100,7 @@ void generateStreamPassingSuppliersAsList() { List> suppliers = List.of(() -> faker.name().firstName(), () -> faker.name().lastName()); Stream stream = faker.stream(suppliers).len(3).generate(); - assertThat(stream.collect(Collectors.toList())).hasSize(3); + assertThat(stream.toList()).hasSize(3); } @Test @@ -115,7 +114,7 @@ void generateStreamWithRepeatableFaker() { .maxLen(20) .generate(); - List namesList = names.collect(Collectors.toList()); + List namesList = names.toList(); assertThat(namesList).hasSize(14); assertThat(namesList.get(0)).isEqualTo("Flor"); assertThat(namesList.get(1)).isEqualTo("Brian"); From 78445108a65ae3b8495eb2c3a3d76c059835c1a7 Mon Sep 17 00:00:00 2001 From: kingthorin Date: Sat, 27 Jun 2026 12:09:13 -0400 Subject: [PATCH 2/8] Prefer List/Set/Map.of methods where practical Signed-off-by: kingthorin --- docs/documentation/formats.md | 2 +- docs/documentation/schemas.md | 4 ++-- src/main/java/net/datafaker/providers/base/Internet.java | 5 ++--- src/main/java/net/datafaker/providers/base/Options.java | 5 ++--- src/main/java/net/datafaker/service/FakeValues.java | 3 +-- .../java/net/datafaker/service/FakeValuesGrouping.java | 4 ++-- .../java/net/datafaker/service/FakeValuesService.java | 8 +++----- .../net/datafaker/providers/base/CredentialsTest.java | 3 +-- .../java/net/datafaker/providers/base/InternetTest.java | 6 +++--- .../net/datafaker/service/WeightedRandomSelectorTest.java | 3 +-- 10 files changed, 18 insertions(+), 25 deletions(-) diff --git a/docs/documentation/formats.md b/docs/documentation/formats.md index a799a9d99..b22abdd38 100644 --- a/docs/documentation/formats.md +++ b/docs/documentation/formats.md @@ -22,7 +22,7 @@ attributes using randomly generated data in the following way: Collection address = faker.collection() .suppliers(() -> new Xml.XmlNode("address", map(entry("country", faker.address().country()), - entry("city", faker.address().city()), entry("streetAddress", faker.address().streetAddress())), Collections.emptyList())) + entry("city", faker.address().city()), entry("streetAddress", faker.address().streetAddress())), List.of())) .maxLen(3).build().get(); Collection persons = faker.collection() diff --git a/docs/documentation/schemas.md b/docs/documentation/schemas.md index 9fc957582..a8087c939 100644 --- a/docs/documentation/schemas.md +++ b/docs/documentation/schemas.md @@ -271,13 +271,13 @@ INSERT INTO "MyTable" ("ints") VALUES (ARRAY[1, 2, 3]); === "Java" ```java - Schema.of(field("names_multiset", () -> Collections.singleton("hello"))); + Schema.of(field("names_multiset", () -> Set.of("hello"))); ``` === "Kotlin" ```kotlin - val schema: Schema> = Schema.of(field("names_multiset", Supplier { Collections.singleton("hello") } )) + val schema: Schema> = Schema.of(field("names_multiset", Supplier { Set.of("hello") } )) ``` will lead to diff --git a/src/main/java/net/datafaker/providers/base/Internet.java b/src/main/java/net/datafaker/providers/base/Internet.java index 73e4f9f11..40d2921d6 100644 --- a/src/main/java/net/datafaker/providers/base/Internet.java +++ b/src/main/java/net/datafaker/providers/base/Internet.java @@ -10,7 +10,6 @@ import java.nio.ByteBuffer; import java.text.Normalizer; import java.util.Arrays; -import java.util.Collections; import java.util.List; import java.util.UUID; import java.util.regex.Pattern; @@ -135,7 +134,7 @@ private String toLocalPart(String name) { final List prefixList = (prefixObj instanceof List list && list.stream().allMatch(String.class::isInstance)) ? list.stream().map(String.class::cast).toList() - : Collections.emptyList(); + : List.of(); if (prefixList.contains(parts[0])) { parts = Arrays.copyOfRange(parts, 1, parts.length); } @@ -144,7 +143,7 @@ private String toLocalPart(String name) { final List suffixList = (suffixObj instanceof List list && list.stream().allMatch(String.class::isInstance)) ? list.stream().map(String.class::cast).toList() - : Collections.emptyList(); + : List.of(); if (suffixList.contains(parts[parts.length - 1])) { parts = Arrays.copyOfRange(parts, 0, parts.length - 1); } diff --git a/src/main/java/net/datafaker/providers/base/Options.java b/src/main/java/net/datafaker/providers/base/Options.java index 64032eb65..1fa4f966e 100644 --- a/src/main/java/net/datafaker/providers/base/Options.java +++ b/src/main/java/net/datafaker/providers/base/Options.java @@ -1,6 +1,5 @@ package net.datafaker.providers.base; -import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Set; @@ -76,7 +75,7 @@ public final Set subset(int size, E... options) { throw new IllegalArgumentException("size should be not negative: " + size); } if (size == 0) { - return Collections.emptySet(); + return Set.of(); } List opts = Stream.of(options).distinct().collect(Collectors.toList()); if (size >= opts.size()) { @@ -119,7 +118,7 @@ public final Set subset(int size, String... options) { throw new IllegalArgumentException("size should be not negative: " + size); } if (size == 0) { - return Collections.emptySet(); + return Set.of(); } List opts = Stream.of(options).distinct().collect(Collectors.toList()); if (size >= opts.size()) { diff --git a/src/main/java/net/datafaker/service/FakeValues.java b/src/main/java/net/datafaker/service/FakeValues.java index 702449bd8..ca88e1d53 100644 --- a/src/main/java/net/datafaker/service/FakeValues.java +++ b/src/main/java/net/datafaker/service/FakeValues.java @@ -15,7 +15,6 @@ import java.util.Set; import java.util.concurrent.ConcurrentHashMap; -import static java.util.Collections.emptyMap; import static net.datafaker.internal.helper.JavaNames.toJavaNames; public class FakeValues implements FakeValuesInterface { @@ -82,7 +81,7 @@ private Map loadValues() { return result; } } - return emptyMap(); + return Map.of(); } private void enrichMapWithJavaNames(Map result) { diff --git a/src/main/java/net/datafaker/service/FakeValuesGrouping.java b/src/main/java/net/datafaker/service/FakeValuesGrouping.java index 48ad17f5f..04e51fcf8 100644 --- a/src/main/java/net/datafaker/service/FakeValuesGrouping.java +++ b/src/main/java/net/datafaker/service/FakeValuesGrouping.java @@ -3,9 +3,9 @@ import net.datafaker.service.files.EnFile; import java.util.Collection; -import java.util.Collections; import java.util.HashMap; import java.util.HashSet; +import java.util.List; import java.util.Locale; import java.util.Map; @@ -42,7 +42,7 @@ public void add(FakeValuesInterface fakeValue) { @SuppressWarnings({"unchecked", "rawtypes"}) public Map get(String key) { Map result = null; - for (FakeValuesInterface fakeValues : fakeValues.getOrDefault(key, Collections.emptyList())) { + for (FakeValuesInterface fakeValues : fakeValues.getOrDefault(key, List.of())) { if (result == null) { result = fakeValues.get(key); } else { diff --git a/src/main/java/net/datafaker/service/FakeValuesService.java b/src/main/java/net/datafaker/service/FakeValuesService.java index 9dd55d8a3..7411fdeba 100644 --- a/src/main/java/net/datafaker/service/FakeValuesService.java +++ b/src/main/java/net/datafaker/service/FakeValuesService.java @@ -42,8 +42,6 @@ import java.util.logging.Logger; import java.util.stream.Collectors; -import static java.util.Collections.emptyList; -import static java.util.Collections.emptyMap; import static java.util.Locale.ROOT; import static java.util.Objects.requireNonNull; import static java.util.logging.Level.FINE; @@ -264,7 +262,7 @@ public T fetchObject(String key, FakerContext context) { } if (local2Add != null) { Object valueToCache = result; - Object curResult = key2fetchedObject.getOrDefault(local2Add, emptyMap()).get(key); + Object curResult = key2fetchedObject.getOrDefault(local2Add, Map.of()).get(key); if (curResult != null) { return (T) result; // Strange... Why return result, not curResult? } @@ -925,7 +923,7 @@ private MethodAndCoercedArgs accessor(Class clazz, final String accessorName, Map> classMethodsMap = CLASS_2_METHODS_CACHE.computeIfAbsent(clazz, (__) -> { Method[] classMethods = clazz.getMethods(); Map> methodMap = - classMethods.length == 0 ? emptyMap() : new HashMap<>(classMethods.length); + classMethods.length == 0 ? Map.of() : new HashMap<>(classMethods.length); for (Method m : classMethods) { String key = m.getName().toLowerCase(ROOT); methodMap.computeIfAbsent(key, k -> new ArrayList<>()).add(m); @@ -934,7 +932,7 @@ private MethodAndCoercedArgs accessor(Class clazz, final String accessorName, return methodMap; }); - Collection methods = classMethodsMap.getOrDefault(name, emptyList()); + Collection methods = classMethodsMap.getOrDefault(name, List.of()); if (methods.isEmpty()) { LOG.fine(() -> "Didn't find accessor named %s on %s with args %s".formatted(accessorName, clazz.getSimpleName(), Arrays.toString(args))); return null; diff --git a/src/test/java/net/datafaker/providers/base/CredentialsTest.java b/src/test/java/net/datafaker/providers/base/CredentialsTest.java index 5f511793a..d6fc8e517 100644 --- a/src/test/java/net/datafaker/providers/base/CredentialsTest.java +++ b/src/test/java/net/datafaker/providers/base/CredentialsTest.java @@ -1,6 +1,5 @@ package net.datafaker.providers.base; -import java.util.Collections; import java.util.List; import java.util.Locale; import java.util.regex.Matcher; @@ -132,7 +131,7 @@ void weakPassword() { final List list = (obj instanceof List l && l.stream().allMatch(String.class::isInstance)) ? l.stream().map(String.class::cast).toList() - : Collections.emptyList(); + : List.of(); assertThat(faker.credentials().weakPassword()).isIn(list); } diff --git a/src/test/java/net/datafaker/providers/base/InternetTest.java b/src/test/java/net/datafaker/providers/base/InternetTest.java index 5dc7c1a2b..c1dea983d 100644 --- a/src/test/java/net/datafaker/providers/base/InternetTest.java +++ b/src/test/java/net/datafaker/providers/base/InternetTest.java @@ -13,8 +13,8 @@ import java.net.URL; import java.util.ArrayList; -import java.util.Collections; import java.util.List; +import java.util.Set; import java.util.Locale; import java.util.Random; import java.util.regex.Pattern; @@ -129,9 +129,9 @@ void testEmailAddressTypeSafety() { when(spyedFaker.fakeValuesService()).thenReturn(mockedFakeValuesService); when(mockedFakeValuesService.fetchObject("name.prefix", spyedFaker.getContext())) - .thenReturn(Collections.emptySet()); + .thenReturn(Set.of()); when(mockedFakeValuesService.fetchObject("name.suffix", spyedFaker.getContext())) - .thenReturn(Collections.emptySet()); + .thenReturn(Set.of()); String emailAddress = spyedFaker.internet().emailAddress("John McClane"); assertThat(emailAddress).startsWith("john.mcclane@"); diff --git a/src/test/java/net/datafaker/service/WeightedRandomSelectorTest.java b/src/test/java/net/datafaker/service/WeightedRandomSelectorTest.java index 124f0f17a..091f01afe 100644 --- a/src/test/java/net/datafaker/service/WeightedRandomSelectorTest.java +++ b/src/test/java/net/datafaker/service/WeightedRandomSelectorTest.java @@ -6,7 +6,6 @@ import org.junit.jupiter.params.provider.MethodSource; import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -132,7 +131,7 @@ static Stream exceptionCasesProvider() { "Input list cannot be null" ), Arguments.of( - Collections.emptyList(), + List.of(), "Input list cannot be empty" ), Arguments.of( From 1e579b4f8b8bec8e1c293e0460fabde1d25042bf Mon Sep 17 00:00:00 2001 From: kingthorin Date: Sat, 27 Jun 2026 12:18:48 -0400 Subject: [PATCH 3/8] Leverage Records Signed-off-by: kingthorin --- .../net/datafaker/providers/base/Text.java | 65 +++++++++-------- .../datafaker/service/FakeValuesContext.java | 69 +++++++++---------- .../datafaker/service/FakeValuesService.java | 21 ++---- .../net/datafaker/service/files/EnFile.java | 9 +-- .../base/AbstractProviderListTest.java | 24 ++----- 5 files changed, 82 insertions(+), 106 deletions(-) diff --git a/src/main/java/net/datafaker/providers/base/Text.java b/src/main/java/net/datafaker/providers/base/Text.java index 689adb693..30bc297ff 100644 --- a/src/main/java/net/datafaker/providers/base/Text.java +++ b/src/main/java/net/datafaker/providers/base/Text.java @@ -121,27 +121,39 @@ public Text(BaseProviders faker) { super(faker); } - public static class TextRuleConfig { - private final char[][] textKeys; - private final int[] required; - private final int fixedNumberOfCharacters; - - private final int numberOfRequiredSymbols; - + public record TextRuleConfig( + char[][] textKeys, + int[] required, + int fixedNumberOfCharacters, + int numberOfRequiredSymbols + ) { private TextRuleConfig(int fixedNumberOfCharacters, Map map, int numberOfRequiredSymbols) { + this( + buildTextKeys(map), + buildRequired(map), + fixedNumberOfCharacters, + numberOfRequiredSymbols + ); assert numberOfRequiredSymbols >= 0; assert fixedNumberOfCharacters >= numberOfRequiredSymbols; + } + + private static char[][] buildTextKeys(Map map) { + char[][] textKeys = new char[map.size()][]; + int i = 0; + for (Map.Entry entry : map.entrySet()) { + textKeys[i++] = entry.getKey().toCharArray(); + } + return textKeys; + } - this.fixedNumberOfCharacters = fixedNumberOfCharacters; - this.numberOfRequiredSymbols = numberOfRequiredSymbols; - this.textKeys = new char[map.size()][]; - this.required = new int[map.size()]; + private static int[] buildRequired(Map map) { + int[] required = new int[map.size()]; int i = 0; - for (Map.Entry entry: map.entrySet()) { - textKeys[i] = entry.getKey().toCharArray(); - required[i] = entry.getValue(); - i++; + for (Map.Entry entry : map.entrySet()) { + required[i++] = entry.getValue(); } + return required; } public int getFixedNumberOfCharacters() { @@ -151,7 +163,6 @@ public int getFixedNumberOfCharacters() { public int getNumberOfRequiredSymbols() { return numberOfRequiredSymbols; } - } public static class TextSymbolsBuilder { @@ -238,8 +249,8 @@ public String text(TextRuleConfig textRuleConfig) { char[] buffer = new char[fixedNumberOfCharacters]; int idx = 0; int maxDiffSymbols = 0; - for (int i = 0; i < textRuleConfig.textKeys.length; i++) { - maxDiffSymbols += textRuleConfig.textKeys[i].length; + for (int i = 0; i < textRuleConfig.textKeys().length; i++) { + maxDiffSymbols += textRuleConfig.textKeys()[i].length; } // 256 is a length of byte value range if (maxDiffSymbols <= 256) { @@ -248,13 +259,13 @@ public String text(TextRuleConfig textRuleConfig) { fixedNumberOfCharacters, numberOfRequiredSymbols); } int numberOfRequired = 0; - int[] required = Arrays.copyOf(textRuleConfig.required, textRuleConfig.required.length); + int[] required = Arrays.copyOf(textRuleConfig.required(), textRuleConfig.required().length); while (idx < buffer.length) { if (numberOfRequiredSymbols > numberOfRequired && numberOfRequiredSymbols - numberOfRequired == buffer.length - idx) { - for (int j = 0; j < textRuleConfig.textKeys.length; j++) { + for (int j = 0; j < textRuleConfig.textKeys().length; j++) { while (required[j] > 0) { - buffer[idx++] = textRuleConfig.textKeys[j][faker.random().nextInt(textRuleConfig.textKeys[j].length)]; + buffer[idx++] = textRuleConfig.textKeys()[j][faker.random().nextInt(textRuleConfig.textKeys()[j].length)]; numberOfRequired++; required[j]--; } @@ -266,7 +277,7 @@ public String text(TextRuleConfig textRuleConfig) { numberOfRequired++; required[index]--; } - buffer[idx++] = textRuleConfig.textKeys[index][faker.random().nextInt(textRuleConfig.textKeys[index].length)]; + buffer[idx++] = textRuleConfig.textKeys()[index][faker.random().nextInt(textRuleConfig.textKeys()[index].length)]; } } return String.valueOf(buffer); @@ -278,25 +289,25 @@ private String textWithNotMoreThan256DiffSymbols( int idx = 0; int bytesCounter = 0; int numberOfRequired = 0; - int[] required = Arrays.copyOf(textRuleConfig.required, textRuleConfig.required.length); + int[] required = Arrays.copyOf(textRuleConfig.required(), textRuleConfig.required().length); while (idx < buffer.length) { if (numberOfRequiredSymbols > numberOfRequired && numberOfRequiredSymbols - numberOfRequired == buffer.length - idx) { - for (int j = 0; j < textRuleConfig.textKeys.length; j++) { + for (int j = 0; j < textRuleConfig.textKeys().length; j++) { while (required[j] > 0) { - buffer[idx++] = textRuleConfig.textKeys[j][((char) (bytes[bytesCounter++])) % textRuleConfig.textKeys[j].length]; + buffer[idx++] = textRuleConfig.textKeys()[j][((char) (bytes[bytesCounter++])) % textRuleConfig.textKeys()[j].length]; numberOfRequired++; required[j]--; } if (idx == buffer.length) break; } } else { - int index = ((char) (bytes[bytesCounter++])) % textRuleConfig.textKeys.length; + int index = ((char) (bytes[bytesCounter++])) % textRuleConfig.textKeys().length; if (required[index] > 0) { numberOfRequired++; required[index]--; } - buffer[idx++] = textRuleConfig.textKeys[index][((char) bytes[bytesCounter++]) % textRuleConfig.textKeys[index].length]; + buffer[idx++] = textRuleConfig.textKeys()[index][((char) bytes[bytesCounter++]) % textRuleConfig.textKeys()[index].length]; } } return String.valueOf(buffer); diff --git a/src/main/java/net/datafaker/service/FakeValuesContext.java b/src/main/java/net/datafaker/service/FakeValuesContext.java index c24540957..cea160689 100644 --- a/src/main/java/net/datafaker/service/FakeValuesContext.java +++ b/src/main/java/net/datafaker/service/FakeValuesContext.java @@ -7,37 +7,18 @@ import java.util.Locale; import java.util.Objects; -class FakeValuesContext { - private final SingletonLocale singletonLocale; - private final String filename; - private final int filenameHashCode; - private final String path; - private final URL url; - private final int urlHashCode; +record FakeValuesContext(SingletonLocale singletonLocale, String filename, String path, URL url) { private FakeValuesContext(Locale locale) { - this(locale, getFilename(locale), getFilename(locale), null); + this(SingletonLocale.get(locale), getFilename(locale), getFilename(locale), null); } private FakeValuesContext(Locale locale, URL url) { - this(locale, getFilename(locale), null, url); + this(SingletonLocale.get(locale), getFilename(locale), null, url); } private FakeValuesContext(Locale locale, String filename, String path) { - this(locale, filename, path, null); - } - - private FakeValuesContext(Locale locale, String filename, String path, URL url) { - this.singletonLocale = SingletonLocale.get(locale); - this.filename = filename; - this.path = path; - this.url = url; - this.filenameHashCode = filename == null ? 0 : filename.hashCode(); - try { - this.urlHashCode = url == null ? 0 : url.toURI().hashCode(); - } catch (URISyntaxException e) { - throw new RuntimeException("Invalid url: \"%s\"".formatted(url), e); - } + this(SingletonLocale.get(locale), filename, path, null); } public static FakeValuesContext of(Locale locale) { @@ -53,7 +34,7 @@ public static FakeValuesContext of(Locale locale, String filename, String path) } public static FakeValuesContext of(Locale locale, String filename, String path, URL url) { - return new FakeValuesContext(locale, filename, path, url); + return new FakeValuesContext(SingletonLocale.get(locale), filename, path, url); } private static String getFilename(Locale locale) { @@ -80,11 +61,11 @@ private static String language(Locale locale) { }; } - public Locale getLocale() { + Locale getLocale() { return singletonLocale.getLocale(); } - public String getFilename() { + String getFilename() { return filename; } @@ -92,32 +73,44 @@ String getPath() { return path; } - public URL getUrl() { + URL getUrl() { return url; } @Override public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - FakeValuesContext that = (FakeValuesContext) o; - - if (!Objects.equals(singletonLocale, that.singletonLocale)) return false; - if (!Objects.equals(filename, that.filename)) return false; - if (!Objects.equals(path, that.path)) return false; - return Objects.equals(url, that.url); + if (this == o) { + return true; + } + if (!(o instanceof FakeValuesContext that)) { + return false; + } + return Objects.equals(singletonLocale, that.singletonLocale) + && Objects.equals(filename, that.filename) + && Objects.equals(path, that.path) + && Objects.equals(url, that.url); } @Override public int hashCode() { int result = singletonLocale == null ? 0 : singletonLocale.hashCode(); - result = 31 * result + filenameHashCode; + result = 31 * result + (filename == null ? 0 : filename.hashCode()); result = 31 * result + (path == null ? 0 : path.hashCode()); - result = 31 * result + urlHashCode; + result = 31 * result + urlHashCode(url); return result; } + private static int urlHashCode(URL url) { + if (url == null) { + return 0; + } + try { + return url.toURI().hashCode(); + } catch (URISyntaxException e) { + throw new RuntimeException("Invalid url: \"%s\"".formatted(url), e); + } + } + @Override public String toString() { return "FakeValuesContext{%s, filename='%s', path='%s', url=%s}".formatted(singletonLocale, filename, path, url); diff --git a/src/main/java/net/datafaker/service/FakeValuesService.java b/src/main/java/net/datafaker/service/FakeValuesService.java index 7411fdeba..70fd4f684 100644 --- a/src/main/java/net/datafaker/service/FakeValuesService.java +++ b/src/main/java/net/datafaker/service/FakeValuesService.java @@ -163,23 +163,12 @@ public String fetchString(String key, FakerContext context) { return (String) fetch(key, context); } - private class SafeFetchResolver implements ValueResolver { - private final String simpleDirective; - private final FakerContext context; - - private SafeFetchResolver(String simpleDirective, FakerContext context) { - this.simpleDirective = simpleDirective; - this.context = context; - } + private record SafeFetchResolver(FakeValuesService service, String simpleDirective, FakerContext context) + implements ValueResolver { @Override public Object resolve() { - return safeFetch(simpleDirective, context, null); - } - - @Override - public String toString() { - return "%s[simpleDirective=%s, context=%s]".formatted(getClass().getSimpleName(), simpleDirective, context); + return service.safeFetch(simpleDirective, context, null); } } @@ -755,7 +744,7 @@ private Object resolveExpression(String directive, String[] args, Object current // car.wheel will be looked up in the YAML file. // It's only "simple" if there aren't args if (args.length == 0) { - res.add(new SafeFetchResolver(simpleDirective, context)); + res.add(new SafeFetchResolver(this, simpleDirective, context)); } // resolve method references on faker object like #{regexify '[a-z]'} @@ -775,7 +764,7 @@ private Object resolveExpression(String directive, String[] args, Object current // class.method_name (lowercase) if (dotIndex >= 0) { final String key = javaNameToYamlName(simpleDirective); - res.add(new SafeFetchResolver(key, context)); + res.add(new SafeFetchResolver(this, key, context)); } return res; diff --git a/src/main/java/net/datafaker/service/files/EnFile.java b/src/main/java/net/datafaker/service/files/EnFile.java index 737d1a43a..446d8f6c4 100644 --- a/src/main/java/net/datafaker/service/files/EnFile.java +++ b/src/main/java/net/datafaker/service/files/EnFile.java @@ -3,20 +3,13 @@ import java.util.List; import java.util.stream.Stream; -public class EnFile { +public record EnFile(String file, String path) { private static final String YML = ".yml"; - private final String file; - private final String path; private EnFile(String file) { this(file, file.endsWith(YML) ? file.substring(0, file.length() - YML.length()) : file); } - private EnFile(String file, String path) { - this.file = file; - this.path = path; - } - public String getFile() { return file; } diff --git a/src/test/java/net/datafaker/providers/base/AbstractProviderListTest.java b/src/test/java/net/datafaker/providers/base/AbstractProviderListTest.java index 227d95443..e864679b8 100644 --- a/src/test/java/net/datafaker/providers/base/AbstractProviderListTest.java +++ b/src/test/java/net/datafaker/providers/base/AbstractProviderListTest.java @@ -37,14 +37,14 @@ protected List getBaseList(T faker, String key) { return faker.fakeValuesService().fetchObject(key, faker.getContext()); } - protected void testProviderList(ProviderListTest.TestSpec testSpec, T faker) { + protected void testProviderList(TestSpec testSpec, T faker) { // Given - Set expected = new HashSet<>(getBaseList(faker, testSpec.key)); + Set expected = new HashSet<>(getBaseList(faker, testSpec.key())); // When - String actual = (String) testSpec.supplier.get(); + String actual = (String) testSpec.supplier().get(); // Then assertThat(actual).isNotEmpty(); - String collection = "\"" + testSpec.key + "\""; + String collection = "\"" + testSpec.key() + "\""; assertThat(expected) .as(() -> "Check expected list isn't empty and contains the actual for the key " + collection) .isNotEmpty() @@ -52,22 +52,12 @@ protected void testProviderList(ProviderListTest.TestSpec testSpec, T faker) { assertThat(expected) .as(() -> "Actual should not have empty entries. " + collection) .noneMatch(String::isBlank); - if (!testSpec.regex.isEmpty()) { - assertThat(actual).matches(Pattern.compile(testSpec.regex)); + if (!testSpec.regex().isEmpty()) { + assertThat(actual).matches(Pattern.compile(testSpec.regex())); } } - protected static class TestSpec { - private final Supplier supplier; - private final String key; - private final String regex; - - private TestSpec(Supplier supplier, String key, String regex) { - this.supplier = supplier; - this.key = key; - this.regex = regex; - } - + protected record TestSpec(Supplier supplier, String key, String regex) { public static TestSpec of(Supplier supplier, String key) { return new TestSpec(supplier, key, ""); } From 7a8f78bfe16cd5a89c5296753f05fa6c72964817 Mon Sep 17 00:00:00 2001 From: kingthorin Date: Sat, 27 Jun 2026 12:24:19 -0400 Subject: [PATCH 4/8] Adjust instanceof usage Signed-off-by: kingthorin --- .../net/datafaker/service/FakeValues.java | 4 ++-- .../datafaker/service/FakeValuesGrouping.java | 8 +++---- .../datafaker/service/FakeValuesService.java | 24 +++++++++---------- .../transformations/CsvTransformer.java | 4 ++-- .../JavaObjectTransformer.java | 6 ++--- .../transformations/JsonTransformer.java | 14 ++++++----- .../transformations/XmlTransformer.java | 8 +++---- .../transformations/YamlTransformer.java | 8 +++---- .../transformations/sql/SqlTransformer.java | 4 ++-- 9 files changed, 41 insertions(+), 39 deletions(-) diff --git a/src/main/java/net/datafaker/service/FakeValues.java b/src/main/java/net/datafaker/service/FakeValues.java index ca88e1d53..b897a3967 100644 --- a/src/main/java/net/datafaker/service/FakeValues.java +++ b/src/main/java/net/datafaker/service/FakeValues.java @@ -90,9 +90,9 @@ private void enrichMapWithJavaNames(Map result) { for (Map.Entry entry : result.entrySet()) { final String key = entry.getKey(); Object value = entry.getValue(); - if (entry.getValue() instanceof Map) { + if (value instanceof Map rawMap) { @SuppressWarnings("unchecked") - Map entryMap = (Map) entry.getValue(); + Map entryMap = (Map) rawMap; prefixUnqualifiedExpressions(entryMap, key); Map nestedMap = new HashMap<>(entryMap.size()); for (Map.Entry e: entryMap.entrySet()) { diff --git a/src/main/java/net/datafaker/service/FakeValuesGrouping.java b/src/main/java/net/datafaker/service/FakeValuesGrouping.java index 04e51fcf8..0f34b7f23 100644 --- a/src/main/java/net/datafaker/service/FakeValuesGrouping.java +++ b/src/main/java/net/datafaker/service/FakeValuesGrouping.java @@ -27,12 +27,12 @@ public FakeValuesGrouping(FakeValues values) { } public void add(FakeValuesInterface fakeValue) { - if (fakeValue instanceof FakeValues) { - ((FakeValues) fakeValue).getPaths().forEach(p -> + if (fakeValue instanceof FakeValues values) { + values.getPaths().forEach(p -> fakeValues.computeIfAbsent(p, key -> new HashSet<>()) .add(fakeValue)); - } else if (fakeValue instanceof FakeValuesGrouping) { - fakeValues.putAll(((FakeValuesGrouping) fakeValue).fakeValues); + } else if (fakeValue instanceof FakeValuesGrouping grouping) { + fakeValues.putAll(grouping.fakeValues); } else { throw new RuntimeException(fakeValues.getClass().getName() + " not supported (please raise an issue)"); } diff --git a/src/main/java/net/datafaker/service/FakeValuesService.java b/src/main/java/net/datafaker/service/FakeValuesService.java index 70fd4f684..426b12163 100644 --- a/src/main/java/net/datafaker/service/FakeValuesService.java +++ b/src/main/java/net/datafaker/service/FakeValuesService.java @@ -142,8 +142,8 @@ public void addUrl(Locale locale, URL url) { public Object fetch(String key, FakerContext context) { List valuesArray = null; final Object o = fetchObject(key, context); - if (o instanceof List) { - valuesArray = (List) o; + if (o instanceof List list) { + valuesArray = list; final int size = valuesArray.size(); if (size == 0) { return null; @@ -193,8 +193,8 @@ public String safeFetch(String key, FakerContext context, String defaultIfNull) Object o = fetchObject(key, context); String str; if (o == null) return defaultIfNull; - if (o instanceof List) { - final List values = (List) o; + if (o instanceof List list) { + final List values = (List) list; final int size = values.size(); return switch (size) { case 0 -> defaultIfNull; @@ -237,8 +237,8 @@ public T fetchObject(String key, FakerContext context) { Object currentValue = fakeValuesInterfaceMap.get(sLocale); for (int p = 0; currentValue != null && p < path.length; p++) { String currentPath = path[p]; - if (currentValue instanceof Map) { - currentValue = ((Map) currentValue).get(currentPath); + if (currentValue instanceof Map map) { + currentValue = map.get(currentPath); } else { currentValue = ((FakeValuesInterface) currentValue).get(currentPath); } @@ -670,14 +670,14 @@ private String[] splitExpressions(String expression, int length) { private Object resExp(String directive, String[] args, Object current, ProviderRegistration root, FakerContext context, String expr) { Object res = resolveExpression(directive, args, current, root, context); LOG.fine(() -> "resExp(%s [%s]) current: %s, root: %s, context: %s, expr: %s -> res: %s".formatted(directive, Arrays.toString(args), current, root, context, expr, res)); - if (res instanceof CharSequence) { - if (((CharSequence) res).isEmpty()) { + if (res instanceof CharSequence charSequence) { + if (charSequence.isEmpty()) { regexp2SupplierMap.put(expr, new RegExpContext(root, context, EMPTY_STRING)); } return res; } - if (res instanceof List) { - Iterator it = ((List) res).iterator(); + if (res instanceof List list) { + Iterator it = ((List) list).iterator(); while (it.hasNext()) { Object valueResolver = it.next(); Object value; @@ -716,8 +716,8 @@ private Object resolveExpression(String directive, String[] args, Object current // resolve method references on CURRENT object like #{number_between '1','10'} on Number or // #{ssn_valid} on IdNumber if (dotIndex == -1) { - if (current instanceof AbstractProvider) { - final Method method = BaseFaker.getMethod((AbstractProvider) current, directive); + if (current instanceof AbstractProvider provider) { + final Method method = BaseFaker.getMethod(provider, directive); if (method != null) { res.add(new MethodResolver(method, current, args)); return res; diff --git a/src/main/java/net/datafaker/transformations/CsvTransformer.java b/src/main/java/net/datafaker/transformations/CsvTransformer.java index be3c5b91a..b3bb6f801 100644 --- a/src/main/java/net/datafaker/transformations/CsvTransformer.java +++ b/src/main/java/net/datafaker/transformations/CsvTransformer.java @@ -61,8 +61,8 @@ public String generate(Iterable input, Schema schema) { } private void addLine(StringBuilder sb, Object transform) { - if (transform instanceof CharSequence) { - addCharSequence(sb, (CharSequence) transform); + if (transform instanceof CharSequence charSequence) { + addCharSequence(sb, charSequence); } else { sb.append(transform); } diff --git a/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java b/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java index 3e7ec85e2..fe8e7de6c 100644 --- a/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java +++ b/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java @@ -28,10 +28,10 @@ public class JavaObjectTransformer implements Transformer { @Override public Object apply(Object input, Schema schema) { - Class clazz; + Class clazz; Object result = null; - if (input instanceof Class) { - clazz = (Class) input; + if (input instanceof Class inputClass) { + clazz = inputClass; } else { clazz = input.getClass(); result = input; diff --git a/src/main/java/net/datafaker/transformations/JsonTransformer.java b/src/main/java/net/datafaker/transformations/JsonTransformer.java index 3afbf1995..409aa0628 100644 --- a/src/main/java/net/datafaker/transformations/JsonTransformer.java +++ b/src/main/java/net/datafaker/transformations/JsonTransformer.java @@ -32,8 +32,10 @@ public String apply(IN input, Schema schema) { for (int i = 0; i < fields.length; i++) { value2String((fields[i].getName()), sb); sb.append(": "); - if (fields[i] instanceof CompositeField) { - sb.append(apply(input, (CompositeField) fields[i], i)); + if (fields[i] instanceof CompositeField compositeField) { + sb.append(apply(input, compositeField, i)); + } else if (fields[i] instanceof SimpleField simpleField) { + applyValue(input, sb, simpleField.transform(input)); } else { applyValue(input, sb, ((SimpleField) fields[i]).transform(input)); } @@ -89,8 +91,8 @@ public String getElementSeparator() { } private void applyValue(IN input, StringBuilder sb, Object value) { - if (value instanceof Collection) { - sb.append(generate(input, (Collection) value)); + if (value instanceof Collection collection) { + sb.append(generate(input, (Collection) collection)); } else if (value != null && value.getClass().isArray()) { sb.append(generate(input, Arrays.asList((Object[]) value))); } else { @@ -107,8 +109,8 @@ private String generate(IN input, Collection collection) { sb.append(", "); } i++; - if (value instanceof CompositeField) { - sb.append(apply(input, ((CompositeField) value))); + if (value instanceof CompositeField compositeField) { + sb.append(apply(input, compositeField)); } else { applyValue(input, sb, value); } diff --git a/src/main/java/net/datafaker/transformations/XmlTransformer.java b/src/main/java/net/datafaker/transformations/XmlTransformer.java index 5bb52a9aa..915995dcf 100644 --- a/src/main/java/net/datafaker/transformations/XmlTransformer.java +++ b/src/main/java/net/datafaker/transformations/XmlTransformer.java @@ -85,8 +85,8 @@ private void apply(IN input, StringBuilder sb, Field xmlNode) { final String tag = xmlNode.getName().trim(); sb.append("<").append(tag); - if (xmlNode instanceof CompositeField) { - Field[] attrs = ((CompositeField) xmlNode).getFields(); + if (xmlNode instanceof CompositeField compositeField) { + Field[] attrs = compositeField.getFields(); applyAttributes(input, sb, attrs); xmlNode = Arrays.stream(attrs) @@ -120,8 +120,8 @@ private void applyTag(IN input, StringBuilder sb, Field field, String tag sb.append(""); } - } else if (xmlNodeValue instanceof String) { - applyValue(sb, tag, (String) xmlNodeValue); + } else if (xmlNodeValue instanceof String stringValue) { + applyValue(sb, tag, stringValue); } else if (xmlNodeValue == null) { applyValue(sb, tag, null); } diff --git a/src/main/java/net/datafaker/transformations/YamlTransformer.java b/src/main/java/net/datafaker/transformations/YamlTransformer.java index 80f0dea5c..1361f8918 100644 --- a/src/main/java/net/datafaker/transformations/YamlTransformer.java +++ b/src/main/java/net/datafaker/transformations/YamlTransformer.java @@ -89,13 +89,13 @@ private void addCollection(StringBuilder sb, Collection collection, Stri } } private void value2String(Object value, StringBuilder sb, String offset) { - if (value instanceof Schema) { - Field[] fields = ((Schema) value).getFields(); + if (value instanceof Schema schemaValue) { + Field[] fields = schemaValue.getFields(); apply(sb, null, fields, offset); - } else if (value instanceof Collection) { + } else if (value instanceof Collection collection) { sb.append(System.lineSeparator()); offset += INDENTATION; - addCollection(sb, (Collection) value, offset); + addCollection(sb, (Collection) collection, offset); } else if (value != null && value.getClass().isArray()) { sb.append(System.lineSeparator()); offset += INDENTATION; diff --git a/src/main/java/net/datafaker/transformations/sql/SqlTransformer.java b/src/main/java/net/datafaker/transformations/sql/SqlTransformer.java index 697212ed3..18316628b 100644 --- a/src/main/java/net/datafaker/transformations/sql/SqlTransformer.java +++ b/src/main/java/net/datafaker/transformations/sql/SqlTransformer.java @@ -118,9 +118,9 @@ private String addValues(IN input, Field[] fields, Boolean isRoot) { } } - if (fields[i] instanceof SimpleField) { + if (fields[i] instanceof SimpleField simpleField) { //noinspection unchecked - Object value = ((SimpleField) fields[i]).transform(input); + Object value = ((SimpleField) simpleField).transform(input); Class clazz = value == null ? null : value.getClass(); if (value == null || value instanceof Number From 33d6de2c9690a7b26ea38af634a93baef1528486 Mon Sep 17 00:00:00 2001 From: kingthorin Date: Sat, 27 Jun 2026 12:28:46 -0400 Subject: [PATCH 5/8] var + local variable type inference Types inferred at compile time; no runtime performance impact when var replaces an equivalent explicit type. Signed-off-by: kingthorin --- .../net/datafaker/providers/base/Fingerprint.java | 2 +- .../java/net/datafaker/providers/base/Image.java | 2 +- src/main/java/net/datafaker/providers/base/Text.java | 4 ++-- src/main/java/net/datafaker/service/FakeValues.java | 10 +++++----- .../net/datafaker/service/FakeValuesService.java | 5 ++--- .../datafaker/transformations/CsvTransformer.java | 4 +--- .../transformations/JavaObjectTransformer.java | 2 +- .../datafaker/transformations/JsonTransformer.java | 3 +-- .../datafaker/transformations/TomlTransformer.java | 2 +- .../datafaker/transformations/XmlTransformer.java | 2 +- .../datafaker/transformations/YamlTransformer.java | 2 +- .../transformations/sql/SqlTransformer.java | 2 +- src/test/java/net/datafaker/FakerTest.java | 2 +- .../java/net/datafaker/NoDuplicatesInYmlTest.java | 5 ++--- .../java/net/datafaker/ThreadLocalLogHandler.java | 2 +- .../java/net/datafaker/assertions/ImageAssert.java | 3 +-- src/test/java/net/datafaker/formats/JsonTest.java | 2 +- src/test/java/net/datafaker/formats/YamlTest.java | 2 +- .../datafaker/integration/FakerIntegrationTest.java | 6 +++--- .../FakerRepeatabilityIntegrationTest.java | 4 ++-- .../datafaker/integration/UkLocalDirectivesTest.java | 4 ++-- .../net/datafaker/providers/base/DomainTest.java | 8 ++++---- .../net/datafaker/providers/base/FinanceTest.java | 2 +- .../java/net/datafaker/providers/base/HttpTest.java | 2 +- .../net/datafaker/providers/base/InternetTest.java | 4 ++-- .../net/datafaker/providers/base/NumberTest.java | 4 ++-- .../net/datafaker/providers/base/TwitterTest.java | 4 ++-- .../datafaker/script/MkdocsReleaseNavUpdater.java | 4 ++-- .../java/net/datafaker/script/ProviderGenerator.java | 6 +++--- .../net/datafaker/script/ProvidersDocsGenerator.java | 8 ++++---- .../net/datafaker/script/ReleaseNotesGenerator.java | 4 ++-- .../net/datafaker/sequence/FakeCollectionTest.java | 12 ++++++------ .../java/net/datafaker/sequence/FakeStreamTest.java | 6 +++--- .../service/WeightedRandomSelectorTest.java | 2 +- 34 files changed, 65 insertions(+), 71 deletions(-) diff --git a/src/main/java/net/datafaker/providers/base/Fingerprint.java b/src/main/java/net/datafaker/providers/base/Fingerprint.java index a837eb353..06102f6e3 100644 --- a/src/main/java/net/datafaker/providers/base/Fingerprint.java +++ b/src/main/java/net/datafaker/providers/base/Fingerprint.java @@ -65,7 +65,7 @@ private PatternType randomType() { } private byte[] encodePng(BufferedImage image) { - try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) { + try (var baos = new ByteArrayOutputStream()) { ImageIO.write(image, "PNG", baos); return baos.toByteArray(); } catch (IOException e) { diff --git a/src/main/java/net/datafaker/providers/base/Image.java b/src/main/java/net/datafaker/providers/base/Image.java index 3cfb53c93..89aa305d3 100644 --- a/src/main/java/net/datafaker/providers/base/Image.java +++ b/src/main/java/net/datafaker/providers/base/Image.java @@ -150,7 +150,7 @@ private String generateBase64RasterImage(ImageType imageType, int width, int hei } graphics.dispose(); - try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) { + try (var baos = new ByteArrayOutputStream()) { ImageIO.write(bufferedImage, imageType.name(), baos); byte[] imageBytes = baos.toByteArray(); return "data:" + imageType.mimeType + ";base64," + Base64.getEncoder().encodeToString(imageBytes); diff --git a/src/main/java/net/datafaker/providers/base/Text.java b/src/main/java/net/datafaker/providers/base/Text.java index 30bc297ff..8961e6630 100644 --- a/src/main/java/net/datafaker/providers/base/Text.java +++ b/src/main/java/net/datafaker/providers/base/Text.java @@ -141,7 +141,7 @@ private TextRuleConfig(int fixedNumberOfCharacters, Map map, in private static char[][] buildTextKeys(Map map) { char[][] textKeys = new char[map.size()][]; int i = 0; - for (Map.Entry entry : map.entrySet()) { + for (var entry : map.entrySet()) { textKeys[i++] = entry.getKey().toCharArray(); } return textKeys; @@ -150,7 +150,7 @@ private static char[][] buildTextKeys(Map map) { private static int[] buildRequired(Map map) { int[] required = new int[map.size()]; int i = 0; - for (Map.Entry entry : map.entrySet()) { + for (var entry : map.entrySet()) { required[i++] = entry.getValue(); } return required; diff --git a/src/main/java/net/datafaker/service/FakeValues.java b/src/main/java/net/datafaker/service/FakeValues.java index b897a3967..227e7abb7 100644 --- a/src/main/java/net/datafaker/service/FakeValues.java +++ b/src/main/java/net/datafaker/service/FakeValues.java @@ -40,7 +40,7 @@ private Map loadFromUrl() { if (url == null) { return null; } - try (InputStream stream = url.openStream()) { + try (var stream = url.openStream()) { Map result = readFromStream(stream); enrichMapWithJavaNames(result); return result; @@ -63,12 +63,12 @@ private Map loadValues() { "/" + locale.getLanguage() + ".yml"}; for (String path : paths) { - try (InputStream stream = getClass().getResourceAsStream(path)) { + try (var stream = getClass().getResourceAsStream(path)) { if (stream != null) { result = readFromStream(stream); enrichMapWithJavaNames(result); } else { - try (InputStream stream2 = getClass().getClassLoader().getResourceAsStream(path)) { + try (var stream2 = getClass().getClassLoader().getResourceAsStream(path)) { result = readFromStream(stream2); enrichMapWithJavaNames(result); } @@ -87,7 +87,7 @@ private Map loadValues() { private void enrichMapWithJavaNames(Map result) { if (result != null) { Map map = null; - for (Map.Entry entry : result.entrySet()) { + for (var entry : result.entrySet()) { final String key = entry.getKey(); Object value = entry.getValue(); if (value instanceof Map rawMap) { @@ -95,7 +95,7 @@ private void enrichMapWithJavaNames(Map result) { Map entryMap = (Map) rawMap; prefixUnqualifiedExpressions(entryMap, key); Map nestedMap = new HashMap<>(entryMap.size()); - for (Map.Entry e: entryMap.entrySet()) { + for (var e : entryMap.entrySet()) { nestedMap.put(toJavaNames(e.getKey(), true), e.getValue()); } entryMap.putAll(nestedMap); diff --git a/src/main/java/net/datafaker/service/FakeValuesService.java b/src/main/java/net/datafaker/service/FakeValuesService.java index 426b12163..0690bef55 100644 --- a/src/main/java/net/datafaker/service/FakeValuesService.java +++ b/src/main/java/net/datafaker/service/FakeValuesService.java @@ -31,7 +31,6 @@ import java.util.Collection; import java.util.HashMap; import java.util.IdentityHashMap; -import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; @@ -677,7 +676,7 @@ private Object resExp(String directive, String[] args, Object current, ProviderR return res; } if (res instanceof List list) { - Iterator it = ((List) list).iterator(); + var it = ((List) list).iterator(); while (it.hasNext()) { Object valueResolver = it.next(); Object value; @@ -909,7 +908,7 @@ private MethodAndCoercedArgs accessor(Class clazz, final String accessorName, LOG.fine(() -> "Find accessor named %s on %s with args %s".formatted(accessorName, clazz.getSimpleName(), Arrays.toString(args))); String name = removeUnderscoreChars(accessorName); - Map> classMethodsMap = CLASS_2_METHODS_CACHE.computeIfAbsent(clazz, (__) -> { + var classMethodsMap = CLASS_2_METHODS_CACHE.computeIfAbsent(clazz, (__) -> { Method[] classMethods = clazz.getMethods(); Map> methodMap = classMethods.length == 0 ? Map.of() : new HashMap<>(classMethods.length); diff --git a/src/main/java/net/datafaker/transformations/CsvTransformer.java b/src/main/java/net/datafaker/transformations/CsvTransformer.java index b3bb6f801..00ba474f8 100644 --- a/src/main/java/net/datafaker/transformations/CsvTransformer.java +++ b/src/main/java/net/datafaker/transformations/CsvTransformer.java @@ -2,8 +2,6 @@ import net.datafaker.sequence.FakeSequence; -import java.util.Iterator; - public class CsvTransformer implements Transformer { public static final String DEFAULT_SEPARATOR = ";"; public static final char DEFAULT_QUOTE = '"'; @@ -46,7 +44,7 @@ public String generate(Iterable input, Schema schema) { StringBuilder sb = new StringBuilder(); generateHeader(schema, sb, true); - Iterator iterator = input.iterator(); + var iterator = input.iterator(); boolean hasNext = iterator.hasNext(); while (hasNext) { IN in = iterator.next(); diff --git a/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java b/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java index fe8e7de6c..49828598e 100644 --- a/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java +++ b/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java @@ -78,7 +78,7 @@ public Object apply(Object input, Schema schema) { Consumer consumer = SCHEMA2CONSUMER.get(schema); if (consumer == null) { final Field[] fields = schema.getFields(); - final Map name2ClassField = Stream.of(clazz.getDeclaredFields()).collect( + var name2ClassField = Stream.of(clazz.getDeclaredFields()).collect( Collectors.toMap(java.lang.reflect.Field::getName, Function.identity())); final java.lang.reflect.Field[] rFields = new java.lang.reflect.Field[fields.length]; for (int i = 0; i < fields.length; i++) { diff --git a/src/main/java/net/datafaker/transformations/JsonTransformer.java b/src/main/java/net/datafaker/transformations/JsonTransformer.java index 409aa0628..419d3e1a4 100644 --- a/src/main/java/net/datafaker/transformations/JsonTransformer.java +++ b/src/main/java/net/datafaker/transformations/JsonTransformer.java @@ -6,7 +6,6 @@ import java.math.BigInteger; import java.util.Arrays; import java.util.Collection; -import java.util.Iterator; import java.util.Map; import java.util.StringJoiner; @@ -54,7 +53,7 @@ public String generate(Iterable input, Schema schema) { } StringJoiner data = new StringJoiner(LINE_SEPARATOR); - Iterator iterator = input.iterator(); + var iterator = input.iterator(); while (iterator.hasNext()) { data.add(apply(iterator.next(), schema) + (commaBetweenObjects && iterator.hasNext() ? "," : "")); } diff --git a/src/main/java/net/datafaker/transformations/TomlTransformer.java b/src/main/java/net/datafaker/transformations/TomlTransformer.java index 7a0c7cea0..f3a311979 100644 --- a/src/main/java/net/datafaker/transformations/TomlTransformer.java +++ b/src/main/java/net/datafaker/transformations/TomlTransformer.java @@ -27,7 +27,7 @@ public String generate(Iterable input, Schema schema) { throw new IllegalArgumentException("The sequence should be finite of size: " + fs); } StringJoiner joiner = new StringJoiner(LINE_SEPARATOR); - for (IN in : input) { + for (var in : input) { joiner.add(apply(in, schema)); } return joiner.toString(); diff --git a/src/main/java/net/datafaker/transformations/XmlTransformer.java b/src/main/java/net/datafaker/transformations/XmlTransformer.java index 915995dcf..30f21e46d 100644 --- a/src/main/java/net/datafaker/transformations/XmlTransformer.java +++ b/src/main/java/net/datafaker/transformations/XmlTransformer.java @@ -34,7 +34,7 @@ public String generate(Iterable input, Schema schema) { } StringJoiner data = new StringJoiner(LINE_SEPARATOR); - for (IN in : input) { + for (var in : input) { data.add(apply(in, schema)); } diff --git a/src/main/java/net/datafaker/transformations/YamlTransformer.java b/src/main/java/net/datafaker/transformations/YamlTransformer.java index 1361f8918..457d6d1f4 100644 --- a/src/main/java/net/datafaker/transformations/YamlTransformer.java +++ b/src/main/java/net/datafaker/transformations/YamlTransformer.java @@ -30,7 +30,7 @@ public String generate(Iterable input, Schema schema) { } StringJoiner data = new StringJoiner(LINE_SEPARATOR); - for (IN in : input) { + for (var in : input) { data.add(apply(in, schema)); } diff --git a/src/main/java/net/datafaker/transformations/sql/SqlTransformer.java b/src/main/java/net/datafaker/transformations/sql/SqlTransformer.java index 18316628b..5c15f9ba0 100644 --- a/src/main/java/net/datafaker/transformations/sql/SqlTransformer.java +++ b/src/main/java/net/datafaker/transformations/sql/SqlTransformer.java @@ -181,7 +181,7 @@ private String handleObjectInCollection(Collection collection) { private String handleObjectInMap(Map map) { StringBuilder result = new StringBuilder(); int i = 0; - for (Map.Entry entry : map.entrySet()) { + for (var entry : map.entrySet()) { result.append(handleObject(entry.getKey())); result.append(", "); result.append(handleObject(entry.getValue())); diff --git a/src/test/java/net/datafaker/FakerTest.java b/src/test/java/net/datafaker/FakerTest.java index 6dba85849..ca00fb7c4 100644 --- a/src/test/java/net/datafaker/FakerTest.java +++ b/src/test/java/net/datafaker/FakerTest.java @@ -372,7 +372,7 @@ void testDeterministicAndNonDeterministicProvidersReturnValues() { IllegalAccessException e) { throw new RuntimeException(e); } - for (Method m : methods) { + for (var m : methods) { final var set = new HashSet<>(); try { int currentSize = 0; diff --git a/src/test/java/net/datafaker/NoDuplicatesInYmlTest.java b/src/test/java/net/datafaker/NoDuplicatesInYmlTest.java index 926f1a60a..0808a6fb0 100644 --- a/src/test/java/net/datafaker/NoDuplicatesInYmlTest.java +++ b/src/test/java/net/datafaker/NoDuplicatesInYmlTest.java @@ -5,7 +5,6 @@ import org.yaml.snakeyaml.Yaml; import java.io.IOException; -import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; @@ -24,7 +23,7 @@ public class NoDuplicatesInYmlTest { @ParameterizedTest @MethodSource("ymlFiles") void noDuplicatesInArrays(Path file) { - try (InputStream in = newInputStream(file)) { + try (var in = newInputStream(file)) { Object ymlContent = new Yaml().load(in); var errors = findDuplicates(ymlContent); assertThat(errors) @@ -64,7 +63,7 @@ private void findDuplicatesRecursively(Object node, String path, Map list) { Set seen = new HashSet<>(); - for (Object value : list) { + for (var value : list) { if (!seen.add(value) && !areDuplicatesAllowed(path)) { errors.computeIfAbsent(path, k -> new HashSet<>()).add(value); } diff --git a/src/test/java/net/datafaker/ThreadLocalLogHandler.java b/src/test/java/net/datafaker/ThreadLocalLogHandler.java index 333e82bdd..152fd5a2c 100644 --- a/src/test/java/net/datafaker/ThreadLocalLogHandler.java +++ b/src/test/java/net/datafaker/ThreadLocalLogHandler.java @@ -42,7 +42,7 @@ static void finish(boolean writeLogs) { List threadLogs = logs.get(); if (!threadLogs.isEmpty()) { consoleHandler.publish(summaryLog(threadLogs)); - for (LogRecord log : threadLogs) { + for (var log : threadLogs) { consoleHandler.publish(log); } } diff --git a/src/test/java/net/datafaker/assertions/ImageAssert.java b/src/test/java/net/datafaker/assertions/ImageAssert.java index 32a73dde7..5151d0574 100644 --- a/src/test/java/net/datafaker/assertions/ImageAssert.java +++ b/src/test/java/net/datafaker/assertions/ImageAssert.java @@ -13,7 +13,6 @@ import java.awt.image.BufferedImage; import java.io.ByteArrayInputStream; import java.io.IOException; -import java.io.InputStream; import java.util.Base64; import java.util.regex.Pattern; @@ -54,7 +53,7 @@ private void assertImageDataUrl(ImageType type) { private ImageAssert verifyImage(ImageData image, int width, int height) { String content = RE.matcher(image.url()).replaceFirst("$1"); byte[] bytes = Base64.getDecoder().decode(content); - try (InputStream in = new ByteArrayInputStream(bytes)) { + try (var in = new ByteArrayInputStream(bytes)) { BufferedImage i = ImageIO.read(in); assertThat(i.getWidth()).isEqualTo(width); assertThat(i.getHeight()).isEqualTo(height); diff --git a/src/test/java/net/datafaker/formats/JsonTest.java b/src/test/java/net/datafaker/formats/JsonTest.java index d48f51d4a..8e8a84bb6 100644 --- a/src/test/java/net/datafaker/formats/JsonTest.java +++ b/src/test/java/net/datafaker/formats/JsonTest.java @@ -324,7 +324,7 @@ private static Map.Entry, Supplier> entry( private static Map, Supplier> map( Map.Entry, Supplier>... entries) { Map, Supplier> map = new LinkedHashMap<>(); - for (Map.Entry, Supplier> entry : entries) { + for (var entry : entries) { map.put(entry.getKey(), entry.getValue()); } return map; diff --git a/src/test/java/net/datafaker/formats/YamlTest.java b/src/test/java/net/datafaker/formats/YamlTest.java index 90bca7ea3..e3b289cb1 100644 --- a/src/test/java/net/datafaker/formats/YamlTest.java +++ b/src/test/java/net/datafaker/formats/YamlTest.java @@ -119,7 +119,7 @@ void generateFromFakeSequenceWithCollection(int limit) { @SafeVarargs private static Map, Supplier> map(Map.Entry, Supplier>... entries) { Map, Supplier> map = new LinkedHashMap<>(); - for (Map.Entry, Supplier> entry : entries) { + for (var entry : entries) { map.put(entry.getKey(), entry.getValue()); } return map; diff --git a/src/test/java/net/datafaker/integration/FakerIntegrationTest.java b/src/test/java/net/datafaker/integration/FakerIntegrationTest.java index 8e0768bd3..43de8f804 100644 --- a/src/test/java/net/datafaker/integration/FakerIntegrationTest.java +++ b/src/test/java/net/datafaker/integration/FakerIntegrationTest.java @@ -93,7 +93,7 @@ void testAllFakerMethodsThatReturnStrings(Locale locale, Random random) throws E final Faker faker = init(locale, random); Method[] methods = faker.getClass().getMethods(); - for (Method provider : methods) { + for (var provider : methods) { if (AbstractProvider.class.isAssignableFrom(provider.getReturnType()) && provider.getParameterCount() == 0) { log.fine(() -> " (%s), method: %s.%s()".formatted(locale, provider.getDeclaringClass().getSimpleName(), provider.getName())); @@ -111,7 +111,7 @@ private void testAllMethodsThatReturnStringsActuallyReturnStrings(AbstractProvid withReturnType(String.class), withParametersCount(0)); - for (Method method : methodsThatReturnStrings) { + for (var method : methodsThatReturnStrings) { if (isExcepted(provider, method, locale)) { continue; } @@ -169,7 +169,7 @@ private static Stream dataParameters() { arguments.add(Arguments.of(null, null)); String[] ymlFiles = requireNonNull(new File("./src/main/resources").list()); - for (String ymlFileName : ymlFiles) { + for (var ymlFileName : ymlFiles) { if (ymlFileName.endsWith(".yml") && !ymlFileName.startsWith("_")) { String locale = substringBefore(ymlFileName, ".").replace("-", "_"); arguments.add(Arguments.of(new Locale(locale), null)); diff --git a/src/test/java/net/datafaker/integration/FakerRepeatabilityIntegrationTest.java b/src/test/java/net/datafaker/integration/FakerRepeatabilityIntegrationTest.java index ac8fb150e..1e53554ed 100644 --- a/src/test/java/net/datafaker/integration/FakerRepeatabilityIntegrationTest.java +++ b/src/test/java/net/datafaker/integration/FakerRepeatabilityIntegrationTest.java @@ -63,7 +63,7 @@ private static Map buildReport(Faker faker) throws IllegalAccess List providerList = Arrays.asList(methods); providerList.sort(Comparator.comparing(Method::getName)); - for (Method provider : providerList) { + for (var provider : providerList) { if (AbstractProvider.class.isAssignableFrom(provider.getReturnType()) && provider.getParameterCount() == 0) { AbstractProvider providerImpl = (AbstractProvider) provider.invoke(faker); @@ -73,7 +73,7 @@ private static Map buildReport(Faker faker) throws IllegalAccess List generatorMethodList = Arrays.asList(generatorMethods); generatorMethodList.sort(Comparator.comparing(Method::getName)); - for (Method generatorMethod : generatorMethodList) { + for (var generatorMethod : generatorMethodList) { if (!Instant.class.isAssignableFrom(generatorMethod.getReturnType()) && !byte[].class.isAssignableFrom(generatorMethod.getReturnType()) diff --git a/src/test/java/net/datafaker/integration/UkLocalDirectivesTest.java b/src/test/java/net/datafaker/integration/UkLocalDirectivesTest.java index aa479cdf0..dd3530b8a 100644 --- a/src/test/java/net/datafaker/integration/UkLocalDirectivesTest.java +++ b/src/test/java/net/datafaker/integration/UkLocalDirectivesTest.java @@ -33,10 +33,10 @@ void resolvesDirectivesOnlyInYmlFile() { boolean startsWithMascPrefix = false; boolean startsWithFemPrefix = false; - for (String mascPrefix : masc) { + for (var mascPrefix : masc) { startsWithMascPrefix |= streetName.startsWith(mascPrefix); } - for (String femPrefix : fem) { + for (var femPrefix : fem) { startsWithFemPrefix |= streetName.startsWith(femPrefix); } diff --git a/src/test/java/net/datafaker/providers/base/DomainTest.java b/src/test/java/net/datafaker/providers/base/DomainTest.java index bfa736dda..4fbc92e1c 100644 --- a/src/test/java/net/datafaker/providers/base/DomainTest.java +++ b/src/test/java/net/datafaker/providers/base/DomainTest.java @@ -16,7 +16,7 @@ void testFirstLevelDomainNotNull() { @Test void testFirstLevelDomain() { String[] components = faker.domain().firstLevelDomain("example").split("\\."); - for (String str : components) { + for (var str : components) { assert (!str.isEmpty()); } } @@ -30,7 +30,7 @@ void testSecondLevelDomainNotNull() { @Test void testSecondLevelDomain() { String[] components = faker.domain().secondLevelDomain("example").split("\\."); - for (String str : components) { + for (var str : components) { assert (!str.isEmpty()); } } @@ -45,7 +45,7 @@ void testFullDomainNotNull() { @Test void testFullDomain() { String[] components = faker.domain().fullDomain("example").split("\\."); - for (String str : components) { + for (var str : components) { assert (!str.isEmpty()); } } @@ -59,7 +59,7 @@ void testValidDomainNotNull() { @Test void testValidDomain() { String[] components = faker.domain().validDomain("example").split("\\."); - for (String str : components) { + for (var str : components) { assert (!str.isEmpty()); } } diff --git a/src/test/java/net/datafaker/providers/base/FinanceTest.java b/src/test/java/net/datafaker/providers/base/FinanceTest.java index ed284d61d..fc4f9a31d 100644 --- a/src/test/java/net/datafaker/providers/base/FinanceTest.java +++ b/src/test/java/net/datafaker/providers/base/FinanceTest.java @@ -81,7 +81,7 @@ void ibanCountryCodes() { @Test void ibanWithAllCountryCodes() { Set ibanCountryCodes = Finance.ibanSupportedCountries(); - for (String givenCountryCode : ibanCountryCodes) { + for (var givenCountryCode : ibanCountryCodes) { final String iban = finance.iban(givenCountryCode).toUpperCase(faker.getContext().getLocale()); assertThatIban(iban) .hasCountryCode(givenCountryCode) diff --git a/src/test/java/net/datafaker/providers/base/HttpTest.java b/src/test/java/net/datafaker/providers/base/HttpTest.java index e44c3a33d..a3c543e68 100644 --- a/src/test/java/net/datafaker/providers/base/HttpTest.java +++ b/src/test/java/net/datafaker/providers/base/HttpTest.java @@ -115,7 +115,7 @@ void mobileUserAgent() { @Test void userAgentForAllBrowsers() { - for (Http.Browser browser : Http.Browser.values()) { + for (var browser : Http.Browser.values()) { assertThat(http.userAgent(browser)) .as("User agent for browser %s", browser) .isNotBlank() diff --git a/src/test/java/net/datafaker/providers/base/InternetTest.java b/src/test/java/net/datafaker/providers/base/InternetTest.java index c1dea983d..c1d7a5f8b 100644 --- a/src/test/java/net/datafaker/providers/base/InternetTest.java +++ b/src/test/java/net/datafaker/providers/base/InternetTest.java @@ -521,7 +521,7 @@ void testFarsiIDNs() { @Test void testUserAgent() { Internet.UserAgent[] agents = Internet.UserAgent.values(); - for (Internet.UserAgent agent : agents) { + for (var agent : agents) { assertThat(faker.internet().userAgent(agent)).isNotEmpty(); } @@ -532,7 +532,7 @@ void testUserAgent() { @Test void testBotUserAgent() { Internet.BotUserAgent[] agents = Internet.BotUserAgent.values(); - for (Internet.BotUserAgent agent : agents) { + for (var agent : agents) { assertThat(faker.internet().botUserAgent(agent)).isNotEmpty(); } diff --git a/src/test/java/net/datafaker/providers/base/NumberTest.java b/src/test/java/net/datafaker/providers/base/NumberTest.java index 73e0c7198..1682a93ec 100644 --- a/src/test/java/net/datafaker/providers/base/NumberTest.java +++ b/src/test/java/net/datafaker/providers/base/NumberTest.java @@ -391,7 +391,7 @@ void testIntNumberBetweenQuality() { map.merge(r, 1, Integer::sum); } - for (Map.Entry entry : map.entrySet()) { + for (var entry : map.entrySet()) { int count = entry.getValue(); assertThat((mean - count) / mean).isLessThan(0.2); } @@ -417,7 +417,7 @@ void testLongNumberBetweenQuality() { map.merge(r, 1, Integer::sum); } - for (Map.Entry entry : map.entrySet()) { + for (var entry : map.entrySet()) { int count = entry.getValue(); assertThat(Math.abs(mean - count) / mean) .as(() -> "Entry: %s, all numbers: %s".formatted(entry, map)) diff --git a/src/test/java/net/datafaker/providers/base/TwitterTest.java b/src/test/java/net/datafaker/providers/base/TwitterTest.java index 6b7b6ad74..bb2f1e2fe 100644 --- a/src/test/java/net/datafaker/providers/base/TwitterTest.java +++ b/src/test/java/net/datafaker/providers/base/TwitterTest.java @@ -79,9 +79,9 @@ void testTextKeyWords() { String text = twitter.text(keywords, sentenceMaxLength, wordMaxLength); String[] textwords = text.split(" "); boolean flag = true; - for (String keyword : keywords) { + for (var keyword : keywords) { boolean tmpFlag = false; - for (String textword : textwords) { + for (var textword : textwords) { if (keyword.equals(textword)) { tmpFlag = true; break; diff --git a/src/test/java/net/datafaker/script/MkdocsReleaseNavUpdater.java b/src/test/java/net/datafaker/script/MkdocsReleaseNavUpdater.java index 86a24f44f..e76593cdb 100644 --- a/src/test/java/net/datafaker/script/MkdocsReleaseNavUpdater.java +++ b/src/test/java/net/datafaker/script/MkdocsReleaseNavUpdater.java @@ -56,7 +56,7 @@ static List updateNav(List lines, String releasedVersion, String List out = new ArrayList<>(lines.size() + 2); boolean inReleases = false; - for (String line : lines) { + for (var line : lines) { if (RELEASES_HEADER.matcher(line).matches()) { out.add(line); inReleases = true; @@ -89,7 +89,7 @@ static List updateNav(List lines, String releasedVersion, String private static String findPreviousStable(List lines, String releasedVersion) { boolean inReleases = false; - for (String line : lines) { + for (var line : lines) { if (RELEASES_HEADER.matcher(line).matches()) { inReleases = true; continue; diff --git a/src/test/java/net/datafaker/script/ProviderGenerator.java b/src/test/java/net/datafaker/script/ProviderGenerator.java index eea2a9f75..4d6b83583 100644 --- a/src/test/java/net/datafaker/script/ProviderGenerator.java +++ b/src/test/java/net/datafaker/script/ProviderGenerator.java @@ -44,7 +44,7 @@ void generateProvider() throws FileNotFoundException { System.out.println(files.length + " files"); - for (File file : filesToProcess) { + for (var file : filesToProcess) { final Map valuesMap = new Yaml().loadAs(new FileReader(file), Map.class); Map en = (Map) valuesMap.get("en"); @@ -101,7 +101,7 @@ private void createCreator(File file, String key, Set strings, ProviderT System.out.println(" }"); System.out.println(); - for (String string : strings) { + for (var string : strings) { String methodName = StringUtils.uncapitalize(toJavaConvention(string)); System.out.println(" public String " + methodName + "() {\n" + @@ -127,7 +127,7 @@ private void createTest(File file, Set strings, ProviderType providerTyp System.out.println("class " + className + "Test extends " + providerType.getTestSuperclassSimpleName() + " {"); System.out.println(); - for (String string : strings) { + for (var string : strings) { String testMethodName = StringUtils.uncapitalize(toJavaConvention(string)); System.out.println(" @" + Test.class.getSimpleName()); diff --git a/src/test/java/net/datafaker/script/ProvidersDocsGenerator.java b/src/test/java/net/datafaker/script/ProvidersDocsGenerator.java index c50034e4a..fd020f862 100644 --- a/src/test/java/net/datafaker/script/ProvidersDocsGenerator.java +++ b/src/test/java/net/datafaker/script/ProvidersDocsGenerator.java @@ -48,7 +48,7 @@ public class ProvidersDocsGenerator { public static void main(String[] args) { ProvidersDocsGenerator providersDocsGenerator = new ProvidersDocsGenerator(); providersDocsGenerator.initSubtypes(); - try (BufferedWriter writer = new BufferedWriter(new FileWriter(DESTINATION_PLACE_OF_PROVIDERS_FILE))) { + try (var writer = new BufferedWriter(new FileWriter(DESTINATION_PLACE_OF_PROVIDERS_FILE))) { providersDocsGenerator.constructHeaderInProvidersFile(writer); providersDocsGenerator.generateProvidersDocs(writer); writer.flush(); @@ -67,7 +67,7 @@ private void initSubtypes() { } void generateProvidersDocs(BufferedWriter writer) throws IOException { - for (Class clazz : subTypes) { + for (var clazz : subTypes) { String groupName = extractGroupName(clazz); String comment = extractCommentFromJavadoc("src/main/java/net/datafaker/providers/" + groupName + "/" + clazz.getSimpleName() + ".java"); writer.write(Column.generateRow(' ', clazz.getSimpleName(), comment, formatGroupName(groupName))); @@ -149,7 +149,7 @@ private String providersPerVersionTable() { .append("\n|---------|-------------------------|---------------------------|\n"); int cumulativeCountOfProvidersPerVersion = 0; - for (Map.Entry entry : providersPerVersion.entrySet()) { + for (var entry : providersPerVersion.entrySet()) { cumulativeCountOfProvidersPerVersion += entry.getValue(); sb.append("| ").append(entry.getKey()).append(" | ") .append(entry.getValue().toString()).append(" | ") @@ -167,7 +167,7 @@ private String providersPerVersionTable() { private Map extractProvidersPerVersion() { Map providersPerVersion = new TreeMap<>(Comparator.naturalOrder()); - for (Class clazz : subTypes) { + for (var clazz : subTypes) { String groupName = extractGroupName(clazz); String comment = extractCommentFromJavadoc("src/main/java/net/datafaker/providers/" + groupName + "/" + clazz.getSimpleName() + ".java"); String sinceTag = Column.SINCE.getValue(comment); diff --git a/src/test/java/net/datafaker/script/ReleaseNotesGenerator.java b/src/test/java/net/datafaker/script/ReleaseNotesGenerator.java index 5cd856385..7d2200888 100644 --- a/src/test/java/net/datafaker/script/ReleaseNotesGenerator.java +++ b/src/test/java/net/datafaker/script/ReleaseNotesGenerator.java @@ -60,12 +60,12 @@ static String generate(List templateLines, String version, String date, List out = new ArrayList<>(templateLines.size() + bodyLines.size()); List preparedBody = prepareBodyLines(bodyLines); boolean inserted = false; - for (String line : templateLines) { + for (var line : templateLines) { out.add(line.replace("X.Y.Z", version).replace("dd-mm-yyyy", date)); if (!inserted && WHATS_CHANGED.equals(out.get(out.size() - 1))) { if (!preparedBody.isEmpty()) { out.add(""); - for (String bodyLine : preparedBody) { + for (var bodyLine : preparedBody) { out.add(stripIssueHash(bodyLine)); } } diff --git a/src/test/java/net/datafaker/sequence/FakeCollectionTest.java b/src/test/java/net/datafaker/sequence/FakeCollectionTest.java index fefc3688f..2d7b67213 100644 --- a/src/test/java/net/datafaker/sequence/FakeCollectionTest.java +++ b/src/test/java/net/datafaker/sequence/FakeCollectionTest.java @@ -34,7 +34,7 @@ void generateCollection() { .minLen(3) .maxLen(5).build().get(); assertThat(names).hasSizeBetween(3, 5); - for (String name : names) { + for (var name : names) { assertThat(name).matches("[a-zA-Z']+"); } } @@ -45,7 +45,7 @@ void generateSequence() { .collection(() -> faker.number().digit()) .len(3, 10).generate(); assertThat(digits).hasSizeBetween(3, 10); - for (String digit : digits) { + for (var digit : digits) { assertThat(digit).matches("\\d"); } } @@ -94,7 +94,7 @@ void generateSequence5() { .collection(() -> faker.number().digit()) .len(5).generate(); assertThat(digits).hasSize(5); - for (String digit : digits) { + for (var digit : digits) { assertThat(digit).matches("\\d"); } } @@ -107,7 +107,7 @@ void generateNullCollection() { .minLen(3) .maxLen(5).build().get(); assertThat(names).hasSizeBetween(3, 5); - for (String name : names) { + for (var name : names) { assertThat(name).isNull(); } } @@ -155,7 +155,7 @@ void generateCollectionWithDifferentObjects() { .suppliers(() -> faker.name().firstName(), () -> faker.random().nextInt(100)) .maxLen(5).build().get(); assertThat(objects).hasSize(5); - for (Object object : objects) { + for (var object : objects) { assertThat(object).isInstanceOfAny(Integer.class, String.class); } } @@ -284,7 +284,7 @@ void testIterator() { .build(); int count = 0; - for (String digit : digits) { + for (var digit : digits) { assertThat(digit).matches("\\d"); count++; } diff --git a/src/test/java/net/datafaker/sequence/FakeStreamTest.java b/src/test/java/net/datafaker/sequence/FakeStreamTest.java index e872debf1..3c8c8e822 100644 --- a/src/test/java/net/datafaker/sequence/FakeStreamTest.java +++ b/src/test/java/net/datafaker/sequence/FakeStreamTest.java @@ -318,7 +318,7 @@ void testIterator() { .build(); int count = 0; - for (String digit : digits) { + for (var digit : digits) { assertThat(digit).matches("\\d"); count++; } @@ -336,7 +336,7 @@ void testIteratorInfinite() { int count = 0; int amountOfElementsToTake = 1_000; - for (String digit : digits) { + for (var digit : digits) { assertThat(digit).matches("\\d"); count++; if (count == amountOfElementsToTake) { @@ -360,7 +360,7 @@ void testCsvFilesCreated(final String testName, final Transformer transformer, f File csvFile = Files.newTemporaryFile(); assertThat(csvFile).exists().isEmpty(); - try (BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(csvFile))) { + try (var fos = new BufferedOutputStream(new FileOutputStream(csvFile))) { transformer.writeToOutputStream(fos, schema, 2); } catch (IOException e) { throw new RuntimeException(e); diff --git a/src/test/java/net/datafaker/service/WeightedRandomSelectorTest.java b/src/test/java/net/datafaker/service/WeightedRandomSelectorTest.java index 091f01afe..1973e0b4a 100644 --- a/src/test/java/net/datafaker/service/WeightedRandomSelectorTest.java +++ b/src/test/java/net/datafaker/service/WeightedRandomSelectorTest.java @@ -119,7 +119,7 @@ void testWeightedArrayElementWithMultipleElements(List> item Map counts = countResults(selector, items); assertThat(counts.keySet()).containsExactlyInAnyOrderElementsOf(expectedCounts.keySet()); - for (String element : expectedCounts.keySet()) { + for (var element : expectedCounts.keySet()) { assertThat(counts.get(element)).isCloseTo(expectedCounts.get(element), withinPercentage(1)); } } From 2aa34b108a9d7c57a50ffe57eb1d556a5fcacea3 Mon Sep 17 00:00:00 2001 From: kingthorin Date: Sat, 27 Jun 2026 12:39:46 -0400 Subject: [PATCH 6/8] Use text blocks Signed-off-by: kingthorin --- src/test/java/net/datafaker/TestStrings.java | 19 ++++ .../java/net/datafaker/formats/CsvTest.java | 47 +++++----- .../java/net/datafaker/formats/JsonTest.java | 87 +++++++++++-------- .../java/net/datafaker/formats/SqlTest.java | 77 +++++++++------- .../java/net/datafaker/formats/TomlTest.java | 38 ++++---- .../java/net/datafaker/formats/XmlTest.java | 7 +- .../java/net/datafaker/formats/YamlTest.java | 83 ++++++++++++------ .../datafaker/providers/base/BarcodeTest.java | 7 +- .../providers/base/PhoneNumberTest.java | 7 +- .../script/ProvidersDocsGenerator.java | 11 ++- 10 files changed, 237 insertions(+), 146 deletions(-) create mode 100644 src/test/java/net/datafaker/TestStrings.java diff --git a/src/test/java/net/datafaker/TestStrings.java b/src/test/java/net/datafaker/TestStrings.java new file mode 100644 index 000000000..3573d6d1b --- /dev/null +++ b/src/test/java/net/datafaker/TestStrings.java @@ -0,0 +1,19 @@ +package net.datafaker; + +public final class TestStrings { + + private TestStrings() { + } + + /** Maps text-block newlines to the platform line separator used by transformers. */ + public static String lines(String textBlock) { + return textBlock.replace("\n", System.lineSeparator()); + } + + /** Like {@link #lines(String)}, but strips one trailing platform line separator. */ + public static String linesTrimTrailing(String textBlock) { + String result = lines(textBlock); + String sep = System.lineSeparator(); + return result.endsWith(sep) ? result.substring(0, result.length() - sep.length()) : result; + } +} diff --git a/src/test/java/net/datafaker/formats/CsvTest.java b/src/test/java/net/datafaker/formats/CsvTest.java index d0092790a..29332bfac 100644 --- a/src/test/java/net/datafaker/formats/CsvTest.java +++ b/src/test/java/net/datafaker/formats/CsvTest.java @@ -11,6 +11,7 @@ import java.util.Random; +import static net.datafaker.TestStrings.linesTrimTrailing; import static net.datafaker.transformations.Field.field; import static net.datafaker.transformations.Transformer.LINE_SEPARATOR; import static org.assertj.core.api.Assertions.assertThat; @@ -84,9 +85,10 @@ void testCsvWithCommaNew() { String csv = transformer.generate(schema, 1); - String expected = - "\"values\",\"title\"" + LINE_SEPARATOR - + "\"1,2,3\",\"The \"\"fabulous\"\" artist\""; + String expected = linesTrimTrailing(""" + "values","title" + "1,2,3","The ""fabulous"" artist" + """); assertThat(csv).isEqualTo(expected); } @@ -105,12 +107,13 @@ void testCsvWithDifferentObjects() { String csv = transformer.generate(schema, 4); - String expected = - "\"Number\",\"Bool\",\"String\",\"Text\"" + LINE_SEPARATOR - + "3,false,\"Flor\",\"The, \"\"fabulous\"\" artist'\"" + LINE_SEPARATOR - + "6,true,\"Stephnie\",\"The, \"\"fabulous\"\" artist'\"" + LINE_SEPARATOR - + "1,false,\"Edythe\",\"The, \"\"fabulous\"\" artist'\"" + LINE_SEPARATOR - + "1,true,\"Dwight\",\"The, \"\"fabulous\"\" artist'\""; + String expected = linesTrimTrailing(""" + "Number","Bool","String","Text" + 3,false,"Flor","The, ""fabulous"" artist'" + 6,true,"Stephnie","The, ""fabulous"" artist'" + 1,false,"Edythe","The, ""fabulous"" artist'" + 1,true,"Dwight","The, ""fabulous"" artist'" + """); assertThat(csv).isEqualTo(expected); } @@ -132,13 +135,14 @@ void testCsvWithDifferentObjectsFunction() { .build(); String csv = transformer.generate(fakeSequence, schema); - String expected = - "\"Number\",\"Password\"" + LINE_SEPARATOR - + "3,\"nf3\"" + LINE_SEPARATOR - + "6,\"4b0v69\"" + LINE_SEPARATOR - + "7,\"00827v2\"" + LINE_SEPARATOR - + "1,\"5\"" + LINE_SEPARATOR - + "3,\"p6x\""; + String expected = linesTrimTrailing(""" + "Number","Password" + 3,"nf3" + 6,"4b0v69" + 7,"00827v2" + 1,"5" + 3,"p6x" + """); assertThat(csv).isEqualTo(expected); } @@ -161,11 +165,12 @@ void testCsvWithDifferentObjectsFunctionStream() { String csv = transformer.generate(fakeSequence, schema); - String expected = - "\"Number\",\"Password\"" + LINE_SEPARATOR - + "3,\"0p4\"" + LINE_SEPARATOR - + "8,\"714487nf\"" + LINE_SEPARATOR - + "5,\"0v691\""; + String expected = linesTrimTrailing(""" + "Number","Password" + 3,"0p4" + 8,"714487nf" + 5,"0v691" + """); assertThat(csv).isEqualTo(expected); } diff --git a/src/test/java/net/datafaker/formats/JsonTest.java b/src/test/java/net/datafaker/formats/JsonTest.java index 8e8a84bb6..a0c8f6e29 100644 --- a/src/test/java/net/datafaker/formats/JsonTest.java +++ b/src/test/java/net/datafaker/formats/JsonTest.java @@ -21,6 +21,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; +import static net.datafaker.TestStrings.linesTrimTrailing; import static net.datafaker.transformations.Field.compositeField; import static net.datafaker.transformations.Field.field; import static net.datafaker.transformations.Transformer.LINE_SEPARATOR; @@ -40,18 +41,20 @@ void testJsonStream() { JsonTransformer transformer = JsonTransformer.builder().build(); Stream json = transformer.generateStream(schema, 10); String output = json.collect(Collectors.joining(LINE_SEPARATOR)); - assertThat(output).isEqualTo("[" + LINE_SEPARATOR + - "{\"Text\": \"Willis\", \"Bool\": false}," + LINE_SEPARATOR + - "{\"Text\": \"Carlena\", \"Bool\": true}," + LINE_SEPARATOR + - "{\"Text\": \"Stephnie\", \"Bool\": true}," + LINE_SEPARATOR + - "{\"Text\": \"Rutha\", \"Bool\": true}," + LINE_SEPARATOR + - "{\"Text\": \"Armand\", \"Bool\": true}," + LINE_SEPARATOR + - "{\"Text\": \"Margot\", \"Bool\": false}," + LINE_SEPARATOR + - "{\"Text\": \"Patrick\", \"Bool\": false}," + LINE_SEPARATOR + - "{\"Text\": \"Alphonse\", \"Bool\": false}," + LINE_SEPARATOR + - "{\"Text\": \"Louisa\", \"Bool\": true}," + LINE_SEPARATOR + - "{\"Text\": \"Caryn\", \"Bool\": false}" + LINE_SEPARATOR + - "]"); + assertThat(output).isEqualTo(linesTrimTrailing(""" + [ + {"Text": "Willis", "Bool": false}, + {"Text": "Carlena", "Bool": true}, + {"Text": "Stephnie", "Bool": true}, + {"Text": "Rutha", "Bool": true}, + {"Text": "Armand", "Bool": true}, + {"Text": "Margot", "Bool": false}, + {"Text": "Patrick", "Bool": false}, + {"Text": "Alphonse", "Bool": false}, + {"Text": "Louisa", "Bool": true}, + {"Text": "Caryn", "Bool": false} + ] + """)); } @Test @@ -64,10 +67,12 @@ void testGenerateFromSchemaWithLimit() { JsonTransformer transformer = JsonTransformer.builder().build(); String json = transformer.generate(schema, 2); - String expected = "[" + LINE_SEPARATOR + - "{\"Text\": \"Willis\", \"Bool\": false}," + LINE_SEPARATOR + - "{\"Text\": \"Carlena\", \"Bool\": true}" + LINE_SEPARATOR + - "]"; + String expected = linesTrimTrailing(""" + [ + {"Text": "Willis", "Bool": false}, + {"Text": "Carlena", "Bool": true} + ] + """); assertThat(json).isEqualTo(expected); } @@ -89,13 +94,15 @@ void testGenerateFromFakeSequenceCollectionWithoutComma() { String json = transformer.generate(fakeSequence, schema); - String expected = "[" + LINE_SEPARATOR + - "{\"Number\": 3, \"Password\": \"nf3\"}" + LINE_SEPARATOR + - "{\"Number\": 6, \"Password\": \"4b0v69\"}" + LINE_SEPARATOR + - "{\"Number\": 7, \"Password\": \"00827v2\"}" + LINE_SEPARATOR + - "{\"Number\": 1, \"Password\": \"5\"}" + LINE_SEPARATOR + - "{\"Number\": 3, \"Password\": \"p6x\"}" + LINE_SEPARATOR + - "]"; + String expected = linesTrimTrailing(""" + [ + {"Number": 3, "Password": "nf3"} + {"Number": 6, "Password": "4b0v69"} + {"Number": 7, "Password": "00827v2"} + {"Number": 1, "Password": "5"} + {"Number": 3, "Password": "p6x"} + ] + """); assertThat(json).isEqualTo(expected); } @@ -117,13 +124,15 @@ void testGenerateFromFakeSequenceCollection() { String json = transformer.generate(fakeSequence, schema); - String expected = "[" + LINE_SEPARATOR + - "{\"Number\": 3, \"Password\": \"nf3\"}," + LINE_SEPARATOR + - "{\"Number\": 6, \"Password\": \"4b0v69\"}," + LINE_SEPARATOR + - "{\"Number\": 7, \"Password\": \"00827v2\"}," + LINE_SEPARATOR + - "{\"Number\": 1, \"Password\": \"5\"}," + LINE_SEPARATOR + - "{\"Number\": 3, \"Password\": \"p6x\"}" + LINE_SEPARATOR + - "]"; + String expected = linesTrimTrailing(""" + [ + {"Number": 3, "Password": "nf3"}, + {"Number": 6, "Password": "4b0v69"}, + {"Number": 7, "Password": "00827v2"}, + {"Number": 1, "Password": "5"}, + {"Number": 3, "Password": "p6x"} + ] + """); assertThat(json).isEqualTo(expected); } @@ -145,10 +154,12 @@ void testGenerateFromFakeSequenceStream() { String json = transformer.generate(fakeSequence, schema); - String expected = "[" + LINE_SEPARATOR + - "{\"Number\": 3, \"Password\": \"0p4\"}" + LINE_SEPARATOR + - "{\"Number\": 8, \"Password\": \"714487nf\"}" + LINE_SEPARATOR + - "]"; + String expected = linesTrimTrailing(""" + [ + {"Number": 3, "Password": "0p4"} + {"Number": 8, "Password": "714487nf"} + ] + """); assertThat(json).isEqualTo(expected); } @@ -282,8 +293,8 @@ void jsonObjectCollectionTest() { ) ) ), 1); - assertThat(json).isEqualTo("{\"text\": \"Mrs. Brian Braun\", " + - "\"objectCollection\": [{\"country\": \"Denmark\", \"city\": \"Port Angel\"}, {\"two\": \"Denmark\", \"one\": \"Port Angel\"}]}"); + assertThat(json).isEqualTo(""" + {"text": "Mrs. Brian Braun", "objectCollection": [{"country": "Denmark", "city": "Port Angel"}, {"two": "Denmark", "one": "Port Angel"}]}"""); } @Test @@ -311,8 +322,8 @@ void jsonCollectionOfCollectionsTest() { ) ) ), 1); - assertThat(json).isEqualTo("{\"text\": \"Mrs. Brian Braun\", " + - "\"objectCollection\": [[[{\"country\": \"Denmark\", \"city\": \"Port Angel\"}, {\"two\": \"Denmark\", \"one\": \"Port Angel\"}]]]}"); + assertThat(json).isEqualTo(""" + {"text": "Mrs. Brian Braun", "objectCollection": [[[{"country": "Denmark", "city": "Port Angel"}, {"two": "Denmark", "one": "Port Angel"}]]]}"""); } private static Map.Entry, Supplier> entry( diff --git a/src/test/java/net/datafaker/formats/SqlTest.java b/src/test/java/net/datafaker/formats/SqlTest.java index 006596b02..069681d17 100644 --- a/src/test/java/net/datafaker/formats/SqlTest.java +++ b/src/test/java/net/datafaker/formats/SqlTest.java @@ -22,6 +22,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; +import static net.datafaker.TestStrings.linesTrimTrailing; import static net.datafaker.transformations.Field.compositeField; import static net.datafaker.transformations.Field.field; import static net.datafaker.transformations.Transformer.LINE_SEPARATOR; @@ -47,11 +48,13 @@ void generateFromFakeSequenceSeparated() { String sql = transformer.generate(fakeSequence, schema); - String expected = "INSERT INTO \"MyTable\" (\"Number\", \"Password\") VALUES (3, 'nf3');" + LINE_SEPARATOR + - "INSERT INTO \"MyTable\" (\"Number\", \"Password\") VALUES (6, '4b0v69');" + LINE_SEPARATOR + - "INSERT INTO \"MyTable\" (\"Number\", \"Password\") VALUES (7, '00827v2');" + LINE_SEPARATOR + - "INSERT INTO \"MyTable\" (\"Number\", \"Password\") VALUES (1, '5');" + LINE_SEPARATOR + - "INSERT INTO \"MyTable\" (\"Number\", \"Password\") VALUES (3, 'p6x');"; + String expected = linesTrimTrailing(""" + INSERT INTO "MyTable" ("Number", "Password") VALUES (3, 'nf3'); + INSERT INTO "MyTable" ("Number", "Password") VALUES (6, '4b0v69'); + INSERT INTO "MyTable" ("Number", "Password") VALUES (7, '00827v2'); + INSERT INTO "MyTable" ("Number", "Password") VALUES (1, '5'); + INSERT INTO "MyTable" ("Number", "Password") VALUES (3, 'p6x'); + """); assertThat(sql).isEqualTo(expected); } @@ -74,13 +77,14 @@ void generateFromFakeSequenceBatch() { String sql = transformer.generate(fakeSequence, schema); - String expected = - "INSERT INTO \"MyTable\" (\"Number\", \"Password\")" + LINE_SEPARATOR + - "VALUES (3, 'nf3')," + LINE_SEPARATOR + - " (6, '4b0v69')," + LINE_SEPARATOR + - " (7, '00827v2')," + LINE_SEPARATOR + - " (1, '5')," + LINE_SEPARATOR + - " (3, 'p6x');"; + String expected = linesTrimTrailing(""" + INSERT INTO "MyTable" ("Number", "Password") + VALUES (3, 'nf3'), + (6, '4b0v69'), + (7, '00827v2'), + (1, '5'), + (3, 'p6x'); + """); assertThat(sql).isEqualTo(expected); } @@ -131,9 +135,10 @@ void testGenerateFromSchemaWithLimitSeparatedStatements() { SqlTransformer transformer = SqlTransformer.builder().build(); String sql = transformer.generate(schema, 2); - String expected = - "INSERT INTO \"MyTable\" (\"Text\", \"Bool\") VALUES ('Willis', false);" + LINE_SEPARATOR + - "INSERT INTO \"MyTable\" (\"Text\", \"Bool\") VALUES ('Carlena', true);"; + String expected = linesTrimTrailing(""" + INSERT INTO "MyTable" ("Text", "Bool") VALUES ('Willis', false); + INSERT INTO "MyTable" ("Text", "Bool") VALUES ('Carlena', true); + """); assertThat(sql).isEqualTo(expected); } @@ -151,10 +156,11 @@ void testGenerateFromSchemaWithLimitBatchModeStatements() { .build(); String sql = transformer.generate(schema, 2); - String expected = - "INSERT INTO \"MyTable\" (\"Text\", \"Bool\")" + LINE_SEPARATOR + - "VALUES ('Willis', false)," + LINE_SEPARATOR + - " ('Carlena', true);"; + String expected = linesTrimTrailing(""" + INSERT INTO "MyTable" ("Text", "Bool") + VALUES ('Willis', false), + ('Carlena', true); + """); assertThat(sql).isEqualTo(expected); } @@ -173,9 +179,11 @@ void testForceQuotedWithSqlIdentifiers() { .build(); String sql = forceQuotedTransformer.generate(schema, 2); - String expected = "INSERT INTO \"MY_TABLE\" (\"TEXT\", \"BOOL\")" + LINE_SEPARATOR + - "VALUES ('Willis', false)," + LINE_SEPARATOR + - " ('Carlena', true);"; + String expected = linesTrimTrailing(""" + INSERT INTO "MY_TABLE" ("TEXT", "BOOL") + VALUES ('Willis', false), + ('Carlena', true); + """); assertThat(sql).isEqualTo(expected); } @@ -560,13 +568,14 @@ void testSqlBatch() { .generateStream(schema, 4) .collect(Collectors.joining(LINE_SEPARATOR)); - String expected = - "INSERT INTO \"MyTable\" (\"Number\", \"Password\")" + LINE_SEPARATOR + - "VALUES ('6', '09fd4007-40ba-39df-8cb1-65926bf7b8a9')," + LINE_SEPARATOR + - " ('8', '96c19757-1f18-3051-9acb-f56f0b5555ae')," + LINE_SEPARATOR + - " ('2', '8a4a0365-cd39-33c1-a52a-279b1076cf2d');" + LINE_SEPARATOR + - "INSERT INTO \"MyTable\" (\"Number\", \"Password\")" + LINE_SEPARATOR + - "VALUES ('6', 'e807efdd-b6db-319d-8342-a044274d3417');"; + String expected = linesTrimTrailing(""" + INSERT INTO "MyTable" ("Number", "Password") + VALUES ('6', '09fd4007-40ba-39df-8cb1-65926bf7b8a9'), + ('8', '96c19757-1f18-3051-9acb-f56f0b5555ae'), + ('2', '8a4a0365-cd39-33c1-a52a-279b1076cf2d'); + INSERT INTO "MyTable" ("Number", "Password") + VALUES ('6', 'e807efdd-b6db-319d-8342-a044274d3417'); + """); assertThat(sql).isEqualTo(expected); } @@ -587,10 +596,12 @@ void testWordTruncated() { String sql = transformer.generateStream(schema,3).collect(Collectors.joining(LINE_SEPARATOR)); - String expected = "INSERT INTO \"MyTable\" (\"Address\", \"Book\")" + LINE_SEPARATOR + - "VALUES ('Cote d\\'Ivoire', 'All the King\\'s Men')," + LINE_SEPARATOR + - " ('Cote d\\'Ivoire', 'Blood\\'s a Rover')," + LINE_SEPARATOR + - " ('Cote d\\'Ivoire', 'Blood\\'s a Rover');"; + String expected = linesTrimTrailing(""" + INSERT INTO "MyTable" ("Address", "Book") + VALUES ('Cote d\\'Ivoire', 'All the King\\'s Men'), + ('Cote d\\'Ivoire', 'Blood\\'s a Rover'), + ('Cote d\\'Ivoire', 'Blood\\'s a Rover'); + """); assertThat(sql).isEqualTo(expected); } diff --git a/src/test/java/net/datafaker/formats/TomlTest.java b/src/test/java/net/datafaker/formats/TomlTest.java index 021c00c12..bce31166a 100644 --- a/src/test/java/net/datafaker/formats/TomlTest.java +++ b/src/test/java/net/datafaker/formats/TomlTest.java @@ -15,6 +15,7 @@ import java.util.stream.IntStream; import java.util.stream.Stream; +import static net.datafaker.TestStrings.linesTrimTrailing; import static net.datafaker.transformations.Field.field; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.params.provider.Arguments.of; @@ -29,7 +30,6 @@ void simpleTomlTest(Schema schema, String expected) { } private static Stream generateTestSchema() { - String sep = System.lineSeparator(); return Stream.of( of(Schema.of(), ""), of(Schema.of(field("key", () -> "value")), "key = \"value\""), @@ -49,9 +49,11 @@ private static Stream generateTestSchema() { of(Schema.of( field("key", () -> "value"), field("nested", () -> Schema.of(field("nestedkey", () -> "nestedvalue"))) - ), "key = \"value\"" + sep + - "[nested]" + sep + - "nestedkey = \"nestedvalue\""), + ), linesTrimTrailing(""" + key = "value" + [nested] + nestedkey = "nestedvalue" + """)), of(Schema.of( field("key", () -> "value"), field("nested", () -> Schema.of( @@ -60,26 +62,32 @@ private static Stream generateTestSchema() { field("nestedkey2", () -> "nestedvalue2") )) )) - ), "key = \"value\"" + sep + - "[nested]" + sep + - "nestedkey = \"nestedvalue\"" + sep + - "[nested.nested2]" + sep + - "nestedkey2 = \"nestedvalue2\""), + ), linesTrimTrailing(""" + key = "value" + [nested] + nestedkey = "nestedvalue" + [nested.nested2] + nestedkey2 = "nestedvalue2" + """)), of(Schema.of( field("parent", () -> Schema.of( field("numbers", () -> new Integer[]{1, 2}) )) - ), "[parent]" + sep + - "numbers = [ 1, 2 ]"), + ), linesTrimTrailing(""" + [parent] + numbers = [ 1, 2 ] + """)), of(Schema.of( field("items", () -> List.of( Schema.of(field("id", () -> 1)), Schema.of(field("id", () -> 2)) )) - ), "[[items]]" + sep + - "id = 1" + sep + - "[[items]]" + sep + - "id = 2") + ), linesTrimTrailing(""" + [[items]] + id = 1 + [[items]] + id = 2 + """)) ); } diff --git a/src/test/java/net/datafaker/formats/XmlTest.java b/src/test/java/net/datafaker/formats/XmlTest.java index 839c8f71f..b0b1c59e6 100644 --- a/src/test/java/net/datafaker/formats/XmlTest.java +++ b/src/test/java/net/datafaker/formats/XmlTest.java @@ -16,6 +16,7 @@ import java.util.List; import java.util.stream.Stream; +import static net.datafaker.TestStrings.linesTrimTrailing; import static net.datafaker.transformations.Field.compositeField; import static net.datafaker.transformations.Field.field; import static org.assertj.core.api.Assertions.assertThat; @@ -74,7 +75,11 @@ private static Stream generateTestXmlPrettySchema() { compositeField("root", new Field[]{field("attribute1", () -> "value1"), field("attribute2", () -> "value2"), field(null, () -> List.of(field("child", () -> "value")))})), - "" + System.lineSeparator() + " value" + System.lineSeparator() + ""), + linesTrimTrailing(""" + + value + + """)), of(Schema.of(field("root", () -> "<> value\"")), "<> value"") ); } diff --git a/src/test/java/net/datafaker/formats/YamlTest.java b/src/test/java/net/datafaker/formats/YamlTest.java index e3b289cb1..b8295988b 100644 --- a/src/test/java/net/datafaker/formats/YamlTest.java +++ b/src/test/java/net/datafaker/formats/YamlTest.java @@ -18,6 +18,7 @@ import java.util.stream.IntStream; import java.util.stream.Stream; +import static net.datafaker.TestStrings.lines; import static net.datafaker.transformations.Field.field; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.params.provider.Arguments.of; @@ -34,40 +35,66 @@ void simpleYamlTest(Schema schema, String expected) { private static Stream generateTestSchema() { return Stream.of( of(Schema.of(), ""), - of(Schema.of(field("key", () -> "value")), "key: value" + System.lineSeparator()), - of(Schema.of(field("number", () -> 123)), "number: 123" + System.lineSeparator()), - of(Schema.of(field("number", () -> BigDecimal.valueOf(123.0))), "number: 123.0" + System.lineSeparator()), - of(Schema.of(field("number", () -> BigDecimal.valueOf(123.123))), "number: 123.123" + System.lineSeparator()), - of(Schema.of(field("boolean", () -> true)), "boolean: true" + System.lineSeparator()), - of(Schema.of(field("nullValue", () -> null)), "nullValue: null" + System.lineSeparator()), - of(Schema.of(field("array", () -> new String[]{null, "test", "123"})), - "array:" + System.lineSeparator() - + " - null" + System.lineSeparator() - + " - test" + System.lineSeparator() - + " - 123" + System.lineSeparator()), - of(Schema.of(field("array", () -> new Integer[]{123, 456, 789})), - "array:" + System.lineSeparator() - + " - 123" + System.lineSeparator() - + " - 456" + System.lineSeparator() - + " - 789" + System.lineSeparator()), - of(Schema.of(field("array", () -> new Object[]{"test", 456, true})), - "array:" + System.lineSeparator() - + " - test" + System.lineSeparator() - + " - 456" + System.lineSeparator() - + " - true" + System.lineSeparator()), - of(Schema.of(field("emptyarray", () -> new Long[]{})), "emptyarray:" + System.lineSeparator()), - of(Schema.of(field("emptyarray", Collections::emptyList)), "emptyarray:" + System.lineSeparator()), + of(Schema.of(field("key", () -> "value")), lines(""" + key: value + """)), + of(Schema.of(field("number", () -> 123)), lines(""" + number: 123 + """)), + of(Schema.of(field("number", () -> BigDecimal.valueOf(123.0))), lines(""" + number: 123.0 + """)), + of(Schema.of(field("number", () -> BigDecimal.valueOf(123.123))), lines(""" + number: 123.123 + """)), + of(Schema.of(field("boolean", () -> true)), lines(""" + boolean: true + """)), + of(Schema.of(field("nullValue", () -> null)), lines(""" + nullValue: null + """)), + of(Schema.of(field("array", () -> new String[]{null, "test", "123"})), lines(""" + array: + - null + - test + - 123 + """)), + of(Schema.of(field("array", () -> new Integer[]{123, 456, 789})), lines(""" + array: + - 123 + - 456 + - 789 + """)), + of(Schema.of(field("array", () -> new Object[]{"test", 456, true})), lines(""" + array: + - test + - 456 + - true + """)), + of(Schema.of(field("emptyarray", () -> new Long[]{})), lines(""" + emptyarray: + """)), + of(Schema.of(field("emptyarray", Collections::emptyList)), lines(""" + emptyarray: + """)), of(Schema.of(field("key", () -> "value"), field("nested", () -> Schema.of(field("nestedkey", () -> "nestedvalue")))), - "key: value" + System.lineSeparator() + "nested:" + System.lineSeparator() + " nestedkey: nestedvalue" + System.lineSeparator()), + lines(""" + key: value + nested: + nestedkey: nestedvalue + """)), of(Schema.of(field("key", () -> "value"), field("nested", () -> Schema.of(field("nestedkey", () -> "nestedvalue"), field("nested2", () -> Schema.of(field("nestedkey2", () -> "nestedvalue2")))))), - "key: value" + System.lineSeparator() - + "nested:" + System.lineSeparator() + " nestedkey: nestedvalue" + System.lineSeparator() - + " nested2:" + System.lineSeparator() - + " nestedkey2: nestedvalue2" + System.lineSeparator()) + lines(""" + key: value + nested: + nestedkey: nestedvalue + nested2: + nestedkey2: nestedvalue2 + """)) ); } diff --git a/src/test/java/net/datafaker/providers/base/BarcodeTest.java b/src/test/java/net/datafaker/providers/base/BarcodeTest.java index 175948c96..934a9fe43 100644 --- a/src/test/java/net/datafaker/providers/base/BarcodeTest.java +++ b/src/test/java/net/datafaker/providers/base/BarcodeTest.java @@ -10,9 +10,10 @@ class BarcodeTest { @Test void type() { - assertThat(faker.barcode().type()).matches("(Code(128|39|93))|([EJ])AN(-\\d{1,2})*|Codabar|UCC|UPC(-([AE]))*|IS([BS])N|ITF|" + - "Ames\\sCode|NW-7|Monarch|Code\\s2\\sof\\s7|Rationalized|ANSI/AIM BC3-1995|USD-4|" + - "GS1 Databar|MSI Plessey"); + assertThat(faker.barcode().type()).matches(""" + (Code(128|39|93))|([EJ])AN(-\\d{1,2})*|Codabar|UCC|UPC(-([AE]))*|IS([BS])N|ITF|\ + Ames\\sCode|NW-7|Monarch|Code\\s2\\sof\\s7|Rationalized|ANSI/AIM BC3-1995|USD-4|\ + GS1 Databar|MSI Plessey"""); } private static boolean isBarcodeValid(long barcode) { diff --git a/src/test/java/net/datafaker/providers/base/PhoneNumberTest.java b/src/test/java/net/datafaker/providers/base/PhoneNumberTest.java index 2508c637a..b8ebd376e 100644 --- a/src/test/java/net/datafaker/providers/base/PhoneNumberTest.java +++ b/src/test/java/net/datafaker/providers/base/PhoneNumberTest.java @@ -48,9 +48,10 @@ void testPhone_esMx() { @ParameterizedTest @MethodSource("canadianLocales") void testPhone_CA(Locale locale) { - String areaCode = "263|354|382|403|587|780|825|236|250|368|428|604|672|778|204|431|506|" - + "709|782|902|226|249|289|343|365|416|437|519|548|613|647|705|807|905|367|" - + "418|438|450|468|474|514|579|581|584|683|742|753|819|873|306|639|867|879|942|257"; + String areaCode = """ + 263|354|382|403|587|780|825|236|250|368|428|604|672|778|204|431|506|\ + 709|782|902|226|249|289|343|365|416|437|519|548|613|647|705|807|905|367|\ + 418|438|450|468|474|514|579|581|584|683|742|753|819|873|306|639|867|879|942|257"""; Pattern canadianPhone = Pattern.compile("((\\+1)?(\\(?(%s)\\)?)|(%s))[- .]\\d{3}[- .]\\d{4}".formatted(areaCode, areaCode)); PhoneNumber phoneNumber = new BaseFaker(locale).phoneNumber(); for (int i = 0; i < COUNT; i++) { diff --git a/src/test/java/net/datafaker/script/ProvidersDocsGenerator.java b/src/test/java/net/datafaker/script/ProvidersDocsGenerator.java index fd020f862..cac05b3af 100644 --- a/src/test/java/net/datafaker/script/ProvidersDocsGenerator.java +++ b/src/test/java/net/datafaker/script/ProvidersDocsGenerator.java @@ -143,10 +143,13 @@ private void constructHeaderInProvidersFile(Writer writer) throws IOException { private String providersPerVersionTable() { Map providersPerVersion = extractProvidersPerVersion(); - StringBuilder sb = new StringBuilder() - .append("\nNumber of providers per Datafaker version:\n") - .append("\n| Version | Number of new providers | Total number of providers |") - .append("\n|---------|-------------------------|---------------------------|\n"); + StringBuilder sb = new StringBuilder(""" + + Number of providers per Datafaker version: + + | Version | Number of new providers | Total number of providers | + |---------|-------------------------|---------------------------| + """); int cumulativeCountOfProvidersPerVersion = 0; for (var entry : providersPerVersion.entrySet()) { From 6c8e9b343c62722c43c9a5a104c65bee7cc7aa72 Mon Sep 17 00:00:00 2001 From: kingthorin Date: Sun, 28 Jun 2026 20:18:29 -0400 Subject: [PATCH 7/8] Adjustments Signed-off-by: kingthorin --- .../net/datafaker/providers/base/Text.java | 65 ++++++++--------- .../datafaker/service/FakeValuesContext.java | 69 ++++++++++--------- .../net/datafaker/service/files/EnFile.java | 9 ++- .../JavaObjectTransformer.java | 11 +-- .../transformations/TomlTransformer.java | 5 +- src/test/java/net/datafaker/TestStrings.java | 7 -- .../java/net/datafaker/formats/CsvTest.java | 47 ++++++------- .../java/net/datafaker/formats/JsonTest.java | 27 +++----- .../java/net/datafaker/formats/SqlTest.java | 37 ++++------ .../java/net/datafaker/formats/TomlTest.java | 38 ++++------ .../java/net/datafaker/formats/XmlTest.java | 7 +- 11 files changed, 147 insertions(+), 175 deletions(-) diff --git a/src/main/java/net/datafaker/providers/base/Text.java b/src/main/java/net/datafaker/providers/base/Text.java index 8961e6630..689adb693 100644 --- a/src/main/java/net/datafaker/providers/base/Text.java +++ b/src/main/java/net/datafaker/providers/base/Text.java @@ -121,39 +121,27 @@ public Text(BaseProviders faker) { super(faker); } - public record TextRuleConfig( - char[][] textKeys, - int[] required, - int fixedNumberOfCharacters, - int numberOfRequiredSymbols - ) { + public static class TextRuleConfig { + private final char[][] textKeys; + private final int[] required; + private final int fixedNumberOfCharacters; + + private final int numberOfRequiredSymbols; + private TextRuleConfig(int fixedNumberOfCharacters, Map map, int numberOfRequiredSymbols) { - this( - buildTextKeys(map), - buildRequired(map), - fixedNumberOfCharacters, - numberOfRequiredSymbols - ); assert numberOfRequiredSymbols >= 0; assert fixedNumberOfCharacters >= numberOfRequiredSymbols; - } - - private static char[][] buildTextKeys(Map map) { - char[][] textKeys = new char[map.size()][]; - int i = 0; - for (var entry : map.entrySet()) { - textKeys[i++] = entry.getKey().toCharArray(); - } - return textKeys; - } - private static int[] buildRequired(Map map) { - int[] required = new int[map.size()]; + this.fixedNumberOfCharacters = fixedNumberOfCharacters; + this.numberOfRequiredSymbols = numberOfRequiredSymbols; + this.textKeys = new char[map.size()][]; + this.required = new int[map.size()]; int i = 0; - for (var entry : map.entrySet()) { - required[i++] = entry.getValue(); + for (Map.Entry entry: map.entrySet()) { + textKeys[i] = entry.getKey().toCharArray(); + required[i] = entry.getValue(); + i++; } - return required; } public int getFixedNumberOfCharacters() { @@ -163,6 +151,7 @@ public int getFixedNumberOfCharacters() { public int getNumberOfRequiredSymbols() { return numberOfRequiredSymbols; } + } public static class TextSymbolsBuilder { @@ -249,8 +238,8 @@ public String text(TextRuleConfig textRuleConfig) { char[] buffer = new char[fixedNumberOfCharacters]; int idx = 0; int maxDiffSymbols = 0; - for (int i = 0; i < textRuleConfig.textKeys().length; i++) { - maxDiffSymbols += textRuleConfig.textKeys()[i].length; + for (int i = 0; i < textRuleConfig.textKeys.length; i++) { + maxDiffSymbols += textRuleConfig.textKeys[i].length; } // 256 is a length of byte value range if (maxDiffSymbols <= 256) { @@ -259,13 +248,13 @@ public String text(TextRuleConfig textRuleConfig) { fixedNumberOfCharacters, numberOfRequiredSymbols); } int numberOfRequired = 0; - int[] required = Arrays.copyOf(textRuleConfig.required(), textRuleConfig.required().length); + int[] required = Arrays.copyOf(textRuleConfig.required, textRuleConfig.required.length); while (idx < buffer.length) { if (numberOfRequiredSymbols > numberOfRequired && numberOfRequiredSymbols - numberOfRequired == buffer.length - idx) { - for (int j = 0; j < textRuleConfig.textKeys().length; j++) { + for (int j = 0; j < textRuleConfig.textKeys.length; j++) { while (required[j] > 0) { - buffer[idx++] = textRuleConfig.textKeys()[j][faker.random().nextInt(textRuleConfig.textKeys()[j].length)]; + buffer[idx++] = textRuleConfig.textKeys[j][faker.random().nextInt(textRuleConfig.textKeys[j].length)]; numberOfRequired++; required[j]--; } @@ -277,7 +266,7 @@ public String text(TextRuleConfig textRuleConfig) { numberOfRequired++; required[index]--; } - buffer[idx++] = textRuleConfig.textKeys()[index][faker.random().nextInt(textRuleConfig.textKeys()[index].length)]; + buffer[idx++] = textRuleConfig.textKeys[index][faker.random().nextInt(textRuleConfig.textKeys[index].length)]; } } return String.valueOf(buffer); @@ -289,25 +278,25 @@ private String textWithNotMoreThan256DiffSymbols( int idx = 0; int bytesCounter = 0; int numberOfRequired = 0; - int[] required = Arrays.copyOf(textRuleConfig.required(), textRuleConfig.required().length); + int[] required = Arrays.copyOf(textRuleConfig.required, textRuleConfig.required.length); while (idx < buffer.length) { if (numberOfRequiredSymbols > numberOfRequired && numberOfRequiredSymbols - numberOfRequired == buffer.length - idx) { - for (int j = 0; j < textRuleConfig.textKeys().length; j++) { + for (int j = 0; j < textRuleConfig.textKeys.length; j++) { while (required[j] > 0) { - buffer[idx++] = textRuleConfig.textKeys()[j][((char) (bytes[bytesCounter++])) % textRuleConfig.textKeys()[j].length]; + buffer[idx++] = textRuleConfig.textKeys[j][((char) (bytes[bytesCounter++])) % textRuleConfig.textKeys[j].length]; numberOfRequired++; required[j]--; } if (idx == buffer.length) break; } } else { - int index = ((char) (bytes[bytesCounter++])) % textRuleConfig.textKeys().length; + int index = ((char) (bytes[bytesCounter++])) % textRuleConfig.textKeys.length; if (required[index] > 0) { numberOfRequired++; required[index]--; } - buffer[idx++] = textRuleConfig.textKeys()[index][((char) bytes[bytesCounter++]) % textRuleConfig.textKeys()[index].length]; + buffer[idx++] = textRuleConfig.textKeys[index][((char) bytes[bytesCounter++]) % textRuleConfig.textKeys[index].length]; } } return String.valueOf(buffer); diff --git a/src/main/java/net/datafaker/service/FakeValuesContext.java b/src/main/java/net/datafaker/service/FakeValuesContext.java index cea160689..c24540957 100644 --- a/src/main/java/net/datafaker/service/FakeValuesContext.java +++ b/src/main/java/net/datafaker/service/FakeValuesContext.java @@ -7,18 +7,37 @@ import java.util.Locale; import java.util.Objects; -record FakeValuesContext(SingletonLocale singletonLocale, String filename, String path, URL url) { +class FakeValuesContext { + private final SingletonLocale singletonLocale; + private final String filename; + private final int filenameHashCode; + private final String path; + private final URL url; + private final int urlHashCode; private FakeValuesContext(Locale locale) { - this(SingletonLocale.get(locale), getFilename(locale), getFilename(locale), null); + this(locale, getFilename(locale), getFilename(locale), null); } private FakeValuesContext(Locale locale, URL url) { - this(SingletonLocale.get(locale), getFilename(locale), null, url); + this(locale, getFilename(locale), null, url); } private FakeValuesContext(Locale locale, String filename, String path) { - this(SingletonLocale.get(locale), filename, path, null); + this(locale, filename, path, null); + } + + private FakeValuesContext(Locale locale, String filename, String path, URL url) { + this.singletonLocale = SingletonLocale.get(locale); + this.filename = filename; + this.path = path; + this.url = url; + this.filenameHashCode = filename == null ? 0 : filename.hashCode(); + try { + this.urlHashCode = url == null ? 0 : url.toURI().hashCode(); + } catch (URISyntaxException e) { + throw new RuntimeException("Invalid url: \"%s\"".formatted(url), e); + } } public static FakeValuesContext of(Locale locale) { @@ -34,7 +53,7 @@ public static FakeValuesContext of(Locale locale, String filename, String path) } public static FakeValuesContext of(Locale locale, String filename, String path, URL url) { - return new FakeValuesContext(SingletonLocale.get(locale), filename, path, url); + return new FakeValuesContext(locale, filename, path, url); } private static String getFilename(Locale locale) { @@ -61,11 +80,11 @@ private static String language(Locale locale) { }; } - Locale getLocale() { + public Locale getLocale() { return singletonLocale.getLocale(); } - String getFilename() { + public String getFilename() { return filename; } @@ -73,44 +92,32 @@ String getPath() { return path; } - URL getUrl() { + public URL getUrl() { return url; } @Override public boolean equals(Object o) { - if (this == o) { - return true; - } - if (!(o instanceof FakeValuesContext that)) { - return false; - } - return Objects.equals(singletonLocale, that.singletonLocale) - && Objects.equals(filename, that.filename) - && Objects.equals(path, that.path) - && Objects.equals(url, that.url); + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + FakeValuesContext that = (FakeValuesContext) o; + + if (!Objects.equals(singletonLocale, that.singletonLocale)) return false; + if (!Objects.equals(filename, that.filename)) return false; + if (!Objects.equals(path, that.path)) return false; + return Objects.equals(url, that.url); } @Override public int hashCode() { int result = singletonLocale == null ? 0 : singletonLocale.hashCode(); - result = 31 * result + (filename == null ? 0 : filename.hashCode()); + result = 31 * result + filenameHashCode; result = 31 * result + (path == null ? 0 : path.hashCode()); - result = 31 * result + urlHashCode(url); + result = 31 * result + urlHashCode; return result; } - private static int urlHashCode(URL url) { - if (url == null) { - return 0; - } - try { - return url.toURI().hashCode(); - } catch (URISyntaxException e) { - throw new RuntimeException("Invalid url: \"%s\"".formatted(url), e); - } - } - @Override public String toString() { return "FakeValuesContext{%s, filename='%s', path='%s', url=%s}".formatted(singletonLocale, filename, path, url); diff --git a/src/main/java/net/datafaker/service/files/EnFile.java b/src/main/java/net/datafaker/service/files/EnFile.java index 446d8f6c4..737d1a43a 100644 --- a/src/main/java/net/datafaker/service/files/EnFile.java +++ b/src/main/java/net/datafaker/service/files/EnFile.java @@ -3,13 +3,20 @@ import java.util.List; import java.util.stream.Stream; -public record EnFile(String file, String path) { +public class EnFile { private static final String YML = ".yml"; + private final String file; + private final String path; private EnFile(String file) { this(file, file.endsWith(YML) ? file.substring(0, file.length() - YML.length()) : file); } + private EnFile(String file, String path) { + this.file = file; + this.path = path; + } + public String getFile() { return file; } diff --git a/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java b/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java index 49828598e..5083c8eae 100644 --- a/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java +++ b/src/main/java/net/datafaker/transformations/JavaObjectTransformer.java @@ -4,6 +4,7 @@ import java.io.OutputStream; import java.lang.reflect.Constructor; +import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Modifier; import java.lang.reflect.RecordComponent; @@ -77,10 +78,10 @@ public Object apply(Object input, Schema schema) { Consumer consumer = SCHEMA2CONSUMER.get(schema); if (consumer == null) { - final Field[] fields = schema.getFields(); - var name2ClassField = Stream.of(clazz.getDeclaredFields()).collect( - Collectors.toMap(java.lang.reflect.Field::getName, Function.identity())); - final java.lang.reflect.Field[] rFields = new java.lang.reflect.Field[fields.length]; + final net.datafaker.transformations.Field[] fields = schema.getFields(); + final Map name2ClassField = Stream.of(clazz.getDeclaredFields()).collect( + Collectors.toMap(Field::getName, Function.identity())); + final Field[] rFields = new Field[fields.length]; for (int i = 0; i < fields.length; i++) { rFields[i] = name2ClassField.get(fields[i].getName()); rFields[i].setAccessible(true); @@ -164,7 +165,7 @@ public String getEndStream() { } private Object getObject(Schema schema, Object result, Constructor recordConstructor) { - final Field[] fields = schema.getFields(); + final net.datafaker.transformations.Field[] fields = schema.getFields(); final Object[] values = new Object[fields.length]; for (int i = 0; i < fields.length; i++) { values[i] = fields[i].transform(result); diff --git a/src/main/java/net/datafaker/transformations/TomlTransformer.java b/src/main/java/net/datafaker/transformations/TomlTransformer.java index f3a311979..997371c50 100644 --- a/src/main/java/net/datafaker/transformations/TomlTransformer.java +++ b/src/main/java/net/datafaker/transformations/TomlTransformer.java @@ -2,6 +2,7 @@ import net.datafaker.sequence.FakeSequence; +import java.lang.reflect.Array; import java.util.*; import java.util.stream.Collectors; @@ -105,14 +106,14 @@ private void writeValue(StringBuilder sb, String key, String pathPrefix, Object } private void handleArray(StringBuilder sb, String key, Object array) { - int length = java.lang.reflect.Array.getLength(array); + int length = Array.getLength(array); if (length == 0) { sb.append(key).append(" = []").append(LINE_SEPARATOR); return; } List list = new ArrayList<>(length); for (int i = 0; i < length; i++) { - list.add(java.lang.reflect.Array.get(array, i)); + list.add(Array.get(array, i)); } String joined = list.stream().map(this::value2String).collect(Collectors.joining(", ")); sb.append(key).append(" = [ ").append(joined).append(" ]").append(LINE_SEPARATOR); diff --git a/src/test/java/net/datafaker/TestStrings.java b/src/test/java/net/datafaker/TestStrings.java index 3573d6d1b..388879c54 100644 --- a/src/test/java/net/datafaker/TestStrings.java +++ b/src/test/java/net/datafaker/TestStrings.java @@ -9,11 +9,4 @@ private TestStrings() { public static String lines(String textBlock) { return textBlock.replace("\n", System.lineSeparator()); } - - /** Like {@link #lines(String)}, but strips one trailing platform line separator. */ - public static String linesTrimTrailing(String textBlock) { - String result = lines(textBlock); - String sep = System.lineSeparator(); - return result.endsWith(sep) ? result.substring(0, result.length() - sep.length()) : result; - } } diff --git a/src/test/java/net/datafaker/formats/CsvTest.java b/src/test/java/net/datafaker/formats/CsvTest.java index 29332bfac..d0092790a 100644 --- a/src/test/java/net/datafaker/formats/CsvTest.java +++ b/src/test/java/net/datafaker/formats/CsvTest.java @@ -11,7 +11,6 @@ import java.util.Random; -import static net.datafaker.TestStrings.linesTrimTrailing; import static net.datafaker.transformations.Field.field; import static net.datafaker.transformations.Transformer.LINE_SEPARATOR; import static org.assertj.core.api.Assertions.assertThat; @@ -85,10 +84,9 @@ void testCsvWithCommaNew() { String csv = transformer.generate(schema, 1); - String expected = linesTrimTrailing(""" - "values","title" - "1,2,3","The ""fabulous"" artist" - """); + String expected = + "\"values\",\"title\"" + LINE_SEPARATOR + + "\"1,2,3\",\"The \"\"fabulous\"\" artist\""; assertThat(csv).isEqualTo(expected); } @@ -107,13 +105,12 @@ void testCsvWithDifferentObjects() { String csv = transformer.generate(schema, 4); - String expected = linesTrimTrailing(""" - "Number","Bool","String","Text" - 3,false,"Flor","The, ""fabulous"" artist'" - 6,true,"Stephnie","The, ""fabulous"" artist'" - 1,false,"Edythe","The, ""fabulous"" artist'" - 1,true,"Dwight","The, ""fabulous"" artist'" - """); + String expected = + "\"Number\",\"Bool\",\"String\",\"Text\"" + LINE_SEPARATOR + + "3,false,\"Flor\",\"The, \"\"fabulous\"\" artist'\"" + LINE_SEPARATOR + + "6,true,\"Stephnie\",\"The, \"\"fabulous\"\" artist'\"" + LINE_SEPARATOR + + "1,false,\"Edythe\",\"The, \"\"fabulous\"\" artist'\"" + LINE_SEPARATOR + + "1,true,\"Dwight\",\"The, \"\"fabulous\"\" artist'\""; assertThat(csv).isEqualTo(expected); } @@ -135,14 +132,13 @@ void testCsvWithDifferentObjectsFunction() { .build(); String csv = transformer.generate(fakeSequence, schema); - String expected = linesTrimTrailing(""" - "Number","Password" - 3,"nf3" - 6,"4b0v69" - 7,"00827v2" - 1,"5" - 3,"p6x" - """); + String expected = + "\"Number\",\"Password\"" + LINE_SEPARATOR + + "3,\"nf3\"" + LINE_SEPARATOR + + "6,\"4b0v69\"" + LINE_SEPARATOR + + "7,\"00827v2\"" + LINE_SEPARATOR + + "1,\"5\"" + LINE_SEPARATOR + + "3,\"p6x\""; assertThat(csv).isEqualTo(expected); } @@ -165,12 +161,11 @@ void testCsvWithDifferentObjectsFunctionStream() { String csv = transformer.generate(fakeSequence, schema); - String expected = linesTrimTrailing(""" - "Number","Password" - 3,"0p4" - 8,"714487nf" - 5,"0v691" - """); + String expected = + "\"Number\",\"Password\"" + LINE_SEPARATOR + + "3,\"0p4\"" + LINE_SEPARATOR + + "8,\"714487nf\"" + LINE_SEPARATOR + + "5,\"0v691\""; assertThat(csv).isEqualTo(expected); } diff --git a/src/test/java/net/datafaker/formats/JsonTest.java b/src/test/java/net/datafaker/formats/JsonTest.java index a0c8f6e29..8794e9304 100644 --- a/src/test/java/net/datafaker/formats/JsonTest.java +++ b/src/test/java/net/datafaker/formats/JsonTest.java @@ -21,7 +21,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import static net.datafaker.TestStrings.linesTrimTrailing; +import static net.datafaker.TestStrings.lines; import static net.datafaker.transformations.Field.compositeField; import static net.datafaker.transformations.Field.field; import static net.datafaker.transformations.Transformer.LINE_SEPARATOR; @@ -41,7 +41,7 @@ void testJsonStream() { JsonTransformer transformer = JsonTransformer.builder().build(); Stream json = transformer.generateStream(schema, 10); String output = json.collect(Collectors.joining(LINE_SEPARATOR)); - assertThat(output).isEqualTo(linesTrimTrailing(""" + assertThat(output).isEqualTo(lines(""" [ {"Text": "Willis", "Bool": false}, {"Text": "Carlena", "Bool": true}, @@ -53,8 +53,7 @@ void testJsonStream() { {"Text": "Alphonse", "Bool": false}, {"Text": "Louisa", "Bool": true}, {"Text": "Caryn", "Bool": false} - ] - """)); + ]""")); } @Test @@ -67,12 +66,11 @@ void testGenerateFromSchemaWithLimit() { JsonTransformer transformer = JsonTransformer.builder().build(); String json = transformer.generate(schema, 2); - String expected = linesTrimTrailing(""" + String expected = lines(""" [ {"Text": "Willis", "Bool": false}, {"Text": "Carlena", "Bool": true} - ] - """); + ]"""); assertThat(json).isEqualTo(expected); } @@ -94,15 +92,14 @@ void testGenerateFromFakeSequenceCollectionWithoutComma() { String json = transformer.generate(fakeSequence, schema); - String expected = linesTrimTrailing(""" + String expected = lines(""" [ {"Number": 3, "Password": "nf3"} {"Number": 6, "Password": "4b0v69"} {"Number": 7, "Password": "00827v2"} {"Number": 1, "Password": "5"} {"Number": 3, "Password": "p6x"} - ] - """); + ]"""); assertThat(json).isEqualTo(expected); } @@ -124,15 +121,14 @@ void testGenerateFromFakeSequenceCollection() { String json = transformer.generate(fakeSequence, schema); - String expected = linesTrimTrailing(""" + String expected = lines(""" [ {"Number": 3, "Password": "nf3"}, {"Number": 6, "Password": "4b0v69"}, {"Number": 7, "Password": "00827v2"}, {"Number": 1, "Password": "5"}, {"Number": 3, "Password": "p6x"} - ] - """); + ]"""); assertThat(json).isEqualTo(expected); } @@ -154,12 +150,11 @@ void testGenerateFromFakeSequenceStream() { String json = transformer.generate(fakeSequence, schema); - String expected = linesTrimTrailing(""" + String expected = lines(""" [ {"Number": 3, "Password": "0p4"} {"Number": 8, "Password": "714487nf"} - ] - """); + ]"""); assertThat(json).isEqualTo(expected); } diff --git a/src/test/java/net/datafaker/formats/SqlTest.java b/src/test/java/net/datafaker/formats/SqlTest.java index 069681d17..77c2feb28 100644 --- a/src/test/java/net/datafaker/formats/SqlTest.java +++ b/src/test/java/net/datafaker/formats/SqlTest.java @@ -22,7 +22,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import static net.datafaker.TestStrings.linesTrimTrailing; +import static net.datafaker.TestStrings.lines; import static net.datafaker.transformations.Field.compositeField; import static net.datafaker.transformations.Field.field; import static net.datafaker.transformations.Transformer.LINE_SEPARATOR; @@ -48,13 +48,12 @@ void generateFromFakeSequenceSeparated() { String sql = transformer.generate(fakeSequence, schema); - String expected = linesTrimTrailing(""" + String expected = lines(""" INSERT INTO "MyTable" ("Number", "Password") VALUES (3, 'nf3'); INSERT INTO "MyTable" ("Number", "Password") VALUES (6, '4b0v69'); INSERT INTO "MyTable" ("Number", "Password") VALUES (7, '00827v2'); INSERT INTO "MyTable" ("Number", "Password") VALUES (1, '5'); - INSERT INTO "MyTable" ("Number", "Password") VALUES (3, 'p6x'); - """); + INSERT INTO "MyTable" ("Number", "Password") VALUES (3, 'p6x');"""); assertThat(sql).isEqualTo(expected); } @@ -77,14 +76,13 @@ void generateFromFakeSequenceBatch() { String sql = transformer.generate(fakeSequence, schema); - String expected = linesTrimTrailing(""" + String expected = lines(""" INSERT INTO "MyTable" ("Number", "Password") VALUES (3, 'nf3'), (6, '4b0v69'), (7, '00827v2'), (1, '5'), - (3, 'p6x'); - """); + (3, 'p6x');"""); assertThat(sql).isEqualTo(expected); } @@ -135,10 +133,9 @@ void testGenerateFromSchemaWithLimitSeparatedStatements() { SqlTransformer transformer = SqlTransformer.builder().build(); String sql = transformer.generate(schema, 2); - String expected = linesTrimTrailing(""" + String expected = lines(""" INSERT INTO "MyTable" ("Text", "Bool") VALUES ('Willis', false); - INSERT INTO "MyTable" ("Text", "Bool") VALUES ('Carlena', true); - """); + INSERT INTO "MyTable" ("Text", "Bool") VALUES ('Carlena', true);"""); assertThat(sql).isEqualTo(expected); } @@ -156,11 +153,10 @@ void testGenerateFromSchemaWithLimitBatchModeStatements() { .build(); String sql = transformer.generate(schema, 2); - String expected = linesTrimTrailing(""" + String expected = lines(""" INSERT INTO "MyTable" ("Text", "Bool") VALUES ('Willis', false), - ('Carlena', true); - """); + ('Carlena', true);"""); assertThat(sql).isEqualTo(expected); } @@ -179,11 +175,10 @@ void testForceQuotedWithSqlIdentifiers() { .build(); String sql = forceQuotedTransformer.generate(schema, 2); - String expected = linesTrimTrailing(""" + String expected = lines(""" INSERT INTO "MY_TABLE" ("TEXT", "BOOL") VALUES ('Willis', false), - ('Carlena', true); - """); + ('Carlena', true);"""); assertThat(sql).isEqualTo(expected); } @@ -568,14 +563,13 @@ void testSqlBatch() { .generateStream(schema, 4) .collect(Collectors.joining(LINE_SEPARATOR)); - String expected = linesTrimTrailing(""" + String expected = lines(""" INSERT INTO "MyTable" ("Number", "Password") VALUES ('6', '09fd4007-40ba-39df-8cb1-65926bf7b8a9'), ('8', '96c19757-1f18-3051-9acb-f56f0b5555ae'), ('2', '8a4a0365-cd39-33c1-a52a-279b1076cf2d'); INSERT INTO "MyTable" ("Number", "Password") - VALUES ('6', 'e807efdd-b6db-319d-8342-a044274d3417'); - """); + VALUES ('6', 'e807efdd-b6db-319d-8342-a044274d3417');"""); assertThat(sql).isEqualTo(expected); } @@ -596,12 +590,11 @@ void testWordTruncated() { String sql = transformer.generateStream(schema,3).collect(Collectors.joining(LINE_SEPARATOR)); - String expected = linesTrimTrailing(""" + String expected = lines(""" INSERT INTO "MyTable" ("Address", "Book") VALUES ('Cote d\\'Ivoire', 'All the King\\'s Men'), ('Cote d\\'Ivoire', 'Blood\\'s a Rover'), - ('Cote d\\'Ivoire', 'Blood\\'s a Rover'); - """); + ('Cote d\\'Ivoire', 'Blood\\'s a Rover');"""); assertThat(sql).isEqualTo(expected); } diff --git a/src/test/java/net/datafaker/formats/TomlTest.java b/src/test/java/net/datafaker/formats/TomlTest.java index bce31166a..021c00c12 100644 --- a/src/test/java/net/datafaker/formats/TomlTest.java +++ b/src/test/java/net/datafaker/formats/TomlTest.java @@ -15,7 +15,6 @@ import java.util.stream.IntStream; import java.util.stream.Stream; -import static net.datafaker.TestStrings.linesTrimTrailing; import static net.datafaker.transformations.Field.field; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.params.provider.Arguments.of; @@ -30,6 +29,7 @@ void simpleTomlTest(Schema schema, String expected) { } private static Stream generateTestSchema() { + String sep = System.lineSeparator(); return Stream.of( of(Schema.of(), ""), of(Schema.of(field("key", () -> "value")), "key = \"value\""), @@ -49,11 +49,9 @@ private static Stream generateTestSchema() { of(Schema.of( field("key", () -> "value"), field("nested", () -> Schema.of(field("nestedkey", () -> "nestedvalue"))) - ), linesTrimTrailing(""" - key = "value" - [nested] - nestedkey = "nestedvalue" - """)), + ), "key = \"value\"" + sep + + "[nested]" + sep + + "nestedkey = \"nestedvalue\""), of(Schema.of( field("key", () -> "value"), field("nested", () -> Schema.of( @@ -62,32 +60,26 @@ private static Stream generateTestSchema() { field("nestedkey2", () -> "nestedvalue2") )) )) - ), linesTrimTrailing(""" - key = "value" - [nested] - nestedkey = "nestedvalue" - [nested.nested2] - nestedkey2 = "nestedvalue2" - """)), + ), "key = \"value\"" + sep + + "[nested]" + sep + + "nestedkey = \"nestedvalue\"" + sep + + "[nested.nested2]" + sep + + "nestedkey2 = \"nestedvalue2\""), of(Schema.of( field("parent", () -> Schema.of( field("numbers", () -> new Integer[]{1, 2}) )) - ), linesTrimTrailing(""" - [parent] - numbers = [ 1, 2 ] - """)), + ), "[parent]" + sep + + "numbers = [ 1, 2 ]"), of(Schema.of( field("items", () -> List.of( Schema.of(field("id", () -> 1)), Schema.of(field("id", () -> 2)) )) - ), linesTrimTrailing(""" - [[items]] - id = 1 - [[items]] - id = 2 - """)) + ), "[[items]]" + sep + + "id = 1" + sep + + "[[items]]" + sep + + "id = 2") ); } diff --git a/src/test/java/net/datafaker/formats/XmlTest.java b/src/test/java/net/datafaker/formats/XmlTest.java index b0b1c59e6..d86428bd5 100644 --- a/src/test/java/net/datafaker/formats/XmlTest.java +++ b/src/test/java/net/datafaker/formats/XmlTest.java @@ -16,7 +16,7 @@ import java.util.List; import java.util.stream.Stream; -import static net.datafaker.TestStrings.linesTrimTrailing; +import static net.datafaker.TestStrings.lines; import static net.datafaker.transformations.Field.compositeField; import static net.datafaker.transformations.Field.field; import static org.assertj.core.api.Assertions.assertThat; @@ -75,11 +75,10 @@ private static Stream generateTestXmlPrettySchema() { compositeField("root", new Field[]{field("attribute1", () -> "value1"), field("attribute2", () -> "value2"), field(null, () -> List.of(field("child", () -> "value")))})), - linesTrimTrailing(""" + lines(""" value - - """)), + """)), of(Schema.of(field("root", () -> "<> value\"")), "<> value"") ); } From 72d1738fc3a6be7654ce9be87bb96bba5f9ff8af Mon Sep 17 00:00:00 2001 From: kingthorin Date: Sun, 28 Jun 2026 20:57:05 -0400 Subject: [PATCH 8/8] Don't use our own deprecated code Signed-off-by: kingthorin --- src/test/java/net/datafaker/formats/CsvTest.java | 6 ++---- src/test/java/net/datafaker/formats/JsonTest.java | 12 ++++-------- .../datafaker/providers/base/CredentialsTest.java | 3 +-- .../net/datafaker/providers/base/InternetTest.java | 7 ++++--- 4 files changed, 11 insertions(+), 17 deletions(-) diff --git a/src/test/java/net/datafaker/formats/CsvTest.java b/src/test/java/net/datafaker/formats/CsvTest.java index d0092790a..5fc9f7096 100644 --- a/src/test/java/net/datafaker/formats/CsvTest.java +++ b/src/test/java/net/datafaker/formats/CsvTest.java @@ -116,12 +116,11 @@ void testCsvWithDifferentObjects() { } @Test - @SuppressWarnings("removal") void testCsvWithDifferentObjectsFunction() { BaseFaker faker = new BaseFaker(new Random(10L)); Schema schema = Schema.of( field("Number", integer -> integer), - field("Password", integer -> faker.internet().password(integer, integer)) + field("Password", integer -> faker.credentials().password(integer, integer)) ); CsvTransformer transformer = CsvTransformer.builder().header(true).separator(",").build(); @@ -144,12 +143,11 @@ void testCsvWithDifferentObjectsFunction() { } @Test - @SuppressWarnings("removal") void testCsvWithDifferentObjectsFunctionStream() { BaseFaker faker = new BaseFaker(new Random(10L)); Schema schema = Schema.of( field("Number", integer -> integer), - field("Password", integer -> faker.internet().password(integer, integer)) + field("Password", integer -> faker.credentials().password(integer, integer)) ); CsvTransformer transformer = CsvTransformer.builder().header(true).separator(",").build(); diff --git a/src/test/java/net/datafaker/formats/JsonTest.java b/src/test/java/net/datafaker/formats/JsonTest.java index 8794e9304..4420c1bfc 100644 --- a/src/test/java/net/datafaker/formats/JsonTest.java +++ b/src/test/java/net/datafaker/formats/JsonTest.java @@ -76,12 +76,11 @@ void testGenerateFromSchemaWithLimit() { } @Test - @SuppressWarnings("removal") void testGenerateFromFakeSequenceCollectionWithoutComma() { BaseFaker faker = new BaseFaker(new Random(10L)); Schema schema = Schema.of( field("Number", integer -> integer), - field("Password", integer -> faker.internet().password(integer, integer)) + field("Password", integer -> faker.credentials().password(integer, integer)) ); JsonTransformer transformer = JsonTransformer.builder().withCommaBetweenObjects(false).build(); @@ -105,12 +104,11 @@ void testGenerateFromFakeSequenceCollectionWithoutComma() { } @Test - @SuppressWarnings("removal") void testGenerateFromFakeSequenceCollection() { BaseFaker faker = new BaseFaker(new Random(10L)); Schema schema = Schema.of( field("Number", integer -> integer), - field("Password", integer -> faker.internet().password(integer, integer)) + field("Password", integer -> faker.credentials().password(integer, integer)) ); JsonTransformer transformer = JsonTransformer.builder().build(); @@ -134,12 +132,11 @@ void testGenerateFromFakeSequenceCollection() { } @Test - @SuppressWarnings("removal") void testGenerateFromFakeSequenceStream() { BaseFaker faker = new BaseFaker(new Random(10L)); Schema schema = Schema.of( field("Number", integer -> integer), - field("Password", integer -> faker.internet().password(integer, integer)) + field("Password", integer -> faker.credentials().password(integer, integer)) ); JsonTransformer transformer = JsonTransformer.builder().withCommaBetweenObjects(false).build(); @@ -160,12 +157,11 @@ void testGenerateFromFakeSequenceStream() { } @Test - @SuppressWarnings("removal") void testGenerateFromInfiniteFakeSequence() { BaseFaker faker = new BaseFaker(new Random(10L)); Schema schema = Schema.of( field("Number", integer -> integer), - field("Password", integer -> faker.internet().password(integer, integer)) + field("Password", integer -> faker.credentials().password(integer, integer)) ); JsonTransformer transformer = JsonTransformer.builder().build(); diff --git a/src/test/java/net/datafaker/providers/base/CredentialsTest.java b/src/test/java/net/datafaker/providers/base/CredentialsTest.java index d6fc8e517..f64eb94f3 100644 --- a/src/test/java/net/datafaker/providers/base/CredentialsTest.java +++ b/src/test/java/net/datafaker/providers/base/CredentialsTest.java @@ -26,7 +26,6 @@ void testUsername() { @ParameterizedTest @MethodSource("userNameWithSpacesProvider") - @SuppressWarnings("removal") void testUsernameWithSpaces(String firstName, String lastName, String expected) { Locale locale = new Locale("TR"); Name name = mock(); @@ -40,7 +39,7 @@ public Name name() { } }; - assertThat(mockedFaker.internet().username()) + assertThat(mockedFaker.credentials().username()) .isEqualTo(expected); } diff --git a/src/test/java/net/datafaker/providers/base/InternetTest.java b/src/test/java/net/datafaker/providers/base/InternetTest.java index c1d7a5f8b..13af48326 100644 --- a/src/test/java/net/datafaker/providers/base/InternetTest.java +++ b/src/test/java/net/datafaker/providers/base/InternetTest.java @@ -14,10 +14,11 @@ import java.net.URL; import java.util.ArrayList; import java.util.List; -import java.util.Set; import java.util.Locale; import java.util.Random; +import java.util.Set; import java.util.regex.Pattern; +import java.util.stream.Collectors; import java.util.stream.Stream; import static java.lang.Integer.parseInt; @@ -160,7 +161,7 @@ void testSafeEmailAddress() { } final String safeDomain = faker.internet().resolve("internet.safe_email"); - assertThat(emails.stream().filter(t -> t.endsWith("@" + safeDomain)).toList()) + assertThat(emails.stream().filter(t -> t.endsWith("@" + safeDomain)).collect(Collectors.toList())) .isNotEmpty(); } @@ -175,7 +176,7 @@ void testSafeEmailAddressWithNameParameter() { } final String safeDomain = faker.internet().resolve("internet.safe_email"); - assertThat(emails.stream().filter(t -> t.endsWith("@" + safeDomain)).toList()) + assertThat(emails.stream().filter(t -> t.endsWith("@" + safeDomain)).collect(Collectors.toList())) .isNotEmpty(); }