Source Code for Module diffpy.pdffit2.tests.ExceptionsTest

  1  #!/usr/bin/env python 
  2  ############################################################################## 
  3  # 
  4  # pdffit2           by DANSE Diffraction group 
  5  #                   Simon J. L. Billinge 
  6  #                   (c) 2006 trustees of the Michigan State University. 
  7  #                   All rights reserved. 
  8  # 
  9  # File coded by:    Chris Farrow 
 10  # 
 11  # See AUTHORS.txt for a list of people who contributed. 
 12  # See LICENSE.txt for license information. 
 13  # 
 14  ############################################################################## 
 15   
 16   
 17  import unittest 
 18   
 19  from diffpy.pdffit2 import PdfFit 
 20  from diffpy.pdffit2 import pdffit2 
 21  from pdffit2testutils import datafile 
 22   
 23   
 24 -class read_structExceptions(unittest.TestCase): 
 25   
 26 -    def setUp(self): 
 27          self.P = PdfFit() 
 28   
 29 -    def tearDown(self): 
 30          del self.P 
 31   
 32 -    def test_IOError(self): 
 33          """raise IOError when structure file does not exist""" 
 34          self.assertRaises(IOError, self.P.read_struct, "Nofile.stru") 
 35   
 36 -    def test_structureError(self): 
 37          """raise pdffit2.structureError when structure is malformed""" 
 38          self.assertRaises(pdffit2.structureError, self.P.read_struct, 
 39                  datafile("badNi.stru")) 
 40   
 41 -    def test_structureErrorZeroVolume(self): 
 42          """raise pdffit2.structureError when unit cell volume is negative""" 
 43          #I don't know how to test for this, but it's in the library code 
 44          self.assertRaises(pdffit2.structureError, 
 45                  self.P.read_struct, datafile("badNiZeroVolume.stru")) 
 46   
 47 -class read_dataExceptions(unittest.TestCase): 
 48   
 49 -    def setUp(self): 
 50          self.P = PdfFit() 
 51   
 52 -    def tearDown(self): 
 53          del self.P 
 54   
 55 -    def test_IOError(self): 
 56          """raise IOError when data file does not exist""" 
 57          self.assertRaises(IOError, self.P.read_data, "Nofile.dat", 
 58                 'X', 25.0, 0.5) 
 59   
 60 -    def test_dataError(self): 
 61          """raise pdffit2.dataError when data has improper spacing""" 
 62          self.assertRaises(pdffit2.dataError, self.P.read_data, 
 63                  datafile("badNi.dat"), 'X', 25.0, 0.5) 
 64   
 65 -class read_data_listsExceptions(unittest.TestCase): 
 66   
 67 -    def setUp(self): 
 68          self.P = PdfFit() 
 69          self.r_data = [0.1, 0.2] 
 70          self.Gr_data = [1, 2, 3] 
 71          self.qmax = 10 
 72          self.qdamp = 0.5 
 73   
 74 -    def tearDown(self): 
 75          del self.P 
 76   
 77 -    def test_ValueError1(self): 
 78          """raise ValueError when lists are of different length""" 
 79          self.assertRaises(ValueError, self.P.read_data_lists, 'X', self.qmax, 
 80                  self.qdamp, self.r_data, self.Gr_data) 
 81   
 82 -    def test_ValueError2(self): 
 83          """raise ValueError when qmax < 0""" 
 84          self.assertRaises(ValueError, self.P.read_data_lists, 'X', -self.qmax, 
 85                  self.qdamp, self.r_data, self.Gr_data) 
 86   
 87 -    def test_ValueError3(self): 
 88          """raise ValueError when qdamp < 0""" 
 89          self.assertRaises(ValueError, self.P.read_data_lists, 'X', self.qmax, 
 90                  -self.qdamp, self.r_data, self.Gr_data) 
 91   
 92 -    def test_dataError(self): 
 93          """raise pdffit2.dataError when data has improper spacing""" 
 94          r_data = [0.1, 0.52, 0.2] 
 95          self.assertRaises(pdffit2.dataError, self.P.read_data_lists, 'X', self.qmax, 
 96                  self.qdamp, r_data, self.Gr_data) 
 97   
 98   
 99 -class pdfrangeExceptions(unittest.TestCase): 
