Java 类com.fasterxml.jackson.core.JsonFactory 实例源码

private StructObjectInspector initialize(final ObjectInspector jsonArg, final ObjectInspector jqArg, final List<ObjectInspector> nameAndTypeArgs) throws UDFArgumentException {
    this.in = Arguments.asString(jsonArg, "JSON");

    try {
        this.jq = JsonQuery.compile(Arguments.asConstantNonNullString(jqArg, "JQ"));
    } catch (final JsonQueryException e) {
        throw new UDFArgumentException("JQ is invalid: " + e.getMessage());
    }

    this.marshaller = ResultObjectMarshallers.create(Arguments.asConstantNonNullStrings(nameAndTypeArgs, "TYPE or NAME:TYPE"));

    this.scope = new Scope();
    this.mapper = new ObjectMapper(new JsonFactory().enable(Feature.ALLOW_UNQUOTED_CONTROL_CHARS));

    return marshaller.objectInspector();
}

/**
 * @param content
 * @throws JsonParseException
 * @throws IOException
 */
public PageInstance parse(String content) throws JsonParseException, IOException {
    JsonFactory f = new JsonFactory();
    JsonParser parser = f.createJsonParser(content);

    JsonToken current = parser.nextToken(); // move to the start of the
    // object

    String instanceId = getNextTextValue("sid", parser); // get instanceId

    String pageId = getNextTextValue("cid", parser); // get pageId

    current = parser.nextToken(); // move to field: segments
    assertExpectedFiled(parser.getCurrentName(), "segments", parser.getCurrentLocation());

    PageInstance pageInstance = new PageInstance();
    pageInstance.setCid(pageId);
    pageInstance.setSid(Long.valueOf(instanceId));
    pageInstance.setSegments(parseSegments(parser));
    return pageInstance;
    // 构建组件树，用于递归渲染
    // pageInstance.buildComponentTree();

}

/**
 * Internal constructor used when creating child instances.
 */
private CharsToNameCanonicalizer(CharsToNameCanonicalizer parent, int flags, int seed,
        TableInfo parentState)
{
    _parent = parent;
    _seed = seed;
    _tableInfo = null; // not used by child tables
    _flags = flags;
    _canonicalize = JsonFactory.Feature.CANONICALIZE_FIELD_NAMES.enabledIn(flags);

    // Then copy shared state
    _symbols = parentState.symbols;
    _buckets = parentState.buckets;

    _size = parentState.size;
    _longestCollisionList = parentState.longestCollisionList;

    // Hard-coded fill factor, 75%
    int arrayLen = (_symbols.length);
    _sizeThreshold = _thresholdSize(arrayLen);
    _indexMask =  (arrayLen - 1);

    // Need to make copies of arrays, if/when adding new entries
    _hashShared = true;
}

private void _testFailOnWritingStringFromReaderWithTooFewCharacters(JsonFactory f, boolean useReader) throws Exception{
    JsonGenerator gen;
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    if (useReader) {
        gen = f.createGenerator(ObjectWriteContext.empty(), new OutputStreamWriter(bout, "UTF-8"));
    } else {
        gen = f.createGenerator(ObjectWriteContext.empty(), bout, JsonEncoding.UTF8);
    }
    gen.writeStartObject();

    try {
        String testStr = "aaaaaaaaa";
        StringReader reader = new StringReader(testStr);
        gen.writeFieldName("a");
        gen.writeString(reader, testStr.length() + 1);
        gen.flush();
        String json = bout.toString("UTF-8");
        fail("Should not have let "+gen.getClass().getName()+".writeString() ': output = "+json);
    } catch (JsonProcessingException e) {
        verifyException(e, "Didn't read enough from reader");
    }
    gen.close();
}

