[apple/icu.git] / icuSources / test / intltest / astrotst.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
 * COPYRIGHT:
 * Copyright (c) 1996-2016, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/

/* Test CalendarAstronomer for C++ */

#include "unicode/utypes.h"
#include "string.h"
#include "unicode/locid.h"

#if !UCONFIG_NO_FORMATTING

#include "astro.h"
#include "astrotst.h"
#include "cmemory.h"
#include "gregoimp.h" // for Math
#include "unicode/simpletz.h"


#define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break

AstroTest::AstroTest(): astro(NULL), gc(NULL) {
}

void AstroTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
    if (exec) logln("TestSuite AstroTest");
    switch (index) {
      // CASE(0,FooTest);
      CASE(0,TestSolarLongitude);
      CASE(1,TestLunarPosition);
      CASE(2,TestCoordinates);
      CASE(3,TestCoverage);
      CASE(4,TestSunriseTimes);
      CASE(5,TestBasics);
      CASE(6,TestMoonAge);
    default: name = ""; break;
    }
}

#undef CASE

#define ASSERT_OK(x)   if(U_FAILURE(x)) { dataerrln("%s:%d: %s\n", __FILE__, __LINE__, u_errorName(x)); return; }


void AstroTest::initAstro(UErrorCode &status) {
  if(U_FAILURE(status)) return;

  if((astro != NULL) || (gc != NULL)) {
    dataerrln("Err: initAstro() called twice!");
    closeAstro(status);
    if(U_SUCCESS(status)) {
      status = U_INTERNAL_PROGRAM_ERROR;
    }
  }

  if(U_FAILURE(status)) return;

  astro = new CalendarAstronomer();
  gc = Calendar::createInstance(TimeZone::getGMT()->clone(), status);
}

void AstroTest::closeAstro(UErrorCode &/*status*/) {
  if(astro != NULL) {
    delete astro;
    astro = NULL;
  }
  if(gc != NULL) {
    delete gc;
    gc = NULL;
  }
}

void AstroTest::TestSolarLongitude(void) {
  UErrorCode status = U_ZERO_ERROR;
  initAstro(status);
  ASSERT_OK(status);

  struct {
    int32_t d[5]; double f ;
  } tests[] = {
    { { 1980, 7, 27, 0, 00 },  124.114347 },
    { { 1988, 7, 27, 00, 00 },  124.187732 }
  };

  logln("");
  for (uint32_t i = 0; i < UPRV_LENGTHOF(tests); i++) {
    gc->clear();
    gc->set(tests[i].d[0], tests[i].d[1]-1, tests[i].d[2], tests[i].d[3], tests[i].d[4]);

    astro->setDate(gc->getTime(status));

    double longitude = astro->getSunLongitude();
    //longitude = 0;
    CalendarAstronomer::Equatorial result;
    astro->getSunPosition(result);
    logln((UnicodeString)"Sun position is " + result.toString() + (UnicodeString)";  " /* + result.toHmsString()*/ + " Sun longitude is " + longitude );
  }
  closeAstro(status);
  ASSERT_OK(status);
}


void AstroTest::TestLunarPosition(void) {
  UErrorCode status = U_ZERO_ERROR;
  initAstro(status);
  ASSERT_OK(status);

  static const double tests[][7] = {
    { 1979, 2, 26, 16, 00,  0, 0 }
  };
  logln("");

  for (int32_t i = 0; i < UPRV_LENGTHOF(tests); i++) {
    gc->clear();
    gc->set((int32_t)tests[i][0], (int32_t)tests[i][1]-1, (int32_t)tests[i][2], (int32_t)tests[i][3], (int32_t)tests[i][4]);
    astro->setDate(gc->getTime(status));

    const CalendarAstronomer::Equatorial& result = astro->getMoonPosition();
    logln((UnicodeString)"Moon position is " + result.toString() + (UnicodeString)";  " /* + result->toHmsString()*/);
  }

  closeAstro(status);
  ASSERT_OK(status);
}


void AstroTest::TestCoordinates(void) {
  UErrorCode status = U_ZERO_ERROR;
  initAstro(status);
  ASSERT_OK(status);

  CalendarAstronomer::Equatorial result;
  astro->eclipticToEquatorial(result, 139.686111 * CalendarAstronomer::PI / 180.0, 4.875278* CalendarAstronomer::PI / 180.0);
  logln((UnicodeString)"result is " + result.toString() + (UnicodeString)";  " /* + result.toHmsString()*/ );
  closeAstro(status);
  ASSERT_OK(status);
}


