← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/builders/TestNumericRangeQueryBuilder.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/contrib/xml-query-parser/src/test/org/apache/lucene/xmlparser/builders/TestNumericRangeQueryBuilder.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.search.NumericRangeQuery;
31
 
import org.apache.lucene.search.Query;
32
 
import org.apache.lucene.xmlparser.ParserException;
33
 
import org.w3c.dom.Document;
34
 
import org.xml.sax.SAXException;
35
 
 
36
 
public class TestNumericRangeQueryBuilder extends LuceneTestCase {
37
 
 
38
 
        public void testGetFilterHandleNumericParseErrorStrict() throws Exception {
39
 
                NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
40
 
 
41
 
                String xml = "<NumericRangeQuery fieldName='AGE' type='int' lowerTerm='-1' upperTerm='NaN'/>";
42
 
                Document doc = getDocumentFromString(xml);
43
 
                try {
44
 
                        filterBuilder.getQuery(doc.getDocumentElement());
45
 
                } catch (ParserException e) {
46
 
                        return;
47
 
                }
48
 
                fail("Expected to throw " + ParserException.class);
49
 
        }
50
 
 
51
 
        public void testGetFilterInt() throws Exception {
52
 
                NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
53
 
 
54
 
                String xml = "<NumericRangeQuery fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10'/>";
55
 
                Document doc = getDocumentFromString(xml);
56
 
                Query filter = filterBuilder.getQuery(doc.getDocumentElement());
57
 
                assertTrue(filter instanceof NumericRangeQuery<?>);
58
 
                @SuppressWarnings("unchecked")
59
 
                NumericRangeQuery<Integer> numRangeFilter = (NumericRangeQuery<Integer>) filter;
60
 
                assertEquals(Integer.valueOf(-1), numRangeFilter.getMin());
61
 
                assertEquals(Integer.valueOf(10), numRangeFilter.getMax());
62
 
                assertEquals("AGE", numRangeFilter.getField());
63
 
                assertTrue(numRangeFilter.includesMin());
64
 
                assertTrue(numRangeFilter.includesMax());
65
 
 
66
 
                String xml2 = "<NumericRangeQuery fieldName='AGE' type='int' lowerTerm='-1' upperTerm='10' includeUpper='false'/>";
67
 
                Document doc2 = getDocumentFromString(xml2);
68
 
                Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
69
 
                assertTrue(filter2 instanceof NumericRangeQuery<?>);
70
 
                @SuppressWarnings("unchecked")
71
 
                NumericRangeQuery<Integer> numRangeFilter2 = (NumericRangeQuery) filter2;
72
 
                assertEquals(Integer.valueOf(-1), numRangeFilter2.getMin());
73
 
                assertEquals(Integer.valueOf(10), numRangeFilter2.getMax());
74
 
                assertEquals("AGE", numRangeFilter2.getField());
75
 
                assertTrue(numRangeFilter2.includesMin());
76
 
                assertFalse(numRangeFilter2.includesMax());
77
 
        }
78
 
 
79
 
        public void testGetFilterLong() throws Exception {
80
 
                NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
81
 
 
82
 
                String xml = "<NumericRangeQuery fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000'/>";
83
 
                Document doc = getDocumentFromString(xml);
84
 
                Query filter = filterBuilder.getQuery(doc.getDocumentElement());
85
 
                assertTrue(filter instanceof NumericRangeQuery<?>);
86
 
                @SuppressWarnings("unchecked")
87
 
                NumericRangeQuery<Long> numRangeFilter = (NumericRangeQuery) filter;
88
 
                assertEquals(Long.valueOf(-2321L), numRangeFilter.getMin());
89
 
                assertEquals(Long.valueOf(60000000L), numRangeFilter.getMax());
90
 
                assertEquals("AGE", numRangeFilter.getField());
91
 
                assertTrue(numRangeFilter.includesMin());
92
 
                assertTrue(numRangeFilter.includesMax());
93
 
 
94
 
                String xml2 = "<NumericRangeQuery fieldName='AGE' type='LoNg' lowerTerm='-2321' upperTerm='60000000' includeUpper='false'/>";
95
 
                Document doc2 = getDocumentFromString(xml2);
96
 
                Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
97
 
                assertTrue(filter2 instanceof NumericRangeQuery<?>);
98
 
                @SuppressWarnings("unchecked")
99
 
                NumericRangeQuery<Long> numRangeFilter2 = (NumericRangeQuery) filter2;
100
 
                assertEquals(Long.valueOf(-2321L), numRangeFilter2.getMin());
101
 
                assertEquals(Long.valueOf(60000000L), numRangeFilter2.getMax());
102
 
                assertEquals("AGE", numRangeFilter2.getField());
103
 
                assertTrue(numRangeFilter2.includesMin());
104
 
                assertFalse(numRangeFilter2.includesMax());
105
 
        }
106
 
 
107
 
