← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lucene/src/test/org/apache/lucene/document/TestDateTools.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/src/test/org/apache/lucene/document/TestDateTools.java
1
 
package org.apache.lucene.document;
2
 
 
3
 
import java.text.ParseException;
4
 
import java.text.SimpleDateFormat;
5
 
import java.util.Calendar;
6
 
import java.util.Date;
7
 
import java.util.GregorianCalendar;
8
 
import java.util.TimeZone;
9
 
import java.util.Locale;
10
 
 
11
 
import org.apache.lucene.util.LuceneTestCase;
12
 
 
13
 
/**
14
 
 * Licensed to the Apache Software Foundation (ASF) under one or more
15
 
 * contributor license agreements.  See the NOTICE file distributed with
16
 
 * this work for additional information regarding copyright ownership.
17
 
 * The ASF licenses this file to You under the Apache License, Version 2.0
18
 
 * (the "License"); you may not use this file except in compliance with
19
 
 * the License.  You may obtain a copy of the License at
20
 
 *
21
 
 *     http://www.apache.org/licenses/LICENSE-2.0
22
 
 *
23
 
 * Unless required by applicable law or agreed to in writing, software
24
 
 * distributed under the License is distributed on an "AS IS" BASIS,
25
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
26
 
 * See the License for the specific language governing permissions and
27
 
 * limitations under the License.
28
 
 */
29
 
public class TestDateTools extends LuceneTestCase {
30
 
 
31
 
  public void testStringToDate() throws ParseException {
32
 
    
33
 
    Date d = null;
34
 
    d = DateTools.stringToDate("2004");
35
 
    assertEquals("2004-01-01 00:00:00:000", isoFormat(d));
36
 
    d = DateTools.stringToDate("20040705");
37
 
    assertEquals("2004-07-05 00:00:00:000", isoFormat(d));
38
 
    d = DateTools.stringToDate("200407050910");
39
 
    assertEquals("2004-07-05 09:10:00:000", isoFormat(d));
40
 
    d = DateTools.stringToDate("20040705091055990");
41
 
    assertEquals("2004-07-05 09:10:55:990", isoFormat(d));
42
 
 
43
 
    try {
44
 
      d = DateTools.stringToDate("97");    // no date
45
 
      fail();
46
 
    } catch(ParseException e) { /* expected exception */ }
47
 
    try {
48
 
      d = DateTools.stringToDate("200401011235009999");    // no date
49
 
      fail();
50
 
    } catch(ParseException e) { /* expected exception */ }
51
 
    try {
52
 
      d = DateTools.stringToDate("aaaa");    // no date
53
 
      fail();
54
 
    } catch(ParseException e) { /* expected exception */ }
55
 
 
56
 
  }
57
 
  
58
 
  public void testStringtoTime() throws ParseException {
59
 
    long time = DateTools.stringToTime("197001010000");
60
 
    Calendar cal = new GregorianCalendar();
61
 
    cal.clear();
62
 
    cal.set(1970, 0, 1,    // year=1970, month=january, day=1
63
 
        0, 0, 0);          // hour, minute, second
64
 
    cal.set(Calendar.MILLISECOND, 0);
65
 
    cal.setTimeZone(TimeZone.getTimeZone("GMT"));
66
 
    assertEquals(cal.getTime().getTime(), time);
67
 
    cal.set(1980, 1, 2,    // year=1980, month=february, day=2
68
 
        11, 5, 0);          // hour, minute, second
69
 
    cal.set(Calendar.MILLISECOND, 0);
70
 
    time = DateTools.stringToTime("198002021105");
71
 
    assertEquals(cal.getTime().getTime(), time);
72
 
  }
73
 
  
74
 
