hg/bck2brwsr: javaquery/api/src/test/java/org/apidesign/bck2brwsr/htmlpage/JSONTest.java@6448c284fe21

     1 /**

     2  * Back 2 Browser Bytecode Translator

     3  * Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

     4  *

     5  * This program is free software: you can redistribute it and/or modify

     6  * it under the terms of the GNU General Public License as published by

     7  * the Free Software Foundation, version 2 of the License.

     8  *

     9  * This program is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12  * GNU General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU General Public License

    15  * along with this program. Look for COPYING file in the top folder.

    16  * If not, see http://opensource.org/licenses/GPL-2.0.

    17  */

    18 package org.apidesign.bck2brwsr.htmlpage;

    20 import java.util.Arrays;

    21 import java.util.Iterator;

    22 import java.util.List;

    23 import org.apidesign.bck2brwsr.htmlpage.api.OnReceive;

    24 import org.apidesign.bck2brwsr.htmlpage.api.Page;

    25 import org.apidesign.bck2brwsr.htmlpage.api.Property;

    26 import org.apidesign.bck2brwsr.vmtest.BrwsrTest;

    27 import org.apidesign.bck2brwsr.vmtest.Http;

    28 import org.apidesign.bck2brwsr.vmtest.VMTest;

    29 import org.json.JSONException;

    30 import org.json.JSONObject;

    31 import org.json.JSONTokener;

    32 import org.testng.annotations.Test;

    33 import static org.testng.Assert.*;

    34 import org.testng.annotations.Factory;

    36 /** Need to verify that models produce reasonable JSON objects.

    37  *

    38  * @author Jaroslav Tulach <jtulach@netbeans.org>

    39  */

    40 @Page(xhtml = "Empty.html", className = "JSONik", properties = {

    41     @Property(name = "fetched", type = PersonImpl.class),

    42     @Property(name = "fetchedCount", type = int.class)

    43 })

    44 public class JSONTest {

    45     private JSONik js;

    47     @Test public void personToString() throws JSONException {

    48         Person p = new Person();

    49         p.setSex(Sex.MALE);

    50         p.setFirstName("Jarda");

    51         p.setLastName("Tulach");

    53         JSONTokener t = new JSONTokener(p.toString());

    54         JSONObject o;

    55         try {

    56             o = new JSONObject(t);

    57         } catch (JSONException ex) {

    58             throw new AssertionError("Can't parse " + p.toString(), ex);

    59         }

    61         Iterator it = o.sortedKeys();

    62         assertEquals(it.next(), "firstName");

    63         assertEquals(it.next(), "lastName");

    64         assertEquals(it.next(), "sex");

    66         assertEquals(o.getString("firstName"), "Jarda");

    67         assertEquals(o.getString("lastName"), "Tulach");

    68         assertEquals(o.getString("sex"), "MALE");

    69     }

    71     @Test public void personWithWildCharactersAndNulls() throws JSONException {

    72         Person p = new Person();

    73         p.setFirstName("'\"\n");

    74         p.setLastName("\t\r\u0002");

    76         JSONTokener t = new JSONTokener(p.toString());

    77         JSONObject o;

    78         try {

    79             o = new JSONObject(t);

    80         } catch (JSONException ex) {

    81             throw new AssertionError("Can't parse " + p.toString(), ex);

    82         }

    84         Iterator it = o.sortedKeys();

    85         assertEquals(it.next(), "firstName");

    86         assertEquals(it.next(), "lastName");

    87         assertEquals(it.next(), "sex");

    89         assertEquals(o.getString("firstName"), p.getFirstName());

    90         assertEquals(o.getString("lastName"), p.getLastName());

    91         assertEquals(o.get("sex"), JSONObject.NULL);

    92     }

    94     @Test public void personsInArray() throws JSONException {

    95         Person p1 = new Person();

    96         p1.setFirstName("One");

    98         Person p2 = new Person();

    99         p2.setFirstName("Two");

   101         People arr = new People();

   102         arr.getInfo().add(p1);

   103         arr.getInfo().add(p2);

   104         arr.getNicknames().add("Prvn\u00ed k\u016f\u0148");

   105         final String n2 = "Druh\u00fd hlem\u00fd\u017e\u010f, star\u0161\u00ed";

   106         arr.getNicknames().add(n2);

   107         arr.getAge().add(33);

   108         arr.getAge().add(73);

   111         final String json = arr.toString();

   113         JSONTokener t = new JSONTokener(json);

   114         JSONObject o;

   115         try {

   116             o = new JSONObject(t);

   117         } catch (JSONException ex) {

   118             throw new AssertionError("Can't parse " + json, ex);

   119         }

   121         assertEquals(o.getJSONArray("info").getJSONObject(0).getString("firstName"), "One");

   122         assertEquals(o.getJSONArray("nicknames").getString(1), n2);

   123         assertEquals(o.getJSONArray("age").getInt(1), 73);

   124     }

   127     @OnReceive(url="/{url}")

   128     static void fetch(Person p, JSONik model) {

   129         model.setFetched(p);

   130     }

   132     @OnReceive(url="/{url}")

   133     static void fetchArray(Person[] p, JSONik model) {

   134         model.setFetchedCount(p.length);

   135         model.setFetched(p[0]);

   136     }

   138     @OnReceive(url="/{url}")

   139     static void fetchPeople(People p, JSONik model) {

   140         model.setFetchedCount(p.getInfo().size());

   141         model.setFetched(p.getInfo().get(0));

   142     }

   144     @OnReceive(url="/{url}")

   145     static void fetchPeopleAge(People p, JSONik model) {

   146         int sum = 0;

   147         for (int a : p.getAge()) {

   148             sum += a;

   149         }

   150         model.setFetchedCount(sum);

   151     }

   153     @Http(@Http.Resource(

   154         content = "{'firstName': 'Sitar', 'sex': 'MALE'}",

   155         path="/person.json",

   156         mimeType = "application/json"

   157     ))

   158     @BrwsrTest public void loadAndParseJSON() throws InterruptedException {

   159         if (js == null) {

   160             js = new JSONik();

   161             js.applyBindings();

   163             js.fetch("person.json");

   164         }

   166         Person p = js.getFetched();

   167         if (p == null) {

   168             throw new InterruptedException();

   169         }

   171         assert "Sitar".equals(p.getFirstName()) : "Expecting Sitar: " + p.getFirstName();

   172       //  assert Sex.MALE.equals(p.getSex()) : "Expecting MALE: " + p.getSex();

   173     }

   175     @OnReceive(url="/{url}?callme={me}", jsonp = "me")

   176     static void fetchViaJSONP(Person p, JSONik model) {

   177         model.setFetched(p);

   178     }

   180     @Http(@Http.Resource(

   181         content = "$0({'firstName': 'Mitar', 'sex': 'MALE'})",

   182         path="/person.json",

   183         mimeType = "application/javascript",

   184         parameters = { "callme" }

   185     ))

   186     @BrwsrTest public void loadAndParseJSONP() throws InterruptedException {

   187         if (js == null) {

   188             js = new JSONik();

   189             js.applyBindings();

   191             js.fetchViaJSONP("person.json");

   192         }

   194         Person p = js.getFetched();

   195         if (p == null) {

   196             throw new InterruptedException();

   197         }

   199         assert "Mitar".equals(p.getFirstName()) : "Unexpected: " + p.getFirstName();

   200       //  assert Sex.MALE.equals(p.getSex()) : "Expecting MALE: " + p.getSex();

   201     }

   203     @Http(@Http.Resource(

   204         content = "{'firstName': 'Sitar', 'sex': 'MALE'}",

   205         path="/person.json",

   206         mimeType = "application/json"

   207     ))

   208     @BrwsrTest public void loadAndParseJSONSentToArray() throws InterruptedException {

   209         if (js == null) {

   210             js = new JSONik();

   211             js.applyBindings();

   213             js.fetchArray("person.json");

   214         }

   216         Person p = js.getFetched();

   217         if (p == null) {

   218             throw new InterruptedException();

   219         }

   221         assert p != null : "We should get our person back: " + p;

   222         assert "Sitar".equals(p.getFirstName()) : "Expecting Sitar: " + p.getFirstName();

   223 //        assert Sex.MALE.equals(p.getSex()) : "Expecting MALE: " + p.getSex();

   224     }

   226     @Http(@Http.Resource(

   227         content = "[{'firstName': 'Gitar', 'sex': 'FEMALE'}]",

   228         path="/person.json",

   229         mimeType = "application/json"

   230     ))

   231     @BrwsrTest public void loadAndParseJSONArraySingle() throws InterruptedException {

   232         if (js == null) {

   233             js = new JSONik();

   234             js.applyBindings();

   236             js.fetch("person.json");

   237         }

   239         Person p = js.getFetched();

   240         if (p == null) {

   241             throw new InterruptedException();

   242         }

   244         assert p != null : "We should get our person back: " + p;

   245         assert "Gitar".equals(p.getFirstName()) : "Expecting Gitar: " + p.getFirstName();

   246 //        assert Sex.MALE.equals(p.getSex()) : "Expecting MALE: " + p.getSex();

   247     }

   249     @Http(@Http.Resource(

   250         content = "{'info':[{'firstName': 'Gitar', 'sex': 'FEMALE'}]}",

   251         path="/people.json",

   252         mimeType = "application/json"

   253     ))

   254     @BrwsrTest public void loadAndParseArrayInPeople() throws InterruptedException {

   255         if (js == null) {

   256             js = new JSONik();

   257             js.applyBindings();

   259             js.fetchPeople("people.json");

   260         }

   262         if (0 == js.getFetchedCount()) {

   263             throw new InterruptedException();

   264         }

   266         assert js.getFetchedCount() == 1 : "One person loaded: " + js.getFetchedCount();

   268         Person p = js.getFetched();

   270         assert p != null : "We should get our person back: " + p;

   271         assert "Gitar".equals(p.getFirstName()) : "Expecting Gitar: " + p.getFirstName();

   272 //        assert Sex.MALE.equals(p.getSex()) : "Expecting MALE: " + p.getSex();

   273     }

   275     @Http(@Http.Resource(

   276         content = "{'age':[1, 2, 3]}",

   277         path="/people.json",

   278         mimeType = "application/json"

   279     ))

   280     @BrwsrTest public void loadAndParseArrayOfIntegers() throws InterruptedException {

   281         if (js == null) {

   282             js = new JSONik();

   283             js.applyBindings();

   285             js.fetchPeopleAge("people.json");

   286         }

   288         if (0 == js.getFetchedCount()) {

   289             throw new InterruptedException();

   290         }

   292         assert js.getFetchedCount() == 6 : "1 + 2 + 3 is " + js.getFetchedCount();

   293     }

   295     @Http(@Http.Resource(

   296         content = "[{'firstName': 'Gitar', 'sex': 'FEMALE'},"

   297         + "{'firstName': 'Peter', 'sex': 'MALE'}"

   298         + "]",

   299         path="/person.json",

   300         mimeType = "application/json"

   301     ))

   302     @BrwsrTest public void loadAndParseJSONArray() throws InterruptedException {

   303         if (js == null) {

   304             js = new JSONik();

   305             js.applyBindings();

   306             js.fetchArray("person.json");

   307         }

   310         Person p = js.getFetched();

   311         if (p == null) {

   312             throw new InterruptedException();

   313         }

   315         assert js.getFetchedCount() == 2 : "We got two values: " + js.getFetchedCount();

   316         assert p != null : "We should get our person back: " + p;

   317         assert "Gitar".equals(p.getFirstName()) : "Expecting Gitar: " + p.getFirstName();

   318 //        assert Sex.MALE.equals(p.getSex()) : "Expecting MALE: " + p.getSex();

   319     }

   321     @Factory public static Object[] create() {

   322         return VMTest.create(JSONTest.class);

   323     }

   325 }

author	Jaroslav Tulach <jaroslav.tulach@apidesign.org>
	Mon, 08 Apr 2013 16:51:30 +0200
branch	model
changeset 954	6448c284fe21
parent 944	1e2b0dcc8326
child 960	4887e22cb810
permissions	-rw-r--r--