Changeset 1840

Timestamp:

08/03/10 18:34:32 (14 years ago)

Author:

Malte Marquarding

Message:

movde to nose based testing

File:

• trunk/test/test_scantable.py (modified) (8 diffs)

trunk/test/test_scantable.py

@@ -1 @@
-import unittest
+import sys
+import os
+import shutil
 import datetime
-from asap import scantable, selector, rcParams, mask_not, asaplog
+from asap import scantable, selector, mask_not
+from asap.logging import asaplog
 asaplog.disable()
 
-class ScantableTest(unittest.TestCase):
-    def setUp(self):
+from nose.tools import *
+
+def tempdir_setup():
+    os.makedirs("test_temp")
+
+def tempdir_teardown():
+    shutil.rmtree("test_temp", True)
+
+class TestScantable(object):
+    def setup(self):
         s = scantable("data/MOPS.rpf", average=True)
         sel = selector()
@@ -17 +28 @@
     def test_init(self):
         st = scantable("data/MOPS.rpf", average=False)
-        self.assertEqual(st.ncycle(), 32)
+        assert_equal(st.ncycle(), 32)
         st = scantable("data/MOPS.rpf", average=True)
-        self.assertEqual(st.ncycle(), 2)
+        assert_equal(st.ncycle(), 2)
         st = scantable("data/MOPS.rpf", unit="Jy")
-        self.assertEqual(st.get_fluxunit(), "Jy")
+        assert_equal(st.get_fluxunit(), "Jy")
         st = scantable("data/MOPS.rpf", unit="K")
-        self.assertEqual(st.get_fluxunit(), "K")
-        self.assertRaises(RuntimeError, scantable, "data/MOPS.rpf", unit="junk")
+        assert_equal(st.get_fluxunit(), "K")
+        assert_raises(RuntimeError, scantable, "data/MOPS.rpf", unit="junk")
         st = scantable(["data/MOPS.rpf","data/MOPS.rpf"], average=False)
-        self.assertEqual(st.nscan(), 4)
+        assert_equal(st.nscan(), 4)
 
     def test_copy(self):
         st = self.st.copy()
-        self.assertNotEqual(id(st), id(self.st))
+        assert_not_equal(id(st), id(self.st))
 
     def test_drop_scan(self):
         st = self.st.drop_scan([1])
-        self.assertEqual(st.nscan(), 1)
+        assert_equal(st.nscan(), 1)
 
     def test_get_scan(self):
         st = self.st.get_scan([1])
-        self.assertEqual(st.nscan(), 1)
+        assert_equal(st.nscan(), 1)
         st = self.st.get_scan("Orion_SiO_R")
-        self.assertEqual(st.get_sourcename()[-1], "Orion_SiO_R")
-        self.assertEqual(st.nscan(), 1)
+        assert_equal(st.get_sourcename()[-1], "Orion_SiO_R")
+        assert_equal(st.nscan(), 1)
 
     def test_get_spectrum(self):
         spec = self.st.get_spectrum(0)
-        self.assertAlmostEqual(max(spec), 215.279830933)
+        assert_almost_equal(max(spec), 215.279830933)
 
     def test_get_mask(self):
         spec = self.st.get_mask(0)
-        self.assertEqual(len(spec), 4096)
+        assert_equal(len(spec), 4096)
 
     def test_set_spectrum(self):
@@ -55 +66 @@
         self.st.set_spectrum(spec, 0)
         spec1 = self.st.get_spectrum(0)
-        self.assertAlmostEqual(max(spec1), 1.0)
+        assert_almost_equal(max(spec1), 1.0)
 
     def test_selection(self):
@@ -61 +72 @@
         sel.set_polarisations("YY")
         self.st.set_selection(sel)
-        self.assertEqual(self.st.getpolnos(), (1,))
+        assert_equal(self.st.getpolnos(), (1,))
         sel1 = self.st.get_selection()
-        self.assertEqual(sel1.get_pols(), [1])
+        assert_equal(sel1.get_pols(), [1])
         self.st.set_selection(pols="XX")
-        self.assertEqual(self.st.getpolnos(), (0,))
+        assert_equal(self.st.getpolnos(), (0,))
 
     def test_stats(self):
@@ -76 +87 @@
         for k,v in stats.iteritems():
             sval = self.st.stats(stat=k)
-            self.assertAlmostEqual(sval[0], v)
+            assert_almost_equal(sval[0], v)
         msk = self.st.create_mask([0,100], [3900,4096])
-        self.assertAlmostEqual(self.st.stats("sum", msk)[0], 35216.87890625)
+        assert_almost_equal(self.st.stats("sum", msk)[0], 35216.87890625)
 
     def test_get_column_names(self):
@@ -90 +101 @@
                   'SRCPROPERMOTION', 'SRCDIRECTION',
                   'SCANRATE']
-        self.assertEqual(self.st.get_column_names(), cnames)
+        assert_equal(self.st.get_column_names(), cnames)
 
     def test_get_tsys(self):
