| /* |
| * Copyright (C) 2008 Google Inc. |
| * |
| * 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 com.google.gson.functional; |
| |
| import com.google.gson.Gson; |
| import com.google.gson.GsonBuilder; |
| import com.google.gson.JsonParseException; |
| import com.google.gson.common.TestTypes.BagOfPrimitives; |
| import com.google.gson.common.TestTypes.ClassWithObjects; |
| import com.google.gson.reflect.TypeToken; |
| |
| import junit.framework.TestCase; |
| import static org.junit.Assert.assertArrayEquals; |
| |
| import java.lang.reflect.Type; |
| import java.math.BigDecimal; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| /** |
| * Functional tests for Json serialization and deserialization of arrays. |
| * |
| * @author Inderjeet Singh |
| * @author Joel Leitch |
| */ |
| public class ArrayTest extends TestCase { |
| private Gson gson; |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| gson = new Gson(); |
| } |
| |
| public void testTopLevelArrayOfIntsSerialization() { |
| int[] target = {1, 2, 3, 4, 5, 6, 7, 8, 9}; |
| assertEquals("[1,2,3,4,5,6,7,8,9]", gson.toJson(target)); |
| } |
| |
| public void testTopLevelArrayOfIntsDeserialization() { |
| int[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; |
| int[] actual = gson.fromJson("[1,2,3,4,5,6,7,8,9]", int[].class); |
| assertArrayEquals(expected, actual); |
| } |
| |
| public void testInvalidArrayDeserialization() { |
| String json = "[1, 2 3, 4, 5]"; |
| try { |
| gson.fromJson(json, int[].class); |
| fail("Gson should not deserialize array elements with missing ,"); |
| } catch (JsonParseException expected) { |
| } |
| } |
| |
| public void testEmptyArraySerialization() { |
| int[] target = {}; |
| assertEquals("[]", gson.toJson(target)); |
| } |
| |
| public void testEmptyArrayDeserialization() { |
| int[] actualObject = gson.fromJson("[]", int[].class); |
| assertTrue(actualObject.length == 0); |
| |
| Integer[] actualObject2 = gson.fromJson("[]", Integer[].class); |
| assertTrue(actualObject2.length == 0); |
| |
| actualObject = gson.fromJson("[ ]", int[].class); |
| assertTrue(actualObject.length == 0); |
| } |
| |
| public void testNullsInArraySerialization() { |
| String[] array = {"foo", null, "bar"}; |
| String expected = "[\"foo\",null,\"bar\"]"; |
| String json = gson.toJson(array); |
| assertEquals(expected, json); |
| } |
| |
| public void testNullsInArrayDeserialization() { |
| String json = "[\"foo\",null,\"bar\"]"; |
| String[] expected = {"foo", null, "bar"}; |
| String[] target = gson.fromJson(json, expected.getClass()); |
| for (int i = 0; i < expected.length; ++i) { |
| assertEquals(expected[i], target[i]); |
| } |
| } |
| |
| public void testSingleNullInArraySerialization() { |
| BagOfPrimitives[] array = new BagOfPrimitives[1]; |
| array[0] = null; |
| String json = gson.toJson(array); |
| assertEquals("[null]", json); |
| } |
| |
| public void testSingleNullInArrayDeserialization() { |
| BagOfPrimitives[] array = gson.fromJson("[null]", BagOfPrimitives[].class); |
| assertNull(array[0]); |
| } |
| |
| public void testNullsInArrayWithSerializeNullPropertySetSerialization() { |
| gson = new GsonBuilder().serializeNulls().create(); |
| String[] array = {"foo", null, "bar"}; |
| String expected = "[\"foo\",null,\"bar\"]"; |
| String json = gson.toJson(array); |
| assertEquals(expected, json); |
| } |
| |
| public void testArrayOfStringsSerialization() { |
| String[] target = {"Hello", "World"}; |
| assertEquals("[\"Hello\",\"World\"]", gson.toJson(target)); |
| } |
| |
| public void testArrayOfStringsDeserialization() { |
| String json = "[\"Hello\",\"World\"]"; |
| String[] target = gson.fromJson(json, String[].class); |
| assertEquals("Hello", target[0]); |
| assertEquals("World", target[1]); |
| } |
| |
| public void testSingleStringArraySerialization() throws Exception { |
| String[] s = { "hello" }; |
| String output = gson.toJson(s); |
| assertEquals("[\"hello\"]", output); |
| } |
| |
| public void testSingleStringArrayDeserialization() throws Exception { |
| String json = "[\"hello\"]"; |
| String[] arrayType = gson.fromJson(json, String[].class); |
| assertEquals(1, arrayType.length); |
| assertEquals("hello", arrayType[0]); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public void testArrayOfCollectionSerialization() throws Exception { |
| StringBuilder sb = new StringBuilder("["); |
| int arraySize = 3; |
| |
| Type typeToSerialize = new TypeToken<Collection<Integer>[]>() {}.getType(); |
| Collection<Integer>[] arrayOfCollection = new ArrayList[arraySize]; |
| for (int i = 0; i < arraySize; ++i) { |
| int startValue = (3 * i) + 1; |
| sb.append('[').append(startValue).append(',').append(startValue + 1).append(']'); |
| ArrayList<Integer> tmpList = new ArrayList<>(); |
| tmpList.add(startValue); |
| tmpList.add(startValue + 1); |
| arrayOfCollection[i] = tmpList; |
| |
| if (i < arraySize - 1) { |
| sb.append(','); |
| } |
| } |
| sb.append(']'); |
| |
| String json = gson.toJson(arrayOfCollection, typeToSerialize); |
| assertEquals(sb.toString(), json); |
| } |
| |
| public void testArrayOfCollectionDeserialization() throws Exception { |
| String json = "[[1,2],[3,4]]"; |
| Type type = new TypeToken<Collection<Integer>[]>() {}.getType(); |
| Collection<Integer>[] target = gson.fromJson(json, type); |
| |
| assertEquals(2, target.length); |
| assertArrayEquals(new Integer[] { 1, 2 }, target[0].toArray(new Integer[0])); |
| assertArrayEquals(new Integer[] { 3, 4 }, target[1].toArray(new Integer[0])); |
| } |
| |
| public void testArrayOfPrimitivesAsObjectsSerialization() throws Exception { |
| Object[] objs = new Object[] {1, "abc", 0.3f, 5L}; |
| String json = gson.toJson(objs); |
| assertTrue(json.contains("abc")); |
| assertTrue(json.contains("0.3")); |
| assertTrue(json.contains("5")); |
| } |
| |
| public void testArrayOfPrimitivesAsObjectsDeserialization() throws Exception { |
| String json = "[1,'abc',0.3,1.1,5]"; |
| Object[] objs = gson.fromJson(json, Object[].class); |
| assertEquals(1, ((Number)objs[0]).intValue()); |
| assertEquals("abc", objs[1]); |
| assertEquals(0.3, ((Number)objs[2]).doubleValue()); |
| assertEquals(new BigDecimal("1.1"), new BigDecimal(objs[3].toString())); |
| assertEquals(5, ((Number)objs[4]).shortValue()); |
| } |
| |
| public void testObjectArrayWithNonPrimitivesSerialization() throws Exception { |
| ClassWithObjects classWithObjects = new ClassWithObjects(); |
| BagOfPrimitives bagOfPrimitives = new BagOfPrimitives(); |
| String classWithObjectsJson = gson.toJson(classWithObjects); |
| String bagOfPrimitivesJson = gson.toJson(bagOfPrimitives); |
| |
| Object[] objects = new Object[] { classWithObjects, bagOfPrimitives }; |
| String json = gson.toJson(objects); |
| |
| assertTrue(json.contains(classWithObjectsJson)); |
| assertTrue(json.contains(bagOfPrimitivesJson)); |
| } |
| |
| public void testArrayOfNullSerialization() { |
| Object[] array = new Object[] {null}; |
| String json = gson.toJson(array); |
| assertEquals("[null]", json); |
| } |
| |
| public void testArrayOfNullDeserialization() { |
| String[] values = gson.fromJson("[null]", String[].class); |
| assertNull(values[0]); |
| } |
| |
| /** |
| * Regression tests for Issue 272 |
| */ |
| public void testMultidimenstionalArraysSerialization() { |
| String[][] items = new String[][]{ |
| {"3m Co", "71.72", "0.02", "0.03", "4/2 12:00am", "Manufacturing"}, |
| {"Alcoa Inc", "29.01", "0.42", "1.47", "4/1 12:00am", "Manufacturing"} |
| }; |
| String json = gson.toJson(items); |
| assertTrue(json.contains("[[\"3m Co")); |
| assertTrue(json.contains("Manufacturing\"]]")); |
| } |
| |
| public void testMultiDimenstionalObjectArraysSerialization() { |
| Object[][] array = new Object[][] { new Object[] { 1, 2 } }; |
| assertEquals("[[1,2]]", gson.toJson(array)); |
| } |
| |
| /** |
| * Regression test for Issue 205 |
| */ |
| public void testMixingTypesInObjectArraySerialization() { |
| Object[] array = new Object[] { 1, 2, new Object[] { "one", "two", 3 } }; |
| assertEquals("[1,2,[\"one\",\"two\",3]]", gson.toJson(array)); |
| } |
| |
| /** |
| * Regression tests for Issue 272 |
| */ |
| public void testMultidimenstionalArraysDeserialization() { |
| String json = "[['3m Co','71.72','0.02','0.03','4/2 12:00am','Manufacturing']," |
| + "['Alcoa Inc','29.01','0.42','1.47','4/1 12:00am','Manufacturing']]"; |
| String[][] items = gson.fromJson(json, String[][].class); |
| assertEquals("3m Co", items[0][0]); |
| assertEquals("Manufacturing", items[1][5]); |
| } |
| |
| /** http://code.google.com/p/google-gson/issues/detail?id=342 */ |
| public void testArrayElementsAreArrays() { |
| Object[] stringArrays = { |
| new String[] {"test1", "test2"}, |
| new String[] {"test3", "test4"} |
| }; |
| assertEquals("[[\"test1\",\"test2\"],[\"test3\",\"test4\"]]", |
| new Gson().toJson(stringArrays)); |
| } |
| } |