tools/CurvePlot/src/python/test/plot_test.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2019  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   4 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   5 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   6 #
   7 # This library is free software; you can redistribute it and/or
   8 # modify it under the terms of the GNU Lesser General Public
   9 # License as published by the Free Software Foundation; either
  10 # version 2.1 of the License, or (at your option) any later version.
  11 #
  12 # This library 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 GNU
  15 # Lesser General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Lesser General Public
  18 # License along with this library; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 #
  21 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  22 #
  23 # Author : A. Bruneton
  24 #
  25 from curveplot import *
  26 from curveplot.PlotTestBase import PlotTestBase, processDecorator
  27 from curveplot.PlotSettings import PlotSettings
  28
  29 from pyqtside.QtWidgets import QApplication
  30 import sys
  31 qapp = QApplication(sys.argv)
  32
  33 class PlotTest(PlotTestBase):
  34   """ Unit test suite for the curve plotter. The tests themselves are stored in this class,
  35   the screenshot comparison logic is in PlotTestBase.
  36
  37   The class variable below can be turned on to regenerate base line files (reference images).
  38   All baselines start with the name of the corresponding test, plus a possible suffix.
  39   The baselines directory is set relative to the path of this script.
  40
  41   The decorator @runOnly can be used to run/rebuild a single test.
  42   """
  43   REBUILD_BASELINES = False
  44
  45   def __init__(self, methodName):
  46     PlotTestBase.__init__(self, methodName)
  47
  48   ###
  49   ### Data generation
  50   ###
  51   def generateSine(self, alpha=1.0):
  52     import numpy as np
  53     x = np.arange(100)
  54     y = np.sin(x*alpha/np.pi)
  55     return x, y
  56
  57   def generateExp(self, alpha=1.0):
  58     import numpy as np
  59     x = np.arange(20) + 1.0
  60     y = np.exp(x*alpha)
  61     return x, y
  62
  63   ###
  64   ### The tests themselves
  65   ###
  66
  67   #
  68   # Non GUI tests (some of them still need to show the widget to work properly but no
  69   # screenshot comparison is made).
  70   #
  71   def testTableModel(self):
  72     import numpy as np
  73     from curveplot.TableModel import TableModel
  74     t = TableModel(None)
  75     t.setTitle("coucou")
  76     t.addColumn([1.0,2.0,3.0,4.0])
  77     self.assertRaises(ValueError, t.addColumn, [1.0,2.0])
  78     t.addColumn([1.0,2.0,3.0,4.0])
  79     t.addColumn([1.0, 4.0, 9.0, 16.0])
  80     self.assertEqual((4,3), t.getShape())
  81     t.removeValue(0, 1)
  82     self.assertTrue(np.isnan(t.getData()[0,1]))
  83     t.setColumnTitle(1, "a title")
  84     self.assertEqual("a title", t.getColumnTitle(1))
  85     self.assertEqual("", t.getColumnTitle(0))
  86
  87   def testGetAllPlotSets(self):
  88     self.showTabWidget()
  89     ids, titles = PlotController.GetAllPlotSets()
  90     self.assertEqual([], ids)
  91     self.assertEqual([], titles)
  92
  93     id1 = PlotController.AddPlotSet("toto")
  94     id2 = PlotController.AddPlotSet("tutu")
  95     id3 = PlotController.AddPlotSet("titi")
  96     ids, titles = PlotController.GetAllPlotSets()
  97     self.assertEqual([id1,id2,id3], ids)
  98     self.assertEqual(["toto","tutu","titi"], titles)
  99
 100   def testGetCurrentXX(self):
 101     self.showTabWidget()
 102     self.assertEqual(-1, PlotController.GetCurrentCurveID())
 103     self.assertEqual(-1, PlotController.GetCurrentPlotSetID())
 104
 105     x, y = self.generateSine()
 106     _, psID1 = PlotController.AddCurve(x, y, append=False)
 107     self.assertEqual(psID1, PlotController.GetCurrentPlotSetID())
 108     _, psID2 = PlotController.AddCurve(x, y, append=True)
 109     self.assertEqual(psID1, psID2)  # doesn't hurt!
 110     self.assertEqual(psID2, PlotController.GetCurrentPlotSetID())
 111     psID3 = PlotController.AddPlotSet("ps")
 112     self.assertEqual(psID3, PlotController.GetCurrentPlotSetID())
 113     PlotController.DeletePlotSet(psID3)
 114     PlotController.DeletePlotSet(psID2)
 115     self.assertEqual(-1, PlotController.GetCurrentCurveID())
 116     self.assertEqual(-1, PlotController.GetCurrentPlotSetID())
 117
 118   def testGetPlotSetID(self):
 119     self.showTabWidget()
 120     x, y = self.generateSine()
 121     crvID, psID = PlotController.AddCurve(x, y, append=False)
 122     self.assertEqual(psID, PlotController.GetPlotSetID(crvID))
 123     self.assertEqual(-1, PlotController.GetPlotSetID(145))  # invalid ID
 124     PlotController.DeletePlotSet(psID)
 125     self.assertEqual(-1, PlotController.GetPlotSetID(crvID))  # invalid ID
 126
 127   def testGetPlotSetIDByName(self):
 128     self.showTabWidget()
 129     self.assertEqual(-1,PlotController.GetPlotSetIDByName("invalid"))
 130     psID = PlotController.AddPlotSet("ps")
 131     self.assertEqual(psID,PlotController.GetPlotSetIDByName("ps"))
 132     PlotController.DeletePlotSet(psID)
 133     self.assertEqual(-1,PlotController.GetPlotSetIDByName("ps"))
 134
 135   def testIsValidPlotSetID(self):
 136     self.showTabWidget()
 137     self.assertEqual(False,PlotController.IsValidPlotSetID(0))
 138     psID = PlotController.AddPlotSet("ps")
 139     self.assertEqual(True,PlotController.IsValidPlotSetID(psID))
 140     PlotController.DeletePlotSet(psID)
 141     self.assertEqual(False,PlotController.IsValidPlotSetID(psID))
 142
 143   #
 144   # GUI tests
 145   #
 146   def testAddCurve(self):
 147     x, y = self.generateSine()
 148     tw = self.showTabWidget()
 149     PlotController.AddCurve(x, y, curve_label="My curve", x_label="Lèés X (unicode!)", y_label="Et des ŷ", append=False)
 150     self.assertTrue(self.areScreenshotEqual(tw))
 151
 152   def testAddCurveAppend(self):
 153     x, y = self.generateSine()
 154     tw = self.showTabWidget()
 155     PlotController.AddCurve(x, y, curve_label="My curve", x_label="The X-s", y_label="The Y-s", append=False)
 156     PlotController.AddCurve(x, y*1.5, curve_label="My curve 2", append=True)
 157     self.assertTrue(self.areScreenshotEqual(tw))
 158
 159   def testAddPlotSet(self):
 160     tw = self.showTabWidget()
 161     PlotController.AddPlotSet("My plotset")
 162     self.assertTrue(self.areScreenshotEqual(tw))
 163
 164   def testClearPlotSet(self):
 165     x, y = self.generateSine()
 166     tw = self.showTabWidget()
 167     PlotController.AddCurve(x, y, curve_label="My curve", x_label="The X-s", y_label="The Y-s", append=False)
 168     _, psID = PlotController.AddCurve(x, y, curve_label="My curve 2", append=True)
 169     clearedID = PlotController.ClearPlotSet()
 170     self.assertEqual(clearedID, psID)
 171     self.assertTrue(self.areScreenshotEqual(tw))
 172
 173   def testClearPlotSet2(self):
 174     tw = self.showTabWidget()
 175     self.assertRaises(ValueError, PlotController.ClearPlotSet, -789)
 176     psID = PlotController.AddPlotSet("My plotset")
 177     clearedID = PlotController.ClearPlotSet(psID)
 178     self.assertEqual(psID, clearedID)
 179     self.assertTrue(self.areScreenshotEqual(tw))
 180
 181   def testCopyCurve(self):
 182     x, y = self.generateSine()
 183     tw = self.showTabWidget()
 184     crvID, _ = PlotController.AddCurve(x, y, curve_label="My curve", x_label="The X-s", y_label="The Y-s", append=False)
 185     psID = PlotController.AddPlotSet("Another plotset")
 186     newID = PlotController.CopyCurve(crvID, psID)
 187     PlotController.SetCurrentPlotSet(psID)
 188     self.assertNotEqual(crvID, newID)
 189     self.assertTrue(self.areScreenshotEqual(tw))
 190
 191   def testDeleteCurrentItem_curve(self):
 192     x, y = self.generateSine()
 193     tw = self.showTabWidget()
 194     PlotController.AddCurve(x, y, append=False)
 195     crvID, _ = PlotController.AddCurve(x, y*1.5, append=True)
 196     PlotController.SetCurrentCurve(crvID)
 197     b, anID = PlotController.DeleteCurrentItem()  # currently selected curve
 198     self.assertFalse(b)
 199     self.assertEqual(crvID, anID)
 200     self.assertTrue(self.areScreenshotEqual(tw))
 201
 202   def testDeleteCurrentItem_plotSet(self):
 203     tw = self.showTabWidget()
 204     PlotController.AddPlotSet("tutu")
 205     psID = PlotController.AddPlotSet("tata")
 206     b, anID = PlotController.DeleteCurrentItem()
 207     self.assertTrue(b)
 208     self.assertEqual(psID, anID)
 209     self.assertTrue(self.areScreenshotEqual(tw))
 210
 211   def testDeleteCurrentItem_void(self):
 212     self.showTabWidget()
 213     b, anID = PlotController.DeleteCurrentItem()  # nothing selected
 214     self.assertTrue(b)
 215     self.assertEqual(-1, anID)
 216
 217   def testDeleteCurve1(self):
 218     tw = self.showTabWidget()
 219     x, y = self.generateSine()
 220     crvID, _ = PlotController.AddCurve(x, y, append=False)
 221     PlotController.AddCurve(x, y*1.5, append=True)
 222     cID = PlotController.DeleteCurve(crvID)
 223     self.assertEqual(crvID, cID)
 224     self.assertTrue(self.areScreenshotEqual(tw))
 225
 226   def testDeleteCurve2(self):
 227     tw = self.showTabWidget()
 228     x, y = self.generateSine()
 229     crvID, _ = PlotController.AddCurve(x, y, append=False)
 230     PlotController.AddCurve(x, y*1.5, append=True)
 231     PlotController.SetCurrentCurve(crvID)
 232     cID = PlotController.DeleteCurve()   # current curve
 233     self.assertEqual(crvID, cID)
 234     self.assertTrue(self.areScreenshotEqual(tw))
 235
 236   def testDeleteCurve3(self):
 237     """ resulting in an empty plot set, legend should be hidden """
 238     tw = self.showTabWidget()
 239     x, y = self.generateSine()
 240     crvID, _ = PlotController.AddCurve(x, y, append=False)
 241     cID = PlotController.DeleteCurve(crvID)
 242     self.assertEqual(crvID, cID)
 243     self.assertTrue(self.areScreenshotEqual(tw))
 244
 245   def testDeletePlotSet1(self):
 246     tw = self.showTabWidget()
 247     psID = PlotController.AddPlotSet("tutu")
 248     PlotController.AddPlotSet("tata")
 249     psID2 = PlotController.DeletePlotSet(psID)
 250     self.assertEqual(psID2, psID)
 251     self.assertTrue(self.areScreenshotEqual(tw))
 252
 253   def testDeletePlotSet2(self):
 254     tw = self.showTabWidget()
 255     psID1 = PlotController.DeletePlotSet()
 256     self.assertEqual(-1, psID1)             # nothing selected yet
 257     psID2 = PlotController.AddPlotSet("tutu")
 258     PlotController.AddPlotSet("tata")
 259     PlotController.SetCurrentPlotSet(psID2)
 260     psID3 = PlotController.DeletePlotSet()  # current plot set
 261     self.assertEqual(psID3, psID2)
 262     self.assertTrue(self.areScreenshotEqual(tw))
 263
 264   def testSetCurrentCurve(self):
 265     tw = self.showTabWidget()
 266     self.assertRaises(ValueError, PlotController.SetCurrentCurve, 23)
 267     x, y = self.generateSine()
 268     crvID, psID = PlotController.AddCurve(x, y, append=False)
 269     _, _ = PlotController.AddCurve(x, y, append=False)  # in a new plot set
 270     psID2 = PlotController.SetCurrentCurve(crvID)
 271     self.assertEqual(psID, psID2)
 272     self.assertTrue(self.areScreenshotEqual(tw))
 273
 274   def testSetCurrentCurve2(self):
 275     tw = self.showTabWidget()
 276     x, y = self.generateSine()
 277     crvID, psID = PlotController.AddCurve(x, y, append=False)
 278     PlotController.SetCurrentCurve(crvID)
 279     _, crvID2 = PlotController.AddCurve(x, y, append=False)  # in a new plot set
 280     PlotController.SetCurrentCurve(crvID2)
 281     # on first plot set curve should not be selected anymore
 282     PlotController.SetCurrentPlotSet(psID)
 283     self.assertTrue(self.areScreenshotEqual(tw))
 284
 285   def testSetCurrentCurve3(self):
 286     tw = self.showTabWidget()
 287     x, y = self.generateSine()
 288     crvID, _ = PlotController.AddCurve(x, y, append=False)
 289     # Selecting and de-selecting
 290     PlotController.SetCurrentCurve(crvID)
 291     PlotController.SetCurrentCurve(-1)
 292     self.assertTrue(self.areScreenshotEqual(tw))
 293
 294   def testSetCurrentPlotSet(self):
 295     tw = self.showTabWidget()
 296     psID = PlotController.AddPlotSet("tutu")
 297     PlotController.AddPlotSet("tata")
 298     PlotController.SetCurrentPlotSet(psID)
 299     self.assertTrue(self.areScreenshotEqual(tw))
 300     self.assertRaises(ValueError, PlotController.SetCurrentPlotSet, 124) # invalid ps_id
 301
 302   def testSetLabelX(self):
 303     tw = self.showTabWidget()
 304     ps_id = PlotController.AddPlotSet("My plotset")
 305     PlotController.SetXLabel("The X-s éà", ps_id)
 306     self.assertTrue(self.areScreenshotEqual(tw))
 307
 308   def testSetLabelY(self):
 309     tw = self.showTabWidget()
 310     ps_id = PlotController.AddPlotSet("My plotset")
 311     PlotController.SetYLabel("Tutu", ps_id)
 312     PlotController.SetYLabel("The Y-s uûàç", ps_id)
 313     self.assertTrue(self.areScreenshotEqual(tw))
 314
 315   def testSetPlotSetTitle(self):
 316     tw = self.showTabWidget()
 317     ps_id = PlotController.AddPlotSet("tutu")
 318     PlotController.AddPlotSet("tata")
 319     PlotController.SetPlotSetTitle("un titre àé", ps_id)
 320     PlotController.SetCurrentPlotSet(ps_id)
 321     self.assertTrue(self.areScreenshotEqual(tw))
 322
 323 #   def testToggleCurveBrowser(self):
 324 #     # hard to test ...
 325 #     raise NotImplementedError
 326
 327   def testPlotCurveFromTable(self):
 328     tw = self.showTabWidget()
 329     from curveplot.TableModel import TableModel
 330     t = TableModel(None)
 331     t.setTitle("coucou")
 332     t.addColumn([1.0,2.0,3.0,4.0])
 333     t.addColumn([1.0,2.0,3.0,4.0])
 334     t.addColumn([1.0,4.0,9.0,16.0])
 335     t.setColumnTitle(0, "X-s")
 336     t.setColumnTitle(1, "Identity")
 337     t.setColumnTitle(2, "Square")
 338     cont = PlotController.GetInstance()
 339     cont.plotCurveFromTable(t, y_col_index=1, append=False)
 340     cont.plotCurveFromTable(t, y_col_index=2, append=True)
 341     self.assertTrue(self.areScreenshotEqual(tw))
 342
 343   def testSettingsCurveColor(self):
 344     tw = self.showTabWidget()
 345     x, y = self.generateSine()
 346     crvID, _ = PlotController.AddCurve(x, y, append=False)
 347     PlotController.SetCurrentCurve(crvID)
 348     # Emulate changing the curve color from the settings box:
 349     dlg_test = PlotSettings()
 350     def fun():
 351       dlg_test.setRGB(0,0,0)
 352       dlg_test.showLegendCheckBox.setChecked(True)
 353       return True
 354     dlg_test.exec_ = fun
 355     t = list(PlotController.GetInstance()._curveTabsView._XYViews.items())
 356     t[0][1].onSettings(dlg_test=dlg_test)
 357     self.assertTrue(self.areScreenshotEqual(tw))
 358
 359   def testExtendCurve(self):
 360     tw = self.showTabWidget()
 361     x, y = self.generateSine()
 362     crvID, _ = PlotController.AddCurve(x, y, append=False)
 363     PlotController.SetCurrentCurve(crvID)
 364     PlotController.ExtendCurve(crvID, x+100.0, y*2.0)
 365     # Curve must remain blue, bold and with first marker:
 366     self.assertTrue(self.areScreenshotEqual(tw))
 367
 368   def testResetCurve(self):
 369     tw = self.showTabWidget()
 370     x, y = self.generateSine()
 371     crvID, _ = PlotController.AddCurve(x, y, append=False)
 372     PlotController.SetCurrentCurve(crvID)
 373     PlotController.ResetCurve(crvID)
 374     PlotController.ExtendCurve(crvID, x+100.0, y*x)
 375     # Curve must remain blue, bold and with first marker:
 376     self.assertTrue(self.areScreenshotEqual(tw))
 377
 378   def testSettingsCurveMarker(self):
 379     tw = self.showTabWidget()
 380     x, y = self.generateSine()
 381     crvID, _ = PlotController.AddCurve(x, y, append=False)
 382     PlotController.SetCurrentCurve(crvID)
 383     # Emulate changing the marker from the settings box:
 384     dlg_test = PlotSettings()
 385     def fun():
 386       dlg_test.markerCurve.setCurrentIndex(2)
 387       dlg_test.showLegendCheckBox.setChecked(True)
 388       return True
 389     dlg_test.exec_ = fun
 390     t = list(PlotController.GetInstance()._curveTabsView._XYViews.items())
 391     t[0][1].onSettings(dlg_test=dlg_test)
 392     self.assertTrue(self.areScreenshotEqual(tw))
 393
 394   def testSetCurveMarker(self):
 395     tw = self.showTabWidget()
 396     x, y = self.generateSine()
 397     crvID, _ = PlotController.AddCurve(x, y, append=False)
 398     PlotController.SetCurveMarker(crvID, "v")
 399     self.assertTrue(self.areScreenshotEqual(tw))
 400
 401   def testSetCurveLabel(self):
 402     tw = self.showTabWidget()
 403     x, y = self.generateSine()
 404     crvID, _ = PlotController.AddCurve(x, y, curve_label="titi", append=False)
 405     _, _ = PlotController.AddCurve(x, y, curve_label="toto", append=True)
 406     PlotController.SetCurrentCurve(crvID)
 407     PlotController.SetCurveLabel(crvID, "tata")
 408     self.assertTrue(self.areScreenshotEqual(tw))
 409
 410   def testToggleXLog(self):
 411     tw = self.showTabWidget()
 412     x, y = self.generateExp()
 413     _, psID = PlotController.AddCurve(x, y, curve_label="titi", append=False)
 414     PlotController.SetXLog(psID, True)
 415     PlotController.SetYSciNotation(psID, True)
 416     self.assertTrue(self.areScreenshotEqual(tw))
 417
 418   def testToggleYLog(self):
 419     tw = self.showTabWidget()
 420     x, y = self.generateExp()
 421     _, psID = PlotController.AddCurve(x, y, curve_label="titi", append=False)
 422     PlotController.SetYLog(psID, True)
 423     PlotController.SetYSciNotation(psID, True)
 424     self.assertTrue(self.areScreenshotEqual(tw))
 425
 426   def testSetXSciNotation(self):
 427     tw = self.showTabWidget()
 428     x, y = self.generateSine()
 429     _, psID = PlotController.AddCurve(x*1.0e6, y*1.0e6, curve_label="titi", append=False)
 430     PlotController.SetXSciNotation(psID, True)
 431     self.assertTrue(self.areScreenshotEqual(tw))
 432
 433   def testSetYSciNotation(self):
 434     tw = self.showTabWidget()
 435     x, y = self.generateSine()
 436     _, psID = PlotController.AddCurve(x*1.0e6, y*1.0e6, curve_label="titi", append=False)
 437     PlotController.SetYSciNotation(psID, True)
 438     self.assertTrue(self.areScreenshotEqual(tw))
 439
 440   def testRegisterCallback(self):
 441     global a_callb
 442     a_callb = 0
 443     def fun(crv_id):
 444       global a_callb
 445       a_callb = crv_id
 446     self.showTabWidget()
 447     x, y = self.generateExp()
 448     crvId, _ = PlotController.AddCurve(x, y)
 449     PlotController.RegisterCallback(fun)
 450     PlotController.SetCurrentCurve(crvId)
 451     self.assertEqual(crvId, a_callb)
 452
 453   def testDeleteCallback(self):
 454     global a_callb
 455     a_callb = 0
 456     def fun(crv_id):
 457       global a_callb
 458       a_callb = crv_id
 459     self.showTabWidget()
 460     x, y = self.generateExp()
 461     crvId, _ = PlotController.AddCurve(x, y)
 462     PlotController.RegisterCallback(fun)
 463     PlotController.ClearCallbacks()
 464     PlotController.SetCurrentCurve(crvId)
 465     _, _ = PlotController.AddCurve(x, y)
 466     self.assertEqual(crvId, a_callb)
 467
 468   def testAddCurveEmptyPs(self):
 469     """ Adding a curve when no ps was active was buggy """
 470     self.showTabWidget()
 471     x, y = self.generateSine()
 472     PlotController.AddPlotSet("toto")
 473     # No current plot set:
 474     PlotController.SetCurrentPlotSet(-1)
 475     # Should create a new plot set:
 476     PlotController.AddCurve(x, y, append=True)
 477     l, _ = PlotController.GetAllPlotSets()
 478     self.assertEqual(2, len(l))
 479
 480   def test_onCurrentCurveChange(self):
 481     self.showTabWidget()
 482     x, y = self.generateSine()
 483     crvID, _ = PlotController.AddCurve(x, y)
 484     PlotController.SetCurrentCurve(crvID)
 485     PlotController.DeleteCurve(crvID)
 486     crvID2, _ = PlotController.AddCurve(x, y)
 487     # was throwing:
 488     PlotController.SetCurrentCurve(crvID2)
 489
 490   def testSetLegendVisible(self):
 491     tw = self.showTabWidget()
 492     x, y = self.generateSine()
 493     _, psID = PlotController.AddCurve(x, y, curve_label="titi", append=False)
 494     PlotController.SetLegendVisible(psID, False)  # by default legend is always visible in the tests
 495     self.assertTrue(self.areScreenshotEqual(tw))
 496
 497   def testLockRepaint(self):
 498     tw = self.showTabWidget()
 499     x, y = self.generateSine()
 500     PlotController.LockRepaint()
 501     for i in range(10):
 502       _, psID = PlotController.AddCurve(x, y*float(i+1), append=True)
 503     PlotController.UnlockRepaint()
 504     self.assertTrue(self.areScreenshotEqual(tw))
 505
 506   def testDelPlotSetSelectPrev(self):
 507     """ When deleting a full plot set, the previous plot set should become active """
 508     self.showTabWidget()
 509     x, y = self.generateSine()
 510     _, psID0 = PlotController.AddCurve(x, y, append=True)  # creates a new plot set
 511     _, psID1 = PlotController.AddCurve(x, y, append=False)  # creates a new plot set
 512     PlotController.DeletePlotSet(psID1)
 513     PlotController.AddCurve(x, y, append=True)  # should NOT create a new plot set
 514     psID2 = PlotController.GetCurrentPlotSetID()
 515     self.assertEqual(psID0, psID2)
 516     l, _ = PlotController.GetAllPlotSets()
 517     self.assertEqual(1, len(l))
 518
 519 # Even if not in main:
 520 processDecorator(__name__)
 521
 522 if __name__ == "__main__":
 523   import unittest
 524   unittest.main()