View
2 twisted/test/test_rebuild.py
@@ -121,7 +121,7 @@ def testComponentInteraction(self):
# Test that a duplicate registerAdapter is not allowed
from twisted.python import components
self.failUnlessRaises(ValueError, components.registerAdapter,
self.assertRaises(ValueError, components.registerAdapter,
crash_test_dummy.XA, crash_test_dummy.X,
crash_test_dummy.IX)
View
4 twisted/test/test_roots.py
@@ -50,7 +50,7 @@ def nameConstraint(self, name):
return (name == 'x')
c = const()
self.assertEqual(c.putEntity('x', 'test'), None)
self.failUnlessRaises(roots.ConstraintViolation,
self.assertRaises(roots.ConstraintViolation,
c.putEntity, 'y', 'test')
@@ -59,5 +59,5 @@ def testHomogenous(self):
h.entityType = int
h.putEntity('a', 1)
self.assertEqual(h.getStaticEntity('a'),1 )
self.failUnlessRaises(roots.ConstraintViolation,
self.assertRaises(roots.ConstraintViolation,
h.putEntity, 'x', 'y')
View
4 twisted/test/test_shortcut.py
@@ -19,7 +19,7 @@ def testCreate(self):
s1=shortcut.Shortcut("test_shortcut.py")
tempname=self.mktemp() + '.lnk'
s1.save(tempname)
self.assert_(os.path.exists(tempname))
self.assertTrue(os.path.exists(tempname))
sc=shortcut.open(tempname)
self.assert_(sc.GetPath(0)[0].endswith('test_shortcut.py'))
self.assertTrue(sc.GetPath(0)[0].endswith('test_shortcut.py'))
ShortcutTests.skip = skipWindowsNopywin32
View
22 twisted/test/test_socks.py
@@ -95,7 +95,7 @@ def setUp(self):
def tearDown(self):
outgoing = self.sock.driver_outgoing
if outgoing is not None:
self.assert_(outgoing.transport.stringTCPTransport_closing,
self.assertTrue(outgoing.transport.stringTCPTransport_closing,
"Outgoing SOCKS connections need to be closed.")
@@ -110,8 +110,8 @@ def test_simple(self):
self.assertEqual(sent,
struct.pack('!BBH', 0, 90, 34)
+ socket.inet_aton('1.2.3.4'))
self.assert_(not self.sock.transport.stringTCPTransport_closing)
self.assert_(self.sock.driver_outgoing is not None)
self.assertTrue(not self.sock.transport.stringTCPTransport_closing)
self.assertTrue(self.sock.driver_outgoing is not None)
# pass some data through
self.sock.dataReceived('hello, world')
@@ -211,7 +211,7 @@ def test_accessDenied(self):
self.assertEqual(self.sock.transport.value(),
struct.pack('!BBH', 0, 91, 0)
+ socket.inet_aton('0.0.0.0'))
self.assert_(self.sock.transport.stringTCPTransport_closing)
self.assertTrue(self.sock.transport.stringTCPTransport_closing)
self.assertIdentical(self.sock.driver_outgoing, None)
@@ -279,8 +279,8 @@ def test_simple(self):
self.assertEqual(sent,
struct.pack('!BBH', 0, 90, 1234)
+ socket.inet_aton('6.7.8.9'))
self.assert_(not self.sock.transport.stringTCPTransport_closing)
self.assert_(self.sock.driver_listen is not None)
self.assertTrue(not self.sock.transport.stringTCPTransport_closing)
self.assertTrue(self.sock.driver_listen is not None)
# connect
incoming = self.sock.driver_listen.buildProtocol(('1.2.3.4', 5345))
@@ -294,7 +294,7 @@ def test_simple(self):
self.assertEqual(sent,
struct.pack('!BBH', 0, 90, 0)
+ socket.inet_aton('0.0.0.0'))
self.assert_(not self.sock.transport.stringTCPTransport_closing)
self.assertTrue(not self.sock.transport.stringTCPTransport_closing)
# pass some data through
self.sock.dataReceived('hello, world')
@@ -407,7 +407,7 @@ def test_accessDenied(self):
self.assertEqual(self.sock.transport.value(),
struct.pack('!BBH', 0, 91, 0)
+ socket.inet_aton('0.0.0.0'))
self.assert_(self.sock.transport.stringTCPTransport_closing)
self.assertTrue(self.sock.transport.stringTCPTransport_closing)
self.assertIdentical(self.sock.driver_listen, None)
def test_eofRemote(self):
@@ -431,7 +431,7 @@ def test_eofRemote(self):
self.assertEqual(sent,
struct.pack('!BBH', 0, 90, 0)
+ socket.inet_aton('0.0.0.0'))
self.assert_(not self.sock.transport.stringTCPTransport_closing)
self.assertTrue(not self.sock.transport.stringTCPTransport_closing)
# pass some data through
self.sock.dataReceived('hello, world')
@@ -463,7 +463,7 @@ def test_eofLocal(self):
self.assertEqual(sent,
struct.pack('!BBH', 0, 90, 0)
+ socket.inet_aton('0.0.0.0'))
self.assert_(not self.sock.transport.stringTCPTransport_closing)
self.assertTrue(not self.sock.transport.stringTCPTransport_closing)
# pass some data through
self.sock.dataReceived('hello, world')
@@ -493,4 +493,4 @@ def test_badSource(self):
self.assertEqual(sent,
struct.pack('!BBH', 0, 91, 0)
+ socket.inet_aton('0.0.0.0'))
self.assert_(self.sock.transport.stringTCPTransport_closing)
self.assertTrue(self.sock.transport.stringTCPTransport_closing)
View
4 twisted/test/test_threads.py
@@ -172,7 +172,7 @@ def test_errorBlockingCallFromThread(self):
def reactorFunc():
return defer.fail(RuntimeError("bar"))
def cb(res):
self.assert_(isinstance(res[1][0], RuntimeError))
self.assertTrue(isinstance(res[1][0], RuntimeError))
self.assertEqual(res[1][0].args[0], "bar")
return self._testBlockingCallFromThread(reactorFunc).addCallback(cb)
@@ -187,7 +187,7 @@ def reactorFunc():
reactor.callLater(0.1, d.errback, RuntimeError("spam"))
return d
def cb(res):
self.assert_(isinstance(res[1][0], RuntimeError))
self.assertTrue(isinstance(res[1][0], RuntimeError))
self.assertEqual(res[1][0].args[0], "spam")
return self._testBlockingCallFromThread(reactorFunc).addCallback(cb)
View
2 twisted/test/test_unix.py
@@ -347,7 +347,7 @@ def test_cannotListen(self):
addr = self.mktemp()
p = ServerProto()
s = reactor.listenUNIXDatagram(addr, p)
self.failUnlessRaises(error.CannotListenError, reactor.listenUNIXDatagram, addr, p)
self.assertRaises(error.CannotListenError, reactor.listenUNIXDatagram, addr, p)
s.stopListening()
os.unlink(addr)
View
12 twisted/test/test_usage.py
@@ -111,9 +111,9 @@ def test_defaultValues(self):
argV = []
self.usage.parseOptions(argV)
self.assertEqual(self.usage.opts['fooint'], 392)
self.assert_(isinstance(self.usage.opts['fooint'], int))
self.assertTrue(isinstance(self.usage.opts['fooint'], int))
self.assertEqual(self.usage.opts['foofloat'], 4.23)
self.assert_(isinstance(self.usage.opts['foofloat'], float))
self.assertTrue(isinstance(self.usage.opts['foofloat'], float))
self.assertEqual(self.usage.opts['eggint'], None)
self.assertEqual(self.usage.opts['eggfloat'], None)
@@ -126,13 +126,13 @@ def test_parsingValues(self):
"--eggint 32 --eggfloat 21").split()
self.usage.parseOptions(argV)
self.assertEqual(self.usage.opts['fooint'], 912)
self.assert_(isinstance(self.usage.opts['fooint'], int))
self.assertTrue(isinstance(self.usage.opts['fooint'], int))
self.assertEqual(self.usage.opts['foofloat'], -823.1)
self.assert_(isinstance(self.usage.opts['foofloat'], float))
self.assertTrue(isinstance(self.usage.opts['foofloat'], float))
self.assertEqual(self.usage.opts['eggint'], 32)
self.assert_(isinstance(self.usage.opts['eggint'], int))
self.assertTrue(isinstance(self.usage.opts['eggint'], int))
self.assertEqual(self.usage.opts['eggfloat'], 21.)
self.assert_(isinstance(self.usage.opts['eggfloat'], float))
self.assertTrue(isinstance(self.usage.opts['eggfloat'], float))
def test_underscoreOption(self):
View
72 twisted/trial/test/test_assertions.py
@@ -152,7 +152,7 @@ def test_failIfFalse(self):
L{SynchronousTestCase.failIf} returns its argument if its argument is
not considered true.
"""
self._assertFalseFalse(self.failIf)
self._assertFalseFalse(self.assertFalse)
def test_assertFalseFalse(self):
@@ -169,7 +169,7 @@ def test_failIfTrue(self):
L{SynchronousTestCase.failureException} if its argument is considered
true.
"""
self._assertFalseTrue(self.failIf)
self._assertFalseTrue(self.assertFalse)
def test_assertFalseTrue(self):
@@ -239,7 +239,7 @@ def test_failUnlessFalse(self):
L{SynchronousTestCase.failureException} if its argument is not
considered true.
"""
self._assertTrueFalse(self.failUnless)
self._assertTrueFalse(self.assertTrue)
def test_assertTrueTrue(self):
@@ -255,7 +255,7 @@ def test_failUnlessTrue(self):
L{SynchronousTestCase.failUnless} returns its argument if its argument
is considered true.
"""
self._assertTrueTrue(self.failUnless)
self._assertTrueTrue(self.assertTrue)
@@ -366,14 +366,14 @@ def _raiseError(self, error):
def test_failUnlessRaises_expected(self):
x = self.failUnlessRaises(ValueError, self._raiseError, ValueError)
x = self.assertRaises(ValueError, self._raiseError, ValueError)
self.assertTrue(isinstance(x, ValueError),
"Expect failUnlessRaises to return instance of raised "
"exception.")
def test_failUnlessRaises_unexpected(self):
try:
self.failUnlessRaises(ValueError, self._raiseError, TypeError)
self.assertRaises(ValueError, self._raiseError, TypeError)
except TypeError:
self.fail("failUnlessRaises shouldn't re-raise unexpected "
"exceptions")
@@ -387,7 +387,7 @@ def test_failUnlessRaises_unexpected(self):
def test_failUnlessRaises_noException(self):
returnValue = 3
try:
self.failUnlessRaises(ValueError, lambda : returnValue)
self.assertRaises(ValueError, lambda : returnValue)
except self.failureException as e:
self.assertEqual(str(e),
'ValueError not raised (3 returned)')
@@ -396,13 +396,13 @@ def test_failUnlessRaises_noException(self):
def test_failUnlessRaises_failureException(self):
x = self.failUnlessRaises(self.failureException, self._raiseError,
x = self.assertRaises(self.failureException, self._raiseError,
self.failureException)
self.assertTrue(isinstance(x, self.failureException),
"Expected %r instance to be returned"
% (self.failureException,))
try:
x = self.failUnlessRaises(self.failureException, self._raiseError,
x = self.assertRaises(self.failureException, self._raiseError,
ValueError)
except self.failureException:
# what we expect
@@ -497,25 +497,25 @@ def test_brokenName(self):
def test_failIfEqual_basic(self):
x, y, z = [1], [2], [1]
ret = self.failIfEqual(x, y)
ret = self.assertNotEqual(x, y)
self.assertEqual(ret, x,
"failIfEqual should return first parameter")
self.failUnlessRaises(self.failureException,
self.failIfEqual, x, x)
self.failUnlessRaises(self.failureException,
self.failIfEqual, x, z)
self.assertRaises(self.failureException,
self.assertNotEqual, x, x)
self.assertRaises(self.failureException,
self.assertNotEqual, x, z)
def test_failIfEqual_customEq(self):
x = MockEquality('first')
y = MockEquality('second')
z = MockEquality('fecund')
ret = self.failIfEqual(x, y)
ret = self.assertNotEqual(x, y)
self.assertEqual(ret, x,
"failIfEqual should return first parameter")
self.failUnlessRaises(self.failureException,
self.failIfEqual, x, x)
self.failIfEqual(x, z, "__ne__ should make these not equal")
self.assertRaises(self.failureException,
self.assertNotEqual, x, x)
self.assertNotEqual(x, z, "__ne__ should make these not equal")
def test_failIfIdenticalPositive(self):
@@ -535,7 +535,7 @@ def test_failIfIdenticalNegative(self):
arguments are the same object.
"""
x = object()
self.failUnlessRaises(self.failureException,
self.assertRaises(self.failureException,
self.failIfIdentical, x, x)
@@ -545,9 +545,9 @@ def test_failUnlessIdentical(self):
self.assertEqual(ret, x,
'failUnlessIdentical should return first '
'parameter')
self.failUnlessRaises(self.failureException,
self.assertRaises(self.failureException,
self.failUnlessIdentical, x, y)
self.failUnlessRaises(self.failureException,
self.assertRaises(self.failureException,
self.failUnlessIdentical, x, z)
def test_failUnlessApproximates(self):
@@ -556,9 +556,9 @@ def test_failUnlessApproximates(self):
ret = self.failUnlessApproximates(x, y, 0.2)
self.assertEqual(ret, x, "failUnlessApproximates should return "
"first parameter")
self.failUnlessRaises(self.failureException,
self.assertRaises(self.failureException,
self.failUnlessApproximates, x, z, 0.1)
self.failUnlessRaises(self.failureException,
self.assertRaises(self.failureException,
self.failUnlessApproximates, x, y, 0.1)
@@ -567,26 +567,26 @@ def test_failUnlessAlmostEqual(self):
x = 8.000001
y = 8.00001
z = 8.000002
self.failUnlessAlmostEqual(x, x, precision)
ret = self.failUnlessAlmostEqual(x, z, precision)
self.assertAlmostEqual(x, x, precision)
ret = self.assertAlmostEqual(x, z, precision)
self.assertEqual(ret, x, "failUnlessAlmostEqual should return "
"first parameter (%r, %r)" % (ret, x))
self.failUnlessRaises(self.failureException,
self.failUnlessAlmostEqual, x, y, precision)
self.assertRaises(self.failureException,
self.assertAlmostEqual, x, y, precision)
def test_failIfAlmostEqual(self):
precision = 5
x = 8.000001
y = 8.00001
z = 8.000002
ret = self.failIfAlmostEqual(x, y, precision)
ret = self.assertNotAlmostEqual(x, y, precision)
self.assertEqual(ret, x, "failIfAlmostEqual should return "
"first parameter (%r, %r)" % (ret, x))
self.failUnlessRaises(self.failureException,
self.failIfAlmostEqual, x, x, precision)
self.failUnlessRaises(self.failureException,
self.failIfAlmostEqual, x, z, precision)
self.assertRaises(self.failureException,
self.assertNotAlmostEqual, x, x, precision)
self.assertRaises(self.failureException,
self.assertNotAlmostEqual, x, z, precision)
def test_failUnlessSubstring(self):
@@ -596,9 +596,9 @@ def test_failUnlessSubstring(self):
self.failUnlessSubstring(x, x)
ret = self.failUnlessSubstring(x, z)
self.assertEqual(ret, x, 'should return first parameter')
self.failUnlessRaises(self.failureException,
self.assertRaises(self.failureException,
self.failUnlessSubstring, x, y)
self.failUnlessRaises(self.failureException,
self.assertRaises(self.failureException,
self.failUnlessSubstring, z, x)
@@ -609,9 +609,9 @@ def test_failIfSubstring(self):
self.failIfSubstring(z, x)
ret = self.failIfSubstring(x, y)
self.assertEqual(ret, x, 'should return first parameter')
self.failUnlessRaises(self.failureException,
self.assertRaises(self.failureException,
self.failIfSubstring, x, x)
self.failUnlessRaises(self.failureException,
self.assertRaises(self.failureException,
self.failIfSubstring, x, z)
View
50 twisted/trial/test/test_loader.py
@@ -79,18 +79,18 @@ def test_findObject(self):
test_findObject.skip = _Py3SkipMsg
def test_findNonModule(self):
self.failUnlessRaises(AttributeError,
self.assertRaises(AttributeError,
self.loader.findByName,
'twisted.trial.test.nonexistent')
def test_findNonPackage(self):
self.failUnlessRaises(ValueError,
self.assertRaises(ValueError,
self.loader.findByName,
'nonextant')
def test_findNonFile(self):
path = util.sibpath(__file__, 'nonexistent.py')
self.failUnlessRaises(ValueError, self.loader.findByName, path)
self.assertRaises(ValueError, self.loader.findByName, path)
@@ -196,7 +196,7 @@ def test_filenameNotPython(self):
"""
filename = filepath.FilePath(self.parent).child('notpython')
filename.setContent(b"This isn't python")
self.failUnlessRaises(
self.assertRaises(
SyntaxError, runner.filenameToModule, filename.path)
@@ -225,9 +225,9 @@ def test_directory(self):
try:
module = runner.filenameToModule(goodDir.path)
self.assert_(module.__name__.endswith('goodDirectory'))
self.assertTrue(module.__name__.endswith('goodDirectory'))
module = runner.filenameToModule(goodDir.path + os.path.sep)
self.assert_(module.__name__.endswith('goodDirectory'))
self.assertTrue(module.__name__.endswith('goodDirectory'))
finally:
goodDir.remove()
@@ -287,11 +287,11 @@ def test_loadFailure(self):
def test_loadNonMethod(self):
from twisted.trial.test import sample
self.failUnlessRaises(TypeError, self.loader.loadMethod, sample)
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError, self.loader.loadMethod, sample)
self.assertRaises(TypeError,
self.loader.loadMethod, sample.FooTest)
self.failUnlessRaises(TypeError, self.loader.loadMethod, "string")
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError, self.loader.loadMethod, "string")
self.assertRaises(TypeError,
self.loader.loadMethod, ('foo', 'bar'))
@@ -349,17 +349,17 @@ def test_loadClass(self):
def test_loadNonClass(self):
from twisted.trial.test import sample
self.failUnlessRaises(TypeError, self.loader.loadClass, sample)
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError, self.loader.loadClass, sample)
self.assertRaises(TypeError,
self.loader.loadClass, sample.FooTest.test_foo)
self.failUnlessRaises(TypeError, self.loader.loadClass, "string")
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError, self.loader.loadClass, "string")
self.assertRaises(TypeError,
self.loader.loadClass, ('foo', 'bar'))
def test_loadNonTestCase(self):
from twisted.trial.test import sample
self.failUnlessRaises(ValueError, self.loader.loadClass,
self.assertRaises(ValueError, self.loader.loadClass,
sample.NotATest)
@@ -371,12 +371,12 @@ def test_loadModule(self):
def test_loadNonModule(self):
from twisted.trial.test import sample
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError,
self.loader.loadModule, sample.FooTest)
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError,
self.loader.loadModule, sample.FooTest.test_foo)
self.failUnlessRaises(TypeError, self.loader.loadModule, "string")
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError, self.loader.loadModule, "string")
self.assertRaises(TypeError,
self.loader.loadModule, ('foo', 'bar'))
@@ -388,19 +388,19 @@ def test_loadPackage(self):
def test_loadNonPackage(self):
from twisted.trial.test import sample
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError,
self.loader.loadPackage, sample.FooTest)
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError,
self.loader.loadPackage, sample.FooTest.test_foo)
self.failUnlessRaises(TypeError, self.loader.loadPackage, "string")
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError, self.loader.loadPackage, "string")
self.assertRaises(TypeError,
self.loader.loadPackage, ('foo', 'bar'))
def test_loadModuleAsPackage(self):
from twisted.trial.test import sample
## XXX -- should this instead raise a ValueError? -- jml
self.failUnlessRaises(TypeError, self.loader.loadPackage, sample)
self.assertRaises(TypeError, self.loader.loadPackage, sample)
def test_loadPackageRecursive(self):
@@ -445,7 +445,7 @@ def test_loadAnythingOnPackageRecursive(self):
def test_loadAnythingOnString(self):
# the important thing about this test is not the string-iness
# but the non-handledness.
self.failUnlessRaises(TypeError,
self.assertRaises(TypeError,
self.loader.loadAnything, "goodpackage")
View
8 twisted/trial/test/test_script.py
@@ -271,15 +271,15 @@ def test_surroundingGuff(self):
localVars)
def test_invalidLine(self):
self.failUnlessRaises(ValueError, trial._parseLocalVariables,
self.assertRaises(ValueError, trial._parseLocalVariables,
'foo')
def test_invalidDeclaration(self):
self.failUnlessRaises(ValueError, trial._parseLocalVariables,
self.assertRaises(ValueError, trial._parseLocalVariables,
'-*- foo -*-')
self.failUnlessRaises(ValueError, trial._parseLocalVariables,
self.assertRaises(ValueError, trial._parseLocalVariables,
'-*- foo: bar; qux -*-')
self.failUnlessRaises(ValueError, trial._parseLocalVariables,
self.assertRaises(ValueError, trial._parseLocalVariables,
'-*- foo: bar: baz; qux: qax -*-')
def test_variablesFromFile(self):
View
2 twisted/web/test/test_webclient.py
@@ -566,7 +566,7 @@ def testFactoryInfo(self):
def _cbFactoryInfo(self, ignoredResult, factory):
self.assertEqual(factory.status, b'200')
self.assert_(factory.version.startswith(b'HTTP/'))
self.assertTrue(factory.version.startswith(b'HTTP/'))
self.assertEqual(factory.message, b'OK')
self.assertEqual(factory.response_headers[b'content-length'][0], b'10')
View
48 twisted/web/test/test_xml.py
@@ -223,13 +223,13 @@ def testPreserveCase(self):
# however this assertion tests preserving case for start and
# end tags while still matching stuff like <bOrk></BoRk>
self.assertEqual(d.documentElement.toxml(), s)
self.assert_(d.isEqualToDocument(d2), "%r != %r" % (d.toxml(), d2.toxml()))
self.assert_(d2.isEqualToDocument(d3), "%r != %r" % (d2.toxml(), d3.toxml()))
self.assertTrue(d.isEqualToDocument(d2), "%r != %r" % (d.toxml(), d2.toxml()))
self.assertTrue(d2.isEqualToDocument(d3), "%r != %r" % (d2.toxml(), d3.toxml()))
# caseInsensitive=0 on the left, NOT perserveCase=1 on the right
## XXX THIS TEST IS TURNED OFF UNTIL SOMEONE WHO CARES ABOUT FIXING IT DOES
#self.assertFalse(d3.isEqualToDocument(d2), "%r == %r" % (d3.toxml(), d2.toxml()))
self.assert_(d3.isEqualToDocument(d4), "%r != %r" % (d3.toxml(), d4.toxml()))
self.assert_(d4.isEqualToDocument(d5), "%r != %r" % (d4.toxml(), d5.toxml()))
self.assertTrue(d3.isEqualToDocument(d4), "%r != %r" % (d3.toxml(), d4.toxml()))
self.assertTrue(d4.isEqualToDocument(d5), "%r != %r" % (d4.toxml(), d5.toxml()))
def testDifferentQuotes(self):
s = '<test a="a" b=\'b\' />'
@@ -255,19 +255,19 @@ def testComment(self):
e = d.documentElement
self.assertEqual(e.nodeName, "bar")
c = e.childNodes[0]
self.assert_(isinstance(c, microdom.Comment))
self.assertTrue(isinstance(c, microdom.Comment))
self.assertEqual(c.value, "<foo />")
c2 = c.cloneNode()
self.assert_(c is not c2)
self.assertTrue(c is not c2)
self.assertEqual(c2.toxml(), "<!--<foo />-->")
def testText(self):
d = microdom.parseString("<bar>xxxx</bar>").documentElement
text = d.childNodes[0]
self.assert_(isinstance(text, microdom.Text))
self.assertTrue(isinstance(text, microdom.Text))
self.assertEqual(text.value, "xxxx")
clone = text.cloneNode()
self.assert_(clone is not text)
self.assertTrue(clone is not text)
self.assertEqual(clone.toxml(), "xxxx")
def testEntities(self):
@@ -277,12 +277,12 @@ def testEntities(self):
self.assertEqual(nodes[1].data, "&#12AB;")
self.assertEqual(nodes[0].cloneNode().toxml(), "&amp;")
for n in nodes:
self.assert_(isinstance(n, microdom.EntityReference))
self.assertTrue(isinstance(n, microdom.EntityReference))
def testCData(self):
s = '<x><![CDATA[</x>\r\n & foo]]></x>'
cdata = microdom.parseString(s).documentElement.childNodes[0]
self.assert_(isinstance(cdata, microdom.CDATASection))
self.assertTrue(isinstance(cdata, microdom.CDATASection))
self.assertEqual(cdata.data, "</x>\r\n & foo")
self.assertEqual(cdata.cloneNode().toxml(), "<![CDATA[</x>\r\n & foo]]>")
@@ -293,18 +293,18 @@ def testSingletons(self):
nodes2 = microdom.parseString(s2).documentElement.childNodes
self.assertEqual(len(nodes), 3)
for (n, n2) in zip(nodes, nodes2):
self.assert_(isinstance(n, microdom.Element))
self.assertTrue(isinstance(n, microdom.Element))
self.assertEqual(n.nodeName, "b")
self.assert_(n.isEqualToNode(n2))
self.assertTrue(n.isEqualToNode(n2))
def testAttributes(self):
s = '<foo a="b" />'
node = microdom.parseString(s).documentElement
self.assertEqual(node.getAttribute("a"), "b")
self.assertEqual(node.getAttribute("c"), None)
self.assert_(node.hasAttribute("a"))
self.assert_(not node.hasAttribute("c"))
self.assertTrue(node.hasAttribute("a"))
self.assertTrue(not node.hasAttribute("c"))
a = node.getAttributeNode("a")
self.assertEqual(a.value, "b")
@@ -317,8 +317,8 @@ def testChildren(self):
self.assertEqual([n.nodeName for n in d.childNodes], ["bar", "baz", "bax"])
self.assertEqual(d.lastChild().nodeName, "bax")
self.assertEqual(d.firstChild().nodeName, "bar")
self.assert_(d.hasChildNodes())
self.assert_(not d.firstChild().hasChildNodes())
self.assertTrue(d.hasChildNodes())
self.assertTrue(not d.firstChild().hasChildNodes())
def testMutate(self):
s = "<foo />"
@@ -339,7 +339,7 @@ def testMutate(self):
self.assertEqual(d.childNodes[1], child)
for n in d.childNodes:
self.assertEqual(n.parentNode, d)
self.assert_(d.isEqualToNode(d1))
self.assertTrue(d.isEqualToNode(d1))
d.removeChild(child)
self.assertEqual(len(d.childNodes), 1)
@@ -348,7 +348,7 @@ def testMutate(self):
t = microdom.Text("foo")
d.replaceChild(t, d.firstChild())
self.assertEqual(d.firstChild(), t)
self.assert_(d.isEqualToNode(d2))
self.assertTrue(d.isEqualToNode(d2))
def test_replaceNonChild(self):
@@ -416,7 +416,7 @@ def testOutput(self):
d2 = microdom.parseString(out, caseInsensitive=0)
testOut = d.documentElement.toxml()
self.assertEqual(out, testOut)
self.assert_(d.isEqualToDocument(d2))
self.assertTrue(d.isEqualToDocument(d2))
def testErrors(self):
for s in ["<foo>&am</foo>", "<foo", "<f>&</f>", "<() />"]:
@@ -519,13 +519,13 @@ def reverseBytes(s):
urd = microdom.parseString(reverseBytes(s.encode('UTF-16')))
ud = microdom.parseString(s.encode('UTF-16'))
sd = microdom.parseString(s)
self.assert_(ud.isEqualToDocument(sd))
self.assert_(ud.isEqualToDocument(urd))
self.assertTrue(ud.isEqualToDocument(sd))
self.assertTrue(ud.isEqualToDocument(urd))
ud = microdom.parseString(j)
urd = microdom.parseString(reverseBytes(j2))
sd = microdom.parseString(j2)
self.assert_(ud.isEqualToDocument(sd))
self.assert_(ud.isEqualToDocument(urd))
self.assertTrue(ud.isEqualToDocument(sd))
self.assertTrue(ud.isEqualToDocument(urd))
# test that raw text still gets encoded
# test that comments get encoded
@@ -549,7 +549,7 @@ def testNamedChildren(self):
result = domhelpers.namedChildren(node, 'bar')
self.assertEqual(len(result), tests[t])
if result:
self.assert_(hasattr(result[0], 'tagName'))
self.assertTrue(hasattr(result[0], 'tagName'))
def testCloneNode(self):
s = '<foo a="b"><bax>x</bax></foo>'
View
12 twisted/words/test/test_basesupport.py
@@ -58,9 +58,9 @@ def test_connect(self):
account.loginDeferred.callback(None)
def check(result):
self.assert_(not account.loginHasFailed,
self.assertTrue(not account.loginHasFailed,
"Login shouldn't have failed")
self.assert_(account.loginCallbackCalled,
self.assertTrue(account.loginCallbackCalled,
"We should be logged in")
d.addCallback(check)
return d
@@ -76,12 +76,12 @@ def test_failedConnect(self):
account.loginDeferred.errback(Exception())
def err(reason):
self.assert_(account.loginHasFailed, "Login should have failed")
self.assert_(not account.loginCallbackCalled,
self.assertTrue(account.loginHasFailed, "Login should have failed")
self.assertTrue(not account.loginCallbackCalled,
"We shouldn't be logged in")
self.assert_(not ui.clientRegistered,
self.assertTrue(not ui.clientRegistered,
"Client shouldn't be registered in the UI")
cb = lambda r: self.assert_(False, "Shouldn't get called back")
cb = lambda r: self.assertTrue(False, "Shouldn't get called back")
d.addCallbacks(cb, err)
return d
View
8 twisted/words/test/test_jabberclient.py
@@ -403,10 +403,10 @@ def testBasic(self):
# test list of initializers
version, tls, sasl, bind, session = xs.initializers
self.assert_(isinstance(tls, xmlstream.TLSInitiatingInitializer))
self.assert_(isinstance(sasl, SASLInitiatingInitializer))
self.assert_(isinstance(bind, client.BindInitializer))
self.assert_(isinstance(session, client.SessionInitializer))
self.assertTrue(isinstance(tls, xmlstream.TLSInitiatingInitializer))
self.assertTrue(isinstance(sasl, SASLInitiatingInitializer))
self.assertTrue(isinstance(bind, client.BindInitializer))
self.assertTrue(isinstance(session, client.SessionInitializer))
self.assertFalse(tls.required)
self.assertTrue(sasl.required)
View
6 twisted/words/test/test_jabbererror.py
@@ -273,7 +273,7 @@ def test_basic(self):
uc['feature'] = 'retrieve-subscriptions'
result = error.exceptionFromStanza(stanza)
self.assert_(isinstance(result, error.StanzaError))
self.assertTrue(isinstance(result, error.StanzaError))
self.assertEqual('feature-not-implemented', result.condition)
self.assertEqual('cancel', result.type)
self.assertEqual(uc, result.appCondition)
@@ -301,7 +301,7 @@ def test_legacy(self):
e['code'] = '502'
result = error.exceptionFromStanza(stanza)
self.assert_(isinstance(result, error.StanzaError))
self.assertTrue(isinstance(result, error.StanzaError))
self.assertEqual('service-unavailable', result.condition)
self.assertEqual('wait', result.type)
self.assertEqual('Unable to resolve hostname.', result.text)
@@ -326,5 +326,5 @@ def test_basic(self):
e.addElement((NS_XMPP_STREAMS, 'xml-not-well-formed'))
result = error.exceptionFromStreamError(e)
self.assert_(isinstance(result, error.StreamError))
self.assertTrue(isinstance(result, error.StreamError))
self.assertEqual('xml-not-well-formed', result.condition)