pjs/extensions/python/xpcom/test/test_misc.py

278 строки
10 KiB
Python

# The contents of this file are subject to the Mozilla Public License Version
# 1.1 (the "License"); you may not use this file except in compliance with the
# License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
#
# Software distributed under the License is distributed on an "AS IS" basis,
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
# the specific language governing rights and limitations under the License.
#
# The Original Code is the Python XPCOM language bindings.
#
# The Initial Developer of the Original Code is ActiveState Tool Corp.
# Portions created by ActiveState Tool Corp. are Copyright (C) 2000, 2001
# ActiveState Tool Corp. All Rights Reserved.
#
# Contributor(s): Mark Hammond <MarkH@ActiveState.com> (original author)
#
import xpcom
import xpcom.client
import xpcom.server
import xpcom._xpcom
import xpcom.components
import string
import traceback, getopt, sys
verbose_level = 0
def _check(condition, error = "test failed!"):
if not condition:
print error
class SampleComponentsMissing(Exception):
pass
def DumpEveryInterfaceUnderTheSun():
"Dump every interface under the sun!"
import xpcom, xpcom.xpt, xpcom._xpcom
iim = xpcom._xpcom.XPTI_GetInterfaceInfoManager()
print "Dumping every interface I can find - please wait"
if verbose_level == 0:
print "(verbosity is turned off, so I'm not actually going to print them)"
enum = iim.EnumerateInterfaces()
rc = enum.First()
num = 0
while rc==0:
item = enum.CurrentItem(xpcom._xpcom.IID_nsIInterfaceInfo)
try:
iid = item.GetIID()
except xpcom.COMException:
if verbose_level:
print "Can't dump", item
continue # Dont bother dumping this.
interface = xpcom.xpt.Interface(iid)
num = num + 1
text = interface.Describe()
if verbose_level:
print text
rc = enum.Next()
if num < 200:
print "Only found", num, "interfaces - this seems unusually low!"
print "Finished dumping all the interfaces."
def EnumContractIDs():
"""Enumerate all the ContractIDs registered"""
cm = xpcom._xpcom.NS_GetGlobalComponentManager()
enum = cm.EnumerateContractIDs()
rc = enum.First()
n = 0
while rc == 0:
n = n + 1
if verbose_level:
print "ContractID:", enum.CurrentItem()
rc = enum.Next()
if n < 200:
print "Only found", n, "ContractIDs - this seems unusually low!"
print "Enumerated all the ContractIDs"
def TestSampleComponent(test_flat = 0):
"""Test the standard Netscape 'sample' sample"""
# contractid = "mozilla.jssample.1" # the JS version
contractid = "@mozilla.org/sample;1" # The C++ version.
try:
c = xpcom.components.classes[contractid].createInstance()
except xpcom.COMException:
raise SampleComponentsMissing
if not test_flat:
c = c.queryInterface(xpcom.components.interfaces.nsISample)
_check(c.value == "initial value")
c.value = "new value"
_check(c.value == "new value")
c.poke("poked value")
_check(c.value == "poked value")
c.writeValue("Python just poked:")
if test_flat:
print "The netscape sample worked with interface flattening!"
else:
print "The netscape sample worked!"
def TestSampleComponentFlat():
"""Test the standard Netscape 'sample' sample using interface flattening"""
TestSampleComponent(1)
def TestHash():
"Test that hashing COM objects works"
d = {}
contractid = "@mozilla.org/sample;1" # The C++ version.
try:
c = xpcom.components.classes[contractid].createInstance() \
.queryInterface(xpcom.components.interfaces.nsISample)
except xpcom.COMException:
raise SampleComponentsMissing
d[c] = None
if not d.has_key(c):
raise RuntimeError, "Can't get the exact same object back!"
if not d.has_key(c.queryInterface(xpcom.components.interfaces.nsISupports)):
raise RuntimeError, "Can't get back as nsISupports"
# And the same in reverse - stick an nsISupports in, and make sure an explicit interface comes back.
d = {}
contractid = "@mozilla.org/sample;1" # The C++ version.
c = xpcom.components.classes[contractid].createInstance() \
.queryInterface(xpcom.components.interfaces.nsISupports)
d[c] = None
if not d.has_key(c):
raise RuntimeError, "Can't get the exact same object back!"
if not d.has_key(c.queryInterface(xpcom.components.interfaces.nsISample)):
raise RuntimeError, "Can't get back as nsISupports"
print "xpcom object hashing tests seemed to work"
def TestIIDs():
"Do some basic IID semantic tests."
iid_str = "{7ee4bdc6-cb53-42c1-a9e4-616b8e012aba}"
IID = xpcom._xpcom.IID
_check(IID(iid_str)==IID(iid_str), "IIDs with identical strings dont compare!")
_check(hash(IID(iid_str))==hash(IID(iid_str)), "IIDs with identical strings dont have identical hashes!")
_check(IID(iid_str)==IID(iid_str.upper()), "IIDs with case-different strings dont compare!")
_check(hash(IID(iid_str))==hash(IID(iid_str.upper())), "IIDs with case-different strings dont have identical hashes!")
# If the above work, this shoud too, but WTF
dict = {}
dict[IID(iid_str)] = None
_check(dict.has_key(IID(iid_str)), "hashes failed in dictionary")
_check(dict.has_key(IID(iid_str.upper())), "uppercase hash failed in dictionary")
print "The IID tests seemed to work"
def _doTestRepr(progid, interfaces):
try:
ob = xpcom.components.classes[progid].createInstance()
except xpcom.COMException, details:
print "Could not test repr for progid '%s' - %s" % (progid, details)
return 0
ok = 1
if repr(ob).find(progid) < 0:
print "The contract ID '%s' did not appear in the object repr '%r'" % (progid, ob)
ok = 0
for interface_name in interfaces.split():
if repr(ob).find(interface_name) < 0:
print "The interface '%s' did not appear in the object repr '%r'" % (interface_name, ob)
ok = 0
return ok
def TestRepr():
"Test that the repr of our objects works as we expect."
ok = 1
ok = _doTestRepr("Python.TestComponent", "nsIPythonTestInterfaceDOMStrings nsIPythonTestInterfaceExtra nsIPythonTestInterface") and ok
# eeek - JS doesn't automatically provide class info yet :(
#ok = _doTestRepr("@mozilla.org/jssample;1", "nsISample") and ok
ok = _doTestRepr("@mozilla.org/sample;1", "nsISample") and ok
print "The object repr() tests seemed to have",
if ok: print "worked"
else: print "failed"
def TestUnwrap():
"Test the unwrap facilities"
# First test that a Python object can be unwrapped.
ob = xpcom.components.classes["Python.TestComponent"].createInstance()
pyob = xpcom.server.UnwrapObject(ob)
if not str(pyob).startswith("<component:py_test_component.PythonTestComponent"):
print "It appears we got back an invalid unwrapped object", pyob
# Test that a non-Python implemented object can NOT be unwrapped.
try:
ob = xpcom.components.classes["@mozilla.org/sample;1"].createInstance()
except xpcom.COMException:
raise SampleComponentsMissing
try:
pyob = xpcom.server.UnwrapObject(ob)
print "Eeek - was able to unwrap a C++ implemented component!!"
except ValueError:
pass
print "The unwrapping tests seemed to work"
def usage(tests):
import os
print "Usage: %s [-v] [Test ...]" % os.path.basename(sys.argv[0])
print " -v : Verbose - print more information"
print "where Test is one of:"
for t in tests:
print t.__name__,":", t.__doc__
print
print "If not tests are specified, all tests are run"
sys.exit(1)
def main():
tests = []
args = []
for ob in globals().values():
if type(ob)==type(main) and ob.__doc__:
tests.append(ob)
# Ensure consistent test order.
tests.sort(lambda a,b:cmp(a.__name__, b.__name__))
if __name__ == '__main__': # Only process args when not running under the test suite!
opts, args = getopt.getopt(sys.argv[1:], "hv")
for opt, val in opts:
if opt=="-h":
usage(tests)
if opt=="-v":
global verbose_level
verbose_level = verbose_level + 1
if len(args)==0:
print "Running all tests - use '-h' to see command-line options..."
dotests = tests
else:
dotests = []
for arg in args:
for t in tests:
if t.__name__==arg:
dotests.append(t)
break
else:
print "Test '%s' unknown - skipping" % arg
if not len(dotests):
print "Nothing to do!"
usage(tests)
reportedSampleMissing = 0
for test in dotests:
try:
test()
except SampleComponentsMissing:
if not reportedSampleMissing:
print "***"
print "*** This test requires an XPCOM sample component,"
print "*** which does not exist. To build this test, you"
print "*** should change to the 'mozilla/xpcom/sample' directory,"
print "*** and execute the standard Mozilla build process"
if sys.platform.startswith("win"):
print "*** ie, 'nmake -f makefile.win'"
else:
print "*** ie, 'make'"
print "*** then run this test again."
print "***"
print "*** If this is the only failure messages from this test,"
print "*** you can almost certainly ignore this message, and assume"
print "*** that PyXPCOM is working correctly."
print "***"
reportedSampleMissing = 1
except:
print "Test %s failed" % test.__name__
traceback.print_exc()
# regrtest doesnt like if __name__=='__main__' blocks - it fails when running as a test!
main()
if __name__=='__main__':
# We can only afford to shutdown if we are truly running as the main script.
# (xpcom can't handle shutdown/init pairs)
xpcom._xpcom.NS_ShutdownXPCOM()
ni = xpcom._xpcom._GetInterfaceCount()
ng = xpcom._xpcom._GetGatewayCount()
if ni or ng:
print "********* WARNING - Leaving with %d/%d objects alive" % (ni,ng)