--- /dev/null
+package org.opendaylight.controller.sal.restconf.impl.test;
+
+import static org.junit.Assert.*;
+
+import java.io.*;
+import java.util.Set;
+import java.util.regex.*;
+
+import javax.ws.rs.WebApplicationException;
+
+import org.junit.*;
+import org.opendaylight.controller.sal.rest.impl.StructuredDataToJsonProvider;
+import org.opendaylight.controller.sal.restconf.impl.StructuredData;
+import org.opendaylight.yangtools.yang.model.api.*;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+
+public class YangAndXmlToJsonConversion {
+
+ @Ignore
+ @Test
+ /**
+ * Test for simple yang types (leaf, list, leaf-list, container and various combination of them)
+ *
+ */
+ public void simpleYangTypesTest() {
+ String jsonOutput = null;
+
+ jsonOutput = convertXmlDataAndYangToJson("/yang-to-json-conversion/simple-yang-types/xml/data.xml",
+ "/yang-to-json-conversion/simple-yang-types");
+
+// jsonOutput =
+// readJsonFromFile("/yang-to-json-conversion/simple-yang-types/xml/output.json");
+
+ verifyJsonOutputForSimpleYangTypes(jsonOutput);
+
+ }
+
+ private void verifyJsonOutputForSimpleYangTypes(String jsonOutput) {
+
+ assertTrue("First and last character has to be '{' and '}'", Pattern.compile("\\A\\{.*\\}\\z", Pattern.DOTALL)
+ .matcher(jsonOutput).matches());
+
+ String prefix = "\"(smptp:|)";
+
+ // subnodes of cont1
+ String cont1 = prefix + "cont1\":\\{";
+ testLeaf(cont1, "lf11", new String("lf"), jsonOutput, prefix);
+ testLeafList(cont1, "lflst11", jsonOutput, prefix, new Integer(55), new Integer(56), new Integer(57));
+ testLeafList(cont1, "lflst12", jsonOutput, prefix, new String("lflst12 str1"), new String("lflst12 str2"),
+ new String("lflst12 str1"));
+
+ // subnodes of lst111
+ // first object of lst111
+ String lst11 = cont1 + ".*" + prefix + "lst11\":\\[\\{";
+ testLeaf(lst11, "lf111", new Integer(140), jsonOutput, prefix);
+ testLeaf(lst11, "lf112", new String("lf112 str"), jsonOutput, prefix);
+
+ // subnodes of cont111
+ String cont111 = lst11 + ".*" + prefix + "cont111\":\\{";
+ testLeaf(cont111, "lf1111", new String("lf1111 str"), jsonOutput, prefix);
+ testLeafList(cont1, "lflst1111", jsonOutput, prefix, new Integer(2048), new Integer(1024), new Integer(4096));
+
+ // subnodes of lst1111
+ String lst1111 = cont111 + ".*" + prefix + "lst1111\":\\[\\{";
+ testLeaf(lst1111, "lf1111A", new String("lf1111A str11"), jsonOutput, prefix);
+ testLeaf(lst1111, "lf1111B", new Integer(4), jsonOutput, prefix);
+ testLeaf(lst1111, "lf1111A", new String("lf1111A str12"), jsonOutput, prefix);
+ testLeaf(lst1111, "lf1111B", new Integer(7), jsonOutput, prefix);
+ // :subnodes of lst1111
+ // :subnodes of cont111
+ // :first object of lst111
+
+ // second object of lst111
+ testLeaf(lst11, "lf111", new Integer(141), jsonOutput, prefix);
+ testLeaf(lst11, "lf112", new String("lf112 str2"), jsonOutput, prefix);
+
+ // subnodes of cont111
+ testLeaf(cont111, "lf1111", new String("lf1111 str2"), jsonOutput, prefix);
+ testLeafList(cont1, "lflst1111", jsonOutput, prefix, new Integer(2049), new Integer(1025), new Integer(4097));
+
+ // subnodes of lst1111
+ testLeaf(lst1111, "lf1111A", new String("lf1111A str21"), jsonOutput, prefix);
+ testLeaf(lst1111, "lf1111B", new Integer(5), jsonOutput, prefix);
+ testLeaf(lst1111, "lf1111A", new String("lf1111A str22"), jsonOutput, prefix);
+ testLeaf(lst1111, "lf1111B", new Integer(8), jsonOutput, prefix);
+ // :subnodes of lst111
+ // :subnodes of cont111
+ // :second object of lst111
+ // :second object of lst111
+ // :subnodes of cont1
+ }
+
+ private void testLeaf(String prevRegEx, String lstName, Object value, String jsonFile, String elementPrefix) {
+ String newValue = null;
+ if (value instanceof Integer) {
+ newValue = value.toString();
+ } else if (value instanceof String) {
+ newValue = "\"" + value.toString() + "\"";
+ }
+ String lf = elementPrefix + lstName + "\":" + newValue;
+ assertTrue(">>\"" + lstName + "\":" + newValue + "<< is missing",
+ Pattern.compile(".*" + prevRegEx + ".*" + lf + ".*", Pattern.DOTALL).matcher(jsonFile).matches());
+
+ }
+
+ private void testLeafList(String prevRegEx, String lflstName, String jsonFile, String elementPrefix,
+ Object... dataInList) {
+ // order of element in the list isn't defined :(
+ String lflstBegin = elementPrefix + lflstName + "\":\\[";
+ String lflstEnd = ".*\\],";
+ assertTrue(
+ ">>\"" + lflstName + "\": [],<< is missing",
+ Pattern.compile(".*" + prevRegEx + ".*" + lflstBegin + lflstEnd + ".*", Pattern.DOTALL)
+ .matcher(jsonFile).matches());
+
+ for (Object obj : dataInList) {
+ testValueOfLeafList(prevRegEx, lflstBegin, obj, jsonFile);
+ }
+ }
+
+ private void testValueOfLeafList(String prevRegEx, String lflstPrevRegEx, Object value, String jsonFile) {
+ String lflstData = null;
+ lflstData = regExForDataValueInList(value);
+ assertNotNull(lflstPrevRegEx + ": value doesn't have correct type.", lflstData);
+ assertTrue(
+ prevRegEx + ": data value >" + value + "< is missing.",
+ Pattern.compile(".*" + prevRegEx + ".*" + lflstPrevRegEx + lflstData + ".*", Pattern.DOTALL)
+ .matcher(jsonFile).matches());
+
+ }
+
+ /**
+ * Data value can be first, inner, last or only one member of list
+ *
+ * @param dataValue
+ * @return
+ */
+ private String regExForDataValueInList(Object dataValue) {
+ String newDataValue;
+ if (dataValue instanceof Integer) {
+ newDataValue = dataValue.toString();
+ return "(" + newDataValue + "(,[0-9]+)+|([0-9]+,)+" + newDataValue + "(,[0-9]+)+|([0-9]+,)+" + newDataValue
+ + "|" + newDataValue + ")\\]";
+ } else if (dataValue instanceof String) {
+ newDataValue = "\"" + dataValue.toString() + "\"";
+ return "(" + newDataValue + "(,\".+\")+|(\".+\",)+" + newDataValue + "(,\".+\")+|(\".+\",)+" + newDataValue
+ + "|" + newDataValue + ")\\]";
+ }
+ return null;
+ }
+
+ private String readJsonFromFile(String path) {
+ String fullPath = YangAndXmlToJsonConversion.class.getResource(path).getPath();
+ assertNotNull("Path to file can't be null.", fullPath);
+ File file = new File(fullPath);
+ assertNotNull("File can't be null", file);
+ FileReader fileReader = null;
+ try {
+ fileReader = new FileReader(file);
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ }
+ assertNotNull("File reader can't be null.", fileReader);
+
+ StringBuilder strBuilder = new StringBuilder();
+ char[] buffer = new char[1000];
+
+ while (true) {
+ int loadedCharNum;
+ try {
+ loadedCharNum = fileReader.read(buffer);
+ } catch (IOException e) {
+ break;
+ }
+ if (loadedCharNum == -1) {
+ break;
+ }
+ strBuilder.append(buffer, 0, loadedCharNum);
+ }
+ try {
+ fileReader.close();
+ } catch (IOException e) {
+ System.out.println("The file wasn't closed");
+ ;
+ }
+ String rawStr = strBuilder.toString();
+ rawStr = rawStr.replace("\n", "");
+ rawStr = rawStr.replace("\r", "");
+ rawStr = rawStr.replace("\t", "");
+ rawStr = removeSpaces(rawStr);
+
+ return rawStr;
+ }
+
+ private String removeSpaces(String rawStr) {
+ StringBuilder strBuilder = new StringBuilder();
+ int i = 0;
+ int quoteCount = 0;
+ while (i < rawStr.length()) {
+ if (rawStr.substring(i, i + 1).equals("\"")) {
+ quoteCount++;
+ }
+
+ if (!rawStr.substring(i, i + 1).equals(" ") || (quoteCount % 2 == 1)) {
+ strBuilder.append(rawStr.charAt(i));
+ }
+ i++;
+ }
+
+ return strBuilder.toString();
+ }
+
+ private String convertXmlDataAndYangToJson(String xmlDataPath, String yangPath) {
+ String jsonResult = null;
+ Set<Module> modules = null;
+
+ try {
+ modules = TestUtils.loadModules(YangAndXmlToJsonConversion.class.getResource(yangPath).getPath());
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ }
+ assertNotNull("modules can't be null.", modules);
+
+ InputStream xmlStream = YangAndXmlToJsonConversion.class.getResourceAsStream(xmlDataPath);
+ CompositeNode compositeNode = null;
+ try {
+ compositeNode = TestUtils.loadCompositeNode(xmlStream);
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ }
+ assertNotNull("Composite node can't be null", compositeNode);
+
+ StructuredDataToJsonProvider structuredDataToJsonProvider = StructuredDataToJsonProvider.INSTANCE;
+ for (Module module : modules) {
+ for (DataSchemaNode dataSchemaNode : module.getChildNodes()) {
+ StructuredData structuredData = new StructuredData(compositeNode, dataSchemaNode);
+ ByteArrayOutputStream byteArrayOS = new ByteArrayOutputStream();
+ try {
+ structuredDataToJsonProvider.writeTo(structuredData, null, null, null, null, null, byteArrayOS);
+ } catch (WebApplicationException | IOException e) {
+ e.printStackTrace();
+ }
+ assertFalse(
+ "Returning JSON string can't be empty for node " + dataSchemaNode.getQName().getLocalName(),
+ byteArrayOS.toString().isEmpty());
+ jsonResult = byteArrayOS.toString();
+ try {
+ outputToFile(byteArrayOS);
+ } catch (IOException e) {
+ System.out.println("Output file wasn't cloased sucessfuly.");
+ }
+ }
+ }
+ return jsonResult;
+ }
+
+ private void outputToFile(ByteArrayOutputStream outputStream) throws IOException {
+ FileOutputStream fileOS = null;
+ try {
+ String path = YangAndXmlToJsonConversion.class.getResource("/yang-to-json-conversion/xml").getPath();
+ File outFile = new File(path + "/data.json");
+ fileOS = new FileOutputStream(outFile);
+ try {
+ fileOS.write(outputStream.toByteArray());
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ fileOS.close();
+ } catch (FileNotFoundException e1) {
+ e1.printStackTrace();
+ }
+ }
+}
Code Review / controller.git / commitdiff