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