IMP  2.2.1
The Integrative Modeling Platform
test/__init__.py
1 # This file was automatically generated by SWIG (http://www.swig.org).
2 # Version 3.0.2
3 #
4 # Do not make changes to this file unless you know what you are doing--modify
5 # the SWIG interface file instead.
6 
7 
8 
9 
10 
11 from sys import version_info
12 if version_info >= (2,6,0):
13  def swig_import_helper():
14  from os.path import dirname
15  import imp
16  fp = None
17  try:
18  fp, pathname, description = imp.find_module('_IMP_test', [dirname(__file__)])
19  except ImportError:
20  import _IMP_test
21  return _IMP_test
22  if fp is not None:
23  try:
24  _mod = imp.load_module('_IMP_test', fp, pathname, description)
25  finally:
26  fp.close()
27  return _mod
28  _IMP_test = swig_import_helper()
29  del swig_import_helper
30 else:
31  import _IMP_test
32 del version_info
33 try:
34  _swig_property = property
35 except NameError:
36  pass # Python < 2.2 doesn't have 'property'.
37 def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
38  if (name == "thisown"): return self.this.own(value)
39  if (name == "this"):
40  if type(value).__name__ == 'SwigPyObject':
41  self.__dict__[name] = value
42  return
43  method = class_type.__swig_setmethods__.get(name,None)
44  if method: return method(self,value)
45  if (not static):
46  self.__dict__[name] = value
47  else:
48  raise AttributeError("You cannot add attributes to %s" % self)
49 
50 def _swig_setattr(self,class_type,name,value):
51  return _swig_setattr_nondynamic(self,class_type,name,value,0)
52 
53 def _swig_getattr(self,class_type,name):
54  if (name == "thisown"): return self.this.own()
55  method = class_type.__swig_getmethods__.get(name,None)
56  if method: return method(self)
57  raise AttributeError(name)
58 
59 def _swig_repr(self):
60  try: strthis = "proxy of " + self.this.__repr__()
61  except: strthis = ""
62  return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
63 
64 try:
65  _object = object
66  _newclass = 1
67 except AttributeError:
68  class _object : pass
69  _newclass = 0
70 
71 
72 try:
73  import weakref
74  weakref_proxy = weakref.proxy
75 except:
76  weakref_proxy = lambda x: x
77 
78 
79 class IMP_TEST_SwigPyIterator(_object):
80  """Proxy of C++ swig::IMP_TEST_SwigPyIterator class"""
81  __swig_setmethods__ = {}
82  __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_TEST_SwigPyIterator, name, value)
83  __swig_getmethods__ = {}
84  __getattr__ = lambda self, name: _swig_getattr(self, IMP_TEST_SwigPyIterator, name)
85  def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
86  __repr__ = _swig_repr
87  __swig_destroy__ = _IMP_test.delete_IMP_TEST_SwigPyIterator
88  __del__ = lambda self : None;
89  def value(self):
90  """value(IMP_TEST_SwigPyIterator self) -> PyObject *"""
91  return _IMP_test.IMP_TEST_SwigPyIterator_value(self)
92 
93  def incr(self, n=1):
94  """
95  incr(IMP_TEST_SwigPyIterator self, size_t n=1) -> IMP_TEST_SwigPyIterator
96  incr(IMP_TEST_SwigPyIterator self) -> IMP_TEST_SwigPyIterator
97  """
98  return _IMP_test.IMP_TEST_SwigPyIterator_incr(self, n)
99 
100  def decr(self, n=1):
101  """
102  decr(IMP_TEST_SwigPyIterator self, size_t n=1) -> IMP_TEST_SwigPyIterator
103  decr(IMP_TEST_SwigPyIterator self) -> IMP_TEST_SwigPyIterator
104  """
105  return _IMP_test.IMP_TEST_SwigPyIterator_decr(self, n)
106 
107  def distance(self, *args):
108  """distance(IMP_TEST_SwigPyIterator self, IMP_TEST_SwigPyIterator x) -> ptrdiff_t"""
109  return _IMP_test.IMP_TEST_SwigPyIterator_distance(self, *args)
110 
111  def equal(self, *args):
112  """equal(IMP_TEST_SwigPyIterator self, IMP_TEST_SwigPyIterator x) -> bool"""
113  return _IMP_test.IMP_TEST_SwigPyIterator_equal(self, *args)
114 
115  def copy(self):
116  """copy(IMP_TEST_SwigPyIterator self) -> IMP_TEST_SwigPyIterator"""
117  return _IMP_test.IMP_TEST_SwigPyIterator_copy(self)
118 
119  def next(self):
120  """next(IMP_TEST_SwigPyIterator self) -> PyObject *"""
121  return _IMP_test.IMP_TEST_SwigPyIterator_next(self)
122 
123  def __next__(self):
124  """__next__(IMP_TEST_SwigPyIterator self) -> PyObject *"""
125  return _IMP_test.IMP_TEST_SwigPyIterator___next__(self)
126 
127  def previous(self):
128  """previous(IMP_TEST_SwigPyIterator self) -> PyObject *"""
129  return _IMP_test.IMP_TEST_SwigPyIterator_previous(self)
130 
131  def advance(self, *args):
132  """advance(IMP_TEST_SwigPyIterator self, ptrdiff_t n) -> IMP_TEST_SwigPyIterator"""
133  return _IMP_test.IMP_TEST_SwigPyIterator_advance(self, *args)
134 
135  def __eq__(self, *args):
136  """__eq__(IMP_TEST_SwigPyIterator self, IMP_TEST_SwigPyIterator x) -> bool"""
137  return _IMP_test.IMP_TEST_SwigPyIterator___eq__(self, *args)
138 
139  def __ne__(self, *args):
140  """__ne__(IMP_TEST_SwigPyIterator self, IMP_TEST_SwigPyIterator x) -> bool"""
141  return _IMP_test.IMP_TEST_SwigPyIterator___ne__(self, *args)
142 
143  def __iadd__(self, *args):
144  """__iadd__(IMP_TEST_SwigPyIterator self, ptrdiff_t n) -> IMP_TEST_SwigPyIterator"""
145  return _IMP_test.IMP_TEST_SwigPyIterator___iadd__(self, *args)
146 
147  def __isub__(self, *args):
148  """__isub__(IMP_TEST_SwigPyIterator self, ptrdiff_t n) -> IMP_TEST_SwigPyIterator"""
149  return _IMP_test.IMP_TEST_SwigPyIterator___isub__(self, *args)
150 
151  def __add__(self, *args):
152  """__add__(IMP_TEST_SwigPyIterator self, ptrdiff_t n) -> IMP_TEST_SwigPyIterator"""
153  return _IMP_test.IMP_TEST_SwigPyIterator___add__(self, *args)
154 
155  def __sub__(self, *args):
156  """
157  __sub__(IMP_TEST_SwigPyIterator self, ptrdiff_t n) -> IMP_TEST_SwigPyIterator
158  __sub__(IMP_TEST_SwigPyIterator self, IMP_TEST_SwigPyIterator x) -> ptrdiff_t
159  """
160  return _IMP_test.IMP_TEST_SwigPyIterator___sub__(self, *args)
161 
162  def __iter__(self): return self
163 IMP_TEST_SwigPyIterator_swigregister = _IMP_test.IMP_TEST_SwigPyIterator_swigregister
164 IMP_TEST_SwigPyIterator_swigregister(IMP_TEST_SwigPyIterator)
165 
166 _value_types=[]
167 _object_types=[]
168 _raii_types=[]
169 _plural_types=[]
170 
171 IMP_DEBUG = _IMP_test.IMP_DEBUG
172 IMP_RELEASE = _IMP_test.IMP_RELEASE
173 IMP_SILENT = _IMP_test.IMP_SILENT
174 IMP_PROGRESS = _IMP_test.IMP_PROGRESS
175 IMP_TERSE = _IMP_test.IMP_TERSE
176 IMP_VERBOSE = _IMP_test.IMP_VERBOSE
177 IMP_MEMORY = _IMP_test.IMP_MEMORY
178 IMP_NONE = _IMP_test.IMP_NONE
179 IMP_USAGE = _IMP_test.IMP_USAGE
180 IMP_INTERNAL = _IMP_test.IMP_INTERNAL
181 IMP_BASE_HAS_LOG4CXX = _IMP_test.IMP_BASE_HAS_LOG4CXX
182 IMP_COMPILER_HAS_AUTO = _IMP_test.IMP_COMPILER_HAS_AUTO
183 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_test.IMP_COMPILER_HAS_DEBUG_VECTOR
184 IMP_BASE_HAS_BOOST_RANDOM = _IMP_test.IMP_BASE_HAS_BOOST_RANDOM
185 IMP_BASE_HAS_GPERFTOOLS = _IMP_test.IMP_BASE_HAS_GPERFTOOLS
186 IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_test.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
187 IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_test.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
188 IMPBASE_SHOW_WARNINGS = _IMP_test.IMPBASE_SHOW_WARNINGS
189 import sys
190 class _DirectorObjects(object):
191  """@internal Simple class to keep references to director objects
192  to prevent premature deletion."""
193  def __init__(self):
194  self._objects = []
195  def register(self, obj):
196  """Take a reference to a director object; will only work for
197  refcounted C++ classes"""
198  if hasattr(obj, 'get_ref_count'):
199  self._objects.append(obj)
200  def cleanup(self):
201  """Only drop our reference and allow cleanup by Python if no other
202  Python references exist (we hold 3 references: one in self._objects,
203  one in x, and one in the argument list for getrefcount) *and* no
204  other C++ references exist (the Python object always holds one)"""
205  objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
206  or x.get_ref_count() > 1]
207 
208 
209  self._objects = objs
210  def get_object_count(self):
211  """Get number of director objects (useful for testing only)"""
212  return len(self._objects)
213 _director_objects = _DirectorObjects()
214 
215 DEFAULT_CHECK = _IMP_test.DEFAULT_CHECK
216 NONE = _IMP_test.NONE
217 USAGE = _IMP_test.USAGE
218 USAGE_AND_INTERNAL = _IMP_test.USAGE_AND_INTERNAL
219 
220 def set_check_level(*args):
221  """set_check_level(IMP::base::CheckLevel tf)"""
222  return _IMP_test.set_check_level(*args)
223 
224 def get_check_level():
225  """get_check_level() -> IMP::base::CheckLevel"""
226  return _IMP_test.get_check_level()
227 class _ostream(_object):
228  """Proxy of C++ std::ostream class"""
229  __swig_setmethods__ = {}
230  __setattr__ = lambda self, name, value: _swig_setattr(self, _ostream, name, value)
231  __swig_getmethods__ = {}
232  __getattr__ = lambda self, name: _swig_getattr(self, _ostream, name)
233  def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
234  __repr__ = _swig_repr
235  def write(self, *args):
236  """write(_ostream self, char const * osa_buf)"""
237  return _IMP_test._ostream_write(self, *args)
238 
239 _ostream_swigregister = _IMP_test._ostream_swigregister
240 _ostream_swigregister(_ostream)
241 
242 IMP_COMPILER_HAS_OVERRIDE = _IMP_test.IMP_COMPILER_HAS_OVERRIDE
243 IMP_COMPILER_HAS_FINAL = _IMP_test.IMP_COMPILER_HAS_FINAL
244 IMP_HAS_NOEXCEPT = _IMP_test.IMP_HAS_NOEXCEPT
245 import IMP.base
246 IMP_TEST_HAS_BOOST_FILESYSTEM = _IMP_test.IMP_TEST_HAS_BOOST_FILESYSTEM
247 IMP_TEST_HAS_BOOST_PROGRAMOPTIONS = _IMP_test.IMP_TEST_HAS_BOOST_PROGRAMOPTIONS
248 IMP_TEST_HAS_BOOST_RANDOM = _IMP_test.IMP_TEST_HAS_BOOST_RANDOM
249 IMP_TEST_HAS_BOOST_SYSTEM = _IMP_test.IMP_TEST_HAS_BOOST_SYSTEM
250 IMPTEST_SHOW_WARNINGS = _IMP_test.IMPTEST_SHOW_WARNINGS
251 """@namespace IMP::test
252  @brief Methods and classes for testing the IMP kernel and modules.
253  @ingroup python
254 """
255 
256 import re, math
257 import sys
258 import os
259 import re
260 import tempfile
261 import random
262 import IMP
263 import time
264 import types
265 import shutil
266 import _compat_python
267 import _compat_python.unittest2
268 import datetime
269 import pickle
270 
271 # Fall back to the sets.Set class on older Pythons that don't have
272 # the 'set' builtin type.
273 try:
274  set = set
275 except NameError:
276  import sets
277  set = sets.Set
278 
279 # Load a new enough unittest package (should have the 'skip' decorator)
280 # - On Python 2.7 or 3.2, the standard 'unittest' package will work.
281 # - On older Pythons, use the 'unittest2' package if available, otherwise use
282 # our bundled version of this package.
283 def __load_unittest_package():
284  errors = []
285  for modname, fromlist in (('unittest', []),
286  ('unittest2', []),
287  ):
288  try:
289  u = __import__(modname, {}, {}, fromlist)
290  if hasattr(u, 'skip'):
291  return u
292  else:
293  errors.append("'%s' does not have the 'skip' decorator" \
294  % modname)
295  except ImportError, e:
296  errors.append(str(e))
297  #u = __import__("_compat_python.unittest2
298  return _compat_python.unittest2
299  raise ImportError("IMP.test requires a newer version of Python's unittest "
300  "package than is available. Either upgrade to a new "
301  "enough Python (at least 2.7 or 3.2) or install the "
302  "unittest2 package. Encountered errors: %s" \
303  % "; ".join(errors))
304 unittest = __load_unittest_package()
305 
306 # Expose some unittest decorators for convenience
307 expectedFailure = unittest.expectedFailure
308 skip = unittest.skip
309 skipIf = unittest.skipIf
310 skipUnless = unittest.skipUnless
311 
312 class RunInTempDir(object):
313  """Simple RAII-style class to run in a temporary directory.
314  When the object is created, the temporary directory is created
315  and becomes the current working directory. When the object goes out
316  of scope, the working directory is reset and the temporary directory
317  deleted."""
318  def __init__(self):
319  self.origdir = os.getcwd()
320  self.tmpdir = tempfile.mkdtemp()
321  os.chdir(self.tmpdir)
322  def __del__(self):
323  os.chdir(self.origdir)
324  shutil.rmtree(self.tmpdir, ignore_errors=True)
325 
326 
327 def numerical_derivative(func, val, step):
328  """Calculate the derivative of the single-value function `func` at
329  point `val`. The derivative is calculated using simple finite
330  differences starting with the given `step`; Richardson extrapolation
331  is then used to extrapolate the derivative at step=0."""
332  maxsteps = 50
333  con = 1.4
334  safe = 2.0
335  err = 1.0e30
336  f1 = func(val + step)
337  f2 = func(val - step)
338  # create first element in triangular matrix d of derivatives
339  d = [[(f1 - f2) / (2.0 * step)]]
340  retval = None
341  for i in range(1, maxsteps):
342  d.append([0.] * (i + 1))
343  step /= con
344  f1 = func(val + step)
345  f2 = func(val - step)
346  d[i][0] = (f1 - f2) / (2.0 * step)
347  fac = con * con
348  for j in range(1, i + 1):
349  d[i][j] = (d[i][j-1] * fac - d[i-1][j-1]) / (fac - 1.)
350  fac *= con * con
351  errt = max(abs(d[i][j] - d[i][j-1]),
352  abs(d[i][j] - d[i-1][j-1]))
353  if errt <= err:
354  err = errt
355  retval = d[i][j]
356  if abs(d[i][i] - d[i-1][i-1]) >= safe * err:
357  break
358  if retval is None:
359  raise ValueError("Cannot calculate numerical derivative")
360  return retval
361 
362 
363 def xyz_numerical_derivatives(model, xyz, step):
364  """Calculate the x,y and z derivatives of `model`'s scoring function
365  on the `xyz` particle. The derivatives are approximated numerically
366  using the numerical_derivatives() function."""
367  class _XYZDerivativeFunc(object):
368  def __init__(self, xyz, basis_vector):
369  self._xyz = xyz
370  self._model = xyz.get_particle().get_model()
371  self._basis_vector = basis_vector
372  self._starting_coordinates = xyz.get_coordinates()
373 
374  def __call__(self, val):
375  self._xyz.set_coordinates(self._starting_coordinates + \
376  self._basis_vector * val)
377  return self._model.evaluate(False)
378 
379  return tuple([IMP.test.numerical_derivative(_XYZDerivativeFunc(xyz,
380  IMP.algebra.Vector3D(*x)), 0, 0.01) \
381  for x in ((1,0,0), (0,1,0), (0,0,1))])
382 
383 
384 class TestCase(unittest.TestCase):
385  """Super class for IMP test cases"""
386 
387  def setUp(self):
388  self.__check_level = IMP.base.get_check_level()
389  # Turn on expensive runtime checks while running the test suite:
390  IMP.base.set_check_level(IMP.base.USAGE_AND_INTERNAL)
391  # python ints are bigger than C++ ones, so we need to make sure it fits
392  # otherwise python throws fits
393  IMP.base.random_number_generator.seed(hash(time.time())%2**30)
394 
395  def tearDown(self):
396  # Restore original check level
397  IMP.base.set_check_level(self.__check_level)
398 
399  def get_input_file_name(self, filename):
400  """Get the full name of an input file in the top-level
401  test directory."""
402  testdir = os.path.dirname(os.path.abspath(sys.argv[0]))
403  dirs = testdir.split(os.path.sep)
404  for i in range(len(dirs), 0, -1):
405  input = os.path.sep.join(dirs[:i] + ['input'])
406  if os.path.isdir(input):
407  ret = os.path.join(input, filename)
408  if not open(ret, "r"):
409  raise IOError("Test input file "+ret+" does not exist")
410  return ret
411  raise IOError("No test input directory found")
412 
413  def open_input_file(self, filename, mode='rb'):
414  """Open and return an input file in the top-level test directory."""
415  return open(self.get_input_file_name(filename), mode)
416 
417  def get_tmp_file_name(self, filename):
418  """Get the full name of an output file in the build/tmp directory."""
419  dirpath=os.environ['IMP_TMP_DIR']
420  if not os.path.exists(dirpath):
421  os.mkdir(dirpath)
422  return os.path.join(dirpath, filename)
423 
424  def get_magnitude(self, vector):
425  return sum([x*x for x in vector], 0)**.5
426 
427  def assertXYZDerivativesInTolerance(self, model, xyz, tolerance=0,
428  percentage=0):
429  """Assert that x,y,z analytical derivatives match numerical within
430  a tolerance, or a percentage (of the analytical value), whichever
431  is larger."""
432  model.evaluate(True)
433  derivs = xyz.get_derivatives()
434  num_derivs = xyz_numerical_derivatives(model, xyz, 0.01)
435  pct = percentage / 100.0
436  self.assertAlmostEqual(self.get_magnitude(derivs-num_derivs),0,
437  delta=tolerance+percentage*self.get_magnitude(num_derivs),
438  msg="Don't match "+str(derivs) + str(num_derivs))
439  self.assertAlmostEqual(derivs[0], num_derivs[0],
440  delta=max(tolerance, abs(derivs[0]) * pct))
441  self.assertAlmostEqual(derivs[1], num_derivs[1],
442  delta=max(tolerance, abs(derivs[1]) * pct))
443  self.assertAlmostEqual(derivs[2], num_derivs[2],
444  delta=max(tolerance, abs(derivs[2]) * pct))
445 
446  def create_point_particle(self, model, x, y, z):
447  """Make a particle with optimizable x, y and z attributes, and
448  add it to the model."""
449  p = IMP.Particle(model)
450  p.add_attribute(IMP.FloatKey("x"), x, True)
451  p.add_attribute(IMP.FloatKey("y"), y, True)
452  p.add_attribute(IMP.FloatKey("z"), z, True)
453  return p
454 
455  def probabilistic_test(self, testcall, chance_of_failure):
456  """Help handle a test which is expected to fail some fraction of
457  the time. The test is run multiple times and an exception
458  is thrown only if it fails too many times."""
459  prob=chance_of_failure
460  tries=1
461  while prob > .001:
462  tries=tries+1
463  prob= prob*chance_of_failure
464  for i in range(0, tries):
465  try:
466  eval(testcall)
467  except:
468  pass
469  else:
470  return
471  eval(testcall)
472  raise AssertError("Too many failures")
473 
474  def failure_probability(self, testcall):
475  """Estimate how likely a given block of code is to raise an
476  AssertionError."""
477  failures=0
478  tries=0.0
479  while failures < 10 and tries <1000:
480  try:
481  eval(testcall)
482  except:
483  failures=failures+1
484  tries=tries+1
485  return failures/tries
486 
487  def randomize_particles(self, particles, deviation):
488  """Randomize the xyz coordinates of a list of particles"""
489  # Note: cannot use XYZ here since that pulls in IMP.core
490  xkey = IMP.FloatKey("x")
491  ykey = IMP.FloatKey("y")
492  zkey = IMP.FloatKey("z")
493  for p in particles:
494  p.set_value(xkey, random.uniform(-deviation, deviation))
495  p.set_value(ykey, random.uniform(-deviation, deviation))
496  p.set_value(zkey, random.uniform(-deviation, deviation))
497 
498  def particle_distance(self, p1, p2):
499  """Return distance between two given particles"""
500  xkey = IMP.FloatKey("x")
501  ykey = IMP.FloatKey("y")
502  zkey = IMP.FloatKey("z")
503  dx = p1.get_value(xkey) - p2.get_value(xkey)
504  dy = p1.get_value(ykey) - p2.get_value(ykey)
505  dz = p1.get_value(zkey) - p2.get_value(zkey)
506  return math.sqrt(dx*dx + dy*dy + dz*dz)
507 
508  def check_unary_function_deriv(self, func, lb, ub, step):
509  """Check the unary function func's derivatives against numerical
510  approximations between lb and ub"""
511  for f in [lb + i * step for i in range(1, int((ub-lb)/step))]:
512  (v,d)= func.evaluate_with_derivative(f)
513  da = numerical_derivative(func.evaluate, f, step / 10.)
514  self.assertAlmostEqual(d, da, delta=max(abs(.1 *d), 0.01))
515 
516  def check_unary_function_min(self, func, lb, ub, step, expected_fmin):
517  """Make sure that the minimum of the unary function func over the
518  range between lb and ub is at expected_fmin"""
519  fmin, vmin = lb, func.evaluate(lb)
520  for f in [lb + i * step for i in range(1, int((ub-lb)/step))]:
521  v = func.evaluate(f)
522  if v < vmin:
523  fmin, vmin = f, v
524  self.assertAlmostEqual(fmin, expected_fmin, delta=step)
525 
526  def create_particles_in_box(self, model, num=10,
527  lb= [0,0,0],
528  ub= [10,10,10]):
529  """Create a bunch of particles in a box"""
530  import IMP.algebra
531  lbv=IMP.algebra.Vector3D(lb[0],lb[1],lb[2])
532  ubv=IMP.algebra.Vector3D(ub[0],ub[1],ub[2])
533  ps= []
534  for i in range(0,num):
536  p = self.create_point_particle(model, v[0], v[1], v[2])
537  ps.append(p)
538  return ps
539  def _get_type(self, module, name):
540  return eval('type('+module+"."+name+')')
541  def assertValueObjects(self, module, exceptions_list):
542  "Check that all the C++ classes in the module are values or objects."
543  all= dir(module)
544  ok = set(exceptions_list + eval(module.__name__+"._value_types") + eval(module.__name__+"._object_types") + eval(module.__name__+"._raii_types") +eval(module.__name__+"._plural_types"))
545 
546  bad=[]
547  for name in all:
548  if self._get_type(module.__name__, name)==types.TypeType and not name.startswith("_"):
549  if name.find("SwigPyIterator") != -1:
550  continue
551  # Exclude Python-only classes
552  if not eval('hasattr(%s.%s, "__swig_destroy__")' \
553  % (module.__name__, name)):
554  continue
555  if name in ok:
556  continue
557  bad.append(name)
558  message="All IMP classes should be labeled values or as objects to get memory management correct in python. The following are not:\n%s\nPlease add an IMP_SWIG_OBJECT or IMP_SWIG_VALUE call to the python wrapper, or if the class has a good reason to be neither, add the name to the value_object_exceptions list in the IMPModuleTest call." \
559  % (str(bad))
560  self.assertEquals(len(bad), 0,
561  message)
562  for e in exceptions_list:
563  self.assertTrue(e not in eval(module.__name__+"._value_types")\
564  + eval(module.__name__+"._object_types")\
565  + eval(module.__name__+"._raii_types")\
566  + eval(module.__name__+"._plural_types"),
567  "Value/Object exception "+e+" is not an exception")
568 
569  def _check_spelling(self, word, words):
570  """Check that the word is spelled correctly"""
571  if "words" not in dir(self):
572  wordlist= open(IMP.test.get_data_path("linux.words"), "r").read().split("\n")
573  # why is "all" missing on my mac?
574  custom_words=["info", "prechange", "int", "ints", "optimizeds", "graphviz",
575  "voxel", "voxels", "endian", 'rna', 'dna',
576  "xyzr", "pdbs", "fft", "ccc", "gaussian"]
577  self.words=set(wordlist+custom_words)
578  if self.words:
579  for i in "0123456789":
580  if i in word:
581  return True
582  if word in words:
583  return True
584  if word in self.words:
585  return True
586  else:
587  return False
588  else:
589  return True
590  def assertClassNames(self, module, exceptions, words):
591  """Check that all the classes in the module follow the imp naming conventions."""
592  all= dir(module)
593  misspelled = []
594  bad=[]
595  cc=re.compile("([A-Z][a-z]*)")
596  for name in all:
597  if self._get_type(module.__name__, name)==types.TypeType and not name.startswith("_"):
598  if name.find("SwigPyIterator") != -1:
599  continue
600  for t in re.findall(cc, name):
601  if not self._check_spelling(t.lower(), words):
602  misspelled.append(t.lower())
603  bad.append(name)
604 
605  self.assertEquals(len(bad), 0,
606  "All IMP classes should be properly spelled. The following are not: %s.\nMisspelled words: %s. Add words to the spelling_exceptions variable of the IMPModuleTest if needed." \
607  % (str(bad), ", ".join(set(misspelled))))
608 
609  for name in all:
610  if self._get_type(module.__name__, name)==types.TypeType and not name.startswith("_"):
611  if name.find("SwigPyIterator") != -1:
612  continue
613  if name.find('_') != -1:
614  bad.append(name)
615  if name.lower== name:
616  bad.append(name)
617  for t in re.findall(cc, name):
618  if not self._check_spelling(t.lower(), words):
619  print "misspelled", t, "in", name
620  bad.append(name)
621  message="All IMP classes should have CamelCase names. The following do not: %s." \
622  % ("\n".join(bad))
623  self.assertEquals(len(bad), 0,
624  message)
625 
626 
627  def _check_function_name(self, prefix, name, verbs, all, exceptions, words,
628  misspelled):
629  if prefix:
630  fullname=prefix+"."+name
631  else:
632  fullname=name
633  old_exceptions=['unprotected_evaluate', "unprotected_evaluate_if_good",
634  "unprotected_evaluate_if_below",
635  "after_evaluate", "before_evaluate", "has_attribute",
636  "decorate_particle","particle_is_instance"]
637  if name in old_exceptions:
638  return []
639  #print "name", fullname
640  if fullname in exceptions:
641  return []
642  if name.endswith("swigregister"):
643  return []
644  if name.lower() != name:
645  if name[0].lower() != name[0] and name.split('_')[0] in all:
646  # static methods
647  return []
648  else:
649  return [fullname]
650  tokens= name.split("_")
651  if tokens[0] not in verbs:
652  return [fullname]
653  for t in tokens:
654  if not self._check_spelling(t, words):
655  misspelled.append(t)
656  print "misspelled", t, "in", name
657  return [fullname]
658  return []
659  def _check_function_names(self, module, prefix, names, verbs, all, exceptions, words, misspelled):
660  bad=[]
661  #print "names", module, prefix
662  for name in names:
663  if name.startswith("_") or name =="weakref_proxy":
664  continue
665  if self._get_type(module, name)==types.BuiltinMethodType\
666  or self._get_type(module, name)==types.MethodType:
667  bad.extend(self._check_function_name(prefix, name, verbs, all, exceptions, words, misspelled))
668  if self._get_type(module, name)==types.TypeType and name.find("SwigPyIterator")==-1:
669  #print "sub", module+"."+name
670  members=eval("dir("+module+"."+name+")")
671  #print members
672  bad.extend(self._check_function_names(module+"."+name,
673  name,
674  members,
675  verbs, [], exceptions, words, misspelled))
676  return bad
677 
678 
679 
680  def assertFunctionNames(self, module, exceptions, words):
681  """Check that all the functions in the module follow the imp naming conventions."""
682  all= dir(module)
683  verbs=set(["add", "remove", "get", "set", "evaluate", "compute", "show", "create", "destroy",
684  "push", "pop", "write", "read", "do", "show", "load", "save", "reset",
685  "accept", "reject",
686  "clear", "handle", "update", "apply", "optimize", "reserve", "dump",
687  "propose", "setup", "teardown", "visit", "find", "run", "swap", "link",
688  "validate"])
689  misspelled = []
690  bad=self._check_function_names(module.__name__, None, all, verbs, all, exceptions, words, misspelled)
691  message="All IMP methods should have lower case names separated by underscores and beginning with a verb, preferably one of ['add', 'remove', 'get', 'set', 'create', 'destroy']. Each of the words should be a properly spelled english word. The following do not (given our limited list of verbs that we check for):\n%(bad)s\nIf there is a good reason for them not to (eg it does start with a verb, just one with a meaning that is not covered by the normal list), add them to the function_name_exceptions variable in the standards_exceptions file. Otherwise, please fix. The current verb list is %(verbs)s" \
692  % {"bad":"\n".join(bad), "verbs":verbs}
693  if len(misspelled) > 0:
694  message += "\nMisspelled words: " + ", ".join(set(misspelled)) \
695  + ". Add words to the spelling_exceptions variable " \
696  + "of the standards_exceptions file if needed."
697  self.assertEquals(len(bad), 0,
698  message)
699 
700 
701  def assertShow(self, modulename, exceptions):
702  """Check that all the classes in modulename have a show method"""
703  all= dir(modulename)
704  not_found=[]
705  for f in all:
706  # Exclude Python-only classes; they are all showable
707  if not eval('hasattr(%s.%s, "__swig_destroy__")' \
708  % (modulename.__name__, f)):
709  continue
710  if self._get_type(modulename.__name__, f) == types.TypeType\
711  and not f.startswith("_") \
712  and not f.endswith("_swigregister")\
713  and f not in exceptions\
714  and not f.endswith("Temp") and not f.endswith("Iterator")\
715  and not f.endswith("Exception") and\
716  f not in eval(modulename.__name__+"._raii_types") and \
717  f not in eval(modulename.__name__+"._plural_types"):
718  if not hasattr(getattr(modulename, f), 'show'):
719  not_found.append(f)
720  message="All IMP classes should support show and __str__. The following do not:\n%s\n If there is a good reason for them not to, add them to the show_exceptions variable in the IMPModuleTest call. Otherwise, please fix." \
721  % "\n".join(not_found)
722  self.assertEquals(len(not_found), 0,
723  message)
724  for e in exceptions:
725  self.assertIn(e, all, "Show exception "+e+" is not a class in module")
726  self.assertTrue(not hasattr(getattr(modulename, e), 'show'),
727  "Exception "+e+" is not really a show exception")
728 
729  def run_example(self, filename):
730  """Run the named example script.
731  A dictionary of all the script's global variables is returned.
732  This can be queried in a test case to make sure the example
733  performed correctly."""
734  class _FatalError(Exception): pass
735 
736  # Add directory containing the example to sys.path, so it can import
737  # other Python modules in the same directory
738  path, name = os.path.split(filename)
739  oldsyspath = sys.path[:]
740  olssysargv= sys.argv[:]
741  sys.path.insert(0, path)
742  sys.argv=[filename]
743  vars = {}
744  try:
745  try:
746  exec open(filename) in vars
747  # Catch sys.exit() called from within the example; a non-zero exit
748  # value should cause the test case to fail
749  except SystemExit, e:
750  if e.code != 0 and e.code is not None:
751  raise _FatalError("Example exit with code %s" % str(e.code))
752  finally:
753  # Restore sys.path (note that Python 2.3 does not allow
754  # try/except/finally, so we need to use nested trys)
755  sys.path = oldsyspath
756  sys.argv= olssysargv
757 
758  return _ExecDictProxy(vars)
759 
760  def run_python_module(self, module, args):
761  """Run a Python module as if with "python -m <modname>",
762  with the given list of arguments as sys.argv.
763 
764  If module is an already-imported Python module, run its 'main'
765  function and return the result.
766 
767  If module is a string, run the module in a subprocess and return
768  a subprocess.Popen-like object containing the child stdin,
769  stdout and stderr.
770  """
771  import IMP.kernel
772  if type(module) == type(os):
773  mod = module
774  else:
775  mod = __import__(module, {}, {}, [''])
776  modpath = mod.__file__
777  if modpath.endswith('.pyc'):
778  modpath = modpath[:-1]
779  if type(module) == type(os):
780  old_sys_argv = sys.argv
781  # boost parser doesn't like being called multiple times per process
782  IMP.kernel.OptionParser._use_boost_parser = False
783  try:
784  sys.argv = [modpath] + args
785  return module.main()
786  finally:
787  IMP.kernel.OptionParser._use_boost_parser = True
788  sys.argv = old_sys_argv
789  else:
790  return _SubprocessWrapper(sys.executable, [modpath] + args)
791 
792  def check_runnable_python_module(self, module):
793  """Check a Python module designed to be runnable with 'python -m'
794  to make sure it supports standard command line options."""
795  # --help should return with exit 0, no errors
796  r = self.run_python_module(module, ['--help'])
797  out, err = r.communicate()
798  self.assertEqual(r.returncode, 0)
799  self.assertNotEqual(err, "")
800  self.assertEqual(out, "")
801 
802 
803 class _ExecDictProxy(object):
804  """exec returns a Python dictionary, which contains IMP objects, other
805  Python objects, as well as base Python modules (such as sys and
806  __builtins__). If we just delete this dictionary, it is entirely
807  possible that base Python modules are removed from the dictionary
808  *before* some IMP objects. This will prevent the IMP objects' Python
809  destructors from running properly, so C++ objects will not be
810  cleaned up. This class proxies the base dict class, and on deletion
811  attempts to remove keys from the dictionary in an order that allows
812  IMP destructors to fire."""
813  def __init__(self, d):
814  self._d = d
815  def __del__(self):
816  # Try to release example objects in a sensible order
817  module_type = type(IMP)
818  d = self._d
819  for k in d.keys():
820  if type(d[k]) != module_type:
821  del d[k]
822 
823  for meth in ['__contains__', '__getitem__', '__iter__', '__len__',
824  'get', 'has_key', 'items', 'keys', 'values']:
825  exec("def %s(self, *args, **keys): "
826  "return self._d.%s(*args, **keys)" % (meth, meth))
827 
828 
829 class _TestResult(unittest.TextTestResult):
830 
831  def __init__(self, stream=None, descriptions=None, verbosity=None):
832  super(_TestResult, self).__init__(stream, descriptions, verbosity)
833  self.all_tests = []
834 
835  def stopTestRun(self):
836  if 'IMP_TEST_DETAIL_DIR' in os.environ:
837  fname = os.path.join(os.environ['IMP_TEST_DETAIL_DIR'],
838  os.path.basename(sys.argv[0]))
839  pickle.dump(self.all_tests, open(fname, 'wb'), -1)
840  super(_TestResult, self).stopTestRun()
841 
842  def startTest(self, test):
843  super(_TestResult, self).startTest(test)
844  test.start_time=datetime.datetime.now()
845 
846  def _test_finished(self, test, state, detail=None):
847  delta = datetime.datetime.now() - test.start_time
848  try:
849  pv= delta.total_seconds()
850  except AttributeError:
851  pv = (float(delta.microseconds) \
852  + (delta.seconds + delta.days * 24 * 3600) * 10**6) / 10**6
853  if pv > 1:
854  self.stream.write("in %.3fs ... " % pv)
855  if detail is not None and not isinstance(detail, str):
856  detail = self._exc_info_to_string(detail, test)
857  test_doc = self.getDescription(test)
858  test_name = test.id()
859  if test_name.startswith('__main__.'):
860  test_name = test_name[9:]
861  self.all_tests.append({'name': test_name,
862  'docstring': test_doc,
863  'time': pv, 'state': state, 'detail': detail})
864 
865  def addSuccess(self, test):
866  self._test_finished(test, 'OK')
867  super(_TestResult, self).addSuccess(test)
868 
869  def addError(self, test, err):
870  self._test_finished(test, 'ERROR', err)
871  super(_TestResult, self).addError(test, err)
872 
873  def addFailure(self, test, err):
874  self._test_finished(test, 'FAIL', err)
875  super(_TestResult, self).addFailure(test, err)
876 
877  def addSkip(self, test, reason):
878  self._test_finished(test, 'SKIP', reason)
879  super(_TestResult, self).addSkip(test, reason)
880 
881  def addExpectedFailure(self, test, err):
882  self._test_finished(test, 'EXPFAIL', err)
883  super(_TestResult, self).addExpectedFailure(test, err)
884 
885  def addUnexpectedSuccess(self, test):
886  self._test_finished(test, 'UNEXPSUC')
887  super(_TestResult, self).addUnexpectedSuccess(test)
888 
889  def getDescription(self, test):
890  doc_first_line = test.shortDescription()
891  if self.descriptions and doc_first_line:
892  return doc_first_line
893  else:
894  return str(test)
895 
896 
897 class _TestRunner(unittest.TextTestRunner):
898  def _makeResult(self):
899  return _TestResult(self.stream, self.descriptions, self.verbosity)
900 
901 
902 def main(*args, **keys):
903  """Run a set of tests; essentially the same as unittest.main(). Obviates
904  the need to separately import the 'unittest' module, and ensures that
905  main() is from the same unittest module that the IMP.test testcases
906  are."""
907  return unittest.main(testRunner=_TestRunner, *args, **keys)
908 
909 try:
910  import subprocess
911  class _SubprocessWrapper(subprocess.Popen):
912  def __init__(self, app, args):
913  # For (non-Python) applications to work on Windows, the
914  # PATH must include the directory containing built DLLs
915  if sys.platform == 'win32' and app != sys.executable:
916  # Hack to find the location of build/lib/
917  libdir = os.environ['PYTHONPATH'].split(';')[0]
918  env = os.environ.copy()
919  env['PATH'] += ';' + libdir
920  else:
921  env = None
922  subprocess.Popen.__init__(self, [app]+list(args),
923  stdin=subprocess.PIPE,
924  stdout=subprocess.PIPE,
925  stderr=subprocess.PIPE, env=env)
926 except ImportError:
927  import threading
928  import popen2
929  # Provide a subprocess workalike for Python 2.3 systems (e.g. old Macs)
930  class _SubprocessWrapper(object):
931  def __init__(self, app, args):
932  self.popen = popen2.Popen3(app + " " + " ".join(args), True)
933  self.stdin = self.popen.tochild
934  self.stdout = self.popen.fromchild
935  self.stderr = self.popen.childerr
936 
937  def _readerthread(self, fh, buffer):
938  buffer.append(fh.read())
939 
940  def communicate(self, input=None):
941  stdout = []
942  stderr = []
943  stdout_thread = threading.Thread(target=self._readerthread,
944  args=(self.stdout, stdout))
945  stdout_thread.setDaemon(True)
946  stdout_thread.start()
947  stderr_thread = threading.Thread(target=self._readerthread,
948  args=(self.stderr, stderr))
949  stderr_thread.setDaemon(True)
950  stderr_thread.start()
951 
952  if input:
953  self.stdin.write(input)
954  self.stdin.close()
955  stdout_thread.join()
956  stderr_thread.join()
957  self.returncode = self.popen.wait()
958  return stdout[0], stderr[0]
959 
960 
962  """Super class for simple IMP application test cases"""
963  def _get_application_file_name(self, filename):
964  # If we ran from run-all-tests.py, it set an env variable for us with
965  # the top-level test directory
966  if sys.platform == 'win32':
967  filename += '.exe'
968  #if 'IMP_BUILD_ROOT' in os.environ:
969  # testdir = os.environ['IMP_BUILD_ROOT']
970  # return os.path.join(testdir, "build", "bin", filename)
971  return filename
972 
973  def run_application(self, app, args):
974  """Run an application with the given list of arguments.
975  @return a subprocess.Popen-like object containing the child stdin,
976  stdout and stderr.
977  """
978  filename = self._get_application_file_name(app)
979  if sys.platform == 'win32':
980  # Cannot rely on PATH on wine builds, so use full pathname
981  return _SubprocessWrapper(os.path.join(os.environ['IMP_BIN_DIR'],
982  filename), args)
983  else:
984  return _SubprocessWrapper(filename, args)
985 
986  def run_python_application(self, app, args):
987  """Run a Python application with the given list of arguments.
988  The Python application should be self-runnable (i.e. it should
989  be executable and with a #! on the first line).
990  @return a subprocess.Popen-like object containing the child stdin,
991  stdout and stderr.
992  """
993  # Handle platforms where /usr/bin/python doesn't work
994  if sys.executable != '/usr/bin/python':
995  return _SubprocessWrapper(sys.executable,
996  [os.path.join(os.environ['IMP_BIN_DIR'], app)] + args)
997  else:
998  return _SubprocessWrapper(app, args)
999 
1001  """Import an installed Python application, rather than running it.
1002  This is useful to directly test components of the application.
1003  @return the Python module object."""
1004  import imp
1005  return imp.load_source(os.path.splitext(app)[0],
1006  os.path.join(os.environ['IMP_BIN_DIR'], app))
1007 
1008  def run_script(self, app, args):
1009  """Run an application with the given list of arguments.
1010  @return a subprocess.Popen-like object containing the child stdin,
1011  stdout and stderr.
1012  """
1013  return _SubprocessWrapper(sys.executable, [app]+args)
1014 
1015  def assertApplicationExitedCleanly(self, ret, error):
1016  """Assert that the application exited cleanly (return value = 0)."""
1017  if ret < 0:
1018  raise OSError("Application exited with signal %d\n" % -ret\
1019  +error)
1020  else:
1021  self.assertEqual(ret, 0,
1022  "Application exited uncleanly, with exit code %d\n" % ret\
1023  + error)
1024 
1025  def read_shell_commands(self, doxfile):
1026  """Read and return a set of shell commands from a doxygen file.
1027  Each command is assumed to be in a \\code{.sh}...\\endcode block.
1028  The doxygen file is specified relative to the test file itself.
1029  This is used to make sure the commands shown in an application
1030  example actually work (the testcase can also check the resulting
1031  files for correctness)."""
1032  def fix_win32_command(cmd):
1033  # Make substitutions so a Unix shell command works on Windows
1034  if cmd.startswith('cp -r '):
1035  return 'xcopy /E ' + cmd[6:]
1036  elif cmd.startswith('cp '):
1037  return 'copy ' + cmd[3:]
1038  else:
1039  return cmd
1040  d = os.path.dirname(sys.argv[0])
1041  doc = os.path.join(d, doxfile)
1042  inline = False
1043  cmds = []
1044  example_path = os.path.abspath(IMP.get_example_path('..'))
1045  for line in open(doc).readlines():
1046  if '\code{.sh}' in line:
1047  inline = True
1048  elif '\endcode' in line:
1049  inline = False
1050  elif inline:
1051  cmds.append(line.rstrip('\r\n').replace('<imp_example_path>',
1052  example_path))
1053  if sys.platform == 'win32':
1054  cmds = [fix_win32_command(x) for x in cmds]
1055  return cmds
1056 
1057  def run_shell_command(self, cmd):
1058  "Print and run a shell command, as returned by read_shell_commands()"
1059  import subprocess
1060  print cmd
1061  p = subprocess.call(cmd, shell=True)
1062  if p != 0:
1063  raise OSError("%s failed with exit value %d" % (cmd, p))
1064 
1065 
1066 class RefCountChecker(object):
1067  """Check to make sure the number of C++ object references is as expected"""
1068 
1069  def __init__(self, testcase):
1070  # Make sure no director objects are hanging around; otherwise these
1071  # may be unexpectedly garbage collected later, decreasing the
1072  # live object count
1073  IMP.base._director_objects.cleanup()
1074  self.__testcase = testcase
1075  if IMP.base.get_check_level() >= IMP.base.USAGE_AND_INTERNAL:
1076  self.__basenum = IMP.base.Object.get_number_of_live_objects()
1077  self.__names= IMP.base.get_live_object_names()
1078 
1079  def assert_number(self, expected):
1080  "Make sure that the number of references matches the expected value."
1081  t = self.__testcase
1082  IMP.base._director_objects.cleanup()
1083  if IMP.base.get_check_level() >= IMP.base.USAGE_AND_INTERNAL:
1084  newnames=[x for x in IMP.base.get_live_object_names() if x not in self.__names]
1085  newnum=IMP.base.Object.get_number_of_live_objects()-self.__basenum
1086  t.assertEqual(newnum, expected,
1087  "Number of objects don't match: "\
1088  +str(newnum)\
1089  +" != "+ str(expected) +" found "+\
1090  str(newnames))
1091 
1092 
1093 
1095  """Check to make sure the number of director references is as expected"""
1096 
1097  def __init__(self, testcase):
1098  IMP.base._director_objects.cleanup()
1099  self.__testcase = testcase
1100  self.__basenum = IMP.base._director_objects.get_object_count()
1101 
1102  def assert_number(self, expected, force_cleanup=True):
1103  """Make sure that the number of references matches the expected value.
1104  If force_cleanup is set, clean up any unused references first before
1105  doing the assertion.
1106  """
1107  t = self.__testcase
1108  if force_cleanup:
1109  IMP.base._director_objects.cleanup()
1110  t.assertEqual(IMP.base._director_objects.get_object_count() \
1111  - self.__basenum, expected)
1112 
1113 # Make sure that the IMP binary directory (build/bin) is in the PATH, if
1114 # we're running under wine (the imppy.sh script normally ensures this, but
1115 # wine overrides the PATH). This is needed so that tests of imported Python
1116 # applications can successfully spawn C++ applications (e.g. idock.py tries
1117 # to run recompute_zscore.exe). build/lib also needs to be in the PATH, since
1118 # that's how Windows locates dependent DLLs such as libimp.dll.
1119 if sys.platform == 'win32' and 'PYTHONPATH' in os.environ \
1120  and 'IMP_BIN_DIR' in os.environ:
1121  libdir = os.environ['PYTHONPATH'].split(';')[0]
1122  bindir = os.environ['IMP_BIN_DIR']
1123  path = os.environ['PATH']
1124  if libdir not in path or bindir not in path:
1125  os.environ['PATH'] = bindir + ';' + libdir + ';' + path
1126 
1127 
1128 def get_module_version():
1129  """get_module_version() -> std::string const"""
1130  return _IMP_test.get_module_version()
1131 
1132 def get_example_path(*args):
1133  """get_example_path(std::string fname) -> std::string"""
1134  return _IMP_test.get_example_path(*args)
1135 
1136 def get_data_path(*args):
1137  """get_data_path(std::string fname) -> std::string"""
1138  return _IMP_test.get_data_path(*args)
1139 import _version_check
1140 _version_check.check_version(get_module_version())
1141 
1142 # This file is compatible with both classic and new-style classes.
1143 
1144 
def run_python_module
Run a Python module as if with "python -m <modname>", with the given list of arguments as sys...
def assertApplicationExitedCleanly
Assert that the application exited cleanly (return value = 0).
def import_python_application
Import an installed Python application, rather than running it.
def open_input_file
Open and return an input file in the top-level test directory.
def run_application
Run an application with the given list of arguments.
def randomize_particles
Randomize the xyz coordinates of a list of particles.
Super class for simple IMP application test cases.
void set_check_level(CheckLevel tf)
Control runtime checks in the code.
See IMP.base for more information.
Definition: base/Array.h:20
std::string get_example_path(std::string file_name)
Return the path to installed example data for this module.
def assert_number
Make sure that the number of references matches the expected value.
Check to make sure the number of director references is as expected.
def assertShow
Check that all the classes in modulename have a show method.
def run_shell_command
Print and run a shell command, as returned by read_shell_commands()
Vector3D get_random_vector_in(const Cylinder3D &c)
Generate a random vector in a cylinder with uniform density.
def run_python_application
Run a Python application with the given list of arguments.
def assert_number
Make sure that the number of references matches the expected value.
Simple RAII-style class to run in a temporary directory.
def particle_distance
Return distance between two given particles.
def check_unary_function_deriv
Check the unary function func's derivatives against numerical approximations between lb and ub...
def get_tmp_file_name
Get the full name of an output file in the build/tmp directory.
See IMP.kernel for more information.
def run_example
Run the named example script.
Class to handle individual model particles.
def check_unary_function_min
Make sure that the minimum of the unary function func over the range between lb and ub is at expected...
def probabilistic_test
Help handle a test which is expected to fail some fraction of the time.
def create_particles_in_box
Create a bunch of particles in a box.
See IMP.algebra for more information.
def numerical_derivative
Calculate the derivative of the single-value function func at point val.
def xyz_numerical_derivatives
Calculate the x,y and z derivatives of model's scoring function on the xyz particle.
def failure_probability
Estimate how likely a given block of code is to raise an AssertionError.
VectorD< 3 > Vector3D
Definition: VectorD.h:395
def assertClassNames
Check that all the classes in the module follow the imp naming conventions.
def create_point_particle
Make a particle with optimizable x, y and z attributes, and add it to the model.
def read_shell_commands
Read and return a set of shell commands from a doxygen file.
std::string get_data_path(std::string file_name)
Return the full path to installed data.
Check to make sure the number of C++ object references is as expected.
def assertFunctionNames
Check that all the functions in the module follow the imp naming conventions.
def assertValueObjects
Check that all the C++ classes in the module are values or objects.
CheckLevel get_check_level()
Get the current audit mode.
Super class for IMP test cases.
def assertXYZDerivativesInTolerance
Assert that x,y,z analytical derivatives match numerical within a tolerance, or a percentage (of the ...
def run_script
Run an application with the given list of arguments.
def get_input_file_name
Get the full name of an input file in the top-level test directory.
def check_runnable_python_module
Check a Python module designed to be runnable with 'python -m' to make sure it supports standard comm...
Strings get_live_object_names()