Java 类org.elasticsearch.common.xcontent.XContentFactory 实例源码

@Override
public String explain() {
    try {
        XContentBuilder firstBuilder = XContentFactory.contentBuilder(XContentType.JSON).prettyPrint();
        firstTable.getRequestBuilder().request().source().toXContent(firstBuilder, ToXContent.EMPTY_PARAMS);

        XContentBuilder secondBuilder = XContentFactory.contentBuilder(XContentType.JSON).prettyPrint();
        secondTable.getRequestBuilder().request().source().toXContent(secondBuilder, ToXContent.EMPTY_PARAMS);
        String explained = String.format(" first query:\n%s\n second query:\n%s", firstBuilder.string(), secondBuilder.string());

        return explained;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

public void testConditionsParsing() throws Exception {
    final RolloverRequest request = new RolloverRequest(randomAsciiOfLength(10), randomAsciiOfLength(10));
    final XContentBuilder builder = XContentFactory.jsonBuilder()
        .startObject()
            .startObject("conditions")
                .field("max_age", "10d")
                .field("max_docs", 100)
            .endObject()
        .endObject();
    RolloverRequest.PARSER.parse(createParser(builder), request, null);
    Set<Condition> conditions = request.getConditions();
    assertThat(conditions.size(), equalTo(2));
    for (Condition condition : conditions) {
        if (condition instanceof MaxAgeCondition) {
            MaxAgeCondition maxAgeCondition = (MaxAgeCondition) condition;
            assertThat(maxAgeCondition.value.getMillis(), equalTo(TimeValue.timeValueHours(24 * 10).getMillis()));
        } else if (condition instanceof MaxDocsCondition) {
            MaxDocsCondition maxDocsCondition = (MaxDocsCondition) condition;
            assertThat(maxDocsCondition.value, equalTo(100L));
        } else {
            fail("unexpected condition " + condition);
        }
    }
}

public void testCamelCaseFieldNameStaysAsIs() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .endObject().endObject().string();

    IndexService index = createIndex("test");
    client().admin().indices().preparePutMapping("test").setType("type").setSource(mapping, XContentType.JSON).get();
    DocumentMapper documentMapper = index.mapperService().documentMapper("type");

    ParsedDocument doc = documentMapper.parse("test", "type", "1", XContentFactory.jsonBuilder().startObject()
            .field("thisIsCamelCase", "value1")
            .endObject().bytes());

    assertNotNull(doc.dynamicMappingsUpdate());
    client().admin().indices().preparePutMapping("test").setType("type")
        .setSource(doc.dynamicMappingsUpdate().toString(), XContentType.JSON).get();

    documentMapper = index.mapperService().documentMapper("type");
    assertNotNull(documentMapper.mappers().getMapper("thisIsCamelCase"));
    assertNull(documentMapper.mappers().getMapper("this_is_camel_case"));

    documentMapper = index.mapperService().documentMapperParser().parse("type", documentMapper.mappingSource());

    assertNotNull(documentMapper.mappers().getMapper("thisIsCamelCase"));
    assertNull(documentMapper.mappers().getMapper("this_is_camel_case"));
}

public void testStore() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "ip").field("store", true).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "::1")
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(3, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(1, pointField.fieldType().pointDimensionCount());
    IndexableField dvField = fields[1];
    assertEquals(DocValuesType.SORTED_SET, dvField.fieldType().docValuesType());
    IndexableField storedField = fields[2];
    assertTrue(storedField.fieldType().stored());
    assertEquals(new BytesRef(InetAddressPoint.encode(InetAddress.getByName("::1"))),
            storedField.binaryValue());
}

/**
 *  creates random rescorer, renders it to xContent and back to new instance that should be equal to original
 */
public void testFromXContent() throws IOException {
    for (int runs = 0; runs < NUMBER_OF_TESTBUILDERS; runs++) {
        RescoreBuilder<?> rescoreBuilder = randomRescoreBuilder();
        XContentBuilder builder = XContentFactory.contentBuilder(randomFrom(XContentType.values()));
        if (randomBoolean()) {
            builder.prettyPrint();
        }
        rescoreBuilder.toXContent(builder, ToXContent.EMPTY_PARAMS);
        XContentBuilder shuffled = shuffleXContent(builder);


        XContentParser parser = createParser(shuffled);
        QueryParseContext context = new QueryParseContext(parser);
        parser.nextToken();
        RescoreBuilder<?> secondRescoreBuilder = RescoreBuilder.parseFromXContent(context);
        assertNotSame(rescoreBuilder, secondRescoreBuilder);
        assertEquals(rescoreBuilder, secondRescoreBuilder);
        assertEquals(rescoreBuilder.hashCode(), secondRescoreBuilder.hashCode());
    }
}

