Source Code for Module test_suite.unit_tests.residue_testing_base

  1  ############################################################################### 
  2  #                                                                             # 
  3  # Copyright (C) 2007-2011 Edward d'Auvergne                                   # 
  4  #                                                                             # 
  5  # This file is part of the program relax.                                     # 
  6  #                                                                             # 
  7  # relax is free software; you can redistribute it and/or modify               # 
  8  # it under the terms of the GNU General Public License as published by        # 
  9  # the Free Software Foundation; either version 2 of the License, or           # 
 10  # (at your option) any later version.                                         # 
 11  #                                                                             # 
 12  # relax is distributed in the hope that it will be useful,                    # 
 13  # but WITHOUT ANY WARRANTY; without even the implied warranty of              # 
 14  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               # 
 15  # GNU General Public License for more details.                                # 
 16  #                                                                             # 
 17  # You should have received a copy of the GNU General Public License           # 
 18  # along with relax; if not, write to the Free Software                        # 
 19  # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA   # 
 20  #                                                                             # 
 21  ############################################################################### 
 22   
 23  # relax module imports. 
 24  from data import Relax_data_store; ds = Relax_data_store() 
 25  from generic_fns import pipes 
 26  from relax_errors import RelaxError, RelaxNoPipeError, RelaxSpinSelectDisallowError 
 27  from test_suite.unit_tests.base_classes import UnitTestCase 
 28   
 29   
 30 -class Residue_base_class(UnitTestCase): 
 31      """Testing base class for 'prompt.residue' and corresponding 'generic_fns.mol_res_spin' fns. 
 32   
 33      This base class also contains many shared unit tests. 
 34      """ 
 35   
 36 -    def setUp(self): 
 37          """Set up for all the residue unit tests.""" 
 38   
 39          # Add a data pipe to the data store. 
 40          ds.add(pipe_name='orig', pipe_type='mf') 
 41   
 42          # Add a second data pipe for copying tests. 
 43          ds.add(pipe_name='test', pipe_type='mf') 
 44   
 45          # Set the current data pipe to 'orig'. 
 46          pipes.switch('orig') 
 47   
 48   
 49 -    def setup_data(self): 
 50          """Function for setting up some data for the unit tests.""" 
 51   
 52          # Get the data pipe. 
 53          dp = pipes.get_pipe('orig') 
 54   
 55          # Create the first residue and add some data to its spin container. 
 56          self.residue_fns.create(1, 'Ala') 
 57          dp.mol[0].res[0].spin[0].num = 111 
 58          dp.mol[0].res[0].spin[0].x = 1 
 59          dp.mol[0].name = 'Old mol' 
 60   
 61          # Create a second molecule. 
 62          dp.mol.add_item('New mol') 
 63   
 64          # Copy the residue to the new molecule. 
 65          self.residue_fns.copy(res_from=':1', res_to='#New mol') 
 66          self.residue_fns.copy(res_from='#Old mol:1', res_to='#New mol:5') 
 67   
 68          # Change the first residue's data. 
 69          dp.mol[0].res[0].spin[0].num = 222 
 70          dp.mol[0].res[0].spin[0].x = 2 
 71   
 72   
 73 -    def test_copy_residue_between_molecules(self): 
 74          """Test the copying of the residue data between different molecules. 
 75   
 76          The function tested is both generic_fns.mol_res_spin.copy_residue() and 
 77          prompt.residue.copy(). 
 78          """ 
 79   
 80          # Set up some data. 
 81          self.setup_data() 
 82   
 83          # Get the data pipe. 
 84          dp = pipes.get_pipe('orig') 
 85   
 86          # Test the original residue. 
 87          self.assertEqual(dp.mol[0].res[0].num, 1) 
 88          self.assertEqual(dp.mol[0].res[0].name, 'Ala') 
 89          self.assertEqual(dp.mol[0].res[0].spin[0].num, 222) 
 90          self.assertEqual(dp.mol[0].res[0].spin[0].x, 2) 
 91   
 92          # Test the new residue 1. 
 93          self.assertEqual(dp.mol[1].name, 'New mol') 
 94          self.assertEqual(dp.mol[1].res[0].num, 1) 
 95          self.assertEqual(dp.mol[1].res[0].name, 'Ala') 
 96          self.assertEqual(dp.mol[1].res[0].spin[0].num, 111) 
 97          self.assertEqual(dp.mol[1].res[0].spin[0].x, 1) 
 98   
 99          # Test the new residue 5. 