private void _testFailOnWritingStringFromNullReader(JsonFactory f, boolean useReader) throws Exception{
    JsonGenerator gen;
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    if (useReader) {
        gen = f.createGenerator(ObjectWriteContext.empty(), new OutputStreamWriter(bout, "UTF-8"));
    } else {
        gen = f.createGenerator(ObjectWriteContext.empty(), bout, JsonEncoding.UTF8);
    }
    gen.writeStartObject();

    try {
        gen.writeFieldName("a");
        gen.writeString(null, -1);
        gen.flush();
        String json = bout.toString("UTF-8");
        fail("Should not have let "+gen.getClass().getName()+".writeString() ': output = "+json);
    } catch (JsonProcessingException e) {
        verifyException(e, "null reader");
    }
    gen.close();
}

private void _testDupFieldNameWrites(JsonFactory f, boolean useReader) throws Exception
{
    JsonGenerator gen;
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    if (useReader) {
        gen = f.createGenerator(ObjectWriteContext.empty(), new OutputStreamWriter(bout, "UTF-8"));
    } else {
        gen = f.createGenerator(ObjectWriteContext.empty(), bout, JsonEncoding.UTF8);
    }
    gen.writeStartObject();
    gen.writeFieldName("a");

    try {
        gen.writeFieldName("b");
        gen.flush();
        String json = bout.toString("UTF-8");
        fail("Should not have let two consecutive field name writes succeed: output = "+json);
    } catch (JsonProcessingException e) {
        verifyException(e, "can not write a field name, expecting a value");
    }
    gen.close();
}

private void _testFailOnWritingFieldNameInRoot(JsonFactory f, boolean useReader) throws Exception
{
    JsonGenerator gen;
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    if (useReader) {
        gen = f.createGenerator(ObjectWriteContext.empty(), new OutputStreamWriter(bout, "UTF-8"));
    } else {
        gen = f.createGenerator(ObjectWriteContext.empty(), bout, JsonEncoding.UTF8);
    }
    try {
        gen.writeFieldName("a");
        gen.flush();
        String json = bout.toString("UTF-8");
        fail("Should not have let "+gen.getClass().getName()+".writeFieldName() be used in root context: output = "+json);
    } catch (JsonProcessingException e) {
        verifyException(e, "can not write a field name");
    }
    gen.close();
}

