001: /* ===========================================================
002: * JFreeChart : a free chart library for the Java(tm) platform
003: * ===========================================================
004: *
005: * (C) Copyright 2000-2007, by Object Refinery Limited and Contributors.
006: *
007: * Project Info: http://www.jfree.org/jfreechart/index.html
008: *
009: * This library is free software; you can redistribute it and/or modify it
010: * under the terms of the GNU Lesser General Public License as published by
011: * the Free Software Foundation; either version 2.1 of the License, or
012: * (at your option) any later version.
013: *
014: * This library is distributed in the hope that it will be useful, but
015: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017: * License for more details.
018: *
019: * You should have received a copy of the GNU Lesser General Public
020: * License along with this library; if not, write to the Free Software
021: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
022: * USA.
023: *
024: * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025: * in the United States and other countries.]
026: *
027: * ----------------------------
028: * SegmentedTimelineTests2.java
029: * ----------------------------
030: * (C) Copyright 2004-2007, by Object Refinery Limited and Contributors.
031: *
032: * Original Author: David Gilbert (for Object Refinery Limited);
033: * Contributor(s): -;
034: *
035: * $Id: SegmentedTimelineTests2.java,v 1.1.2.3 2007/02/02 15:10:21 mungady Exp $
036: *
037: * Changes
038: * -------
039: * 02-Aug-2004 : Added standard header (DG);
040: * 02-Feb-2007 : Removed author tags all over JFreeChart sources (DG);
041: *
042: */
043:
044: package org.jfree.chart.axis.junit;
045:
046: import java.util.Calendar;
047: import java.util.Date;
048: import java.util.Locale;
049:
050: import junit.framework.TestCase;
051:
052: import org.jfree.chart.axis.SegmentedTimeline;
053:
054: /**
055: * Some tests for the {@link SegmentedTimeline} class.
056: */
057: public class SegmentedTimelineTests2 extends TestCase {
058:
059: /**
060: * Constructor
061: */
062: public SegmentedTimelineTests2() {
063: super ();
064: }
065:
066: /**
067: * Test 1 checks 9am Friday 26 March 2004 converts to a timeline value and
068: * back again correctly. This is prior to Daylight Saving.
069: */
070: public void test1() {
071:
072: Calendar cal = Calendar.getInstance(Locale.UK);
073: cal.set(Calendar.YEAR, 2004);
074: cal.set(Calendar.MONTH, Calendar.MARCH);
075: cal.set(Calendar.DAY_OF_MONTH, 26);
076: cal.set(Calendar.HOUR_OF_DAY, 9);
077: cal.set(Calendar.MINUTE, 0);
078: cal.set(Calendar.SECOND, 0);
079: cal.set(Calendar.MILLISECOND, 0);
080: Date date = cal.getTime();
081:
082: SegmentedTimeline timeline = getTimeline();
083: long value = timeline.toTimelineValue(date);
084: long ms = timeline.toMillisecond(value);
085:
086: Calendar cal2 = Calendar.getInstance(Locale.UK);
087: cal2.setTime(new Date(ms));
088: Date reverted = cal2.getTime();
089:
090: assertTrue("test1", value == (900000 * 34)
091: && date.getTime() == reverted.getTime());
092:
093: }
094:
095: /**
096: * Test 2 checks 9.15am Friday 26 March 2004 converts to a timeline value
097: * and back again correctly. This is prior to Daylight Saving.
098: */
099: public void test2() {
100: Calendar cal = Calendar.getInstance(Locale.UK);
101: cal.set(Calendar.YEAR, 2004);
102: cal.set(Calendar.MONTH, Calendar.MARCH);
103: cal.set(Calendar.DAY_OF_MONTH, 26);
104: cal.set(Calendar.HOUR_OF_DAY, 9);
105: cal.set(Calendar.MINUTE, 15);
106: cal.set(Calendar.SECOND, 0);
107: cal.set(Calendar.MILLISECOND, 0);
108: Date date = cal.getTime();
109:
110: SegmentedTimeline timeline = getTimeline();
111:
112: long value = timeline.toTimelineValue(date);
113: long ms = timeline.toMillisecond(value);
114: Calendar cal2 = Calendar.getInstance(Locale.UK);
115: cal2.setTime(new Date(ms));
116: Date reverted = cal2.getTime();
117: assertTrue("test2", value == (900000 * 34 + 900000)
118: && date.getTime() == reverted.getTime());
119: }
120:
121: /**
122: * Test 3 checks 9.30am Friday 26 March 2004 converts to a timeline value
123: * and back again correctly. This is prior to Daylight Saving.
124: */
125: public void test3() {
126: Calendar cal = Calendar.getInstance(Locale.UK);
127: cal.set(Calendar.YEAR, 2004);
128: cal.set(Calendar.MONTH, Calendar.MARCH);
129: cal.set(Calendar.DAY_OF_MONTH, 26);
130: cal.set(Calendar.HOUR_OF_DAY, 9);
131: cal.set(Calendar.MINUTE, 30);
132: cal.set(Calendar.SECOND, 0);
133: cal.set(Calendar.MILLISECOND, 0);
134: Date date = cal.getTime();
135: SegmentedTimeline timeline = getTimeline();
136:
137: long value = timeline.toTimelineValue(date);
138: long ms = timeline.toMillisecond(value);
139:
140: Calendar cal2 = Calendar.getInstance(Locale.UK);
141: cal2.setTime(new Date(ms));
142: Date reverted = cal2.getTime();
143: assertTrue("test2", value == (900000 * 34 + 900000 * 2)
144: && date.getTime() == reverted.getTime());
145: }
146:
147: /**
148: * Test 4 checks 9.30am Friday 26 March 2004 (+ 1 millisecond) converts to
149: * a timeline value and back again correctly. This is prior to Daylight
150: * Saving.
151: */
152: public void test4() {
153: Calendar cal = Calendar.getInstance(Locale.UK);
154: cal.set(Calendar.YEAR, 2004);
155: cal.set(Calendar.MONTH, Calendar.MARCH);
156: cal.set(Calendar.DAY_OF_MONTH, 26);
157: cal.set(Calendar.HOUR_OF_DAY, 9);
158: cal.set(Calendar.MINUTE, 30);
159: cal.set(Calendar.SECOND, 0);
160: cal.set(Calendar.MILLISECOND, 1);
161: Date date = cal.getTime();
162: SegmentedTimeline timeline = getTimeline();
163:
164: long value = timeline.toTimelineValue(date);
165: long ms = timeline.toMillisecond(value);
166: Calendar cal2 = Calendar.getInstance(Locale.UK);
167: cal2.setTime(new Date(ms));
168: Date reverted = cal2.getTime();
169: assertTrue("test4", value == (900000 * 34 + 900000 * 2 + 1)
170: && date.getTime() == reverted.getTime());
171: }
172:
173: /**
174: * Test 5 checks 5.30pm Thursday 25 March 2004 converts to a timeline
175: * value and back again correctly. As it is in the excluded segment, we
176: * expect it to map to 9am, Friday 26 March 2004. This is prior to
177: * Daylight Saving.
178: */
179: public void test5() {
180: Calendar cal = Calendar.getInstance(Locale.UK);
181: cal.set(Calendar.YEAR, 2004);
182: cal.set(Calendar.MONTH, Calendar.MARCH);
183: cal.set(Calendar.DAY_OF_MONTH, 25);
184: cal.set(Calendar.HOUR_OF_DAY, 17);
185: cal.set(Calendar.MINUTE, 30);
186: cal.set(Calendar.SECOND, 0);
187: cal.set(Calendar.MILLISECOND, 0);
188: Date date = cal.getTime();
189: SegmentedTimeline timeline = getTimeline();
190:
191: long value = timeline.toTimelineValue(date);
192: long ms = timeline.toMillisecond(value);
193: Calendar cal2 = Calendar.getInstance(Locale.UK);
194: cal2.setTime(new Date(ms));
195: Date reverted = cal2.getTime();
196: Calendar expectedReverted = Calendar.getInstance(Locale.UK);
197: expectedReverted.set(Calendar.YEAR, 2004);
198: expectedReverted.set(Calendar.MONTH, Calendar.MARCH);
199: expectedReverted.set(Calendar.DAY_OF_MONTH, 26);
200: expectedReverted.set(Calendar.HOUR_OF_DAY, 9);
201: expectedReverted.set(Calendar.MINUTE, 0);
202: expectedReverted.set(Calendar.SECOND, 0);
203: expectedReverted.set(Calendar.MILLISECOND, 0);
204:
205: assertTrue("test5", value == (900000 * 34)
206: && expectedReverted.getTime().getTime() == reverted
207: .getTime());
208: }
209:
210: /**
211: * Test 6 checks that 9am on Sunday 28 March 2004 converts to the timeline
212: * value and back again correctly. Note that Saturday and Sunday are
213: * excluded from the timeline, so we expect the value to map to 9am on
214: * Monday 29 March 2004. This is during daylight saving.
215: */
216: public void test6() {
217: Calendar cal = Calendar.getInstance(Locale.UK);
218: cal.set(Calendar.YEAR, 2004);
219: cal.set(Calendar.MONTH, Calendar.MARCH);
220: cal.set(Calendar.DAY_OF_MONTH, 28);
221: cal.set(Calendar.HOUR_OF_DAY, 9);
222: cal.set(Calendar.MINUTE, 0);
223: cal.set(Calendar.SECOND, 0);
224: cal.set(Calendar.MILLISECOND, 0);
225: Date date = cal.getTime();
226: SegmentedTimeline timeline = getTimeline();
227:
228: long value = timeline.toTimelineValue(date);
229: long ms = timeline.toMillisecond(value);
230: Calendar cal2 = Calendar.getInstance(Locale.UK);
231: cal2.setTime(new Date(ms));
232: Date reverted = cal2.getTime();
233:
234: Calendar expectedReverted = Calendar.getInstance(Locale.UK);
235: expectedReverted.set(Calendar.YEAR, 2004);
236: expectedReverted.set(Calendar.MONTH, Calendar.MARCH);
237: expectedReverted.set(Calendar.DAY_OF_MONTH, 29);
238: expectedReverted.set(Calendar.HOUR_OF_DAY, 9);
239: expectedReverted.set(Calendar.MINUTE, 0);
240: expectedReverted.set(Calendar.SECOND, 0);
241: expectedReverted.set(Calendar.MILLISECOND, 0);
242:
243: assertTrue("test6", value == (900000 * 34 * 2)
244: && expectedReverted.getTime().getTime() == reverted
245: .getTime());
246: }
247:
248: /**
249: * Test 7 checks 9am Monday 29 March 2004 converts to a timeline value and
250: * back again correctly. This is during Daylight Saving.
251: */
252: public void test7() {
253: Calendar cal = Calendar.getInstance(Locale.UK);
254: cal.set(Calendar.YEAR, 2004);
255: cal.set(Calendar.MONTH, Calendar.MARCH);
256: cal.set(Calendar.DAY_OF_MONTH, 29);
257: cal.set(Calendar.HOUR_OF_DAY, 9);
258: cal.set(Calendar.MINUTE, 0);
259: cal.set(Calendar.SECOND, 0);
260: cal.set(Calendar.MILLISECOND, 0);
261: Date date = cal.getTime();
262:
263: SegmentedTimeline timeline = getTimeline();
264: long value = timeline.toTimelineValue(date);
265: long ms = timeline.toMillisecond(value);
266:
267: Calendar cal2 = Calendar.getInstance(Locale.UK);
268: cal2.setTime(new Date(ms));
269: Date reverted = cal2.getTime();
270:
271: Calendar expectedReverted = Calendar.getInstance();
272: expectedReverted.set(Calendar.YEAR, 2004);
273: expectedReverted.set(Calendar.MONTH, Calendar.MARCH);
274: expectedReverted.set(Calendar.DAY_OF_MONTH, 29);
275: expectedReverted.set(Calendar.HOUR_OF_DAY, 9);
276: expectedReverted.set(Calendar.MINUTE, 0);
277: expectedReverted.set(Calendar.SECOND, 0);
278: expectedReverted.set(Calendar.MILLISECOND, 0);
279:
280: assertTrue("test7", value == (900000 * 34 * 2)
281: && expectedReverted.getTime().getTime() == reverted
282: .getTime());
283: }
284:
285: /**
286: * Test 8.
287: */
288: public void test8() {
289: Calendar cal = Calendar.getInstance(Locale.UK);
290: cal.set(Calendar.YEAR, 2004);
291: cal.set(Calendar.MONTH, Calendar.MARCH);
292: cal.set(Calendar.DAY_OF_MONTH, 29);
293: cal.set(Calendar.HOUR_OF_DAY, 10);
294: cal.set(Calendar.MINUTE, 0);
295: cal.set(Calendar.SECOND, 0);
296: cal.set(Calendar.MILLISECOND, 0);
297: Date date = cal.getTime();
298:
299: SegmentedTimeline timeline = getTimeline();
300:
301: // Add exception in included segments
302: cal.set(Calendar.YEAR, 2004);
303: cal.set(Calendar.MONTH, Calendar.MARCH);
304: cal.set(Calendar.DAY_OF_MONTH, 29);
305: cal.set(Calendar.HOUR_OF_DAY, 9);
306: cal.set(Calendar.MINUTE, 15);
307: cal.set(Calendar.SECOND, 0);
308: cal.set(Calendar.MILLISECOND, 0);
309: timeline.addException(cal.getTime());
310:
311: long value = timeline.toTimelineValue(date);
312: long ms = timeline.toMillisecond(value);
313:
314: Calendar cal2 = Calendar.getInstance(Locale.UK);
315: cal2.setTime(new Date(ms));
316: Date reverted = cal2.getTime();
317:
318: Calendar expectedReverted = Calendar.getInstance();
319: expectedReverted.set(Calendar.YEAR, 2004);
320: expectedReverted.set(Calendar.MONTH, Calendar.MARCH);
321: expectedReverted.set(Calendar.DAY_OF_MONTH, 29);
322: expectedReverted.set(Calendar.HOUR_OF_DAY, 10);
323: expectedReverted.set(Calendar.MINUTE, 0);
324: expectedReverted.set(Calendar.SECOND, 0);
325: expectedReverted.set(Calendar.MILLISECOND, 0);
326:
327: assertTrue(
328: "test8",
329: value == (900000 * 34 * 2 + 900000 * (4 - 1))
330: && expectedReverted.getTime().getTime() == reverted
331: .getTime());
332: }
333:
334: /**
335: * Creates a timeline from 9am on Thursday 25 March 2004 to 5pm on
336: * Tuesday 30 March 2004, for the UK locale.
337: *
338: * @return A timeline.
339: */
340: private SegmentedTimeline getTimeline() {
341: Calendar cal = Calendar.getInstance(Locale.UK);
342: cal.set(Calendar.YEAR, 2004);
343: cal.set(Calendar.MONTH, Calendar.MARCH);
344: cal.set(Calendar.DAY_OF_MONTH, 25);
345: cal.set(Calendar.HOUR_OF_DAY, 9);
346: cal.set(Calendar.MINUTE, 0);
347: cal.set(Calendar.SECOND, 0);
348: cal.set(Calendar.MILLISECOND, 0);
349: Date from = cal.getTime();
350:
351: cal = Calendar.getInstance(Locale.UK);
352: cal.set(Calendar.YEAR, 2004);
353: cal.set(Calendar.MONTH, Calendar.MARCH);
354: cal.set(Calendar.DAY_OF_MONTH, 30);
355: cal.set(Calendar.HOUR_OF_DAY, 17);
356: cal.set(Calendar.MINUTE, 30);
357: cal.set(Calendar.SECOND, 0);
358: cal.set(Calendar.MILLISECOND, 0);
359: Date to = cal.getTime();
360:
361: return getTimeline(from, to);
362: }
363:
364: /**
365: * Returns a segmented timeline for 15 minute segments, Monday to Friday
366: * only, between 9am and 5pm. The UK locale is used.
367: *
368: * @param start the start date.
369: * @param end the end date.
370: *
371: * @return The timeline.
372: */
373: private SegmentedTimeline getTimeline(Date start, Date end) {
374:
375: Calendar cal = Calendar.getInstance(Locale.UK);
376: cal.set(Calendar.YEAR, 1970);
377: cal.set(Calendar.MONTH, Calendar.JANUARY);
378: cal.set(Calendar.DAY_OF_MONTH, 1);
379: cal.set(Calendar.HOUR_OF_DAY, 9);
380: cal.set(Calendar.MINUTE, 0);
381: cal.set(Calendar.SECOND, 0);
382: cal.set(Calendar.MILLISECOND, 0);
383: Date open = cal.getTime();
384:
385: cal = Calendar.getInstance(Locale.UK);
386: cal.set(Calendar.YEAR, 1970);
387: cal.set(Calendar.MONTH, Calendar.JANUARY);
388: cal.set(Calendar.DAY_OF_MONTH, 1);
389: cal.set(Calendar.HOUR_OF_DAY, 17);
390: cal.set(Calendar.MINUTE, 30);
391: cal.set(Calendar.SECOND, 0);
392: cal.set(Calendar.MILLISECOND, 0);
393: Date close = cal.getTime();
394:
395: SegmentedTimeline result = null;
396: // Create a segmented time line (segment size : 15 minutes)
397: long quarterHourCount = (close.getTime() - open.getTime())
398: / SegmentedTimeline.FIFTEEN_MINUTE_SEGMENT_SIZE;
399: long totalQuarterHourCount = SegmentedTimeline.DAY_SEGMENT_SIZE
400: / SegmentedTimeline.FIFTEEN_MINUTE_SEGMENT_SIZE;
401: result = new SegmentedTimeline(
402: SegmentedTimeline.FIFTEEN_MINUTE_SEGMENT_SIZE,
403: (int) quarterHourCount,
404: (int) (totalQuarterHourCount - quarterHourCount));
405: result.setAdjustForDaylightSaving(true);
406: // Set start time
407: result.setStartTime(start.getTime());
408: // Saturday and Sundays are non business hours
409: result.setBaseTimeline(SegmentedTimeline
410: .newMondayThroughFridayTimeline());
411: /* PUT exclusions in test */
412: if (start != null && end != null) {
413: result.addBaseTimelineExclusions(start.getTime(), end
414: .getTime());
415: }
416:
417: return result;
418: }
419:
420: }
|