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
|
package com.fasterxml.jackson.databind.jsontype;
import java.util.*;
import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
import com.fasterxml.jackson.annotation.JsonTypeInfo.Id;
import com.fasterxml.jackson.annotation.JsonSubTypes.Type;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsontype.impl.StdSubtypeResolver;
import com.fasterxml.jackson.databind.type.TypeFactory;
/**
* Separate tests for verifying that "type name" type id mechanism
* works.
*/
public class TestTypeNames extends BaseMapTest
{
@SuppressWarnings("serial")
static class AnimalMap extends LinkedHashMap<String,Animal> { }
@JsonTypeInfo(property = "type", include = JsonTypeInfo.As.PROPERTY, use = JsonTypeInfo.Id.NAME)
@JsonSubTypes({
@JsonSubTypes.Type(value = A1616.class,name = "A"),
@JsonSubTypes.Type(value = B1616.class)
})
static abstract class Base1616 { }
static class A1616 extends Base1616 { }
@JsonTypeName("B")
static class B1616 extends Base1616 { }
/*
/**********************************************************
/* Unit tests
/**********************************************************
*/
private final ObjectMapper MAPPER = objectMapper();
public void testBaseTypeId1616() throws Exception
{
ObjectMapper mapper = new ObjectMapper();
Collection<NamedType> subtypes = new StdSubtypeResolver().collectAndResolveSubtypesByTypeId(
mapper.getDeserializationConfig(),
// note: `null` is fine here as `AnnotatedMember`:
null,
mapper.constructType(Base1616.class));
assertEquals(2, subtypes.size());
Set<String> ok = new HashSet<>(Arrays.asList("A", "B"));
for (NamedType type : subtypes) {
String id = type.getName();
if (!ok.contains(id)) {
fail("Unexpected id '"+id+"' (mapping to: "+type.getType()+"), should be one of: "+ok);
}
}
}
public void testSerialization() throws Exception
{
// Note: need to use wrapper array just so that we can define
// static type on serialization. If we had root static types,
// could use those; but at the moment root type is dynamic
assertEquals("[{\"doggy\":{\"name\":\"Spot\",\"ageInYears\":3}}]",
MAPPER.writeValueAsString(new Animal[] { new Dog("Spot", 3) }));
assertEquals("[{\"MaineCoon\":{\"name\":\"Belzebub\",\"purrs\":true}}]",
MAPPER.writeValueAsString(new Animal[] { new MaineCoon("Belzebub", true)}));
}
public void testRoundTrip() throws Exception
{
Animal[] input = new Animal[] {
new Dog("Odie", 7),
null,
new MaineCoon("Piru", false),
new Persian("Khomeini", true)
};
String json = MAPPER.writeValueAsString(input);
List<Animal> output = MAPPER.readValue(json,
TypeFactory.defaultInstance().constructCollectionType(ArrayList.class, Animal.class));
assertEquals(input.length, output.size());
for (int i = 0, len = input.length; i < len; ++i) {
assertEquals("Entry #"+i+" differs, input = '"+json+"'",
input[i], output.get(i));
}
}
public void testRoundTripMap() throws Exception
{
AnimalMap input = new AnimalMap();
input.put("venla", new MaineCoon("Venla", true));
input.put("ama", new Dog("Amadeus", 13));
String json = MAPPER.writeValueAsString(input);
AnimalMap output = MAPPER.readValue(json, AnimalMap.class);
assertNotNull(output);
assertEquals(AnimalMap.class, output.getClass());
assertEquals(input.size(), output.size());
// for some reason, straight comparison won't work...
for (String name : input.keySet()) {
Animal in = input.get(name);
Animal out = output.get(name);
if (!in.equals(out)) {
fail("Animal in input was ["+in+"]; output not matching: ["+out+"]");
}
}
}
}
/*
/**********************************************************
/* Helper types
/**********************************************************
*/
@JsonTypeInfo(use=Id.NAME, include=As.WRAPPER_OBJECT)
@JsonSubTypes({
@Type(value=Dog.class, name="doggy"),
@Type(Cat.class) /* defaults to "TestTypedNames$Cat" then */
})
class Animal
{
public String name;
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (o == null) return false;
if (o.getClass() != getClass()) return false;
return name.equals(((Animal) o).name);
}
@Override
public String toString() {
return getClass().toString() + "('"+name+"')";
}
}
class Dog extends Animal
{
public int ageInYears;
public Dog() { }
public Dog(String n, int y) {
name = n;
ageInYears = y;
}
@Override
public boolean equals(Object o) {
return super.equals(o)
&& ((Dog) o).ageInYears == ageInYears;
}
}
@JsonSubTypes({
@Type(MaineCoon.class),
@Type(Persian.class)
})
abstract class Cat extends Animal {
public boolean purrs;
public Cat() { }
public Cat(String n, boolean p) {
name = n;
purrs = p;
}
@Override
public boolean equals(Object o) {
return super.equals(o) && ((Cat) o).purrs == purrs;
}
@Override
public String toString() {
return super.toString()+"(purrs: "+purrs+")";
}
}
/* uses default name ("MaineCoon") since there's no @JsonTypeName,
* nor did supertype specify name
*/
class MaineCoon extends Cat {
public MaineCoon() { super(); }
public MaineCoon(String n, boolean p) {
super(n, p);
}
}
@JsonTypeName("persialaisKissa")
class Persian extends Cat {
public Persian() { super(); }
public Persian(String n, boolean p) {
super(n, p);
}
}
|