@Override
public void write(OutputStream output) throws IOException, WebApplicationException {
    try (
            Writer writer = new BufferedWriter(new OutputStreamWriter(output));
            JsonGenerator jsonGenerator = new JsonFactory(new ObjectMapper()).createGenerator(writer)
    ) {
        BigInteger index = BigInteger.ONE;
        jsonGenerator.writeStartArray();
        for (BigInteger v : (Iterable<BigInteger>) bigIntegerStream::iterator) {
            try {
                jsonGenerator.writeObject(new Sequence(index, v));
                index = index.add(BigInteger.ONE);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }
        jsonGenerator.writeEndArray();
    } catch (UncheckedIOException ignored) {}
}

/**
 * Creates a new EclipseParser
 *
 * @param sourceFile String of source file to read
 * @param outJ       JSON parsed out
 * @throws IOException when file can't be opened or errors in reading/writing
 */
public EclipseParser(String sourceFile, PrintStream outJ, boolean prettyprint) throws IOException {

    File file = new File(sourceFile);
    final BufferedReader reader = new BufferedReader(new FileReader(file));
    char[] source = IOUtils.toCharArray(reader);
    reader.close();
    this.parser = ASTParser.newParser(AST.JLS8);
    parser.setSource(source);
    parser.setKind(ASTParser.K_COMPILATION_UNIT);

    final JsonFactory jsonF = new JsonFactory();
    jG = jsonF.createGenerator(outJ);
    if (prettyprint) {
        jG.setPrettyPrinter(new DefaultPrettyPrinter());
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
    }
    mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
    SimpleModule module = new SimpleModule();
    module.addSerializer(ASTNode.class, new NodeSerializer());
    mapper.registerModule(module);
}

public void _testTokenAccess(JsonFactory jf, boolean useStream) throws Exception
{
    final String DOC = "[ ]";
    JsonParser jp = useStream ?
            jf.createParser(ObjectReadContext.empty(), new ByteArrayInputStream(DOC.getBytes("UTF-8")))
            : jf.createParser(ObjectReadContext.empty(), DOC);
    assertNull(jp.currentToken());
    jp.clearCurrentToken();
    assertNull(jp.currentToken());
    assertNull(jp.getEmbeddedObject());
    assertToken(JsonToken.START_ARRAY, jp.nextToken());
    assertToken(JsonToken.START_ARRAY, jp.currentToken());
    jp.clearCurrentToken();
    assertNull(jp.currentToken());
    // Also: no codec defined by default
    try {
        jp.readValueAsTree();
        fail("Should get exception without codec");
    } catch (UnsupportedOperationException e) {
        verifyException(e, "Operation not supported");
    }
    jp.close();
}

public void testParseException() throws Exception
{
    JsonFactory jf = new JsonFactory();
    JsonParser p = jf.createParser(ObjectReadContext.empty(), "  { garbage! }");
    JsonParseException exc = null;
    try {
        p.nextToken();
        p.nextToken();
        fail("Should not get here");
    } catch (JsonParseException e) {
        exc = e;
    }
    p.close();
    byte[] stuff = jdkSerialize(exc);
    JsonParseException result = jdkDeserialize(stuff);
    assertNotNull(result);
}

@Test
public void readJSONFile() {

    // new error-free endpoint
    Endpoint endpoint = resources.createEndpoint("GET", "/test-json-file", "200");

    // write json file on temporary directory
    ObjectMapper mapperJson = new ObjectMapper(new JsonFactory());
    File file = TempIO.buildFile("read-json-file", ".lyre", resources.getDirectory(0));

    try {
        mapperJson.writeValue(file, endpoint);
    } catch (IOException e) {
        fail("Couldn't write on temporary file: " + e.getMessage());
    }

    reader.read(file);

    //should have a object node with json file on it.
    assertThat(reader.getObjectNodes()).isNotEmpty();
    assertThat(reader.getObjectNodes().get(file.getAbsolutePath())).isNotNull();

}

private ObjectMapper createMapper(JsonFactory mapping, ClassLoader classLoader) {
    ObjectMapper mapper = new ObjectMapper(mapping);
    mapper.addMixIn(MasterSlaveServersConfig.class, MasterSlaveServersConfigMixIn.class);
    mapper.addMixIn(SingleServerConfig.class, SingleSeverConfigMixIn.class);
    mapper.addMixIn(Config.class, ConfigMixIn.class);
    mapper.addMixIn(CodecProvider.class, ClassMixIn.class);
    mapper.addMixIn(ResolverProvider.class, ClassMixIn.class);
    mapper.addMixIn(Codec.class, ClassMixIn.class);
    mapper.addMixIn(RedissonNodeInitializer.class, ClassMixIn.class);
    mapper.addMixIn(LoadBalancer.class, ClassMixIn.class);
    FilterProvider filterProvider = new SimpleFilterProvider()
            .addFilter("classFilter", SimpleBeanPropertyFilter.filterOutAllExcept());
    mapper.setFilterProvider(filterProvider);
    mapper.setSerializationInclusion(Include.NON_NULL);

    if (classLoader != null) {
        TypeFactory tf = TypeFactory.defaultInstance()
                .withClassLoader(classLoader);
        mapper.setTypeFactory(tf);
    }

    return mapper;
}

/**
 * @return A json representation of the topology. Intended for printing only.
 */
public static final String toJson(ITopology topo, boolean pretty) throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    if (pretty)
        mapper.enable(SerializationFeature.INDENT_OUTPUT);

    StringWriter sw = new StringWriter();
    JsonFactory f = mapper.getFactory();

    JsonGenerator g = f.createGenerator(sw);

    g.writeStartObject();
    // use TreeSet to sort the list
    g.writeObjectField("switches", new TreeSet<String>(topo.getSwitches().keySet()));
    g.writeObjectField("links", new TreeSet<String>(topo.getLinks().keySet()));
    g.writeEndObject();
    g.close();

    return sw.toString();
}

