1 /*

     2  * To change this license header, choose License Headers in Project Properties.

     3  * To change this template file, choose Tools | Templates

     4  * and open the template in the editor.

     5  */

     6 

     7 import com.oracle.jmx.remote.rest.json.parser.JSONParser;

     8 import com.oracle.jmx.remote.rest.json.parser.ParseException;

     9 import java.util.ArrayList;

    10 import java.util.Iterator;

    11 import java.util.LinkedHashMap;

    12 import java.util.LinkedList;

    13 import java.util.List;

    14 import java.util.Random;

    15 

    16 /**

    17  * @test @modules java.management.rest

    18  * @run main JSONTest

    19  */

    20 public class JSONTest {

    21 

    22     public static void main(String[] args) throws ParseException {

    23         JSONGraphGenerator graphGen = new JSONGraphGenerator(50);

    24         JSONElement jElem = graphGen.generateJsonGraph(20000);

    25         System.out.println("Graph Generated");

    26         String str = jElem.toJsonString();

    27         System.out.println(str);

    28 

    29         JSONParser parser = new JSONParser(str);

    30 

    31         com.oracle.jmx.remote.rest.json.JSONElement parse = parser.parse();

    32         String resultJson = parse.toJsonString();

    33         System.out.println(resultJson);

    34     }

    35 }

    36 

    37 interface JSONElement {

    38 

    39     String toJsonString();

    40 }

    41 

    42 interface Visitable {

    43 

    44     public void accept(NodeVisitor visitor);

    45 }

    46 

    47 interface NodeVisitor {

    48 

    49     public void visit(Node node);

    50 

    51     //visit other concrete items

    52     public void visit(Digit19 digit12);

    53 

    54     public void visit(Digits dvd);

    55 }

    56 

    57 class Node implements Visitable {

    58 

    59     final private String label;

    60 

    61     public Node(String label) {

    62         children = new LinkedList<>();

    63         this.label = label;

    64     }

    65 

    66     public Node() {

    67         this("");

    68     }

    69 

    70     public void add(Node node) {

    71         if (!children.contains(node)) {

    72             children.add(node);

    73         }

    74     }

    75 

    76     public String getLabel() {

    77         return label;

    78     }

    79     List<Node> children;

    80 

    81     @Override

    82     public void accept(NodeVisitor visitor) {

    83         visitor.visit(this);

    84     }

    85 }

    86 

    87 class Digit19 extends Node {

    88 

    89     Random rnd = new Random();

    90 

    91     public Digit19() {

    92         super();

    93     }

    94 

    95     @Override

    96     public String getLabel() {

    97         return "" + (rnd.nextInt(9) + 1);

    98     }

    99 }

   100 

   101 class Digits extends Node {

   102 

   103     Random rnd = new Random();

   104 

   105     public Digits() {

   106         super();

   107     }

   108 

   109     @Override

   110     public String getLabel() {

   111         return "" + (rnd.nextInt(10));

   112     }

   113 }

   114 

   115 class JSONNumberGenerator {

   116 

   117     private final static Node root;

   118     Number num;

   119 

   120     static {

   121         root = new Node("R");

   122         Node minus1 = new Node("-");

   123         Node zero = new Node("0");

   124         Node digit19 = new Digit19();

   125         Node digits1 = new Digits();

   126         Node dot = new Node(".");

   127         Node digits2 = new Digits();

   128         Node e = new Node("e");

   129         Node E = new Node("E");

   130         Node plus = new Node("+");

   131         Node minus2 = new Node("-");

   132         Node digits3 = new Digits();

   133         Node terminal = new Node("T");

   134 

   135         root.add(zero);

   136         root.add(minus1);

   137         root.add(digit19);

   138 

   139         minus1.add(zero);

   140         minus1.add(digit19);

   141 

   142         zero.add(dot);

   143 //        zero.add(e);

   144 //        zero.add(E);

   145         zero.add(terminal);

   146 

   147         digit19.add(dot);

   148         digit19.add(digits1);

   149 //        digit19.add(e);

   150 //        digit19.add(E);

   151         digit19.add(terminal);

   152 

   153         digits1.add(dot);

   154         digits1.add(digits1);

   155 //        digits1.add(e);

   156 //        digits1.add(E);

   157         digits1.add(terminal);

   158 

   159         dot.add(digits2);

   160 

   161         digits2.add(digits2);

   162         digits2.add(e);

   163         digits2.add(E);

   164         digits2.add(terminal);

   165 

   166         e.add(plus);

   167         e.add(minus2);

   168         e.add(digits3);

   169 

   170         E.add(plus);

   171         E.add(minus2);

   172         E.add(digits3);

   173 

   174         plus.add(digits3);

   175         minus2.add(digits3);

   176 

   177         digits3.add(digits3);

   178         digits3.add(terminal);

   179     }

   180 

   181     private static class NumberNodeVisitor implements NodeVisitor {

   182 

   183         private final StringBuilder sbuf = new StringBuilder();

   184         Random rnd = new Random();

   185 

   186         public NumberNodeVisitor() {

   187         }

   188 

   189         @Override

   190         public void visit(Node node) {

   191             if (!node.getLabel().equals("R")) {

   192                 sbuf.append(node.getLabel());

   193             }

   194             if (node.children.size() > 0) {

   195                 Node child = node.children.get(rnd.nextInt(node.children.size()));

   196                 if (!child.getLabel().equals("T")) {

   197                     visit(child);

   198                 }

   199             } else {

   200                 System.out.println("Found node " + node.getLabel() + " with children : " + node.children.size());

   201             }

   202         }

   203 

   204         @Override

   205         public void visit(Digit19 digit12) {

   206             sbuf.append(digit12.getLabel());

   207             Node child = digit12.children.get(rnd.nextInt(digit12.children.size()));

   208             if (!child.getLabel().equals("T")) {

   209                 visit(child);

   210             }

   211         }

   212 

   213         @Override

   214         public void visit(Digits digits) {

   215             sbuf.append(digits.getLabel());

   216             Node child = digits.children.get(rnd.nextInt(digits.children.size()));

   217             if (!child.getLabel().equals("T")) {

   218                 visit(child);

   219             }

   220         }

   221 

   222         public String getNumber() {

   223             return sbuf.toString();

   224         }

   225 

   226     }

   227 

   228     public String generate() {

   229         NumberNodeVisitor visitor = new NumberNodeVisitor();

   230         visitor.visit(root);

   231         // System.out.println(visitor.getNumber());

   232 //        Double.parseDouble(visitor.getNumber());

   233         return visitor.getNumber();

   234     }

   235 }

   236 

   237 class TestJsonObject extends LinkedHashMap<String, JSONElement> implements JSONElement {

   238 

   239     @Override

   240     public String toJsonString() {

   241         if (isEmpty()) {

   242             return null;

   243         }

   244 

   245         StringBuilder sbuild = new StringBuilder();

   246         sbuild.append("{");

   247         keySet().forEach((elem) -> {

   248             sbuild.append(elem).append(": ").

   249                     append((get(elem) != null) ? get(elem).toJsonString() : "null").append(",");

   250         });

   251 

   252         sbuild.deleteCharAt(sbuild.lastIndexOf(","));

   253         sbuild.append("}");

   254         return sbuild.toString();

   255     }

   256 }

   257 

   258 class TestJsonArray extends ArrayList<JSONElement> implements JSONElement {

   259 

   260     @Override

   261     public String toJsonString() {

   262         if (isEmpty()) {

   263             return null;

   264         }

   265         StringBuilder sbuild = new StringBuilder();

   266         sbuild.append("[");

   267         Iterator<JSONElement> itr = iterator();

   268         while (itr.hasNext()) {

   269             JSONElement val = itr.next();

   270             if (val != null) {

   271                 sbuild.append(val.toJsonString()).append(", ");

   272             } else {

   273                 sbuild.append("null").append(", ");

   274             }

   275         }

   276 

   277         sbuild.deleteCharAt(sbuild.lastIndexOf(","));

   278         sbuild.append("]");

   279         return sbuild.toString();

   280     }

   281 }

   282 

   283 class TestJsonPrimitive implements JSONElement {

   284 

   285     private final String s;

   286 

   287     public TestJsonPrimitive(String s) {

   288         this.s = s;

   289     }

   290 

   291     @Override

   292     public String toJsonString() {

   293         return s;

   294     }

   295 }

   296 

   297 class JSONStringGenerator {

   298 

   299     private static final int minStringLength = 0;

   300     private static final int maxStringLength = 10;

   301 

   302     private final Random rnd = new Random(System.currentTimeMillis());

   303 

   304     private static final String specials = "\b" + "\f" + "\n" + "\r" + "\t" + "\\" + "\"";    // TODO: Special characters '/', '\', '"', "\\uxxxx"

   305     private static final String alphanums = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

   306 

   307     public String generate() {

   308         char ch;

   309         StringBuilder sbuf = new StringBuilder();

   310         int len = minStringLength + rnd.nextInt(maxStringLength - minStringLength + 1);

   311         sbuf.append("\"");

   312         for (int i = 0; i < len; i++) {

   313             if (rnd.nextInt(10) == 1) { // 1/10 chances of a control character

   314                 ch = specials.charAt(rnd.nextInt(specials.length()));

   315             } else {

   316 //                ch = alphanums.charAt(rnd.nextInt(alphanums.length()));

   317                 ch = (char) rnd.nextInt(Character.MAX_VALUE + 1);

   318             }

   319             switch (ch) {

   320                 case '\"':

   321                 case '\\':

   322                     sbuf.append('\\');

   323             }

   324             sbuf.append(ch);

   325         }

   326         sbuf.append("\"");

   327         return sbuf.toString();

   328     }

   329 }

   330 

   331 class JSONGraphGenerator {

   332 

   333     JSONStringGenerator stringGen;

   334     JSONNumberGenerator numGen;

   335     private final int maxChildPerNode;

   336     static Random rnd = new Random(System.currentTimeMillis());

   337 

   338     public JSONGraphGenerator(int maxChildPerNode) {

   339         this.maxChildPerNode = maxChildPerNode;

   340         stringGen = new JSONStringGenerator();

   341         numGen = new JSONNumberGenerator();

   342     }

   343 

   344     private TestJsonPrimitive generatePrimitiveData() {

   345         int primitiveTypre = rnd.nextInt(10) + 1;

   346         switch (primitiveTypre) {

   347             case 1:

   348             case 2:

   349             case 3:

   350             case 4:

   351                 return new TestJsonPrimitive(stringGen.generate());

   352             case 5:

   353             case 6:

   354             case 7:

   355             case 8:

   356                 return new TestJsonPrimitive(numGen.generate());

   357             case 9:

   358                 return new TestJsonPrimitive(Boolean.toString(rnd.nextBoolean()));

   359             case 10:

   360                 return null;

   361         }

   362         return null;

   363     }

   364 

   365     public TestJsonObject generateJsonObject(int size) {

   366         TestJsonObject jobj = new TestJsonObject();

   367         if (size <= maxChildPerNode) {

   368             for (int i = 0; i < size; i++) {

   369                 jobj.put(stringGen.generate(), generatePrimitiveData());

   370             }

   371         } else {

   372             int newSize = size;

   373             do {

   374                 int childSize = rnd.nextInt(newSize);

   375                 jobj.put(stringGen.generate(), generateJsonGraph(childSize));

   376                 newSize = newSize - childSize;

   377             } while (newSize > maxChildPerNode);

   378             jobj.put(stringGen.generate(), generateJsonGraph(newSize));

   379         }

   380         return jobj;

   381     }

   382 

   383     public TestJsonArray generateJsonArray(int size) {

   384         TestJsonArray array = new TestJsonArray();

   385         if (size <= maxChildPerNode) {

   386             for (int i = 0; i < size; i++) {

   387                 array.add(generatePrimitiveData());

   388             }

   389         } else if (size >= maxChildPerNode) {

   390             int newSize = size;

   391             do {

   392                 int childSize = rnd.nextInt(newSize);

   393                 array.add(generateJsonGraph(childSize));

   394                 newSize = newSize - childSize;

   395             } while (newSize > maxChildPerNode);

   396             array.add(generateJsonGraph(newSize));

   397         }

   398         return array;

   399     }

   400 

   401     public JSONElement generateJsonGraph(int size) {

   402         if (rnd.nextBoolean()) {

   403             return generateJsonArray(size);

   404         } else {

   405             return generateJsonObject(size);

   406         }

   407     }

   408 }