snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/ptolemy/test.py

@@ -1,32 +1,37 @@
-from __future__ import print_function
-### Tests the ptolemy module
+# Tests the ptolemy module
 ###
-### Test in sage with precomputed results in testing_files_directory:
-### sage -python test.py 
+# Test in sage with precomputed results in testing_files_directory:
+# sage -python test.py
 ###
-### Test in python with precomputed results:
-### python test.py
+# Test in python with precomputed results:
+# python test.py
 ###
-### Test in sage computing the results:
-### sage -python test.py --compute
+# Test in sage computing the results:
+# sage -python test.py --compute
 ###
-### Test in python computing the results using magma:
-### python test.py --compute
+# Test in python computing the results using magma:
+# python test.py --compute
 
 from snappy import Manifold, pari, ptolemy
+from snappy import ptolemy
 from snappy.ptolemy import solutions_from_magma, Flattenings, parse_solutions
 from snappy.ptolemy.processFileBase import get_manifold
 from snappy.ptolemy import __path__ as ptolemy_paths
 from snappy.ptolemy.coordinates import PtolemyCannotBeCheckedError
-from snappy.sage_helper import _within_sage, doctest_modules
+from snappy.sage_helper import _within_sage
+from snappy.testing import doctest_modules
 from snappy.pari import pari
 import bz2
-import os, sys
+import os
+import sys
+import doctest
+import traceback
 
 if _within_sage:
     from sage.misc.sage_eval import sage_eval
 
 test_regina = '--regina' in sys.argv
+compute_solutions = '--compute' in sys.argv
 
 base_path = ptolemy_paths[0]
 if test_regina:
@@ -50,9 +55,10 @@ else:
 
 vol_tet = pari('1.014941606409653625021202554274520285941689307530299792017489106776597476258244022136470354228256695')
 
+
 def check_volumes(complex_volumes, baseline_complex_volumes,
-                  check_real_part_only = False,
-                  torsion_imaginary_part = 6, epsilon = 1e-80):
+                  check_real_part_only=False,
+                  torsion_imaginary_part=6, epsilon=1e-80):
 
     # add complex volumes from complex conjugation to baseline
 