public static void OutputStreamDemo() throws IOException {
    String out = "";
    JsonFactory f = new JsonFactory();
    FileOutputStream fos = new FileOutputStream(new File("user.out.json"));
    JsonGenerator g = f.createGenerator(fos);

    g.writeStartObject();
    g.writeObjectFieldStart("name");
    g.writeStringField("first", "BorLion");
    g.writeStringField("last", "Zhu");
    g.writeEndObject(); // for field 'name'
    g.writeStringField("gender", "MALE");
    g.writeBooleanField("verified", true);
    g.writeBinaryField("userImage", "Rm9vYmFyIQ==".getBytes());
    g.writeEndObject();
    g.writeRaw('\n');
    g.close();

}

/**
 * Serialises the {@link DecisionTreeRuleSet} into the {@link OutputStream} in Json format.
 *
 * <p>Any exceptions are wrapped and thrown via the {@link EhSupport} API.
 *
 * @param out     {@link OutputStream} to write into
 * @param ruleSet {@link DecisionTreeRuleSet} to serialise
 */
public static void toJsonWriter(final OutputStream out, final DecisionTreeRuleSet ruleSet) {
    EhSupport.propagate(() -> {
        try (JsonGenerator generator = new JsonFactory().createGenerator(out, JsonEncoding.UTF8)) {
            generator.useDefaultPrettyPrinter();
            generator.writeStartObject();
            generator.writeStringField("name", ruleSet.getName());
            writeRuleSetDrivers(generator, ruleSet);
            writeRuleSetGroups(generator, ruleSet.getValueGroups());
            writeRules(generator, ruleSet);

            generator.writeEndObject();
            generator.flush();
        }
    });
}

/**
 * Constructs a new response handler that will use the specified JSON unmarshaller to unmarshall
 * the service response and uses the specified response element path to find the root of the
 * business data in the service's response.
 * @param responseUnmarshaller    The JSON unmarshaller to use on the response.
 * @param simpleTypeUnmarshallers List of unmarshallers to be used for scalar types.
 * @param customTypeMarshallers   List of custom unmarshallers to be used for special types.
 * @param jsonFactory             the json factory to be used for parsing the response.
 */
public JsonResponseHandler(Unmarshaller<T, JsonUnmarshallerContext> responseUnmarshaller,
                           Map<Class<?>, Unmarshaller<?, JsonUnmarshallerContext>> simpleTypeUnmarshallers,
                           Map<UnmarshallerType, Unmarshaller<?, JsonUnmarshallerContext>> customTypeMarshallers,
                           JsonFactory jsonFactory, boolean needsConnectionLeftOpen,
                           boolean isPayloadJson) {
    /*
     * Even if the invoked operation just returns null, we still need an
     * unmarshaller to run so we can pull out response metadata.
     *
     * We might want to pass this in through the client class so that we
     * don't have to do this check here.
     */
    this.responseUnmarshaller =
            responseUnmarshaller != null ? responseUnmarshaller : new VoidJsonUnmarshaller<T>();

    this.needsConnectionLeftOpen = needsConnectionLeftOpen;
    this.isPayloadJson = isPayloadJson;

    this.simpleTypeUnmarshallers = ValidationUtils.assertNotNull(simpleTypeUnmarshallers, "simple type unmarshallers");
    this.customTypeMarshallers = ValidationUtils.assertNotNull(customTypeMarshallers, "custom type marshallers");
    this.jsonFactory = ValidationUtils.assertNotNull(jsonFactory, "JSONFactory");
}

RaceTrack(String filename) throws IOException {
    ClassLoader classLoader = getClass().getClassLoader();

    double len = 0.0;
    try (JsonParser parser = new JsonFactory().createParser(classLoader.getResource(filename))) {
        while (parser.nextToken() != JsonToken.END_OBJECT) {
            if (Objects.equals(parser.getCurrentName(), "parts")) {
                // We found parts so load them
                if (parser.nextToken() != JsonToken.START_ARRAY) {
                    throw new IOException("Array expected.");
                }
                int index = 0;
                while (parser.nextToken() == JsonToken.START_OBJECT) {
                    Part part = loadPart(index, parser, len);
                    len += part.length;
                    parts.add(part);
                    index += 1;
                }
                break;
            }
        }
    }

    length = len;
    trackFile = filename;
}

