@Test
 public void testDeserializeJsonWithClassAlias() {
   Genson genson = new GensonBuilder().addAlias("rect", Rectangle.class).create();
   Shape p = genson.deserialize("{\"@class\":\"rect\"}", Shape.class);
   assertTrue(p instanceof Rectangle);
   p = genson.deserialize("{\"@class\":\"java.awt.Rectangle\"}", Shape.class);
   assertTrue(p instanceof Rectangle);
 }
  @Test
  public void testJsonNumbersLimit() {
    String src = "[" + String.valueOf(Long.MAX_VALUE) + "," + String.valueOf(Long.MIN_VALUE) + "]";
    long[] arr = genson.deserialize(src, long[].class);
    assertTrue(Long.MAX_VALUE == arr[0]);
    assertTrue(Long.MIN_VALUE == arr[1]);

    src = "[" + String.valueOf(Double.MAX_VALUE) + "," + String.valueOf(Double.MIN_VALUE) + "]";
    double[] arrD = genson.deserialize(src, double[].class);
    assertTrue(Double.MAX_VALUE == arrD[0]);
    assertTrue(Double.MIN_VALUE == arrD[1]);
  }
Example #3
0
 @Override
 public void serialize(Object value, boolean pretty, OutputStream out) throws IOException {
   try {
     if (pretty) {
       gensonPretty.serialize(value, out);
     } else {
       genson.serialize(value, out);
     }
   } catch (TransformationException e) {
     throw new IOException(e.toString(), e);
   }
 }
  @Test
  public void testMultidimensionalArray() {
    String json = "[[\"abc\",[42,24]],[\"def\",[43,34]]]";
    Object[][] array = genson.deserialize(json, Object[][].class);
    assertEquals("abc", array[0][0]);
    assertArrayEquals(new Object[] {42L, 24L}, (Object[]) array[0][1]);
    assertEquals("def", array[1][0]);
    assertArrayEquals(new Object[] {43L, 34L}, (Object[]) array[1][1]);

    String json3 = "[[[\"abc\"],[42,24],[\"def\"],[43,34]]]";
    genson.deserialize(json3, Object[][][].class);
  }
 public static CarryForwardContext getCarryForwardContext(Message message) throws JMSException {
   if (!message.propertyExists(MessagePropertyNames.CARRY_FORWARD_CONTEXT)) {
     return CarryForwardContext.getDefault();
   }
   String carryForwardContextJson =
       message.getStringProperty(MessagePropertyNames.CARRY_FORWARD_CONTEXT);
   if (!StringUtil.isEmpty(carryForwardContextJson)) {
     Genson genson = new Genson();
     CarryForwardContext carryForwardContext =
         genson.deserialize(carryForwardContextJson, CarryForwardContext.class);
     return carryForwardContext;
   }
   return CarryForwardContext.getDefault();
 }
  public static void setCarryForwardContext(Message message, Object carryForwardContext)
      throws JMSException {
    if (carryForwardContext == null) {
      return;
    }
    String carryForwardContextJson;
    //  carryForwardContextJson = fioranoJsonUtil.serialize((CarryForwardContext)
    // carryForwardContext);
    Genson genson = new Genson();
    carryForwardContextJson = genson.serialize(carryForwardContext);

    // message.setObjectProperty(MessagePropertyNames.CARRY_FORWARD_CONTEXT, carryForwardContext);
    message.setStringProperty(MessagePropertyNames.CARRY_FORWARD_CONTEXT, carryForwardContextJson);
  }
 @Test
 public void testDeserealizeIntoExistingBean() {
   BeanDescriptor<ClassWithConstructorFieldsAndGetters> desc =
       (BeanDescriptor<ClassWithConstructorFieldsAndGetters>)
           genson
               .getBeanDescriptorFactory()
               .provide(
                   ClassWithConstructorFieldsAndGetters.class,
                   ClassWithConstructorFieldsAndGetters.class,
                   genson);
   ClassWithConstructorFieldsAndGetters c =
       new ClassWithConstructorFieldsAndGetters(1, 2, "3") {
         @Override
         public void setP2(Integer p2) {
           this.p2 = p2;
         }
       };
   c.constructorCalled = false;
   String json = "{\"p0\":0,\"p1\":1,\"p2\":2,\"shouldSkipIt\":55,   \"nameInJson\":\"125\"}";
   desc.deserialize(c, new JsonReader(json), new Context(genson));
   assertFalse(c.constructorCalled);
   assertEquals(c.p0, new Integer(0));
   assertEquals(c.p1, new Integer(1));
   assertEquals(c.p2, new Integer(2));
 }
 @SuppressWarnings("unchecked")
 @Test
 public void testJsonToUntypedList() {
   String src = "[1, 1.1, \"aa\", true, false]";
   List<Object> l = genson.deserialize(src, List.class);
   assertArrayEquals(new Object[] {1L, 1.1, "aa", true, false}, l.toArray(new Object[l.size()]));
 }
