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); + } + } +}