From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 6794 invoked by alias); 18 Apr 2007 16:00:54 -0000 Received: (qmail 6776 invoked by uid 22791); 18 Apr 2007 16:00:52 -0000 X-Spam-Check-By: sourceware.org Received: from gbenson.demon.co.uk (HELO gbenson.demon.co.uk) (80.177.220.214) by sourceware.org (qpsmtpd/0.31) with ESMTP; Wed, 18 Apr 2007 17:00:43 +0100 Date: Wed, 18 Apr 2007 16:00:00 -0000 From: Gary Benson To: mauve-patches@sources.redhat.com Subject: FYI: GregorianCalendar internal state checks Message-ID: <20070418160036.GD3823@redhat.com> Mail-Followup-To: mauve-patches@sources.redhat.com Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="wRRV7LY7NUeQGEoC" Content-Disposition: inline X-IsSubscribed: yes Mailing-List: contact mauve-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: mauve-patches-owner@sourceware.org X-SW-Source: 2007/txt/msg00027.txt.bz2 --wRRV7LY7NUeQGEoC Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-length: 431 Hi all, This is what I've been using to try and make the our interaction between java.util.Calendar and java.util.GregorianCalendar match what Sun does. It may well be overkill and it's not finished yet, but I just spent a couple of days figuring out the logic for the last bit of it and I thought I'd commit it in the unlikely event that I get run over by a bus, and someone else dares to pick up this insanity :) Cheers, Gary --wRRV7LY7NUeQGEoC Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename=patch Content-length: 13598 Index: ChangeLog =================================================================== RCS file: /cvs/mauve/mauve/ChangeLog,v retrieving revision 1.2054 diff -u -r1.2054 ChangeLog --- ChangeLog 12 Apr 2007 20:31:55 -0000 1.2054 +++ ChangeLog 18 Apr 2007 15:55:11 -0000 @@ -1,3 +1,8 @@ +2007-04-18 Gary Benson + + * gnu/testlet/java/util/GregorianCalendar/internal.java: + New test. + 2007-04-12 Roman Kennke * gnu/testlet/java/nio/CharBuffer/CharSequenceWrapper.java: Index: gnu/testlet/java/util/GregorianCalendar/internal.java =================================================================== RCS file: gnu/testlet/java/util/GregorianCalendar/internal.java diff -N gnu/testlet/java/util/GregorianCalendar/internal.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ gnu/testlet/java/util/GregorianCalendar/internal.java 18 Apr 2007 15:55:11 -0000 @@ -0,0 +1,432 @@ +// Copyright (C) 2007 Red Hat, Inc. +// Written by Gary Benson + +// This file is part of Mauve. + +// Mauve is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2, or (at your option) +// any later version. + +// Mauve is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Mauve; see the file COPYING. If not, write to +// the Free Software Foundation, 59 Temple Place - Suite 330, +// Boston, MA 02111-1307, USA. + +// Tags: JDK1.1 + +package gnu.testlet.java.util.GregorianCalendar; + +import java.util.Calendar; +import java.util.GregorianCalendar; +import java.util.Iterator; +import java.util.Locale; +import java.util.TimeZone; + +import gnu.testlet.Testlet; +import gnu.testlet.TestHarness; + +public class internal implements Testlet +{ + private static class TestCalendar extends GregorianCalendar + { + /** + * Creates a calendar with all values unset and zeroed. + */ + public static TestCalendar getTestCalendar(TimeZone zone, Locale locale) + { + // There is no way to get a calendar with a specific + // locale without calling one of the constructors that + // calls setTimeInMillis(). So we do it this way... + Locale defaultLocale = Locale.getDefault(); + Locale.setDefault(locale); + try + { + TestCalendar c = new TestCalendar(); + c.setTimeZone(zone); + return c; + } + finally + { + Locale.setDefault(defaultLocale); + } + } + + private TestCalendar() + { + // Initializing this way avoids calling setTimeInMillis(), + // giving us an object whose time has never been set. + super(2007, Calendar.APRIL, 11); + clear(); + } + + /** + * Compare the internal state of this calendar with the supplied values. + */ + public void checkState( + TestHarness harness, + boolean areFieldsSet, int isSetBitmask, int[] fields, + boolean isTimeSet, long time) + { + String expected, actual; + boolean success; + + expected = stateString(areFieldsSet, isSetBitmask, isTimeSet, time); + harness.debug("expecting " + expected); + actual = stateString( + this.areFieldsSet, isSet, this.isTimeSet, this.time); + success = expected.equals(actual); + if (!success) + harness.debug(" got " + actual); + harness.check(success); + + expected = stateString(fields); + harness.debug("expecting " + expected); + actual = stateString(this.fields); + success = expected.equals(actual); + if (!success) + harness.debug(" got " + actual); + harness.check(success); + } + + /** + * Return a string representation of part of the internal state. + */ + private String stateString( + boolean areFieldsSet, int isSetBitmask, boolean isTimeSet, long time) + { + String result = areFieldsSet + " ("; + for (int i = 0; i < FIELD_COUNT; i++) + result += ((isSetBitmask & (1 << i)) != 0) ? "S" : "-"; + result += "), " + isTimeSet + " (" + time + ")"; + return result; + } + + /** + * Return a string representation of part of the internal state. + */ + private String stateString( + boolean areFieldsSet, boolean[] isSet, boolean isTimeSet, long time) + { + int isSetBitmask = 0; + for (int i = 0; i < FIELD_COUNT; i++) + { + if (isSet[i]) + isSetBitmask |= 1 << i; + } + return stateString(areFieldsSet, isSetBitmask, isTimeSet, time); + } + + /** + * Return a string representation of part of the internal state. + */ + private String stateString(int[] fields) + { + String result = "{"; + for (int i = 0; i < FIELD_COUNT; i++) + { + if (i > 0) + result += ", "; + result += fields[i]; + } + result += "}"; + return result; + } + +// public void debug() +// { +// System.out.print(areFieldsSet + " ("); +// for (int i = 0; i < FIELD_COUNT; i++) +// System.out.print(isSet[i] ? "S" : "-"); +// System.out.print("/"); +// for (int i = 0; i < FIELD_COUNT; i++) +// System.out.print(isSet(i) ? "S" : "-"); +// System.out.println("), " + isTimeSet + " (" + time + ")"); +// +// System.out.print(" {"); +// for (int i = 0; i < FIELD_COUNT; i++) +// { +// if (i > 0) +// System.out.print(", "); +// // if (i > 2 && i < 5) +// // System.out.print("\u001B[1;33m"); +// System.out.print(fields[i]); +// // if (i > 2 && i < 5) +// // System.out.print("\u001B[0m"); +// } +// System.out.println("}"); +// } + +// protected void computeTime() +// { +// System.out.println(" computeTime:"); +// debug(); +// super.computeTime(); +// debug(); +// System.out.println(" /computeTime"); +// } + +// protected void computeFields() +// { +// //areFieldsSet = false; +// System.out.println(" computeFields:"); +// debug(); +// super.computeFields(); +// debug(); +// System.out.println(" /computeFields"); +// } + +// protected void complete() +// { +// System.out.println(" complete:"); +// debug(); +// super.complete(); +// debug(); +// System.out.println(" /complete"); +// } + } + + /** + * Generate every possible permutation of a specified length + */ + private static class Permutator implements Iterator + { + private int size, length, pos; + + public Permutator(int s) + { + size = s; + length = 1; + for (int i = 2; i <= size; i++) + length *= i; + pos = 0; + } + + public boolean hasNext() + { + return pos < length; + } + + public Object next() + { + int[] result = new int[size]; + boolean[] used = new boolean[size]; + for (int tmp = pos, j = size; j > 0; tmp /= j, j--) + { + int choice = tmp % j; + for (int k = 0; k < size; k++) + { + if (!used[k]) + { + if (choice == 0) + { + result[size - j] = k; + used[k] = true; + break; + } + choice--; + } + } + } + pos++; + return result; + } + + public void remove() + { + throw new UnsupportedOperationException(); + } + } + + public void test(TestHarness harness) + { + int[][] checkFields = { + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, -18000000, 0}, + {1, 1969, 11, 1, 5, 31, 365, 4, 5, 1, 10, 22, 0, 0, 0, -25200000, 0}, + {1, 1970, 11, 1, 5, 31, 365, 5, 5, 1, 10, 22, 0, 0, 0, -25200000, 0}, + {1, 1969, 0, 5, 5, 31, 31, 6, 5, 1, 10, 22, 0, 0, 0, -25200000, 0}, + {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, -25200000, 0}, + {0, 2007, 3, 15, 4, 18, 107, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0}, + }; + + TestCalendar c = TestCalendar.getTestCalendar( + TimeZone.getTimeZone("EST"), Locale.US); + + // check it really is as blank as it should be. + c.checkState(harness, false, 0, checkFields[0], false, 0); + + // check that things that affect week numbering are as expected. + harness.check(c.getFirstDayOfWeek() == Calendar.SUNDAY); + harness.check(c.getMinimalDaysInFirstWeek() == 1); + +// // print the heading. +// String vendor = System.getProperty("java.vendor"); +// if (vendor.endsWith(".")) +// vendor = vendor.substring(0, vendor.length() - 1); +// System.out.println(vendor); +// for (int i = 0; i < vendor.length(); i++) +// System.out.print('='); +// System.out.println(); + + // cause a complete() and check we got the epoch right. + c.get(Calendar.YEAR); + c.checkState(harness, true, 0x1ffff, checkFields[1], true, 18000000); + + // set a different timezone and check that areFieldsSet is cleared. + c.setTimeZone(TimeZone.getTimeZone("MST")); + c.checkState(harness, false, 0x1ffff, checkFields[1], true, 18000000); + + // cause a complete() and check the fields recalculate correctly. + c.get(Calendar.YEAR); + c.checkState(harness, true, 0x1ffff, checkFields[2], true, 18000000); + + // clear each field in turn and check everything recalculates correctly. + for (int i = 0; i < Calendar.FIELD_COUNT; i++) + { + TestCalendar d = (TestCalendar) c.clone(); + int[] expectFields = (int[]) checkFields[2].clone(); + long expectTime = 18000000; + + d.checkState(harness, true, 0x1ffff, expectFields, true, expectTime); + + d.clear(i); + expectFields[i] = 0; + + d.checkState(harness, false, ~(1<= 0; i++) + { + if (order[i] >= Calendar.WEEK_OF_YEAR + && order[i] <= Calendar.DAY_OF_WEEK_IN_MONTH) + setOrder[j--] = order[i]; + } + + long expectTime = -1; + if (setOrder[0] == Calendar.DAY_OF_MONTH) + { + // YEAR + MONTH + DAY_OF_MONTH + expectTime = 1176879600000L; + } + else if (setOrder[0] == Calendar.DAY_OF_WEEK_IN_MONTH) + { + // YEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK + expectTime = 1178175600000L; + } + else if (setOrder[0] == Calendar.DAY_OF_YEAR) + { + // YEAR + DAY_OF_YEAR + expectTime = 1176793200000L; + } + else if (setOrder[0] == Calendar.WEEK_OF_YEAR) + { + // YEAR + DAY_OF_WEEK + WEEK_OF_YEAR + // (some of them) + expectTime = 1176361200000L; + } + else if (setOrder[0] == Calendar.DAY_OF_WEEK) + { + for (int i = 1; i < setOrder.length; i++) + { + if (setOrder[i] == Calendar.DAY_OF_MONTH + || setOrder[i] == Calendar.DAY_OF_YEAR) + continue; + + if (setOrder[i] == Calendar.WEEK_OF_YEAR) + { + // YEAR + DAY_OF_WEEK + WEEK_OF_YEAR + // (the rest) + expectTime = 1176361200000L; + } + else + { + // YEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEK + // (some of them) + expectTime = 1177570800000L; + } + break; + } + } + else + { + // YEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEK + // (the rest) + expectTime = 1177570800000L; + } + + long actualTime = c.getTimeInMillis(); +// if (actualTime != expectTime) +// { +// System.out.print("expect = " + expectTime + ", actual = " +// + actualTime + ", setOrder = ["); +// for (int i = 0; i < setOrder.length; i++) +// { +// if (i > 0) +// System.out.print(", "); +// System.out.print(setOrder[i]); +// } +// System.out.println("]"); +// } + harness.check(actualTime == expectTime); + } + } +} --wRRV7LY7NUeQGEoC--