public void testDynamicDateDetectionEnabledWithNoSpecialCharacters() throws IOException {
    DocumentMapperParser mapperParser = createIndex("test").mapperService().documentMapperParser();
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startArray("dynamic_date_formats")
                .value("yyyy MM")
            .endArray().endObject().endObject().string();
    DocumentMapper mapper = mapperParser.parse("type", new CompressedXContent(mapping));

    BytesReference bytes = XContentFactory.jsonBuilder()
        .startObject()
            .field("foo", "2016 12")
        .endObject().bytes();

    // We should have generated a date field
    ParsedDocument doc = mapper.parse("test", "type", "1", bytes);
    Mapping update = doc.dynamicMappingsUpdate();
    assertNotNull(update);
    Mapper dateMapper = update.root().getMapper("foo");
    assertNotNull(dateMapper);
    assertThat(dateMapper, instanceOf(DateFieldMapper.class));
}

@SuppressWarnings({"unchecked"})
public void testIncludingObjectWithNestedIncludedObject() throws Exception {
    XContentBuilder builder = XContentFactory.jsonBuilder().startObject()
            .startObject("obj1")
            .startObject("obj2")
            .endObject()
            .endObject()
            .endObject();

    Tuple<XContentType, Map<String, Object>> mapTuple = XContentHelper.convertToMap(builder.bytes(), true, builder.contentType());
    Map<String, Object> filteredSource = XContentMapValues.filter(mapTuple.v2(), new String[]{"*.obj2"}, Strings.EMPTY_ARRAY);

    assertThat(filteredSource.size(), equalTo(1));
    assertThat(filteredSource, hasKey("obj1"));
    assertThat(((Map) filteredSource.get("obj1")).size(), equalTo(1));
    assertThat(((Map<String, Object>) filteredSource.get("obj1")), hasKey("obj2"));
    assertThat(((Map) ((Map) filteredSource.get("obj1")).get("obj2")).size(), equalTo(0));
}

public void testToXContent() throws IOException {
    Build build = new Build("buildHash", "2016-11-15".toString(), true);
    Version version = Version.V_2_4_5;
    MainResponse response = new MainResponse("nodeName", version, new ClusterName("clusterName"), "clusterUuid", build, true);
    XContentBuilder builder = XContentFactory.jsonBuilder();
    response.toXContent(builder, ToXContent.EMPTY_PARAMS);
    assertEquals("{"
            + "\"name\":\"nodeName\","
            + "\"cluster_name\":\"clusterName\","
            + "\"cluster_uuid\":\"clusterUuid\","
            + "\"version\":{"
                + "\"number\":\"2.4.5\","
                + "\"build_hash\":\"buildHash\","
                + "\"build_date\":\"2016-11-15\","
                + "\"build_snapshot\":true,"
                + "\"lucene_version\":\"5.5.2\"},"
            + "\"tagline\":\"You Know, for Search\""
      + "}", builder.string());
}

@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
    XContentParser parser = parseContext.parser();

    XContentParser.Token token = parser.nextToken();
    if (token != XContentParser.Token.FIELD_NAME) {
        throw new QueryParsingException(parseContext, "[wrapper] query malformed");
    }
    String fieldName = parser.currentName();
    if (!fieldName.equals("query")) {
        throw new QueryParsingException(parseContext, "[wrapper] query malformed");
    }
    parser.nextToken();

    byte[] querySource = parser.binaryValue();
    try (XContentParser qSourceParser = XContentFactory.xContent(querySource).createParser(querySource)) {
        final QueryParseContext context = new QueryParseContext(parseContext.index(), parseContext.indexQueryParserService());
        context.reset(qSourceParser);
        Query result = context.parseInnerQuery();
        parser.nextToken();
        parseContext.combineNamedQueries(context);
        return result;
    }
}

