From 45d177bc91adf936908e4b8734b4a6eb4ba22618 Mon Sep 17 00:00:00 2001 From: Miguel Escobar Date: Sun, 28 Jan 2024 22:34:38 -0600 Subject: [PATCH 1/5] 39-suport-for-array-data-types --- .../processor/PactDslProcessor.java | 21 ++---- .../processor/mapping/StringArrayMapping.java | 53 +++++++++++++++ .../templates/templateDslBuilder.ftlh | 8 ++- .../annotation/processor/ArrayTest.java | 20 ++++++ src/test/resources/basic/ArrayDataTypes.java | 41 ++++++++++++ .../basic/ArrayDataTypesBuilder.java | 67 +++++++++++++++++++ 6 files changed, 195 insertions(+), 15 deletions(-) create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java create mode 100644 src/test/java/com/sngular/annotation/processor/ArrayTest.java create mode 100644 src/test/resources/basic/ArrayDataTypes.java create mode 100644 src/test/resources/basic/ArrayDataTypesBuilder.java diff --git a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java index 77db721..4068ff6 100644 --- a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java +++ b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java @@ -38,20 +38,7 @@ import com.sngular.annotation.processor.exception.PactProcessorException; import com.sngular.annotation.processor.exception.TemplateFactoryException; import com.sngular.annotation.processor.exception.TemplateGenerationException; -import com.sngular.annotation.processor.mapping.BigDecimalMapping; -import com.sngular.annotation.processor.mapping.BigIntegerMapping; -import com.sngular.annotation.processor.mapping.BooleanMapping; -import com.sngular.annotation.processor.mapping.ByteMapping; -import com.sngular.annotation.processor.mapping.CharMapping; -import com.sngular.annotation.processor.mapping.DateMapping; -import com.sngular.annotation.processor.mapping.DoubleMapping; -import com.sngular.annotation.processor.mapping.FloatMapping; -import com.sngular.annotation.processor.mapping.IntegerMapping; -import com.sngular.annotation.processor.mapping.LongMapping; -import com.sngular.annotation.processor.mapping.ShortMapping; -import com.sngular.annotation.processor.mapping.StringMapping; -import com.sngular.annotation.processor.mapping.TypeMapping; -import com.sngular.annotation.processor.mapping.ZonedDateTimeMapping; +import com.sngular.annotation.processor.mapping.*; import com.sngular.annotation.processor.model.ClassBuilderTemplate; import com.sngular.annotation.processor.model.DslComplexField; import com.sngular.annotation.processor.model.DslComplexTypeEnum; @@ -101,6 +88,8 @@ public class PactDslProcessor extends AbstractProcessor { .put("ZonedDateTime", new ZonedDateTimeMapping()) .put("java.util.Date", new DateMapping()) .put("Date", new DateMapping()) + .put("String[]", new StringArrayMapping()) + .put("java.lang.String[]", new StringArrayMapping()) .build(); private static final String CUSTOM_MODIFIERS = "customModifiers"; @@ -385,6 +374,9 @@ private static Object getDefaultValue(final Element fieldElement, final String t private Optional> extractMappingByType(final Element element) { final var type = element.asType(); + + //Object cont = TYPE_MAPPING.get(this.typeUtils.asElement(type).getSimpleName().toString()); + return switch (type.getKind()) { case BOOLEAN -> Optional.of(TYPE_MAPPING.get("boolean")); case BYTE -> Optional.of(TYPE_MAPPING.get("byte")); @@ -394,6 +386,7 @@ private Optional> extractMappingByType(final Element element) { case CHAR -> Optional.of(TYPE_MAPPING.get("char")); case FLOAT -> Optional.of(TYPE_MAPPING.get("float")); case DOUBLE -> Optional.of(TYPE_MAPPING.get("double")); + case ARRAY -> Optional.of(TYPE_MAPPING.get("String[]")); case DECLARED -> Optional.ofNullable(TYPE_MAPPING.get(this.typeUtils.asElement(type).getSimpleName().toString())); default -> Optional.empty(); }; diff --git a/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java new file mode 100644 index 0000000..e5c859a --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java @@ -0,0 +1,53 @@ +/* + * This Source Code Form is subject to the terms of the Mozilla Public + * * License, v. 2.0. If a copy of the MPL was not distributed with this + * * file, You can obtain one at https://mozilla.org/MPL/2.0/. + */ + +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.commons.lang3.RandomStringUtils; +import org.apache.commons.rng.UniformRandomProvider; + +import java.util.Objects; + +public class StringArrayMapping implements TypeMapping { + + public static final int DEFAULT_MAX = 15; + + public static final int DEFAULT_MIN = 1; + + @Override + public final String getFieldType() { + return "String[]"; + } + + @Override + public final String getFunctionType() { + return "stringArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "stringArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + final int length; + + if (Objects.nonNull(fieldValidations) && ObjectUtils.anyNotNull(fieldValidations.getMin(), fieldValidations.getMax())) { + final int minLength = ObjectUtils.defaultIfNull(fieldValidations.getMin(), DEFAULT_MIN); + final int maxLength = ObjectUtils.defaultIfNull(fieldValidations.getMax(), DEFAULT_MAX); + + length = uniformRandomProvider.nextInt(minLength, maxLength); + } else { + length = uniformRandomProvider.nextInt(DEFAULT_MIN, DEFAULT_MAX); + } + + //return RandomStringUtils.randomAlphanumeric(length); + return "RandomDefaultValue"; // String en duro para las pruebas + } +} diff --git a/src/main/resources/templates/templateDslBuilder.ftlh b/src/main/resources/templates/templateDslBuilder.ftlh index e29a080..40ecd67 100644 --- a/src/main/resources/templates/templateDslBuilder.ftlh +++ b/src/main/resources/templates/templateDslBuilder.ftlh @@ -1,7 +1,11 @@ <#assign constructor = false> <#macro writeAttrField field> <#if field.functionByType??> - <#if field.fieldType == "boolean"> + <#if field.fieldType == "String[]"> + ${field.fieldType} ${field.name} = {"${field.defaultValue?string}"}; + String ${field.name}Name = "${field.name}"; + String ${field.name}Value = "${field.defaultValue?string}"; + <#elseif field.fieldType == "boolean"> ${field.fieldType} ${field.name} = ${field.defaultValue?string}; <#elseif field.fieldType == "char"> String ${field.name} = "${field.defaultValue}"; @@ -112,6 +116,8 @@ pactDslJsonBody.${field.functionByType}("${field.name}", (double) ${field.name}); <#elseif field.fieldType == "byte"> pactDslJsonBody.${field.functionByType}("${field.name}", (int) ${field.name}); + <#elseif field.fieldType == "String[]"> + pactDslJsonBody.array(${field.name}Name).stringValue(${field.name}Value).closeArray(); <#else> pactDslJsonBody.${field.functionByType}("${field.name}", ${field.name}); diff --git a/src/test/java/com/sngular/annotation/processor/ArrayTest.java b/src/test/java/com/sngular/annotation/processor/ArrayTest.java new file mode 100644 index 0000000..0785307 --- /dev/null +++ b/src/test/java/com/sngular/annotation/processor/ArrayTest.java @@ -0,0 +1,20 @@ +package com.sngular.annotation.processor; + +import com.google.testing.compile.Compilation; +import com.google.testing.compile.JavaFileObjects; +import org.junit.jupiter.api.Test; + +import static com.google.testing.compile.CompilationSubject.assertThat; +import static com.google.testing.compile.Compiler.javac; + +public class ArrayTest { + + @Test + public void arrays() { + + Compilation compilation = javac().withProcessors(new PactDslProcessor()).compile(JavaFileObjects.forResource("basic/ArrayDataTypes.java")); + assertThat(compilation).succeeded(); + assertThat(compilation).generatedSourceFile("com/sngular/resources/basic/ArrayDataTypesBuilder") + .hasSourceEquivalentTo(JavaFileObjects.forResource("basic/ArrayDataTypesBuilder.java")); + } +} diff --git a/src/test/resources/basic/ArrayDataTypes.java b/src/test/resources/basic/ArrayDataTypes.java new file mode 100644 index 0000000..678b001 --- /dev/null +++ b/src/test/resources/basic/ArrayDataTypes.java @@ -0,0 +1,41 @@ +package com.sngular.resources.basic; + +import com.sngular.annotation.pact.Example; +import com.sngular.annotation.pact.PactDslBodyBuilder; +import com.sngular.annotation.pact.DslExclude; + +@PactDslBodyBuilder +public class ArrayDataTypes { + + @Example("stringArrayExample") + private String[] stringArray; + + @DslExclude + private String[] stringArrayExclude; + + private String[] stringArrayDefault; + + public String[] getStringArray() { + return stringArray; + } + + public void setStringArray(String[] stringArray) { + this.stringArray = stringArray; + } + + public String[] getStringArrayExclude() { + return stringArrayExclude; + } + + public void setStringArrayExclude(String[] stringArrayExclude) { + this.stringArrayExclude = stringArrayExclude; + } + + public String[] getStringArrayDefault() { + return stringArrayDefault; + } + + public void setStringArrayDefault(String[] stringArrayDefault) { + this.stringArrayDefault = stringArrayDefault; + } +} \ No newline at end of file diff --git a/src/test/resources/basic/ArrayDataTypesBuilder.java b/src/test/resources/basic/ArrayDataTypesBuilder.java new file mode 100644 index 0000000..07638a3 --- /dev/null +++ b/src/test/resources/basic/ArrayDataTypesBuilder.java @@ -0,0 +1,67 @@ +package com.sngular.resources.basic; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.Instant; +import java.time.LocalDate; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.util.Date; +import java.util.List; +import java.util.Objects; + +import au.com.dius.pact.consumer.dsl.DslPart; +import au.com.dius.pact.consumer.dsl.PactDslJsonArray; +import au.com.dius.pact.consumer.dsl.PactDslJsonBody; +import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue; +import com.sngular.annotation.processor.mapping.CustomDslModifier; +import com.sngular.resources.basic.ArrayDataTypes; + +public class ArrayDataTypesBuilder { + + String[] stringArray = {"stringArrayExample"}; + String stringArrayName = "stringArray"; + String stringArrayValue = "stringArrayExample"; + + String[] stringArrayDefault = {"RandomDefaultValue"}; + String stringArrayDefaultName = "stringArrayDefault"; + String stringArrayDefaultValue = "RandomDefaultValue"; + + + public ArrayDataTypesBuilder setStringArray(final String[] stringArray) { + this.stringArray = stringArray; + return this; + } + + public ArrayDataTypesBuilder setStringArrayDefault(final String[] stringArrayDefault) { + this.stringArrayDefault = stringArrayDefault; + return this; + } + + public DslPart build() { + PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); + + if (Objects.nonNull(stringArray)) { + pactDslJsonBody.array(stringArrayName).stringValue(stringArrayValue).closeArray(); + } + + if (Objects.nonNull(stringArrayDefault)) { + pactDslJsonBody.array(stringArrayDefaultName).stringValue(stringArrayDefaultValue).closeArray(); + } + return pactDslJsonBody; + } + + public ArrayDataTypes buildExpectedInstance() { + ArrayDataTypes object = new ArrayDataTypes(); + object.setStringArray(this.stringArray); + object.setStringArrayDefault(this.stringArrayDefault); + return object; + } + + private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { + } +} + From bcce442a6401e69d799686199946256c24251f37 Mon Sep 17 00:00:00 2001 From: Miguel Escobar Date: Fri, 2 Feb 2024 18:16:35 -0600 Subject: [PATCH 2/5] add array in @Example for test String[] for many values --- .../com/sngular/annotation/pact/Example.java | 1 + .../processor/PactDslProcessor.java | 40 ++++++++++---- .../processor/mapping/CharArrayMapping.java | 31 +++++++++++ .../templates/templateDslBuilder.ftlh | 32 ++++++----- src/test/resources/basic/ArrayDataTypes.java | 12 +---- .../basic/ArrayDataTypesBuilder.java | 53 +++++++------------ 6 files changed, 101 insertions(+), 68 deletions(-) create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java diff --git a/src/main/java/com/sngular/annotation/pact/Example.java b/src/main/java/com/sngular/annotation/pact/Example.java index b94e532..a54f25a 100644 --- a/src/main/java/com/sngular/annotation/pact/Example.java +++ b/src/main/java/com/sngular/annotation/pact/Example.java @@ -18,4 +18,5 @@ String value() default ""; String format() default ""; + String[] array() default { }; } diff --git a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java index 4068ff6..4ea8684 100644 --- a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java +++ b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java @@ -7,13 +7,7 @@ package com.sngular.annotation.processor; import java.io.IOException; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.Optional; -import java.util.Random; -import java.util.Set; +import java.util.*; import javax.annotation.processing.AbstractProcessor; import javax.annotation.processing.Processor; @@ -117,6 +111,25 @@ private static String getFormat(final Element fieldElement, final String default return StringUtils.defaultIfEmpty(value, defaultFormat); } + private static String getFormatArray(final Element fieldElement, final String defaultFormat) { + final String[] value = fieldElement.getAnnotation(Example.class).array(); + return StringUtils.defaultIfEmpty(getStringFromArray(value), defaultFormat); + + } + + private static String getStringFromArray(String[] value) { + + String arrayToString = ""; + + for (int i = 0; ; i++) { + if (i == value.length-1) { + return arrayToString += "\"" + value[i] + "\""; + } else { + arrayToString += "\"" + value[i] + "\","; + } + } + } + @Override public final SourceVersion getSupportedSourceVersion() { return SourceVersion.latestSupported(); @@ -335,9 +348,15 @@ private DslSimpleField.DslSimpleFieldBuilder createSimpleFieldBuilder(final Elem if (Objects.nonNull(fieldElement.getAnnotation(DslExclude.class))) { simpleFieldBuilder.empty(true); + + } else if (fieldElement.getAnnotation(Example.class).array().length != 0){ + simpleFieldBuilder.defaultValue(getFormatArray(fieldElement, mapping.getFieldType())); + simpleFieldBuilder.formatValue(null); + } else if (Objects.nonNull(fieldElement.getAnnotation(Example.class))) { simpleFieldBuilder.defaultValue(getDefaultValue(fieldElement, mapping.getFieldType())); simpleFieldBuilder.formatValue(getFormat(fieldElement, mapping.getFormatValue())); + } else { simpleFieldBuilder.defaultValue(mapping.getRandomDefaultValue(validationBuilder.build(), randomSource)); simpleFieldBuilder.formatValue(mapping.getFormatValue()); @@ -375,7 +394,9 @@ private Optional> extractMappingByType(final Element element) { final var type = element.asType(); - //Object cont = TYPE_MAPPING.get(this.typeUtils.asElement(type).getSimpleName().toString()); + Object obj = type.getKind(); + + String typeArray = type.toString(); return switch (type.getKind()) { case BOOLEAN -> Optional.of(TYPE_MAPPING.get("boolean")); @@ -386,11 +407,10 @@ private Optional> extractMappingByType(final Element element) { case CHAR -> Optional.of(TYPE_MAPPING.get("char")); case FLOAT -> Optional.of(TYPE_MAPPING.get("float")); case DOUBLE -> Optional.of(TYPE_MAPPING.get("double")); - case ARRAY -> Optional.of(TYPE_MAPPING.get("String[]")); + case ARRAY -> Optional.of(TYPE_MAPPING.get(type.toString())); case DECLARED -> Optional.ofNullable(TYPE_MAPPING.get(this.typeUtils.asElement(type).getSimpleName().toString())); default -> Optional.empty(); }; } - } diff --git a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java new file mode 100644 index 0000000..d56ed25 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java @@ -0,0 +1,31 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +/** Represents an array of char. + * @author Miguel ANgel Escobar + * @version 1.0 + */ +public class CharArrayMapping implements TypeMapping { + @Override + public final String getFieldType() { + return "char[]"; + } + + @Override + public final String getFunctionType() { + return "charArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "charArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + //return RandomStringUtils.randomAlphanumeric(1); + return "x"; + } +} \ No newline at end of file diff --git a/src/main/resources/templates/templateDslBuilder.ftlh b/src/main/resources/templates/templateDslBuilder.ftlh index 40ecd67..b10ed0b 100644 --- a/src/main/resources/templates/templateDslBuilder.ftlh +++ b/src/main/resources/templates/templateDslBuilder.ftlh @@ -2,9 +2,11 @@ <#macro writeAttrField field> <#if field.functionByType??> <#if field.fieldType == "String[]"> - ${field.fieldType} ${field.name} = {"${field.defaultValue?string}"}; + ${field.fieldType} ${field.name} = {${field.defaultValue?no_esc}}; + String ${field.name}Name = "${field.name}"; + <#elseif field.fieldType == "char[]"> + String[] ${field.name} = {"${field.defaultValue?string}"}; String ${field.name}Name = "${field.name}"; - String ${field.name}Value = "${field.defaultValue?string}"; <#elseif field.fieldType == "boolean"> ${field.fieldType} ${field.name} = ${field.defaultValue?string}; <#elseif field.fieldType == "char"> @@ -48,11 +50,13 @@ <#macro writeSetterField field builderName> <#if field.functionByType??> - <#if field.fieldType == "char"> - public ${builderName}Builder set${field.name?cap_first}(final String ${field.name}) { - <#else> - public ${builderName}Builder set${field.name?cap_first}(final ${field.fieldType?no_esc} ${field.name}) { - + <#if field.fieldType == "char"> + public ${builderName}Builder set${field.name?cap_first}(final String ${field.name}) { + <#elseif field.fieldType == "char[]"> + public ${builderName}Builder set${field.name?cap_first}(final String[] ${field.name}) { + <#else > + public ${builderName}Builder set${field.name?cap_first}(final ${field.fieldType?no_esc} ${field.name}) { + <#elseif field.complexType??> <#if field.complexType.name() == "COLLECTION"> public ${builderName}Builder set${field.name?cap_first}(final ${field.fieldType?no_esc} ${field.name}) { @@ -71,11 +75,13 @@ <#macro writeExpectedInstanceSetters field> <#if !field.empty> - <#if field.fieldType == "char"> + <#if field.fieldType == "char"> object.set${field.name?cap_first}(this.${field.name}.charAt(0)); - <#else> + <#elseif field.fieldType == "char[]"> + object.set${field.name?cap_first}("a".toCharArray()); + <#else > object.set${field.name?cap_first}(this.${field.name}); - + @@ -117,6 +123,8 @@ <#elseif field.fieldType == "byte"> pactDslJsonBody.${field.functionByType}("${field.name}", (int) ${field.name}); <#elseif field.fieldType == "String[]"> + pactDslJsonBody.array(stringArrayName).stringValue(Arrays.toString(stringArray)).closeArray(); + <#elseif field.fieldType == "char[]"> pactDslJsonBody.array(${field.name}Name).stringValue(${field.name}Value).closeArray(); <#else> pactDslJsonBody.${field.functionByType}("${field.name}", ${field.name}); @@ -266,10 +274,8 @@ import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue; <#if schema.customModifiers??> import com.sngular.annotation.processor.mapping.CustomDslModifier; - - import ${schema.modelPackage}.${schema.className}; - +import java.util.Arrays; <#function complex(field)> <#return field.functionByType??> diff --git a/src/test/resources/basic/ArrayDataTypes.java b/src/test/resources/basic/ArrayDataTypes.java index 678b001..e2bb639 100644 --- a/src/test/resources/basic/ArrayDataTypes.java +++ b/src/test/resources/basic/ArrayDataTypes.java @@ -7,14 +7,12 @@ @PactDslBodyBuilder public class ArrayDataTypes { - @Example("stringArrayExample") + @Example(array = {"abc","bef","ghi"} ) private String[] stringArray; @DslExclude private String[] stringArrayExclude; - private String[] stringArrayDefault; - public String[] getStringArray() { return stringArray; } @@ -30,12 +28,4 @@ public String[] getStringArrayExclude() { public void setStringArrayExclude(String[] stringArrayExclude) { this.stringArrayExclude = stringArrayExclude; } - - public String[] getStringArrayDefault() { - return stringArrayDefault; - } - - public void setStringArrayDefault(String[] stringArrayDefault) { - this.stringArrayDefault = stringArrayDefault; - } } \ No newline at end of file diff --git a/src/test/resources/basic/ArrayDataTypesBuilder.java b/src/test/resources/basic/ArrayDataTypesBuilder.java index 07638a3..3e7dbfb 100644 --- a/src/test/resources/basic/ArrayDataTypesBuilder.java +++ b/src/test/resources/basic/ArrayDataTypesBuilder.java @@ -19,49 +19,34 @@ import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue; import com.sngular.annotation.processor.mapping.CustomDslModifier; import com.sngular.resources.basic.ArrayDataTypes; +import java.util.Arrays; public class ArrayDataTypesBuilder { - String[] stringArray = {"stringArrayExample"}; - String stringArrayName = "stringArray"; - String stringArrayValue = "stringArrayExample"; + String[] stringArray = {"abc","bef","ghi"}; + String stringArrayName = "stringArray"; - String[] stringArrayDefault = {"RandomDefaultValue"}; - String stringArrayDefaultName = "stringArrayDefault"; - String stringArrayDefaultValue = "RandomDefaultValue"; + public ArrayDataTypesBuilder setStringArray(final String[] stringArray) { + this.stringArray = stringArray; + return this; + } + public DslPart build() { + PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); - public ArrayDataTypesBuilder setStringArray(final String[] stringArray) { - this.stringArray = stringArray; - return this; - } - - public ArrayDataTypesBuilder setStringArrayDefault(final String[] stringArrayDefault) { - this.stringArrayDefault = stringArrayDefault; - return this; - } - - public DslPart build() { - PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); - - if (Objects.nonNull(stringArray)) { - pactDslJsonBody.array(stringArrayName).stringValue(stringArrayValue).closeArray(); + if (Objects.nonNull(stringArray)) { + pactDslJsonBody.array(stringArrayName).stringValue(Arrays.toString(stringArray)).closeArray(); + } + return pactDslJsonBody; } - if (Objects.nonNull(stringArrayDefault)) { - pactDslJsonBody.array(stringArrayDefaultName).stringValue(stringArrayDefaultValue).closeArray(); + public ArrayDataTypes buildExpectedInstance() { + ArrayDataTypes object = new ArrayDataTypes(); + object.setStringArray(this.stringArray); + return object; } - return pactDslJsonBody; - } - public ArrayDataTypes buildExpectedInstance() { - ArrayDataTypes object = new ArrayDataTypes(); - object.setStringArray(this.stringArray); - object.setStringArrayDefault(this.stringArrayDefault); - return object; - } - - private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { - } + private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { + } } From 7d48c0aa5e8184fb03846b4f6c4b449523fec5a4 Mon Sep 17 00:00:00 2001 From: Miguel Escobar Date: Mon, 5 Feb 2024 22:22:21 -0600 Subject: [PATCH 3/5] add tests of arrays primitive data, wrappers and default values --- .../com/sngular/annotation/pact/Example.java | 3 + .../processor/PactDslProcessor.java | 95 +++-- .../annotation/processor/TypeArray.java | 88 ++++ .../mapping/BooleanArrayMapping.java | 34 ++ .../mapping/BooleanArrayWrapMapping.java | 34 ++ .../processor/mapping/ByteArrayMapping.java | 31 ++ .../mapping/ByteArrayWrapMapping.java | 31 ++ .../processor/mapping/CharArrayMapping.java | 6 +- .../mapping/CharArrayWrapMapping.java | 31 ++ .../processor/mapping/DoubleArrayMapping.java | 34 ++ .../mapping/DoubleArrayWrapMapping.java | 35 ++ .../processor/mapping/FloatArrayMapping.java | 38 ++ .../mapping/FloatArrayWrapMapping.java | 39 ++ .../processor/mapping/IntArrayMapping.java | 31 ++ .../mapping/IntArrayWrapMapping.java | 31 ++ .../processor/mapping/LongArrayMapping.java | 36 ++ .../mapping/LongArrayWrapMapping.java | 36 ++ .../processor/mapping/ShortArrayMapping.java | 31 ++ .../mapping/ShortArrayWrapMapping.java | 31 ++ .../processor/mapping/StringArrayMapping.java | 19 +- .../templates/templateDslBuilder.ftlh | 43 +- .../annotation/processor/ArrayTest.java | 4 + .../processor/RandomValueGenerationTest.java | 6 +- src/test/resources/basic/ArrayDataTypes.java | 135 +++++++ .../basic/ArrayDataTypesBuilder.java | 165 +++++++- .../basic/CharacterDataTypesBuilder.java | 1 + .../basic/NumericDataTypesBuilder.java | 6 + .../resources/date/DateDataTypesBuilder.java | 3 +- .../resources/random/NumericDataTypes.java | 18 - .../random/NumericDataTypesBuilder.java | 48 --- .../random/RandomValueGeneration.java | 282 +++++++++++++ .../random/RandomValueGenerationBuilder.java | 381 ++++++++++++++++++ 32 files changed, 1681 insertions(+), 125 deletions(-) create mode 100644 src/main/java/com/sngular/annotation/processor/TypeArray.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/LongArrayWrapMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/ShortArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/ShortArrayWrapMapping.java delete mode 100644 src/test/resources/random/NumericDataTypes.java delete mode 100644 src/test/resources/random/NumericDataTypesBuilder.java create mode 100644 src/test/resources/random/RandomValueGeneration.java create mode 100644 src/test/resources/random/RandomValueGenerationBuilder.java diff --git a/src/main/java/com/sngular/annotation/pact/Example.java b/src/main/java/com/sngular/annotation/pact/Example.java index a54f25a..f8202ab 100644 --- a/src/main/java/com/sngular/annotation/pact/Example.java +++ b/src/main/java/com/sngular/annotation/pact/Example.java @@ -18,5 +18,8 @@ String value() default ""; String format() default ""; + String[] array() default { }; + + long[] longArray() default { }; } diff --git a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java index 4ea8684..d85ec96 100644 --- a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java +++ b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java @@ -7,7 +7,13 @@ package com.sngular.annotation.processor; import java.io.IOException; -import java.util.*; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.Random; +import java.util.Set; import javax.annotation.processing.AbstractProcessor; import javax.annotation.processing.Processor; @@ -84,6 +90,22 @@ public class PactDslProcessor extends AbstractProcessor { .put("Date", new DateMapping()) .put("String[]", new StringArrayMapping()) .put("java.lang.String[]", new StringArrayMapping()) + .put("boolean[]", new BooleanArrayMapping()) + .put("java.lang.Boolean[]", new BooleanArrayWrapMapping()) + .put("byte[]", new ByteArrayMapping()) + .put("java.lang.Byte[]", new ByteArrayWrapMapping()) + .put("short[]", new ShortArrayMapping()) + .put("java.lang.Short[]", new ShortArrayWrapMapping()) + .put("int[]", new IntArrayMapping()) + .put("java.lang.Integer[]", new IntArrayWrapMapping()) + .put("long[]", new LongArrayMapping()) + .put("java.lang.Long[]", new LongArrayWrapMapping()) + .put("char[]", new CharArrayMapping()) + .put("java.lang.Character[]", new CharArrayWrapMapping()) + .put("float[]", new FloatArrayMapping()) + .put("java.lang.Float[]", new FloatArrayWrapMapping()) + .put("double[]", new DoubleArrayMapping()) + .put("java.lang.Double[]", new DoubleArrayWrapMapping()) .build(); private static final String CUSTOM_MODIFIERS = "customModifiers"; @@ -112,22 +134,52 @@ private static String getFormat(final Element fieldElement, final String default } private static String getFormatArray(final Element fieldElement, final String defaultFormat) { - final String[] value = fieldElement.getAnnotation(Example.class).array(); - return StringUtils.defaultIfEmpty(getStringFromArray(value), defaultFormat); - + String[] value = fieldElement.getAnnotation(Example.class).array(); + return StringUtils.defaultIfEmpty(PactDslProcessor.getStringFromArray(value,defaultFormat), defaultFormat); } - private static String getStringFromArray(String[] value) { + private static String getStringFromArray(String[] value, String defaultFormat) { String arrayToString = ""; - for (int i = 0; ; i++) { - if (i == value.length-1) { - return arrayToString += "\"" + value[i] + "\""; - } else { + for (int i = 0; i < value.length; i++) { + + switch (TypeArray.get(defaultFormat)) { + case STRING_ARRAY: + if (i == value.length-1) { + arrayToString += "\"" + value[i] + "\""; + } else { arrayToString += "\"" + value[i] + "\","; - } + } + break; + + case BOOLEAN_ARRAY: + case BYTE_ARRAY: + case SHORT_ARRAY: + case INT_ARRAY: + case LONG_ARRAY: + case FLOAT_ARRAY: + case DOUBLE_ARRAY: + if (i == value.length-1) { + arrayToString += value[i] ; + } else { + arrayToString += value[i] + ","; + } + break; + + case CHAR_ARRAY: + if (i == value.length-1) { + arrayToString += "'" + value[i] + "'"; + } else { + arrayToString += "'" + value[i] + "',"; + } + break; + + default: + arrayToString = "not_found_type_array"; + } } + return arrayToString; } @Override @@ -347,19 +399,20 @@ private DslSimpleField.DslSimpleFieldBuilder createSimpleFieldBuilder(final Elem .empty(false); if (Objects.nonNull(fieldElement.getAnnotation(DslExclude.class))) { - simpleFieldBuilder.empty(true); - - } else if (fieldElement.getAnnotation(Example.class).array().length != 0){ - simpleFieldBuilder.defaultValue(getFormatArray(fieldElement, mapping.getFieldType())); - simpleFieldBuilder.formatValue(null); + simpleFieldBuilder.empty(true); } else if (Objects.nonNull(fieldElement.getAnnotation(Example.class))) { - simpleFieldBuilder.defaultValue(getDefaultValue(fieldElement, mapping.getFieldType())); - simpleFieldBuilder.formatValue(getFormat(fieldElement, mapping.getFormatValue())); + if (fieldElement.getAnnotation(Example.class).array().length != 0) { + simpleFieldBuilder.defaultValue(getFormatArray(fieldElement, mapping.getFieldType())); + simpleFieldBuilder.formatValue(null); + } else { + simpleFieldBuilder.defaultValue(getDefaultValue(fieldElement, mapping.getFieldType())); + simpleFieldBuilder.formatValue(getFormat(fieldElement, mapping.getFormatValue())); + } } else { - simpleFieldBuilder.defaultValue(mapping.getRandomDefaultValue(validationBuilder.build(), randomSource)); - simpleFieldBuilder.formatValue(mapping.getFormatValue()); + simpleFieldBuilder.defaultValue(mapping.getRandomDefaultValue(validationBuilder.build(), randomSource)); + simpleFieldBuilder.formatValue(mapping.getFormatValue()); } return simpleFieldBuilder; @@ -394,10 +447,6 @@ private Optional> extractMappingByType(final Element element) { final var type = element.asType(); - Object obj = type.getKind(); - - String typeArray = type.toString(); - return switch (type.getKind()) { case BOOLEAN -> Optional.of(TYPE_MAPPING.get("boolean")); case BYTE -> Optional.of(TYPE_MAPPING.get("byte")); diff --git a/src/main/java/com/sngular/annotation/processor/TypeArray.java b/src/main/java/com/sngular/annotation/processor/TypeArray.java new file mode 100644 index 0000000..266b0b9 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/TypeArray.java @@ -0,0 +1,88 @@ +package com.sngular.annotation.processor; + +import java.util.Arrays; +import java.util.Optional; + + +/** Represents an enum of array types. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public enum TypeArray { + + /** + * An array type {@code String[]}. + */ + STRING_ARRAY("","String[]"), + /** + * An array type {@code boolean[]}. + */ + BOOLEAN_ARRAY("boolean[]","Boolean[]"), + + /** + * An array type {@code byte[]}. + */ + BYTE_ARRAY("byte[]","Byte[]"), + + /** + * An array type {@code short[]}. + */ + SHORT_ARRAY("short[]","Short[]"), + + /** + * An array type {@code int[]}. + */ + INT_ARRAY("int[]","Integer[]"), + + /** + * An array type {@code long[]}. + */ + LONG_ARRAY("long[]","Long[]"), + + /** + * An array type {@code char[]}. + */ + CHAR_ARRAY("char[]","Character[]"), + + /** + * An array type {@code float[]}. + */ + FLOAT_ARRAY("float[]","Float[]"), + + /** + * An array type {@code double[]}. + */ + DOUBLE_ARRAY("double[]","Double[]"); + + private String primitiveName; + private String objectName; + + TypeArray(String primitiveName, String objectName) { + this.primitiveName = primitiveName; + this.objectName = objectName; + } + /** + * {@return primitive name} + */ + public String getPrimitiveName() { + return primitiveName; + } + + /** + * {@return object name} + */ + public String getobjectName() { + return objectName; + } + /** + * {@return TypeArray value that matches typeString} + */ + public static TypeArray get(String typeString) { + Optional op = Arrays.stream(TypeArray.values()) + .filter(accStatus -> accStatus.primitiveName.equals(typeString) + || accStatus.objectName.equals(typeString)) + .findFirst(); + + return op.get(); + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java new file mode 100644 index 0000000..c0d1682 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java @@ -0,0 +1,34 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; +import org.apache.commons.rng.simple.RandomSource; + +/** Represents an array of boolean. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class BooleanArrayMapping implements TypeMapping { + + private final UniformRandomProvider uniformRandomProvider = RandomSource.XO_RO_SHI_RO_128_PP.create(); + + @Override + public final String getFieldType() { + return "boolean[]"; + } + + @Override + public final String getFunctionType() { + return "booleanArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "booleanArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "true"; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java new file mode 100644 index 0000000..f50412b --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java @@ -0,0 +1,34 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; +import org.apache.commons.rng.simple.RandomSource; + +/** Represents an array of Boolean. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class BooleanArrayWrapMapping implements TypeMapping { + + private final UniformRandomProvider uniformRandomProvider = RandomSource.XO_RO_SHI_RO_128_PP.create(); + + @Override + public final String getFieldType() { + return "Boolean[]"; + } + + @Override + public final String getFunctionType() { + return "booleanArrayWrapType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "booleanArrayWrapValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "false"; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java new file mode 100644 index 0000000..332a113 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java @@ -0,0 +1,31 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +/** Represents an array of byte. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class ByteArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "byte[]"; + } + + @Override + public final String getFunctionType() { + return "byteArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "byteArrayValue"; + } + + @Override + public final Integer getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return -128; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java new file mode 100644 index 0000000..4465077 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java @@ -0,0 +1,31 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +/** Represents an array of Byte. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class ByteArrayWrapMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "Byte[]"; + } + + @Override + public final String getFunctionType() { + return "byteArrayWrapType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "byteArrayWrapValue"; + } + + @Override + public final Integer getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return 127; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java index d56ed25..6b61e32 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java @@ -2,9 +2,10 @@ import com.sngular.annotation.processor.model.FieldValidations; import org.apache.commons.rng.UniformRandomProvider; +import org.apache.commons.lang3.RandomStringUtils; /** Represents an array of char. - * @author Miguel ANgel Escobar + * @author Miguel Angel Escobar * @version 1.0 */ public class CharArrayMapping implements TypeMapping { @@ -25,7 +26,6 @@ public final String getFunctionOnlyValue() { @Override public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { - //return RandomStringUtils.randomAlphanumeric(1); - return "x"; + return "'x'"; } } \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java new file mode 100644 index 0000000..4f9ac35 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java @@ -0,0 +1,31 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; +import org.apache.commons.lang3.RandomStringUtils; + +/** Represents an array of Character. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class CharArrayWrapMapping implements TypeMapping { + @Override + public final String getFieldType() { + return "Character[]"; + } + + @Override + public final String getFunctionType() { + return "charArrayWrapType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "charArrayWrapValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "'X'"; + } +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java new file mode 100644 index 0000000..00a3c9b --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java @@ -0,0 +1,34 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.commons.rng.UniformRandomProvider; +import java.util.Objects; + +public class DoubleArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "double[]"; + } + + @Override + public final String getFunctionType() { + return "floatArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "floatArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "-1234567890123456789012345678901234567890.79769313486232D"; + } + + @Override + public final String getSuffixValue() { + return "D"; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java new file mode 100644 index 0000000..e0ca2fe --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java @@ -0,0 +1,35 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.commons.rng.UniformRandomProvider; + +import java.util.Objects; + +public class DoubleArrayWrapMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "Double[]"; + } + + @Override + public final String getFunctionType() { + return "doubleArrayWrapType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "doubleArrayWrapValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "1234567890123456789012345678901234567890.79769313486232D"; + } + + @Override + public final String getSuffixValue() { + return "D"; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java new file mode 100644 index 0000000..97b26ed --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java @@ -0,0 +1,38 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.commons.rng.UniformRandomProvider; +import java.util.Objects; + +/** Represents an array of float. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class FloatArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "float[]"; + } + + @Override + public final String getFunctionType() { + return "floatArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "floatArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "-123456789012345678901234567890.402823F"; + } + + @Override + public final String getSuffixValue() { + return "F"; + } +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java new file mode 100644 index 0000000..ad6b740 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java @@ -0,0 +1,39 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.commons.rng.UniformRandomProvider; + +import java.util.Objects; + +/** Represents an array of Float. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class FloatArrayWrapMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "Float[]"; + } + + @Override + public final String getFunctionType() { + return "floatArrayWrapType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "floatArrayWrapValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "123456789012345678901234567890.402823F"; + } + + @Override + public final String getSuffixValue() { + return "F"; + } +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java new file mode 100644 index 0000000..d6bd157 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java @@ -0,0 +1,31 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +/** Represents an array of int. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class IntArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "int[]"; + } + + @Override + public final String getFunctionType() { + return "intArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "intArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "-2147483648"; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java new file mode 100644 index 0000000..7ea2937 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java @@ -0,0 +1,31 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +/** Represents an array of int. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class IntArrayWrapMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "Integer[]"; + } + + @Override + public final String getFunctionType() { + return "intArrayWrapType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "intArrayWrapValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "2147483647"; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java new file mode 100644 index 0000000..e432960 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java @@ -0,0 +1,36 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +/** Represents an array of long. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class LongArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "long[]"; + } + + @Override + public final String getFunctionType() { + return "longArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "longArrayType"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "-9223372036854775808L"; + } + + @Override + public final String getSuffixValue() { + return "L"; + } +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/LongArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayWrapMapping.java new file mode 100644 index 0000000..12c6901 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayWrapMapping.java @@ -0,0 +1,36 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +/** Represents an array of Long. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class LongArrayWrapMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "Long[]"; + } + + @Override + public final String getFunctionType() { + return "longArrayWrapType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "longArrayWrapType"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "9223372036854775807L"; + } + + @Override + public final String getSuffixValue() { + return "L"; + } +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayMapping.java new file mode 100644 index 0000000..06a466d --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayMapping.java @@ -0,0 +1,31 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +/** Represents an array of short. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class ShortArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "short[]"; + } + + @Override + public final String getFunctionType() { + return "shortArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "shortArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "-32768"; + } +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayWrapMapping.java new file mode 100644 index 0000000..70d6685 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/ShortArrayWrapMapping.java @@ -0,0 +1,31 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +/** Represents an array of Short. + * @author Miguel Angel Escobar + * @version 1.0 + */ +public class ShortArrayWrapMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "Short[]"; + } + + @Override + public final String getFunctionType() { + return "shortArrayWrapType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "shortArrayWrapValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "32767"; + } +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java index e5c859a..2d92aad 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/StringArrayMapping.java @@ -13,6 +13,11 @@ import java.util.Objects; + +/** Represents an array of String. + * @author Miguel Angel Escobar + * @version 1.0 + */ public class StringArrayMapping implements TypeMapping { public static final int DEFAULT_MAX = 15; @@ -36,18 +41,6 @@ public final String getFunctionOnlyValue() { @Override public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { - final int length; - - if (Objects.nonNull(fieldValidations) && ObjectUtils.anyNotNull(fieldValidations.getMin(), fieldValidations.getMax())) { - final int minLength = ObjectUtils.defaultIfNull(fieldValidations.getMin(), DEFAULT_MIN); - final int maxLength = ObjectUtils.defaultIfNull(fieldValidations.getMax(), DEFAULT_MAX); - - length = uniformRandomProvider.nextInt(minLength, maxLength); - } else { - length = uniformRandomProvider.nextInt(DEFAULT_MIN, DEFAULT_MAX); - } - - //return RandomStringUtils.randomAlphanumeric(length); - return "RandomDefaultValue"; // String en duro para las pruebas + return "\"defaultValue\""; } } diff --git a/src/main/resources/templates/templateDslBuilder.ftlh b/src/main/resources/templates/templateDslBuilder.ftlh index b10ed0b..fdc0276 100644 --- a/src/main/resources/templates/templateDslBuilder.ftlh +++ b/src/main/resources/templates/templateDslBuilder.ftlh @@ -1,12 +1,25 @@ <#assign constructor = false> <#macro writeAttrField field> <#if field.functionByType??> - <#if field.fieldType == "String[]"> - ${field.fieldType} ${field.name} = {${field.defaultValue?no_esc}}; - String ${field.name}Name = "${field.name}"; - <#elseif field.fieldType == "char[]"> - String[] ${field.name} = {"${field.defaultValue?string}"}; - String ${field.name}Name = "${field.name}"; + <#if field.fieldType == "String[]" + || field.fieldType == "char[]" || field.fieldType == "Character[]" + || field.fieldType == "boolean[]" || field.fieldType == "Boolean[]" + || field.fieldType == "byte[]" || field.fieldType == "Byte[]" + || field.fieldType == "short[]" || field.fieldType == "Short[]" + || field.fieldType == "int[]" || field.fieldType == "Integer[]"> + + ${field.fieldType} ${field.name} = {${field.defaultValue?no_esc}}; + String ${field.name}Name = "${field.name}"; + <#elseif field.fieldType == "double[]" || field.fieldType == "Double[]"> + + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = Arrays.stream(in${field.name?cap_first}).mapToDouble(Double::parseDouble).toArray(); + String ${field.name}Name = "${field.name}"; + <#elseif field.fieldType == "long[]" || field.fieldType == "Long[]"> + + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = Arrays.stream(in${field.name?cap_first}).mapToLong(Long::parseLong).toArray(); + String ${field.name}Name = "${field.name}"; <#elseif field.fieldType == "boolean"> ${field.fieldType} ${field.name} = ${field.defaultValue?string}; <#elseif field.fieldType == "char"> @@ -52,8 +65,6 @@ <#if field.functionByType??> <#if field.fieldType == "char"> public ${builderName}Builder set${field.name?cap_first}(final String ${field.name}) { - <#elseif field.fieldType == "char[]"> - public ${builderName}Builder set${field.name?cap_first}(final String[] ${field.name}) { <#else > public ${builderName}Builder set${field.name?cap_first}(final ${field.fieldType?no_esc} ${field.name}) { @@ -77,8 +88,6 @@ <#if !field.empty> <#if field.fieldType == "char"> object.set${field.name?cap_first}(this.${field.name}.charAt(0)); - <#elseif field.fieldType == "char[]"> - object.set${field.name?cap_first}("a".toCharArray()); <#else > object.set${field.name?cap_first}(this.${field.name}); @@ -122,10 +131,16 @@ pactDslJsonBody.${field.functionByType}("${field.name}", (double) ${field.name}); <#elseif field.fieldType == "byte"> pactDslJsonBody.${field.functionByType}("${field.name}", (int) ${field.name}); - <#elseif field.fieldType == "String[]"> - pactDslJsonBody.array(stringArrayName).stringValue(Arrays.toString(stringArray)).closeArray(); - <#elseif field.fieldType == "char[]"> - pactDslJsonBody.array(${field.name}Name).stringValue(${field.name}Value).closeArray(); + <#elseif field.fieldType == "String[]" + || field.fieldType == "char[]" || field.fieldType == "Character[]" + || field.fieldType == "boolean[]" || field.fieldType == "Boolean[]" + || field.fieldType == "byte[]" || field.fieldType == "Byte[]" + || field.fieldType == "short[]" || field.fieldType == "Short[]" + || field.fieldType == "int[]" || field.fieldType == "Integer[]" + || field.fieldType == "long[]" || field.fieldType == "Long[]" + || field.fieldType == "float[]" || field.fieldType == "Float[]" + || field.fieldType == "double[]" || field.fieldType == "Double[]"> + pactDslJsonBody.array(${field.name}Name).stringValue(Arrays.toString(${field.name})).closeArray(); <#else> pactDslJsonBody.${field.functionByType}("${field.name}", ${field.name}); diff --git a/src/test/java/com/sngular/annotation/processor/ArrayTest.java b/src/test/java/com/sngular/annotation/processor/ArrayTest.java index 0785307..a55b5c4 100644 --- a/src/test/java/com/sngular/annotation/processor/ArrayTest.java +++ b/src/test/java/com/sngular/annotation/processor/ArrayTest.java @@ -7,6 +7,10 @@ import static com.google.testing.compile.CompilationSubject.assertThat; import static com.google.testing.compile.Compiler.javac; +/** Represents a test of array types. + * @author Miguel Angel Escobar + * @version 1.0 + */ public class ArrayTest { @Test diff --git a/src/test/java/com/sngular/annotation/processor/RandomValueGenerationTest.java b/src/test/java/com/sngular/annotation/processor/RandomValueGenerationTest.java index 8ee0e0c..de1577e 100644 --- a/src/test/java/com/sngular/annotation/processor/RandomValueGenerationTest.java +++ b/src/test/java/com/sngular/annotation/processor/RandomValueGenerationTest.java @@ -14,10 +14,10 @@ public class RandomValueGenerationTest { public void numericDataTypes() { var theMock = Mockito.mock(RestorableUniformRandomProvider.class); Mockito.when(theMock.nextInt(0, Integer.MAX_VALUE)).thenReturn(18); - Compilation compilation = Compiler.javac().withProcessors( new PactDslProcessor(theMock)).compile(JavaFileObjects.forResource("random/NumericDataTypes.java")); + Compilation compilation = Compiler.javac().withProcessors( new PactDslProcessor(theMock)).compile(JavaFileObjects.forResource("random/RandomValueGeneration.java")); CompilationSubject.assertThat(compilation).succeeded(); - CompilationSubject.assertThat(compilation).generatedSourceFile("com/sngular/annotation/examples/NumericDataTypesBuilder") - .hasSourceEquivalentTo(JavaFileObjects.forResource("random/NumericDataTypesBuilder.java")); + CompilationSubject.assertThat(compilation).generatedSourceFile("com/sngular/annotation/examples/RandomValueGenerationBuilder") + .hasSourceEquivalentTo(JavaFileObjects.forResource("random/RandomValueGenerationBuilder.java")); } } diff --git a/src/test/resources/basic/ArrayDataTypes.java b/src/test/resources/basic/ArrayDataTypes.java index e2bb639..a115df3 100644 --- a/src/test/resources/basic/ArrayDataTypes.java +++ b/src/test/resources/basic/ArrayDataTypes.java @@ -4,6 +4,8 @@ import com.sngular.annotation.pact.PactDslBodyBuilder; import com.sngular.annotation.pact.DslExclude; +import java.util.Optional; + @PactDslBodyBuilder public class ArrayDataTypes { @@ -13,6 +15,42 @@ public class ArrayDataTypes { @DslExclude private String[] stringArrayExclude; + @Example(array = {"true","false"}) + private boolean[] booleanArray; + + @Example(array = {"false","true"}) + private Boolean[] booleanArrayWrap; + + @Example(array = {"1","2","3","4","5"}) + private byte[] byteArray; + + @Example(array = {"6","7","8","9","10"}) + private Byte[] byteArrayWrap; + + @Example(array = {"11","12","13","14","15"} ) + private short[] shortArray; + + @Example(array = {"16","17","18","19","20"} ) + private Short[] shortArrayWrap; + + @Example(array = {"-2147483648"} ) + private int[] intArray; + + @Example(array = {"2147483647"} ) + private Integer[] intArrayWrap; + + @Example(array = {"j","k","l"} ) + private char[] charArray; + + @Example(array = {"m","n","o"} ) + private Character[] charArrayWrap; + + @Example(array = {"-123456789012345678901234567890.402823L"} ) + private long[] longArray; + + @Example(array = {"-1234567890123456789012345678901234567890.79769313486232D"} ) + private double[] doubleArray; + public String[] getStringArray() { return stringArray; } @@ -28,4 +66,101 @@ public String[] getStringArrayExclude() { public void setStringArrayExclude(String[] stringArrayExclude) { this.stringArrayExclude = stringArrayExclude; } + + public boolean[] getBooleanArray() { + return booleanArray; + } + + public void setBooleanArray(boolean[] booleanArray) { + this.booleanArray = booleanArray; + } + + public Boolean[] getBooleanArrayWrap() { + return booleanArrayWrap; + } + + public void setBooleanArrayWrap(Boolean[] booleanArrayWrap) { + this.booleanArrayWrap = booleanArrayWrap; + } + + public byte[] getByteArray() { + return byteArray; + } + + public void setByteArray(byte[] byteArray) { + this.byteArray = byteArray; + } + + public Byte[] getByteArrayWrap() { + return byteArrayWrap; + } + + public void setByteArrayWrap(Byte[] byteArrayWrap) { + this.byteArrayWrap = byteArrayWrap; + } + + public short[] getShortArray() { + return shortArray; + } + + public void setShortArray(short[] shortArray) { + this.shortArray = shortArray; + } + + public Short[] getShortArrayWrap() { + return shortArrayWrap; + } + + public void setShortArrayWrap(Short[] shortArrayWrap) { + this.shortArrayWrap = shortArrayWrap; + } + + public int[] getIntArray() { + return intArray; + } + + public void setIntArray(int[] intArray) { + this.intArray = intArray; + } + + public Integer[] getIntArrayWrap() { + return intArrayWrap; + } + + public void setIntArrayWrap(Integer[] intArrayWrap) { + this.intArrayWrap = intArrayWrap; + } + + public char[] getCharArray() { + return charArray; + } + + public void setCharArray(char[] charArray) { + this.charArray = charArray; + } + + public Character[] getCharArrayWrap() { + return charArrayWrap; + } + + public void setCharArrayWrap(Character[] charArrayWrap) { + this.charArrayWrap = charArrayWrap; + } + + public long[] getLongArray() { + return longArray; + } + + public void setLongArray(long[] longArray) { + this.longArray = longArray; + } + + public double[] getDoubleArray() { + return doubleArray; + } + + public void setDoubleArray(double[] doubleArray) { + this.doubleArray = doubleArray; + } + } \ No newline at end of file diff --git a/src/test/resources/basic/ArrayDataTypesBuilder.java b/src/test/resources/basic/ArrayDataTypesBuilder.java index 3e7dbfb..6d345fc 100644 --- a/src/test/resources/basic/ArrayDataTypesBuilder.java +++ b/src/test/resources/basic/ArrayDataTypesBuilder.java @@ -26,10 +26,112 @@ public class ArrayDataTypesBuilder { String[] stringArray = {"abc","bef","ghi"}; String stringArrayName = "stringArray"; + boolean[] booleanArray = {true, false}; + String booleanArrayName = "booleanArray"; + + Boolean[] booleanArrayWrap = {false, true}; + String booleanArrayWrapName = "booleanArrayWrap"; + + byte[] byteArray = {1,2,3,4,5}; + String byteArrayName = "byteArray"; + + Byte[] byteArrayWrap = {6,7,8,9,10}; + String byteArrayWrapName = "byteArrayWrap"; + + short[] shortArray = {11,12,13,14,15}; + String shortArrayName = "shortArray"; + + Short[] shortArrayWrap = {16,17,18,19,20}; + String shortArrayWrapName = "shortArrayWrap"; + + int[] intArray = {-2147483648}; + String intArrayName = "intArray"; + + Integer[] intArrayWrap = {2147483647}; + String intArrayWrapName = "intArrayWrap"; + + char[] charArray = {'j','k','l'}; + String charArrayName = "charArray"; + + Character[] charArrayWrap = {'m','n','o'}; + String charArrayWrapName = "charArrayWrap"; + + // se requiere "inLongArray" para poder crear "longArray", ya que si se pasa + // el valor String directo a long[], tenemos conflicto + String[] inLongArray = {"-123456789012345678901234567890.402823L"}; + long[] longArray = Arrays.stream(inLongArray).mapToLong(Long::parseLong).toArray(); + String longArrayName = "longArray"; + + String[] inDoubleArray = {"-1234567890123456789012345678901234567890.79769313486232D"}; + double[] doubleArray = Arrays.stream(inDoubleArray).mapToDouble(Double::parseDouble).toArray(); + String doubleArrayName = "doubleArray"; + + public ArrayDataTypesBuilder setStringArray(final String[] stringArray) { this.stringArray = stringArray; return this; - } + } + + public ArrayDataTypesBuilder setBooleanArray(final boolean[] booleanArray) { + this.booleanArray = booleanArray; + return this; + } + + public ArrayDataTypesBuilder setBooleanArrayWrap(final Boolean[] booleanArrayWrap) { + this.booleanArrayWrap = booleanArrayWrap; + return this; + } + + public ArrayDataTypesBuilder setByteArray(final byte[] byteArray) { + this.byteArray = byteArray; + return this; + } + + public ArrayDataTypesBuilder setByteArrayWrap(final Byte[] byteArrayWrap) { + this.byteArrayWrap = byteArrayWrap; + return this; + } + + public ArrayDataTypesBuilder setShortArray(final short[] shortArray) { + this.shortArray = shortArray; + return this; + } + + public ArrayDataTypesBuilder setShortArrayWrap(final Short[] shortArrayWrap) { + this.shortArrayWrap = shortArrayWrap; + return this; + } + + public ArrayDataTypesBuilder setIntArray(final int[] intArray) { + this.intArray = intArray; + return this; + } + + public ArrayDataTypesBuilder setIntArrayWrap(final Integer[] intArrayWrap) { + this.intArrayWrap = intArrayWrap; + return this; + } + + public ArrayDataTypesBuilder setCharArray(final char[] charArray) { + this.charArray = charArray; + return this; + } + + public ArrayDataTypesBuilder setCharArrayWrap(final Character[] charArrayWrap) { + this.charArrayWrap = charArrayWrap; + return this; + } + + public ArrayDataTypesBuilder setLongArray(final long[] longArray) { + this.longArray = longArray; + return this; + } + + public ArrayDataTypesBuilder setDoubleArray(final double[] doubleArray) { + this.doubleArray = doubleArray; + return this; + } + public DslPart build() { PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); @@ -37,12 +139,73 @@ public DslPart build() { if (Objects.nonNull(stringArray)) { pactDslJsonBody.array(stringArrayName).stringValue(Arrays.toString(stringArray)).closeArray(); } + + if (Objects.nonNull(booleanArray)) { + pactDslJsonBody.array(booleanArrayName).stringValue(Arrays.toString(booleanArray)).closeArray(); + } + + if (Objects.nonNull(booleanArrayWrap)) { + pactDslJsonBody.array(booleanArrayWrapName).stringValue(Arrays.toString(booleanArrayWrap)).closeArray(); + } + + if (Objects.nonNull(byteArray)) { + pactDslJsonBody.array(byteArrayName).stringValue(Arrays.toString(byteArray)).closeArray(); + } + + if (Objects.nonNull(byteArrayWrap)) { + pactDslJsonBody.array(byteArrayWrapName).stringValue(Arrays.toString(byteArrayWrap)).closeArray(); + } + + if (Objects.nonNull(shortArray)) { + pactDslJsonBody.array(shortArrayName).stringValue(Arrays.toString(shortArray)).closeArray(); + } + + if (Objects.nonNull(shortArrayWrap)) { + pactDslJsonBody.array(shortArrayWrapName).stringValue(Arrays.toString(shortArrayWrap)).closeArray(); + } + + if (Objects.nonNull(intArray)) { + pactDslJsonBody.array(intArrayName).stringValue(Arrays.toString(intArray)).closeArray(); + } + + if (Objects.nonNull(intArrayWrap)) { + pactDslJsonBody.array(intArrayWrapName).stringValue(Arrays.toString(intArrayWrap)).closeArray(); + } + + if (Objects.nonNull(charArray)) { + pactDslJsonBody.array(charArrayName).stringValue(Arrays.toString(charArray)).closeArray(); + } + + if (Objects.nonNull(charArrayWrap)) { + pactDslJsonBody.array(charArrayWrapName).stringValue(Arrays.toString(charArrayWrap)).closeArray(); + } + + if (Objects.nonNull(longArray)) { + pactDslJsonBody.array(longArrayName).stringValue(Arrays.toString(longArray)).closeArray(); + } + + if (Objects.nonNull(doubleArray)) { + pactDslJsonBody.array(doubleArrayName).stringValue(Arrays.toString(doubleArray)).closeArray(); + } return pactDslJsonBody; } public ArrayDataTypes buildExpectedInstance() { ArrayDataTypes object = new ArrayDataTypes(); object.setStringArray(this.stringArray); + object.setBooleanArray(this.booleanArray); + object.setBooleanArrayWrap(this.booleanArrayWrap); + object.setByteArray(this.byteArray); + object.setByteArrayWrap(this.byteArrayWrap); + object.setShortArray(this.shortArray); + object.setShortArrayWrap(this.shortArrayWrap); + object.setIntArray(this.intArray); + object.setIntArrayWrap(this.intArrayWrap); + object.setCharArray(this.charArray); + object.setCharArrayWrap(this.charArrayWrap); + object.setLongArray(this.longArray); + object.setDoubleArray(this.doubleArray); + return object; } diff --git a/src/test/resources/basic/CharacterDataTypesBuilder.java b/src/test/resources/basic/CharacterDataTypesBuilder.java index 6f3cec0..204a8af 100644 --- a/src/test/resources/basic/CharacterDataTypesBuilder.java +++ b/src/test/resources/basic/CharacterDataTypesBuilder.java @@ -19,6 +19,7 @@ import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue; import com.sngular.annotation.processor.mapping.CustomDslModifier; import com.sngular.resources.basic.CharacterDataTypes; +import java.util.Arrays; public class CharacterDataTypesBuilder { String name = "nameExample"; diff --git a/src/test/resources/basic/NumericDataTypesBuilder.java b/src/test/resources/basic/NumericDataTypesBuilder.java index 31acc8b..42a8690 100644 --- a/src/test/resources/basic/NumericDataTypesBuilder.java +++ b/src/test/resources/basic/NumericDataTypesBuilder.java @@ -19,6 +19,7 @@ import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue; import com.sngular.annotation.processor.mapping.CustomDslModifier; import com.sngular.resources.basic.NumericDataTypes; +import java.util.Arrays; public class NumericDataTypesBuilder { @@ -122,18 +123,23 @@ public NumericDataTypesBuilder setBigDecimalObject(final BigDecimal bigDecimalOb public DslPart build() { PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); + if (Objects.nonNull(integer)) { pactDslJsonBody.integerType("integer", integer); } + if (Objects.nonNull(primitiveInt)) { pactDslJsonBody.integerType("primitiveInt", primitiveInt); } + if (Objects.nonNull(longObject)) { pactDslJsonBody.integerType("longObject", longObject); } + if (Objects.nonNull(primitiveLong)) { pactDslJsonBody.integerType("primitiveLong", primitiveLong); } + if (Objects.nonNull(floatObject)) { pactDslJsonBody.decimalType("floatObject", (double) floatObject); } diff --git a/src/test/resources/date/DateDataTypesBuilder.java b/src/test/resources/date/DateDataTypesBuilder.java index bfb096e..ad0b142 100644 --- a/src/test/resources/date/DateDataTypesBuilder.java +++ b/src/test/resources/date/DateDataTypesBuilder.java @@ -19,8 +19,7 @@ import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue; import com.sngular.annotation.processor.mapping.CustomDslModifier; import com.sngular.annotation.examples.DateDataTypes; - - +import java.util.Arrays; public class DateDataTypesBuilder { ZonedDateTime formattedZoneDateTime = ZonedDateTime.parse("23/04/2023 12:00", DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm")); ZonedDateTime defaultFormatZoneDateTime = ZonedDateTime.parse("2023-12-03T10:15:30+01:00[Europe/Madrid]", DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss[.SSSSSS][.SSS]XXX['['VV']']")); diff --git a/src/test/resources/random/NumericDataTypes.java b/src/test/resources/random/NumericDataTypes.java deleted file mode 100644 index f063ab3..0000000 --- a/src/test/resources/random/NumericDataTypes.java +++ /dev/null @@ -1,18 +0,0 @@ -package com.sngular.annotation.examples; - -import com.sngular.annotation.pact.Example; -import com.sngular.annotation.pact.PactDslBodyBuilder; - -@PactDslBodyBuilder -public class NumericDataTypes { - - private int age; - - protected int getAge() { - return age; - } - - protected void setAge(final int age) { - this.age = age; - } -} \ No newline at end of file diff --git a/src/test/resources/random/NumericDataTypesBuilder.java b/src/test/resources/random/NumericDataTypesBuilder.java deleted file mode 100644 index 61cd59c..0000000 --- a/src/test/resources/random/NumericDataTypesBuilder.java +++ /dev/null @@ -1,48 +0,0 @@ -package com.sngular.annotation.examples; - -import java.math.BigDecimal; -import java.math.BigInteger; -import java.text.DateFormat; -import java.text.ParseException; -import java.text.SimpleDateFormat; -import java.time.Instant; -import java.time.LocalDate; -import java.time.ZonedDateTime; -import java.time.format.DateTimeFormatter; -import java.util.Date; -import java.util.List; -import java.util.Objects; - -import au.com.dius.pact.consumer.dsl.DslPart; -import au.com.dius.pact.consumer.dsl.PactDslJsonArray; -import au.com.dius.pact.consumer.dsl.PactDslJsonBody; -import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue; -import com.sngular.annotation.processor.mapping.CustomDslModifier; -import com.sngular.annotation.examples.NumericDataTypes; - -public class NumericDataTypesBuilder { - int age = 0; - - public NumericDataTypesBuilder setAge(final int age) { - this.age = age; - return this; - } - - public DslPart build() { - PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); - if (Objects.nonNull(age)) { - pactDslJsonBody.integerType("age", age); - } - - return pactDslJsonBody; - } - public NumericDataTypes buildExpectedInstance() { - NumericDataTypes object = new NumericDataTypes(); - object.setAge(this.age); - return object; - } - private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { - } - -} - diff --git a/src/test/resources/random/RandomValueGeneration.java b/src/test/resources/random/RandomValueGeneration.java new file mode 100644 index 0000000..a112ffd --- /dev/null +++ b/src/test/resources/random/RandomValueGeneration.java @@ -0,0 +1,282 @@ +package com.sngular.annotation.examples; + +import com.sngular.annotation.pact.Example; +import com.sngular.annotation.pact.PactDslBodyBuilder; + +import java.math.BigDecimal; +import java.math.BigInteger; + +@PactDslBodyBuilder +public class RandomValueGeneration { + + public Integer integer; + + public int primitiveInt; + + public Long longObject; + + public long primitiveLong; + + public Float floatObject; + + public float primitiveFloat; + + public Double doubleObject; + + public double primitiveDouble; + + public Short shortObject; + + public short primitiveShort; + + public Byte byteObject; + + public byte primitiveByte; + + public BigInteger bigIntegerObject; + + public BigDecimal bigDecimalObject; + + public String[] stringArray; + + public boolean[] booleanArray; + + public Boolean[] booleanArrayWrap; + + public byte[] byteArray; + + public Byte[] byteArrayWrap; + + public short[] shortArray; + + public Short[] shortArrayWrap; + + public int[] intArray; + + public Integer[] intArrayWrap; + + public char[] charArray; + + public Character[] charArrayWrap; + + public long[] longArray; + + public double[] doubleArray; + + + public Integer getInteger() { + return integer; + } + + public void setInteger(final Integer integer) { + this.integer = integer; + } + + public int getPrimitiveInt() { + return primitiveInt; + } + + public void setPrimitiveInt(final int primitiveInt) { + this.primitiveInt = primitiveInt; + } + + public Long getLongObject() { + return longObject; + } + + public void setLongObject(final Long longObject) { + this.longObject = longObject; + } + + public long getPrimitiveLong() { + return primitiveLong; + } + + public void setPrimitiveLong(final long primitiveLong) { + this.primitiveLong = primitiveLong; + } + + public Float getFloatObject() { + return floatObject; + } + + public void setFloatObject(Float floatObject) { + this.floatObject = floatObject; + } + + public float getPrimitiveFloat() { + return primitiveFloat; + } + + public void setPrimitiveFloat(float primitiveFloat) { + this.primitiveFloat = primitiveFloat; + } + + public Double getDoubleObject() { + return doubleObject; + } + + public void setDoubleObject(Double doubleObject) { + this.doubleObject = doubleObject; + } + + public double getPrimitiveDouble() { + return primitiveDouble; + } + + public void setPrimitiveDouble(double primitiveDouble) { + this.primitiveDouble = primitiveDouble; + } + + public Short getShortObject() { + return shortObject; + } + + public void setShortObject(Short shortObject) { + this.shortObject = shortObject; + } + + public short getPrimitiveShort() { + return primitiveShort; + } + + public void setPrimitiveShort(short primitiveShort) { + this.primitiveShort = primitiveShort; + } + + public Byte getByteObject() { + return byteObject; + } + + public void setByteObject(Byte byteObject) { + this.byteObject = byteObject; + } + + public byte getPrimitiveByte() { + return primitiveByte; + } + + public void setPrimitiveByte(byte primitiveByte) { + this.primitiveByte = primitiveByte; + } + + public BigInteger getBigIntegerObject() { + return bigIntegerObject; + } + + public void setBigIntegerObject(BigInteger bigIntegerObject) { + this.bigIntegerObject = bigIntegerObject; + } + + public BigDecimal getBigDecimalObject() { + return bigDecimalObject; + } + + public void setBigDecimalObject(BigDecimal bigDecimalObject) { + this.bigDecimalObject = bigDecimalObject; + } + + public String[] getStringArray() { + return stringArray; + } + + public void setStringArray(String[] stringArray) { + this.stringArray = stringArray; + } + + public boolean[] getBooleanArray() { + return booleanArray; + } + + public void setBooleanArray(boolean[] booleanArray) { + this.booleanArray = booleanArray; + } + + public Boolean[] getBooleanArrayWrap() { + return booleanArrayWrap; + } + + public void setBooleanArrayWrap(Boolean[] booleanArrayWrap) { + this.booleanArrayWrap = booleanArrayWrap; + } + + public byte[] getByteArray() { + return byteArray; + } + + public void setByteArray(byte[] byteArray) { + this.byteArray = byteArray; + } + + public Byte[] getByteArrayWrap() { + return byteArrayWrap; + } + + public void setByteArrayWrap(Byte[] byteArrayWrap) { + this.byteArrayWrap = byteArrayWrap; + } + + public short[] getShortArray() { + return shortArray; + } + + public void setShortArray(short[] shortArray) { + this.shortArray = shortArray; + } + + public Short[] getShortArrayWrap() { + return shortArrayWrap; + } + + public void setShortArrayWrap(Short[] shortArrayWrap) { + this.shortArrayWrap = shortArrayWrap; + } + + public int[] getIntArray() { + return intArray; + } + + public void setIntArray(int[] intArray) { + this.intArray = intArray; + } + + public Integer[] getIntArrayWrap() { + return intArrayWrap; + } + + public void setIntArrayWrap(Integer[] intArrayWrap) { + this.intArrayWrap = intArrayWrap; + } + + public char[] getCharArray() { + return charArray; + } + + public void setCharArray(char[] charArray) { + this.charArray = charArray; + } + + public Character[] getCharArrayWrap() { + return charArrayWrap; + } + + public void setCharArrayWrap(Character[] charArrayWrap) { + this.charArrayWrap = charArrayWrap; + } + + public long[] getLongArray() { + return longArray; + } + + public void setLongArray(long[] longArray) { + this.longArray = longArray; + } + + public double[] getDoubleArray() { + return doubleArray; + } + + public void setDoubleArray(double[] doubleArray) { + this.doubleArray = doubleArray; + } +} \ No newline at end of file diff --git a/src/test/resources/random/RandomValueGenerationBuilder.java b/src/test/resources/random/RandomValueGenerationBuilder.java new file mode 100644 index 0000000..fc0c20f --- /dev/null +++ b/src/test/resources/random/RandomValueGenerationBuilder.java @@ -0,0 +1,381 @@ +package com.sngular.annotation.examples; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.Instant; +import java.time.LocalDate; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.util.Date; +import java.util.List; +import java.util.Objects; + +import au.com.dius.pact.consumer.dsl.DslPart; +import au.com.dius.pact.consumer.dsl.PactDslJsonArray; +import au.com.dius.pact.consumer.dsl.PactDslJsonBody; +import au.com.dius.pact.consumer.dsl.PactDslJsonRootValue; +import com.sngular.annotation.processor.mapping.CustomDslModifier; +import com.sngular.annotation.examples.RandomValueGeneration; +import java.util.Arrays; + +public class RandomValueGenerationBuilder { + + int integer = 0; + + int primitiveInt = 0; + + long longObject = 0L; + + long primitiveLong = 0L; + + float floatObject = 0.0F; + + float primitiveFloat = 0.0F; + + double doubleObject = 0.0D; + + double primitiveDouble = 0.0D; + + short shortObject = 0; + + short primitiveShort = 0; + + byte byteObject = 0; + + byte primitiveByte = 0; + + BigInteger bigIntegerObject = new BigInteger("0"); + + BigDecimal bigDecimalObject = new BigDecimal("0"); + + String[] stringArray = {"defaultValue"}; + String stringArrayName = "stringArray"; + + boolean[] booleanArray = {true}; + String booleanArrayName = "booleanArray"; + + Boolean[] booleanArrayWrap = {false}; + String booleanArrayWrapName = "booleanArrayWrap"; + + byte[] byteArray = {-128}; + String byteArrayName = "byteArray"; + + Byte[] byteArrayWrap = {127}; + String byteArrayWrapName = "byteArrayWrap"; + + short[] shortArray = {-32768}; + String shortArrayName = "shortArray"; + + Short[] shortArrayWrap = {32767}; + String shortArrayWrapName = "shortArrayWrap"; + + int[] intArray = {-2147483648}; + String intArrayName = "intArray"; + + Integer[] intArrayWrap = {2147483647}; + String intArrayWrapName = "intArrayWrap"; + + char[] charArray = {'x'}; + String charArrayName = "charArray"; + + Character[] charArrayWrap = {'X'}; + String charArrayWrapName = "charArrayWrap"; + + String[] inLongArray = {"-9223372036854775808L"}; + long[] longArray = Arrays.stream(inLongArray).mapToLong(Long::parseLong).toArray(); + String longArrayName = "longArray"; + + String[] inDoubleArray = {"-1234567890123456789012345678901234567890.79769313486232D"}; + double[] doubleArray = Arrays.stream(inDoubleArray).mapToDouble(Double::parseDouble).toArray(); + String doubleArrayName = "doubleArray"; + + public RandomValueGenerationBuilder setInteger(final int integer) { + this.integer = integer; + return this; + } + + public RandomValueGenerationBuilder setPrimitiveInt(final int primitiveInt) { + this.primitiveInt = primitiveInt; + return this; + } + + public RandomValueGenerationBuilder setLongObject(final long longObject) { + this.longObject = longObject; + return this; + } + + public RandomValueGenerationBuilder setPrimitiveLong(final long primitiveLong) { + this.primitiveLong = primitiveLong; + return this; + } + + public RandomValueGenerationBuilder setFloatObject(final float floatObject) { + this.floatObject = floatObject; + return this; + } + + public RandomValueGenerationBuilder setPrimitiveFloat(final float primitiveFloat) { + this.primitiveFloat = primitiveFloat; + return this; + } + + public RandomValueGenerationBuilder setDoubleObject(final double doubleObject) { + this.doubleObject = doubleObject; + return this; + } + + public RandomValueGenerationBuilder setPrimitiveDouble(final double primitiveDouble) { + this.primitiveDouble = primitiveDouble; + return this; + } + + public RandomValueGenerationBuilder setShortObject(final short shortObject) { + this.shortObject = shortObject; + return this; + } + + public RandomValueGenerationBuilder setPrimitiveShort(final short primitiveShort) { + this.primitiveShort = primitiveShort; + return this; + } + + public RandomValueGenerationBuilder setByteObject(final byte byteObject) { + this.byteObject = byteObject; + return this; + } + + public RandomValueGenerationBuilder setPrimitiveByte(final byte primitiveByte) { + this.primitiveByte = primitiveByte; + return this; + } + + public RandomValueGenerationBuilder setBigIntegerObject(final BigInteger bigIntegerObject) { + this.bigIntegerObject = bigIntegerObject; + return this; + } + + public RandomValueGenerationBuilder setBigDecimalObject(final BigDecimal bigDecimalObject) { + this.bigDecimalObject = bigDecimalObject; + return this; + } + + public RandomValueGenerationBuilder setStringArray(final String[] stringArray) { + this.stringArray = stringArray; + return this; + } + + public RandomValueGenerationBuilder setBooleanArray(final boolean[] booleanArray) { + this.booleanArray = booleanArray; + return this; + } + + public RandomValueGenerationBuilder setBooleanArrayWrap(final Boolean[] booleanArrayWrap) { + this.booleanArrayWrap = booleanArrayWrap; + return this; + } + + public RandomValueGenerationBuilder setByteArray(final byte[] byteArray) { + this.byteArray = byteArray; + return this; + } + + public RandomValueGenerationBuilder setByteArrayWrap(final Byte[] byteArrayWrap) { + this.byteArrayWrap = byteArrayWrap; + return this; + } + + public RandomValueGenerationBuilder setShortArray(final short[] shortArray) { + this.shortArray = shortArray; + return this; + } + + public RandomValueGenerationBuilder setShortArrayWrap(final Short[] shortArrayWrap) { + this.shortArrayWrap = shortArrayWrap; + return this; + } + + public RandomValueGenerationBuilder setIntArray(final int[] intArray) { + this.intArray = intArray; + return this; + } + + public RandomValueGenerationBuilder setIntArrayWrap(final Integer[] intArrayWrap) { + this.intArrayWrap = intArrayWrap; + return this; + } + + public RandomValueGenerationBuilder setCharArray(final char[] charArray) { + this.charArray = charArray; + return this; + } + + public RandomValueGenerationBuilder setCharArrayWrap(final Character[] charArrayWrap) { + this.charArrayWrap = charArrayWrap; + return this; + } + + public RandomValueGenerationBuilder setLongArray(final long[] longArray) { + this.longArray = longArray; + return this; + } + + public RandomValueGenerationBuilder setDoubleArray(final double[] doubleArray) { + this.doubleArray = doubleArray; + return this; + } + + + public DslPart build() { + PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); + + if (Objects.nonNull(integer)) { + pactDslJsonBody.integerType("integer", integer); + } + + if (Objects.nonNull(primitiveInt)) { + pactDslJsonBody.integerType("primitiveInt", primitiveInt); + } + + if (Objects.nonNull(longObject)) { + pactDslJsonBody.integerType("longObject", longObject); + } + + if (Objects.nonNull(primitiveLong)) { + pactDslJsonBody.integerType("primitiveLong", primitiveLong); + } + + if (Objects.nonNull(floatObject)) { + pactDslJsonBody.decimalType("floatObject", (double) floatObject); + } + + if (Objects.nonNull(primitiveFloat)) { + pactDslJsonBody.decimalType("primitiveFloat", (double) primitiveFloat); + } + + if (Objects.nonNull(doubleObject)) { + pactDslJsonBody.decimalType("doubleObject", doubleObject); + } + + if (Objects.nonNull(primitiveDouble)) { + pactDslJsonBody.decimalType("primitiveDouble", primitiveDouble); + } + + if (Objects.nonNull(shortObject)) { + pactDslJsonBody.integerType("shortObject", (int) shortObject); + } + + if (Objects.nonNull(primitiveShort)) { + pactDslJsonBody.integerType("primitiveShort", (int) primitiveShort); + } + + if (Objects.nonNull(byteObject)) { + pactDslJsonBody.integerType("byteObject", (int) byteObject); + } + + if (Objects.nonNull(primitiveByte)) { + pactDslJsonBody.integerType("primitiveByte", (int) primitiveByte); + } + + if (Objects.nonNull(bigIntegerObject)) { + pactDslJsonBody.integerType("bigIntegerObject", bigIntegerObject.intValue()); + } + + if (Objects.nonNull(bigDecimalObject)) { + pactDslJsonBody.decimalType("bigDecimalObject", bigDecimalObject); + } + + if (Objects.nonNull(stringArray)) { + pactDslJsonBody.array(stringArrayName).stringValue(Arrays.toString(stringArray)).closeArray(); + } + + if (Objects.nonNull(booleanArray)) { + pactDslJsonBody.array(booleanArrayName).stringValue(Arrays.toString(booleanArray)).closeArray(); + } + + if (Objects.nonNull(booleanArrayWrap)) { + pactDslJsonBody.array(booleanArrayWrapName).stringValue(Arrays.toString(booleanArrayWrap)).closeArray(); + } + + if (Objects.nonNull(byteArray)) { + pactDslJsonBody.array(byteArrayName).stringValue(Arrays.toString(byteArray)).closeArray(); + } + + if (Objects.nonNull(byteArrayWrap)) { + pactDslJsonBody.array(byteArrayWrapName).stringValue(Arrays.toString(byteArrayWrap)).closeArray(); + } + + if (Objects.nonNull(shortArray)) { + pactDslJsonBody.array(shortArrayName).stringValue(Arrays.toString(shortArray)).closeArray(); + } + + if (Objects.nonNull(shortArrayWrap)) { + pactDslJsonBody.array(shortArrayWrapName).stringValue(Arrays.toString(shortArrayWrap)).closeArray(); + } + + if (Objects.nonNull(intArray)) { + pactDslJsonBody.array(intArrayName).stringValue(Arrays.toString(intArray)).closeArray(); + } + + if (Objects.nonNull(intArrayWrap)) { + pactDslJsonBody.array(intArrayWrapName).stringValue(Arrays.toString(intArrayWrap)).closeArray(); + } + + if (Objects.nonNull(charArray)) { + pactDslJsonBody.array(charArrayName).stringValue(Arrays.toString(charArray)).closeArray(); + } + + if (Objects.nonNull(charArrayWrap)) { + pactDslJsonBody.array(charArrayWrapName).stringValue(Arrays.toString(charArrayWrap)).closeArray(); + } + + if (Objects.nonNull(longArray)) { + pactDslJsonBody.array(longArrayName).stringValue(Arrays.toString(longArray)).closeArray(); + } + + if (Objects.nonNull(doubleArray)) { + pactDslJsonBody.array(doubleArrayName).stringValue(Arrays.toString(doubleArray)).closeArray(); + } + + + return pactDslJsonBody; + } + + public RandomValueGeneration buildExpectedInstance() { + RandomValueGeneration object = new RandomValueGeneration(); + object.setInteger(this.integer); + object.setPrimitiveInt(this.primitiveInt); + object.setLongObject(this.longObject); + object.setPrimitiveLong(this.primitiveLong); + object.setFloatObject(this.floatObject); + object.setPrimitiveFloat(this.primitiveFloat); + object.setDoubleObject(this.doubleObject); + object.setPrimitiveDouble(this.primitiveDouble); + object.setShortObject(this.shortObject); + object.setPrimitiveShort(this.primitiveShort); + object.setByteObject(this.byteObject); + object.setPrimitiveByte(this.primitiveByte); + object.setBigIntegerObject(this.bigIntegerObject); + object.setBigDecimalObject(this.bigDecimalObject); + object.setStringArray(this.stringArray); + object.setBooleanArray(this.booleanArray); + object.setBooleanArrayWrap(this.booleanArrayWrap); + object.setByteArray(this.byteArray); + object.setByteArrayWrap(this.byteArrayWrap); + object.setShortArray(this.shortArray); + object.setShortArrayWrap(this.shortArrayWrap); + object.setIntArray(this.intArray); + object.setIntArrayWrap(this.intArrayWrap); + object.setCharArray(this.charArray); + object.setCharArrayWrap(this.charArrayWrap); + object.setLongArray(this.longArray); + object.setDoubleArray(this.doubleArray); + return object; + } + + private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { + } +} + From a7e413db12cf38622629ba14fc6600b306eb7218 Mon Sep 17 00:00:00 2001 From: Miguel Escobar Date: Thu, 8 Feb 2024 14:18:53 -0600 Subject: [PATCH 4/5] add tests of arrays (long, float, double) Wrappers and default values --- .../com/sngular/annotation/pact/Example.java | 2 - .../processor/PactDslProcessor.java | 64 +++++--- .../mapping/BooleanArrayMapping.java | 5 +- .../mapping/BooleanArrayWrapMapping.java | 5 +- .../processor/mapping/ByteArrayMapping.java | 2 +- .../mapping/ByteArrayWrapMapping.java | 2 +- .../processor/mapping/CharArrayMapping.java | 1 - .../mapping/CharArrayWrapMapping.java | 2 +- .../processor/mapping/DoubleArrayMapping.java | 10 +- .../mapping/DoubleArrayWrapMapping.java | 9 +- .../processor/mapping/FloatArrayMapping.java | 4 +- .../mapping/FloatArrayWrapMapping.java | 3 - .../processor/mapping/IntArrayMapping.java | 2 +- .../mapping/IntArrayWrapMapping.java | 2 +- .../processor/mapping/LongArrayMapping.java | 2 +- .../templates/templateDslBuilder.ftlh | 86 ++++++++-- src/test/resources/basic/ArrayDataTypes.java | 85 +++++++++- .../basic/ArrayDataTypesBuilder.java | 154 +++++++++++++++++- .../basic/CharacterDataTypesBuilder.java | 49 +++++- .../basic/NumericDataTypesBuilder.java | 50 +++++- .../resources/date/DateDataTypesBuilder.java | 49 +++++- .../random/RandomValueGeneration.java | 43 ++++- .../random/RandomValueGenerationBuilder.java | 132 +++++++++++++-- 23 files changed, 669 insertions(+), 94 deletions(-) diff --git a/src/main/java/com/sngular/annotation/pact/Example.java b/src/main/java/com/sngular/annotation/pact/Example.java index f8202ab..afc1436 100644 --- a/src/main/java/com/sngular/annotation/pact/Example.java +++ b/src/main/java/com/sngular/annotation/pact/Example.java @@ -20,6 +20,4 @@ String format() default ""; String[] array() default { }; - - long[] longArray() default { }; } diff --git a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java index d85ec96..157c64b 100644 --- a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java +++ b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java @@ -133,48 +133,72 @@ private static String getFormat(final Element fieldElement, final String default return StringUtils.defaultIfEmpty(value, defaultFormat); } - private static String getFormatArray(final Element fieldElement, final String defaultFormat) { + /** + * This method gets the values obtained from the array attribute of the example annotation + * ( @Example(array = {"value1","value2"} ) + * @param fieldElement Element, Class containing the attributes annotated with Example + * @param defaultFormat String, Array type. + * @return The processed strings to set the parameter: parametersimpleFieldBuilder.defaultValue + */ + private static String getArrayFromExample(final Element fieldElement, final String defaultFormat) { String[] value = fieldElement.getAnnotation(Example.class).array(); - return StringUtils.defaultIfEmpty(PactDslProcessor.getStringFromArray(value,defaultFormat), defaultFormat); + return PactDslProcessor.getStringFromArray(value,defaultFormat); } - private static String getStringFromArray(String[] value, String defaultFormat) { + /** + * This method process the array of values to format them according to the type of array. + * @param arrayValues String[], Strings to be processed. + * @param arrayType String, Array type to be processed. + * @return The processed strings to set the parameter: parametersimpleFieldBuilder.defaultValue + */ + private static String getStringFromArray(String[] arrayValues, String arrayType) { + int size = arrayValues.length-1; String arrayToString = ""; + String element = ""; - for (int i = 0; i < value.length; i++) { + for (int i = 0; i < arrayValues.length; i++) { - switch (TypeArray.get(defaultFormat)) { + element = arrayValues[i]; + switch (TypeArray.get(arrayType)) { case STRING_ARRAY: - if (i == value.length-1) { - arrayToString += "\"" + value[i] + "\""; + if (i == size) { + arrayToString += "\"" + element + "\""; } else { - arrayToString += "\"" + value[i] + "\","; + arrayToString += "\"" + element + "\","; + } + break; + case LONG_ARRAY: + case FLOAT_ARRAY: + case DOUBLE_ARRAY: + if (i == size) { //ultimo elemento + if (i != 0) { + arrayToString += "\"" + element; //si son mas de uno + } else { arrayToString += element; } //si es unico elemento + } else { + if (i != 0) { + arrayToString += "\"" + element + "\","; //si son mas de uno y elemento intermedio + } else { arrayToString += element + "\","; } //si son mas de uno y primer elemento } break; - case BOOLEAN_ARRAY: case BYTE_ARRAY: case SHORT_ARRAY: case INT_ARRAY: - case LONG_ARRAY: - case FLOAT_ARRAY: - case DOUBLE_ARRAY: - if (i == value.length-1) { - arrayToString += value[i] ; + if (i == size) { + arrayToString += element ; } else { - arrayToString += value[i] + ","; + arrayToString += element + ","; } break; case CHAR_ARRAY: - if (i == value.length-1) { - arrayToString += "'" + value[i] + "'"; + if (i == size) { + arrayToString += "'" + element + "'"; } else { - arrayToString += "'" + value[i] + "',"; + arrayToString += "'" + element + "',"; } break; - default: arrayToString = "not_found_type_array"; } @@ -404,7 +428,7 @@ private DslSimpleField.DslSimpleFieldBuilder createSimpleFieldBuilder(final Elem } else if (Objects.nonNull(fieldElement.getAnnotation(Example.class))) { if (fieldElement.getAnnotation(Example.class).array().length != 0) { - simpleFieldBuilder.defaultValue(getFormatArray(fieldElement, mapping.getFieldType())); + simpleFieldBuilder.defaultValue(getArrayFromExample(fieldElement, mapping.getFieldType())); simpleFieldBuilder.formatValue(null); } else { simpleFieldBuilder.defaultValue(getDefaultValue(fieldElement, mapping.getFieldType())); diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java index c0d1682..ee7f5a1 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayMapping.java @@ -2,7 +2,6 @@ import com.sngular.annotation.processor.model.FieldValidations; import org.apache.commons.rng.UniformRandomProvider; -import org.apache.commons.rng.simple.RandomSource; /** Represents an array of boolean. * @author Miguel Angel Escobar @@ -10,8 +9,6 @@ */ public class BooleanArrayMapping implements TypeMapping { - private final UniformRandomProvider uniformRandomProvider = RandomSource.XO_RO_SHI_RO_128_PP.create(); - @Override public final String getFieldType() { return "boolean[]"; @@ -31,4 +28,4 @@ public final String getFunctionOnlyValue() { public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { return "true"; } -} +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java index f50412b..2d8dc52 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/BooleanArrayWrapMapping.java @@ -2,7 +2,6 @@ import com.sngular.annotation.processor.model.FieldValidations; import org.apache.commons.rng.UniformRandomProvider; -import org.apache.commons.rng.simple.RandomSource; /** Represents an array of Boolean. * @author Miguel Angel Escobar @@ -10,8 +9,6 @@ */ public class BooleanArrayWrapMapping implements TypeMapping { - private final UniformRandomProvider uniformRandomProvider = RandomSource.XO_RO_SHI_RO_128_PP.create(); - @Override public final String getFieldType() { return "Boolean[]"; @@ -31,4 +28,4 @@ public final String getFunctionOnlyValue() { public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { return "false"; } -} +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java index 332a113..d090efe 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayMapping.java @@ -28,4 +28,4 @@ public final String getFunctionOnlyValue() { public final Integer getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { return -128; } -} +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java index 4465077..acca723 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/ByteArrayWrapMapping.java @@ -28,4 +28,4 @@ public final String getFunctionOnlyValue() { public final Integer getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { return 127; } -} +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java index 6b61e32..991b8d3 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayMapping.java @@ -2,7 +2,6 @@ import com.sngular.annotation.processor.model.FieldValidations; import org.apache.commons.rng.UniformRandomProvider; -import org.apache.commons.lang3.RandomStringUtils; /** Represents an array of char. * @author Miguel Angel Escobar diff --git a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java index 4f9ac35..b0d91eb 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/CharArrayWrapMapping.java @@ -2,7 +2,7 @@ import com.sngular.annotation.processor.model.FieldValidations; import org.apache.commons.rng.UniformRandomProvider; -import org.apache.commons.lang3.RandomStringUtils; + /** Represents an array of Character. * @author Miguel Angel Escobar diff --git a/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java index 00a3c9b..52d4cdc 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayMapping.java @@ -1,10 +1,12 @@ package com.sngular.annotation.processor.mapping; import com.sngular.annotation.processor.model.FieldValidations; -import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.rng.UniformRandomProvider; -import java.util.Objects; +/** Represents an array of double. + * @author Miguel Angel Escobar + * @version 1.0 + */ public class DoubleArrayMapping implements TypeMapping { @Override @@ -24,11 +26,11 @@ public final String getFunctionOnlyValue() { @Override public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { - return "-1234567890123456789012345678901234567890.79769313486232D"; + return "-1234567890123456789012345678901234567890.79769313486232d"; } @Override public final String getSuffixValue() { return "D"; } -} +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java index e0ca2fe..fa715e8 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/DoubleArrayWrapMapping.java @@ -1,11 +1,12 @@ package com.sngular.annotation.processor.mapping; import com.sngular.annotation.processor.model.FieldValidations; -import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.rng.UniformRandomProvider; -import java.util.Objects; - +/** Represents an array of Double. + * @author Miguel Angel Escobar + * @version 1.0 + */ public class DoubleArrayWrapMapping implements TypeMapping { @Override @@ -32,4 +33,4 @@ public final String getRandomDefaultValue(final FieldValidations fieldValidation public final String getSuffixValue() { return "D"; } -} +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java index 97b26ed..05b90bf 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayMapping.java @@ -1,9 +1,7 @@ package com.sngular.annotation.processor.mapping; import com.sngular.annotation.processor.model.FieldValidations; -import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.rng.UniformRandomProvider; -import java.util.Objects; /** Represents an array of float. * @author Miguel Angel Escobar @@ -28,7 +26,7 @@ public final String getFunctionOnlyValue() { @Override public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { - return "-123456789012345678901234567890.402823F"; + return "-123456789012345678901234567890.402823f"; } @Override diff --git a/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java index ad6b740..b15d1bb 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/FloatArrayWrapMapping.java @@ -1,11 +1,8 @@ package com.sngular.annotation.processor.mapping; import com.sngular.annotation.processor.model.FieldValidations; -import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.rng.UniformRandomProvider; -import java.util.Objects; - /** Represents an array of Float. * @author Miguel Angel Escobar * @version 1.0 diff --git a/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java index d6bd157..908d21f 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayMapping.java @@ -28,4 +28,4 @@ public final String getFunctionOnlyValue() { public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { return "-2147483648"; } -} +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java index 7ea2937..90310fa 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/IntArrayWrapMapping.java @@ -28,4 +28,4 @@ public final String getFunctionOnlyValue() { public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { return "2147483647"; } -} +} \ No newline at end of file diff --git a/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java index e432960..87aebc5 100644 --- a/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java +++ b/src/main/java/com/sngular/annotation/processor/mapping/LongArrayMapping.java @@ -26,7 +26,7 @@ public final String getFunctionOnlyValue() { @Override public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { - return "-9223372036854775808L"; + return "-9223372036854775808l"; } @Override diff --git a/src/main/resources/templates/templateDslBuilder.ftlh b/src/main/resources/templates/templateDslBuilder.ftlh index fdc0276..9aa44f8 100644 --- a/src/main/resources/templates/templateDslBuilder.ftlh +++ b/src/main/resources/templates/templateDslBuilder.ftlh @@ -7,19 +7,39 @@ || field.fieldType == "byte[]" || field.fieldType == "Byte[]" || field.fieldType == "short[]" || field.fieldType == "Short[]" || field.fieldType == "int[]" || field.fieldType == "Integer[]"> - ${field.fieldType} ${field.name} = {${field.defaultValue?no_esc}}; String ${field.name}Name = "${field.name}"; - <#elseif field.fieldType == "double[]" || field.fieldType == "Double[]"> - String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; - ${field.fieldType} ${field.name} = Arrays.stream(in${field.name?cap_first}).mapToDouble(Double::parseDouble).toArray(); - String ${field.name}Name = "${field.name}"; - <#elseif field.fieldType == "long[]" || field.fieldType == "Long[]"> + <#elseif field.fieldType == "long[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = getLongArray(in${field.name?cap_first}); + String ${field.name}Name = "${field.name}"; + + <#elseif field.fieldType == "Long[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = getLongArrayWrap(in${field.name?cap_first}); + String ${field.name}Name = "${field.name}"; + + <#elseif field.fieldType == "float[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = getFloatArray(in${field.name?cap_first}); + String ${field.name}Name = "${field.name}"; + + <#elseif field.fieldType == "Float[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = getFloatArrayWrap(in${field.name?cap_first}); + String ${field.name}Name = "${field.name}"; + + <#elseif field.fieldType == "double[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = getDoubleArray(in${field.name?cap_first}); + String ${field.name}Name = "${field.name}"; + + <#elseif field.fieldType == "Double[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = getDoubleArrayWrap(in${field.name?cap_first}); + String ${field.name}Name = "${field.name}"; - String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; - ${field.fieldType} ${field.name} = Arrays.stream(in${field.name?cap_first}).mapToLong(Long::parseLong).toArray(); - String ${field.name}Name = "${field.name}"; <#elseif field.fieldType == "boolean"> ${field.fieldType} ${field.name} = ${field.defaultValue?string}; <#elseif field.fieldType == "char"> @@ -356,5 +376,51 @@ public class ${schema.className}Builder { } -} + public static long[] getLongArray(String[] numbers) { + long[] result = new long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0l; } + return result; + } + + public static Long[] getLongArrayWrap(String[] numbers) { + Long[] result = new Long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0L; } + return result; + } + + public static float[] getFloatArray(String[] numbers) { + float[] result = new float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0f; } + return result; + } + public static Float[] getFloatArrayWrap(String[] numbers) { + Float[] result = new Float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0F; } + return result; + } + + public static double[] getDoubleArray(String[] numbers) { + double[] result = new double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0d; } + return result; + } + + public static Double[] getDoubleArrayWrap(String[] numbers) { + Double[] result = new Double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0D; } + return result; + } + } \ No newline at end of file diff --git a/src/test/resources/basic/ArrayDataTypes.java b/src/test/resources/basic/ArrayDataTypes.java index a115df3..a3c12c6 100644 --- a/src/test/resources/basic/ArrayDataTypes.java +++ b/src/test/resources/basic/ArrayDataTypes.java @@ -3,9 +3,7 @@ import com.sngular.annotation.pact.Example; import com.sngular.annotation.pact.PactDslBodyBuilder; import com.sngular.annotation.pact.DslExclude; - import java.util.Optional; - @PactDslBodyBuilder public class ArrayDataTypes { @@ -45,12 +43,60 @@ public class ArrayDataTypes { @Example(array = {"m","n","o"} ) private Character[] charArrayWrap; - @Example(array = {"-123456789012345678901234567890.402823L"} ) + @Example(array = {"-9223372036854775807l", + "9223372036854775807L", + "-0l", + "0L", + "-3.402823e38", + "0.0", + "al"} ) private long[] longArray; - @Example(array = {"-1234567890123456789012345678901234567890.79769313486232D"} ) + @Example(array = {"-9223372036854775807l", + "9223372036854775807L", + "-0l", + "0L", + "-3.402823e38", + "-0.0", + "aL"} ) + private Long[] longArrayWrap; + + @Example(array = {"-82233720368547758080000001f", + "100.0F", + "-123456789012345678901234567890123456789f", + "123456789012345678901234567890123456789F", + "-3.402823e38", + "0.0", + "af"} ) + private float[] floatArray; + + @Example(array = {"-1234567890123456789012345678901234567890.79769313486232d", + "1000.0D", + "-123456789012345678901234567890123456789d", + "123456789012345678901234567890123456789D", + "-3.402823e300d", + "-0.0", + "aF"} ) + private Float[] floatArrayWrap; + + @Example(array = {"-1234567890123456789012345678901234567890.79769313486232d", + "1000.0D", + "1234567890123456789012345678901234567890123456789012345678901234567890D", + "-2.12345678901234d", + "3.402823e307D", + "0.0", + "ad"} ) private double[] doubleArray; + @Example(array = {"-1234567890123456789012345678901234567890.79769313486232d", + "1000.0D", + "1234567890123456789012345678901234567890123456789012345678901234567890D", + "-2.12345678901234d", + "3.402823e307D", + "-0.0", + "aD"} ) + private Double[] doubleArrayWrap; + public String[] getStringArray() { return stringArray; } @@ -155,6 +201,30 @@ public void setLongArray(long[] longArray) { this.longArray = longArray; } + public Long[] getLongArrayWrap() { + return longArrayWrap; + } + + public void setLongArrayWrap(Long[] longArrayWrap) { + this.longArrayWrap = longArrayWrap; + } + + public float[] getFloatArray() { + return floatArray; + } + + public void setFloatArray(float[] floatArray) { + this.floatArray = floatArray; + } + + public Float[] getFloatArrayWrap() { + return floatArrayWrap; + } + + public void setFloatArrayWrap(Float[] floatArrayWrap) { + this.floatArrayWrap = floatArrayWrap; + } + public double[] getDoubleArray() { return doubleArray; } @@ -163,4 +233,11 @@ public void setDoubleArray(double[] doubleArray) { this.doubleArray = doubleArray; } + public Double[] getDoubleArrayWrap() { + return doubleArrayWrap; + } + + public void setDoubleArrayWrap(Double[] doubleArrayWrap) { + this.doubleArrayWrap = doubleArrayWrap; + } } \ No newline at end of file diff --git a/src/test/resources/basic/ArrayDataTypesBuilder.java b/src/test/resources/basic/ArrayDataTypesBuilder.java index 6d345fc..0a7fe9a 100644 --- a/src/test/resources/basic/ArrayDataTypesBuilder.java +++ b/src/test/resources/basic/ArrayDataTypesBuilder.java @@ -56,17 +56,70 @@ public class ArrayDataTypesBuilder { Character[] charArrayWrap = {'m','n','o'}; String charArrayWrapName = "charArrayWrap"; - // se requiere "inLongArray" para poder crear "longArray", ya que si se pasa - // el valor String directo a long[], tenemos conflicto - String[] inLongArray = {"-123456789012345678901234567890.402823L"}; - long[] longArray = Arrays.stream(inLongArray).mapToLong(Long::parseLong).toArray(); + String[] inLongArray = {"-9223372036854775807l", + "9223372036854775807L", + "-0l", + "0L", + "-3.402823e38", + "0.0", + "al"} + long[] longArray = getLongArray(inLongArray); String longArrayName = "longArray"; - String[] inDoubleArray = {"-1234567890123456789012345678901234567890.79769313486232D"}; - double[] doubleArray = Arrays.stream(inDoubleArray).mapToDouble(Double::parseDouble).toArray(); + String[] inLongArrayWrap = {"-9223372036854775807l", + "9223372036854775807L", + "-0l", + "0L", + "-3.402823e38", + "-0.0", + "aL"}; + Long[] longArrayWrap = getLongArrayWrap(inLongArrayWrap); + String longArrayWrapName = "longArrayWrap"; + + String[] inFloatArray = {"-82233720368547758080000001f", + "100.0F", + "-123456789012345678901234567890123456789f", + "123456789012345678901234567890123456789F", + "-3.402823e38", + "0.0", + "af"}; + float[] floatArray = getFloatArray(inFloatArray); + String floatArrayName = "floatArray"; + + + String[] inFloatArrayWrap = {"-1234567890123456789012345678901234567890.79769313486232d", + "1000.0D", + "-123456789012345678901234567890123456789d", + "123456789012345678901234567890123456789D", + "-3.402823e300d", + "-0.0", + "aF"}; + Float[] floatArrayWrap = getFloatArrayWrap(inFloatArrayWrap); + String floatArrayWrapName = "floatArrayWrap"; + + + String[] inDoubleArray = {"-1234567890123456789012345678901234567890.79769313486232d", + "1000.0D", + "1234567890123456789012345678901234567890123456789012345678901234567890D", + "-2.12345678901234d", + "3.402823e307D", + "0.0", + "ad"}; + double[] doubleArray = getDoubleArray(inDoubleArray); String doubleArrayName = "doubleArray"; + String[] inDoubleArrayWrap = {"-1234567890123456789012345678901234567890.79769313486232d", + "1000.0D", + "1234567890123456789012345678901234567890123456789012345678901234567890D", + "-2.12345678901234d", + "3.402823e307D", + "-0.0", + "aD"}; + Double[] doubleArrayWrap = getDoubleArrayWrap(inDoubleArrayWrap); + String doubleArrayWrapName = "doubleArrayWrap"; + + public ArrayDataTypesBuilder setStringArray(final String[] stringArray) { this.stringArray = stringArray; return this; @@ -127,11 +180,30 @@ public ArrayDataTypesBuilder setLongArray(final long[] longArray) { return this; } + public ArrayDataTypesBuilder setLongArrayWrap(final Long[] longArrayWrap) { + this.longArrayWrap = longArrayWrap; + return this; + } + + public ArrayDataTypesBuilder setFloatArray(final float[] floatArray) { + this.floatArray = floatArray; + return this; + } + + public ArrayDataTypesBuilder setFloatArrayWrap(final Float[] floatArrayWrap) { + this.floatArrayWrap = floatArrayWrap; + return this; + } + public ArrayDataTypesBuilder setDoubleArray(final double[] doubleArray) { this.doubleArray = doubleArray; return this; } + public ArrayDataTypesBuilder setDoubleArrayWrap(final Double[] doubleArrayWrap) { + this.doubleArrayWrap = doubleArrayWrap; + return this; + } public DslPart build() { PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); @@ -184,9 +256,25 @@ public DslPart build() { pactDslJsonBody.array(longArrayName).stringValue(Arrays.toString(longArray)).closeArray(); } + if (Objects.nonNull(longArrayWrap)) { + pactDslJsonBody.array(longArrayWrapName).stringValue(Arrays.toString(longArrayWrap)).closeArray(); + } + + if (Objects.nonNull(floatArray)) { + pactDslJsonBody.array(floatArrayName).stringValue(Arrays.toString(floatArray)).closeArray(); + } + + if (Objects.nonNull(floatArrayWrap)) { + pactDslJsonBody.array(floatArrayWrapName).stringValue(Arrays.toString(floatArrayWrap)).closeArray(); + } + if (Objects.nonNull(doubleArray)) { pactDslJsonBody.array(doubleArrayName).stringValue(Arrays.toString(doubleArray)).closeArray(); } + + if (Objects.nonNull(doubleArrayWrap)) { + pactDslJsonBody.array(doubleArrayWrapName).stringValue(Arrays.toString(doubleArrayWrap)).closeArray(); + } return pactDslJsonBody; } @@ -204,12 +292,62 @@ public ArrayDataTypes buildExpectedInstance() { object.setCharArray(this.charArray); object.setCharArrayWrap(this.charArrayWrap); object.setLongArray(this.longArray); + object.setLongArrayWrap(this.longArrayWrap); + object.setFloatArray(this.floatArray); + object.setFloatArrayWrap(this.floatArrayWrap); object.setDoubleArray(this.doubleArray); - + object.setDoubleArrayWrap(this.doubleArrayWrap); return object; } private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { } -} + public static long[] getLongArray(String[] numbers) { + long[] result = new long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0l; } + return result; + } + + public static Long[] getLongArrayWrap(String[] numbers) { + Long[] result = new Long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0L; } + return result; + } + + public static float[] getFloatArray(String[] numbers) { + float[] result = new float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0f; } + return result; + } + + public static Float[] getFloatArrayWrap(String[] numbers) { + Float[] result = new Float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0F; } + return result; + } + + public static double[] getDoubleArray(String[] numbers) { + double[] result = new double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0d; } + return result; + } + + public static Double[] getDoubleArrayWrap(String[] numbers) { + Double[] result = new Double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0D; } + return result; + } +} \ No newline at end of file diff --git a/src/test/resources/basic/CharacterDataTypesBuilder.java b/src/test/resources/basic/CharacterDataTypesBuilder.java index 204a8af..71ff6f9 100644 --- a/src/test/resources/basic/CharacterDataTypesBuilder.java +++ b/src/test/resources/basic/CharacterDataTypesBuilder.java @@ -94,5 +94,52 @@ public CharacterDataTypes buildExpectedInstance() { private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { } -} + public static long[] getLongArray(String[] numbers) { + long[] result = new long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0l; } + return result; + } + + public static Long[] getLongArrayWrap(String[] numbers) { + Long[] result = new Long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0L; } + return result; + } + + public static float[] getFloatArray(String[] numbers) { + float[] result = new float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0f; } + return result; + } + + public static Float[] getFloatArrayWrap(String[] numbers) { + Float[] result = new Float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0F; } + return result; + } + + public static double[] getDoubleArray(String[] numbers) { + double[] result = new double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0d; } + return result; + } + + public static Double[] getDoubleArrayWrap(String[] numbers) { + Double[] result = new Double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0D; } + return result; + } +} \ No newline at end of file diff --git a/src/test/resources/basic/NumericDataTypesBuilder.java b/src/test/resources/basic/NumericDataTypesBuilder.java index 42a8690..b56679d 100644 --- a/src/test/resources/basic/NumericDataTypesBuilder.java +++ b/src/test/resources/basic/NumericDataTypesBuilder.java @@ -199,9 +199,57 @@ public NumericDataTypes buildExpectedInstance() { object.setPrimitiveByte(this.primitiveByte); object.setBigIntegerObject(this.bigIntegerObject); object.setBigDecimalObject(this.bigDecimalObject); - return object; } + private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { } + + public static long[] getLongArray(String[] numbers) { + long[] result = new long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0l; } + return result; + } + + public static Long[] getLongArrayWrap(String[] numbers) { + Long[] result = new Long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0L; } + return result; + } + + public static float[] getFloatArray(String[] numbers) { + float[] result = new float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0f; } + return result; + } + + public static Float[] getFloatArrayWrap(String[] numbers) { + Float[] result = new Float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0F; } + return result; + } + + public static double[] getDoubleArray(String[] numbers) { + double[] result = new double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0d; } + return result; + } + + public static Double[] getDoubleArrayWrap(String[] numbers) { + Double[] result = new Double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0D; } + return result; + } } \ No newline at end of file diff --git a/src/test/resources/date/DateDataTypesBuilder.java b/src/test/resources/date/DateDataTypesBuilder.java index ad0b142..4c4e842 100644 --- a/src/test/resources/date/DateDataTypesBuilder.java +++ b/src/test/resources/date/DateDataTypesBuilder.java @@ -70,8 +70,55 @@ public DateDataTypes buildExpectedInstance() { object.setFormattedDate(this.formattedDate); return object; } + private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { } -} + public static long[] getLongArray(String[] numbers) { + long[] result = new long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0l; } + return result; + } + + public static Long[] getLongArrayWrap(String[] numbers) { + Long[] result = new Long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0L; } + return result; + } + + public static float[] getFloatArray(String[] numbers) { + float[] result = new float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0f; } + return result; + } + public static Float[] getFloatArrayWrap(String[] numbers) { + Float[] result = new Float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0F; } + return result; + } + + public static double[] getDoubleArray(String[] numbers) { + double[] result = new double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0d; } + return result; + } + + public static Double[] getDoubleArrayWrap(String[] numbers) { + Double[] result = new Double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0D; } + return result; + } +} \ No newline at end of file diff --git a/src/test/resources/random/RandomValueGeneration.java b/src/test/resources/random/RandomValueGeneration.java index a112ffd..8accf88 100644 --- a/src/test/resources/random/RandomValueGeneration.java +++ b/src/test/resources/random/RandomValueGeneration.java @@ -59,10 +59,17 @@ public class RandomValueGeneration { public Character[] charArrayWrap; - public long[] longArray; + long[] longArray; - public double[] doubleArray; + Long[] longArrayWrap; + float[] floatArray; + + Float[] floatArrayWrap; + + double[] doubleArray; + + Double[] doubleArrayWrap; public Integer getInteger() { return integer; @@ -272,6 +279,30 @@ public void setLongArray(long[] longArray) { this.longArray = longArray; } + public Long[] getLongArrayWrap() { + return longArrayWrap; + } + + public void setLongArrayWrap(Long[] longArrayWrap) { + this.longArrayWrap = longArrayWrap; + } + + public float[] getFloatArray() { + return floatArray; + } + + public void setFloatArray(float[] floatArray) { + this.floatArray = floatArray; + } + + public Float[] getFloatArrayWrap() { + return floatArrayWrap; + } + + public void setFloatArrayWrap(Float[] floatArrayWrap) { + this.floatArrayWrap = floatArrayWrap; + } + public double[] getDoubleArray() { return doubleArray; } @@ -279,4 +310,12 @@ public double[] getDoubleArray() { public void setDoubleArray(double[] doubleArray) { this.doubleArray = doubleArray; } + + public Double[] getDoubleArrayWrap() { + return doubleArrayWrap; + } + + public void setDoubleArrayWrap(Double[] doubleArrayWrap) { + this.doubleArrayWrap = doubleArrayWrap; + } } \ No newline at end of file diff --git a/src/test/resources/random/RandomValueGenerationBuilder.java b/src/test/resources/random/RandomValueGenerationBuilder.java index fc0c20f..2fe97b3 100644 --- a/src/test/resources/random/RandomValueGenerationBuilder.java +++ b/src/test/resources/random/RandomValueGenerationBuilder.java @@ -54,44 +54,60 @@ public class RandomValueGenerationBuilder { String[] stringArray = {"defaultValue"}; String stringArrayName = "stringArray"; - boolean[] booleanArray = {true}; + boolean[] booleanArray = {true}; String booleanArrayName = "booleanArray"; - Boolean[] booleanArrayWrap = {false}; + Boolean[] booleanArrayWrap = {false}; String booleanArrayWrapName = "booleanArrayWrap"; - byte[] byteArray = {-128}; + byte[] byteArray = {-128}; String byteArrayName = "byteArray"; - Byte[] byteArrayWrap = {127}; + Byte[] byteArrayWrap = {127}; String byteArrayWrapName = "byteArrayWrap"; - short[] shortArray = {-32768}; + short[] shortArray = {-32768}; String shortArrayName = "shortArray"; - Short[] shortArrayWrap = {32767}; + Short[] shortArrayWrap = {32767}; String shortArrayWrapName = "shortArrayWrap"; - int[] intArray = {-2147483648}; + int[] intArray = {-2147483648}; String intArrayName = "intArray"; - Integer[] intArrayWrap = {2147483647}; + Integer[] intArrayWrap = {2147483647}; String intArrayWrapName = "intArrayWrap"; - char[] charArray = {'x'}; + char[] charArray = {'x'}; String charArrayName = "charArray"; - Character[] charArrayWrap = {'X'}; + Character[] charArrayWrap = {'X'}; String charArrayWrapName = "charArrayWrap"; - String[] inLongArray = {"-9223372036854775808L"}; - long[] longArray = Arrays.stream(inLongArray).mapToLong(Long::parseLong).toArray(); + String[] inLongArray = {"-9223372036854775808l"}; + long[] longArray = getLongArray(inLongArray); String longArrayName = "longArray"; - String[] inDoubleArray = {"-1234567890123456789012345678901234567890.79769313486232D"}; - double[] doubleArray = Arrays.stream(inDoubleArray).mapToDouble(Double::parseDouble).toArray(); + String[] inLongArrayWrap = {"9223372036854775807L"}; + Long[] longArrayWrap = getLongArrayWrap(inLongArrayWrap); + String longArrayWrapName = "longArrayWrap"; + + String[] inFloatArray = {"-123456789012345678901234567890.402823f"}; + float[] floatArray = getFloatArray(inFloatArray); + String floatArrayName = "floatArray"; + + String[] inFloatArrayWrap = {"123456789012345678901234567890.402823F"}; + Float[] floatArrayWrap = getFloatArrayWrap(inFloatArrayWrap); + String floatArrayWrapName = "floatArrayWrap"; + + String[] inDoubleArray = {"-1234567890123456789012345678901234567890.79769313486232d"}; + double[] doubleArray = getDoubleArray(inDoubleArray); String doubleArrayName = "doubleArray"; + String[] inDoubleArrayWrap = {"1234567890123456789012345678901234567890.79769313486232D"}; + Double[] doubleArrayWrap = getDoubleArrayWrap(inDoubleArrayWrap); + String doubleArrayWrapName = "doubleArrayWrap"; + public RandomValueGenerationBuilder setInteger(final int integer) { this.integer = integer; return this; @@ -222,11 +238,30 @@ public RandomValueGenerationBuilder setLongArray(final long[] longArray) { return this; } + public RandomValueGenerationBuilder setLongArrayWrap(final Long[] longArrayWrap) { + this.longArrayWrap = longArrayWrap; + return this; + } + + public RandomValueGenerationBuilder setFloatArray(final float[] floatArray) { + this.floatArray = floatArray; + return this; + } + + public RandomValueGenerationBuilder setFloatArrayWrap(final Float[] floatArrayWrap) { + this.floatArrayWrap = floatArrayWrap; + return this; + } + public RandomValueGenerationBuilder setDoubleArray(final double[] doubleArray) { this.doubleArray = doubleArray; return this; } + public RandomValueGenerationBuilder setDoubleArrayWrap(final Double[] doubleArrayWrap) { + this.doubleArrayWrap = doubleArrayWrap; + return this; + } public DslPart build() { PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); @@ -335,11 +370,25 @@ public DslPart build() { pactDslJsonBody.array(longArrayName).stringValue(Arrays.toString(longArray)).closeArray(); } + if (Objects.nonNull(longArrayWrap)) { + pactDslJsonBody.array(longArrayWrapName).stringValue(Arrays.toString(longArrayWrap)).closeArray(); + } + + if (Objects.nonNull(floatArray)) { + pactDslJsonBody.array(floatArrayName).stringValue(Arrays.toString(floatArray)).closeArray(); + } + + if (Objects.nonNull(floatArrayWrap)) { + pactDslJsonBody.array(floatArrayWrapName).stringValue(Arrays.toString(floatArrayWrap)).closeArray(); + } + if (Objects.nonNull(doubleArray)) { pactDslJsonBody.array(doubleArrayName).stringValue(Arrays.toString(doubleArray)).closeArray(); } - + if (Objects.nonNull(doubleArrayWrap)) { + pactDslJsonBody.array(doubleArrayWrapName).stringValue(Arrays.toString(doubleArrayWrap)).closeArray(); + } return pactDslJsonBody; } @@ -371,11 +420,62 @@ public RandomValueGeneration buildExpectedInstance() { object.setCharArray(this.charArray); object.setCharArrayWrap(this.charArrayWrap); object.setLongArray(this.longArray); + object.setLongArrayWrap(this.longArrayWrap); + object.setFloatArray(this.floatArray); + object.setFloatArrayWrap(this.floatArrayWrap); object.setDoubleArray(this.doubleArray); + object.setDoubleArrayWrap(this.doubleArrayWrap); return object; } private static void applyCustomModifiers(PactDslJsonBody pactDslJsonBody) throws ClassNotFoundException, InstantiationException, IllegalAccessException { } -} + public static long[] getLongArray(String[] numbers) { + long[] result = new long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0l; } + return result; + } + + public static Long[] getLongArrayWrap(String[] numbers) { + Long[] result = new Long[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Long.parseLong(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0L; } + return result; + } + + public static float[] getFloatArray(String[] numbers) { + float[] result = new float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0f; } + return result; + } + + public static Float[] getFloatArrayWrap(String[] numbers) { + Float[] result = new Float[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Float.parseFloat(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0F; } + return result; + } + + public static double[] getDoubleArray(String[] numbers) { + double[] result = new double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0d; } + return result; + } + + public static Double[] getDoubleArrayWrap(String[] numbers) { + Double[] result = new Double[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = Double.parseDouble(numbers[i]); + } catch (NumberFormatException nfe) { result[i] = 0.0D; } + return result; + } +} \ No newline at end of file From b6656dc0a367b8709243ccca6cd97e376dfa6b6a Mon Sep 17 00:00:00 2001 From: Miguel Escobar Date: Wed, 28 Feb 2024 19:13:59 -0600 Subject: [PATCH 5/5] tests arrays completed --- .../processor/PactDslProcessor.java | 18 +- .../annotation/processor/TypeArray.java | 28 ++- .../mapping/BigDecimalArrayMapping.java | 27 +++ .../mapping/BigIntegerArrayMapping.java | 33 +++ .../processor/mapping/DateArrayMapping.java | 32 +++ .../mapping/ZonedDateTimeArrayMapping.java | 32 +++ .../templates/templateDslBuilder.ftlh | 125 +++++++++-- src/test/resources/basic/ArrayDataTypes.java | 95 +++++++++ .../basic/ArrayDataTypesBuilder.java | 195 +++++++++++++++++- .../basic/CharacterDataTypesBuilder.java | 85 +++++++- .../basic/NumericDataTypesBuilder.java | 85 +++++++- .../resources/date/DateDataTypesBuilder.java | 85 +++++++- .../random/RandomValueGeneration.java | 42 ++++ .../random/RandomValueGenerationBuilder.java | 145 ++++++++++++- 14 files changed, 973 insertions(+), 54 deletions(-) create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/BigDecimalArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/BigIntegerArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/DateArrayMapping.java create mode 100644 src/main/java/com/sngular/annotation/processor/mapping/ZonedDateTimeArrayMapping.java diff --git a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java index 157c64b..26f0b28 100644 --- a/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java +++ b/src/main/java/com/sngular/annotation/processor/PactDslProcessor.java @@ -1,9 +1,3 @@ -/* - * This Source Code Form is subject to the terms of the Mozilla Public - * * License, v. 2.0. If a copy of the MPL was not distributed with this - * * file, You can obtain one at https://mozilla.org/MPL/2.0/. - */ - package com.sngular.annotation.processor; import java.io.IOException; @@ -106,6 +100,11 @@ public class PactDslProcessor extends AbstractProcessor { .put("java.lang.Float[]", new FloatArrayWrapMapping()) .put("double[]", new DoubleArrayMapping()) .put("java.lang.Double[]", new DoubleArrayWrapMapping()) + .put("java.math.BigInteger[]", new BigIntegerArrayMapping()) + .put("java.math.BigDecimal[]", new BigDecimalArrayMapping()) + .put("java.time.ZonedDateTime[]", new ZonedDateTimeArrayMapping()) + .put("java.util.Date[]", new DateArrayMapping()) + .put("Date[]", new DateArrayMapping()) .build(); private static final String CUSTOM_MODIFIERS = "customModifiers"; @@ -171,6 +170,10 @@ private static String getStringFromArray(String[] arrayValues, String arrayType) case LONG_ARRAY: case FLOAT_ARRAY: case DOUBLE_ARRAY: + case BIG_INTEGER_ARRAY: + case BIG_DECIMAL_ARRAY: + case ZONED_DATE_TIME_ARRAY: + case DATE_ARRAY: if (i == size) { //ultimo elemento if (i != 0) { arrayToString += "\"" + element; //si son mas de uno @@ -429,7 +432,8 @@ private DslSimpleField.DslSimpleFieldBuilder createSimpleFieldBuilder(final Elem if (fieldElement.getAnnotation(Example.class).array().length != 0) { simpleFieldBuilder.defaultValue(getArrayFromExample(fieldElement, mapping.getFieldType())); - simpleFieldBuilder.formatValue(null); + simpleFieldBuilder.formatValue(getFormat(fieldElement, mapping.getFormatValue())); + } else { simpleFieldBuilder.defaultValue(getDefaultValue(fieldElement, mapping.getFieldType())); simpleFieldBuilder.formatValue(getFormat(fieldElement, mapping.getFormatValue())); diff --git a/src/main/java/com/sngular/annotation/processor/TypeArray.java b/src/main/java/com/sngular/annotation/processor/TypeArray.java index 266b0b9..d7bda95 100644 --- a/src/main/java/com/sngular/annotation/processor/TypeArray.java +++ b/src/main/java/com/sngular/annotation/processor/TypeArray.java @@ -3,7 +3,6 @@ import java.util.Arrays; import java.util.Optional; - /** Represents an enum of array types. * @author Miguel Angel Escobar * @version 1.0 @@ -52,7 +51,27 @@ public enum TypeArray { /** * An array type {@code double[]}. */ - DOUBLE_ARRAY("double[]","Double[]"); + DOUBLE_ARRAY("double[]","Double[]"), + + /** + * An array type {@code BigInteger[]}. + */ + BIG_INTEGER_ARRAY("","BigInteger[]"), + + /** + * An array type {@code BigDecimal[]}. + */ + BIG_DECIMAL_ARRAY("","BigDecimal[]"), + + /** + * An array type {@code ZonedDateTime[]}. + */ + ZONED_DATE_TIME_ARRAY("","ZonedDateTime[]"), + + /** + * An array type {@code Date[]}. + */ + DATE_ARRAY("","Date[]"); private String primitiveName; private String objectName; @@ -74,13 +93,14 @@ public String getPrimitiveName() { public String getobjectName() { return objectName; } + /** * {@return TypeArray value that matches typeString} */ public static TypeArray get(String typeString) { Optional op = Arrays.stream(TypeArray.values()) - .filter(accStatus -> accStatus.primitiveName.equals(typeString) - || accStatus.objectName.equals(typeString)) + .filter(typeArray -> typeArray.primitiveName.equals(typeString) + || typeArray.objectName.equals(typeString)) .findFirst(); return op.get(); diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BigDecimalArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BigDecimalArrayMapping.java new file mode 100644 index 0000000..6818421 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/BigDecimalArrayMapping.java @@ -0,0 +1,27 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +public class BigDecimalArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "BigDecimal[]"; + } + + @Override + public final String getFunctionType() { + return "bigDecimalArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "bigDecimalArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "12345678901234567890123456789012345678901234567890123456789012345678901234567890.901234567890123456789012345678901234567890"; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/BigIntegerArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/BigIntegerArrayMapping.java new file mode 100644 index 0000000..14a796d --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/BigIntegerArrayMapping.java @@ -0,0 +1,33 @@ +/* + * This Source Code Form is subject to the terms of the Mozilla Public + * * License, v. 2.0. If a copy of the MPL was not distributed with this + * * file, You can obtain one at https://mozilla.org/MPL/2.0/. + */ + +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +public class BigIntegerArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "BigInteger[]"; + } + + @Override + public final String getFunctionType() { + return "bigIntegerArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "bigIntegerArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "12345678901234567890123456789012345678901234567890123456789012345678901234567890"; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/DateArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/DateArrayMapping.java new file mode 100644 index 0000000..4dc7e16 --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/DateArrayMapping.java @@ -0,0 +1,32 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +public class DateArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "Date[]"; + } + + @Override + public final String getFunctionType() { + return "dateArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "dateArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "Wed Feb 28 13:59:00 CST 2024"; + } + + @Override + public final String getFormatValue() { + return "yyyy-MM-dd"; + } +} diff --git a/src/main/java/com/sngular/annotation/processor/mapping/ZonedDateTimeArrayMapping.java b/src/main/java/com/sngular/annotation/processor/mapping/ZonedDateTimeArrayMapping.java new file mode 100644 index 0000000..2db44cb --- /dev/null +++ b/src/main/java/com/sngular/annotation/processor/mapping/ZonedDateTimeArrayMapping.java @@ -0,0 +1,32 @@ +package com.sngular.annotation.processor.mapping; + +import com.sngular.annotation.processor.model.FieldValidations; +import org.apache.commons.rng.UniformRandomProvider; + +public class ZonedDateTimeArrayMapping implements TypeMapping { + + @Override + public final String getFieldType() { + return "ZonedDateTime[]"; + } + + @Override + public final String getFunctionType() { + return "zonedDateTimeArrayType"; + } + + @Override + public final String getFunctionOnlyValue() { + return "zonedDateTimeArrayValue"; + } + + @Override + public final String getRandomDefaultValue(final FieldValidations fieldValidations, final UniformRandomProvider uniformRandomProvider) { + return "2024-02-28T13:59-06:00[America/Mexico_City]"; + } + + @Override + public final String getFormatValue() { + return "yyyy-MM-dd'T'HH:mm:ss[.SSSSSS][.SSS]XXX['['VV']']"; + } +} diff --git a/src/main/resources/templates/templateDslBuilder.ftlh b/src/main/resources/templates/templateDslBuilder.ftlh index 9aa44f8..59d236f 100644 --- a/src/main/resources/templates/templateDslBuilder.ftlh +++ b/src/main/resources/templates/templateDslBuilder.ftlh @@ -40,6 +40,28 @@ ${field.fieldType} ${field.name} = getDoubleArrayWrap(in${field.name?cap_first}); String ${field.name}Name = "${field.name}"; + <#elseif field.fieldType == "BigInteger[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = getBigIntegerArray(in${field.name?cap_first}); + String ${field.name}Name = "${field.name}"; + + <#elseif field.fieldType == "BigDecimal[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + ${field.fieldType} ${field.name} = getBigDecimalArray(in${field.name?cap_first}); + String ${field.name}Name = "${field.name}"; + + <#elseif field.fieldType == "ZonedDateTime[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + String ${field.name}Format = "${field.formatValue?no_esc}"; + ${field.fieldType} ${field.name} = getZonedDateTimeArray(in${field.name?cap_first},${field.name}Format); + String ${field.name}Name = "${field.name}"; + + <#elseif field.fieldType == "Date[]"> + String[] in${field.name?cap_first} = {"${field.defaultValue?no_esc}"}; + String ${field.name}Format = "${field.formatValue?no_esc}"; + ${field.fieldType} ${field.name} = getDateArray(in${field.name?cap_first},${field.name}Format); + String ${field.name}Name = "${field.name}"; + <#elseif field.fieldType == "boolean"> ${field.fieldType} ${field.name} = ${field.defaultValue?string}; <#elseif field.fieldType == "char"> @@ -138,11 +160,13 @@ <#if field.name?has_content> if (Objects.nonNull(${field.name})) { <#if field.formatValue??> - <#if field.functionByType != "datetime"> - pactDslJsonBody.${field.functionByType}("${field.name}", "${field.formatValue?no_esc}", ${field.name}); - <#else> - pactDslJsonBody.${field.functionByType}("${field.name}", "${field.formatValue?no_esc}", ${field.name}.toInstant()); - + <#if field.fieldType == "ZonedDateTime[]" || field.fieldType == "Date[]"> + pactDslJsonBody.array(${field.name}Name).stringValue(Arrays.toString(${field.name})).closeArray(); + <#elseif field.functionByType != "datetime"> + pactDslJsonBody.${field.functionByType}("${field.name}", "${field.formatValue?no_esc}", ${field.name}); + <#else> + pactDslJsonBody.${field.functionByType}("${field.name}", "${field.formatValue?no_esc}", ${field.name}.toInstant()); + <#elseif field.fieldType == "short"> pactDslJsonBody.${field.functionByType}("${field.name}", (int) ${field.name}); <#elseif field.fieldType == "BigInteger"> @@ -159,7 +183,9 @@ || field.fieldType == "int[]" || field.fieldType == "Integer[]" || field.fieldType == "long[]" || field.fieldType == "Long[]" || field.fieldType == "float[]" || field.fieldType == "Float[]" - || field.fieldType == "double[]" || field.fieldType == "Double[]"> + || field.fieldType == "double[]" || field.fieldType == "Double[]" + || field.fieldType == "BigInteger[]" || field.fieldType == "BigDecimal[]"> + pactDslJsonBody.array(${field.name}Name).stringValue(Arrays.toString(${field.name})).closeArray(); <#else> pactDslJsonBody.${field.functionByType}("${field.name}", ${field.name}); @@ -296,6 +322,9 @@ import java.text.ParseException; import java.text.SimpleDateFormat; import java.time.Instant; import java.time.LocalDate; +import java.time.DateTimeException; +import java.time.LocalDateTime; +import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.Date; @@ -380,7 +409,10 @@ public class ${schema.className}Builder { long[] result = new long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0l; } + } catch (NumberFormatException nfe) { + System.out.println("long value expected but was: "+numbers[i]); + result[i] = 0l; + } return result; } @@ -388,7 +420,10 @@ public class ${schema.className}Builder { Long[] result = new Long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0L; } + } catch (NumberFormatException nfe) { + System.out.println("Long value expected but was: "+numbers[i]); + result[i] = 0L; + } return result; } @@ -396,7 +431,10 @@ public class ${schema.className}Builder { float[] result = new float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0f; } + } catch (NumberFormatException nfe) { + System.out.println("float value expected but was: "+numbers[i]); + result[i] = 0.0f; + } return result; } @@ -404,7 +442,10 @@ public class ${schema.className}Builder { Float[] result = new Float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0F; } + } catch (NumberFormatException nfe) { + System.out.println("Float value expected but was: "+numbers[i]); + result[i] = 0.0F; + } return result; } @@ -412,7 +453,10 @@ public class ${schema.className}Builder { double[] result = new double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0d; } + } catch (NumberFormatException nfe) { + System.out.println("double value expected but was: "+numbers[i]); + result[i] = 0.0d; + } return result; } @@ -420,7 +464,62 @@ public class ${schema.className}Builder { Double[] result = new Double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0D; } + } catch (NumberFormatException nfe) { + System.out.println("Double value expected but was: "+numbers[i]); + result[i] = 0.0D; + } return result; } - } \ No newline at end of file + + public static BigInteger[] getBigIntegerArray(String[] numbers) { + BigInteger[] result = new BigInteger[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigInteger(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigInteger value expected but was: "+numbers[i]); + result[i] = new BigInteger("0"); + } + return result; + } + + public static BigDecimal[] getBigDecimalArray(String[] numbers) { + BigDecimal[] result = new BigDecimal[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigDecimal(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigDecimal value expected but was: "+numbers[i]); + result[i] = new BigDecimal("0.0"); + } + return result; + } + + public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) { + ZonedDateTime[] result = new ZonedDateTime[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = LocalDateTime + .parse(numbers[i],DateTimeFormatter.ofPattern(format)) + .atZone(ZoneId.systemDefault()) + .withZoneSameInstant(ZoneId.systemDefault()); + + } catch (DateTimeException dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = ZonedDateTime.now(); + } + return result; + } + + public static Date[] getDateArray(String[] numbers, String format) { + Date[] result = new Date[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = new SimpleDateFormat(format).parse(numbers[i]); + } catch (Exception dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = new Date(); + } + return result; + } + } \ No newline at end of file diff --git a/src/test/resources/basic/ArrayDataTypes.java b/src/test/resources/basic/ArrayDataTypes.java index a3c12c6..0bca76d 100644 --- a/src/test/resources/basic/ArrayDataTypes.java +++ b/src/test/resources/basic/ArrayDataTypes.java @@ -3,7 +3,13 @@ import com.sngular.annotation.pact.Example; import com.sngular.annotation.pact.PactDslBodyBuilder; import com.sngular.annotation.pact.DslExclude; + +import java.math.BigInteger; +import java.math.BigDecimal; +import java.time.ZonedDateTime; import java.util.Optional; +import java.util.Date; + @PactDslBodyBuilder public class ArrayDataTypes { @@ -97,6 +103,55 @@ public class ArrayDataTypes { "aD"} ) private Double[] doubleArrayWrap; + @Example(array = {"-8223372036854775808000000182233720368547758000182233720368547758080000001", + "9542233720368547758080000001822334563456435643720367867865758000182233720352345368547758080000001", + "100.0", + "0", + "-0", + "abc"}) + private BigInteger[] bigIntegerArray; + + @Example(array = {"-8223372036854775808000000182233720368547758000182233720368547758080000001.8000182233720368547758080000001", + "954223372036854775808000000135643720367867865758000182233720352345368547758080000001.58000182233720352345368547758080000001", + "100.0", + "0", + "-0", + "abc"}) + private BigDecimal[] bigDecimalArray; + + @Example(array = {"28/02/2024 00:00", + "28/02/2024 23:59", + "30/02/2024 00:00", + "28/03/2024 25:00", + "28/04/2024 23:70", + "00/00/0000 00:00", + "12345", + "100.100", + "abc"}, format = "dd/MM/yyyy HH:mm") + private ZonedDateTime[] zonedDateTimeArray; + + @Example(array = {"2024-02-28 00:00", + "2024-02-28 23:59", + "2024-02-30 00:00", + "2024-03-28 25:00", + "2024-04-28 23:70", + "0000-00-00 00:00", + "12345", + "100.100", + "abc"}, format = "yyyy-MM-dd HH:mm") + private ZonedDateTime[] zonedDateTimeArray2; + + @Example(array = {"28/02/2024", + "28/02/2024", + "30/02/2024", + "28/03/2024", + "28/04/2024", + "00/00/0000", + "12345", + "100.100", + "abc"}, format = "dd/MM/yyyy") + private Date[] dateArray; + public String[] getStringArray() { return stringArray; } @@ -240,4 +295,44 @@ public Double[] getDoubleArrayWrap() { public void setDoubleArrayWrap(Double[] doubleArrayWrap) { this.doubleArrayWrap = doubleArrayWrap; } + + public BigInteger[] getBigIntegerArray() { + return bigIntegerArray; + } + + public void setBigIntegerArray(BigInteger[] bigIntegerArray) { + this.bigIntegerArray = bigIntegerArray; + } + + public BigDecimal[] getBigDecimalArray() { + return bigDecimalArray; + } + + public void setBigDecimalArray(BigDecimal[] bigDecimalArray) { + this.bigDecimalArray = bigDecimalArray; + } + + public ZonedDateTime[] getZonedDateTimeArray() { + return zonedDateTimeArray; + } + + public void setZonedDateTimeArray(ZonedDateTime[] zonedDateTimeArray) { + this.zonedDateTimeArray = zonedDateTimeArray; + } + + public ZonedDateTime[] getZonedDateTimeArray2() { + return zonedDateTimeArray2; + } + + public void setZonedDateTimeArray2(ZonedDateTime[] zonedDateTimeArray2) { + this.zonedDateTimeArray2 = zonedDateTimeArray2; + } + + public Date[] getDateArray() { + return dateArray; + } + + public void setDateArray(Date[] dateArray) { + dateArray = dateArray; + } } \ No newline at end of file diff --git a/src/test/resources/basic/ArrayDataTypesBuilder.java b/src/test/resources/basic/ArrayDataTypesBuilder.java index 0a7fe9a..714502a 100644 --- a/src/test/resources/basic/ArrayDataTypesBuilder.java +++ b/src/test/resources/basic/ArrayDataTypesBuilder.java @@ -7,6 +7,9 @@ import java.text.SimpleDateFormat; import java.time.Instant; import java.time.LocalDate; +import java.time.DateTimeException; +import java.time.LocalDateTime; +import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.Date; @@ -119,6 +122,66 @@ public class ArrayDataTypesBuilder { Double[] doubleArrayWrap = getDoubleArrayWrap(inDoubleArrayWrap); String doubleArrayWrapName = "doubleArrayWrap"; + String[] inBigIntegerArray = {"-8223372036854775808000000182233720368547758000182233720368547758080000001", + "9542233720368547758080000001822334563456435643720367867865758000182233720352345368547758080000001", + "100.0", + "0", + "-0", + "abc"}; + BigInteger[] bigIntegerArray = getBigIntegerArray(inBigIntegerArray); + String bigIntegerArrayName = "bigIntegerArray"; + + String[] inBigDecimalArray = {"-8223372036854775808000000182233720368547758000182233720368547758080000001.8000182233720368547758080000001", + "954223372036854775808000000135643720367867865758000182233720352345368547758080000001.58000182233720352345368547758080000001", + "100.0", + "0", + "-0", + "abc"}; + BigDecimal[] bigDecimalArray = getBigDecimalArray(inBigDecimalArray); + String bigDecimalArrayName = "bigDecimalArray"; + + //2024-02-28T00:00-06:00[America/Mexico_City] + String[] inZonedDateTimeArray = {"28/02/2024 00:00", + "28/02/2024 23:59", + "30/02/2024 00:00", + "28/03/2024 25:00", + "28/04/2024 23:70", + "00/00/0000 00:00", + "12345", + "100.100", + "abc"}; + String zonedDateTimeArrayFormat = "dd/MM/yyyy HH:mm"; + ZonedDateTime[] zonedDateTimeArray = getZonedDateTimeArray(inZonedDateTimeArray,zonedDateTimeArrayFormat); + String zonedDateTimeArrayName = "zonedDateTimeArray"; + + //2024-02-28T00:00-06:00[America/Mexico_City] + String[] inZonedDateTimeArray2 = {"2024-02-28 00:00", + "2024-02-28 23:59", + "2024-02-30 00:00", + "2024-03-28 25:00", + "2024-04-28 23:70", + "0000-00-00 00:00", + "12345", + "100.100", + "abc"}; + String zonedDateTimeArray2Format = "yyyy-MM-dd HH:mm"; + ZonedDateTime[] zonedDateTimeArray2 = getZonedDateTimeArray(inZonedDateTimeArray2,zonedDateTimeArray2Format); + String zonedDateTimeArray2Name = "zonedDateTimeArray2"; + + + //Wed Feb 28 00:00:00 CST 2024 + String[] inDateArray = {"28/02/2024", + "28/02/2024", + "30/02/2024", + "28/03/2024", + "28/04/2024", + "00/00/0000", + "12345", + "100.100", + "abc"}; + String dateArrayFormat = "dd/MM/yyyy"; + Date[] dateArray = getDateArray(inDateArray,dateArrayFormat); + String dateArrayName = "dateArray"; public ArrayDataTypesBuilder setStringArray(final String[] stringArray) { this.stringArray = stringArray; @@ -205,6 +268,31 @@ public ArrayDataTypesBuilder setDoubleArrayWrap(final Double[] doubleArrayWrap) return this; } + public ArrayDataTypesBuilder setBigIntegerArray(final BigInteger[] bigIntegerArray) { + this.bigIntegerArray = bigIntegerArray; + return this; + } + + public ArrayDataTypesBuilder setBigDecimalArray(final BigDecimal[] bigDecimalArray) { + this.bigDecimalArray = bigDecimalArray; + return this; + } + + public ArrayDataTypesBuilder setZonedDateTimeArray(final ZonedDateTime[] zonedDateTimeArray) { + this.zonedDateTimeArray = zonedDateTimeArray; + return this; + } + + public ArrayDataTypesBuilder setZonedDateTimeArray2(final ZonedDateTime[] zonedDateTimeArray2) { + this.zonedDateTimeArray2 = zonedDateTimeArray2; + return this; + } + + public ArrayDataTypesBuilder setDateArray(final Date[] dateArray) { + this.dateArray = dateArray; + return this; + } + public DslPart build() { PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); @@ -275,6 +363,26 @@ public DslPart build() { if (Objects.nonNull(doubleArrayWrap)) { pactDslJsonBody.array(doubleArrayWrapName).stringValue(Arrays.toString(doubleArrayWrap)).closeArray(); } + + if (Objects.nonNull(bigIntegerArray)) { + pactDslJsonBody.array(bigIntegerArrayName).stringValue(Arrays.toString(bigIntegerArray)).closeArray(); + } + + if (Objects.nonNull(bigDecimalArray)) { + pactDslJsonBody.array(bigDecimalArrayName).stringValue(Arrays.toString(bigDecimalArray)).closeArray(); + } + + if (Objects.nonNull(zonedDateTimeArray)) { + pactDslJsonBody.array(zonedDateTimeArrayName).stringValue(Arrays.toString(zonedDateTimeArray)).closeArray(); + } + + if (Objects.nonNull(zonedDateTimeArray2)) { + pactDslJsonBody.array(zonedDateTimeArray2Name).stringValue(Arrays.toString(zonedDateTimeArray2)).closeArray(); + } + + if (Objects.nonNull(dateArray)) { + pactDslJsonBody.array(dateArrayName).stringValue(Arrays.toString(dateArray)).closeArray(); + } return pactDslJsonBody; } @@ -297,6 +405,11 @@ public ArrayDataTypes buildExpectedInstance() { object.setFloatArrayWrap(this.floatArrayWrap); object.setDoubleArray(this.doubleArray); object.setDoubleArrayWrap(this.doubleArrayWrap); + object.setBigIntegerArray(this.bigIntegerArray); + object.setBigDecimalArray(this.bigDecimalArray); + object.setZonedDateTimeArray(this.zonedDateTimeArray); + object.setZonedDateTimeArray2(this.zonedDateTimeArray2); + object.setDateArray(this.dateArray); return object; } @@ -307,7 +420,10 @@ public static long[] getLongArray(String[] numbers) { long[] result = new long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0l; } + } catch (NumberFormatException nfe) { + System.out.println("long value expected but was: "+numbers[i]); + result[i] = 0l; + } return result; } @@ -315,7 +431,10 @@ public static Long[] getLongArrayWrap(String[] numbers) { Long[] result = new Long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0L; } + } catch (NumberFormatException nfe) { + System.out.println("Long value expected but was: "+numbers[i]); + result[i] = 0L; + } return result; } @@ -323,7 +442,10 @@ public static float[] getFloatArray(String[] numbers) { float[] result = new float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0f; } + } catch (NumberFormatException nfe) { + System.out.println("float value expected but was: "+numbers[i]); + result[i] = 0.0f; + } return result; } @@ -331,7 +453,10 @@ public static Float[] getFloatArrayWrap(String[] numbers) { Float[] result = new Float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0F; } + } catch (NumberFormatException nfe) { + System.out.println("Float value expected but was: "+numbers[i]); + result[i] = 0.0F; + } return result; } @@ -339,7 +464,10 @@ public static double[] getDoubleArray(String[] numbers) { double[] result = new double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0d; } + } catch (NumberFormatException nfe) { + System.out.println("double value expected but was: "+numbers[i]); + result[i] = 0.0d; + } return result; } @@ -347,7 +475,62 @@ public static Double[] getDoubleArrayWrap(String[] numbers) { Double[] result = new Double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0D; } + } catch (NumberFormatException nfe) { + System.out.println("Double value expected but was: "+numbers[i]); + result[i] = 0.0D; + } + return result; + } + + public static BigInteger[] getBigIntegerArray(String[] numbers) { + BigInteger[] result = new BigInteger[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigInteger(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigInteger value expected but was: "+numbers[i]); + result[i] = new BigInteger("0"); + } + return result; + } + + public static BigDecimal[] getBigDecimalArray(String[] numbers) { + BigDecimal[] result = new BigDecimal[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigDecimal(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigDecimal value expected but was: "+numbers[i]); + result[i] = new BigDecimal("0.0"); + } + return result; + } + + public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) { + ZonedDateTime[] result = new ZonedDateTime[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = LocalDateTime + .parse(numbers[i],DateTimeFormatter.ofPattern(format)) + .atZone(ZoneId.systemDefault()) + .withZoneSameInstant(ZoneId.systemDefault()); + + } catch (DateTimeException dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = ZonedDateTime.now(); + } + return result; + } + + public static Date[] getDateArray(String[] numbers, String format) { + Date[] result = new Date[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = new SimpleDateFormat(format).parse(numbers[i]); + } catch (Exception dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = new Date(); + } return result; } } \ No newline at end of file diff --git a/src/test/resources/basic/CharacterDataTypesBuilder.java b/src/test/resources/basic/CharacterDataTypesBuilder.java index 71ff6f9..d6a52b4 100644 --- a/src/test/resources/basic/CharacterDataTypesBuilder.java +++ b/src/test/resources/basic/CharacterDataTypesBuilder.java @@ -7,6 +7,9 @@ import java.text.SimpleDateFormat; import java.time.Instant; import java.time.LocalDate; +import java.time.DateTimeException; +import java.time.LocalDateTime; +import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.Date; @@ -99,7 +102,10 @@ public static long[] getLongArray(String[] numbers) { long[] result = new long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0l; } + } catch (NumberFormatException nfe) { + System.out.println("long value expected but was: "+numbers[i]); + result[i] = 0l; + } return result; } @@ -107,7 +113,10 @@ public static Long[] getLongArrayWrap(String[] numbers) { Long[] result = new Long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0L; } + } catch (NumberFormatException nfe) { + System.out.println("Long value expected but was: "+numbers[i]); + result[i] = 0L; + } return result; } @@ -115,7 +124,10 @@ public static float[] getFloatArray(String[] numbers) { float[] result = new float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0f; } + } catch (NumberFormatException nfe) { + System.out.println("float value expected but was: "+numbers[i]); + result[i] = 0.0f; + } return result; } @@ -123,7 +135,10 @@ public static Float[] getFloatArrayWrap(String[] numbers) { Float[] result = new Float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0F; } + } catch (NumberFormatException nfe) { + System.out.println("Float value expected but was: "+numbers[i]); + result[i] = 0.0F; + } return result; } @@ -131,7 +146,10 @@ public static double[] getDoubleArray(String[] numbers) { double[] result = new double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0d; } + } catch (NumberFormatException nfe) { + System.out.println("double value expected but was: "+numbers[i]); + result[i] = 0.0d; + } return result; } @@ -139,7 +157,62 @@ public static Double[] getDoubleArrayWrap(String[] numbers) { Double[] result = new Double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0D; } + } catch (NumberFormatException nfe) { + System.out.println("Double value expected but was: "+numbers[i]); + result[i] = 0.0D; + } + return result; + } + + public static BigInteger[] getBigIntegerArray(String[] numbers) { + BigInteger[] result = new BigInteger[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigInteger(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigInteger value expected but was: "+numbers[i]); + result[i] = new BigInteger("0"); + } + return result; + } + + public static BigDecimal[] getBigDecimalArray(String[] numbers) { + BigDecimal[] result = new BigDecimal[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigDecimal(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigDecimal value expected but was: "+numbers[i]); + result[i] = new BigDecimal("0.0"); + } + return result; + } + + public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) { + ZonedDateTime[] result = new ZonedDateTime[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = LocalDateTime + .parse(numbers[i],DateTimeFormatter.ofPattern(format)) + .atZone(ZoneId.systemDefault()) + .withZoneSameInstant(ZoneId.systemDefault()); + + } catch (DateTimeException dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = ZonedDateTime.now(); + } + return result; + } + + public static Date[] getDateArray(String[] numbers, String format) { + Date[] result = new Date[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = new SimpleDateFormat(format).parse(numbers[i]); + } catch (Exception dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = new Date(); + } return result; } } \ No newline at end of file diff --git a/src/test/resources/basic/NumericDataTypesBuilder.java b/src/test/resources/basic/NumericDataTypesBuilder.java index b56679d..491ac8b 100644 --- a/src/test/resources/basic/NumericDataTypesBuilder.java +++ b/src/test/resources/basic/NumericDataTypesBuilder.java @@ -7,6 +7,9 @@ import java.text.SimpleDateFormat; import java.time.Instant; import java.time.LocalDate; +import java.time.DateTimeException; +import java.time.LocalDateTime; +import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.Date; @@ -209,7 +212,10 @@ public static long[] getLongArray(String[] numbers) { long[] result = new long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0l; } + } catch (NumberFormatException nfe) { + System.out.println("long value expected but was: "+numbers[i]); + result[i] = 0l; + } return result; } @@ -217,7 +223,10 @@ public static Long[] getLongArrayWrap(String[] numbers) { Long[] result = new Long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0L; } + } catch (NumberFormatException nfe) { + System.out.println("Long value expected but was: "+numbers[i]); + result[i] = 0L; + } return result; } @@ -225,7 +234,10 @@ public static float[] getFloatArray(String[] numbers) { float[] result = new float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0f; } + } catch (NumberFormatException nfe) { + System.out.println("float value expected but was: "+numbers[i]); + result[i] = 0.0f; + } return result; } @@ -233,7 +245,10 @@ public static Float[] getFloatArrayWrap(String[] numbers) { Float[] result = new Float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0F; } + } catch (NumberFormatException nfe) { + System.out.println("Float value expected but was: "+numbers[i]); + result[i] = 0.0F; + } return result; } @@ -241,7 +256,10 @@ public static double[] getDoubleArray(String[] numbers) { double[] result = new double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0d; } + } catch (NumberFormatException nfe) { + System.out.println("double value expected but was: "+numbers[i]); + result[i] = 0.0d; + } return result; } @@ -249,7 +267,62 @@ public static Double[] getDoubleArrayWrap(String[] numbers) { Double[] result = new Double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0D; } + } catch (NumberFormatException nfe) { + System.out.println("Double value expected but was: "+numbers[i]); + result[i] = 0.0D; + } + return result; + } + + public static BigInteger[] getBigIntegerArray(String[] numbers) { + BigInteger[] result = new BigInteger[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigInteger(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigInteger value expected but was: "+numbers[i]); + result[i] = new BigInteger("0"); + } + return result; + } + + public static BigDecimal[] getBigDecimalArray(String[] numbers) { + BigDecimal[] result = new BigDecimal[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigDecimal(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigDecimal value expected but was: "+numbers[i]); + result[i] = new BigDecimal("0.0"); + } + return result; + } + + public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) { + ZonedDateTime[] result = new ZonedDateTime[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = LocalDateTime + .parse(numbers[i],DateTimeFormatter.ofPattern(format)) + .atZone(ZoneId.systemDefault()) + .withZoneSameInstant(ZoneId.systemDefault()); + + } catch (DateTimeException dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = ZonedDateTime.now(); + } + return result; + } + + public static Date[] getDateArray(String[] numbers, String format) { + Date[] result = new Date[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = new SimpleDateFormat(format).parse(numbers[i]); + } catch (Exception dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = new Date(); + } return result; } } \ No newline at end of file diff --git a/src/test/resources/date/DateDataTypesBuilder.java b/src/test/resources/date/DateDataTypesBuilder.java index 4c4e842..938749b 100644 --- a/src/test/resources/date/DateDataTypesBuilder.java +++ b/src/test/resources/date/DateDataTypesBuilder.java @@ -7,6 +7,9 @@ import java.text.SimpleDateFormat; import java.time.Instant; import java.time.LocalDate; +import java.time.DateTimeException; +import java.time.LocalDateTime; +import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.Date; @@ -78,7 +81,10 @@ public static long[] getLongArray(String[] numbers) { long[] result = new long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0l; } + } catch (NumberFormatException nfe) { + System.out.println("long value expected but was: "+numbers[i]); + result[i] = 0l; + } return result; } @@ -86,7 +92,10 @@ public static Long[] getLongArrayWrap(String[] numbers) { Long[] result = new Long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0L; } + } catch (NumberFormatException nfe) { + System.out.println("Long value expected but was: "+numbers[i]); + result[i] = 0L; + } return result; } @@ -94,7 +103,10 @@ public static float[] getFloatArray(String[] numbers) { float[] result = new float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0f; } + } catch (NumberFormatException nfe) { + System.out.println("float value expected but was: "+numbers[i]); + result[i] = 0.0f; + } return result; } @@ -102,7 +114,10 @@ public static Float[] getFloatArrayWrap(String[] numbers) { Float[] result = new Float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0F; } + } catch (NumberFormatException nfe) { + System.out.println("Float value expected but was: "+numbers[i]); + result[i] = 0.0F; + } return result; } @@ -110,7 +125,10 @@ public static double[] getDoubleArray(String[] numbers) { double[] result = new double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0d; } + } catch (NumberFormatException nfe) { + System.out.println("double value expected but was: "+numbers[i]); + result[i] = 0.0d; + } return result; } @@ -118,7 +136,62 @@ public static Double[] getDoubleArrayWrap(String[] numbers) { Double[] result = new Double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0D; } + } catch (NumberFormatException nfe) { + System.out.println("Double value expected but was: "+numbers[i]); + result[i] = 0.0D; + } + return result; + } + + public static BigInteger[] getBigIntegerArray(String[] numbers) { + BigInteger[] result = new BigInteger[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigInteger(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigInteger value expected but was: "+numbers[i]); + result[i] = new BigInteger("0"); + } + return result; + } + + public static BigDecimal[] getBigDecimalArray(String[] numbers) { + BigDecimal[] result = new BigDecimal[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigDecimal(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigDecimal value expected but was: "+numbers[i]); + result[i] = new BigDecimal("0.0"); + } + return result; + } + + public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) { + ZonedDateTime[] result = new ZonedDateTime[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = LocalDateTime + .parse(numbers[i],DateTimeFormatter.ofPattern(format)) + .atZone(ZoneId.systemDefault()) + .withZoneSameInstant(ZoneId.systemDefault()); + + } catch (DateTimeException dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = ZonedDateTime.now(); + } + return result; + } + + public static Date[] getDateArray(String[] numbers, String format) { + Date[] result = new Date[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = new SimpleDateFormat(format).parse(numbers[i]); + } catch (Exception dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = new Date(); + } return result; } } \ No newline at end of file diff --git a/src/test/resources/random/RandomValueGeneration.java b/src/test/resources/random/RandomValueGeneration.java index 8accf88..3461388 100644 --- a/src/test/resources/random/RandomValueGeneration.java +++ b/src/test/resources/random/RandomValueGeneration.java @@ -5,6 +5,8 @@ import java.math.BigDecimal; import java.math.BigInteger; +import java.time.ZonedDateTime; +import java.util.Date; @PactDslBodyBuilder public class RandomValueGeneration { @@ -71,6 +73,14 @@ public class RandomValueGeneration { Double[] doubleArrayWrap; + BigInteger[] bigIntegerArray; + + BigDecimal[] bigDecimalArray; + + ZonedDateTime[] zonedDateTimeArray; + + Date[] dateArray; + public Integer getInteger() { return integer; } @@ -318,4 +328,36 @@ public Double[] getDoubleArrayWrap() { public void setDoubleArrayWrap(Double[] doubleArrayWrap) { this.doubleArrayWrap = doubleArrayWrap; } + + public BigInteger[] getBigIntegerArray() { + return bigIntegerArray; + } + + public void setBigIntegerArray(BigInteger[] bigIntegerArray) { + this.bigIntegerArray = bigIntegerArray; + } + + public BigDecimal[] getBigDecimalArray() { + return bigDecimalArray; + } + + public void setBigDecimalArray(BigDecimal[] bigDecimalArray) { + this.bigDecimalArray = bigDecimalArray; + } + + public ZonedDateTime[] getZonedDateTimeArray() { + return zonedDateTimeArray; + } + + public void setZonedDateTimeArray(ZonedDateTime[] zonedDateTimeArray) { + this.zonedDateTimeArray = zonedDateTimeArray; + } + + public Date[] getDateArray() { + return dateArray; + } + + public void setDateArray(Date[] dateArray) { + this.dateArray = dateArray; + } } \ No newline at end of file diff --git a/src/test/resources/random/RandomValueGenerationBuilder.java b/src/test/resources/random/RandomValueGenerationBuilder.java index 2fe97b3..d84666e 100644 --- a/src/test/resources/random/RandomValueGenerationBuilder.java +++ b/src/test/resources/random/RandomValueGenerationBuilder.java @@ -7,6 +7,9 @@ import java.text.SimpleDateFormat; import java.time.Instant; import java.time.LocalDate; +import java.time.DateTimeException; +import java.time.LocalDateTime; +import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.format.DateTimeFormatter; import java.util.Date; @@ -108,6 +111,24 @@ public class RandomValueGenerationBuilder { Double[] doubleArrayWrap = getDoubleArrayWrap(inDoubleArrayWrap); String doubleArrayWrapName = "doubleArrayWrap"; + String[] inBigIntegerArray = {"12345678901234567890123456789012345678901234567890123456789012345678901234567890"}; + BigInteger[] bigIntegerArray = getBigIntegerArray(inBigIntegerArray); + String bigIntegerArrayName = "bigIntegerArray"; + + String[] inBigDecimalArray = {"12345678901234567890123456789012345678901234567890123456789012345678901234567890.901234567890123456789012345678901234567890"}; + BigDecimal[] bigDecimalArray = getBigDecimalArray(inBigDecimalArray); + String bigDecimalArrayName = "bigDecimalArray"; + + String[] inZonedDateTimeArray = {"2024-02-28T13:59-06:00[America/Mexico_City]"}; + String zonedDateTimeArrayFormat = "yyyy-MM-dd'T'HH:mm:ss[.SSSSSS][.SSS]XXX['['VV']']"; + ZonedDateTime[] zonedDateTimeArray = getZonedDateTimeArray(inZonedDateTimeArray,zonedDateTimeArrayFormat); + String zonedDateTimeArrayName = "zonedDateTimeArray"; + + String[] inDateArray = {"Wed Feb 28 13:59:00 CST 2024"}; + String dateArrayFormat = "yyyy-MM-dd"; + Date[] dateArray = getDateArray(inDateArray,dateArrayFormat); + String dateArrayName = "dateArray"; + public RandomValueGenerationBuilder setInteger(final int integer) { this.integer = integer; return this; @@ -263,6 +284,26 @@ public RandomValueGenerationBuilder setDoubleArrayWrap(final Double[] doubleArra return this; } + public RandomValueGenerationBuilder setBigIntegerArray(final BigInteger[] bigIntegerArray) { + this.bigIntegerArray = bigIntegerArray; + return this; + } + + public RandomValueGenerationBuilder setBigDecimalArray(final BigDecimal[] bigDecimalArray) { + this.bigDecimalArray = bigDecimalArray; + return this; + } + + public RandomValueGenerationBuilder setZonedDateTimeArray(final ZonedDateTime[] zonedDateTimeArray) { + this.zonedDateTimeArray = zonedDateTimeArray; + return this; + } + + public RandomValueGenerationBuilder setDateArray(final Date[] dateArray) { + this.dateArray = dateArray; + return this; + } + public DslPart build() { PactDslJsonBody pactDslJsonBody = new PactDslJsonBody(); @@ -389,6 +430,24 @@ public DslPart build() { if (Objects.nonNull(doubleArrayWrap)) { pactDslJsonBody.array(doubleArrayWrapName).stringValue(Arrays.toString(doubleArrayWrap)).closeArray(); } + + if (Objects.nonNull(bigIntegerArray)) { + + pactDslJsonBody.array(bigIntegerArrayName).stringValue(Arrays.toString(bigIntegerArray)).closeArray(); + } + + if (Objects.nonNull(bigDecimalArray)) { + + pactDslJsonBody.array(bigDecimalArrayName).stringValue(Arrays.toString(bigDecimalArray)).closeArray(); + } + + if (Objects.nonNull(zonedDateTimeArray)) { + pactDslJsonBody.array(zonedDateTimeArrayName).stringValue(Arrays.toString(zonedDateTimeArray)).closeArray(); + } + + if (Objects.nonNull(dateArray)) { + pactDslJsonBody.array(dateArrayName).stringValue(Arrays.toString(dateArray)).closeArray(); + } return pactDslJsonBody; } @@ -425,6 +484,10 @@ public RandomValueGeneration buildExpectedInstance() { object.setFloatArrayWrap(this.floatArrayWrap); object.setDoubleArray(this.doubleArray); object.setDoubleArrayWrap(this.doubleArrayWrap); + object.setBigIntegerArray(this.bigIntegerArray); + object.setBigDecimalArray(this.bigDecimalArray); + object.setZonedDateTimeArray(this.zonedDateTimeArray); + object.setDateArray(this.dateArray); return object; } @@ -435,7 +498,10 @@ public static long[] getLongArray(String[] numbers) { long[] result = new long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0l; } + } catch (NumberFormatException nfe) { + System.out.println("long value expected but was: "+numbers[i]); + result[i] = 0l; + } return result; } @@ -443,7 +509,10 @@ public static Long[] getLongArrayWrap(String[] numbers) { Long[] result = new Long[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Long.parseLong(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0L; } + } catch (NumberFormatException nfe) { + System.out.println("Long value expected but was: "+numbers[i]); + result[i] = 0L; + } return result; } @@ -451,7 +520,10 @@ public static float[] getFloatArray(String[] numbers) { float[] result = new float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0f; } + } catch (NumberFormatException nfe) { + System.out.println("float value expected but was: "+numbers[i]); + result[i] = 0.0f; + } return result; } @@ -459,7 +531,10 @@ public static Float[] getFloatArrayWrap(String[] numbers) { Float[] result = new Float[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Float.parseFloat(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0F; } + } catch (NumberFormatException nfe) { + System.out.println("Float value expected but was: "+numbers[i]); + result[i] = 0.0F; + } return result; } @@ -467,7 +542,10 @@ public static double[] getDoubleArray(String[] numbers) { double[] result = new double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0d; } + } catch (NumberFormatException nfe) { + System.out.println("double value expected but was: "+numbers[i]); + result[i] = 0.0d; + } return result; } @@ -475,7 +553,62 @@ public static Double[] getDoubleArrayWrap(String[] numbers) { Double[] result = new Double[numbers.length]; for (int i = 0; i < numbers.length; i++) try { result[i] = Double.parseDouble(numbers[i]); - } catch (NumberFormatException nfe) { result[i] = 0.0D; } + } catch (NumberFormatException nfe) { + System.out.println("Double value expected but was: "+numbers[i]); + result[i] = 0.0D; + } + return result; + } + + public static BigInteger[] getBigIntegerArray(String[] numbers) { + BigInteger[] result = new BigInteger[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigInteger(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigInteger value expected but was: "+numbers[i]); + result[i] = new BigInteger("0"); + } + return result; + } + + public static BigDecimal[] getBigDecimalArray(String[] numbers) { + BigDecimal[] result = new BigDecimal[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { result[i] = new BigDecimal(numbers[i]); + } catch (NumberFormatException nfe) { + System.out.println("BigDecimal value expected but was: "+numbers[i]); + result[i] = new BigDecimal("0.0"); + } + return result; + } + + public static ZonedDateTime[] getZonedDateTimeArray(String[] numbers, String format) { + ZonedDateTime[] result = new ZonedDateTime[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = LocalDateTime + .parse(numbers[i],DateTimeFormatter.ofPattern(format)) + .atZone(ZoneId.systemDefault()) + .withZoneSameInstant(ZoneId.systemDefault()); + + } catch (DateTimeException dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = ZonedDateTime.now(); + } + return result; + } + + public static Date[] getDateArray(String[] numbers, String format) { + Date[] result = new Date[numbers.length]; + for (int i = 0; i < numbers.length; i++) + try { + result[i] = new SimpleDateFormat(format).parse(numbers[i]); + } catch (Exception dte) { + System.out.println("Format["+format+"] expected but was: "+numbers[i]); + System.out.println(" "+dte.getMessage()); + result[i] = new Date(); + } return result; } } \ No newline at end of file