/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.solr.schema;

import java.io.IOException;
import java.lang.invoke.MethodHandles;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;

import org.apache.lucene.index.DocValuesType;
import org.apache.lucene.index.FieldInfos;
import org.apache.lucene.index.IndexableField;
import org.apache.lucene.index.LeafReader;
import org.apache.lucene.index.NumericDocValues;
import org.apache.lucene.index.SortedDocValues;
import org.apache.lucene.queries.function.FunctionValues;
import org.apache.lucene.util.NumericUtils;
import org.apache.solr.SolrTestCaseJ4;
import org.apache.solr.core.SolrCore;
import org.apache.solr.search.SolrIndexSearcher;
import org.apache.solr.util.RefCounted;
import org.junit.BeforeClass;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DocValuesTest extends SolrTestCaseJ4 {

  private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

  @BeforeClass
  public static void beforeTests() throws Exception {
    initCore("solrconfig-basic.xml", "schema-docValues.xml");

    // sanity check our schema meets our expectations
    final IndexSchema schema = h.getCore().getLatestSchema();
    for (String f : new String[] {"floatdv", "intdv", "doubledv", "longdv", "datedv", "stringdv", "booldv"}) {
      final SchemaField sf = schema.getField(f);
      assertFalse(f + " is multiValued, test is useless, who changed the schema?",
                  sf.multiValued());
      assertFalse(f + " is indexed, test is useless, who changed the schema?",
                  sf.indexed());
      assertTrue(f + " has no docValues, test is useless, who changed the schema?",
                 sf.hasDocValues());
    }
  }

  public void setUp() throws Exception {
    super.setUp();
    assertU(delQ("*:*"));
  }

  @Test
  public void testDocValues() throws IOException {
    assertU(adoc("id", "1"));
    assertU(commit());
    try (SolrCore core = h.getCoreInc()) {
      final RefCounted<SolrIndexSearcher> searcherRef = core.openNewSearcher(true, true);
      final SolrIndexSearcher searcher = searcherRef.get();
      try {
        final LeafReader reader = searcher.getSlowAtomicReader();
        assertEquals(1, reader.numDocs());
        final FieldInfos infos = reader.getFieldInfos();
        assertEquals(DocValuesType.NUMERIC, infos.fieldInfo("floatdv").getDocValuesType());
        assertEquals(DocValuesType.NUMERIC, infos.fieldInfo("intdv").getDocValuesType());
        assertEquals(DocValuesType.NUMERIC, infos.fieldInfo("doubledv").getDocValuesType());
        assertEquals(DocValuesType.NUMERIC, infos.fieldInfo("longdv").getDocValuesType());
        assertEquals(DocValuesType.SORTED, infos.fieldInfo("stringdv").getDocValuesType());
        assertEquals(DocValuesType.SORTED, infos.fieldInfo("booldv").getDocValuesType());

        NumericDocValues dvs = reader.getNumericDocValues("floatdv");
        assertEquals(0, dvs.nextDoc());
        assertEquals((long) Float.floatToIntBits(1), dvs.longValue());
        dvs = reader.getNumericDocValues("intdv");
        assertEquals(0, dvs.nextDoc());
        assertEquals(2L, dvs.longValue());
        dvs = reader.getNumericDocValues("doubledv");
        assertEquals(0, dvs.nextDoc());
        assertEquals(Double.doubleToLongBits(3), dvs.longValue());
        dvs = reader.getNumericDocValues("longdv");
        assertEquals(0, dvs.nextDoc());
        assertEquals(4L, dvs.longValue());
        SortedDocValues sdv = reader.getSortedDocValues("stringdv");
        assertEquals(0, sdv.nextDoc());
        assertEquals("solr", sdv.binaryValue().utf8ToString());
        sdv = reader.getSortedDocValues("booldv");
        assertEquals(0, sdv.nextDoc());
        assertEquals("T", sdv.binaryValue().utf8ToString());

        final IndexSchema schema = core.getLatestSchema();
        final SchemaField floatDv = schema.getField("floatdv");
        final SchemaField intDv = schema.getField("intdv");
        final SchemaField doubleDv = schema.getField("doubledv");
        final SchemaField longDv = schema.getField("longdv");
        final SchemaField boolDv = schema.getField("booldv");

        FunctionValues values = floatDv.getType().getValueSource(floatDv, null).getValues(null, searcher.getSlowAtomicReader().leaves().get(0));
        assertEquals(1f, values.floatVal(0), 0f);
        assertEquals(1f, values.objectVal(0));
        values = intDv.getType().getValueSource(intDv, null).getValues(null, searcher.getSlowAtomicReader().leaves().get(0));
        assertEquals(2, values.intVal(0));
        assertEquals(2, values.objectVal(0));
        values = doubleDv.getType().getValueSource(doubleDv, null).getValues(null, searcher.getSlowAtomicReader().leaves().get(0));
        assertEquals(3d, values.doubleVal(0), 0d);
        assertEquals(3d, values.objectVal(0));
        values = longDv.getType().getValueSource(longDv, null).getValues(null, searcher.getSlowAtomicReader().leaves().get(0));
        assertEquals(4L, values.longVal(0));
        assertEquals(4L, values.objectVal(0));
        
        values = boolDv.getType().getValueSource(boolDv, null).getValues(null, searcher.getSlowAtomicReader().leaves().get(0));
        assertEquals("true", values.strVal(0));
        assertEquals(true, values.objectVal(0));

        // check reversibility of created fields
        tstToObj(schema.getField("floatdv"), -1.5f);
        tstToObj(schema.getField("floatdvs"), -1.5f);
        tstToObj(schema.getField("doubledv"), -1.5d);
        tstToObj(schema.getField("doubledvs"), -1.5d);
        tstToObj(schema.getField("intdv"), -7);
        tstToObj(schema.getField("intdvs"), -7);
        tstToObj(schema.getField("longdv"), -11L);
        tstToObj(schema.getField("longdvs"), -11L);
        tstToObj(schema.getField("datedv"), new Date(1000));
        tstToObj(schema.getField("datedvs"), new Date(1000));
        tstToObj(schema.getField("stringdv"), "foo");
        tstToObj(schema.getField("stringdvs"), "foo");
        tstToObj(schema.getField("booldv"), true);
        tstToObj(schema.getField("booldvs"), true);

      } finally {
        searcherRef.decref();
      }
    }
  }

  private void tstToObj(SchemaField sf, Object o) {
    List<IndexableField> fields = sf.createFields(o);
    for (IndexableField field : fields) {
      assertEquals( sf.getType().toObject(field), o);
    }
  }

  @Test
  public void testDocValuesSorting() {
    assertU(adoc("id", "1", "floatdv", "2", "intdv", "3", "doubledv", "4", "longdv", "5", "datedv", "1995-12-31T23:59:59.999Z", "stringdv", "b", "booldv", "true"));
    assertU(adoc("id", "2", "floatdv", "5", "intdv", "4", "doubledv", "3", "longdv", "2", "datedv", "1997-12-31T23:59:59.999Z", "stringdv", "a", "booldv", "false"));
    assertU(adoc("id", "3", "floatdv", "3", "intdv", "1", "doubledv", "2", "longdv", "1", "datedv", "1996-12-31T23:59:59.999Z", "stringdv", "c", "booldv", "true"));
    assertU(adoc("id", "4"));
    assertU(commit());
    assertQ(req("q", "*:*", "sort", "floatdv desc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='2']");
    assertQ(req("q", "*:*", "sort", "intdv desc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='2']");
    assertQ(req("q", "*:*", "sort", "doubledv desc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='1']");
    assertQ(req("q", "*:*", "sort", "longdv desc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='1']");
    assertQ(req("q", "*:*", "sort", "datedv desc", "rows", "1", "fl", "id,datedv"),
        "//str[@name='id'][.='2']",
        "//result/doc[1]/date[@name='datedv'][.='1997-12-31T23:59:59.999Z']"
        );
    assertQ(req("q", "*:*", "sort", "stringdv desc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='4']");
    assertQ(req("q", "*:*", "sort", "floatdv asc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='4']");
    assertQ(req("q", "*:*", "sort", "intdv asc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='3']");
    assertQ(req("q", "*:*", "sort", "doubledv asc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='3']");
    assertQ(req("q", "*:*", "sort", "longdv asc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='3']");
    assertQ(req("q", "*:*", "sort", "datedv asc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='1']");
    assertQ(req("q", "*:*", "sort", "stringdv asc", "rows", "1", "fl", "id"),
        "//str[@name='id'][.='2']");
    assertQ(req("q", "*:*", "sort", "booldv asc", "rows", "10", "fl", "booldv,stringdv"),
        "//result/doc[1]/bool[@name='booldv'][.='false']",
        "//result/doc[2]/bool[@name='booldv'][.='true']",
        "//result/doc[3]/bool[@name='booldv'][.='true']",
        "//result/doc[4]/bool[@name='booldv'][.='true']"
        );
        

  }
  
  @Test
  public void testDocValuesSorting2() {
    assertU(adoc("id", "1", "doubledv", "12"));
    assertU(adoc("id", "2", "doubledv", "50.567"));
    assertU(adoc("id", "3", "doubledv", "+0"));
    assertU(adoc("id", "4", "doubledv", "4.9E-324"));
    assertU(adoc("id", "5", "doubledv", "-0.1"));
    assertU(adoc("id", "6", "doubledv", "-5.123"));
    assertU(adoc("id", "7", "doubledv", "1.7976931348623157E308"));
    assertU(commit());
    assertQ(req("fl", "id", "q", "*:*", "sort", "doubledv asc"),
        "//result/doc[1]/str[@name='id'][.='6']",
        "//result/doc[2]/str[@name='id'][.='5']",
        "//result/doc[3]/str[@name='id'][.='3']",
        "//result/doc[4]/str[@name='id'][.='4']",
        "//result/doc[5]/str[@name='id'][.='1']",
        "//result/doc[6]/str[@name='id'][.='2']",
        "//result/doc[7]/str[@name='id'][.='7']"
        );
  }

  @Test
  public void testDocValuesFaceting() {
    for (int i = 0; i < 50; ++i) {
      assertU(adoc("id", "" + i));
    }
    for (int i = 0; i < 50; ++i) {
      if (rarely()) {
        assertU(commit()); // to have several segments
      }
      switch (i % 3) {
        case 0:
          assertU(adoc("id", "1000" + i, "floatdv", "" + i, "intdv", "" + i, "doubledv", "" + i, "longdv", "" + i,
              "datedv", (1900 + i) + "-12-31T23:59:59.999Z", "stringdv", "abc" + i, "booldv", "false"));
          break;
        case 1:
          assertU(adoc("id", "1000" + i, "floatdv", "" + i, "intdv", "" + i, "doubledv", "" + i, "longdv", "" + i,
              "datedv", (1900 + i) + "-12-31T23:59:59.999Z", "stringdv", "abc" + i, "booldv", "true"));
          break;
        case 2:
          assertU(adoc("id", "1000" + i, "floatdv", "" + i, "intdv", "" + i, "doubledv", "" + i, "longdv", "" + i,
              "datedv", (1900 + i) + "-12-31T23:59:59.999Z", "stringdv", "abc" + i));
          break;
      }
    }
    assertU(commit());
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "longdv", "facet.sort", "count", "facet.limit", "1"),
        "//lst[@name='longdv']/int[@name='4'][.='51']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "longdv", "facet.sort", "count", "facet.offset", "1", "facet.limit", "1"),
        "//lst[@name='longdv']/int[@name='0'][.='1']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "longdv", "facet.sort", "index", "facet.offset", "33", "facet.limit", "1", "facet.mincount", "1"),
        "//lst[@name='longdv']/int[@name='33'][.='1']");

    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "floatdv", "facet.sort", "count", "facet.limit", "1"),
        "//lst[@name='floatdv']/int[@name='1.0'][.='51']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "floatdv", "facet.sort", "count", "facet.offset", "1", "facet.limit", "-1", "facet.mincount", "1"),
        "//lst[@name='floatdv']/int[@name='0.0'][.='1']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "floatdv", "facet.sort", "index", "facet.offset", "33", "facet.limit", "1", "facet.mincount", "1"),
        "//lst[@name='floatdv']/int[@name='33.0'][.='1']");

    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "doubledv", "facet.sort", "count", "facet.limit", "1"),
        "//lst[@name='doubledv']/int[@name='3.0'][.='51']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "doubledv", "facet.sort", "count", "facet.offset", "1", "facet.limit", "-1", "facet.mincount", "1"),
        "//lst[@name='doubledv']/int[@name='0.0'][.='1']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "doubledv", "facet.sort", "index", "facet.offset", "33", "facet.limit", "1", "facet.mincount", "1"),
        "//lst[@name='doubledv']/int[@name='33.0'][.='1']");

    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "intdv", "facet.sort", "count", "facet.limit", "1"),
        "//lst[@name='intdv']/int[@name='2'][.='51']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "intdv", "facet.sort", "count", "facet.offset", "1", "facet.limit", "-1", "facet.mincount", "1"),
        "//lst[@name='intdv']/int[@name='0'][.='1']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "intdv", "facet.sort", "index", "facet.offset", "33", "facet.limit", "1", "facet.mincount", "1"),
        "//lst[@name='intdv']/int[@name='33'][.='1']");

    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "datedv", "facet.sort", "count", "facet.limit", "1"),
        "//lst[@name='datedv']/int[@name='1995-12-31T23:59:59.999Z'][.='50']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "datedv", "facet.sort", "count", "facet.offset", "1", "facet.limit", "-1", "facet.mincount", "1"),
        "//lst[@name='datedv']/int[@name='1900-12-31T23:59:59.999Z'][.='1']");
    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "datedv", "facet.sort", "index", "facet.offset", "33", "facet.limit", "1", "facet.mincount", "1"),
        "//lst[@name='datedv']/int[@name='1933-12-31T23:59:59.999Z'][.='1']");

    assertQ(req("q", "booldv:true"),
        "//*[@numFound='83']");

    assertQ(req("q", "booldv:false"),
        "//*[@numFound='17']");

    assertQ(req("q", "*:*", "facet", "true", "rows", "0", "facet.field", "booldv", "facet.sort", "index", "facet.mincount", "1"),
        "//lst[@name='booldv']/int[@name='false'][.='17']",
        "//lst[@name='booldv']/int[@name='true'][.='83']");

  }

  @Test
  public void testDocValuesStats() {
    for (int i = 0; i < 50; ++i) {
      assertU(adoc("id", "1000" + i, "floatdv", "" + i%2, "intdv", "" + i%3, "doubledv", "" + i%4, "longdv", "" + i%5, "datedv", (1900+i%6) + "-12-31T23:59:59.999Z", "stringdv", "abc" + i%7));
      if (rarely()) {
        assertU(commit()); // to have several segments
      }
    }
    assertU(commit());

    assertQ(req("q", "*:*", "stats", "true", "rows", "0", "stats.field", "stringdv"),
        "//str[@name='min'][.='abc0']",
        "//str[@name='max'][.='abc6']",
        "//long[@name='count'][.='50']");

    assertQ(req("q", "*:*", "stats", "true", "rows", "0", "stats.field", "floatdv"),
        "//double[@name='min'][.='0.0']",
        "//double[@name='max'][.='1.0']",
        "//long[@name='count'][.='50']",
        "//double[@name='sum'][.='25.0']",
        "//double[@name='mean'][.='0.5']");

    assertQ(req("q", "*:*", "stats", "true", "rows", "0", "stats.field", "intdv"),
        "//double[@name='min'][.='0.0']",
        "//double[@name='max'][.='2.0']",
        "//long[@name='count'][.='50']",
        "//double[@name='sum'][.='49.0']");

    assertQ(req("q", "*:*", "stats", "true", "rows", "0", "stats.field", "doubledv"),
        "//double[@name='min'][.='0.0']",
        "//double[@name='max'][.='3.0']",
        "//long[@name='count'][.='50']",
        "//double[@name='sum'][.='73.0']");

    assertQ(req("q", "*:*", "stats", "true", "rows", "0", "stats.field", "longdv"),
        "//double[@name='min'][.='0.0']",
        "//double[@name='max'][.='4.0']",
        "//long[@name='count'][.='50']",
        "//double[@name='sum'][.='100.0']",
        "//double[@name='mean'][.='2.0']");

    assertQ(req("q", "*:*", "stats", "true", "rows", "0", "stats.field", "datedv"),
        "//date[@name='min'][.='1900-12-31T23:59:59.999Z']",
        "//date[@name='max'][.='1905-12-31T23:59:59.999Z']",
        "//long[@name='count'][.='50']");

    assertQ(req("q", "*:*", "stats", "true", "rows", "0", "stats.field", "floatdv", "stats.facet", "intdv"),
        "//lst[@name='intdv']/lst[@name='0']/long[@name='count'][.='17']",
        "//lst[@name='intdv']/lst[@name='1']/long[@name='count'][.='17']",
        "//lst[@name='intdv']/lst[@name='2']/long[@name='count'][.='16']");

    assertQ(req("q", "*:*", "stats", "true", "rows", "0", "stats.field", "floatdv", "stats.facet", "datedv"),
        "//lst[@name='datedv']/lst[@name='1900-12-31T23:59:59.999Z']/long[@name='count'][.='9']",
        "//lst[@name='datedv']/lst[@name='1901-12-31T23:59:59.999Z']/long[@name='count'][.='9']",
        "//lst[@name='datedv']/lst[@name='1902-12-31T23:59:59.999Z']/long[@name='count'][.='8']",
        "//lst[@name='datedv']/lst[@name='1903-12-31T23:59:59.999Z']/long[@name='count'][.='8']",
        "//lst[@name='datedv']/lst[@name='1904-12-31T23:59:59.999Z']/long[@name='count'][.='8']",
        "//lst[@name='datedv']/lst[@name='1905-12-31T23:59:59.999Z']/long[@name='count'][.='8']");
  }
  
  /** Tests the ability to do basic queries (without scoring, just match-only) on
   *  docvalues fields that are not inverted (indexed "forward" only)
   */
  @Test
  public void testDocValuesMatch() throws Exception {
    assertU(adoc("id", "1", "floatdv", "2", "intdv", "3", "doubledv", "3.1", "longdv", "5", "datedv", "1995-12-31T23:59:59.999Z", "stringdv", "b", "booldv", "false"));
    assertU(adoc("id", "2", "floatdv", "-5", "intdv", "4", "doubledv", "-4.3", "longdv", "2", "datedv", "1997-12-31T23:59:59.999Z", "stringdv", "a", "booldv", "true"));
    assertU(adoc("id", "3", "floatdv", "3", "intdv", "1", "doubledv", "2.1", "longdv", "1", "datedv", "1996-12-31T23:59:59.999Z", "stringdv", "c", "booldv", "false"));
    assertU(adoc("id", "4", "floatdv", "3", "intdv", "-1", "doubledv", "1.5", "longdv", "1", "datedv", "1996-12-31T23:59:59.999Z", "stringdv", "car"));
    assertU(commit());

    // string: termquery
    assertQ(req("q", "stringdv:car", "sort", "id_i asc"),
        "//*[@numFound='1']",
        "//result/doc[1]/str[@name='id'][.=4]"
    );
    
    // string: range query
    assertQ(req("q", "stringdv:[b TO d]", "sort", "id_i asc"),
        "//*[@numFound='3']",
        "//result/doc[1]/str[@name='id'][.=1]",
        "//result/doc[2]/str[@name='id'][.=3]",
        "//result/doc[3]/str[@name='id'][.=4]"
    );
    
    // string: prefix query
    assertQ(req("q", "stringdv:c*", "sort", "id_i asc"),
        "//*[@numFound='2']",
        "//result/doc[1]/str[@name='id'][.=3]",
        "//result/doc[2]/str[@name='id'][.=4]"
    );
    
    // string: wildcard query
    assertQ(req("q", "stringdv:c?r", "sort", "id_i asc"),
        "//*[@numFound='1']",
        "//result/doc[1]/str[@name='id'][.=4]"
    );
    
    // string: regexp query
    assertQ(req("q", "stringdv:/c[a-b]r/", "sort", "id_i asc"),
        "//*[@numFound='1']",
        "//result/doc[1]/str[@name='id'][.=4]"
    );
    
    // float: termquery
    assertQ(req("q", "floatdv:3", "sort", "id_i asc"),
        "//*[@numFound='2']",
        "//result/doc[1]/str[@name='id'][.=3]",
        "//result/doc[2]/str[@name='id'][.=4]"
    );
    
    // float: rangequery
    assertQ(req("q", "floatdv:[2 TO 3]", "sort", "id_i asc"),
        "//*[@numFound='3']",
        "//result/doc[1]/str[@name='id'][.=1]",
        "//result/doc[2]/str[@name='id'][.=3]",
        "//result/doc[3]/str[@name='id'][.=4]"
    );
    
    // (neg) float: termquery
    assertQ(req("q", "floatdv:\"-5\"", "sort", "id_i asc"),
            "//*[@numFound='1']",
            "//result/doc[1]/str[@name='id'][.=2]"
            );

    // (neg) float: rangequery
    assertQ(req("q", "floatdv:[-6 TO -4]", "sort", "id_i asc"),
            "//*[@numFound='1']",
            "//result/doc[1]/str[@name='id'][.=2]"
            );
    
    // (cross zero bounds) float: rangequery
    assertQ(req("q", "floatdv:[-6 TO 2.1]", "sort", "id_i asc"),
            "//*[@numFound='2']",
            "//result/doc[1]/str[@name='id'][.=1]",
            "//result/doc[2]/str[@name='id'][.=2]"
            );
    
    // int: termquery
    assertQ(req("q", "intdv:1", "sort", "id_i asc"),
            "//*[@numFound='1']",
            "//result/doc[1]/str[@name='id'][.=3]"
            );
    
    // int: rangequery
    assertQ(req("q", "intdv:[3 TO 4]", "sort", "id_i asc"),
            "//*[@numFound='2']",
            "//result/doc[1]/str[@name='id'][.=1]",
            "//result/doc[2]/str[@name='id'][.=2]"
            );
    
    // (neg) int: termquery
    assertQ(req("q", "intdv:\"-1\"", "sort", "id_i asc"),
            "//*[@numFound='1']",
            "//result/doc[1]/str[@name='id'][.=4]"
            );
    
    // (neg) int: rangequery
    assertQ(req("q", "intdv:[-1 TO 1]", "sort", "id_i asc"),
            "//*[@numFound='2']",
            "//result/doc[1]/str[@name='id'][.=3]",
            "//result/doc[2]/str[@name='id'][.=4]"
            );

    // long: termquery
    assertQ(req("q", "longdv:1", "sort", "id_i asc"),
        "//*[@numFound='2']",
        "//result/doc[1]/str[@name='id'][.=3]",
        "//result/doc[2]/str[@name='id'][.=4]"
    );
    
    // long: rangequery
    assertQ(req("q", "longdv:[1 TO 2]", "sort", "id_i asc"),
        "//*[@numFound='3']",
        "//result/doc[1]/str[@name='id'][.=2]",
        "//result/doc[2]/str[@name='id'][.=3]",
        "//result/doc[3]/str[@name='id'][.=4]"
    );
    
    // double: termquery
    assertQ(req("q", "doubledv:3.1", "sort", "id_i asc"),
            "//*[@numFound='1']",
            "//result/doc[1]/str[@name='id'][.=1]"
            );
    
    // double: rangequery
    assertQ(req("q", "doubledv:[2 TO 3.3]", "sort", "id_i asc"),
            "//*[@numFound='2']",
            "//result/doc[1]/str[@name='id'][.=1]",
            "//result/doc[2]/str[@name='id'][.=3]"
            );
    
    // (neg) double: termquery
    assertQ(req("q", "doubledv:\"-4.3\"", "sort", "id_i asc"),
            "//*[@numFound='1']",
            "//result/doc[1]/str[@name='id'][.=2]"
            );
    
    // (neg) double: rangequery
    assertQ(req("q", "doubledv:[-6 TO -4]", "sort", "id_i asc"),
            "//*[@numFound='1']",
            "//result/doc[1]/str[@name='id'][.=2]"
            );
    
    // (cross zero bounds) double: rangequery
    assertQ(req("q", "doubledv:[-6 TO 2.0]", "sort", "id_i asc"),
            "//*[@numFound='2']",
            "//result/doc[1]/str[@name='id'][.=2]",
            "//result/doc[2]/str[@name='id'][.=4]"
            );
    // boolean basic queries:

    assertQ(req("q", "booldv:false", "sort", "id_i asc"),
        "//*[@numFound='2']",
        "//result/doc[1]/str[@name='id'][.=1]",
        "//result/doc[2]/str[@name='id'][.=3]"
    );

    assertQ(req("q", "booldv:true", "sort", "id_i asc"),
        "//*[@numFound='2']",
        "//result/doc[1]/str[@name='id'][.=2]",
        "//result/doc[2]/str[@name='id'][.=4]"
    );

  }

  @Test
  public void testFloatAndDoubleRangeQueryRandom() throws Exception {

    String fieldName[] = new String[] {"floatdv", "doubledv"};
    
    Number largestNegative[] = new Number[] {0f-Float.MIN_NORMAL, 0f-Double.MIN_NORMAL};
    Number smallestPositive[] = new Number[] {Float.MIN_NORMAL, Double.MIN_NORMAL};
    Number positiveInfinity[] = new Number[] {Float.POSITIVE_INFINITY, Double.POSITIVE_INFINITY};
    Number negativeInfinity[] = new Number[] {Float.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY};
    Number largestValue[] = new Number[] {Float.MAX_VALUE, Double.MAX_VALUE};
    Number zero[] = new Number[] {0f, 0d};
    Function<Supplier<Number>,Number> noNaN = (next)
        -> { Number num; while (String.valueOf(num = next.get()).equals("NaN")); return num; };
    List<Supplier<Number>> nextRandNoNaN = Arrays.asList(
        () -> noNaN.apply(() -> Float.intBitsToFloat(random().nextInt())),
        () -> noNaN.apply(() -> Double.longBitsToDouble(random().nextLong())));
    List<Function<Number,Long>> toSortableLong = Arrays.asList(
        (num) -> (long)NumericUtils.floatToSortableInt(num.floatValue()),
        (num) -> NumericUtils.doubleToSortableLong(num.doubleValue()));

    // Number minusZero[] = new Number[] {-0f, -0d}; // -0 == 0, so we should not treat them differently (and we should not guarantee that sign is preserved... we should be able to index both as 0)

    for (int i=0; i<fieldName.length; i++) {
      assertU(delQ("*:*"));
      commit();

      Number specialValues[] = new Number[] {largestNegative[i], smallestPositive[i], negativeInfinity[i], 
          largestValue[i], positiveInfinity[i], zero[i]};

      List<Number> values = new ArrayList<>();
      int numDocs = 1 + random().nextInt(10);
      for (int j=0; j<numDocs; j++) {
        
        if (random().nextInt(100) < 5) { // Add a boundary value with 5% probability
          values.add(specialValues[random().nextInt(specialValues.length)]);
        } else 
        {
          if (fieldName[i].equals("floatdv")) { // Add random values with 95% probability
            values.add(Float.intBitsToFloat(random().nextInt()));
          } else {
            values.add(Double.longBitsToDouble(random().nextLong()));
          }
        }
      }
      // Indexing
      for (int j=0; j<values.size(); j++) {
        assertU(adoc("id", String.valueOf(j+1), fieldName[i], String.valueOf(values.get(j))));
      }
      assertU(commit());

      log.info("Indexed values: {}", values);
      // Querying
      int numQueries = 10000;
      for (int j=0; j<numQueries; j++) {
        boolean minInclusive = random().nextBoolean();
        boolean maxInclusive = random().nextBoolean();

        Number minVal, maxVal;
        String min = String.valueOf(minVal = nextRandNoNaN.get(i).get());
        String max = String.valueOf(maxVal = nextRandNoNaN.get(i).get());

        // randomly use boundary values for min, 15% of the time
        int r = random().nextInt(100);
        if (r<5) {
          minVal = negativeInfinity[i]; min = "*";
        } else if (r<10) {
          minVal = specialValues[random().nextInt(specialValues.length)]; min = String.valueOf(minVal);
        } else if (r<15) {
          minVal = values.get(random().nextInt(values.size())); min = String.valueOf(minVal);
        }

        // randomly use boundary values for max, 15% of the time
        r = random().nextInt(100);
        if (r<5) {
          maxVal = positiveInfinity[i]; max = "*";
        } else if (r<10) {
            maxVal = specialValues[random().nextInt(specialValues.length)]; max = String.valueOf(maxVal);
        } else if (r<15) {
          // Don't pick a NaN for the range query
          Number tmp = values.get(random().nextInt(values.size()));
          if (!Double.isNaN(tmp.doubleValue()) && !Float.isNaN(tmp.floatValue())) {
            maxVal = tmp; max = String.valueOf(maxVal);
          }
        }

        List<String> tests = new ArrayList<>();
        int counter = 0;
        
        for (int k=0; k<values.size(); k++) {
          Number val = values.get(k);
          long valSortable = toSortableLong.get(i).apply(val);
          long minSortable = toSortableLong.get(i).apply(minVal);
          long maxSortable = toSortableLong.get(i).apply(maxVal);
          
          if((minInclusive && minSortable<=valSortable || !minInclusive && minSortable<valSortable || (min.equals("*") && val == negativeInfinity[i])) &&
              (maxInclusive && maxSortable>=valSortable || !maxInclusive && maxSortable>valSortable || (max.equals("*") && val == positiveInfinity[i]))) {
            counter++;
            tests.add("//result/doc["+counter+"]/str[@name='id'][.="+(k+1)+"]");
            tests.add("//result/doc["+counter+"]/float[@name='score'][.=1.0]");
          }
        }

        tests.add(0, "//*[@numFound='"+counter+"']");

        String testsArr[] = new String[tests.size()];
        for (int k=0; k<tests.size(); k++) {
          testsArr[k] = tests.get(k);
        }
        log.info("Expected: {}", tests);
        assertQ(req("q", fieldName[i] + ":" + (minInclusive? '[': '{') + min + " TO " + max + (maxInclusive? ']': '}'),
                         "sort", "id_i asc", "fl", "id,"+fieldName[i]+",score"),
            testsArr);
      }
    }
  }

  @Test
  public void testFloatAndDoubleRangeQuery() throws Exception {
    String fieldName[] = new String[] {"floatdv", "doubledv"};
    String largestNegative[] = new String[] {String.valueOf(0f-Float.MIN_NORMAL), String.valueOf(0f-Double.MIN_NORMAL)};
    String negativeInfinity[] = new String[] {String.valueOf(Float.NEGATIVE_INFINITY), String.valueOf(Double.NEGATIVE_INFINITY)};
    String largestValue[] = new String[] {String.valueOf(Float.MAX_VALUE), String.valueOf(Double.MAX_VALUE)};
    
    for (int i=0; i<fieldName.length; i++) {
      assertU(adoc("id", "1", fieldName[i], "2"));
      assertU(adoc("id", "2", fieldName[i], "-5"));
      assertU(adoc("id", "3", fieldName[i], "3"));
      assertU(adoc("id", "4", fieldName[i], "3"));
      assertU(adoc("id", "5", fieldName[i], largestNegative[i]));
      assertU(adoc("id", "6", fieldName[i], negativeInfinity[i]));
      assertU(adoc("id", "7", fieldName[i], largestValue[i]));
      assertU(commit());

      // Negative Zero to Positive
      assertQ(req("q", fieldName[i]+":[-0.0 TO 2.5]", "sort", "id_i asc", "fl", "id,"+fieldName[i]+",score"),
          "//*[@numFound='1']",
          "//result/doc[1]/str[@name='id'][.=1]"
          );

      // Negative to Positive Zero
      assertQ(req("q", fieldName[i]+":[-6 TO 0]", "sort", "id_i asc", "fl", "id,"+fieldName[i]+",score"),
          "//*[@numFound='2']",
          "//result/doc[1]/str[@name='id'][.=2]",
          "//result/doc[2]/str[@name='id'][.=5]"
          );

      // Negative to Positive
      assertQ(req("q", fieldName[i]+":[-6 TO 2.5]", "sort", "id_i asc", "fl", "id,"+fieldName[i]+",score"),
          "//*[@numFound='3']",
          "//result/doc[1]/str[@name='id'][.=1]",
          "//result/doc[2]/str[@name='id'][.=2]",
          "//result/doc[3]/str[@name='id'][.=5]"
          );

      // Positive to Positive
      assertQ(req("q", fieldName[i]+":[2 TO 3]", "sort", "id_i asc", "fl", "id,"+fieldName[i]+",score"),
          "//*[@numFound='3']",
          "//result/doc[1]/str[@name='id'][.=1]",
          "//result/doc[2]/str[@name='id'][.=3]",
          "//result/doc[3]/str[@name='id'][.=4]"
          );

      // Positive to POSITIVE_INF
      assertQ(req("q", fieldName[i]+":[2 TO *]", "sort", "id_i asc", "fl", "id,"+fieldName[i]+",score"),
          "//*[@numFound='4']",
          "//result/doc[1]/str[@name='id'][.=1]",
          "//result/doc[2]/str[@name='id'][.=3]",
          "//result/doc[3]/str[@name='id'][.=4]",
          "//result/doc[4]/str[@name='id'][.=7]"
          );

      // NEGATIVE_INF to Negative
      assertQ(req("q", fieldName[i]+":[* TO -1]", "sort", "id_i asc", "fl", "id,"+fieldName[i]+",score"),
          "//*[@numFound='2']",
          "//result/doc[1]/str[@name='id'][.=2]",
          "//result/doc[2]/str[@name='id'][.=6]"
          );

      // NEGATIVE_INF to Positive
      assertQ(req("q", fieldName[i]+":[* TO 2]", "sort", "id_i asc", "fl", "id,"+fieldName[i]),
          "//*[@numFound='4']",
          "//result/doc[1]/str[@name='id'][.=1]",
          "//result/doc[2]/str[@name='id'][.=2]",
          "//result/doc[3]/str[@name='id'][.=5]",
          "//result/doc[4]/str[@name='id'][.=6]"
          );

      // NEGATIVE_INF to Positive (non-inclusive)
      assertQ(req("q", fieldName[i]+":[* TO 2}", "sort", "id_i asc", "fl", "id,"+fieldName[i]),
          "//*[@numFound='3']",
          "//result/doc[1]/str[@name='id'][.=2]",
          "//result/doc[2]/str[@name='id'][.=5]",
          "//result/doc[3]/str[@name='id'][.=6]"
          );

      // Negative to POSITIVE_INF
      assertQ(req("q", fieldName[i]+":[-6 TO *]", "sort", "id_i asc", "fl", "id,"+fieldName[i]),
          "//*[@numFound='6']",
          "//result/doc[1]/str[@name='id'][.=1]",
          "//result/doc[2]/str[@name='id'][.=2]",
          "//result/doc[3]/str[@name='id'][.=3]",
          "//result/doc[4]/str[@name='id'][.=4]",
          "//result/doc[5]/str[@name='id'][.=5]",
          "//result/doc[6]/str[@name='id'][.=7]"
          );

      // NEGATIVE_INF to POSITIVE_INF
      assertQ(req("q", fieldName[i]+":[* TO *]", "sort", "id_i asc", "fl", "id,"+fieldName[i]+",score"),
          "//*[@numFound='7']",
          "//result/doc[1]/str[@name='id'][.=1]",
          "//result/doc[2]/str[@name='id'][.=2]",
          "//result/doc[3]/str[@name='id'][.=3]",
          "//result/doc[4]/str[@name='id'][.=4]",
          "//result/doc[5]/str[@name='id'][.=5]",
          "//result/doc[6]/str[@name='id'][.=6]",
          "//result/doc[7]/str[@name='id'][.=7]",
          "//result/doc[1]/float[@name='score'][.=1.0]",
          "//result/doc[2]/float[@name='score'][.=1.0]",
          "//result/doc[3]/float[@name='score'][.=1.0]",
          "//result/doc[4]/float[@name='score'][.=1.0]",
          "//result/doc[5]/float[@name='score'][.=1.0]",
          "//result/doc[6]/float[@name='score'][.=1.0]",
          "//result/doc[7]/float[@name='score'][.=1.0]"
          );
    }
  }
}