public String toString(boolean pretty)
{
   try
   {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      JsonGenerator json = new JsonFactory().createGenerator(baos);
      if (pretty)
         json.useDefaultPrettyPrinter();
      write(json, new HashSet());
      json.flush();
      baos.flush();

      return new String(baos.toByteArray());
   }
   catch (Exception ex)
   {
      throw new RuntimeException(ex);
   }
}

@Test
public void multiDimTest() throws JsonProcessingException, IOException
{
    String json = "{\"request\":{\"values\":[[1.0]]}}";

    System.out.println(json);
    ObjectMapper mapper = new ObjectMapper();
    JsonFactory factory = mapper.getFactory();
    JsonParser parser = factory.createParser(json);
    JsonNode j = mapper.readTree(parser);
    JsonNode values = j.get("request").get("values");

    double[][] v = mapper.readValue(values.toString(),double[][].class);
    double[] vs = Doubles.concat(v);
    int[] shape = {v.length,v[0].length };
    ((ObjectNode) j.get("request")).replace("values",mapper.valueToTree(vs));
    ((ObjectNode) j.get("request")).set("shape",mapper.valueToTree(shape));
    System.out.println(j.toString());
}

@Test
public void constructor_ThrowsException_ForMissingMediaType() {
  // Assert
  thrown.expect(NullPointerException.class);

  // Act
  new AbstractJsonGeneratorTupleEntityWriter(null) {

    @Override
    protected JsonFactory createFactory() {
      return null;
    }

    @Override
    protected AbstractTupleQueryResultSerializer createSerializer() {
      return null;
    }
  };
}

private String buildJSONFromFields(Collection<SearchHitField> values) {
    JsonFactory nodeFactory = new JsonFactory();
    try {
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        JsonGenerator generator = nodeFactory.createGenerator(stream, JsonEncoding.UTF8);
        generator.writeStartObject();
        for (SearchHitField value : values) {
            if (value.getValues().size() > 1) {
                generator.writeArrayFieldStart(value.getName());
                for (Object val : value.getValues()) {
                    generator.writeObject(val);
                }
                generator.writeEndArray();
            } else {
                generator.writeObjectField(value.getName(), value.getValue());
            }
        }
        generator.writeEndObject();
        generator.flush();
        return new String(stream.toByteArray(), Charset.forName("UTF-8"));
    } catch (IOException e) {
        return null;
    }
}

@Test
public void translateJavascriptToBinary() throws Exception {
    InputStream snapshotIn = getClass().getResourceAsStream("l3book_snapshot.js");

    JsonFactory jsonFactory = new JsonFactory();
    JsonParser parser = jsonFactory.createParser(snapshotIn);

    OrderBookSnapshot snapshot = new OrderBookSnapshot();
    snapshot.decodeFrame(parser);

    RecordContext ctx = new InMemoryRecordContext();

    OrderBookSnapshotEvent event = new OrderBookSnapshotEvent(snapshot);
    byte[] data = event.encodeRecord(ctx);

    OrderBookSnapshotEvent decoded = new OrderBookSnapshotEvent();
    decoded.decodeRecord(ctx, ByteBuffer.wrap(data));

    assertEquals(snapshot.getSequence(), decoded.getSnapshot().getSequence());
    assertEquals(snapshot.getBids().size(), decoded.getSnapshot().getBids().size());
    assertEquals(snapshot.getAsks().size(), decoded.getSnapshot().getAsks().size());
}

/**
 * Constructs a new response handler that will use the specified JSON unmarshaller to unmarshall
 * the service response and uses the specified response element path to find the root of the
 * business data in the service's response.
 *
 * @param responseUnmarshaller    The JSON unmarshaller to use on the response.
 * @param simpleTypeUnmarshallers List of unmarshallers to be used for scalar types.
 * @param jsonFactory             the json factory to be used for parsing the response.
 */