@@ -79,8 +85,7 @@ def check_volumes(complex_volumes, baseline_complex_volumes,
     # check that every base line volume appears in computed volumes
     for cvol1 in baseline_complex_volumes:
 
-        if not True in [
-            is_close(cvol1, cvol2) for cvol2 in complex_volumes]:
+        if not any(is_close(cvol1, cvol2) for cvol2 in complex_volumes):
             print("Missing base line volume:", cvol1)
 
             print("Volumes:")
@@ -91,19 +96,20 @@ def check_volumes(complex_volumes, baseline_complex_volumes,
 
     # check that every computed volume is a base line volume
     for cvol2 in complex_volumes:
-        if not True in [
-            is_close(cvol1, cvol2) for cvol1 in baseline_complex_volumes]:
+        if not any(is_close(cvol1, cvol2)
+                   for cvol1 in baseline_complex_volumes):
             print("Extra volume:", cvol2)
-            
+
             print("Volumes:")
             for i in complex_volumes:
                 print("     ", i)
-    
+
             raise Exception
 
-def testSolutionsForManifold(M, N, solutions, baseline_cvolumes = None,
-                             expect_non_zero_dimensional = None,
-                             against_geometric = True):
+
+def testSolutionsForManifold(M, N, solutions, baseline_cvolumes=None,
+                             expect_non_zero_dimensional=None,
+                             against_geometric=True):
 
     old_precision = pari.set_real_precision(100)
 
@@ -135,14 +141,14 @@ def testSolutionsForManifold(M, N, solutions, baseline_cvolumes = None,
             for numerical_solution in solution.numerical():
                 numerical_solutions.append(numerical_solution)
                 numerical_cross_ratios.append(numerical_solution.cross_ratios())
-            
+
             # check exact cross ratios
             cross_ratios = solution.cross_ratios()
             if not test_regina:
                 cross_ratios.check_against_manifold(M)
 
             assert cross_ratios.N() == N
-        
+
             # compute numerical cross ratios alternatively
             # (above we converted exact Ptolemy's to numerical and then
             # converted to cross ratio, here we first compute cross ratios
@@ -151,23 +157,23 @@ def testSolutionsForManifold(M, N, solutions, baseline_cvolumes = None,
 
     # check we encountered non-zero dimensional component if that's
     # expected
-    if not expect_non_zero_dimensional is None:
+    if expect_non_zero_dimensional is not None:
         assert expect_non_zero_dimensional == found_non_zero_dimensional
 
     # check the numerical solutions against the manifold
     for s in numerical_solutions:
-        s.check_against_manifold(M, epsilon = 1e-80)
+        s.check_against_manifold(M, epsilon=1e-80)
 
         # check that they make a flattening
         if not test_regina:
-            s.flattenings_numerical().check_against_manifold(M, epsilon = 1e-80)
+            s.flattenings_numerical().check_against_manifold(M, epsilon=1e-80)
 
     if not test_regina:
         for s in numerical_cross_ratios:
-            s.check_against_manifold(M, epsilon = 1e-80)
+            s.check_against_manifold(M, epsilon=1e-80)
 
         for s in numerical_cross_ratios_alt:
-            s.check_against_manifold(M, epsilon = 1e-80)
+            s.check_against_manifold(M, epsilon=1e-80)
 
     # compute complex volumes and volumes
     complex_volumes = [s.complex_volume_numerical() for s in numerical_solutions]
@@ -186,8 +192,8 @@ def testSolutionsForManifold(M, N, solutions, baseline_cvolumes = None,
 
     # volumes should be equal
     assert len(volumes) == len(volumes_alt)
-    volumes.sort(key = float)
-    volumes_alt.sort(key = float)
+    volumes.sort(key=float)
+    volumes_alt.sort(key=float)
     for vol1, vol2 in zip(volumes, volumes_alt):
         assert (vol1 - vol2).abs() < 1e-80
 
@@ -198,17 +204,19 @@ def testSolutionsForManifold(M, N, solutions, baseline_cvolumes = None,
                 abs(geom_vol - vol) < 1e-11 for vol in volumes]
 
     # check that complex volumes match baseline volumes
-    if not baseline_cvolumes is None:
+    if baseline_cvolumes is not None:
         check_volumes(complex_volumes, baseline_cvolumes)
 
     pari.set_real_precision(old_precision)
 
-def testComputeSolutionsForManifold(manifold, N, 
-                                    compute_solutions = False, 
-                                    baseline_cvolumes = None,
-                                    expect_non_zero_dimensional = None):
 
-    varieties = manifold.ptolemy_variety(N, obstruction_class = "all_original")
+def testComputeSolutionsForManifold(manifold, N,
+                                    compute_solutions=False,
+                                    baseline_cvolumes=None,
+                                    expect_non_zero_dimensional=None,
+                                    print_info=True):
+
+    varieties = manifold.ptolemy_variety(N, obstruction_class="all_original")
 
     if compute_solutions:
         def compute(variety):
@@ -220,14 +228,15 @@ def testComputeSolutionsForManifold(manifold, N,
 
     solutions = sum([compute(variety) for variety in varieties], [])
 
-    testSolutionsForManifold(manifold, N, solutions, 
+    testSolutionsForManifold(manifold, N, solutions,
                              baseline_cvolumes, expect_non_zero_dimensional)
 
     if manifold.name() == 't00000':
-        testMatrixMethods(manifold, solutions)
+        testMatrixMethods(manifold, solutions, print_info=print_info)
+
+
+def testMatrixMethods(manifold, solutions, print_info=True):
 
-def testMatrixMethods(manifold, solutions):
-    
     def matrix_is_diagonal(m):
         return (
             m[0][0] - m[1][1] == 0 and
@@ -238,14 +247,15 @@ def testMatrixMethods(manifold, solutions):
         return matrix_is_diagonal(m) and (
             m[0][0] + 1 == 0 or m[0][0] - 1 == 0)
 
-    print("Testing matrix methods...")
+    if print_info:
+        print("Testing matrix methods...")
 
-    G = manifold.fundamental_group(simplify_presentation = True)
-    Graw = manifold.fundamental_group(simplify_presentation = False)
+    G = manifold.fundamental_group(simplify_presentation=True)
+    Graw = manifold.fundamental_group(simplify_presentation=False)
 
     for solution in solutions:
         if solution.dimension == 0:
-            
+
             solution._testing_check_cocycles()
 
             cross_ratios = solution.cross_ratios()
@@ -281,7 +291,7 @@ def testMatrixMethods(manifold, solutions):
                     solution.evaluate_word(rel))
                 assert matrix_is_diagonal(
                     solution.evaluate_word(rel))
-            
+
 
 def test_flattenings_from_tetrahedra_shapes_of_manifold():
 
@@ -299,46 +309,52 @@ def test_flattenings_from_tetrahedra_shapes_of_manifold():
 
     from snappy import OrientableCuspedCensus
 
-    for M in (list(OrientableCuspedCensus()[0:10])+
-              list(OrientableCuspedCensus()[10000:10010])):
+    for M_database in (list(OrientableCuspedCensus()[0:10]) +
+                       list(OrientableCuspedCensus()[10000:10010])):
+
+        # The manifold returned by OrientableCuspedCensus is
+        # a SnapPy.Manifold, not a snappy.Manifold (as is overridden
+        # in python/test.py).
+        M = Manifold(M_database)
         
         flattening = Flattenings.from_tetrahedra_shapes_of_manifold(M)
-        flattening.check_against_manifold(M, epsilon = 1e-80)
+        flattening.check_against_manifold(M, epsilon=1e-80)
 
         if not is_close(flattening.complex_volume(),
                         M.complex_volume(), # returns only double precision
-                        epsilon = 1e-13):
+                        epsilon=1e-13):
             raise Exception("Wrong volume")
-        
+
     # test high precision
 
     M = ManifoldGetter("5_2")
     flattening = Flattenings.from_tetrahedra_shapes_of_manifold(M)
-    flattening.check_against_manifold(M, epsilon = 1e-80)
+    flattening.check_against_manifold(M, epsilon=1e-80)
 
     if not is_close(flattening.complex_volume(),
                     pari('2.828122088330783162763898809276634942770981317300649477043520327258802548322471630936947017929999108 - 3.024128376509301659719951221694600993984450242270735312503300643508917708286193746506469158300472966*I'),
-                    epsilon = 1e-80):
+                    epsilon=1e-80):
         raise Exception("Wrong volume")
 
     pari.set_real_precision(old_precision)
 
+
 def checkSolutionsForManifoldGeneralizedObstructionClass(
     solutions_trivial, solutions_non_trivial,
     manifold, N, baseline_volumes, baseline_dimensions):
 
     torsionTrivial = pari('Pi^2/6 * I')
     torsionNonTrivial = pari('Pi^2/18 * I')
-    
+
     solutions = (
         [ (s, False) for s in solutions_trivial ] +
-        [ (s, True)  for s in solutions_non_trivial ])
+        [ (s, True) for s in solutions_non_trivial ])
 
     # Dimensions and volumes encountered
     dimensions = set()
     volumes = []
     volumes_2 = []
-    
+
     for solution, sol_is_non_trivial in solutions:
         # Add the dimension
         dimensions.add(solution.dimension)
@@ -350,19 +366,19 @@ def checkSolutionsForManifoldGeneralizedObstructionClass(
                     solution.check_against_manifold(manifold)
                 except PtolemyCannotBeCheckedError:
                     got_exception = True
-                    
+
                     assert got_exception, (
                         "check_against_manifold should not have passed")
             else:
                 solution.check_against_manifold(manifold)
-            
+
             fl = solution.flattenings_numerical()
             for f in fl:
                 if not test_regina:
                     # Not supported yet in regina
-                    f.check_against_manifold(epsilon = 1e-80)
+                    f.check_against_manifold(epsilon=1e-80)
 
-                cvol, modulo = f.complex_volume(with_modulo = True)
+                cvol, modulo = f.complex_volume(with_modulo=True)
 
                 if sol_is_non_trivial and N == 3:
                     assert (modulo - torsionNonTrivial).abs() < 1e-80, (
@@ -375,7 +391,7 @@ def checkSolutionsForManifoldGeneralizedObstructionClass(
 
             # Add the volumes
             volumes += solution.volume_numerical()
-            
+
             # Check that the resulting cross ratios full fill
             # the gluing equations
             cross_ratios = solution.cross_ratios()
@@ -388,12 +404,12 @@ def checkSolutionsForManifoldGeneralizedObstructionClass(
     def make_unique(L):
         L.sort()
         result = L[:1]
-        
+
         for i in L:
             if not is_close(result[-1], i):
                 result.append(i)
         return result
-    
+
     volumes = make_unique(volumes)
     volumes_2 = make_unique(volumes_2)
     all_expected_volumes = make_unique(baseline_volumes +
@@ -409,15 +425,16 @@ def checkSolutionsForManifoldGeneralizedObstructionClass(
 
     assert dimensions == set(baseline_dimensions)
 
+
 def testComputeSolutionsForManifoldGeneralizedObstructionClass(
     manifold, N, compute_solutions, baseline_volumes, baseline_dimensions):
 
     varieties = manifold.ptolemy_variety(N,
-                                        obstruction_class = "all_generalized"
-                                        #, simplify = False
-                                        #, eliminate_fixed_ptolemys = True
+                                        obstruction_class="all_generalized"
+                                        # , simplify = False
+                                        # , eliminate_fixed_ptolemys = True
                                         )
-    
+
     assert len(varieties) == 2
 
     if compute_solutions:
@@ -427,11 +444,11 @@ def testComputeSolutionsForManifoldGeneralizedObstructionClass(
     else:
         def compute(variety):
             return compute_using_precomputed_magma(
-                variety, dir = testing_files_generalized_directory)
+                variety, dir=testing_files_generalized_directory)
 
     # Solutions for the trivial obstruction class
     solutions_trivial = compute(varieties[0])
-    
+
     # Solutions for the non-trivial obstruction class
     solutions_non_trivial = sum([compute(variety)
                                  for variety in varieties[1:]],
@@ -441,7 +458,8 @@ def testComputeSolutionsForManifoldGeneralizedObstructionClass(
         solutions_trivial, solutions_non_trivial,
         manifold, N, baseline_volumes, baseline_dimensions)
 
-def testGeneralizedObstructionClass(compute_solutions):
+
+def testGeneralizedObstructionClass(compute_solutions, print_info = True):
 
     vols = [
         pari('0'),
@@ -478,16 +496,18 @@ def testGeneralizedObstructionClass(compute_solutions):
 
     for manifold, N, vols, dims in test_cases:
 
-        print("Checking for", manifold.name(), "N = %d" % N)
+        if print_info:
+            print("Checking for", manifold.name(), "N = %d" % N)
 
         testComputeSolutionsForManifoldGeneralizedObstructionClass(
             manifold, N, compute_solutions, vols, dims)
 
+
 def testMapleLikeRur():
-    
+
     M = ManifoldGetter("m052")
     p = M.ptolemy_variety(3, 0)
-    
+
     sols = parse_solutions(
         bz2.BZ2File(os.path.join(testing_files_rur_directory,
                          p.filename_base() + '.rur.bz2'),
@@ -515,11 +535,11 @@ def testMapleLikeRur():
 
     old_precision = pari.set_real_precision(60)
 
-    sols.numerical().check_against_manifold(epsilon = 1e-50)
-    sols.numerical().cross_ratios().check_against_manifold(epsilon = 1e-50)
-    cross_ratios.numerical().check_against_manifold(epsilon = 1e-50)
-    sol_pur.numerical().check_against_manifold(epsilon = 1e-50)
-    cross_ratio_pur.numerical().check_against_manifold(epsilon = 1e-50)
+    sols.numerical().check_against_manifold(epsilon=1e-50)
+    sols.numerical().cross_ratios().check_against_manifold(epsilon=1e-50)
+    cross_ratios.numerical().check_against_manifold(epsilon=1e-50)
+    sol_pur.numerical().check_against_manifold(epsilon=1e-50)
+    cross_ratio_pur.numerical().check_against_manifold(epsilon=1e-50)
 
     expected_cvols = [
         pari('-0.78247122081308825152609555186377860994691907952043*I'),
@@ -557,12 +577,12 @@ def testMapleLikeRur():
 
     cvols = sols.complex_volume_numerical().flatten(2) # Include witnesses
 
-    check_volumes(cvols, expected_cvols, epsilon = 1e-40)
+    check_volumes(cvols, expected_cvols, epsilon=1e-40)
 
     vols = sols.volume_numerical().flatten(2) # Include witnesses
 
-    check_volumes(vols, expected_cvols, check_real_part_only = True, epsilon = 1e-40)
-    
+    check_volumes(vols, expected_cvols, check_real_part_only=True, epsilon=1e-40)
+
     pari.set_real_precision(old_precision)
 
 
@@ -571,13 +591,13 @@ def testNumericalSolutions():
     M = ManifoldGetter("m003")
     N = 3
 
-    varieties = M.ptolemy_variety(N, obstruction_class = 'all')
+    varieties = M.ptolemy_variety(N, obstruction_class='all')
 
-    solutions = [ 
+    solutions = [
         solutions_from_magma(
             get_precomputed_magma(variety,
-                                  dir = testing_files_generalized_directory),
-            numerical = True)
+                                  dir=testing_files_generalized_directory),
+            numerical=True)
         for variety in varieties ]
 
     for obstruction_index, obstruction in enumerate(solutions):
@@ -585,7 +605,7 @@ def testNumericalSolutions():
             for solution in component:
                 flattenings = solution.flattenings_numerical()
                 if not test_regina:
-                    flattenings.check_against_manifold(epsilon = 1e-80)
+                    flattenings.check_against_manifold(epsilon=1e-80)
                 order = flattenings.get_order()
 
                 if obstruction_index:
@@ -594,8 +614,8 @@ def testNumericalSolutions():
                     assert order == 2
 
                 cross_ratios = solution.cross_ratios()
-                is_cr = cross_ratios.is_pu_2_1_representation(epsilon = 1e-80,
-                                                              epsilon2 = 1e-10)
+                is_cr = cross_ratios.is_pu_2_1_representation(epsilon=1e-80,
+                                                              epsilon2=1e-10)
 
                 if cross_ratios.volume_numerical().abs() < 1e-10:
                     # Every volume 0 representation of m003 happens to be
@@ -612,7 +632,7 @@ def testNumericalSolutions():
     degree_dict = {}
 
     for component in allComponents:
-        
+
         dim = component.dimension
         deg = len(component)
 
@@ -620,10 +640,10 @@ def testNumericalSolutions():
         degree_dict[deg] = 1 + degree_dict.get(deg, 0)
 
         assert (dim == 0) ^ (deg == 0)
-        
+
     assert dimension_dict == {0: 4, 1: 2}
     assert degree_dict == {0 :2, 2: 2, 8: 2}
-    
+
     allSolutions = sum(allComponents, [])
 
     allCVolumes = [s.complex_volume_numerical() for s in allSolutions]
@@ -639,53 +659,59 @@ def testNumericalSolutions():
 
     check_volumes(allCVolumes, expected_cvolumes)
 
-def testGeometricRep(compute_solutions):
-    
+
+def testGeometricRep(compute_solutions, print_info=False):
+
     from snappy.ptolemy import geometricRep
-    
+
     M = Manifold("m019")
     if compute_solutions:
         sol = geometricRep.compute_geometric_solution(M)
     else:
         from urllib.request import pathname2url
         url = pathname2url(os.path.abspath(testing_files_directory))
-        sol = geometricRep.retrieve_geometric_solution(M, data_url=url)
+        sol = geometricRep.retrieve_geometric_solution(
+            M, data_url=url, verbose = print_info)
 
     # Make sure this is of type Ptolemy
     sol['c_0011_2']
 
     assert any(
-        [ abs(vol - 2.9441064867) < 1e-9 for vol in sol.volume_numerical()])
+        abs(vol - 2.9441064867) < 1e-9 for vol in sol.volume_numerical())
+
 
 def testSageCommandLine():
 
     sage_eval('Manifold("m004").ptolemy_variety(3,0).compute_solutions().check_against_manifold()',
               { 'Manifold' : ManifoldGetter })
-    
+
+
 def get_precomputed_magma(variety, dir):
-    magma_file_name = os.path.join(dir, 
+    magma_file_name = os.path.join(dir,
                         variety.filename_base() + '.magma_out.bz2')
     return bz2.BZ2File(magma_file_name,'r').read().decode('ascii')
 
-def compute_using_precomputed_magma(variety, dir = testing_files_directory):
+
+def compute_using_precomputed_magma(variety, dir=testing_files_directory):
     return solutions_from_magma(get_precomputed_magma(variety, dir))
 
+
 def test_induced_representation():
 
     M = ManifoldGetter("m015")
-    variety__sl2_c1 = M.ptolemy_variety(2, obstruction_class = 1)
-    variety__sl3_c0 = M.ptolemy_variety(3, obstruction_class = 0)
+    variety__sl2_c1 = M.ptolemy_variety(2, obstruction_class=1)
+    variety__sl3_c0 = M.ptolemy_variety(3, obstruction_class=0)
 
     solutions__sl2_c1 = compute_using_precomputed_magma(
-        variety__sl2_c1, dir = testing_files_generalized_directory)
+        variety__sl2_c1, dir=testing_files_generalized_directory)
     solutions__sl3_c0 = compute_using_precomputed_magma(
-        variety__sl3_c0, dir = testing_files_generalized_directory)
+        variety__sl3_c0, dir=testing_files_generalized_directory)
+
+    # Check that is_real
 
-    # Check that is_real 
-    
     got_exception = False
     try:
-        solutions__sl3_c0[0].cross_ratios().is_real(epsilon = 1e-80)
+        solutions__sl3_c0[0].cross_ratios().is_real(epsilon=1e-80)
     except:
         got_exception = True
     assert got_exception, (
@@ -699,11 +725,11 @@ def test_induced_representation():
         number_real = 0
         number_all = 0
         for z in component.cross_ratios_numerical():
-            if z.is_real(epsilon = 1e-80):
+            if z.is_real(epsilon=1e-80):
                 number_real += 1
             number_all += 1
         numbers_all_and_real.append((number_all, number_real))
-        
+
     # Bring into canonical form
     numbers_all_and_real.sort()
 
@@ -711,7 +737,7 @@ def test_induced_representation():
         (3, 1), # component has 3 solutions, 1 of them has real cross ratios
         (4, 2),
         (6, 0) ]
-        
+
     assert numbers_all_and_real == expected_numbers, (
         "Order of components and number of real solutions is off")
 
@@ -728,16 +754,15 @@ def test_induced_representation():
     number_psl2 = 0
 
     for component in solutions__sl3_c0:
-        is_induced_from_psl2 = [ z.is_induced_from_psl2(epsilon = 1e-80)
-                    for z in component.cross_ratios_numerical() ]
-        if True in is_induced_from_psl2:
+        is_induced_from_psl2 = [z.is_induced_from_psl2(epsilon=1e-80)
+                                for z in component.cross_ratios_numerical()]
+        if any(is_induced_from_psl2):
             number_psl2 += 1
-            assert not False in is_induced_from_psl2, (
-                "Mixed up is_induced_from_psl2")
+            assert all(is_induced_from_psl2), "Mixed up is_induced_from_psl2"
 
     assert number_psl2 == 1, (
         "Only one component can come from psl2 (numerically)")
-            
+
     # Check that induced_representation for sl3 throws error
     got_exception = False
     try:
@@ -767,12 +792,13 @@ def test_induced_representation():
         assert v.abs() < 1e-80 or (v.abs() - 4 * m015_volume).abs() < 1e-80, (
             "Did not get expected voluem for induced representation")
 
+
 def test_induced_sl4_representation():
     M = Manifold("m004")
 
     z_gl2 = ptolemy.CrossRatios.from_snappy_manifold(M)
     z_gl4 = z_gl2.induced_representation(4)
-    
+
     G = M.fundamental_group()
 
     mat = z_gl4.evaluate_word(G.relators()[0], G)
@@ -783,7 +809,7 @@ def test_induced_sl4_representation():
                 assert abs(entry - 1) < 1e-9
             else:
                 assert abs(entry) < 1e-9
-    
+
 
 def test_num_obstruction_class_match():
     from snappy import OrientableCuspedCensus
@@ -796,79 +822,69 @@ def test_num_obstruction_class_match():
 
         for i in range(2,6):
             assert len(M.ptolemy_generalized_obstruction_classes(i)) == len(N.ptolemy_generalized_obstruction_classes(i))
-            
-modules = [ptolemy.component, ptolemy.coordinates, ptolemy.manifoldMethods,
-           ptolemy.matrix, ptolemy.polynomial, ptolemy.processMagmaFile,
-           ptolemy.ptolemyObstructionClass, ptolemy.ptolemyVariety,
-           ptolemy.ptolemyVariety, ptolemy.processFileBase, ptolemy.processRurFile,
-           ptolemy.rur, ptolemy.utilities]
-if test_regina:
-    modules.append(ptolemy.reginaWrapper)
 
-def run_doctests(verbose=False, print_info=True):
-     return doctest_modules(modules, verbose, print_info)
+def run_ptolemy_tests_raising_exceptions(print_info=True):
+    if print_info:
+        print("Testing in sage:", _within_sage)
 
-def main(verbose=False, doctest=True):
-    print("Testing in sage:", _within_sage)
-
-    print("Testing in regina:", test_regina)
-
-    if doctest:
-        print("Running doctests...")
-        run_doctests(verbose)
-        print()
+        print("Testing in regina:", test_regina)
 
     if test_regina:
-        print("Testing that regina agrees with snappy obstruction classes")
+        if print_info:
+            print("Testing that regina agrees with snappy obstruction classes")
         test_num_obstruction_class_match()
 
     if not test_regina:
-        print("Testing Flattenings.from_tetrahedra_shapes_of_manifold...")
+        if print_info:
+            print("Testing Flattenings.from_tetrahedra_shapes_of_manifold...")
 
         test_flattenings_from_tetrahedra_shapes_of_manifold()
 
-    compute_solutions = False
-
-    if '--compute' in sys.argv:
-        compute_solutions = True
- 
     if test_regina and not compute_solutions:
         print("regina testing requires --compute")
         sys.exit(1)
-       
+
     old_precision = pari.set_real_precision(100)
 
-    print("Testing induced representation...")
+    if print_info:
+        print("Testing induced representation...")
 
     test_induced_representation()
 
-    print("Testing induced SL(4,C) representation...")
+    if print_info:
+        print("Testing induced SL(4,C) representation...")
 
     test_induced_sl4_representation()
 
-    print("Running manifold tests for generalized obstruction class...")
+    if print_info:
+        print("Running manifold tests for generalized obstruction class...")
 
-    testGeneralizedObstructionClass(compute_solutions)
+    testGeneralizedObstructionClass(compute_solutions, print_info=print_info)
 
     if not test_regina:
-        print("Testing RUR for m052__sl3_c0.rur")
+        if print_info:
+            print("Testing RUR for m052__sl3_c0.rur")
 
         testMapleLikeRur()
 
-    print("Testing numerical solution retrieval method...")
+    if print_info:
+        print("Testing numerical solution retrieval method...")
 
     testNumericalSolutions()
 
-    print("Testing geometricRep...")
-    testGeometricRep(compute_solutions)
+    if print_info:
+        print("Testing geometricRep...")
+    testGeometricRep(compute_solutions, print_info=print_info)
 
     if _within_sage:
-        print("Testing in sage command line...")
+        if print_info:
+            print("Testing in sage command line...")
         testSageCommandLine()
 
-    print("Running manifold tests...")
+    if print_info:
+        print("Running manifold tests...")
 
-    ### Test for a non-hyperbolic manifold
+    # Test for a non-hyperbolic manifold
 
     cvols = [ # Expected Complex volumes
         pari('0') ]
@@ -877,7 +893,7 @@ def main(verbose=False, doctest=True):
                     cvols,  # expected complex volumes
                     False)  # No non-zero dimensional components
 
-    ### Test for 4_1, amphichiral, expect zero CS
+    # Test for 4_1, amphichiral, expect zero CS
 
     cvols = [ # Expected Complex volumes
         2 * vol_tet
@@ -887,7 +903,7 @@ def main(verbose=False, doctest=True):
                     cvols,  # expected complex volumes
                     False)   # expect non-zero dimensional components
 
-    ### N = 3
+    # N = 3
 
     cvols = [ # Expected Complex volumes
         pari(0),
@@ -898,7 +914,7 @@ def main(verbose=False, doctest=True):
                     cvols,  # expected complex volumes
                     False)   # expect non-zero dimensional components
 
-    ### N = 4 
+    # N = 4
 
     cvols = [ # Expected Complex volumes
         2 * 10 * vol_tet,
@@ -918,10 +934,9 @@ def main(verbose=False, doctest=True):
                     cvols,  # expected complex volumes
                     True)   # expect non-zero dimensional components
 
-
-    ### Test for 5_2, expect non-trivial CS
-    ### Number field has one real embedding with non-trival CS
-    ### And one pair of complex embeddings with non-trivial CS
+    # Test for 5_2, expect non-trivial CS
+    # Number field has one real embedding with non-trival CS
+    # And one pair of complex embeddings with non-trivial CS
 
     cvols = [ # Expected Complex volumes
         pari('+ 1.113454552473924010022656943451126420312050780921075311799926598907813005362784871512051614741669817*I'),
@@ -932,8 +947,8 @@ def main(verbose=False, doctest=True):
                     cvols,  # expected complex volumes
                     False)   # expect no non-zero dimensional components
 
-    ### m015 which is isometric to 5_2
-    ### This example is also appearing on the website
+    # m015 which is isometric to 5_2
+    # This example is also appearing on the website
 
     cvols = [ # Expected Complex volumes
         pari('+ 0.4033353624187061319128390413376061001062613536896471642214173008084760853375773296525240139108027276*I'),
@@ -949,8 +964,8 @@ def main(verbose=False, doctest=True):
                      cvols, # expected volumes
                      False)   # expect no non-zero dimensional components
 
-    ### Test for m135
-    ### Ptolemy Variety has one non-zero dimensional component
+    # Test for m135
+    # Ptolemy Variety has one non-zero dimensional component
 
     cvols = [ # Expected Complex volumes
         pari('3.66386237670887606021841405972953644309659749712668853706599247848705207910501907791742605170446042499429769047678479831614359521330343623772637894992 + 4.93480220054467930941724549993807556765684970362039531320667468811002241120960262150088670185927611591201295688701157203888617406101502336380530883900*I')
@@ -961,9 +976,9 @@ def main(verbose=False, doctest=True):
                      cvols,       # expected volumes
                      True)        # expect a non-zero dimensional component
 
-    ### Test for s000
-    ### Number field has one real embedding with non-trival CS
-    ### And two complex embeddings with non-trivial CS
+    # Test for s000
+    # Number field has one real embedding with non-trival CS
+    # And two complex embeddings with non-trivial CS
 
     cvols = [ # Expected Complex volumes
         pari('3.296902414326637335562593088559162089146991699269941951875989849869324250860299302482577730785960256 + 0.4908671850777469648812718224097607532197026477625119178645010117072332396428578681905186509136879130*I'),
@@ -976,24 +991,23 @@ def main(verbose=False, doctest=True):
                      cvols,   # expected complex volumes
                      False)   # expect non-zero dimensional components
 
-    ### Test for v0000
-    ### This also tests the case of having more than one (here two)
-    ### cusps
+    # Test for v0000
+    # This also tests the case of having more than one (here two)
+    # cusps
 
     cvols = [ # Expected Complex volumes
         pari('3.377597408231442496961257171798882829176020069714519460350380851901055794392493960110119513942153791 + 0.3441889979504813554136570264352067044809511501367282461849580661783699588789118851518262199077361427*I'),
         pari('1.380586178282342062845519278761524817753278777803238623999221385504661588501960339341800843520223671 + 0.06704451876157525370444676522629959282378632516497136324893149116413190872188833330658100524720353406*I')
         ]
-    
+
     test__v0000__2 = (ManifoldGetter("v0000"),  # Manifold
                       2,       # N = 2
                       cvols,   # expected complex volumes
                       False)   # expect non-zero dimensional components
 
-
-    ### Test for t00000
-    ### This also tests the case of having more than one (here two)
-    ### cusps
+    # Test for t00000
+    # This also tests the case of having more than one (here two)
+    # cusps
 
     cvols = [ # Expected Complex volumes
         pari('1.801231981344929412976326011175173926741195258454700704383597306674496002389749200442131507334117933 - 0.5490336239273931479260463113980794374780078424892352183284248305887346671477869107359071072271699046*I'),
@@ -1001,16 +1015,16 @@ def main(verbose=False, doctest=True):
         pari('2.781430316400743786576311128801205534982324055570742403430395886754122643539081915302290955978507418 - 0.1135489194824466736456241002458946823709871812077727407261274931826622024508518397031626436088171650*I'),
         pari('0.6223401945262803853426860070209275705147832620602921139947907237662088851273537136119288228151713940 + 0.06594907226052699343130923275995552293727798462035885627276325301997714628516294342514039299674185799*I')
         ]
-    
+
     test__t00000__2 = (ManifoldGetter("t00000"),  # Manifold
                       2,          # N = 2
                       cvols,      # expected complex volumes
                       False)      # expect non-zero dimensional components
 
-    ### Check a big link
-    ### Also an example from the website
+    # Check a big link
+    # Also an example from the website
 
-    magma_file_name = os.path.join(testing_files_directory, 
+    magma_file_name = os.path.join(testing_files_directory,
                        'DT_mcbbiceaibjklmdfgh__sl2_c0.magma_out.bz2')
     magma_file = bz2.BZ2File(magma_file_name, 'r').read().decode('ascii')
     M = get_manifold(magma_file)
@@ -1050,18 +1064,63 @@ def main(verbose=False, doctest=True):
                    test__4_1__3,
                    test__m015__3,
                    test__4_1__4]
-    
+
     pari.set_real_precision(old_precision)
 
     for manifold, N, cvols, expect_non_zero_dim in test_cases:
 
-        print("Checking for", manifold.name(), "N = %d" % N)
+        if print_info:
+            print("Checking for", manifold.name(), "N = %d" % N)
 
         testComputeSolutionsForManifold(
             manifold, N,
-            compute_solutions = compute_solutions,
-            baseline_cvolumes = cvols,
-            expect_non_zero_dimensional = expect_non_zero_dim)
+            compute_solutions=compute_solutions,
+            baseline_cvolumes=cvols,
+            expect_non_zero_dimensional=expect_non_zero_dim,
+            print_info=print_info)
+
+def run_ptolemy_tests(verbose=False, print_info=True):
+    try:
+        run_ptolemy_tests_raising_exceptions(
+            print_info=print_info)
+        return doctest.TestResults(failed=0, attempted=1)
+    except Exception as e:
+        print()
+        print("FAILED TEST in Ptolemy. Exception is:")
+        traceback.print_exc()
+        print()
+        return doctest.TestResults(failed=1, attempted=1)
+
+run_ptolemy_tests.__name__ = ptolemy.__name__ + ' (non-doc tests)'
+
+modules = [ptolemy.component,
+           ptolemy.coordinates,
+           ptolemy.manifoldMethods,
+           ptolemy.matrix,
+           ptolemy.polynomial,
+           ptolemy.processFileBase,
+           ptolemy.processMagmaFile,
+           ptolemy.processRurFile,
+           ptolemy.ptolemyObstructionClass,
+           ptolemy.ptolemyVariety,
+           ptolemy.rur,
+           ptolemy.utilities]
+if test_regina:
+    modules.append(ptolemy.reginaWrapper)
+
+def run_doctests(verbose=False, print_info=True):
+    return doctest_modules(
+        modules,
+        verbose=verbose, print_info=print_info)
+
+run_doctests.__name__ = ptolemy.__name__
 
 if __name__ == '__main__':
-    main()
+    verbose = '-v' in sys.argv[1:] or '--verbose' in sys.argv[1:]
+
+    result = run_doctests(verbose=verbose, print_info=True)
+    if result.failed:
+        sys.exit(result.failed)
+
+    result = run_ptolemy_tests(verbose=verbose, print_info=True)
+    sys.exit(result.failed)