void AstroTest::TestCoverage(void) {
  UErrorCode status = U_ZERO_ERROR;
  initAstro(status);
  ASSERT_OK(status);
  GregorianCalendar *cal = new GregorianCalendar(1958, UCAL_AUGUST, 15,status);
  UDate then = cal->getTime(status);
  CalendarAstronomer *myastro = new CalendarAstronomer(then);
  ASSERT_OK(status);

  //Latitude:  34 degrees 05' North
  //Longitude:  118 degrees 22' West
  double laLat = 34 + 5./60, laLong = 360 - (118 + 22./60);
  CalendarAstronomer *myastro2 = new CalendarAstronomer(laLong, laLat);

  double eclLat = laLat * CalendarAstronomer::PI / 360;
  double eclLong = laLong * CalendarAstronomer::PI / 360;

  CalendarAstronomer::Ecliptic ecl(eclLat, eclLong);
  CalendarAstronomer::Equatorial eq;
  CalendarAstronomer::Horizon hor;

  logln("ecliptic: " + ecl.toString());
  CalendarAstronomer *myastro3 = new CalendarAstronomer();
  myastro3->setJulianDay((4713 + 2000) * 365.25);

  CalendarAstronomer *astronomers[] = {
    myastro, myastro2, myastro3, myastro2 // check cache
  };

  for (uint32_t i = 0; i < UPRV_LENGTHOF(astronomers); ++i) {
    CalendarAstronomer *anAstro = astronomers[i];

    //logln("astro: " + astro);
    logln((UnicodeString)"   date: " + anAstro->getTime());
    logln((UnicodeString)"   cent: " + anAstro->getJulianCentury());
    logln((UnicodeString)"   gw sidereal: " + anAstro->getGreenwichSidereal());
    logln((UnicodeString)"   loc sidereal: " + anAstro->getLocalSidereal());
    logln((UnicodeString)"   equ ecl: " + (anAstro->eclipticToEquatorial(eq,ecl)).toString());
    logln((UnicodeString)"   equ long: " + (anAstro->eclipticToEquatorial(eq, eclLong)).toString());
    logln((UnicodeString)"   horiz: " + (anAstro->eclipticToHorizon(hor, eclLong)).toString());
    logln((UnicodeString)"   sunrise: " + (anAstro->getSunRiseSet(TRUE)));
    logln((UnicodeString)"   sunset: " + (anAstro->getSunRiseSet(FALSE)));
    logln((UnicodeString)"   moon phase: " + anAstro->getMoonPhase());
    logln((UnicodeString)"   moonrise: " + (anAstro->getMoonRiseSet(TRUE)));
    logln((UnicodeString)"   moonset: " + (anAstro->getMoonRiseSet(FALSE)));
    logln((UnicodeString)"   prev summer solstice: " + (anAstro->getSunTime(CalendarAstronomer::SUMMER_SOLSTICE(), FALSE)));
    logln((UnicodeString)"   next summer solstice: " + (anAstro->getSunTime(CalendarAstronomer::SUMMER_SOLSTICE(), TRUE)));
    logln((UnicodeString)"   prev full moon: " + (anAstro->getMoonTime(CalendarAstronomer::FULL_MOON(), FALSE)));
    logln((UnicodeString)"   next full moon: " + (anAstro->getMoonTime(CalendarAstronomer::FULL_MOON(), TRUE)));
  }

  delete myastro2;
  delete myastro3;
  delete myastro;
  delete cal;

  closeAstro(status);
  ASSERT_OK(status);
}