public JsonResponseHandler(Unmarshaller<T, JsonUnmarshallerContext> responseUnmarshaller,
                           Map<Class<?>, Unmarshaller<?, JsonUnmarshallerContext>> simpleTypeUnmarshallers,
                           JsonFactory jsonFactory, boolean needsConnectionLeftOpen,
                           boolean isPayloadJson) {
    /*
     * Even if the invoked operation just returns null, we still need an
     * unmarshaller to run so we can pull out response metadata.
     *
     * We might want to pass this in through the client class so that we
     * don't have to do this check here.
     */
    this.responseUnmarshaller =
            responseUnmarshaller != null ? responseUnmarshaller : new VoidJsonUnmarshaller<T>();

    this.needsConnectionLeftOpen = needsConnectionLeftOpen;
    this.isPayloadJson = isPayloadJson;

    this.simpleTypeUnmarshallers = ValidationUtils
            .assertNotNull(simpleTypeUnmarshallers, "simple type unmarshallers");
    this.jsonFactory = ValidationUtils.assertNotNull(jsonFactory, "JSONFactory");
}

private static Map<String, Object> extractErrorDetailsFromResponse(ClientHttpResponse response) throws IOException {
    ObjectMapper mapper = new ObjectMapper(new JsonFactory());
    try {
        return mapper.readValue(response.getBody(), new TypeReference<Map<String, Object>>() {
        });
    } catch (JsonParseException e) {
        log.error("Can not parse error details from response", e);
        return Collections.emptyMap();
    }
}

private String _addSymbol(char[] buffer, int start, int len, int h, int index)
{
    if (_hashShared) { //need to do copy-on-write?
        copyArrays();
        _hashShared = false;
    } else if (_size >= _sizeThreshold) { // Need to expand?
        rehash();
        /* Need to recalc hash; rare occurence (index mask has been
         * recalculated as part of rehash)
         */
        index = _hashToIndex(calcHash(buffer, start, len));
    }

    String newSymbol = new String(buffer, start, len);
    if (JsonFactory.Feature.INTERN_FIELD_NAMES.enabledIn(_flags)) {
        newSymbol = InternCache.instance.intern(newSymbol);
    }
    ++_size;
    // Ok; do we need to add primary entry, or a bucket?
    if (_symbols[index] == null) {
        _symbols[index] = newSymbol;
    } else {
        final int bix = (index >> 1);
        Bucket newB = new Bucket(newSymbol, _buckets[bix]);
        int collLen = newB.length;
        if (collLen > MAX_COLL_CHAIN_LENGTH) {
            // 23-May-2014, tatu: Instead of throwing an exception right away,
            //    let's handle in bit smarter way.
            _handleSpillOverflow(bix, newB);
        } else {
            _buckets[bix] = newB;
            _longestCollisionList = Math.max(collLen, _longestCollisionList);
        }
    }
    return newSymbol;
}

/**
 * Factory method used to create actual symbol table instance to
 * use for parsing.
 */
public ByteQuadsCanonicalizer makeChild(int flags) {
    return new ByteQuadsCanonicalizer(this,
            JsonFactory.Feature.INTERN_FIELD_NAMES.enabledIn(flags),
            _seed,
            JsonFactory.Feature.FAIL_ON_SYMBOL_HASH_OVERFLOW.enabledIn(flags),
            _tableInfo.get());
}

