internal void TestConvert(String caseString, CalendarFieldsSet fromSet,
                                  Calendar fromCalendar, CalendarFieldsSet toSet,
                                  Calendar toCalendar, bool forward)
        {
            String thisString = caseString + ((forward) ? "forward" : "reverse")
                                + " " + fromCalendar.GetType() + "->" + toCalendar.GetType()
                                + " ";

            fromCalendar.Clear();

            fromSet.SetOnCalendar(fromCalendar);

            CalendarFieldsSet diffSet = new CalendarFieldsSet();

            diffSet.Clear();
            // Is the calendar sane at the first?
            if (!fromSet.Matches(fromCalendar, diffSet))
            {
                String diffs = diffSet.DiffFrom(fromSet);
                Errln((String)"FAIL: " + thisString
                      + ", SOURCE calendar was not set: Differences: " + diffs);
            }
            else
            {
                Logln("PASS: "******" SOURCE calendar match.");
            }

            // logln("Set Source calendar: " + from);

            DateTime fromTime = fromCalendar.GetTime();

            diffSet.Clear();
            // Is the calendar sane after being set?
            if (!fromSet.Matches(fromCalendar, diffSet))
            {
                String diffs_0 = diffSet.DiffFrom(fromSet);
                Errln((String)"FAIL: " + thisString
                      + ", SET SOURCE calendar was not set: Differences: "
                      + diffs_0);
            }
            else
            {
                Logln("PASS: "******" SET SOURCE calendar match.");
            }

            toCalendar.Clear();
            toCalendar.SetTime(fromTime);

            diffSet.Clear();
            if (!toSet.Matches(toCalendar, diffSet))
            {
                String diffs_1 = diffSet.DiffFrom(toSet);
                Errln((String)"FAIL: " + thisString + ", Differences: " + diffs_1);
                DateFormat fmt        = new SimpleDateFormat("EEE MMM dd yyyy G");
                String     fromString = fmt.Format(fromTime);
                Logln("Source Time: " + fromString + ", Source Calendar: "
                      + fromCalendar.GetType());
            }
            else
            {
                Logln("PASS: "******" match.");
            }
        }
        private void TestOps(TestDataModule_Constants.TestData testData, IBM.ICU.Charset.TestDataModule_Constants.DataMap settings)
        {
            // Get 'from' time
            CalendarFieldsSet fromSet = new CalendarFieldsSet(), toSet = new CalendarFieldsSet(), paramsSet = new CalendarFieldsSet(), diffSet = new CalendarFieldsSet();
            // DateFormat fmt = new
            // SimpleDateFormat("EEE MMM dd yyyy / YYYY'-W'ww-ee");
            // Start the processing
            int n = 0;

            for (IIterator iter = testData.GetDataIterator(); iter.HasNext();)
            {
                ++n;
                IBM.ICU.Charset.TestDataModule_Constants.DataMap currentCase = (IBM.ICU.Charset.TestDataModule_Constants.DataMap)iter.Next();

                String caseString = "[case " + n + "]";
                // build to calendar
                // Headers { "locale","from","operation","params","to" }
                // #1 locale
                String param = "locale";
                String locale;
                String testSetting = currentCase.GetString(param);
                locale = testSetting;
                ULocale  loc          = new ULocale(locale);
                Calendar fromCalendar = IBM.ICU.Util.Calendar.GetInstance(loc);

                fromSet.Clear();
                // #2 'from' info
                param = "from";
                String from = testSetting = currentCase.GetString(param);
                fromSet.ParseFrom(testSetting);
                // System.err.println("fromset: ["+testSetting+"] >> " + fromSet);

                // #4 'operation' info
                param = "operation";
                String operation = testSetting = currentCase.GetString(param);
                paramsSet.Clear();
                // #3 'params' info
                param = "params";
                String paramsData = testSetting = currentCase.GetString(param);
                paramsSet.ParseFrom(paramsData); // parse with inheritance.
                // System.err.println("paramsSet: ["+testSetting+"] >> " +
                // paramsSet);

                toSet.Clear();
                // #4 'to' info
                param = "to";
                String to = testSetting = currentCase.GetString(param);
                toSet.ParseFrom(testSetting, fromSet); // parse with inheritance.
                // System.err.println("toSet: ["+testSetting+"] >> " + toSet);

                String caseContentsString = locale + ":  from " + from + ": "
                                            + operation + " [[[ " + paramsSet + " ]]]   >>> " + to;
                Logln(caseString + ": " + caseContentsString);

                // ------
                // now, do it.

                // / prepare calendar
                fromSet.SetOnCalendar(fromCalendar);

                // from calendar: 'starting date'

                diffSet.Clear();

                // Is the calendar sane after being set?
                if (!fromSet.Matches(fromCalendar, diffSet))
                {
                    String diffs = diffSet.DiffFrom(fromSet);
                    Errln((String)"FAIL: " + caseString
                          + ", SET SOURCE calendar was not set: Differences: "
                          + diffs);
                }
                else
                {
                    Logln(" " + caseString + " SET SOURCE calendar match."); // verifies
                    // that
                    // the
                    // requested
                    // fields
                    // were
                    // set.
                }

                // to calendar - copy of from calendar
                Calendar toCalendar = (Calendar)fromCalendar.Clone();

                // / perform op on 'to calendar'
                for (int q = 0; q < paramsSet.FieldCount(); q++)
                {
                    if (paramsSet.IsSet(q))
                    {
                        if (operation.Equals(kROLL))
                        {
                            toCalendar.Roll(q, paramsSet.Get(q));
                        }
                        else if (operation.Equals(kADD))
                        {
                            toCalendar.Add(q, paramsSet.Get(q));
                        }
                        else
                        {
                            Errln(caseString + " FAIL: unknown operation "
                                  + operation);
                        }
                        Logln(operation + " of " + paramsSet.Get(q));
                    }
                }
                // now - what's the result?
                diffSet.Clear();

                // toset contains 'expected'

                if (!toSet.Matches(toCalendar, diffSet))
                {
                    String diffs_0 = diffSet.DiffFrom(toSet);
                    Errln((String)"FAIL: " + caseString + " - , "
                          + caseContentsString + " Differences: " + diffs_0);
                }
                else
                {
                    Logln("PASS: "******" matched! ");
                }
            }
        }