  public void testDateAndTimetoString() throws ParseException {
75
 
    Calendar cal = new GregorianCalendar();
76
 
    cal.clear();
77
 
    cal.setTimeZone(TimeZone.getTimeZone("GMT"));
78
 
    cal.set(2004, 1, 3,   // year=2004, month=february(!), day=3
79
 
        22, 8, 56);       // hour, minute, second
80
 
    cal.set(Calendar.MILLISECOND, 333);
81
 
    
82
 
    String dateString;
83
 
    dateString = DateTools.dateToString(cal.getTime(), DateTools.Resolution.YEAR);
84
 
    assertEquals("2004", dateString);
85
 
    assertEquals("2004-01-01 00:00:00:000", isoFormat(DateTools.stringToDate(dateString)));
86
 
    
87
 
    dateString = DateTools.dateToString(cal.getTime(), DateTools.Resolution.MONTH);
88
 
    assertEquals("200402", dateString);
89
 
    assertEquals("2004-02-01 00:00:00:000", isoFormat(DateTools.stringToDate(dateString)));
90
 
 
91
 
    dateString = DateTools.dateToString(cal.getTime(), DateTools.Resolution.DAY);
92
 
    assertEquals("20040203", dateString);
93
 
    assertEquals("2004-02-03 00:00:00:000", isoFormat(DateTools.stringToDate(dateString)));
94
 
    
95
 
    dateString = DateTools.dateToString(cal.getTime(), DateTools.Resolution.HOUR);
96
 
    assertEquals("2004020322", dateString);
97
 
    assertEquals("2004-02-03 22:00:00:000", isoFormat(DateTools.stringToDate(dateString)));
98
 
    
99
 
    dateString = DateTools.dateToString(cal.getTime(), DateTools.Resolution.MINUTE);
100
 
    assertEquals("200402032208", dateString);
101
 
    assertEquals("2004-02-03 22:08:00:000", isoFormat(DateTools.stringToDate(dateString)));
102
 
    
103
 
    dateString = DateTools.dateToString(cal.getTime(), DateTools.Resolution.SECOND);
104
 
    assertEquals("20040203220856", dateString);
105
 
    assertEquals("2004-02-03 22:08:56:000", isoFormat(DateTools.stringToDate(dateString)));
106
 
    
107
 
    dateString = DateTools.dateToString(cal.getTime(), DateTools.Resolution.MILLISECOND);
108
 
    assertEquals("20040203220856333", dateString);
109
 
    assertEquals("2004-02-03 22:08:56:333", isoFormat(DateTools.stringToDate(dateString)));
110
 
 
111
 
    // date before 1970:
112
 
    cal.set(1961, 2, 5,   // year=1961, month=march(!), day=5
113
 
        23, 9, 51);       // hour, minute, second
114
 
    cal.set(Calendar.MILLISECOND, 444);
115
 
    dateString = DateTools.dateToString(cal.getTime(), DateTools.Resolution.MILLISECOND);
116
 
    assertEquals("19610305230951444", dateString);
117
 
    assertEquals("1961-03-05 23:09:51:444", isoFormat(DateTools.stringToDate(dateString)));
118
 
 
119
 
    dateString = DateTools.dateToString(cal.getTime(), DateTools.Resolution.HOUR);
120
 
    assertEquals("1961030523", dateString);
121
 
    assertEquals("1961-03-05 23:00:00:000", isoFormat(DateTools.stringToDate(dateString)));
122
 
 
123
 
    // timeToString:
124
 
    cal.set(1970, 0, 1, // year=1970, month=january, day=1
125
 
        0, 0, 0); // hour, minute, second
126
 
    cal.set(Calendar.MILLISECOND, 0);
127
 
    dateString = DateTools.timeToString(cal.getTime().getTime(),
128
 
        DateTools.Resolution.MILLISECOND);
129
 
    assertEquals("19700101000000000", dateString);
130
 
        
131
 
    cal.set(1970, 0, 1, // year=1970, month=january, day=1
132
 
        1, 2, 3); // hour, minute, second
133
 
    cal.set(Calendar.MILLISECOND, 0);
134
 
    dateString = DateTools.timeToString(cal.getTime().getTime(),
135
 
        DateTools.Resolution.MILLISECOND);
136
 
    assertEquals("19700101010203000", dateString);
137
 
  }
138
 
  
139
 
