Issue 135: Arrays of primitives are not fully supported
- added new test case 'PrimitiveArrayTest', which tests all types of primitive
array, including cycling Java -> YAML -> Java.
- removed outdated tests from generics.GenericArrayTypeTest and types.SeqTagTest
- updated BaseRepresenter to remove outdated "not fully supported" message
- updated SafeRepresenter to handle serializing primitive arrays
- updated Representer.checkGlobalTag to ignore primitive arrays
- updated BaseConstructor to handle constructing arrays of primitives as well as
arrays of Object.
diff --git a/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.java b/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.java
index fadc89c..6d6d200 100644
--- a/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.java
+++ b/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.java
@@ -226,9 +226,8 @@
return new LinkedHashSet<Object>(initSize);
}
- @SuppressWarnings("unchecked")
- protected <T> T[] createArray(Class<T> type, int size) {
- return (T[]) Array.newInstance(type.getComponentType(), size);
+ protected Object createArray(Class<?> type, int size) {
+ return Array.newInstance(type.getComponentType(), size);
}
@SuppressWarnings("unchecked")
@@ -278,9 +277,65 @@
}
protected Object constructArrayStep2(SequenceNode node, Object array) {
+ final Class<?> componentType = node.getType().getComponentType();
+
int index = 0;
for (Node child : node.getValue()) {
- Array.set(array, index++, constructObject(child));
+ Object value = constructObject(child);
+
+ if (componentType.isPrimitive()) {
+ // Primitive arrays require quite a lot of work.
+ if (byte.class.equals(componentType)) {
+ Array.setByte(array, index, ((Number) value).byteValue());
+
+ } else if (short.class.equals(componentType)) {
+ Array.setShort(array, index, ((Number) value).shortValue());
+
+ } else if (int.class.equals(componentType)) {
+ Array.setInt(array, index, ((Number) value).intValue());
+
+ } else if (long.class.equals(componentType)) {
+ Array.setLong(array, index, ((Number) value).longValue());
+
+ } else if (float.class.equals(componentType)) {
+ Array.setFloat(array, index, ((Number) value).floatValue());
+
+ } else if (double.class.equals(componentType)) {
+ Array.setDouble(array, index,
+ ((Number) value).doubleValue());
+
+ } else if (char.class.equals(componentType)) {
+
+ if (value instanceof Character) {
+ Array.setChar(array, index,
+ ((Character) value).charValue());
+
+ } else if (value instanceof String) {
+ String val = (String) value;
+ if (val.length() != 1) {
+ throw new YAMLException("expected char but got \""
+ + val + "\"");
+ }
+ Array.setChar(array, index, val.charAt(0));
+ } else {
+ throw new ClassCastException("expected char but got "
+ + value.getClass().getCanonicalName());
+ }
+
+ } else if (boolean.class.equals(componentType)) {
+ Array.setBoolean(array, index,
+ ((Boolean) value).booleanValue());
+
+ } else {
+ throw new YAMLException("unexpected primitive type");
+ }
+
+ } else {
+ // Non-primitive arrays can simply be assigned:
+ Array.set(array, index, constructObject(child));
+ }
+
+ ++index;
}
return array;
}
diff --git a/src/main/java/org/yaml/snakeyaml/representer/BaseRepresenter.java b/src/main/java/org/yaml/snakeyaml/representer/BaseRepresenter.java
index fcbde03..743824a 100644
--- a/src/main/java/org/yaml/snakeyaml/representer/BaseRepresenter.java
+++ b/src/main/java/org/yaml/snakeyaml/representer/BaseRepresenter.java
@@ -96,10 +96,7 @@
return node;
}
}
- // check array of primitives
- if (clazz.isArray()) {
- throw new YAMLException("Arrays of primitives are not fully supported.");
- }
+
// check defaults
if (multiRepresenters.containsKey(null)) {
Represent representer = multiRepresenters.get(null);
diff --git a/src/main/java/org/yaml/snakeyaml/representer/Representer.java b/src/main/java/org/yaml/snakeyaml/representer/Representer.java
index 486094f..c4a7908 100644
--- a/src/main/java/org/yaml/snakeyaml/representer/Representer.java
+++ b/src/main/java/org/yaml/snakeyaml/representer/Representer.java
@@ -162,6 +162,12 @@
*/
@SuppressWarnings("unchecked")
protected void checkGlobalTag(Property property, Node node, Object object) {
+ // Skip primitive arrays.
+ if (object.getClass().isArray()
+ && object.getClass().getComponentType().isPrimitive()) {
+ return;
+ }
+
Class<?>[] arguments = property.getActualTypeArguments();
if (arguments != null) {
if (node.getNodeId() == NodeId.sequence) {
diff --git a/src/main/java/org/yaml/snakeyaml/representer/SafeRepresenter.java b/src/main/java/org/yaml/snakeyaml/representer/SafeRepresenter.java
index b2d599f..b4b618f 100644
--- a/src/main/java/org/yaml/snakeyaml/representer/SafeRepresenter.java
+++ b/src/main/java/org/yaml/snakeyaml/representer/SafeRepresenter.java
@@ -17,6 +17,7 @@
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
@@ -49,6 +50,16 @@
this.representers.put(Boolean.class, new RepresentBoolean());
this.representers.put(Character.class, new RepresentString());
this.representers.put(byte[].class, new RepresentByteArray());
+
+ Represent primitiveArray = new RepresentPrimitiveArray();
+ representers.put(short[].class, primitiveArray);
+ representers.put(int[].class, primitiveArray);
+ representers.put(long[].class, primitiveArray);
+ representers.put(float[].class, primitiveArray);
+ representers.put(double[].class, primitiveArray);
+ representers.put(char[].class, primitiveArray);
+ representers.put(boolean[].class, primitiveArray);
+
this.multiRepresenters.put(Number.class, new RepresentNumber());
this.multiRepresenters.put(List.class, new RepresentList());
this.multiRepresenters.put(Map.class, new RepresentMap());
@@ -207,11 +218,107 @@
}
}
+ /**
+ * Represents primitive arrays, such as short[] and float[], by converting
+ * them into equivalent List<Short> and List<Float> using the appropriate
+ * autoboxing type.
+ */
+ protected class RepresentPrimitiveArray implements Represent {
+ public Node representData(Object data) {
+ Class<?> type = data.getClass().getComponentType();
+
+ if (byte.class == type) {
+ return representSequence(Tag.SEQ, asByteList(data), null);
+ } else if (short.class == type) {
+ return representSequence(Tag.SEQ, asShortList(data), null);
+ } else if (int.class == type) {
+ return representSequence(Tag.SEQ, asIntList(data), null);
+ } else if (long.class == type) {
+ return representSequence(Tag.SEQ, asLongList(data), null);
+ } else if (float.class == type) {
+ return representSequence(Tag.SEQ, asFloatList(data), null);
+ } else if (double.class == type) {
+ return representSequence(Tag.SEQ, asDoubleList(data), null);
+ } else if (char.class == type) {
+ return representSequence(Tag.SEQ, asCharList(data), null);
+ } else if (boolean.class == type) {
+ return representSequence(Tag.SEQ, asBooleanList(data), null);
+ }
+
+ throw new YAMLException("Unexpected primitive '"
+ + type.getCanonicalName() + "'");
+ }
+
+ private List<Byte> asByteList(Object in) {
+ byte[] array = (byte[]) in;
+ List<Byte> list = new ArrayList<Byte>(array.length);
+ for (int i = 0; i < array.length; ++i)
+ list.add(array[i]);
+ return list;
+ }
+
+ private List<Short> asShortList(Object in) {
+ short[] array = (short[]) in;
+ List<Short> list = new ArrayList<Short>(array.length);
+ for (int i = 0; i < array.length; ++i)
+ list.add(array[i]);
+ return list;
+ }
+
+ private List<Integer> asIntList(Object in) {
+ int[] array = (int[]) in;
+ List<Integer> list = new ArrayList<Integer>(array.length);
+ for (int i = 0; i < array.length; ++i)
+ list.add(array[i]);
+ return list;
+ }
+
+ private List<Long> asLongList(Object in) {
+ long[] array = (long[]) in;
+ List<Long> list = new ArrayList<Long>(array.length);
+ for (int i = 0; i < array.length; ++i)
+ list.add(array[i]);
+ return list;
+ }
+
+ private List<Float> asFloatList(Object in) {
+ float[] array = (float[]) in;
+ List<Float> list = new ArrayList<Float>(array.length);
+ for (int i = 0; i < array.length; ++i)
+ list.add(array[i]);
+ return list;
+ }
+
+ private List<Double> asDoubleList(Object in) {
+ double[] array = (double[]) in;
+ List<Double> list = new ArrayList<Double>(array.length);
+ for (int i = 0; i < array.length; ++i)
+ list.add(array[i]);
+ return list;
+ }
+
+ private List<Character> asCharList(Object in) {
+ char[] array = (char[]) in;
+ List<Character> list = new ArrayList<Character>(array.length);
+ for (int i = 0; i < array.length; ++i)
+ list.add(array[i]);
+ return list;
+ }
+
+ private List<Boolean> asBooleanList(Object in) {
+ boolean[] array = (boolean[]) in;
+ List<Boolean> list = new ArrayList<Boolean>(array.length);
+ for (int i = 0; i < array.length; ++i)
+ list.add(array[i]);
+ return list;
+ }
+ }
+
protected class RepresentMap implements Represent {
@SuppressWarnings("unchecked")
public Node representData(Object data) {
- return representMapping(getTag(data.getClass(), Tag.MAP), (Map<Object, Object>) data,
- null);
+ return representMapping(getTag(data.getClass(), Tag.MAP),
+ (Map<Object, Object>) data, null);
}
}
diff --git a/src/test/java/org/yaml/snakeyaml/array/BooleanArr.java b/src/test/java/org/yaml/snakeyaml/array/BooleanArr.java
new file mode 100644
index 0000000..c46bf8f
--- /dev/null
+++ b/src/test/java/org/yaml/snakeyaml/array/BooleanArr.java
@@ -0,0 +1,25 @@
+package org.yaml.snakeyaml.array;
+
+import java.util.Arrays;
+
+public class BooleanArr {
+ private boolean[] bools;
+
+ public BooleanArr () {}
+
+ public BooleanArr ( boolean[] bools ) {
+ this.bools = bools;
+ }
+
+ public String toString() {
+ return Arrays.toString(bools);
+ }
+
+ public boolean[] getBools() {
+ return bools;
+ }
+
+ public void setBools(boolean[] bools) {
+ this.bools = bools;
+ }
+}
diff --git a/src/test/java/org/yaml/snakeyaml/array/ByteArr.java b/src/test/java/org/yaml/snakeyaml/array/ByteArr.java
new file mode 100644
index 0000000..ee8ab2c
--- /dev/null
+++ b/src/test/java/org/yaml/snakeyaml/array/ByteArr.java
@@ -0,0 +1,26 @@
+package org.yaml.snakeyaml.array;
+
+import java.util.Arrays;
+
+public class ByteArr {
+
+ private byte[] bytes;
+
+ public ByteArr(){}
+
+ public ByteArr ( byte[] bytes ) {
+ this.bytes = bytes;
+ }
+
+ public String toString() {
+ return Arrays.toString(bytes);
+ }
+
+ public byte[] getBytes() {
+ return bytes;
+ }
+
+ public void setBytes(byte[] bytes) {
+ this.bytes = bytes;
+ }
+}
diff --git a/src/test/java/org/yaml/snakeyaml/array/CharArr.java b/src/test/java/org/yaml/snakeyaml/array/CharArr.java
new file mode 100644
index 0000000..12dd78a
--- /dev/null
+++ b/src/test/java/org/yaml/snakeyaml/array/CharArr.java
@@ -0,0 +1,25 @@
+package org.yaml.snakeyaml.array;
+
+import java.util.Arrays;
+
+public class CharArr {
+ private char[] chars;
+
+ public CharArr () {}
+
+ public CharArr ( char[] chars ) {
+ this.chars = chars;
+ }
+
+ public String toString() {
+ return Arrays.toString(chars);
+ }
+
+ public char[] getChars() {
+ return chars;
+ }
+
+ public void setChars(char[] chars) {
+ this.chars = chars;
+ }
+}
diff --git a/src/test/java/org/yaml/snakeyaml/array/DoubleArr.java b/src/test/java/org/yaml/snakeyaml/array/DoubleArr.java
new file mode 100644
index 0000000..84ff81e
--- /dev/null
+++ b/src/test/java/org/yaml/snakeyaml/array/DoubleArr.java
@@ -0,0 +1,25 @@
+package org.yaml.snakeyaml.array;
+
+import java.util.Arrays;
+
+public class DoubleArr {
+ private double[] doubles;
+
+ public DoubleArr () {}
+
+ public DoubleArr ( double[] doubles ) {
+ this.doubles = doubles;
+ }
+
+ public String toString() {
+ return Arrays.toString(doubles);
+ }
+
+ public double[] getDoubles() {
+ return doubles;
+ }
+
+ public void setDoubles(double[] doubles) {
+ this.doubles = doubles;
+ }
+}
diff --git a/src/test/java/org/yaml/snakeyaml/array/FloatArr.java b/src/test/java/org/yaml/snakeyaml/array/FloatArr.java
new file mode 100644
index 0000000..7cce7b2
--- /dev/null
+++ b/src/test/java/org/yaml/snakeyaml/array/FloatArr.java
@@ -0,0 +1,25 @@
+package org.yaml.snakeyaml.array;
+
+import java.util.Arrays;
+
+public class FloatArr {
+ private float[] floats;
+
+ public FloatArr () {}
+
+ public FloatArr ( float[] floats ) {
+ this.floats = floats;
+ }
+
+ public String toString() {
+ return Arrays.toString(floats);
+ }
+
+ public float[] getFloats() {
+ return floats;
+ }
+
+ public void setFloats(float[] floats) {
+ this.floats = floats;
+ }
+}
diff --git a/src/test/java/org/yaml/snakeyaml/array/IntArr.java b/src/test/java/org/yaml/snakeyaml/array/IntArr.java
new file mode 100644
index 0000000..ac95eb4
--- /dev/null
+++ b/src/test/java/org/yaml/snakeyaml/array/IntArr.java
@@ -0,0 +1,25 @@
+package org.yaml.snakeyaml.array;
+
+import java.util.Arrays;
+
+public class IntArr {
+ private int[] ints;
+
+ public IntArr () {}
+
+ public IntArr ( int[] ints ) {
+ this.ints = ints;
+ }
+
+ public String toString() {
+ return Arrays.toString(ints);
+ }
+
+ public int[] getInts() {
+ return ints;
+ }
+
+ public void setInts(int[] ints) {
+ this.ints = ints;
+ }
+}
diff --git a/src/test/java/org/yaml/snakeyaml/array/LongArr.java b/src/test/java/org/yaml/snakeyaml/array/LongArr.java
new file mode 100644
index 0000000..7aae69a
--- /dev/null
+++ b/src/test/java/org/yaml/snakeyaml/array/LongArr.java
@@ -0,0 +1,25 @@
+package org.yaml.snakeyaml.array;
+
+import java.util.Arrays;
+
+public class LongArr {
+ private long[] longs;
+
+ public LongArr () {}
+
+ public LongArr ( long[] longs ) {
+ this.longs = longs;
+ }
+
+ public String toString() {
+ return Arrays.toString(longs);
+ }
+
+ public long[] getLongs() {
+ return longs;
+ }
+
+ public void setLongs(long[] longs) {
+ this.longs = longs;
+ }
+}
diff --git a/src/test/java/org/yaml/snakeyaml/array/PrimitiveArrayTest.java b/src/test/java/org/yaml/snakeyaml/array/PrimitiveArrayTest.java
new file mode 100644
index 0000000..f5b13a2
--- /dev/null
+++ b/src/test/java/org/yaml/snakeyaml/array/PrimitiveArrayTest.java
@@ -0,0 +1,184 @@
+package org.yaml.snakeyaml.array;
+
+import java.util.Arrays;
+import java.util.List;
+
+import junit.framework.TestCase;
+
+import org.junit.Assert;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.ConstructorException;
+import org.yaml.snakeyaml.error.YAMLException;
+
+public class PrimitiveArrayTest extends TestCase {
+
+ private final String pkg = "!!org.yaml.snakeyaml.array";
+
+ private final byte[] bytes = new byte[]{1,2,3};
+ private final short[] shorts = new short[]{300,301,302};
+ private final int[] ints = new int[]{40000,40001,40002};
+ private final long[] longs = new long[]{5000000000L,5000000001L};
+ private final float[] floats = new float[]{0.1f,3.1415f};
+ private final double[] doubles = new double[]{50.0001, 2150.0002};
+ private final char[] chars = new char[]{'a', 'b', 'c', 'd', 'e'};
+ private final boolean[] bools = new boolean[]{true, false};
+
+ public void testValidConstructor () {
+ String testInput =
+ "- " + pkg + ".ByteArr [ " + Arrays.toString(bytes) + " ]\n" +
+ "- " + pkg + ".ShortArr [ " + Arrays.toString(shorts) + " ]\n" +
+ "- " + pkg + ".IntArr [ " + Arrays.toString(ints) + " ]\n" +
+ "- " + pkg + ".LongArr [ " + Arrays.toString(longs) + " ]\n" +
+ "- " + pkg + ".FloatArr [ " + Arrays.toString(floats) + " ]\n" +
+ "- " + pkg + ".DoubleArr [ " + Arrays.toString(doubles) + " ]\n" +
+ "- " + pkg + ".CharArr [ " + Arrays.toString(chars) + " ]\n" +
+ "- " + pkg + ".BooleanArr [ " + Arrays.toString(bools) + " ]\n";
+
+ Yaml yaml = new Yaml();
+ List<Object> wrappers = (List<Object>)yaml.load(testInput);
+
+ Assert.assertArrayEquals ( bytes, ((ByteArr) wrappers.get(0)).getBytes() );
+ Assert.assertArrayEquals ( shorts, ((ShortArr) wrappers.get(1)).getShorts() );
+ Assert.assertArrayEquals ( ints, ((IntArr) wrappers.get(2)).getInts() );
+ Assert.assertArrayEquals ( longs, ((LongArr) wrappers.get(3)).getLongs() );
+ Assert.assertArrayEquals ( floats, ((FloatArr) wrappers.get(4)).getFloats(), 0.001f );
+ Assert.assertArrayEquals ( doubles,((DoubleArr)wrappers.get(5)).getDoubles(), 0.001 );
+ Assert.assertArrayEquals ( chars, ((CharArr) wrappers.get(6)).getChars() );
+ assertArrayEquals ( bools, ((BooleanArr)wrappers.get(7)).getBools() );
+ }
+
+ /*
+ * For some reason, every other assertArrayEquals specialization is
+ * provided by org.junit.Assert, but not this one.
+ */
+ private void assertArrayEquals ( boolean[] expected, boolean[] actuals ) {
+ assertEquals ( "Arrays differ in length", expected.length, actuals.length );
+ for ( int i = 0; i < expected.length; ++i ) {
+ if ( expected[i] != actuals[i] ) {
+ fail ( "Arrays first differ at " + i + "; expected " + expected[i] + " but got " + actuals[i] );
+ }
+ }
+ }
+
+ private void tryInvalid ( String t, Class<?> expectedException ) {
+ Yaml yaml = new Yaml();
+ try {
+ Object loaded = yaml.load(t);
+ fail ( "Expected " + expectedException.getCanonicalName() + " but loaded = \"" + loaded + "\"" );
+ } catch ( YAMLException e ) {
+ assertEquals ( expectedException, e.getCause().getClass() );
+ }
+ }
+
+ public void testInvalidConstructors() {
+ // Loading a character as any primitive other than 'char' is a ClassCastException
+ tryInvalid ( pkg + ".ByteArr [ [ 'a' ] ]", ClassCastException.class );
+ tryInvalid ( pkg + ".ShortArr [ [ 'a' ] ]", ClassCastException.class );
+ tryInvalid ( pkg + ".IntArr [ [ 'a' ] ]", ClassCastException.class );
+ tryInvalid ( pkg + ".LongArr [ [ 'a' ] ]", ClassCastException.class );
+ tryInvalid ( pkg + ".FloatArr [ [ 'a' ] ]", ClassCastException.class );
+ tryInvalid ( pkg + ".DoubleArr [ [ 'a' ] ]", ClassCastException.class );
+ tryInvalid ( pkg + ".BooleanArr [ [ 'a' ] ]", ClassCastException.class );
+
+ // Loading a floating-point number as a character is a ClassCastException
+ tryInvalid ( pkg + ".CharArr [ [ 1.2 ] ]", ClassCastException.class );
+
+ // Loading a String as a Character is a YAMLException
+ tryInvalid ( pkg + ".CharArr [ [ 'abcd' ] ]", YAMLException.class );
+
+ }
+
+ public void testTruncation() {
+ Yaml yaml = new Yaml();
+
+ // Loading floating-point numbers as integer types is allowed, because
+ // that's how the Number.byteValue(), .shortValue(), .intValue(),
+ // .longValue().
+ Assert.assertArrayEquals (
+ new byte[]{3,5},
+ ((ByteArr)yaml.load(pkg + ".ByteArr [ [ 3.14, 5.2 ] ] ")).getBytes()
+ );
+
+ Assert.assertArrayEquals (
+ new short[]{3,5},
+ ((ShortArr)yaml.load(pkg + ".ShortArr [ [ 3.14, 5.2 ] ] ")).getShorts()
+ );
+
+ Assert.assertArrayEquals (
+ new int[]{3,5},
+ ((IntArr)yaml.load(pkg + ".IntArr [ [ 3.14, 5.2 ] ] ")).getInts()
+ );
+
+ Assert.assertArrayEquals (
+ new long[]{3,5},
+ ((LongArr)yaml.load(pkg + ".LongArr [ [ 3.14, 5.2 ] ] ")).getLongs()
+ );
+ }
+
+ public void testPromotion() {
+ Yaml yaml = new Yaml();
+
+ // Loading integer numbers as floating-point types is allowed...
+ Assert.assertArrayEquals (
+ new float[]{3,5},
+ ((FloatArr)yaml.load(pkg + ".FloatArr [ [ 3, 5 ] ] ")).getFloats(),
+ 0.001f
+ );
+
+ Assert.assertArrayEquals (
+ new double[]{3,5},
+ ((DoubleArr)yaml.load(pkg + ".DoubleArr [ [ 3, 5 ] ] ")).getDoubles(),
+ 0.001f
+ );
+ }
+
+ public void testStringCharArray () {
+ Yaml yaml = new Yaml();
+
+ try {
+ yaml.load(pkg + ".CharArr [ [ abcd ] ]");
+ fail ( "Expected exception." );
+ } catch ( Exception e ) {
+ assertEquals ( ConstructorException.class, e.getClass() );
+ assertEquals ( "expected char but got \"abcd\"", e.getCause().getMessage() );
+ }
+ }
+
+ private static Object cycle ( Object in ) {
+ Yaml yaml = new Yaml();
+ String dumped = yaml.dump(in);
+ //System.out.println ( dumped );
+ return yaml.load(dumped);
+ }
+
+ /**
+ * All kinds of primitive arrays should be able to cycle from (Java array)
+ * to (YAML string) to (Java array) again, and they should be exactly the
+ * same before and after.
+ */
+ public void testCycle() {
+ ByteArr byteArr = new ByteArr(bytes);
+ Assert.assertArrayEquals ( byteArr.getBytes(), ((ByteArr)cycle(byteArr)).getBytes() );
+
+ ShortArr shortArr = new ShortArr(shorts);
+ Assert.assertArrayEquals ( shortArr.getShorts(), ((ShortArr)cycle(shortArr)).getShorts() );
+
+ IntArr intArr = new IntArr(ints);
+ Assert.assertArrayEquals ( intArr.getInts(), ((IntArr)cycle(intArr)).getInts() );
+
+ LongArr longArr = new LongArr(longs);
+ Assert.assertArrayEquals ( longArr.getLongs(), ((LongArr)cycle(longArr)).getLongs() );
+
+ FloatArr floatArr = new FloatArr(floats);
+ Assert.assertArrayEquals ( floatArr.getFloats(), ((FloatArr)cycle(floatArr)).getFloats(), 0.001f );
+
+ DoubleArr doubleArr = new DoubleArr(doubles);
+ Assert.assertArrayEquals ( doubleArr.getDoubles(), ((DoubleArr)cycle(doubleArr)).getDoubles(), 0.001 );
+
+ CharArr charArr = new CharArr(chars);
+ Assert.assertArrayEquals ( charArr.getChars(), ((CharArr)cycle(charArr)).getChars() );
+
+ BooleanArr boolArr = new BooleanArr(bools);
+ assertArrayEquals ( boolArr.getBools(), ((BooleanArr)cycle(boolArr)).getBools() );
+ }
+}
diff --git a/src/test/java/org/yaml/snakeyaml/array/ShortArr.java b/src/test/java/org/yaml/snakeyaml/array/ShortArr.java
new file mode 100644
index 0000000..9351370
--- /dev/null
+++ b/src/test/java/org/yaml/snakeyaml/array/ShortArr.java
@@ -0,0 +1,25 @@
+package org.yaml.snakeyaml.array;
+
+import java.util.Arrays;
+
+public class ShortArr {
+ private short[] shorts;
+
+ public ShortArr(){}
+
+ public ShortArr ( short[] shorts ) {
+ this.shorts = shorts;
+ }
+
+ public String toString() {
+ return Arrays.toString(shorts);
+ }
+
+ public short[] getShorts() {
+ return shorts;
+ }
+
+ public void setShorts(short[] shorts) {
+ this.shorts = shorts;
+ }
+}
diff --git a/src/test/java/org/yaml/snakeyaml/generics/GenericArrayTypeTest.java b/src/test/java/org/yaml/snakeyaml/generics/GenericArrayTypeTest.java
index 9848ff7..40880c0 100644
--- a/src/test/java/org/yaml/snakeyaml/generics/GenericArrayTypeTest.java
+++ b/src/test/java/org/yaml/snakeyaml/generics/GenericArrayTypeTest.java
@@ -24,38 +24,6 @@
public class GenericArrayTypeTest extends TestCase {
- public void testPrimitives() {
- GenericPrimitivesArray ga = new GenericPrimitivesArray(3);
- Yaml yaml = new Yaml();
- try {
- yaml.dump(ga);
- fail("Arrays of primitives are not yet fully supported.");
- } catch (Exception e) {
- assertEquals("Arrays of primitives are not fully supported.", e.getMessage());
- }
- }
-
- public static class GenericPrimitivesArray extends AbstractAnimal<int[]> {
- private int[] home;
-
- public GenericPrimitivesArray(int count) {
- home = new int[count];
- for (int i = 0; i < home.length; i++) {
- home[i] = i + 1;
- }
- }
-
- @Override
- public int[] getHome() {
- return home;
- }
-
- @Override
- public void setHome(int[] home) {
- this.home = home;
- }
- }
-
public void testClasses() throws IntrospectionException {
GenericArray ga = new GenericArray();
Yaml yaml = new Yaml();
diff --git a/src/test/java/org/yaml/snakeyaml/types/SeqTagTest.java b/src/test/java/org/yaml/snakeyaml/types/SeqTagTest.java
index 89434d6..8859eb3 100644
--- a/src/test/java/org/yaml/snakeyaml/types/SeqTagTest.java
+++ b/src/test/java/org/yaml/snakeyaml/types/SeqTagTest.java
@@ -90,17 +90,4 @@
String output = dump(array);
assertEquals("[aaa, bbb, ccc]\n", output);
}
-
- public void testArrayPrimitives() {
- int[] array = new int[3];
- array[0] = 1;
- array[1] = 1;
- array[2] = 2;
- try {
- dump(array);
- fail("Arrays of primitives are not supported.");
- } catch (RuntimeException e) {
- assertEquals("Arrays of primitives are not fully supported.", e.getMessage());
- }
- }
}
