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
|
package com.fasterxml.jackson.databind.deser.merge;
import org.junit.Assert;
import com.fasterxml.jackson.annotation.JsonMerge;
import com.fasterxml.jackson.annotation.OptBoolean;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
public class ArrayMergeTest extends BaseMapTest
{
static class MergedX<T>
{
@JsonMerge(OptBoolean.TRUE)
public T value;
public MergedX(T v) { value = v; }
protected MergedX() { }
}
/*
/********************************************************
/* Test methods
/********************************************************
*/
private final ObjectMapper MAPPER = jsonMapperBuilder()
// 26-Oct-2016, tatu: Make sure we'll report merge problems by default
.disable(MapperFeature.IGNORE_MERGE_FOR_UNMERGEABLE)
.build();
public void testObjectArrayMerging() throws Exception
{
MergedX<Object[]> input = new MergedX<Object[]>(new Object[] {
"foo"
});
final JavaType type = MAPPER.getTypeFactory().constructType(new TypeReference<MergedX<Object[]>>() {});
MergedX<Object[]> result = MAPPER.readerFor(type)
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':['bar']}"));
assertSame(input, result);
assertEquals(2, result.value.length);
assertEquals("foo", result.value[0]);
assertEquals("bar", result.value[1]);
// and with one trick
result = MAPPER.readerFor(type)
.with(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':'zap'}"));
assertSame(input, result);
assertEquals(3, result.value.length);
assertEquals("foo", result.value[0]);
assertEquals("bar", result.value[1]);
assertEquals("zap", result.value[2]);
}
public void testStringArrayMerging() throws Exception
{
MergedX<String[]> input = new MergedX<String[]>(new String[] { "foo" });
MergedX<String[]> result = MAPPER
.readerFor(new TypeReference<MergedX<String[]>>() {})
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':['bar']}"));
assertSame(input, result);
assertEquals(2, result.value.length);
assertEquals("foo", result.value[0]);
assertEquals("bar", result.value[1]);
}
public void testBooleanArrayMerging() throws Exception
{
MergedX<boolean[]> input = new MergedX<boolean[]>(new boolean[] { true, false });
MergedX<boolean[]> result = MAPPER
.readerFor(new TypeReference<MergedX<boolean[]>>() {})
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':[true]}"));
assertSame(input, result);
assertEquals(3, result.value.length);
Assert.assertArrayEquals(new boolean[] { true, false, true }, result.value);
}
public void testByteArrayMerging() throws Exception
{
MergedX<byte[]> input = new MergedX<byte[]>(new byte[] { 1, 2 });
MergedX<byte[]> result = MAPPER
.readerFor(new TypeReference<MergedX<byte[]>>() {})
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':[4, 6.0, null]}"));
assertSame(input, result);
assertEquals(5, result.value.length);
Assert.assertArrayEquals(new byte[] { 1, 2, 4, 6, 0 }, result.value);
}
public void testShortArrayMerging() throws Exception
{
MergedX<short[]> input = new MergedX<short[]>(new short[] { 1, 2 });
MergedX<short[]> result = MAPPER
.readerFor(new TypeReference<MergedX<short[]>>() {})
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':[4, 6]}"));
assertSame(input, result);
assertEquals(4, result.value.length);
Assert.assertArrayEquals(new short[] { 1, 2, 4, 6 }, result.value);
}
public void testCharArrayMerging() throws Exception
{
MergedX<char[]> input = new MergedX<char[]>(new char[] { 'a', 'b' });
MergedX<char[]> result = MAPPER
.readerFor(new TypeReference<MergedX<char[]>>() {})
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':['c']}"));
assertSame(input, result);
Assert.assertArrayEquals(new char[] { 'a', 'b', 'c' }, result.value);
// also some variation
input = new MergedX<char[]>(new char[] { });
result = MAPPER
.readerFor(new TypeReference<MergedX<char[]>>() {})
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':['c']}"));
assertSame(input, result);
Assert.assertArrayEquals(new char[] { 'c' }, result.value);
}
public void testIntArrayMerging() throws Exception
{
MergedX<int[]> input = new MergedX<int[]>(new int[] { 1, 2 });
MergedX<int[]> result = MAPPER
.readerFor(new TypeReference<MergedX<int[]>>() {})
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':[4, 6]}"));
assertSame(input, result);
assertEquals(4, result.value.length);
Assert.assertArrayEquals(new int[] { 1, 2, 4, 6 }, result.value);
// also some variation
input = new MergedX<int[]>(new int[] { 3, 4, 6 });
result = MAPPER
.readerFor(new TypeReference<MergedX<int[]>>() {})
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':[ ]}"));
assertSame(input, result);
Assert.assertArrayEquals(new int[] { 3, 4, 6 }, result.value);
}
public void testLongArrayMerging() throws Exception
{
MergedX<long[]> input = new MergedX<long[]>(new long[] { 1, 2 });
MergedX<long[]> result = MAPPER
.readerFor(new TypeReference<MergedX<long[]>>() {})
.withValueToUpdate(input)
.readValue(aposToQuotes("{'value':[4, 6]}"));
assertSame(input, result);
assertEquals(4, result.value.length);
Assert.assertArrayEquals(new long[] { 1, 2, 4, 6 }, result.value);
}
}
|