        public void testGetFilterDouble() throws Exception {
108
 
                NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
109
 
 
110
 
                String xml = "<NumericRangeQuery fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023'/>";
111
 
                Document doc = getDocumentFromString(xml);
112
 
 
113
 
                Query filter = filterBuilder.getQuery(doc.getDocumentElement());
114
 
                assertTrue(filter instanceof NumericRangeQuery<?>);
115
 
                @SuppressWarnings("unchecked")
116
 
                NumericRangeQuery<Double> numRangeFilter = (NumericRangeQuery) filter;
117
 
                assertEquals(Double.valueOf(-23.21d), numRangeFilter.getMin());
118
 
                assertEquals(Double.valueOf(60000.00023d), numRangeFilter.getMax());
119
 
                assertEquals("AGE", numRangeFilter.getField());
120
 
                assertTrue(numRangeFilter.includesMin());
121
 
                assertTrue(numRangeFilter.includesMax());
122
 
 
123
 
                String xml2 = "<NumericRangeQuery fieldName='AGE' type='doubLe' lowerTerm='-23.21' upperTerm='60000.00023' includeUpper='false'/>";
124
 
                Document doc2 = getDocumentFromString(xml2);
125
 
                Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
126
 
                assertTrue(filter2 instanceof NumericRangeQuery<?>);
127
 
                @SuppressWarnings("unchecked")
128
 
                NumericRangeQuery<Double> numRangeFilter2 = (NumericRangeQuery) filter2;
129
 
                assertEquals(Double.valueOf(-23.21d), numRangeFilter2.getMin());
130
 
                assertEquals(Double.valueOf(60000.00023d), numRangeFilter2.getMax());
131
 
                assertEquals("AGE", numRangeFilter2.getField());
132
 
                assertTrue(numRangeFilter2.includesMin());
133
 
                assertFalse(numRangeFilter2.includesMax());
134
 
        }
135
 
 
136
 
        public void testGetFilterFloat() throws Exception {
137
 
                NumericRangeQueryBuilder filterBuilder = new NumericRangeQueryBuilder();
138
 
 
139
 
                String xml = "<NumericRangeQuery fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23'/>";
140
 
                Document doc = getDocumentFromString(xml);
141
 
 
142
 
                Query filter = filterBuilder.getQuery(doc.getDocumentElement());
143
 
                assertTrue(filter instanceof NumericRangeQuery<?>);
144
 
                @SuppressWarnings("unchecked")
145
 
                NumericRangeQuery<Float> numRangeFilter = (NumericRangeQuery) filter;
146
 
                assertEquals(Float.valueOf(-2.321432f), numRangeFilter.getMin());
147
 
                assertEquals(Float.valueOf(32432.23f), numRangeFilter.getMax());
148
 
                assertEquals("AGE", numRangeFilter.getField());
149
 
                assertTrue(numRangeFilter.includesMin());
150
 
                assertTrue(numRangeFilter.includesMax());
151
 
 
152
 
                String xml2 = "<NumericRangeQuery fieldName='AGE' type='FLOAT' lowerTerm='-2.321432' upperTerm='32432.23' includeUpper='false' precisionStep='2' />";
153
 
                Document doc2 = getDocumentFromString(xml2);
154
 
 
155
 
                Query filter2 = filterBuilder.getQuery(doc2.getDocumentElement());
156
 
                assertTrue(filter2 instanceof NumericRangeQuery<?>);
157
 
                @SuppressWarnings("unchecked")
158
 
                NumericRangeQuery<Float> numRangeFilter2 = (NumericRangeQuery) filter2;
159
 
                assertEquals(Float.valueOf(-2.321432f), numRangeFilter2.getMin());
160
 
                assertEquals(Float.valueOf(32432.23f), numRangeFilter2.getMax());
161
 
                assertEquals("AGE", numRangeFilter2.getField());
162
 
                assertTrue(numRangeFilter2.includesMin());
163
 
                assertFalse(numRangeFilter2.includesMax());
164
 
        }
165
 
 
166
 
        private static Document getDocumentFromString(String str)
167
 
                        throws SAXException, IOException, ParserConfigurationException {
168
 
                InputStream is = new ByteArrayInputStream(str.getBytes());
169
 
                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
170
 
                factory.setNamespaceAware(true);
171
 
                DocumentBuilder builder = factory.newDocumentBuilder();
172
 
                Document doc = builder.parse(is);
173
 
                is.close();
174
 
                return doc;
175
 
        }
176
 
 
177
 
}