lucene-java-3.4.0/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 }