private void _testCurrentName(JsonFactory jf, boolean useStream) throws Exception
{
    final String DOC = "{\"first\":{\"second\":3, \"third\":false}}";
    JsonParser jp = useStream ?
            jf.createParser(ObjectReadContext.empty(), new ByteArrayInputStream(DOC.getBytes("UTF-8")))
            : jf.createParser(ObjectReadContext.empty(), new StringReader(DOC));
    assertNull(jp.currentToken());
    assertToken(JsonToken.START_OBJECT, jp.nextToken());
    assertToken(JsonToken.FIELD_NAME, jp.nextToken());
    assertEquals("first", jp.currentName());
    assertToken(JsonToken.START_OBJECT, jp.nextToken());
    assertEquals("first", jp.currentName()); // still the same...
    jp.overrideCurrentName("foobar");
    assertEquals("foobar", jp.currentName()); // but not any more!

    assertToken(JsonToken.FIELD_NAME, jp.nextToken());
    assertEquals("second", jp.currentName());
    assertToken(JsonToken.VALUE_NUMBER_INT, jp.nextToken());
    assertEquals("second", jp.currentName());

    assertToken(JsonToken.FIELD_NAME, jp.nextToken());
    assertEquals("third", jp.currentName());
    assertToken(JsonToken.VALUE_FALSE, jp.nextToken());
    assertEquals("third", jp.currentName());

    assertToken(JsonToken.END_OBJECT, jp.nextToken());
    // should retain overrides, too
    assertEquals("foobar", jp.currentName());

    assertToken(JsonToken.END_OBJECT, jp.nextToken());
    jp.clearCurrentToken();
    assertNull(jp.currentToken());
    jp.close();
}

public AsyncMissingValuesInObjectTest(Collection<JsonParser.Feature> features) {
    this.factory = new JsonFactory();
    this.features = new HashSet<JsonParser.Feature>(features);

    for (JsonParser.Feature feature : features) {
        factory.enable(feature);
    }
}

public void testJsonFactorySerializable() throws Exception
{
    JsonFactory f = new JsonFactory();
    String origJson = "{\"simple\":[1,true,{}]}";
    assertEquals(origJson, _copyJson(f, origJson, false));

    // Ok: freeze dry factory, thaw, and try to use again:
    byte[] frozen = jdkSerialize(f);
    JsonFactory f2 = jdkDeserialize(frozen);
    assertNotNull(f2);
    assertEquals(origJson, _copyJson(f2, origJson, false));

    // Let's also try byte-based variant, for fun...
    assertEquals(origJson, _copyJson(f2, origJson, true));
}

public void testLocation() throws Exception
{
    JsonFactory jf = new JsonFactory();
    JsonParser jp = jf.createParser(ObjectReadContext.empty(), "  { }");
    assertToken(JsonToken.START_OBJECT, jp.nextToken());
    JsonLocation loc = jp.getCurrentLocation();

    byte[] stuff = jdkSerialize(loc);
    JsonLocation loc2 = jdkDeserialize(stuff);
    assertNotNull(loc2);

    assertEquals(loc.getLineNr(), loc2.getLineNr());
    assertEquals(loc.getColumnNr(), loc2.getColumnNr());
    jp.close();
}

@Test
public void handle_NoUnmarshallersAdded_ReturnsGenericAmazonServiceException() throws
                                                                               Exception {
    responseHandler = new JsonErrorResponseHandler(new ArrayList<JsonErrorUnmarshaller>(),
                                                   new JsonErrorCodeParser(),
                                                   JsonErrorMessageParser.DEFAULT_ERROR_MESSAGE_PARSER,
                                                   new JsonFactory());

    AmazonServiceException ase = responseHandler.handle(httpResponse);

    assertNotNull(ase);
}

protected void _copyJson(JsonFactory f, String json, JsonGenerator g) throws IOException
{
    JsonParser p = f.createParser(ObjectReadContext.empty(), json);
    while (p.nextToken() != null) {
        g.copyCurrentEvent(p);
    }
    p.close();
    g.close();
}

