Changeset 5a8cdbb in sasview for test/sasdataloader


Ignore:
Timestamp:
Aug 1, 2017 10:02:35 AM (7 years ago)
Author:
lewis
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
511ccb2d
Parents:
248ff73 (diff), bc04647 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into ticket-876

Location:
test/sasdataloader
Files:
12 added
3 deleted
8 edited

Legend:

Unmodified
Added
Removed

  • test/sasdataloader/plugins/test_reader.py

    r959eb01 raaf5e49  
    88copyright 2008, University of Tennessee 
    99""" 
     10from __future__ import print_function 
     11 
    1012import os 
    1113import numpy as np 
    … …  
    5961    reader = Reader() 
    6062    output = reader.read("../test/test_data.test") 
    61     print output.x 
     63    print(output.x) 
    6264     
    6365     

  • test/sasdataloader/test/sequence_tests.py

    r959eb01 raaf5e49  
     1from __future__ import print_function 
     2 
    13from DataLoader.loader import Loader 
    24from DataLoader.readers.IgorReader import Reader as igor_reader 
    … …  
    810    out2 = Loader().load("MAR07232_rest.ASC") 
    911    if len(out2.detector)>1: 
    10         print "Consecutive reads using Loader failed" 
     12        print("Consecutive reads using Loader failed") 
    1113 
    1214def consecutive_reader(): 
    … …  
    1416    out2 = igor_reader().read("MAR07232_rest.ASC") 
    1517    if len(out2.detector)>1: 
    16         print "Consecutive reads using Readers failed" 
    17         print out1 
    18         print out2 
     18        print("Consecutive reads using Readers failed") 
     19        print(out1) 
     20        print(out2) 
    1921 
    2022def single_abs(): 
    … …  
    2931    single_igor() 
    3032    single_abs() 
    31     print "Test passed" 
     33    print("Test passed") 

  • test/sasdataloader/test/testplugings.py

    r959eb01 r17c9436  
    33""" 
    44 
     5import os 
    56import unittest 
    67from sas.sascalc.dataloader.loader import  Loader, Registry 
    … …  
    4142        # Create module 
    4243        import zipfile 
    43         z = zipfile.PyZipFile("plugins.zip", 'w') 
     44        f_name = "plugins.zip" 
     45        z = zipfile.PyZipFile(f_name, 'w') 
    4446        z.writepy("../plugins", "") 
    4547        z.close() 
     48        if os.path.isfile(f_name): 
     49            os.remove(f_name) 
    4650         
    4751    def testplugin_checksetup(self): 

  • test/sasdataloader/test/utest_abs_reader.py

    r371b9e2 r5a8cdbb  
    22    Unit tests for data manipulations 
    33""" 
     4from __future__ import print_function 
    45 
    56import unittest 
    … …  
    78from sas.sascalc.dataloader.loader import Loader 
    89from sas.sascalc.dataloader.readers.IgorReader import Reader as IgorReader 
    9 from sas.sascalc.dataloader.readers.abs_reader import Reader as ABSReader 
    10  
    11  
    12 class ABSReaderTests(unittest.TestCase): 
    13      
     10from sas.sascalc.dataloader.readers.abs_reader import Reader as AbsReader 
     11from sas.sascalc.dataloader.readers.hfir1d_reader import Reader as HFIRReader 
     12from sas.sascalc.dataloader.readers.danse_reader import Reader as DANSEReader 
     13from sas.sascalc.dataloader.readers.cansas_reader import Reader as CANSASReader 
     14 
     15from sas.sascalc.dataloader.data_info import Data1D 
     16 
     17import os.path 
     18 
     19 
     20class abs_reader(unittest.TestCase): 
     21 
    1422    def setUp(self): 
    15         self.data_list = ABSReader().read("jan08002.ABS") 
    16         self.data = self.data_list[0] 
    17          
     23        reader = AbsReader() 
     24        self.data = reader.read("jan08002.ABS") 
     25 
    1826    def test_abs_checkdata(self): 
    1927        """ 
    20             Check the data content to see whether  
     28            Check the data content to see whether 
    2129            it matches the specific file we loaded. 
    2230            Check the units too to see whether the 
    … …  
    2634        self.assertEqual(self.data.filename, "jan08002.ABS") 
    2735        self.assertEqual(self.data.meta_data['loader'], "IGOR 1D") 
    28          
     36 
    2937        self.assertEqual(self.data.source.wavelength_unit, 'A') 
    3038        self.assertEqual(self.data.source.wavelength, 6.0) 
    31          
     39 
    3240        self.assertEqual(self.data.detector[0].distance_unit, 'mm') 
    3341        self.assertEqual(self.data.detector[0].distance, 1000.0) 
    34          
     42 
    3543        self.assertEqual(self.data.sample.transmission, 0.5667) 
    36          
     44 
    3745        self.assertEqual(self.data.detector[0].beam_center_unit, 'mm') 
    3846        center_x = 114.58*5.08 
    … …  
    4048        self.assertEqual(self.data.detector[0].beam_center.x, center_x) 
    4149        self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
    42          
     50 
    4351        self.assertEqual(self.data.y_unit, '1/cm') 
    4452        self.assertEqual(self.data.x[0], 0.002618) 
    … …  
    4654        self.assertEqual(self.data.x[2], 0.01309) 
    4755        self.assertEqual(self.data.x[126], 0.5828) 
    48          
     56 
    4957        self.assertEqual(self.data.y[0], 0.02198) 
    5058        self.assertEqual(self.data.y[1], 0.02201) 
    5159        self.assertEqual(self.data.y[2], 0.02695) 
    5260        self.assertEqual(self.data.y[126], 0.2958) 
    53          
     61 
    5462        self.assertEqual(self.data.dy[0], 0.002704) 
    5563        self.assertEqual(self.data.dy[1], 0.001643) 
    5664        self.assertEqual(self.data.dy[2], 0.002452) 
    5765        self.assertEqual(self.data.dy[126], 1) 
    58          
     66 
    5967    def test_checkdata2(self): 
    6068        self.assertEqual(self.data.dy[126], 1) 
    6169 
    62  
    63 class HFIRReaderTests(unittest.TestCase): 
     70    def test_generic_loader(self): 
     71        # the generic loader should work as well 
     72        data = Loader().load("jan08002.ABS") 
     73        self.assertEqual(data.meta_data['loader'], "IGOR 1D") 
     74 
     75 
     76class hfir_reader(unittest.TestCase): 
    6477 
    6578    def setUp(self): 
    66         self.data = Loader().load("S2-30dq.d1d") 
     79        reader = HFIRReader() 
     80        self.data = reader.read("S2-30dq.d1d") 
    6781 
    6882    def test_hfir_checkdata(self): 
    6983        """ 
    70             Check the data content to see whether  
     84            Check the data content to see whether 
    7185            it matches the specific file we loaded. 
    7286        """ 
    … …  
    7690        self.assertEqual(len(self.data.x), 134) 
    7791        self.assertEqual(len(self.data.y), 134) 
    78         #          Q           I               dI          dQ   
     92        #          Q           I               dI          dQ 
    7993        # Point 1: 0.003014    0.003010        0.000315    0.008249 
    8094        self.assertEqual(self.data.x[1], 0.003014) 
    … …  
    8397        self.assertEqual(self.data.dx[1], 0.008249) 
    8498 
    85  
    86 class DanseReaderTests(unittest.TestCase): 
    87      
     99    def test_generic_loader(self): 
     100        # the generic loader should work as well 
     101        data = Loader().load("S2-30dq.d1d") 
     102        self.assertEqual(data.meta_data['loader'], "HFIR 1D") 
     103 
     104 
     105class igor_reader(unittest.TestCase): 
     106 
    88107    def setUp(self): 
    89         self.data = Loader().load("MP_New.sans") 
    90  
    91     def test_checkdata(self): 
    92         """ 
    93             Check the data content to see whether  
     108        # the IgorReader should be able to read this filetype 
     109        # if it can't, stop here. 
     110        reader = IgorReader() 
     111        self.data = reader.read("MAR07232_rest.ASC") 
     112 
     113    def test_igor_checkdata(self): 
     114        """ 
     115            Check the data content to see whether 
    94116            it matches the specific file we loaded. 
    95117            Check the units too to see whether the 
    … …  
    97119            tests won't pass 
    98120        """ 
     121        self.assertEqual(self.data.filename, "MAR07232_rest.ASC") 
     122        self.assertEqual(self.data.meta_data['loader'], "IGOR 2D") 
     123 
     124        self.assertEqual(self.data.source.wavelength_unit, 'A') 
     125        self.assertEqual(self.data.source.wavelength, 8.4) 
     126 
     127        self.assertEqual(self.data.detector[0].distance_unit, 'mm') 
     128        self.assertEqual(self.data.detector[0].distance, 13705) 
     129 
     130        self.assertEqual(self.data.sample.transmission, 0.84357) 
     131 
     132        self.assertEqual(self.data.detector[0].beam_center_unit, 'mm') 
     133        center_x = (68.76 - 1)*5.0 
     134        center_y = (62.47 - 1)*5.0 
     135        self.assertEqual(self.data.detector[0].beam_center.x, center_x) 
     136        self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
     137 
     138        self.assertEqual(self.data.I_unit, '1/cm') 
     139        # 3 points should be suffcient to check that the data is in column 
     140        # major order. 
     141        np.testing.assert_almost_equal(self.data.data[0:3], 
     142                                       [0.279783, 0.28951, 0.167634]) 
     143        np.testing.assert_almost_equal(self.data.qx_data[0:3], 
     144                                       [-0.01849072, -0.01821785, -0.01794498]) 
     145        np.testing.assert_almost_equal(self.data.qy_data[0:3], 
     146                                       [-0.01677435, -0.01677435, -0.01677435]) 
     147 
     148    def test_generic_loader(self): 
     149        # the generic loader should direct the file to IgorReader as well 
     150        data = Loader().load("MAR07232_rest.ASC") 
     151        self.assertEqual(data.meta_data['loader'], "IGOR 2D") 
     152 
     153 
     154class DanseReaderTests(unittest.TestCase): 
     155 
     156    def setUp(self): 
     157        reader = DANSEReader() 
     158        self.data = reader.read("MP_New.sans") 
     159 
     160    def test_checkdata(self): 
     161        """ 
     162            Check the data content to see whether 
     163            it matches the specific file we loaded. 
     164            Check the units too to see whether the 
     165            Data1D defaults changed. Otherwise the 
     166            tests won't pass 
     167        """ 
    99168        self.assertEqual(self.data.filename, "MP_New.sans") 
    100169        self.assertEqual(self.data.meta_data['loader'], "DANSE") 
    101          
     170 
    102171        self.assertEqual(self.data.source.wavelength_unit, 'A') 
    103172        self.assertEqual(self.data.source.wavelength, 7.5) 
    104          
     173 
    105174        self.assertEqual(self.data.detector[0].distance_unit, 'mm') 
    106175        self.assertAlmostEqual(self.data.detector[0].distance, 5414.99, 3) 
    107          
     176 
    108177        self.assertEqual(self.data.detector[0].beam_center_unit, 'mm') 
    109178        center_x = 68.74*5.0 
    … …  
    111180        self.assertEqual(self.data.detector[0].beam_center.x, center_x) 
    112181        self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
    113          
     182 
    114183        self.assertEqual(self.data.I_unit, '1/cm') 
    115184        self.assertEqual(self.data.data[0], 1.57831) 
    … …  
    121190        self.assertEqual(self.data.err_data[2], 2.06313) 
    122191 
    123   
     192    def test_generic_loader(self): 
     193        # the generic loader should work as well 
     194        data = Loader().load("MP_New.sans") 
     195        self.assertEqual(data.meta_data['loader'], "DANSE") 
     196 
     197 
    124198class cansas_reader(unittest.TestCase): 
    125      
     199 
    126200    def setUp(self): 
     201        reader = CANSASReader() 
     202        data = reader.read("cansas1d.xml") 
     203        self.data = data[0] 
     204 
     205    def test_generic_loader(self): 
     206        # the generic loader should work as well 
    127207        data = Loader().load("cansas1d.xml") 
    128         self.data = data[0] 
    129   
     208        self.assertEqual(data[0].meta_data['loader'], "CanSAS XML 1D") 
     209 
    130210    def test_cansas_checkdata(self): 
    131211        self.assertEqual(self.data.filename, "cansas1d.xml") 
    132212        self._checkdata() 
    133          
     213 
    134214    def _checkdata(self): 
    135215        """ 
    136             Check the data content to see whether  
     216            Check the data content to see whether 
    137217            it matches the specific file we loaded. 
    138218            Check the units too to see whether the 
    … …  
    140220            tests won't pass 
    141221        """ 
    142          
    143222        self.assertEqual(self.data.run[0], "1234") 
    144223        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    145          
     224 
    146225        # Data 
    147226        self.assertEqual(len(self.data.x), 2) 
    … …  
    158237        self.assertEqual(self.data.run_name['1234'], 'run name') 
    159238        self.assertEqual(self.data.title, "Test title") 
    160          
     239 
    161240        # Sample info 
    162241        self.assertEqual(self.data.sample.ID, "SI600-new-long") 
    … …  
    164243        self.assertEqual(self.data.sample.thickness_unit, 'mm') 
    165244        self.assertAlmostEqual(self.data.sample.thickness, 1.03) 
    166          
     245 
    167246        self.assertAlmostEqual(self.data.sample.transmission, 0.327) 
    168          
     247 
    169248        self.assertEqual(self.data.sample.temperature_unit, 'C') 
    170249        self.assertEqual(self.data.sample.temperature, 0) 
    … …  
    178257        self.assertAlmostEqual(self.data.sample.orientation.y, 0.02, 6) 
    179258 
    180         self.assertEqual(self.data.sample.details[0], "http://chemtools.chem.soton.ac.uk/projects/blog/blogs.php/bit_id/2720")  
    181         self.assertEqual(self.data.sample.details[1], "Some text here")  
    182          
     259        self.assertEqual(self.data.sample.details[0], "http://chemtools.chem.soton.ac.uk/projects/blog/blogs.php/bit_id/2720") 
     260        self.assertEqual(self.data.sample.details[1], "Some text here") 
     261 
    183262        # Instrument info 
    184263        self.assertEqual(self.data.instrument, "canSAS instrument") 
    185          
     264 
    186265        # Source 
    187266        self.assertEqual(self.data.source.radiation, "neutron") 
    188          
     267 
    189268        self.assertEqual(self.data.source.beam_size_unit, "mm") 
    190269        self.assertEqual(self.data.source.beam_size_name, "bm") 
    191270        self.assertEqual(self.data.source.beam_size.x, 12) 
    192271        self.assertEqual(self.data.source.beam_size.y, 13) 
    193          
     272 
    194273        self.assertEqual(self.data.source.beam_shape, "disc") 
    195          
     274 
    196275        self.assertEqual(self.data.source.wavelength_unit, "A") 
    197276        self.assertEqual(self.data.source.wavelength, 6) 
    198          
     277 
    199278        self.assertEqual(self.data.source.wavelength_max_unit, "nm") 
    200279        self.assertAlmostEqual(self.data.source.wavelength_max, 1.0) 
    … …  
    203282        self.assertEqual(self.data.source.wavelength_spread_unit, "percent") 
    204283        self.assertEqual(self.data.source.wavelength_spread, 14.3) 
    205          
     284 
    206285        # Collimation 
    207286        _found1 = False 
    … …  
    209288        self.assertEqual(self.data.collimation[0].length, 123.) 
    210289        self.assertEqual(self.data.collimation[0].name, 'test coll name') 
    211          
     290 
    212291        for item in self.data.collimation[0].aperture: 
    213292            self.assertEqual(item.size_unit,'mm') 
    214293            self.assertEqual(item.distance_unit,'mm') 
    215294 
    216             if item.size.x==50 \ 
    217                 and item.distance==11000.0 \ 
    218                 and item.name=='source' \ 
    219                 and item.type=='radius': 
     295            if item.size.x == 50 \ 
     296                and item.distance == 11000.0 \ 
     297                and item.name == 'source' \ 
     298                and item.type == 'radius': 
    220299                _found1 = True 
    221             elif item.size.x==1.0 \ 
    222                 and item.name=='sample' \ 
    223                 and item.type=='radius': 
     300            elif item.size.x == 1.0 \ 
     301                and item.name == 'sample' \ 
     302                and item.type == 'radius': 
    224303                _found2 = True 
    225                  
    226         if _found1==False or _found2==False: 
    227             raise RuntimeError, "Could not find all data %s %s" % (_found1, _found2)  
    228              
     304 
     305        if _found1 == False or _found2 == False: 
     306            raise RuntimeError, "Could not find all data %s %s" % (_found1, _found2) 
     307 
    229308        # Detector 
    230309        self.assertEqual(self.data.detector[0].name, "fictional hybrid") 
    231310        self.assertEqual(self.data.detector[0].distance_unit, "mm") 
    232311        self.assertEqual(self.data.detector[0].distance, 4150) 
    233          
     312 
    234313        self.assertEqual(self.data.detector[0].orientation_unit, "degree") 
    235314        self.assertAlmostEqual(self.data.detector[0].orientation.x, 1.0, 6) 
    236315        self.assertEqual(self.data.detector[0].orientation.y, 0.0) 
    237316        self.assertEqual(self.data.detector[0].orientation.z, 0.0) 
    238          
     317 
    239318        self.assertEqual(self.data.detector[0].offset_unit, "m") 
    240319        self.assertEqual(self.data.detector[0].offset.x, .001) 
    241320        self.assertEqual(self.data.detector[0].offset.y, .002) 
    242321        self.assertEqual(self.data.detector[0].offset.z, None) 
    243          
     322 
    244323        self.assertEqual(self.data.detector[0].beam_center_unit, "mm") 
    245324        self.assertEqual(self.data.detector[0].beam_center.x, 322.64) 
    246325        self.assertEqual(self.data.detector[0].beam_center.y, 327.68) 
    247326        self.assertEqual(self.data.detector[0].beam_center.z, None) 
    248          
     327 
    249328        self.assertEqual(self.data.detector[0].pixel_size_unit, "mm") 
    250329        self.assertEqual(self.data.detector[0].pixel_size.x, 5) 
    251330        self.assertEqual(self.data.detector[0].pixel_size.y, 5) 
    252331        self.assertEqual(self.data.detector[0].pixel_size.z, None) 
    253          
     332 
    254333        # Process 
    255334        _found_term1 = False 
    … …  
    259338            self.assertTrue(item.date in ['04-Sep-2007 18:35:02', 
    260339                                          '03-SEP-2006 11:42:47']) 
    261             print item.term 
     340            print(item.term) 
    262341            for t in item.term: 
    263                 if t['name']=="ABS:DSTAND" \ 
    264                     and t['unit']=='mm' \ 
    265                     and float(t['value'])==1.0: 
     342                if (t['name'] == "ABS:DSTAND" 
     343                    and t['unit'] == 'mm' 
     344                    and float(t['value']) == 1.0): 
    266345                    _found_term2 = True 
    267                 elif t['name']=="radialstep" \ 
    268                     and t['unit']=='mm' \ 
    269                     and float(t['value'])==10.0: 
     346                elif (t['name'] == "radialstep" 
     347                      and t['unit'] == 'mm' 
     348                      and float(t['value']) == 10.0): 
    270349                    _found_term1 = True 
    271                      
    272         if _found_term1==False or _found_term2==False: 
     350 
     351        if _found_term1 == False or _found_term2 == False: 
    273352            raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2) 
    274353 
    275354    def test_writer(self): 
    276         from sas.sascalc.dataloader.readers.cansas_reader import Reader 
    277         r = Reader() 
    278         x = np.ones(5) 
    279         y = np.ones(5) 
    280         dy = np.ones(5) 
    281          
     355        r = CANSASReader() 
     356 
    282357        filename = "write_test.xml" 
    283358        r.write(filename, self.data) 
    … …  
    286361        self.assertEqual(self.data.filename, filename) 
    287362        self._checkdata() 
     363        if os.path.isfile(filename): 
     364            os.remove(filename) 
    288365 
    289366    def test_units(self): 
    … …  
    293370        """ 
    294371        filename = "cansas1d_units.xml" 
    295         data = Loader().load(filename) 
     372        data = CANSASReader().read(filename) 
    296373        self.data = data[0] 
    297374        self.assertEqual(self.data.filename, filename) 
    … …  
    304381        """ 
    305382        filename = "cansas1d_badunits.xml" 
    306         data = Loader().load(filename) 
     383        data = CANSASReader().read(filename) 
    307384        self.data = data[0] 
    308385        self.assertEqual(self.data.filename, filename) 
    … …  
    311388        # This one should 
    312389        self.assertAlmostEqual(self.data.sample.transmission, 0.327) 
    313          
     390 
    314391        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    315         print self.data.errors 
     392        print(self.data.errors) 
    316393        self.assertEqual(len(self.data.errors), 1) 
    317394 
    … …  
    321398        """ 
    322399        filename = "cansas1d_slit.xml" 
    323         data = Loader().load(filename) 
     400        data = CANSASReader().read(filename) 
    324401        self.data = data[0] 
    325402        self.assertEqual(self.data.filename, filename) 
    326403        self.assertEqual(self.data.run[0], "1234") 
    327          
     404 
    328405        # Data 
    329406        self.assertEqual(len(self.data.x), 2) 

  • test/sasdataloader/test/utest_averaging.py

    r8ffafd1 r5a8cdbb  
    11 
    22import math 
     3import os 
    34import unittest 
     5from scipy.stats import binned_statistic_2d 
    46import numpy as np 
     7 
    58import sas.sascalc.dataloader.data_info as data_info 
    69from sas.sascalc.dataloader.loader import Loader 
    7 from sas.sascalc.dataloader.manipulations import Boxsum, Boxavg, Ring, get_q,\ 
    8     CircularAverage, SectorPhi, SectorQ, reader2D_converter, SlabX, SlabY 
     10from sas.sascalc.dataloader.manipulations import (Boxavg, Boxsum, 
     11                                                  CircularAverage, Ring, 
     12                                                  SectorPhi, SectorQ, SlabX, 
     13                                                  SlabY, get_q, 
     14                                                  reader2D_converter) 
    915 
    1016 
    … …  
    1319        Test averaging manipulations on a flat distribution 
    1420    """ 
     21 
    1522    def setUp(self): 
    1623        """ 
    … …  
    1825            should return the predefined height of the distribution (1.0). 
    1926        """ 
    20         x_0 = np.ones([100,100]) 
    21         dx_0 = np.ones([100,100]) 
     27        x_0 = np.ones([100, 100]) 
     28        dx_0 = np.ones([100, 100]) 
    2229 
    2330        self.data = data_info.Data2D(data=x_0, err_data=dx_0) 
    2431        detector = data_info.Detector() 
    2532        detector.distance = 1000.0  # mm 
    26         detector.pixel_size.x = 1.0 # mm 
    27         detector.pixel_size.y = 1.0 # mm 
     33        detector.pixel_size.x = 1.0  # mm 
     34        detector.pixel_size.y = 1.0  # mm 
    2835 
    2936        # center in pixel position = (len(x_0)-1)/2 
    30         detector.beam_center.x = (len(x_0)-1)/2 # pixel number 
    31         detector.beam_center.y = (len(x_0)-1)/2 # pixel number 
     37        detector.beam_center.x = (len(x_0) - 1) / 2 # pixel number 
     38        detector.beam_center.y = (len(x_0) - 1) / 2 # pixel number 
    3239        self.data.detector.append(detector) 
    33          
     40 
    3441        source = data_info.Source() 
    35         source.wavelength = 10.0 # A 
     42        source.wavelength = 10.0  # A 
    3643        self.data.source = source 
    3744 
    38         # get_q(dx, dy, det_dist, wavelength) where units are mm, mm, mm, and A 
     45        # get_q(dx, dy, det_dist, wavelength) where units are mm,mm,mm,and A 
     46        # respectively. 
    3947        self.qmin = get_q(1.0, 1.0, detector.distance, source.wavelength) 
    4048        self.qmax = get_q(49.5, 49.5, detector.distance, source.wavelength) 
    4149 
    4250        self.qstep = len(x_0) 
    43         x=  np.linspace(start= -1*self.qmax, 
    44                                stop= self.qmax, 
    45                                num= self.qstep, 
    46                                endpoint=True )   
    47         y = np.linspace(start= -1*self.qmax, 
    48                                stop= self.qmax, 
    49                                num= self.qstep, 
    50                                endpoint=True ) 
    51         self.data.x_bins=x 
    52         self.data.y_bins=y 
     51        x = np.linspace(start=-1 * self.qmax, 
     52                        stop=self.qmax, 
     53                        num=self.qstep, 
     54                        endpoint=True) 
     55        y = np.linspace(start=-1 * self.qmax, 
     56                        stop=self.qmax, 
     57                        num=self.qstep, 
     58                        endpoint=True) 
     59        self.data.x_bins = x 
     60        self.data.y_bins = y 
    5361        self.data = reader2D_converter(self.data) 
    5462 
    … …  
    5765            Test ring averaging 
    5866        """ 
    59         r = Ring(r_min=2*self.qmin, r_max=5*self.qmin,  
    60                  center_x=self.data.detector[0].beam_center.x,  
     67        r = Ring(r_min=2 * self.qmin, r_max=5 * self.qmin, 
     68                 center_x=self.data.detector[0].beam_center.x, 
    6169                 center_y=self.data.detector[0].beam_center.y) 
    6270        r.nbins_phi = 20 
    … …  
    7078            Test sector averaging 
    7179        """ 
    72         r = SectorPhi(r_min=self.qmin, r_max=3*self.qmin,  
    73                       phi_min=0, phi_max=math.pi*2.0) 
     80        r = SectorPhi(r_min=self.qmin, r_max=3 * self.qmin, 
     81                      phi_min=0, phi_max=math.pi * 2.0) 
    7482        r.nbins_phi = 20 
    7583        o = r(self.data) 
    … …  
    8189        """ 
    8290        phi_max = math.pi * 1.5 
    83         r = SectorPhi(r_min=self.qmin, r_max=3*self.qmin,  
     91        r = SectorPhi(r_min=self.qmin, r_max=3 * self.qmin, 
    8492                      phi_min=0, phi_max=phi_max) 
    8593        self.assertEqual(r.phi_max, phi_max) 
    … …  
    94102 
    95103    def setUp(self): 
    96         self.data = Loader().load('MAR07232_rest.ASC') 
     104        filepath = os.path.join(os.path.dirname( 
     105            os.path.realpath(__file__)), 'MAR07232_rest.ASC') 
     106        self.data = Loader().load(filepath) 
    97107 
    98108    def test_ring(self): 
    … …  
    100110            Test ring averaging 
    101111        """ 
    102         r = Ring(r_min=.005, r_max=.01,  
    103                  center_x=self.data.detector[0].beam_center.x,  
     112        r = Ring(r_min=.005, r_max=.01, 
     113                 center_x=self.data.detector[0].beam_center.x, 
    104114                 center_y=self.data.detector[0].beam_center.y, 
    105                  nbins = 20) 
    106         # r.nbins_phi = 20 
    107  
    108         o = r(self.data) 
    109         data_list = Loader().load('ring_testdata.txt') 
    110         answer = data_list[0] 
     115                 nbins=20) 
     116        ##r.nbins_phi = 20 
     117 
     118        o = r(self.data) 
     119        filepath = os.path.join(os.path.dirname( 
     120            os.path.realpath(__file__)), 'ring_testdata.txt') 
     121        answer = Loader().load(filepath) 
    111122 
    112123        for i in range(r.nbins_phi - 1): 
    … …  
    115126            self.assertAlmostEqual(o.dy[i + 1], answer.dy[i], 4) 
    116127 
    117     def test_circular_avg(self): 
     128    def test_circularavg(self): 
     129        """ 
     130        Test circular averaging 
     131        The test data was not generated by IGOR. 
     132        """ 
     133        r = CircularAverage(r_min=.00, r_max=.025, 
     134                            bin_width=0.0003) 
     135        r.nbins_phi = 20 
     136 
     137        o = r(self.data) 
     138 
     139        filepath = os.path.join(os.path.dirname( 
     140            os.path.realpath(__file__)), 'avg_testdata.txt') 
     141        answer = Loader().load(filepath) 
     142        for i in range(r.nbins_phi): 
     143            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     144            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     145            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     146 
     147    def test_box(self): 
    118148        """ 
    119149            Test circular averaging 
    120150            The test data was not generated by IGOR. 
    121151        """ 
    122         r = CircularAverage(r_min=.00, r_max=.025,  
    123                  bin_width=0.0003) 
    124         r.nbins_phi = 20 
    125         o = r(self.data) 
    126  
    127         output = Loader().load('avg_testdata.txt') 
    128         answer = output[0] 
    129         for i in range(r.nbins_phi): 
    130             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    131             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    132             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
    133  
    134     def test_box(self): 
    135         """ 
    136             Test circular averaging 
    137             The test data was not generated by IGOR. 
    138         """ 
     152 
    139153        r = Boxsum(x_min=.01, x_max=.015, y_min=0.01, y_max=0.015) 
    140154        s, ds, npoints = r(self.data) 
    141155        self.assertAlmostEqual(s, 34.278990899999997, 4) 
    142156        self.assertAlmostEqual(ds, 7.8007981835194293, 4) 
    143         self.assertAlmostEqual(npoints, 324.0000, 4)         
     157        self.assertAlmostEqual(npoints, 324.0000, 4) 
    144158 
    145159        r = Boxavg(x_min=.01, x_max=.015, y_min=0.01, y_max=0.015) 
    … …  
    153167            The test data was not generated by IGOR. 
    154168        """ 
    155         r = SlabX(x_min=-.01, x_max=.01, y_min=-0.0002, y_max=0.0002, bin_width=0.0004) 
     169 
     170        r = SlabX(x_min=-.01, x_max=.01, y_min=-0.0002, 
     171                  y_max=0.0002, bin_width=0.0004) 
    156172        r.fold = False 
    157173        o = r(self.data) 
    158174 
    159         output = Loader().load('slabx_testdata.txt') 
    160         answer = output[0] 
     175        filepath = os.path.join(os.path.dirname( 
     176            os.path.realpath(__file__)), 'slabx_testdata.txt') 
     177        answer = Loader().load(filepath) 
    161178        for i in range(len(o.x)): 
    162179            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    169186            The test data was not generated by IGOR. 
    170187        """ 
    171         r = SlabY(x_min=.005, x_max=.01, y_min=-0.01, y_max=0.01, bin_width=0.0004) 
     188 
     189        r = SlabY(x_min=.005, x_max=.01, y_min=- 
     190                  0.01, y_max=0.01, bin_width=0.0004) 
    172191        r.fold = False 
    173192        o = r(self.data) 
    174193 
    175         output = Loader().load('slaby_testdata.txt') 
    176         answer = output[0] 
     194        filepath = os.path.join(os.path.dirname( 
     195            os.path.realpath(__file__)), 'slaby_testdata.txt') 
     196        answer = Loader().load(filepath) 
    177197        for i in range(len(o.x)): 
    178198            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    … …  
    183203        """ 
    184204            Test sector averaging I(phi) 
    185             When considering the whole azimuthal range (2pi),  
     205            When considering the whole azimuthal range (2pi), 
    186206            the answer should be the same as ring averaging. 
    187207            The test data was not generated by IGOR. 
    188208        """ 
     209 
    189210        nbins = 19 
    190211        phi_min = math.pi / (nbins + 1) 
    … …  
    198219        o = r(self.data) 
    199220 
    200         output = Loader().load('ring_testdata.txt') 
    201         answer = output[0] 
    202         for i in range(len(o.x)): 
    203             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    204             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    205             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
    206              
     221        filepath = os.path.join(os.path.dirname( 
     222            os.path.realpath(__file__)), 'ring_testdata.txt') 
     223        answer = Loader().load(filepath) 
     224        for i in range(len(o.x)): 
     225            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     226            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     227            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     228 
    207229    def test_sectorphi_quarter(self): 
    208230        """ 
    … …  
    210232            The test data was not generated by IGOR. 
    211233        """ 
    212         r = SectorPhi(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi/2.0) 
    213         r.nbins_phi = 20 
    214         o = r(self.data) 
    215  
    216         output = Loader().load('sectorphi_testdata.txt') 
    217         answer = output[0] 
    218         for i in range(len(o.x)): 
    219             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    220             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    221             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
    222              
     234 
     235        r = SectorPhi(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi / 2.0) 
     236        r.nbins_phi = 20 
     237        o = r(self.data) 
     238 
     239        filepath = os.path.join(os.path.dirname( 
     240            os.path.realpath(__file__)), 'sectorphi_testdata.txt') 
     241        answer = Loader().load(filepath) 
     242        for i in range(len(o.x)): 
     243            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     244            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     245            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     246 
    223247    def test_sectorq_full(self): 
    224248        """ 
    … …  
    226250            The test data was not generated by IGOR. 
    227251        """ 
    228         r = SectorQ(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi/2.0) 
    229         r.nbins_phi = 20 
    230         o = r(self.data) 
    231  
    232         output = Loader().load('sectorq_testdata.txt') 
    233         answer = output[0] 
    234         for i in range(len(o.x)): 
    235             self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
    236             self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
    237             self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     252 
     253        r = SectorQ(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi / 2.0) 
     254        r.nbins_phi = 20 
     255        o = r(self.data) 
     256 
     257        filepath = os.path.join(os.path.dirname( 
     258            os.path.realpath(__file__)), 'sectorq_testdata.txt') 
     259        answer = Loader().load(filepath) 
     260        for i in range(len(o.x)): 
     261            self.assertAlmostEqual(o.x[i], answer.x[i], 4) 
     262            self.assertAlmostEqual(o.y[i], answer.y[i], 4) 
     263            self.assertAlmostEqual(o.dy[i], answer.dy[i], 4) 
     264 
     265    def test_sectorq_log(self): 
     266        """ 
     267            Test sector averaging I(q) 
     268            The test data was not generated by IGOR. 
     269        """ 
     270 
     271        r = SectorQ(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi / 2.0, base=10) 
     272        r.nbins_phi = 20 
     273        o = r(self.data) 
     274 
     275        expected_binning = np.logspace(np.log10(0.005), np.log10(0.01), 20, base=10) 
     276        for i in range(len(o.x)): 
     277            self.assertAlmostEqual(o.x[i], expected_binning[i], 3) 
     278 
     279        # TODO: Test for Y values (o.y) 
     280        # print len(self.data.x_bins) 
     281        # print len(self.data.y_bins) 
     282        # print self.data.q_data.shape 
     283        # data_to_bin = np.array(self.data.q_data) 
     284        # data_to_bin = data_to_bin.reshape(len(self.data.x_bins), len(self.data.y_bins)) 
     285        # H, xedges, yedges, binnumber = binned_statistic_2d(self.data.x_bins, self.data.y_bins, data_to_bin, 
     286        #     bins=[[0, math.pi / 2.0], expected_binning], statistic='mean') 
     287        # xedges_width = (xedges[1] - xedges[0]) 
     288        # xedges_center = xedges[1:] - xedges_width / 2 
     289 
     290        # yedges_width = (yedges[1] - yedges[0]) 
     291        # yedges_center = yedges[1:] - yedges_width / 2 
     292 
     293        # print H.flatten().shape 
     294        # print o.y.shape 
    238295 
    239296 

  • test/sasdataloader/test/utest_cansas.py

    r7432acb r1fc50fb2  
    4646        self.schema_1_0 = "cansas1d_v1_0.xsd" 
    4747        self.schema_1_1 = "cansas1d_v1_1.xsd" 
    48  
     48        self.write_1_0_filename = "isis_1_0_write_test.xml" 
     49        self.write_1_1_filename = "isis_1_1_write_test.xml" 
    4950 
    5051    def get_number_of_entries(self, dictionary, name, i): 
    … …  
    5657        return name 
    5758 
    58  
    5959    def test_invalid_xml(self): 
    6060        """ 
    … …  
    6262        """ 
    6363        invalid = StringIO.StringIO('<a><c></b></a>') 
    64         reader = XMLreader(invalid) 
    65  
     64        XMLreader(invalid) 
    6665 
    6766    def test_xml_validate(self): 
    … …  
    8281        self.assertFalse(xmlschema.validate(invalid)) 
    8382 
    84  
    8583    def test_real_xml(self): 
    8684        reader = XMLreader(self.xml_valid, self.schema_1_0) 
    … …  
    9088        else: 
    9189            self.assertFalse(valid) 
    92  
    9390 
    9491    def _check_data(self, data): 
    … …  
    105102        self.assertTrue(data.meta_data["xmlpreprocess"] is not None) 
    106103 
    107  
    108104    def _check_data_1_1(self, data): 
    109105        spectrum = data.trans_spectrum[0] 
    110106        self.assertTrue(len(spectrum.wavelength) == 138) 
    111107 
    112  
    113108    def test_cansas_xml(self): 
    114         filename = "isis_1_1_write_test.xml" 
    115109        xmlreader = XMLreader(self.isis_1_1, self.schema_1_1) 
    116110        valid = xmlreader.validate_xml() 
    117111        xmlreader.set_processing_instructions() 
    118112        self.assertTrue(valid) 
    119         fo = open(self.isis_1_1) 
    120         str = fo.read() 
    121113        reader_generic = Loader() 
    122114        dataloader = reader_generic.load(self.isis_1_1) 
    … …  
    128120            self._check_data(cansasreader[i]) 
    129121            self._check_data_1_1(cansasreader[i]) 
    130             reader_generic.save(filename, dataloader[i], None) 
    131             fo = open(filename) 
    132             str = fo.read() 
     122            reader_generic.save(self.write_1_1_filename, dataloader[i], None) 
    133123            reader2 = Loader() 
    134             return_data = reader2.load(filename) 
     124            self.assertTrue(os.path.isfile(self.write_1_1_filename)) 
     125            return_data = reader2.load(self.write_1_1_filename) 
    135126            written_data = return_data[0] 
    136127            self._check_data(written_data) 
    137  
     128        if os.path.isfile(self.write_1_1_filename): 
     129            os.remove(self.write_1_1_filename) 
    138130 
    139131    def test_double_trans_spectra(self): 
    … …  
    144136        for item in data: 
    145137            self._check_data(item) 
    146  
    147138 
    148139    def test_entry_name_recurse(self): 
    … …  
    155146        self.assertTrue(len(d) == 6) 
    156147 
    157  
    158148    def test_load_cansas_file(self): 
    159         valid = [] 
    160149        reader1 = XMLreader(self.xml_valid, self.schema_1_0) 
    161150        self.assertTrue(reader1.validate_xml()) 
    … …  
    173162        self.assertFalse(reader7.validate_xml()) 
    174163 
    175  
    176164    def test_invalid_cansas(self): 
    177165        list = self.loader.load(self.cansas1d_notitle) 
    … …  
    184172        self.assertTrue(data.detector[0].distance == 4150) 
    185173 
    186  
    187174    def test_old_cansas_files(self): 
    188175        reader1 = XMLreader(self.cansas1d, self.schema_1_0) 
    189176        self.assertTrue(reader1.validate_xml()) 
    190177        file_loader = Loader() 
    191         file1 = file_loader.load(self.cansas1d) 
     178        file_loader.load(self.cansas1d) 
    192179        reader2 = XMLreader(self.cansas1d_units, self.schema_1_0) 
    193180        self.assertTrue(reader2.validate_xml()) 
    … …  
    197184        self.assertTrue(reader4.validate_xml()) 
    198185 
    199  
    200186    def test_save_cansas_v1_0(self): 
    201         filename = "isis_1_0_write_test.xml" 
    202187        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0) 
    203188        valid = xmlreader.validate_xml() 
    … …  
    210195            self._check_data(dataloader[i]) 
    211196            self._check_data(cansasreader[i]) 
    212             reader_generic.save(filename, dataloader[i], None) 
     197            reader_generic.save(self.write_1_0_filename, dataloader[i], None) 
    213198            reader2 = Reader() 
    214             return_data = reader2.read(filename) 
     199            self.assertTrue(os.path.isfile(self.write_1_0_filename)) 
     200            return_data = reader2.read(self.write_1_0_filename) 
    215201            written_data = return_data[0] 
    216             xmlwrite = XMLreader(filename, self.schema_1_0) 
     202            XMLreader(self.write_1_0_filename, self.schema_1_0) 
    217203            valid = xmlreader.validate_xml() 
    218204            self.assertTrue(valid) 
    219205            self._check_data(written_data) 
    220  
     206        if os.path.isfile(self.write_1_0_filename): 
     207            os.remove(self.write_1_0_filename) 
    221208 
    222209    def test_processing_instructions(self): 
    … …  
    224211        valid = reader.validate_xml() 
    225212        if valid: 
    226             ## find the processing instructions and make into a dictionary 
     213            # find the processing instructions and make into a dictionary 
    227214            dic = self.get_processing_instructions(reader) 
    228215            self.assertTrue(dic == {'xml-stylesheet': \ 
    … …  
    232219            xmldoc = minidom.parseString(xml) 
    233220 
    234             ## take the processing instructions and put them back in 
     221            # take the processing instructions and put them back in 
    235222            xmldoc = self.set_processing_instructions(xmldoc, dic) 
    236             xml_output = xmldoc.toprettyxml() 
    237  
     223            xmldoc.toprettyxml() 
    238224 
    239225    def set_processing_instructions(self, minidom_object, dic): 
    … …  
    243229            minidom_object.insertBefore(pi, xmlroot) 
    244230        return minidom_object 
    245  
    246231 
    247232    def get_processing_instructions(self, xml_reader_object): 

  • test/sasdataloader/test/utest_ascii.py

    r959eb01 rad92c5a  
    66 
    77import unittest 
    8 from sas.sascalc.dataloader.loader import  Loader 
    9   
    10 import os.path 
     8from sas.sascalc.dataloader.loader import Loader 
    119 
    12 class abs_reader(unittest.TestCase): 
     10 
     11class ABSReaderTests(unittest.TestCase): 
    1312     
    1413    def setUp(self): 
    1514        self.loader = Loader() 
    16          
     15        self.f1_list = self.loader.load("ascii_test_1.txt") 
     16        self.f1 = self.f1_list[0] 
     17        self.f2_list = self.loader.load("ascii_test_2.txt") 
     18        self.f2 = self.f2_list[0] 
     19        self.f3_list = self.loader.load("ascii_test_3.txt") 
     20        self.f3 = self.f3_list[0] 
     21        self.f4_list = self.loader.load("ascii_test_4.abs") 
     22        self.f4 = self.f4_list[0] 
     23        self.f5_list = self.loader.load("ascii_test_5.txt") 
     24        self.f5 = self.f5_list[0] 
     25 
    1726    def test_checkdata(self): 
    1827        """ 
    1928            Test .ABS file loaded as ascii 
    2029        """ 
    21         f = self.loader.load("ascii_test_1.txt") 
    2230        # The length of the data is 10 
    23         self.assertEqual(len(f.x), 10) 
    24         self.assertEqual(f.x[0],0.002618) 
    25         self.assertEqual(f.x[9],0.0497) 
    26         self.assertEqual(f.x_unit, '1/A') 
    27         self.assertEqual(f.y_unit, '1/cm') 
     31        self.assertEqual(len(self.f1.x), 10) 
     32        self.assertEqual(self.f1.x[0],0.002618) 
     33        self.assertEqual(self.f1.x[9],0.0497) 
     34        self.assertEqual(self.f1.x_unit, '1/A') 
     35        self.assertEqual(self.f1.y_unit, '1/cm') 
    2836         
    29         self.assertEqual(f.meta_data['loader'],"ASCII") 
    30          
     37        self.assertEqual(self.f1.meta_data['loader'],"ASCII") 
     38 
    3139    def test_truncated_1(self): 
    3240        """ 
    … …  
    3846            as though it were the start of a footer). 
    3947        """ 
    40         # Test .ABS file loaded as ascii 
    41         f = self.loader.load("ascii_test_2.txt") 
    42         # The length of the data is 10 
    43         self.assertEqual(len(f.x), 5) 
    44         self.assertEqual(f.x[0],0.002618) 
    45         self.assertEqual(f.x[4],0.02356) 
    46          
     48        # The length of the data is 5 
     49        self.assertEqual(len(self.f2.x), 5) 
     50        self.assertEqual(self.f2.x[0],0.002618) 
     51        self.assertEqual(self.f2.x[4],0.02356) 
     52 
    4753    def test_truncated_2(self): 
    4854        """ 
    … …  
    5258            reading at the first inconsitent line. 
    5359        """ 
    54         # Test .ABS file loaded as ascii 
    55         f = self.loader.load("ascii_test_3.txt") 
    5660        # The length of the data is 5 
    57         self.assertEqual(len(f.x), 5) 
    58         self.assertEqual(f.x[0],0.002618) 
    59         self.assertEqual(f.x[4],0.02356) 
    60          
     61        self.assertEqual(len(self.f3.x), 5) 
     62        self.assertEqual(self.f3.x[0],0.002618) 
     63        self.assertEqual(self.f3.x[4],0.02356) 
     64 
    6165    def test_truncated_3(self): 
    6266        """ 
    … …  
    6670            reading at the last line of header. 
    6771        """ 
    68         # Test .ABS file loaded as ascii 
    69         f = self.loader.load("ascii_test_4.abs") 
    7072        # The length of the data is 5 
    71         self.assertEqual(len(f.x), 5) 
    72         self.assertEqual(f.x[0],0.012654) 
    73         self.assertEqual(f.x[4],0.02654) 
    74          
     73        self.assertEqual(len(self.f4.x), 5) 
     74        self.assertEqual(self.f4.x[0],0.012654) 
     75        self.assertEqual(self.f4.x[4],0.02654) 
     76 
    7577    def test_truncated_4(self): 
    7678        """ 
    … …  
    7880            Only the last 5 2-col lines should be read. 
    7981        """ 
    80         # Test .ABS file loaded as ascii 
    81         f = self.loader.load("ascii_test_5.txt") 
    8282        # The length of the data is 5 
    83         self.assertEqual(len(f.x), 5) 
    84         self.assertEqual(f.x[0],0.02879) 
    85         self.assertEqual(f.x[4],0.0497) 
    86          
     83        self.assertEqual(len(self.f5.x), 5) 
     84        self.assertEqual(self.f5.x[0],0.02879) 
     85        self.assertEqual(self.f5.x[4],0.0497) 
     86 
    8787    def test_truncated_5(self): 
    8888        """ 
    89             Test a 6-col ascii file with complex header where one of them has a letter and  
    90             many lines with 2 or 2 columns in the middle of the data section. 
    91             Only last four lines should be read. 
     89            Test a 6-col ascii file with complex header where one of them has a 
     90            letter and many lines with 2 or 2 columns in the middle of the data 
     91            section. Will be rejected because fewer than 5 lines. 
    9292        """ 
    9393        # Test .ABS file loaded as ascii 
    … …  
    9898        except: 
    9999            self.assertEqual(f, None) 
    100          
     100 
    101101if __name__ == '__main__': 
    102102    unittest.main() 

  • test/sasdataloader/test/utest_red2d_reader.py

    r959eb01 r248ff73  
    77import unittest 
    88from sas.sascalc.dataloader.loader import  Loader 
    9   
     9 
    1010import os.path 
    1111 
    1212class abs_reader(unittest.TestCase): 
    13      
     13 
    1414    def setUp(self): 
    1515        self.loader = Loader() 
    16          
     16 
    1717    def test_checkdata(self): 
    1818        """ 
    1919            Test .DAT file loaded as IGOR/DAT 2D Q_map 
    2020        """ 
    21         f = self.loader.load("exp18_14_igor_2dqxqy.dat") 
     21        f = self.loader.load("exp18_14_igor_2dqxqy.dat")[0] 
    2222        # The length of the data is 10 
    2323        self.assertEqual(len(f.qx_data),  36864) 
    … …  
    2626        self.assertEqual(f.Q_unit, '1/A') 
    2727        self.assertEqual(f.I_unit, '1/cm') 
    28          
     28 
    2929        self.assertEqual(f.meta_data['loader'],"IGOR/DAT 2D Q_map") 
    30          
    31          
     30 
     31 
    3232if __name__ == '__main__': 
    3333    unittest.main() 
    34     
Note: See TracChangeset for help on using the changeset viewer.