private Script createScript() throws IOException {
    final Map<String, Object> params = randomBoolean() ? Collections.emptyMap() : Collections.singletonMap("key", "value");
    ScriptType scriptType = randomFrom(ScriptType.values());
    String script;
    if (scriptType == ScriptType.INLINE) {
        try (XContentBuilder builder = XContentFactory.jsonBuilder()) {
            builder.startObject();
            builder.field("field", randomAsciiOfLengthBetween(1, 5));
            builder.endObject();
            script = builder.string();
        }
    } else {
        script = randomAsciiOfLengthBetween(1, 5);
    }
    return new Script(
        scriptType,
        scriptType == ScriptType.STORED ? null : randomFrom("_lang1", "_lang2", "_lang3"),
        script,
        scriptType == ScriptType.INLINE ?
                Collections.singletonMap(Script.CONTENT_TYPE_OPTION, XContentType.JSON.mediaType()) : null, params
    );
}

public void testEmptyName() throws Exception {
    // after 5.x
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type1")
        .startObject("properties").startObject("").field("type", "percolator").endObject().endObject()
        .endObject().endObject().string();
    DocumentMapperParser parser = mapperService.documentMapperParser();

    IllegalArgumentException e = expectThrows(IllegalArgumentException.class,
        () -> parser.parse("type1", new CompressedXContent(mapping))
    );
    assertThat(e.getMessage(), containsString("name cannot be empty string"));

    // before 5.x
    Version oldVersion = VersionUtils.randomVersionBetween(getRandom(), Version.V_2_0_0, Version.V_2_3_5);
    Settings oldIndexSettings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, oldVersion).build();
    DocumentMapperParser parser2x = createIndex("test_old", oldIndexSettings).mapperService().documentMapperParser();

    DocumentMapper defaultMapper = parser2x.parse("type1", new CompressedXContent(mapping));
    assertEquals(mapping, defaultMapper.mappingSource().string());
}

public void testMappingMetaDataParsed() throws Exception {
    logger.info("--> starting 1 nodes");
    internalCluster().startNode();

    logger.info("--> creating test index, with meta routing");
    client().admin().indices().prepareCreate("test")
            .addMapping("type1", XContentFactory.jsonBuilder().startObject().startObject("type1").startObject("_routing")
                .field("required", true).endObject().endObject().endObject())
            .execute().actionGet();

    logger.info("--> verify meta _routing required exists");
    MappingMetaData mappingMd = client().admin().cluster().prepareState().execute().actionGet().getState().metaData()
        .index("test").mapping("type1");
    assertThat(mappingMd.routing().required(), equalTo(true));

    logger.info("--> restarting nodes...");
    internalCluster().fullRestart();

    logger.info("--> waiting for yellow status");
    ensureYellow();

    logger.info("--> verify meta _routing required exists");
    mappingMd = client().admin().cluster().prepareState().execute().actionGet().getState().metaData().index("test").mapping("type1");
    assertThat(mappingMd.routing().required(), equalTo(true));
}

public void testNotIndexed() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "scaled_float")
            .field("index", false).field("scaling_factor", 10.0).endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", 123)
            .endObject()
            .bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField dvField = fields[0];
    assertEquals(DocValuesType.SORTED_NUMERIC, dvField.fieldType().docValuesType());
    assertEquals(1230, dvField.numericValue().longValue());
}

@Override
public boolean indexWord(String word) {
    if (bulk == null) {
        bulk = client.prepareBulk();
    }
    try {
        bulk.add(client.prepareIndex(INDEX_NAME, INDEX_TYPE)
                .setSource(XContentFactory.jsonBuilder()
                        .startObject()
                        .field(FIELD_NAME, word)
                        .endObject()));
    } catch (IOException e) {
        // should never happen
        throw new RuntimeException(e);
    }
    return true;
}

/**
 *  creates random candidate generator, renders it to xContent and back to new instance that should be equal to original
 */
public void testFromXContent() throws IOException {
    for (int runs = 0; runs < NUMBER_OF_RUNS; runs++) {
        DirectCandidateGeneratorBuilder generator = randomCandidateGenerator();
        XContentBuilder builder = XContentFactory.contentBuilder(randomFrom(XContentType.values()));
        if (randomBoolean()) {
            builder.prettyPrint();
        }
        generator.toXContent(builder, ToXContent.EMPTY_PARAMS);
        XContentParser parser = createParser(shuffleXContent(builder));
        parser.nextToken();
        DirectCandidateGeneratorBuilder secondGenerator = DirectCandidateGeneratorBuilder.PARSER.apply(parser, null);
        assertNotSame(generator, secondGenerator);
        assertEquals(generator, secondGenerator);
        assertEquals(generator.hashCode(), secondGenerator.hashCode());
    }
}

