2008-09-01 05:13:32 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2008 Google Inc.
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
package com.google.gson.functional;
|
|
|
|
|
2008-11-15 03:26:57 +01:00
|
|
|
import java.math.BigDecimal;
|
|
|
|
import java.math.BigInteger;
|
2008-09-01 05:13:32 +02:00
|
|
|
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
|
2008-11-15 03:26:57 +01:00
|
|
|
import com.google.gson.Gson;
|
|
|
|
import com.google.gson.GsonBuilder;
|
|
|
|
import com.google.gson.JsonParseException;
|
|
|
|
import com.google.gson.common.TestTypes.CrazyLongTypeAdapter;
|
2008-09-01 05:13:32 +02:00
|
|
|
|
|
|
|
/**
|
2008-10-10 04:29:06 +02:00
|
|
|
* Functional tests for Json primitive values: integers, and floating point numbers.
|
2008-09-01 05:13:32 +02:00
|
|
|
*
|
|
|
|
* @author Inderjeet Singh
|
|
|
|
* @author Joel Leitch
|
|
|
|
*/
|
|
|
|
public class PrimitiveTest extends TestCase {
|
|
|
|
private Gson gson;
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected void setUp() throws Exception {
|
|
|
|
super.setUp();
|
|
|
|
gson = new Gson();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveIntegerAutoboxedSerialization() {
|
|
|
|
assertEquals("1", gson.toJson(1));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveIntegerAutoboxedDeserialization() {
|
|
|
|
int expected = 1;
|
|
|
|
int actual = gson.fromJson("1", int.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
|
|
|
|
actual = gson.fromJson("1", Integer.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveIntegerAutoboxedInASingleElementArraySerialization() {
|
|
|
|
int target[] = {-9332};
|
|
|
|
assertEquals("[-9332]", gson.toJson(target));
|
|
|
|
assertEquals("[-9332]", gson.toJson(target, int[].class));
|
|
|
|
assertEquals("[-9332]", gson.toJson(target, Integer[].class));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveIntegerAutoboxedInASingleElementArrayDeserialization() {
|
|
|
|
int expected = 1;
|
|
|
|
int actual = gson.fromJson("[1]", int.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
|
|
|
|
actual = gson.fromJson("[1]", Integer.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testReallyLongValuesSerialization() {
|
|
|
|
long value = 333961828784581L;
|
|
|
|
assertEquals("333961828784581", gson.toJson(value));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testReallyLongValuesDeserialization() {
|
|
|
|
String json = "333961828784581";
|
|
|
|
long value = gson.fromJson(json, Long.class);
|
|
|
|
assertEquals(333961828784581L, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveLongAutoboxedSerialization() {
|
|
|
|
assertEquals("1", gson.toJson(1L, long.class));
|
|
|
|
assertEquals("1", gson.toJson(1L, Long.class));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveLongAutoboxedDeserialization() {
|
|
|
|
long expected = 1L;
|
|
|
|
long actual = gson.fromJson("1", long.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
|
|
|
|
actual = gson.fromJson("1", Long.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveLongAutoboxedInASingleElementArraySerialization() {
|
|
|
|
long[] target = {-23L};
|
|
|
|
assertEquals("[-23]", gson.toJson(target));
|
|
|
|
assertEquals("[-23]", gson.toJson(target, long[].class));
|
|
|
|
assertEquals("[-23]", gson.toJson(target, Long[].class));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveLongAutoboxedInASingleElementArrayDeserialization() {
|
|
|
|
long expected = 1L;
|
|
|
|
long actual = gson.fromJson("[1]", long.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
|
|
|
|
actual = gson.fromJson("[1]", Long.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveBooleanAutoboxedSerialization() {
|
|
|
|
assertEquals("true", gson.toJson(true));
|
|
|
|
assertEquals("false", gson.toJson(false));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveBooleanAutoboxedDeserialization() {
|
|
|
|
assertEquals(Boolean.FALSE, gson.fromJson("[false]", Boolean.class));
|
|
|
|
assertEquals(Boolean.TRUE, gson.fromJson("[true]", Boolean.class));
|
|
|
|
|
|
|
|
boolean value = gson.fromJson("false", boolean.class);
|
|
|
|
assertEquals(false, value);
|
|
|
|
value = gson.fromJson("true", boolean.class);
|
|
|
|
assertEquals(true, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveBooleanAutoboxedInASingleElementArraySerialization() {
|
|
|
|
boolean target[] = {false};
|
|
|
|
assertEquals("[false]", gson.toJson(target));
|
|
|
|
assertEquals("[false]", gson.toJson(target, boolean[].class));
|
|
|
|
assertEquals("[false]", gson.toJson(target, Boolean[].class));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveBooleanAutoboxedInASingleElementArrayDeserialization() {
|
|
|
|
assertEquals(Boolean.FALSE, gson.fromJson("[false]", Boolean.class));
|
|
|
|
assertEquals(Boolean.TRUE, gson.fromJson("[true]", Boolean.class));
|
|
|
|
|
|
|
|
boolean value = gson.fromJson("[false]", boolean.class);
|
|
|
|
assertEquals(false, value);
|
|
|
|
value = gson.fromJson("[true]", boolean.class);
|
|
|
|
assertEquals(true, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveDoubleAutoboxedSerialization() {
|
|
|
|
assertEquals("-122.08234335", gson.toJson(-122.08234335));
|
|
|
|
assertEquals("122.08112002", gson.toJson(new Double(122.08112002)));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveDoubleAutoboxedDeserialization() {
|
|
|
|
double actual = gson.fromJson("-122.08858585", double.class);
|
|
|
|
assertEquals(-122.08858585, actual);
|
|
|
|
|
|
|
|
actual = gson.fromJson("122.023900008000", Double.class);
|
|
|
|
assertEquals(122.023900008, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveDoubleAutoboxedInASingleElementArraySerialization() {
|
|
|
|
double[] target = {-122.08D};
|
|
|
|
assertEquals("[-122.08]", gson.toJson(target));
|
|
|
|
assertEquals("[-122.08]", gson.toJson(target, double[].class));
|
|
|
|
assertEquals("[-122.08]", gson.toJson(target, Double[].class));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testPrimitiveDoubleAutoboxedInASingleElementArrayDeserialization() {
|
|
|
|
double expected = -122.08;
|
|
|
|
double actual = gson.fromJson("[-122.08]", double.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
|
|
|
|
actual = gson.fromJson("[-122.08]", Double.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBigDecimalSerialization() {
|
|
|
|
BigDecimal target = new BigDecimal("-122.0e-21");
|
|
|
|
String json = gson.toJson(target);
|
|
|
|
assertEquals(target, new BigDecimal(json));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBigDecimalDeserialization() {
|
|
|
|
BigDecimal target = new BigDecimal("-122.0e-21");
|
|
|
|
String json = "-122.0e-21";
|
|
|
|
assertEquals(target, gson.fromJson(json, BigDecimal.class));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBigDecimalInASingleElementArraySerialization() {
|
|
|
|
BigDecimal[] target = {new BigDecimal("-122.08e-21")};
|
|
|
|
String json = gson.toJson(target);
|
|
|
|
String actual = extractElementFromArray(json);
|
|
|
|
assertEquals(target[0], new BigDecimal(actual));
|
|
|
|
|
|
|
|
json = gson.toJson(target, BigDecimal[].class);
|
|
|
|
actual = extractElementFromArray(json);
|
|
|
|
assertEquals(target[0], new BigDecimal(actual));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBigDecimalInASingleElementArrayDeserialization() {
|
|
|
|
BigDecimal expected = new BigDecimal("-122.08e-21");
|
|
|
|
BigDecimal actual = gson.fromJson("[-122.08e-21]", BigDecimal.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testSmallValueForBigDecimalSerialization() {
|
|
|
|
BigDecimal target = new BigDecimal("1.55");
|
|
|
|
String actual = gson.toJson(target);
|
|
|
|
assertEquals(target.toString(), actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testSmallValueForBigDecimalDeserialization() {
|
|
|
|
BigDecimal expected = new BigDecimal("1.55");
|
|
|
|
BigDecimal actual = gson.fromJson("1.55", BigDecimal.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBigIntegerSerialization() {
|
|
|
|
BigInteger target = new BigInteger("12121211243123245845384534687435634558945453489543985435");
|
|
|
|
assertEquals(target.toString(), gson.toJson(target));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBigIntegerDeserialization() {
|
|
|
|
String json = "12121211243123245845384534687435634558945453489543985435";
|
|
|
|
BigInteger target = new BigInteger(json);
|
|
|
|
assertEquals(target, gson.fromJson(json, BigInteger.class));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBigIntegerInASingleElementArraySerialization() {
|
|
|
|
BigInteger[] target = {new BigInteger("1212121243434324323254365345367456456456465464564564")};
|
|
|
|
String json = gson.toJson(target);
|
|
|
|
String actual = extractElementFromArray(json);
|
|
|
|
assertEquals(target[0], new BigInteger(actual));
|
|
|
|
|
|
|
|
json = gson.toJson(target, BigInteger[].class);
|
|
|
|
actual = extractElementFromArray(json);
|
|
|
|
assertEquals(target[0], new BigInteger(actual));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBigIntegerInASingleElementArrayDeserialization() {
|
|
|
|
BigInteger expected = new BigInteger("34343434343424242423432323243243242");
|
|
|
|
BigInteger actual = gson.fromJson("[34343434343424242423432323243243242]", BigInteger.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testSmallValueForBigIntegerSerialization() {
|
|
|
|
BigInteger target = new BigInteger("15");
|
|
|
|
String actual = gson.toJson(target);
|
|
|
|
assertEquals(target.toString(), actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testSmallValueForBigIntegerDeserialization() {
|
|
|
|
BigInteger expected = new BigInteger("15");
|
|
|
|
BigInteger actual = gson.fromJson("15", BigInteger.class);
|
|
|
|
assertEquals(expected, actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testBadValueForBigIntegerDeserialization() {
|
|
|
|
try {
|
|
|
|
gson.fromJson("15.099", BigInteger.class);
|
|
|
|
fail("BigInteger can not be decimal values.");
|
|
|
|
} catch (JsonParseException expected) { }
|
|
|
|
}
|
2008-11-15 03:26:57 +01:00
|
|
|
|
|
|
|
public void testOverridingDefaultPrimitiveSerialization() {
|
|
|
|
CrazyLongTypeAdapter typeAdapter = new CrazyLongTypeAdapter();
|
|
|
|
gson = new GsonBuilder()
|
|
|
|
.registerTypeAdapter(long.class, typeAdapter)
|
|
|
|
.registerTypeAdapter(Long.class, typeAdapter)
|
|
|
|
.create();
|
|
|
|
long value = 1L;
|
|
|
|
String serializedValue = gson.toJson(value);
|
|
|
|
assertEquals(String.valueOf(value + CrazyLongTypeAdapter.DIFFERENCE), serializedValue);
|
|
|
|
|
|
|
|
long deserializedValue = gson.fromJson(serializedValue, long.class);
|
|
|
|
assertEquals(value, deserializedValue);
|
|
|
|
}
|
2008-09-01 05:13:32 +02:00
|
|
|
|
|
|
|
private String extractElementFromArray(String json) {
|
|
|
|
return json.substring(json.indexOf('[') + 1, json.indexOf(']'));
|
|
|
|
}
|
|
|
|
}
|