Index: /trunk/psLib/test/Makefile.am =================================================================== --- /trunk/psLib/test/Makefile.am (revision 4546) +++ /trunk/psLib/test/Makefile.am (revision 4547) @@ -1,7 +1,3 @@ -# not a GNU package. You can remove this line, if -# have all needed files, that a GNU package needs -AUTOMAKE_OPTIONS = foreign 1.4 - -SUBDIRS = astronomy collections dataManip dataIO image sysUtils +SUBDIRS = $(SRCDIRS) EXTRA_DIST = runTest FullUnitTest Index: /trunk/psLib/test/astro/Makefile.am =================================================================== --- /trunk/psLib/test/astro/Makefile.am (revision 4547) +++ /trunk/psLib/test/astro/Makefile.am (revision 4547) @@ -0,0 +1,61 @@ + #Makefile for astro tests of psLib +# + +AM_LDFLAGS = -L$(top_builddir)/src -lpslib $(PSLIB_LIBS) + +TESTS = \ + tst_psCoord \ + tst_psCoord01 \ + tst_psTime_01 \ + tst_psTime_02 \ + tst_psTime_03 \ + tst_psTime_04 + +tst_psTime_01_SOURCES = tst_psTime_01.c +tst_psTime_02_SOURCES = tst_psTime_02.c +tst_psTime_03_SOURCES = tst_psTime_03.c +tst_psTime_04_SOURCES = tst_psTime_04.c +tst_psCoord_SOURCES = tst_psCoord.c +tst_psCoord01_SOURCES = tst_psCoord01.c + +check_DATA = \ + psTime.config \ + test.psTime.config1 \ + test.psTime.config2 \ + test.psTime.config3 \ + test.psTime.config4 \ + test.ser7.dat + +check_PROGRAMS = $(TESTS) + +TESTS_ENVIRONMENT = export PS_CONFIG_FILE="psTime.config" && perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified + +EXTRA_DIST = data verified + +tests: $(check_DATA) $(TESTS) + +CLEANFILES = $(TESTS) $(check_DATA) temp/* + +psTime.config: $(top_srcdir)/etc/pslib/psTime.config.template + sed 's|PREFIX|$(top_srcdir)|' $? > $@ + +test.psTime.config1: data/test.psTime.config1.template + cp $? $@ + +test.psTime.config2: data/test.psTime.config2.template + sed 's|PREFIX|$(top_srcdir)|' $? > $@ + +test.psTime.config3: data/test.psTime.config3.template + sed 's|PREFIX|$(top_srcdir)|' $? > $@ + +test.psTime.config4: data/test.psTime.config4.template + cp $? $@ + +test.ser7.dat: data/test.ser7.dat + cp $? $@ + +tests: $(check_DATA) $(TESTS) + +test: check + + Index: /trunk/psLib/test/astro/data/psTime.config.template =================================================================== --- /trunk/psLib/test/astro/data/psTime.config.template (revision 4547) +++ /trunk/psLib/test/astro/data/psTime.config.template (revision 4547) @@ -0,0 +1,23 @@ +# This configuration file specifies values required for time calculations by psLib. +psLib.time.tables.dir STR PREFIX/share/pslib # Directory for time tables +psLib.time.tables.n S32 4 # Number of time tables +psLib.time.tables.files STR ser7.dat eopc01_1900_2004.dat finals_all.dat tai_utc.dat # These are the table file names +@psLib.time.tables.from F64 53258.0, 15020.0, 41684.0 2437300.5 # Valid from these dates +@psLib.time.tables.to F64 53622.0, 53258.0, 53627.0 2451179.5 # Valid to these dates +psLib.time.before.xp F64 0.0 # Value of XP for before the earliest MJD +psLib.time.before.yp F64 0.0 # Value of YP for before the earliest MJD +psLib.time.before.dut F64 0.0 # Value of UT1-UTC for before the earliest MJD + +# Now follows formulae for predicting ahead of the most recent available table entry. +# xp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# yp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# A = 2*pi*(MJD - pslib.time.predict.mjd)/365.25 +# C = 2*pi*(MJD - pslib.time.predict.mjd)/435.0 +# dut = ut1-utc = [0] + [1]*(MJD - [2]) - (UT2-UT1) +# ut2-ut1 = 0.022 sin(2*pi*T) - 0.012 cos(2*pi*T) - 0.006 sin(4*pi*T) + 0.007 cos(4*pi*T) +# T = 2000.0 + (MJD - 51544.03)/365.2422 +@psLib.time.predict.xp F64 0.0569, 0.0555, -0.0200, 0.0513, 0.1483 +@psLib.time.predict.yp F64 0.3498, -0.0176, -0.0498, 0.1483, -0.0513 +psLib.time.predict.mjd F64 53257.0 +@psLib.time.predict.dut F64 -0.4944, -0.00023, 53262.0 + Index: /trunk/psLib/test/astro/data/test.psTime.config1.template =================================================================== --- /trunk/psLib/test/astro/data/test.psTime.config1.template (revision 4547) +++ /trunk/psLib/test/astro/data/test.psTime.config1.template (revision 4547) @@ -0,0 +1,23 @@ +# This configuration file specifies values required for time calculations by psLib. +psLib.time.tables.dir STR bogus # Directory for time tables +psLib.time.tables.n S32 4 # Number of time tables +psLib.time.tables.files STR ser7.dat eopc01_1900_2004.dat finals_all.dat tai_utc.dat # These are the table file names +@psLib.time.tables.from F64 53258.0, 15020.0, 41684.0 2437300.5 # Valid from these dates +@psLib.time.tables.to F64 53622.0, 53258.0, 53627.0 2451179.5 # Valid to these dates +psLib.time.before.xp F64 0.0 # Value of XP for before the earliest MJD +psLib.time.before.yp F64 0.0 # Value of YP for before the earliest MJD +psLib.time.before.dut F64 0.0 # Value of UT1-UTC for before the earliest MJD + +# Now follows formulae for predicting ahead of the most recent available table entry. +# xp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# yp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# A = 2*pi*(MJD - pslib.time.predict.mjd)/365.25 +# C = 2*pi*(MJD - pslib.time.predict.mjd)/435.0 +# dut = ut1-utc = [0] + [1]*(MJD - [2]) - (UT2-UT1) +# ut2-ut1 = 0.022 sin(2*pi*T) - 0.012 cos(2*pi*T) - 0.006 sin(4*pi*T) + 0.007 cos(4*pi*T) +# T = 2000.0 + (MJD - 51544.03)/365.2422 +@psLib.time.predict.xp F64 0.0569, 0.0555, -0.0200, 0.0513, 0.1483 +@psLib.time.predict.yp F64 0.3498, -0.0176, -0.0498, 0.1483, -0.0513 +psLib.time.predict.mjd F64 53257.0 +@psLib.time.predict.dut F64 -0.4944, -0.00023, 53262.0 + Index: /trunk/psLib/test/astro/data/test.psTime.config2.template =================================================================== --- /trunk/psLib/test/astro/data/test.psTime.config2.template (revision 4547) +++ /trunk/psLib/test/astro/data/test.psTime.config2.template (revision 4547) @@ -0,0 +1,23 @@ +# This configuration file specifies values required for time calculations by psLib. +psLib.time.tables.dir STR PREFIX/share/pslib # Directory for time tables +psLib.time.tables.n S32 4 # Number of time tables +psLib.time.tables.files STR eopc01_1900_2004.dat finals_all.dat tai_utc.dat # These are the table file names +@psLib.time.tables.from F64 53258.0, 15020.0, 41684.0 2437300.5 # Valid from these dates +@psLib.time.tables.to F64 53622.0, 53258.0, 53627.0 2451179.5 # Valid to these dates +psLib.time.before.xp F64 0.0 # Value of XP for before the earliest MJD +psLib.time.before.yp F64 0.0 # Value of YP for before the earliest MJD +psLib.time.before.dut F64 0.0 # Value of UT1-UTC for before the earliest MJD + +# Now follows formulae for predicting ahead of the most recent available table entry. +# xp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# yp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# A = 2*pi*(MJD - pslib.time.predict.mjd)/365.25 +# C = 2*pi*(MJD - pslib.time.predict.mjd)/435.0 +# dut = ut1-utc = [0] + [1]*(MJD - [2]) - (UT2-UT1) +# ut2-ut1 = 0.022 sin(2*pi*T) - 0.012 cos(2*pi*T) - 0.006 sin(4*pi*T) + 0.007 cos(4*pi*T) +# T = 2000.0 + (MJD - 51544.03)/365.2422 +@psLib.time.predict.xp F64 0.0569, 0.0555, -0.0200, 0.0513, 0.1483 +@psLib.time.predict.yp F64 0.3498, -0.0176, -0.0498, 0.1483, -0.0513 +psLib.time.predict.mjd F64 53257.0 +@psLib.time.predict.dut F64 -0.4944, -0.00023, 53262.0 + Index: /trunk/psLib/test/astro/data/test.psTime.config3.template =================================================================== --- /trunk/psLib/test/astro/data/test.psTime.config3.template (revision 4547) +++ /trunk/psLib/test/astro/data/test.psTime.config3.template (revision 4547) @@ -0,0 +1,23 @@ +# This configuration file specifies values required for time calculations by psLib. +psLib.time.tables.dir STR PREFIX/share/pslib # Directory for time tables +psLib.time.tables.n S32 4 # Number of time tables +psLib.time.tables.files STR ser7.dat eopc01_1900_2004.dat finals_all.dat tai_utc.dat # These are the table file names +@psLib.time.tables.from F64 15020.0, 41684.0 2437300.5 # Valid from these dates +@psLib.time.tables.to F64 53622.0, 53258.0, 53627.0 2451179.5 # Valid to these dates +psLib.time.before.xp F64 0.0 # Value of XP for before the earliest MJD +psLib.time.before.yp F64 0.0 # Value of YP for before the earliest MJD +psLib.time.before.dut F64 0.0 # Value of UT1-UTC for before the earliest MJD + +# Now follows formulae for predicting ahead of the most recent available table entry. +# xp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# yp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# A = 2*pi*(MJD - pslib.time.predict.mjd)/365.25 +# C = 2*pi*(MJD - pslib.time.predict.mjd)/435.0 +# dut = ut1-utc = [0] + [1]*(MJD - [2]) - (UT2-UT1) +# ut2-ut1 = 0.022 sin(2*pi*T) - 0.012 cos(2*pi*T) - 0.006 sin(4*pi*T) + 0.007 cos(4*pi*T) +# T = 2000.0 + (MJD - 51544.03)/365.2422 +@psLib.time.predict.xp F64 0.0569, 0.0555, -0.0200, 0.0513, 0.1483 +@psLib.time.predict.yp F64 0.3498, -0.0176, -0.0498, 0.1483, -0.0513 +psLib.time.predict.mjd F64 53257.0 +@psLib.time.predict.dut F64 -0.4944, -0.00023, 53262.0 + Index: /trunk/psLib/test/astro/data/test.psTime.config4.template =================================================================== --- /trunk/psLib/test/astro/data/test.psTime.config4.template (revision 4547) +++ /trunk/psLib/test/astro/data/test.psTime.config4.template (revision 4547) @@ -0,0 +1,23 @@ +# This configuration file specifies values required for time calculations by psLib. +psLib.time.tables.dir STR . # Directory for time tables +psLib.time.tables.n S32 1 # Number of time tables +psLib.time.tables.files STR test.ser7.dat # This the table file +@psLib.time.tables.from F64 53258.0 # Valid from this date +@psLib.time.tables.to F64 53622.0 # Valid to this date +psLib.time.before.xp F64 0.0 # Value of XP for before the earliest MJD +psLib.time.before.yp F64 0.0 # Value of YP for before the earliest MJD +psLib.time.before.dut F64 0.0 # Value of UT1-UTC for before the earliest MJD + +# Now follows formulae for predicting ahead of the most recent available table entry. +# xp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# yp = [0] + [1]*cos A + [2]*sin A + [3]*cos C + [4]*sin C +# A = 2*pi*(MJD - pslib.time.predict.mjd)/365.25 +# C = 2*pi*(MJD - pslib.time.predict.mjd)/435.0 +# dut = ut1-utc = [0] + [1]*(MJD - [2]) - (UT2-UT1) +# ut2-ut1 = 0.022 sin(2*pi*T) - 0.012 cos(2*pi*T) - 0.006 sin(4*pi*T) + 0.007 cos(4*pi*T) +# T = 2000.0 + (MJD - 51544.03)/365.2422 +@psLib.time.predict.xp F64 0.0569 +@psLib.time.predict.yp F64 0.3498 +psLib.time.predict.mjd F64 53257.0 +@psLib.time.predict.dut F64 -0.4944 + Index: /trunk/psLib/test/astro/data/test.ser7.dat =================================================================== --- /trunk/psLib/test/astro/data/test.ser7.dat (revision 4547) +++ /trunk/psLib/test/astro/data/test.ser7.dat (revision 4547) @@ -0,0 +1,380 @@ +# ser7.dat +# +# This file comes from http://maia.usno.navy.mil (Click on General Information about Earth Orientation). This +# file may also be directly downloaded from ftp://maia.usno.navy.mil/ser7/ser7.dat. See readme.ser7 (located +# in the psLib/data directory) for details. +# +# @author Ross Harman, MHPCC +# +# @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ +# @date $Date: 2005-07-13 02:46:58 $ +# +# +# MJD PM-x PM-y UT1-UTC +# (days) (arcsec) (arcsec) (sec) + psF64 psF64 psF64 psF64 + 53yyy244 0.1377 0.5027 -0.45210 + 53245 0.1394 0.5015 -0.45190 + 53246 0.1411 0.5002 -0.45197 + 53247 0.1429 0.4989 -0.45234 + 53248 0.1447 0.4976 -0.45293 + 53249 0.1465 0.4962 -0.45361 + 53250 0.1484 0.4948 -0.45424 + 53251 0.1503 0.4934 -0.45476 + 53252 0.1521 0.4920 -0.45512 + 53253 0.1540 0.4905 -0.45530 + 53254 0.1558 0.4890 -0.45531 + 53255 0.1577 0.4874 -0.45519 + 53256 0.1595 0.4859 -0.45497 + 53257 0.1613 0.4843 -0.45474 + 53258 0.1631 0.4827 -0.45458 + 53259 0.1649 0.4810 -0.45456 + 53260 0.1667 0.4794 -0.45474 + 53261 0.1684 0.4777 -0.45514 + 53262 0.1701 0.4760 -0.45578 + 53263 0.1717 0.4742 -0.45660 + 53264 0.1734 0.4725 -0.45754 + 53265 0.1750 0.4707 -0.45849 + 53266 0.1765 0.4689 -0.45932 + 53267 0.1780 0.4671 -0.45996 + 53268 0.1795 0.4652 -0.46036 + 53269 0.1810 0.4634 -0.46055 + 53270 0.1824 0.4615 -0.46061 + 53271 0.1838 0.4596 -0.46068 + 53272 0.1852 0.4576 -0.46086 + 53273 0.1865 0.4557 -0.46126 + 53274 0.1878 0.4537 -0.46192 + 53275 0.1890 0.4517 -0.46280 + 53276 0.1902 0.4497 -0.46382 + 53277 0.1914 0.4477 -0.46486 + 53278 0.1925 0.4457 -0.46581 + 53279 0.1936 0.4436 -0.46658 + 53280 0.1946 0.4415 -0.46715 + 53281 0.1956 0.4394 -0.46750 + 53282 0.1966 0.4373 -0.46766 + 53283 0.1976 0.4352 -0.46772 + 53284 0.1985 0.4331 -0.46773 + 53285 0.1993 0.4309 -0.46778 + 53286 0.2001 0.4288 -0.46795 + 53287 0.2009 0.4266 -0.46830 + 53288 0.2017 0.4244 -0.46887 + 53289 0.2024 0.4222 -0.46968 + 53290 0.2031 0.4200 -0.47071 + 53291 0.2037 0.4178 -0.47191 + 53292 0.2043 0.4155 -0.47317 + 53293 0.2049 0.4133 -0.47435 + 53294 0.2054 0.4111 -0.47536 + 53295 0.2059 0.4088 -0.47610 + 53296 0.2063 0.4065 -0.47659 + 53297 0.2067 0.4042 -0.47691 + 53298 0.2071 0.4020 -0.47718 + 53299 0.2075 0.3997 -0.47755 + 53300 0.2078 0.3974 -0.47811 + 53301 0.2080 0.3951 -0.47893 + 53302 0.2083 0.3928 -0.47998 + 53303 0.2085 0.3905 -0.48119 + 53304 0.2086 0.3881 -0.48247 + 53305 0.2088 0.3858 -0.48369 + 53306 0.2089 0.3835 -0.48477 + 53307 0.2089 0.3812 -0.48565 + 53308 0.2090 0.3789 -0.48630 + 53309 0.2089 0.3765 -0.48674 + 53310 0.2089 0.3742 -0.48701 + 53311 0.2088 0.3719 -0.48718 + 53312 0.2088 0.3696 -0.48732 + 53313 0.2086 0.3672 -0.48753 + 53314 0.2085 0.3649 -0.48785 + 53315 0.2082 0.3626 -0.48835 + 53316 0.2080 0.3603 -0.48906 + 53317 0.2077 0.3579 -0.48997 + 53318 0.2074 0.3556 -0.49106 + 53319 0.2071 0.3533 -0.49226 + 53320 0.2067 0.3510 -0.49344 + 53321 0.2063 0.3487 -0.49449 + 53322 0.2059 0.3464 -0.49531 + 53323 0.2054 0.3441 -0.49585 + 53324 0.2049 0.3418 -0.49618 + 53325 0.2044 0.3396 -0.49639 + 53326 0.2038 0.3373 -0.49664 + 53327 0.2032 0.3350 -0.49705 + 53328 0.2026 0.3328 -0.49769 + 53329 0.2020 0.3305 -0.49854 + 53330 0.2013 0.3283 -0.49953 + 53331 0.2006 0.3261 -0.50058 + 53332 0.1999 0.3239 -0.50158 + 53333 0.1991 0.3217 -0.50243 + 53334 0.1983 0.3195 -0.50308 + 53335 0.1975 0.3173 -0.50350 + 53336 0.1967 0.3151 -0.50369 + 53337 0.1958 0.3130 -0.50370 + 53338 0.1949 0.3108 -0.50358 + 53339 0.1940 0.3087 -0.50342 + 53340 0.1931 0.3066 -0.50329 + 53341 0.1921 0.3045 -0.50327 + 53342 0.1911 0.3024 -0.50340 + 53343 0.1901 0.3004 -0.50372 + 53344 0.1890 0.2983 -0.50423 + 53345 0.1880 0.2963 -0.50493 + 53346 0.1869 0.2943 -0.50574 + 53347 0.1858 0.2923 -0.50660 + 53348 0.1846 0.2903 -0.50739 + 53349 0.1835 0.2883 -0.50808 + 53350 0.1823 0.2864 -0.50851 + 53351 0.1811 0.2844 -0.50870 + 53352 0.1799 0.2825 -0.50874 + 53353 0.1786 0.2807 -0.50875 + 53354 0.1773 0.2788 -0.50890 + 53355 0.1760 0.2769 -0.50927 + 53356 0.1747 0.2751 -0.50987 + 53357 0.1734 0.2733 -0.51064 + 53358 0.1720 0.2715 -0.51148 + 53359 0.1707 0.2698 -0.51228 + 53360 0.1693 0.2680 -0.51295 + 53361 0.1679 0.2663 -0.51342 + 53362 0.1664 0.2646 -0.51367 + 53363 0.1650 0.2629 -0.51371 + 53364 0.1635 0.2613 -0.51357 + 53365 0.1620 0.2596 -0.51330 + 53366 0.1605 0.2580 -0.51298 + 53367 0.1590 0.2565 -0.51268 + 53368 0.1575 0.2549 -0.51247 + 53369 0.1559 0.2534 -0.51241 + 53370 0.1543 0.2519 -0.51253 + 53371 0.1528 0.2504 -0.51283 + 53372 0.1511 0.2489 -0.51331 + 53373 0.1495 0.2475 -0.51391 + 53374 0.1479 0.2461 -0.51458 + 53375 0.1463 0.2447 -0.51522 + 53376 0.1446 0.2434 -0.51574 + 53377 0.1429 0.2420 -0.51605 + 53378 0.1412 0.2407 -0.51614 + 53379 0.1395 0.2395 -0.51605 + 53380 0.1378 0.2382 -0.51590 + 53381 0.1361 0.2370 -0.51585 + 53382 0.1344 0.2358 -0.51603 + 53383 0.1326 0.2347 -0.51648 + 53384 0.1308 0.2335 -0.51717 + 53385 0.1291 0.2324 -0.51800 + 53386 0.1273 0.2313 -0.51881 + 53387 0.1255 0.2303 -0.51951 + 53388 0.1237 0.2293 -0.52000 + 53389 0.1219 0.2283 -0.52027 + 53390 0.1200 0.2273 -0.52032 + 53391 0.1182 0.2264 -0.52018 + 53392 0.1164 0.2255 -0.51992 + 53393 0.1145 0.2246 -0.51959 + 53394 0.1126 0.2237 -0.51928 + 53395 0.1108 0.2229 -0.51905 + 53396 0.1089 0.2221 -0.51897 + 53397 0.1070 0.2213 -0.51908 + 53398 0.1051 0.2206 -0.51939 + 53399 0.1032 0.2199 -0.51987 + 53400 0.1013 0.2192 -0.52050 + 53401 0.0994 0.2186 -0.52119 + 53402 0.0975 0.2180 -0.52187 + 53403 0.0956 0.2174 -0.52246 + 53404 0.0936 0.2168 -0.52288 + 53405 0.0917 0.2163 -0.52309 + 53406 0.0898 0.2158 -0.52311 + 53407 0.0878 0.2153 -0.52305 + 53408 0.0859 0.2149 -0.52303 + 53409 0.0840 0.2144 -0.52321 + 53410 0.0820 0.2141 -0.52368 + 53411 0.0801 0.2137 -0.52444 + 53412 0.0781 0.2134 -0.52542 + 53413 0.0761 0.2131 -0.52646 + 53414 0.0742 0.2128 -0.52744 + 53415 0.0722 0.2126 -0.52822 + 53416 0.0703 0.2124 -0.52877 + 53417 0.0683 0.2122 -0.52907 + 53418 0.0663 0.2120 -0.52916 + 53419 0.0644 0.2119 -0.52910 + 53420 0.0624 0.2118 -0.52897 + 53421 0.0605 0.2117 -0.52883 + 53422 0.0585 0.2117 -0.52876 + 53423 0.0566 0.2117 -0.52882 + 53424 0.0546 0.2117 -0.52907 + 53425 0.0526 0.2118 -0.52951 + 53426 0.0507 0.2118 -0.53014 + 53427 0.0487 0.2119 -0.53091 + 53428 0.0468 0.2121 -0.53174 + 53429 0.0449 0.2122 -0.53254 + 53430 0.0429 0.2124 -0.53321 + 53431 0.0410 0.2126 -0.53368 + 53432 0.0391 0.2129 -0.53392 + 53433 0.0372 0.2131 -0.53393 + 53434 0.0352 0.2134 -0.53380 + 53435 0.0333 0.2138 -0.53366 + 53436 0.0314 0.2141 -0.53365 + 53437 0.0296 0.2145 -0.53389 + 53438 0.0277 0.2149 -0.53443 + 53439 0.0258 0.2154 -0.53526 + 53440 0.0239 0.2159 -0.53627 + 53441 0.0221 0.2164 -0.53733 + 53442 0.0202 0.2169 -0.53830 + 53443 0.0184 0.2174 -0.53908 + 53444 0.0166 0.2180 -0.53964 + 53445 0.0147 0.2186 -0.53998 + 53446 0.0129 0.2192 -0.54014 + 53447 0.0111 0.2198 -0.54018 + 53448 0.0093 0.2205 -0.54018 + 53449 0.0076 0.2212 -0.54022 + 53450 0.0058 0.2219 -0.54037 + 53451 0.0040 0.2227 -0.54069 + 53452 0.0023 0.2234 -0.54118 + 53453 0.0005 0.2242 -0.54185 + 53454 -0.0012 0.2250 -0.54266 + 53455 -0.0029 0.2258 -0.54356 + 53456 -0.0046 0.2267 -0.54447 + 53457 -0.0063 0.2276 -0.54530 + 53458 -0.0079 0.2285 -0.54598 + 53459 -0.0096 0.2294 -0.54647 + 53460 -0.0112 0.2303 -0.54675 + 53461 -0.0128 0.2313 -0.54688 + 53462 -0.0144 0.2323 -0.54699 + 53463 -0.0160 0.2333 -0.54724 + 53464 -0.0176 0.2343 -0.54775 + 53465 -0.0191 0.2353 -0.54858 + 53466 -0.0207 0.2364 -0.54970 + 53467 -0.0222 0.2375 -0.55097 + 53468 -0.0237 0.2386 -0.55228 + 53469 -0.0252 0.2397 -0.55354 + 53470 -0.0267 0.2408 -0.55465 + 53471 -0.0281 0.2420 -0.55556 + 53472 -0.0295 0.2431 -0.55626 + 53473 -0.0310 0.2443 -0.55677 + 53474 -0.0323 0.2455 -0.55715 + 53475 -0.0337 0.2468 -0.55748 + 53476 -0.0351 0.2480 -0.55785 + 53477 -0.0364 0.2493 -0.55833 + 53478 -0.0377 0.2505 -0.55899 + 53479 -0.0390 0.2518 -0.55988 + 53480 -0.0403 0.2531 -0.56095 + 53481 -0.0415 0.2545 -0.56216 + 53482 -0.0427 0.2558 -0.56347 + 53483 -0.0439 0.2572 -0.56478 + 53484 -0.0451 0.2585 -0.56599 + 53485 -0.0463 0.2599 -0.56699 + 53486 -0.0474 0.2613 -0.56769 + 53487 -0.0485 0.2627 -0.56808 + 53488 -0.0496 0.2641 -0.56824 + 53489 -0.0507 0.2656 -0.56830 + 53490 -0.0517 0.2670 -0.56839 + 53491 -0.0527 0.2685 -0.56860 + 53492 -0.0537 0.2700 -0.56897 + 53493 -0.0547 0.2714 -0.56955 + 53494 -0.0556 0.2729 -0.57032 + 53495 -0.0565 0.2744 -0.57119 + 53496 -0.0574 0.2760 -0.57204 + 53497 -0.0583 0.2775 -0.57277 + 53498 -0.0591 0.2790 -0.57329 + 53499 -0.0600 0.2806 -0.57354 + 53500 -0.0607 0.2821 -0.57350 + 53501 -0.0615 0.2837 -0.57328 + 53502 -0.0622 0.2853 -0.57298 + 53503 -0.0630 0.2869 -0.57261 + 53504 -0.0636 0.2885 -0.57218 + 53505 -0.0643 0.2901 -0.57175 + 53506 -0.0649 0.2917 -0.57143 + 53507 -0.0655 0.2933 -0.57124 + 53508 -0.0661 0.2949 -0.57117 + 53509 -0.0667 0.2966 -0.57124 + 53510 -0.0672 0.2982 -0.57139 + 53511 -0.0677 0.2999 -0.57158 + 53512 -0.0682 0.3015 -0.57166 + 53513 -0.0686 0.3032 -0.57155 + 53514 -0.0690 0.3048 -0.57116 + 53515 -0.0694 0.3065 -0.57057 + 53516 -0.0698 0.3082 -0.56989 + 53517 -0.0701 0.3098 -0.56921 + 53518 -0.0704 0.3115 -0.56860 + 53519 -0.0707 0.3132 -0.56818 + 53520 -0.0710 0.3149 -0.56799 + 53521 -0.0712 0.3166 -0.56800 + 53522 -0.0714 0.3183 -0.56809 + 53523 -0.0716 0.3200 -0.56815 + 53524 -0.0717 0.3217 -0.56808 + 53525 -0.0718 0.3234 -0.56781 + 53526 -0.0719 0.3251 -0.56728 + 53527 -0.0720 0.3268 -0.56651 + 53528 -0.0720 0.3285 -0.56557 + 53529 -0.0720 0.3302 -0.56454 + 53530 -0.0720 0.3319 -0.56347 + 53531 -0.0720 0.3336 -0.56244 + 53532 -0.0719 0.3353 -0.56148 + 53533 -0.0718 0.3370 -0.56060 + 53534 -0.0717 0.3387 -0.55990 + 53535 -0.0715 0.3404 -0.55943 + 53536 -0.0713 0.3421 -0.55916 + 53537 -0.0711 0.3438 -0.55897 + 53538 -0.0709 0.3455 -0.55881 + 53539 -0.0707 0.3472 -0.55859 + 53540 -0.0704 0.3489 -0.55820 + 53541 -0.0701 0.3506 -0.55751 + 53542 -0.0697 0.3523 -0.55650 + 53543 -0.0694 0.3540 -0.55529 + 53544 -0.0690 0.3557 -0.55402 + 53545 -0.0686 0.3573 -0.55279 + 53546 -0.0682 0.3590 -0.55173 + 53547 -0.0677 0.3607 -0.55093 + 53548 -0.0673 0.3623 -0.55037 + 53549 -0.0668 0.3640 -0.54994 + 53550 -0.0662 0.3656 -0.54947 + 53551 -0.0657 0.3673 -0.54884 + 53552 -0.0651 0.3689 -0.54798 + 53553 -0.0645 0.3705 -0.54689 + 53554 -0.0639 0.3721 -0.54560 + 53555 -0.0633 0.3738 -0.54414 + 53556 -0.0626 0.3754 -0.54257 + 53557 -0.0620 0.3770 -0.54101 + 53558 -0.0613 0.3786 -0.53952 + 53559 -0.0605 0.3801 -0.53819 + 53560 -0.0598 0.3817 -0.53705 + 53561 -0.0590 0.3833 -0.53611 + 53562 -0.0583 0.3848 -0.53535 + 53563 -0.0575 0.3864 -0.53475 + 53564 -0.0566 0.3879 -0.53425 + 53565 -0.0558 0.3895 -0.53374 + 53566 -0.0549 0.3910 -0.53315 + 53567 -0.0541 0.3925 -0.53243 + 53568 -0.0532 0.3940 -0.53152 + 53569 -0.0523 0.3955 -0.53042 + 53570 -0.0513 0.3969 -0.52913 + 53571 -0.0504 0.3984 -0.52776 + 53572 -0.0494 0.3998 -0.52644 + 53573 -0.0485 0.4013 -0.52532 + 53574 -0.0475 0.4027 -0.52451 + 53575 -0.0464 0.4041 -0.52400 + 53576 -0.0454 0.4055 -0.52377 + 53577 -0.0444 0.4069 -0.52366 + 53578 -0.0433 0.4083 -0.52344 + 53579 -0.0423 0.4096 -0.52299 + 53580 -0.0412 0.4110 -0.52228 + 53581 -0.0401 0.4123 -0.52130 + 53582 -0.0390 0.4136 -0.52010 + 53583 -0.0378 0.4149 -0.51872 + 53584 -0.0367 0.4162 -0.51725 + 53585 -0.0356 0.4175 -0.51578 + 53586 -0.0344 0.4188 -0.51436 + 53587 -0.0332 0.4200 -0.51310 + 53588 -0.0320 0.4212 -0.51204 + 53589 -0.0309 0.4224 -0.51120 + 53590 -0.0297 0.4236 -0.51055 + 53591 -0.0284 0.4248 -0.51006 + 53592 -0.0272 0.4260 -0.50966 + 53593 -0.0260 0.4271 -0.50922 + 53594 -0.0247 0.4283 -0.50872 + 53595 -0.0235 0.4294 -0.50809 + 53596 -0.0222 0.4305 -0.50729 + 53597 -0.0210 0.4315 -0.50638 + 53598 -0.0197 0.4326 -0.50535 + 53599 -0.0184 0.4336 -0.50431 + 53600 -0.0171 0.4347 -0.50339 + 53601 -0.0158 0.4357 -0.50273 + 53602 -0.0145 0.4367 -0.50244 + 53603 -0.0132 0.4376 -0.50247 + 53604 -0.0119 0.4386 -0.50267 + 53605 -0.0106 0.4395 -0.50286 + 53606 -0.0093 0.4404 -0.50287 + 53607 -0.0079 0.4413 -0.50263 + 53608 -0.0066 0.4422 -0.50217 Index: /trunk/psLib/test/astro/tst_psCoord.c =================================================================== --- /trunk/psLib/test/astro/tst_psCoord.c (revision 4547) +++ /trunk/psLib/test/astro/tst_psCoord.c (revision 4547) @@ -0,0 +1,1351 @@ +/** @file tst_psCoord.c +* +* @brief The code will ... +* +* +* @author GLG, MHPCC +* +* @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ +* @date $Date: 2005-07-13 02:46:58 $ +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ + +#include "psTest.h" +#include "pslib_strict.h" +static psS32 testSphereRotAlloc(void); +static psS32 testPlaneTransformAlloc(void); +static psS32 testPlaneDistortAlloc(void); +static psS32 testPlaneTransformApply(void); +static psS32 testPlaneDistortApply(void); +static psS32 testSphereRotApply1(void); +static psS32 testSphereRotApply2(void); +static psS32 testSphereRotApply3(void); +static psS32 testSphereRotApply4(void); +static psS32 testSphereRotApply5(void); +static psS32 testSphereRotICRSToEcliptic(void); +static psS32 testSphereRotEclipticToICRS(void); +static psS32 testSphereRotICRSToGalactic(void); +static psS32 testSphereRotGalacticToICRS(void); +static psS32 testSphereRotPrecess(void); +testDescription tests[] = { + {testSphereRotAlloc, 819, "psSphereRotAlloc()", 0, false}, + {testPlaneTransformAlloc, 826, "psPlaneTransformAlloc()", 0, false}, + {testPlaneDistortAlloc, 827, "psPlaneDistortAlloc()", 0, false}, + {testPlaneTransformApply, 831, "psPlaneTransformApply()", 0, false}, + {testPlaneDistortApply, 832, "psPlaneDistortApply()", 0, false}, + {testSphereRotApply1, 820, "psSphereRotApply()", 0, false}, + {testSphereRotApply2, 820, "psSphereRotApply()", 0, false}, + {testSphereRotApply3, 820, "psSphereRotApply()", 0, false}, + {testSphereRotApply4, 820, "psSphereRotApply()", 0, false}, + {testSphereRotApply5, 820, "psSphereRotApply()", 0, false}, + {testSphereRotICRSToEcliptic, 821, "psSphereRotICRSToEcliptic()", 0, false}, + {testSphereRotEclipticToICRS, 822, "psSphereRotEclipticToICRS()", 0, false}, + {testSphereRotICRSToGalactic, 824, "psSphereRotICRSToGalactic()", 0, false}, + {testSphereRotGalacticToICRS, 823, "psSphereRotGalacticToICRS()", 0, false}, + {testSphereRotPrecess, 825, "psSphereRotPrecess()", 0, false}, + {NULL} + }; + +psS32 main( psS32 argc, char* argv[] ) +{ + psLogSetLevel( PS_LOG_INFO ); + + return ( ! runTestSuite( stderr, "psCoord", tests, argc, argv ) ); +} + +#define DEG_INC 30.0 + +#define MJD_1900 15021.0 // Modified Julian Day 1/1/1900 00:00:00 +#define MJD_2000 51544.0 // Modified Julian Day 1/1/2000 00:00:00 +#define MJD_2100 88069.0 // Modified Julian Day 1/1/2100 00:00:00 + +#define ERROR_TOL 0.0001 + +#define ALPHA_P 1.0 +#define DELTA_P 2.0 +#define PHI_P 3.0 + +psS32 testSphereRotAlloc( void ) +{ + // Allocate data structure + psSphereRot* myST = psSphereRotAlloc(ALPHA_P, DELTA_P, PHI_P); + + // Verify null not returned + if(myST == NULL) { + psError(PS_ERR_UNKNOWN,true,"Returned NULL with valid parameters"); + return 1; + } + // Verify sin member is updated + double vx = cos(DELTA_P)*cos(ALPHA_P); + double vy = cos(DELTA_P)*sin(ALPHA_P); + double vz = sin(DELTA_P); + double q0 = vx * sin(PHI_P/2.0); + double q1 = vy * sin(PHI_P/2.0); + double q2 = vz * sin(PHI_P/2.0); + double q3 = cos(PHI_P/2.0); + + if (FLT_EPSILON < fabs(q0 - myST->q0)) { + psError(PS_ERR_UNKNOWN,true,"myST->q0 is %f, should be %f\n", myST->q0, q0); + return 2; + } + if (FLT_EPSILON < fabs(q1 - myST->q1)) { + psError(PS_ERR_UNKNOWN,true,"myST->q1 is %f, should be %f\n", myST->q1, q1); + return 3; + } + if (FLT_EPSILON < fabs(q2 - myST->q2)) { + psError(PS_ERR_UNKNOWN,true,"myST->q2 is %f, should be %f\n", myST->q2, q2); + return 4; + } + if (FLT_EPSILON < fabs(q3 - myST->q3)) { + psError(PS_ERR_UNKNOWN,true,"myST->q0 is %f, should be %f\n", myST->q3, q3); + return 5; + } + + // Free data structure + psFree(myST); + + return 0; +} + +#define NX_TERMS 2 +#define NY_TERMS 3 +#define NZ_TERMS 4 +#define NT_TERMS 5 + +psS32 testPlaneTransformAlloc( void ) +{ + // Allocate psPlaneTransform with known x and y terms + psPlaneTransform *myPT = psPlaneTransformAlloc(NX_TERMS, NY_TERMS); + + // Verify returned value is not NULL + if(myPT == NULL) { + psError(PS_ERR_UNKNOWN,true,"Function returned NULL not expected."); + return 1; + } + + // Verify returned transform has members set properly + if (myPT->x->nX != NX_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPT->x->nX is %d, should be %d", + myPT->x->nX, NX_TERMS); + return 2; + } + if (myPT->y->nX != NX_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPT->y->nX is %d, should be %d", + myPT->y->nX, NX_TERMS); + return 3; + } + if (myPT->x->nY != NY_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPT->x->nY is %d, should be %d", + myPT->x->nY, NY_TERMS); + return 4; + } + if (myPT->y->nY != NY_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPT->y->nY is %d, should be %d", + myPT->y->nY, NY_TERMS); + return 5; + } + + // Free plane transform + psFree(myPT); + + // Attempt to specify negative x terms and verify NULL returned and errror message generated + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message: negative x terms"); + myPT = psPlaneTransformAlloc(-1.0, 1.0); + if (myPT != NULL) { + psError(PS_ERR_UNKNOWN,true,"psPlaneTransformAlloc() did not return NULL."); + return 6; + } + + // Attempt to specify negative y terms and verify NULL returned and error message generated + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message: negative y terms"); + myPT = psPlaneTransformAlloc(1.0, -1.0); + if (myPT != NULL) { + psError(PS_ERR_UNKNOWN,true,"psPlaneTransformAlloc() did not return NULL."); + return 7; + } + + psFree(myPT); + + return 0; +} + + +psS32 testPlaneDistortAlloc( void ) +{ + // Invoke function with known parameters + psPlaneDistort *myPD = psPlaneDistortAlloc(NX_TERMS, NY_TERMS, NZ_TERMS, NT_TERMS); + + // Verify NULL is not returned + if(myPD == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return of NULL not expected"); + return 1; + } + // Verify the terms are properly set after allocation + if (myPD->x->nX != NX_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPD->x->nX is %d, should be %d", + myPD->x->nX, NX_TERMS); + return 2; + } + if (myPD->y->nX != NX_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPD->y->nX is %d, should be %d", + myPD->y->nX, NX_TERMS); + return 3; + } + if (myPD->x->nY != NY_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPD->x->nY is %d, should be %d", + myPD->x->nY, NY_TERMS); + return 4; + } + if (myPD->y->nY != NY_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPD->y->nY is %d, should be %d", + myPD->y->nY, NY_TERMS); + return 5; + } + if (myPD->x->nZ != NZ_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPD->x->nZ is %d, should be %d", + myPD->x->nZ, NZ_TERMS); + return 6; + } + if (myPD->y->nZ != NZ_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPD->y->nZ is %d, should be %d", + myPD->y->nZ, NZ_TERMS); + return 7; + } + if (myPD->x->nT != NT_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPD->x->nT is %d, should be %d", + myPD->x->nT, NT_TERMS); + return 8; + } + if (myPD->y->nT != NT_TERMS) { + psError(PS_ERR_UNKNOWN,true,"myPD->y->nT is %d, should be %d", + myPD->y->nT, NT_TERMS); + return 9; + } + // Free psPlaneTransform + psFree(myPD); + + // Invoke function with negative x term parameter + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for negative x term"); + myPD = psPlaneDistortAlloc(-1.0, 1.0, 1.0, 1.0); + if (myPD != NULL) { + psError(PS_ERR_UNKNOWN,true,"psPlaneDistortAlloc() did not return NULL."); + return 10; + } + + // Invoke function with negative y term parameter + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for negative y term"); + myPD = psPlaneDistortAlloc(1.0, -1.0, 1.0, 1.0); + if (myPD != NULL) { + psError(PS_ERR_UNKNOWN,true,"psPlaneDistortAlloc() did not return NULL."); + return 11; + } + + // Invoke function with negative z term parameter + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for negative z term"); + myPD = psPlaneDistortAlloc(1.0, 1.0, -1.0, 1.0); + if (myPD != NULL) { + psError(PS_ERR_UNKNOWN,true,"psPlaneDistortAlloc() did not return NULL."); + return 12; + } + + // Invoke function with negative w term parameter + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for negative w term"); + myPD = psPlaneDistortAlloc(1.0, 1.0, 1.0, -1.0); + if (myPD != NULL) { + psError(PS_ERR_UNKNOWN,true,"psPlaneDistortAlloc() did not return NULL."); + } + + return 0; +} + +#define N 10 +// We do a simple identity transformation on a few x,y pairs. +psS32 testPlaneTransformApply( void ) +{ + psPlane* out = NULL; + psDPolynomial2D* tmp2DPoly = NULL; + psPlane* rc; + + // Create input coordinate + psPlane* in = psPlaneAlloc(); + if(in == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not expect NULL return from psPlaneAlloc"); + return 1; + } + + // Create transform + psPlaneTransform* pt = psPlaneTransformAlloc(2,2); + + // Set transform coefficients so the x coord input will equal x coord output, same for y + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + + // Apply transform for several points + for (psS32 i = 0; i < N; i++) { + in->x = (psF64) i; + in->y = (psF64) (i + 5.0); + in->xErr = 0.0; + in->yErr = 0.0; + + // Verify function does not return NULL + out = psPlaneTransformApply(out, pt, in); + if( out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Expected non-NULL return value"); + return 1; + } + // Verify the expected values are returned + if (FLT_EPSILON < fabs(out->x - in->x)) { + psError(PS_ERR_UNKNOWN,true,"out.x is %lf, should be %lf", out->x, in->x); + return 3; + } + if (FLT_EPSILON < fabs(out->y - in->y)) { + psError(PS_ERR_UNKNOWN,true,"out.y is %lf, should be %lf", out->y, in->y); + return 4; + } + } + psFree(out); + + // Verify return null and error message generater for null specified transform + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL psPlaneTransform"); + rc = psPlaneTransformApply(NULL, NULL, in); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"Function did not return NULL as expected for NULL psPlaneTransform."); + return 5; + } + + // Verify return null and error message generated for null psPlaneTransform x coeff + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL x coeff psPlaneTransform"); + tmp2DPoly = pt->x; + pt->x = NULL; + rc = psPlaneTransformApply(NULL, pt, in); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"Function did not return NULL as expected for NULL x coeff psPlaneTransform"); + return 6; + } + pt->x = tmp2DPoly; + + // Verify return null and error message generated for null psPlaneTransform y coeff + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL y coeff psPlaneTransform"); + tmp2DPoly = pt->y; + pt->y = NULL; + rc = psPlaneTransformApply(NULL, pt, in); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"Function did not return NULL as expected for NULL y coeff psPlaneTransform"); + return 7; + } + pt->y = tmp2DPoly; + + // Verify return null and error message generated for null psPlane coordinate + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL psPlane"); + rc = psPlaneTransformApply(NULL, pt, NULL); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"Function did not return NULL as expected for NULL psPlane"); + return 8; + } + + psFree(pt); + psFree(in); + + return 0; +} + +#define COLOR 1.0 +#define MAGNITUDE 1.0 +// We do a simple identity transformation on a few x,y pairs. For x and y, +// we add in the COLOR and MAGNITUDE. +psS32 testPlaneDistortApply( void ) +{ + psPlane* out = NULL; + psPlane* rc = NULL; + psDPolynomial4D* tmp4DPoly = NULL; + + // Allocate input coordinate + psPlane* in = psPlaneAlloc(); + + // Create psPlaneTransform structure + psPlaneDistort* pt = psPlaneDistortAlloc(2, 2, 2, 2); + + pt->x->coeff[1][0][0][0] = 1.0; + pt->x->coeff[0][0][1][0] = 1.0; + pt->x->coeff[0][0][0][1] = 1.0; + + pt->y->coeff[0][1][0][0] = 1.0; + pt->y->coeff[0][0][1][0] = 1.0; + pt->y->coeff[0][0][0][1] = 1.0; + + for (psS32 i = 0; i < N; i++) { + in->x = (psF64) i; + in->y = (psF64) (i + 5.0); + in->xErr = 0.0; + in->yErr = 0.0; + out = psPlaneDistortApply(out, pt, in, COLOR, MAGNITUDE); + + // Verify return value is not NULL + if(out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Expected non-NULL return"); + return 1; + } + // Verify return value contains expected values + if (FLT_EPSILON < fabs(out->x - COLOR - MAGNITUDE - in->x)) { + psError(PS_ERR_UNKNOWN,true,"out->x is %lf, should be %lf", + out->x, in->x + COLOR + MAGNITUDE); + return 2; + } + if (FLT_EPSILON < fabs(out->y - COLOR - MAGNITUDE - in->y)) { + psError(PS_ERR_UNKNOWN,true,"out->y is %lf, should be %lf", + out->y, in->y + COLOR + MAGNITUDE); + return 3; + } + } + psFree(out); + + // Attempt to invoke psPlaneDistortApply with NULL psPlaneDistort + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null psPlaneDistort"); + rc = psPlaneDistortApply(NULL, NULL, in, COLOR, MAGNITUDE); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL."); + return 4; + } + + // Attempt to invoke psPlaneDistortApply with NULL psPlaneDistort x member + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null x member psPlaneDistort"); + tmp4DPoly = pt->x; + pt->x = NULL; + rc = psPlaneDistortApply(NULL, pt, in, COLOR, MAGNITUDE); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL."); + return 5; + } + pt->x = tmp4DPoly; + + // Attempt to invoke psPlaneDistortApply with NULL psPlaneDistort y member + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null y member psPlaneDistort"); + tmp4DPoly = pt->y; + pt->y = NULL; + rc = psPlaneDistortApply(NULL, pt, in, COLOR, MAGNITUDE); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL."); + return 6; + } + pt->y = tmp4DPoly; + + // Attempt to invoke psPlaneDistortApply with NULL input psPlane + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null input psPlane"); + rc = psPlaneDistortApply(NULL, pt, NULL, COLOR, MAGNITUDE); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL"); + return 7; + } + + psFree(pt); + psFree(in); + + return 0; +} + +// We do a simple identity transformation on a few RA, DEC pairs. +psS32 testSphereRotApply1( void ) +{ + psSphere *in = psSphereAlloc(); + psSphere *out = psSphereAlloc(); + psSphere *temp = NULL; + psSphere *rc = NULL; + psSphereRot *myST = psSphereRotAlloc(0.0, 0.0, 0.0); + + for (float r=0.0;r<180.0;r+=DEG_INC) { + for (float d=0.0;d<90.0;d+=DEG_INC) { + in->r = DEG_TO_RAD(r); + in->d = DEG_TO_RAD(d); + in->rErr = 0.0; + in->dErr = 0.0; + + if(psSphereRotApply(out, myST, in) != out) { + psError(PS_ERR_UNKNOWN,true,"Did not return output pointer."); + return 1; + } + if (ERROR_TOL < fabs(out->r - in->r)) { + psError(PS_ERR_UNKNOWN,true,"out->r is %f, should be %f\n", out->r, in->r); + return 2; + } + if (ERROR_TOL < fabs(out->d - in->d)) { + psError(PS_ERR_UNKNOWN,true,"out->d is %f, should be %f\n", out->d, in->d); + return 3; + } + } + } + + // Verify new sphere object is created if out parameter NULL + temp = psSphereRotApply(NULL, myST, in); + if ( temp == NULL) { + psError(PS_ERR_UNKNOWN,true,"Returned NULL when out parameter was null"); + return 4; + } + psFree(temp); + + // Verify NULL returned if transform structure null + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error"); + rc = psSphereRotApply(NULL, NULL, in); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply() did not return NULL."); + return 5; + } + + // Verify NULL returned when input sphere is NULL + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error"); + rc = psSphereRotApply(NULL, myST, NULL); + if (rc != NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply() did not return NULL"); + return 6; + } + + psFree(myST); + psFree(out); + psFree(in); + + return 0; +} + +/****************************************************************************** +testSphereRotApply2(): This test verifies that psSphereRotApply() +works properly. We create two psSphereRots: a forward transform and a +reverse transform (which is the mathematical inverse of the forward transform). +We apply both transforms to several spherical coordinates and ensure that the +original input coordinate is obtained after applying both transforms. + +XXX: We currently test the alpha and delta offsets independently. Attempts to +test them both concurrently failed. Determine why this is. Are the following +spherical transforms not mathematical inverses? + psSphereRotAlloc(X, Y, 0.0) + psSphereRotAlloc(-X, -Y, 0.0) + *****************************************************************************/ +#define ERROR_PERCENT 0.01 +psS32 testSphereRotApply2( void ) +{ + psS32 testStatus = 0; + psSphere in; + psSphere out; + psSphere out2; + psSphereRot *mySphereRotForward = NULL; + psSphereRot *mySphereRotReverse = NULL; + + + mySphereRotForward = psSphereRotAlloc(DEG_TO_RAD(22.0), + 0.0, + 0.0); + mySphereRotReverse = psSphereRotAlloc(DEG_TO_RAD(-22.0), + 0.0, + 0.0); + + for (float r=0.1;r<180.0;r+=(DEG_INC/5.0)) { + for (float d=0.1;d<90.0;d+=(DEG_INC/5.0)) { + in.r = DEG_TO_RAD(r); + in.d = DEG_TO_RAD(d); + in.rErr = 0.0; + in.dErr = 0.0; + + psSphereRotApply(&out, mySphereRotForward, &in); + psSphereRotApply(&out2, mySphereRotReverse, &out); + + if ((fabs((in.r - out2.r) / in.r) > ERROR_PERCENT) || + (fabs((in.d - out2.d) / in.d) > ERROR_PERCENT)) { + printf("ERROR: \n"); + printf("Input coords (R, D) are (%f, %f)\n", in.r, in.d); + printf("Output coords (R, D) are (%f, %f)\n", out2.r, out2.d); + testStatus = 4; + } + } + } + psFree(mySphereRotForward); + psFree(mySphereRotReverse); + + mySphereRotForward = psSphereRotAlloc(0.0, + DEG_TO_RAD(33.0), + 0.0); + mySphereRotReverse = psSphereRotAlloc(0.0, + DEG_TO_RAD(-33.0), + 0.0); + for (float r=0.1;r<180.0;r+=(DEG_INC/5.0)) { + for (float d=0.1;d<90.0;d+=(DEG_INC/5.0)) { + in.r = DEG_TO_RAD(r); + in.d = DEG_TO_RAD(d); + in.rErr = 0.0; + in.dErr = 0.0; + + psSphereRotApply(&out, mySphereRotForward, &in); + psSphereRotApply(&out2, mySphereRotReverse, &out); + + if ((fabs((in.r - out2.r) / in.r) > ERROR_PERCENT) || + (fabs((in.d - out2.d) / in.d) > ERROR_PERCENT)) { + printf("ERROR: \n"); + printf("Input coords (R, D) are (%f, %f)\n", in.r, in.d); + printf("Output coords (R, D) are (%f, %f)\n", out2.r, out2.d); + testStatus = 4; + } + } + } + psFree(mySphereRotForward); + psFree(mySphereRotReverse); + + return(testStatus); +} + +// Test point 1 ADD ICRS(0,0) to Galactic (96.337272,-60.188553) +// to Ecliptic (0,0) with T=1 +#define SPHERE_COORD_TP1_GAL_R 1.681409 // 96.337272 degrees +#define SPHERE_COORD_TP1_GAL_D -1.050488 // -60.188553 degrees +#define SPHERE_COORD_TP1_ECL_R 0.0 +#define SPHERE_COORD_TP1_ECL_D 0.0 +#define SPHERE_COORD_TP1_INVERSE_R 0.0 +#define SPHERE_COORD_TP1_INVERSE_D 0.0 + +// Test point 2 ADD ICRS(0,90) to Galactic (122.93192, 27.12825) +// to Ecliptic (90,66.560719) with T=1 +#define SPHERE_COORD_TP2_GAL_R 2.145567 // 122.93192 degrees +#define SPHERE_COORD_TP2_GAL_D 0.473477 // 27.12825 degrees +#define SPHERE_COORD_TP2_ECL_R 1.570796 // 90 degrees +#define SPHERE_COORD_TP2_ECL_D 1.161704 // 66.560719 degrees +#define SPHERE_COORD_TP2_INVERSE_R 0.0 // 0 degrees +#define SPHERE_COORD_TP2_INVERSE_D 1.570796 // 90 degrees + +// Test point 3 ADD ICRS(180,30) to Galactic (195.639488, 78.353806) +// to Ecliptic (167.072470, 27.308813) with T=2 +#define SPHERE_COORD_TP3_GAL_R 3.414553 // 195.639488 degrees +#define SPHERE_COORD_TP3_GAL_D 1.367532 // 78.353806 degrees +#define SPHERE_COORD_TP3_ECL_R 2.915965 // 167.07247 degrees +#define SPHERE_COORD_TP3_ECL_D 0.476629 // 27.308813 degrees +#define SPHERE_COORD_TP3_INVERSE_R 3.141593 // 180.0 degrees +#define SPHERE_COORD_TP3_INVERSE_D 0.523599 // 30.0 degrees + +psS32 testSphereRotApply3( void) +{ + + psSphereRot* testTransform; + psSphere* inputCoord = psSphereAlloc(); + psSphere* outputCoord = NULL; + psSphere* inverseOutputCoord = NULL; + + inputCoord->r = SPHERE_COORD_TP1_INVERSE_R; + inputCoord->d = SPHERE_COORD_TP1_INVERSE_D; + inputCoord->rErr = 0.0; + inputCoord->dErr = 0.0; + + // Set test date time to 1/1/2000 00:00:00 + psTime* testDateTime = psTimeFromMJD(MJD_2000); + + // Create transform ICRS to Galactic + testTransform = psSphereRotICRSToGalactic(); + + // Perform transform from ICRS to Galactic + outputCoord = psSphereRotApply(outputCoord,testTransform,inputCoord); + // Verify output not NULL and member values set correctly + if(outputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 1; + } + if(fabs(outputCoord->r - SPHERE_COORD_TP1_GAL_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + outputCoord->r, SPHERE_COORD_TP1_GAL_R); + return 2; + } + if(fabs(outputCoord->d - SPHERE_COORD_TP1_GAL_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + outputCoord->d, SPHERE_COORD_TP1_GAL_D); + return 3; + } + psFree(testTransform); + + // Create inverse transform Galactic to ICRS + testTransform = psSphereRotGalacticToICRS(); + + // Perform transform from Galactic to ICRS + inverseOutputCoord = psSphereRotApply(inverseOutputCoord,testTransform,outputCoord); + // Verify output not NULL and member values set correctly + if(inverseOutputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 4; + } + + if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP1_INVERSE_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + inverseOutputCoord->r, SPHERE_COORD_TP1_INVERSE_R); + return 5; + } + if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP1_INVERSE_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + inverseOutputCoord->d, SPHERE_COORD_TP1_INVERSE_D); + return 6; + } + psFree(testTransform); + + // Create transform ICRS to Ecliptic + testTransform = psSphereRotICRSToEcliptic(testDateTime); + + // Perform transform from ICRS to Ecliptic + outputCoord = psSphereRotApply(outputCoord,testTransform,inputCoord); + // Verify output not NULL and member values set correctly + if(outputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 7; + } + if(fabs(outputCoord->r - SPHERE_COORD_TP1_ECL_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + outputCoord->r, SPHERE_COORD_TP1_ECL_R); + return 8; + } + if(fabs(outputCoord->d - SPHERE_COORD_TP1_ECL_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + outputCoord->d, SPHERE_COORD_TP1_ECL_D); + return 9; + } + psFree(testTransform); + + // Create inverse transform Ecliptic to ICRS + testTransform = psSphereRotEclipticToICRS(testDateTime); + + // Perform transform from Ecliptic to ICRS + inverseOutputCoord = psSphereRotApply(inverseOutputCoord,testTransform,outputCoord); + // Verify output not NULL and member values set correctly + if(inverseOutputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 10; + } + if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP1_INVERSE_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + inverseOutputCoord->r, SPHERE_COORD_TP1_INVERSE_R); + return 11; + } + if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP1_INVERSE_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + inverseOutputCoord->d, SPHERE_COORD_TP1_INVERSE_D); + return 12; + } + psFree(testTransform); + + psFree(testDateTime); + psFree(outputCoord); + psFree(inputCoord); + psFree(inverseOutputCoord); + + return 0; +} + +psS32 testSphereRotApply4( void) +{ + + psSphereRot* testTransform; + psSphere* inputCoord = psSphereAlloc(); + psSphere* outputCoord = NULL; + psSphere* inverseOutputCoord = NULL; + + inputCoord->r = SPHERE_COORD_TP2_INVERSE_R; + inputCoord->d = SPHERE_COORD_TP2_INVERSE_D; + inputCoord->rErr = 0.0; + inputCoord->dErr = 0.0; + + // Set test date time to 1/1/2000 00:00:00 + psTime* testDateTime = psTimeFromMJD(MJD_2000); + + // Create transform ICRS to Galactic + testTransform = psSphereRotICRSToGalactic(); + + // Perform transform from ICRS to Galactic + outputCoord = psSphereRotApply(outputCoord,testTransform,inputCoord); + // Verify output not NULL and member values set correctly + if(outputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 1; + } + if(fabs(outputCoord->r - SPHERE_COORD_TP2_GAL_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + outputCoord->r, SPHERE_COORD_TP2_GAL_R); + return 2; + } + if(fabs(outputCoord->d - SPHERE_COORD_TP2_GAL_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + outputCoord->d, SPHERE_COORD_TP2_GAL_D); + return 3; + } + psFree(testTransform); + + // Create inverse transform Galactic to ICRS + testTransform = psSphereRotGalacticToICRS(); + + // Perform transform from Galactic to ICRS + inverseOutputCoord = psSphereRotApply(inverseOutputCoord,testTransform,outputCoord); + // Verify output not NULL and member values set correctly + if(inverseOutputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 4; + } + // atan2 function introduces some error with y close to zero, increased error tolerance + if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP2_INVERSE_R) > ERROR_TOL+0.1) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + inverseOutputCoord->r, SPHERE_COORD_TP2_INVERSE_R); + return 5; + } + if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP2_INVERSE_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + inverseOutputCoord->d, SPHERE_COORD_TP2_INVERSE_D); + return 6; + } + psFree(testTransform); + + // Create transform ICRS to Ecliptic + testTransform = psSphereRotICRSToEcliptic(testDateTime); + + // Perform transform from ICRS to Ecliptic + outputCoord = psSphereRotApply(outputCoord,testTransform,inputCoord); + // Verify output not NULL and member values set correctly + if(outputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 7; + } + if(fabs(outputCoord->r - SPHERE_COORD_TP2_ECL_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + outputCoord->r, SPHERE_COORD_TP2_ECL_R); + return 8; + } + if(fabs(outputCoord->d - SPHERE_COORD_TP2_ECL_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + outputCoord->d, SPHERE_COORD_TP2_ECL_D); + return 9; + } + psFree(testTransform); + + // Create inverse transform Ecliptic to ICRS + testTransform = psSphereRotEclipticToICRS(testDateTime); + + // Perform transform from Ecliptic to ICRS + inverseOutputCoord = psSphereRotApply(inverseOutputCoord,testTransform,outputCoord); + // Verify output not NULL and member values set correctly + if(inverseOutputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 10; + } + if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP2_INVERSE_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + inverseOutputCoord->r, SPHERE_COORD_TP2_INVERSE_R); + return 11; + } + if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP2_INVERSE_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + inverseOutputCoord->d, SPHERE_COORD_TP2_INVERSE_D); + return 12; + } + psFree(testTransform); + + psFree(testDateTime); + psFree(outputCoord); + psFree(inputCoord); + psFree(inverseOutputCoord); + + return 0; +} + +psS32 testSphereRotApply5( void) +{ + psSphereRot* testTransform; + psSphere* inputCoord = psSphereAlloc(); + psSphere* outputCoord = NULL; + psSphere* inverseOutputCoord = NULL; + + inputCoord->r = SPHERE_COORD_TP3_INVERSE_R; + inputCoord->d = SPHERE_COORD_TP3_INVERSE_D; + inputCoord->rErr = 0.0; + inputCoord->dErr = 0.0; + + // Set test date time to 1/1/2100 00:00:00 + psTime* testDateTime = psTimeFromMJD(MJD_2100); + + // Create transform ICRS to Galactic + testTransform = psSphereRotICRSToGalactic(); + + // Perform transform from ICRS to Galactic + outputCoord = psSphereRotApply(outputCoord,testTransform,inputCoord); + // Verify output not NULL and member values set correctly + if(outputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 1; + } + if(fabs(outputCoord->r - SPHERE_COORD_TP3_GAL_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + outputCoord->r, SPHERE_COORD_TP3_GAL_R); + return 2; + } + if(fabs(outputCoord->d - SPHERE_COORD_TP3_GAL_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + outputCoord->d, SPHERE_COORD_TP3_GAL_D); + return 3; + } + psFree(testTransform); + + // Create inverse transform Galactic to ICRS + testTransform = psSphereRotGalacticToICRS(); + + // Perform transform from Galactic to ICRS + inverseOutputCoord = psSphereRotApply(inverseOutputCoord,testTransform,outputCoord); + // Verify output not NULL and member values set correctly + if(inverseOutputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 4; + } + if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP3_INVERSE_R) > ERROR_TOL+0.1) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + inverseOutputCoord->r, SPHERE_COORD_TP3_INVERSE_R); + return 5; + } + if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP3_INVERSE_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + inverseOutputCoord->d, SPHERE_COORD_TP3_INVERSE_D); + return 6; + } + psFree(testTransform); + + // Create transform ICRS to Ecliptic + testTransform = psSphereRotICRSToEcliptic(testDateTime); + + // Perform transform from ICRS to Ecliptic + outputCoord = psSphereRotApply(outputCoord,testTransform,inputCoord); + // Verify output not NULL and member values set correctly + if(outputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 7; + } + if(fabs(outputCoord->r - SPHERE_COORD_TP3_ECL_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + outputCoord->r, SPHERE_COORD_TP3_ECL_R); + return 8; + } + if(fabs(outputCoord->d - SPHERE_COORD_TP3_ECL_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + outputCoord->d, SPHERE_COORD_TP3_ECL_D); + return 9; + } + psFree(testTransform); + + // Create inverse transform Ecliptic to ICRS + testTransform = psSphereRotEclipticToICRS(testDateTime); + + // Perform transform from Ecliptic to ICRS + inverseOutputCoord = psSphereRotApply(inverseOutputCoord,testTransform,outputCoord); + // Verify output not NULL and member values set correctly + if(inverseOutputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply returned NULL"); + return 10; + } + if(fabs(inverseOutputCoord->r - SPHERE_COORD_TP3_INVERSE_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord r %lg not as expected %lg", + inverseOutputCoord->r, SPHERE_COORD_TP3_INVERSE_R); + return 11; + } + if(fabs(inverseOutputCoord->d - SPHERE_COORD_TP3_INVERSE_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotApply return coord d %ld not as expected %lg", + inverseOutputCoord->d, SPHERE_COORD_TP3_INVERSE_D); + return 12; + } + psFree(testTransform); + + psFree(testDateTime); + psFree(outputCoord); + psFree(inputCoord); + psFree(inverseOutputCoord); + + return 0; +} + +#define SPHERE_PRECESS_TP1_R 0.0 // 0.0 degrees +#define SPHERE_PRECESS_TP1_D 0.0 // 0.0 degrees +#define SPHERE_PRECESS_TP1_EXPECT_R 6.238453 // 357.437 degrees +#define SPHERE_PRECESS_TP1_EXPECT_D -0.019426 // -1.113 degrees +#define SPHERE_PRECESS_TP2_R 0.0 // 0.0 degrees +#define SPHERE_PRECESS_TP2_D 1.570796 // 90.0 degrees +#define SPHERE_PRECESS_TP2_EXPECT_R 6.260828 // 358.719 degrees +#define SPHERE_PRECESS_TP2_EXPECT_D 1.551353 // 88.886 degrees +#define SPHERE_PRECESS_TP3_R 3.141593 // 180.0 degrees +#define SPHERE_PRECESS_TP3_D 0.523599 // 30.0 degrees +#define SPHERE_PRECESS_TP3_EXPECT_R 3.096616 // 177.423 degrees +#define SPHERE_PRECESS_TP3_EXPECT_D 0.543024 // 31.113 degrees + +psS32 testSphereRotPrecess( void ) +{ + psSphere* inputCoord = psSphereAlloc(); + psSphere* outputCoord = NULL; + psTime* fromTime = psTimeFromMJD(MJD_2100); + psTime* toTime = psTimeFromMJD(MJD_1900); + + // Set input coordinate + inputCoord->r = SPHERE_PRECESS_TP1_R; + inputCoord->d = SPHERE_PRECESS_TP1_D; + inputCoord->rErr = 0.0; + inputCoord->dErr = 0.0; + + // Calculate precess + outputCoord = psSpherePrecess(inputCoord, fromTime, toTime); + // Verify return is not NULL + if(outputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); + return 1; + } + // Verify return with expected values + if( fabs(outputCoord->r - SPHERE_PRECESS_TP1_EXPECT_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Precess r = %lg not equal to expected = %lg", + outputCoord->r,SPHERE_PRECESS_TP1_EXPECT_R); + return 2; + } + if( fabs(outputCoord->d - SPHERE_PRECESS_TP1_EXPECT_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Precess d = %lg not equal to expected = %lg", + outputCoord->d,SPHERE_PRECESS_TP1_EXPECT_D); + return 3; + } + psFree(outputCoord); + + // Set input coordinate + inputCoord->r = SPHERE_PRECESS_TP2_R; + inputCoord->d = SPHERE_PRECESS_TP2_D; + inputCoord->rErr = 0.0; + inputCoord->dErr = 0.0; + + // Calculate precess + outputCoord = psSpherePrecess(inputCoord, fromTime, toTime); + // Verify return is not NULL + if(outputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); + return 4; + } + // Verify return with expected values + if( fabs(outputCoord->r - SPHERE_PRECESS_TP2_EXPECT_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Precess r = %lg not equal to expected = %lg", + outputCoord->r,SPHERE_PRECESS_TP2_EXPECT_R); + return 5; + } + if( fabs(outputCoord->d - SPHERE_PRECESS_TP2_EXPECT_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Precess d = %lg not equal to expected = %lg", + outputCoord->d,SPHERE_PRECESS_TP2_EXPECT_D); + return 6; + } + psFree(outputCoord); + + // Set input coordinate + inputCoord->r = SPHERE_PRECESS_TP3_R; + inputCoord->d = SPHERE_PRECESS_TP3_D; + inputCoord->rErr = 0.0; + inputCoord->dErr = 0.0; + + // Calculate precess + outputCoord = psSpherePrecess(inputCoord, fromTime, toTime); + // Verify return is not NULL + if(outputCoord == NULL) { + psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected"); + return 7; + } + // Verify return with expected values + if( fabs(outputCoord->r - SPHERE_PRECESS_TP3_EXPECT_R) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Precess r = %lg not equal to expected = %lg", + outputCoord->r,SPHERE_PRECESS_TP3_EXPECT_R); + return 8; + } + if( fabs(outputCoord->d - SPHERE_PRECESS_TP3_EXPECT_D) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Precess d = %lg not equal to expected = %lg", + outputCoord->d,SPHERE_PRECESS_TP3_EXPECT_D); + return 9; + } + psFree(outputCoord); + + // Invoke precess with invalid parameter + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); + outputCoord = psSpherePrecess(inputCoord, fromTime, NULL); + if(outputCoord != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL with invalid input"); + return 10; + } + + // Invoke precess with invalid parameter + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); + outputCoord = psSpherePrecess(inputCoord, NULL, toTime); + if(outputCoord != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL with invalid input"); + return 11; + } + + // Invoke precess with invalid parameter + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); + outputCoord = psSpherePrecess(NULL, fromTime, toTime); + if(outputCoord != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL with invalid input"); + return 12; + } + + // Free objects + psFree(fromTime); + psFree(toTime); + psFree(inputCoord); + + return 0; +} + +psS32 testSphereRotICRSToEcliptic( void ) +{ + psF64 expectedQ0 = 0.0; + psF64 expectedQ1 = 0.0; + psF64 expectedQ2 = 0.0; + psF64 expectedQ3 = 0.0; + + // Set test date time to 1/1/2000 00:00:00 + psTime* testDateTime = psTimeFromMJD(MJD_2000); + + // Invoke function to set psSphereRota objec + psSphereRot *myST = psSphereRotICRSToEcliptic(testDateTime); + + // Verify expected values for the specified time + if (ERROR_TOL < fabs(expectedQ0 - myST->q0)) { + psError(PS_ERR_UNKNOWN,true,"myST->q0 is %f, should be %f", + myST->q0, expectedQ0); + return 1; + } + if (ERROR_TOL < fabs(expectedQ1 - myST->q1)) { + psError(PS_ERR_UNKNOWN,true,"myST->q1 is %f, should be %f", + myST->q1, expectedQ1); + return 2; + } + if (ERROR_TOL < fabs(expectedQ2 - myST->q2)) { + psError(PS_ERR_UNKNOWN,true,"myST->q2 is %f, should be %f", + myST->q2, expectedQ2); + return 3; + } + if (ERROR_TOL < fabs(expectedQ3 - myST->q3)) { + psError(PS_ERR_UNKNOWN,true,"myST->q3 is %f, should be %f", + myST->q3, expectedQ3); + return 4; + } + psFree(myST); + psFree(testDateTime); + + // Set test date time to 1/1/2100 00:00:00 + testDateTime = psTimeFromMJD(MJD_2100); + + // Invoke function to set psSphereRota objec + myST = psSphereRotICRSToEcliptic(testDateTime); + + // Verify expected values for the specified time + // Verify expected values for the specified time + if (ERROR_TOL < fabs(expectedQ0 - myST->q0)) { + psError(PS_ERR_UNKNOWN,true,"myST->q0 is %f, should be %f", + myST->q0, expectedQ0); + return 5; + } + if (ERROR_TOL < fabs(expectedQ1 - myST->q1)) { + psError(PS_ERR_UNKNOWN,true,"myST->q1 is %f, should be %f", + myST->q1, expectedQ1); + return 6; + } + if (ERROR_TOL < fabs(expectedQ2 - myST->q2)) { + psError(PS_ERR_UNKNOWN,true,"myST->q2 is %f, should be %f", + myST->q2, expectedQ2); + return 7; + } + if (ERROR_TOL < fabs(expectedQ3 - myST->q3)) { + psError(PS_ERR_UNKNOWN,true,"myST->q3 is %f, should be %f", + myST->q3, expectedQ3); + return 8; + } + psFree(myST); + psFree(testDateTime); + + // Verify if argument psTime is NULL, function returns NULL and error message generated + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); + myST = psSphereRotICRSToEcliptic(NULL); + if (myST != NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotICRSToEcliptic() did not return NULL."); + return 9; + } + + // Verify if argument psTime is less than 1900, function return NULL and error msg generated + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); + testDateTime = psTimeFromMJD(MJD_1900 - 1.0); + myST = psSphereRotICRSToEcliptic(testDateTime); + if (myST != NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotICRSToEcliptic() did not return NULL."); + return 10; + } + psFree(testDateTime); + + return 0; +} + + +psS32 testSphereRotEclipticToICRS( void ) +{ + psF64 expectedPhiP = 0.0; + psF64 expectedAlphaP = 0.0; + psF64 expectedCosDeltaP = 0.0; + psF64 expectedSinDeltaP = 0.0; + + // Set test date time to 1/1/2000 00:00:00 + psTime* testDateTime = psTimeFromMJD(MJD_2000); + + // Invoke function to set psSphereRota object + psSphereRot *myST = psSphereRotEclipticToICRS(testDateTime); + + // Verify expected values for the specified time + if (ERROR_TOL < fabs(expectedSinDeltaP - myST->sinDeltaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->sinDeltaP is %f, should be %f", + myST->sinDeltaP, expectedSinDeltaP); + return 1; + } + if (ERROR_TOL < fabs(expectedCosDeltaP - myST->cosDeltaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->cosDeltaP is %f, should be %f", + myST->cosDeltaP, expectedCosDeltaP); + return 2; + } + if (ERROR_TOL < fabs(expectedAlphaP - myST->alphaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->alphaP is %f, should be %f", + myST->alphaP, expectedAlphaP); + return 3; + } + if (ERROR_TOL < fabs(expectedPhiP - myST->phiP)) { + psError(PS_ERR_UNKNOWN,true,"myST->phiP is %f, should be %f", + myST->phiP, expectedPhiP); + return 4; + } + psFree(myST); + psFree(testDateTime); + + expectedCosDeltaP = EXPECT_COS_DELTAP_2100; + expectedSinDeltaP = -EXPECT_SIN_DELTAP_2100; + + // Set test date time to 1/1/2100 00:00:00 + testDateTime = psTimeFromMJD(MJD_2100); + + // Invoke function to set psSphereRota objec + myST = psSphereRotEclipticToICRS(testDateTime); + + // Verify expected values for the specified time + if (ERROR_TOL < fabs(expectedSinDeltaP - myST->sinDeltaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->sinDeltaP is %f, should be %f", + myST->sinDeltaP, expectedSinDeltaP); + return 5; + } + if (ERROR_TOL < fabs(expectedCosDeltaP - myST->cosDeltaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->cosDeltaP is %f, should be %f", + myST->cosDeltaP, expectedCosDeltaP); + return 6; + } + if (ERROR_TOL < fabs(expectedAlphaP - myST->alphaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->alphaP is %f, should be %f", + myST->alphaP, expectedAlphaP); + return 7; + } + if (ERROR_TOL < fabs(expectedPhiP - myST->phiP)) { + psError(PS_ERR_UNKNOWN,true,"myST->phiP is %f, should be %f", + myST->phiP, expectedPhiP); + return 8; + } + psFree(myST); + psFree(testDateTime); + + // Verify if argument psTime is NULL, function returns NULL and error message generated + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); + myST = psSphereRotEclipticToICRS(NULL); + if (myST != NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotEclipticICRS() did not return NULL."); + return 9; + } + + // Verify if argument psTime is less than 1900, function return NULL and error msg generated + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); + testDateTime = psTimeFromMJD(MJD_1900 - 1.0); + myST = psSphereRotEclipticToICRS(testDateTime); + if (myST != NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotEclipticToICRS() did not return NULL."); + return 10; + } + psFree(testDateTime); + + return 0; +} + +#define ITG_EXPECT_ALPHAP 4.93683 +#define ITG_EXPECT_SINDELTAP 0.88999 +#define ITG_EXPECT_COSDELTAP 0.45598 +#define ITG_EXPECT_PHIP 0.57477 + +psS32 testSphereRotICRSToGalactic( void ) +{ + // Invoke function + psSphereRot *myST = psSphereRotICRSToGalactic(); + + // Verify did not return NULL + if(myST == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotICRSToGalactic returned NULL"); + return 1; + } + // Verify returned structure has members set properly + if (ERROR_TOL < fabs(ITG_EXPECT_SINDELTAP - myST->sinDeltaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->sinDeltaP is %f, should be %f", + myST->sinDeltaP, ITG_EXPECT_SINDELTAP); + return 2; + } + if (ERROR_TOL < fabs(ITG_EXPECT_COSDELTAP - myST->cosDeltaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->cosDeltaP is %f, should be %f", + myST->cosDeltaP, ITG_EXPECT_COSDELTAP); + return 3; + } + if (ERROR_TOL < fabs(ITG_EXPECT_ALPHAP - myST->alphaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->alphaP is %f, should be %f", + myST->alphaP, ITG_EXPECT_ALPHAP); + return 4; + } + if (ERROR_TOL < fabs(ITG_EXPECT_PHIP - myST->phiP)) { + psError(PS_ERR_UNKNOWN,true,"myST->phiP is %f, should be %f", + myST->phiP, ITG_EXPECT_PHIP); + return 5; + } + // Free data structure created + psFree(myST); + + return 0; +} + +#define GTI_EXPECT_PHIP 4.93683 +#define GTI_EXPECT_SINDELTAP -0.88999 +#define GTI_EXPECT_COSDELTAP 0.45598 +#define GTI_EXPECT_ALPHAP 0.57477 + +psS32 testSphereRotGalacticToICRS( void ) +{ + // Invoke function + psSphereRot *myST = psSphereRotGalacticToICRS(); + + // Verify did not return NULL + if(myST == NULL) { + psError(PS_ERR_UNKNOWN,true,"psSphereRotGalacticToICRS returned NULL"); + return 1; + } + // Verify returned structure has members set properly + if (ERROR_TOL < fabs(GTI_EXPECT_SINDELTAP - myST->sinDeltaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->sinDeltaP is %f, should be %f", + myST->sinDeltaP, GTI_EXPECT_SINDELTAP); + return 2; + } + if (ERROR_TOL < fabs(GTI_EXPECT_COSDELTAP - myST->cosDeltaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->cosDeltaP is %f, should be %f", + myST->cosDeltaP, GTI_EXPECT_COSDELTAP); + return 3; + } + if (ERROR_TOL < fabs(GTI_EXPECT_ALPHAP - myST->alphaP)) { + psError(PS_ERR_UNKNOWN,true,"myST->alphaP is %f, should be %f", + myST->alphaP, GTI_EXPECT_ALPHAP); + return 4; + } + if (ERROR_TOL < fabs(GTI_EXPECT_PHIP - myST->phiP)) { + psError(PS_ERR_UNKNOWN,true,"myST->phiP is %f, should be %f", + myST->phiP, GTI_EXPECT_PHIP); + return 5; + } + // Free data structure created + psFree(myST); + + return 0; +} + Index: /trunk/psLib/test/astro/tst_psCoord01.c =================================================================== --- /trunk/psLib/test/astro/tst_psCoord01.c (revision 4547) +++ /trunk/psLib/test/astro/tst_psCoord01.c (revision 4547) @@ -0,0 +1,917 @@ +/** @file tst_psCoord01.c +* +* @brief The code will test several functions with PSLib source file +* psCoord.c +* +* @author Eric Van Alst, MHPCC +* +* @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ +* @date $Date: 2005-07-13 02:46:58 $ +* +* Copyright 2005 Maui High Performance Computing Center, Univ. of Hawaii +*/ + +#include "pslib_strict.h" +#include "psTest.h" + +static psS32 testProjectionAlloc(void); +static psS32 testProjectTan(void); +static psS32 testDeprojectTan(void); +static psS32 testProjectSin(void); +static psS32 testDeprojectSin(void); +static psS32 testProjectAit(void); +static psS32 testDeprojectAit(void); +static psS32 testProjectPar(void); +static psS32 testDeprojectPar(void); +static psS32 testProjectFail(void); +static psS32 testDeprojectFail(void); +static psS32 testSetOffsetSphere(void); +static psS32 testSetOffsetLinear(void); +static psS32 testGetOffsetSphere(void); +static psS32 testGetOffsetLinear(void); + +testDescription tests[] = { + {testProjectionAlloc, 833, "psProjectionAlloc",0,false}, + {testProjectTan, 834, "psProject(TAN)",0,false}, + {testDeprojectTan, 835, "psDeproject(TAN)",0,false}, + {testProjectSin, 834, "psProject(SIN)",0,false}, + {testDeprojectSin, 835, "psDeproject(SIN)",0,false}, + {testProjectAit, 834, "psProject(AIT)",0,false}, + {testDeprojectAit, 835, "psDeproject(AIT)",0,false}, + {testProjectPar, 834, "psProject(PAR)",0,false}, + {testDeprojectPar, 835, "psDeproject(PAR)",0,false}, + {testProjectFail, 834, "psProject",0,false}, + {testDeprojectFail, 835, "psProject",0,false}, + {testSetOffsetSphere, 0000, "psSphereSetOffset",0,false}, + {testSetOffsetLinear, 0000, "psSphereSetOffset",0,false}, + {testGetOffsetSphere, 0000, "psSphereGetOffset",0,false}, + {testGetOffsetLinear, 0000, "psSphereGetOffset",0,false}, + {NULL} + }; + + +#define ERROR_TOL 0.0001 +#define TESTPOINTS 4 +#define DEG_INC 30.0 + +#define MY_TINY 0.0001 +#define PS_COMPARE_TINY_THEN_PRINT_ERROR(ACTUAL, EXPECT, TESTSTATUS) \ +if (MY_TINY < fabs(EXPECT - ACTUAL)) { \ + psError(PS_ERR_UNKNOWN,true,"%s is %lg, should be %lg", #ACTUAL, ACTUAL, EXPECT, TESTSTATUS); \ + return TESTSTATUS; \ +} + + +// alpha, delta, alpha-center, delta-center, scale-x, scale-y +psF64 projectionTestPoint[TESTPOINTS][6] = { + { 0.785398, 0.785398, 0.000000, 0.000000, 1.000000, 1.000000 }, + { 0.100000, 1.500000, 0.500000, 0.250000, 1.000000, 1.000000 }, + { 0.628319, 0.448799, 0.000000, 0.000000, 0.250000, 0.750000 }, + { -1.047196, 0.222222, -0.250000, 0.000000, 1.500000, 1.250000 } + }; + +// Expected values for TAN +psF64 projectionTanExpected[TESTPOINTS][2] = { + { -1.000000, -1.414214 }, + { 0.088884, -3.066567 }, + { -0.181636, -0.446444 }, + { 1.535818, -0.404231 } + }; + +// Expected values for SIN +psF64 projectionSinExpected[TESTPOINTS][2] = { + { -0.500000, -0.707101 }, + { 0.027546, -0.950366 }, + { -0.132394, -0.325413 }, + { 1.046712, -0.275497 } + }; + +// Expected values for AIT +psF64 projectionAitExpected[TESTPOINTS][2] = { + { -0.549175, 0.523375 }, + { 0.027895, 0.313807 }, + { -0.162822, 0.607646 }, + { 1.455312, 0.955388 } + }; + +// Expected values for PAR +psF64 projectionParExpected[TESTPOINTS][2] = { + { -0.541244, 0.545532 }, + { 0.027703, 0.329366 }, + { -0.157157, 0.633550 }, + { 1.432951, 0.971372 } + }; + +// Testpoints, offset and expected values for psSphereSetOffset test +#define TESTPOINTS_OFFSET 4 +psF64 setOffsetTestpoint[TESTPOINTS_OFFSET][2] = { + { 0.50, 0.50 }, + {-0.50, 0.50 }, + { 0.00, 0.00 }, + { 1.50, -0.10 } + }; + +psF64 setOffsetOffset[TESTPOINTS_OFFSET][2] = { + { 0.190761, -0.272205 }, + {-0.553049, -0.460926 }, + { 0.100335,-14.172222 }, + {14.172222, -0.100335 } + }; + +psF64 setOffsetResult[TESTPOINTS_OFFSET][2] = { + { 0.25, 0.75 }, + { 0.20, 0.80 }, + {-0.10, 1.50 }, + { 0.00, 0.00 } + }; + +psF64 getOffsetTestpoint1[TESTPOINTS_OFFSET][2] = { + { 0.00, 0.00 }, + {-0.25, 0.50 }, + { 0.50, -0.25 }, + { 0.25, -0.10 } + }; + +psF64 getOffsetTestpoint2[TESTPOINTS_OFFSET][2] = { + { 0.75, 0.25 }, + { 0.40, -0.60 }, + { 1.50, 0.50 }, + { 0.10, 0.75 } + }; + +psF64 getOffsetResult[TESTPOINTS_OFFSET][2] = { + { -0.931596, -0.348976 }, + { -1.632830, 2.649629 }, + { -2.166795, -1.707211 }, + { 0.167752, -1.151351 } + }; + + +psS32 main( psS32 argc, char* argv[] ) +{ + psLogSetLevel( PS_LOG_INFO ); + + return ( !runTestSuite(stderr,"psCoord",tests,argc,argv) ); +} + +psS32 testProjectionAlloc(void) +{ + // Allocate new psProjection structure + psProjection* myProjection = psProjectionAlloc(1.1, 2.2, 3.3, 4.4, PS_PROJ_AIT); + + // Verify NULL is not returned + if(myProjection == NULL) { + psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL"); + return 1; + } + // Verify the members are set correctly + if(myProjection->R != 1.1) { + psError(PS_ERR_UNKNOWN,true,"R member set to %lg, but expected %lg", + myProjection->R, 1.1); + return 2; + } + if(myProjection->D != 2.2) { + psError(PS_ERR_UNKNOWN,true,"D member set to %lg, but expected %lg", + myProjection->D, 2.2); + return 3; + } + if(myProjection->Xs != 3.3) { + psError(PS_ERR_UNKNOWN,true,"Xs member set to %lg, but expected %lg", + myProjection->Xs, 3.3); + return 4; + } + if(myProjection->Ys != 4.4) { + psError(PS_ERR_UNKNOWN,true,"Ys member set to %lg, but expected %lg", + myProjection->Ys, 4.4); + return 5; + } + if(myProjection->type != PS_PROJ_AIT) { + psError(PS_ERR_UNKNOWN,true,"type member set to %d, but expected %d", + myProjection->type, PS_PROJ_AIT); + return 6; + } + + // Free projection + psFree(myProjection); + + return 0; +} + +psS32 testProjectTan(void) +{ + psPlane* out = NULL; + psSphere* in = psSphereAlloc(); + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_TAN); + + // Perform projecton on various test points + for(psS32 i = 0; i < TESTPOINTS; i++) { + + // Initialize input and project members + in->r = projectionTestPoint[i][0]; + in->d = projectionTestPoint[i][1]; + myProjection->R = projectionTestPoint[i][2]; + myProjection->D = projectionTestPoint[i][3]; + myProjection->Xs = projectionTestPoint[i][4]; + myProjection->Ys = projectionTestPoint[i][5]; + + // Perform projection + out = psProject(in, myProjection); + + // Verify output not NULL + if(out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return null not expected"); + return i*10; + } + + // Verify output is as expected + if(fabs(out->x - projectionTanExpected[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psPlane->x = %lg expected %lg", + i,out->x, projectionTanExpected[i][0]); + return i*10+1; + } + if(fabs(out->y - projectionTanExpected[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint % d psPlane->y = %lg expected %lg", + i,out->y, projectionTanExpected[i][1]); + return i*10+2; + } + psFree(out); + } + + psFree(in); + psFree(myProjection); + + return 0; +} + +psS32 testDeprojectTan(void) +{ + psSphere* out = NULL; + psPlane* in = psPlaneAlloc(); + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_TAN); + + // Perform deprojection on various test points + for(psS32 i = 0; i < TESTPOINTS; i++) { + + // Initialize input and projection members + in->x = projectionTanExpected[i][0]; + in->y = projectionTanExpected[i][1]; + myProjection->R = projectionTestPoint[i][2]; + myProjection->D = projectionTestPoint[i][3]; + myProjection->Xs = projectionTestPoint[i][4]; + myProjection->Ys = projectionTestPoint[i][5]; + + // Perform deprojection + out = psDeproject(in, myProjection); + + // Verify output is not NULL + if(out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return null not expected"); + return 20*i; + } + + // Verify output is as expected + if(fabs(out->r - projectionTestPoint[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psSphere->r = %lg expected %lg", + i,out->r,projectionTestPoint[i][0]); + return 20*i + 1; + } + if(fabs(out->d - projectionTestPoint[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psSphere->d = %lg expected %lg", + i, out->d, projectionTestPoint[i][1]); + return 20*i + 2; + } + psFree(out); + } + + psFree(in); + psFree(myProjection); + + return 0; +} + +psS32 testProjectSin(void) +{ + psPlane* out = NULL; + psSphere* in = psSphereAlloc(); + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_SIN); + + // Perform projecton on various test points + for(psS32 i = 0; i < TESTPOINTS; i++) { + + // Initialize input and project members + in->r = projectionTestPoint[i][0]; + in->d = projectionTestPoint[i][1]; + myProjection->R = projectionTestPoint[i][2]; + myProjection->D = projectionTestPoint[i][3]; + myProjection->Xs = projectionTestPoint[i][4]; + myProjection->Ys = projectionTestPoint[i][5]; + + // Perform projection + out = psProject(in, myProjection); + + // Verify output not NULL + if(out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return null not expected"); + return i*10; + } + + // Verify output is as expected + if(fabs(out->x - projectionSinExpected[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psPlane->x = %lg expected %lg", + i,out->x, projectionSinExpected[i][0]); + return i*10+1; + } + if(fabs(out->y - projectionSinExpected[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint % d psPlane->y = %lg expected %lg", + i,out->y, projectionSinExpected[i][1]); + return i*10+2; + } + psFree(out); + } + + psFree(in); + psFree(myProjection); + + return 0; +} + +psS32 testDeprojectSin(void) +{ + psSphere* out = NULL; + psPlane* in = psPlaneAlloc(); + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_SIN); + + // Perform deprojection on various test points + for(psS32 i = 0; i < TESTPOINTS; i++) { + + // Initialize input and projection members + in->x = projectionSinExpected[i][0]; + in->y = projectionSinExpected[i][1]; + myProjection->R = projectionTestPoint[i][2]; + myProjection->D = projectionTestPoint[i][3]; + myProjection->Xs = projectionTestPoint[i][4]; + myProjection->Ys = projectionTestPoint[i][5]; + + // Perform deprojection + out = psDeproject(in, myProjection); + + // Verify output is not NULL + if(out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return null not expected"); + return 20*i; + } + + // Verify output is as expected + if(fabs(out->r - projectionTestPoint[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psSphere->r = %lg expected %lg", + i,out->r,projectionTestPoint[i][0]); + return 20*i + 1; + } + if(fabs(out->d - projectionTestPoint[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psSphere->d = %lg expected %lg", + i, out->d, projectionTestPoint[i][1]); + return 20*i + 2; + } + psFree(out); + } + + psFree(in); + psFree(myProjection); + + return 0; +} + +psS32 testProjectAit(void) +{ + psPlane* out = NULL; + psSphere* in = psSphereAlloc(); + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_AIT); + + // Perform projecton on various test points + for(psS32 i = 0; i < TESTPOINTS; i++) { + + // Initialize input and project members + in->r = projectionTestPoint[i][0]; + in->d = projectionTestPoint[i][1]; + myProjection->R = projectionTestPoint[i][2]; + myProjection->D = projectionTestPoint[i][3]; + myProjection->Xs = projectionTestPoint[i][4]; + myProjection->Ys = projectionTestPoint[i][5]; + + // Perform projection + out = psProject(in, myProjection); + + // Verify output not NULL + if(out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return null not expected"); + return i*10; + } + + // Verify output is as expected + if(fabs(out->x - projectionAitExpected[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psPlane->x = %lg expected %lg", + i,out->x, projectionAitExpected[i][0]); + return i*10+1; + } + if(fabs(out->y - projectionAitExpected[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint % d psPlane->y = %lg expected %lg", + i,out->y, projectionAitExpected[i][1]); + return i*10+2; + } + psFree(out); + } + + psFree(in); + psFree(myProjection); + + return 0; +} + +psS32 testDeprojectAit(void) +{ + psSphere* out = NULL; + psPlane* in = psPlaneAlloc(); + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_AIT); + + // Perform deprojection on various test points + for(psS32 i = 0; i < TESTPOINTS; i++) { + + // Initialize input and projection members + in->x = projectionAitExpected[i][0]; + in->y = projectionAitExpected[i][1]; + myProjection->R = projectionTestPoint[i][2]; + myProjection->D = projectionTestPoint[i][3]; + myProjection->Xs = projectionTestPoint[i][4]; + myProjection->Ys = projectionTestPoint[i][5]; + + // Perform deprojection + out = psDeproject(in, myProjection); + + // Verify output is not NULL + if(out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return null not expected"); + return 20*i; + } + + // Verify output is as expected + if(fabs(out->r - projectionTestPoint[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psSphere->r = %lg expected %lg", + i,out->r,projectionTestPoint[i][0]); + return 20*i + 1; + } + if(fabs(out->d - projectionTestPoint[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psSphere->d = %lg expected %lg", + i, out->d, projectionTestPoint[i][1]); + return 20*i + 2; + } + psFree(out); + } + + psFree(in); + psFree(myProjection); + + return 0; +} + +psS32 testProjectPar(void) +{ + psPlane* out = NULL; + psSphere* in = psSphereAlloc(); + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_PAR); + + // Perform projecton on various test points + for(psS32 i = 0; i < TESTPOINTS; i++) { + + // Initialize input and project members + in->r = projectionTestPoint[i][0]; + in->d = projectionTestPoint[i][1]; + myProjection->R = projectionTestPoint[i][2]; + myProjection->D = projectionTestPoint[i][3]; + myProjection->Xs = projectionTestPoint[i][4]; + myProjection->Ys = projectionTestPoint[i][5]; + + // Perform projection + out = psProject(in, myProjection); + + // Verify output not NULL + if(out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return null not expected"); + return i*10; + } + + // Verify output is as expected + if(fabs(out->x - projectionParExpected[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psPlane->x = %lg expected %lg", + i,out->x, projectionParExpected[i][0]); + return i*10+1; + } + if(fabs(out->y - projectionParExpected[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint % d psPlane->y = %lg expected %lg", + i,out->y, projectionParExpected[i][1]); + return i*10+2; + } + psFree(out); + } + + psFree(in); + psFree(myProjection); + + return 0; +} + +psS32 testDeprojectPar(void) +{ + psSphere* out = NULL; + psPlane* in = psPlaneAlloc(); + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_PAR); + + // Perform deprojection on various test points + for(psS32 i = 0; i < TESTPOINTS; i++) { + + // Initialize input and projection members + in->x = projectionParExpected[i][0]; + in->y = projectionParExpected[i][1]; + myProjection->R = projectionTestPoint[i][2]; + myProjection->D = projectionTestPoint[i][3]; + myProjection->Xs = projectionTestPoint[i][4]; + myProjection->Ys = projectionTestPoint[i][5]; + + // Perform deprojection + out = psDeproject(in, myProjection); + + // Verify output is not NULL + if(out == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return null not expected"); + return 20*i; + } + + // Verify output is as expected + if(fabs(out->r - projectionTestPoint[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psSphere->r = %lg expected %lg", + i,out->r,projectionTestPoint[i][0]); + return 20*i + 1; + } + if(fabs(out->d - projectionTestPoint[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d psSphere->d = %lg expected %lg", + i, out->d, projectionTestPoint[i][1]); + return 20*i + 2; + } + psFree(out); + } + + psFree(in); + psFree(myProjection); + + return 0; +} + +psS32 testProjectFail(void) +{ + psPlane* out = NULL; + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_TAN); + psSphere* in = psSphereAlloc(); + + // Invoke function with null coordinate argument + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null coord arg"); + out = psProject(NULL, myProjection); + if(out != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return null as expected"); + return 1; + } + + // Invoke function with null projection argument + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null projection arg"); + out = psProject(in, NULL); + if(out != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return null as expected"); + return 2; + } + + // Invoke function with invalid projection type + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid projection type"); + myProjection->type = PS_PROJ_NTYPE; + out = psProject(in,myProjection); + if(out != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return null as expected"); + return 3; + } + + psFree(myProjection); + psFree(in); + + return 0; +} + +psS32 testDeprojectFail(void) +{ + psSphere* out = NULL; + psProjection* myProjection = psProjectionAlloc(0.0,0.0,1.0,1.0,PS_PROJ_TAN); + psPlane* in = psPlaneAlloc(); + + // Invoke function with null coordinate argument + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null coord arg"); + out = psDeproject(NULL, myProjection); + if(out != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return null as expected"); + return 1; + } + + // Invoke function with null projection argument + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null projection arg"); + out = psDeproject(in, NULL); + if(out != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return null as expected"); + return 2; + } + + // Invoke function with invalid projection type + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid projection type"); + myProjection->type = PS_PROJ_NTYPE; + out = psDeproject(in,myProjection); + if(out != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return null as expected"); + return 3; + } + + psFree(myProjection); + psFree(in); + + return 0; +} + +psS32 testSetOffsetSphere( void ) +{ + psSphere* position1 = psSphereAlloc(); + psSphere* position2 = NULL; + psSphere* offset = psSphereAlloc(); + psSphere* tmpOffset = psSphereAlloc(); + + // Initialize first position + position1->r = DEG_TO_RAD(90.0); + position1->d = DEG_TO_RAD(45.0); + position1->rErr = 0.0; + position1->dErr = 0.0; + + // Using various offset verify spherical offset + // Use all the valid unit types + for (psF64 r = 0.0; r < 180.0; r += DEG_INC) { + for (psF64 d = 0.0; d < 90.0; d += DEG_INC) { + + offset->r = DEG_TO_RAD(r); + offset->d = DEG_TO_RAD(d); + offset->rErr = 0.0; + offset->dErr = 0.0; + + position2 = psSphereSetOffset(position1, offset, PS_SPHERICAL, PS_RADIAN); + PS_COMPARE_TINY_THEN_PRINT_ERROR(position2->r, (position1->r + offset->r), 1); + PS_COMPARE_TINY_THEN_PRINT_ERROR(position2->d, (position1->d + offset->d), 2); + psFree(position2); + + tmpOffset->r = RAD_TO_DEG(offset->r); + tmpOffset->d = RAD_TO_DEG(offset->d); + tmpOffset->rErr = 0.0; + tmpOffset->dErr = 0.0; + position2 = psSphereSetOffset(position1, tmpOffset, PS_SPHERICAL, PS_DEGREE); + PS_COMPARE_TINY_THEN_PRINT_ERROR(position2->r, (position1->r + offset->r), 3); + PS_COMPARE_TINY_THEN_PRINT_ERROR(position2->d, (position1->d + offset->d), 4); + psFree(position2); + + tmpOffset->r = RAD_TO_MIN(offset->r); + tmpOffset->d = RAD_TO_MIN(offset->d); + tmpOffset->rErr = 0.0; + tmpOffset->dErr = 0.0; + position2 = psSphereSetOffset(position1, tmpOffset, PS_SPHERICAL, PS_ARCMIN); + PS_COMPARE_TINY_THEN_PRINT_ERROR(position2->r, (position1->r + offset->r), 5); + PS_COMPARE_TINY_THEN_PRINT_ERROR(position2->d, (position1->d + offset->d), 6); + psFree(position2); + + tmpOffset->r = RAD_TO_SEC(offset->r); + tmpOffset->d = RAD_TO_SEC(offset->d); + tmpOffset->rErr = 0.0; + tmpOffset->dErr = 0.0; + position2 = psSphereSetOffset(position1, tmpOffset, PS_SPHERICAL, PS_ARCSEC); + PS_COMPARE_TINY_THEN_PRINT_ERROR(position2->r, (position1->r + offset->r), 7); + PS_COMPARE_TINY_THEN_PRINT_ERROR(position2->d, (position1->d + offset->d), 8); + psFree(position2); + } + } + + // Attempt to call function with null input coordinate + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message null input coord"); + position2 = psSphereSetOffset(NULL, offset, PS_LINEAR, PS_ARCSEC); + if (position2 != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL"); + return 30; + } + + // Attempt to call function with null offset + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message null offset"); + position2 = psSphereSetOffset(position1, NULL, PS_LINEAR, PS_ARCSEC); + if (position2 != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL"); + return 31; + } + + // Attempt to call function with invalid mode + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid mode"); + position2 = psSphereSetOffset(position1, offset, 0x54321, 0); + if (position2 != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL"); + return 32; + } + + // Attempt to call function with invalid unit + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message invalid unit"); + position2 = psSphereSetOffset(position1, offset, PS_SPHERICAL, 0x54321); + if (position2 != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL"); + return 33; + } + + psFree(position1); + psFree(offset); + psFree(tmpOffset); + + return 0; +} + +psS32 testSetOffsetLinear(void) +{ + psSphere* coord = psSphereAlloc(); + psSphere* offset = psSphereAlloc(); + psSphere* out = NULL; + + for(psS32 i = 0; i < TESTPOINTS_OFFSET; i++) { + + coord->r = setOffsetTestpoint[i][0]; + coord->d = setOffsetTestpoint[i][1]; + + offset->r = setOffsetOffset[i][0]; + offset->d = setOffsetOffset[i][1]; + + out = psSphereSetOffset(coord, offset, PS_LINEAR, PS_RADIAN); + + if(fabs(out->r - setOffsetResult[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d: Result out->r = %lg not equal to expected %lg", + i, out->r, setOffsetResult[i][0]); + return i*10; + } + if(fabs(out->d - setOffsetResult[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d: Result out->d = %lg not equal to expected %lg", + i,out->d, setOffsetResult[i][1]); + return i*10+1; + } + + psFree(out); + } + + psFree(coord); + psFree(offset); + + return 0; +} + +psS32 testGetOffsetSphere( void ) +{ + psSphere* position1 = psSphereAlloc(); + psSphere* position2 = psSphereAlloc(); + psSphere *offset = NULL; + + position1->r = DEG_TO_RAD(90.0); + position1->d = DEG_TO_RAD(45.0); + position1->rErr = 0.0; + position1->dErr = 0.0; + + for (psF64 r = 0.0; r < 180.0;r += DEG_INC) { + for (psF64 d = 0.0;d < 90.0; d += DEG_INC) { + position2->r = DEG_TO_RAD(r); + position2->d = DEG_TO_RAD(d); + position2->rErr = 0.0; + position2->dErr = 0.0; + + offset = psSphereGetOffset( position1, position2, + PS_SPHERICAL, PS_RADIAN); + PS_COMPARE_TINY_THEN_PRINT_ERROR(offset->r, (position2->r - position1->r), 1); + PS_COMPARE_TINY_THEN_PRINT_ERROR(offset->d, (position2->d - position1->d), 1); + psFree(offset); + + offset = psSphereGetOffset( position1, position2, + PS_SPHERICAL, PS_DEGREE); + offset->r = DEG_TO_RAD(offset->r); + offset->d = DEG_TO_RAD(offset->d); + PS_COMPARE_TINY_THEN_PRINT_ERROR(offset->r, (position2->r - position1->r), 2); + PS_COMPARE_TINY_THEN_PRINT_ERROR(offset->d, (position2->d - position1->d), 3); + psFree(offset); + + offset = psSphereGetOffset( position1, position2, + PS_SPHERICAL, PS_ARCMIN); + offset->r = MIN_TO_RAD(offset->r); + offset->d = MIN_TO_RAD(offset->d); + PS_COMPARE_TINY_THEN_PRINT_ERROR(offset->r, (position2->r - position1->r), 2); + PS_COMPARE_TINY_THEN_PRINT_ERROR(offset->d, (position2->d - position1->d), 3); + psFree(offset); + + offset = psSphereGetOffset( position1, position2, + PS_SPHERICAL, PS_ARCSEC); + offset->r = SEC_TO_RAD(offset->r); + offset->d = SEC_TO_RAD(offset->d); + PS_COMPARE_TINY_THEN_PRINT_ERROR(offset->r, (position2->r - position1->r), 2); + PS_COMPARE_TINY_THEN_PRINT_ERROR(offset->d, (position2->d - position1->d), 3); + psFree(offset); + } + } + + // Attempt to invoke function with null position 1 parameter + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null position"); + offset = psSphereGetOffset(NULL, position2, PS_LINEAR, 0); + if (offset != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 10; + } + + // Attempt to invoke function with null position 2 parameter + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for null position"); + offset = psSphereGetOffset(position1, NULL, PS_LINEAR, 0); + if (offset != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 11; + } + + // Attempt to invoke function with invalid mode + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid mode"); + offset = psSphereGetOffset(position1, position2, 0x54321, 0); + if (offset != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 12; + } + + // Attempt to invoke function with invalid unit type + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid unit type"); + offset = psSphereGetOffset(position1, position2, PS_SPHERICAL, 0x54321); + if (offset != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 13; + } + + // Attempt to invoke function with coordinate 1 declination value 90.0 degree + position1->d = DEG_TO_RAD(90.0); + psLogMsg(__func__,PS_LOG_INFO,"Following should generate warning message"); + offset = psSphereGetOffset(position1, position2, PS_SPHERICAL, PS_RADIAN); + if (offset != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 14; + } + + // Attempt to invoke function with coordinate 2 declination value 90.0 degree + position1->d = DEG_TO_RAD(45.0); + position2->d = DEG_TO_RAD(90.0); + psLogMsg(__func__,PS_LOG_INFO,"Following should generate warning message"); + offset = psSphereGetOffset(position1, position2, PS_SPHERICAL, PS_RADIAN); + if (offset != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 15; + } + + psFree(position1); + psFree(position2); + + return 0; +} + +psS32 testGetOffsetLinear(void) +{ + psSphere* coord1 = psSphereAlloc(); + psSphere* coord2 = psSphereAlloc(); + psSphere* out = NULL; + + for(psS32 i = 0; i < TESTPOINTS_OFFSET; i++) { + + coord1->r = getOffsetTestpoint1[i][0]; + coord1->d = getOffsetTestpoint1[i][1]; + + coord2->r = getOffsetTestpoint2[i][0]; + coord2->d = getOffsetTestpoint2[i][1]; + + out = psSphereGetOffset(coord1, coord2, PS_LINEAR, PS_RADIAN); + + if(fabs(out->r - getOffsetResult[i][0]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d: Result out->r = %lg not equal to expected %lg", + i, out->r, getOffsetResult[i][0]); + return i*10; + } + if(fabs(out->d - getOffsetResult[i][1]) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Testpoint %d: Result out->d = %lg not equal to expected %lg", + i,out->d, getOffsetResult[i][1]); + return i*10+1; + } + + psFree(out); + } + + psFree(coord1); + psFree(coord2); + + return 0; +} + + Index: /trunk/psLib/test/astro/tst_psTime_01.c =================================================================== --- /trunk/psLib/test/astro/tst_psTime_01.c (revision 4547) +++ /trunk/psLib/test/astro/tst_psTime_01.c (revision 4547) @@ -0,0 +1,1160 @@ +/** @file tst_psTime_01.c + * + * @brief Test driver for psTime functions + * + * This test driver contains the following tests for psTime: + * 1) Allocate psTime structure + * 2) Get current time + * 3) Get UT1 UTC delta + * 4) Convert psTime to MJD + * 5) Convert psTime to JD + * 6) Convert psTime to ISO + * 7) Convert psTime to timeval + * 8) Create psTime from MJD + * 9) Create psTime from JD + * 10) Create psTime from ISO + * 11) Create psTime from timeval + * 12) Create psTime from TM + * 13) Convert time between different types + * + * O) Convert psTime time to LMST + * + * @author Ross Harman, MHPCC + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-07-13 02:46:58 $ + * + * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii + * + */ + +#include "pslib_strict.h" +#include "psTest.h" +#include + +#define ERROR_TOL 0.0001 + +static psS32 testTimeAlloc(void); +static psS32 testTimeGetNow(void); +static psS32 testTimeGetUT1Delta(void); +static psS32 testTimeToMJD(void); +static psS32 testTimeToJD(void); +static psS32 testTimeToISO(void); +static psS32 testTimeToTimeval(void); +static psS32 testTimeFromMJD(void); +static psS32 testTimeFromJD(void); +static psS32 testTimeFromISO(void); +static psS32 testTimeFromTimeval(void); +static psS32 testTimeFromTM(void); +static psS32 testTimeConvert(void); + +testDescription tests[] = { + {testTimeAlloc,000,"psTimeAlloc",0,false}, + {testTimeGetNow,000,"psTimeGetNow",0,false}, + {testTimeGetUT1Delta,000,"psTimeGetUT1Delta",0,false}, + {testTimeToMJD,000,"psTimeToMJD",0,false}, + {testTimeToJD,000,"psTimeToJD",0,false}, + {testTimeToISO,000,"psTimeToISO",0,false}, + {testTimeToTimeval,000,"psTimeToTimeval",0,false}, + {testTimeFromMJD,000,"psTimeFromMJD",0,false}, + {testTimeFromJD,000,"psTimeFromJD",0,false}, + {testTimeFromISO,000,"psTimeFromISO",0,false}, + {testTimeFromTimeval,000,"psTimeFromTimeval",0,false}, + {testTimeFromTM,000,"p_psTimeFromTM",0,false}, + {testTimeConvert,000,"psTimeConvert",0,false}, + {NULL} + }; + +// Test Time 1 : July 21, 2004 18:22:24.3 +// MJD = 53207.765559 +// JD = 2453208.265559 +// UTC Test Time 1 +const psS64 testTime1SecondsUTC = 1090434144; +const psU32 testTime1NanosecondsUTC = 272044000; +// TAI Test Time 1 +const psS64 testTime1SecondsTAI = 1090434176; +const psU32 testTime1NanosecondsTAI = 272044000; +const psF64 testTime1MJDTAI = 53207.76592937; +const psF64 testTime1JDTAI = 2453208.26592937; + +// TT Test Time 1 +const psS64 testTime1SecondsTT = 1090434208; +const psU32 testTime1NanosecondsTT = 456044000; +// Expected UT1-UTC IERS A & B +const psF64 testTime1UT1DeltaBullA = -0.457233186; +const psF64 testTime1UT1DeltaBullB = -0.457227; +// UT1 Test Time 1 +const psS64 testTime1SecondsUT1 = 1090434143; +const psU32 testTime1NanosecondsUT1 = 814810814; +// Expected MJD & JD +const psF64 testTime1MJD = 53207.765559; +const psF64 testTime1JD = 2453208.265559; +// Expected ISO string +const char* testTime1Str = "2004-07-21T18:22:24,2Z"; +const char* testTime1StrLeap = "2004-07-21T18:22:60,2Z"; +// Expected timeval values +const psS32 testTime1TimevalSec = 1090434144; +const psS32 testTime1TimevalUsec = 272044; + +// Test Time 2 : Jan. 1, 1973 00:00:00.0000 +// MJD = 41683.0000 +// JD = 2441683.5000 +const psS64 testTime2SecondsUTC = 94694400; +const psU32 testTime2NanosecondsUTC = 0; + +// Expected UT1-UTC IERS A & B +const psF64 testTime2UT1DeltaBullA = 0.000000; +const psF64 testTime2UT1DeltaBullB = 0.000000; + +// Test Time 3 : Sept. 21, 2006 00:00:00.0000 +// MJD = 53999 +// JD = 2453999.5 +const psS64 testTime3SecondsUTC = 1158796800; +const psU32 testTime3NanosecondsUTC = 0; +// Expected UT1-UTC IERS A & B +const psF64 testTime3UT1DeltaBullA = -0.63574; +const psF64 testTime3UT1DeltaBullB = -0.63574; + +// Test Time 4 : Jan. 1, 1969 00:00:00.0000 +// MJD = 40222 +// JD = 2440222.5 +const psS64 testTime4SecondsUTC = -31536000; +const psU32 testTime4NanosecondsUTC = 0; +// Expected MJD and JD +const psF64 testTime4MJD = 40222.0; +const psF64 testTime4JD = 2440222.5; + +// Test Time 5 : Dec 31, 0001 BC 23:59:59 +// MJD = -1397755 +// JD = 1002245.4999 +const psS64 testTime5SecondsUTC = -62125920001; +const psU32 testTime5NanosecondsUTC = 0; + +// Test Time 6 : Jan. 1, 10000 AD 00:00:00 +const psS64 testTime6SecondsUTC = 253202544001; +const psU32 testTime6NanosecondsUTC = 0; + +// Test Time 7 : Jan. 1, 2004 00:00:00,0 +const psS64 testTime7Seconds = 1072915200; +const psU32 testTime7Nanoseconds = 0; +const psS32 testTime7TmYear = 104; +const psS32 testTime7TmMon = 0; +const psS32 testTime7TmDay = 1; +const psS32 testTime7TmHour = 0; +const psS32 testTime7TmMin = 0; +const psS32 testTime7TmSec = 0; + +// Test Time 8 : Dec. 31, 2003 00:00:00,0 +const psS64 testTime8Seconds = 1072828800; +const psU32 testTime8Nanoseconds = 0; +const psS32 testTime8TmYear = 103; +const psS32 testTime8TmMon = 11; +const psS32 testTime8TmDay = 31; +const psS32 testTime8TmHour = 0; +const psS32 testTime8TmMin = 0; +const psS32 testTime8TmSec = 0; + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetLevel(PS_LOG_INFO); + + // Initialize library internal structures + psLibInit("psTime.config"); + + if( !runTestSuite(stderr,"psTime",tests,argc,argv)) { + return 1; + } + + // Cleanup library + psLibFinalize(); + + return 0; +} + +psS32 testTimeAlloc(void) +{ + psTime* time = NULL; + + // Allocate new psTime with valid time type + time = psTimeAlloc(PS_TIME_TAI); + if(time == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return NULL when psTime object ptr expected"); + return 1; + } + // Verify members set properly + if(time->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"Member type = %d not as expected %d",time->type,PS_TIME_TAI); + return 2; + } + if((time->sec != 0) && (time->nsec != 0) && (time->leapsecond != false)) { + psError(PS_ERR_UNKNOWN,true,"Members not set appropriately"); + return 3; + } + psFree(time); + + // Allocate new psTime with invalid time type + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message"); + time = psTimeAlloc(-100); + if(time != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid time type"); + return 4; + } + + return 0; +} +psS32 testTimeGetNow(void) +{ + psTime* timeNow = NULL; + + // Get current time and verify return is psTime structure + timeNow = psTimeGetNow(PS_TIME_TAI); + if(timeNow == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return valid psTime struct"); + return 1; + } + if(timeNow->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"Time type %d not as expected %d", + timeNow->type, PS_TIME_TAI); + return 2; + } + psFree(timeNow); + + // Attempt to get time with invalid type + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time type"); + timeNow = psTimeGetNow(-100); + if(timeNow != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid time type"); + return 3; + } + + return 0; +} + +psS32 testTimeGetUT1Delta(void) +{ + psTime* time = NULL; + psF64 ut1Delta = 0.0; + + // Attempt to convert NULL time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL time"); + ut1Delta = psTimeGetUT1Delta(time,PS_IERS_B); + if( !isnan(ut1Delta)) { + psError(PS_ERR_UNKNOWN,true,"Did not return NAN for NULL psTime"); + return 1; + } + + // Attempt to convert invalid time + time = psTimeAlloc(PS_TIME_TAI); + time->sec = 1; + time->nsec = 2e9; + time->leapsecond = false; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + ut1Delta = psTimeGetUT1Delta(time,PS_IERS_B); + if( !isnan(ut1Delta)) { + psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid time"); + return 2; + } + + // Attempt to convert time with invalid bulletin + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid bulletin"); + time->nsec = 2; + ut1Delta = psTimeGetUT1Delta(time,-100); + if( !isnan(ut1Delta)) { + psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid bulletin"); + return 3; + } + + // Attempt to get delta with valid time and bulletin A + time->sec = testTime1SecondsUTC; + time->nsec = testTime1NanosecondsUTC; + time->type = PS_TIME_UTC; + ut1Delta = psTimeGetUT1Delta(time,PS_IERS_A); + if(fabs(ut1Delta - testTime1UT1DeltaBullA) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"UT1 Delta %lf not as expected %lf test time 1 bulletin A", + ut1Delta,testTime1UT1DeltaBullA); + return 4; + } + + // Attempt to get delta with valid time and bulletin B + ut1Delta = psTimeGetUT1Delta(time,PS_IERS_B); + if(fabs(ut1Delta - testTime1UT1DeltaBullB) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"UT1 Delta %lf not as expected %lf test time 1 bulletin B", + ut1Delta,testTime1UT1DeltaBullB); + return 5; + } + + // Attempt to get delta with valid time and bulletin A + time->sec = testTime2SecondsUTC; + time->nsec = testTime2NanosecondsUTC; + time->type = PS_TIME_UTC; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning message predating table"); + ut1Delta = psTimeGetUT1Delta(time,PS_IERS_A); + if(fabs(ut1Delta - testTime2UT1DeltaBullA) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"UT1 Delta %lf not as expected %lf test time 2 bulletin A", + ut1Delta,testTime2UT1DeltaBullA); + return 6; + } + + // Attempt to get delta with valid time and bulletin B + psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning message predating table"); + ut1Delta = psTimeGetUT1Delta(time,PS_IERS_B); + if(fabs(ut1Delta - testTime2UT1DeltaBullB) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"UT1 Delta %lf not as expected %lf test time 2 bulletin B", + ut1Delta,testTime2UT1DeltaBullB); + return 7; + } + + // Attempt to get delta with valid time and bulletin A + time->sec = testTime3SecondsUTC; + time->nsec = testTime3NanosecondsUTC; + time->type = PS_TIME_UTC; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning message postdating table"); + ut1Delta = psTimeGetUT1Delta(time,PS_IERS_A); + if(fabs(ut1Delta - testTime3UT1DeltaBullA) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"UT1 Delta %lf not as expected %lf test time 3 bulletin A", + ut1Delta,testTime3UT1DeltaBullA); + return 8; + } + + // Attempt to get delta with valid time and bulletin B + psLogMsg(__func__,PS_LOG_INFO,"Following should generate a warning message postdating table"); + ut1Delta = psTimeGetUT1Delta(time,PS_IERS_B); + if(fabs(ut1Delta - testTime3UT1DeltaBullB) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"UT1 Delta %lf not as expected %lf test time 3 bulletin B", + ut1Delta,testTime3UT1DeltaBullB); + return 9; + } + + psFree(time); + + return 0; +} + +psS32 testTimeToMJD(void) +{ + psTime* time = NULL; + psF64 mjd = 0.0; + + // Attempt to convert with time NULL + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL time"); + mjd = psTimeToMJD(NULL); + if(!isnan(mjd)) { + psError(PS_ERR_UNKNOWN,true,"Expected NaN for NULL time"); + return 1; + } + + // Attempt to convert invalid time + time = psTimeAlloc(PS_TIME_UTC); + time->sec = 1; + time->nsec = 2e9; + time->leapsecond = false; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + mjd = psTimeToMJD(time); + if( !isnan(mjd)) { + psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid time"); + return 2; + } + + // Check valid time conversion to MJD after 1/1/1970 epoch + time->sec = testTime1SecondsUTC; + time->nsec = testTime1NanosecondsUTC; + mjd = psTimeToMJD(time); + if(fabs(mjd - testTime1MJD) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Expected MJD = %lf not as expected %lf", + mjd, testTime1MJD); + return 3; + } + + // Check valid time conversion to MJD before 1/1/1970 epoch + time->sec = testTime4SecondsUTC; + time->nsec = testTime4NanosecondsUTC; + mjd = psTimeToMJD(time); + if(fabs(mjd - testTime4MJD) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Expected MJD = %lf not as expected %lf", + mjd, testTime4MJD); + return 4; + } + + psFree(time); + + return 0; +} + +psS32 testTimeToJD(void) +{ + psTime* time = NULL; + psF64 jd = 0.0; + + // Attempt to convert with time NULL + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL time"); + jd = psTimeToJD(NULL); + if(!isnan(jd)) { + psError(PS_ERR_UNKNOWN,true,"Expected NaN for NULL time"); + return 1; + } + + // Attempt to convert invalid time + time = psTimeAlloc(PS_TIME_UTC); + time->sec = 1; + time->nsec = 2e9; + time->leapsecond = false; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + jd = psTimeToJD(time); + if( !isnan(jd)) { + psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid time"); + return 2; + } + + // Check valid time conversion to MJD after 1/1/1970 epoch + time->sec = testTime1SecondsUTC; + time->nsec = testTime1NanosecondsUTC; + jd = psTimeToJD(time); + if(fabs(jd - testTime1JD) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Expected JD = %lf not as expected %lf", + jd, testTime1JD); + return 3; + } + + // Check valid time conversion to MJD before 1/1/1970 epoch + time->sec = testTime4SecondsUTC; + time->nsec = testTime4NanosecondsUTC; + jd = psTimeToJD(time); + if(fabs(jd - testTime4JD) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Expected JD = %lf not as expected %lf", + jd, testTime4JD); + return 4; + } + + psFree(time); + + return 0; +} + +psS32 testTimeToISO(void) +{ + psTime* time = NULL; + char* timeStr = NULL; + + // Attempt to convert with NULL time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL time"); + timeStr = psTimeToISO(time); + if(timeStr != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 1; + } + + // Attempt to convert invalid time + time = psTimeAlloc(PS_TIME_UTC); + time->sec = 1; + time->nsec = 2e9; + time->leapsecond = false; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + timeStr = psTimeToISO(time); + if( timeStr != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid time"); + return 2; + } + + // Verify return NULL for time prior to year 0000 + time->sec = testTime5SecondsUTC; + time->nsec = testTime5NanosecondsUTC; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for time prior year 0000"); + timeStr = psTimeToISO(time); + if(timeStr != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for time prior to year 0000"); + return 3; + } + + // Verify return NULL for time after to year 9999 + time->sec = testTime6SecondsUTC; + time->nsec = testTime6NanosecondsUTC; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for time after year 9999"); + timeStr = psTimeToISO(time); + if(timeStr != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for time after to year 9999"); + return 4; + } + + // Verify return string with valid time + time->sec = testTime1SecondsUTC; + time->nsec = testTime1NanosecondsUTC; + timeStr = psTimeToISO(time); + if(strcmp(timeStr,testTime1Str) != 0) { + psError(PS_ERR_UNKNOWN,true,"String %s not as expected %s", + timeStr, testTime1Str); + return 5; + } + psFree(timeStr); + + // Verify return string with valid time and leap second set + time->sec = testTime1SecondsUTC; + time->nsec = testTime1NanosecondsUTC; + time->leapsecond = true; + timeStr = psTimeToISO(time); + if(strcmp(timeStr,testTime1StrLeap) != 0) { + psError(PS_ERR_UNKNOWN,true,"String %s not as expected %s", + timeStr, testTime1StrLeap); + return 6; + } + psFree(timeStr); + psFree(time); + + return 0; +} + +psS32 testTimeToTimeval(void) +{ + psTime* time = NULL; + struct timeval* timevalTime = NULL; + + // Attempt to convert with NULL time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL time"); + timevalTime = psTimeToTimeval(time); + if(timevalTime != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 1; + } + + // Attempt to convert invalid time + time = psTimeAlloc(PS_TIME_UTC); + time->sec = 1; + time->nsec = 2e9; + time->leapsecond = false; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + timevalTime = psTimeToTimeval(time); + if( timevalTime != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid time"); + return 2; + } + + // Attempt to convert invalid time + time->sec = -1; + time->nsec = 0; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + timevalTime = psTimeToTimeval(time); + if( timevalTime != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid time"); + return 2; + } + + // Verify convert to timeval with valid time + time->sec = testTime1SecondsUTC; + time->nsec = testTime1NanosecondsUTC; + timevalTime = psTimeToTimeval(time); + if(timevalTime->tv_sec != testTime1TimevalSec) { + psError(PS_ERR_UNKNOWN,true,"Timeval seconds %ld not as expectd %ld", + timevalTime->tv_sec,testTime1TimevalSec); + return 4; + } + if(timevalTime->tv_usec != testTime1TimevalUsec) { + psError(PS_ERR_UNKNOWN,true,"Timeval useconds %ld not as expected %ld", + timevalTime->tv_usec,testTime1TimevalUsec); + return 5; + } + + psFree(timevalTime); + psFree(time); + + return 0; +} + +psS32 testTimeFromMJD(void) +{ + psTime* time = NULL; + + // Attempt to convert valid time to psTime + time = psTimeFromMJD(testTime1MJDTAI); + if(time->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", + time->type,PS_TIME_TAI); + return 1; + } + if(time->sec != testTime1SecondsTAI) { + psError(PS_ERR_UNKNOWN,true,"psTime seconds %ld not as expected %ld", + (long int)time->sec,testTime1SecondsTAI); + return 2; + } + psFree(time); + + // Attempt to convert valid time before 1970 epoch + time = psTimeFromMJD(testTime4MJD); + if(time->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", + time->type,PS_TIME_TAI); + return 3; + } + if(time->sec != testTime4SecondsUTC) { + psError(PS_ERR_UNKNOWN,true,"psTime seconds %ld not as expected %ld", + (long int)time->sec,testTime4SecondsUTC); + return 4; + } + psFree(time); + + return 0; +} + +psS32 testTimeFromJD(void) +{ + psTime* time = NULL; + + // Attempt to convert valid time to psTime + time = psTimeFromJD(testTime1JDTAI); + if(time->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", + time->type,PS_TIME_TAI); + return 1; + } + if(time->sec != testTime1SecondsTAI) { + psError(PS_ERR_UNKNOWN,true,"psTime seconds %ld not as expected %ld", + (long int)time->sec,(long int)testTime1SecondsTAI); + return 2; + } + psFree(time); + + // Attempt to convert valid time before 1970 epoch + time = psTimeFromJD(testTime4JD); + if(time->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", + time->type,PS_TIME_TAI); + return 3; + } + if(time->sec != testTime4SecondsUTC) { + psError(PS_ERR_UNKNOWN,true,"psTime seconds %ld not as expected %ld", + (long int)time->sec,testTime4SecondsUTC); + return 4; + } + psFree(time); + + return 0; +} + +psS32 testTimeFromISO(void) +{ + psTime* time = NULL; + + // Attempt to convert NULL string + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL ISO string"); + time = psTimeFromISO(NULL); + if(time != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected for NULL ISO string"); + return 1; + } + + // Convert valid ISO string + time = psTimeFromISO(testTime1Str); + if(time->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d", + time->type, PS_TIME_TAI); + return 2; + } + if(time->sec != testTime1SecondsUTC) { + psError(PS_ERR_UNKNOWN,true,"psTime seconds %ld not as expected %ld", + (long int)time->sec,testTime1SecondsTAI); + return 3; + } + psFree(time); + + // Attempt to convert invalid ISO string + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error for invalid ISO string"); + time = psTimeFromISO("Here I am"); + if(time != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected for invalid ISO string"); + return 4; + } + psFree(time); + + return 0; +} + +psS32 testTimeFromTimeval(void) +{ + psTime* time = NULL; + struct timeval* timevalTime = NULL; + + // Attempt to create psTime from NULL timeval ptr + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL timeval"); + time = psTimeFromTimeval(NULL); + if(time != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for NULL timeval ptr"); + return 1; + } + + // Convert valid timeval structure + timevalTime = (struct timeval*)psAlloc(sizeof(struct timeval)); + timevalTime->tv_sec = testTime1SecondsTAI; + timevalTime->tv_usec = testTime1NanosecondsTAI / 1000; + time = psTimeFromTimeval(timevalTime); + if(time == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not expect NULL return value for valid timeval"); + return 2; + } + if(time->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"psTime type %d not as expected %d", + time->type, PS_TIME_TAI); + return 3; + } + if(time->sec != testTime1SecondsTAI) { + psError(PS_ERR_UNKNOWN,true,"psTime seconds %ld not as expected %ld", + time->sec, testTime1SecondsTAI); + return 4; + } + if(time->nsec != testTime1NanosecondsTAI) { + psError(PS_ERR_UNKNOWN,true,"psTime nanosec %ld not as expected %ld", + time->nsec, testTime1NanosecondsTAI); + return 5; + } + psFree(timevalTime); + psFree(time); + + return 0; +} + +psS32 testTimeFromTM(void) +{ + psTime* time = NULL; + struct tm* tmTime = NULL; + + // Attempt to convert from NULL tm structure ptr + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL tm ptr"); + time = p_psTimeFromTM(tmTime); + if(time != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for NULL tm ptr"); + return 1; + } + + // Verify convert for valid tm structure + tmTime = (struct tm*)psAlloc(sizeof(struct tm)); + tmTime->tm_year = testTime7TmYear; + tmTime->tm_mon = testTime7TmMon; + tmTime->tm_mday = testTime7TmDay; + tmTime->tm_hour = testTime7TmHour; + tmTime->tm_min = testTime7TmMin; + tmTime->tm_sec = testTime7TmSec; + time = p_psTimeFromTM(tmTime); + if(time == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not expect NULL return value for valid tm structure"); + return 2; + } + if(time->sec != testTime7Seconds) { + psError(PS_ERR_UNKNOWN,true,"psTime seconds %ld not as expected %ld", + (long int)time->sec, (long int)testTime7Seconds); + return 3; + } + if(time->nsec != testTime7Nanoseconds) { + psError(PS_ERR_UNKNOWN,true,"psTime nanoseconds %ld not as expected %ld", + time->nsec, testTime7Nanoseconds); + return 4; + } + psFree(tmTime); + psFree(time); + + // Verify convert for valid tm structure + tmTime = (struct tm*)psAlloc(sizeof(struct tm)); + tmTime->tm_year = testTime8TmYear; + tmTime->tm_mon = testTime8TmMon; + tmTime->tm_mday = testTime8TmDay; + tmTime->tm_hour = testTime8TmHour; + tmTime->tm_min = testTime8TmMin; + tmTime->tm_sec = testTime8TmSec; + time = p_psTimeFromTM(tmTime); + if(time == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not expect NULL return value for valid tm structure"); + return 2; + } + if(time->sec != testTime8Seconds) { + psError(PS_ERR_UNKNOWN,true,"psTime seconds %ld not as expected %ld", + (long int)time->sec, (long int)testTime8Seconds); + return 3; + } + if(time->nsec != testTime8Nanoseconds) { + psError(PS_ERR_UNKNOWN,true,"psTime nanoseconds %ld not as expected %ld", + time->nsec, testTime8Nanoseconds); + return 4; + } + psFree(tmTime); + psFree(time); + + return 0; +} + +psS32 testTimeConvert(void) +{ + psTime* time1 = NULL; + psTime* time2 = NULL; + + // Attempt to convert NULL time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL time"); + time2 = psTimeConvert(time1,PS_TIME_TAI); + // Verify return value is NULL + if(time2 != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for NULL time specified"); + return 1; + } + + // Attempt to convert to invalid type + time1 = psTimeAlloc(PS_TIME_TAI); + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid type"); + time2 = psTimeConvert(time1,-100); + // Verify return value is NULL + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for invalid type to convert to"); + return 2; + } + time1->type = PS_TIME_UTC; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid type"); + time2 = psTimeConvert(time1,-100); + // Verify return value is NULL + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for invalid type to convert to"); + return 2; + } + time1->type = PS_TIME_TT; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid type"); + time2 = psTimeConvert(time1,-100); + // Verify return value is NULL + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for invalid type to convert to"); + return 2; + } + time1->type = -100; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid type"); + time2 = psTimeConvert(time1,PS_TIME_TAI); + // Verify return value is NULL + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for invalid type to convert to"); + return 2; + } + + // Attempt to convert with invalid time nsec > 1e9 + time1->nsec = 2e9; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + time2 = psTimeConvert(time1,PS_TIME_TAI); + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for invalid time specified"); + return 3; + } + + //Attempt to convert a time to the same type + time2 = NULL; + time1->sec = 1; + time1->nsec = 2; + time1->type = PS_TIME_TAI; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_TAI); + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion to same type"); + return 4; + } + // Verify time not changed + if((time2->sec != 1) || (time2->nsec != 2) || (time2->type != PS_TIME_TAI) || + (time2->leapsecond != false) ) { + psError(PS_ERR_UNKNOWN,true,"Time member changes when no change expected"); + return 5; + } + + // Attempt to convert a UTC time to a TAI + time2 = NULL; + time1->sec = testTime1SecondsUTC; + time1->nsec = testTime1NanosecondsUTC; + time1->type = PS_TIME_UTC; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_TAI); + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from UTC to TAI"); + return 6; + } + // Verify time type + if(time2->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"Returned time type %d not as expected %d", + time2->type, PS_TIME_TAI); + return 7; + } + // Verify time is TAI as expected + if(time2->sec != testTime1SecondsTAI) { + psError(PS_ERR_UNKNOWN,true,"TAI seconds = %ld not as expected %ld",(long int)time2->sec, + (long int)testTime1SecondsTAI); + return 7; + } + if(time2->nsec != testTime1NanosecondsTAI) { + psError(PS_ERR_UNKNOWN,true,"TAI nanoseconds = %ld not as expected %ld",(long int)time2->nsec, + (long int)testTime1NanosecondsTAI); + return 8; + } + + // Attempt to convert a UTC time to a TT + time2 = NULL; + time1->sec = testTime1SecondsUTC; + time1->nsec = testTime1NanosecondsUTC; + time1->type = PS_TIME_UTC; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_TT); + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from UTC to TT"); + return 6; + } + // Verify time type + if(time2->type != PS_TIME_TT) { + psError(PS_ERR_UNKNOWN,true,"Returned time type %d not as expected %d", + time2->type, PS_TIME_TT); + return 7; + } + // Verify time is TT as expected + if(time2->sec != testTime1SecondsTT) { + psError(PS_ERR_UNKNOWN,true,"TT seconds = %ld not as expected %ld",(long int)time2->sec, + (long int)testTime1SecondsTT); + return 7; + } + if(time2->nsec != testTime1NanosecondsTT) { + psError(PS_ERR_UNKNOWN,true,"TT nanoseconds = %ld not as expected %ld",(long int)time2->nsec, + (long int)testTime1NanosecondsTT); + return 8; + } + + // Attempt to convert a UTC time to UT1 + time2 = NULL; + time1->sec = testTime1SecondsUTC; + time1->nsec = testTime1NanosecondsUTC; + time1->type = PS_TIME_UTC; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_UT1); + if(time1 != time2) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from UTC to UT1"); + return 9; + } + // Verify time type + if(time2->type != PS_TIME_UT1) { + psError(PS_ERR_UNKNOWN,true,"Returned time type %d not as expected %d", + time2->type, PS_TIME_UT1); + return 7; + } + // Verify time is UT1 as expected + if(time2->sec != testTime1SecondsUT1) { + psError(PS_ERR_UNKNOWN,true,"UT1 seconds = %ld not as expected %ld",(long int)time2->sec, + (long int)testTime1SecondsUT1); + return 9; + } + if(time2->nsec != testTime1NanosecondsUT1) { + psError(PS_ERR_UNKNOWN,true,"UT1 nanoseconds = %d not as expected %d",time2->nsec, + testTime1NanosecondsUT1); + return 10; + } + + // Attempt to convert a TAI time to UTC + time2 = NULL; + time1->sec = testTime1SecondsTAI; + time1->nsec = testTime1NanosecondsTAI; + time1->type = PS_TIME_TAI; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_UTC); + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from TAI to UTC"); + return 11; + } + // Verify time type + if(time2->type != PS_TIME_UTC) { + psError(PS_ERR_UNKNOWN,true,"Returned time type %d not as expected %d", + time2->type, PS_TIME_UTC); + return 7; + } + // Verify time is UTC as expected + if(time2->sec != testTime1SecondsUTC) { + psError(PS_ERR_UNKNOWN,true,"UTC seconds = %ld not as expected %ld",(long int)time2->sec, + (long int)testTime1SecondsUTC); + return 12; + } + if(time2->nsec != testTime1NanosecondsUTC) { + psError(PS_ERR_UNKNOWN,true,"UTC nanoseconds = %ld not as expected %ld",(long int)time2->nsec, + (long int)testTime1NanosecondsUTC); + return 13; + } + + // Attempt to convert a TAI time to TT + time2 = NULL; + time1->sec = testTime1SecondsTAI; + time1->nsec = testTime1NanosecondsTAI; + time1->type = PS_TIME_TAI; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_TT); + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from TAI to TT"); + return 14; + } + // Verify time type + if(time2->type != PS_TIME_TT) { + psError(PS_ERR_UNKNOWN,true,"Returned time type %d not as expected %d", + time2->type, PS_TIME_TT); + return 7; + } + // Verify time is TT as expected + if(time2->sec != testTime1SecondsTT) { + psError(PS_ERR_UNKNOWN,true,"TT seconds = %ld not as expected %ld",(long int)time2->sec, + (long int)testTime1SecondsTT); + return 15; + } + if(time2->nsec != testTime1NanosecondsTT) { + psError(PS_ERR_UNKNOWN,true,"TT nanoseconds = %ld not as expected %ld",(long int)time2->nsec, + (long int)testTime1NanosecondsTT); + return 16; + } + + // Attempt to convert a TAI time to UT1 + time2 = NULL; + time1->sec = testTime1SecondsTAI; + time1->nsec = testTime1NanosecondsTAI; + time1->type = PS_TIME_TAI; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_UT1); + if(time1 != time2) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from TAI to UT1"); + return 9; + } + // Verify time type + if(time2->type != PS_TIME_UT1) { + psError(PS_ERR_UNKNOWN,true,"Returned time type %d not as expected %d", + time2->type, PS_TIME_UT1); + return 7; + } + // Verify time is UT1 as expected + if(time2->sec != testTime1SecondsUT1) { + psError(PS_ERR_UNKNOWN,true,"UT1 seconds = %ld not as expected %ld",(long int)time2->sec, + (long int)testTime1SecondsUT1); + return 9; + } + if(time2->nsec != testTime1NanosecondsUT1) { + psError(PS_ERR_UNKNOWN,true,"UT1 nanoseconds = %d not as expected %d",time2->nsec, + testTime1NanosecondsUT1); + return 10; + } + + // Attempt to convert a TT time to UTC + time2 = NULL; + time1->sec = testTime1SecondsTT; + time1->nsec = testTime1NanosecondsTT; + time1->type = PS_TIME_TT; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_UTC); + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from TT to UTC"); + return 17; + } + // Verify time type + if(time2->type != PS_TIME_UTC) { + psError(PS_ERR_UNKNOWN,true,"Returned time type %d not as expected %d", + time2->type, PS_TIME_UTC); + return 7; + } + // Verify time is UTC as expected + if(time2->sec != testTime1SecondsUTC) { + psError(PS_ERR_UNKNOWN,true,"UTC seconds = %ld not as expected %ld",(long int)time2->sec, + (long int)testTime1SecondsUTC); + return 18; + } + if(time2->nsec != testTime1NanosecondsUTC) { + psError(PS_ERR_UNKNOWN,true,"UTC nanoseconds = %ld not as expected %ld",(long int)time2->nsec, + (long int)testTime1NanosecondsUTC); + return 19; + } + + // Attempt to convert a TT time to TAI + time2 = NULL; + time1->sec = testTime1SecondsTT; + time1->nsec = testTime1NanosecondsTT; + time1->type = PS_TIME_TT; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_TAI); + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from TT to TAI"); + return 20; + } + // Verify time type + if(time2->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"Returned time type %d not as expected %d", + time2->type, PS_TIME_TAI); + return 7; + } + // Verify time is TAI as expected + if(time2->sec != testTime1SecondsTAI) { + psError(PS_ERR_UNKNOWN,true,"TAI seconds = %ld not as expected %ld",(long int)time2->sec, + (long int)testTime1SecondsTAI); + return 21; + } + if(time2->nsec != testTime1NanosecondsTAI) { + psError(PS_ERR_UNKNOWN,true,"TT nanoseconds = %ld not as expected %ld",(long int)time2->nsec, + (long int)testTime1NanosecondsTAI); + return 22; + } + + // Attempt to convert a TT time to UT1 + time2 = NULL; + time1->sec = testTime1SecondsTT; + time1->nsec = testTime1NanosecondsTT; + time1->type = PS_TIME_TT; + time1->leapsecond = false; + time2 = psTimeConvert(time1,PS_TIME_UT1); + if(time1 != time2) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from TT to UT1"); + return 9; + } + // Verify time type + if(time2->type != PS_TIME_UT1) { + psError(PS_ERR_UNKNOWN,true,"Returned time type %d not as expected %d", + time2->type, PS_TIME_UT1); + return 7; + } + // Verify time is UT1 as expected + if(time2->sec != testTime1SecondsUT1) { + psError(PS_ERR_UNKNOWN,true,"UT1 seconds = %ld not as expected %ld",(long int)time2->sec, + (long int)testTime1SecondsUT1); + return 9; + } + if(time2->nsec != testTime1NanosecondsUT1) { + psError(PS_ERR_UNKNOWN,true,"UT1 nanoseconds = %d not as expected %d",time2->nsec, + testTime1NanosecondsUT1); + return 10; + } + + // Attempt to convert from UT1 to TAI, UTC, TT + time2 = NULL; + time1->sec = 1; + time1->nsec = 2; + time1->type = PS_TIME_UT1; + time1->leapsecond = false; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message converting from UT1"); + time2 = psTimeConvert(time1,PS_TIME_UTC); + if(time2 != time1) { + psError(PS_ERR_UNKNOWN,true,"Did not return time for conversion from UT1"); + return 23; + } + + psFree(time1); + + return 0; +} + +//psS32 testTimeOther(void) +//{ +// psTime *testTime; +// char *testString = "2004-07-21T18:22:24.272Z"; +// +// psLibInit("psTime.config"); +// +// Test time was taken at July 21, 2004 at 18:22:24.272044 +// testTime = (psTime*)psAlloc(sizeof(psTime)); +// testTime->sec = 1090434144; +// testTime->nsec = 272044000; +// testTime->type = PS_TIME_TAI; + +// Test O - psTime to LMST +// printPositiveTestHeader(stdout, "psTime", "Convert psTime time to LST"); +// char *testString2 = "2004-09-10T1:00:00.00Z"; +// psTime* testTime2 = NULL; +// testTime2 = psTimeFromISO(testString2); +// double dblTime = psTimeToLMST(testTime2, 1); +// printf("LST (rad): %lf\n", dblTime); +// psFree(testTime2); +// printFooter(stdout, "psTime", "Convert psTime time to LST", true); + + +// return 0; +//} Index: /trunk/psLib/test/astro/tst_psTime_02.c =================================================================== --- /trunk/psLib/test/astro/tst_psTime_02.c (revision 4547) +++ /trunk/psLib/test/astro/tst_psTime_02.c (revision 4547) @@ -0,0 +1,368 @@ +/** @file tst_psTime_02.c + * + * @brief Test driver for psTime functions + * + * This test driver contains the following tests for psTime: + * 1) Convert psTime to Local Mean Sidereal Time (LMST) + * 2) Calculate leap second delta between times + * 3) Creation of psTime of type TT + * 4) Creation of psTime of type UTC + * + * @author Ross Harman, MHPCC + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-07-13 02:46:58 $ + * + * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii + * + */ + +#include "pslib_strict.h" +#include "psTest.h" + +#define ERROR_TOL 0.001 + +static psS32 testTimeLMST(void); +static psS32 testTimeLeapSecondDelta(void); +static psS32 testTimeIsLeapSecond(void); +static psS32 testTimeFromTT(void); +static psS32 testTimeFromUTC(void); + +// Test Time 1 : May 9, 2005 00:00:00,0 +// MJD = 53499.000 +// JD = 2453499.5 +// UTC Test Time 1 +const psS64 testTime1SecondsUTC = 1115596900; +const psU32 testTime1NanosecondsUTC = 0; +// Expected LMST 15:09:18 +const psF64 testTime1LMST0 = 3.967604; + +// Test Time 2 : May 9, 1995 00:00:00,0 +// MJD = 49846.00 +// JD = 2449846.5 +// UTC Test Time 2 +const psS64 testTime2SecondsUTC = 799977600; +const psU32 testTime2NanosecondsUTC = 0; +// Expected leap second delta +const psS64 testTimeLeapSecondDelta1 = 3; + +// Test Time 3: Jan 1, 1999 00:00:00,0 +// MJD = 51179 +// JD = 2451179.5 +const psS64 testTime3SecondsUTC = 915148800; +const psU32 testTime3NanosecondsUTC = 0; + +testDescription tests[] = { + {testTimeLMST,000,"psTimeToLMST",0,false}, + {testTimeLeapSecondDelta,000,"psTimeLeapSecondDelta",0,false}, + {testTimeIsLeapSecond,000,"psTimeIsLeapSecond",0,false}, + {testTimeFromTT,000,"psTimeFromTT",0,false}, + {testTimeFromUTC,000,"psTimeFromUTC",0,false}, + {NULL} + }; +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetLevel(PS_LOG_INFO); + + // Initialize library internal structures + psLibInit("psTime.config"); + + if( !runTestSuite(stderr,"psTime",tests,argc,argv)) { + return 1; + } + + // Clean up library + psLibFinalize(); + + return 0; +} + +psS32 testTimeLMST(void) +{ + psTime* time = NULL; + psF64 lmst = 0.0; + + // Attempt to get LMST with NULL time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL time"); + lmst = psTimeToLMST(time,0); + if(!isnan(lmst)) { + psError(PS_ERR_UNKNOWN,true,"Did not return NaN as expected %lf",lmst); + return 1; + } + + // Attempt to get LMST with valid test time + // Allocate test time + time = psTimeAlloc(PS_TIME_UTC); + time->sec = testTime1SecondsUTC; + time->nsec = testTime1NanosecondsUTC; + time->leapsecond = false; + lmst = psTimeToLMST(time,0.0); + if(fabs(lmst-testTime1LMST0) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"LMST %lf not as expected %lf",lmst,testTime1LMST0); + return 2; + } + + // Attempt to get LMST with invalid input time UT1 + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for incorrect type"); + time->type = PS_TIME_UT1; + lmst = psTimeToLMST(time,0.0); + if(!isnan(lmst)) { + psError(PS_ERR_UNKNOWN,true,"Did not return NaN as expected %lf",lmst); + return 3; + } + psFree(time); + + return 0; +} + +psS32 testTimeLeapSecondDelta(void) +{ + psTime* time1 = NULL; + psTime* time2 = NULL; + psS64 delta = 0; + + // Attempt to get delta with NULL time1 argument + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL time"); + delta = psTimeLeapSecondDelta(time1,time2); + if(delta != 0) { + psError(PS_ERR_UNKNOWN,true,"Delta of %ld not as expected 0",(long int)delta); + return 1; + } + + // Set test time 1 + time1 = psTimeAlloc(PS_TIME_UTC); + time1->sec = testTime1SecondsUTC; + time1->nsec = testTime1NanosecondsUTC; + time1->leapsecond = false; + + // Attempt to get delta with NULL time2 argument + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL time"); + delta = psTimeLeapSecondDelta(time1,time2); + if(delta != 0) { + psError(PS_ERR_UNKNOWN,true,"Delta of %ld not as expected 0",(long int)delta); + return 2; + } + + // Set test time 2 with invalid time + time2 = psTimeAlloc(PS_TIME_UTC); + time2->sec = 0; + time2->nsec = 2e9; + time2->leapsecond = false; + + // Attempt to get delta with invalid time2 + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + delta = psTimeLeapSecondDelta(time1,time2); + if(delta != 0) { + psError(PS_ERR_UNKNOWN,true,"Delta of %ld not as expected 0",(long int)delta); + return 3; + } + + // Set test time 2 valid + time2->sec = testTime2SecondsUTC; + time2->nsec = testTime2NanosecondsUTC; + + // Set test time 1 invalid + time1->sec = 0; + time1->nsec = 2e9; + + // Attempt to get delta with invalid time1 + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + delta = psTimeLeapSecondDelta(time1,time2); + if(delta != 0) { + psError(PS_ERR_UNKNOWN,true,"Delta of %ld not as expected 0",(long int)delta); + return 4; + } + + // Set test time 1 to greater time + time1->sec = testTime1SecondsUTC; + time1->nsec = testTime1NanosecondsUTC; + delta = psTimeLeapSecondDelta(time1,time2); + if(delta != testTimeLeapSecondDelta1) { + psError(PS_ERR_UNKNOWN,true,"Delta %ld not as expected %ld", + (long int)delta,(long int)testTimeLeapSecondDelta1); + return 5; + } + + // Set test time 1 to lesser time + delta = psTimeLeapSecondDelta(time2,time1); + if(delta != testTimeLeapSecondDelta1) { + psError(PS_ERR_UNKNOWN,true,"Delta %ld not as expected %ld", + (long int)delta,(long int)testTimeLeapSecondDelta1); + return 6; + } + + // Attempt to get delta with times equal + delta = psTimeLeapSecondDelta(time1,time1); + if(delta != 0) { + psError(PS_ERR_UNKNOWN,true,"Delta %ld not as expected 0",(long int)delta); + return 7; + } + + psFree(time2); + psFree(time1); + + return 0; +} + +psS32 testTimeIsLeapSecond(void) +{ + psTime* time = NULL; + psBool leapsecond = false; + + // Attempt to determine if leap second with NULL time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL time"); + leapsecond = psTimeIsLeapSecond(time); + if(leapsecond) { + psError(PS_ERR_UNKNOWN,true,"Leapsecond flag %d not as expected 0",leapsecond); + return 1; + } + + // Set time + time = psTimeAlloc(PS_TIME_TAI); + time->sec = testTime1SecondsUTC; + time->nsec = testTime1NanosecondsUTC; + time->leapsecond = false; + + // Attempt to determine if leap second with non-UTC time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid type"); + leapsecond = psTimeIsLeapSecond(time); + if(leapsecond) { + psError(PS_ERR_UNKNOWN,true,"Leapsecond flag %d not as expected 0",leapsecond); + return 2; + } + + // Set time to UTC + time->type = PS_TIME_UTC; + + // Attempt to determine if leap second with valid time + leapsecond = psTimeIsLeapSecond(time); + if(leapsecond) { + psError(PS_ERR_UNKNOWN,true,"Leapsecond flag %d not a expected 0",leapsecond); + return 3; + } + + // Set time to UTC with leap second + time->sec = testTime3SecondsUTC; + time->nsec = testTime3NanosecondsUTC; + leapsecond = psTimeIsLeapSecond(time); + if(!leapsecond) { + psError(PS_ERR_UNKNOWN,true,"Leapsecond flag %d not a expected 1",leapsecond); + return 4; + } + + // Set time to 1 second before a known leap second + time->sec--; + leapsecond = psTimeIsLeapSecond(time); + if(leapsecond) { + psError(PS_ERR_UNKNOWN,true,"Leapsecond flag %d not as expected 0",leapsecond); + return 5; + } + + // Set time to 1 second after a known leap second + time->sec +=2; + leapsecond = psTimeIsLeapSecond(time); + if(leapsecond) { + psError(PS_ERR_UNKNOWN,true,"Leapsecond flag %d not as expected 0",leapsecond); + return 6; + } + + psFree(time); + + return 0; +} + +psS32 testTimeFromTT(void) +{ + psTime* time = NULL; + + // Attempt to create psTime with invalid time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + time = psTimeFromTT(0,2e9); + if(time != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 1; + } + + // Attempt to create psTime with valid time + time = psTimeFromTT(testTime1SecondsUTC,testTime1NanosecondsUTC); + if(time == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return NULL when not expected"); + return 2; + } + if(time->type != PS_TIME_TT) { + psError(PS_ERR_UNKNOWN,true,"Type of time object %d not as expected %d", + time->type,PS_TIME_TT); + return 3; + } + if((time->sec != testTime1SecondsUTC) || (time->nsec != testTime1NanosecondsUTC)) { + psError(PS_ERR_UNKNOWN,true,"Seconds %ld nanoseconds %d not as expected seconds %ld nanoseconds %d", + (long int)time->sec,time->nsec,(long int)testTime1SecondsUTC,testTime1NanosecondsUTC); + return 4; + } + psFree(time); + + return 0; +} + +psS32 testTimeFromUTC(void) +{ + psTime* time = NULL; + + // Attempt to create psTime with invalid time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid time"); + time = psTimeFromUTC(0,2e9,true); + if(time != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL as expected"); + return 1; + } + + // Attempt to create psTime with valid non-leapsecond time and leapsecond flag true + time = psTimeFromUTC(testTime1SecondsUTC,testTime1NanosecondsUTC,true); + if(time == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return NULL when not expected"); + return 2; + } + if(time->type != PS_TIME_UTC) { + psError(PS_ERR_UNKNOWN,true,"Type of time object %d not as expected %d", + time->type,PS_TIME_UTC); + return 3; + } + if((time->sec != testTime1SecondsUTC) || (time->nsec != testTime1NanosecondsUTC)) { + psError(PS_ERR_UNKNOWN,true,"Seconds %ld nanoseconds %d not as expected seconds %ld nanoseconds %d", + (long int)time->sec,time->nsec,(long int)testTime1SecondsUTC,testTime1NanosecondsUTC); + return 4; + } + if(time->leapsecond) { + psError(PS_ERR_UNKNOWN,true,"Leapsecond flag %d not as expected 0",time->leapsecond); + return 5; + } + psFree(time); + + // Attempt to create psTime with valid leapsecond time but leapsecond flag false + time = psTimeFromUTC(testTime3SecondsUTC,testTime3NanosecondsUTC,false); + if(time == NULL) { + psError(PS_ERR_UNKNOWN,true,"Return NULL when not expected"); + return 6; + } + if(time->type != PS_TIME_UTC) { + psError(PS_ERR_UNKNOWN,true,"Type of time object %d not as expected %d", + time->type,PS_TIME_UTC); + return 7; + } + if((time->sec != testTime3SecondsUTC) || (time->nsec != testTime3NanosecondsUTC)) { + psError(PS_ERR_UNKNOWN,true,"Seconds %ld nanoseconds %d not as expected seconds %ld nanoseconds %d", + (long int)time->sec,time->nsec,(long int)testTime1SecondsUTC,testTime1NanosecondsUTC); + return 8; + } + if(!time->leapsecond) { + psError(PS_ERR_UNKNOWN,true,"Leapsecond flag %d not as expected 1",time->leapsecond); + return 9; + } + + + psFree(time); + + return 0; +} + Index: /trunk/psLib/test/astro/tst_psTime_03.c =================================================================== --- /trunk/psLib/test/astro/tst_psTime_03.c (revision 4547) +++ /trunk/psLib/test/astro/tst_psTime_03.c (revision 4547) @@ -0,0 +1,501 @@ +/** @file tst_psTime_03.c + * + * @brief Test driver for psTime functions + * + * This test driver contains the following tests for psTime: + * 1) psTimeMath invalid times + * 2) psTimeMath valid time of different types + * 3) psTimeDelta valid times with different types + * + * @author Ross Harman, MHPCC + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-07-13 02:46:58 $ + * + * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii + * + */ + +#include "pslib_strict.h" +#include "psTest.h" +#include + +#define ERROR_TOL 0.001 + +static psS32 testTimeMath(void); +static psS32 testTimeDelta(void); +static psS32 testTimeConvert1(void); + +// Test Time 1 : May 9, 2005 00:00:00,0 +// MJD = 53499.00 +// JD = 2453499.5 +// UTC Test Time 1 +const psS64 testTime1SecondsUTC = 1115596900; +const psU32 testTime1NanosecondsUTC = 0; +// TAI Test Time 1 +const psS64 testTime1SecondsTAI = 1115596932; +const psU32 testTime1NanosecondsTAI = 0; +// TT Test Time 1 +const psS64 testTime1SecondsTT = 1115596964; +const psU32 testTime1NanosecondsTT = 184000000; +// UT1 Test Time 1 +const psS64 testTime1SecondsUT1 = 1115596900; +const psU32 testTime1NanosecondsUT1 = 184000000; +// Delta 1 +const psF64 deltaTime1 = -15.5; +// Expected UTC Time 1 +const psS64 newTestTime1SecondsUTC = 1115596884; +const psU32 newTestTime1NanosecondsUTC = 500000000; +// Expected TAI Time 1 +const psS64 newTestTime1SecondsTAI = 1115596916; +const psU32 newTestTime1NanosecondsTAI = 500000000; +// Delta 2 +const psF64 deltaTime2 = 123.066; +// Expected TT Time 1 w/ delta 2 +const psS64 newTestTime1SecondsTT = 1115597087; +const psU32 newTestTime1NanosecondsTT = 250000000; +// Expected UT1 Time 1 w/ delta 2 +const psS64 newTestTime1SecondsUT1 = 1115597023; +const psU32 newTestTime1NanosecondsUT1 = 250000000; + +// Test Time 2 : Dec. 31 1998 23:59:45,0 +// MJD = 51178.99983 +// JD = 2451179.49983 +// UTC Test Time 1 +const psS64 testTime2SecondsUTC = 915148785; +const psU32 testTime2NanosecondsUTC = 0; +// Delta 3 +const psF64 deltaTime3 = 30.0; +// Expected UTC Time +const psS64 newTestTime2SecondsUTC = 915148814; +const psU32 newTestTime2NanosecondsUTC = 0; + +// Appendix B time conversion tests +// +#define APPB_TESTS 8 +const psS64 testTimeBSeconds[APPB_TESTS] = + { + 915148829, + 915148829, + 915148830, + 915148830, + 915148831, + 915148831, + 915148832, + 915148832 + }; +const psU32 testTimeBNanoseconds[APPB_TESTS] = + { + 0, + 500000000, + 0, + 500000000, + 0, + 500000000, + 0, + 500000000 + }; +const psBool testTimeBLeapsecond[APPB_TESTS] = + { + false, + false, + false, + false, + true, + true, + false, + false + }; +// Expected results +const char* testTimeBStrUTC[APPB_TESTS] = + { + "1998-12-31T23:59:58,0Z", + "1998-12-31T23:59:58,5Z", + "1998-12-31T23:59:59,0Z", + "1998-12-31T23:59:59,5Z", + "1998-12-31T23:59:60,0Z", + "1998-12-31T23:59:60,5Z", + "1999-01-01T00:00:00,0Z", + "1999-01-01T00:00:00,5Z" + }; +const char* testTimeBStrTAI[APPB_TESTS] = + { + "1999-01-01T00:00:29,0Z", + "1999-01-01T00:00:29,5Z", + "1999-01-01T00:00:30,0Z", + "1999-01-01T00:00:30,5Z", + "1999-01-01T00:00:31,0Z", + "1999-01-01T00:00:31,5Z", + "1999-01-01T00:00:32,0Z", + "1999-01-01T00:00:32,5Z" + }; +const char* testTimeBStrTT[APPB_TESTS] = + { + "1999-01-01T00:01:01,1Z", + "1999-01-01T00:01:01,6Z", + "1999-01-01T00:01:02,1Z", + "1999-01-01T00:01:02,6Z", + "1999-01-01T00:01:03,1Z", + "1999-01-01T00:01:03,6Z", + "1999-01-01T00:01:04,1Z", + "1999-01-01T00:01:04,6Z" + }; +const char* testTimeBStrUT1[APPB_TESTS] = + { + "1998-12-31T23:59:58,7Z", + "1998-12-31T23:59:59,2Z", + "1998-12-31T23:59:59,7Z", + "1998-12-31T23:59:60,2Z", + "1998-12-31T23:59:60,7Z", + "1999-01-01T00:00:00,2Z", + "1999-01-01T00:00:00,7Z", + "1999-01-01T00:00:01,2Z" + }; + +// Test Time B1 : Dec 31, 1998 23:59:58,0 +// MJD = 51178.99998 +// JD = 2451179.49998 +//const psS64 testTimeB1SecondsUTC = 915148798; +//const psU32 testTimeB1NanosecondsUTC = 0; +// Expected ISO times +//const char testTimeB1StrUTC[] = "1998-12-31T23:59:58,0Z"; +//const char testTimeB1StrTAI[] = "1999-01-01T00:00:29,0Z"; +//const char testTimeB1StrTT[] = "1999-01-01T00:01:01,1Z"; +//const char testTimeB1StrUT1[] = "1998-12-31T23:59:57,7Z"; +// +// Test Time B2 : Dec 31, 1998 23:59:58,5 +// +// +//const psS64 testTimeB2SecondsUTC = 915148798; +//const psU32 testTimeB2NanosecondsUTC = 500000000; +// Expected ISO times +//const char testTimeB2StrUTC[] = "1998-12-31T23:59:58,5Z"; +//const char testTimeB2StrTAI[] = "1991-01-01T00:00:29,5Z"; +//const char testTimeB2StrTT[] = "1999-01-01T00:01:01,6Z"; +//const char testTimeB2StrUT1[] = "1998-12-31T23:59:58,2Z"; + +testDescription tests[] = { + {testTimeMath,000,"psTimeMath",0,false}, + {testTimeDelta,000,"psTimeDelta",0,false}, + {testTimeConvert1,000,"psTimeConvert",0,false}, + {NULL} + }; + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetLevel(PS_LOG_INFO); + + // Initialize library internal structures + psLibInit("psTime.config"); + + if( !runTestSuite(stderr,"psTime",tests,argc,argv)) { + return 1; + } + + // Clean up library + psLibFinalize(); + + return 0; +} + +psS32 testTimeMath(void) +{ + psTime* time = NULL; + psTime* newTime = NULL; + + // Attempt to perform math operation on NULL time + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL time"); + if(psTimeMath(time,-1.1) != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for NULL time"); + return 1; + } + + // Set up input time with invalid nanoseconds + time = psTimeAlloc(PS_TIME_UTC); + time->sec = 0; + time->nsec = 2e9; + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for invalid time"); + if(psTimeMath(time,-1.1) != NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid time"); + return 2; + } + + // Set up input time with valid time + time->sec = testTime1SecondsUTC; + time->nsec = testTime1NanosecondsUTC; + newTime = psTimeMath(time,deltaTime1); + if(newTime == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not expect NULL return"); + return 3; + } + if(newTime->type != PS_TIME_UTC) { + psError(PS_ERR_UNKNOWN,true,"New time type %d not as expected %d", + newTime->type,PS_TIME_UTC); + return 4; + } + if((newTime->sec != newTestTime1SecondsUTC) || (newTime->nsec != newTestTime1NanosecondsUTC)) { + psError(PS_ERR_UNKNOWN,true,"UTC sec %ld nsec %d not as expected sec %ld nsec %d", + (long int)newTime->sec,newTime->nsec,(long int)newTestTime1SecondsUTC, + newTestTime1NanosecondsUTC); + return 5; + } + psFree(newTime); + + // Set up input time with valid TAI time + time->sec = testTime1SecondsTAI; + time->nsec = testTime1NanosecondsTAI; + time->type = PS_TIME_TAI; + newTime = psTimeMath(time,deltaTime1); + if(newTime == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not expect NULL return"); + return 3; + } + if(newTime->type != PS_TIME_TAI) { + psError(PS_ERR_UNKNOWN,true,"New time type %d not as expected %d", + newTime->type,PS_TIME_TAI); + return 4; + } + if((newTime->sec != newTestTime1SecondsTAI) || (newTime->nsec != newTestTime1NanosecondsTAI)) { + psError(PS_ERR_UNKNOWN,true,"TAI sec %ld nsec %d not as expected sec %ld nsec %d", + (long int)newTime->sec,newTime->nsec,(long int)newTestTime1SecondsTAI, + newTestTime1NanosecondsTAI); + return 5; + } + psFree(newTime); + + // Set up input time with valid TT time + time->sec = testTime1SecondsTT; + time->nsec = testTime1NanosecondsTT; + time->type = PS_TIME_TT; + newTime = psTimeMath(time,deltaTime2); + if(newTime == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not expect NULL return"); + return 3; + } + if(newTime->type != PS_TIME_TT) { + psError(PS_ERR_UNKNOWN,true,"New time type %d not as expected %d", + newTime->type,PS_TIME_TT); + return 4; + } + if((newTime->sec != newTestTime1SecondsTT) || (newTime->nsec != newTestTime1NanosecondsTT)) { + psError(PS_ERR_UNKNOWN,true,"TT sec %ld nsec %d not as expected sec %ld nsec %d", + (long int)newTime->sec,newTime->nsec,(long int)newTestTime1SecondsTT, + newTestTime1NanosecondsTT); + return 5; + } + psFree(newTime); + + // Set up input time with valid TT time + time->sec = testTime1SecondsUT1; + time->nsec = testTime1NanosecondsUT1; + time->type = PS_TIME_UT1; + newTime = psTimeMath(time,deltaTime2); + if(newTime == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not expect NULL return"); + return 3; + } + if(newTime->type != PS_TIME_UT1) { + psError(PS_ERR_UNKNOWN,true,"New time type %d not as expected %d", + newTime->type,PS_TIME_UT1); + return 4; + } + if((newTime->sec != newTestTime1SecondsUT1) || (newTime->nsec != newTestTime1NanosecondsUT1)) { + psError(PS_ERR_UNKNOWN,true,"UT1 sec %ld nsec %d not as expected sec %ld nsec %d", + (long int)newTime->sec,newTime->nsec,(long int)newTestTime1SecondsUT1, + newTestTime1NanosecondsUT1); + return 5; + } + psFree(newTime); + + // Set up input time with valid UTC time and delt which crosses leap second + time->sec = testTime2SecondsUTC; + time->nsec = testTime2NanosecondsUTC; + time->type = PS_TIME_UTC; + newTime = psTimeMath(time,deltaTime3); + if(newTime == NULL) { + psError(PS_ERR_UNKNOWN,true,"Did not expect NULL return"); + return 3; + } + if(newTime->type != PS_TIME_UTC) { + psError(PS_ERR_UNKNOWN,true,"New time type %d not as expected %d", + newTime->type,PS_TIME_UTC); + return 4; + } + if((newTime->sec != newTestTime2SecondsUTC) || (newTime->nsec != newTestTime2NanosecondsUTC)) { + psError(PS_ERR_UNKNOWN,true,"UTC sec %ld nsec %d not as expected sec %ld nsec %d", + (long int)newTime->sec,newTime->nsec,(long int)newTestTime2SecondsUTC, + newTestTime2NanosecondsUTC); + return 5; + } + psFree(newTime); + + psFree(time); + + return 0; +} + +psS32 testTimeDelta(void) +{ + psTime* time1 = NULL; + psTime* time2 = NULL; + psF64 delta = 0.0; + + // Attempt to get delta with time1 NULL + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL time"); + delta = psTimeDelta(time1,time2); + if(fabs(delta-0.0) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Did not return 0 for NULL time argument"); + return 1; + } + + // Set time 1 + time1 = psTimeAlloc(PS_TIME_UTC); + + // Attempt to get delta with time2 NULL + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for NULL time"); + delta = psTimeDelta(time1,time2); + if(fabs(delta-0.0) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Did not return 0 for NULL time argument"); + return 2; + } + + // Set time 2 + time2 = psTimeAlloc(PS_TIME_UTC); + + // Set time1 invalid + time1->sec = 0; + time1->nsec = 2e9; + // Attempt to get delta with time1 invalid + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for invalid time"); + delta = psTimeDelta(time1,time2); + if(fabs(delta-0.0) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Did not return 0 for invalid time argument"); + return 3; + } + + // Set time 1 valid + time1->sec = testTime1SecondsUTC; + time1->nsec = testTime1NanosecondsUTC; + + // Set time 2 invalid + time2->sec = 0; + time2->nsec = 2e9; + // Attempt to get delta with time2 invalid + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for invalid time"); + delta = psTimeDelta(time1,time2); + if(fabs(delta-0.0) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Did not return 0 for invalid time argument"); + return 4; + } + + // Set time 2 valid but different type + time2->sec = newTestTime1SecondsUTC; + time2->nsec = newTestTime1NanosecondsUTC; + time2->type = PS_TIME_TAI; + // Attempt to get delta with different time types + psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message for incorrect type"); + delta = psTimeDelta(time1,time2); + if(fabs(delta-0.0) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Did not return 0 for invalid time argument"); + return 5; + } + + // Set time 2 to same as time 1 + time2->type = PS_TIME_UTC; + // Attempt to get delta with valid times of the same type + delta = psTimeDelta(time2,time1); + if(fabs(delta-deltaTime1) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Delta %lf not as expected %lf", + delta,deltaTime1); + return 6; + } + + // Set time 1 and 2 as different times with same type + time1->sec = testTime1SecondsTT; + time1->nsec = testTime1NanosecondsTT; + time1->type = PS_TIME_TT; + time2->sec = newTestTime1SecondsTT; + time2->nsec = newTestTime1NanosecondsTT; + time2->type = PS_TIME_TT; + // Attempt to get delta with valid times of the same type + delta = psTimeDelta(time2,time1); + if(fabs(delta-deltaTime2) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Delta %lf not as expected %lf", + delta,deltaTime2); + return 7; + } + + // Set time 1 and 2 as different times with same type + time1->sec = testTime2SecondsUTC; + time1->nsec = testTime2NanosecondsUTC; + time1->type = PS_TIME_UTC; + time2->sec = newTestTime2SecondsUTC; + time2->nsec = newTestTime2NanosecondsUTC; + time2->type = PS_TIME_UTC; + // Attempt to get delta with valid times of the same type + delta = psTimeDelta(time2,time1); + if(fabs(delta-deltaTime3) > ERROR_TOL) { + psError(PS_ERR_UNKNOWN,true,"Delta %lf not as expected %lf", + delta,deltaTime3); + return 7; + } + + psFree(time1); + psFree(time2); + + return 0; +} + +psS32 testTimeConvert1(void) +{ + psTime* time = NULL; + char* timeStr = NULL; + + for(psS32 i = 0; i < APPB_TESTS; i++) { + + // Initialize time for test time B1 + time = psTimeAlloc(PS_TIME_TAI); + time->sec = testTimeBSeconds[i]; + time->nsec = testTimeBNanoseconds[i]; + + // Verify TAI ISO string + timeStr = psTimeToISO(time); + if(strcmp(timeStr,testTimeBStrTAI[i]) != 0) { + psError(PS_ERR_UNKNOWN,true,"TAI ISO string %s not as expected %s",timeStr,testTimeBStrTAI[i]); + return i+1; + } + psFree(timeStr); + + time = psTimeConvert(time,PS_TIME_TT); + timeStr = psTimeToISO(time); + if(strcmp(timeStr,testTimeBStrTT[i]) != 0) { + psError(PS_ERR_UNKNOWN,true,"TT ISO string %s not as expected %s",timeStr,testTimeBStrTT[i]); + return i+10; + } + psFree(timeStr); + + // Verify UTC ISO string + time = psTimeConvert(time,PS_TIME_UTC); + time->leapsecond = testTimeBLeapsecond[i]; + timeStr = psTimeToISO(time); + if(strcmp(timeStr,testTimeBStrUTC[i]) != 0) { + psError(PS_ERR_UNKNOWN,true,"UTC ISO string %s not as expected %s",timeStr,testTimeBStrUTC[i]); + return i+20; + } + psFree(timeStr); + + time = psTimeConvert(time,PS_TIME_UT1); + timeStr = psTimeToISO(time); + if(strcmp(timeStr,testTimeBStrUT1[i]) != 0) { + psError(PS_ERR_UNKNOWN,true,"UT1 ISO string %s not as expected %s",timeStr,testTimeBStrUT1[i]); + return i+30; + } + psFree(timeStr); + + psFree(time); + } + + return 0; +} + Index: /trunk/psLib/test/astro/tst_psTime_04.c =================================================================== --- /trunk/psLib/test/astro/tst_psTime_04.c (revision 4547) +++ /trunk/psLib/test/astro/tst_psTime_04.c (revision 4547) @@ -0,0 +1,106 @@ +/** @file tst_psTime_04.c + * + * @brief Test driver for psTime functions + * + * This test driver contains the following tests for psTime: + * Test A - Initialize time + * Test B - Attempt to open non-existant time config file + * Test C - Attempt to open non-existant time data files + * Test D - Attempt to read incorrect number of files + * Test E - Attempt to read incorrect number of from values + * Test F - Attempt to read data file with typo in number + * Test G - Free data + * + * @author Ross Harman, MHPCC + * @author Eric Van Alst, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-07-13 02:46:58 $ + * + * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii + * + */ +#include "config.h" + +#include "pslib_strict.h" +#include "psTest.h" + +static psS32 testTimeInit1(void); +static psS32 testTimeInit2(void); +static psS32 testTimeInit3(void); +static psS32 testTimeInit4(void); +static psS32 testTimeInit5(void); +static psS32 testTimeInit6(void); + +testDescription tests[] = { + {testTimeInit1,000,"p_psTimeInit",0,false}, + {testTimeInit2,000,"p_psTimeInit",0,false}, + {testTimeInit3,000,"p_psTimeInit",0,false}, + {testTimeInit4,000,"p_psTimeInit",0,false}, + {testTimeInit5,000,"p_psTimeInit",0,false}, + {testTimeInit6,000,"p_psTimeInit",0,false}, + {NULL} + }; + +psS32 main(psS32 argc, char* argv[]) +{ + if(!runTestSuite(stderr,"psTime",tests,argc,argv)) { + return 1; + } + + return 0; +} + +psS32 testTimeInit1(void) +{ + // Test A - Initialize time + psLibInit("psTime.config"); + psLibFinalize(); + + return 0; +} + +psS32 testTimeInit2(void) +{ + // Test B - Attempt to open non-existant time config file + psLibInit("zzz"); + + return 0; +} + +psS32 testTimeInit3(void) +{ + // Test C - Attempt to open non-existant time data files + psLibInit("test.psTime.config1"); + psLibFinalize(); + + return 0; +} + +psS32 testTimeInit4(void) +{ + // Test D - Attempt to read incorrect number of files + psLibInit("test.psTime.config2"); + psLibFinalize(); + + return 0; +} + +psS32 testTimeInit5(void) +{ + // Test E - Attempt to read incorrect number of from values + psLibInit("test.psTime.config3"); + psLibFinalize(); + + return 0; +} + +psS32 testTimeInit6(void) +{ + // Test F - Attempt to read data file with typo in number + psLibInit("test.psTime.config4"); + psLibFinalize(); + + return 0; +} + Index: /trunk/psLib/test/astro/verified/tst_psCoord.stderr =================================================================== --- /trunk/psLib/test/astro/verified/tst_psCoord.stderr (revision 4547) +++ /trunk/psLib/test/astro/verified/tst_psCoord.stderr (revision 4547) @@ -0,0 +1,227 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psCoord.c * +* TestPoint: psCoord{psSphereTransformAlloc()} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (psCoord{psSphereTransformAlloc()} | tst_psCoord.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psCoord.c * +* TestPoint: psCoord{psPlaneTransformAlloc()} * +* TestType: Positive * +\**********************************************************************************/ + +