public void testDynamicDottedFieldNameObjectWithExistingParent() throws Exception {
    DocumentMapperParser mapperParser = createIndex("test").mapperService().documentMapperParser();
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties").startObject("foo")
            .field("type", "object").endObject().endObject().endObject().endObject().string();
    DocumentMapper mapper = mapperParser.parse("type", new CompressedXContent(mapping));

    BytesReference bytes = XContentFactory.jsonBuilder().startObject().startObject("foo.bar.baz").field("a", 0).endObject().endObject()
            .bytes();
    ParsedDocument doc = mapper.parse("test", "type", "1", bytes);
    assertEquals(2, doc.rootDoc().getFields("foo.bar.baz.a").length);
    Mapper fooMapper = doc.dynamicMappingsUpdate().root().getMapper("foo");
    assertNotNull(fooMapper);
    assertThat(fooMapper, instanceOf(ObjectMapper.class));
    Mapper barMapper = ((ObjectMapper) fooMapper).getMapper("bar");
    assertNotNull(barMapper);
    assertThat(barMapper, instanceOf(ObjectMapper.class));
    Mapper bazMapper = ((ObjectMapper) barMapper).getMapper("baz");
    assertNotNull(bazMapper);
    assertThat(bazMapper, instanceOf(ObjectMapper.class));
    Mapper aMapper = ((ObjectMapper) bazMapper).getMapper("a");
    assertNotNull(aMapper);
    assertThat(aMapper, instanceOf(NumberFieldMapper.class));
}

public void testDateTypesConversion() throws Exception {
    Date date = new Date();
    String expectedDate = XContentBuilder.DEFAULT_DATE_PRINTER.print(date.getTime());
    Calendar calendar = new GregorianCalendar(TimeZone.getTimeZone("UTC"), Locale.ROOT);
    String expectedCalendar = XContentBuilder.DEFAULT_DATE_PRINTER.print(calendar.getTimeInMillis());
    XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON);
    builder.startObject().field("date", date).endObject();
    assertThat(builder.string(), equalTo("{\"date\":\"" + expectedDate + "\"}"));

    builder = XContentFactory.contentBuilder(XContentType.JSON);
    builder.startObject().field("calendar", calendar).endObject();
    assertThat(builder.string(), equalTo("{\"calendar\":\"" + expectedCalendar + "\"}"));

    builder = XContentFactory.contentBuilder(XContentType.JSON);
    Map<String, Object> map = new HashMap<>();
    map.put("date", date);
    builder.map(map);
    assertThat(builder.string(), equalTo("{\"date\":\"" + expectedDate + "\"}"));

    builder = XContentFactory.contentBuilder(XContentType.JSON);
    map = new HashMap<>();
    map.put("calendar", calendar);
    builder.map(map);
    assertThat(builder.string(), equalTo("{\"calendar\":\"" + expectedCalendar + "\"}"));
}

public void testIndentIsPlatformIndependent() throws IOException {
    XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON).prettyPrint();
    builder.startObject().field("test","foo").startObject("foo").field("foobar", "boom").endObject().endObject();
    String string = builder.string();
    assertEquals("{\n" +
            "  \"test\" : \"foo\",\n" +
            "  \"foo\" : {\n" +
            "    \"foobar\" : \"boom\"\n" +
            "  }\n" +
            "}", string);

    builder = XContentFactory.contentBuilder(XContentType.YAML).prettyPrint();
    builder.startObject().field("test","foo").startObject("foo").field("foobar", "boom").endObject().endObject();
    string = builder.string();
    assertEquals("---\n" +
            "test: \"foo\"\n" +
            "foo:\n" +
            "  foobar: \"boom\"\n", string);
}

public void testNoLevelWithFieldTypeAsObject() throws Exception {
    String defaultMapping = XContentFactory.jsonBuilder().startObject().startObject("type").endObject().endObject().string();

    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type", new CompressedXContent(defaultMapping));

    ParsedDocument doc = defaultMapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type").field("type_field", "type_value").endObject()
            .field("test1", "value1")
            .field("test2", "value2")
            .startObject("inner").field("inner_field", "inner_value").endObject()
            .endObject()
            .bytes());

    // in this case, we analyze the type object as the actual document, and ignore the other same level fields
    assertThat(doc.rootDoc().get("type.type_field"), equalTo("type_value"));
    assertThat(doc.rootDoc().get("test1"), equalTo("value1"));
    assertThat(doc.rootDoc().get("test2"), equalTo("value2"));
}

