Mass conversion to static methods
[netconf.git] / restconf / sal-rest-connector / src / test / java / org / opendaylight / controller / sal / restconf / impl / cnsn / to / json / test / CnSnToJsonBasicDataTypesTest.java
1 /*
2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.controller.sal.restconf.impl.cnsn.to.json.test;
9
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertFalse;
12 import static org.junit.Assert.assertNotNull;
13 import static org.junit.Assert.assertNull;
14 import static org.junit.Assert.fail;
15
16 import com.google.common.collect.Maps;
17 import com.google.gson.stream.JsonReader;
18 import com.google.gson.stream.JsonToken;
19 import java.io.FileNotFoundException;
20 import java.io.IOException;
21 import java.io.StringReader;
22 import java.util.Map;
23 import org.junit.BeforeClass;
24 import org.opendaylight.controller.sal.restconf.impl.test.YangAndXmlAndDataSchemaLoader;
25 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
26
27 public class CnSnToJsonBasicDataTypesTest extends YangAndXmlAndDataSchemaLoader {
28
29     static abstract class LeafVerifier {
30
31         Object expectedValue;
32         JsonToken expectedToken;
33
34         LeafVerifier(final Object expectedValue, final JsonToken expectedToken) {
35             this.expectedValue = expectedValue;
36             this.expectedToken = expectedToken;
37         }
38
39         abstract Object getActualValue(JsonReader reader) throws IOException;
40
41         void verify(final JsonReader reader, final String keyName) throws IOException {
42             assertEquals("Json value for key " + keyName, this.expectedValue, getActualValue(reader));
43         }
44
45         JsonToken expectedTokenType() {
46             return this.expectedToken;
47         }
48     }
49
50     static class BooleanVerifier extends LeafVerifier {
51
52         public BooleanVerifier(final boolean expected) {
53             super(expected, JsonToken.BOOLEAN);
54         }
55
56         @Override
57         Object getActualValue(final JsonReader reader) throws IOException {
58             return reader.nextBoolean();
59         }
60     }
61
62     static class NumberVerifier extends LeafVerifier {
63
64         public NumberVerifier(final Number expected) {
65             super(expected, JsonToken.NUMBER);
66         }
67
68         @Override
69         Object getActualValue(final JsonReader reader) throws IOException {
70             if (this.expectedValue instanceof Double) {
71                 return reader.nextDouble();
72             } else if (this.expectedValue instanceof Long) {
73                 return reader.nextLong();
74             } else if (this.expectedValue instanceof Integer) {
75                 return reader.nextInt();
76             }
77
78             return null;
79         }
80     }
81
82     static class StringVerifier extends LeafVerifier {
83
84         StringVerifier(final String expected) {
85             super(expected, JsonToken.STRING);
86         }
87
88         @Override
89         Object getActualValue(final JsonReader reader) throws IOException {
90             return reader.nextString();
91         }
92     }
93
94     static class EmptyVerifier extends LeafVerifier {
95
96         EmptyVerifier() {
97             super(null, null);
98         }
99
100         @Override
101         Object getActualValue(final JsonReader reader) throws IOException {
102             reader.beginArray();
103             reader.nextNull();
104             reader.endArray();
105             return null;
106         }
107
108     }
109
110     static class ComplexAnyXmlVerifier extends LeafVerifier {
111
112         ComplexAnyXmlVerifier() {
113             super(null, JsonToken.BEGIN_OBJECT);
114         }
115
116         @Override
117         void verify(final JsonReader reader, final String keyName) throws IOException {
118
119             reader.beginObject();
120             final String innerKey = reader.nextName();
121             assertEquals("Json reader child key for " + keyName, "data", innerKey);
122             assertEquals("Json token type for key " + innerKey, JsonToken.BEGIN_OBJECT, reader.peek());
123
124             reader.beginObject();
125             verifyLeaf(reader, innerKey, "leaf1", "leaf1-value");
126             verifyLeaf(reader, innerKey, "leaf2", "leaf2-value");
127
128             String nextName = reader.nextName();
129             assertEquals("Json reader child key for " + innerKey, "leaf-list", nextName);
130             reader.beginArray();
131             assertEquals("Json value for key " + nextName, "leaf-list-value1", reader.nextString());
132             assertEquals("Json value for key " + nextName, "leaf-list-value2", reader.nextString());
133             reader.endArray();
134
135             nextName = reader.nextName();
136             assertEquals("Json reader child key for " + innerKey, "list", nextName);
137             reader.beginArray();
138             verifyNestedLists(reader, 1);
139             verifyNestedLists(reader, 3);
140             reader.endArray();
141
142             reader.endObject();
143             reader.endObject();
144         }
145
146         void verifyNestedLists(final JsonReader reader, int leafNum) throws IOException {
147             reader.beginObject();
148
149             final String nextName = reader.nextName();
150             assertEquals("Json reader next name", "nested-list", nextName);
151
152             reader.beginArray();
153
154             reader.beginObject();
155             verifyLeaf(reader, "nested-list", "nested-leaf", "nested-value" + leafNum++);
156             reader.endObject();
157
158             reader.beginObject();
159             verifyLeaf(reader, "nested-list", "nested-leaf", "nested-value" + leafNum);
160             reader.endObject();
161
162             reader.endArray();
163             reader.endObject();
164         }
165
166         void verifyLeaf(final JsonReader reader, final String parent, final String name, final String value) throws IOException {
167             final String nextName = reader.nextName();
168             assertEquals("Json reader child key for " + parent, name, nextName);
169             assertEquals("Json token type for key " + parent, JsonToken.STRING, reader.peek());
170             assertEquals("Json value for key " + nextName, value, reader.nextString());
171         }
172
173         @Override
174         Object getActualValue(final JsonReader reader) throws IOException {
175             return null;
176         }
177     }
178
179     @BeforeClass
180     public static void initialize() throws FileNotFoundException, ReactorException {
181         dataLoad("/cnsn-to-json/simple-data-types");
182     }
183
184     private static void verifyJsonOutput(final String jsonOutput) {
185         final StringReader strReader = new StringReader(jsonOutput);
186         final JsonReader jReader = new JsonReader(strReader);
187
188         String exception = null;
189         try {
190             jsonReadCont(jReader);
191         } catch (final IOException e) {
192             exception = e.getMessage();
193         }
194
195         assertNull("Error during reading Json output: " + exception, exception);
196     }
197
198     private static void jsonReadCont(final JsonReader jReader) throws IOException {
199         jReader.beginObject();
200         assertNotNull("cont1 is missing.", jReader.hasNext());
201
202         // Cont dataFromJson = new Cont(jReader.nextName());
203         jReader.nextName();
204         jsonReadContElements(jReader);
205
206         assertFalse("cont shouldn't have other element.", jReader.hasNext());
207         jReader.endObject();
208         // return dataFromJson;
209     }
210
211     private static void jsonReadContElements(final JsonReader jReader) throws IOException {
212         jReader.beginObject();
213
214         final Map<String, LeafVerifier> expectedMap = Maps.newHashMap();
215         expectedMap.put("lfnint8Min", new NumberVerifier(Integer.valueOf(-128)));
216         expectedMap.put("lfnint8Max", new NumberVerifier(Integer.valueOf(127)));
217         expectedMap.put("lfnint16Min", new NumberVerifier(Integer.valueOf(-32768)));
218         expectedMap.put("lfnint16Max", new NumberVerifier(Integer.valueOf(32767)));
219         expectedMap.put("lfnint32Min", new NumberVerifier(Integer.valueOf(-2147483648)));
220         expectedMap.put("lfnint32Max", new NumberVerifier(Long.valueOf(2147483647)));
221         expectedMap.put("lfnint64Min", new NumberVerifier(Long.valueOf(-9223372036854775808L)));
222         expectedMap.put("lfnint64Max", new NumberVerifier(Long.valueOf(9223372036854775807L)));
223         expectedMap.put("lfnuint8Max", new NumberVerifier(Integer.valueOf(255)));
224         expectedMap.put("lfnuint16Max", new NumberVerifier(Integer.valueOf(65535)));
225         expectedMap.put("lfnuint32Max", new NumberVerifier(Long.valueOf(4294967295L)));
226         expectedMap.put("lfstr", new StringVerifier("lfstr"));
227         expectedMap.put("lfstr1", new StringVerifier(""));
228         expectedMap.put("lfbool1", new BooleanVerifier(true));
229         expectedMap.put("lfbool2", new BooleanVerifier(false));
230         expectedMap.put("lfbool3", new BooleanVerifier(false));
231         expectedMap.put("lfdecimal1", new NumberVerifier(new Double(43.32)));
232         expectedMap.put("lfdecimal2", new NumberVerifier(new Double(-0.43)));
233         expectedMap.put("lfdecimal3", new NumberVerifier(new Double(43)));
234         expectedMap.put("lfdecimal4", new NumberVerifier(new Double(43E3)));
235         expectedMap.put("lfdecimal6", new NumberVerifier(new Double(33.12345)));
236         expectedMap.put("lfenum", new StringVerifier("enum3"));
237         expectedMap.put("lfbits", new StringVerifier("bit3 bit2"));
238         expectedMap.put("lfbinary", new StringVerifier("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"));
239         expectedMap.put("lfunion1", new StringVerifier("324"));
240         expectedMap.put("lfunion2", new StringVerifier("33.3"));
241         expectedMap.put("lfunion3", new StringVerifier("55"));
242         expectedMap.put("lfunion4", new StringVerifier("true"));
243         expectedMap.put("lfunion5", new StringVerifier("true"));
244         expectedMap.put("lfunion6", new StringVerifier("10"));
245         expectedMap.put("lfunion7", new StringVerifier(""));
246         expectedMap.put("lfunion8", new StringVerifier(""));
247         expectedMap.put("lfunion9", new StringVerifier(""));
248         expectedMap.put("lfunion10", new StringVerifier("bt1"));
249         expectedMap.put("lfunion11", new StringVerifier("33"));
250         expectedMap.put("lfunion12", new StringVerifier("false"));
251         expectedMap.put("lfunion13", new StringVerifier("b1"));
252         expectedMap.put("lfunion14", new StringVerifier("zero"));
253         expectedMap.put("lfempty", new EmptyVerifier());
254         expectedMap.put("identityref1", new StringVerifier("simple-data-types:iden"));
255         expectedMap.put("complex-any", new ComplexAnyXmlVerifier());
256         expectedMap.put("simple-any", new StringVerifier("simple"));
257         expectedMap.put("empty-any", new StringVerifier(""));
258
259         while (jReader.hasNext()) {
260             final String keyName = jReader.nextName();
261             final JsonToken peek = jReader.peek();
262
263             final LeafVerifier verifier = expectedMap.remove(keyName);
264             assertNotNull("Found unexpected leaf: " + keyName, verifier);
265
266             final JsonToken expToken = verifier.expectedTokenType();
267             if (expToken != null) {
268                 assertEquals("Json token type for key " + keyName, expToken, peek);
269             }
270
271             verifier.verify(jReader, keyName);
272         }
273
274         if (!expectedMap.isEmpty()) {
275             fail("Missing leaf nodes in Json output: " + expectedMap.keySet());
276         }
277
278         jReader.endObject();
279     }
280
281 }