  public void testRound() {
140
 
    Calendar cal = new GregorianCalendar();
141
 
    cal.clear();
142
 
    cal.setTimeZone(TimeZone.getTimeZone("GMT"));
143
 
    cal.set(2004, 1, 3,   // year=2004, month=february(!), day=3
144
 
        22, 8, 56);       // hour, minute, second
145
 
    cal.set(Calendar.MILLISECOND, 333);
146
 
    Date date = cal.getTime();
147
 
    assertEquals("2004-02-03 22:08:56:333", isoFormat(date));
148
 
 
149
 
    Date dateYear = DateTools.round(date, DateTools.Resolution.YEAR);
150
 
    assertEquals("2004-01-01 00:00:00:000", isoFormat(dateYear));
151
 
 
152
 
    Date dateMonth = DateTools.round(date, DateTools.Resolution.MONTH);
153
 
    assertEquals("2004-02-01 00:00:00:000", isoFormat(dateMonth));
154
 
 
155
 
    Date dateDay = DateTools.round(date, DateTools.Resolution.DAY);
156
 
    assertEquals("2004-02-03 00:00:00:000", isoFormat(dateDay));
157
 
 
158
 
    Date dateHour = DateTools.round(date, DateTools.Resolution.HOUR);
159
 
    assertEquals("2004-02-03 22:00:00:000", isoFormat(dateHour));
160
 
 
161
 
    Date dateMinute = DateTools.round(date, DateTools.Resolution.MINUTE);
162
 
    assertEquals("2004-02-03 22:08:00:000", isoFormat(dateMinute));
163
 
 
164
 
    Date dateSecond = DateTools.round(date, DateTools.Resolution.SECOND);
165
 
    assertEquals("2004-02-03 22:08:56:000", isoFormat(dateSecond));
166
 
 
167
 
    Date dateMillisecond = DateTools.round(date, DateTools.Resolution.MILLISECOND);
168
 
    assertEquals("2004-02-03 22:08:56:333", isoFormat(dateMillisecond));
169
 
 
170
 
    // long parameter:
171
 
    long dateYearLong = DateTools.round(date.getTime(), DateTools.Resolution.YEAR);
172
 
    assertEquals("2004-01-01 00:00:00:000", isoFormat(new Date(dateYearLong)));
173
 
 
174
 
    long dateMillisecondLong = DateTools.round(date.getTime(), DateTools.Resolution.MILLISECOND);
175
 
    assertEquals("2004-02-03 22:08:56:333", isoFormat(new Date(dateMillisecondLong)));
176
 
  }
177
 
 
178
 
  private String isoFormat(Date date) {
179
 
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS", Locale.US);
180
 
    sdf.setTimeZone(TimeZone.getTimeZone("GMT"));
181
 
    return sdf.format(date);
182
 
  }
183
 
 
184
 
  public void testDateToolsUTC() throws Exception {
185
 
    // Sun, 30 Oct 2005 00:00:00 +0000 -- the last second of 2005's DST in Europe/London
186
 
    long time = 1130630400;
187
 
    try {
188
 
        TimeZone.setDefault(TimeZone.getTimeZone(/* "GMT" */ "Europe/London"));
189
 
        String d1 = DateTools.dateToString(new Date(time*1000), DateTools.Resolution.MINUTE);
190
 
        String d2 = DateTools.dateToString(new Date((time+3600)*1000), DateTools.Resolution.MINUTE);
191
 
        assertFalse("different times", d1.equals(d2));
192
 
        assertEquals("midnight", DateTools.stringToTime(d1), time*1000);
193
 
        assertEquals("later", DateTools.stringToTime(d2), (time+3600)*1000);
194
 
    } finally {
195
 
        TimeZone.setDefault(null);
196
 
    }
197
 
  }
198
 
 
199
 
}