net.opentsdb.utils.TestJSON.java Source code

Introduction

Here is the source code for net.opentsdb.utils.TestJSON.java

Source

// This file is part of OpenTSDB.
// Copyright (C) 2013-2014  The OpenTSDB Authors.
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or (at your
// option) any later version.  This program is distributed in the hope that it
// will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
// General Public License for more details.  You should have received a copy
// of the GNU Lesser General Public License along with this program.  If not,
// see <http://www.gnu.org/licenses/>.
package net.opentsdb.utils;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.HashMap;
import java.util.HashSet;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.Test;

public final class TestJSON {

    @Test
    public void getMapperNotNull() {
        assertNotNull(JSON.getMapper());
    }

    @Test
    public void getFactoryNotNull() {
        assertNotNull(JSON.getFactory());
    }

    @Test
    public void mapperAllowNonNumerics() {
        assertTrue(JSON.getMapper().isEnabled(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS));
    }

    // parseToObject - Strings && Class
    @Test
    public void parseToObjectStringUTFString() throws Exception {
        @SuppressWarnings("unchecked")
        HashMap<String, String> map = JSON.parseToObject("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}",
                HashMap.class);
        assertEquals("ariennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test
    public void parseToObjectStringAsciiString() throws Exception {
        @SuppressWarnings("unchecked")
        HashMap<String, String> map = JSON.parseToObject("{\"utf\":\"aeriennes\",\"ascii\":\"aariennes\"}",
                HashMap.class);
        assertEquals("aeriennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectStringNull() throws Exception {
        JSON.parseToObject((String) null, HashMap.class);
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectStringEmpty() throws Exception {
        JSON.parseToObject("", HashMap.class);
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectStringBad() throws Exception {
        String json = "{\"notgonnafinish";
        JSON.parseToObject(json, HashMap.class);
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectStringBadMap() throws Exception {
        JSON.parseToObject("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}", HashSet.class);
    }

    // parseToObject - Byte && Class
    public void parseToObjectByteUTFString() throws Exception {
        @SuppressWarnings("unchecked")
        HashMap<String, String> map = JSON
                .parseToObject("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}".getBytes(), HashMap.class);
        assertEquals("ariennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test
    public void parseToObjectByteString() throws Exception {
        @SuppressWarnings("unchecked")
        HashMap<String, String> map = JSON
                .parseToObject("{\"utf\":\"aeriennes\",\"ascii\":\"aariennes\"}".getBytes(), HashMap.class);
        assertEquals("aeriennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectByteNull() throws Exception {
        byte[] json = null;
        JSON.parseToObject(json, HashMap.class);
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectByteBad() throws Exception {
        byte[] json = "{\"notgonnafinish".getBytes();
        JSON.parseToObject(json, HashMap.class);
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectByteBadMap() throws Exception {
        JSON.parseToObject("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}".getBytes(), HashSet.class);
    }

    //parseToObject - Strings && Type
    @Test
    public void parseToObjectStringTypeUTFString() throws Exception {
        HashMap<String, String> map = JSON.parseToObject("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}",
                getTRMap());
        assertEquals("ariennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test
    public void parseToObjectStringTypeAsciiString() throws Exception {
        HashMap<String, String> map = JSON.parseToObject("{\"utf\":\"aeriennes\",\"ascii\":\"aariennes\"}",
                getTRMap());
        assertEquals("aeriennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectStringTypeNull() throws Exception {
        JSON.parseToObject((String) null, getTRMap());
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectStringTypeEmpty() throws Exception {
        JSON.parseToObject("", getTRMap());
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectStringTypeBad() throws Exception {
        JSON.parseToObject("{\"notgonnafinish", getTRMap());
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectStringTypeBadMap() throws Exception {
        JSON.parseToObject("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}", getTRSet());
    }

    // parseToObject - Byte && Class
    public void parseToObjectByteTypeUTFString() throws Exception {
        HashMap<String, String> map = JSON
                .parseToObject("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}".getBytes(), getTRMap());
        assertEquals("ariennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test
    public void parseToObjectByteTypeString() throws Exception {
        HashMap<String, String> map = JSON
                .parseToObject("{\"utf\":\"aeriennes\",\"ascii\":\"aariennes\"}".getBytes(), getTRMap());
        assertEquals("aeriennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectByteTypeNull() throws Exception {
        JSON.parseToObject((byte[]) null, getTRMap());
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectByteTypeBad() throws Exception {
        byte[] json = "{\"notgonnafinish".getBytes();
        JSON.parseToObject(json, getTRMap());
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToObjectByteTypeBadMap() throws Exception {
        JSON.parseToObject("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}".getBytes(), getTRSet());
    }

    // parseToStream - String
    @Test
    public void parseToStreamUTFString() throws Exception {
        JsonParser jp = JSON.parseToStream("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}");
        HashMap<String, String> map = this.parseToMap(jp);
        assertEquals("ariennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test
    public void parseToStreamASCIIString() throws Exception {
        JsonParser jp = JSON.parseToStream("{\"utf\":\"aeriennes\",\"ascii\":\"aariennes\"}");
        HashMap<String, String> map = this.parseToMap(jp);
        assertEquals("aeriennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToStreamStringNull() throws Exception {
        JSON.parseToStream((String) null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToStreamStringEmpty() throws Exception {
        JSON.parseToStream("");
    }

    @Test
    public void parseToStreamStringUnfinished() throws Exception {
        String json = "{\"notgonnafinish";
        JsonParser jp = JSON.parseToStream(json);
        assertNotNull(jp);
    }

    // parseToStream - Byte
    @Test
    public void parseToStreamUTFSByte() throws Exception {
        JsonParser jp = JSON.parseToStream("{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}".getBytes("UTF8"));
        HashMap<String, String> map = this.parseToMap(jp);
        assertEquals("ariennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test
    public void parseToStreamASCIIByte() throws Exception {
        JsonParser jp = JSON.parseToStream("{\"utf\":\"aeriennes\",\"ascii\":\"aariennes\"}".getBytes());
        HashMap<String, String> map = this.parseToMap(jp);
        assertEquals("aeriennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToStreamByteNull() throws Exception {
        JSON.parseToStream((byte[]) null);
    }

    // parseToStream - Stream
    @Test
    public void parseToStreamUTFSStream() throws Exception {
        InputStream is = new ByteArrayInputStream(
                "{\"utf\":\"ariennes\",\"ascii\":\"aariennes\"}".getBytes("UTF8"));
        HashMap<String, String> map = this.parseToMap(is);
        assertEquals("ariennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test
    public void parseToStreamASCIIStream() throws Exception {
        InputStream is = new ByteArrayInputStream("{\"utf\":\"aeriennes\",\"ascii\":\"aariennes\"}".getBytes());
        HashMap<String, String> map = this.parseToMap(is);
        assertEquals("aeriennes", map.get("utf"));
        assertEquals("aariennes", map.get("ascii"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void parseToStreamStreamNull() throws Exception {
        JSON.parseToStream((InputStream) null);
    }

    // serializeToString
    @Test
    public void serializeToString() throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("utf", "ariennes");
        map.put("ascii", "aariennes");
        String json = JSON.serializeToString(map);
        assertNotNull(json);
        assertFalse(json.isEmpty());
        assertTrue(json.matches(".*[{,]\"ascii\":\"aariennes\"[,}].*"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void serializeToStringNull() throws Exception {
        JSON.serializeToString((HashMap<String, String>) null);
    }

    // serializeToBytes
    @Test
    public void serializeToBytes() throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("utf", "ariennes");
        map.put("ascii", "aariennes");
        byte[] raw = JSON.serializeToBytes(map);
        assertNotNull(raw);
        String json = new String(raw, "UTF8");
        assertTrue(json.matches(".*[{,]\"ascii\":\"aariennes\"[,}].*"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void serializeToBytesNull() throws Exception {
        JSON.serializeToString((HashMap<String, String>) null);
    }

    // serializeToJSONString
    @Test
    public void serializeToJSONString() throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("utf", "ariennes");
        map.put("ascii", "aariennes");
        String json = JSON.serializeToJSONPString("dummycb", map);
        assertNotNull(json);
        assertFalse(json.isEmpty());
        assertTrue(json.matches("dummycb\\(.*[{,]\"ascii\":\"aariennes\"[,}].*\\)"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void serializeToJSONStringNullData() throws Exception {
        JSON.serializeToJSONPString("dummycb", (HashMap<String, String>) null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void serializeToJSONStringNullCB() throws Exception {
        JSON.serializeToJSONPString((String) null, (HashMap<String, String>) null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void serializeToJSONStringEmptyCB() throws Exception {
        JSON.serializeToJSONPString("", (HashMap<String, String>) null);
    }

    // serializeToJSONPBytes
    @Test
    public void serializeToJSONPBytes() throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("utf", "ariennes");
        map.put("ascii", "aariennes");
        byte[] raw = JSON.serializeToJSONPBytes("dummycb", map);
        assertNotNull(raw);
        String json = new String(raw, "UTF8");
        assertTrue(json.matches("dummycb\\(.*[{,]\"ascii\":\"aariennes\"[,}].*\\)"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void serializeToJSONPBytesNullData() throws Exception {
        JSON.serializeToJSONPBytes("dummycb", (HashMap<String, String>) null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void serializeToJSONPBytesNullCB() throws Exception {
        JSON.serializeToJSONPBytes((String) null, (HashMap<String, String>) null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void serializeToJSONPBytesEmptyCB() throws Exception {
        JSON.serializeToJSONPBytes("", (HashMap<String, String>) null);
    }

    /** Helper to parse an input stream into a map */
    private HashMap<String, String> parseToMap(final InputStream is) throws Exception {
        JsonParser jp = JSON.parseToStream(is);
        HashMap<String, String> map = new HashMap<String, String>();
        String field = "";
        String value;
        while (jp.nextToken() != null) {
            if (jp.getCurrentToken() == JsonToken.FIELD_NAME && jp.getCurrentName() != null) {
                field = jp.getCurrentName();
            } else if (jp.getCurrentToken() == JsonToken.VALUE_STRING) {
                value = jp.getText();
                map.put(field, value);
            }
        }
        return map;
    }

    /** Helper to parse an input stream into a map */
    private HashMap<String, String> parseToMap(final JsonParser jp) throws Exception {
        HashMap<String, String> map = new HashMap<String, String>();
        String field = "";
        String value;
        while (jp.nextToken() != null) {
            if (jp.getCurrentToken() == JsonToken.FIELD_NAME && jp.getCurrentName() != null) {
                field = jp.getCurrentName();
            } else if (jp.getCurrentToken() == JsonToken.VALUE_STRING) {
                value = jp.getText();
                map.put(field, value);
            }
        }
        return map;
    }

    /** Helper to return a TypeReference for a Hash Map */
    private final TypeReference<HashMap<String, String>> getTRMap() {
        return new TypeReference<HashMap<String, String>>() {
        };
    }

    /** Helper to return a TypeReference for a Hash Set */
    private final TypeReference<HashSet<String>> getTRSet() {
        return new TypeReference<HashSet<String>>() {
        };
    }
}