Example #9
0
 @Override
 public <T> T deserialize(InputStream in, Class<T> cls) throws IOException {
   try {
     return genson.deserialize(in, cls);
   } catch (TransformationException e) {
     throw new IOException(e.toString(), e);
   }
 }
 @Test
 public void testJsonDoubleArray() {
   String src = "[5,      0.006, 9.0E-11 ]";
   double[] array = genson.deserialize(src, double[].class);
   assertEquals(array[0], 5, 0);
   assertEquals(array[1], 0.006, 0);
   assertEquals(array[2], 0.00000000009, 0);
 }
 @Test
 public void testJsonToBeanWithConstructor() {
   String json = "{\"other\":{\"name\":\"TITI\", \"age\": 13}, \"name\":\"TOTO\", \"age\":26}";
   BeanWithConstructor bean = genson.deserialize(json, BeanWithConstructor.class);
   assertEquals(bean.age, 26);
   assertEquals(bean.name, "TOTO");
   assertEquals(bean.other.age, 13);
   assertEquals(bean.other.name, "TITI");
 }
  @Test
  public void testJsonComplexObjectEmpty() {
    String src = "{\"primitives\":null,\"listOfPrimitives\":[], \"arrayOfPrimitives\": null}";
    ComplexObject co = genson.deserialize(src, ComplexObject.class);

    assertNull(co.getPrimitives());
    assertTrue(co.getListOfPrimitives().size() == 0);
    assertNull(co.getArrayOfPrimitives());
  }
 @Test
 public void testJsonComplexObject() {
   ComplexObject coo =
       new ComplexObject(
           createPrimitives(),
           Arrays.asList(createPrimitives(), createPrimitives()),
           new Primitives[] {createPrimitives(), createPrimitives()});
   ComplexObject co = genson.deserialize(coo.jsonString(), ComplexObject.class);
   ComplexObject.assertCompareComplexObjects(co, coo);
 }
 @Test
 public void testDeserializeWithConstructorAndFieldsAndSetters() {
   String json = "{\"p0\":0,\"p1\":1,\"p2\":2,\"shouldSkipIt\":55, \"nameInJson\": 3}";
   ClassWithConstructorFieldsAndGetters c =
       genson.deserialize(json, ClassWithConstructorFieldsAndGetters.class);
   assertEquals(c.p0, new Integer(0));
   assertEquals(c.p1, new Integer(1));
   assertEquals(c.p2, new Integer(2));
   assertTrue(c.constructorCalled);
 }
  public boolean addTrigger(Trigger drug) {

    DBCollection collection = db.getCollection("trigger");
    // convert JSON to DBObject directly
    BasicDBObject bdbo = new BasicDBObject();
    bdbo.put("name", drug.getName());
    DBCursor curs = collection.find(bdbo);
    if (curs.count() > 0) return false;
    Genson genson = new Genson();
    DBObject dbObject = (DBObject) JSON.parse(genson.serialize(drug));
    collection.insert(dbObject);

    DBCursor cursorDoc = collection.find();
    while (cursorDoc.hasNext()) {
      System.out.println(cursorDoc.next());
    }

    System.out.println("Done");
    return true;
  }
 @Test
 public void testDeserializeWithConstructorAndMissingFields() {
   String json = "{\"p0\":0,\"p1\":1, \"nameInJson\": 3}";
   ClassWithConstructorFieldsAndGetters c =
       genson.deserialize(json, ClassWithConstructorFieldsAndGetters.class);
   assertTrue(c.constructorCalled);
   assertEquals(new Integer(0), c.p0);
   assertEquals(new Integer(1), c.p1);
   assertEquals(null, c.p2);
   assertEquals(new Integer(3), c.hidden);
 }
  @SuppressWarnings("unchecked")
  @Test
  public void testContentDrivenDeserialization() {
    String src = "{\"list\":[1, 2.3, 5, null]}";
    TypeVariableList<Number> tvl = genson.deserialize(src, TypeVariableList.class);
    assertArrayEquals(
        tvl.list.toArray(new Number[tvl.list.size()]), new Number[] {1, 2.3, 5, null});

    String json = "[\"hello\",5,{\"name\":\"GREETINGS\",\"source\":\"guest\"}]";
    Map<String, String> map = new HashMap<String, String>();
    map.put("name", "GREETINGS");
    map.put("source", "guest");
    assertEquals(Arrays.asList("hello", 5L, map), genson.deserialize(json, Collection.class));

    // doit echouer du a la chaine et que list est de type <E extends Number>
    src = "{\"list\":[1, 2.3, 5, \"a\"]}";
    try {
      tvl = genson.deserialize(src, TypeVariableList.class);
      fail();
    } catch (Exception e) {
    }
  }
 @SuppressWarnings("unchecked")
 @Test
 public void testUntypedDeserializationToMap() {
   String src =
       "{\"key1\": 1, \"key2\": 1.2, \"key3\": true, \"key4\": \"string\", \"key5\": null, \"list\":[1,2.0005,3]}";
   Map<String, Object> map = genson.deserialize(src, Map.class);
   assertEquals(map.get("key1"), 1L);
   assertEquals(map.get("key2"), 1.2);
   assertEquals(map.get("key3"), true);
   assertEquals(map.get("key4"), "string");
   assertNull(map.get("key5"));
   Object[] list = (Object[]) map.get("list");
   assertArrayEquals(new Number[] {1L, 2.0005, 3L}, list);
 }
 /**
  * Creates an instance of BeanDescriptor based on the passed arguments. Subclasses can override
  * this method to create their own BeanDescriptors.
  *
  * @param forClass
  * @param ofType
  * @param creator
  * @param accessors
  * @param mutators
  * @return a instance
  */
 protected <T> BeanDescriptor<T> create(
     Class<T> forClass,
     Type ofType,
     BeanCreator creator,
     List<PropertyAccessor> accessors,
     Map<String, PropertyMutator> mutators,
     Genson genson) {
   return new BeanDescriptor<T>(
       forClass,
       getRawClass(ofType),
       accessors,
       mutators,
       creator,
       genson.failOnMissingProperty());
 }
 @Test
 public void testJsonPrimitivesObject() {
   String src =
       "{\"intPrimitive\":1, \"integerObject\":7, \"doublePrimitive\":1.01,"
           + "\"doubleObject\":2.003,\"text\": \"HEY...YA!\", "
           + "\"booleanPrimitive\":true,\"booleanObject\":false}";
   Primitives p = genson.deserialize(src, Primitives.class);
   assertEquals(p.getIntPrimitive(), 1);
   assertEquals(p.getIntegerObject(), new Integer(7));
   assertEquals(p.getDoublePrimitive(), 1.01, 0);
   assertEquals(p.getDoubleObject(), new Double(2.003));
   assertEquals(p.getText(), "HEY...YA!");
   assertEquals(p.isBooleanPrimitive(), true);
   assertEquals(p.isBooleanObject(), Boolean.FALSE);
 }
  @Test
  public void testDeserializeEmptyJson() {
    Integer i = genson.deserialize("\"\"", Integer.class);
    assertNull(i);
    i = genson.deserialize("", Integer.class);
    assertNull(i);
    i = genson.deserialize("null", Integer.class);
    assertNull(i);

    int[] arr = genson.deserialize("", int[].class);
    assertNull(arr);
    arr = genson.deserialize("null", int[].class);
    assertNull(arr);
    arr = genson.deserialize("[]", int[].class);
    assertNotNull(arr);

    Primitives p = genson.deserialize("", Primitives.class);
    assertNull(p);
    p = genson.deserialize("null", Primitives.class);
    assertNull(p);
    p = genson.deserialize("{}", Primitives.class);
    assertNotNull(p);
  }
  private Converter<Object> provide(BeanProperty property, Genson genson) {
    // contextual converters must not be retrieved from cache nor stored in cache, by first
    // trying to create it and reusing it during the
    // call to genson.provideConverter we avoid retrieving it from cache, and by setting
    // DO_NOT_CACHE_CONVERTER to true we tell genson not to store
    // this converter in cache

    @SuppressWarnings("unchecked")
    Converter<Object> converter =
        (Converter<Object>) contextualConverterFactory.provide(property, genson);
    if (converter != null) {
      ThreadLocalHolder.store(DO_NOT_CACHE_CONVERTER_KEY, true);
      ThreadLocalHolder.store(CONTEXT_KEY, converter);
    }
    try {
      return genson.provideConverter(property.type);
    } finally {
      if (converter != null) {
        ThreadLocalHolder.remove(DO_NOT_CACHE_CONVERTER_KEY, Boolean.class);
        ThreadLocalHolder.remove(CONTEXT_KEY, Converter.class);
      }
    }
  }
  @Test
  public void testJsonComplexObjectSkipValue() {
    ComplexObject coo =
        new ComplexObject(
            createPrimitives(),
            Arrays.asList(
                createPrimitives(),
                createPrimitives(),
                createPrimitives(),
                createPrimitives(),
                createPrimitives(),
                createPrimitives()),
            new Primitives[] {createPrimitives(), createPrimitives()});

    DummyWithFieldToSkip dummy =
        new DummyWithFieldToSkip(coo, coo, createPrimitives(), Arrays.asList(coo));
    DummyWithFieldToSkip dummy2 =
        genson.deserialize(dummy.jsonString(), DummyWithFieldToSkip.class);

    ComplexObject.assertCompareComplexObjects(dummy.getO1(), dummy2.getO1());
    ComplexObject.assertCompareComplexObjects(dummy.getO2(), dummy2.getO2());
    Primitives.assertComparePrimitives(dummy.getP(), dummy2.getP());
  }
 @Test
 public void testASMResolverShouldNotFailWhenUsingBootstrapClassloader() {
   assertNotNull(genson.deserialize("{}", Exception.class));
 }
 @Test
 public void testDeserializeEnum() {
   assertEquals(Player.JAVA, genson.deserialize("\"JAVA\"", Player.class));
 }
 @Test
 public void testJsonEmptyObject() {
   String src = "{}";
   Primitives p = genson.deserialize(src, Primitives.class);
   assertNull(p.getText());
 }
 @Test
 public void testJsonEmptyArray() {
   String src = "[]";
   Integer[] p = genson.deserialize(src, Integer[].class);
   assertTrue(p.length == 0);
 }