diff --git a/README.md b/README.md index ee589df3..e5400676 100644 --- a/README.md +++ b/README.md @@ -64,6 +64,8 @@ Core lib's Maven group ID is `io.apimatic`, and its artifact ID is `core`. | [`CoreJsonObject`](./src/main/java/io/apimatic/core/utilities/CoreJsonObject.java) | Wrapper class for JSON object | | [`CoreJsonValue`](./src/main/java/io/apimatic/core/utilities/CoreJsonValue.java) | Wrapper class for JSON value | | [`TestHelper`](./src/main/java/io/apimatic/core/utilities/TestHelper.java) | Contains utility methods for comparing objects, arrays and files | +| [`AdditionalProperties`](./src/main/java/io/apimatic/core/types/AdditionalProperties.java) | A generic class for managing additional properties in a model. | +| [`ConversionHelper`](./src/main/java/io/apimatic/core/utilities/ConversionHelper.java) | A Helper class for the coversion of type (provided as function) for all structures (array, map, array of map, n-dimensional arrays etc) supported in the SDK. | ## Interfaces diff --git a/src/main/java/io/apimatic/core/types/AdditionalProperties.java b/src/main/java/io/apimatic/core/types/AdditionalProperties.java new file mode 100644 index 00000000..b1d77592 --- /dev/null +++ b/src/main/java/io/apimatic/core/types/AdditionalProperties.java @@ -0,0 +1,113 @@ +package io.apimatic.core.types; + +import java.lang.reflect.Method; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +import com.fasterxml.jackson.annotation.JsonGetter; + +/** + * A generic class for managing additional properties in a model. + * + * @param the type of the additional properties. + */ +public class AdditionalProperties { + + /** + * Map to store additional properties. + */ + private final Map properties = new LinkedHashMap<>(); + + /** + * Set to store model properties. + */ + private final Set modelProperties = new HashSet<>(); + + /** + * Default constructor. + */ + public AdditionalProperties() { + // Default constructor + } + + /** + * Parameterized constructor. + * @param classInstance The instance of the class with additional properties. + */ + public AdditionalProperties(final Class classInstance) { + Method[] methods = classInstance.getMethods(); + for (Method method : methods) { + JsonGetter jsonGetter = method.getAnnotation(JsonGetter.class); + if (jsonGetter != null) { + modelProperties.add(jsonGetter.value()); + } + } + } + + /** + * Gets the additional properties. + * @return the map of additional properties. + */ + public Map getAdditionalProperties() { + return properties; + } + + /** + * Sets an additional property. + * @param key The key for the additional property. + * @param value The value of the additional property. + * @throws IllegalArgumentException if there is a conflict between the key and + * any model property. + */ + public void setAdditionalProperty(String key, T value) { + if (key == null || key.trim().isEmpty()) { + throw new IllegalArgumentException("Key cannot be null or empty."); + } + + if (modelProperties.contains(key)) { + throw new IllegalArgumentException( + "Key '" + key + "' conflicts with a model property."); + } + + properties.put(key, value); + } + + /** + * Sets an additional property with an option to skip null values. + * @param key The key for the additional property. + * @param value The value of the additional property. + * @param skipNullValue If true, null values will be skipped. + * @throws IllegalArgumentException if there is a conflict between the key and + * any model property. + */ + public void setAdditionalProperty(String key, T value, boolean skipNullValue) { + if (skipNullValue && value == null) { + return; + } + + setAdditionalProperty(key, value); + } + + @Override + public String toString() { + if (properties.isEmpty()) { + return ""; + } + + return properties.entrySet().stream().map(entry -> entry.getKey() + "=" + entry.getValue()) + .collect(Collectors.joining(", ", ", ", "")); + } + + /** + * Gets an additional property by key. + * @param key The key of the additional property to retrieve. + * @return the value of the additional property associated with the given key, + * or null if not found. + */ + public T getAdditionalProperty(String key) { + return properties.get(key); + } +} diff --git a/src/main/java/io/apimatic/core/utilities/ConversionHelper.java b/src/main/java/io/apimatic/core/utilities/ConversionHelper.java new file mode 100644 index 00000000..6dc5ac26 --- /dev/null +++ b/src/main/java/io/apimatic/core/utilities/ConversionHelper.java @@ -0,0 +1,213 @@ +package io.apimatic.core.utilities; + +import java.util.AbstractMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.function.Function; +import java.util.stream.Collectors; + +/** + * A helper class for converting types of various structures supported in the + * SDK. + */ +public final class ConversionHelper { + + /** + * Private constructor to prevent instantiation of this utility class. + */ + private ConversionHelper() { + // Prevent instantiation + } + + /** + * Converts a single object to the specified type. + * + * @param the type to convert to. + * @param value the object to convert. + * @param conversionFunction the function to apply for conversion. + * @return the converted object of type {@code S}, or null if conversion fails. + */ + public static S convertToSimpleType(Object value, Function conversionFunction) { + try { + return conversionFunction.apply(value); + } catch (Exception e) { + return null; + } + } + + /** + * Converts a map of objects to a map of the specified type. + * + * @param the type of values in the resulting map. + * @param value the map of objects to convert. + * @param conversionFunction the function to apply for conversion of each value. + * @return a map with values converted to type {@code S}, or null if conversion + * fails. + */ + @SuppressWarnings("unchecked") + public static Map convertToMap(Object value, + Function conversionFunction) { + if (value == null) { + return null; + } + + try { + Map valueMap = (Map) value; + return valueMap.entrySet().stream() + .map(entry -> new AbstractMap.SimpleEntry<>(entry.getKey(), + convertToSimpleType(entry.getValue(), conversionFunction))) + .filter(entry -> entry.getValue() != null) + .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); + } catch (Exception e) { + return null; + } + } + + /** + * Converts a list of objects to a list of the specified type. + * + * @param the type of elements in the resulting list. + * @param value the list of objects to convert. + * @param conversionFunction the function to apply for conversion of each item. + * @return a list with elements converted to type {@code S}, or null if + * conversion fails. + */ + @SuppressWarnings("unchecked") + public static List convertToArray(Object value, + Function conversionFunction) { + if (value == null) { + return null; + } + + try { + List valueList = (List) value; + return valueList.stream().map(item -> convertToSimpleType(item, conversionFunction)) + .filter(Objects::nonNull).collect(Collectors.toList()); + } catch (Exception e) { + return null; + } + } + + /** + * Converts a list of maps to a list of maps with values of the specified type. + * + * @param the type of values in the maps of the resulting + * list. + * @param value the list of maps to convert. + * @param conversionFunction the function to apply for conversion of each map's + * values. + * @return a list of maps with converted values of type {@code S}, or null if + * conversion fails. + */ + @SuppressWarnings("unchecked") + public static List> convertToArrayOfMap(Object value, + Function conversionFunction) { + if (value == null) { + return null; + } + + try { + List valueList = (List) value; + return valueList.stream().map(item -> convertToMap(item, conversionFunction)) + .filter(map -> map != null && !map.isEmpty()).collect(Collectors.toList()); + } catch (Exception e) { + return null; + } + } + + /** + * Converts a map of lists to a map with lists of the specified type. + * + * @param the type of elements in the lists of the resulting + * map. + * @param value the map of lists to convert. + * @param conversionFunction the function to apply for conversion of each list's + * elements. + * @return a map with lists converted to type {@code S}, or null if conversion + * fails. + */ + @SuppressWarnings("unchecked") + public static Map> convertToMapOfArray(Object value, + Function conversionFunction) { + if (value == null) { + return null; + } + + try { + Map valueMap = (Map) value; + return valueMap.entrySet().stream() + .map(entry -> new AbstractMap.SimpleEntry<>(entry.getKey(), + convertToArray(entry.getValue(), conversionFunction))) + .filter(entry -> entry.getValue() != null && !entry.getValue().isEmpty()) + .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); + } catch (Exception e) { + return null; + } + } + + /** + * Converts an n-dimensional array to a nested list with elements of the + * specified type. + * + * @param the type of the nested structure. + * @param the type of elements in the nested structure. + * @param value the n-dimensional array to convert. + * @param conversionFunction the function to apply for conversion of each + * element. + * @param dimensionCount the depth of the nested structure. + * @return a nested list with elements converted to type {@code S}, or null if + * conversion fails. + */ + @SuppressWarnings("unchecked") + public static T convertToNDimensionalArray(Object value, + Function conversionFunction, + int dimensionCount) { + if (value == null) { + return null; + } + + try { + return (T) convertToNDimensionalArrayInternal(value, + conversionFunction, dimensionCount); + } catch (Exception e) { + return null; + } + } + + /** + * Applies the conversion function to the n-dimensional arrays recursively. + * + * @param the type of elements in the nested structure. + * @param value the n-dimensional array to convert. + * @param conversionFunction the function to apply for conversion of each + * element. + * @param dimensionCount the depth of the nested structure. + * @return a nested list with elements converted to type {@code S}, or null if + * conversion fails. + */ + @SuppressWarnings("unchecked") + private static List convertToNDimensionalArrayInternal(Object value, + Function conversionFunction, + int dimensionCount) { + if (value == null) { + return null; + } + + try { + if (dimensionCount == 1) { + return convertToArray(value, conversionFunction); + } else if (dimensionCount > 1) { + List valueList = (List) value; + return valueList.stream() + .map(item -> convertToNDimensionalArray(item, + conversionFunction, dimensionCount - 1)) + .filter(item -> item != null && !((List) item).isEmpty()) + .collect(Collectors.toList()); + } + } catch (Exception e) { + // Ignoring exception to handle silently. + } + return null; + } +} diff --git a/src/main/java/io/apimatic/core/utilities/CoreHelper.java b/src/main/java/io/apimatic/core/utilities/CoreHelper.java index 231fcf42..328a9d76 100644 --- a/src/main/java/io/apimatic/core/utilities/CoreHelper.java +++ b/src/main/java/io/apimatic/core/utilities/CoreHelper.java @@ -35,6 +35,8 @@ import javax.xml.bind.Unmarshaller; import javax.xml.namespace.QName; import javax.xml.transform.stream.StreamSource; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonGetter; import com.fasterxml.jackson.core.JsonParser; @@ -147,6 +149,10 @@ private static JsonSerializer getCollectionCustomSerializer( * @return The JsonSerializer instance of the required type. */ private static JsonSerializer getSerializer(JsonSerialize serializerAnnotation) { + if (serializerAnnotation == null) { + return null; + } + try { return serializerAnnotation.using().getDeclaredConstructor().newInstance(); } catch (Exception e) { @@ -162,6 +168,10 @@ private static JsonSerializer getSerializer(JsonSerialize serializerAnnotatio * @return The JsonSerializer instance of the required type. */ private static JsonSerializer getCollectionSerializer(JsonSerialize serializerAnnotation) { + if (serializerAnnotation == null) { + return null; + } + try { return serializerAnnotation.contentUsing().getDeclaredConstructor().newInstance(); } catch (Exception e) { @@ -203,6 +213,25 @@ public static String serialize(Object obj) throws JsonProcessingException { return mapper.writeValueAsString(obj); } + /** + * Json Serialization of a given object. + * + * @param obj The object to serialize into Json. + * @return The serialized Json String representation of the given object or null + * if unable to serialize. + */ + public static String trySerialize(Object obj) { + if (obj == null) { + return null; + } + + try { + return serialize(obj); + } catch (JsonProcessingException jpe) { + return null; + } + } + /** * Json Serialization of a given object using a specified JsonSerializer. * @@ -389,6 +418,25 @@ public static T deserialize(String json, Class clazz) thro return mapper.readValue(json, clazz); } + /** + * Json deserialization of the given Json string. + * + * @param The type of the object to deserialize into. + * @param json The Json string to deserialize. + * @param clazz The type of the object to deserialize into. + * @return The deserialized object else null if unable to deserialize. + */ + public static T tryDeserialize(String json, Class clazz) { + if (isNullOrWhiteSpace(json)) { + return null; + } + try { + return deserialize(json, clazz); + } catch (IOException io) { + return null; + } + } + /** * Strict JSON deserialization of the given JSON string with * FAIL_ON_UNKNOWN_PROPERTIES flag as true, used particularly for type @@ -1214,7 +1262,8 @@ private static void objectToList(String objName, Object obj, // Is a public/protected getter or internalGetter? if (method.getParameterTypes().length != 0 - || Modifier.isPrivate(method.getModifiers()) + || (Modifier.isPrivate(method.getModifiers()) + && !method.getName().equals("getAdditionalProperties")) || (!method.getName().startsWith("get") && !method.getName().startsWith("internalGet"))) { continue; @@ -1222,32 +1271,43 @@ private static void objectToList(String objName, Object obj, // Get JsonGetter annotation Annotation getterAnnotation = method.getAnnotation(JsonGetter.class); - if (getterAnnotation == null) { - continue; - } + Annotation anyGetterAnnotation = method.getAnnotation(JsonAnyGetter.class); - // Load key name from getter attribute name - String attribName = ((JsonGetter) getterAnnotation).value(); - if ((objName != null) && (!objName.isEmpty())) { - attribName = String.format("%s[%s]", objName, attribName); + if (getterAnnotation == null && anyGetterAnnotation == null) { + continue; } - try { // Load value by invoking getter method method.setAccessible(true); Object value = method.invoke(obj); JsonSerialize serializerAnnotation = method .getAnnotation(JsonSerialize.class); - // Load key value pair into objectList - if (serializerAnnotation != null) { - loadKeyValuePairForEncoding(attribName, value, objectList, processed, - serializerAnnotation, arraySerializationFormat); + if (getterAnnotation != null) { + // Load key name from getter attribute name + String attribName = ((JsonGetter) getterAnnotation).value(); + if ((objName != null) && (!objName.isEmpty())) { + attribName = String.format("%s[%s]", objName, attribName); + } + + // Load key value pair into objectList + if (serializerAnnotation != null) { + loadKeyValuePairForEncoding(attribName, value, objectList, + processed, serializerAnnotation, arraySerializationFormat); + } else { + loadKeyValuePairForEncoding(attribName, value, objectList, + processed, arraySerializationFormat); + } } else { - loadKeyValuePairForEncoding(attribName, value, objectList, processed, + JsonSerializer serializer = getCollectionSerializer( + serializerAnnotation); + String serializedValue = serialize(value, serializer); + value = serializedValue != null + ? deserializeAsObject(serializedValue) : value; + objectToList(objName, (Map) value, objectList, processed, arraySerializationFormat); } } catch (IllegalAccessException | IllegalArgumentException - | InvocationTargetException e) { + | InvocationTargetException | JsonProcessingException e) { // This block only calls getter methods. // These getters don't throw any exception except invocationTargetException. // The getters are public so there is no chance of an IllegalAccessException diff --git a/src/test/java/apimatic/core/constants/DateTimeConstants.java b/src/test/java/apimatic/core/constants/DateTimeConstants.java new file mode 100644 index 00000000..64425729 --- /dev/null +++ b/src/test/java/apimatic/core/constants/DateTimeConstants.java @@ -0,0 +1,47 @@ +package apimatic.core.constants; + +/** + * A class to store constant values for date and time used in tests. + */ +public final class DateTimeConstants { + + /** + * Private constructor to prevent instantiation of this utility class. + */ + private DateTimeConstants() { + // Prevent instantiation + } + + /** UNIX timestamp representing 1997-06-16 00:00:00 UTC. */ + public static final long UNIXTIMESTAMP3 = 868756200L; + + /** UNIX timestamp representing 2020-07-25 06:10:00 UTC. */ + public static final long UNIXTIMESTAMP2 = 1595639400L; + + /** UNIX timestamp representing 2000-07-13 06:10:00 UTC. */ + public static final long UNIXTIMESTAMP1 = 963450600L; + + /** Day value for the 25th. */ + public static final int DAY25 = 25; + + /** Year value for 2020. */ + public static final int YEAR2020 = 2020; + + /** Year value for 2000. */ + public static final int YEAR2000 = 2000; + + /** Hour value for 6 AM. */ + public static final int HOUR6 = 6; + + /** Day value for the 13th. */ + public static final int DAY13 = 13; + + /** Month value for July. */ + public static final int JULY = 7; + + /** Minute value for 10 minutes. */ + public static final int MINUTES10 = 10; + + /** Year value for 1997. */ + public static final int YEAR1997 = 1997; +} diff --git a/src/test/java/apimatic/core/models/ModelWith3dArrayOfNonPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWith3dArrayOfNonPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..48d41e8e --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWith3dArrayOfNonPrimitiveAdditionalProperties.java @@ -0,0 +1,165 @@ +package apimatic.core.models; + +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; +import io.apimatic.core.utilities.CoreHelper; + +public class ModelWith3dArrayOfNonPrimitiveAdditionalProperties { + + private static final int ARRAY_DIMENSION = 3; + private String company; + private AdditionalProperties>>> additionalProperties = + new AdditionalProperties>>>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWith3dArrayOfNonPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * + * @param company String value for company. + */ + public ModelWith3dArrayOfNonPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map>>> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToNDimensionalArray(value, + x -> CoreHelper.tryDeserialize( + CoreHelper.trySerialize(x), Vehicle.class), + ARRAY_DIMENSION), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public List>> getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ModelWith3dArrayOfNonPrimitiveAdditionalProperties into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWith3dArrayOfNonPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWith3dArrayOfNonPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWith3dArrayOfNonPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWith3dArrayOfNonPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWith3dArrayOfNonPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties>>> additionalProperties = + new AdditionalProperties>>>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, List>> value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWith3dArrayOfNonPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWith3dArrayOfNonPrimitiveAdditionalProperties} + */ + public ModelWith3dArrayOfNonPrimitiveAdditionalProperties build() { + ModelWith3dArrayOfNonPrimitiveAdditionalProperties obj = + new ModelWith3dArrayOfNonPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWith3dArrayOfPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWith3dArrayOfPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..46a819cb --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWith3dArrayOfPrimitiveAdditionalProperties.java @@ -0,0 +1,163 @@ +package apimatic.core.models; + +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; + +public class ModelWith3dArrayOfPrimitiveAdditionalProperties { + + private static final int ARRAY_DIMENSION = 3; + private String company; + private AdditionalProperties>>> additionalProperties = + new AdditionalProperties>>>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWith3dArrayOfPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * + * @param company String value for company. + */ + public ModelWith3dArrayOfPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map>>> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToNDimensionalArray(value, + x -> ((String) x), + ARRAY_DIMENSION), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public List>> getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ChildNumberType into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWith3dArrayOfPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWith3dArrayOfPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWith3dArrayOfPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWith3dArrayOfPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWith3dArrayOfPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties>>> additionalProperties = + new AdditionalProperties>>>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, List>> value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWith3dArrayOfPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ChildNumberType} + */ + public ModelWith3dArrayOfPrimitiveAdditionalProperties build() { + ModelWith3dArrayOfPrimitiveAdditionalProperties obj = + new ModelWith3dArrayOfPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..a2dbda2c --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties.java @@ -0,0 +1,164 @@ +package apimatic.core.models; + +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; +import io.apimatic.core.utilities.CoreHelper; + +public class ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties>> additionalProperties = + new AdditionalProperties>>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * + * @param company String value for company. + + */ + public ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map>> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToArrayOfMap(value, + x -> CoreHelper.tryDeserialize( + CoreHelper.trySerialize(x), Vehicle.class)), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public List> getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties.Builder} object. + */ + public Builder toModelWithArrayOfMapOfNonPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties>> additionalProperties = + new AdditionalProperties>>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, List> value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties} + */ + public ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties build() { + ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties obj = + new ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithArrayOfMapOfPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithArrayOfMapOfPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..58883b9c --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithArrayOfMapOfPrimitiveAdditionalProperties.java @@ -0,0 +1,160 @@ +package apimatic.core.models; + +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; + +public class ModelWithArrayOfMapOfPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties>> additionalProperties = + new AdditionalProperties>>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithArrayOfMapOfPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithArrayOfMapOfPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map>> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToArrayOfMap(value, + x -> (String) x), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public List> getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ChildNumberType into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithArrayOfMapOfPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithArrayOfMapOfPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithArrayOfMapOfPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWithArrayOfMapOfPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithArrayOfMapOfPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties>> additionalProperties = + new AdditionalProperties>>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, List> value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithArrayOfMapOfPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithArrayOfMapOfPrimitiveAdditionalProperties} + */ + public ModelWithArrayOfMapOfPrimitiveAdditionalProperties build() { + ModelWithArrayOfMapOfPrimitiveAdditionalProperties obj = + new ModelWithArrayOfMapOfPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithArrayOfNonPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithArrayOfNonPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..5b4b1c64 --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithArrayOfNonPrimitiveAdditionalProperties.java @@ -0,0 +1,162 @@ +package apimatic.core.models; + +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; +import io.apimatic.core.utilities.CoreHelper; + +public class ModelWithArrayOfNonPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties> additionalProperties = + new AdditionalProperties>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithArrayOfNonPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithArrayOfNonPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToArray(value, + x -> CoreHelper.tryDeserialize( + CoreHelper.trySerialize(x), Vehicle.class)), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public List getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ModelWithArrayOfNonPrimitiveAdditionalProperties into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithArrayOfNonPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithArrayOfNonPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithArrayOfNonPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWithArrayOfNonPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithArrayOfNonPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties> additionalProperties = + new AdditionalProperties>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, List value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithArrayOfNonPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithArrayOfNonPrimitiveAdditionalProperties} + */ + public ModelWithArrayOfNonPrimitiveAdditionalProperties build() { + ModelWithArrayOfNonPrimitiveAdditionalProperties obj = + new ModelWithArrayOfNonPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithArrayOfPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithArrayOfPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..f6b33952 --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithArrayOfPrimitiveAdditionalProperties.java @@ -0,0 +1,160 @@ +package apimatic.core.models; + +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; + +public class ModelWithArrayOfPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties> additionalProperties = + new AdditionalProperties>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithArrayOfPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithArrayOfPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToArray(value, + x -> (String) x), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public List getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ModelWithArrayOfPrimitiveAdditionalProperties into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithArrayOfPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithArrayOfPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithArrayOfPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWithArrayOfPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithArrayOfPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties> additionalProperties = + new AdditionalProperties>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, List value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithArrayOfPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithArrayOfPrimitiveAdditionalProperties} + */ + public ModelWithArrayOfPrimitiveAdditionalProperties build() { + ModelWithArrayOfPrimitiveAdditionalProperties obj = + new ModelWithArrayOfPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithDateTimeAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithDateTimeAdditionalProperties.java new file mode 100644 index 00000000..319589ea --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithDateTimeAdditionalProperties.java @@ -0,0 +1,162 @@ +package apimatic.core.models; + +import java.time.LocalDateTime; +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; +import io.apimatic.core.utilities.LocalDateTimeHelper; + +public class ModelWithDateTimeAdditionalProperties { + + private String company; + private AdditionalProperties additionalProperties = + new AdditionalProperties(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithDateTimeAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithDateTimeAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + @JsonSerialize(contentUsing = LocalDateTimeHelper.Rfc1123DateTimeSerializer.class) + private Map getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToSimpleType(value, + x -> LocalDateTimeHelper.fromRfc1123DateTime(String.valueOf(x))), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public LocalDateTime getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ChildNumberType into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithDateTimeAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithDateTimeAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithDateTimeAdditionalProperties.Builder} object + */ + public Builder toModelWithDateTimeAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithDateTimeAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties additionalProperties = + new AdditionalProperties(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, LocalDateTime value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithDateTimeAdditionalProperties} object using the set fields. + * @return {@link ModelWithDateTimeAdditionalProperties} + */ + public ModelWithDateTimeAdditionalProperties build() { + ModelWithDateTimeAdditionalProperties obj = + new ModelWithDateTimeAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..3f647802 --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties.java @@ -0,0 +1,162 @@ +package apimatic.core.models; + +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; +import io.apimatic.core.utilities.CoreHelper; + +public class ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties>> additionalProperties = + new AdditionalProperties>>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map>> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToMapOfArray(value, + x -> CoreHelper.tryDeserialize( + CoreHelper.trySerialize(x), Vehicle.class)), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public Map> getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ChildNumberType into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWithMapOfArrayOfNonPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties>> additionalProperties = + new AdditionalProperties>>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, Map> value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties} + */ + public ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties build() { + ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties obj = + new ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithMapOfArrayOfPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithMapOfArrayOfPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..2f9b682b --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithMapOfArrayOfPrimitiveAdditionalProperties.java @@ -0,0 +1,160 @@ +package apimatic.core.models; + +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; + +public class ModelWithMapOfArrayOfPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties>> additionalProperties = + new AdditionalProperties>>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithMapOfArrayOfPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithMapOfArrayOfPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map>> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToMapOfArray(value, + x -> (String) x), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public Map> getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ChildNumberType into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithMapOfArrayOfPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithMapOfArrayOfPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithMapOfArrayOfPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWithMapOfArrayOfPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithMapOfArrayOfPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties>> additionalProperties = + new AdditionalProperties>>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, Map> value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithMapOfArrayOfPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithMapOfArrayOfPrimitiveAdditionalProperties} + */ + public ModelWithMapOfArrayOfPrimitiveAdditionalProperties build() { + ModelWithMapOfArrayOfPrimitiveAdditionalProperties obj = + new ModelWithMapOfArrayOfPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithMapOfNonPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithMapOfNonPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..ff664371 --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithMapOfNonPrimitiveAdditionalProperties.java @@ -0,0 +1,161 @@ +package apimatic.core.models; + +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; +import io.apimatic.core.utilities.CoreHelper; + +public class ModelWithMapOfNonPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties> additionalProperties = + new AdditionalProperties>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithMapOfNonPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithMapOfNonPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToMap(value, + x -> CoreHelper.tryDeserialize( + CoreHelper.trySerialize(x), Vehicle.class)), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public Map getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ChildNumberType into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithMapOfNonPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithMapOfNonPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithMapOfNonPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWithMapOfNonPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithMapOfNonPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties> additionalProperties = + new AdditionalProperties>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, Map value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithMapOfNonPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithMapOfNonPrimitiveAdditionalProperties} + */ + public ModelWithMapOfNonPrimitiveAdditionalProperties build() { + ModelWithMapOfNonPrimitiveAdditionalProperties obj = + new ModelWithMapOfNonPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithMapOfPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithMapOfPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..02f2b41f --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithMapOfPrimitiveAdditionalProperties.java @@ -0,0 +1,159 @@ +package apimatic.core.models; + +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; + +public class ModelWithMapOfPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties> additionalProperties = + new AdditionalProperties>(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithMapOfPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithMapOfPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map> getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToMap(value, + x -> (String) x), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public Map getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ModelWithMapOfPrimitiveAdditionalProperties into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithMapOfPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithMapOfPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithMapOfPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWithMapOfPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithMapOfPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties> additionalProperties = + new AdditionalProperties>(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, Map value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithMapOfPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithMapOfPrimitiveAdditionalProperties} + */ + public ModelWithMapOfPrimitiveAdditionalProperties build() { + ModelWithMapOfPrimitiveAdditionalProperties obj = + new ModelWithMapOfPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithNonPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithNonPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..e34a428b --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithNonPrimitiveAdditionalProperties.java @@ -0,0 +1,161 @@ +package apimatic.core.models; + +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; +import io.apimatic.core.utilities.CoreHelper; + +public class ModelWithNonPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties additionalProperties = + new AdditionalProperties(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithNonPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithNonPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToSimpleType(value, + x -> CoreHelper.tryDeserialize( + CoreHelper.trySerialize(x), Vehicle.class)), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public Vehicle getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ChildNumberType into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithNonPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithNonPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithNonPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWithPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithNonPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties additionalProperties = + new AdditionalProperties(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, Vehicle value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithNonPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithNonPrimitiveAdditionalProperties} + */ + public ModelWithNonPrimitiveAdditionalProperties build() { + ModelWithNonPrimitiveAdditionalProperties obj = + new ModelWithNonPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithPrimitiveAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithPrimitiveAdditionalProperties.java new file mode 100644 index 00000000..81c20750 --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithPrimitiveAdditionalProperties.java @@ -0,0 +1,159 @@ +package apimatic.core.models; + +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; + +public class ModelWithPrimitiveAdditionalProperties { + + private String company; + private AdditionalProperties additionalProperties = + new AdditionalProperties(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithPrimitiveAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithPrimitiveAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToSimpleType(value, + x -> (String) x), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public String getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ModelWithPrimitiveAdditionalProperties into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithPrimitiveAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithPrimitiveAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithPrimitiveAdditionalProperties.Builder} object + */ + public Builder toModelWithPrimitiveAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithPrimitiveAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties additionalProperties = + new AdditionalProperties(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, String value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithPrimitiveAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithPrimitiveAdditionalProperties} + */ + public ModelWithPrimitiveAdditionalProperties build() { + ModelWithPrimitiveAdditionalProperties obj = + new ModelWithPrimitiveAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/models/ModelWithTypeCombinatorAdditionalProperties.java b/src/test/java/apimatic/core/models/ModelWithTypeCombinatorAdditionalProperties.java new file mode 100644 index 00000000..06134c97 --- /dev/null +++ b/src/test/java/apimatic/core/models/ModelWithTypeCombinatorAdditionalProperties.java @@ -0,0 +1,162 @@ +package apimatic.core.models; + +import java.util.Map; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonGetter; +import com.fasterxml.jackson.annotation.JsonSetter; + +import apimatic.core.models.containers.SendScalarParamBody; +import io.apimatic.core.types.AdditionalProperties; +import io.apimatic.core.utilities.ConversionHelper; +import io.apimatic.core.utilities.CoreHelper; + +public class ModelWithTypeCombinatorAdditionalProperties { + + private String company; + private AdditionalProperties additionalProperties = + new AdditionalProperties(this.getClass()); + + /** + * Default constructor. + */ + public ModelWithTypeCombinatorAdditionalProperties() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public ModelWithTypeCombinatorAdditionalProperties(final String company) { + this.company = company; + } + + /** + * Getter for Company. + * @return Returns the String + */ + @JsonGetter("company") + public String getCompany() { + return company; + } + + /** + * Setter for Company. + * @param company Value for String + */ + @JsonSetter("company") + public void setCompany(String company) { + this.company = company; + } + + /** + * Any GETTER. Needed for serialization of additional properties. + * @return Returns the map of all additional properties. + */ + @JsonAnyGetter + private Map getAdditionalProperties() { + return additionalProperties.getAdditionalProperties(); + } + + /** + * Any SETTER. Needed for de-serialization of additional properties. + * @param name The String key. + * @param value The Object value. + */ + @JsonAnySetter + private void setAdditionalProperties(String name, Object value) { + additionalProperties.setAdditionalProperty(name, + ConversionHelper.convertToSimpleType(value, + x -> CoreHelper.tryDeserialize( + CoreHelper.trySerialize(x), SendScalarParamBody.class)), + true); + } + + /** + * Provides access to value of additional properties using property name as key. + * @param key The property name, which may or may not be declared. + * @return property associated with the key. + */ + public SendScalarParamBody getAdditionalProperty(String key) { + return additionalProperties.getAdditionalProperty(key); + } + + /** + * Converts this ModelWithTypeCombinatorAdditionalProperties into string format. + * @return String representation of this class + */ + @Override + public String toString() { + return "ModelWithTypeCombinatorAdditionalProperties [" + + "company=" + company + additionalProperties + "]"; + } + + /** + * Builds a new {@link ModelWithTypeCombinatorAdditionalProperties.Builder} object. + * Creates the instance with the state of the current model. + * @return a new {@link ModelWithTypeCombinatorAdditionalProperties.Builder} object + */ + public Builder toModelWithTypeCombinatorAdditionalPropertiesBuilder() { + Builder builder = new Builder(company); + builder.additionalProperties = additionalProperties; + return builder; + } + + /** + * Class to build instances of {@link ModelWithTypeCombinatorAdditionalProperties}. + */ + public static class Builder { + private String company; + private AdditionalProperties additionalProperties = + new AdditionalProperties(); + + /** + * Initialization constructor. + */ + public Builder() { + } + + /** + * Initialization constructor. + * @param company String value for company. + */ + public Builder(final String company) { + this.company = company; + } + + /** + * Setter for company. + * @param company String value for company. + * @return Builder + */ + public Builder company(String company) { + this.company = company; + return this; + } + + /** + * Setter for additionalProperties. + * @param name The String key. + * @param value The String value. + * @return Builder + */ + public Builder additionalProperty(String name, SendScalarParamBody value) { + this.additionalProperties.setAdditionalProperty(name, value); + return this; + } + + /** + * Builds a new {@link ModelWithTypeCombinatorAdditionalProperties} object + * using the set fields. + * @return {@link ModelWithTypeCombinatorAdditionalProperties} + */ + public ModelWithTypeCombinatorAdditionalProperties build() { + ModelWithTypeCombinatorAdditionalProperties obj = + new ModelWithTypeCombinatorAdditionalProperties(company); + obj.additionalProperties = this.additionalProperties; + return obj; + } + } + +} diff --git a/src/test/java/apimatic/core/type/AdditionalPropertiesTest.java b/src/test/java/apimatic/core/type/AdditionalPropertiesTest.java new file mode 100644 index 00000000..091411c6 --- /dev/null +++ b/src/test/java/apimatic/core/type/AdditionalPropertiesTest.java @@ -0,0 +1,349 @@ +package apimatic.core.type; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import java.io.IOException; +import java.time.LocalDateTime; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Test; + +import apimatic.core.constants.DateTimeConstants; +import apimatic.core.models.ModelWith3dArrayOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWith3dArrayOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithArrayOfMapOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithArrayOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithArrayOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithDateTimeAdditionalProperties; +import apimatic.core.models.ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithMapOfArrayOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithMapOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithMapOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithTypeCombinatorAdditionalProperties; +import apimatic.core.models.Vehicle; +import apimatic.core.models.containers.SendScalarParamBody; +import io.apimatic.core.utilities.CoreHelper; +import io.apimatic.core.utilities.LocalDateTimeHelper; + +public class AdditionalPropertiesTest { + @Test + public void testSimpleAdditionalProperties() throws IOException { + ModelWithPrimitiveAdditionalProperties simpleModel = + new ModelWithPrimitiveAdditionalProperties.Builder( + "APIMatic").additionalProperty("name", "value").build(); + + ModelWithPrimitiveAdditionalProperties actualSimpleModel = CoreHelper + .deserialize(CoreHelper.serialize(simpleModel), + ModelWithPrimitiveAdditionalProperties.class); + assertEquals("value", actualSimpleModel.getAdditionalProperty("name")); + + // DateTime Case + ModelWithDateTimeAdditionalProperties dateTimeModel = + new ModelWithDateTimeAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", + LocalDateTime.of(DateTimeConstants.YEAR2000, DateTimeConstants.JULY, + DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10)) + .build(); + + ModelWithDateTimeAdditionalProperties actualDateTimeModel = CoreHelper + .deserialize(CoreHelper.serialize(dateTimeModel), + ModelWithDateTimeAdditionalProperties.class); + assertEquals(LocalDateTimeHelper.fromRfc1123DateTime("Thu, 13 Jul 2000 06:10:00 GMT"), + actualDateTimeModel.getAdditionalProperty("name")); + + // Non-Primitive Case + ModelWithNonPrimitiveAdditionalProperties nonPrimitiveModel = + new ModelWithNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", new Vehicle.Builder("4").build()).build(); + + Vehicle expectedNonPrimitiveModel = new Vehicle.Builder("4").build(); + + ModelWithNonPrimitiveAdditionalProperties actualNonPrimitiveModel = CoreHelper + .deserialize(CoreHelper.serialize(nonPrimitiveModel), + ModelWithNonPrimitiveAdditionalProperties.class); + assertEquals(expectedNonPrimitiveModel.toString(), + actualNonPrimitiveModel.getAdditionalProperty("name").toString()); + } + + @Test + public void testArrayAdditionalProperties() throws IOException { + ModelWithArrayOfPrimitiveAdditionalProperties model = + new ModelWithArrayOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList("value1", "value2")).build(); + + List expectedValue = Arrays.asList("value1", "value2"); + + ModelWithArrayOfPrimitiveAdditionalProperties actualModel = + CoreHelper.deserialize(CoreHelper.serialize(model), + ModelWithArrayOfPrimitiveAdditionalProperties.class); + assertEquals(expectedValue, actualModel.getAdditionalProperty("name")); + + // Non-Primitive Case + ModelWithArrayOfNonPrimitiveAdditionalProperties nonPrimitiveModel = + new ModelWithArrayOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", + Arrays.asList(new Vehicle.Builder("4").build(), + new Vehicle.Builder("5").build())) + .build(); + + List expectedNonPrimitiveModel = Arrays.asList(new Vehicle.Builder("4").build(), + new Vehicle.Builder("5").build()); + + ModelWithArrayOfNonPrimitiveAdditionalProperties actualNonPrimitiveModel = + CoreHelper.deserialize( + CoreHelper.serialize(nonPrimitiveModel), + ModelWithArrayOfNonPrimitiveAdditionalProperties.class); + assertEquals(expectedNonPrimitiveModel.get(0).toString(), + actualNonPrimitiveModel.getAdditionalProperty("name").get(0).toString()); + assertEquals(expectedNonPrimitiveModel.get(1).toString(), + actualNonPrimitiveModel.getAdditionalProperty("name").get(1).toString()); + } + + @SuppressWarnings("serial") + @Test + public void testMapAdditionalProperties() throws IOException { + Map primitiveAdditionalProperties = new HashMap() { + { + put("key1", "value1"); + put("key2", "value2"); + } + }; + ModelWithMapOfPrimitiveAdditionalProperties model = + new ModelWithMapOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", primitiveAdditionalProperties).build(); + + Map expectedValue = new HashMap() { + { + put("key1", "value1"); + put("key2", "value2"); + } + }; + + ModelWithMapOfPrimitiveAdditionalProperties actualModel = CoreHelper.deserialize( + CoreHelper.serialize(model), + ModelWithMapOfPrimitiveAdditionalProperties.class); + assertEquals(expectedValue, actualModel.getAdditionalProperty("name")); + + // Non-Primitive Case + Map nonPrimitiveAdditionalProperties = new HashMap() { + { + put("key1", new Vehicle.Builder("4").build()); + put("key2", new Vehicle.Builder("5").build()); + } + }; + ModelWithMapOfNonPrimitiveAdditionalProperties nonPrimitiveModel = + new ModelWithMapOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", nonPrimitiveAdditionalProperties).build(); + + Map expectedNonPrimitiveModel = new HashMap() { + { + put("key1", new Vehicle.Builder("4").build()); + put("key2", new Vehicle.Builder("5").build()); + } + }; + + ModelWithMapOfNonPrimitiveAdditionalProperties actualNonPrimitiveModel = + CoreHelper.deserialize(CoreHelper.serialize(nonPrimitiveModel), + ModelWithMapOfNonPrimitiveAdditionalProperties.class); + assertEquals(expectedNonPrimitiveModel.get("key1").toString(), + actualNonPrimitiveModel.getAdditionalProperty("name").get("key1").toString()); + } + + @SuppressWarnings("serial") + @Test + public void testMapOfArrayAdditionalProperties() throws IOException { + Map> primitiveAdditionalProperties = + new HashMap>() { + { + put("key1", Arrays.asList("value1", "value2")); + put("key2", Arrays.asList("value1", "value2")); + } + }; + ModelWithMapOfArrayOfPrimitiveAdditionalProperties model = + new ModelWithMapOfArrayOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", primitiveAdditionalProperties).build(); + + Map> expectedValue = new HashMap>() { + { + put("key1", Arrays.asList("value1", "value2")); + put("key2", Arrays.asList("value1", "value2")); + } + }; + + ModelWithMapOfArrayOfPrimitiveAdditionalProperties actualModel = + CoreHelper.deserialize(CoreHelper.serialize(model), + ModelWithMapOfArrayOfPrimitiveAdditionalProperties.class); + assertEquals(expectedValue, actualModel.getAdditionalProperty("name")); + + // Non-Primitive Case + Map> nonPrimitiveAdditionalProperties = + new HashMap>() { + { + put("key1", Arrays.asList(new Vehicle.Builder("4").build())); + put("key2", Arrays.asList(new Vehicle.Builder("5").build())); + } + }; + ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties nonPrimitiveModel = + new ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", nonPrimitiveAdditionalProperties).build(); + + Map> expectedNonPrimitiveModel = + new HashMap>() { + { + put("key1", Arrays.asList(new Vehicle.Builder("4").build())); + put("key2", Arrays.asList(new Vehicle.Builder("5").build())); + } + }; + + ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties actualNonPrimitiveModel = + CoreHelper.deserialize(CoreHelper.serialize(nonPrimitiveModel), + ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties.class); + assertEquals(expectedNonPrimitiveModel.get("key1").get(0).toString(), + actualNonPrimitiveModel.getAdditionalProperty("name") + .get("key1").get(0).toString()); + assertEquals(expectedNonPrimitiveModel.get("key2").get(0).toString(), + actualNonPrimitiveModel.getAdditionalProperty("name") + .get("key2").get(0).toString()); + } + + @SuppressWarnings("serial") + @Test + public void testArrayOfMapAdditionalProperties() throws IOException { + Map primitiveAdditionalProperties = new HashMap() { + { + put("key1", "value1"); + put("key2", "value2"); + } + }; + ModelWithArrayOfMapOfPrimitiveAdditionalProperties model = + new ModelWithArrayOfMapOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList(primitiveAdditionalProperties)).build(); + + List> expectedValue = Arrays.asList(primitiveAdditionalProperties); + + ModelWithArrayOfMapOfPrimitiveAdditionalProperties actualModel = CoreHelper.deserialize( + CoreHelper.serialize(model), + ModelWithArrayOfMapOfPrimitiveAdditionalProperties.class); + assertEquals(expectedValue, actualModel.getAdditionalProperty("name")); + + // Non-Primitive Case + Map nonPrimitiveAdditionalProperties = new HashMap() { + { + put("key1", new Vehicle.Builder("4").build()); + put("key2", new Vehicle.Builder("5").build()); + } + }; + ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties nonPrimitiveModel = + new ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList(nonPrimitiveAdditionalProperties)) + .build(); + + List> expectedNonPrimitiveModel = Arrays.asList( + nonPrimitiveAdditionalProperties); + + ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties actualNonPrimitiveModel = + CoreHelper.deserialize(CoreHelper.serialize(nonPrimitiveModel), + ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties.class); + assertEquals(expectedNonPrimitiveModel.get(0).get("key1").toString(), + actualNonPrimitiveModel.getAdditionalProperty("name") + .get(0).get("key1").toString()); + assertEquals(expectedNonPrimitiveModel.get(0).get("key2").toString(), + actualNonPrimitiveModel.getAdditionalProperty("name") + .get(0).get("key2").toString()); + } + + @Test + public void test3DArrayAdditionalProperties() throws IOException { + ModelWith3dArrayOfPrimitiveAdditionalProperties model = + new ModelWith3dArrayOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList( + Arrays.asList(Arrays.asList("value1", "value2")))) + .build(); + + List>> expectedValue = Arrays.asList(Arrays.asList( + Arrays.asList("value1", "value2"))); + + ModelWith3dArrayOfPrimitiveAdditionalProperties actualModel = CoreHelper.deserialize( + CoreHelper.serialize(model), + ModelWith3dArrayOfPrimitiveAdditionalProperties.class); + assertEquals(expectedValue, actualModel.getAdditionalProperty("name")); + + // Non-Primitive Case + ModelWith3dArrayOfNonPrimitiveAdditionalProperties nonPrimitiveModel = + new ModelWith3dArrayOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList(Arrays.asList(Arrays.asList( + new Vehicle.Builder("4").build(), new Vehicle.Builder("4").build())))) + .build(); + + List>> expectedNonPrimitiveModel = Arrays.asList( + Arrays.asList(Arrays.asList(new Vehicle.Builder("4").build(), + new Vehicle.Builder("4").build()))); + + ModelWith3dArrayOfNonPrimitiveAdditionalProperties actualNonPrimitiveModel = + CoreHelper.deserialize(CoreHelper.serialize(nonPrimitiveModel), + ModelWith3dArrayOfNonPrimitiveAdditionalProperties.class); + assertEquals(expectedNonPrimitiveModel.get(0).get(0).get(0).toString(), + actualNonPrimitiveModel.getAdditionalProperty("name") + .get(0).get(0).get(0).toString()); + } + + @Test + public void testTypeCombinatorAdditionalProperties() throws IOException { + final Double item1 = 100.11; + final Double item2 = 133.00; + // Case A + ModelWithTypeCombinatorAdditionalProperties model = + new ModelWithTypeCombinatorAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", SendScalarParamBody.fromPrecision( + Arrays.asList(item1, item2))) + .build(); + + ModelWithTypeCombinatorAdditionalProperties actualModel = CoreHelper.deserialize( + CoreHelper.serialize(model), ModelWithTypeCombinatorAdditionalProperties.class); + List expectedListValue = Arrays.asList(item1, item2); + actualModel.getAdditionalProperty("name").match(new SendScalarParamBody.Cases() { + + @Override + public Void precision(List actualValue) { + assertEquals(expectedListValue, actualValue); + return null; + } + + @Override + public Void mString(String mString) { + fail("Got unexpected type combinator case."); + return null; + } + }); + + // Case B + model = new ModelWithTypeCombinatorAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", SendScalarParamBody.fromMString("value")).build(); + + actualModel = CoreHelper.deserialize(CoreHelper.serialize(model), + ModelWithTypeCombinatorAdditionalProperties.class); + String expectedStringValue = "value"; + actualModel.getAdditionalProperty("name").match(new SendScalarParamBody.Cases() { + + @Override + public Void precision(List actualValue) { + fail("Got unexpected type combinator case."); + return null; + } + + @Override + public Void mString(String actualValue) { + assertEquals(expectedStringValue, actualValue); + return null; + } + }); + } +} diff --git a/src/test/java/apimatic/core/utilities/ConversionHelperTest.java b/src/test/java/apimatic/core/utilities/ConversionHelperTest.java new file mode 100644 index 00000000..e3c641fb --- /dev/null +++ b/src/test/java/apimatic/core/utilities/ConversionHelperTest.java @@ -0,0 +1,193 @@ +package apimatic.core.utilities; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Function; + +import org.junit.Test; + +import io.apimatic.core.utilities.ConversionHelper; + +public class ConversionHelperTest { + + // Constants + private static final int EXPECTED_SIZE_ONE = 1; + private static final int EXPECTED_SIZE_TWO = 2; + private static final Integer EXPECTED_INTEGER_ONE = Integer.valueOf(1); + private static final Integer EXPECTED_INTEGER_TWO = Integer.valueOf(2); + private static final Integer EXPECTED_INTEGER_THREE = Integer.valueOf(3); + private static final Integer EXPECTED_INTEGER_FOUR = Integer.valueOf(4); + private static final Integer TEST_INTEGER_FIVE = Integer.valueOf(5); + private static final String KEY_ONE = "key1"; + private static final String KEY_TWO = "key2"; + private static final String NON_INTEGER_VALUE = "not an int"; + private static final int DIMENSION_ONE = 1; + private static final int DIMENSION_TWO = 2; + + // Helper function for conversion + private static final Function TO_INTEGER = value -> { + if (value instanceof Number) { + return ((Number) value).intValue(); + } + return null; + }; + + @Test + public void testConvertToSimpleTypeSuccess() { + assertEquals(TEST_INTEGER_FIVE, ConversionHelper.convertToSimpleType( + TEST_INTEGER_FIVE, TO_INTEGER)); + } + + @Test + public void testConvertToSimpleTypeNullConversionFunction() { + assertNull(ConversionHelper.convertToSimpleType("test", TO_INTEGER)); + } + + @Test + public void testConvertToMapSuccess() { + Map input = new HashMap<>(); + input.put(KEY_ONE, EXPECTED_INTEGER_ONE); + input.put(KEY_TWO, EXPECTED_INTEGER_TWO); + Map result = ConversionHelper.convertToMap(input, TO_INTEGER); + assertEquals(EXPECTED_SIZE_TWO, result.size()); + assertEquals(EXPECTED_INTEGER_ONE, result.get(KEY_ONE)); + assertEquals(EXPECTED_INTEGER_TWO, result.get(KEY_TWO)); + } + + @Test + public void testConvertToMapSkipsUnconvertibleValues() { + Map input = new HashMap<>(); + input.put(KEY_ONE, EXPECTED_INTEGER_ONE); + input.put(KEY_TWO, NON_INTEGER_VALUE); + Map result = ConversionHelper.convertToMap(input, TO_INTEGER); + assertEquals(EXPECTED_SIZE_ONE, result.size()); + assertEquals(EXPECTED_INTEGER_ONE, result.get(KEY_ONE)); + assertNull(result.get(KEY_TWO)); + } + + @Test + public void testConvertToMapNullInput() { + assertNull(ConversionHelper.convertToMap(null, TO_INTEGER)); + } + + @Test + public void testConvertToArraySuccess() { + List input = Arrays.asList(EXPECTED_INTEGER_ONE, + EXPECTED_INTEGER_TWO, EXPECTED_INTEGER_THREE); + List result = ConversionHelper.convertToArray(input, TO_INTEGER); + assertEquals(Arrays.asList(EXPECTED_INTEGER_ONE, + EXPECTED_INTEGER_TWO, EXPECTED_INTEGER_THREE), result); + } + + @Test + public void testConvertToArraySkipsUnconvertibleItems() { + List input = Arrays.asList(EXPECTED_INTEGER_ONE, + NON_INTEGER_VALUE, EXPECTED_INTEGER_THREE); + List result = ConversionHelper.convertToArray(input, TO_INTEGER); + assertEquals(Arrays.asList(EXPECTED_INTEGER_ONE, EXPECTED_INTEGER_THREE), result); + } + + @Test + public void testConvertToArrayNullInput() { + assertNull(ConversionHelper.convertToArray(null, TO_INTEGER)); + } + + @Test + public void testConvertToArrayOfMapSuccess() { + List input = new ArrayList<>(); + Map map1 = new HashMap<>(); + map1.put(KEY_ONE, EXPECTED_INTEGER_ONE); + input.add(map1); + List> result = ConversionHelper.convertToArrayOfMap(input, TO_INTEGER); + assertEquals(EXPECTED_SIZE_ONE, result.size()); + assertEquals(EXPECTED_INTEGER_ONE, result.get(0).get(KEY_ONE)); + } + + @Test + public void testConvertToArrayOfMapSkipsEmptyAndUnconvertibleMaps() { + List input = new ArrayList<>(); + Map map1 = new HashMap<>(); + map1.put(KEY_ONE, EXPECTED_INTEGER_ONE); + Map map2 = new HashMap<>(); + map2.put(KEY_TWO, NON_INTEGER_VALUE); + input.add(map1); + input.add(map2); + List> result = ConversionHelper.convertToArrayOfMap(input, TO_INTEGER); + assertEquals(EXPECTED_SIZE_ONE, result.size()); + assertEquals(EXPECTED_INTEGER_ONE, result.get(0).get(KEY_ONE)); + } + + @Test + public void testConvertToArrayOfMapNullInput() { + assertNull(ConversionHelper.convertToArrayOfMap(null, TO_INTEGER)); + } + + @Test + public void testConvertToMapOfArraySuccess() { + Map input = new HashMap<>(); + input.put(KEY_ONE, Arrays.asList(EXPECTED_INTEGER_ONE, EXPECTED_INTEGER_TWO)); + Map> result = ConversionHelper.convertToMapOfArray(input, TO_INTEGER); + assertEquals(EXPECTED_SIZE_ONE, result.size()); + assertEquals(Arrays.asList(EXPECTED_INTEGER_ONE, EXPECTED_INTEGER_TWO), + result.get(KEY_ONE)); + } + + @Test + public void testConvertToMapOfArraySkipsEmptyAndUnconvertibleArrays() { + Map input = new HashMap<>(); + input.put(KEY_ONE, Arrays.asList(EXPECTED_INTEGER_ONE, + NON_INTEGER_VALUE, EXPECTED_INTEGER_THREE)); + input.put(KEY_TWO, Arrays.asList(NON_INTEGER_VALUE)); + Map> result = ConversionHelper.convertToMapOfArray(input, TO_INTEGER); + assertEquals(EXPECTED_SIZE_ONE, result.size()); + assertEquals(Arrays.asList(EXPECTED_INTEGER_ONE, EXPECTED_INTEGER_THREE), + result.get(KEY_ONE)); + } + + @Test + public void testConvertToMapOfArrayNullInput() { + assertNull(ConversionHelper.convertToMapOfArray(null, TO_INTEGER)); + } + + @Test + public void testConvertToNDimensionalArray1DArray() { + List input = Arrays.asList(EXPECTED_INTEGER_ONE, + EXPECTED_INTEGER_TWO, EXPECTED_INTEGER_THREE); + List result = ConversionHelper.convertToNDimensionalArray(input, + TO_INTEGER, DIMENSION_ONE); + assertEquals(Arrays.asList(EXPECTED_INTEGER_ONE, + EXPECTED_INTEGER_TWO, EXPECTED_INTEGER_THREE), result); + } + + @Test + public void testConvertToNDimensionalArray2DArray() { + List input = Arrays.asList( + Arrays.asList(EXPECTED_INTEGER_ONE, EXPECTED_INTEGER_TWO), + Arrays.asList(EXPECTED_INTEGER_THREE, EXPECTED_INTEGER_FOUR)); + List> result = ConversionHelper.convertToNDimensionalArray(input, + TO_INTEGER, DIMENSION_TWO); + assertEquals(Arrays.asList(Arrays.asList(EXPECTED_INTEGER_ONE, EXPECTED_INTEGER_TWO), + Arrays.asList(EXPECTED_INTEGER_THREE, EXPECTED_INTEGER_FOUR)), result); + } + + @Test + public void testConvertToNDimensionalArraySkipsEmptyAndUnconvertibleItems() { + List input = Arrays.asList(Arrays.asList(EXPECTED_INTEGER_ONE, NON_INTEGER_VALUE), + Arrays.asList(EXPECTED_INTEGER_THREE, EXPECTED_INTEGER_FOUR)); + List> result = ConversionHelper.convertToNDimensionalArray(input, + TO_INTEGER, DIMENSION_TWO); + assertEquals(Arrays.asList(Arrays.asList(EXPECTED_INTEGER_ONE), + Arrays.asList(EXPECTED_INTEGER_THREE, EXPECTED_INTEGER_FOUR)), result); + } + + @Test + public void testConvertToNDimensionalArrayNullInput() { + assertNull(ConversionHelper.convertToNDimensionalArray(null, TO_INTEGER, DIMENSION_TWO)); + } +} diff --git a/src/test/java/apimatic/core/utilities/CoreHelperTest.java b/src/test/java/apimatic/core/utilities/CoreHelperTest.java index 560b56a9..09e20d88 100644 --- a/src/test/java/apimatic/core/utilities/CoreHelperTest.java +++ b/src/test/java/apimatic/core/utilities/CoreHelperTest.java @@ -5,6 +5,7 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; + import java.io.IOException; import java.time.LocalDate; import java.time.LocalDateTime; @@ -14,12 +15,15 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.Comparator; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.UUID; + import org.junit.Test; + import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.type.TypeReference; @@ -27,6 +31,8 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.ObjectMapper; + +import apimatic.core.constants.DateTimeConstants; import apimatic.core.mocks.TestDateTimeHelper; import apimatic.core.models.AtomCase; import apimatic.core.models.AttributesAndElements; @@ -35,10 +41,25 @@ import apimatic.core.models.ComplexType; import apimatic.core.models.DateTimeCases; import apimatic.core.models.DeleteBody; +import apimatic.core.models.ModelWith3dArrayOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWith3dArrayOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithArrayOfMapOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithArrayOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithArrayOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithDateTimeAdditionalProperties; +import apimatic.core.models.ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithMapOfArrayOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithMapOfNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithMapOfPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithNonPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithPrimitiveAdditionalProperties; +import apimatic.core.models.ModelWithTypeCombinatorAdditionalProperties; import apimatic.core.models.MorningCase; import apimatic.core.models.NonScalarModel; import apimatic.core.models.OrbitCase; import apimatic.core.models.Person; +import apimatic.core.models.Vehicle; import apimatic.core.models.containers.SendParamsFormDateTime; import apimatic.core.models.containers.SendScalarParamBody; import io.apimatic.core.types.AnyOfValidationException; @@ -103,6 +124,31 @@ public void testSerializeNullObject() throws JsonProcessingException { assertNull(CoreHelper.serialize(obj)); } + @Test + public void testTrySerializeValidObject() { + Vehicle model = new Vehicle.Builder("4").build(); + String expectedJson = "{\"NumberOfTyres\":\"4\"}"; + assertEquals(expectedJson, CoreHelper.trySerialize(model)); + } + + @Test + public void testTrySerializeInvalidObject() { + assertNull(CoreHelper.trySerialize(new Object())); + } + + @Test + public void testTryDeserializeValidJson() { + String json = "{\"NumberOfTyres\":\"4\"}"; + Vehicle expectedModel = new Vehicle.Builder("4").build(); + Vehicle actualModel = CoreHelper.tryDeserialize(json, Vehicle.class); + assertEquals(expectedModel.toString(), actualModel.toString()); + } + + @Test + public void testTryDeserializeInvalidJson() { + assertNull(CoreHelper.tryDeserialize("}{", Vehicle.class)); + } + @Test public void testIsWhiteSpace() { String whiteSpaceString = " "; @@ -374,7 +420,7 @@ public void testAppendTemplateParameters5() { } @Test - public void testptionalNullable() throws IOException { + public void testOptionalNullable() throws IOException { ChildClass child = CoreHelper .deserialize( "{\"Grand_Parent_Required_Nullable\":null,\"Grand_Parent_Required\":" @@ -676,6 +722,281 @@ public void testPrepareFormFieldsModel() { assertEquals(actual, expected); } + @SuppressWarnings("serial") + @Test + public void testPrepareFormFieldsPrimitiveAdditionalPropertiesModel() { + ModelWithPrimitiveAdditionalProperties simple = + new ModelWithPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", "value").build(); + Map formParameters = new HashMap<>(); + formParameters.put("body", simple); + + List> expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name]", "value")); + + List> actual = CoreHelper.prepareFormFields(formParameters, + ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // Array of primitive types + ModelWithArrayOfPrimitiveAdditionalProperties array = + new ModelWithArrayOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList("value1", "value2")).build(); + formParameters = new HashMap<>(); + formParameters.put("body", array); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][0]", "value1")); + expected.add(new SimpleEntry("body[name][1]", "value2")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // Map of primitive types + Map primitiveAdditionalProperties = new HashMap() { + { + put("key1", "value1"); + put("key2", "value2"); + } + }; + ModelWithMapOfPrimitiveAdditionalProperties map = + new ModelWithMapOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", primitiveAdditionalProperties).build(); + formParameters = new HashMap<>(); + formParameters.put("body", map); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][key1]", "value1")); + expected.add(new SimpleEntry("body[name][key2]", "value2")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // Array of Map of primitive types + ModelWithArrayOfMapOfPrimitiveAdditionalProperties arrayOfMap = + new ModelWithArrayOfMapOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList(primitiveAdditionalProperties)).build(); + formParameters = new HashMap<>(); + formParameters.put("body", arrayOfMap); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][0][key1]", "value1")); + expected.add(new SimpleEntry("body[name][0][key2]", "value2")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // Map of Array of primitive types + Map> arrayAdditionalProperties = new HashMap>() { + { + put("key1", Arrays.asList("value1", "value2")); + put("key2", Arrays.asList("value1", "value2")); + } + }; + ModelWithMapOfArrayOfPrimitiveAdditionalProperties mapOfArray = + new ModelWithMapOfArrayOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", arrayAdditionalProperties).build(); + formParameters = new HashMap<>(); + formParameters.put("body", mapOfArray); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][key1][0]", "value1")); + expected.add(new SimpleEntry("body[name][key1][1]", "value2")); + expected.add(new SimpleEntry("body[name][key2][0]", "value1")); + expected.add(new SimpleEntry("body[name][key2][1]", "value2")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // 3D Array of primitive types + ModelWith3dArrayOfPrimitiveAdditionalProperties array3D = + new ModelWith3dArrayOfPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList(Arrays.asList( + Arrays.asList("value1", "value2")))) + .build(); + formParameters = new HashMap<>(); + formParameters.put("body", array3D); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][0][0][0]", "value1")); + expected.add(new SimpleEntry("body[name][0][0][1]", "value2")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + ModelWithDateTimeAdditionalProperties dateTimeModel = + new ModelWithDateTimeAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", + LocalDateTime.of(DateTimeConstants.YEAR2000, DateTimeConstants.JULY, + DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10)) + .build(); + formParameters = new HashMap<>(); + formParameters.put("body", dateTimeModel); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name]", + "Thu, 13 Jul 2000 06:10:00 GMT")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + } + + @SuppressWarnings("serial") + @Test + public void testPrepareFormFieldsNonPrimitiveAdditionalPropertiesModel() { + ModelWithNonPrimitiveAdditionalProperties simpleModel = + new ModelWithNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", new Vehicle.Builder("4").build()).build(); + Map formParameters = new HashMap<>(); + formParameters.put("body", simpleModel); + + List> expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][NumberOfTyres]", "4")); + + List> actual = CoreHelper.prepareFormFields(formParameters, + ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // Array of non primitive types + ModelWithArrayOfNonPrimitiveAdditionalProperties array = + new ModelWithArrayOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList( + new Vehicle.Builder("4").build(), new Vehicle.Builder("5").build())) + .build(); + formParameters = new HashMap<>(); + formParameters.put("body", array); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][0][NumberOfTyres]", "4")); + expected.add(new SimpleEntry("body[name][1][NumberOfTyres]", "5")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // Map of non primitive types + Map nonPrimitiveAdditionalProperties = new HashMap() { + { + put("key1", new Vehicle.Builder("4").build()); + put("key2", new Vehicle.Builder("5").build()); + } + }; + ModelWithMapOfNonPrimitiveAdditionalProperties map = + new ModelWithMapOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", nonPrimitiveAdditionalProperties).build(); + formParameters = new HashMap<>(); + formParameters.put("body", map); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][key1][NumberOfTyres]", "4")); + expected.add(new SimpleEntry("body[name][key2][NumberOfTyres]", "5")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // Array of Map of non primitive types + ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties arrayOfMap = + new ModelWithArrayOfMapOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList(nonPrimitiveAdditionalProperties)) + .build(); + formParameters = new HashMap<>(); + formParameters.put("body", arrayOfMap); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][0][key1][NumberOfTyres]", "4")); + expected.add(new SimpleEntry("body[name][0][key2][NumberOfTyres]", "5")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // Map of Array of non primitive types + Map> arrayNonPrimitiveAdditionalProperties = + new HashMap>() { + { + put("key1", Arrays.asList(new Vehicle.Builder("4").build())); + put("key2", Arrays.asList(new Vehicle.Builder("5").build())); + } + }; + ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties mapOfArray = + new ModelWithMapOfArrayOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", arrayNonPrimitiveAdditionalProperties).build(); + formParameters = new HashMap<>(); + formParameters.put("body", mapOfArray); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][key1][0][NumberOfTyres]", "4")); + expected.add(new SimpleEntry("body[name][key2][0][NumberOfTyres]", "5")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // 3D Array of non primitive types + ModelWith3dArrayOfNonPrimitiveAdditionalProperties array3D = + new ModelWith3dArrayOfNonPrimitiveAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", Arrays.asList(Arrays.asList(Arrays.asList( + new Vehicle.Builder("4").build(), new Vehicle.Builder("5").build())))) + .build(); + formParameters = new HashMap<>(); + formParameters.put("body", array3D); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][0][0][0][NumberOfTyres]", "4")); + expected.add(new SimpleEntry("body[name][0][0][1][NumberOfTyres]", "5")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + // oneOf/anyOf cases + final Double item1 = 100.11; + final Double item2 = 133.0; + ModelWithTypeCombinatorAdditionalProperties typeCombinatorAModel = + new ModelWithTypeCombinatorAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", SendScalarParamBody.fromPrecision( + Arrays.asList(item1, item2))) + .build(); + + formParameters = new HashMap<>(); + formParameters.put("body", typeCombinatorAModel); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name][0]", item1)); + expected.add(new SimpleEntry("body[name][1]", item2)); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + + ModelWithTypeCombinatorAdditionalProperties typeCombinatorBModel = + new ModelWithTypeCombinatorAdditionalProperties.Builder("APIMatic") + .additionalProperty("name", SendScalarParamBody.fromMString("value")) + .build(); + + formParameters = new HashMap<>(); + formParameters.put("body", typeCombinatorBModel); + + expected = new ArrayList>(); + expected.add(new SimpleEntry("body[company]", "APIMatic")); + expected.add(new SimpleEntry("body[name]", "value")); + actual = CoreHelper.prepareFormFields(formParameters, ArraySerializationFormat.INDEXED); + actual.sort(Comparator.comparing(SimpleEntry::getKey)); + assertEquals(expected, actual); + } + @Test public void testPrepareFormFieldsIndexedSerialization() { String bodyText = "test for prepare form fields"; diff --git a/src/test/java/apimatic/core/utilities/LocalDateTimeHelperTest.java b/src/test/java/apimatic/core/utilities/LocalDateTimeHelperTest.java index 8e1fefad..46c45260 100644 --- a/src/test/java/apimatic/core/utilities/LocalDateTimeHelperTest.java +++ b/src/test/java/apimatic/core/utilities/LocalDateTimeHelperTest.java @@ -15,27 +15,18 @@ import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.module.SimpleModule; + +import apimatic.core.constants.DateTimeConstants; import apimatic.core.mocks.TestDateTimeHelper; import io.apimatic.core.utilities.LocalDateTimeHelper; public class LocalDateTimeHelperTest { - - private static final long UNIXTIMESTAMP3 = 868756200L; - private static final long UNITIMESTAMP2 = 1595639400L; - private static final long UNIXTIMESTAMP1 = 963450600L; - private static final int DAY25 = 25; - private static final int YEAR2020 = 2020; - private static final int YEAR2000 = 2000; - private static final int HOUR6 = 6; - private static final int DAY13 = 13; - private static final int JULY = 7; - private static final int MINUTES10 = 10; - private static final int YEAR1997 = 1997; - @Test public void testLocalDateTimeToRfc1123() { - LocalDateTime dateTime = LocalDateTime.of(YEAR1997, JULY, DAY13, HOUR6, MINUTES10); + LocalDateTime dateTime = LocalDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); // stub String expected = "Sun, 13 Jul 1997 06:10:00 GMT"; @@ -51,13 +42,17 @@ public void testLocalDateTimeNullToRfc1123() { @Test public void testLocalDateTimeListToRfc1123() { - LocalDateTime dateTime1 = LocalDateTime.of(YEAR2000, JULY, DAY13, HOUR6, MINUTES10); - LocalDateTime dateTime2 = LocalDateTime.of(YEAR2020, JULY, DAY25, HOUR6, MINUTES10); + LocalDateTime dateTime1 = LocalDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); + LocalDateTime dateTime2 = LocalDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); List dateTimeArray = Arrays.asList(dateTime1, dateTime2); // stub - List expected = - Arrays.asList("Thu, 13 Jul 2000 06:10:00 GMT", "Sat, 25 Jul 2020 06:10:00 GMT"); + List expected = Arrays.asList("Thu, 13 Jul 2000 06:10:00 GMT", + "Sat, 25 Jul 2020 06:10:00 GMT"); assertEquals(LocalDateTimeHelper.toRfc1123DateTime(dateTimeArray), expected); } @@ -68,11 +63,14 @@ public void testLocalDateTimeNullListToRfc1123() { assertNull(LocalDateTimeHelper.toRfc1123DateTime(dateTimeArray)); } - @Test public void testLocalDateTimeMapToRfc1123() { - LocalDateTime dateTime1 = LocalDateTime.of(YEAR2000, JULY, DAY13, HOUR6, MINUTES10); - LocalDateTime dateTime2 = LocalDateTime.of(YEAR2020, JULY, DAY25, HOUR6, MINUTES10); + LocalDateTime dateTime1 = LocalDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); + LocalDateTime dateTime2 = LocalDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); Map dateTimeMap = new HashMap<>(); dateTimeMap.put("dateTime1", dateTime1); dateTimeMap.put("dateTime2", dateTime2); @@ -88,8 +86,12 @@ public void testLocalDateTimeMapToRfc1123() { @Test public void testLocalDateTimeListOfMapToRfc1123() { - LocalDateTime dateTime1 = LocalDateTime.of(YEAR2000, JULY, DAY13, HOUR6, MINUTES10); - LocalDateTime dateTime2 = LocalDateTime.of(YEAR2020, JULY, DAY25, HOUR6, MINUTES10); + LocalDateTime dateTime1 = LocalDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); + LocalDateTime dateTime2 = LocalDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); Map dateTimeMap = new HashMap<>(); dateTimeMap.put("dateTime1", dateTime1); dateTimeMap.put("dateTime2", dateTime2); @@ -121,10 +123,11 @@ public void testLocalDateTimeMapValidateToRfc1123() { assertNull(LocalDateTimeHelper.toRfc1123DateTime(dateTimeMap)); } - @Test public void testLocalDateTimeToRfc8601() { - LocalDateTime dateTime = LocalDateTime.of(YEAR1997, JULY, DAY13, HOUR6, MINUTES10); + LocalDateTime dateTime = LocalDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); // stub String expected = "1997-07-13T06:10Z"; @@ -140,13 +143,16 @@ public void testLocalDateTimeNullToRfc8601() { @Test public void testLocalDateTimeListToRfc8601() { - LocalDateTime dateTime1 = LocalDateTime.of(YEAR2000, JULY, DAY13, HOUR6, MINUTES10); - LocalDateTime dateTime2 = LocalDateTime.of(YEAR2020, JULY, DAY25, HOUR6, MINUTES10); + LocalDateTime dateTime1 = LocalDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); + LocalDateTime dateTime2 = LocalDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); List dateTimeArray = Arrays.asList(dateTime1, dateTime2); // stub List expected = Arrays.asList("2000-07-13T06:10Z", "2020-07-25T06:10Z"); - assertEquals(LocalDateTimeHelper.toRfc8601DateTime(dateTimeArray), expected); } @@ -156,11 +162,14 @@ public void testLocalDateTimeNullListToRfc8601() { assertNull(LocalDateTimeHelper.toRfc8601DateTime(dateTimeArray)); } - @Test public void testLocalDateTimeMapToRfc8601() { - LocalDateTime dateTime1 = LocalDateTime.of(YEAR2000, JULY, DAY13, HOUR6, MINUTES10); - LocalDateTime dateTime2 = LocalDateTime.of(YEAR2020, JULY, DAY25, HOUR6, MINUTES10); + LocalDateTime dateTime1 = LocalDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); + LocalDateTime dateTime2 = LocalDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); Map dateTimeMap = new HashMap<>(); dateTimeMap.put("dateTime1", dateTime1); dateTimeMap.put("dateTime2", dateTime2); @@ -176,8 +185,12 @@ public void testLocalDateTimeMapToRfc8601() { @Test public void testLocalDateTimeListOfMapToRfc8601() { - LocalDateTime dateTime1 = LocalDateTime.of(YEAR2000, JULY, DAY13, HOUR6, MINUTES10); - LocalDateTime dateTime2 = LocalDateTime.of(YEAR2020, JULY, DAY25, HOUR6, MINUTES10); + LocalDateTime dateTime1 = LocalDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); + LocalDateTime dateTime2 = LocalDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); Map dateTimeMap = new HashMap<>(); dateTimeMap.put("dateTime1", dateTime1); dateTimeMap.put("dateTime2", dateTime2); @@ -209,12 +222,12 @@ public void testLocalDateTimeMapValidateToRfc8601() { assertNull(LocalDateTimeHelper.toRfc8601DateTime(dateTimeMap)); } - @Test public void testLocalDateTimeToUnixTimeStamp() { - LocalDateTime dateTime = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR1997, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); // stub String expected = "868756200"; assertEquals(LocalDateTimeHelper.toUnixTimestamp(dateTime), expected); @@ -229,18 +242,19 @@ public void testLocalDateTimeNullToUnixTimeStamp() { @Test public void testLocalDateTimeListToUnixTimeStamp() { - LocalDateTime dateTime1 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2000, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); - LocalDateTime dateTime2 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2020, JULY, DAY25, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime1 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime2 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); List dateTimeArray = Arrays.asList(dateTime1, dateTime2); // stub List expected = Arrays.asList("963450600", "1595639400"); - assertEquals(LocalDateTimeHelper.toUnixTimestamp(dateTimeArray), expected); } @@ -250,15 +264,16 @@ public void testLocalDateTimeNullListToUnixTimeStamp() { assertNull(LocalDateTimeHelper.toUnixTimestamp(dateTimeArray)); } - @Test public void testLocalDateTimeMapToUnixTimeStamp() { - LocalDateTime dateTime1 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2000, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); - LocalDateTime dateTime2 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2020, JULY, DAY25, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime1 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime2 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); Map dateTimeMap = new HashMap<>(); dateTimeMap.put("dateTime1", dateTime1); dateTimeMap.put("dateTime2", dateTime2); @@ -274,12 +289,14 @@ public void testLocalDateTimeMapToUnixTimeStamp() { @Test public void testListOfMapToUnixTimeStamp() { - LocalDateTime dateTime1 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2000, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); - LocalDateTime dateTime2 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2020, JULY, DAY25, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime1 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime2 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); Map dateTimeMap = new HashMap<>(); dateTimeMap.put("dateTime1", dateTime1); dateTimeMap.put("dateTime2", dateTime2); @@ -313,11 +330,12 @@ public void testLocalDateTimeMapValidateToUnixTimeStamp() { @Test public void testUnixDateTimeLong() { - LocalDateTime dateTime = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR1997, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); - Long expectedValue = UNIXTIMESTAMP3; + Long expectedValue = DateTimeConstants.UNIXTIMESTAMP3; Long actualValue = LocalDateTimeHelper.toUnixTimestampLong(dateTime); assertEquals(actualValue, expectedValue); @@ -334,17 +352,19 @@ public void testNullUnixDateTimeLong() { @Test public void testListToUnixTimeLong() { - LocalDateTime dateTime1 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2000, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); - LocalDateTime dateTime2 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2020, JULY, DAY25, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime1 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime2 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); List dateTimeArray = Arrays.asList(dateTime1, dateTime2); // stub - List expected = Arrays.asList(UNIXTIMESTAMP1, UNITIMESTAMP2); - + List expected = Arrays.asList(DateTimeConstants.UNIXTIMESTAMP1, + DateTimeConstants.UNIXTIMESTAMP2); assertEquals(LocalDateTimeHelper.toUnixTimestampLong(dateTimeArray), expected); } @@ -357,20 +377,22 @@ public void testNullListToUnixTimeLong() { @Test public void testLocalDateTimeMapToUnixTimeLong() { - LocalDateTime dateTime1 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2000, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); - LocalDateTime dateTime2 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2020, JULY, DAY25, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime1 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime2 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); Map dateTimeMap = new HashMap<>(); dateTimeMap.put("dateTime1", dateTime1); dateTimeMap.put("dateTime2", dateTime2); // stub Map expected = new HashMap<>(); - expected.put("dateTime1", UNIXTIMESTAMP1); - expected.put("dateTime2", UNITIMESTAMP2); + expected.put("dateTime1", DateTimeConstants.UNIXTIMESTAMP1); + expected.put("dateTime2", DateTimeConstants.UNIXTIMESTAMP2); assertEquals(LocalDateTimeHelper.toUnixTimestampLong(dateTimeMap), expected); @@ -378,12 +400,14 @@ public void testLocalDateTimeMapToUnixTimeLong() { @Test public void testListOfMapToUnixTimeLong() { - LocalDateTime dateTime1 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2000, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); - LocalDateTime dateTime2 = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2020, JULY, DAY25, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime1 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime dateTime2 = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2020, + DateTimeConstants.JULY, DateTimeConstants.DAY25, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); Map dateTimeMap = new HashMap<>(); dateTimeMap.put("dateTime1", dateTime1); dateTimeMap.put("dateTime2", dateTime2); @@ -392,8 +416,8 @@ public void testListOfMapToUnixTimeLong() { // stub Map mapOfLong = new HashMap<>(); - mapOfLong.put("dateTime1", UNIXTIMESTAMP1); - mapOfLong.put("dateTime2", UNITIMESTAMP2); + mapOfLong.put("dateTime1", DateTimeConstants.UNIXTIMESTAMP1); + mapOfLong.put("dateTime2", DateTimeConstants.UNIXTIMESTAMP2); List> expected = Arrays.asList(mapOfLong); @@ -415,13 +439,13 @@ public void testLocalDateTimeMapValidateToUnixTimeLong() { assertNull(LocalDateTimeHelper.toUnixTimestampLong(dateTimeMap)); } - @Test public void testFromUnixTimeStampLong() { - LocalDateTime expected = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2000, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); - Long date = UNIXTIMESTAMP1; + LocalDateTime expected = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); + Long date = DateTimeConstants.UNIXTIMESTAMP1; LocalDateTime actualValue = LocalDateTimeHelper.fromUnixTimestamp(date); assertEquals(actualValue, expected); @@ -429,9 +453,10 @@ public void testFromUnixTimeStampLong() { @Test public void testFromUnixTimeStampString() { - LocalDateTime expected = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR2000, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime expected = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR2000, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); String date = "963450600"; LocalDateTime actualValue = LocalDateTimeHelper.fromUnixTimestamp(date); @@ -441,7 +466,9 @@ public void testFromUnixTimeStampString() { @Test public void testFromRfc1123String() { String date = "Sun, 13 Jul 1997 06:10:00 GMT"; - LocalDateTime expected = LocalDateTime.of(YEAR1997, JULY, DAY13, HOUR6, MINUTES10); + LocalDateTime expected = LocalDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, + DateTimeConstants.HOUR6, DateTimeConstants.MINUTES10); LocalDateTime actualValue = LocalDateTimeHelper.fromRfc1123DateTime(date); assertEquals(actualValue, expected); } @@ -449,7 +476,9 @@ public void testFromRfc1123String() { @Test public void testFromRfc8601String() { String date = "1997-07-13T06:10Z"; - LocalDateTime expected = LocalDateTime.of(YEAR1997, JULY, DAY13, HOUR6, MINUTES10); + LocalDateTime expected = LocalDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); LocalDateTime actualValue = LocalDateTimeHelper.fromRfc8601DateTime(date); assertEquals(actualValue, expected); } @@ -457,7 +486,9 @@ public void testFromRfc8601String() { @SuppressWarnings("unchecked") @Test public void testRfc1123Serializer() throws JsonProcessingException { - LocalDateTime localDateTime = LocalDateTime.of(YEAR1997, JULY, DAY13, HOUR6, MINUTES10); + LocalDateTime localDateTime = LocalDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); @SuppressWarnings("rawtypes") JsonSerializer serializer = new LocalDateTimeHelper.Rfc1123DateTimeSerializer(); ObjectMapper mapper = new ObjectMapper(); @@ -483,7 +514,9 @@ public void testRfc1123Deserializer() throws JsonProcessingException { mapper.registerModule(module); String datetime = "\"Sun, 13 Jul 1997 06:10:00 GMT\""; - LocalDateTime expected = LocalDateTime.of(YEAR1997, JULY, DAY13, HOUR6, MINUTES10); + LocalDateTime expected = LocalDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); LocalDateTime actual = mapper.readValue(datetime, LocalDateTime.class); assertEquals(actual, expected); } @@ -491,7 +524,9 @@ public void testRfc1123Deserializer() throws JsonProcessingException { @SuppressWarnings("unchecked") @Test public void testRfc8601Serializer() throws JsonProcessingException { - LocalDateTime localDateTime = LocalDateTime.of(YEAR1997, JULY, DAY13, HOUR6, MINUTES10); + LocalDateTime localDateTime = LocalDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); @SuppressWarnings("rawtypes") JsonSerializer serializer = new LocalDateTimeHelper.Rfc8601DateTimeSerializer(); ObjectMapper mapper = new ObjectMapper(); @@ -517,7 +552,9 @@ public void testRfc8601Deserializer() throws JsonProcessingException { mapper.registerModule(module); String dateTime = "\"1997-07-13T06:10Z\""; - LocalDateTime expected = LocalDateTime.of(YEAR1997, JULY, DAY13, HOUR6, MINUTES10); + LocalDateTime expected = LocalDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, DateTimeConstants.HOUR6, + DateTimeConstants.MINUTES10); LocalDateTime actual = mapper.readValue(dateTime, LocalDateTime.class); assertEquals(actual, expected); } @@ -525,9 +562,10 @@ public void testRfc8601Deserializer() throws JsonProcessingException { @SuppressWarnings("unchecked") @Test public void testUnixTimeStampSerializer() throws JsonProcessingException { - LocalDateTime localDateTime = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR1997, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime localDateTime = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); @SuppressWarnings("rawtypes") JsonSerializer serializer = new LocalDateTimeHelper.UnixTimestampSerializer(); ObjectMapper mapper = new ObjectMapper(); @@ -551,9 +589,10 @@ public void testUnixTimeStampDeSerializer() throws JsonProcessingException { mapper.registerModule(module); String dateTime = "868756200"; - LocalDateTime expected = - TestDateTimeHelper.getLocalDateTimeFromGMT(ZonedDateTime.of(YEAR1997, JULY, DAY13, - 1, MINUTES10, 0, 0, ZoneId.of("GMT"))); + LocalDateTime expected = TestDateTimeHelper + .getLocalDateTimeFromGMT(ZonedDateTime.of(DateTimeConstants.YEAR1997, + DateTimeConstants.JULY, DateTimeConstants.DAY13, 1, + DateTimeConstants.MINUTES10, 0, 0, ZoneId.of("GMT"))); LocalDateTime actual = mapper.readValue(dateTime, LocalDateTime.class); assertEquals(actual, expected); }