-        self.assertAlmostEqual(self.st.get_tsys()[0], 175.830429077)
+        assert_almost_equal(self.st.get_tsys()[0], 175.830429077)
 
     def test_get_time(self):
-        self.assertEqual(self.st.get_time(0), '2008/03/12/09:32:50')
+        assert_equal(self.st.get_time(0), '2008/03/12/09:32:50')
         dt = datetime.datetime(2008,3,12,9,32,50)
-        self.assertEqual(self.st.get_time(0, True), dt)
+        assert_equal(self.st.get_time(0, True), dt)
 
     def test_get_inttime(self):
-        self.assertAlmostEqual(self.st.get_inttime()[0], 30.720016479)
+        assert_almost_equal(self.st.get_inttime()[0], 30.720016479)
 
     def test_get_sourcename(self):
-        self.assertEqual(self.st.get_sourcename(0), 'Orion_SiO_R')
-        self.assertEqual(self.st.get_sourcename(),
+        assert_equal(self.st.get_sourcename(0), 'Orion_SiO_R')
+        assert_equal(self.st.get_sourcename(),
                          ['Orion_SiO_R', 'Orion_SiO_R',
                           'Orion_SiO', 'Orion_SiO'])
 
     def test_get_azimuth(self):
-        self.assertAlmostEqual(self.st.get_azimuth()[0], 5.628767013)
+        assert_almost_equal(self.st.get_azimuth()[0], 5.628767013)
 
     def test_get_elevation(self):
-        self.assertAlmostEqual(self.st.get_elevation()[0], 1.01711678504)
+        assert_almost_equal(self.st.get_elevation()[0], 1.01711678504)
 
     def test_get_parangle(self):
-        self.assertAlmostEqual(self.st.get_parangle()[0], 2.5921990871)
+        assert_almost_equal(self.st.get_parangle()[0], 2.5921990871)
 
     def test_get_direction(self):
-        self.assertEqual(self.st.get_direction()[0], '05:35:14.5 -04.52.29.5')
+        assert_equal(self.st.get_direction()[0], '05:35:14.5 -04.52.29.5')
 
     def test_get_directionval(self):
         dv = self.st.get_directionval()[0]
-        self.assertAlmostEqual(dv[0], 1.4627692699)
-        self.assertAlmostEqual(dv[1], -0.0850824415)
+        assert_almost_equal(dv[0], 1.4627692699)
+        assert_almost_equal(dv[1], -0.0850824415)
 
     def test_unit(self):
@@ -130 +141 @@
         self.st.set_unit('GHz')
         self.st.set_unit('km/s')
-        self.assertRaises(RuntimeError, self.st.set_unit, 'junk')
-        self.assertEquals(self.st.get_unit(), 'km/s')
+        assert_raises(RuntimeError, self.st.set_unit, 'junk')
+        assert_equals(self.st.get_unit(), 'km/s')
 
     def test_average_pol(self):
         ap = self.st.average_pol()
-        self.assertEqual(ap.npol(), 1)
+        assert_equal(ap.npol(), 1)
 
     def test_drop_scan(self):
         s0 = self.st.drop_scan(1)
-        self.assertEqual(s0.getscannos(), (0,))
+        assert_equal(s0.getscannos(), (0,))
         s1 = self.st.drop_scan([0])
-        self.assertEqual(s1.getscannos(), (1,))
+        assert_equal(s1.getscannos(), (1,))
 
     def test_flag(self):
@@ -151 +162 @@
         q0.flag(mask=mask_not(msk))
         q1.flag(mask=msk)
-        self.assertAlmostEqual(q0.stats(stat='max')[0], 95.62171936)
-        self.assertAlmostEqual(q1.stats(stat='max')[0], 2.66563416)
+        assert_almost_equal(q0.stats(stat='max')[0], 95.62171936)
+        assert_almost_equal(q1.stats(stat='max')[0], 2.66563416)
 
-if __name__ == '__main__':
-    unittest.main()
+
+    @with_setup(tempdir_setup, tempdir_teardown)
+    def test_save(self):
+        fname = os.path.join("test_temp", 'scantable_test.%s')
+        formats = [(fname % 'sdfits', 'SDFITS', True),
+                   (fname % 'ms', 'MS2', True),
+                   (fname % 'class.fits', 'CLASS', False),
+                   (fname % 'fits', 'FITS', False),
+                   (fname % 'txt', 'ASCII', False),
+                   ]
+        for format in formats:
+            yield self.save, format
+
+    def save(self, args):
+        fname = args[0]
+        self.st.save(fname, args[1], True)
+        if args[-1]:
+            s = scantable(fname)
+            ds = self.st - s
+            assert_equals(self.st.getpolnos(), s.getpolnos())
+            assert_equals(self.st.getscannos(), s.getscannos())
+            assert_equals(self.st.getifnos(), s.getifnos())
+            assert_equals(self.st.getbeamnos(), s.getbeamnos())
+            for spec in ds:
+                assert_almost_equals(sum(spec)/len(spec), 0.0, 5)