[DEV] update new aknot
This commit is contained in:
parent
9069a26622
commit
1812bfccf1
12
.classpath
12
.classpath
@ -17,7 +17,17 @@
|
||||
<attribute name="test" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry combineaccessrules="false" kind="src" path="/atriasoft-etk">
|
||||
<classpathentry combineaccessrules="false" exported="true" kind="src" path="/atriasoft-aknot">
|
||||
<attributes>
|
||||
<attribute name="module" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry combineaccessrules="false" exported="true" kind="src" path="/atriasoft-etk">
|
||||
<attributes>
|
||||
<attribute name="module" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry combineaccessrules="false" exported="true" kind="src" path="/scenarium-logger">
|
||||
<attributes>
|
||||
<attribute name="module" value="true"/>
|
||||
</attributes>
|
||||
|
||||
@ -11,9 +11,9 @@ open module org.atriasoft.exml {
|
||||
exports org.atriasoft.exml.exception;
|
||||
exports org.atriasoft.exml.builder;
|
||||
exports org.atriasoft.exml.parser;
|
||||
exports org.atriasoft.exml.annotation;
|
||||
|
||||
requires transitive org.atriasoft.etk;
|
||||
requires transitive org.atriasoft.aknot;
|
||||
requires transitive io.scenarium.logger;
|
||||
requires java.base;
|
||||
|
||||
|
||||
@ -12,8 +12,8 @@ import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
|
||||
import org.atriasoft.aknot.model.InterfaceFactoryAccess;
|
||||
import org.atriasoft.etk.Uri;
|
||||
import org.atriasoft.exml.annotation.XmlFactory.InterfaceXmlFactoryAccess;
|
||||
import org.atriasoft.exml.builder.Builder;
|
||||
import org.atriasoft.exml.builder.BuilderGeneric;
|
||||
import org.atriasoft.exml.builder.BuilderIntrospection;
|
||||
@ -134,7 +134,7 @@ public class Exml {
|
||||
}
|
||||
}
|
||||
|
||||
public static Object[] parse(final String data, final InterfaceXmlFactoryAccess widgetXmlFactory) throws ExmlException, ExmlParserErrorMulti {
|
||||
public static Object[] parse(final String data, final InterfaceFactoryAccess widgetXmlFactory) throws ExmlException, ExmlParserErrorMulti {
|
||||
Builder builder;
|
||||
try {
|
||||
builder = new BuilderIntrospection(widgetXmlFactory);
|
||||
|
||||
@ -1,19 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Meta-annotation (annotations used on other annotations)
|
||||
* used for marking all annotations that are
|
||||
* part of Exml package. Can be used for recognizing all
|
||||
* Exml annotations generically, and in future also for
|
||||
* passing other generic annotation configuration.
|
||||
*/
|
||||
@Target(ElementType.ANNOTATION_TYPE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface ExmlAnnotation {
|
||||
// for now, a pure tag annotation, no parameters
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that set the Xml element seen as a property.
|
||||
*/
|
||||
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER })
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlAttribute {
|
||||
/**
|
||||
* Set at true to set the element managed as a property of the Xml node
|
||||
* @return property management.
|
||||
*/
|
||||
boolean value() default true;
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that to set the element is case sensitive or not.
|
||||
*
|
||||
*/
|
||||
@Target({ ElementType.FIELD, ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER })
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlCaseSensitive {
|
||||
/**
|
||||
* Set if the element is is case sensitive.
|
||||
* @return true if case sensitive
|
||||
*/
|
||||
boolean value() default true;
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that permit to set the default parsing as attributes.
|
||||
*/
|
||||
@Target(ElementType.TYPE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlDefaultAttibute {
|
||||
/**
|
||||
* Set this to false to select the attribute as default.
|
||||
* @return true select default attribute, false select default element.
|
||||
*/
|
||||
boolean value() default true;
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that permit to select if the parsing is case sensitive or not.
|
||||
*/
|
||||
@Target(ElementType.TYPE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlDefaultCaseSensitive {
|
||||
/**
|
||||
* Set this at true to set all the element are case sensitive.
|
||||
* @return true if the element are by default case_sensitive.
|
||||
*/
|
||||
boolean value() default true;
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that set the element are not managed by default. Need to add @XmlManaged to be enable.
|
||||
*
|
||||
*/
|
||||
@Target(ElementType.TYPE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlDefaultManaged {
|
||||
/**
|
||||
* Set this at false to remove all the field and the function from Xml introspection
|
||||
* @return true if the element are by default managed.
|
||||
*/
|
||||
boolean value() default true;
|
||||
}
|
||||
@ -1,18 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
@Target(ElementType.TYPE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlDefaultNullValue {
|
||||
/**
|
||||
* Set the default value at true in the constructor if needed (set at 0 for basic type int, long ...).
|
||||
* @return true if the element are by default at null.
|
||||
*/
|
||||
boolean value() default true;
|
||||
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that set the element not found are ignored.
|
||||
*
|
||||
*/
|
||||
@Target(ElementType.TYPE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlDefaultOptional {
|
||||
/**
|
||||
* Set this at true to set all the element optional.
|
||||
* @return true if the element are by default optional.
|
||||
*/
|
||||
boolean value() default false;
|
||||
}
|
||||
@ -1,40 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Marker annotation that permit to set the default parsing as attributes.
|
||||
*/
|
||||
@Target(ElementType.METHOD)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlFactory {
|
||||
public interface InterfaceXmlFactoryAccess {
|
||||
/**
|
||||
* Find the class type with the specific name.
|
||||
* @param name Name of the node to find.
|
||||
* @return Value of the class interface to create or null.
|
||||
*/
|
||||
Class<?> findClass(String name);
|
||||
|
||||
/**
|
||||
* Retrieve the name of the node in xml for the specific Object.
|
||||
* @param object The object that we need to find the type name.
|
||||
* @return The xml string to inject (or null).
|
||||
*/
|
||||
String generateName(Object object);
|
||||
|
||||
Map<String, Class<?>> getConversionMap();
|
||||
}
|
||||
|
||||
/**
|
||||
* Set this to false to select the attribute as default.
|
||||
* @return true select default attribute, false select default element.
|
||||
*/
|
||||
Class<?> value();
|
||||
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that permit to set the default parsing as attributes.
|
||||
*/
|
||||
@Target(ElementType.TYPE)
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlIgnoreUnknow {
|
||||
/**
|
||||
* Set the element ignore unknown Nodes.
|
||||
* @return true does not display unknown node.
|
||||
*/
|
||||
boolean value() default true;
|
||||
}
|
||||
@ -1,29 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that can be used to define a group list of element:
|
||||
* {@code
|
||||
* <GROUP>
|
||||
* <NAME> ... </NAME>
|
||||
* <NAME> ... </NAME>
|
||||
* <NAME> ... </NAME>
|
||||
* </GROUP>
|
||||
* }
|
||||
* @apiNote To change the group name @see XmlName
|
||||
*/
|
||||
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER })
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlList {
|
||||
|
||||
/**
|
||||
* Element names node
|
||||
* @return The name of the elements
|
||||
*/
|
||||
String value();
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that force the xml Parser to manage this element (used when the class is mark as @XmldefaultNotManaged).
|
||||
*
|
||||
*/
|
||||
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlManaged {
|
||||
/**
|
||||
* Set this at false to remove this function or this field form the XML parsing system
|
||||
* @return true if the element is managed.
|
||||
*/
|
||||
boolean value() default true;
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that can be used to define an other name of the attribute or the Element name.
|
||||
*
|
||||
*/
|
||||
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER })
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlName {
|
||||
|
||||
/**
|
||||
* Names of the property of the Element name
|
||||
* @note The first name if the default generated in serialization.
|
||||
* @return The list the the possible names
|
||||
* @apiNote this is incompatible with XmlModel
|
||||
*/
|
||||
String[] value();
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that to ignore the element if not present in the XML, the default case the parser throw a missing error.
|
||||
*
|
||||
*/
|
||||
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER })
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlOptional {
|
||||
/**
|
||||
* Set if the element is optional or not. If optional, the parser does not throw error if the element is not declared.
|
||||
* @return thru if optional
|
||||
*/
|
||||
boolean value() default true;
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
package org.atriasoft.exml.annotation;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Marker annotation that set the Xml element seen as a property.
|
||||
*/
|
||||
@Target({ ElementType.FIELD, ElementType.METHOD })
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@ExmlAnnotation
|
||||
public @interface XmlText {
|
||||
/**
|
||||
* Set at true to set the element used as text data as a property of the Xml node
|
||||
* @return property management.
|
||||
*/
|
||||
boolean value() default true;
|
||||
}
|
||||
@ -3,8 +3,8 @@ package org.atriasoft.exml.builder;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.aknot.model.InterfaceFactoryAccess;
|
||||
import org.atriasoft.eStringSerialize.StringSerializer;
|
||||
import org.atriasoft.exml.annotation.XmlFactory.InterfaceXmlFactoryAccess;
|
||||
import org.atriasoft.exml.exception.ExmlAttributeDoesNotExist;
|
||||
import org.atriasoft.exml.exception.ExmlBuilderException;
|
||||
import org.atriasoft.exml.exception.ExmlException;
|
||||
@ -16,9 +16,9 @@ public class BuilderIntrospection implements Builder {
|
||||
// The root class (need to keep it if we use 2 time the builder, the root class is no more accessible).
|
||||
final Class<?> rootClassType;
|
||||
final String rootNodeName;
|
||||
final InterfaceXmlFactoryAccess factory;
|
||||
final InterfaceFactoryAccess factory;
|
||||
|
||||
public BuilderIntrospection(final InterfaceXmlFactoryAccess factory) throws ExmlException {
|
||||
public BuilderIntrospection(final InterfaceFactoryAccess factory) throws ExmlException {
|
||||
this.factory = factory;
|
||||
this.rootNodeName = null;
|
||||
this.rootClassType = null;
|
||||
|
||||
@ -13,14 +13,14 @@ import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import org.atriasoft.aknot.reflect.ReflectClass;
|
||||
import org.atriasoft.aknot.reflect.ReflectTools;
|
||||
import org.atriasoft.eStringSerialize.StringSerializer;
|
||||
import org.atriasoft.etk.util.ArraysTools;
|
||||
import org.atriasoft.exml.exception.ExmlBuilderException;
|
||||
import org.atriasoft.exml.internal.Log;
|
||||
import org.atriasoft.exml.parser.Tools;
|
||||
import org.atriasoft.exml.reflect.ReflectTools;
|
||||
|
||||
record ConstructorModel(
|
||||
String[] values,
|
||||
@ -195,7 +195,7 @@ public class IntrospectionModelComplex extends IntrospectionModel {
|
||||
Log.verbose(tmpPrint.toString());
|
||||
}
|
||||
final List<String> recordAllPossibleValues = new ArrayList<>();
|
||||
final List<String> recordAllPossibleValuesFiltered = new ArrayList<>();
|
||||
|
||||
if (this.isRecord) {
|
||||
for (final ConstructorModel elem : this.constructors) {
|
||||
for (int iii = 0; iii < elem.values().length; iii++) {
|
||||
@ -286,77 +286,9 @@ public class IntrospectionModelComplex extends IntrospectionModel {
|
||||
}
|
||||
Log.verbose(" - " + elem.toGenericString());
|
||||
}
|
||||
final Method[] methodsTmp = this.classType.getMethods();
|
||||
// filter getX setX isX
|
||||
final List<Method> methods = List.of(methodsTmp).stream().filter(o -> {
|
||||
if (o.getName().contentEquals("getClass")) {
|
||||
return false;
|
||||
}
|
||||
// we does not manage private function
|
||||
if (!Modifier.isPublic(o.getModifiers())) {
|
||||
return false;
|
||||
}
|
||||
if (Modifier.isStatic(o.getModifiers())) {
|
||||
if (o.getName().contentEquals("valueOf") && o.getParameterCount() == 1 && o.getParameters()[0].getType() == String.class) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (o.getName().equals("toString")) {
|
||||
if (o.getParameterCount() != 0 || o.getReturnType() != String.class) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (this.isRecord) {
|
||||
if (recordAllPossibleValues.contains(o.getName())) {
|
||||
// This list is the real list of record members
|
||||
recordAllPossibleValuesFiltered.add(o.getName());
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
if (o.getName().startsWith("get")) {
|
||||
if (o.getParameterCount() != 0 || o.getReturnType() == void.class || o.getReturnType() == Boolean.class || o.getReturnType() == boolean.class) {
|
||||
return false;
|
||||
}
|
||||
// check name format
|
||||
if (o.getName().length() == 3) {
|
||||
return false;
|
||||
}
|
||||
if (o.getName().charAt(3) >= 'A' && o.getName().charAt(3) <= 'Z') {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (o.getName().startsWith("set")) {
|
||||
if (o.getReturnType() != void.class || o.getParameterCount() != 1) {
|
||||
return false;
|
||||
}
|
||||
// check name format
|
||||
if (o.getName().length() == 3) {
|
||||
return false;
|
||||
}
|
||||
if (o.getName().charAt(3) >= 'A' && o.getName().charAt(3) <= 'Z') {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (o.getName().startsWith("is")) {
|
||||
if ((o.getReturnType() != Boolean.class && o.getReturnType() != boolean.class) || o.getParameterCount() != 0) {
|
||||
return false;
|
||||
}
|
||||
// check name format
|
||||
if (o.getName().length() == 2) {
|
||||
return false;
|
||||
}
|
||||
if (o.getName().charAt(2) >= 'A' && o.getName().charAt(2) <= 'Z') {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}).collect(Collectors.toList());
|
||||
|
||||
final List<Method> methods = ReflectClass.getFilterGenericFucntion(this.classType, recordAllPossibleValues, true, true, true);
|
||||
|
||||
Log.verbose(" Methods: (" + methods.size() + ")");
|
||||
for (final Method elem : methods) {
|
||||
Log.verbose(" - " + elem.toGenericString());
|
||||
@ -369,40 +301,11 @@ public class IntrospectionModelComplex extends IntrospectionModel {
|
||||
// for records:
|
||||
// - xxx();
|
||||
|
||||
List<Method> methodsGet;
|
||||
List<Method> methodsSet;
|
||||
List<Method> methodsIs;
|
||||
if (!Enum.class.isAssignableFrom(classType)) {
|
||||
if (this.isRecord) {
|
||||
methodsGet = methods.stream().filter(o -> recordAllPossibleValues.contains(o.getName())).collect(Collectors.toList());
|
||||
methodsSet = new ArrayList<>();
|
||||
methodsIs = new ArrayList<>();
|
||||
} else {
|
||||
methodsGet = methods.stream().filter(o -> o.getName().startsWith("get")).collect(Collectors.toList());
|
||||
methodsSet = methods.stream().filter(o -> o.getName().startsWith("set")).collect(Collectors.toList());
|
||||
methodsIs = methods.stream().filter(o -> o.getName().startsWith("is")).collect(Collectors.toList());
|
||||
}
|
||||
} else {
|
||||
methodsGet = new ArrayList<>();
|
||||
methodsSet = new ArrayList<>();
|
||||
methodsIs = new ArrayList<>();
|
||||
}
|
||||
final List<Method> valueOfString = methods.stream().filter(o -> o.getName().startsWith("valueOf")).collect(Collectors.toList());
|
||||
if (valueOfString.size() == 1) {
|
||||
this.valueof = valueOfString.get(0);
|
||||
} else {
|
||||
// some specific model:
|
||||
|
||||
this.valueof = null;
|
||||
}
|
||||
final List<Method> tostringMethod = methods.stream().filter(o -> o.getName().startsWith("toString")).collect(Collectors.toList());
|
||||
if (tostringMethod.size() == 1) {
|
||||
this.tostring = tostringMethod.get(0);
|
||||
} else {
|
||||
// some specific model:
|
||||
|
||||
this.tostring = null;
|
||||
}
|
||||
final List<Method> methodsGet = ReflectClass.extractGetMethod(classType, methods, recordAllPossibleValues);
|
||||
final List<Method> methodsSet = ReflectClass.extractSetMethod(classType, methods);
|
||||
final List<Method> methodsIs = ReflectClass.extractIsMethod(classType, methods);
|
||||
this.valueof = ReflectClass.extractValueOf(methods);
|
||||
this.tostring = ReflectClass.extractToString(methods);
|
||||
// associate methods by pair.
|
||||
for (final Method method : methodsGet) {
|
||||
final String name = Tools.decapitalizeFirst(this.isRecord ? method.getName() : method.getName().substring(3));
|
||||
|
||||
@ -6,8 +6,8 @@ import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
import org.atriasoft.aknot.model.InterfaceFactoryAccess;
|
||||
import org.atriasoft.eStringSerialize.StringSerializer;
|
||||
import org.atriasoft.exml.annotation.XmlFactory.InterfaceXmlFactoryAccess;
|
||||
import org.atriasoft.exml.exception.ExmlBuilderException;
|
||||
import org.atriasoft.exml.internal.Log;
|
||||
|
||||
@ -29,7 +29,7 @@ public final class IntrospectionProperty {
|
||||
private String listName = null;
|
||||
private boolean canBeSetByConstructor = false;
|
||||
private Class<?> factory = null;
|
||||
private InterfaceXmlFactoryAccess factoryCreated = null;
|
||||
private InterfaceFactoryAccess factoryCreated = null;
|
||||
private final Class<?> type;
|
||||
private final Class<?> subType;
|
||||
// can get the property, if null not gettable ... ==> TODO need to remove this property ???
|
||||
@ -92,7 +92,7 @@ public final class IntrospectionProperty {
|
||||
}
|
||||
|
||||
public Class<?> getCompatible(final String name) {
|
||||
final InterfaceXmlFactoryAccess factoryGenerator = getFactory();
|
||||
final InterfaceFactoryAccess factoryGenerator = getFactory();
|
||||
if (factoryGenerator != null) {
|
||||
if (this.caseSensitive) {
|
||||
for (final Entry<String, Class<?>> elem : factoryGenerator.getConversionMap().entrySet()) {
|
||||
@ -129,10 +129,10 @@ public final class IntrospectionProperty {
|
||||
return null;
|
||||
}
|
||||
|
||||
public InterfaceXmlFactoryAccess getFactory() {
|
||||
public InterfaceFactoryAccess getFactory() {
|
||||
if (this.factoryCreated == null && this.factory != null) {
|
||||
try {
|
||||
this.factoryCreated = (InterfaceXmlFactoryAccess) this.factory.getConstructor().newInstance();
|
||||
this.factoryCreated = (InterfaceFactoryAccess) this.factory.getConstructor().newInstance();
|
||||
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
@ -207,7 +207,7 @@ public final class IntrospectionProperty {
|
||||
*/
|
||||
public boolean isCompatible(final String name) {
|
||||
Log.verbose("Check compatible : '{}' in {}", name, Arrays.toString(this.names));
|
||||
final InterfaceXmlFactoryAccess factoryGenerator = getFactory();
|
||||
final InterfaceFactoryAccess factoryGenerator = getFactory();
|
||||
if (factoryGenerator != null) {
|
||||
Log.verbose(" ===> Detect factory !!!!");
|
||||
if (this.caseSensitive) {
|
||||
|
||||
@ -1,510 +0,0 @@
|
||||
package org.atriasoft.exml.reflect;
|
||||
|
||||
import java.lang.annotation.Annotation;
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Parameter;
|
||||
import java.lang.reflect.ParameterizedType;
|
||||
import java.lang.reflect.Type;
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.exml.annotation.XmlAttribute;
|
||||
import org.atriasoft.exml.annotation.XmlCaseSensitive;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultCaseSensitive;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultManaged;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultNullValue;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultOptional;
|
||||
import org.atriasoft.exml.annotation.XmlFactory;
|
||||
import org.atriasoft.exml.annotation.XmlIgnoreUnknow;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
import org.atriasoft.exml.annotation.XmlManaged;
|
||||
import org.atriasoft.exml.annotation.XmlName;
|
||||
import org.atriasoft.exml.annotation.XmlOptional;
|
||||
import org.atriasoft.exml.annotation.XmlText;
|
||||
import org.atriasoft.exml.exception.ExmlBuilderException;
|
||||
import org.atriasoft.exml.internal.Log;
|
||||
|
||||
public class ReflectTools {
|
||||
public static Class<?> getFactory(final Field element) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlFactory.class);
|
||||
if (annotation.length == 0) {
|
||||
return null;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlFactory on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlFactory) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Class<?> getFactory(final Method element) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlFactory.class);
|
||||
if (annotation.length == 0) {
|
||||
return null;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlFactory on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlFactory) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsAttribute(final Constructor<?> constructor, final Parameter element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlAttribute.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlAttribute on " + constructor.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlAttribute) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsAttribute(final Field element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlAttribute.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlAttribute on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlAttribute) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsAttribute(final Method element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlAttribute.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlAttribute on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlAttribute) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsCaseSensitive(final Constructor<?> constructor, final Parameter element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlCaseSensitive.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlCaseSensitive on " + constructor.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlCaseSensitive) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsCaseSensitive(final Field element, final Boolean defaultValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlCaseSensitive.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlCaseSensitive on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlCaseSensitive) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsCaseSensitive(final Method element, final Boolean defaultValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlCaseSensitive.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlCaseSensitive on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlCaseSensitive) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsDefaultAttribute(final Class<?> classType, final Boolean defaultValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = classType.getDeclaredAnnotationsByType(XmlDefaultAttibute.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlDefaultAttibute on " + classType.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlDefaultAttibute) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsDefaultCaseSensitive(final Class<?> classType, final Boolean defaultValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = classType.getDeclaredAnnotationsByType(XmlDefaultCaseSensitive.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlDefaultCaseSensitive on " + classType.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlDefaultCaseSensitive) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsDefaultManaged(final Class<?> classType, final Boolean defaultValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = classType.getDeclaredAnnotationsByType(XmlDefaultManaged.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlDefaultManaged on " + classType.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlDefaultManaged) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsDefaultNullValue(final Class<?> classType, final Boolean defaultValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = classType.getDeclaredAnnotationsByType(XmlDefaultNullValue.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlDefaultNullValue on " + classType.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlDefaultNullValue) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsDefaultOptional(final Class<?> classType, final Boolean defaultValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = classType.getDeclaredAnnotationsByType(XmlDefaultOptional.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlDefaultOptional on " + classType.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlDefaultOptional) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsIgnoreUnknown(final Class<?> classType, final Boolean defaultValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = classType.getDeclaredAnnotationsByType(XmlIgnoreUnknow.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlIgnoreUnknow on " + classType.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlIgnoreUnknow) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsManaged(final Constructor<?> constructor, final Parameter element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlManaged.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlManaged on " + constructor.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlManaged) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsManaged(final Field element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlManaged.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @ on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlManaged) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsManaged(final Method element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlManaged.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlManaged on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlManaged) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsOptional(final Constructor<?> constructor, final Parameter element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlOptional.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlOptional on " + constructor.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlOptional) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsOptional(final Field element, final Boolean parentValue) throws Exception {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlOptional.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new Exception("Must not have more than 1 element @XmlOptional on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlOptional) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsOptional(final Method element, final Boolean parentValue) throws Exception {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlOptional.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new Exception("Must not have more than 1 element @XmlOptional on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlOptional) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsText(final Constructor<?> constructor, final Parameter element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlText.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlText on " + constructor.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlText) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsText(final Field element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlText.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlText on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlText) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static Boolean getIsText(final Method element, final Boolean parentValue) throws ExmlBuilderException {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlText.class);
|
||||
if (annotation.length == 0) {
|
||||
return parentValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new ExmlBuilderException("Must not have more than 1 element @XmlText on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
return ((XmlText) annotation[0]).value();
|
||||
}
|
||||
|
||||
public static String getListName(final Field element, final String defaultValue) throws Exception {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlList.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new Exception("Must not have more than 1 element @XmlList on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
final String tmp = ((XmlList) annotation[0]).value();
|
||||
if (tmp == null) {
|
||||
throw new Exception("Set null value in decorator @XmlList is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
public static String getListName(final Method element, final String defaultValue) throws Exception {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlList.class);
|
||||
if (annotation.length == 0) {
|
||||
return defaultValue;
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new Exception("Must not have more than 1 element @XmlList on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
final String tmp = ((XmlList) annotation[0]).value();
|
||||
if (tmp == null) {
|
||||
throw new Exception("Set null value in decorator @XmlList is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
public static String[] getNames(final Constructor<?> constructor, final Parameter element, final String defaultValue) throws Exception {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlName.class);
|
||||
if (annotation.length == 0) {
|
||||
if (defaultValue == null) {
|
||||
return null;
|
||||
}
|
||||
return new String[] { defaultValue };
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new Exception("Must not have more than 1 element @XmlName on " + constructor.getClass().getCanonicalName());
|
||||
}
|
||||
final String[] tmp = ((XmlName) annotation[0]).value();
|
||||
if (tmp == null) {
|
||||
throw new Exception("Set null value in decorator @XmlName is not availlable on: " + constructor.toGenericString());
|
||||
}
|
||||
if (tmp.length == 0) {
|
||||
throw new Exception("Set empty list value in decorator @XmlName is not availlable on: " + constructor.toGenericString());
|
||||
}
|
||||
for (final String elem : tmp) {
|
||||
if (elem == null) {
|
||||
throw new Exception("Set null String in list of value in decorator @XmlName is not availlable on: " + constructor.toGenericString());
|
||||
}
|
||||
if (elem.isEmpty()) {
|
||||
throw new Exception("Set empty String in list of value in decorator @XmlName is not availlable on: " + constructor.toGenericString());
|
||||
}
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
public static String[] getNames(final Constructor<?> element, final String defaultValue) throws Exception {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlName.class);
|
||||
if (annotation.length == 0) {
|
||||
if (defaultValue == null) {
|
||||
return null;
|
||||
}
|
||||
return new String[] { defaultValue };
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new Exception("Must not have more than 1 element @XmlName on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
final String[] tmp = ((XmlName) annotation[0]).value();
|
||||
if (tmp == null) {
|
||||
throw new Exception("Set null value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
if (tmp.length == 0) {
|
||||
throw new Exception("Set empty list value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
for (final String elem : tmp) {
|
||||
if (elem == null) {
|
||||
throw new Exception("Set null String in list of value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
if (elem.isEmpty()) {
|
||||
throw new Exception("Set empty String in list of value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
public static String[] getNames(final Field element, final String defaultValue) throws Exception {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlName.class);
|
||||
if (annotation.length == 0) {
|
||||
if (defaultValue == null) {
|
||||
return null;
|
||||
}
|
||||
return new String[] { defaultValue };
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new Exception("Must not have more than 1 element @XmlName on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
final String[] tmp = ((XmlName) annotation[0]).value();
|
||||
if (tmp == null) {
|
||||
throw new Exception("Set null value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
if (tmp.length == 0) {
|
||||
throw new Exception("Set empty list value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
for (final String elem : tmp) {
|
||||
if (elem == null) {
|
||||
throw new Exception("Set null String in list of value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
if (elem.isEmpty()) {
|
||||
throw new Exception("Set empty String in list of value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
public static String[] getNames(final Method element, final String defaultValue) throws Exception {
|
||||
final Annotation[] annotation = element.getDeclaredAnnotationsByType(XmlName.class);
|
||||
if (annotation.length == 0) {
|
||||
if (defaultValue == null) {
|
||||
return null;
|
||||
}
|
||||
return new String[] { defaultValue };
|
||||
}
|
||||
if (annotation.length > 1) {
|
||||
throw new Exception("Must not have more than 1 element @XmlName on " + element.getClass().getCanonicalName());
|
||||
}
|
||||
final String[] tmp = ((XmlName) annotation[0]).value();
|
||||
if (tmp == null) {
|
||||
throw new Exception("Set null value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
if (tmp.length == 0) {
|
||||
throw new Exception("Set empty list value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
for (final String elem : tmp) {
|
||||
if (elem == null) {
|
||||
throw new Exception("Set null String in list of value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
if (elem.isEmpty()) {
|
||||
throw new Exception("Set empty String in list of value in decorator @XmlName is not availlable on: " + element.toGenericString());
|
||||
}
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
public static Class<?>[] getTypeField(final Field fieldDescription) {
|
||||
final Class<?> type = fieldDescription.getType();
|
||||
Class<?> subType = null;
|
||||
final Type empppe = fieldDescription.getGenericType();
|
||||
if (empppe instanceof final ParameterizedType plopppppp) {
|
||||
final Type[] realType = plopppppp.getActualTypeArguments();
|
||||
if (realType.length > 0) {
|
||||
try {
|
||||
subType = Class.forName(realType[0].getTypeName());
|
||||
} catch (final ClassNotFoundException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
return new Class<?>[] { type, subType };
|
||||
}
|
||||
|
||||
public static Class<?>[] getTypeParameterfunction(final Constructor<?> elem, final int paramId) throws ClassNotFoundException {
|
||||
Class<?> type = null;
|
||||
Class<?> subType = null;
|
||||
|
||||
type = elem.getParameters()[paramId].getType();
|
||||
if (List.class.isAssignableFrom(type)) {
|
||||
Class<?> internalModelClass = null;
|
||||
final Type[] empppe = elem.getGenericParameterTypes();
|
||||
if (empppe.length > paramId) {
|
||||
if (empppe[paramId] instanceof final ParameterizedType plopppppp) {
|
||||
final Type[] realType = plopppppp.getActualTypeArguments();
|
||||
//Log.info("ppplllppp: " + realType.length);
|
||||
if (realType.length > 0) {
|
||||
Log.verbose(" -->> " + realType[0]);
|
||||
internalModelClass = Class.forName(realType[0].getTypeName());
|
||||
}
|
||||
}
|
||||
}
|
||||
subType = internalModelClass;
|
||||
}
|
||||
return new Class<?>[] { type, subType };
|
||||
}
|
||||
|
||||
public static Class<?>[] getTypeParameterfunction(final Method setter) throws Exception {
|
||||
Class<?> type = null;
|
||||
Class<?> subType = null;
|
||||
|
||||
type = setter.getParameters()[0].getType();
|
||||
if (List.class.isAssignableFrom(type)) {
|
||||
Class<?> internalModelClass = null;
|
||||
final Type[] empppe = setter.getGenericParameterTypes();
|
||||
if (empppe.length > 0) {
|
||||
if (empppe[0] instanceof final ParameterizedType plopppppp) {
|
||||
final Type[] realType = plopppppp.getActualTypeArguments();
|
||||
if (realType.length > 0) {
|
||||
Log.verbose(" -->> " + realType[0]);
|
||||
internalModelClass = Class.forName(realType[0].getTypeName());
|
||||
}
|
||||
}
|
||||
}
|
||||
subType = internalModelClass;
|
||||
}
|
||||
return new Class<?>[] { type, subType };
|
||||
}
|
||||
|
||||
public static Class<?>[] getTypeReturnFunction(/*@NotNull*/ final Method getter) throws Exception {
|
||||
Class<?> type = null;
|
||||
Class<?> subType = null;
|
||||
type = getter.getReturnType();
|
||||
if (!Enum.class.isAssignableFrom(type)) {
|
||||
final Type empppe = getter.getGenericReturnType();
|
||||
if (empppe instanceof final ParameterizedType plopppppp) {
|
||||
final Type[] realType = plopppppp.getActualTypeArguments();
|
||||
if (realType.length > 0) {
|
||||
subType = Class.forName(realType[0].getTypeName());
|
||||
}
|
||||
}
|
||||
}
|
||||
return new Class<?>[] { type, subType };
|
||||
}
|
||||
|
||||
private ReflectTools() {}
|
||||
|
||||
}
|
||||
@ -7,140 +7,20 @@ package test.atriasoft.exml;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionBoolean {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestBoolean {
|
||||
public Boolean valueA;
|
||||
public Boolean valueB;
|
||||
public Boolean valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelBoolean() {
|
||||
TestBoolean elem = new TestBoolean();
|
||||
elem.valueA = false;
|
||||
elem.valueB = true;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
|
||||
|
||||
final TestBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.valueA);
|
||||
Assertions.assertEquals(true, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayBoolean {
|
||||
public Boolean[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayBoolean() {
|
||||
TestArrayBoolean elem = new TestArrayBoolean();
|
||||
elem.values = new Boolean[] {false, false, true, false, true};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestArrayBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListBoolean {
|
||||
public List<Boolean> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListBoolean() {
|
||||
TestListBoolean elem = new TestListBoolean();
|
||||
elem.values = List.of(false, false, true, false, true);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestListBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(false, root.values.get(0));
|
||||
Assertions.assertEquals(false, root.values.get(1));
|
||||
Assertions.assertEquals(true, root.values.get(2));
|
||||
Assertions.assertEquals(false, root.values.get(3));
|
||||
Assertions.assertEquals(true, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestBooleanFunc {
|
||||
private Boolean valueA;
|
||||
private Boolean valueB;
|
||||
private Boolean valueNull;
|
||||
public Boolean isValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Boolean valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Boolean isValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Boolean valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Boolean isValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Boolean valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelBooleanFunc() {
|
||||
TestBooleanFunc elem = new TestBooleanFunc();
|
||||
elem.setValueA(false);
|
||||
elem.setValueB(true);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
|
||||
|
||||
final TestBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.isValueA());
|
||||
Assertions.assertEquals(true, root.isValueB());
|
||||
Assertions.assertEquals(null, root.isValueNull());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayBooleanFunc {
|
||||
private Boolean[] values;
|
||||
|
||||
@ -153,195 +33,10 @@ public class ExmlTestIntrospectionBoolean {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayBooleanFunc() {
|
||||
TestArrayBooleanFunc elem = new TestArrayBooleanFunc();
|
||||
elem.setValues(new Boolean[] {false, false, true, false, true});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestArrayBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(false, root.getValues()[0]);
|
||||
Assertions.assertEquals(false, root.getValues()[1]);
|
||||
Assertions.assertEquals(true, root.getValues()[2]);
|
||||
Assertions.assertEquals(false, root.getValues()[3]);
|
||||
Assertions.assertEquals(true, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListBooleanFunc {
|
||||
private List<Boolean> values;
|
||||
|
||||
public List<Boolean> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Boolean> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListBooleanFunc() {
|
||||
TestListBooleanFunc elem = new TestListBooleanFunc();
|
||||
elem.setValues(List.of(false, false, true, false, true));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestListBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(false, root.getValues().get(0));
|
||||
Assertions.assertEquals(false, root.getValues().get(1));
|
||||
Assertions.assertEquals(true, root.getValues().get(2));
|
||||
Assertions.assertEquals(false, root.getValues().get(3));
|
||||
Assertions.assertEquals(true, root.getValues().get(4));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
public class TestNodeBoolean {
|
||||
public Boolean valueA;
|
||||
public Boolean valueB;
|
||||
public Boolean valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeBoolean() {
|
||||
TestNodeBoolean elem = new TestNodeBoolean();
|
||||
elem.valueA = false;
|
||||
elem.valueB = true;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>false</valueA>\n"
|
||||
+ " <valueB>true</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.valueA);
|
||||
Assertions.assertEquals(true, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
public class TestArrayNodeBoolean {
|
||||
public Boolean[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeBoolean() {
|
||||
TestArrayNodeBoolean elem = new TestArrayNodeBoolean();
|
||||
elem.values = new Boolean[] {false, false, true, false, true};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestListNodeBoolean {
|
||||
public List<Boolean> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeBoolean() {
|
||||
TestListNodeBoolean elem = new TestListNodeBoolean();
|
||||
elem.values = List.of(false, false, true, false, true);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(false, root.values.get(0));
|
||||
Assertions.assertEquals(false, root.values.get(1));
|
||||
Assertions.assertEquals(true, root.values.get(2));
|
||||
Assertions.assertEquals(false, root.values.get(3));
|
||||
Assertions.assertEquals(true, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
public class TestNodeBooleanFunc {
|
||||
private Boolean valueA;
|
||||
private Boolean valueB;
|
||||
private Boolean valueNull;
|
||||
public Boolean isValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Boolean valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Boolean isValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Boolean valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Boolean isValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Boolean valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeBooleanFunc() {
|
||||
TestNodeBooleanFunc elem = new TestNodeBooleanFunc();
|
||||
elem.setValueA(false);
|
||||
elem.setValueB(true);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>false</valueA>\n"
|
||||
+ " <valueB>true</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.isValueA());
|
||||
Assertions.assertEquals(true, root.isValueB());
|
||||
Assertions.assertEquals(null, root.isValueNull());
|
||||
}
|
||||
|
||||
public class TestArrayNodeBooleanFunc {
|
||||
private Boolean[] values;
|
||||
@ -355,30 +50,70 @@ public class ExmlTestIntrospectionBoolean {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeBooleanFunc() {
|
||||
TestArrayNodeBooleanFunc elem = new TestArrayNodeBooleanFunc();
|
||||
elem.setValues(new Boolean[] {false, false, true, false, true});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
public class TestArrayNodeBooleanStructured {
|
||||
@AknotList(value = "elem")
|
||||
public Boolean[] values;
|
||||
}
|
||||
|
||||
final TestArrayNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(false, root.getValues()[0]);
|
||||
Assertions.assertEquals(false, root.getValues()[1]);
|
||||
Assertions.assertEquals(true, root.getValues()[2]);
|
||||
Assertions.assertEquals(false, root.getValues()[3]);
|
||||
Assertions.assertEquals(true, root.getValues()[4]);
|
||||
@AknotDefaultAttribute
|
||||
public class TestBoolean {
|
||||
public Boolean valueA;
|
||||
public Boolean valueB;
|
||||
public Boolean valueNull;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestBooleanFunc {
|
||||
private Boolean valueA;
|
||||
private Boolean valueB;
|
||||
private Boolean valueNull;
|
||||
|
||||
public Boolean isValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Boolean isValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Boolean isValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Boolean valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Boolean valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Boolean valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListBoolean {
|
||||
public List<Boolean> values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListBooleanFunc {
|
||||
private List<Boolean> values;
|
||||
|
||||
public List<Boolean> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Boolean> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestListNodeBoolean {
|
||||
public List<Boolean> values;
|
||||
}
|
||||
|
||||
// Note this is set in static to test an other part of code...
|
||||
@ -393,22 +128,329 @@ public class ExmlTestIntrospectionBoolean {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestListNodeBooleanStructured {
|
||||
@AknotList(value = "elem")
|
||||
public List<Boolean> values;
|
||||
}
|
||||
|
||||
public class TestNodeBoolean {
|
||||
public Boolean valueA;
|
||||
public Boolean valueB;
|
||||
public Boolean valueNull;
|
||||
}
|
||||
|
||||
public class TestNodeBooleanFunc {
|
||||
private Boolean valueA;
|
||||
private Boolean valueB;
|
||||
private Boolean valueNull;
|
||||
|
||||
public Boolean isValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Boolean isValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Boolean isValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Boolean valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Boolean valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Boolean valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeBooleanFunc() {
|
||||
TestListNodeBooleanFunc elem = new TestListNodeBooleanFunc();
|
||||
public void testArrayNodeBooleanStructured() {
|
||||
final TestArrayNodeBooleanStructured elem = new TestArrayNodeBooleanStructured();
|
||||
elem.values = new Boolean[] { false, false, true, false, true };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>false</elem>
|
||||
<elem>false</elem>
|
||||
<elem>true</elem>
|
||||
<elem>false</elem>
|
||||
<elem>true</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeBooleanStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanStructured.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testListNodeBooleanStructured() {
|
||||
final TestListNodeBooleanStructured elem = new TestListNodeBooleanStructured();
|
||||
elem.values = List.of(false, false, true, false, true);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>false</elem>
|
||||
<elem>false</elem>
|
||||
<elem>true</elem>
|
||||
<elem>false</elem>
|
||||
<elem>true</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeBooleanStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeBooleanStructured.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(false, root.values.get(0));
|
||||
Assertions.assertEquals(false, root.values.get(1));
|
||||
Assertions.assertEquals(true, root.values.get(2));
|
||||
Assertions.assertEquals(false, root.values.get(3));
|
||||
Assertions.assertEquals(true, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayBoolean() {
|
||||
final TestArrayBoolean elem = new TestArrayBoolean();
|
||||
elem.values = new Boolean[] { false, false, true, false, true };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestArrayBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayBooleanFunc() {
|
||||
final TestArrayBooleanFunc elem = new TestArrayBooleanFunc();
|
||||
elem.setValues(new Boolean[] { false, false, true, false, true });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestArrayBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(false, root.getValues()[0]);
|
||||
Assertions.assertEquals(false, root.getValues()[1]);
|
||||
Assertions.assertEquals(true, root.getValues()[2]);
|
||||
Assertions.assertEquals(false, root.getValues()[3]);
|
||||
Assertions.assertEquals(true, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeBoolean() {
|
||||
final TestArrayNodeBoolean elem = new TestArrayNodeBoolean();
|
||||
elem.values = new Boolean[] { false, false, true, false, true };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>false</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeBooleanFunc() {
|
||||
final TestArrayNodeBooleanFunc elem = new TestArrayNodeBooleanFunc();
|
||||
elem.setValues(new Boolean[] { false, false, true, false, true });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>false</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(false, root.getValues()[0]);
|
||||
Assertions.assertEquals(false, root.getValues()[1]);
|
||||
Assertions.assertEquals(true, root.getValues()[2]);
|
||||
Assertions.assertEquals(false, root.getValues()[3]);
|
||||
Assertions.assertEquals(true, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelBoolean() {
|
||||
final TestBoolean elem = new TestBoolean();
|
||||
elem.valueA = false;
|
||||
elem.valueB = true;
|
||||
elem.valueNull = null;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
|
||||
|
||||
final TestBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.valueA);
|
||||
Assertions.assertEquals(true, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelBooleanFunc() {
|
||||
final TestBooleanFunc elem = new TestBooleanFunc();
|
||||
elem.setValueA(false);
|
||||
elem.setValueB(true);
|
||||
elem.setValueNull(null);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
|
||||
|
||||
final TestBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.isValueA());
|
||||
Assertions.assertEquals(true, root.isValueB());
|
||||
Assertions.assertEquals(null, root.isValueNull());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListBoolean() {
|
||||
final TestListBoolean elem = new TestListBoolean();
|
||||
elem.values = List.of(false, false, true, false, true);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestListBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(false, root.values.get(0));
|
||||
Assertions.assertEquals(false, root.values.get(1));
|
||||
Assertions.assertEquals(true, root.values.get(2));
|
||||
Assertions.assertEquals(false, root.values.get(3));
|
||||
Assertions.assertEquals(true, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListBooleanFunc() {
|
||||
final TestListBooleanFunc elem = new TestListBooleanFunc();
|
||||
elem.setValues(List.of(false, false, true, false, true));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestListBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(false, root.getValues().get(0));
|
||||
Assertions.assertEquals(false, root.getValues().get(1));
|
||||
Assertions.assertEquals(true, root.getValues().get(2));
|
||||
Assertions.assertEquals(false, root.getValues().get(3));
|
||||
Assertions.assertEquals(true, root.getValues().get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeBoolean() {
|
||||
final TestListNodeBoolean elem = new TestListNodeBoolean();
|
||||
elem.values = List.of(false, false, true, false, true);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>false</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(false, root.values.get(0));
|
||||
Assertions.assertEquals(false, root.values.get(1));
|
||||
Assertions.assertEquals(true, root.values.get(2));
|
||||
Assertions.assertEquals(false, root.values.get(3));
|
||||
Assertions.assertEquals(true, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeBooleanFunc() {
|
||||
final TestListNodeBooleanFunc elem = new TestListNodeBooleanFunc();
|
||||
elem.setValues(List.of(false, false, true, false, true));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>false</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
@ -419,71 +461,49 @@ public class ExmlTestIntrospectionBoolean {
|
||||
Assertions.assertEquals(true, root.getValues().get(4));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
public class TestListNodeBooleanStructured {
|
||||
@XmlList(value="elem")
|
||||
public List<Boolean> values;
|
||||
}
|
||||
@Test
|
||||
public void testListNodeBooleanStructured() {
|
||||
TestListNodeBooleanStructured elem = new TestListNodeBooleanStructured();
|
||||
elem.values = List.of(false, false, true, false, true);
|
||||
public void testModelNodeBoolean() {
|
||||
final TestNodeBoolean elem = new TestNodeBoolean();
|
||||
elem.valueA = false;
|
||||
elem.valueB = true;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>false</elem>\n"
|
||||
+ " <elem>false</elem>\n"
|
||||
+ " <elem>true</elem>\n"
|
||||
+ " <elem>false</elem>\n"
|
||||
+ " <elem>true</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>false</valueA>
|
||||
<valueB>true</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeBooleanStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeBooleanStructured.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(false, root.values.get(0));
|
||||
Assertions.assertEquals(false, root.values.get(1));
|
||||
Assertions.assertEquals(true, root.values.get(2));
|
||||
Assertions.assertEquals(false, root.values.get(3));
|
||||
Assertions.assertEquals(true, root.values.get(4));
|
||||
}
|
||||
public class TestArrayNodeBooleanStructured {
|
||||
@XmlList(value="elem")
|
||||
public Boolean[] values;
|
||||
final TestNodeBoolean root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBoolean.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.valueA);
|
||||
Assertions.assertEquals(true, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeBooleanStructured() {
|
||||
TestArrayNodeBooleanStructured elem = new TestArrayNodeBooleanStructured();
|
||||
elem.values = new Boolean[] {false, false, true, false, true};
|
||||
public void testModelNodeBooleanFunc() {
|
||||
final TestNodeBooleanFunc elem = new TestNodeBooleanFunc();
|
||||
elem.setValueA(false);
|
||||
elem.setValueB(true);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>false</elem>\n"
|
||||
+ " <elem>false</elem>\n"
|
||||
+ " <elem>true</elem>\n"
|
||||
+ " <elem>false</elem>\n"
|
||||
+ " <elem>true</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>false</valueA>
|
||||
<valueB>true</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeBooleanStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanStructured.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
final TestNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBooleanFunc.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.isValueA());
|
||||
Assertions.assertEquals(true, root.isValueB());
|
||||
Assertions.assertEquals(null, root.isValueNull());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -5,104 +5,15 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
|
||||
public class ExmlTestIntrospectionBooleanNative {
|
||||
public static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.verbose("----------------------------------------------------------------");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestBooleanNative {
|
||||
public boolean valueA;
|
||||
public boolean valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelBooleanNative() {
|
||||
TestBooleanNative elem = new TestBooleanNative();
|
||||
elem.valueA = false;
|
||||
elem.valueB = true;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
|
||||
|
||||
final TestBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.valueA);
|
||||
Assertions.assertEquals(true, root.valueB);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestArrayBooleanNative {
|
||||
public boolean[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayBooleanNative() {
|
||||
TestArrayBooleanNative elem = new TestArrayBooleanNative();
|
||||
elem.values = new boolean[] {false, false, true, false, true};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestArrayBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestBooleanFunc {
|
||||
private boolean valueA;
|
||||
private boolean valueB;
|
||||
public boolean isValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final boolean valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public boolean isValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final boolean valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelBooleanFunc() {
|
||||
TestBooleanFunc elem = new TestBooleanFunc();
|
||||
elem.setValueA(false);
|
||||
elem.setValueB(true);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
|
||||
|
||||
final TestBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.isValueA());
|
||||
Assertions.assertEquals(true, root.isValueB());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayBooleanFunc {
|
||||
private boolean[] values;
|
||||
|
||||
@ -115,115 +26,11 @@ public class ExmlTestIntrospectionBooleanNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayBooleanFunc() {
|
||||
TestArrayBooleanFunc elem = new TestArrayBooleanFunc();
|
||||
elem.setValues(new boolean[] {false, false, true, false, true});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestArrayBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(false, root.getValues()[0]);
|
||||
Assertions.assertEquals(false, root.getValues()[1]);
|
||||
Assertions.assertEquals(true, root.getValues()[2]);
|
||||
Assertions.assertEquals(false, root.getValues()[3]);
|
||||
Assertions.assertEquals(true, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestNodeBooleanNative {
|
||||
public boolean valueA;
|
||||
public boolean valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeBooleanNative() {
|
||||
TestNodeBooleanNative elem = new TestNodeBooleanNative();
|
||||
elem.valueA = false;
|
||||
elem.valueB = true;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>false</valueA>\n"
|
||||
+ " <valueB>true</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.valueA);
|
||||
Assertions.assertEquals(true, root.valueB);
|
||||
}
|
||||
|
||||
public class TestArrayNodeBooleanNative {
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayBooleanNative {
|
||||
public boolean[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeBooleanNative() {
|
||||
TestArrayNodeBooleanNative elem = new TestArrayNodeBooleanNative();
|
||||
elem.values = new boolean[] {false, false, true, false, true};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestNodeBooleanFunc {
|
||||
private boolean valueA;
|
||||
private boolean valueB;
|
||||
public boolean isValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final boolean valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public boolean isValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final boolean valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeBooleanFunc() {
|
||||
TestNodeBooleanFunc elem = new TestNodeBooleanFunc();
|
||||
elem.setValueA(false);
|
||||
elem.setValueB(true);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>false</valueA>\n"
|
||||
+ " <valueB>true</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.isValueA());
|
||||
Assertions.assertEquals(true, root.isValueB());
|
||||
}
|
||||
|
||||
public class TestArrayNodeBooleanFunc {
|
||||
private boolean[] values;
|
||||
@ -237,22 +44,164 @@ public class ExmlTestIntrospectionBooleanNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeBooleanFunc() {
|
||||
TestArrayNodeBooleanFunc elem = new TestArrayNodeBooleanFunc();
|
||||
elem.setValues(new boolean[] {false, false, true, false, true});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
public class TestArrayNodeBooleanNative {
|
||||
public boolean[] values;
|
||||
}
|
||||
|
||||
public class TestArrayNodeBooleanNativeStructured {
|
||||
@AknotList(value = "elem")
|
||||
public boolean[] values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestBooleanFunc {
|
||||
private boolean valueA;
|
||||
private boolean valueB;
|
||||
|
||||
public boolean isValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public boolean isValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final boolean valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final boolean valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestBooleanNative {
|
||||
public boolean valueA;
|
||||
public boolean valueB;
|
||||
}
|
||||
|
||||
public class TestNodeBooleanFunc {
|
||||
private boolean valueA;
|
||||
private boolean valueB;
|
||||
|
||||
public boolean isValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public boolean isValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final boolean valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final boolean valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestNodeBooleanNative {
|
||||
public boolean valueA;
|
||||
public boolean valueB;
|
||||
}
|
||||
|
||||
public static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.verbose("----------------------------------------------------------------");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeBooleanNativeStructured() {
|
||||
final TestArrayNodeBooleanNativeStructured elem = new TestArrayNodeBooleanNativeStructured();
|
||||
elem.values = new boolean[] { false, false, true, false, true };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ " <values>false</values>\n"
|
||||
+ " <values>true</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>false</elem>
|
||||
<elem>false</elem>
|
||||
<elem>true</elem>
|
||||
<elem>false</elem>
|
||||
<elem>true</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeBooleanNativeStructured root = Assertions
|
||||
.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanNativeStructured.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayBooleanFunc() {
|
||||
final TestArrayBooleanFunc elem = new TestArrayBooleanFunc();
|
||||
elem.setValues(new boolean[] { false, false, true, false, true });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestArrayBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(false, root.getValues()[0]);
|
||||
Assertions.assertEquals(false, root.getValues()[1]);
|
||||
Assertions.assertEquals(true, root.getValues()[2]);
|
||||
Assertions.assertEquals(false, root.getValues()[3]);
|
||||
Assertions.assertEquals(true, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayBooleanNative() {
|
||||
final TestArrayBooleanNative elem = new TestArrayBooleanNative();
|
||||
elem.values = new boolean[] { false, false, true, false, true };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"false;false;true;false;true\"/>", dataTest);
|
||||
|
||||
final TestArrayBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
Assertions.assertEquals(true, root.values[2]);
|
||||
Assertions.assertEquals(false, root.values[3]);
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeBooleanFunc() {
|
||||
final TestArrayNodeBooleanFunc elem = new TestArrayNodeBooleanFunc();
|
||||
elem.setValues(new boolean[] { false, false, true, false, true });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>false</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
@ -263,30 +212,25 @@ public class ExmlTestIntrospectionBooleanNative {
|
||||
Assertions.assertEquals(true, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestArrayNodeBooleanNativeStructured {
|
||||
@XmlList(value="elem")
|
||||
public boolean[] values;
|
||||
}
|
||||
@Test
|
||||
public void testArrayNodeBooleanNativeStructured() {
|
||||
TestArrayNodeBooleanNativeStructured elem = new TestArrayNodeBooleanNativeStructured();
|
||||
elem.values = new boolean[] {false, false, true, false, true};
|
||||
public void testModelArrayNodeBooleanNative() {
|
||||
final TestArrayNodeBooleanNative elem = new TestArrayNodeBooleanNative();
|
||||
elem.values = new boolean[] { false, false, true, false, true };
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBoolean.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>false</elem>\n"
|
||||
+ " <elem>false</elem>\n"
|
||||
+ " <elem>true</elem>\n"
|
||||
+ " <elem>false</elem>\n"
|
||||
+ " <elem>true</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>false</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
<values>false</values>
|
||||
<values>true</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeBooleanNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanNativeStructured.class, ExmlTestIntrospectionBoolean.NODE_NAME));
|
||||
final TestArrayNodeBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(false, root.values[0]);
|
||||
Assertions.assertEquals(false, root.values[1]);
|
||||
@ -295,5 +239,80 @@ public class ExmlTestIntrospectionBooleanNative {
|
||||
Assertions.assertEquals(true, root.values[4]);
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelBooleanFunc() {
|
||||
final TestBooleanFunc elem = new TestBooleanFunc();
|
||||
elem.setValueA(false);
|
||||
elem.setValueB(true);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
|
||||
|
||||
final TestBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.isValueA());
|
||||
Assertions.assertEquals(true, root.isValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelBooleanNative() {
|
||||
final TestBooleanNative elem = new TestBooleanNative();
|
||||
elem.valueA = false;
|
||||
elem.valueB = true;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"false\" valueB=\"true\"/>", dataTest);
|
||||
|
||||
final TestBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.valueA);
|
||||
Assertions.assertEquals(true, root.valueB);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeBooleanFunc() {
|
||||
final TestNodeBooleanFunc elem = new TestNodeBooleanFunc();
|
||||
elem.setValueA(false);
|
||||
elem.setValueB(true);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>false</valueA>
|
||||
<valueB>true</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeBooleanFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBooleanFunc.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.isValueA());
|
||||
Assertions.assertEquals(true, root.isValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeBooleanNative() {
|
||||
final TestNodeBooleanNative elem = new TestNodeBooleanNative();
|
||||
elem.valueA = false;
|
||||
elem.valueB = true;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionBooleanNative.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>false</valueA>
|
||||
<valueB>true</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeBooleanNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeBooleanNative.class, ExmlTestIntrospectionBooleanNative.NODE_NAME));
|
||||
Assertions.assertEquals(false, root.valueA);
|
||||
Assertions.assertEquals(true, root.valueB);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -5,103 +5,15 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionByteNative {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestByteNative {
|
||||
public byte valueA;
|
||||
public byte valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelByteNative() {
|
||||
TestByteNative elem = new TestByteNative();
|
||||
elem.valueA = (byte)12;
|
||||
elem.valueB = (byte)-13;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals((byte)12, root.valueA);
|
||||
Assertions.assertEquals((byte)-13, root.valueB);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestArrayByteNative {
|
||||
public byte[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayByteNative() {
|
||||
TestArrayByteNative elem = new TestArrayByteNative();
|
||||
elem.values = new byte[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((byte)12, root.values[0]);
|
||||
Assertions.assertEquals((byte)-13, root.values[1]);
|
||||
Assertions.assertEquals((byte)33, root.values[2]);
|
||||
Assertions.assertEquals((byte)78, root.values[3]);
|
||||
Assertions.assertEquals((byte)-127, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestbyteFunc {
|
||||
private byte valueA;
|
||||
private byte valueB;
|
||||
public byte getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final byte valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public byte getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final byte valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelByteFunc() {
|
||||
TestbyteFunc elem = new TestbyteFunc();
|
||||
elem.setValueA((byte)-55);
|
||||
elem.setValueB((byte)57);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestbyteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestbyteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals((byte)-55, root.getValueA());
|
||||
Assertions.assertEquals((byte)57, root.getValueB());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayByteFunc {
|
||||
private byte[] values;
|
||||
|
||||
@ -114,115 +26,11 @@ public class ExmlTestIntrospectionByteNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayByteFunc() {
|
||||
TestArrayByteFunc elem = new TestArrayByteFunc();
|
||||
elem.setValues(new byte[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((byte)12, root.getValues()[0]);
|
||||
Assertions.assertEquals((byte)-13, root.getValues()[1]);
|
||||
Assertions.assertEquals((byte)33, root.getValues()[2]);
|
||||
Assertions.assertEquals((byte)78, root.getValues()[3]);
|
||||
Assertions.assertEquals((byte)-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestNodeByteNative {
|
||||
public byte valueA;
|
||||
public byte valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeByteNative() {
|
||||
TestNodeByteNative elem = new TestNodeByteNative();
|
||||
elem.valueA = (byte)11;
|
||||
elem.valueB = (byte)-120;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>11</valueA>\n"
|
||||
+ " <valueB>-120</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals((byte)11, root.valueA);
|
||||
Assertions.assertEquals((byte)-120, root.valueB);
|
||||
}
|
||||
|
||||
public class TestArrayNodeByteNative {
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayByteNative {
|
||||
public byte[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodebyteNative() {
|
||||
TestArrayNodeByteNative elem = new TestArrayNodeByteNative();
|
||||
elem.values = new byte[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((byte)12, root.values[0]);
|
||||
Assertions.assertEquals((byte)-13, root.values[1]);
|
||||
Assertions.assertEquals((byte)33, root.values[2]);
|
||||
Assertions.assertEquals((byte)78, root.values[3]);
|
||||
Assertions.assertEquals((byte)-127, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestNodebyteFunc {
|
||||
private byte valueA;
|
||||
private byte valueB;
|
||||
public byte getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final byte valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public byte getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final byte valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeByteFunc() {
|
||||
TestNodebyteFunc elem = new TestNodebyteFunc();
|
||||
elem.setValueA((byte)54);
|
||||
elem.setValueB((byte)-68);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>54</valueA>\n"
|
||||
+ " <valueB>-68</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodebyteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodebyteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals((byte)54, root.getValueA());
|
||||
Assertions.assertEquals((byte)-68, root.getValueB());
|
||||
}
|
||||
|
||||
public class TestArrayNodeByteFunc {
|
||||
private byte[] values;
|
||||
@ -236,103 +44,316 @@ public class ExmlTestIntrospectionByteNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeByteFunc() {
|
||||
TestArrayNodeByteFunc elem = new TestArrayNodeByteFunc();
|
||||
elem.setValues(new byte[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
public class TestArrayNodeByteNative {
|
||||
public byte[] values;
|
||||
}
|
||||
|
||||
final TestArrayNodeByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((byte)12, root.getValues()[0]);
|
||||
Assertions.assertEquals((byte)-13, root.getValues()[1]);
|
||||
Assertions.assertEquals((byte)33, root.getValues()[2]);
|
||||
Assertions.assertEquals((byte)78, root.getValues()[3]);
|
||||
Assertions.assertEquals((byte)-127, root.getValues()[4]);
|
||||
public class TestArrayNodeByteNativeStructured {
|
||||
@AknotList(value = "elem")
|
||||
public byte[] values;
|
||||
}
|
||||
|
||||
public class TestArrayNodeByteNativeStructuredFunc {
|
||||
private byte[] values;
|
||||
@XmlList(value="elem")
|
||||
|
||||
@AknotList(value = "elem")
|
||||
public byte[] getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final byte[] values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testArrayNodeByteNativeStructuredFunc() {
|
||||
TestArrayNodeByteNativeStructuredFunc elem = new TestArrayNodeByteNativeStructuredFunc();
|
||||
elem.setValues(new byte[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12</elem>\n"
|
||||
+ " <elem>-13</elem>\n"
|
||||
+ " <elem>33</elem>\n"
|
||||
+ " <elem>78</elem>\n"
|
||||
+ " <elem>-127</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
@AknotDefaultAttribute
|
||||
public class TestbyteFunc {
|
||||
private byte valueA;
|
||||
private byte valueB;
|
||||
|
||||
final TestArrayNodeByteNativeStructuredFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteNativeStructuredFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((byte)12, root.getValues()[0]);
|
||||
Assertions.assertEquals((byte)-13, root.getValues()[1]);
|
||||
Assertions.assertEquals((byte)33, root.getValues()[2]);
|
||||
Assertions.assertEquals((byte)78, root.getValues()[3]);
|
||||
Assertions.assertEquals((byte)-127, root.getValues()[4]);
|
||||
public byte getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public byte getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final byte valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final byte valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
public class TestArrayNodeByteNativeStructured {
|
||||
@XmlList(value="elem")
|
||||
public byte[] values;
|
||||
@AknotDefaultAttribute
|
||||
public class TestByteNative {
|
||||
public byte valueA;
|
||||
public byte valueB;
|
||||
}
|
||||
@Test
|
||||
public void testArrayNodeByteNativeStructured() {
|
||||
TestArrayNodeByteNativeStructured elem = new TestArrayNodeByteNativeStructured();
|
||||
elem.values = new byte[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public class TestNodebyteFunc {
|
||||
private byte valueA;
|
||||
private byte valueB;
|
||||
|
||||
public byte getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public byte getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final byte valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final byte valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestNodeByteNative {
|
||||
public byte valueA;
|
||||
public byte valueB;
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeByteNativeStructured() {
|
||||
final TestArrayNodeByteNativeStructured elem = new TestArrayNodeByteNativeStructured();
|
||||
elem.values = new byte[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12</elem>\n"
|
||||
+ " <elem>-13</elem>\n"
|
||||
+ " <elem>33</elem>\n"
|
||||
+ " <elem>78</elem>\n"
|
||||
+ " <elem>-127</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12</elem>
|
||||
<elem>-13</elem>
|
||||
<elem>33</elem>
|
||||
<elem>78</elem>
|
||||
<elem>-127</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeByteNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteNativeStructured.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((byte)12, root.values[0]);
|
||||
Assertions.assertEquals((byte)-13, root.values[1]);
|
||||
Assertions.assertEquals((byte)33, root.values[2]);
|
||||
Assertions.assertEquals((byte)78, root.values[3]);
|
||||
Assertions.assertEquals((byte)-127, root.values[4]);
|
||||
Assertions.assertEquals((byte) 12, root.values[0]);
|
||||
Assertions.assertEquals((byte) -13, root.values[1]);
|
||||
Assertions.assertEquals((byte) 33, root.values[2]);
|
||||
Assertions.assertEquals((byte) 78, root.values[3]);
|
||||
Assertions.assertEquals((byte) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeByteNativeStructuredFunc() {
|
||||
final TestArrayNodeByteNativeStructuredFunc elem = new TestArrayNodeByteNativeStructuredFunc();
|
||||
elem.setValues(new byte[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12</elem>
|
||||
<elem>-13</elem>
|
||||
<elem>33</elem>
|
||||
<elem>78</elem>
|
||||
<elem>-127</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeByteNativeStructuredFunc root = Assertions
|
||||
.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteNativeStructuredFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((byte) 12, root.getValues()[0]);
|
||||
Assertions.assertEquals((byte) -13, root.getValues()[1]);
|
||||
Assertions.assertEquals((byte) 33, root.getValues()[2]);
|
||||
Assertions.assertEquals((byte) 78, root.getValues()[3]);
|
||||
Assertions.assertEquals((byte) -127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayByteFunc() {
|
||||
final TestArrayByteFunc elem = new TestArrayByteFunc();
|
||||
elem.setValues(new byte[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((byte) 12, root.getValues()[0]);
|
||||
Assertions.assertEquals((byte) -13, root.getValues()[1]);
|
||||
Assertions.assertEquals((byte) 33, root.getValues()[2]);
|
||||
Assertions.assertEquals((byte) 78, root.getValues()[3]);
|
||||
Assertions.assertEquals((byte) -127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayByteNative() {
|
||||
final TestArrayByteNative elem = new TestArrayByteNative();
|
||||
elem.values = new byte[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((byte) 12, root.values[0]);
|
||||
Assertions.assertEquals((byte) -13, root.values[1]);
|
||||
Assertions.assertEquals((byte) 33, root.values[2]);
|
||||
Assertions.assertEquals((byte) 78, root.values[3]);
|
||||
Assertions.assertEquals((byte) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeByteFunc() {
|
||||
final TestArrayNodeByteFunc elem = new TestArrayNodeByteFunc();
|
||||
elem.setValues(new byte[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeByteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((byte) 12, root.getValues()[0]);
|
||||
Assertions.assertEquals((byte) -13, root.getValues()[1]);
|
||||
Assertions.assertEquals((byte) 33, root.getValues()[2]);
|
||||
Assertions.assertEquals((byte) 78, root.getValues()[3]);
|
||||
Assertions.assertEquals((byte) -127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodebyteNative() {
|
||||
final TestArrayNodeByteNative elem = new TestArrayNodeByteNative();
|
||||
elem.values = new byte[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((byte) 12, root.values[0]);
|
||||
Assertions.assertEquals((byte) -13, root.values[1]);
|
||||
Assertions.assertEquals((byte) 33, root.values[2]);
|
||||
Assertions.assertEquals((byte) 78, root.values[3]);
|
||||
Assertions.assertEquals((byte) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelByteFunc() {
|
||||
final TestbyteFunc elem = new TestbyteFunc();
|
||||
elem.setValueA((byte) -55);
|
||||
elem.setValueB((byte) 57);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestbyteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestbyteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals((byte) -55, root.getValueA());
|
||||
Assertions.assertEquals((byte) 57, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelByteNative() {
|
||||
final TestByteNative elem = new TestByteNative();
|
||||
elem.valueA = (byte) 12;
|
||||
elem.valueB = (byte) -13;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals((byte) 12, root.valueA);
|
||||
Assertions.assertEquals((byte) -13, root.valueB);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeByteFunc() {
|
||||
final TestNodebyteFunc elem = new TestNodebyteFunc();
|
||||
elem.setValueA((byte) 54);
|
||||
elem.setValueB((byte) -68);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>54</valueA>
|
||||
<valueB>-68</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodebyteFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodebyteFunc.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals((byte) 54, root.getValueA());
|
||||
Assertions.assertEquals((byte) -68, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeByteNative() {
|
||||
final TestNodeByteNative elem = new TestNodeByteNative();
|
||||
elem.valueA = (byte) 11;
|
||||
elem.valueB = (byte) -120;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>11</valueA>
|
||||
<valueB>-120</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeByteNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeByteNative.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals((byte) 11, root.valueA);
|
||||
Assertions.assertEquals((byte) -120, root.valueB);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -5,35 +5,24 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotName;
|
||||
import org.atriasoft.aknot.annotation.AknotAttribute;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlAttribute;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlName;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionDecoratorAttribute {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
// ************************************************************
|
||||
// ** Attribute
|
||||
// ************************************************************
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestNodeObject {
|
||||
|
||||
public int valueA;
|
||||
@XmlAttribute
|
||||
@AknotAttribute
|
||||
public int valueB;
|
||||
@XmlAttribute(true)
|
||||
@AknotAttribute(true)
|
||||
public int valueC;
|
||||
@XmlAttribute(false)
|
||||
@AknotAttribute(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
@ -44,13 +33,12 @@ public class ExmlTestIntrospectionDecoratorAttribute {
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
|
||||
public final int finalValueM;
|
||||
@XmlAttribute
|
||||
@AknotAttribute
|
||||
public final int finalValueN;
|
||||
@XmlAttribute(true)
|
||||
@AknotAttribute(true)
|
||||
public final int finalValueO;
|
||||
@XmlAttribute(false)
|
||||
@AknotAttribute(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
@ -64,13 +52,10 @@ public class ExmlTestIntrospectionDecoratorAttribute {
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@XmlName({"finalValueM", "finalValueN", "finalValueO", "finalValueP",
|
||||
"finalValueQ", "finalValueR", "finalValueS", "finalValueT",
|
||||
"pFinalValueQ", "pFinalValueR", "pFinalValueS", "pFinalValueT"})
|
||||
public TestNodeObject(
|
||||
final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP,
|
||||
final int finalValueQ, @XmlAttribute final int finalValueR, @XmlAttribute(true) final int finalValueS, @XmlAttribute(false) final int finalValueT,
|
||||
final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
|
||||
@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
|
||||
"pFinalValueT" })
|
||||
public TestNodeObject(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotAttribute final int finalValueR,
|
||||
@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
@ -85,78 +70,378 @@ public class ExmlTestIntrospectionDecoratorAttribute {
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@AknotAttribute
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@AknotAttribute(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@AknotAttribute(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
@XmlAttribute
|
||||
|
||||
@AknotAttribute
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
@XmlAttribute
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
@XmlAttribute(true)
|
||||
|
||||
@AknotAttribute(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
@XmlAttribute(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
@XmlAttribute(false)
|
||||
|
||||
@AknotAttribute(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
@XmlAttribute(false)
|
||||
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
|
||||
@AknotAttribute
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
|
||||
@AknotAttribute(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
|
||||
@AknotAttribute(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute(false)
|
||||
public class TestNodeObjectFalse {
|
||||
public int valueA;
|
||||
@AknotAttribute
|
||||
public int valueB;
|
||||
@AknotAttribute(true)
|
||||
public int valueC;
|
||||
@AknotAttribute(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
private int valueF;
|
||||
private int valueG;
|
||||
private int valueH;
|
||||
private int valueI;
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
public final int finalValueM;
|
||||
@AknotAttribute
|
||||
public final int finalValueN;
|
||||
@AknotAttribute(true)
|
||||
public final int finalValueO;
|
||||
@AknotAttribute(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
public final int finalValueQ;
|
||||
public final int finalValueR;
|
||||
public final int finalValueS;
|
||||
public final int finalValueT;
|
||||
|
||||
private final int pFinalValueQ;
|
||||
private final int pFinalValueR;
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
|
||||
"pFinalValueT" })
|
||||
public TestNodeObjectFalse(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotAttribute final int finalValueR,
|
||||
@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
this.finalValueP = finalValueP;
|
||||
this.finalValueQ = finalValueQ;
|
||||
this.finalValueR = finalValueR;
|
||||
this.finalValueS = finalValueS;
|
||||
this.finalValueT = finalValueT;
|
||||
this.pFinalValueQ = pFinalValueQ;
|
||||
this.pFinalValueR = pFinalValueR;
|
||||
this.pFinalValueS = pFinalValueS;
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@XmlAttribute
|
||||
@AknotAttribute
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@XmlAttribute(true)
|
||||
@AknotAttribute(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@XmlAttribute(false)
|
||||
@AknotAttribute(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
|
||||
@AknotAttribute
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
|
||||
@AknotAttribute(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
|
||||
@AknotAttribute(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
|
||||
@AknotAttribute
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
|
||||
@AknotAttribute(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
|
||||
@AknotAttribute(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute(true)
|
||||
public class TestNodeObjectTrue {
|
||||
public int valueA;
|
||||
@AknotAttribute
|
||||
public int valueB;
|
||||
@AknotAttribute(true)
|
||||
public int valueC;
|
||||
@AknotAttribute(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
private int valueF;
|
||||
private int valueG;
|
||||
private int valueH;
|
||||
private int valueI;
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
public final int finalValueM;
|
||||
@AknotAttribute
|
||||
public final int finalValueN;
|
||||
@AknotAttribute(true)
|
||||
public final int finalValueO;
|
||||
@AknotAttribute(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
public final int finalValueQ;
|
||||
public final int finalValueR;
|
||||
public final int finalValueS;
|
||||
public final int finalValueT;
|
||||
|
||||
private final int pFinalValueQ;
|
||||
private final int pFinalValueR;
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
|
||||
"pFinalValueT" })
|
||||
public TestNodeObjectTrue(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotAttribute final int finalValueR,
|
||||
@AknotAttribute(true) final int finalValueS, @AknotAttribute(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
this.finalValueP = finalValueP;
|
||||
this.finalValueQ = finalValueQ;
|
||||
this.finalValueR = finalValueR;
|
||||
this.finalValueS = finalValueS;
|
||||
this.finalValueT = finalValueT;
|
||||
this.pFinalValueQ = pFinalValueQ;
|
||||
this.pFinalValueR = pFinalValueR;
|
||||
this.pFinalValueS = pFinalValueS;
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@AknotAttribute
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@AknotAttribute(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@AknotAttribute(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
|
||||
@AknotAttribute
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
|
||||
@AknotAttribute(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
|
||||
@AknotAttribute(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
|
||||
@AknotAttribute
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
|
||||
@AknotAttribute(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
|
||||
@AknotAttribute(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
// ************************************************************
|
||||
// ** Attribute
|
||||
// ************************************************************
|
||||
@Test
|
||||
public void testDefaultAttribute() {
|
||||
TestNodeObject elem = new TestNodeObject(321,654,987,159,267,264,1524,182445, -552, -965, -98885, -8754);
|
||||
public void testDefaultAttribute() {
|
||||
final TestNodeObject elem = new TestNodeObject(321, 654, 987, 159, 267, 264, 1524, 182445, -552, -965, -98885, -8754);
|
||||
elem.valueA = 55;
|
||||
elem.valueB = 78;
|
||||
elem.valueC = 51;
|
||||
@ -169,18 +454,21 @@ public class ExmlTestIntrospectionDecoratorAttribute {
|
||||
elem.setValueJ(8247);
|
||||
elem.setValueK(885522);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + dataTest);
|
||||
Assertions.assertEquals("<elem finalValueM=\"321\" finalValueN=\"654\" finalValueO=\"987\" finalValueQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" pFinalValueQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" valueA=\"55\" valueB=\"78\" valueC=\"51\" valueE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\">\n"
|
||||
+ " <finalValueP>159</finalValueP>\n"
|
||||
+ " <finalValueT>182445</finalValueT>\n"
|
||||
+ " <pFinalValueT>-8754</pFinalValueT>\n"
|
||||
+ " <valueD>24</valueD>\n"
|
||||
+ " <valueJ>8247</valueJ>\n"
|
||||
+ " <valueK>885522</valueK>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals(
|
||||
"""
|
||||
<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
|
||||
<finalValueP>159</finalValueP>
|
||||
<finalValueT>182445</finalValueT>
|
||||
<pFinalValueT>-8754</pFinalValueT>
|
||||
<valueD>24</valueD>
|
||||
<valueJ>8247</valueJ>
|
||||
<valueK>885522</valueK>
|
||||
</elem>""",
|
||||
dataTest);
|
||||
|
||||
final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA);
|
||||
@ -208,138 +496,9 @@ public class ExmlTestIntrospectionDecoratorAttribute {
|
||||
Assertions.assertEquals(-8754, root.getPFinalValueT());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute(true)
|
||||
public class TestNodeObjectTrue {
|
||||
public int valueA;
|
||||
@XmlAttribute
|
||||
public int valueB;
|
||||
@XmlAttribute(true)
|
||||
public int valueC;
|
||||
@XmlAttribute(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
private int valueF;
|
||||
private int valueG;
|
||||
private int valueH;
|
||||
private int valueI;
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
|
||||
public final int finalValueM;
|
||||
@XmlAttribute
|
||||
public final int finalValueN;
|
||||
@XmlAttribute(true)
|
||||
public final int finalValueO;
|
||||
@XmlAttribute(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
public final int finalValueQ;
|
||||
public final int finalValueR;
|
||||
public final int finalValueS;
|
||||
public final int finalValueT;
|
||||
|
||||
private final int pFinalValueQ;
|
||||
private final int pFinalValueR;
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@XmlName({"finalValueM", "finalValueN", "finalValueO", "finalValueP",
|
||||
"finalValueQ", "finalValueR", "finalValueS", "finalValueT",
|
||||
"pFinalValueQ", "pFinalValueR", "pFinalValueS", "pFinalValueT"})
|
||||
public TestNodeObjectTrue(
|
||||
final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP,
|
||||
final int finalValueQ, @XmlAttribute final int finalValueR, @XmlAttribute(true) final int finalValueS, @XmlAttribute(false) final int finalValueT,
|
||||
final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
this.finalValueP = finalValueP;
|
||||
this.finalValueQ = finalValueQ;
|
||||
this.finalValueR = finalValueR;
|
||||
this.finalValueS = finalValueS;
|
||||
this.finalValueT = finalValueT;
|
||||
this.pFinalValueQ = pFinalValueQ;
|
||||
this.pFinalValueR = pFinalValueR;
|
||||
this.pFinalValueS = pFinalValueS;
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
@XmlAttribute
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
@XmlAttribute
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
@XmlAttribute(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
@XmlAttribute(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
@XmlAttribute(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
@XmlAttribute(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@XmlAttribute
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@XmlAttribute(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@XmlAttribute(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testDefaultAttributeTrue() {
|
||||
TestNodeObjectTrue elem = new TestNodeObjectTrue(321,654,987,159,267,264,1524,182445, -552, -965, -98885, -8754);
|
||||
public void testDefaultAttributeFalse() {
|
||||
final TestNodeObjectFalse elem = new TestNodeObjectFalse(321, 654, 987, 159, 267, 264, 1524, 182445, -552, -965, -98885, -8754);
|
||||
elem.valueA = 55;
|
||||
elem.valueB = 78;
|
||||
elem.valueC = 51;
|
||||
@ -352,205 +511,26 @@ public class ExmlTestIntrospectionDecoratorAttribute {
|
||||
elem.setValueJ(8247);
|
||||
elem.setValueK(885522);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem finalValueM=\"321\" finalValueN=\"654\" finalValueO=\"987\" finalValueQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" pFinalValueQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" valueA=\"55\" valueB=\"78\" valueC=\"51\" valueE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\">\n"
|
||||
+ " <finalValueP>159</finalValueP>\n"
|
||||
+ " <finalValueT>182445</finalValueT>\n"
|
||||
+ " <pFinalValueT>-8754</pFinalValueT>\n"
|
||||
+ " <valueD>24</valueD>\n"
|
||||
+ " <valueJ>8247</valueJ>\n"
|
||||
+ " <valueK>885522</valueK>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectTrue.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA);
|
||||
Assertions.assertEquals(78, root.valueB);
|
||||
Assertions.assertEquals(51, root.valueC);
|
||||
Assertions.assertEquals(24, root.valueD);
|
||||
Assertions.assertEquals(651, root.getValueE());
|
||||
Assertions.assertEquals(654, root.getValueF());
|
||||
Assertions.assertEquals(8552, root.getValueG());
|
||||
Assertions.assertEquals(9531, root.getValueH());
|
||||
Assertions.assertEquals(87465, root.getValueI());
|
||||
Assertions.assertEquals(8247, root.getValueJ());
|
||||
Assertions.assertEquals(885522, root.getValueK());
|
||||
Assertions.assertEquals(321, root.finalValueM);
|
||||
Assertions.assertEquals(654, root.finalValueN);
|
||||
Assertions.assertEquals(987, root.finalValueO);
|
||||
Assertions.assertEquals(159, root.finalValueP);
|
||||
Assertions.assertEquals(267, root.finalValueQ);
|
||||
Assertions.assertEquals(264, root.finalValueR);
|
||||
Assertions.assertEquals(1524, root.finalValueS);
|
||||
Assertions.assertEquals(182445, root.finalValueT);
|
||||
Assertions.assertEquals(-552, root.getPFinalValueQ());
|
||||
Assertions.assertEquals(-965, root.getPFinalValueR());
|
||||
Assertions.assertEquals(-98885, root.getPFinalValueS());
|
||||
Assertions.assertEquals(-8754, root.getPFinalValueT());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute(false)
|
||||
public class TestNodeObjectFalse {
|
||||
public int valueA;
|
||||
@XmlAttribute
|
||||
public int valueB;
|
||||
@XmlAttribute(true)
|
||||
public int valueC;
|
||||
@XmlAttribute(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
private int valueF;
|
||||
private int valueG;
|
||||
private int valueH;
|
||||
private int valueI;
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
public final int finalValueM;
|
||||
@XmlAttribute
|
||||
public final int finalValueN;
|
||||
@XmlAttribute(true)
|
||||
public final int finalValueO;
|
||||
@XmlAttribute(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
public final int finalValueQ;
|
||||
public final int finalValueR;
|
||||
public final int finalValueS;
|
||||
public final int finalValueT;
|
||||
|
||||
private final int pFinalValueQ;
|
||||
private final int pFinalValueR;
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@XmlName({"finalValueM", "finalValueN", "finalValueO", "finalValueP",
|
||||
"finalValueQ", "finalValueR", "finalValueS", "finalValueT",
|
||||
"pFinalValueQ", "pFinalValueR", "pFinalValueS", "pFinalValueT"})
|
||||
public TestNodeObjectFalse(
|
||||
final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP,
|
||||
final int finalValueQ, @XmlAttribute final int finalValueR, @XmlAttribute(true) final int finalValueS, @XmlAttribute(false) final int finalValueT,
|
||||
final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
this.finalValueP = finalValueP;
|
||||
this.finalValueQ = finalValueQ;
|
||||
this.finalValueR = finalValueR;
|
||||
this.finalValueS = finalValueS;
|
||||
this.finalValueT = finalValueT;
|
||||
this.pFinalValueQ = pFinalValueQ;
|
||||
this.pFinalValueR = pFinalValueR;
|
||||
this.pFinalValueS = pFinalValueS;
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
@XmlAttribute
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
@XmlAttribute
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
@XmlAttribute(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
@XmlAttribute(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
@XmlAttribute(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
@XmlAttribute(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@XmlAttribute
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@XmlAttribute(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@XmlAttribute(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testDefaultAttributeFalse() {
|
||||
TestNodeObjectFalse elem = new TestNodeObjectFalse(321,654,987,159,267,264,1524,182445, -552, -965, -98885, -8754);
|
||||
elem.valueA = 55;
|
||||
elem.valueB = 78;
|
||||
elem.valueC = 51;
|
||||
elem.valueD = 24;
|
||||
elem.setValueE(651);
|
||||
elem.setValueF(654);
|
||||
elem.setValueG(8552);
|
||||
elem.setValueH(9531);
|
||||
elem.setValueI(87465);
|
||||
elem.setValueJ(8247);
|
||||
elem.setValueK(885522);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem finalValueN=\"654\" finalValueO=\"987\" finalValueR=\"264\" finalValueS=\"1524\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" valueB=\"78\" valueC=\"51\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\">\n"
|
||||
+ " <finalValueM>321</finalValueM>\n"
|
||||
+ " <finalValueP>159</finalValueP>\n"
|
||||
+ " <finalValueQ>267</finalValueQ>\n"
|
||||
+ " <finalValueT>182445</finalValueT>\n"
|
||||
+ " <pFinalValueQ>-552</pFinalValueQ>\n"
|
||||
+ " <pFinalValueT>-8754</pFinalValueT>\n"
|
||||
+ " <valueA>55</valueA>\n"
|
||||
+ " <valueD>24</valueD>\n"
|
||||
+ " <valueE>651</valueE>\n"
|
||||
+ " <valueJ>8247</valueJ>\n"
|
||||
+ " <valueK>885522</valueK>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals(
|
||||
"""
|
||||
<elem finalValueN="654" finalValueO="987" finalValueR="264" finalValueS="1524" pFinalValueR="-965" pFinalValueS="-98885" valueB="78" valueC="51" valueF="654" valueG="8552" valueH="9531" valueI="87465">
|
||||
<finalValueM>321</finalValueM>
|
||||
<finalValueP>159</finalValueP>
|
||||
<finalValueQ>267</finalValueQ>
|
||||
<finalValueT>182445</finalValueT>
|
||||
<pFinalValueQ>-552</pFinalValueQ>
|
||||
<pFinalValueT>-8754</pFinalValueT>
|
||||
<valueA>55</valueA>
|
||||
<valueD>24</valueD>
|
||||
<valueE>651</valueE>
|
||||
<valueJ>8247</valueJ>
|
||||
<valueK>885522</valueK>
|
||||
</elem>""",
|
||||
dataTest);
|
||||
|
||||
final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectFalse.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA);
|
||||
@ -578,5 +558,61 @@ public class ExmlTestIntrospectionDecoratorAttribute {
|
||||
Assertions.assertEquals(-8754, root.getPFinalValueT());
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testDefaultAttributeTrue() {
|
||||
final TestNodeObjectTrue elem = new TestNodeObjectTrue(321, 654, 987, 159, 267, 264, 1524, 182445, -552, -965, -98885, -8754);
|
||||
elem.valueA = 55;
|
||||
elem.valueB = 78;
|
||||
elem.valueC = 51;
|
||||
elem.valueD = 24;
|
||||
elem.setValueE(651);
|
||||
elem.setValueF(654);
|
||||
elem.setValueG(8552);
|
||||
elem.setValueH(9531);
|
||||
elem.setValueI(87465);
|
||||
elem.setValueJ(8247);
|
||||
elem.setValueK(885522);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals(
|
||||
"""
|
||||
<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
|
||||
<finalValueP>159</finalValueP>
|
||||
<finalValueT>182445</finalValueT>
|
||||
<pFinalValueT>-8754</pFinalValueT>
|
||||
<valueD>24</valueD>
|
||||
<valueJ>8247</valueJ>
|
||||
<valueK>885522</valueK>
|
||||
</elem>""",
|
||||
dataTest);
|
||||
|
||||
final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectTrue.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA);
|
||||
Assertions.assertEquals(78, root.valueB);
|
||||
Assertions.assertEquals(51, root.valueC);
|
||||
Assertions.assertEquals(24, root.valueD);
|
||||
Assertions.assertEquals(651, root.getValueE());
|
||||
Assertions.assertEquals(654, root.getValueF());
|
||||
Assertions.assertEquals(8552, root.getValueG());
|
||||
Assertions.assertEquals(9531, root.getValueH());
|
||||
Assertions.assertEquals(87465, root.getValueI());
|
||||
Assertions.assertEquals(8247, root.getValueJ());
|
||||
Assertions.assertEquals(885522, root.getValueK());
|
||||
Assertions.assertEquals(321, root.finalValueM);
|
||||
Assertions.assertEquals(654, root.finalValueN);
|
||||
Assertions.assertEquals(987, root.finalValueO);
|
||||
Assertions.assertEquals(159, root.finalValueP);
|
||||
Assertions.assertEquals(267, root.finalValueQ);
|
||||
Assertions.assertEquals(264, root.finalValueR);
|
||||
Assertions.assertEquals(1524, root.finalValueS);
|
||||
Assertions.assertEquals(182445, root.finalValueT);
|
||||
Assertions.assertEquals(-552, root.getPFinalValueQ());
|
||||
Assertions.assertEquals(-965, root.getPFinalValueR());
|
||||
Assertions.assertEquals(-98885, root.getPFinalValueS());
|
||||
Assertions.assertEquals(-8754, root.getPFinalValueT());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -5,35 +5,24 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultOptional;
|
||||
import org.atriasoft.aknot.annotation.AknotName;
|
||||
import org.atriasoft.aknot.annotation.AknotOptional;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultOptional;
|
||||
import org.atriasoft.exml.annotation.XmlName;
|
||||
import org.atriasoft.exml.annotation.XmlOptional;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionDecoratorOptionnal {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
// ************************************************************
|
||||
// ** Attribute
|
||||
// ************************************************************
|
||||
|
||||
@XmlDefaultOptional
|
||||
@AknotDefaultOptional
|
||||
public class TestNodeObject {
|
||||
|
||||
public int valueA;
|
||||
@XmlOptional
|
||||
@AknotOptional
|
||||
public int valueB;
|
||||
@XmlOptional(true)
|
||||
@AknotOptional(true)
|
||||
public int valueC;
|
||||
@XmlOptional(false)
|
||||
@AknotOptional(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
@ -44,13 +33,12 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
|
||||
public final int finalValueM;
|
||||
@XmlOptional
|
||||
@AknotOptional
|
||||
public final int finalValueN;
|
||||
@XmlOptional(true)
|
||||
@AknotOptional(true)
|
||||
public final int finalValueO;
|
||||
@XmlOptional(false)
|
||||
@AknotOptional(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
@ -64,13 +52,11 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@XmlName({"finalValueM", "finalValueN", "finalValueO", "finalValueP",
|
||||
"finalValueQ", "finalValueR", "finalValueS", "finalValueT",
|
||||
"pFinalValueQ", "pFinalValueR", "pFinalValueS", "pFinalValueT"})
|
||||
public TestNodeObject(
|
||||
final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP,
|
||||
final int finalValueQ, @XmlOptional final int finalValueR, @XmlOptional(true) final int finalValueS, @XmlOptional(false) final int finalValueT,
|
||||
final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
|
||||
@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
|
||||
"pFinalValueT" })
|
||||
public TestNodeObject(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotOptional final int finalValueR,
|
||||
@AknotOptional(true) final int finalValueS, @AknotOptional(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
|
||||
final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
@ -85,78 +71,380 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@AknotOptional
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@AknotOptional(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@AknotOptional(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
@XmlOptional
|
||||
|
||||
@AknotOptional
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
@XmlOptional
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
@XmlOptional(true)
|
||||
|
||||
@AknotOptional(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
@XmlOptional(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
@XmlOptional(false)
|
||||
|
||||
@AknotOptional(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
@XmlOptional(false)
|
||||
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
|
||||
@AknotOptional
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
|
||||
@AknotOptional(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
|
||||
@AknotOptional(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@AknotDefaultOptional(false)
|
||||
public class TestNodeObjectFalse {
|
||||
public int valueA;
|
||||
@AknotOptional
|
||||
public int valueB;
|
||||
@AknotOptional(true)
|
||||
public int valueC;
|
||||
@AknotOptional(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
private int valueF;
|
||||
private int valueG;
|
||||
private int valueH;
|
||||
private int valueI;
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
public final int finalValueM;
|
||||
@AknotOptional
|
||||
public final int finalValueN;
|
||||
@AknotOptional(true)
|
||||
public final int finalValueO;
|
||||
@AknotOptional(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
public final int finalValueQ;
|
||||
public final int finalValueR;
|
||||
public final int finalValueS;
|
||||
public final int finalValueT;
|
||||
|
||||
private final int pFinalValueQ;
|
||||
private final int pFinalValueR;
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
|
||||
"pFinalValueT" })
|
||||
public TestNodeObjectFalse(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotOptional final int finalValueR,
|
||||
@AknotOptional(true) final int finalValueS, @AknotOptional(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
|
||||
final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
this.finalValueP = finalValueP;
|
||||
this.finalValueQ = finalValueQ;
|
||||
this.finalValueR = finalValueR;
|
||||
this.finalValueS = finalValueS;
|
||||
this.finalValueT = finalValueT;
|
||||
this.pFinalValueQ = pFinalValueQ;
|
||||
this.pFinalValueR = pFinalValueR;
|
||||
this.pFinalValueS = pFinalValueS;
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@XmlOptional
|
||||
@AknotOptional
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@XmlOptional(true)
|
||||
@AknotOptional(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@XmlOptional(false)
|
||||
@AknotOptional(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
|
||||
@AknotOptional
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
|
||||
@AknotOptional(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
|
||||
@AknotOptional(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
|
||||
@AknotOptional
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
|
||||
@AknotOptional(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
|
||||
@AknotOptional(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@AknotDefaultOptional(true)
|
||||
public class TestNodeObjectTrue {
|
||||
public int valueA;
|
||||
@AknotOptional
|
||||
public int valueB;
|
||||
@AknotOptional(true)
|
||||
public int valueC;
|
||||
@AknotOptional(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
private int valueF;
|
||||
private int valueG;
|
||||
private int valueH;
|
||||
private int valueI;
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
public final int finalValueM;
|
||||
@AknotOptional
|
||||
public final int finalValueN;
|
||||
@AknotOptional(true)
|
||||
public final int finalValueO;
|
||||
@AknotOptional(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
public final int finalValueQ;
|
||||
public final int finalValueR;
|
||||
public final int finalValueS;
|
||||
public final int finalValueT;
|
||||
|
||||
private final int pFinalValueQ;
|
||||
private final int pFinalValueR;
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@AknotName({ "finalValueM", "finalValueN", "finalValueO", "finalValueP", "finalValueQ", "finalValueR", "finalValueS", "finalValueT", "pFinalValueQ", "pFinalValueR", "pFinalValueS",
|
||||
"pFinalValueT" })
|
||||
public TestNodeObjectTrue(final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP, final int finalValueQ, @AknotOptional final int finalValueR,
|
||||
@AknotOptional(true) final int finalValueS, @AknotOptional(false) final int finalValueT, final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS,
|
||||
final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
this.finalValueP = finalValueP;
|
||||
this.finalValueQ = finalValueQ;
|
||||
this.finalValueR = finalValueR;
|
||||
this.finalValueS = finalValueS;
|
||||
this.finalValueT = finalValueT;
|
||||
this.pFinalValueQ = pFinalValueQ;
|
||||
this.pFinalValueR = pFinalValueR;
|
||||
this.pFinalValueS = pFinalValueS;
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@AknotOptional
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@AknotOptional(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@AknotOptional(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
|
||||
@AknotOptional
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
|
||||
@AknotOptional(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
|
||||
@AknotOptional(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
|
||||
@AknotOptional
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
|
||||
@AknotOptional(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
|
||||
@AknotOptional(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
// ************************************************************
|
||||
// ** Attribute
|
||||
// ************************************************************
|
||||
@Test
|
||||
public void testDefaultAttribute() {
|
||||
TestNodeObject elem = new TestNodeObject(321,654,987,159,267,264,1524,182445, -552, -965, -98885, -8754);
|
||||
public void testDefaultAttribute() {
|
||||
final TestNodeObject elem = new TestNodeObject(321, 654, 987, 159, 267, 264, 1524, 182445, -552, -965, -98885, -8754);
|
||||
elem.valueA = 55;
|
||||
elem.valueB = 78;
|
||||
elem.valueC = 51;
|
||||
@ -169,18 +457,21 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
|
||||
elem.setValueJ(8247);
|
||||
elem.setValueK(885522);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + dataTest);
|
||||
Assertions.assertEquals("<elem finalValueM=\"321\" finalValueN=\"654\" finalValueO=\"987\" finalValueQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" pFinalValueQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" valueA=\"55\" valueB=\"78\" valueC=\"51\" valueE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\">\n"
|
||||
+ " <finalValueP>159</finalValueP>\n"
|
||||
+ " <finalValueT>182445</finalValueT>\n"
|
||||
+ " <pFinalValueT>-8754</pFinalValueT>\n"
|
||||
+ " <valueD>24</valueD>\n"
|
||||
+ " <valueJ>8247</valueJ>\n"
|
||||
+ " <valueK>885522</valueK>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals(
|
||||
"""
|
||||
<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
|
||||
<finalValueP>159</finalValueP>
|
||||
<finalValueT>182445</finalValueT>
|
||||
<pFinalValueT>-8754</pFinalValueT>
|
||||
<valueD>24</valueD>
|
||||
<valueJ>8247</valueJ>
|
||||
<valueK>885522</valueK>
|
||||
</elem>""",
|
||||
dataTest);
|
||||
|
||||
final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA);
|
||||
@ -208,138 +499,9 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
|
||||
Assertions.assertEquals(-8754, root.getPFinalValueT());
|
||||
}
|
||||
|
||||
@XmlDefaultOptional(true)
|
||||
public class TestNodeObjectTrue {
|
||||
public int valueA;
|
||||
@XmlOptional
|
||||
public int valueB;
|
||||
@XmlOptional(true)
|
||||
public int valueC;
|
||||
@XmlOptional(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
private int valueF;
|
||||
private int valueG;
|
||||
private int valueH;
|
||||
private int valueI;
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
|
||||
public final int finalValueM;
|
||||
@XmlOptional
|
||||
public final int finalValueN;
|
||||
@XmlOptional(true)
|
||||
public final int finalValueO;
|
||||
@XmlOptional(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
public final int finalValueQ;
|
||||
public final int finalValueR;
|
||||
public final int finalValueS;
|
||||
public final int finalValueT;
|
||||
|
||||
private final int pFinalValueQ;
|
||||
private final int pFinalValueR;
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@XmlName({"finalValueM", "finalValueN", "finalValueO", "finalValueP",
|
||||
"finalValueQ", "finalValueR", "finalValueS", "finalValueT",
|
||||
"pFinalValueQ", "pFinalValueR", "pFinalValueS", "pFinalValueT"})
|
||||
public TestNodeObjectTrue(
|
||||
final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP,
|
||||
final int finalValueQ, @XmlOptional final int finalValueR, @XmlOptional(true) final int finalValueS, @XmlOptional(false) final int finalValueT,
|
||||
final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
this.finalValueP = finalValueP;
|
||||
this.finalValueQ = finalValueQ;
|
||||
this.finalValueR = finalValueR;
|
||||
this.finalValueS = finalValueS;
|
||||
this.finalValueT = finalValueT;
|
||||
this.pFinalValueQ = pFinalValueQ;
|
||||
this.pFinalValueR = pFinalValueR;
|
||||
this.pFinalValueS = pFinalValueS;
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
@XmlOptional
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
@XmlOptional
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
@XmlOptional(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
@XmlOptional(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
@XmlOptional(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
@XmlOptional(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@XmlOptional
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@XmlOptional(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@XmlOptional(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testDefaultAttributeTrue() {
|
||||
TestNodeObjectTrue elem = new TestNodeObjectTrue(321,654,987,159,267,264,1524,182445, -552, -965, -98885, -8754);
|
||||
public void testDefaultAttributeFalse() {
|
||||
final TestNodeObjectFalse elem = new TestNodeObjectFalse(321, 654, 987, 159, 267, 264, 1524, 182445, -552, -965, -98885, -8754);
|
||||
elem.valueA = 55;
|
||||
elem.valueB = 78;
|
||||
elem.valueC = 51;
|
||||
@ -352,205 +514,26 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
|
||||
elem.setValueJ(8247);
|
||||
elem.setValueK(885522);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem finalValueM=\"321\" finalValueN=\"654\" finalValueO=\"987\" finalValueQ=\"267\" finalValueR=\"264\" finalValueS=\"1524\" pFinalValueQ=\"-552\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" valueA=\"55\" valueB=\"78\" valueC=\"51\" valueE=\"651\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\">\n"
|
||||
+ " <finalValueP>159</finalValueP>\n"
|
||||
+ " <finalValueT>182445</finalValueT>\n"
|
||||
+ " <pFinalValueT>-8754</pFinalValueT>\n"
|
||||
+ " <valueD>24</valueD>\n"
|
||||
+ " <valueJ>8247</valueJ>\n"
|
||||
+ " <valueK>885522</valueK>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectTrue.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA);
|
||||
Assertions.assertEquals(78, root.valueB);
|
||||
Assertions.assertEquals(51, root.valueC);
|
||||
Assertions.assertEquals(24, root.valueD);
|
||||
Assertions.assertEquals(651, root.getValueE());
|
||||
Assertions.assertEquals(654, root.getValueF());
|
||||
Assertions.assertEquals(8552, root.getValueG());
|
||||
Assertions.assertEquals(9531, root.getValueH());
|
||||
Assertions.assertEquals(87465, root.getValueI());
|
||||
Assertions.assertEquals(8247, root.getValueJ());
|
||||
Assertions.assertEquals(885522, root.getValueK());
|
||||
Assertions.assertEquals(321, root.finalValueM);
|
||||
Assertions.assertEquals(654, root.finalValueN);
|
||||
Assertions.assertEquals(987, root.finalValueO);
|
||||
Assertions.assertEquals(159, root.finalValueP);
|
||||
Assertions.assertEquals(267, root.finalValueQ);
|
||||
Assertions.assertEquals(264, root.finalValueR);
|
||||
Assertions.assertEquals(1524, root.finalValueS);
|
||||
Assertions.assertEquals(182445, root.finalValueT);
|
||||
Assertions.assertEquals(-552, root.getPFinalValueQ());
|
||||
Assertions.assertEquals(-965, root.getPFinalValueR());
|
||||
Assertions.assertEquals(-98885, root.getPFinalValueS());
|
||||
Assertions.assertEquals(-8754, root.getPFinalValueT());
|
||||
}
|
||||
|
||||
@XmlDefaultOptional(false)
|
||||
public class TestNodeObjectFalse {
|
||||
public int valueA;
|
||||
@XmlOptional
|
||||
public int valueB;
|
||||
@XmlOptional(true)
|
||||
public int valueC;
|
||||
@XmlOptional(false)
|
||||
public int valueD;
|
||||
|
||||
private int valueE;
|
||||
private int valueF;
|
||||
private int valueG;
|
||||
private int valueH;
|
||||
private int valueI;
|
||||
private int valueJ;
|
||||
private int valueK;
|
||||
|
||||
public final int finalValueM;
|
||||
@XmlOptional
|
||||
public final int finalValueN;
|
||||
@XmlOptional(true)
|
||||
public final int finalValueO;
|
||||
@XmlOptional(false)
|
||||
public final int finalValueP;
|
||||
|
||||
// special case for bijectivity with records
|
||||
public final int finalValueQ;
|
||||
public final int finalValueR;
|
||||
public final int finalValueS;
|
||||
public final int finalValueT;
|
||||
|
||||
private final int pFinalValueQ;
|
||||
private final int pFinalValueR;
|
||||
private final int pFinalValueS;
|
||||
private final int pFinalValueT;
|
||||
|
||||
@XmlName({"finalValueM", "finalValueN", "finalValueO", "finalValueP",
|
||||
"finalValueQ", "finalValueR", "finalValueS", "finalValueT",
|
||||
"pFinalValueQ", "pFinalValueR", "pFinalValueS", "pFinalValueT"})
|
||||
public TestNodeObjectFalse(
|
||||
final int finalValueM, final int finalValueN, final int finalValueO, final int finalValueP,
|
||||
final int finalValueQ, @XmlOptional final int finalValueR, @XmlOptional(true) final int finalValueS, @XmlOptional(false) final int finalValueT,
|
||||
final int pFinalValueQ, final int pFinalValueR, final int pFinalValueS, final int pFinalValueT) {
|
||||
this.finalValueM = finalValueM;
|
||||
this.finalValueN = finalValueN;
|
||||
this.finalValueO = finalValueO;
|
||||
this.finalValueP = finalValueP;
|
||||
this.finalValueQ = finalValueQ;
|
||||
this.finalValueR = finalValueR;
|
||||
this.finalValueS = finalValueS;
|
||||
this.finalValueT = finalValueT;
|
||||
this.pFinalValueQ = pFinalValueQ;
|
||||
this.pFinalValueR = pFinalValueR;
|
||||
this.pFinalValueS = pFinalValueS;
|
||||
this.pFinalValueT = pFinalValueT;
|
||||
}
|
||||
|
||||
public int getValueE() {
|
||||
return this.valueE;
|
||||
}
|
||||
public void setValueE(final int valueE) {
|
||||
this.valueE = valueE;
|
||||
}
|
||||
@XmlOptional
|
||||
public int getValueF() {
|
||||
return this.valueF;
|
||||
}
|
||||
public void setValueF(final int valueF) {
|
||||
this.valueF = valueF;
|
||||
}
|
||||
public int getValueG() {
|
||||
return this.valueG;
|
||||
}
|
||||
@XmlOptional
|
||||
public void setValueG(final int valueG) {
|
||||
this.valueG = valueG;
|
||||
}
|
||||
@XmlOptional(true)
|
||||
public int getValueH() {
|
||||
return this.valueH;
|
||||
}
|
||||
public void setValueH(final int valueH) {
|
||||
this.valueH = valueH;
|
||||
}
|
||||
public int getValueI() {
|
||||
return this.valueI;
|
||||
}
|
||||
@XmlOptional(true)
|
||||
public void setValueI(final int valueI) {
|
||||
this.valueI = valueI;
|
||||
}
|
||||
@XmlOptional(false)
|
||||
public int getValueJ() {
|
||||
return this.valueJ;
|
||||
}
|
||||
public void setValueJ(final int valueJ) {
|
||||
this.valueJ = valueJ;
|
||||
}
|
||||
public int getValueK() {
|
||||
return this.valueK;
|
||||
}
|
||||
@XmlOptional(false)
|
||||
public void setValueK(final int valueK) {
|
||||
this.valueK = valueK;
|
||||
}
|
||||
|
||||
|
||||
public int getPFinalValueQ() {
|
||||
return this.pFinalValueQ;
|
||||
}
|
||||
|
||||
@XmlOptional
|
||||
public int getPFinalValueR() {
|
||||
return this.pFinalValueR;
|
||||
}
|
||||
|
||||
@XmlOptional(true)
|
||||
public int getPFinalValueS() {
|
||||
return this.pFinalValueS;
|
||||
}
|
||||
|
||||
@XmlOptional(false)
|
||||
public int getPFinalValueT() {
|
||||
return this.pFinalValueT;
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testDefaultAttributeFalse() {
|
||||
TestNodeObjectFalse elem = new TestNodeObjectFalse(321,654,987,159,267,264,1524,182445, -552, -965, -98885, -8754);
|
||||
elem.valueA = 55;
|
||||
elem.valueB = 78;
|
||||
elem.valueC = 51;
|
||||
elem.valueD = 24;
|
||||
elem.setValueE(651);
|
||||
elem.setValueF(654);
|
||||
elem.setValueG(8552);
|
||||
elem.setValueH(9531);
|
||||
elem.setValueI(87465);
|
||||
elem.setValueJ(8247);
|
||||
elem.setValueK(885522);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem finalValueN=\"654\" finalValueO=\"987\" finalValueR=\"264\" finalValueS=\"1524\" pFinalValueR=\"-965\" pFinalValueS=\"-98885\" valueB=\"78\" valueC=\"51\" valueF=\"654\" valueG=\"8552\" valueH=\"9531\" valueI=\"87465\">\n"
|
||||
+ " <finalValueM>321</finalValueM>\n"
|
||||
+ " <finalValueP>159</finalValueP>\n"
|
||||
+ " <finalValueQ>267</finalValueQ>\n"
|
||||
+ " <finalValueT>182445</finalValueT>\n"
|
||||
+ " <pFinalValueQ>-552</pFinalValueQ>\n"
|
||||
+ " <pFinalValueT>-8754</pFinalValueT>\n"
|
||||
+ " <valueA>55</valueA>\n"
|
||||
+ " <valueD>24</valueD>\n"
|
||||
+ " <valueE>651</valueE>\n"
|
||||
+ " <valueJ>8247</valueJ>\n"
|
||||
+ " <valueK>885522</valueK>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals(
|
||||
"""
|
||||
<elem finalValueN="654" finalValueO="987" finalValueR="264" finalValueS="1524" pFinalValueR="-965" pFinalValueS="-98885" valueB="78" valueC="51" valueF="654" valueG="8552" valueH="9531" valueI="87465">
|
||||
<finalValueM>321</finalValueM>
|
||||
<finalValueP>159</finalValueP>
|
||||
<finalValueQ>267</finalValueQ>
|
||||
<finalValueT>182445</finalValueT>
|
||||
<pFinalValueQ>-552</pFinalValueQ>
|
||||
<pFinalValueT>-8754</pFinalValueT>
|
||||
<valueA>55</valueA>
|
||||
<valueD>24</valueD>
|
||||
<valueE>651</valueE>
|
||||
<valueJ>8247</valueJ>
|
||||
<valueK>885522</valueK>
|
||||
</elem>""",
|
||||
dataTest);
|
||||
|
||||
final TestNodeObjectFalse root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectFalse.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA);
|
||||
@ -578,5 +561,61 @@ public class ExmlTestIntrospectionDecoratorOptionnal {
|
||||
Assertions.assertEquals(-8754, root.getPFinalValueT());
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testDefaultAttributeTrue() {
|
||||
final TestNodeObjectTrue elem = new TestNodeObjectTrue(321, 654, 987, 159, 267, 264, 1524, 182445, -552, -965, -98885, -8754);
|
||||
elem.valueA = 55;
|
||||
elem.valueB = 78;
|
||||
elem.valueC = 51;
|
||||
elem.valueD = 24;
|
||||
elem.setValueE(651);
|
||||
elem.setValueF(654);
|
||||
elem.setValueG(8552);
|
||||
elem.setValueH(9531);
|
||||
elem.setValueI(87465);
|
||||
elem.setValueJ(8247);
|
||||
elem.setValueK(885522);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals(
|
||||
"""
|
||||
<elem finalValueM="321" finalValueN="654" finalValueO="987" finalValueQ="267" finalValueR="264" finalValueS="1524" pFinalValueQ="-552" pFinalValueR="-965" pFinalValueS="-98885" valueA="55" valueB="78" valueC="51" valueE="651" valueF="654" valueG="8552" valueH="9531" valueI="87465">
|
||||
<finalValueP>159</finalValueP>
|
||||
<finalValueT>182445</finalValueT>
|
||||
<pFinalValueT>-8754</pFinalValueT>
|
||||
<valueD>24</valueD>
|
||||
<valueJ>8247</valueJ>
|
||||
<valueK>885522</valueK>
|
||||
</elem>""",
|
||||
dataTest);
|
||||
|
||||
final TestNodeObjectTrue root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectTrue.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA);
|
||||
Assertions.assertEquals(78, root.valueB);
|
||||
Assertions.assertEquals(51, root.valueC);
|
||||
Assertions.assertEquals(24, root.valueD);
|
||||
Assertions.assertEquals(651, root.getValueE());
|
||||
Assertions.assertEquals(654, root.getValueF());
|
||||
Assertions.assertEquals(8552, root.getValueG());
|
||||
Assertions.assertEquals(9531, root.getValueH());
|
||||
Assertions.assertEquals(87465, root.getValueI());
|
||||
Assertions.assertEquals(8247, root.getValueJ());
|
||||
Assertions.assertEquals(885522, root.getValueK());
|
||||
Assertions.assertEquals(321, root.finalValueM);
|
||||
Assertions.assertEquals(654, root.finalValueN);
|
||||
Assertions.assertEquals(987, root.finalValueO);
|
||||
Assertions.assertEquals(159, root.finalValueP);
|
||||
Assertions.assertEquals(267, root.finalValueQ);
|
||||
Assertions.assertEquals(264, root.finalValueR);
|
||||
Assertions.assertEquals(1524, root.finalValueS);
|
||||
Assertions.assertEquals(182445, root.finalValueT);
|
||||
Assertions.assertEquals(-552, root.getPFinalValueQ());
|
||||
Assertions.assertEquals(-965, root.getPFinalValueR());
|
||||
Assertions.assertEquals(-98885, root.getPFinalValueS());
|
||||
Assertions.assertEquals(-8754, root.getPFinalValueT());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -7,140 +7,20 @@ package test.atriasoft.exml;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionDouble {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestDouble {
|
||||
public Double valueA;
|
||||
public Double valueB;
|
||||
public Double valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelDouble() {
|
||||
TestDouble elem = new TestDouble();
|
||||
elem.valueA = (double)12;
|
||||
elem.valueB = (double)-13;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
|
||||
|
||||
final TestDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayDouble {
|
||||
public Double[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayDouble() {
|
||||
TestArrayDouble elem = new TestArrayDouble();
|
||||
elem.values = new Double[] {(double)12, (double)-13, (double)33, (double)78, (double)-127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListDouble {
|
||||
public List<Double> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListDouble() {
|
||||
TestListDouble elem = new TestListDouble();
|
||||
elem.values = List.of((double)12, (double)-13, (double)33, (double)78, (double)-127);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestListDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestDoubleFunc {
|
||||
private Double valueA;
|
||||
private Double valueB;
|
||||
private Double valueNull;
|
||||
public Double getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Double valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Double getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Double valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Double getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Double valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelDoubleFunc() {
|
||||
TestDoubleFunc elem = new TestDoubleFunc();
|
||||
elem.setValueA((double)-55);
|
||||
elem.setValueB((double)57);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
|
||||
|
||||
final TestDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayDoubleFunc {
|
||||
private Double[] values;
|
||||
|
||||
@ -153,189 +33,10 @@ public class ExmlTestIntrospectionDouble {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayDoubleFunc() {
|
||||
TestArrayDoubleFunc elem = new TestArrayDoubleFunc();
|
||||
elem.setValues(new Double[] {(double)12, (double)-13, (double)33, (double)78, (double)-127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListDoubleFunc {
|
||||
private List<Double> values;
|
||||
|
||||
public List<Double> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Double> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListDoubleFunc() {
|
||||
TestListDoubleFunc elem = new TestListDoubleFunc();
|
||||
elem.setValues(List.of((double)12, (double)-13, (double)33, (double)78, (double)-127));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestListDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(12, root.getValues().get(0));
|
||||
Assertions.assertEquals(-13, root.getValues().get(1));
|
||||
Assertions.assertEquals(33, root.getValues().get(2));
|
||||
Assertions.assertEquals(78, root.getValues().get(3));
|
||||
Assertions.assertEquals(-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
public class TestNodeDouble {
|
||||
public Double valueA;
|
||||
public Double valueB;
|
||||
public Double valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeDouble() {
|
||||
TestNodeDouble elem = new TestNodeDouble();
|
||||
elem.valueA = (double)11;
|
||||
elem.valueB = (double)-120;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>11.0</valueA>\n"
|
||||
+ " <valueB>-120.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
public class TestArrayNodeDouble {
|
||||
public Double[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeDouble() {
|
||||
TestArrayNodeDouble elem = new TestArrayNodeDouble();
|
||||
elem.values = new Double[] {(double)12, (double)-13, (double)33, (double)78, (double)-127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestListNodeDouble {
|
||||
public List<Double> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeDouble() {
|
||||
TestListNodeDouble elem = new TestListNodeDouble();
|
||||
elem.values = List.of((double)12, (double)-13, (double)33, (double)78, (double)-127);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
public class TestNodeDoubleFunc {
|
||||
private Double valueA;
|
||||
private Double valueB;
|
||||
private Double valueNull;
|
||||
public Double getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Double valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Double getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Double valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Double getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Double valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeDoubleFunc() {
|
||||
TestNodeDoubleFunc elem = new TestNodeDoubleFunc();
|
||||
elem.setValueA((double)54);
|
||||
elem.setValueB((double)-68);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>54.0</valueA>\n"
|
||||
+ " <valueB>-68.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
public class TestArrayNodeDoubleFunc {
|
||||
private Double[] values;
|
||||
@ -349,30 +50,70 @@ public class ExmlTestIntrospectionDouble {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeDoubleFunc() {
|
||||
TestArrayNodeDoubleFunc elem = new TestArrayNodeDoubleFunc();
|
||||
elem.setValues(new Double[] {(double)12, (double)-13, (double)33, (double)78, (double)-127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
public class TestArrayNodeDoubleStructured {
|
||||
@AknotList(value = "elem")
|
||||
public Double[] values;
|
||||
}
|
||||
|
||||
final TestArrayNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
@AknotDefaultAttribute
|
||||
public class TestDouble {
|
||||
public Double valueA;
|
||||
public Double valueB;
|
||||
public Double valueNull;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestDoubleFunc {
|
||||
private Double valueA;
|
||||
private Double valueB;
|
||||
private Double valueNull;
|
||||
|
||||
public Double getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Double getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Double getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Double valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Double valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Double valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListDouble {
|
||||
public List<Double> values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListDoubleFunc {
|
||||
private List<Double> values;
|
||||
|
||||
public List<Double> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Double> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestListNodeDouble {
|
||||
public List<Double> values;
|
||||
}
|
||||
|
||||
// Note this is set in static to test an other part of code...
|
||||
@ -387,22 +128,329 @@ public class ExmlTestIntrospectionDouble {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeDoubleFunc() {
|
||||
TestListNodeDoubleFunc elem = new TestListNodeDoubleFunc();
|
||||
elem.setValues(List.of((double)12, (double)-13, (double)33, (double)78, (double)-127));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public class TestListNodeDoubleStructured {
|
||||
@AknotList(value = "elem")
|
||||
public List<Double> values;
|
||||
}
|
||||
|
||||
public class TestNodeDouble {
|
||||
public Double valueA;
|
||||
public Double valueB;
|
||||
public Double valueNull;
|
||||
}
|
||||
|
||||
public class TestNodeDoubleFunc {
|
||||
private Double valueA;
|
||||
private Double valueB;
|
||||
private Double valueNull;
|
||||
|
||||
public Double getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Double getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Double getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Double valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Double valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Double valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeDoubleStructured() {
|
||||
final TestArrayNodeDoubleStructured elem = new TestArrayNodeDoubleStructured();
|
||||
elem.values = new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12.0</elem>
|
||||
<elem>-13.0</elem>
|
||||
<elem>33.0</elem>
|
||||
<elem>78.0</elem>
|
||||
<elem>-127.0</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeDoubleStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleStructured.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals((double) 5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testListNodeDoubleStructured() {
|
||||
final TestListNodeDoubleStructured elem = new TestListNodeDoubleStructured();
|
||||
elem.values = List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12.0</elem>
|
||||
<elem>-13.0</elem>
|
||||
<elem>33.0</elem>
|
||||
<elem>78.0</elem>
|
||||
<elem>-127.0</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeDoubleStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeDoubleStructured.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayDouble() {
|
||||
final TestArrayDouble elem = new TestArrayDouble();
|
||||
elem.values = new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayDoubleFunc() {
|
||||
final TestArrayDoubleFunc elem = new TestArrayDoubleFunc();
|
||||
elem.setValues(new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeDouble() {
|
||||
final TestArrayNodeDouble elem = new TestArrayNodeDouble();
|
||||
elem.values = new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeDoubleFunc() {
|
||||
final TestArrayNodeDoubleFunc elem = new TestArrayNodeDoubleFunc();
|
||||
elem.setValues(new Double[] { (double) 12, (double) -13, (double) 33, (double) 78, (double) -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelDouble() {
|
||||
final TestDouble elem = new TestDouble();
|
||||
elem.valueA = (double) 12;
|
||||
elem.valueB = (double) -13;
|
||||
elem.valueNull = null;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
|
||||
|
||||
final TestDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelDoubleFunc() {
|
||||
final TestDoubleFunc elem = new TestDoubleFunc();
|
||||
elem.setValueA((double) -55);
|
||||
elem.setValueB((double) 57);
|
||||
elem.setValueNull(null);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
|
||||
|
||||
final TestDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListDouble() {
|
||||
final TestListDouble elem = new TestListDouble();
|
||||
elem.values = List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestListDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListDoubleFunc() {
|
||||
final TestListDoubleFunc elem = new TestListDoubleFunc();
|
||||
elem.setValues(List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestListDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(12, root.getValues().get(0));
|
||||
Assertions.assertEquals(-13, root.getValues().get(1));
|
||||
Assertions.assertEquals(33, root.getValues().get(2));
|
||||
Assertions.assertEquals(78, root.getValues().get(3));
|
||||
Assertions.assertEquals(-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeDouble() {
|
||||
final TestListNodeDouble elem = new TestListNodeDouble();
|
||||
elem.values = List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeDoubleFunc() {
|
||||
final TestListNodeDoubleFunc elem = new TestListNodeDoubleFunc();
|
||||
elem.setValues(List.of((double) 12, (double) -13, (double) 33, (double) 78, (double) -127));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
@ -413,72 +461,49 @@ public class ExmlTestIntrospectionDouble {
|
||||
Assertions.assertEquals(-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
public class TestListNodeDoubleStructured {
|
||||
@XmlList(value="elem")
|
||||
public List<Double> values;
|
||||
}
|
||||
@Test
|
||||
public void testListNodeDoubleStructured() {
|
||||
TestListNodeDoubleStructured elem = new TestListNodeDoubleStructured();
|
||||
elem.values = List.of((double)12, (double)-13, (double)33, (double)78, (double)-127);
|
||||
public void testModelNodeDouble() {
|
||||
final TestNodeDouble elem = new TestNodeDouble();
|
||||
elem.valueA = (double) 11;
|
||||
elem.valueB = (double) -120;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12.0</elem>\n"
|
||||
+ " <elem>-13.0</elem>\n"
|
||||
+ " <elem>33.0</elem>\n"
|
||||
+ " <elem>78.0</elem>\n"
|
||||
+ " <elem>-127.0</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>11.0</valueA>
|
||||
<valueB>-120.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeDoubleStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeDoubleStructured.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
public class TestArrayNodeDoubleStructured {
|
||||
@XmlList(value="elem")
|
||||
public Double[] values;
|
||||
final TestNodeDouble root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeDouble.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeDoubleStructured() {
|
||||
TestArrayNodeDoubleStructured elem = new TestArrayNodeDoubleStructured();
|
||||
elem.values = new Double[] {(double)12, (double)-13, (double)33, (double)78, (double)-127};
|
||||
public void testModelNodeDoubleFunc() {
|
||||
final TestNodeDoubleFunc elem = new TestNodeDoubleFunc();
|
||||
elem.setValueA((double) 54);
|
||||
elem.setValueB((double) -68);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12.0</elem>\n"
|
||||
+ " <elem>-13.0</elem>\n"
|
||||
+ " <elem>33.0</elem>\n"
|
||||
+ " <elem>78.0</elem>\n"
|
||||
+ " <elem>-127.0</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>54.0</valueA>
|
||||
<valueB>-68.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeDoubleStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleStructured.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals((double)5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
final TestNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -5,103 +5,15 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionDoubleNative {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestDoubleNative {
|
||||
public double valueA;
|
||||
public double valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelDoubleNative() {
|
||||
TestDoubleNative elem = new TestDoubleNative();
|
||||
elem.valueA = 12;
|
||||
elem.valueB = -13;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
|
||||
|
||||
final TestDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestArrayDoubleNative {
|
||||
public double[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayDoubleNative() {
|
||||
TestArrayDoubleNative elem = new TestArrayDoubleNative();
|
||||
elem.values = new double[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestdoubleFunc {
|
||||
private double valueA;
|
||||
private double valueB;
|
||||
public double getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final double valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public double getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final double valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelDoubleFunc() {
|
||||
TestdoubleFunc elem = new TestdoubleFunc();
|
||||
elem.setValueA(-55);
|
||||
elem.setValueB(57);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
|
||||
|
||||
final TestdoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestdoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayDoubleFunc {
|
||||
private double[] values;
|
||||
|
||||
@ -114,115 +26,11 @@ public class ExmlTestIntrospectionDoubleNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayDoubleFunc() {
|
||||
TestArrayDoubleFunc elem = new TestArrayDoubleFunc();
|
||||
elem.setValues(new double[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestNodeDoubleNative {
|
||||
public double valueA;
|
||||
public double valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeDoubleNative() {
|
||||
TestNodeDoubleNative elem = new TestNodeDoubleNative();
|
||||
elem.valueA = 11;
|
||||
elem.valueB = -120;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>11.0</valueA>\n"
|
||||
+ " <valueB>-120.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
}
|
||||
|
||||
public class TestArrayNodeDoubleNative {
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayDoubleNative {
|
||||
public double[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeDoubleNative() {
|
||||
TestArrayNodeDoubleNative elem = new TestArrayNodeDoubleNative();
|
||||
elem.values = new double[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestNodedoubleFunc {
|
||||
private double valueA;
|
||||
private double valueB;
|
||||
public double getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final double valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public double getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final double valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeDoubleFunc() {
|
||||
TestNodedoubleFunc elem = new TestNodedoubleFunc();
|
||||
elem.setValueA(54);
|
||||
elem.setValueB(-68);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>54.0</valueA>\n"
|
||||
+ " <valueB>-68.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodedoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodedoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
}
|
||||
|
||||
public class TestArrayNodeDoubleFunc {
|
||||
private double[] values;
|
||||
@ -236,22 +44,163 @@ public class ExmlTestIntrospectionDoubleNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeDoubleFunc() {
|
||||
TestArrayNodeDoubleFunc elem = new TestArrayNodeDoubleFunc();
|
||||
elem.setValues(new double[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public class TestArrayNodeDoubleNative {
|
||||
public double[] values;
|
||||
}
|
||||
|
||||
public class TestArrayNodeDoubleNativeStructured {
|
||||
@AknotList(value = "elem")
|
||||
public double[] values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestdoubleFunc {
|
||||
private double valueA;
|
||||
private double valueB;
|
||||
|
||||
public double getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public double getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final double valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final double valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestDoubleNative {
|
||||
public double valueA;
|
||||
public double valueB;
|
||||
}
|
||||
|
||||
public class TestNodedoubleFunc {
|
||||
private double valueA;
|
||||
private double valueB;
|
||||
|
||||
public double getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public double getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final double valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final double valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestNodeDoubleNative {
|
||||
public double valueA;
|
||||
public double valueB;
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeDoubleNativeStructured() {
|
||||
final TestArrayNodeDoubleNativeStructured elem = new TestArrayNodeDoubleNativeStructured();
|
||||
elem.values = new double[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12.0</elem>
|
||||
<elem>-13.0</elem>
|
||||
<elem>33.0</elem>
|
||||
<elem>78.0</elem>
|
||||
<elem>-127.0</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeDoubleNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleNativeStructured.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayDoubleFunc() {
|
||||
final TestArrayDoubleFunc elem = new TestArrayDoubleFunc();
|
||||
elem.setValues(new double[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayDoubleNative() {
|
||||
final TestArrayDoubleNative elem = new TestArrayDoubleNative();
|
||||
elem.values = new double[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeDoubleFunc() {
|
||||
final TestArrayNodeDoubleFunc elem = new TestArrayNodeDoubleFunc();
|
||||
elem.setValues(new double[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeDoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
@ -262,30 +211,25 @@ public class ExmlTestIntrospectionDoubleNative {
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestArrayNodeDoubleNativeStructured {
|
||||
@XmlList(value="elem")
|
||||
public double[] values;
|
||||
}
|
||||
@Test
|
||||
public void testArrayNodeDoubleNativeStructured() {
|
||||
TestArrayNodeDoubleNativeStructured elem = new TestArrayNodeDoubleNativeStructured();
|
||||
elem.values = new double[] {12, -13, 33, 78, -127};
|
||||
public void testModelArrayNodeDoubleNative() {
|
||||
final TestArrayNodeDoubleNative elem = new TestArrayNodeDoubleNative();
|
||||
elem.values = new double[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12.0</elem>\n"
|
||||
+ " <elem>-13.0</elem>\n"
|
||||
+ " <elem>33.0</elem>\n"
|
||||
+ " <elem>78.0</elem>\n"
|
||||
+ " <elem>-127.0</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeDoubleNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleNativeStructured.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
final TestArrayNodeDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
@ -293,5 +237,80 @@ public class ExmlTestIntrospectionDoubleNative {
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelDoubleFunc() {
|
||||
final TestdoubleFunc elem = new TestdoubleFunc();
|
||||
elem.setValueA(-55);
|
||||
elem.setValueB(57);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
|
||||
|
||||
final TestdoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestdoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelDoubleNative() {
|
||||
final TestDoubleNative elem = new TestDoubleNative();
|
||||
elem.valueA = 12;
|
||||
elem.valueB = -13;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
|
||||
|
||||
final TestDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeDoubleFunc() {
|
||||
final TestNodedoubleFunc elem = new TestNodedoubleFunc();
|
||||
elem.setValueA(54);
|
||||
elem.setValueB(-68);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>54.0</valueA>
|
||||
<valueB>-68.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodedoubleFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodedoubleFunc.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeDoubleNative() {
|
||||
final TestNodeDoubleNative elem = new TestNodeDoubleNative();
|
||||
elem.valueA = 11;
|
||||
elem.valueB = -120;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionDouble.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>11.0</valueA>
|
||||
<valueB>-120.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeDoubleNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeDoubleNative.class, ExmlTestIntrospectionDouble.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
}
|
||||
}
|
||||
|
||||
@ -7,134 +7,20 @@ package test.atriasoft.exml;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionEnum {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
public enum TestEnumVal {
|
||||
VALUE_1,
|
||||
VALUE_2,
|
||||
VALUE_3;
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestEnum {
|
||||
public TestEnumVal valueA;
|
||||
public TestEnumVal valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelEnum() {
|
||||
TestEnum elem = new TestEnum();
|
||||
elem.valueA = TestEnumVal.VALUE_1;
|
||||
elem.valueB = TestEnumVal.VALUE_3;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"VALUE_1\" valueB=\"VALUE_3\"/>", dataTest);
|
||||
|
||||
final TestEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.valueA);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.valueB);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayEnum {
|
||||
public TestEnumVal[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayEnum() {
|
||||
TestArrayEnum elem = new TestArrayEnum();
|
||||
elem.values = new TestEnumVal[] {TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestArrayEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListEnum {
|
||||
public List<TestEnumVal> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListEnum() {
|
||||
TestListEnum elem = new TestListEnum();
|
||||
elem.values = List.of(TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestListEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(0));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(1));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values.get(2));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(3));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestEnumFunc {
|
||||
private TestEnumVal valueA;
|
||||
private TestEnumVal valueB;
|
||||
public TestEnumVal getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final TestEnumVal valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public TestEnumVal getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final TestEnumVal valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelEnumFunc() {
|
||||
TestEnumFunc elem = new TestEnumFunc();
|
||||
elem.setValueA(TestEnumVal.VALUE_1);
|
||||
elem.setValueB(TestEnumVal.VALUE_2);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"VALUE_1\" valueB=\"VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValueA());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValueB());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayEnumFunc {
|
||||
private TestEnumVal[] values;
|
||||
|
||||
@ -147,177 +33,10 @@ public class ExmlTestIntrospectionEnum {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayEnumFunc() {
|
||||
TestArrayEnumFunc elem = new TestArrayEnumFunc();
|
||||
elem.setValues(new TestEnumVal[] {TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestArrayEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.getValues()[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListEnumFunc {
|
||||
private List<TestEnumVal> values;
|
||||
|
||||
public List<TestEnumVal> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<TestEnumVal> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListEnumFunc() {
|
||||
TestListEnumFunc elem = new TestListEnumFunc();
|
||||
elem.setValues(List.of(TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestListEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues().get(0));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues().get(1));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.getValues().get(2));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues().get(3));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues().get(4));
|
||||
}
|
||||
|
||||
public class TestNodeEnum {
|
||||
public TestEnumVal valueA;
|
||||
public TestEnumVal valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeEnum() {
|
||||
TestNodeEnum elem = new TestNodeEnum();
|
||||
elem.valueA = TestEnumVal.VALUE_3;
|
||||
elem.valueB = TestEnumVal.VALUE_1;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>VALUE_3</valueA>\n"
|
||||
+ " <valueB>VALUE_1</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.valueA);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.valueB);
|
||||
}
|
||||
|
||||
public class TestArrayNodeEnum {
|
||||
public TestEnumVal[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeEnum() {
|
||||
TestArrayNodeEnum elem = new TestArrayNodeEnum();
|
||||
elem.values = new TestEnumVal[] {TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>VALUE_1</values>\n"
|
||||
+ " <values>VALUE_2</values>\n"
|
||||
+ " <values>VALUE_3</values>\n"
|
||||
+ " <values>VALUE_1</values>\n"
|
||||
+ " <values>VALUE_2</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestListNodeEnum {
|
||||
public List<TestEnumVal> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeEnum() {
|
||||
TestListNodeEnum elem = new TestListNodeEnum();
|
||||
elem.values = List.of(TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>VALUE_1</values>\n"
|
||||
+ " <values>VALUE_2</values>\n"
|
||||
+ " <values>VALUE_3</values>\n"
|
||||
+ " <values>VALUE_1</values>\n"
|
||||
+ " <values>VALUE_2</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(0));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(1));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values.get(2));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(3));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
public class TestNodeEnumFunc {
|
||||
private TestEnumVal valueA;
|
||||
private TestEnumVal valueB;
|
||||
public TestEnumVal getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final TestEnumVal valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public TestEnumVal getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final TestEnumVal valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeEnumFunc() {
|
||||
TestNodeEnumFunc elem = new TestNodeEnumFunc();
|
||||
elem.setValueA(TestEnumVal.VALUE_2);
|
||||
elem.setValueB(TestEnumVal.VALUE_3);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>VALUE_2</valueA>\n"
|
||||
+ " <valueB>VALUE_3</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValueA());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.getValueB());
|
||||
}
|
||||
|
||||
public class TestArrayNodeEnumFunc {
|
||||
private TestEnumVal[] values;
|
||||
@ -331,30 +50,64 @@ public class ExmlTestIntrospectionEnum {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeEnumFunc() {
|
||||
TestArrayNodeEnumFunc elem = new TestArrayNodeEnumFunc();
|
||||
elem.setValues(new TestEnumVal[] {TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>VALUE_1</values>\n"
|
||||
+ " <values>VALUE_2</values>\n"
|
||||
+ " <values>VALUE_3</values>\n"
|
||||
+ " <values>VALUE_1</values>\n"
|
||||
+ " <values>VALUE_2</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
public class TestArrayNodeEnumStructured {
|
||||
@AknotList(value = "elem")
|
||||
public TestEnumVal[] values;
|
||||
}
|
||||
|
||||
final TestArrayNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.getValues()[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[4]);
|
||||
@AknotDefaultAttribute
|
||||
public class TestEnum {
|
||||
public TestEnumVal valueA;
|
||||
public TestEnumVal valueB;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestEnumFunc {
|
||||
private TestEnumVal valueA;
|
||||
private TestEnumVal valueB;
|
||||
|
||||
public TestEnumVal getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public TestEnumVal getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final TestEnumVal valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final TestEnumVal valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
public enum TestEnumVal {
|
||||
VALUE_1, VALUE_2, VALUE_3;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListEnum {
|
||||
public List<TestEnumVal> values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListEnumFunc {
|
||||
private List<TestEnumVal> values;
|
||||
|
||||
public List<TestEnumVal> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<TestEnumVal> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestListNodeEnum {
|
||||
public List<TestEnumVal> values;
|
||||
}
|
||||
|
||||
// Note this is set in static to test an other part of code...
|
||||
@ -369,22 +122,315 @@ public class ExmlTestIntrospectionEnum {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeEnumFunc() {
|
||||
TestListNodeEnumFunc elem = new TestListNodeEnumFunc();
|
||||
elem.setValues(List.of(TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public class TestListNodeEnumStructured {
|
||||
@AknotList(value = "elem")
|
||||
public List<TestEnumVal> values;
|
||||
}
|
||||
|
||||
public class TestNodeEnum {
|
||||
public TestEnumVal valueA;
|
||||
public TestEnumVal valueB;
|
||||
}
|
||||
|
||||
public class TestNodeEnumFunc {
|
||||
private TestEnumVal valueA;
|
||||
private TestEnumVal valueB;
|
||||
|
||||
public TestEnumVal getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public TestEnumVal getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final TestEnumVal valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final TestEnumVal valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeTestEnumValStructured() {
|
||||
final TestArrayNodeEnumStructured elem = new TestArrayNodeEnumStructured();
|
||||
elem.values = new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>VALUE_1</values>\n"
|
||||
+ " <values>VALUE_2</values>\n"
|
||||
+ " <values>VALUE_3</values>\n"
|
||||
+ " <values>VALUE_1</values>\n"
|
||||
+ " <values>VALUE_2</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>VALUE_1</elem>
|
||||
<elem>VALUE_2</elem>
|
||||
<elem>VALUE_3</elem>
|
||||
<elem>VALUE_1</elem>
|
||||
<elem>VALUE_2</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeEnumStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeEnumStructured.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testListNodeTestEnumValStructured() {
|
||||
final TestListNodeEnumStructured elem = new TestListNodeEnumStructured();
|
||||
elem.values = List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>VALUE_1</elem>
|
||||
<elem>VALUE_2</elem>
|
||||
<elem>VALUE_3</elem>
|
||||
<elem>VALUE_1</elem>
|
||||
<elem>VALUE_2</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeEnumStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeEnumStructured.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(0));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(1));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values.get(2));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(3));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayEnum() {
|
||||
final TestArrayEnum elem = new TestArrayEnum();
|
||||
elem.values = new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestArrayEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayEnumFunc() {
|
||||
final TestArrayEnumFunc elem = new TestArrayEnumFunc();
|
||||
elem.setValues(new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestArrayEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.getValues()[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeEnum() {
|
||||
final TestArrayNodeEnum elem = new TestArrayNodeEnum();
|
||||
elem.values = new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>VALUE_1</values>
|
||||
<values>VALUE_2</values>
|
||||
<values>VALUE_3</values>
|
||||
<values>VALUE_1</values>
|
||||
<values>VALUE_2</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeEnumFunc() {
|
||||
final TestArrayNodeEnumFunc elem = new TestArrayNodeEnumFunc();
|
||||
elem.setValues(new TestEnumVal[] { TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>VALUE_1</values>
|
||||
<values>VALUE_2</values>
|
||||
<values>VALUE_3</values>
|
||||
<values>VALUE_1</values>
|
||||
<values>VALUE_2</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.getValues()[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues()[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelEnum() {
|
||||
final TestEnum elem = new TestEnum();
|
||||
elem.valueA = TestEnumVal.VALUE_1;
|
||||
elem.valueB = TestEnumVal.VALUE_3;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"VALUE_1\" valueB=\"VALUE_3\"/>", dataTest);
|
||||
|
||||
final TestEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.valueA);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.valueB);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelEnumFunc() {
|
||||
final TestEnumFunc elem = new TestEnumFunc();
|
||||
elem.setValueA(TestEnumVal.VALUE_1);
|
||||
elem.setValueB(TestEnumVal.VALUE_2);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"VALUE_1\" valueB=\"VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValueA());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListEnum() {
|
||||
final TestListEnum elem = new TestListEnum();
|
||||
elem.values = List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestListEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(0));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(1));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values.get(2));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(3));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListEnumFunc() {
|
||||
final TestListEnumFunc elem = new TestListEnumFunc();
|
||||
elem.setValues(List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"VALUE_1;VALUE_2;VALUE_3;VALUE_1;VALUE_2\"/>", dataTest);
|
||||
|
||||
final TestListEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues().get(0));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues().get(1));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.getValues().get(2));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.getValues().get(3));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues().get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeEnum() {
|
||||
final TestListNodeEnum elem = new TestListNodeEnum();
|
||||
elem.values = List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>VALUE_1</values>
|
||||
<values>VALUE_2</values>
|
||||
<values>VALUE_3</values>
|
||||
<values>VALUE_1</values>
|
||||
<values>VALUE_2</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(0));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(1));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values.get(2));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(3));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeEnumFunc() {
|
||||
final TestListNodeEnumFunc elem = new TestListNodeEnumFunc();
|
||||
elem.setValues(List.of(TestEnumVal.VALUE_1, TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>VALUE_1</values>
|
||||
<values>VALUE_2</values>
|
||||
<values>VALUE_3</values>
|
||||
<values>VALUE_1</values>
|
||||
<values>VALUE_2</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
@ -395,72 +441,45 @@ public class ExmlTestIntrospectionEnum {
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValues().get(4));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
public class TestListNodeEnumStructured {
|
||||
@XmlList(value="elem")
|
||||
public List<TestEnumVal> values;
|
||||
}
|
||||
@Test
|
||||
public void testListNodeTestEnumValStructured() {
|
||||
TestListNodeEnumStructured elem = new TestListNodeEnumStructured();
|
||||
elem.values = List.of(TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2);
|
||||
public void testModelNodeEnum() {
|
||||
final TestNodeEnum elem = new TestNodeEnum();
|
||||
elem.valueA = TestEnumVal.VALUE_3;
|
||||
elem.valueB = TestEnumVal.VALUE_1;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>VALUE_1</elem>\n"
|
||||
+ " <elem>VALUE_2</elem>\n"
|
||||
+ " <elem>VALUE_3</elem>\n"
|
||||
+ " <elem>VALUE_1</elem>\n"
|
||||
+ " <elem>VALUE_2</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>VALUE_3</valueA>
|
||||
<valueB>VALUE_1</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeEnumStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeEnumStructured.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(0));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(1));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values.get(2));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values.get(3));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values.get(4));
|
||||
}
|
||||
public class TestArrayNodeEnumStructured {
|
||||
@XmlList(value="elem")
|
||||
public TestEnumVal[] values;
|
||||
final TestNodeEnum root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeEnum.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.valueA);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.valueB);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeTestEnumValStructured() {
|
||||
TestArrayNodeEnumStructured elem = new TestArrayNodeEnumStructured();
|
||||
elem.values = new TestEnumVal[] {TestEnumVal.VALUE_1,TestEnumVal.VALUE_2, TestEnumVal.VALUE_3, TestEnumVal.VALUE_1, TestEnumVal.VALUE_2};
|
||||
public void testModelNodeEnumFunc() {
|
||||
final TestNodeEnumFunc elem = new TestNodeEnumFunc();
|
||||
elem.setValueA(TestEnumVal.VALUE_2);
|
||||
elem.setValueB(TestEnumVal.VALUE_3);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionEnum.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>VALUE_1</elem>\n"
|
||||
+ " <elem>VALUE_2</elem>\n"
|
||||
+ " <elem>VALUE_3</elem>\n"
|
||||
+ " <elem>VALUE_1</elem>\n"
|
||||
+ " <elem>VALUE_2</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>VALUE_2</valueA>
|
||||
<valueB>VALUE_3</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeEnumStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeEnumStructured.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[0]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[1]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.values[2]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_1, root.values[3]);
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.values[4]);
|
||||
final TestNodeEnumFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeEnumFunc.class, ExmlTestIntrospectionEnum.NODE_NAME));
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_2, root.getValueA());
|
||||
Assertions.assertEquals(TestEnumVal.VALUE_3, root.getValueB());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -7,140 +7,20 @@ package test.atriasoft.exml;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionFloat {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestFloat {
|
||||
public Float valueA;
|
||||
public Float valueB;
|
||||
public Float valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelFloat() {
|
||||
TestFloat elem = new TestFloat();
|
||||
elem.valueA = (float)12;
|
||||
elem.valueB = (float)-13;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
|
||||
|
||||
final TestFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayFloat {
|
||||
public Float[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayFloat() {
|
||||
TestArrayFloat elem = new TestArrayFloat();
|
||||
elem.values = new Float[] {(float)12, (float)-13, (float)33, (float)78, (float)-127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListFloat {
|
||||
public List<Float> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListFloat() {
|
||||
TestListFloat elem = new TestListFloat();
|
||||
elem.values = List.of((float)12, (float)-13, (float)33, (float)78, (float)-127);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestListFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestFloatFunc {
|
||||
private Float valueA;
|
||||
private Float valueB;
|
||||
private Float valueNull;
|
||||
public Float getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Float valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Float getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Float valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Float getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Float valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelFloatFunc() {
|
||||
TestFloatFunc elem = new TestFloatFunc();
|
||||
elem.setValueA((float)-55);
|
||||
elem.setValueB((float)57);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
|
||||
|
||||
final TestFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayFloatFunc {
|
||||
private Float[] values;
|
||||
|
||||
@ -153,189 +33,10 @@ public class ExmlTestIntrospectionFloat {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayFloatFunc() {
|
||||
TestArrayFloatFunc elem = new TestArrayFloatFunc();
|
||||
elem.setValues(new Float[] {(float)12, (float)-13, (float)33, (float)78, (float)-127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListFloatFunc {
|
||||
private List<Float> values;
|
||||
|
||||
public List<Float> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Float> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListFloatFunc() {
|
||||
TestListFloatFunc elem = new TestListFloatFunc();
|
||||
elem.setValues(List.of((float)12, (float)-13, (float)33, (float)78, (float)-127));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestListFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(12, root.getValues().get(0));
|
||||
Assertions.assertEquals(-13, root.getValues().get(1));
|
||||
Assertions.assertEquals(33, root.getValues().get(2));
|
||||
Assertions.assertEquals(78, root.getValues().get(3));
|
||||
Assertions.assertEquals(-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
public class TestNodeFloat {
|
||||
public Float valueA;
|
||||
public Float valueB;
|
||||
public Float valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeFloat() {
|
||||
TestNodeFloat elem = new TestNodeFloat();
|
||||
elem.valueA = (float)11;
|
||||
elem.valueB = (float)-120;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>11.0</valueA>\n"
|
||||
+ " <valueB>-120.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
public class TestArrayNodeFloat {
|
||||
public Float[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeFloat() {
|
||||
TestArrayNodeFloat elem = new TestArrayNodeFloat();
|
||||
elem.values = new Float[] {(float)12, (float)-13, (float)33, (float)78, (float)-127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestListNodeFloat {
|
||||
public List<Float> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeFloat() {
|
||||
TestListNodeFloat elem = new TestListNodeFloat();
|
||||
elem.values = List.of((float)12, (float)-13, (float)33, (float)78, (float)-127);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
public class TestNodeFloatFunc {
|
||||
private Float valueA;
|
||||
private Float valueB;
|
||||
private Float valueNull;
|
||||
public Float getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Float valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Float getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Float valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Float getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Float valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeFloatFunc() {
|
||||
TestNodeFloatFunc elem = new TestNodeFloatFunc();
|
||||
elem.setValueA((float)54);
|
||||
elem.setValueB((float)-68);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>54.0</valueA>\n"
|
||||
+ " <valueB>-68.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
public class TestArrayNodeFloatFunc {
|
||||
private Float[] values;
|
||||
@ -349,30 +50,75 @@ public class ExmlTestIntrospectionFloat {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeFloatFunc() {
|
||||
TestArrayNodeFloatFunc elem = new TestArrayNodeFloatFunc();
|
||||
elem.setValues(new Float[] {(float)12, (float)-13, (float)33, (float)78, (float)-127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
public class TestArrayNodeFloatStructured {
|
||||
@AknotList(value = "elem")
|
||||
public Float[] values;
|
||||
}
|
||||
|
||||
final TestArrayNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
@AknotDefaultAttribute
|
||||
public class TestFloat {
|
||||
public Float valueA;
|
||||
public Float valueB;
|
||||
public Float valueNull;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestFloatFunc {
|
||||
private Float valueA;
|
||||
private Float valueB;
|
||||
private Float valueNull;
|
||||
|
||||
public Float getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Float getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Float getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Float valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Float valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Float valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListFloat {
|
||||
public List<Float> values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListFloatFunc {
|
||||
private List<Float> values;
|
||||
|
||||
public List<Float> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Float> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestListNodeByteStructured {
|
||||
@AknotList(value = "elem")
|
||||
public List<Float> values;
|
||||
}
|
||||
|
||||
public class TestListNodeFloat {
|
||||
public List<Float> values;
|
||||
}
|
||||
|
||||
// Note this is set in static to test an other part of code...
|
||||
@ -387,22 +133,324 @@ public class ExmlTestIntrospectionFloat {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeFloatFunc() {
|
||||
TestListNodeFloatFunc elem = new TestListNodeFloatFunc();
|
||||
elem.setValues(List.of((float)12, (float)-13, (float)33, (float)78, (float)-127));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public class TestNodeFloat {
|
||||
public Float valueA;
|
||||
public Float valueB;
|
||||
public Float valueNull;
|
||||
}
|
||||
|
||||
public class TestNodeFloatFunc {
|
||||
private Float valueA;
|
||||
private Float valueB;
|
||||
private Float valueNull;
|
||||
|
||||
public Float getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Float getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Float getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Float valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Float valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Float valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeFloatStructured() {
|
||||
final TestArrayNodeFloatStructured elem = new TestArrayNodeFloatStructured();
|
||||
elem.values = new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12.0</elem>
|
||||
<elem>-13.0</elem>
|
||||
<elem>33.0</elem>
|
||||
<elem>78.0</elem>
|
||||
<elem>-127.0</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeFloatStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatStructured.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testListNodeByteStructured() {
|
||||
final TestListNodeByteStructured elem = new TestListNodeByteStructured();
|
||||
elem.values = List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12.0</elem>
|
||||
<elem>-13.0</elem>
|
||||
<elem>33.0</elem>
|
||||
<elem>78.0</elem>
|
||||
<elem>-127.0</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeByteStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeByteStructured.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayFloat() {
|
||||
final TestArrayFloat elem = new TestArrayFloat();
|
||||
elem.values = new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayFloatFunc() {
|
||||
final TestArrayFloatFunc elem = new TestArrayFloatFunc();
|
||||
elem.setValues(new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeFloat() {
|
||||
final TestArrayNodeFloat elem = new TestArrayNodeFloat();
|
||||
elem.values = new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeFloatFunc() {
|
||||
final TestArrayNodeFloatFunc elem = new TestArrayNodeFloatFunc();
|
||||
elem.setValues(new Float[] { (float) 12, (float) -13, (float) 33, (float) 78, (float) -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelFloat() {
|
||||
final TestFloat elem = new TestFloat();
|
||||
elem.valueA = (float) 12;
|
||||
elem.valueB = (float) -13;
|
||||
elem.valueNull = null;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
|
||||
|
||||
final TestFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelFloatFunc() {
|
||||
final TestFloatFunc elem = new TestFloatFunc();
|
||||
elem.setValueA((float) -55);
|
||||
elem.setValueB((float) 57);
|
||||
elem.setValueNull(null);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
|
||||
|
||||
final TestFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListFloat() {
|
||||
final TestListFloat elem = new TestListFloat();
|
||||
elem.values = List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestListFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListFloatFunc() {
|
||||
final TestListFloatFunc elem = new TestListFloatFunc();
|
||||
elem.setValues(List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestListFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(12, root.getValues().get(0));
|
||||
Assertions.assertEquals(-13, root.getValues().get(1));
|
||||
Assertions.assertEquals(33, root.getValues().get(2));
|
||||
Assertions.assertEquals(78, root.getValues().get(3));
|
||||
Assertions.assertEquals(-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeFloat() {
|
||||
final TestListNodeFloat elem = new TestListNodeFloat();
|
||||
elem.values = List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeFloatFunc() {
|
||||
final TestListNodeFloatFunc elem = new TestListNodeFloatFunc();
|
||||
elem.setValues(List.of((float) 12, (float) -13, (float) 33, (float) 78, (float) -127));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
@ -413,68 +461,49 @@ public class ExmlTestIntrospectionFloat {
|
||||
Assertions.assertEquals(-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
|
||||
public class TestListNodeByteStructured {
|
||||
@XmlList(value="elem")
|
||||
public List<Float> values;
|
||||
}
|
||||
@Test
|
||||
public void testListNodeByteStructured() {
|
||||
TestListNodeByteStructured elem = new TestListNodeByteStructured();
|
||||
elem.values = List.of((float)12, (float)-13, (float)33, (float)78, (float)-127);
|
||||
public void testModelNodeFloat() {
|
||||
final TestNodeFloat elem = new TestNodeFloat();
|
||||
elem.valueA = (float) 11;
|
||||
elem.valueB = (float) -120;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionByte.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12.0</elem>\n"
|
||||
+ " <elem>-13.0</elem>\n"
|
||||
+ " <elem>33.0</elem>\n"
|
||||
+ " <elem>78.0</elem>\n"
|
||||
+ " <elem>-127.0</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeByteStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeByteStructured.class, ExmlTestIntrospectionByte.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
public class TestArrayNodeFloatStructured {
|
||||
@XmlList(value="elem")
|
||||
public Float[] values;
|
||||
}
|
||||
@Test
|
||||
public void testArrayNodeFloatStructured() {
|
||||
TestArrayNodeFloatStructured elem = new TestArrayNodeFloatStructured();
|
||||
elem.values = new Float[] {(float)12, (float)-13, (float)33, (float)78, (float)-127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12.0</elem>\n"
|
||||
+ " <elem>-13.0</elem>\n"
|
||||
+ " <elem>33.0</elem>\n"
|
||||
+ " <elem>78.0</elem>\n"
|
||||
+ " <elem>-127.0</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>11.0</valueA>
|
||||
<valueB>-120.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeFloatStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatStructured.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
final TestNodeFloat root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeFloat.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeFloatFunc() {
|
||||
final TestNodeFloatFunc elem = new TestNodeFloatFunc();
|
||||
elem.setValueA((float) 54);
|
||||
elem.setValueB((float) -68);
|
||||
elem.setValueNull(null);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>54.0</valueA>
|
||||
<valueB>-68.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -5,103 +5,15 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionFloatNative {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestFloatNative {
|
||||
public float valueA;
|
||||
public float valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelFloatNative() {
|
||||
TestFloatNative elem = new TestFloatNative();
|
||||
elem.valueA = 12;
|
||||
elem.valueB = -13;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
|
||||
|
||||
final TestFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestArrayFloatNative {
|
||||
public float[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayFloatNative() {
|
||||
TestArrayFloatNative elem = new TestArrayFloatNative();
|
||||
elem.values = new float[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestfloatFunc {
|
||||
private float valueA;
|
||||
private float valueB;
|
||||
public float getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final float valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public float getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final float valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelFloatFunc() {
|
||||
TestfloatFunc elem = new TestfloatFunc();
|
||||
elem.setValueA(-55);
|
||||
elem.setValueB(57);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
|
||||
|
||||
final TestfloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestfloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayFloatFunc {
|
||||
private float[] values;
|
||||
|
||||
@ -114,115 +26,11 @@ public class ExmlTestIntrospectionFloatNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayFloatFunc() {
|
||||
TestArrayFloatFunc elem = new TestArrayFloatFunc();
|
||||
elem.setValues(new float[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestNodeFloatNative {
|
||||
public float valueA;
|
||||
public float valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeFloatNative() {
|
||||
TestNodeFloatNative elem = new TestNodeFloatNative();
|
||||
elem.valueA = 11;
|
||||
elem.valueB = -120;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>11.0</valueA>\n"
|
||||
+ " <valueB>-120.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
}
|
||||
|
||||
public class TestArrayNodeFloatNative {
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayFloatNative {
|
||||
public float[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeFloatNative() {
|
||||
TestArrayNodeFloatNative elem = new TestArrayNodeFloatNative();
|
||||
elem.values = new float[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestNodefloatFunc {
|
||||
private float valueA;
|
||||
private float valueB;
|
||||
public float getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final float valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public float getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final float valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeFloatFunc() {
|
||||
TestNodefloatFunc elem = new TestNodefloatFunc();
|
||||
elem.setValueA(54);
|
||||
elem.setValueB(-68);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>54.0</valueA>\n"
|
||||
+ " <valueB>-68.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodefloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodefloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
}
|
||||
|
||||
public class TestArrayNodeFloatFunc {
|
||||
private float[] values;
|
||||
@ -236,22 +44,163 @@ public class ExmlTestIntrospectionFloatNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeFloatFunc() {
|
||||
TestArrayNodeFloatFunc elem = new TestArrayNodeFloatFunc();
|
||||
elem.setValues(new float[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public class TestArrayNodeFloatNative {
|
||||
public float[] values;
|
||||
}
|
||||
|
||||
public class TestArrayNodeFloatNativeStructured {
|
||||
@AknotList(value = "elem")
|
||||
public float[] values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestfloatFunc {
|
||||
private float valueA;
|
||||
private float valueB;
|
||||
|
||||
public float getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public float getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final float valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final float valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestFloatNative {
|
||||
public float valueA;
|
||||
public float valueB;
|
||||
}
|
||||
|
||||
public class TestNodefloatFunc {
|
||||
private float valueA;
|
||||
private float valueB;
|
||||
|
||||
public float getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public float getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final float valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final float valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestNodeFloatNative {
|
||||
public float valueA;
|
||||
public float valueB;
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeFloatNativeStructured() {
|
||||
final TestArrayNodeFloatNativeStructured elem = new TestArrayNodeFloatNativeStructured();
|
||||
elem.values = new float[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12.0</values>\n"
|
||||
+ " <values>-13.0</values>\n"
|
||||
+ " <values>33.0</values>\n"
|
||||
+ " <values>78.0</values>\n"
|
||||
+ " <values>-127.0</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12.0</elem>
|
||||
<elem>-13.0</elem>
|
||||
<elem>33.0</elem>
|
||||
<elem>78.0</elem>
|
||||
<elem>-127.0</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeFloatNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatNativeStructured.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayFloatFunc() {
|
||||
final TestArrayFloatFunc elem = new TestArrayFloatFunc();
|
||||
elem.setValues(new float[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayFloatNative() {
|
||||
final TestArrayFloatNative elem = new TestArrayFloatNative();
|
||||
elem.values = new float[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12.0;-13.0;33.0;78.0;-127.0\"/>", dataTest);
|
||||
|
||||
final TestArrayFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeFloatFunc() {
|
||||
final TestArrayNodeFloatFunc elem = new TestArrayNodeFloatFunc();
|
||||
elem.setValues(new float[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeFloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
@ -262,30 +211,25 @@ public class ExmlTestIntrospectionFloatNative {
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestArrayNodeFloatNativeStructured {
|
||||
@XmlList(value="elem")
|
||||
public float[] values;
|
||||
}
|
||||
@Test
|
||||
public void testArrayNodeFloatNativeStructured() {
|
||||
TestArrayNodeFloatNativeStructured elem = new TestArrayNodeFloatNativeStructured();
|
||||
elem.values = new float[] {12, -13, 33, 78, -127};
|
||||
public void testModelArrayNodeFloatNative() {
|
||||
final TestArrayNodeFloatNative elem = new TestArrayNodeFloatNative();
|
||||
elem.values = new float[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12.0</elem>\n"
|
||||
+ " <elem>-13.0</elem>\n"
|
||||
+ " <elem>33.0</elem>\n"
|
||||
+ " <elem>78.0</elem>\n"
|
||||
+ " <elem>-127.0</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12.0</values>
|
||||
<values>-13.0</values>
|
||||
<values>33.0</values>
|
||||
<values>78.0</values>
|
||||
<values>-127.0</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeFloatNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatNativeStructured.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
final TestArrayNodeFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
@ -293,5 +237,80 @@ public class ExmlTestIntrospectionFloatNative {
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelFloatFunc() {
|
||||
final TestfloatFunc elem = new TestfloatFunc();
|
||||
elem.setValueA(-55);
|
||||
elem.setValueB(57);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55.0\" valueB=\"57.0\"/>", dataTest);
|
||||
|
||||
final TestfloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestfloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelFloatNative() {
|
||||
final TestFloatNative elem = new TestFloatNative();
|
||||
elem.valueA = 12;
|
||||
elem.valueB = -13;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12.0\" valueB=\"-13.0\"/>", dataTest);
|
||||
|
||||
final TestFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeFloatFunc() {
|
||||
final TestNodefloatFunc elem = new TestNodefloatFunc();
|
||||
elem.setValueA(54);
|
||||
elem.setValueB(-68);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>54.0</valueA>
|
||||
<valueB>-68.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodefloatFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodefloatFunc.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeFloatNative() {
|
||||
final TestNodeFloatNative elem = new TestNodeFloatNative();
|
||||
elem.valueA = 11;
|
||||
elem.valueB = -120;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionFloat.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>11.0</valueA>
|
||||
<valueB>-120.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeFloatNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeFloatNative.class, ExmlTestIntrospectionFloat.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
}
|
||||
}
|
||||
|
||||
@ -7,140 +7,20 @@ package test.atriasoft.exml;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionInteger {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestInteger {
|
||||
public Integer valueA;
|
||||
public Integer valueB;
|
||||
public Integer valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelInteger() {
|
||||
TestInteger elem = new TestInteger();
|
||||
elem.valueA = (int)12;
|
||||
elem.valueB = (int)-13;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayInteger {
|
||||
public Integer[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayInteger() {
|
||||
TestArrayInteger elem = new TestArrayInteger();
|
||||
elem.values = new Integer[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListInteger {
|
||||
public List<Integer> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListInteger() {
|
||||
TestListInteger elem = new TestListInteger();
|
||||
elem.values = List.of(12, -13, 33, 78, -127);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestListInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestIntegerFunc {
|
||||
private Integer valueA;
|
||||
private Integer valueB;
|
||||
private Integer valueNull;
|
||||
public Integer getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Integer valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Integer getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Integer valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Integer getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Integer valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelIntegerFunc() {
|
||||
TestIntegerFunc elem = new TestIntegerFunc();
|
||||
elem.setValueA(-55);
|
||||
elem.setValueB(57);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayIntegerFunc {
|
||||
private Integer[] values;
|
||||
|
||||
@ -153,189 +33,10 @@ public class ExmlTestIntrospectionInteger {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayIntegerFunc() {
|
||||
TestArrayIntegerFunc elem = new TestArrayIntegerFunc();
|
||||
elem.setValues(new Integer[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListIntegerFunc {
|
||||
private List<Integer> values;
|
||||
|
||||
public List<Integer> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Integer> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListIntegerFunc() {
|
||||
TestListIntegerFunc elem = new TestListIntegerFunc();
|
||||
elem.setValues(List.of(12, -13, 33, 78, -127));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestListIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(12, root.getValues().get(0));
|
||||
Assertions.assertEquals(-13, root.getValues().get(1));
|
||||
Assertions.assertEquals(33, root.getValues().get(2));
|
||||
Assertions.assertEquals(78, root.getValues().get(3));
|
||||
Assertions.assertEquals(-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
public class TestNodeInteger {
|
||||
public Integer valueA;
|
||||
public Integer valueB;
|
||||
public Integer valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeInteger() {
|
||||
TestNodeInteger elem = new TestNodeInteger();
|
||||
elem.valueA = (int)11;
|
||||
elem.valueB = (int)-120;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>11</valueA>\n"
|
||||
+ " <valueB>-120</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
public class TestArrayNodeInteger {
|
||||
public Integer[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeInteger() {
|
||||
TestArrayNodeInteger elem = new TestArrayNodeInteger();
|
||||
elem.values = new Integer[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestListNodeInteger {
|
||||
public List<Integer> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeInteger() {
|
||||
TestListNodeInteger elem = new TestListNodeInteger();
|
||||
elem.values = List.of(12, -13, 33, 78, -127);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
public class TestNodeIntegerFunc {
|
||||
private Integer valueA;
|
||||
private Integer valueB;
|
||||
private Integer valueNull;
|
||||
public Integer getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Integer valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Integer getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Integer valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Integer getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Integer valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeIntegerFunc() {
|
||||
TestNodeIntegerFunc elem = new TestNodeIntegerFunc();
|
||||
elem.setValueA(54);
|
||||
elem.setValueB(-68);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>54</valueA>\n"
|
||||
+ " <valueB>-68</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
public class TestArrayNodeIntegerFunc {
|
||||
private Integer[] values;
|
||||
@ -349,30 +50,70 @@ public class ExmlTestIntrospectionInteger {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeIntegerFunc() {
|
||||
TestArrayNodeIntegerFunc elem = new TestArrayNodeIntegerFunc();
|
||||
elem.setValues(new Integer[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
public class TestArrayNodeIntegerStructured {
|
||||
@AknotList(value = "elem")
|
||||
public Integer[] values;
|
||||
}
|
||||
|
||||
final TestArrayNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
@AknotDefaultAttribute
|
||||
public class TestInteger {
|
||||
public Integer valueA;
|
||||
public Integer valueB;
|
||||
public Integer valueNull;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestIntegerFunc {
|
||||
private Integer valueA;
|
||||
private Integer valueB;
|
||||
private Integer valueNull;
|
||||
|
||||
public Integer getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Integer getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Integer getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Integer valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Integer valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Integer valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListInteger {
|
||||
public List<Integer> values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestListIntegerFunc {
|
||||
private List<Integer> values;
|
||||
|
||||
public List<Integer> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Integer> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestListNodeInteger {
|
||||
public List<Integer> values;
|
||||
}
|
||||
|
||||
// Note this is set in static to test an other part of code...
|
||||
@ -387,22 +128,329 @@ public class ExmlTestIntrospectionInteger {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestListNodeIntegerStructured {
|
||||
@AknotList(value = "elem")
|
||||
public List<Integer> values;
|
||||
}
|
||||
|
||||
public class TestNodeInteger {
|
||||
public Integer valueA;
|
||||
public Integer valueB;
|
||||
public Integer valueNull;
|
||||
}
|
||||
|
||||
public class TestNodeIntegerFunc {
|
||||
private Integer valueA;
|
||||
private Integer valueB;
|
||||
private Integer valueNull;
|
||||
|
||||
public Integer getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Integer getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Integer getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Integer valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Integer valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Integer valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeIntegerFunc() {
|
||||
TestListNodeIntegerFunc elem = new TestListNodeIntegerFunc();
|
||||
public void testArrayNodeIntegerStructured() {
|
||||
final TestArrayNodeIntegerStructured elem = new TestArrayNodeIntegerStructured();
|
||||
elem.values = new Integer[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12</elem>
|
||||
<elem>-13</elem>
|
||||
<elem>33</elem>
|
||||
<elem>78</elem>
|
||||
<elem>-127</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeIntegerStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerStructured.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testListNodeIntegerStructured() {
|
||||
final TestListNodeIntegerStructured elem = new TestListNodeIntegerStructured();
|
||||
elem.values = List.of(12, -13, 33, 78, -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12</elem>
|
||||
<elem>-13</elem>
|
||||
<elem>33</elem>
|
||||
<elem>78</elem>
|
||||
<elem>-127</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeIntegerStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeIntegerStructured.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayInteger() {
|
||||
final TestArrayInteger elem = new TestArrayInteger();
|
||||
elem.values = new Integer[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayIntegerFunc() {
|
||||
final TestArrayIntegerFunc elem = new TestArrayIntegerFunc();
|
||||
elem.setValues(new Integer[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeInteger() {
|
||||
final TestArrayNodeInteger elem = new TestArrayNodeInteger();
|
||||
elem.values = new Integer[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeIntegerFunc() {
|
||||
final TestArrayNodeIntegerFunc elem = new TestArrayNodeIntegerFunc();
|
||||
elem.setValues(new Integer[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelInteger() {
|
||||
final TestInteger elem = new TestInteger();
|
||||
elem.valueA = (int) 12;
|
||||
elem.valueB = (int) -13;
|
||||
elem.valueNull = null;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelIntegerFunc() {
|
||||
final TestIntegerFunc elem = new TestIntegerFunc();
|
||||
elem.setValueA(-55);
|
||||
elem.setValueB(57);
|
||||
elem.setValueNull(null);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListInteger() {
|
||||
final TestListInteger elem = new TestListInteger();
|
||||
elem.values = List.of(12, -13, 33, 78, -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestListInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListIntegerFunc() {
|
||||
final TestListIntegerFunc elem = new TestListIntegerFunc();
|
||||
elem.setValues(List.of(12, -13, 33, 78, -127));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestListIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals(12, root.getValues().get(0));
|
||||
Assertions.assertEquals(-13, root.getValues().get(1));
|
||||
Assertions.assertEquals(33, root.getValues().get(2));
|
||||
Assertions.assertEquals(78, root.getValues().get(3));
|
||||
Assertions.assertEquals(-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeInteger() {
|
||||
final TestListNodeInteger elem = new TestListNodeInteger();
|
||||
elem.values = List.of(12, -13, 33, 78, -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeIntegerFunc() {
|
||||
final TestListNodeIntegerFunc elem = new TestListNodeIntegerFunc();
|
||||
elem.setValues(List.of(12, -13, 33, 78, -127));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
@ -413,71 +461,49 @@ public class ExmlTestIntrospectionInteger {
|
||||
Assertions.assertEquals(-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
public class TestListNodeIntegerStructured {
|
||||
@XmlList(value="elem")
|
||||
public List<Integer> values;
|
||||
}
|
||||
@Test
|
||||
public void testListNodeIntegerStructured() {
|
||||
TestListNodeIntegerStructured elem = new TestListNodeIntegerStructured();
|
||||
elem.values = List.of(12, -13, 33, 78, -127);
|
||||
public void testModelNodeInteger() {
|
||||
final TestNodeInteger elem = new TestNodeInteger();
|
||||
elem.valueA = (int) 11;
|
||||
elem.valueB = (int) -120;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12</elem>\n"
|
||||
+ " <elem>-13</elem>\n"
|
||||
+ " <elem>33</elem>\n"
|
||||
+ " <elem>78</elem>\n"
|
||||
+ " <elem>-127</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>11</valueA>
|
||||
<valueB>-120</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeIntegerStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeIntegerStructured.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals(12, root.values.get(0));
|
||||
Assertions.assertEquals(-13, root.values.get(1));
|
||||
Assertions.assertEquals(33, root.values.get(2));
|
||||
Assertions.assertEquals(78, root.values.get(3));
|
||||
Assertions.assertEquals(-127, root.values.get(4));
|
||||
}
|
||||
public class TestArrayNodeIntegerStructured {
|
||||
@XmlList(value="elem")
|
||||
public Integer[] values;
|
||||
final TestNodeInteger root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeInteger.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeIntegerStructured() {
|
||||
TestArrayNodeIntegerStructured elem = new TestArrayNodeIntegerStructured();
|
||||
elem.values = new Integer[] {12, -13, 33, 78, -127};
|
||||
public void testModelNodeIntegerFunc() {
|
||||
final TestNodeIntegerFunc elem = new TestNodeIntegerFunc();
|
||||
elem.setValueA(54);
|
||||
elem.setValueB(-68);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12</elem>\n"
|
||||
+ " <elem>-13</elem>\n"
|
||||
+ " <elem>33</elem>\n"
|
||||
+ " <elem>78</elem>\n"
|
||||
+ " <elem>-127</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>54</valueA>
|
||||
<valueB>-68</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeIntegerStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerStructured.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
final TestNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -5,103 +5,15 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionIntegerNative {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestIntegerNative {
|
||||
public int valueA;
|
||||
public int valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelIntegerNative() {
|
||||
TestIntegerNative elem = new TestIntegerNative();
|
||||
elem.valueA = 12;
|
||||
elem.valueB = -13;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestArrayIntegerNative {
|
||||
public int[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayIntegerNative() {
|
||||
TestArrayIntegerNative elem = new TestArrayIntegerNative();
|
||||
elem.values = new int[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestintFunc {
|
||||
private int valueA;
|
||||
private int valueB;
|
||||
public int getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final int valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public int getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final int valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelIntegerFunc() {
|
||||
TestintFunc elem = new TestintFunc();
|
||||
elem.setValueA(-55);
|
||||
elem.setValueB(57);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestintFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestintFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayIntegerFunc {
|
||||
private int[] values;
|
||||
|
||||
@ -114,115 +26,11 @@ public class ExmlTestIntrospectionIntegerNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayIntegerFunc() {
|
||||
TestArrayIntegerFunc elem = new TestArrayIntegerFunc();
|
||||
elem.setValues(new int[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestNodeIntegerNative {
|
||||
public int valueA;
|
||||
public int valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeIntegerNative() {
|
||||
TestNodeIntegerNative elem = new TestNodeIntegerNative();
|
||||
elem.valueA = 11;
|
||||
elem.valueB = -120;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>11</valueA>\n"
|
||||
+ " <valueB>-120</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
}
|
||||
|
||||
public class TestArrayNodeIntegerNative {
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayIntegerNative {
|
||||
public int[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeintNative() {
|
||||
TestArrayNodeIntegerNative elem = new TestArrayNodeIntegerNative();
|
||||
elem.values = new int[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestNodeintFunc {
|
||||
private int valueA;
|
||||
private int valueB;
|
||||
public int getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final int valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public int getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final int valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeIntegerFunc() {
|
||||
TestNodeintFunc elem = new TestNodeintFunc();
|
||||
elem.setValueA(54);
|
||||
elem.setValueB(-68);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>54</valueA>\n"
|
||||
+ " <valueB>-68</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeintFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeintFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
}
|
||||
|
||||
public class TestArrayNodeIntegerFunc {
|
||||
private int[] values;
|
||||
@ -236,22 +44,164 @@ public class ExmlTestIntrospectionIntegerNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeIntegerFunc() {
|
||||
TestArrayNodeIntegerFunc elem = new TestArrayNodeIntegerFunc();
|
||||
elem.setValues(new int[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public class TestArrayNodeIntegerNative {
|
||||
public int[] values;
|
||||
}
|
||||
|
||||
public class TestArrayNodeIntegerNativeStructured {
|
||||
@AknotList(value = "elem")
|
||||
public byte[] values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestIntegerNative {
|
||||
public int valueA;
|
||||
public int valueB;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestintFunc {
|
||||
private int valueA;
|
||||
private int valueB;
|
||||
|
||||
public int getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public int getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final int valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final int valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestNodeIntegerNative {
|
||||
public int valueA;
|
||||
public int valueB;
|
||||
}
|
||||
|
||||
public class TestNodeintFunc {
|
||||
private int valueA;
|
||||
private int valueB;
|
||||
|
||||
public int getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public int getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final int valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final int valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeIntegerNativeStructured() {
|
||||
final TestArrayNodeIntegerNativeStructured elem = new TestArrayNodeIntegerNativeStructured();
|
||||
elem.values = new byte[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12</elem>
|
||||
<elem>-13</elem>
|
||||
<elem>33</elem>
|
||||
<elem>78</elem>
|
||||
<elem>-127</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeIntegerNativeStructured root = Assertions
|
||||
.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerNativeStructured.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((byte) 12, root.values[0]);
|
||||
Assertions.assertEquals((byte) -13, root.values[1]);
|
||||
Assertions.assertEquals((byte) 33, root.values[2]);
|
||||
Assertions.assertEquals((byte) 78, root.values[3]);
|
||||
Assertions.assertEquals((byte) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayIntegerFunc() {
|
||||
final TestArrayIntegerFunc elem = new TestArrayIntegerFunc();
|
||||
elem.setValues(new int[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals(12, root.getValues()[0]);
|
||||
Assertions.assertEquals(-13, root.getValues()[1]);
|
||||
Assertions.assertEquals(33, root.getValues()[2]);
|
||||
Assertions.assertEquals(78, root.getValues()[3]);
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayIntegerNative() {
|
||||
final TestArrayIntegerNative elem = new TestArrayIntegerNative();
|
||||
elem.values = new int[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeIntegerFunc() {
|
||||
final TestArrayNodeIntegerFunc elem = new TestArrayNodeIntegerFunc();
|
||||
elem.setValues(new int[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeIntegerFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
@ -262,36 +212,106 @@ public class ExmlTestIntrospectionIntegerNative {
|
||||
Assertions.assertEquals(-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestArrayNodeIntegerNativeStructured {
|
||||
@XmlList(value="elem")
|
||||
public byte[] values;
|
||||
}
|
||||
@Test
|
||||
public void testArrayNodeIntegerNativeStructured() {
|
||||
TestArrayNodeIntegerNativeStructured elem = new TestArrayNodeIntegerNativeStructured();
|
||||
elem.values = new byte[] {12, -13, 33, 78, -127};
|
||||
public void testModelArrayNodeintNative() {
|
||||
final TestArrayNodeIntegerNative elem = new TestArrayNodeIntegerNative();
|
||||
elem.values = new int[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12</elem>\n"
|
||||
+ " <elem>-13</elem>\n"
|
||||
+ " <elem>33</elem>\n"
|
||||
+ " <elem>78</elem>\n"
|
||||
+ " <elem>-127</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeIntegerNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerNativeStructured.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
final TestArrayNodeIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((byte)12, root.values[0]);
|
||||
Assertions.assertEquals((byte)-13, root.values[1]);
|
||||
Assertions.assertEquals((byte)33, root.values[2]);
|
||||
Assertions.assertEquals((byte)78, root.values[3]);
|
||||
Assertions.assertEquals((byte)-127, root.values[4]);
|
||||
Assertions.assertEquals(12, root.values[0]);
|
||||
Assertions.assertEquals(-13, root.values[1]);
|
||||
Assertions.assertEquals(33, root.values[2]);
|
||||
Assertions.assertEquals(78, root.values[3]);
|
||||
Assertions.assertEquals(-127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelIntegerFunc() {
|
||||
final TestintFunc elem = new TestintFunc();
|
||||
elem.setValueA(-55);
|
||||
elem.setValueB(57);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestintFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestintFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(-55, root.getValueA());
|
||||
Assertions.assertEquals(57, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelIntegerNative() {
|
||||
final TestIntegerNative elem = new TestIntegerNative();
|
||||
elem.valueA = 12;
|
||||
elem.valueB = -13;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(12, root.valueA);
|
||||
Assertions.assertEquals(-13, root.valueB);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeIntegerFunc() {
|
||||
final TestNodeintFunc elem = new TestNodeintFunc();
|
||||
elem.setValueA(54);
|
||||
elem.setValueB(-68);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>54</valueA>
|
||||
<valueB>-68</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeintFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeintFunc.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(54, root.getValueA());
|
||||
Assertions.assertEquals(-68, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeIntegerNative() {
|
||||
final TestNodeIntegerNative elem = new TestNodeIntegerNative();
|
||||
elem.valueA = 11;
|
||||
elem.valueB = -120;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionInteger.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>11</valueA>
|
||||
<valueB>-120</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeIntegerNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeIntegerNative.class, ExmlTestIntrospectionInteger.NODE_NAME));
|
||||
Assertions.assertEquals(11, root.valueA);
|
||||
Assertions.assertEquals(-120, root.valueB);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -7,188 +7,23 @@ package test.atriasoft.exml;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlAttribute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionObject {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
public class SimpleObject {
|
||||
@XmlAttribute
|
||||
@AknotAttribute
|
||||
public int value1;
|
||||
public float value2;
|
||||
}
|
||||
|
||||
public class TestNodeObject {
|
||||
public SimpleObject valueA;
|
||||
public SimpleObject valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeObject() {
|
||||
TestNodeObject elem = new TestNodeObject();
|
||||
elem.valueA = new SimpleObject();
|
||||
elem.valueA.value1 = 55;
|
||||
elem.valueA.value2 = 12568.0f;
|
||||
elem.valueB = new SimpleObject();
|
||||
elem.valueB.value1 = -55;
|
||||
elem.valueB.value2 = -12568.0f;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA value1=\"55\">\n"
|
||||
+ " <value2>12568.0</value2>\n"
|
||||
+ " </valueA>\n"
|
||||
+ " <valueB value1=\"-55\">\n"
|
||||
+ " <value2>-12568.0</value2>\n"
|
||||
+ " </valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA.value1);
|
||||
Assertions.assertEquals(12568.0f, root.valueA.value2);
|
||||
Assertions.assertEquals(-55, root.valueB.value1);
|
||||
Assertions.assertEquals(-12568.0f, root.valueB.value2);
|
||||
}
|
||||
|
||||
public class TestArrayNodeObject {
|
||||
public SimpleObject[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeObject() {
|
||||
TestArrayNodeObject elem = new TestArrayNodeObject();
|
||||
elem.values = new SimpleObject[] {new SimpleObject(), new SimpleObject(), new SimpleObject()};
|
||||
elem.values[0].value1 = 55;
|
||||
elem.values[0].value2 = 12568.0f;
|
||||
elem.values[1].value1 = 77;
|
||||
elem.values[1].value2 = 15.0f;
|
||||
elem.values[2].value1 = 152654;
|
||||
elem.values[2].value2 = -75.0f;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values value1=\"55\">\n"
|
||||
+ " <value2>12568.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ " <values value1=\"77\">\n"
|
||||
+ " <value2>15.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ " <values value1=\"152654\">\n"
|
||||
+ " <value2>-75.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.values.length);
|
||||
Assertions.assertEquals(55, root.values[0].value1);
|
||||
Assertions.assertEquals(12568.0f, root.values[0].value2);
|
||||
Assertions.assertEquals(77, root.values[1].value1);
|
||||
Assertions.assertEquals(15.0f, root.values[1].value2);
|
||||
Assertions.assertEquals(152654, root.values[2].value1);
|
||||
Assertions.assertEquals(-75.0f, root.values[2].value2);
|
||||
}
|
||||
|
||||
public class TestListNodeObject {
|
||||
public List<SimpleObject> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeObject() {
|
||||
TestListNodeObject elem = new TestListNodeObject();
|
||||
elem.values = List.of(new SimpleObject(), new SimpleObject(), new SimpleObject());
|
||||
elem.values.get(0).value1 = 55;
|
||||
elem.values.get(0).value2 = 12568.0f;
|
||||
elem.values.get(1).value1 = 77;
|
||||
elem.values.get(1).value2 = 15.0f;
|
||||
elem.values.get(2).value1 = 152654;
|
||||
elem.values.get(2).value2 = -75.0f;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values value1=\"55\">\n"
|
||||
+ " <value2>12568.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ " <values value1=\"77\">\n"
|
||||
+ " <value2>15.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ " <values value1=\"152654\">\n"
|
||||
+ " <value2>-75.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.values.size());
|
||||
Assertions.assertEquals(55, root.values.get(0).value1);
|
||||
Assertions.assertEquals(12568.0f, root.values.get(0).value2);
|
||||
Assertions.assertEquals(77, root.values.get(1).value1);
|
||||
Assertions.assertEquals(15.0f, root.values.get(1).value2);
|
||||
Assertions.assertEquals(152654, root.values.get(2).value1);
|
||||
Assertions.assertEquals(-75.0f, root.values.get(2).value2);
|
||||
}
|
||||
|
||||
|
||||
public class TestNodeObjectFunc {
|
||||
private SimpleObject valueA;
|
||||
private SimpleObject valueB;
|
||||
public SimpleObject getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final SimpleObject valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public SimpleObject getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final SimpleObject valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeObjectFunc() {
|
||||
TestNodeObjectFunc elem = new TestNodeObjectFunc();
|
||||
elem.setValueA(new SimpleObject());
|
||||
elem.getValueA().value1 = 4564;
|
||||
elem.getValueA().value2 = 152.0f;
|
||||
elem.setValueB(new SimpleObject());
|
||||
elem.getValueB().value1 = 454564;
|
||||
elem.getValueB().value2 = 85422.0f;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA value1=\"4564\">\n"
|
||||
+ " <value2>152.0</value2>\n"
|
||||
+ " </valueA>\n"
|
||||
+ " <valueB value1=\"454564\">\n"
|
||||
+ " <value2>85422.0</value2>\n"
|
||||
+ " </valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(4564, root.getValueA().value1);
|
||||
Assertions.assertEquals(152.0f, root.getValueA().value2);
|
||||
Assertions.assertEquals(454564, root.getValueB().value1);
|
||||
Assertions.assertEquals(85422.0f, root.getValueB().value2);
|
||||
}
|
||||
|
||||
public class TestArrayNodeObjectFunc {
|
||||
private SimpleObject[] values;
|
||||
@ -202,41 +37,23 @@ public class ExmlTestIntrospectionObject {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeObjectFunc() {
|
||||
TestArrayNodeObjectFunc elem = new TestArrayNodeObjectFunc();
|
||||
elem.setValues(new SimpleObject[] {new SimpleObject(), new SimpleObject(), new SimpleObject()});
|
||||
elem.getValues()[0].value1 = 55;
|
||||
elem.getValues()[0].value2 = 12568.0f;
|
||||
elem.getValues()[1].value1 = 77;
|
||||
elem.getValues()[1].value2 = 15.0f;
|
||||
elem.getValues()[2].value1 = 152654;
|
||||
elem.getValues()[2].value2 = -75.0f;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values value1=\"55\">\n"
|
||||
+ " <value2>12568.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ " <values value1=\"77\">\n"
|
||||
+ " <value2>15.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ " <values value1=\"152654\">\n"
|
||||
+ " <value2>-75.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
public class TestArrayNodeStructuredObjectFunc {
|
||||
private SimpleObject[] values;
|
||||
|
||||
final TestArrayNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.getValues().length);
|
||||
Assertions.assertEquals(55, root.getValues()[0].value1);
|
||||
Assertions.assertEquals(12568.0f, root.getValues()[0].value2);
|
||||
Assertions.assertEquals(77, root.getValues()[1].value1);
|
||||
Assertions.assertEquals(15.0f, root.getValues()[1].value2);
|
||||
Assertions.assertEquals(152654, root.getValues()[2].value1);
|
||||
Assertions.assertEquals(-75.0f, root.getValues()[2].value2);
|
||||
@AknotList(value = "elem")
|
||||
public SimpleObject[] getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final SimpleObject[] values) {
|
||||
this.values = values;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public class TestListNodeObject {
|
||||
public List<SimpleObject> values;
|
||||
}
|
||||
|
||||
// Note this is set in static to test an other part of code...
|
||||
@ -251,64 +68,96 @@ public class ExmlTestIntrospectionObject {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeObjectFunc() {
|
||||
TestListNodeObjectFunc elem = new TestListNodeObjectFunc();
|
||||
elem.values = List.of(new SimpleObject(), new SimpleObject(), new SimpleObject());
|
||||
elem.getValues().get(0).value1 = 55;
|
||||
elem.getValues().get(0).value2 = 12568.0f;
|
||||
elem.getValues().get(1).value1 = 77;
|
||||
elem.getValues().get(1).value2 = 15.0f;
|
||||
elem.getValues().get(2).value1 = 152654;
|
||||
elem.getValues().get(2).value2 = -75.0f;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values value1=\"55\">\n"
|
||||
+ " <value2>12568.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ " <values value1=\"77\">\n"
|
||||
+ " <value2>15.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ " <values value1=\"152654\">\n"
|
||||
+ " <value2>-75.0</value2>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
// Note this is set in static to test an other part of code...
|
||||
public static class TestListNodeStructuredObjectFunc {
|
||||
private List<SimpleObject> values;
|
||||
|
||||
final TestListNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.getValues().size());
|
||||
Assertions.assertEquals(55, root.getValues().get(0).value1);
|
||||
Assertions.assertEquals(12568.0f, root.getValues().get(0).value2);
|
||||
Assertions.assertEquals(77, root.getValues().get(1).value1);
|
||||
Assertions.assertEquals(15.0f, root.getValues().get(1).value2);
|
||||
Assertions.assertEquals(152654, root.getValues().get(2).value1);
|
||||
Assertions.assertEquals(-75.0f, root.getValues().get(2).value2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
public class TestArrayNodeStructuredObjectFunc {
|
||||
private SimpleObject[] values;
|
||||
|
||||
@XmlList(value="elem")
|
||||
public SimpleObject[] getValues() {
|
||||
@AknotList(value = "elem")
|
||||
public List<SimpleObject> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final SimpleObject[] values) {
|
||||
public void setValues(final List<SimpleObject> values) {
|
||||
this.values = values;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public class TestNodeObject {
|
||||
public SimpleObject valueA;
|
||||
public SimpleObject valueB;
|
||||
}
|
||||
|
||||
public class TestNodeObjectFunc {
|
||||
private SimpleObject valueA;
|
||||
private SimpleObject valueB;
|
||||
|
||||
public SimpleObject getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public SimpleObject getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final SimpleObject valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final SimpleObject valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeStructuredObjectFunc() {
|
||||
TestArrayNodeStructuredObjectFunc elem = new TestArrayNodeStructuredObjectFunc();
|
||||
elem.setValues(new SimpleObject[] {new SimpleObject(), new SimpleObject(), new SimpleObject()});
|
||||
public void testModelArrayNodeObject() {
|
||||
final TestArrayNodeObject elem = new TestArrayNodeObject();
|
||||
elem.values = new SimpleObject[] { new SimpleObject(), new SimpleObject(), new SimpleObject() };
|
||||
elem.values[0].value1 = 55;
|
||||
elem.values[0].value2 = 12568.0f;
|
||||
elem.values[1].value1 = 77;
|
||||
elem.values[1].value2 = 15.0f;
|
||||
elem.values[2].value1 = 152654;
|
||||
elem.values[2].value2 = -75.0f;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values value1="55">
|
||||
<value2>12568.0</value2>
|
||||
</values>
|
||||
<values value1="77">
|
||||
<value2>15.0</value2>
|
||||
</values>
|
||||
<values value1="152654">
|
||||
<value2>-75.0</value2>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.values.length);
|
||||
Assertions.assertEquals(55, root.values[0].value1);
|
||||
Assertions.assertEquals(12568.0f, root.values[0].value2);
|
||||
Assertions.assertEquals(77, root.values[1].value1);
|
||||
Assertions.assertEquals(15.0f, root.values[1].value2);
|
||||
Assertions.assertEquals(152654, root.values[2].value1);
|
||||
Assertions.assertEquals(-75.0f, root.values[2].value2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeObjectFunc() {
|
||||
final TestArrayNodeObjectFunc elem = new TestArrayNodeObjectFunc();
|
||||
elem.setValues(new SimpleObject[] { new SimpleObject(), new SimpleObject(), new SimpleObject() });
|
||||
elem.getValues()[0].value1 = 55;
|
||||
elem.getValues()[0].value2 = 12568.0f;
|
||||
elem.getValues()[1].value1 = 77;
|
||||
@ -316,23 +165,62 @@ public class ExmlTestIntrospectionObject {
|
||||
elem.getValues()[2].value1 = 152654;
|
||||
elem.getValues()[2].value2 = -75.0f;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem value1=\"55\">\n"
|
||||
+ " <value2>12568.0</value2>\n"
|
||||
+ " </elem>\n"
|
||||
+ " <elem value1=\"77\">\n"
|
||||
+ " <value2>15.0</value2>\n"
|
||||
+ " </elem>\n"
|
||||
+ " <elem value1=\"152654\">\n"
|
||||
+ " <value2>-75.0</value2>\n"
|
||||
+ " </elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values value1="55">
|
||||
<value2>12568.0</value2>
|
||||
</values>
|
||||
<values value1="77">
|
||||
<value2>15.0</value2>
|
||||
</values>
|
||||
<values value1="152654">
|
||||
<value2>-75.0</value2>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.getValues().length);
|
||||
Assertions.assertEquals(55, root.getValues()[0].value1);
|
||||
Assertions.assertEquals(12568.0f, root.getValues()[0].value2);
|
||||
Assertions.assertEquals(77, root.getValues()[1].value1);
|
||||
Assertions.assertEquals(15.0f, root.getValues()[1].value2);
|
||||
Assertions.assertEquals(152654, root.getValues()[2].value1);
|
||||
Assertions.assertEquals(-75.0f, root.getValues()[2].value2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeStructuredObjectFunc() {
|
||||
final TestArrayNodeStructuredObjectFunc elem = new TestArrayNodeStructuredObjectFunc();
|
||||
elem.setValues(new SimpleObject[] { new SimpleObject(), new SimpleObject(), new SimpleObject() });
|
||||
elem.getValues()[0].value1 = 55;
|
||||
elem.getValues()[0].value2 = 12568.0f;
|
||||
elem.getValues()[1].value1 = 77;
|
||||
elem.getValues()[1].value2 = 15.0f;
|
||||
elem.getValues()[2].value1 = 152654;
|
||||
elem.getValues()[2].value2 = -75.0f;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem value1="55">
|
||||
<value2>12568.0</value2>
|
||||
</elem>
|
||||
<elem value1="77">
|
||||
<value2>15.0</value2>
|
||||
</elem>
|
||||
<elem value1="152654">
|
||||
<value2>-75.0</value2>
|
||||
</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeStructuredObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeStructuredObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.getValues().length);
|
||||
@ -344,22 +232,47 @@ public class ExmlTestIntrospectionObject {
|
||||
Assertions.assertEquals(-75.0f, root.getValues()[2].value2);
|
||||
}
|
||||
|
||||
// Note this is set in static to test an other part of code...
|
||||
public static class TestListNodeStructuredObjectFunc {
|
||||
private List<SimpleObject> values;
|
||||
|
||||
@XmlList(value="elem")
|
||||
public List<SimpleObject> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<SimpleObject> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeStructuredObjectFunc() {
|
||||
TestListNodeStructuredObjectFunc elem = new TestListNodeStructuredObjectFunc();
|
||||
public void testModelListNodeObject() {
|
||||
final TestListNodeObject elem = new TestListNodeObject();
|
||||
elem.values = List.of(new SimpleObject(), new SimpleObject(), new SimpleObject());
|
||||
elem.values.get(0).value1 = 55;
|
||||
elem.values.get(0).value2 = 12568.0f;
|
||||
elem.values.get(1).value1 = 77;
|
||||
elem.values.get(1).value2 = 15.0f;
|
||||
elem.values.get(2).value1 = 152654;
|
||||
elem.values.get(2).value2 = -75.0f;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values value1="55">
|
||||
<value2>12568.0</value2>
|
||||
</values>
|
||||
<values value1="77">
|
||||
<value2>15.0</value2>
|
||||
</values>
|
||||
<values value1="152654">
|
||||
<value2>-75.0</value2>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.values.size());
|
||||
Assertions.assertEquals(55, root.values.get(0).value1);
|
||||
Assertions.assertEquals(12568.0f, root.values.get(0).value2);
|
||||
Assertions.assertEquals(77, root.values.get(1).value1);
|
||||
Assertions.assertEquals(15.0f, root.values.get(1).value2);
|
||||
Assertions.assertEquals(152654, root.values.get(2).value1);
|
||||
Assertions.assertEquals(-75.0f, root.values.get(2).value2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeObjectFunc() {
|
||||
final TestListNodeObjectFunc elem = new TestListNodeObjectFunc();
|
||||
elem.values = List.of(new SimpleObject(), new SimpleObject(), new SimpleObject());
|
||||
elem.getValues().get(0).value1 = 55;
|
||||
elem.getValues().get(0).value2 = 12568.0f;
|
||||
@ -368,23 +281,62 @@ public class ExmlTestIntrospectionObject {
|
||||
elem.getValues().get(2).value1 = 152654;
|
||||
elem.getValues().get(2).value2 = -75.0f;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem value1=\"55\">\n"
|
||||
+ " <value2>12568.0</value2>\n"
|
||||
+ " </elem>\n"
|
||||
+ " <elem value1=\"77\">\n"
|
||||
+ " <value2>15.0</value2>\n"
|
||||
+ " </elem>\n"
|
||||
+ " <elem value1=\"152654\">\n"
|
||||
+ " <value2>-75.0</value2>\n"
|
||||
+ " </elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values value1="55">
|
||||
<value2>12568.0</value2>
|
||||
</values>
|
||||
<values value1="77">
|
||||
<value2>15.0</value2>
|
||||
</values>
|
||||
<values value1="152654">
|
||||
<value2>-75.0</value2>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.getValues().size());
|
||||
Assertions.assertEquals(55, root.getValues().get(0).value1);
|
||||
Assertions.assertEquals(12568.0f, root.getValues().get(0).value2);
|
||||
Assertions.assertEquals(77, root.getValues().get(1).value1);
|
||||
Assertions.assertEquals(15.0f, root.getValues().get(1).value2);
|
||||
Assertions.assertEquals(152654, root.getValues().get(2).value1);
|
||||
Assertions.assertEquals(-75.0f, root.getValues().get(2).value2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeStructuredObjectFunc() {
|
||||
final TestListNodeStructuredObjectFunc elem = new TestListNodeStructuredObjectFunc();
|
||||
elem.values = List.of(new SimpleObject(), new SimpleObject(), new SimpleObject());
|
||||
elem.getValues().get(0).value1 = 55;
|
||||
elem.getValues().get(0).value2 = 12568.0f;
|
||||
elem.getValues().get(1).value1 = 77;
|
||||
elem.getValues().get(1).value2 = 15.0f;
|
||||
elem.getValues().get(2).value1 = 152654;
|
||||
elem.getValues().get(2).value2 = -75.0f;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem value1="55">
|
||||
<value2>12568.0</value2>
|
||||
</elem>
|
||||
<elem value1="77">
|
||||
<value2>15.0</value2>
|
||||
</elem>
|
||||
<elem value1="152654">
|
||||
<value2>-75.0</value2>
|
||||
</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeStructuredObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeStructuredObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(3, root.getValues().size());
|
||||
@ -396,5 +348,66 @@ public class ExmlTestIntrospectionObject {
|
||||
Assertions.assertEquals(-75.0f, root.getValues().get(2).value2);
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeObject() {
|
||||
final TestNodeObject elem = new TestNodeObject();
|
||||
elem.valueA = new SimpleObject();
|
||||
elem.valueA.value1 = 55;
|
||||
elem.valueA.value2 = 12568.0f;
|
||||
elem.valueB = new SimpleObject();
|
||||
elem.valueB.value1 = -55;
|
||||
elem.valueB.value2 = -12568.0f;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA value1="55">
|
||||
<value2>12568.0</value2>
|
||||
</valueA>
|
||||
<valueB value1="-55">
|
||||
<value2>-12568.0</value2>
|
||||
</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeObject root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObject.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(55, root.valueA.value1);
|
||||
Assertions.assertEquals(12568.0f, root.valueA.value2);
|
||||
Assertions.assertEquals(-55, root.valueB.value1);
|
||||
Assertions.assertEquals(-12568.0f, root.valueB.value2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeObjectFunc() {
|
||||
final TestNodeObjectFunc elem = new TestNodeObjectFunc();
|
||||
elem.setValueA(new SimpleObject());
|
||||
elem.getValueA().value1 = 4564;
|
||||
elem.getValueA().value2 = 152.0f;
|
||||
elem.setValueB(new SimpleObject());
|
||||
elem.getValueB().value1 = 454564;
|
||||
elem.getValueB().value2 = 85422.0f;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA value1="4564">
|
||||
<value2>152.0</value2>
|
||||
</valueA>
|
||||
<valueB value1="454564">
|
||||
<value2>85422.0</value2>
|
||||
</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeObjectFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeObjectFunc.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(4564, root.getValueA().value1);
|
||||
Assertions.assertEquals(152.0f, root.getValueA().value2);
|
||||
Assertions.assertEquals(454564, root.getValueB().value1);
|
||||
Assertions.assertEquals(85422.0f, root.getValueB().value2);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -5,96 +5,105 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotName;
|
||||
import org.atriasoft.aknot.annotation.AknotAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlAttribute;
|
||||
import org.atriasoft.exml.annotation.XmlName;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionObjectConstructor {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
public class TestMultiConstructor {
|
||||
@XmlAttribute
|
||||
public class TestConstructorSpecific {
|
||||
@AknotAttribute
|
||||
public Integer valueA;
|
||||
public double valueB;
|
||||
|
||||
@AknotName({ "valueA", "valueB" })
|
||||
public TestConstructorSpecific(final Integer valueA, final double valueB) {
|
||||
this.valueA = valueA;
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestConstructorSpecificParameter {
|
||||
@AknotAttribute
|
||||
public Integer valueA;
|
||||
public double valueB;
|
||||
|
||||
public TestConstructorSpecificParameter(@AknotName("valueA") final Integer valueA, @AknotName("valueB") final double valueB) {
|
||||
this.valueA = valueA;
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestMultiConstructor {
|
||||
@AknotAttribute
|
||||
public Integer valueA;
|
||||
public double valueB;
|
||||
|
||||
public TestMultiConstructor() {}
|
||||
|
||||
public TestMultiConstructor(final Integer valueA, final double valueB) {
|
||||
this.valueA = valueA;
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public TestMultiConstructor() {
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelMultiConstructor() {
|
||||
TestMultiConstructor elem = new TestMultiConstructor(66, 18523.0);
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"66\">\n"
|
||||
+ " <valueB>18523.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestMultiConstructor root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestMultiConstructor.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelConstructorSpecific() {
|
||||
final TestConstructorSpecific elem = new TestConstructorSpecific(66, 18523.0);
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem valueA="66">
|
||||
<valueB>18523.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestConstructorSpecific root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestConstructorSpecific.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(66, root.valueA);
|
||||
Assertions.assertEquals(18523.0f, root.valueB);
|
||||
}
|
||||
|
||||
public class TestConstructorSpecificParameter {
|
||||
@XmlAttribute
|
||||
public Integer valueA;
|
||||
public double valueB;
|
||||
public TestConstructorSpecificParameter(@XmlName("valueA") final Integer valueA, @XmlName("valueB") final double valueB) {
|
||||
this.valueA = valueA;
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelConstructorSpecificParameter() {
|
||||
TestConstructorSpecificParameter elem = new TestConstructorSpecificParameter(66, 18523.0);
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public void testModelConstructorSpecificParameter() {
|
||||
final TestConstructorSpecificParameter elem = new TestConstructorSpecificParameter(66, 18523.0);
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"66\">\n"
|
||||
+ " <valueB>18523.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem valueA="66">
|
||||
<valueB>18523.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestConstructorSpecificParameter root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestConstructorSpecificParameter.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(66, root.valueA);
|
||||
Assertions.assertEquals(18523.0f, root.valueB);
|
||||
}
|
||||
|
||||
public class TestConstructorSpecific {
|
||||
@XmlAttribute
|
||||
public Integer valueA;
|
||||
public double valueB;
|
||||
@XmlName({"valueA", "valueB"})
|
||||
public TestConstructorSpecific(final Integer valueA, final double valueB) {
|
||||
this.valueA = valueA;
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelConstructorSpecific() {
|
||||
TestConstructorSpecific elem = new TestConstructorSpecific(66, 18523.0);
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public void testModelMultiConstructor() {
|
||||
final TestMultiConstructor elem = new TestMultiConstructor(66, 18523.0);
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"66\">\n"
|
||||
+ " <valueB>18523.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem valueA="66">
|
||||
<valueB>18523.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestConstructorSpecific root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestConstructorSpecific.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
final TestMultiConstructor root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestMultiConstructor.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(66, root.valueA);
|
||||
Assertions.assertEquals(18523.0f, root.valueB);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -5,55 +5,53 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotName;
|
||||
import org.atriasoft.aknot.annotation.AknotAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlAttribute;
|
||||
import org.atriasoft.exml.annotation.XmlName;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionRecord {
|
||||
public record TestRecord(
|
||||
@AknotName("valueA") Integer valueA,
|
||||
@AknotName("valueB") double valueB) {}
|
||||
|
||||
public record TestRecordProperty(
|
||||
@AknotName("valueA") @AknotAttribute Integer valueA,
|
||||
@AknotName("valueB") @AknotAttribute double valueB) {}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
public record TestRecord(
|
||||
@XmlName("valueA") Integer valueA,
|
||||
@XmlName("valueB") double valueB) {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelRecord() {
|
||||
TestRecord elem = new TestRecord(66, 18523.0);
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public void testModelRecord() {
|
||||
final TestRecord elem = new TestRecord(66, 18523.0);
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>66</valueA>\n"
|
||||
+ " <valueB>18523.0</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>66</valueA>
|
||||
<valueB>18523.0</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestRecord root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestRecord.class, ExmlTestIntrospectionObject.NODE_NAME));
|
||||
Assertions.assertEquals(66, root.valueA);
|
||||
Assertions.assertEquals(18523.0f, root.valueB);
|
||||
}
|
||||
|
||||
|
||||
public record TestRecordProperty (
|
||||
@XmlName("valueA") @XmlAttribute Integer valueA,
|
||||
@XmlName("valueB") @XmlAttribute double valueB) {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelRecordProperty() {
|
||||
TestRecordProperty elem = new TestRecordProperty(66, 18523.0);
|
||||
StringBuilder builder = new StringBuilder();
|
||||
public void testModelRecordProperty() {
|
||||
final TestRecordProperty elem = new TestRecordProperty(66, 18523.0);
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionObject.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"66\" valueB=\"18523.0\"/>", dataTest);
|
||||
|
||||
@ -62,6 +60,4 @@ public class ExmlTestIntrospectionRecord {
|
||||
Assertions.assertEquals(18523.0f, root.valueB);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -7,335 +7,17 @@ package test.atriasoft.exml;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionShort {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestShort {
|
||||
public Short valueA;
|
||||
public Short valueB;
|
||||
public Short valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelShort() {
|
||||
TestShort elem = new TestShort();
|
||||
elem.valueA = (short)12;
|
||||
elem.valueB = (short)-13;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short)12, root.valueA);
|
||||
Assertions.assertEquals((short)-13, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestArrayShort {
|
||||
public Short[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayShort() {
|
||||
TestArrayShort elem = new TestArrayShort();
|
||||
elem.values = new Short[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short)12, root.values[0]);
|
||||
Assertions.assertEquals((short)-13, root.values[1]);
|
||||
Assertions.assertEquals((short)33, root.values[2]);
|
||||
Assertions.assertEquals((short)78, root.values[3]);
|
||||
Assertions.assertEquals((short)-127, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListShort {
|
||||
public List<Short> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListShort() {
|
||||
TestListShort elem = new TestListShort();
|
||||
elem.values = List.of((short)12, (short)-13, (short)33, (short)78, (short)-127);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestListShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals((short)12, root.values.get(0));
|
||||
Assertions.assertEquals((short)-13, root.values.get(1));
|
||||
Assertions.assertEquals((short)33, root.values.get(2));
|
||||
Assertions.assertEquals((short)78, root.values.get(3));
|
||||
Assertions.assertEquals((short)-127, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestShortFunc {
|
||||
private Short valueA;
|
||||
private Short valueB;
|
||||
private Short valueNull;
|
||||
public Short getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Short valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Short getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Short valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Short getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Short valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelShortFunc() {
|
||||
TestShortFunc elem = new TestShortFunc();
|
||||
elem.setValueA((short)-55);
|
||||
elem.setValueB((short)57);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short)-55, root.getValueA());
|
||||
Assertions.assertEquals((short)57, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestArrayShortFunc {
|
||||
private Short[] values;
|
||||
|
||||
public Short[] getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final Short[] values) {
|
||||
this.values = values;
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayShortFunc() {
|
||||
TestArrayShortFunc elem = new TestArrayShortFunc();
|
||||
elem.setValues(new Short[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((short)12, root.getValues()[0]);
|
||||
Assertions.assertEquals((short)-13, root.getValues()[1]);
|
||||
Assertions.assertEquals((short)33, root.getValues()[2]);
|
||||
Assertions.assertEquals((short)78, root.getValues()[3]);
|
||||
Assertions.assertEquals((short)-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestListShortFunc {
|
||||
private List<Short> values;
|
||||
|
||||
public List<Short> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Short> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListShortFunc() {
|
||||
TestListShortFunc elem = new TestListShortFunc();
|
||||
elem.setValues(List.of((short)12, (short)-13, (short)33, (short)78, (short)-127));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestListShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals((short)12, root.getValues().get(0));
|
||||
Assertions.assertEquals((short)-13, root.getValues().get(1));
|
||||
Assertions.assertEquals((short)33, root.getValues().get(2));
|
||||
Assertions.assertEquals((short)78, root.getValues().get(3));
|
||||
Assertions.assertEquals((short)-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
public class TestNodeShort {
|
||||
public Short valueA;
|
||||
public Short valueB;
|
||||
public Short valueNull;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeShort() {
|
||||
TestNodeShort elem = new TestNodeShort();
|
||||
elem.valueA = (short)11;
|
||||
elem.valueB = (short)-120;
|
||||
elem.valueNull = null;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>11</valueA>\n"
|
||||
+ " <valueB>-120</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short)11, root.valueA);
|
||||
Assertions.assertEquals((short)-120, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
public class TestArrayNodeShort {
|
||||
public Short[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeShort() {
|
||||
TestArrayNodeShort elem = new TestArrayNodeShort();
|
||||
elem.values = new Short[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short)12, root.values[0]);
|
||||
Assertions.assertEquals((short)-13, root.values[1]);
|
||||
Assertions.assertEquals((short)33, root.values[2]);
|
||||
Assertions.assertEquals((short)78, root.values[3]);
|
||||
Assertions.assertEquals((short)-127, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestListNodeShort {
|
||||
public List<Short> values;
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeShort() {
|
||||
TestListNodeShort elem = new TestListNodeShort();
|
||||
elem.values = List.of((short)12, (short)-13, (short)33, (short)78, (short)-127);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals((short)12, root.values.get(0));
|
||||
Assertions.assertEquals((short)-13, root.values.get(1));
|
||||
Assertions.assertEquals((short)33, root.values.get(2));
|
||||
Assertions.assertEquals((short)78, root.values.get(3));
|
||||
Assertions.assertEquals((short)-127, root.values.get(4));
|
||||
}
|
||||
|
||||
|
||||
public class TestNodeShortFunc {
|
||||
private Short valueA;
|
||||
private Short valueB;
|
||||
private Short valueNull;
|
||||
public Short getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final Short valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public Short getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final Short valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
public Short getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
public void setValueNull(final Short valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeShortFunc() {
|
||||
TestNodeShortFunc elem = new TestNodeShortFunc();
|
||||
elem.setValueA((short)54);
|
||||
elem.setValueB((short)-68);
|
||||
elem.setValueNull(null);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>54</valueA>\n"
|
||||
+ " <valueB>-68</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short)54, root.getValueA());
|
||||
Assertions.assertEquals((short)-68, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
public class TestArrayNodeShortFunc {
|
||||
private Short[] values;
|
||||
@ -349,30 +31,33 @@ public class ExmlTestIntrospectionShort {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeShortFunc() {
|
||||
TestArrayNodeShortFunc elem = new TestArrayNodeShortFunc();
|
||||
elem.setValues(new Short[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
public class TestArrayNodeShortStructured {
|
||||
@AknotList(value = "elem")
|
||||
public Short[] values;
|
||||
}
|
||||
|
||||
final TestArrayNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((short)12, root.getValues()[0]);
|
||||
Assertions.assertEquals((short)-13, root.getValues()[1]);
|
||||
Assertions.assertEquals((short)33, root.getValues()[2]);
|
||||
Assertions.assertEquals((short)78, root.getValues()[3]);
|
||||
Assertions.assertEquals((short)-127, root.getValues()[4]);
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayShort {
|
||||
public Short[] values;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayShortFunc {
|
||||
private Short[] values;
|
||||
|
||||
public Short[] getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final Short[] values) {
|
||||
this.values = values;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public class TestListNodeShort {
|
||||
public List<Short> values;
|
||||
}
|
||||
|
||||
// Note this is set in static to test an other part of code...
|
||||
@ -387,98 +72,438 @@ public class ExmlTestIntrospectionShort {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
@Test
|
||||
public void testModelListNodeShortFunc() {
|
||||
TestListNodeShortFunc elem = new TestListNodeShortFunc();
|
||||
elem.setValues(List.of((short)12, (short)-13, (short)33, (short)78, (short)-127));
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals((short)12, root.getValues().get(0));
|
||||
Assertions.assertEquals((short)-13, root.getValues().get(1));
|
||||
Assertions.assertEquals((short)33, root.getValues().get(2));
|
||||
Assertions.assertEquals((short)78, root.getValues().get(3));
|
||||
Assertions.assertEquals((short)-127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
public class TestListNodeShortStructured {
|
||||
@XmlList(value="elem")
|
||||
@AknotList(value = "elem")
|
||||
public List<Short> values;
|
||||
}
|
||||
@Test
|
||||
public void testListNodeShortStructured() {
|
||||
TestListNodeShortStructured elem = new TestListNodeShortStructured();
|
||||
elem.values = List.of((short)12, (short)-13, (short)33, (short)78, (short)-127);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12</elem>\n"
|
||||
+ " <elem>-13</elem>\n"
|
||||
+ " <elem>33</elem>\n"
|
||||
+ " <elem>78</elem>\n"
|
||||
+ " <elem>-127</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestListNodeShortStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeShortStructured.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals((short)12, root.values.get(0));
|
||||
Assertions.assertEquals((short)-13, root.values.get(1));
|
||||
Assertions.assertEquals((short)33, root.values.get(2));
|
||||
Assertions.assertEquals((short)78, root.values.get(3));
|
||||
Assertions.assertEquals((short)-127, root.values.get(4));
|
||||
@AknotDefaultAttribute
|
||||
public class TestListShort {
|
||||
public List<Short> values;
|
||||
}
|
||||
public class TestArrayNodeShortStructured {
|
||||
@XmlList(value="elem")
|
||||
public Short[] values;
|
||||
}
|
||||
@Test
|
||||
public void testArrayNodeShortStructured() {
|
||||
TestArrayNodeShortStructured elem = new TestArrayNodeShortStructured();
|
||||
elem.values = new Short[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
@AknotDefaultAttribute
|
||||
public class TestListShortFunc {
|
||||
private List<Short> values;
|
||||
|
||||
public List<Short> getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final List<Short> values) {
|
||||
this.values = values;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestNodeShort {
|
||||
public Short valueA;
|
||||
public Short valueB;
|
||||
public Short valueNull;
|
||||
}
|
||||
|
||||
public class TestNodeShortFunc {
|
||||
private Short valueA;
|
||||
private Short valueB;
|
||||
private Short valueNull;
|
||||
|
||||
public Short getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Short getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Short getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Short valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Short valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Short valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestShort {
|
||||
public Short valueA;
|
||||
public Short valueB;
|
||||
public Short valueNull;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestShortFunc {
|
||||
private Short valueA;
|
||||
private Short valueB;
|
||||
private Short valueNull;
|
||||
|
||||
public Short getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public Short getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public Short getValueNull() {
|
||||
return this.valueNull;
|
||||
}
|
||||
|
||||
public void setValueA(final Short valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final Short valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
|
||||
public void setValueNull(final Short valueNull) {
|
||||
this.valueNull = valueNull;
|
||||
}
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeShortStructured() {
|
||||
final TestArrayNodeShortStructured elem = new TestArrayNodeShortStructured();
|
||||
elem.values = new Short[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12</elem>\n"
|
||||
+ " <elem>-13</elem>\n"
|
||||
+ " <elem>33</elem>\n"
|
||||
+ " <elem>78</elem>\n"
|
||||
+ " <elem>-127</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12</elem>
|
||||
<elem>-13</elem>
|
||||
<elem>33</elem>
|
||||
<elem>78</elem>
|
||||
<elem>-127</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeShortStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortStructured.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short)12, root.values[0]);
|
||||
Assertions.assertEquals((short)-13, root.values[1]);
|
||||
Assertions.assertEquals((short)33, root.values[2]);
|
||||
Assertions.assertEquals((short)78, root.values[3]);
|
||||
Assertions.assertEquals((short)-127, root.values[4]);
|
||||
Assertions.assertEquals((short) 12, root.values[0]);
|
||||
Assertions.assertEquals((short) -13, root.values[1]);
|
||||
Assertions.assertEquals((short) 33, root.values[2]);
|
||||
Assertions.assertEquals((short) 78, root.values[3]);
|
||||
Assertions.assertEquals((short) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testListNodeShortStructured() {
|
||||
final TestListNodeShortStructured elem = new TestListNodeShortStructured();
|
||||
elem.values = List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12</elem>
|
||||
<elem>-13</elem>
|
||||
<elem>33</elem>
|
||||
<elem>78</elem>
|
||||
<elem>-127</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeShortStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeShortStructured.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals((short) 12, root.values.get(0));
|
||||
Assertions.assertEquals((short) -13, root.values.get(1));
|
||||
Assertions.assertEquals((short) 33, root.values.get(2));
|
||||
Assertions.assertEquals((short) 78, root.values.get(3));
|
||||
Assertions.assertEquals((short) -127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeShort() {
|
||||
final TestArrayNodeShort elem = new TestArrayNodeShort();
|
||||
elem.values = new Short[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short) 12, root.values[0]);
|
||||
Assertions.assertEquals((short) -13, root.values[1]);
|
||||
Assertions.assertEquals((short) 33, root.values[2]);
|
||||
Assertions.assertEquals((short) 78, root.values[3]);
|
||||
Assertions.assertEquals((short) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeShortFunc() {
|
||||
final TestArrayNodeShortFunc elem = new TestArrayNodeShortFunc();
|
||||
elem.setValues(new Short[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((short) 12, root.getValues()[0]);
|
||||
Assertions.assertEquals((short) -13, root.getValues()[1]);
|
||||
Assertions.assertEquals((short) 33, root.getValues()[2]);
|
||||
Assertions.assertEquals((short) 78, root.getValues()[3]);
|
||||
Assertions.assertEquals((short) -127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayShort() {
|
||||
final TestArrayShort elem = new TestArrayShort();
|
||||
elem.values = new Short[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short) 12, root.values[0]);
|
||||
Assertions.assertEquals((short) -13, root.values[1]);
|
||||
Assertions.assertEquals((short) 33, root.values[2]);
|
||||
Assertions.assertEquals((short) 78, root.values[3]);
|
||||
Assertions.assertEquals((short) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayShortFunc() {
|
||||
final TestArrayShortFunc elem = new TestArrayShortFunc();
|
||||
elem.setValues(new Short[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((short) 12, root.getValues()[0]);
|
||||
Assertions.assertEquals((short) -13, root.getValues()[1]);
|
||||
Assertions.assertEquals((short) 33, root.getValues()[2]);
|
||||
Assertions.assertEquals((short) 78, root.getValues()[3]);
|
||||
Assertions.assertEquals((short) -127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeShort() {
|
||||
final TestListNodeShort elem = new TestListNodeShort();
|
||||
elem.values = List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals((short) 12, root.values.get(0));
|
||||
Assertions.assertEquals((short) -13, root.values.get(1));
|
||||
Assertions.assertEquals((short) 33, root.values.get(2));
|
||||
Assertions.assertEquals((short) 78, root.values.get(3));
|
||||
Assertions.assertEquals((short) -127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListNodeShortFunc() {
|
||||
final TestListNodeShortFunc elem = new TestListNodeShortFunc();
|
||||
elem.setValues(List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestListNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals((short) 12, root.getValues().get(0));
|
||||
Assertions.assertEquals((short) -13, root.getValues().get(1));
|
||||
Assertions.assertEquals((short) 33, root.getValues().get(2));
|
||||
Assertions.assertEquals((short) 78, root.getValues().get(3));
|
||||
Assertions.assertEquals((short) -127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListShort() {
|
||||
final TestListShort elem = new TestListShort();
|
||||
elem.values = List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestListShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.size());
|
||||
Assertions.assertEquals((short) 12, root.values.get(0));
|
||||
Assertions.assertEquals((short) -13, root.values.get(1));
|
||||
Assertions.assertEquals((short) 33, root.values.get(2));
|
||||
Assertions.assertEquals((short) 78, root.values.get(3));
|
||||
Assertions.assertEquals((short) -127, root.values.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelListShortFunc() {
|
||||
final TestListShortFunc elem = new TestListShortFunc();
|
||||
elem.setValues(List.of((short) 12, (short) -13, (short) 33, (short) 78, (short) -127));
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestListShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestListShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().size());
|
||||
Assertions.assertEquals((short) 12, root.getValues().get(0));
|
||||
Assertions.assertEquals((short) -13, root.getValues().get(1));
|
||||
Assertions.assertEquals((short) 33, root.getValues().get(2));
|
||||
Assertions.assertEquals((short) 78, root.getValues().get(3));
|
||||
Assertions.assertEquals((short) -127, root.getValues().get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeShort() {
|
||||
final TestNodeShort elem = new TestNodeShort();
|
||||
elem.valueA = (short) 11;
|
||||
elem.valueB = (short) -120;
|
||||
elem.valueNull = null;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>11</valueA>
|
||||
<valueB>-120</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short) 11, root.valueA);
|
||||
Assertions.assertEquals((short) -120, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeShortFunc() {
|
||||
final TestNodeShortFunc elem = new TestNodeShortFunc();
|
||||
elem.setValueA((short) 54);
|
||||
elem.setValueB((short) -68);
|
||||
elem.setValueNull(null);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>54</valueA>
|
||||
<valueB>-68</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short) 54, root.getValueA());
|
||||
Assertions.assertEquals((short) -68, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelShort() {
|
||||
final TestShort elem = new TestShort();
|
||||
elem.valueA = (short) 12;
|
||||
elem.valueB = (short) -13;
|
||||
elem.valueNull = null;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestShort root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestShort.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short) 12, root.valueA);
|
||||
Assertions.assertEquals((short) -13, root.valueB);
|
||||
Assertions.assertEquals(null, root.valueNull);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelShortFunc() {
|
||||
final TestShortFunc elem = new TestShortFunc();
|
||||
elem.setValueA((short) -55);
|
||||
elem.setValueB((short) 57);
|
||||
elem.setValueNull(null);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short) -55, root.getValueA());
|
||||
Assertions.assertEquals((short) 57, root.getValueB());
|
||||
Assertions.assertEquals(null, root.getValueNull());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -5,225 +5,14 @@
|
||||
*/
|
||||
package test.atriasoft.exml;
|
||||
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
import org.atriasoft.exml.Exml;
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class ExmlTestIntrospectionShortNative {
|
||||
static final String NODE_NAME = "elem";
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestShortNative {
|
||||
public short valueA;
|
||||
public short valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelShortNative() {
|
||||
TestShortNative elem = new TestShortNative();
|
||||
elem.valueA = (short)12;
|
||||
elem.valueB = (short)-13;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short)12, root.valueA);
|
||||
Assertions.assertEquals((short)-13, root.valueB);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestArrayShortNative {
|
||||
public short[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayShortNative() {
|
||||
TestArrayShortNative elem = new TestArrayShortNative();
|
||||
elem.values = new short[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short)12, root.values[0]);
|
||||
Assertions.assertEquals((short)-13, root.values[1]);
|
||||
Assertions.assertEquals((short)33, root.values[2]);
|
||||
Assertions.assertEquals((short)78, root.values[3]);
|
||||
Assertions.assertEquals((short)-127, root.values[4]);
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestshortFunc {
|
||||
private short valueA;
|
||||
private short valueB;
|
||||
public short getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final short valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public short getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final short valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelShortFunc() {
|
||||
TestshortFunc elem = new TestshortFunc();
|
||||
elem.setValueA((short)-55);
|
||||
elem.setValueB((short)57);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestshortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestshortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short)-55, root.getValueA());
|
||||
Assertions.assertEquals((short)57, root.getValueB());
|
||||
}
|
||||
|
||||
@XmlDefaultAttibute
|
||||
public class TestArrayShortFunc {
|
||||
private short[] values;
|
||||
|
||||
public short[] getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final short[] values) {
|
||||
this.values = values;
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayShortFunc() {
|
||||
TestArrayShortFunc elem = new TestArrayShortFunc();
|
||||
elem.setValues(new short[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((short)12, root.getValues()[0]);
|
||||
Assertions.assertEquals((short)-13, root.getValues()[1]);
|
||||
Assertions.assertEquals((short)33, root.getValues()[2]);
|
||||
Assertions.assertEquals((short)78, root.getValues()[3]);
|
||||
Assertions.assertEquals((short)-127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
public class TestNodeShortNative {
|
||||
public short valueA;
|
||||
public short valueB;
|
||||
}
|
||||
@Test
|
||||
public void testModelNodeShortNative() {
|
||||
TestNodeShortNative elem = new TestNodeShortNative();
|
||||
elem.valueA = (short)11;
|
||||
elem.valueB = (short)-120;
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>11</valueA>\n"
|
||||
+ " <valueB>-120</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short)11, root.valueA);
|
||||
Assertions.assertEquals((short)-120, root.valueB);
|
||||
}
|
||||
|
||||
public class TestArrayNodeShortNative {
|
||||
public short[] values;
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeshortNative() {
|
||||
TestArrayNodeShortNative elem = new TestArrayNodeShortNative();
|
||||
elem.values = new short[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short)12, root.values[0]);
|
||||
Assertions.assertEquals((short)-13, root.values[1]);
|
||||
Assertions.assertEquals((short)33, root.values[2]);
|
||||
Assertions.assertEquals((short)78, root.values[3]);
|
||||
Assertions.assertEquals((short)-127, root.values[4]);
|
||||
}
|
||||
|
||||
public class TestNodeshortFunc {
|
||||
private short valueA;
|
||||
private short valueB;
|
||||
public short getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
public void setValueA(final short valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
public short getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
public void setValueB(final short valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeShortFunc() {
|
||||
TestNodeshortFunc elem = new TestNodeshortFunc();
|
||||
elem.setValueA((short)54);
|
||||
elem.setValueB((short)-68);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <valueA>54</valueA>\n"
|
||||
+ " <valueB>-68</valueB>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestNodeshortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeshortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short)54, root.getValueA());
|
||||
Assertions.assertEquals((short)-68, root.getValueB());
|
||||
}
|
||||
|
||||
public class TestArrayNodeShortFunc {
|
||||
private short[] values;
|
||||
|
||||
@ -236,62 +25,292 @@ public class ExmlTestIntrospectionShortNative {
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testModelArrayNodeShortFunc() {
|
||||
TestArrayNodeShortFunc elem = new TestArrayNodeShortFunc();
|
||||
elem.setValues(new short[] {12, -13, 33, 78, -127});
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>12</values>\n"
|
||||
+ " <values>-13</values>\n"
|
||||
+ " <values>33</values>\n"
|
||||
+ " <values>78</values>\n"
|
||||
+ " <values>-127</values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
|
||||
final TestArrayNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((short)12, root.getValues()[0]);
|
||||
Assertions.assertEquals((short)-13, root.getValues()[1]);
|
||||
Assertions.assertEquals((short)33, root.getValues()[2]);
|
||||
Assertions.assertEquals((short)78, root.getValues()[3]);
|
||||
Assertions.assertEquals((short)-127, root.getValues()[4]);
|
||||
public class TestArrayNodeShortNative {
|
||||
public short[] values;
|
||||
}
|
||||
|
||||
public class TestArrayNodeShortNativeStructured {
|
||||
@XmlList(value="elem")
|
||||
@AknotList(value = "elem")
|
||||
public short[] values;
|
||||
}
|
||||
@Test
|
||||
public void testArrayNodeShortNativeStructured() {
|
||||
TestArrayNodeShortNativeStructured elem = new TestArrayNodeShortNativeStructured();
|
||||
elem.values = new short[] {12, -13, 33, 78, -127};
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayShortFunc {
|
||||
private short[] values;
|
||||
|
||||
public short[] getValues() {
|
||||
return this.values;
|
||||
}
|
||||
|
||||
public void setValues(final short[] values) {
|
||||
this.values = values;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestArrayShortNative {
|
||||
public short[] values;
|
||||
}
|
||||
|
||||
public class TestNodeshortFunc {
|
||||
private short valueA;
|
||||
private short valueB;
|
||||
|
||||
public short getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public short getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final short valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final short valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
public class TestNodeShortNative {
|
||||
public short valueA;
|
||||
public short valueB;
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestshortFunc {
|
||||
private short valueA;
|
||||
private short valueB;
|
||||
|
||||
public short getValueA() {
|
||||
return this.valueA;
|
||||
}
|
||||
|
||||
public short getValueB() {
|
||||
return this.valueB;
|
||||
}
|
||||
|
||||
public void setValueA(final short valueA) {
|
||||
this.valueA = valueA;
|
||||
}
|
||||
|
||||
public void setValueB(final short valueB) {
|
||||
this.valueB = valueB;
|
||||
}
|
||||
}
|
||||
|
||||
@AknotDefaultAttribute
|
||||
public class TestShortNative {
|
||||
public short valueA;
|
||||
public short valueB;
|
||||
}
|
||||
|
||||
static final String NODE_NAME = "elem";
|
||||
|
||||
@BeforeAll
|
||||
public static void beforeClass() {
|
||||
Log.warning("================================================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArrayNodeShortNativeStructured() {
|
||||
final TestArrayNodeShortNativeStructured elem = new TestArrayNodeShortNativeStructured();
|
||||
elem.values = new short[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
String dataTest = builder.toString();
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem>\n"
|
||||
+ " <values>\n"
|
||||
+ " <elem>12</elem>\n"
|
||||
+ " <elem>-13</elem>\n"
|
||||
+ " <elem>33</elem>\n"
|
||||
+ " <elem>78</elem>\n"
|
||||
+ " <elem>-127</elem>\n"
|
||||
+ " </values>\n"
|
||||
+ "</elem>", dataTest);
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>
|
||||
<elem>12</elem>
|
||||
<elem>-13</elem>
|
||||
<elem>33</elem>
|
||||
<elem>78</elem>
|
||||
<elem>-127</elem>
|
||||
</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeShortNativeStructured root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortNativeStructured.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short)12, root.values[0]);
|
||||
Assertions.assertEquals((short)-13, root.values[1]);
|
||||
Assertions.assertEquals((short)33, root.values[2]);
|
||||
Assertions.assertEquals((short)78, root.values[3]);
|
||||
Assertions.assertEquals((short)-127, root.values[4]);
|
||||
Assertions.assertEquals((short) 12, root.values[0]);
|
||||
Assertions.assertEquals((short) -13, root.values[1]);
|
||||
Assertions.assertEquals((short) 33, root.values[2]);
|
||||
Assertions.assertEquals((short) 78, root.values[3]);
|
||||
Assertions.assertEquals((short) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeShortFunc() {
|
||||
final TestArrayNodeShortFunc elem = new TestArrayNodeShortFunc();
|
||||
elem.setValues(new short[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((short) 12, root.getValues()[0]);
|
||||
Assertions.assertEquals((short) -13, root.getValues()[1]);
|
||||
Assertions.assertEquals((short) 33, root.getValues()[2]);
|
||||
Assertions.assertEquals((short) 78, root.getValues()[3]);
|
||||
Assertions.assertEquals((short) -127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayNodeshortNative() {
|
||||
final TestArrayNodeShortNative elem = new TestArrayNodeShortNative();
|
||||
elem.values = new short[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<values>12</values>
|
||||
<values>-13</values>
|
||||
<values>33</values>
|
||||
<values>78</values>
|
||||
<values>-127</values>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestArrayNodeShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayNodeShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short) 12, root.values[0]);
|
||||
Assertions.assertEquals((short) -13, root.values[1]);
|
||||
Assertions.assertEquals((short) 33, root.values[2]);
|
||||
Assertions.assertEquals((short) 78, root.values[3]);
|
||||
Assertions.assertEquals((short) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayShortFunc() {
|
||||
final TestArrayShortFunc elem = new TestArrayShortFunc();
|
||||
elem.setValues(new short[] { 12, -13, 33, 78, -127 });
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayShortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.getValues().length);
|
||||
Assertions.assertEquals((short) 12, root.getValues()[0]);
|
||||
Assertions.assertEquals((short) -13, root.getValues()[1]);
|
||||
Assertions.assertEquals((short) 33, root.getValues()[2]);
|
||||
Assertions.assertEquals((short) 78, root.getValues()[3]);
|
||||
Assertions.assertEquals((short) -127, root.getValues()[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelArrayShortNative() {
|
||||
final TestArrayShortNative elem = new TestArrayShortNative();
|
||||
elem.values = new short[] { 12, -13, 33, 78, -127 };
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem values=\"12;-13;33;78;-127\"/>", dataTest);
|
||||
|
||||
final TestArrayShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestArrayShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals(5, root.values.length);
|
||||
Assertions.assertEquals((short) 12, root.values[0]);
|
||||
Assertions.assertEquals((short) -13, root.values[1]);
|
||||
Assertions.assertEquals((short) 33, root.values[2]);
|
||||
Assertions.assertEquals((short) 78, root.values[3]);
|
||||
Assertions.assertEquals((short) -127, root.values[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeShortFunc() {
|
||||
final TestNodeshortFunc elem = new TestNodeshortFunc();
|
||||
elem.setValueA((short) 54);
|
||||
elem.setValueB((short) -68);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>54</valueA>
|
||||
<valueB>-68</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeshortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeshortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short) 54, root.getValueA());
|
||||
Assertions.assertEquals((short) -68, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelNodeShortNative() {
|
||||
final TestNodeShortNative elem = new TestNodeShortNative();
|
||||
elem.valueA = (short) 11;
|
||||
elem.valueB = (short) -120;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("""
|
||||
<elem>
|
||||
<valueA>11</valueA>
|
||||
<valueB>-120</valueB>
|
||||
</elem>""", dataTest);
|
||||
|
||||
final TestNodeShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestNodeShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short) 11, root.valueA);
|
||||
Assertions.assertEquals((short) -120, root.valueB);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelShortFunc() {
|
||||
final TestshortFunc elem = new TestshortFunc();
|
||||
elem.setValueA((short) -55);
|
||||
elem.setValueB((short) 57);
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"-55\" valueB=\"57\"/>", dataTest);
|
||||
|
||||
final TestshortFunc root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestshortFunc.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short) -55, root.getValueA());
|
||||
Assertions.assertEquals((short) 57, root.getValueB());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testModelShortNative() {
|
||||
final TestShortNative elem = new TestShortNative();
|
||||
elem.valueA = (short) 12;
|
||||
elem.valueB = (short) -13;
|
||||
|
||||
final StringBuilder builder = new StringBuilder();
|
||||
Assertions.assertDoesNotThrow(() -> Exml.generate(elem, ExmlTestIntrospectionShort.NODE_NAME, builder));
|
||||
final String dataTest = builder.toString();
|
||||
Log.warning("data generated: " + builder.toString());
|
||||
Assertions.assertEquals("<elem valueA=\"12\" valueB=\"-13\"/>", dataTest);
|
||||
|
||||
final TestShortNative root = Assertions.assertDoesNotThrow(() -> Exml.parseOne(dataTest, TestShortNative.class, ExmlTestIntrospectionShort.NODE_NAME));
|
||||
Assertions.assertEquals((short) 12, root.valueA);
|
||||
Assertions.assertEquals((short) -13, root.valueB);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,9 +1,8 @@
|
||||
package test.atriasoft.exml.introspection;
|
||||
|
||||
import org.atriasoft.exml.annotation.XmlDefaultManaged;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultManaged;
|
||||
|
||||
@XmlDefaultManaged(value = false)
|
||||
@AknotDefaultManaged(value = false)
|
||||
public class ClassInversion {
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
package test.atriasoft.exml.introspection;
|
||||
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class ClassPublicMemberOnly {
|
||||
public boolean[] memberArrayBoolean;
|
||||
public Boolean[] memberArrayBooleanClass;
|
||||
@ -16,7 +16,7 @@ public class ClassPublicMemberOnly {
|
||||
public Short[] memberArrayShortClass;
|
||||
public boolean memberBoolean;
|
||||
public Boolean memberBooleanClass;
|
||||
//this work !!! @XmlName(value = "jhkjhhkj")
|
||||
//this work !!! @AKName(value = "jhkjhhkj")
|
||||
public byte memberByte;
|
||||
public Byte memberByteClass;
|
||||
public int memberInteger;
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
package test.atriasoft.exml.introspection;
|
||||
|
||||
import org.atriasoft.exml.annotation.XmlDefaultAttibute;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultAttribute;
|
||||
|
||||
@XmlDefaultAttibute
|
||||
@AknotDefaultAttribute
|
||||
public class ClassPublicMethodOnly {
|
||||
private boolean[] memberArrayBoolean;
|
||||
private Boolean[] memberArrayBooleanClass;
|
||||
|
||||
@ -2,9 +2,9 @@ package test.atriasoft.exml.introspection;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.exml.annotation.XmlDefaultManaged;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultManaged;
|
||||
|
||||
@XmlDefaultManaged(value = false)
|
||||
@AknotDefaultManaged(value = false)
|
||||
public class ClassPublicMethodeNode {
|
||||
|
||||
private boolean[] memberArrayBoolean;
|
||||
@ -34,50 +34,6 @@ public class ClassPublicMethodeNode {
|
||||
private Short memberShortClass;
|
||||
private String memberStringClass;
|
||||
|
||||
public List<Boolean> getMemberListBooleanClass() {
|
||||
return memberListBooleanClass;
|
||||
}
|
||||
|
||||
public void setMemberListBooleanClass(List<Boolean> memberListBooleanClass) {
|
||||
this.memberListBooleanClass = memberListBooleanClass;
|
||||
}
|
||||
|
||||
public List<Byte> getMemberListByteClass() {
|
||||
return memberListByteClass;
|
||||
}
|
||||
|
||||
public void setMemberListByteClass(List<Byte> memberListByteClass) {
|
||||
this.memberListByteClass = memberListByteClass;
|
||||
}
|
||||
|
||||
public List<Integer> getMemberListIntegerClass() {
|
||||
return memberListIntegerClass;
|
||||
}
|
||||
|
||||
public void setMemberListIntegerClass(List<Integer> memberListIntegerClass) {
|
||||
this.memberListIntegerClass = memberListIntegerClass;
|
||||
}
|
||||
|
||||
public List<Long> getMemberListLongClass() {
|
||||
return memberListLongClass;
|
||||
}
|
||||
|
||||
public void setMemberListLongClass(List<Long> memberListLongClass) {
|
||||
this.memberListLongClass = memberListLongClass;
|
||||
}
|
||||
|
||||
public List<Short> getMemberListShortClass() {
|
||||
return memberListShortClass;
|
||||
}
|
||||
|
||||
public void setMemberListShortClass(List<Short> memberListShortClass) {
|
||||
this.memberListShortClass = memberListShortClass;
|
||||
}
|
||||
|
||||
public Boolean getMemberBooleanClass() {
|
||||
return memberBooleanClass;
|
||||
}
|
||||
|
||||
public boolean[] getMemberArrayBoolean() {
|
||||
return this.memberArrayBoolean;
|
||||
}
|
||||
@ -118,6 +74,10 @@ public class ClassPublicMethodeNode {
|
||||
return this.memberArrayShortClass;
|
||||
}
|
||||
|
||||
public Boolean getMemberBooleanClass() {
|
||||
return this.memberBooleanClass;
|
||||
}
|
||||
|
||||
public byte getMemberByte() {
|
||||
return this.memberByte;
|
||||
}
|
||||
@ -134,6 +94,26 @@ public class ClassPublicMethodeNode {
|
||||
return this.memberIntegerClass;
|
||||
}
|
||||
|
||||
public List<Boolean> getMemberListBooleanClass() {
|
||||
return this.memberListBooleanClass;
|
||||
}
|
||||
|
||||
public List<Byte> getMemberListByteClass() {
|
||||
return this.memberListByteClass;
|
||||
}
|
||||
|
||||
public List<Integer> getMemberListIntegerClass() {
|
||||
return this.memberListIntegerClass;
|
||||
}
|
||||
|
||||
public List<Long> getMemberListLongClass() {
|
||||
return this.memberListLongClass;
|
||||
}
|
||||
|
||||
public List<Short> getMemberListShortClass() {
|
||||
return this.memberListShortClass;
|
||||
}
|
||||
|
||||
public long getMemberLong() {
|
||||
return this.memberLong;
|
||||
}
|
||||
@ -226,6 +206,26 @@ public class ClassPublicMethodeNode {
|
||||
this.memberIntegerClass = memberIntegerClass;
|
||||
}
|
||||
|
||||
public void setMemberListBooleanClass(final List<Boolean> memberListBooleanClass) {
|
||||
this.memberListBooleanClass = memberListBooleanClass;
|
||||
}
|
||||
|
||||
public void setMemberListByteClass(final List<Byte> memberListByteClass) {
|
||||
this.memberListByteClass = memberListByteClass;
|
||||
}
|
||||
|
||||
public void setMemberListIntegerClass(final List<Integer> memberListIntegerClass) {
|
||||
this.memberListIntegerClass = memberListIntegerClass;
|
||||
}
|
||||
|
||||
public void setMemberListLongClass(final List<Long> memberListLongClass) {
|
||||
this.memberListLongClass = memberListLongClass;
|
||||
}
|
||||
|
||||
public void setMemberListShortClass(final List<Short> memberListShortClass) {
|
||||
this.memberListShortClass = memberListShortClass;
|
||||
}
|
||||
|
||||
public void setMemberLong(final long memberLong) {
|
||||
this.memberLong = memberLong;
|
||||
}
|
||||
@ -246,4 +246,3 @@ public class ClassPublicMethodeNode {
|
||||
this.memberStringClass = memberStringClass;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -2,29 +2,31 @@ package test.atriasoft.exml.introspection;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.atriasoft.exml.annotation.XmlDefaultManaged;
|
||||
import org.atriasoft.exml.annotation.XmlList;
|
||||
import org.atriasoft.aknot.annotation.AknotDefaultManaged;
|
||||
import org.atriasoft.aknot.annotation.AknotList;
|
||||
|
||||
@XmlDefaultManaged(value = false)
|
||||
@AknotDefaultManaged(value = false)
|
||||
public class ClassPublicMethodeStructured {
|
||||
// note: when private the decorator must be set on getter or setter, liker this you can use the internal name you want...
|
||||
private byte[] memberArrayByte;
|
||||
private List<Byte> memberListByte;
|
||||
|
||||
@XmlList(value="value")
|
||||
@AknotList(value = "value")
|
||||
public byte[] getMemberArrayByte() {
|
||||
return this.memberArrayByte;
|
||||
}
|
||||
public void setMemberArrayByte(final byte[] memberArrayByte) {
|
||||
this.memberArrayByte = memberArrayByte;
|
||||
}
|
||||
@XmlList(value="elem")
|
||||
|
||||
@AknotList(value = "elem")
|
||||
public List<Byte> getMemberListByte() {
|
||||
return this.memberListByte;
|
||||
}
|
||||
|
||||
public void setMemberArrayByte(final byte[] memberArrayByte) {
|
||||
this.memberArrayByte = memberArrayByte;
|
||||
}
|
||||
|
||||
public void setMemberListByte(final List<Byte> memberListByte) {
|
||||
this.memberListByte = memberListByte;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user