public static void parsePerson() {
    try {
        JsonFactory jsonfactory = new JsonFactory();
        JsonParser parser = jsonfactory.createParser(new File("Person.json"));
        while (parser.nextToken() != JsonToken.END_OBJECT) {
            String token = parser.getCurrentName();

            if ("firstname".equals(token)) {
                parser.nextToken();
                String fname = parser.getText();
                out.println("firstname : " + fname);
            }
            if ("lastname".equals(token)) {
                parser.nextToken();
                String lname = parser.getText();
                out.println("lastname : " + lname);
            }
            if ("phone".equals(token)) {
                parser.nextToken();
                long phone = parser.getLongValue();
                out.println("phone : " + phone);
            }
            if ("address".equals(token)) {
                out.println("address :");
                parser.nextToken();
                while (parser.nextToken() != JsonToken.END_ARRAY) {
                    out.println(parser.getText());
                }
            }
        }
        parser.close();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

public static <T> T parseJson(Reader reader, Function<JsonParser, T> function) {
    Objects.requireNonNull(reader);
    Objects.requireNonNull(function);
    JsonFactory factory = new JsonFactory();
    try (JsonParser parser = factory.createParser(reader)) {
        return function.apply(parser);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}

@Bean
public JsonParser getJsonParser(@Value("${app.vendors.json}") String filename) throws IOException {
    JsonFactory factory = new JsonFactory();
    ClassLoader classLoader = getClass().getClassLoader();
    File file = new File(classLoader.getResource(filename).getFile());
    JsonParser parser = factory.createJsonParser(file);
    return parser;
}

public static void parsePerson() {
    try {
        JsonFactory jsonfactory = new JsonFactory();
        JsonParser parser = jsonfactory.createParser(new File("Person.json"));
        while (parser.nextToken() != JsonToken.END_OBJECT) {
            String token = parser.getCurrentName();

            if ("firstname".equals(token)) {
                parser.nextToken();
                String fname = parser.getText();
                out.println("firstname : " + fname);
            }
            if ("lastname".equals(token)) {
                parser.nextToken();
                String lname = parser.getText();
                out.println("lastname : " + lname);
            }
            if ("phone".equals(token)) {
                parser.nextToken();
                long phone = parser.getLongValue();
                out.println("phone : " + phone);
            }
            if ("address".equals(token)) {
                out.println("address :");
                parser.nextToken();
                while (parser.nextToken() != JsonToken.END_ARRAY) {
                    out.println(parser.getText());
                }
            }
        }
        parser.close();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

public void parsePersons(String filename) {
    try {
        JsonFactory jsonfactory = new JsonFactory();
        File source = new File(filename);
        JsonParser parser = jsonfactory.createParser(source);
        while (parser.nextToken() != JsonToken.END_OBJECT) {
            String token = parser.getCurrentName();
            if ("persons".equals(token)) {
                out.println("Persons found");
                JsonToken jsonToken = parser.nextToken();
                jsonToken = parser.nextToken();
                token = parser.getCurrentName();
                out.println("Next token is " + token);
                if ("groupname".equals(token)) {
                    parser.nextToken();
                    String groupname = parser.getText();
                    out.println("Group : " + groupname);
                    parser.nextToken();
                    token = parser.getCurrentName();
                    if ("person".equals(token)) {
                        out.println("Found person");
                        parsePerson(parser);
                    }
                }
            }
        }
        parser.close();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

public static void arraysParsingDemo() throws IOException {
    JsonFactory f = new JsonFactory();
    JsonParser jp = f.createParser(new File("user.array.json"));
    ObjectMapper mapper = new ObjectMapper();
    List<User> userArray = new ArrayList<User>();
    jp.nextToken();
    while(jp.nextToken() == JsonToken.START_OBJECT) {
        userArray.add(mapper.readValue(jp, User.class));
    }
    for (User user : userArray) {
        System.out.println("-----");
        System.out.println(user);
    }
}

public static void parsePerson() {
    try {
        JsonFactory jsonfactory = new JsonFactory();
        JsonParser parser = jsonfactory.createParser(new File("Person.json"));
        while (parser.nextToken() != JsonToken.END_OBJECT) {
            String token = parser.getCurrentName();

            if ("firstname".equals(token)) {
                parser.nextToken();
                String fname = parser.getText();
                out.println("firstname : " + fname);
            }
            if ("lastname".equals(token)) {
                parser.nextToken();
                String lname = parser.getText();
                out.println("lastname : " + lname);
            }
            if ("phone".equals(token)) {
                parser.nextToken();
                long phone = parser.getLongValue();
                out.println("phone : " + phone);
            }
            if ("address".equals(token)) {
                out.println("address :");
                parser.nextToken();
                while (parser.nextToken() != JsonToken.END_ARRAY) {
                    out.println(parser.getText());
                }
            }
        }
        parser.close();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}