xref: /external/snakeyaml/src/test/java/org/yaml/snakeyaml/array/PrimitiveArrayTest.java

/**
 * Copyright (c) 2008, http://www.snakeyaml.org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
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
        // NumberFormatException
        tryInvalid(pkg + ".ByteArr [ [ 'a' ] ]", NumberFormatException.class);
        tryInvalid(pkg + ".ShortArr [ [ 'a' ] ]", NumberFormatException.class);
        tryInvalid(pkg + ".IntArr [ [ 'a' ] ]", NumberFormatException.class);
        tryInvalid(pkg + ".LongArr [ [ 'a' ] ]", NumberFormatException.class);
        tryInvalid(pkg + ".FloatArr [ [ 'a' ] ]", NumberFormatException.class);
        tryInvalid(pkg + ".DoubleArr [ [ 'a' ] ]", NumberFormatException.class);

        // Exception: because of how boolean construction works, constructing a
        // boolean from 'a'
        // results in null.
        tryInvalid(pkg + ".BooleanArr [ [ 'a' ] ]", NullPointerException.class);

        // Loading a floating-point number as a character is a YAMLException
        tryInvalid(pkg + ".CharArr [ [ 1.2 ] ]", YAMLException.class);

        // Loading a String as a Character is a YAMLException
        tryInvalid(pkg + ".CharArr [ [ 'abcd' ] ]", YAMLException.class);

    }

    public void testTruncation() {
        // Loading floating-point numbers as integer types is disallowed,
        // because that's a number-format problem.
        tryInvalid(pkg + ".ByteArr [ [ 3.14 ] ]", NumberFormatException.class);
        tryInvalid(pkg + ".ShortArr [ [ 3.14 ] ]", NumberFormatException.class);
        tryInvalid(pkg + ".IntArr [ [ 3.14 ] ]", NumberFormatException.class);
        tryInvalid(pkg + ".LongArr [ [ 3.14 ] ]", NumberFormatException.class);
    }

    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("Invalid node Character: 'abcd'; length: 4", 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());
    }

    public void testMultiDimensional() {
        Array2D two = new Array2D();
        two.setLongs(new long[][] { { 1, 2, 3 }, { 4, 5, 6 } });
        assertTrue(Arrays.deepEquals(two.getLongs(), ((Array2D) cycle(two)).getLongs()));

        Array3D three = new Array3D();
        three.setLongs(new long[][][] { { { 1, 2, 3, 4 }, { 5, 6, 7, 8 } },
                { { 9, 10, 11, 12 }, { 13, 14, 15, 16 } } });
        assertTrue(Arrays.deepEquals(three.getLongs(), ((Array3D) cycle(three)).getLongs()));

        // Object with an array of Objects which each have an array of
        // primitives.
        ArrayLongArr four = new ArrayLongArr();
        four.setContents(new LongArr[] { new LongArr(new long[] { 1, 2, 3, 4 }),
                new LongArr(new long[] { 5, 6, 7, 8 }) });
        Object result = cycle(four);
        assertEquals(four, (ArrayLongArr) result);
    }

    public static class Array2D {
        private long[][] longs;

        public long[][] getLongs() {
            return longs;
        }

        public void setLongs(long[][] longs) {
            this.longs = longs;
        }
    }

    public static class Array3D {
        private long[][][] longs;

        public long[][][] getLongs() {
            return longs;
        }

        public void setLongs(long[][][] longs) {
            this.longs = longs;
        }
    }

    public static class ArrayLongArr {
        private LongArr[] contents;

        public LongArr[] getContents() {
            return contents;
        }

        public void setContents(LongArr[] contents) {
            this.contents = contents;
        }

        @Override
        public boolean equals(Object obj) {
            if (!(obj instanceof ArrayLongArr))
                return false;

            ArrayLongArr other = ((ArrayLongArr) obj);
            if (contents.length != other.getContents().length)
                return false;
            for (int i = 0; i < contents.length; ++i) {
                if (!Arrays.equals(contents[i].getLongs(), other.getContents()[i].getLongs())) {
                    return false;
                }
            }

            return true;
        }
    }
}