source: sasview/test/sansdataloader/test/utest_cansas.py @ 2e3b055

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 2e3b055 was 2e3b055, checked in by Jeff Krzywon <jeffery.krzywon@…>, 10 years ago

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