100          self.assertEqual(dp.mol[1].res[1].num, 5) 
101          self.assertEqual(dp.mol[1].res[1].name, 'Ala') 
102          self.assertEqual(dp.mol[1].res[1].spin[0].num, 111) 
103          self.assertEqual(dp.mol[1].res[1].spin[0].x, 1) 
104   
105   
106   
107 -    def test_copy_residue_between_pipes(self): 
108          """Test the copying of the residue data between different data pipes. 
109   
110          The function tested is both generic_fns.mol_res_spin.copy_residue() and 
111          prompt.residue.copy(). 
112          """ 
113   
114          # Get the data pipes. 
115          dp = pipes.get_pipe('orig') 
116          dp_test = pipes.get_pipe('test') 
117   
118          # Create the first residue and add some data to its spin container. 
119          self.residue_fns.create(1, 'Ala') 
120          dp.mol[0].res[0].spin[0].num = 111 
121          dp.mol[0].res[0].spin[0].x = 1 
122   
123          # Copy the residue to the second data pipe. 
124          self.residue_fns.copy(res_from=':1', pipe_to='test') 
125          self.residue_fns.copy(pipe_from='orig', res_from=':1', pipe_to='test', res_to=':5') 
126   
127          # Change the first residue's data. 
128          dp.mol[0].res[0].spin[0].num = 222 
129          dp.mol[0].res[0].spin[0].x = 2 
130   
131          # Test the original residue. 
132          self.assertEqual(dp.mol[0].res[0].num, 1) 
133          self.assertEqual(dp.mol[0].res[0].name, 'Ala') 
134          self.assertEqual(dp.mol[0].res[0].spin[0].num, 222) 
135          self.assertEqual(dp.mol[0].res[0].spin[0].x, 2) 
136   
137          # Test the new residue 1. 
138          self.assertEqual(dp_test.mol[0].res[0].num, 1) 
139          self.assertEqual(dp_test.mol[0].res[0].name, 'Ala') 
140          self.assertEqual(dp_test.mol[0].res[0].spin[0].num, 111) 
141          self.assertEqual(dp_test.mol[0].res[0].spin[0].x, 1) 
142   
143          # Test the new residue 5. 
144          self.assertEqual(dp_test.mol[0].res[1].num, 5) 
145          self.assertEqual(dp_test.mol[0].res[1].name, 'Ala') 
146          self.assertEqual(dp_test.mol[0].res[1].spin[0].num, 111) 
147          self.assertEqual(dp_test.mol[0].res[1].spin[0].x, 1) 
148   
149   
150 -    def test_copy_residue_between_pipes_fail_no_pipe(self): 
151          """Test the copying of the residue data between different data pipes. 
152   
153          The function tested is both generic_fns.mol_res_spin.copy_residue() and 
154          prompt.residue.copy(). 
155          """ 
156   
157          # Get the data pipe. 
158          dp = pipes.get_pipe('orig') 
159   
160          # Create the first residue and add some data to its spin container. 
161          self.residue_fns.create(1, 'Ala') 
162          dp.mol[0].res[0].spin[0].num = 111 
163          dp.mol[0].res[0].spin[0].x = 1 
164   
165          # Copy the residue to the second data pipe. 
166          self.assertRaises(RelaxNoPipeError, self.residue_fns.copy, res_from=':1', pipe_to='test2') 
167   
168   
169 -    def test_copy_residue_within_molecule(self): 
170          """Test the copying of the residue data within a single molecule. 
171   
172          The function tested is both generic_fns.mol_res_spin.copy_residue() and 
173          prompt.residue.copy(). 
174          """ 
175   
176          # Get the data pipe. 
177          dp = pipes.get_pipe('orig') 
178   
179          # Create the first residue and add some data to its spin container. 
180          self.residue_fns.create(1, 'Ala') 
181          dp.mol[0].res[0].spin[0].num = 111 
182          dp.mol[0].res[0].spin[0].x = 1 
183   
184          # Copy the residue a few times. 
185          self.residue_fns.copy(res_from=':1', res_to=':2') 
186          self.residue_fns.copy(res_from=':1', pipe_to='orig', res_to=':3') 
187   
188          # Change the first residue's data. 
189          dp.mol[0].res[0].spin[0].num = 222 
190          dp.mol[0].res[0].spin[0].x = 2 
191   
192          # Copy the residue once more. 
193          self.residue_fns.copy(res_from=':1', res_to=':4,Met') 
194   
195          # Test the original residue. 
196          self.assertEqual(dp.mol[0].res[0].num, 1) 
197          self.assertEqual(dp.mol[0].res[0].name, 'Ala') 
198          self.assertEqual(dp.mol[0].res[0].spin[0].num, 222) 
199          self.assertEqual(dp.mol[0].res[0].spin[0].x, 2) 
200   
201          # Test the new residue 2. 
202          self.assertEqual(dp.mol[0].res[1].num, 2) 
203          self.assertEqual(dp.mol[0].res[1].name, 'Ala') 
204          self.assertEqual(dp.mol[0].res[1].spin[0].num, 111) 
205          self.assertEqual(dp.mol[0].res[1].spin[0].x, 1) 
206   
207          # Test the new residue 3. 
208          self.assertEqual(dp.mol[0].res[2].num, 3) 
209          self.assertEqual(dp.mol[0].res[2].name, 'Ala') 
210          self.assertEqual(dp.mol[0].res[2].spin[0].num, 111) 
211          self.assertEqual(dp.mol[0].res[2].spin[0].x, 1) 
212   
213          # Test the new residue 4. 
214          self.assertEqual(dp.mol[0].res[3].num, 4) 
215          self.assertEqual(dp.mol[0].res[3].name, 'Met') 
216          self.assertEqual(dp.mol[0].res[3].spin[0].num, 222) 
217          self.assertEqual(dp.mol[0].res[3].spin[0].x, 2) 
218   
219   
220 -    def test_copy_residue_within_molecule_fail1(self): 
221          """The failure of copying residue data within a molecule of a non-existent residue. 
222   
223          The function tested is both generic_fns.mol_res_spin.copy_residue() and 
224          prompt.residue.copy(). 
225          """ 
226   
227          # Create a few residues. 
228          self.residue_fns.create(1, 'Ala') 
229          self.residue_fns.create(-1, 'His') 
230   
231          # Copy a non-existent residue (1 Met). 
232          self.assertRaises(RelaxError, self.residue_fns.copy, res_from=':Met', res_to=':2,Gly') 
233   
234   
235 -    def test_copy_residue_within_molecule_fail2(self): 
236          """The failure of copying residue data within a molecule to a residue which already exists. 
237   
238          The function tested is both generic_fns.mol_res_spin.copy_residue() and 
239          prompt.residue.copy(). 
240          """ 
241   
242          # Create a few residues. 
243          self.residue_fns.create(1, 'Ala') 
244          self.residue_fns.create(-1, 'His') 
245   
246          # Copy a residue to a number which already exists. 
247          self.assertRaises(RelaxError, self.residue_fns.copy, res_from=':1', res_to=':-1,Gly') 
248   
249   
250 -    def test_create_residue(self): 
251          """Test the creation of a residue. 
252   
253          The function tested is both generic_fns.mol_res_spin.create_residue() and 
254          prompt.residue.create(). 
255          """ 
256   
257          # Get the data pipe. 
258          dp = pipes.get_pipe('orig') 
259   
260          # Create a few new residues. 
261          self.residue_fns.create(1, 'Ala') 
262          self.residue_fns.create(2, 'Leu') 
263          self.residue_fns.create(-3, 'Ser') 
264   
265          # Test that the residue numbers are correct. 
266          self.assertEqual(dp.mol[0].res[0].num, 1) 
267          self.assertEqual(dp.mol[0].res[1].num, 2) 
268          self.assertEqual(dp.mol[0].res[2].num, -3) 
269   
270          # Test that the residue names are correct. 
271          self.assertEqual(dp.mol[0].res[0].name, 'Ala') 
272          self.assertEqual(dp.mol[0].res[1].name, 'Leu') 
273          self.assertEqual(dp.mol[0].res[2].name, 'Ser') 
274   
275   
276 -    def test_create_residue_fail(self): 
277          """Test the failure of residue creation (by supplying two residues with the same number). 
278   
279          The function tested is both generic_fns.mol_res_spin.create_residue() and 
280          prompt.residue.create(). 
281          """ 
282   
283          # Create the first residue. 
284          self.residue_fns.create(1, 'Ala') 
285   
286          # Assert that a RelaxError occurs when the next added residue has the same sequence number as the first. 
287          self.assertRaises(RelaxError, self.residue_fns.create, 1, 'Ala') 
288   
289   
290 -    def test_delete_residue_name(self): 
291          """Test residue deletion using residue name identifiers. 
292   
293          The function tested is both generic_fns.mol_res_spin.delete_residue() and 
294          prompt.residue.delete(). 
295          """ 
296   
297          # Get the data pipe. 
298          dp = pipes.get_pipe('orig') 
299   
300          # Create some residues and add some data to the spin containers. 
301          self.residue_fns.create(1, 'Ala') 
302          self.residue_fns.create(2, 'Ala') 
303          self.residue_fns.create(3, 'Ala') 
304          self.residue_fns.create(4, 'Gly') 
305          dp.mol[0].res[3].spin[0].num = 111 
306          dp.mol[0].res[3].spin[0].x = 1 
307   
308          # Delete the first residue. 
309          self.residue_fns.delete(res_id=':Ala') 
310   
311          # Test that the first residue is 4 Gly. 
312          self.assertEqual(dp.mol[0].res[0].num, 4) 
313          self.assertEqual(dp.mol[0].res[0].name, 'Gly') 
314          self.assertEqual(dp.mol[0].res[0].spin[0].num, 111) 
315          self.assert_(hasattr(dp.mol[0].res[0].spin[0], 'x')) 
316   
317   
318 -    def test_delete_residue_num(self): 
319          """Test residue deletion using residue number identifiers. 
320   
321          The function tested is both generic_fns.mol_res_spin.delete_residue() and 
322          prompt.residue.delete(). 
323          """ 
324   
325          # Get the data pipe. 
326          dp = pipes.get_pipe('orig') 
327   
328          # Create some residues and add some data to the spin containers. 
329          self.residue_fns.create(1, 'Ala') 
330          self.residue_fns.create(2, 'Ala') 
331          self.residue_fns.create(3, 'Ala') 
332          self.residue_fns.create(4, 'Gly') 
333          dp.mol[0].res[3].spin[0].num = 111 
334          dp.mol[0].res[3].spin[0].x = 1 
335   
336          # Delete the first residue. 
337          self.residue_fns.delete(res_id=':1') 
338   
339          # Test that the sequence. 
340          self.assertEqual(dp.mol[0].res[0].num, 2) 
341          self.assertEqual(dp.mol[0].res[0].name, 'Ala') 
342          self.assertEqual(dp.mol[0].res[1].num, 3) 
343          self.assertEqual(dp.mol[0].res[1].name, 'Ala') 
344          self.assertEqual(dp.mol[0].res[2].num, 4) 
345          self.assertEqual(dp.mol[0].res[2].name, 'Gly') 
346          self.assertEqual(dp.mol[0].res[2].spin[0].num, 111) 
347          self.assert_(hasattr(dp.mol[0].res[2].spin[0], 'x')) 
348   
349   
350 -    def test_delete_residue_all(self): 
351          """Test the deletion of all residues. 
352   
353          The function tested is both generic_fns.mol_res_spin.delete_residue() and 
354          prompt.residue.delete(). 
355          """ 
356   
357          # Get the data pipe. 
358          dp = pipes.get_pipe('orig') 
359   
360          # Create some residues and add some data to the spin containers. 
361          self.residue_fns.create(1, 'Ala') 
362          self.residue_fns.create(2, 'Ala') 
363          self.residue_fns.create(3, 'Ala') 
364          self.residue_fns.create(4, 'Ala') 
365          dp.mol[0].res[3].spin[0].num = 111 
366          dp.mol[0].res[3].spin[0].x = 1 
367   
368          # Delete all residues. 
369          self.residue_fns.delete(res_id=':1-4') 
370   
371          # Test that the first residue defaults back to the empty residue. 
372          self.assertEqual(dp.mol[0].res[0].num, None) 
373          self.assertEqual(dp.mol[0].res[0].name, None) 
374   
375   
376 -    def test_delete_residue_shift(self): 
377          """Test the deletion of multiple residues. 
378   
379          The function tested is both generic_fns.mol_res_spin.delete_residue() and 
380          prompt.residue.delete(). 
381          """ 
382   
383          # Get the data pipe. 
384          dp = pipes.get_pipe('orig') 
385   
386          # Create some residues and add some data to the spin containers. 
387          self.residue_fns.create(1, 'Ala') 
388          self.residue_fns.create(2, 'Ala') 
389          self.residue_fns.create(3, 'Ala') 
390          self.residue_fns.create(4, 'Ala') 
391          dp.mol[0].res[3].spin[0].num = 111 
392          dp.mol[0].res[3].spin[0].x = 1 
393   
394          # Delete the first and third residues. 
395          self.residue_fns.delete(res_id=':1,3') 
396   
397          # Test that the remaining residues. 
398          self.assertEqual(dp.mol[0].res[0].num, 2) 
399          self.assertEqual(dp.mol[0].res[1].num, 4) 
400          self.assertEqual(dp.mol[0].res[1].spin[0].num, 111) 
401          self.assert_(hasattr(dp.mol[0].res[1].spin[0], 'x')) 
402   
403   
404 -    def test_delete_residue_fail(self): 
405          """Test the failure of residue deletion when an atom id is supplied. 
406   
407          The function tested is both generic_fns.mol_res_spin.delete_residue() and 
408          prompt.residue.delete(). 
409          """ 
410   
411          # Supply an atom id. 
412          self.assertRaises(RelaxSpinSelectDisallowError, self.residue_fns.delete, res_id='@2') 
413   
414   
415 -    def test_display_residue(self): 
416          """Test the display of residue information. 
417   
418          The function tested is both generic_fns.mol_res_spin.display_residue() and 
419          prompt.residue.display(). 
420          """ 
421   
422          # Set up some data. 
423          self.setup_data() 
424   
425          # The following should all work without error. 
426          self.residue_fns.display() 
427          self.residue_fns.display(':1') 
428          self.residue_fns.display('#New mol:5') 
429          self.residue_fns.display('#Old mol:1') 
430   
431   
432 -    def test_display_residue_fail(self): 
433          """Test the failure of the display of residue information. 
434   
435          The function tested is both generic_fns.mol_res_spin.display_residue() and 
436          prompt.residue.display(). 
437          """ 
438   
439          # Set up some data. 
440          self.setup_data() 
441   
442          # The following should fail. 
443          self.assertRaises(RelaxSpinSelectDisallowError, self.residue_fns.display, '@N') 
444   
445   
446 -    def test_name_residue(self): 
447          """Test the renaming of a residue. 
448   
449          The function tested is both generic_fns.mol_res_spin.name_residue() and 
450          prompt.residue.name(). 
451          """ 
452   
453          # Get the data pipe. 
454          dp = pipes.get_pipe('orig') 
455   
456          # Create the first residue and add some data to its spin container. 
457          self.residue_fns.create(-10, 'His') 
458   
459          # Rename the residue. 
460          self.residue_fns.name(res_id=':-10', name='K', force=True) 
461   
462          # Test that the residue has been renamed. 
463          self.assertEqual(dp.mol[0].res[0].name, 'K') 
464   
465   
466 -    def test_name_residue_many(self): 
467          """Test the renaming of multiple residues. 
468   
469          The function tested is both generic_fns.mol_res_spin.name_residue() and 
470          prompt.residue.name(). 
471          """ 
472   
473          # Get the data pipe. 
474          dp = pipes.get_pipe('orig') 
475   
476          # Create the first residue and add some data to its spin container. 
477          self.residue_fns.create(1, 'Ala') 
478          dp.mol[0].res[0].spin[0].num = 111 
479   
480          # Copy the residue a few times. 
481          self.residue_fns.copy(res_from=':1', res_to=':2') 
482          self.residue_fns.copy(res_from=':1', res_to=':3') 
483   
484          # Change the first residue's data. 
485          dp.mol[0].res[0].name = 'His' 
486   
487          # Copy the residue once more. 
488          self.residue_fns.copy(res_from=':1', res_to=':4,Met') 
489   
490          # Rename all alanines. 
491          self.residue_fns.name(res_id=':Ala', name='Gln', force=True) 
492   
493          # Test the renaming of alanines. 
494          self.assertEqual(dp.mol[0].res[1].name, 'Gln') 
495          self.assertEqual(dp.mol[0].res[2].name, 'Gln') 
496   
497          # Test that the other residues have not changed. 
498          self.assertEqual(dp.mol[0].res[0].name, 'His') 
499          self.assertEqual(dp.mol[0].res[3].name, 'Met') 
500   
501   
502 -    def test_name_residue_no_spin(self): 
503          """Test the failure of naming a residue when a spin id is given. 
504   
505          The function tested is both generic_fns.mol_res_spin.name_residue() and 
506          prompt.residue.name(). 
507          """ 
508   
509          # Try naming using a atom id. 
510          self.assertRaises(RelaxSpinSelectDisallowError, self.residue_fns.name, res_id='@111', name='K') 
511   
512   
513 -    def test_number_residue(self): 
514          """Test the renumbering of a residue. 
515   
516          The function tested is both generic_fns.mol_res_spin.number_residue() and 
517          prompt.residue.number(). 
518          """ 
519   
520          # Get the data pipe. 
521          dp = pipes.get_pipe('orig') 
522   
523          # Create the first residue and add some data to its spin container. 
524          self.residue_fns.create(-10, 'His') 
525   
526          # Rename the residue. 
527          self.residue_fns.number(res_id=':-10', number=10, force=True) 
528   
529          # Test that the residue has been renumbered. 
530          self.assertEqual(dp.mol[0].res[0].num, 10) 
531   
532   
533 -    def test_number_residue_many_fail(self): 
534          """Test the numbering of multiple residues. 
535   
536          The function tested is both generic_fns.mol_res_spin.number_residue() and 
537          prompt.residue.number(). 
538          """ 
539   
540          # Get the data pipe. 
541          dp = pipes.get_pipe('orig') 
542   
543          # Create the first residue and add some data to its spin container. 
544          self.residue_fns.create(1, 'Ala') 
545   
546          # Copy the residue a few times. 
547          self.residue_fns.copy(res_from=':1', res_to=':2') 
548          self.residue_fns.copy(res_from=':1', res_to=':3') 
549   
550          # Change the first residue's data. 
551          dp.mol[0].res[0].spin[0].name = 'His' 
552   
553          # Copy the residue once more. 
554          self.residue_fns.copy(res_from=':1', res_to=':4,Met') 
555   
556          # Try numbering all alanines. 
557          self.assertRaises(RelaxError, self.residue_fns.number, res_id=':Ala', number=10) 
558   
559   
560 -    def test_number_residue_no_spin(self): 
561          """Test the failure of naming a residue when a spin id is given. 
562   
563          The function tested is both generic_fns.mol_res_spin.number_residue() and 
564          prompt.residue.number(). 
565          """ 
566   
567          # Try naming using a atom id. 
568          self.assertRaises(RelaxSpinSelectDisallowError, self.residue_fns.number, res_id='@111', number=10) 
569