void AstroTest::TestSunriseTimes(void) {
  UErrorCode status = U_ZERO_ERROR;
  initAstro(status);
  ASSERT_OK(status);

  //  logln("Sunrise/Sunset times for San Jose, California, USA");
  //  CalendarAstronomer *astro2 = new CalendarAstronomer(-121.55, 37.20);
  //  TimeZone *tz = TimeZone::createTimeZone("America/Los_Angeles");

  // We'll use a table generated by the UNSO website as our reference
  // From: http://aa.usno.navy.mil/
  //-Location: W079 25, N43 40
  //-Rise and Set for the Sun for 2001
  //-Zone:  4h West of Greenwich
  int32_t USNO[] = {
    6,59, 19,45,
    6,57, 19,46,
    6,56, 19,47,
    6,54, 19,48,
    6,52, 19,49,
    6,50, 19,51,
    6,48, 19,52,
    6,47, 19,53,
    6,45, 19,54,
    6,43, 19,55,
    6,42, 19,57,
    6,40, 19,58,
    6,38, 19,59,
    6,36, 20, 0,
    6,35, 20, 1,
    6,33, 20, 3,
    6,31, 20, 4,
    6,30, 20, 5,
    6,28, 20, 6,
    6,27, 20, 7,
    6,25, 20, 8,
    6,23, 20,10,
    6,22, 20,11,
    6,20, 20,12,
    6,19, 20,13,
    6,17, 20,14,
    6,16, 20,16,
    6,14, 20,17,
    6,13, 20,18,
    6,11, 20,19,
  };

  logln("Sunrise/Sunset times for Toronto, Canada");
  // long = 79 25", lat = 43 40"
  CalendarAstronomer *astro3 = new CalendarAstronomer(-(79+25/60), 43+40/60);

  // As of ICU4J 2.8 the ICU4J time zones implement pass-through
  // to the underlying JDK.  Because of variation in the
  // underlying JDKs, we have to use a fixed-offset
  // SimpleTimeZone to get consistent behavior between JDKs.
  // The offset we want is [-18000000, 3600000] (raw, dst).
  // [aliu 10/15/03]

  // TimeZone tz = TimeZone.getTimeZone("America/Montreal");
  TimeZone *tz = new SimpleTimeZone(-18000000 + 3600000, "Montreal(FIXED)");

  GregorianCalendar *cal = new GregorianCalendar(tz->clone(), Locale::getUS(), status);
  GregorianCalendar *cal2 = new GregorianCalendar(tz->clone(), Locale::getUS(), status);
  cal->clear();
  cal->set(UCAL_YEAR, 2001);
  cal->set(UCAL_MONTH, UCAL_APRIL);
  cal->set(UCAL_DAY_OF_MONTH, 1);
  cal->set(UCAL_HOUR_OF_DAY, 12); // must be near local noon for getSunRiseSet to work

  DateFormat *df_t  = DateFormat::createTimeInstance(DateFormat::MEDIUM,Locale::getUS());
  DateFormat *df_d  = DateFormat::createDateInstance(DateFormat::MEDIUM,Locale::getUS());
  DateFormat *df_dt = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::MEDIUM, Locale::getUS());
  if(!df_t || !df_d || !df_dt) {
    dataerrln("couldn't create dateformats.");
    return;
  }
  df_t->adoptTimeZone(tz->clone());
  df_d->adoptTimeZone(tz->clone());
  df_dt->adoptTimeZone(tz->clone());

  for (int32_t i=0; i < 30; i++) {
    logln("setDate\n");
    astro3->setDate(cal->getTime(status));
    logln("getRiseSet(TRUE)\n");
    UDate sunrise = astro3->getSunRiseSet(TRUE);
    logln("getRiseSet(FALSE)\n");
    UDate sunset  = astro3->getSunRiseSet(FALSE);
    logln("end of getRiseSet\n");

    cal2->setTime(cal->getTime(status), status);
    cal2->set(UCAL_SECOND,      0);
    cal2->set(UCAL_MILLISECOND, 0);

    cal2->set(UCAL_HOUR_OF_DAY, USNO[4*i+0]);
    cal2->set(UCAL_MINUTE,      USNO[4*i+1]);
    UDate exprise = cal2->getTime(status);
    cal2->set(UCAL_HOUR_OF_DAY, USNO[4*i+2]);
    cal2->set(UCAL_MINUTE,      USNO[4*i+3]);
    UDate expset = cal2->getTime(status);
    // Compute delta of what we got to the USNO data, in seconds
    int32_t deltarise = (int32_t)uprv_fabs((sunrise - exprise) / 1000);
    int32_t deltaset = (int32_t)uprv_fabs((sunset - expset) / 1000);

    // Allow a deviation of 0..MAX_DEV seconds
    // It would be nice to get down to 60 seconds, but at this
    // point that appears to be impossible without a redo of the
    // algorithm using something more advanced than Duffett-Smith.
    int32_t MAX_DEV = 180;
    UnicodeString s1, s2, s3, s4, s5;
    if (deltarise > MAX_DEV || deltaset > MAX_DEV) {
      if (deltarise > MAX_DEV) {
        errln("FAIL: (rise) " + df_d->format(cal->getTime(status),s1) +
              ", Sunrise: " + df_dt->format(sunrise, s2) +
              " (USNO " + df_t->format(exprise,s3) +
              " d=" + deltarise + "s)");
      } else {
        logln(df_d->format(cal->getTime(status),s1) +
              ", Sunrise: " + df_dt->format(sunrise,s2) +
              " (USNO " + df_t->format(exprise,s3) + ")");
      }
      s1.remove(); s2.remove(); s3.remove(); s4.remove(); s5.remove();
      if (deltaset > MAX_DEV) {
        errln("FAIL: (set)  " + df_d->format(cal->getTime(status),s1) +
              ", Sunset:  " + df_dt->format(sunset,s2) +
              " (USNO " + df_t->format(expset,s3) +
              " d=" + deltaset + "s)");
      } else {
        logln(df_d->format(cal->getTime(status),s1) +
              ", Sunset: " + df_dt->format(sunset,s2) +
              " (USNO " + df_t->format(expset,s3) + ")");
      }
    } else {
      logln(df_d->format(cal->getTime(status),s1) +
            ", Sunrise: " + df_dt->format(sunrise,s2) +
            " (USNO " + df_t->format(exprise,s3) + ")" +
            ", Sunset: " + df_dt->format(sunset,s4) +
            " (USNO " + df_t->format(expset,s5) + ")");
    }
    cal->add(UCAL_DATE, 1, status);
  }

  //        CalendarAstronomer a = new CalendarAstronomer(-(71+5/60), 42+37/60);
  //        cal.clear();
  //        cal.set(cal.YEAR, 1986);
  //        cal.set(cal.MONTH, cal.MARCH);
  //        cal.set(cal.DATE, 10);
  //        cal.set(cal.YEAR, 1988);
  //        cal.set(cal.MONTH, cal.JULY);
  //        cal.set(cal.DATE, 27);
  //        a.setDate(cal.getTime());
  //        long r = a.getSunRiseSet2(true);
  delete astro3;
  delete tz;
  delete cal;
  delete cal2;
  delete df_t;
  delete df_d;
  delete df_dt;
  closeAstro(status);
  ASSERT_OK(status);
}


