opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/cnsn/to/json/test/ToJsonBasicDataTypesTest.java

   1 package org.opendaylight.controller.sal.restconf.impl.cnsn.to.json.test;
   2
   3 import static org.junit.Assert.*;
   4
   5 import java.io.IOException;
   6 import java.io.StringReader;
   7 import java.math.BigDecimal;
   8 import java.net.URI;
   9 import java.net.URISyntaxException;
  10 import java.util.*;
  11
  12 import javax.ws.rs.WebApplicationException;
  13 import javax.xml.bind.DatatypeConverter;
  14
  15 import org.junit.Test;
  16 import org.opendaylight.controller.sal.restconf.impl.test.TestUtils;
  17 import org.opendaylight.yangtools.yang.common.QName;
  18 import org.opendaylight.yangtools.yang.data.api.*;
  19 import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
  20 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  21 import org.opendaylight.yangtools.yang.model.api.Module;
  22
  23 import com.google.gson.stream.JsonReader;
  24 import com.google.gson.stream.JsonToken;
  25
  26 public class ToJsonBasicDataTypesTest {
  27
  28     @Test
  29     public void simpleYangDataTest() {
  30         String jsonOutput = "";
  31         CompositeNode compositeNode = TestUtils.loadCompositeNode("/cnsn-to-json/simple-data-types/xml/data.xml");
  32
  33         Set<Module> modules = TestUtils.resolveModules("/cnsn-to-json/simple-data-types");
  34         assertEquals(1, modules.size());
  35         Module module = TestUtils.resolveModule(null, modules);
  36         assertNotNull(module);
  37         DataSchemaNode dataSchemaNode = TestUtils.resolveDataSchemaNode(module, null);
  38         assertNotNull(dataSchemaNode);
  39
  40         TestUtils.normalizeCompositeNode(compositeNode, modules, dataSchemaNode, "simple-data-types:cont");
  41
  42         try {
  43             jsonOutput = TestUtils.writeCompNodeWithSchemaContextToJson(compositeNode, modules, dataSchemaNode);
  44         } catch (WebApplicationException | IOException e) {
  45             assertTrue(false); // shouldn't get here
  46         }
  47
  48         System.out.println(jsonOutput);
  49         verifyJsonOutput(jsonOutput);
  50     }
  51
  52     private CompositeNode prepareData() {
  53         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(TestUtils.buildQName("cont"), null, null,
  54                 ModifyAction.CREATE, null);
  55
  56         List<Node<?>> childNodes = new ArrayList<>();
  57         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint8Min"), cont, (byte) -128,
  58                 ModifyAction.CREATE, null));
  59         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint8Max"), cont, (byte) 127,
  60                 ModifyAction.CREATE, null));
  61         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint16Min"), cont, (short) -32768,
  62                 ModifyAction.CREATE, null));
  63         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint16Max"), cont, (short) 32767,
  64                 ModifyAction.CREATE, null));
  65         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint32Min"), cont,
  66                 (int) -2147483648, ModifyAction.CREATE, null));
  67         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint32Max"), cont, (int) 2147483647,
  68                 ModifyAction.CREATE, null));
  69         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint64Min"), cont, new Long(
  70                 "-9223372036854775807"), ModifyAction.CREATE, null));
  71         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnint64Max"), cont, new Long(
  72                 "9223372036854775807"), ModifyAction.CREATE, null));
  73         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnuint8Max"), cont, (short) 255,
  74                 ModifyAction.CREATE, null));
  75         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnuint16Max"), cont, (int) 65535,
  76                 ModifyAction.CREATE, null));
  77         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfnuint32Max"), cont, new Long(
  78                 "4294967295"), ModifyAction.CREATE, null));
  79         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfstr"), cont, "lfstr",
  80                 ModifyAction.CREATE, null));
  81         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfstr1"), cont, "",
  82                 ModifyAction.CREATE, null));
  83         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfbool1"), cont, Boolean.TRUE,
  84                 ModifyAction.CREATE, null));
  85         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfbool2"), cont, Boolean.FALSE,
  86                 ModifyAction.CREATE, null));
  87         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal1"), cont, new BigDecimal(
  88                 "43.32"), ModifyAction.CREATE, null));
  89         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal2"), cont, new BigDecimal(
  90                 "-0.43"), ModifyAction.CREATE, null));
  91         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal3"), cont, new BigDecimal(
  92                 "43"), ModifyAction.CREATE, null));
  93         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal4"), cont, new BigDecimal(
  94                 "43E3"), ModifyAction.CREATE, null));
  95         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfdecimal6"), cont, new BigDecimal(
  96                 "33.12345"), ModifyAction.CREATE, null));
  97         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfenum"), cont, "enum3",
  98                 ModifyAction.CREATE, null));
  99
 100         HashSet<String> bits = new HashSet<String>();
 101         bits.add("bit3");
 102         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfbits"), cont, bits,
 103                 ModifyAction.CREATE, null));
 104
 105         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfbinary"), cont, DatatypeConverter
 106                 .parseBase64Binary("AAaacdabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"),
 107                 ModifyAction.CREATE, null));
 108         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfempty"), cont, null,
 109                 ModifyAction.CREATE, null));
 110         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion1"), cont, (int) 324,
 111                 ModifyAction.CREATE, null));
 112         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion2"), cont, new BigDecimal(
 113                 "33.3"), ModifyAction.CREATE, null));
 114         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion3"), cont, "55",
 115                 ModifyAction.CREATE, null));
 116         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion4"), cont, Boolean.TRUE,
 117                 ModifyAction.CREATE, null));
 118         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion5"), cont, "true",
 119                 ModifyAction.CREATE, null));
 120         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion6"), cont, "false",
 121                 ModifyAction.CREATE, null));
 122         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion7"), cont, null,
 123                 ModifyAction.CREATE, null));
 124         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion8"), cont, "",
 125                 ModifyAction.CREATE, null));
 126         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion9"), cont, "",
 127                 ModifyAction.CREATE, null));
 128
 129         HashSet<String> bits2 = new HashSet<String>();
 130         bits2.add("bt1");
 131         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion10"), cont, bits2,
 132                 ModifyAction.CREATE, null));
 133
 134         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion11"), cont, (short) 33,
 135                 ModifyAction.CREATE, null));
 136         childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfunion12"), cont, Boolean.FALSE,
 137                 ModifyAction.CREATE, null));
 138         try {
 139             childNodes.add(NodeFactory.createMutableSimpleNode(TestUtils.buildQName("identityref1"), cont, new QName(
 140                     new URI("simple:data:types"), "iden"), ModifyAction.CREATE, null));
 141         } catch (URISyntaxException e) {
 142         }
 143
 144         cont.getChildren().addAll(childNodes);
 145
 146         cont.init();
 147
 148         return cont;
 149     }
 150
 151     private void verifyJsonOutput(String jsonOutput) {
 152         StringReader strReader = new StringReader(jsonOutput);
 153         JsonReader jReader = new JsonReader(strReader);
 154
 155         String exception = null;
 156         try {
 157             jsonReadCont(jReader);
 158         } catch (IOException e) {
 159             exception = e.getMessage();
 160         }
 161
 162         assertNull("Error during reading Json output: " + exception, exception);
 163     }
 164
 165     private void jsonReadCont(JsonReader jReader) throws IOException {
 166         jReader.beginObject();
 167         assertNotNull("cont1 is missing.", jReader.hasNext());
 168
 169         // Cont dataFromJson = new Cont(jReader.nextName());
 170         jReader.nextName();
 171         jsonReadContElements(jReader);
 172
 173         assertFalse("cont shouldn't have other element.", jReader.hasNext());
 174         jReader.endObject();
 175         // return dataFromJson;
 176     }
 177
 178     private void jsonReadContElements(JsonReader jReader) throws IOException {
 179         jReader.beginObject();
 180         List<String> loadedLfs = new ArrayList<>();
 181         boolean exceptForDecimal5Raised = false;
 182         boolean enumChecked = false;
 183         boolean bitsChecked = false;
 184         boolean lfdecimal6Checked = false;
 185         boolean lfdecimal4Checked = false;
 186         boolean lfdecimal3Checked = false;
 187         boolean lfdecimal2Checked = false;
 188         boolean lfdecimal1Checked = false;
 189         boolean lfbool1Checked = false;
 190         boolean lfbool2Checked = false;
 191         boolean lfstrChecked = false;
 192         boolean lfbinaryChecked = false;
 193         // boolean lfref1Checked = false;
 194         boolean lfemptyChecked = false;
 195         boolean lfstr1Checked = false;
 196         boolean lfidentityrefChecked = false;
 197
 198         while (jReader.hasNext()) {
 199             String keyName = jReader.nextName();
 200             JsonToken peek = null;
 201             try {
 202                 peek = jReader.peek();
 203             } catch (IOException e) {
 204                 if (keyName.equals("lfdecimal5")) {
 205                     exceptForDecimal5Raised = true;
 206                 } else {
 207                     assertTrue("Key " + keyName + " has incorrect value for specifed type", false);
 208                 }
 209             }
 210
 211             if (keyName.startsWith("lfnint") || keyName.startsWith("lfnuint")) {
 212                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 213                 try {
 214                     jReader.nextLong();
 215                 } catch (NumberFormatException e) {
 216                     assertTrue("Key " + keyName + " has incorrect value - " + e.getMessage(), false);
 217                 }
 218                 loadedLfs.add(keyName.substring(3));
 219             } else if (keyName.equals("identityref1")) {
 220                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 221                 assertEquals("simple-data-types:iden", jReader.nextString());
 222                 lfidentityrefChecked = true;
 223             } else if (keyName.equals("lfstr")) {
 224                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 225                 assertEquals("lfstr", jReader.nextString());
 226                 lfstrChecked = true;
 227             } else if (keyName.equals("lfstr1")) {
 228                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 229                 assertEquals("", jReader.nextString());
 230                 lfstr1Checked = true;
 231             } else if (keyName.equals("lfbool1")) {
 232                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.BOOLEAN, peek);
 233                 assertEquals(true, jReader.nextBoolean());
 234                 lfbool1Checked = true;
 235             } else if (keyName.equals("lfbool2")) {
 236                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.BOOLEAN, peek);
 237                 assertEquals(false, jReader.nextBoolean());
 238                 lfbool2Checked = true;
 239             } else if (keyName.equals("lfbool3")) {
 240                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.BOOLEAN, peek);
 241                 assertEquals(false, jReader.nextBoolean());
 242             } else if (keyName.equals("lfdecimal1")) {
 243                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 244                 assertEquals(new Double(43.32), (Double) jReader.nextDouble());
 245                 lfdecimal1Checked = true;
 246             } else if (keyName.equals("lfdecimal2")) {
 247                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 248                 assertEquals(new Double(-0.43), (Double) jReader.nextDouble());
 249                 lfdecimal2Checked = true;
 250             } else if (keyName.equals("lfdecimal3")) {
 251                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 252                 assertEquals(new Double(43), (Double) jReader.nextDouble());
 253                 lfdecimal3Checked = true;
 254             } else if (keyName.equals("lfdecimal4")) {
 255                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 256                 assertEquals(new Double(43E3), (Double) jReader.nextDouble());
 257                 lfdecimal4Checked = true;
 258             } else if (keyName.equals("lfdecimal6")) {
 259                 assertEquals("Key " + keyName + " has incorrect type", JsonToken.NUMBER, peek);
 260                 assertEquals(new Double(33.12345), (Double) jReader.nextDouble());
 261                 lfdecimal6Checked = true;
 262             } else if (keyName.equals("lfenum")) {
 263                 assertEquals("enum3", jReader.nextString());
 264                 enumChecked = true;
 265             } else if (keyName.equals("lfbits")) {
 266                 assertEquals("bit3 bit2", jReader.nextString());
 267                 bitsChecked = true;
 268             } else if (keyName.equals("lfbinary")) {
 269                 assertEquals("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", jReader.nextString());
 270                 lfbinaryChecked = true;
 271             } else if (keyName.equals("lfempty")) {
 272                 jReader.beginArray();
 273                 jReader.nextNull();
 274                 jReader.endArray();
 275                 lfemptyChecked = true;
 276             } else if (keyName.startsWith("lfunion")) {
 277                 checkLfUnion(jReader, keyName, peek);
 278             } else {
 279                 assertTrue("Key " + keyName + " doesn't exists in yang file.", false);
 280             }
 281
 282         }
 283         Collections.sort(loadedLfs);
 284         String expectedLfsStr = "[int16Max, int16Min, int32Max, int32Min, int64Max, int64Min, int8Max, int8Min, uint16Max, uint32Max, uint8Max]";
 285         String actualLfsStr = loadedLfs.toString();
 286         assertEquals("Some leaves are missing", expectedLfsStr, actualLfsStr);
 287         assertTrue("Enum wasn't checked", enumChecked);
 288         assertTrue("Bits wasn't checked", bitsChecked);
 289         assertTrue("Decimal1 wasn't checked", lfdecimal1Checked);
 290         assertTrue("Decimal2 wasn't checked", lfdecimal2Checked);
 291         assertTrue("Decimal3 wasn't checked", lfdecimal3Checked);
 292         assertTrue("Decimal4 wasn't checked", lfdecimal4Checked);
 293         assertTrue("Decimal5 wasn't checked", lfdecimal6Checked);
 294         assertTrue("lfbool1 wasn't checked", lfbool1Checked);
 295         assertTrue("lfbool2 wasn't checked", lfbool2Checked);
 296         assertTrue("lfstr wasn't checked", lfstrChecked);
 297         assertTrue("lfstr1 wasn't checked", lfstr1Checked);
 298         assertTrue("lfbinary wasn't checked", lfbinaryChecked);
 299         assertTrue("lfempty wasn't checked", lfemptyChecked);
 300         assertTrue("lfidentityref wasn't checked", lfidentityrefChecked);
 301         jReader.endObject();
 302     }
 303
 304     private void checkLfUnion(JsonReader jReader, String keyName, JsonToken peek) throws IOException {
 305         if (keyName.equals("lfunion1")) {
 306             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 307             assertEquals("324", jReader.nextString());
 308         } else if (keyName.equals("lfunion2")) {
 309             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 310             assertEquals("33.3", jReader.nextString());
 311         } else if (keyName.equals("lfunion3")) {
 312             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 313             assertEquals("55", jReader.nextString());
 314         } else if (keyName.equals("lfunion4")) {
 315             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 316             assertEquals("true", jReader.nextString());
 317         } else if (keyName.equals("lfunion5")) {
 318             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 319             assertEquals("true", jReader.nextString());
 320         } else if (keyName.equals("lfunion6")) {
 321             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 322             assertEquals("false", jReader.nextString());
 323         } else if (keyName.equals("lfunion7")) {
 324             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 325             assertEquals("", jReader.nextString());
 326         } else if (keyName.equals("lfunion8")) {
 327             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 328             assertEquals("", jReader.nextString());
 329         } else if (keyName.equals("lfunion9")) {
 330             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 331             assertEquals("", jReader.nextString());
 332         } else if (keyName.equals("lfunion10")) {
 333             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 334             assertEquals("bt1", jReader.nextString());
 335         } else if (keyName.equals("lfunion11")) {
 336             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 337             assertEquals("33", jReader.nextString());
 338         } else if (keyName.equals("lfunion12")) {
 339             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 340             assertEquals("false", jReader.nextString());
 341         } else if (keyName.equals("lfunion13")) {
 342             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 343             assertEquals("44", jReader.nextString());
 344         } else if (keyName.equals("lfunion14")) {
 345             assertEquals("Key " + keyName + " has incorrect type", JsonToken.STRING, peek);
 346             assertEquals("21", jReader.nextString());
 347         }
 348     }
 349 }