public void testPrettyWithLfAtEnd() throws Exception {
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    XContentGenerator generator = XContentFactory.xContent(XContentType.JSON).createGenerator(os);
    generator.usePrettyPrint();
    generator.usePrintLineFeedAtEnd();

    generator.writeStartObject();
    generator.writeStringField("test", "value");
    generator.writeEndObject();
    generator.flush();

    generator.close();
    // double close, and check there is no error...
    generator.close();

    byte[] bytes = os.toByteArray();
    assertThat((char) bytes[bytes.length - 1], equalTo('\n'));
}

public void testSigmaFromInt() throws Exception {
    XContentBuilder content = XContentFactory.jsonBuilder()
        .startObject()
            .startObject("name")
                .startObject("extended_stats_bucket")
                    .field("sigma", 5)
                    .field("buckets_path", "test")
                .endObject()
            .endObject()
        .endObject();

    ExtendedStatsBucketPipelineAggregationBuilder builder = (ExtendedStatsBucketPipelineAggregationBuilder) parse(
            createParser(content));

    assertThat(builder.sigma(), equalTo(5.0));
}

public void testQuadtreeConfiguration() throws IOException {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type1")
            .startObject("properties").startObject("location")
                .field("type", "geo_shape")
                .field("tree", "quadtree")
                .field("tree_levels", "6")
                .field("distance_error_pct", "0.5")
                .field("points_only", true)
            .endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type1", new CompressedXContent(mapping));
    FieldMapper fieldMapper = defaultMapper.mappers().getMapper("location");
    assertThat(fieldMapper, instanceOf(GeoShapeFieldMapper.class));

    GeoShapeFieldMapper geoShapeFieldMapper = (GeoShapeFieldMapper) fieldMapper;
    PrefixTreeStrategy strategy = geoShapeFieldMapper.fieldType().defaultStrategy();

    assertThat(strategy.getDistErrPct(), equalTo(0.5));
    assertThat(strategy.getGrid(), instanceOf(QuadPrefixTree.class));
    assertThat(strategy.getGrid().getMaxLevels(), equalTo(6));
    assertThat(strategy.isPointsOnly(), equalTo(true));
}

public void testDynamicObjectWithTemplate() throws Exception {
    DocumentMapperParser mapperParser = createIndex("test").mapperService().documentMapperParser();
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
        .startArray("dynamic_templates").startObject().startObject("georule")
            .field("match", "foo*")
            .startObject("mapping").field("type", "object")
            .startObject("properties").startObject("bar").field("type", "keyword").endObject().endObject().endObject()
        .endObject().endObject().endArray().endObject().endObject().string();
    DocumentMapper mapper = mapperParser.parse("type", new CompressedXContent(mapping));

    BytesReference bytes = XContentFactory.jsonBuilder()
            .startObject().startObject("foo")
                .field("bar", "baz")
            .endObject().endObject().bytes();
    ParsedDocument doc = mapper.parse("test", "type", "1", bytes);
    assertEquals(2, doc.rootDoc().getFields("foo.bar").length);
}

@Override
protected void doTestNoDocValues(String type) throws Exception {
    XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
        .startObject("properties").startObject("field").field("type", type).field("doc_values", false);
    if (type.equals("date_range")) {
        mapping = mapping.field("format", DATE_FORMAT);
    }
    mapping = mapping.endObject().endObject().endObject().endObject();
    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping.string()));
    assertEquals(mapping.string(), mapper.mappingSource().toString());

    ParsedDocument doc = mapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
        .startObject()
        .startObject("field")
        .field(getFromField(), getFrom(type))
        .field(getToField(), getTo(type))
        .endObject()
        .endObject().bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(2, pointField.fieldType().pointDimensionCount());
}