void AstroTest::TestBasics(void) {
  UErrorCode status = U_ZERO_ERROR;
  initAstro(status);
  if (U_FAILURE(status)) {
    dataerrln("Got error: %s", u_errorName(status));
    return;
  }

  // Check that our JD computation is the same as the book's (p. 88)
  GregorianCalendar *cal3 = new GregorianCalendar(TimeZone::getGMT()->clone(), Locale::getUS(), status);
  DateFormat *d3 = DateFormat::createDateTimeInstance(DateFormat::MEDIUM,DateFormat::MEDIUM,Locale::getUS());
  d3->setTimeZone(*TimeZone::getGMT());
  cal3->clear();
  cal3->set(UCAL_YEAR, 1980);
  cal3->set(UCAL_MONTH, UCAL_JULY);
  cal3->set(UCAL_DATE, 2);
  logln("cal3[a]=%.1lf, d=%d\n", cal3->getTime(status), cal3->get(UCAL_JULIAN_DAY,status));
  {
    UnicodeString s;
    logln(UnicodeString("cal3[a] = ") + d3->format(cal3->getTime(status),s));
  }
  cal3->clear();
  cal3->set(UCAL_YEAR, 1980);
  cal3->set(UCAL_MONTH, UCAL_JULY);
  cal3->set(UCAL_DATE, 27);
  logln("cal3=%.1lf, d=%d\n", cal3->getTime(status), cal3->get(UCAL_JULIAN_DAY,status));

  ASSERT_OK(status);
  {
    UnicodeString s;
    logln(UnicodeString("cal3 = ") + d3->format(cal3->getTime(status),s));
  }
  astro->setTime(cal3->getTime(status));
  double jd = astro->getJulianDay() - 2447891.5;
  double exp = -3444.;
  if (jd == exp) {
    UnicodeString s;
    logln(d3->format(cal3->getTime(status),s) + " => " + jd);
  } else {
    UnicodeString s;
    errln("FAIL: " + d3->format(cal3->getTime(status), s) + " => " + jd +
          ", expected " + exp);
  }

  //        cal3.clear();
  //        cal3.set(cal3.YEAR, 1990);
  //        cal3.set(cal3.MONTH, Calendar.JANUARY);
  //        cal3.set(cal3.DATE, 1);
  //        cal3.add(cal3.DATE, -1);
  //        astro.setDate(cal3.getTime());
  //        astro.foo();

  delete cal3;
  delete d3;
  ASSERT_OK(status);
  closeAstro(status);
  ASSERT_OK(status);

}

void AstroTest::TestMoonAge(void){
	UErrorCode status = U_ZERO_ERROR;
	initAstro(status);
	ASSERT_OK(status);
	
	// more testcases are around the date 05/20/2012
	//ticket#3785  UDate ud0 = 1337557623000.0;
	static const double testcase[][10] = {{2012, 5, 20 , 16 , 48, 59},
	                {2012, 5, 20 , 16 , 47, 34},
	                {2012, 5, 21, 00, 00, 00},
	                {2012, 5, 20, 14, 55, 59},
	                {2012, 5, 21, 7, 40, 40},
	                {2023, 9, 25, 10,00, 00},
	                {2008, 7, 7, 15, 00, 33}, 
	                {1832, 9, 24, 2, 33, 41 },
	                {2016, 1, 31, 23, 59, 59},
	                {2099, 5, 20, 14, 55, 59}
	        };
	// Moon phase angle - Got from http://www.moonsystem.to/checkupe.htm
	static const double angle[] = {356.8493418421329, 356.8386760059673, 0.09625415252237701, 355.9986960782416, 3.5714026601303317, 124.26906744384183, 53.50364630964228,
									357.54163205513123, 268.41779281511094, 4.82340276581624};
	static const double precision = CalendarAstronomer::PI/32;
	for (int32_t i = 0; i < UPRV_LENGTHOF(testcase); i++) {
		gc->clear();
		logln((UnicodeString)"CASE["+i+"]: Year "+(int32_t)testcase[i][0]+" Month "+(int32_t)testcase[i][1]+" Day "+
		                                    (int32_t)testcase[i][2]+" Hour "+(int32_t)testcase[i][3]+" Minutes "+(int32_t)testcase[i][4]+
		                                    " Seconds "+(int32_t)testcase[i][5]);
		gc->set((int32_t)testcase[i][0], (int32_t)testcase[i][1]-1, (int32_t)testcase[i][2], (int32_t)testcase[i][3], (int32_t)testcase[i][4], (int32_t)testcase[i][5]);
		astro->setDate(gc->getTime(status));
		double expectedAge = (angle[i]*CalendarAstronomer::PI)/180;
		double got = astro->getMoonAge();
		//logln(testString);
		if(!(got>expectedAge-precision && got<expectedAge+precision)){
			errln((UnicodeString)"FAIL: expected " + expectedAge +
					" got " + got);
		}else{
			logln((UnicodeString)"PASS: expected " + expectedAge +
					" got " + got);
		}
	}
	closeAstro(status);
	ASSERT_OK(status);
}


// TODO: try finding next new moon after  07/28/1984 16:00 GMT


#endif
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
374ca955 A	3	/********************************************************************
374ca955 A	4	* COPYRIGHT:
2ca993e8	5	* Copyright (c) 1996-2016, International Business Machines Corporation and
374ca955 A	6	* others. All Rights Reserved.
	7	********************************************************************/
	8
	9	/* Test CalendarAstronomer for C++ */
	10
	11	#include "unicode/utypes.h"
	12	#include "string.h"
	13	#include "unicode/locid.h"
	14
	15	#if !UCONFIG_NO_FORMATTING
	16
	17	#include "astro.h"
	18	#include "astrotst.h"
2ca993e8	19	#include "cmemory.h"
374ca955 A	20	#include "gregoimp.h" // for Math
	21	#include "unicode/simpletz.h"
	22
	23
374ca955 A	24	#define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break
	25
	26	AstroTest::AstroTest(): astro(NULL), gc(NULL) {
	27	}
	28
	29	void AstroTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )
	30	{
	31	if (exec) logln("TestSuite AstroTest");
	32	switch (index) {
	33	// CASE(0,FooTest);
	34	CASE(0,TestSolarLongitude);
	35	CASE(1,TestLunarPosition);
	36	CASE(2,TestCoordinates);
	37	CASE(3,TestCoverage);
	38	CASE(4,TestSunriseTimes);
	39	CASE(5,TestBasics);
729e4ab9	40	CASE(6,TestMoonAge);
374ca955 A	41	default: name = ""; break;
	42	}
	43	}
	44
	45	#undef CASE
	46
