263 lines
8.6 KiB
Python
263 lines
8.6 KiB
Python
import sys, os, string, re
|
|
import pythoncom
|
|
import win32com.client
|
|
from win32com.test.util import CheckClean, TestCase, \
|
|
CapturingFunctionTestCase, ShellTestCase, \
|
|
TestLoader, TestRunner, RegisterPythonServer
|
|
import traceback
|
|
import getopt
|
|
|
|
import unittest
|
|
|
|
verbosity = 1 # default unittest verbosity.
|
|
|
|
try:
|
|
this_file = __file__
|
|
except NameError:
|
|
this_file = sys.argv[0]
|
|
|
|
def GenerateAndRunOldStyle():
|
|
from . import GenTestScripts
|
|
GenTestScripts.GenerateAll()
|
|
try:
|
|
pass #
|
|
finally:
|
|
GenTestScripts.CleanAll()
|
|
|
|
def CleanGenerated():
|
|
import win32com, shutil
|
|
if os.path.isdir(win32com.__gen_path__):
|
|
if verbosity > 1:
|
|
print("Deleting files from %s" % (win32com.__gen_path__))
|
|
shutil.rmtree(win32com.__gen_path__)
|
|
import win32com.client.gencache
|
|
win32com.client.gencache.__init__() # Reset
|
|
|
|
def RemoveRefCountOutput(data):
|
|
while 1:
|
|
last_line_pos = data.rfind("\n")
|
|
if not re.match("\[\d+ refs\]", data[last_line_pos+1:]):
|
|
break
|
|
if last_line_pos < 0:
|
|
# All the output
|
|
return ''
|
|
data = data[:last_line_pos]
|
|
|
|
return data
|
|
|
|
def ExecuteSilentlyIfOK(cmd, testcase):
|
|
f = os.popen(cmd)
|
|
data = f.read().strip()
|
|
rc = f.close()
|
|
if rc:
|
|
print(data)
|
|
testcase.fail("Executing '%s' failed (%d)" % (cmd, rc))
|
|
# for "_d" builds, strip the '[xxx refs]' line
|
|
return RemoveRefCountOutput(data)
|
|
|
|
class PyCOMTest(TestCase):
|
|
no_leak_tests = True # done by the test itself
|
|
def testit(self):
|
|
# Check that the item is registered, so we get the correct
|
|
# 'skipped' behaviour (and recorded as such) rather than either
|
|
# error or silence due to non-registration.
|
|
RegisterPythonServer(os.path.join(os.path.dirname(__file__), '..', "servers", "test_pycomtest.py"),
|
|
"Python.Test.PyCOMTest")
|
|
|
|
# Execute testPyComTest in its own process so it can play
|
|
# with the Python thread state
|
|
fname = os.path.join(os.path.dirname(this_file), "testPyComTest.py")
|
|
cmd = '%s "%s" -q 2>&1' % (sys.executable, fname)
|
|
data = ExecuteSilentlyIfOK(cmd, self)
|
|
|
|
class PippoTest(TestCase):
|
|
def testit(self):
|
|
# Check we are registered before spawning the process.
|
|
from win32com.test import pippo_server
|
|
RegisterPythonServer(pippo_server.__file__, "Python.Test.Pippo")
|
|
|
|
python = sys.executable
|
|
fname = os.path.join(os.path.dirname(this_file), "testPippo.py")
|
|
cmd = '%s "%s" 2>&1' % (python, fname)
|
|
ExecuteSilentlyIfOK(cmd, self)
|
|
|
|
# This is a list of "win32com.test.???" module names, optionally with a
|
|
# function in that module if the module isn't unitest based...
|
|
unittest_modules = [
|
|
# Level 1 tests.
|
|
"""testIterators testvbscript_regexp testStorage
|
|
testStreams testWMI policySemantics testShell testROT
|
|
testAXScript testxslt testDictionary testCollections
|
|
testServers errorSemantics.test testvb testArrays
|
|
testClipboard testMarshal
|
|
""".split(),
|
|
# Level 2 tests.
|
|
"""testMSOffice.TestAll testMSOfficeEvents.test testAccess.test
|
|
testExplorer.TestAll testExchange.test
|
|
""".split(),
|
|
# Level 3 tests.
|
|
"""testmakepy.TestAll
|
|
""".split()
|
|
]
|
|
|
|
# A list of other unittest modules we use - these are fully qualified module
|
|
# names and the module is assumed to be unittest based.
|
|
unittest_other_modules = [
|
|
# Level 1 tests.
|
|
"""win32com.directsound.test.ds_test
|
|
""".split(),
|
|
# Level 2 tests.
|
|
[],
|
|
# Level 3 tests.
|
|
[]
|
|
]
|
|
|
|
|
|
output_checked_programs = [
|
|
# Level 1 tests.
|
|
[
|
|
("cscript.exe /nologo //E:vbscript testInterp.vbs", "VBScript test worked OK"),
|
|
("cscript.exe /nologo //E:vbscript testDictionary.vbs",
|
|
"VBScript has successfully tested Python.Dictionary"),
|
|
],
|
|
# Level 2 tests.
|
|
[
|
|
],
|
|
# Level 3 tests
|
|
[
|
|
],
|
|
]
|
|
|
|
custom_test_cases = [
|
|
# Level 1 tests.
|
|
[
|
|
PyCOMTest,
|
|
PippoTest,
|
|
],
|
|
# Level 2 tests.
|
|
[
|
|
],
|
|
# Level 3 tests
|
|
[
|
|
],
|
|
]
|
|
|
|
def get_test_mod_and_func(test_name, import_failures):
|
|
if test_name.find(".")>0:
|
|
mod_name, func_name = test_name.split(".")
|
|
else:
|
|
mod_name = test_name
|
|
func_name = None
|
|
fq_mod_name = "win32com.test." + mod_name
|
|
try:
|
|
__import__(fq_mod_name)
|
|
mod = sys.modules[fq_mod_name]
|
|
except:
|
|
import_failures.append((mod_name, sys.exc_info()[:2]))
|
|
return None, None
|
|
if func_name is None:
|
|
func = None
|
|
else:
|
|
func = getattr(mod, func_name)
|
|
return mod, func
|
|
|
|
# Return a test suite all loaded with the tests we want to run
|
|
def make_test_suite(test_level = 1):
|
|
suite = unittest.TestSuite()
|
|
import_failures = []
|
|
loader = TestLoader()
|
|
for i in range(testLevel):
|
|
for mod_name in unittest_modules[i]:
|
|
mod, func = get_test_mod_and_func(mod_name, import_failures)
|
|
if mod is None:
|
|
continue
|
|
if func is not None:
|
|
test = CapturingFunctionTestCase(func, description=mod_name)
|
|
else:
|
|
if hasattr(mod, "suite"):
|
|
test = mod.suite()
|
|
else:
|
|
test = loader.loadTestsFromModule(mod)
|
|
assert test.countTestCases() > 0, "No tests loaded from %r" % mod
|
|
suite.addTest(test)
|
|
for cmd, output in output_checked_programs[i]:
|
|
suite.addTest(ShellTestCase(cmd, output))
|
|
|
|
for test_class in custom_test_cases[i]:
|
|
suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(test_class))
|
|
# other "normal" unittest modules.
|
|
for i in range(testLevel):
|
|
for mod_name in unittest_other_modules[i]:
|
|
try:
|
|
__import__(mod_name)
|
|
except:
|
|
import_failures.append((mod_name, sys.exc_info()[:2]))
|
|
continue
|
|
|
|
mod = sys.modules[mod_name]
|
|
if hasattr(mod, "suite"):
|
|
test = mod.suite()
|
|
else:
|
|
test = loader.loadTestsFromModule(mod)
|
|
assert test.countTestCases() > 0, "No tests loaded from %r" % mod
|
|
suite.addTest(test)
|
|
|
|
return suite, import_failures
|
|
|
|
def usage(why):
|
|
print(why)
|
|
print()
|
|
print("win32com test suite")
|
|
print("usage: testall [-v] test_level")
|
|
print(" where test_level is an integer 1-3. Level 1 tests are quick,")
|
|
print(" level 2 tests invoke Word, IE etc, level 3 take ages!")
|
|
sys.exit(1)
|
|
|
|
if __name__=='__main__':
|
|
try:
|
|
opts, args = getopt.getopt(sys.argv[1:], "v")
|
|
except getopt.error as why:
|
|
usage(why)
|
|
for opt, val in opts:
|
|
if opt=='-v':
|
|
verbosity += 1
|
|
testLevel = 1 # default to quick test
|
|
test_names = []
|
|
for arg in args:
|
|
try:
|
|
testLevel = int(arg)
|
|
if testLevel < 0 or testLevel > 3:
|
|
raise ValueError("Only levels 1-3 are supported")
|
|
except ValueError:
|
|
test_names.append(arg)
|
|
if test_names:
|
|
usage("Test names are not supported yet")
|
|
CleanGenerated()
|
|
|
|
suite, import_failures = make_test_suite(testLevel)
|
|
if verbosity:
|
|
if hasattr(sys, "gettotalrefcount"):
|
|
print("This is a debug build - memory leak tests will also be run.")
|
|
print("These tests may take *many* minutes to run - be patient!")
|
|
print("(running from python.exe will avoid these leak tests)")
|
|
print("Executing level %d tests - %d test cases will be run" \
|
|
% (testLevel, suite.countTestCases()))
|
|
if verbosity==1 and suite.countTestCases() < 70:
|
|
# A little row of markers so the dots show how close to finished
|
|
print('|' * suite.countTestCases())
|
|
testRunner = TestRunner(verbosity=verbosity)
|
|
testResult = testRunner.run(suite)
|
|
if import_failures:
|
|
testResult.stream.writeln("*** The following test modules could not be imported ***")
|
|
for mod_name, (exc_type, exc_val) in import_failures:
|
|
desc = '\n'.join(traceback.format_exception_only(exc_type, exc_val))
|
|
testResult.stream.write("%s: %s" % (mod_name, desc))
|
|
testResult.stream.writeln("*** %d test(s) could not be run ***" % len(import_failures))
|
|
|
|
# re-print unit-test error here so it is noticed
|
|
if not testResult.wasSuccessful():
|
|
print("*" * 20, "- unittest tests FAILED")
|
|
|
|
CheckClean()
|
|
pythoncom.CoUninitialize()
|
|
CleanGenerated()
|