source: sasview/test/sasdataloader/test/utest_cansas.py @ b699768

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since b699768 was b699768, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 6 years ago

Initial commit of the refactored SasCalc? module.

  • Property mode set to 100644
File size: 9.6 KB
Line 
1"""
2    Unit tests for the new recursive cansas reader
3"""
4import logging
5import warnings
6warnings.simplefilter("ignore")
7
8import sas.sascalc.dataloader.readers.cansas_reader as cansas
9from sas.sascalc.dataloader.loader import Loader
10from sas.sascalc.dataloader.data_info import Data1D
11from sas.sascalc.dataloader.readers.xml_reader import XMLreader
12from sas.sascalc.dataloader.readers.cansas_reader import Reader
13from sas.sascalc.dataloader.readers.cansas_constants import CansasConstants
14
15import os
16import sys
17import urllib2
18import StringIO
19import pylint as pylint
20import unittest
21import numpy
22
23from lxml import etree
24from xml.dom import minidom
25 
26CANSAS_FORMAT = CansasConstants.CANSAS_FORMAT
27CANSAS_NS = CansasConstants.CANSAS_NS
28   
29class cansas_reader(unittest.TestCase):
30   
31    def setUp(self):
32        self.loader = Loader()
33        self.xml_valid = "cansas_test_modified.xml"
34        self.xml_invalid = "cansas_test.xml"
35        self.cansas1d_badunits = "cansas1d_badunits.xml"
36        self.cansas1d = "cansas1d.xml"
37        self.cansas1d_slit = "cansas1d_slit.xml"
38        self.cansas1d_units = "cansas1d_units.xml"
39        self.isis_1_0 = "ISIS_1_0.xml"
40        self.isis_1_1 = "ISIS_1_1.xml"
41        self.isis_1_1_notrans = "ISIS_1_1_notrans.xml"
42        self.isis_1_1_doubletrans = "ISIS_1_1_doubletrans.xml"
43        self.schema_1_0 = "cansas1d_v1_0.xsd"
44        self.schema_1_1 = "cansas1d_v1_1.xsd"
45       
46   
47    def get_number_of_entries(self, dictionary, name, i):
48        if dictionary.get(name) is not None:
49            i += 1
50            name = name.split("_")[0]
51            name += "_{0}".format(i)
52            name = self.get_number_of_entries(dictionary, name, i)
53        return name
54   
55   
56    def test_invalid_xml(self):
57        """
58        Should fail gracefully and send a message to logging.info()
59        """
60        invalid = StringIO.StringIO('<a><c></b></a>')
61        reader = XMLreader(invalid)
62       
63
64    def test_xml_validate(self):
65        string = "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">\n"
66        string += "\t<xsd:element name=\"a\" type=\"AType\"/>\n"
67        string += "\t<xsd:complexType name=\"AType\">\n"
68        string += "\t\t<xsd:sequence>\n"
69        string += "\t\t\t<xsd:element name=\"b\" type=\"xsd:string\" />\n"
70        string += "\t\t</xsd:sequence>\n"
71        string += "\t</xsd:complexType>\n"
72        string += "</xsd:schema>"
73        f = StringIO.StringIO(string)
74        xmlschema_doc = etree.parse(f)
75        xmlschema = etree.XMLSchema(xmlschema_doc)
76        valid = etree.parse(StringIO.StringIO('<a><b></b></a>'))
77        invalid = etree.parse(StringIO.StringIO('<a><c></c></a>'))
78        self.assertTrue(xmlschema.validate(valid))
79        self.assertFalse(xmlschema.validate(invalid))
80       
81       
82    def test_real_xml(self):
83        reader = XMLreader(self.xml_valid, self.schema_1_0)
84        valid = reader.validate_xml()
85        if valid:
86            self.assertTrue(valid)
87        else:
88            self.assertFalse(valid)
89           
90           
91    def _check_data(self, data):
92        self.assertTrue(data.title == "TK49 c10_SANS")
93        self.assertTrue(data.x.size == 138)
94        self.assertTrue(len(data.meta_data) == 3)
95        self.assertTrue(data.detector[0].distance_unit == "mm")
96        self.assertTrue(data.detector[1].distance_unit == "mm")
97        self.assertTrue(data.detector[0].name == "HAB")
98        self.assertTrue(data.detector[1].name == "main-detector-bank")
99        self.assertTrue(data.detector[0].distance == 575.0)
100        self.assertTrue(data.detector[1].distance == 4145.02)
101        self.assertTrue(data.process[0].name == "Mantid generated CanSAS1D XML")
102        self.assertTrue(data.meta_data["xmlpreprocess"] != None)
103       
104   
105    def _check_data_1_1(self, data):
106        spectrum = data.trans_spectrum[0]
107        self.assertTrue(len(spectrum.wavelength) == 138)
108       
109   
110    def test_cansas_xml(self):
111        filename = "isis_1_1_write_test.xml"
112        xmlreader = XMLreader(self.isis_1_1, self.schema_1_1)
113        valid = xmlreader.validate_xml()
114        xmlreader.set_processing_instructions()
115        self.assertTrue(valid)
116        fo = open(self.isis_1_1)
117        str = fo.read()
118        reader_generic = Loader()
119        dataloader = reader_generic.load(self.isis_1_1)
120        reader_cansas = Reader()
121        cansasreader = reader_cansas.read(self.isis_1_1)
122        for i in range(len(dataloader)):
123            self._check_data(dataloader[i])
124            self._check_data_1_1(dataloader[i])
125            self._check_data(cansasreader[i])
126            self._check_data_1_1(cansasreader[i])
127            reader_generic.save(filename, dataloader[i], None)
128            fo = open(filename)
129            str = fo.read()
130            reader2 = Loader()
131            return_data = reader2.load(filename)
132            written_data = return_data[0]
133            self._check_data(written_data)
134   
135   
136    def test_double_trans_spectra(self):
137        xmlreader = XMLreader(self.isis_1_1_doubletrans, self.schema_1_1)
138        self.assertTrue(xmlreader.validate_xml())
139        reader = Loader()
140        data = reader.load(self.isis_1_1_doubletrans)
141        for item in data:
142            self._check_data(item)
143   
144                   
145    def test_entry_name_recurse(self):
146        test_values = [1,2,3,4,5,6]
147        base_key = "key"
148        d = {}
149        for value in test_values:
150            new_key = self.get_number_of_entries(d, base_key, i = 0)
151            d[new_key] = value
152        self.assertTrue(len(d) == 6)
153       
154   
155    def test_load_cansas_file(self):
156        valid = []
157        reader1 = XMLreader(self.xml_valid, self.schema_1_0)
158        self.assertTrue(reader1.validate_xml())
159        reader2 = XMLreader(self.xml_invalid, self.schema_1_0)
160        self.assertFalse(reader2.validate_xml())
161        reader3 = XMLreader(self.xml_valid, self.schema_1_1)
162        self.assertFalse(reader3.validate_xml())
163        reader4 = XMLreader(self.xml_invalid, self.schema_1_1)
164        self.assertFalse(reader4.validate_xml())
165        reader5 = XMLreader(self.isis_1_0, self.schema_1_0)
166        self.assertTrue(reader5.validate_xml())
167        reader6 = XMLreader(self.isis_1_1, self.schema_1_1)
168        self.assertTrue(reader6.validate_xml())
169        reader7 = XMLreader(self.isis_1_1, self.schema_1_0)
170        self.assertFalse(reader7.validate_xml())
171       
172       
173    def test_old_cansas_files(self):
174        reader1 = XMLreader(self.cansas1d, self.schema_1_0)
175        self.assertTrue(reader1.validate_xml())
176        file_loader = Loader()
177        file1 = file_loader.load(self.cansas1d)
178        reader2 = XMLreader(self.cansas1d_units, self.schema_1_0)
179        self.assertTrue(reader2.validate_xml())
180        reader3 = XMLreader(self.cansas1d_badunits, self.schema_1_0)
181        self.assertTrue(reader3.validate_xml())
182        reader4 = XMLreader(self.cansas1d_slit, self.schema_1_0)
183        self.assertTrue(reader4.validate_xml())
184       
185   
186    def test_save_cansas_v1_0(self):
187        filename = "isis_1_0_write_test.xml"
188        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0)
189        valid = xmlreader.validate_xml()
190        self.assertTrue(valid)
191        reader_generic = Loader()
192        dataloader = reader_generic.load(self.isis_1_0)
193        reader_cansas = Reader()
194        cansasreader = reader_cansas.read(self.isis_1_0)
195        for i in range(len(dataloader)):
196            self._check_data(dataloader[i])
197            self._check_data(cansasreader[i])
198            reader_generic.save(filename, dataloader[i], None)
199            reader2 = Reader()
200            return_data = reader2.read(filename)
201            written_data = return_data[0]
202            xmlwrite = XMLreader(filename, self.schema_1_0)
203            valid = xmlreader.validate_xml()
204            self.assertTrue(valid)
205            self._check_data(written_data)
206       
207       
208    def test_processing_instructions(self):
209        reader = XMLreader(self.isis_1_1, self.schema_1_1)
210        valid = reader.validate_xml()
211        if valid:
212            ## find the processing instructions and make into a dictionary
213            dic = self.get_processing_instructions(reader)
214            self.assertTrue(dic == {'xml-stylesheet': \
215                                    'type="text/xsl" href="cansas1d.xsl" '})
216           
217            xml = "<test><a><b><c></c></b></a></test>"
218            xmldoc = minidom.parseString(xml)
219           
220            ## take the processing instructions and put them back in
221            xmldoc = self.set_processing_instructions(xmldoc, dic)
222            xml_output = xmldoc.toprettyxml()
223           
224   
225    def set_processing_instructions(self, minidom_object, dic):
226        xmlroot = minidom_object.firstChild
227        for item in dic:
228            pi = minidom_object.createProcessingInstruction(item, dic[item])
229            minidom_object.insertBefore(pi, xmlroot)
230        return minidom_object
231   
232   
233    def get_processing_instructions(self, xml_reader_object):
234        dict = {}
235        pi = xml_reader_object.xmlroot.getprevious()
236        i = 0
237        while pi is not None:
238            attr = {}
239            pi_name = ""
240            pi_string = etree.tostring(pi)
241            if isinstance(pi_string, str):
242                pi_string = pi_string.replace("<?", "").replace("?>", "")
243                split = pi_string.split(" ", 1)
244                pi_name = split[0]
245                attr = split[1]
246            dict[pi_name] = attr
247            pi = pi.getprevious()
248        return dict
249       
250
251if __name__ == '__main__':
252    unittest.main()   
Note: See TracBrowser for help on using the repository browser.