729e4ab9	47	#define ASSERT_OK(x) if(U_FAILURE(x)) { dataerrln("%s:%d: %s\n", __FILE__, __LINE__, u_errorName(x)); return; }
374ca955 A	48
	49
	50	void AstroTest::initAstro(UErrorCode &status) {
	51	if(U_FAILURE(status)) return;
	52
	53	if((astro != NULL) \|\| (gc != NULL)) {
729e4ab9	54	dataerrln("Err: initAstro() called twice!");
374ca955 A	55	closeAstro(status);
	56	if(U_SUCCESS(status)) {
	57	status = U_INTERNAL_PROGRAM_ERROR;
	58	}
	59	}
	60
	61	if(U_FAILURE(status)) return;
	62
	63	astro = new CalendarAstronomer();
	64	gc = Calendar::createInstance(TimeZone::getGMT()->clone(), status);
	65	}
	66
	67	void AstroTest::closeAstro(UErrorCode &/status/) {
	68	if(astro != NULL) {
	69	delete astro;
	70	astro = NULL;
	71	}
	72	if(gc != NULL) {
	73	delete gc;
	74	gc = NULL;
	75	}
	76	}
	77
	78	void AstroTest::TestSolarLongitude(void) {
	79	UErrorCode status = U_ZERO_ERROR;
	80	initAstro(status);
	81	ASSERT_OK(status);
	82
	83	struct {
	84	int32_t d[5]; double f ;
	85	} tests[] = {
	86	{ { 1980, 7, 27, 0, 00 }, 124.114347 },
	87	{ { 1988, 7, 27, 00, 00 }, 124.187732 }
	88	};
	89
	90	logln("");
2ca993e8	91	for (uint32_t i = 0; i < UPRV_LENGTHOF(tests); i++) {
374ca955 A	92	gc->clear();
	93	gc->set(tests[i].d[0], tests[i].d[1]-1, tests[i].d[2], tests[i].d[3], tests[i].d[4]);
	94
	95	astro->setDate(gc->getTime(status));
	96
	97	double longitude = astro->getSunLongitude();
	98	//longitude = 0;
	99	CalendarAstronomer::Equatorial result;
	100	astro->getSunPosition(result);
	101	logln((UnicodeString)"Sun position is " + result.toString() + (UnicodeString)"; " /* + result.toHmsString()*/ + " Sun longitude is " + longitude );
	102	}
	103	closeAstro(status);
	104	ASSERT_OK(status);
	105	}
	106
	107
	108
	109	void AstroTest::TestLunarPosition(void) {
	110	UErrorCode status = U_ZERO_ERROR;
	111	initAstro(status);
	112	ASSERT_OK(status);
	113
	114	static const double tests[][7] = {
	115	{ 1979, 2, 26, 16, 00, 0, 0 }
	116	};
	117	logln("");
	118
2ca993e8	119	for (int32_t i = 0; i < UPRV_LENGTHOF(tests); i++) {
374ca955 A	120	gc->clear();
	121	gc->set((int32_t)tests[i][0], (int32_t)tests[i][1]-1, (int32_t)tests[i][2], (int32_t)tests[i][3], (int32_t)tests[i][4]);
	122	astro->setDate(gc->getTime(status));
	123
	124	const CalendarAstronomer::Equatorial& result = astro->getMoonPosition();
	125	logln((UnicodeString)"Moon position is " + result.toString() + (UnicodeString)"; " /* + result->toHmsString()*/);
	126	}
	127
	128	closeAstro(status);
	129	ASSERT_OK(status);
	130	}
	131
	132
	133
	134	void AstroTest::TestCoordinates(void) {
	135	UErrorCode status = U_ZERO_ERROR;
	136	initAstro(status);
	137	ASSERT_OK(status);
	138
	139	CalendarAstronomer::Equatorial result;
	140	astro->eclipticToEquatorial(result, 139.686111 * CalendarAstronomer::PI / 180.0, 4.875278* CalendarAstronomer::PI / 180.0);
	141	logln((UnicodeString)"result is " + result.toString() + (UnicodeString)"; " /* + result.toHmsString()*/ );
	142	closeAstro(status);
	143	ASSERT_OK(status);
	144	}
	145
	146
	147
	148	void AstroTest::TestCoverage(void) {
	149	UErrorCode status = U_ZERO_ERROR;
	150	initAstro(status);
	151	ASSERT_OK(status);
	152	GregorianCalendar *cal = new GregorianCalendar(1958, UCAL_AUGUST, 15,status);
	153	UDate then = cal->getTime(status);
	154	CalendarAstronomer *myastro = new CalendarAstronomer(then);
	155	ASSERT_OK(status);
	156
	157	//Latitude: 34 degrees 05' North
	158	//Longitude: 118 degrees 22' West
	159	double laLat = 34 + 5./60, laLong = 360 - (118 + 22./60);
	160	CalendarAstronomer *myastro2 = new CalendarAstronomer(laLong, laLat);
	161
	162	double eclLat = laLat * CalendarAstronomer::PI / 360;
	163	double eclLong = laLong * CalendarAstronomer::PI / 360;
	164
	165	CalendarAstronomer::Ecliptic ecl(eclLat, eclLong);
	166	CalendarAstronomer::Equatorial eq;
	167	CalendarAstronomer::Horizon hor;
	168
	169	logln("ecliptic: " + ecl.toString());
	170	CalendarAstronomer *myastro3 = new CalendarAstronomer();
	171	myastro3->setJulianDay((4713 + 2000) * 365.25);
	172
	173	CalendarAstronomer *astronomers[] = {
	174	myastro, myastro2, myastro3, myastro2 // check cache
	175	};
	176
2ca993e8	177	for (uint32_t i = 0; i < UPRV_LENGTHOF(astronomers); ++i) {
374ca955 A	178	CalendarAstronomer *anAstro = astronomers[i];
	179
	180	//logln("astro: " + astro);
	181	logln((UnicodeString)" date: " + anAstro->getTime());
	182	logln((UnicodeString)" cent: " + anAstro->getJulianCentury());
	183	logln((UnicodeString)" gw sidereal: " + anAstro->getGreenwichSidereal());
	184	logln((UnicodeString)" loc sidereal: " + anAstro->getLocalSidereal());
	185	logln((UnicodeString)" equ ecl: " + (anAstro->eclipticToEquatorial(eq,ecl)).toString());
	186	logln((UnicodeString)" equ long: " + (anAstro->eclipticToEquatorial(eq, eclLong)).toString());
	187	logln((UnicodeString)" horiz: " + (anAstro->eclipticToHorizon(hor, eclLong)).toString());
	188	logln((UnicodeString)" sunrise: " + (anAstro->getSunRiseSet(TRUE)));
	189	logln((UnicodeString)" sunset: " + (anAstro->getSunRiseSet(FALSE)));
	190	logln((UnicodeString)" moon phase: " + anAstro->getMoonPhase());
	191	logln((UnicodeString)" moonrise: " + (anAstro->getMoonRiseSet(TRUE)));
	192	logln((UnicodeString)" moonset: " + (anAstro->getMoonRiseSet(FALSE)));
	193	logln((UnicodeString)" prev summer solstice: " + (anAstro->getSunTime(CalendarAstronomer::SUMMER_SOLSTICE(), FALSE)));
	194	logln((UnicodeString)" next summer solstice: " + (anAstro->getSunTime(CalendarAstronomer::SUMMER_SOLSTICE(), TRUE)));
	195	logln((UnicodeString)" prev full moon: " + (anAstro->getMoonTime(CalendarAstronomer::FULL_MOON(), FALSE)));
	196	logln((UnicodeString)" next full moon: " + (anAstro->getMoonTime(CalendarAstronomer::FULL_MOON(), TRUE)));
	197	}
	198
	199	delete myastro2;
	200	delete myastro3;
	201	delete myastro;
	202	delete cal;
	203
	204	closeAstro(status);
	205	ASSERT_OK(status);
	206	}
	207
	208
	209
	210	void AstroTest::TestSunriseTimes(void) {
	211	UErrorCode status = U_ZERO_ERROR;
	212	initAstro(status);
	213	ASSERT_OK(status);
	214
	215	// logln("Sunrise/Sunset times for San Jose, California, USA");
	216	// CalendarAstronomer *astro2 = new CalendarAstronomer(-121.55, 37.20);
	217	// TimeZone *tz = TimeZone::createTimeZone("America/Los_Angeles");
	218
	219	// We'll use a table generated by the UNSO website as our reference
	220	// From: http://aa.usno.navy.mil/
	221	//-Location: W079 25, N43 40
	222	//-Rise and Set for the Sun for 2001
	223	//-Zone: 4h West of Greenwich
	224	int32_t USNO[] = {
	225	6,59, 19,45,
	226	6,57, 19,46,
	227	6,56, 19,47,
	228	6,54, 19,48,
	229	6,52, 19,49,
	230	6,50, 19,51,
	231	6,48, 19,52,
	232	6,47, 19,53,
	233	6,45, 19,54,
	234	6,43, 19,55,
	235	6,42, 19,57,
	236	6,40, 19,58,
	237	6,38, 19,59,
	238	6,36, 20, 0,
	239	6,35, 20, 1,
	240	6,33, 20, 3,
	241	6,31, 20, 4,
242	6,30, 20, 5,
243	6,28, 20, 6,
244	6,27, 20, 7,
245	6,25, 20, 8,
246	6,23, 20,10,
247	6,22, 20,11,
248	6,20, 20,12,
249	6,19, 20,13,
250	6,17, 20,14,
251	6,16, 20,16,
252	6,14, 20,17,
253	6,13, 20,18,
254	6,11, 20,19,
255	};
256
257	logln("Sunrise/Sunset times for Toronto, Canada");
258	// long = 79 25", lat = 43 40"
259	CalendarAstronomer *astro3 = new CalendarAstronomer(-(79+25/60), 43+40/60);
260
261	// As of ICU4J 2.8 the ICU4J time zones implement pass-through
262	// to the underlying JDK. Because of variation in the
263	// underlying JDKs, we have to use a fixed-offset
264	// SimpleTimeZone to get consistent behavior between JDKs.
265	// The offset we want is [-18000000, 3600000] (raw, dst).
266	// [aliu 10/15/03]
267
268	// TimeZone tz = TimeZone.getTimeZone("America/Montreal");
269	TimeZone *tz = new SimpleTimeZone(-18000000 + 3600000, "Montreal(FIXED)");
270
271	GregorianCalendar *cal = new GregorianCalendar(tz->clone(), Locale::getUS(), status);
272	GregorianCalendar *cal2 = new GregorianCalendar(tz->clone(), Locale::getUS(), status);
273	cal->clear();
274	cal->set(UCAL_YEAR, 2001);
275	cal->set(UCAL_MONTH, UCAL_APRIL);
276	cal->set(UCAL_DAY_OF_MONTH, 1);
277	cal->set(UCAL_HOUR_OF_DAY, 12); // must be near local noon for getSunRiseSet to work
278
279	DateFormat *df_t = DateFormat::createTimeInstance(DateFormat::MEDIUM,Locale::getUS());
280	DateFormat *df_d = DateFormat::createDateInstance(DateFormat::MEDIUM,Locale::getUS());
281	DateFormat *df_dt = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::MEDIUM, Locale::getUS());
73c04bcf	282	if(!df_t \|\| !df_d \|\| !df_dt) {
729e4ab9	283	dataerrln("couldn't create dateformats.");
73c04bcf A	284	return;
73c04bcf A	285	}
374ca955 A	286	df_t->adoptTimeZone(tz->clone());
	287	df_d->adoptTimeZone(tz->clone());
	288	df_dt->adoptTimeZone(tz->clone());
	289
	290	for (int32_t i=0; i < 30; i++) {
	291	logln("setDate\n");
	292	astro3->setDate(cal->getTime(status));
	293	logln("getRiseSet(TRUE)\n");
	294	UDate sunrise = astro3->getSunRiseSet(TRUE);
	295	logln("getRiseSet(FALSE)\n");
	296	UDate sunset = astro3->getSunRiseSet(FALSE);
	297	logln("end of getRiseSet\n");
	298
	299	cal2->setTime(cal->getTime(status), status);
	300	cal2->set(UCAL_SECOND, 0);
	301	cal2->set(UCAL_MILLISECOND, 0);
	302
	303	cal2->set(UCAL_HOUR_OF_DAY, USNO[4*i+0]);
	304	cal2->set(UCAL_MINUTE, USNO[4*i+1]);
	305	UDate exprise = cal2->getTime(status);
	306	cal2->set(UCAL_HOUR_OF_DAY, USNO[4*i+2]);
	307	cal2->set(UCAL_MINUTE, USNO[4*i+3]);
	308	UDate expset = cal2->getTime(status);
	309	// Compute delta of what we got to the USNO data, in seconds
	310	int32_t deltarise = (int32_t)uprv_fabs((sunrise - exprise) / 1000);
	311	int32_t deltaset = (int32_t)uprv_fabs((sunset - expset) / 1000);
	312
	313	// Allow a deviation of 0..MAX_DEV seconds
	314	// It would be nice to get down to 60 seconds, but at this
	315	// point that appears to be impossible without a redo of the
	316	// algorithm using something more advanced than Duffett-Smith.
	317	int32_t MAX_DEV = 180;
	318	UnicodeString s1, s2, s3, s4, s5;
	319	if (deltarise > MAX_DEV \|\| deltaset > MAX_DEV) {
	320	if (deltarise > MAX_DEV) {
	321	errln("FAIL: (rise) " + df_d->format(cal->getTime(status),s1) +
	322	", Sunrise: " + df_dt->format(sunrise, s2) +
	323	" (USNO " + df_t->format(exprise,s3) +
	324	" d=" + deltarise + "s)");
	325	} else {
	326	logln(df_d->format(cal->getTime(status),s1) +
	327	", Sunrise: " + df_dt->format(sunrise,s2) +
	328	" (USNO " + df_t->format(exprise,s3) + ")");
	329	}
	330	s1.remove(); s2.remove(); s3.remove(); s4.remove(); s5.remove();
	331	if (deltaset > MAX_DEV) {
	332	errln("FAIL: (set) " + df_d->format(cal->getTime(status),s1) +
	333	", Sunset: " + df_dt->format(sunset,s2) +
	334	" (USNO " + df_t->format(expset,s3) +
	335	" d=" + deltaset + "s)");
	336	} else {
	337	logln(df_d->format(cal->getTime(status),s1) +
	338	", Sunset: " + df_dt->format(sunset,s2) +
	339	" (USNO " + df_t->format(expset,s3) + ")");
	340	}
	341	} else {
	342	logln(df_d->format(cal->getTime(status),s1) +
	343	", Sunrise: " + df_dt->format(sunrise,s2) +
	344	" (USNO " + df_t->format(exprise,s3) + ")" +
	345	", Sunset: " + df_dt->format(sunset,s4) +
	346	" (USNO " + df_t->format(expset,s5) + ")");
	347	}
	348	cal->add(UCAL_DATE, 1, status);
	349	}
