lucene-java-3.5.0/lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/builders/TestNumericRangeFilterBuilder.java

   1 package org.apache.lucene.xmlparser.builders;
   2
   3 /**
   4  * Licensed to the Apache Software Foundation (ASF) under one or more
   5  * contributor license agreements.  See the NOTICE file distributed with
   6  * this work for additional information regarding copyright ownership.
   7  * The ASF licenses this file to You under the Apache License, Version 2.0
   8  * (the "License"); you may not use this file except in compliance with
   9  * the License.  You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 import java.io.ByteArrayInputStream;
  21 import java.io.IOException;
  22 import java.io.InputStream;
  23
  24 import javax.xml.parsers.DocumentBuilder;
  25 import javax.xml.parsers.DocumentBuilderFactory;
  26 import javax.xml.parsers.ParserConfigurationException;
  27
  28 import org.apache.lucene.util.LuceneTestCase;
  29
  30 import org.apache.lucene.index.IndexReader;
  31 import org.apache.lucene.index.IndexWriter;
  32 import org.apache.lucene.search.Filter;
  33 import org.apache.lucene.search.NumericRangeFilter;
  34 import org.apache.lucene.store.Directory;
  35 import org.apache.lucene.xmlparser.ParserException;
  36 import org.w3c.dom.Document;
  37 import org.xml.sax.SAXException;
  38
  39 public class TestNumericRangeFilterBuilder extends LuceneTestCase {
  40
  41         public void testGetFilterHandleNumericParseErrorStrict() throws Exception {
  42                 NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
  43                 filterBuilder.setStrictMode(true);
  44
  45                 String xml = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='NaN'/>";
  46                 Document doc = getDocumentFromString(xml);
  47                 try {
  48                         filterBuilder.getFilter(doc.getDocumentElement());
  49                 } catch (ParserException e) {
  50                         return;
  51                 }
  52                 fail("Expected to throw " + ParserException.class);
  53         }
  54
  55         public void testGetFilterHandleNumericParseError() throws Exception {
  56                 NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
  57                 filterBuilder.setStrictMode(false);
  58
  59                 String xml = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='NaN'/>";
  60                 Document doc = getDocumentFromString(xml);
  61                 Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
  62                 Directory ramDir = newDirectory();
  63                 IndexWriter writer = new IndexWriter(ramDir, newIndexWriterConfig(TEST_VERSION_CURRENT, null));
  64                 writer.commit();
  65                 try
  66                 {
  67                         IndexReader reader = IndexReader.open(ramDir, true);
  68                         try
  69                         {
  70                                 assertNull(filter.getDocIdSet(reader));
  71                         }
  72                         finally
  73                         {
  74                                 reader.close();
  75                         }
  76                 }
  77                 finally
  78                 {
  79                         writer.commit();
  80                         writer.close();
  81                         ramDir.close();
  82                 }
  83         }
  84
  85         public void testGetFilterInt() throws Exception {
  86                 NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
  87                 filterBuilder.setStrictMode(true);
  88
  89                 String xml = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10'/>";
  90                 Document doc = getDocumentFromString(xml);
  91                 Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
  92                 assertTrue(filter instanceof NumericRangeFilter<?>);
  93                 @SuppressWarnings("unchecked")
  94                 NumericRangeFilter<Integer> numRangeFilter = (NumericRangeFilter<Integer>) filter;
  95                 assertEquals(Integer.valueOf(-1), numRangeFilter.getMin());
  96                 assertEquals(Integer.valueOf(10), numRangeFilter.getMax());
  97                 assertEquals("AGE", numRangeFilter.getField());
  98                 assertTrue(numRangeFilter.includesMin());
  99                 assertTrue(numRangeFilter.includesMax());
 100
 101                 String xml2 = "<NumericRangeFilter fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10' includeUpper='false'/>";
 102                 Document doc2 = getDocumentFromString(xml2);
 103                 Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
 104                 assertTrue(filter2 instanceof NumericRangeFilter<?>);
 105                 @SuppressWarnings("unchecked")
 106                 NumericRangeFilter<Integer> numRangeFilter2 = (NumericRangeFilter) filter2;
 107                 assertEquals(Integer.valueOf(-1), numRangeFilter2.getMin());
 108                 assertEquals(Integer.valueOf(10), numRangeFilter2.getMax());
 109                 assertEquals("AGE", numRangeFilter2.getField());
 110                 assertTrue(numRangeFilter2.includesMin());
 111                 assertFalse(numRangeFilter2.includesMax());
 112         }
 113
 114         public void testGetFilterLong() throws Exception {
 115                 NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
 116                 filterBuilder.setStrictMode(true);
 117
 118                 String xml = "<NumericRangeFilter fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000'/>";
 119                 Document doc = getDocumentFromString(xml);
 120                 Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
 121                 assertTrue(filter instanceof NumericRangeFilter<?>);
 122                 @SuppressWarnings("unchecked")
 123                 NumericRangeFilter<Long> numRangeFilter = (NumericRangeFilter) filter;
 124                 assertEquals(Long.valueOf(-2321L), numRangeFilter.getMin());
 125                 assertEquals(Long.valueOf(60000000L), numRangeFilter.getMax());
 126                 assertEquals("AGE", numRangeFilter.getField());
 127                 assertTrue(numRangeFilter.includesMin());
 128                 assertTrue(numRangeFilter.includesMax());
 129
 130                 String xml2 = "<NumericRangeFilter fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000' includeUpper='false'/>";
 131                 Document doc2 = getDocumentFromString(xml2);
 132                 Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
 133                 assertTrue(filter2 instanceof NumericRangeFilter<?>);
 134                 @SuppressWarnings("unchecked")
 135                 NumericRangeFilter<Long> numRangeFilter2 = (NumericRangeFilter) filter2;
 136                 assertEquals(Long.valueOf(-2321L), numRangeFilter2.getMin());
 137                 assertEquals(Long.valueOf(60000000L), numRangeFilter2.getMax());
 138                 assertEquals("AGE", numRangeFilter2.getField());
 139                 assertTrue(numRangeFilter2.includesMin());
 140                 assertFalse(numRangeFilter2.includesMax());
 141         }
 142
 143         public void testGetFilterDouble() throws Exception {
 144                 NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
 145                 filterBuilder.setStrictMode(true);
 146
 147                 String xml = "<NumericRangeFilter fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023'/>";
 148                 Document doc = getDocumentFromString(xml);
 149
 150                 Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
 151                 assertTrue(filter instanceof NumericRangeFilter<?>);
 152                 @SuppressWarnings("unchecked")
 153                 NumericRangeFilter<Double> numRangeFilter = (NumericRangeFilter) filter;
 154                 assertEquals(Double.valueOf(-23.21d), numRangeFilter.getMin());
 155                 assertEquals(Double.valueOf(60000.00023d), numRangeFilter.getMax());
 156                 assertEquals("AGE", numRangeFilter.getField());
 157                 assertTrue(numRangeFilter.includesMin());
 158                 assertTrue(numRangeFilter.includesMax());
 159
 160                 String xml2 = "<NumericRangeFilter fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023' includeUpper='false'/>";
 161                 Document doc2 = getDocumentFromString(xml2);
 162                 Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
 163                 assertTrue(filter2 instanceof NumericRangeFilter<?>);
 164                 @SuppressWarnings("unchecked")
 165                 NumericRangeFilter<Double> numRangeFilter2 = (NumericRangeFilter) filter2;
 166                 assertEquals(Double.valueOf(-23.21d), numRangeFilter2.getMin());
 167                 assertEquals(Double.valueOf(60000.00023d), numRangeFilter2.getMax());
 168                 assertEquals("AGE", numRangeFilter2.getField());
 169                 assertTrue(numRangeFilter2.includesMin());
 170                 assertFalse(numRangeFilter2.includesMax());
 171         }
 172
 173         public void testGetFilterFloat() throws Exception {
 174                 NumericRangeFilterBuilder filterBuilder = new NumericRangeFilterBuilder();
 175                 filterBuilder.setStrictMode(true);
 176
 177                 String xml = "<NumericRangeFilter fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23'/>";
 178                 Document doc = getDocumentFromString(xml);
 179
 180                 Filter filter = filterBuilder.getFilter(doc.getDocumentElement());
 181                 assertTrue(filter instanceof NumericRangeFilter<?>);
 182                 @SuppressWarnings("unchecked")
 183                 NumericRangeFilter<Float> numRangeFilter = (NumericRangeFilter) filter;
 184                 assertEquals(Float.valueOf(-2.321432f), numRangeFilter.getMin());
 185                 assertEquals(Float.valueOf(32432.23f), numRangeFilter.getMax());
 186                 assertEquals("AGE", numRangeFilter.getField());
 187                 assertTrue(numRangeFilter.includesMin());
 188                 assertTrue(numRangeFilter.includesMax());
 189
 190                 String xml2 = "<NumericRangeFilter fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23' includeUpper='false' precisionStep='2' />";
 191                 Document doc2 = getDocumentFromString(xml2);
 192
 193                 Filter filter2 = filterBuilder.getFilter(doc2.getDocumentElement());
 194                 assertTrue(filter2 instanceof NumericRangeFilter<?>);
 195                 @SuppressWarnings("unchecked")
 196                 NumericRangeFilter<Float> numRangeFilter2 = (NumericRangeFilter) filter2;
 197                 assertEquals(Float.valueOf(-2.321432f), numRangeFilter2.getMin());
 198                 assertEquals(Float.valueOf(32432.23f), numRangeFilter2.getMax());
 199                 assertEquals("AGE", numRangeFilter2.getField());
 200                 assertTrue(numRangeFilter2.includesMin());
 201                 assertFalse(numRangeFilter2.includesMax());
 202         }
 203
 204         private static Document getDocumentFromString(String str)
 205                         throws SAXException, IOException, ParserConfigurationException {
 206                 InputStream is = new ByteArrayInputStream(str.getBytes());
 207                 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 208                 factory.setNamespaceAware(true);
 209                 DocumentBuilder builder = factory.newDocumentBuilder();
 210                 Document doc = builder.parse(is);
 211                 is.close();
 212                 return doc;
 213         }
 214
 215 }