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

/********************************************************************
 * COPYRIGHT:
 * Copyright (c) 1996-2010, 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 "gregoimp.h" // for Math
#include "unicode/simpletz.h"


static const double DAY_MS = 24.*60.*60.*1000.;

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