350
351	// CalendarAstronomer a = new CalendarAstronomer(-(71+5/60), 42+37/60);
352	// cal.clear();
353	// cal.set(cal.YEAR, 1986);
354	// cal.set(cal.MONTH, cal.MARCH);
355	// cal.set(cal.DATE, 10);
356	// cal.set(cal.YEAR, 1988);
357	// cal.set(cal.MONTH, cal.JULY);
358	// cal.set(cal.DATE, 27);
359	// a.setDate(cal.getTime());
360	// long r = a.getSunRiseSet2(true);
361	delete astro3;
362	delete tz;
363	delete cal;
364	delete cal2;
365	delete df_t;
366	delete df_d;
367	delete df_dt;
368	closeAstro(status);
369	ASSERT_OK(status);
370	}
371
372
373
374	void AstroTest::TestBasics(void) {
375	UErrorCode status = U_ZERO_ERROR;
376	initAstro(status);
729e4ab9 A	377	if (U_FAILURE(status)) {
	378	dataerrln("Got error: %s", u_errorName(status));
	379	return;
	380	}
374ca955 A	381
	382	// Check that our JD computation is the same as the book's (p. 88)
	383	GregorianCalendar *cal3 = new GregorianCalendar(TimeZone::getGMT()->clone(), Locale::getUS(), status);
	384	DateFormat *d3 = DateFormat::createDateTimeInstance(DateFormat::MEDIUM,DateFormat::MEDIUM,Locale::getUS());
	385	d3->setTimeZone(*TimeZone::getGMT());
	386	cal3->clear();
	387	cal3->set(UCAL_YEAR, 1980);
	388	cal3->set(UCAL_MONTH, UCAL_JULY);
	389	cal3->set(UCAL_DATE, 2);
	390	logln("cal3[a]=%.1lf, d=%d\n", cal3->getTime(status), cal3->get(UCAL_JULIAN_DAY,status));
	391	{
	392	UnicodeString s;
	393	logln(UnicodeString("cal3[a] = ") + d3->format(cal3->getTime(status),s));
	394	}
	395	cal3->clear();
	396	cal3->set(UCAL_YEAR, 1980);
	397	cal3->set(UCAL_MONTH, UCAL_JULY);
	398	cal3->set(UCAL_DATE, 27);
	399	logln("cal3=%.1lf, d=%d\n", cal3->getTime(status), cal3->get(UCAL_JULIAN_DAY,status));
	400
	401	ASSERT_OK(status);
	402	{
	403	UnicodeString s;
	404	logln(UnicodeString("cal3 = ") + d3->format(cal3->getTime(status),s));
	405	}
	406	astro->setTime(cal3->getTime(status));
	407	double jd = astro->getJulianDay() - 2447891.5;
	408	double exp = -3444.;
	409	if (jd == exp) {
	410	UnicodeString s;
	411	logln(d3->format(cal3->getTime(status),s) + " => " + jd);
	412	} else {
	413	UnicodeString s;
	414	errln("FAIL: " + d3->format(cal3->getTime(status), s) + " => " + jd +
	415	", expected " + exp);
	416	}
	417
	418	// cal3.clear();
	419	// cal3.set(cal3.YEAR, 1990);
	420	// cal3.set(cal3.MONTH, Calendar.JANUARY);
	421	// cal3.set(cal3.DATE, 1);
	422	// cal3.add(cal3.DATE, -1);
	423	// astro.setDate(cal3.getTime());
	424	// astro.foo();
	425
	426	delete cal3;
	427	delete d3;
	428	ASSERT_OK(status);
	429	closeAstro(status);
	430	ASSERT_OK(status);
	431
	432	}
	433