100   
101 -    def setUp(self): 
102          self.P = PdfFit() 
103          self.iset = 1 
104          self.rmin = 4.0 
105          self.rmax = 10.0 
106   
107 -    def tearDown(self): 
108          del self.P 
109   
110 -    def test_ValueError1(self): 
111          """raise ValueError when iset does not exist""" 
112          self.assertRaises(ValueError, self.P.pdfrange, self.iset, self.rmin, 
113                  self.rmax) 
114   
115 -    def test_ValueError2(self): 
116          """raise ValueError when rmax < rmin""" 
117          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.5) 
118          self.assertRaises(ValueError, self.P.pdfrange, self.iset, self.rmax, 
119                  self.rmin) 
120   
121 -    def test_ValueError3(self): 
122          """raise ValueError when range outside of data""" 
123          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.5) 
124          self.assertRaises(ValueError, self.P.pdfrange, self.iset, -self.rmin, 
125                  self.rmax) 
126   
127   
128 -class allocExceptions(unittest.TestCase): 
129   
130 -    def setUp(self): 
131          self.P = PdfFit() 
132          self.qmax = 25 
133          self.qdamp = 0.5 
134          self.rmin = 4.0 
135          self.rmax = 10.0 
136          self.bin = 100 
137   
138 -    def tearDown(self): 
139          del self.P 
140   
141 -    def test_ValueError1(self): 
142          """raise ValueError when qmax < 0""" 
143          self.P.read_struct(datafile("Ni.stru")) 
144          self.assertRaises(ValueError, self.P.alloc, 'X', -self.qmax, self.qdamp, 
145                  self.rmin, self.rmax, self.bin) 
146   
147 -    def test_ValueError2(self): 
148          """raise ValueError when qdamp < 0""" 
149          self.P.read_struct(datafile("Ni.stru")) 
150          self.assertRaises(ValueError, self.P.alloc, 'X', self.qmax, -self.qdamp, 
151                  self.rmin, self.rmax, self.bin) 
152   
153 -    def test_ValueError3(self): 
154          """raise ValueError when rmin < 0""" 
155          self.P.read_struct(datafile("Ni.stru")) 
156          self.assertRaises(ValueError, self.P.alloc, 'X', self.qmax, self.qdamp, 
157                  -self.rmin, self.rmax, self.bin) 
158   
159 -    def test_ValueError4(self): 
160          """raise ValueError when rmax < 0""" 
161          self.P.read_struct(datafile("Ni.stru")) 
162          self.assertRaises(ValueError, self.P.alloc, 'X', self.qmax, self.qdamp, 
163                  self.rmin, -self.rmax, self.bin) 
164   
165 -    def test_ValueError5(self): 
166          """raise ValueError when bin < 0""" 
167          self.P.read_struct(datafile("Ni.stru")) 
168          self.assertRaises(ValueError, self.P.alloc, 'X', self.qmax, self.qdamp, 
169                  self.rmin, self.rmax, -self.bin) 
170   
171 -    def test_ValueError6(self): 
172          """raise ValueError when rmax < rmin""" 
173          self.P.read_struct(datafile("Ni.stru")) 
174          self.assertRaises(ValueError, self.P.alloc, 'X', self.qmax, self.qdamp, 
175                  self.rmax, self.rmin, self.bin) 
176   
177 -    def test_ValueError7(self): 
178          """raise ValueError when qdamp < 0""" 
179          self.P.read_struct(datafile("Ni.stru")) 
180          self.assertRaises(ValueError, self.P.alloc, 'X', self.qmax, self.qdamp, 
181                  self.rmin, self.rmax, -self.bin) 
182   
183   
184 -class calcExceptions(unittest.TestCase): 
185   
186 -    def setUp(self): 
187          self.P = PdfFit() 
188          self.P.read_struct(datafile("Ni.stru")) 
189   
190 -    def tearDown(self): 
191          del self.P 
192   
193 -    def test_unassignedError(self): 
194          """raise pdffit2.unassignedError when no space has been allocated""" 
195          self.assertRaises(pdffit2.unassignedError, self.P.calc) 
196   
197  # PJ 2006-03-06 
198  # 
199  # test_calculationError raised exception, because for Qmax=0.5, rmax would 
200  # increase to 4010A and this would throw exception when the size of bnd array 
201  # would exceed MAXBND limit.  However, bnd vector can now grow, thus rmax 
202  # is not limited and the following test would hang indefinitely. 
203   
204  #   def test_calculationError(self): 
205  #       """raise pdffit2.calculationError when calculation cannot be done""" 
206  #       self.P.alloc('X', 0.01, 0.5, 2, 10, 100) 
207  #       self.assertRaises(pdffit2.calculationError, self.P.calc) 
208   
209   
210  #class refineExceptions(unittest.TestCase): 
211      #I'm not sure how to test these 
212   
213  #    def setUp(self): 
214  #        self.P = PdfFit() 
215  # 
216  #    def test_calculationError(self): 
217  #        """raise pdffit2.calculationError when model pdf can't be calculated""" 
218  #        #self.assertRaises(pdffit2.calculationError, self.P.calc) 
219  # 
220  #    def test_constraintError(self): 
221  #        """raise pdffit2.constraintError for bad constraint(s)""" 
222  #        #self.assertRaises(pdffit2.constraintError, self.P.calc) 
223   
224   
225  #class refine_stepExceptions(unittest.TestCase): 
226      #I'm not sure how to test these 
227   
228  #    def setUp(self): 
229  #        self.P = PdfFit() 
230  # 
231  #    def test_calculationError(self): 
232  #        """raise pdffit2.calculationError when model pdf can't be calculated""" 
233  #        #self.assertRaises(pdffit2.calculationError, self.P.calc) 
234  # 
235  #    def test_constraintError(self): 
236  #        """raise pdffit2.constraintError for bad constraint(s)""" 
237  #        #self.assertRaises(pdffit2.constraintError, self.P.calc) 
238   
239   
240 -class save_pdfExceptions(unittest.TestCase): 
241   
242 -    def setUp(self): 
243          self.P = PdfFit() 
244          self.strufile = "temp.pdf" 
245   
246 -    def tearDown(self): 
247          del self.P 
248   
249 -    def test_IOError(self): 
250          """raise IOError when structure cannot be saved""" 
251          self.P.read_struct(datafile("Ni.stru")) 
252          self.P.alloc('X', 30.0, 0.05, 2, 10, 100) 
253          self.P.calc() 
254          self.assertRaises(IOError, self.P.save_pdf, 1, 
255                  "nodir183160/"+self.strufile) 
256   
257 -    def test_unassignedError(self): 
258          """raise pdffit2.unassignedError when structure is undefined""" 
259          self.assertRaises(pdffit2.unassignedError, self.P.save_pdf, 1, 
260          self.strufile) 
261   
262   
263 -class save_difExceptions(unittest.TestCase): 
264   
265 -    def setUp(self): 
266          self.P = PdfFit() 
267          self.strufile = "temp.dif" 
268   
269 -    def tearDown(self): 
270          del self.P 
271   
272 -    def test_IOError(self): 
273          """raise IOError when dif cannot be saved""" 
274          self.P.read_struct(datafile("Ni.stru")) 
275          self.P.alloc('X', 30.0, 0.05, 2, 10, 100) 
276          self.P.calc() 
277          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.5) 
278          self.assertRaises(IOError, self.P.save_dif, 1, 
279                  "nodir183160/"+self.strufile) 
280   
281 -    def test_unassignedError(self): 
282          """raise pdffit2.unassignedError when structure is undefined""" 
283          self.assertRaises(pdffit2.unassignedError, self.P.save_dif, 1, 
284          self.strufile) 
285   
286   
287 -class save_resExceptions(unittest.TestCase): 
288   
289 -    def setUp(self): 
290          self.P = PdfFit() 
291          self.resfile = "temp.res" 
292   
293 -    def tearDown(self): 
294          del self.P 
295   
296 -    def test_IOError(self): 
297          """raise IOError when residual file cannot be saved""" 
298          self.P.read_struct(datafile("Ni.stru")) 
299          self.P.read_data(datafile("Ni.dat"), 'X', 30.0, 0.0) 
300          self.P.constrain(self.P.lat(1), 1) 
301          self.P.setpar(1, 3.0) 
302          self.P.pdfrange(1,2.0,10.0) 
303          self.P.refine_step() 
304          self.assertRaises(IOError, self.P.save_res, 
305                  "nodir183160/"+self.resfile) 
306   
307 -    def test_unassignedError(self): 
308          """raise pdffit2.unassignedError when structure is undefined""" 
309          self.assertRaises(pdffit2.unassignedError, self.P.save_res, 
310          self.resfile) 
311   
312   
313 -class save_structExceptions(unittest.TestCase): 
314      #Same code as show_struct 
315   
316 -    def setUp(self): 
317          self.P = PdfFit() 
318          self.strufile = "temp.stru" 
319   
320 -    def tearDown(self): 
321          del self.P 
322   
323 -    def test_IOError(self): 
324          """raise IOError when structure cannot be saved""" 
325          self.P.read_struct(datafile("Ni.stru")) 
326          self.assertRaises(IOError, self.P.save_struct, 1, 
327                  "nodir183160/"+self.strufile) 
328   
329 -    def test_unassignedError(self): 
330          """raise pdffit2.unassignedError when structure is undefined""" 
331          self.assertRaises(pdffit2.unassignedError, self.P.save_struct, 1, 
332          self.strufile) 
333   
334   
335 -class constrainExceptions(unittest.TestCase): 
336   
337 -    def setUp(self): 
338          self.P = PdfFit() 
339          self.par = 1 
340          return 
341   
342 -    def tearDown(self): 
343          self.P = None 
344          return 
345   
346 -    def test_constraintError(self): 
347          """raise constraintError when constraint is bad""" 
348          self.P.read_struct(datafile("Ni.stru")) 
349          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
350          self.P.constrain('x(1)', 'junk+@1') 
351          self.P.setpar(1, 0.01) 
352          self.assertRaises(pdffit2.constraintError, self.P.calc) 
353          self.assertRaises(pdffit2.constraintError, self.P.refine) 
354          return 
355   
356 -    def test_unassignedError(self): 
357          """raise pdffit2.unassignedError when variable is undefined""" 
358          self.assertRaises(pdffit2.unassignedError, self.P.constrain, self.P.x(1), 
359                  self.par) 
360          return 
361   
362 -    def test_ValueError(self): 
363          """raise ValueError when a variable index does not exist""" 
364          self.P.read_struct(datafile("Ni.stru")) 
365          self.assertRaises(ValueError, self.P.constrain, self.P.x(6), 
366                  self.par) 
367          return 
368   
369 -    def test_constrainNonRefVar(self): 
370          "raise constraintError when attempting to constrain non-refinables" 
371          self.P.read_struct(datafile("Ni.stru")) 
372          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
373          self.assertRaises(pdffit2.constraintError, 
374                  self.P.constrain, 'rcut', '@7') 
375          self.assertRaises(pdffit2.constraintError, 
376                  self.P.constrain, 'rcut', 13) 
377          self.assertRaises(pdffit2.constraintError, 
378                  self.P.constrain, 'stepcut', '@17') 
379          return 
380   
381   
382   
383 -class setvarExceptions(unittest.TestCase): 
384   
385 -    def setUp(self): 
386          self.P = PdfFit() 
387          self.val = 3.0 
388   
389 -    def tearDown(self): 
390          del self.P 
391   
392 -    def test_unassignedError(self): 
393          """raise pdffit2.unassignedError when variable is undefined""" 
394          self.assertRaises(pdffit2.unassignedError, self.P.setvar, self.P.lat(1), 
395                  self.val) 
396   
397 -    def test_ValueError(self): 
398          """raise ValueError when a variable index does not exist""" 
399          self.P.read_struct(datafile("Ni.stru")) 
400          self.assertRaises(ValueError, self.P.setvar, self.P.lat(7), 
401                  self.val) 
402   
403   
404 -class getvarExceptions(unittest.TestCase): 
405   
406 -    def setUp(self): 
407          self.P = PdfFit() 
408   
409 -    def tearDown(self): 
410          del self.P 
411   
412 -    def test_unassignedError(self): 
413          """raise pdffit2.unassignedError when variable is undefined""" 
414          self.assertRaises(pdffit2.unassignedError, self.P.getvar, 
415                  self.P.pscale()) 
416   
417 -    def test_ValueError(self): 
418          """raise ValueError when a variable index does not exist""" 
419          self.P.read_struct(datafile("Ni.stru")) 
420          self.assertRaises(ValueError, self.P.getvar, self.P.lat(7)) 
421   
422   
423 -class getRExceptions(unittest.TestCase): 
424   
425 -    def setUp(self): 
426          self.P = PdfFit() 
427   
428 -    def tearDown(self): 
429          del self.P 
430   
431 -    def test_unassignedError(self): 
432          """raise pdffit2.unassignedError when data does not exist""" 
433          self.assertRaises(pdffit2.unassignedError, self.P.getR) 
434   
435   
436 -class getpdf_fitExceptions(unittest.TestCase): 
437   
438 -    def setUp(self): 
439          self.P = PdfFit() 
440   
441 -    def tearDown(self): 
442          del self.P 
443   
444 -    def test_unassignedError(self): 
445          """raise pdffit2.unassignedError when data does not exist""" 
446          self.assertRaises(pdffit2.unassignedError, self.P.getpdf_fit) 
447   
448   
449 -class getpdf_obsExceptions(unittest.TestCase): 
450   
451 -    def setUp(self): 
452          self.P = PdfFit() 
453   
454 -    def tearDown(self): 
455          del self.P 
456   
457 -    def test_unassignedError(self): 
458          """raise pdffit2.unassignedError when data does not exist""" 
459          self.assertRaises(pdffit2.unassignedError, self.P.getpdf_obs) 
460   
461   
462 -class getpdf_diffExceptions(unittest.TestCase): 
463   
464 -    def setUp(self): 
465          self.P = PdfFit() 
466   
467 -    def tearDown(self): 
468          del self.P 
469   
470 -    def test_unassignedError(self): 
471          """raise pdffit2.unassignedError when data does not exist""" 
472          self.assertRaises(pdffit2.unassignedError, self.P.getpdf_diff) 
473   
474   
475 -class get_atomsExceptions(unittest.TestCase): 
476   
477 -    def setUp(self): 
478          self.P = PdfFit() 
479   
480 -    def tearDown(self): 
481          del self.P 
482   
483 -    def test_unassignedError(self): 
484          """raise pdffit2.unassignedError when data does not exist""" 
485          self.assertRaises(pdffit2.unassignedError, self.P.get_atoms) 
486   
487   
488 -class getparExceptions(unittest.TestCase): 
489   
490 -    def setUp(self): 
491          self.P = PdfFit() 
492   
493 -    def tearDown(self): 
494          del self.P 
495   
496 -    def test_unassignedError1(self): 
497          """raise pdffit2.unassignedError when parameter does not exist""" 
498          self.assertRaises(pdffit2.unassignedError, self.P.getpar, 1) 
499   
500 -    def test_unassignedError2(self): 
501          """raise pdffit2.unassignedError when parameter does not exist""" 
502          self.P.read_struct(datafile("Ni.stru")) 
503          self.P.constrain(self.P.lat(1), 2) 
504          self.assertRaises(pdffit2.unassignedError, self.P.getpar, 1) 
505   
506   
507 -class pselExceptions(unittest.TestCase): 
508   
509 -    def setUp(self): 
510          self.P = PdfFit() 
511          self.ip = 1 
512   
513 -    def tearDown(self): 
514          del self.P 
515   
516 -    def test_unassignedError(self): 
517          """raise pdffit2.unassignedError when phase does not exist""" 
518          self.assertRaises(pdffit2.unassignedError, self.P.pdesel, self.ip) 
519   
520 -    def test_unassignedError2(self): 
521          """raise pdffit2.unassignedError when phase does not exist""" 
522          self.assertRaises(pdffit2.unassignedError, self.P.pdesel, self.ip) 
523   
524   
525 -class pdeselExceptions(unittest.TestCase): 
526   
527 -    def setUp(self): 
528          self.P = PdfFit() 
529          self.ip = 1 
530   
531 -    def tearDown(self): 
532          del self.P 
533   
534 -    def test_unassignedError1(self): 
535          """raise pdffit2.unassignedError when phase does not exist""" 
536          self.assertRaises(pdffit2.unassignedError, self.P.pdesel, self.ip) 
537   
538 -    def test_unassignedError2(self): 
539          """raise pdffit2.unassignedError when phase does not exist""" 
540          self.P.read_struct(datafile("Ni.stru")) 
541          self.assertRaises(pdffit2.unassignedError, self.P.pdesel, self.ip) 
542   
543   
544 -class selectAtomTypeExceptions(unittest.TestCase): 
545   
546 -    def setUp(self): 
547          self.P = PdfFit() 
548          self.iset = 1 
549          self.i = 1 
550   
551 -    def tearDown(self): 
552          del self.P 
553   
554 -    def test_unassignedError1(self): 
555          """raise pdffit2.unassignedError when set does not exist""" 
556          self.assertRaises(pdffit2.unassignedError, self.P.selectAtomType, 
557                  self.iset, 'i', 'Ni', True) 
558   
559 -    def test_unassignedError2(self): 
560          """raise pdffit2.unassignedError when set does not exist""" 
561          self.P.read_struct(datafile("Ni.stru")) 
562          # selectAtomType should pass with one phase defined 
563          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
564          self.P.selectAtomType(self.iset, 'i', 'Ni', True) 
565          self.P.selectAtomType(self.iset, 'j', 'Ni', False) 
566          # but fail for phase 2 which is not present 
567          self.assertRaises(pdffit2.unassignedError, self.P.selectAtomType, 
568                  2, 'i', 'Ca', True) 
569   
570 -    def test_ijcharValueError(self): 
571          """raise ValueError when ijchar is neither 'i' nor 'j'""" 
572          self.P.read_struct(datafile("Ni.stru")) 
573          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
574          self.P.selectAtomType(self.iset, 'i', 'Ni', True) 
575          self.P.selectAtomType(self.iset, 'j', 'Ni', True) 
576          self.assertRaises(ValueError, self.P.selectAtomType, 
577                  self.iset, 'k', 'Ni', True) 
578   
579   
580 -class selectAtomIndexExceptions(unittest.TestCase): 
581   
582 -    def setUp(self): 
583          self.P = PdfFit() 
584          self.iset = 1 
585          self.i = 1 
586   
587 -    def tearDown(self): 
588          del self.P 
589   
590 -    def test_unassignedError1(self): 
591          """raise pdffit2.unassignedError when set does not exist""" 
592          self.assertRaises(pdffit2.unassignedError, self.P.selectAtomIndex, 
593                  self.iset, 'i', self.i, True) 
594   
595 -    def test_unassignedError2(self): 
596          """raise pdffit2.unassignedError when set does not exist""" 
597          self.P.read_struct(datafile("Ni.stru")) 
598          # pass for phase 1 
599          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
600          self.P.selectAtomIndex(self.iset, 'i', 1, True) 
601          self.P.selectAtomIndex(self.iset, 'i', 2, False) 
602          # fail for phase 2 
603          self.assertRaises(pdffit2.unassignedError, self.P.selectAtomIndex, 
604                  2, 'i', 1, True) 
605   
606 -    def test_ValueError(self): 
607          """raise ValueError when selected atom does not exist""" 
608          self.P.read_struct(datafile("Ni.stru")) 
609          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
610          self.assertRaises(ValueError, self.P.selectAtomIndex, 
611                  self.iset, 'i', 6, True) 
612   
613   
614 -class selectAllExceptions(unittest.TestCase): 
615   
616 -    def setUp(self): 
617          self.P = PdfFit() 
618          self.iset = 1 
619          self.i = 1 
620   
621 -    def tearDown(self): 
622          del self.P 
623   
624 -    def test_unassignedError1(self): 
625          """raise pdffit2.unassignedError when set does not exist""" 
626          self.assertRaises(pdffit2.unassignedError, self.P.selectAll, 
627                  self.iset, 'i') 
628   
629 -    def test_unassignedError2(self): 
630          """raise pdffit2.unassignedError when set does not exist""" 
631          self.P.read_struct(datafile("Ni.stru")) 
632          # fail when there is no dataset 
633          self.assertRaises(pdffit2.unassignedError, self.P.selectAll, 
634                  self.iset, 'i') 
635          # pass with dataset 
636          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
637          self.P.selectAll(self.iset, 'i') 
638          self.P.selectAll(self.iset, 'j') 
639          # fail for phase 2 
640          self.assertRaises(pdffit2.unassignedError, self.P.selectAll, 2, 'i') 
641          self.assertRaises(pdffit2.unassignedError, self.P.selectAll, 2, 'j') 
642   
643   
644 -class selectNoneExceptions(unittest.TestCase): 
645   
646 -    def setUp(self): 
647          self.P = PdfFit() 
648          self.iset = 1 
649          self.i = 1 
650   
651 -    def tearDown(self): 
652          del self.P 
653   
654 -    def test_unassignedError1(self): 
655          """raise pdffit2.unassignedError when set does not exist""" 
656          self.assertRaises(pdffit2.unassignedError, self.P.selectNone, 
657                  self.iset, 'i') 
658   
659 -    def test_unassignedError2(self): 
660          """raise pdffit2.unassignedError when set does not exist""" 
661          self.P.read_struct(datafile("Ni.stru")) 
662          # fail when there is no dataset 
663          self.assertRaises(pdffit2.unassignedError, self.P.selectNone, 
664                  self.iset, 'i') 
665          # pass with dataset 
666          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
667          self.P.selectNone(self.iset, 'i') 
668          self.P.selectNone(self.iset, 'j') 
669          # fail for phase 2 
670          self.assertRaises(pdffit2.unassignedError, self.P.selectNone, 2, 'i') 
671          self.assertRaises(pdffit2.unassignedError, self.P.selectNone, 2, 'j') 
672   
673   
674 -class bangExceptions(unittest.TestCase): 
675   
676 -    def setUp(self): 
677          self.P = PdfFit() 
678          self.a1 = 1 
679          self.a2 = 2 
680          self.a3 = 3 
681   
682 -    def tearDown(self): 
683          del self.P 
684   
685 -    def test_unassignedError(self): 
686          """raise pdffit2.unassignedError when phase does not exist""" 
687          self.assertRaises(pdffit2.unassignedError, self.P.bang, self.a1, 
688                  self.a2, self.a3) 
689   
690 -    def test_ValueError1(self): 
691          """raise ValueError when selected atom(s) does not exist""" 
692          self.P.read_struct(datafile('Ni.stru')) 
693          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
694          self.assertRaises(ValueError, self.P.bang, 0, 
695                  self.a2, self.a3) 
696   
697 -    def test_ValueError2(self): 
698          """raise ValueError when selected atom(s) does not exist""" 
699          self.P.read_struct(datafile('Ni.stru')) 
700          self.assertRaises(ValueError, self.P.bang, self.a1, 
701                  -1, self.a3) 
702   
703 -    def test_ValueError3(self): 
704          """raise ValueError when selected atom(s) does not exist""" 
705          self.P.read_struct(datafile('Ni.stru')) 
706          self.assertRaises(ValueError, self.P.bang, self.a1, 
707                  self.a2, 6) 
708   
709   
710 -class blenExceptions(unittest.TestCase): 
711   
712 -    def setUp(self): 
713          self.P = PdfFit() 
714          self.a1 = 1 
715          self.a2 = 2 
716   
717 -    def tearDown(self): 
718          del self.P 
719   
720 -    def test_unassignedError(self): 
721          """raise pdffit2.unassignedError when no data exists""" 
722          self.assertRaises(pdffit2.unassignedError, self.P.blen, self.a1, 
723                  self.a2) 
724   
725 -    def test_ValueError1(self): 
726          """raise ValueError when selected atom(s) does not exist""" 
727          self.P.read_struct(datafile('Ni.stru')) 
728          self.assertRaises(ValueError, self.P.blen, 0, self.a2) 
729   
730 -    def test_ValueError2(self): 
731          """raise ValueError when selected atom(s) does not exist""" 
732          self.P.read_struct(datafile('Ni.stru')) 
733          self.assertRaises(ValueError, self.P.blen, self.a1, 6) 
734   
735 -    def test_ValueError3(self): 
736          """raise ValueError when selected atom(s) does not exist""" 
737          self.P.read_struct(datafile('Ni.stru')) 
738          self.assertRaises(ValueError, self.P.blen, 0, 6) 
739   
740   
741 -class show_scatExceptions(unittest.TestCase): 
742   
743 -    def setUp(self): 
744          self.P = PdfFit() 
745   
746 -    def tearDown(self): 
747          del self.P 
748   
749 -    def test_unassignedError(self): 
750          """raise pdffit2.unassignedError when phase does not exist""" 
751          self.assertRaises(pdffit2.unassignedError, self.P.show_scat, 'X') 
752   
753   
754  #class set_scatExceptions(unittest.TestCase): 
755      #I'm not sure how to use this function 
756   
757  #    def setUp(self): 
758  #        self.P = PdfFit() 
759  # 
760  #    def test_unassignedError1(self): 
761  #        """raise pdffit2.unassignedError when phase does not exist""" 
762  #        #self.assertRaises(pdffit2.constraintError, self.P.calc) 
763  # 
764  #    def test_unassignedError2(self): 
765  #        """raise pdffit2.unassignedError when phase does not exist""" 
766  #        #self.assertRaises(pdffit2.constraintError, self.P.calc) 
767  # 
768  #    def test_ValueError(self): 
769  #        """raise pdffit2.unassignedError when selected atom does not exist""" 
770  #        #self.assertRaises(pdffit2.constraintError, self.P.calc) 
771   
772   
773 -class num_atomsExceptions(unittest.TestCase): 
774   
775 -    def setUp(self): 
776          self.P = PdfFit() 
777   
778 -    def tearDown(self): 
779          del self.P 
780   
781 -    def test_unassignedError(self): 
782          """raise pdffit2.unassignedError when no atoms exist""" 
783          self.assertRaises(pdffit2.unassignedError, self.P.num_atoms) 
784   
785 -class fixparExceptions(unittest.TestCase): 
786   
787 -    def setUp(self): 
788          self.P = PdfFit() 
789   
790 -    def tearDown(self): 
791          del self.P 
792   
793 -    def test_unassignedError(self): 
794          """raise pdffit2.unassignedError when parameter does not exist""" 
795          self.P.read_struct(datafile("Ni.stru")) 
796          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
797          self.assertRaises(pdffit2.unassignedError, self.P.fixpar, 1) 
798   
799   
800 -class freeparExceptions(unittest.TestCase): 
801   
802 -    def setUp(self): 
803          self.P = PdfFit() 
804   
805 -    def tearDown(self): 
806          del self.P 
807   
808 -    def test_unassignedError(self): 
809          """raise pdffit2.unassignedError when parameter does not exist""" 
810          self.P.read_struct(datafile("Ni.stru")) 
811          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
812          self.assertRaises(pdffit2.unassignedError, self.P.freepar, 1) 
813   
814   
815 -class setphaseExceptions(unittest.TestCase): 
816   
817 -    def setUp(self): 
818          self.P = PdfFit() 
819   
820 -    def tearDown(self): 
821          del self.P 
822   
823 -    def test_unassignedError(self): 
824          """raise pdffit2.unassignedError when phase does not exist""" 
825          self.P.read_struct(datafile("Ni.stru")) 
826          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
827          self.assertRaises(pdffit2.unassignedError, self.P.setphase, 2) 
828   
829   
830 -class setdataExceptions(unittest.TestCase): 
831   
832 -    def setUp(self): 
833          self.P = PdfFit() 
834   
835 -    def tearDown(self): 
836          del self.P 
837   
838 -    def test_unassignedError(self): 
839          """raise pdffit2.unassignedError when data set does not exist""" 
840          self.P.read_struct(datafile("Ni.stru")) 
841          self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0) 
842          self.assertRaises(pdffit2.unassignedError, self.P.setdata, 2) 
843   
844 -class getcrwExceptions(unittest.TestCase): 
845   
846 -    def setUp(self): 
847          self.P = PdfFit() 
848   
849 -    def tearDown(self): 
850          del self.P 
851   
852 -    def test_unassignedError(self): 
853          """raise pdffit2.unassignedError when data does not exist""" 
854          self.assertRaises(pdffit2.unassignedError, self.P.getcrw) 
855   
856   
857   
858  #main 
859  if __name__ == '__main__': 
860      #suite = unittest.makeSuite(num_atomsExceptions) 
861      #unittest.TextTestRunner(verbosity=3).run(suite) 
862      #testcase = calcExceptions('test_unassignedError') 
863      #unittest.TextTestRunner(verbosity=3).run(testcase) 
864      unittest.main() 
865   
866  # End of file 
867