public XContentBuilder createIndexMapping() {

        try {
            XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject(CITY_TYPE)
                    .startObject("properties")

                    // city
                    .startObject("name")
                    .field("type", "string")
                    .endObject()

                    // country
                    .startObject("country")
                    .field("type", "string")
                    .field("index", "not_analyzed")
                    .endObject()

                    .endObject()
                    .endObject().endObject();

            return mapping;
        }
        catch(IOException ioe) {
            throw new TechnicalException(String.format("Error while getting mapping for index [%s/%s]: %s", INDEX, CITY_TYPE, ioe.getMessage()), ioe);
        }
    }

public void testParsingMinimal() throws Exception {
    String mapping = jsonBuilder().startObject().startObject("type1")
            .startObject("properties").startObject("completion")
            .field("type", "completion")
            .endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type1", new CompressedXContent(mapping));
    FieldMapper fieldMapper = defaultMapper.mappers().getMapper("completion");
    MappedFieldType completionFieldType = fieldMapper.fieldType();
    ParsedDocument parsedDocument = defaultMapper.parse("test", "type1", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("completion", "suggestion")
            .endObject()
            .bytes());
    IndexableField[] fields = parsedDocument.rootDoc().getFields(completionFieldType.name());
    assertSuggestFields(fields, 1);
}

public void testDynamicDottedFieldNameLongWithExistingParent() throws Exception {
    DocumentMapperParser mapperParser = createIndex("test").mapperService().documentMapperParser();
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
        .startObject("properties") .startObject("foo")
        .field("type", "object")
        .endObject().endObject().endObject().endObject().string();
    DocumentMapper mapper = mapperParser.parse("type", new CompressedXContent(mapping));

    BytesReference bytes = XContentFactory.jsonBuilder()
            .startObject().field("foo.bar.baz", 0)
        .endObject().bytes();
    ParsedDocument doc = mapper.parse("test", "type", "1", bytes);
    assertEquals(2, doc.rootDoc().getFields("foo.bar.baz").length);
    Mapper fooMapper = doc.dynamicMappingsUpdate().root().getMapper("foo");
    assertNotNull(fooMapper);
    assertThat(fooMapper, instanceOf(ObjectMapper.class));
    Mapper barMapper = ((ObjectMapper) fooMapper).getMapper("bar");
    assertNotNull(barMapper);
    assertThat(barMapper, instanceOf(ObjectMapper.class));
    Mapper bazMapper = ((ObjectMapper) barMapper).getMapper("baz");
    assertNotNull(bazMapper);
    assertThat(bazMapper, instanceOf(NumberFieldMapper.class));
}

public void testSimpleQueryStringAnalyzeWildcard() throws ExecutionException, InterruptedException, IOException {
    String mapping = XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type1")
            .startObject("properties")
            .startObject("location")
            .field("type", "text")
            .field("analyzer", "german")
            .endObject()
            .endObject()
            .endObject()
            .endObject().string();

    CreateIndexRequestBuilder mappingRequest = client().admin().indices().prepareCreate("test1")
        .addMapping("type1", mapping, XContentType.JSON);
    mappingRequest.execute().actionGet();
    indexRandom(true, client().prepareIndex("test1", "type1", "1").setSource("location", "Köln"));
    refresh();

    SearchResponse searchResponse = client().prepareSearch()
            .setQuery(simpleQueryStringQuery("Köln*").field("location")).get();
    assertNoFailures(searchResponse);
    assertHitCount(searchResponse, 1L);
    assertSearchHits(searchResponse, "1");
}

public void testSimpleList() throws IOException {
    XContentBuilder builder = XContentFactory.jsonBuilder().startObject()
            .startArray("some_array")
                .value(1)
                .value(3)
                .value(0)
            .endArray().endObject();

    try (XContentParser parser = createParser(JsonXContent.jsonXContent, builder.string())) {
        assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
        assertEquals(XContentParser.Token.FIELD_NAME, parser.nextToken());
        assertEquals("some_array", parser.currentName());
        if (random().nextBoolean()) {
            // sometimes read the start array token, sometimes not
            assertEquals(XContentParser.Token.START_ARRAY, parser.nextToken());
        }
        assertEquals(Arrays.asList(1, 3, 0), parser.list());
    }
}

public void testDisabled() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
        .startObject("_field_names").field("enabled", false).endObject()
        .endObject().endObject().string();
    DocumentMapper docMapper = createIndex("test").mapperService().documentMapperParser().parse("type", new CompressedXContent(mapping));
    FieldNamesFieldMapper fieldNamesMapper = docMapper.metadataMapper(FieldNamesFieldMapper.class);
    assertFalse(fieldNamesMapper.fieldType().isEnabled());

    ParsedDocument doc = docMapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
        .startObject()
        .field("field", "value")
        .endObject()
        .bytes());

    assertNull(doc.rootDoc().get("_field_names"));
}

