Python AT.AT類代碼示例

    def test_AT_markUpToDate(self):
        """ test AT isstale(), markUpToDate() """
        at = AT({'alias': 'n'})
        self.assertTrue(at.isstale())

        at.markUpToDate()
        self.assertFalse(at.isstale())

    def test_baseDir(self):
        at = AT({'alias': 'g'})
        basedir = at.baseDir("/tmp/")
        if(self.verbose):
            print "\nAT Class base directory", basedir
 
        self.assertEqual(basedir, "/tmp/")

    def test_FM_add_remove(self):
        """ test FM add() and remove() """
        fm = admit.Flow()

        # connection map diagram: a0->a1->a2->a3
        # structure of an element of the triple-nested dictionary of connmap:
        #     src_taskid: {des_taskid: {des_bdpport: (si,sp, di,dp)}}

        self.correct_connmap = {0: {1: {0: (0, 0, 1, 0)}},
                                1: {2: {0: (1, 0, 2, 0)}},
                                2: {3: {0: (2, 0, 3, 0)}}}
        tasklist= list()
        for i in range(0,4):
            a = AT()
            a._baseDir = admit.Project.baseDir
            # Each AT needs an output BDP
            b = File_BDP();
            b.type="TEST_BDP%d" % i
            a._bdp_out.append( b )
            tasklist.append( a )
            if i == 0:
                taskid = fm.add( tasklist[i] )
            else:
                taskid = fm.add( tasklist[i], [(tasklist[i-1]._taskid,0)])
        self.assertEqual(fm._connmap, self.correct_connmap)

        # Remove a2 and its downstream from a0->a1->a2->a3
        # The result diagram is a0->a1
        self.correct_connmap = {0: {1: {0: (0, 0, 1, 0)}}}
        fm.remove(2)
        self.assertEqual(fm._connmap, self.correct_connmap)

 def test_AT_loggername(self):
     """ test AT set/getloggername() """
     at = AT({'alias': 'log'})
     name = "admit_logger"
     at.setloggername(name)
     ret = at.getloggername()
     self.assertEqual(ret, name)

 def test_AT_baseDir(self):
     """ test AT baseDir(), dir() """
     at = AT({'alias': 'g'})
     basedir = at.baseDir("/tmp/")
     self.assertEqual(basedir, "/tmp/")
     fullpath = at.dir("test.test")
     self.assertEqual(fullpath, "/tmp/test.test")

    def test_len2(self):
        at = AT({'alias': 'c'})
        tuple = at.len2() # bdp_in and bdp_out tuple
        if(self.verbose):
            print "\nAT Class (bdp_in, bdp_out):", tuple
 
        self.assertEqual(tuple, (0,0))  ## should be (0,0)

    def test_effectivelevel(self):
        at = AT({'alias': 'f'})
        at.seteffectivelevel(40)
        level = at.geteffectivelevel()
        if(self.verbose):
            print "\nAT Class effective logging level", level
 
        self.assertEqual(level, 40)

    def test_dir(self):
        at = AT({'alias': 'h'})
        basedir = at.baseDir("/tmp/")
        fullpath = at.dir("test.test")
        if(self.verbose):
            print "\nAT Fullpath:", fullpath
 
        self.assertEqual(fullpath, "/tmp/test.test")

    def test_enabled(self):
        at = AT({'alias': 'm'})
        at.enabled(False)
        after = at._enabled
        if(self.verbose):
            print "\nAT Class state _enabled", after
 
        self.assertEqual(after, False)

    def test_markChanged(self):
        at = AT({'alias': 'p'})
        at.markChanged()
        state = at._stale
        if(self.verbose):
            print "\nAT Class state _stale", state
 
        self.assertEqual(state, True)

    def test_AT_isAutoAlias(self):
        """ test AT isAutoAlias() """
        at = AT()
        self.assertTrue(at.isAutoAlias())

        at = AT({'alias': 'alias_test', 'test_key': 'at_test'})
        ret = at.isAutoAlias(withEmpty=False)
        self.assertFalse(ret)

    def test_isAutoAlias(self):
        at = AT()
        ret = at.isAutoAlias()
        self.assertTrue(ret)  # should be true

        at = AT({'alias': 'alias_test', 'test_key': 'at_test'})
        ret = at.isAutoAlias(withEmpty=False)
        self.assertFalse(ret)  # should be false

 def test_AT_logginglevel(self):
     """ test AT setlogginglevel and getlogginglevel methods """
     # CRITICAL    50
     at = AT({'alias': 'e'})
     at.setlogginglevel(50)
     level = at.getlogginglevel()
     self.assertEqual(level, 50)
     self.assertEqual(level, logging.CRITICAL)

 def __init__(self,**keyval):
     keys = {
            }
     AT.__init__(self,keys,keyval)
     self._version = "0.0.1"
     self.set_bdp_in([(Image_BDP,1,bt.REQUIRED),
                      (CubeStats_BDP,1,bt.OPTIONAL)])
     self.set_bdp_out([])

 def __init__(self, **keyval):
     keys = {
         "basename"   : "",     # defaults to BDP derived
     }
     AT.__init__(self,keys,keyval)
     self._version = "1.0.0"
     self.set_bdp_in([(Image_BDP,     1, bt.REQUIRED)])
     self.set_bdp_out([])