729e4ab9 A	434	void AstroTest::TestMoonAge(void){
	435	UErrorCode status = U_ZERO_ERROR;
	436	initAstro(status);
	437	ASSERT_OK(status);
	438
	439	// more testcases are around the date 05/20/2012
	440	//ticket#3785 UDate ud0 = 1337557623000.0;
	441	static const double testcase[][10] = {{2012, 5, 20 , 16 , 48, 59},
	442	{2012, 5, 20 , 16 , 47, 34},
	443	{2012, 5, 21, 00, 00, 00},
	444	{2012, 5, 20, 14, 55, 59},
	445	{2012, 5, 21, 7, 40, 40},
	446	{2023, 9, 25, 10,00, 00},
	447	{2008, 7, 7, 15, 00, 33},
	448	{1832, 9, 24, 2, 33, 41 },
	449	{2016, 1, 31, 23, 59, 59},
	450	{2099, 5, 20, 14, 55, 59}
	451	};
	452	// Moon phase angle - Got from http://www.moonsystem.to/checkupe.htm
57a6839d	453	static const double angle[] = {356.8493418421329, 356.8386760059673, 0.09625415252237701, 355.9986960782416, 3.5714026601303317, 124.26906744384183, 53.50364630964228,
729e4ab9 A	454	357.54163205513123, 268.41779281511094, 4.82340276581624};
729e4ab9 A	455	static const double precision = CalendarAstronomer::PI/32;
2ca993e8	456	for (int32_t i = 0; i < UPRV_LENGTHOF(testcase); i++) {
729e4ab9 A	457	gc->clear();
	458	logln((UnicodeString)"CASE["+i+"]: Year "+(int32_t)testcase[i][0]+" Month "+(int32_t)testcase[i][1]+" Day "+
	459	(int32_t)testcase[i][2]+" Hour "+(int32_t)testcase[i][3]+" Minutes "+(int32_t)testcase[i][4]+
	460	" Seconds "+(int32_t)testcase[i][5]);
	461	gc->set((int32_t)testcase[i][0], (int32_t)testcase[i][1]-1, (int32_t)testcase[i][2], (int32_t)testcase[i][3], (int32_t)testcase[i][4], (int32_t)testcase[i][5]);
	462	astro->setDate(gc->getTime(status));
	463	double expectedAge = (angle[i]*CalendarAstronomer::PI)/180;
	464	double got = astro->getMoonAge();
	465	//logln(testString);
	466	if(!(got>expectedAge-precision && got<expectedAge+precision)){
	467	errln((UnicodeString)"FAIL: expected " + expectedAge +
	468	" got " + got);
	469	}else{
	470	logln((UnicodeString)"PASS: expected " + expectedAge +
	471	" got " + got);
	472	}
	473	}
	474	closeAstro(status);
	475	ASSERT_OK(status);
	476	}
	477
374ca955 A	478
	479	// TODO: try finding next new moon after 07/28/1984 16:00 GMT
	480
	481
	482	#endif
	483
	484
	485