public void testParseSelfCrossingPolygon() throws IOException {
    // test self crossing ccw poly not crossing dateline
    String polygonGeoJson = XContentFactory.jsonBuilder().startObject().field("type", "Polygon")
            .startArray("coordinates")
            .startArray()
            .startArray().value(176.0).value(15.0).endArray()
            .startArray().value(-177.0).value(10.0).endArray()
            .startArray().value(-177.0).value(-10.0).endArray()
            .startArray().value(176.0).value(-15.0).endArray()
            .startArray().value(-177.0).value(15.0).endArray()
            .startArray().value(172.0).value(0.0).endArray()
            .startArray().value(176.0).value(15.0).endArray()
            .endArray()
            .endArray()
            .endObject().string();

    XContentParser parser = createParser(JsonXContent.jsonXContent, polygonGeoJson);
    parser.nextToken();
    ElasticsearchGeoAssertions.assertValidException(parser, InvalidShapeException.class);
}

public void testEmptyNested() throws Exception {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
            .startObject("nested1").field("type", "nested").endObject()
            .endObject().endObject().endObject().string();

    DocumentMapper docMapper = createIndex("test").mapperService().documentMapperParser().parse("type", new CompressedXContent(mapping));

    ParsedDocument doc = docMapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "value")
            .nullField("nested1")
            .endObject()
            .bytes());

    assertThat(doc.docs().size(), equalTo(1));

    doc = docMapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "value")
            .startArray("nested").endArray()
            .endObject()
            .bytes());

    assertThat(doc.docs().size(), equalTo(1));
}

public void testAddWithValidSourceValueIsAccepted() throws Exception {
    XContentParser parser = createParser(XContentFactory.jsonBuilder()
        .startObject()
            .startArray("docs")
                .startObject()
                    .field("_source", randomFrom("false", "true"))
                .endObject()
                .startObject()
                    .field("_source", randomBoolean())
                .endObject()
            .endArray()
        .endObject()
    );

    MultiGetRequest multiGetRequest = new MultiGetRequest();
    multiGetRequest.add(
        randomAsciiOfLength(5), randomAsciiOfLength(3), null, FetchSourceContext.FETCH_SOURCE, null, parser, true);

    assertEquals(2, multiGetRequest.getItems().size());
}

