278 lines
9.0 KiB
Java
278 lines
9.0 KiB
Java
/*
|
|
* Copyright (C) 2009 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.JsonArray;
|
|
import com.google.gson.JsonElement;
|
|
import com.google.gson.JsonObject;
|
|
import com.google.gson.common.TestTypes.BagOfPrimitives;
|
|
import com.google.gson.common.TestTypes.Base;
|
|
import com.google.gson.common.TestTypes.ClassWithBaseArrayField;
|
|
import com.google.gson.common.TestTypes.ClassWithBaseCollectionField;
|
|
import com.google.gson.common.TestTypes.ClassWithBaseField;
|
|
import com.google.gson.common.TestTypes.Nested;
|
|
import com.google.gson.common.TestTypes.Sub;
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Queue;
|
|
import java.util.Set;
|
|
import java.util.SortedSet;
|
|
import java.util.TreeSet;
|
|
|
|
/**
|
|
* Functional tests for Json serialization and deserialization of classes with
|
|
* inheritance hierarchies.
|
|
*
|
|
* @author Inderjeet Singh
|
|
* @author Joel Leitch
|
|
*/
|
|
public class InheritanceTest extends TestCase {
|
|
private Gson gson;
|
|
|
|
@Override
|
|
protected void setUp() throws Exception {
|
|
super.setUp();
|
|
gson = new Gson();
|
|
}
|
|
|
|
public void testSubClassSerialization() throws Exception {
|
|
SubTypeOfNested target = new SubTypeOfNested(new BagOfPrimitives(10, 20, false, "stringValue"),
|
|
new BagOfPrimitives(30, 40, true, "stringValue"));
|
|
assertEquals(target.getExpectedJson(), gson.toJson(target));
|
|
}
|
|
|
|
public void testSubClassDeserialization() throws Exception {
|
|
String json = "{\"value\":5,\"primitive1\":{\"longValue\":10,\"intValue\":20,"
|
|
+ "\"booleanValue\":false,\"stringValue\":\"stringValue\"},\"primitive2\":"
|
|
+ "{\"longValue\":30,\"intValue\":40,\"booleanValue\":true,"
|
|
+ "\"stringValue\":\"stringValue\"}}";
|
|
SubTypeOfNested target = gson.fromJson(json, SubTypeOfNested.class);
|
|
assertEquals(json, target.getExpectedJson());
|
|
}
|
|
|
|
public void testClassWithBaseFieldSerialization() {
|
|
ClassWithBaseField sub = new ClassWithBaseField(new Sub());
|
|
JsonObject json = (JsonObject) gson.toJsonTree(sub);
|
|
JsonElement base = json.getAsJsonObject().get(ClassWithBaseField.FIELD_KEY);
|
|
assertEquals(Sub.SUB_NAME, base.getAsJsonObject().get(Sub.SUB_FIELD_KEY).getAsString());
|
|
}
|
|
|
|
public void testClassWithBaseArrayFieldSerialization() {
|
|
Base[] baseClasses = new Base[]{ new Sub(), new Sub()};
|
|
ClassWithBaseArrayField sub = new ClassWithBaseArrayField(baseClasses);
|
|
JsonObject json = gson.toJsonTree(sub).getAsJsonObject();
|
|
JsonArray bases = json.get(ClassWithBaseArrayField.FIELD_KEY).getAsJsonArray();
|
|
for (JsonElement element : bases) {
|
|
assertEquals(Sub.SUB_NAME, element.getAsJsonObject().get(Sub.SUB_FIELD_KEY).getAsString());
|
|
}
|
|
}
|
|
|
|
public void testClassWithBaseCollectionFieldSerialization() {
|
|
Collection<Base> baseClasses = new ArrayList<>();
|
|
baseClasses.add(new Sub());
|
|
baseClasses.add(new Sub());
|
|
ClassWithBaseCollectionField sub = new ClassWithBaseCollectionField(baseClasses);
|
|
JsonObject json = gson.toJsonTree(sub).getAsJsonObject();
|
|
JsonArray bases = json.get(ClassWithBaseArrayField.FIELD_KEY).getAsJsonArray();
|
|
for (JsonElement element : bases) {
|
|
assertEquals(Sub.SUB_NAME, element.getAsJsonObject().get(Sub.SUB_FIELD_KEY).getAsString());
|
|
}
|
|
}
|
|
|
|
public void testBaseSerializedAsSub() {
|
|
Base base = new Sub();
|
|
JsonObject json = gson.toJsonTree(base).getAsJsonObject();
|
|
assertEquals(Sub.SUB_NAME, json.get(Sub.SUB_FIELD_KEY).getAsString());
|
|
}
|
|
|
|
public void testBaseSerializedAsSubForToJsonMethod() {
|
|
Base base = new Sub();
|
|
String json = gson.toJson(base);
|
|
assertTrue(json.contains(Sub.SUB_NAME));
|
|
}
|
|
|
|
public void testBaseSerializedAsBaseWhenSpecifiedWithExplicitType() {
|
|
Base base = new Sub();
|
|
JsonObject json = gson.toJsonTree(base, Base.class).getAsJsonObject();
|
|
assertEquals(Base.BASE_NAME, json.get(Base.BASE_FIELD_KEY).getAsString());
|
|
assertNull(json.get(Sub.SUB_FIELD_KEY));
|
|
}
|
|
|
|
public void testBaseSerializedAsBaseWhenSpecifiedWithExplicitTypeForToJsonMethod() {
|
|
Base base = new Sub();
|
|
String json = gson.toJson(base, Base.class);
|
|
assertTrue(json.contains(Base.BASE_NAME));
|
|
assertFalse(json.contains(Sub.SUB_FIELD_KEY));
|
|
}
|
|
|
|
public void testBaseSerializedAsSubWhenSpecifiedWithExplicitType() {
|
|
Base base = new Sub();
|
|
JsonObject json = gson.toJsonTree(base, Sub.class).getAsJsonObject();
|
|
assertEquals(Sub.SUB_NAME, json.get(Sub.SUB_FIELD_KEY).getAsString());
|
|
}
|
|
|
|
public void testBaseSerializedAsSubWhenSpecifiedWithExplicitTypeForToJsonMethod() {
|
|
Base base = new Sub();
|
|
String json = gson.toJson(base, Sub.class);
|
|
assertTrue(json.contains(Sub.SUB_NAME));
|
|
}
|
|
|
|
private static class SubTypeOfNested extends Nested {
|
|
private final long value = 5;
|
|
|
|
public SubTypeOfNested(BagOfPrimitives primitive1, BagOfPrimitives primitive2) {
|
|
super(primitive1, primitive2);
|
|
}
|
|
|
|
@Override
|
|
public void appendFields(StringBuilder sb) {
|
|
sb.append("\"value\":").append(value).append(",");
|
|
super.appendFields(sb);
|
|
}
|
|
}
|
|
|
|
public void testSubInterfacesOfCollectionSerialization() throws Exception {
|
|
List<Integer> list = new LinkedList<>();
|
|
list.add(0);
|
|
list.add(1);
|
|
list.add(2);
|
|
list.add(3);
|
|
Queue<Long> queue = new LinkedList<>();
|
|
queue.add(0L);
|
|
queue.add(1L);
|
|
queue.add(2L);
|
|
queue.add(3L);
|
|
Set<Float> set = new TreeSet<>();
|
|
set.add(0.1F);
|
|
set.add(0.2F);
|
|
set.add(0.3F);
|
|
set.add(0.4F);
|
|
SortedSet<Character> sortedSet = new TreeSet<>();
|
|
sortedSet.add('a');
|
|
sortedSet.add('b');
|
|
sortedSet.add('c');
|
|
sortedSet.add('d');
|
|
ClassWithSubInterfacesOfCollection target =
|
|
new ClassWithSubInterfacesOfCollection(list, queue, set, sortedSet);
|
|
assertEquals(target.getExpectedJson(), gson.toJson(target));
|
|
}
|
|
|
|
public void testSubInterfacesOfCollectionDeserialization() throws Exception {
|
|
String json = "{\"list\":[0,1,2,3],\"queue\":[0,1,2,3],\"set\":[0.1,0.2,0.3,0.4],"
|
|
+ "\"sortedSet\":[\"a\",\"b\",\"c\",\"d\"]"
|
|
+ "}";
|
|
ClassWithSubInterfacesOfCollection target =
|
|
gson.fromJson(json, ClassWithSubInterfacesOfCollection.class);
|
|
assertTrue(target.listContains(0, 1, 2, 3));
|
|
assertTrue(target.queueContains(0, 1, 2, 3));
|
|
assertTrue(target.setContains(0.1F, 0.2F, 0.3F, 0.4F));
|
|
assertTrue(target.sortedSetContains('a', 'b', 'c', 'd'));
|
|
}
|
|
|
|
private static class ClassWithSubInterfacesOfCollection {
|
|
private List<Integer> list;
|
|
private Queue<Long> queue;
|
|
private Set<Float> set;
|
|
private SortedSet<Character> sortedSet;
|
|
|
|
public ClassWithSubInterfacesOfCollection(List<Integer> list, Queue<Long> queue, Set<Float> set,
|
|
SortedSet<Character> sortedSet) {
|
|
this.list = list;
|
|
this.queue = queue;
|
|
this.set = set;
|
|
this.sortedSet = sortedSet;
|
|
}
|
|
|
|
boolean listContains(int... values) {
|
|
for (int value : values) {
|
|
if (!list.contains(value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
boolean queueContains(long... values) {
|
|
for (long value : values) {
|
|
if (!queue.contains(value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
boolean setContains(float... values) {
|
|
for (float value : values) {
|
|
if (!set.contains(value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
boolean sortedSetContains(char... values) {
|
|
for (char value : values) {
|
|
if (!sortedSet.contains(value)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public String getExpectedJson() {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("{");
|
|
sb.append("\"list\":");
|
|
append(sb, list).append(",");
|
|
sb.append("\"queue\":");
|
|
append(sb, queue).append(",");
|
|
sb.append("\"set\":");
|
|
append(sb, set).append(",");
|
|
sb.append("\"sortedSet\":");
|
|
append(sb, sortedSet);
|
|
sb.append("}");
|
|
return sb.toString();
|
|
}
|
|
|
|
private StringBuilder append(StringBuilder sb, Collection<?> c) {
|
|
sb.append("[");
|
|
boolean first = true;
|
|
for (Object o : c) {
|
|
if (!first) {
|
|
sb.append(",");
|
|
} else {
|
|
first = false;
|
|
}
|
|
if (o instanceof String || o instanceof Character) {
|
|
sb.append('\"');
|
|
}
|
|
sb.append(o.toString());
|
|
if (o instanceof String || o instanceof Character) {
|
|
sb.append('\"');
|
|
}
|
|
}
|
|
sb.append("]");
|
|
return sb;
|
|
}
|
|
}
|
|
}
|