1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
package com.fasterxml.jackson.databind.jsontype;
import java.util.*;
import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import static com.fasterxml.jackson.annotation.JsonTypeInfo.*;
public class TestTypedSerialization
extends BaseMapTest
{
/*
/**********************************************************
/* Helper types
/**********************************************************
*/
/**
* Polymorphic base class
*/
@JsonTypeInfo(use=Id.CLASS, include=As.PROPERTY)
static abstract class Animal {
public String name;
protected Animal(String n) { name = n; }
}
@JsonTypeName("doggie")
static class Dog extends Animal
{
public int boneCount;
private Dog() { super(null); }
public Dog(String name, int b) {
super(name);
boneCount = b;
}
}
@JsonTypeName("kitty")
static class Cat extends Animal
{
public String furColor;
private Cat() { super(null); }
public Cat(String name, String c) {
super(name);
furColor = c;
}
}
public class AnimalWrapper {
public Animal animal;
public AnimalWrapper(Animal a) { animal = a; }
}
@JsonTypeInfo(use=Id.MINIMAL_CLASS, include=As.WRAPPER_OBJECT)
interface TypeWithWrapper { }
@JsonTypeInfo(use=Id.CLASS, include=As.WRAPPER_ARRAY)
interface TypeWithArray { }
@JsonTypeInfo(use=Id.NAME)
@JsonTypeName("empty")
public class Empty { }
@JsonTypeInfo(include=As.PROPERTY, use=Id.CLASS)
public class Super {}
public class A extends Super {}
public class B extends Super {}
/*
/**********************************************************
/* Unit tests
/**********************************************************
*/
private final ObjectMapper MAPPER = new ObjectMapper();
/**
* First things first, let's ensure we can serialize using
* class name, written as main-level property name
*/
public void testSimpleClassAsProperty() throws Exception
{
Map<String,Object> result = writeAndMap(MAPPER, new Cat("Beelzebub", "tabby"));
assertEquals(3, result.size());
assertEquals("Beelzebub", result.get("name"));
assertEquals("tabby", result.get("furColor"));
// should we try customized class name?
String classProp = Id.CLASS.getDefaultPropertyName();
assertEquals(Cat.class.getName(), result.get(classProp));
}
/**
* Test inclusion using wrapper style
*/
public void testTypeAsWrapper() throws Exception
{
ObjectMapper m = new ObjectMapper();
m.addMixIn(Animal.class, TypeWithWrapper.class);
Map<String,Object> result = writeAndMap(m, new Cat("Venla", "black"));
// should get a wrapper; keyed by minimal class name ("Cat" here)
assertEquals(1, result.size());
// minimal class name is prefixed by dot, and for inner classes it's bit longer
Map<?,?> cat = (Map<?,?>) result.get(".TestTypedSerialization$Cat");
assertNotNull(cat);
assertEquals(2, cat.size());
assertEquals("Venla", cat.get("name"));
assertEquals("black", cat.get("furColor"));
}
/**
* Test inclusion using 2-element array
*/
public void testTypeAsArray() throws Exception
{
ObjectMapper m = new ObjectMapper();
m.addMixIn(Animal.class, TypeWithArray.class);
// hmmh. Not good idea to rely on exact output, order may change. But...
Map<String,Object> result = writeAndMap(m, new AnimalWrapper(new Dog("Amadeus", 7)));
// First level, wrapper
assertEquals(1, result.size());
List<?> l = (List<?>) result.get("animal");
assertNotNull(l);
assertEquals(2, l.size());
assertEquals(Dog.class.getName(), l.get(0));
Map<?,?> doggie = (Map<?,?>) l.get(1);
assertNotNull(doggie);
assertEquals(2, doggie.size());
assertEquals("Amadeus", doggie.get("name"));
assertEquals(Integer.valueOf(7), doggie.get("boneCount"));
}
/* !!! 30-Jan-2010, tatus: I am not completely sure below works as it should
* Problem is, context of "untyped" map should prevent type information
* being added to Animal entries, because Object.class has no type.
* If type information is included, it will not be useful for deserialization,
* since static type does not carry through (unlike in serialization).
*
* But it is not quite clear how type information should be pushed through
* array types...
*/
@SuppressWarnings("unchecked")
public void testInArray() throws Exception
{
// ensure we'll use mapper with default configs
ObjectMapper m = new ObjectMapper();
// ... so this should NOT be needed...
m.deactivateDefaultTyping();
Animal[] animals = new Animal[] { new Cat("Miuku", "white"), new Dog("Murre", 9) };
Map<String,Object> map = new HashMap<String,Object>();
map.put("a", animals);
String json = m.writeValueAsString(map);
Map<String,Object> result = m.readValue(json, Map.class);
assertEquals(1, result.size());
Object ob = result.get("a");
if (!(ob instanceof List<?>)) {
// 03-Feb-2010, tatu: Weird; seems to fail sometimes...
fail("Did not map to entry with 'a' as List (but as "+ob.getClass().getName()+"): JSON == '"+json+"'");
}
List<?> l = (List<?>)ob;
assertNotNull(l);
assertEquals(2, l.size());
Map<?,?> a1 = (Map<?,?>) l.get(0);
assertEquals(3, a1.size());
String classProp = Id.CLASS.getDefaultPropertyName();
assertEquals(Cat.class.getName(), a1.get(classProp));
Map<?,?> a2 = (Map<?,?>) l.get(1);
assertEquals(3, a2.size());
assertEquals(Dog.class.getName(), a2.get(classProp));
}
/**
* Simple unit test to verify that serializing "empty" beans is ok
*/
public void testEmptyBean() throws Exception
{
ObjectMapper m = new ObjectMapper();
m.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
assertEquals("{\"@type\":\"empty\"}", m.writeValueAsString(new Empty()));
}
/**
* Unit test for [JACKSON-543]
*/
public void testTypedMaps() throws Exception
{
ObjectMapper mapper = new ObjectMapper();
Map<Long, Collection<Super>> map = new HashMap<Long, Collection<Super>>();
List<Super> list = new ArrayList<Super>();
list.add(new A());
map.put(1L, list);
String json = mapper.writerFor(new TypeReference<Map<Long, Collection<Super>>>() {}).writeValueAsString(map);
assertTrue("JSON does not contain '@class': "+json, json.contains("@class"));
}
}
|
