@Override
 protected void doAssertLuceneQuery(
     SpanNotQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException {
   assertThat(query, instanceOf(SpanNotQuery.class));
   SpanNotQuery spanNotQuery = (SpanNotQuery) query;
   assertThat(spanNotQuery.getExclude(), equalTo(queryBuilder.excludeQuery().toQuery(context)));
   assertThat(spanNotQuery.getInclude(), equalTo(queryBuilder.includeQuery().toQuery(context)));
 }
  public void testFromJson() throws IOException {
    String json =
        "{\n"
            + "  \"span_not\" : {\n"
            + "    \"include\" : {\n"
            + "      \"span_term\" : {\n"
            + "        \"field1\" : {\n"
            + "          \"value\" : \"hoya\",\n"
            + "          \"boost\" : 1.0\n"
            + "        }\n"
            + "      }\n"
            + "    },\n"
            + "    \"exclude\" : {\n"
            + "      \"span_near\" : {\n"
            + "        \"clauses\" : [ {\n"
            + "          \"span_term\" : {\n"
            + "            \"field1\" : {\n"
            + "              \"value\" : \"la\",\n"
            + "              \"boost\" : 1.0\n"
            + "            }\n"
            + "          }\n"
            + "        }, {\n"
            + "          \"span_term\" : {\n"
            + "            \"field1\" : {\n"
            + "              \"value\" : \"hoya\",\n"
            + "              \"boost\" : 1.0\n"
            + "            }\n"
            + "          }\n"
            + "        } ],\n"
            + "        \"slop\" : 0,\n"
            + "        \"in_order\" : true,\n"
            + "        \"boost\" : 1.0\n"
            + "      }\n"
            + "    },\n"
            + "    \"pre\" : 0,\n"
            + "    \"post\" : 0,\n"
            + "    \"boost\" : 1.0\n"
            + "  }\n"
            + "}";

    SpanNotQueryBuilder parsed = (SpanNotQueryBuilder) parseQuery(json);
    checkGeneratedJson(json, parsed);

    assertEquals(json, "hoya", ((SpanTermQueryBuilder) parsed.includeQuery()).value());
    assertEquals(json, 2, ((SpanNearQueryBuilder) parsed.excludeQuery()).clauses().size());
  }
 public void testPrePost() {
   SpanNotQueryBuilder builder =
       new SpanNotQueryBuilder(
           new SpanTermQueryBuilder("name1", "value1"),
           new SpanTermQueryBuilder("name2", "value2"));
   assertThat(builder.pre(), equalTo(0));
   assertThat(builder.post(), equalTo(0));
   builder.pre(-4).post(-4);
   assertThat(builder.pre(), equalTo(0));
   assertThat(builder.post(), equalTo(0));
   builder.pre(1).post(2);
   assertThat(builder.pre(), equalTo(1));
   assertThat(builder.post(), equalTo(2));
 }
 public void testDist() {
   SpanNotQueryBuilder builder =
       new SpanNotQueryBuilder(
           new SpanTermQueryBuilder("name1", "value1"),
           new SpanTermQueryBuilder("name2", "value2"));
   assertThat(builder.pre(), equalTo(0));
   assertThat(builder.post(), equalTo(0));
   builder.dist(-4);
   assertThat(builder.pre(), equalTo(0));
   assertThat(builder.post(), equalTo(0));
   builder.dist(4);
   assertThat(builder.pre(), equalTo(4));
   assertThat(builder.post(), equalTo(4));
 }
 @Override
 protected SpanNotQueryBuilder doCreateTestQueryBuilder() {
   SpanTermQueryBuilder[] spanTermQueries =
       new SpanTermQueryBuilderTests().createSpanTermQueryBuilders(2);
   SpanNotQueryBuilder queryBuilder =
       new SpanNotQueryBuilder(spanTermQueries[0], spanTermQueries[1]);
   if (randomBoolean()) {
     // also test negative values, they should implicitly be changed to 0
     queryBuilder.dist(randomIntBetween(-2, 10));
   } else {
     if (randomBoolean()) {
       queryBuilder.pre(randomIntBetween(-2, 10));
     }
     if (randomBoolean()) {
       queryBuilder.post(randomIntBetween(-2, 10));
     }
   }
   return queryBuilder;
 }
 /**
  * test correct parsing of `dist` parameter, this should create builder with pre/post set to same
  * value
  */
 public void testParseDist() throws IOException {
   XContentBuilder builder = XContentFactory.jsonBuilder();
   builder.startObject();
   builder.startObject(SpanNotQueryBuilder.NAME);
   builder.field("exclude");
   spanTermQuery("description", "jumped").toXContent(builder, null);
   builder.field("include");
   spanNearQuery(QueryBuilders.spanTermQuery("description", "quick"), 1)
       .clause(QueryBuilders.spanTermQuery("description", "fox"))
       .toXContent(builder, null);
   builder.field("dist", 3);
   builder.endObject();
   builder.endObject();
   SpanNotQueryBuilder query = (SpanNotQueryBuilder) parseQuery(builder.string());
   assertThat(query.pre(), equalTo(3));
   assertThat(query.post(), equalTo(3));
   assertNotNull(query.includeQuery());
   assertNotNull(query.excludeQuery());
 }