Python TestUtils.runTests方法代码示例

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
def runTestSuite():
    """
    Transfer function for setup.py script ro-manager-test
    """
    base = os.path.dirname(__file__)
    #print "Run test suite assuming base path "+base
    sys.path.insert(0, os.path.normpath(base+"/..") )
    sys.path.insert(0, os.path.normpath(base+"/../..") )
    sys.path.insert(0, os.path.normpath(base+"/../../iaeval/test") )
    sys.path.insert(0, os.path.normpath(base+"/../../sync/test") )
    #print "Path: "+repr(sys.path)
    TestUtils.runTests("TestAll", getTestSuite, sys.argv)
    return 0

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
    select  is one of the following:
            "unit"      return suite of unit tests only
            "component" return suite of unit and component tests
            "all"       return suite of unit, component and integration tests
            "pending"   return suite of pending tests
            name        a single named test to be run
    """
    testdict = {
        "unit": 
            [
              "GetEvents"            
            , "DecodeMessage"
            , "DecodeMultiple"
            , "DecodeDirtyMessage"
            ],
        "component":
            [ "testDummy"
            ],
        "integration":
            [ "testDummy"
            ],
        "pending":
            [ "testDummy"
            ]
        }
    return TestUtils.getTestSuite(TestSkyDrivers, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
    TestUtils.runTests("TestSkyDrivers.log", getTestSuite, sys.argv)

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
            , "testUserACreateHTTPCollabDeleteHTTP"       
            # Test RG Leader's access permissions on files in User A's Private area     
            , "testRGLeaderCreateCIFSInUserA"
            , "testUserACreateCIFSRGLeaderReadCIFS"
            , "testUserACreateCIFSRGLeaderUpdateCIFS"
            , "testUserACreateCIFSRGLeaderDeleteCIFS"
            , "testRGLeaderCreateHTTPInUserA"
            , "testUserACreateHTTPRGLeaderReadHTTP"
            , "testUserACreateHTTPRGLeaderUpdateHTTP"
            , "testUserACreateHTTPRGLeaderDeleteHTTP"
            ],
        "component":
            [ "testComponents"
            ],
        "integration":
            [ "testIntegration"
            ],
        "pending":
            [ "testPending"
            ]
        }
    return TestUtils.getTestSuite(TestFileCommonArea, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
    TestUtils.runTests("TestFileCommonArea.log", getTestSuite, sys.argv)

# End.

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
# Assemble test suite

from MiscLib import TestUtils

def getTestSuite(select="unit"):
	testdict = {
		"unit": 
			[ 
			],
		"component":
			[ "testMe"
			],
		"integration":
			[ "testIntegration"
			],
		"pending":
			[ "testPending"
			]
		}
	return TestUtils.getTestSuite(OXDSDataset, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
	TestUtils.runTests("OXDSDataset", getTestSuite, sys.argv)

# End.


                   

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
    Get test suite

    select  is one of the following:
            "unit"      return suite of unit tests only
            "component" return suite of unit and component tests
            "all"       return suite of unit, component and integration tests
            "pending"   return suite of pending tests
            name        a single named test to be run
    """
    testdict = {
        "zzunit": 
            [ "testDummy"
            ],
        "zzcomponent":
            [ "testDummy"
            ],
        "integration":
            [ "testSend"
            , "testListen"
            ],
        "zzpending":
            [ "testDummy"
            ]
        }
    return TestUtils.getTestSuite(TestCounters, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
    TestUtils.runTests("TestCounters.log", getTestSuite, sys.argv)

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
            name        a single named test to be run
    """
    testdict = {
        "unit":
            [ "testUnits"
            , "testNull"
            , "testLink"
            , "testLinkType"
            , "testLinkCreated"
            , "testLinkRdfType"
            , "testLinkUnknownUri"
            , "testLinkWithGraph"
            , "testLinkWithNotExistentGraph"
            ],
        "component":
            [ "testComponents"
            ],
        "integration":
            [ "testIntegration"
            ],
        "pending":
            [ "testPending"
            ]
        }
    return TestUtils.getTestSuite(TestLinks, testdict, select=select)

if __name__ == "__main__":
    TestUtils.runTests("TestLinks.log", getTestSuite, sys.argv)

# End.

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
            , "testMultipleFilesLocal"
            , "testMultipleFilesLocalCleanUp"
            , "testMultipleFilesAbsoluteLocal"
            , "testSingleDirectoryAbsoluteLocal"
            , "testSingleDirectoryRecursiveAbsoluteLocal"
            , "testMultipleDirectorysLocal"
            , "testMixedDataSetLocal"
            , "testMultipleFileChangeLocal"
            , "testMixedDataSetChangeLocal"
            , "testMultipleFileDeltaLocal"
            , "testMixedDataSetDeltaLocal"
            , "testCommandLine"
            ],
        "zzcomponent":
            [ "testComponents"
            ],
        "integration":
            [ "testSingleDirectoryHttpS"
             ,"testSingleDirectoryFtp"
            ],
        "zzpending":
            [ "testPending"
            ]
        }
    return TestUtils.getTestSuite(TestBackupHandler, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
    TestUtils.runTests("TestBackupHandler.log", getTestSuite, sys.argv)

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
            "all"       return suite of unit, component and integration tests
            "pending"   return suite of pending tests
            name        a single named test to be run
    """
    testdict = {
        "unit": 
            [ "testUnits"
            , "testNull"
            ,"testDatasetSubmission"
            ],
        "component":
            [ "testComponents"
            ],
        "integration":
            [ "testIntegration"
            ],
        "pending":
            [ 

            ]
        }
    return TestUtils.getTestSuite(TestDatasetSubmission, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
    TestUtils.runTests("TestDatasetSubmission", getTestSuite, sys.argv)

# End.

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
            "component"   return suite of component tests
            "integration" return suite of integration tests
            "all"         return suite of unit and component tests
            "pending"     return suite of pending tests
            name          a single named test to be run
    """
    testdict = {
        "unit": 
            [ "testUnits"
            ],
        "component":
            [ "testComponents"
            ],
        "integration":
            [ "testIntegration"
            , "testGetHomepage"
            , "testGetStatus"
            , "testGetConfig"
            , "testCommand"
            ],
        "pending":
            [ "testPending"
            ]
        }
    return TestUtils.getTestSuite(TestWbAccess, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
    TestUtils.runTests("TestWbAccess.log", getTestSuite, sys.argv)

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
            "component"   return suite of component tests
            "integration" return suite of integration tests
            "all"         return suite of unit and component tests
            "pending"     return suite of pending tests
            name          a single named test to be run
    """
    testdict = {
        "unit": 
            [ "testUnits"
            , "testOrigConfig"
            , "testMakeConfig"
            , "testCopyConfig"
            , "testSetConfig"
            ],
        "component":
            [ "testComponents"
            ],
        "integration":
            [ "testIntegration"
            ],
        "pending":
            [ "testPending"
            ]
        }
    return TestUtils.getTestSuite(TestWbConfigEdit, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
    TestUtils.runTests("TestWbConfigEdit.log", getTestSuite, sys.argv)

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
            "pending"   return suite of pending tests
            name        a single named test to be run
    """
    testdict = {
        "unit": 
            [ "testUnits"
            ],
        "component":
            [ "testComponents"
            ],
        "integration":
            [ "testIntegration"
            , "testTestEventHTTPClientIntro"
            , "testSubscriptionForwarding1"
            , "testSubscriptionForwarding2"
            , "testSubscriptionForwarding3"
            , "testSubscriptionForwarding4"
            , "testTestEventHTTPClientDone"
            ],
        "pending":
            [ "testPending"
            ]
        }
    return TestUtils.getTestSuite(TestEventHTTPClient, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
    TestUtils.runTests("TestEventHTTPClient.log", getTestSuite, sys.argv)

# End.

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
            ],
        "integration":
            [ "testIntegration"
            , "verifyVersion"
            , "verifyName"
            , "verifyNodeNumber"
            , "verifyFadeRate"
            , "verifyIp"
            , "verifyMacAddress"
            , "verifyRotary"
            , "verifyDwellConfiguration"
            , "verifySetPointConfiguration"
            , "verifyDoNameConfiguration"
            , "verifyAoNameConfiguration"
            , "verifyDigitalIn"
            , "verifyTemperatures"
            , "verifyAnalogueIn"
            , "verifySchedules"
            , "verifyScenes"
            ],
        "pending":
            [ "testPending"
            ]
        }
    return TestUtils.getTestSuite(TestWb6Config, testdict, select=select)

# Run unit tests directly from command line
if __name__ == "__main__":
    TestUtils.runTests("TestWb6Config.log", getTestSuite, sys.argv)

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]

def getTestSuite(select="unit"):
    """
    Get test suite

    select  is one of the following:
            "unit"      return suite of unit tests only
            "component" return suite of unit and component tests
            "all"       return suite of unit, component and integration tests
            "pending"   return suite of pending tests
             name       a single named test to be run
    """
    testdict = {
        "unit": [
            "testReadMetadata",
            "testUpdateMetadata",
            "testGetElementValuesFromManifest",
            "testGetDictionaryFromManifest",
        ],
        "component": [],  # "testComponents"
        "integration": [],  # "testIntegration"
        "pending": [],  # "testPending"
    }
    return TestUtils.getTestSuite(TestMetadataMerging, testdict, select=select)


if __name__ == "__main__":
    TestConfig.setDatasetsBaseDir(".")
    TestUtils.runTests("TestMetadataMerging.log", getTestSuite, sys.argv)

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
    Get test suite

    select  is one of the following:
            "unit"      return suite of unit tests only
            "component" return suite of unit and component tests
            "all"       return suite of unit, component and integration tests
            "pending"   return suite of pending tests
            name        a single named test to be run
    """
    testdict = {
        "unit":
            [ #"testUnits"
              "testAdmiralModifyUserDetails"
            ],
        "component":
            [ #"testComponents"
            ],
        "integration":
            [ #"testIntegration"
            ],
        "pending":
            [ #"testPending"
            ]
        }
    return TestUtils.getTestSuite(TestAdminInterfaceRestfulAPIs, testdict, select=select)

if __name__ == "__main__":
    #logging.basicConfig(level=logging.DEBUG)
    TestUtils.runTests("TestAdminInterfaceRestfulAPIs.log", getTestSuite, sys.argv)
    #runner = unittest.TextTestRunner()
    #runner.run(getTestSuite())

# 需要导入模块: from MiscLib import TestUtils [as 别名]
# 或者: from MiscLib.TestUtils import runTests [as 别名]
    select  is one of the following:
            "unit"      return suite of unit tests only
            "component" return suite of unit and component tests
            "all"       return suite of unit, component and integration tests
            "pending"   return suite of pending tests
            name        a single named test to be run
    """
    testdict = {
        "unit":
            [ "testUnits"
            , "testNull"
            , "testTripleExists"
            , "testSimpleJSONDecode"
            ],
        "component":
            [ "testComponents"
            ],
        "integration":
            [ "testIntegration"
            ],
        "pending":
            [ "testPending"
            ]
        }
    return TestUtils.getTestSuite(SparqlQueryTestCase, testdict, select=select)

if __name__ == "__main__":
    TestUtils.runTests("SparqlQueryTestCase", getTestSuite, sys.argv)

# End.