private void prepareIndex() {
    try {
        XContentBuilder source = XContentFactory.jsonBuilder()
                .startObject()
                    .startObject(INDEX_TYPE)
                        .startObject("properties")
                            .startObject(FIELD_NAME)
                                .field("type", "text")
                                .field("analyzer", "simple")
                            .endObject()
                        .endObject()
                    .endObject()
                .endObject();
        client.admin().indices()
                .prepareCreate(INDEX_NAME)
                .addMapping(INDEX_TYPE, source)
                .setSettings(Settings.builder()
                        .put("number_of_shards", 1)
                        .put("number_of_replicas", 0))
                .get();
    } catch (IOException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}

public void testThatParserExtractsCorrectTypeAndCoordinatesFromArbitraryJson() throws IOException {
    XContentBuilder pointGeoJson = XContentFactory.jsonBuilder()
            .startObject()
                .startObject("crs")
                    .field("type", "name")
                    .startObject("properties")
                        .field("name", "urn:ogc:def:crs:OGC:1.3:CRS84")
                    .endObject()
                .endObject()
                .field("bbox", "foobar")
                .field("type", "point")
                .field("bubu", "foobar")
                .startArray("coordinates").value(100.0).value(0.0).endArray()
                .startObject("nested").startArray("coordinates").value(200.0).value(0.0).endArray().endObject()
                .startObject("lala").field("type", "NotAPoint").endObject()
            .endObject();

    Point expected = GEOMETRY_FACTORY.createPoint(new Coordinate(100.0, 0.0));
    assertGeometryEquals(new JtsPoint(expected, SPATIAL_CONTEXT), pointGeoJson);
}

public void testFieldNameWithDots() throws Exception {
    IndexService indexService = createIndex("test");
    DocumentMapperParser mapperParser = indexService.mapperService().documentMapperParser();
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
        .startObject("foo.bar").field("type", "text").endObject()
        .startObject("foo.baz").field("type", "keyword").endObject()
        .endObject().endObject().endObject().string();
    DocumentMapper docMapper = mapperParser.parse("type", new CompressedXContent(mapping));
    assertNotNull(docMapper.mappers().getMapper("foo.bar"));
    assertNotNull(docMapper.mappers().getMapper("foo.baz"));
    assertNotNull(docMapper.objectMappers().get("foo"));
}

public void testParseInvalidMultiPolygon() throws IOException {
    // test invalid multipolygon (an "accidental" polygon with inner rings outside outer ring)
    String multiPolygonGeoJson = XContentFactory.jsonBuilder().startObject().field("type", "MultiPolygon")
            .startArray("coordinates")
            .startArray()//one poly (with two holes)
            .startArray()
            .startArray().value(102.0).value(2.0).endArray()
            .startArray().value(103.0).value(2.0).endArray()
            .startArray().value(103.0).value(3.0).endArray()
            .startArray().value(102.0).value(3.0).endArray()
            .startArray().value(102.0).value(2.0).endArray()
            .endArray()
            .startArray()// first hole
            .startArray().value(100.0).value(0.0).endArray()
            .startArray().value(101.0).value(0.0).endArray()
            .startArray().value(101.0).value(1.0).endArray()
            .startArray().value(100.0).value(1.0).endArray()
            .startArray().value(100.0).value(0.0).endArray()
            .endArray()
            .startArray()//second hole
            .startArray().value(100.2).value(0.8).endArray()
            .startArray().value(100.2).value(0.2).endArray()
            .startArray().value(100.8).value(0.2).endArray()
            .startArray().value(100.8).value(0.8).endArray()
            .startArray().value(100.2).value(0.8).endArray()
            .endArray()
            .endArray()
            .endArray()
            .endObject().string();

    XContentParser parser = createParser(JsonXContent.jsonXContent, multiPolygonGeoJson);
    parser.nextToken();
    ElasticsearchGeoAssertions.assertValidException(parser, InvalidShapeException.class);
}

public void testParsingFull() throws Exception {
    String mapping = jsonBuilder().startObject().startObject("type1")
            .startObject("properties").startObject("completion")
            .field("type", "completion")
            .endObject().endObject()
            .endObject().endObject().string();

    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type1", new CompressedXContent(mapping));
    FieldMapper fieldMapper = defaultMapper.mappers().getMapper("completion");
    MappedFieldType completionFieldType = fieldMapper.fieldType();
    ParsedDocument parsedDocument = defaultMapper.parse("test", "type1", "1", XContentFactory.jsonBuilder()
            .startObject()
            .startArray("completion")
            .startObject()
            .field("input", "suggestion1")
            .field("weight", 3)
            .endObject()
            .startObject()
            .field("input", "suggestion2")
            .field("weight", 4)
            .endObject()
            .startObject()
            .field("input", "suggestion3")
            .field("weight", 5)
            .endObject()
            .endArray()
            .endObject()
            .bytes());
    IndexableField[] fields = parsedDocument.rootDoc().getFields(completionFieldType.name());
    assertSuggestFields(fields, 3);
}

public void testDynamicFalseDottedFieldNameObject() throws Exception {
    DocumentMapperParser mapperParser = createIndex("test").mapperService().documentMapperParser();
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type").field("dynamic", "false")
        .endObject().endObject().string();
    DocumentMapper mapper = mapperParser.parse("type", new CompressedXContent(mapping));

    BytesReference bytes = XContentFactory.jsonBuilder()
            .startObject().startObject("foo.bar.baz")
            .field("a", 0)
        .endObject().endObject().bytes();
    ParsedDocument doc = mapper.parse("test", "type", "1", bytes);
    assertEquals(0, doc.rootDoc().getFields("foo.bar.baz.a").length);
}

public void testIllegalScalingFactor() throws IOException {
    String mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
            .startObject("properties").startObject("field").field("type", "scaled_float")
            .field("scaling_factor", -1).endObject().endObject()
            .endObject().endObject().string();

    IllegalArgumentException e = expectThrows(IllegalArgumentException.class,
            () -> parser.parse("type", new CompressedXContent(mapping)));
    assertEquals("[scaling_factor] must be a positive number, got [-1.0]", e.getMessage());
}