[Checkins] SVN: Products.CMFDefault/trunk/Products/CMFDefault/ unittest cleanup:

Yvo Schubbe cvs-admin at zope.org
Sun Apr 22 11:04:28 UTC 2012


Log message for revision 125229:
  unittest cleanup:
  - replaced deprecated assert method aliases
  - PEP 8

Changed:
  U   Products.CMFDefault/trunk/Products/CMFDefault/browser/content/tests/test_folder.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/browser/membership/tests/test_members.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/browser/skins/tests/test_icons.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/browser/skins/tests/test_ursa.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DefaultWorkflow.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DiscussionTool.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_Discussions.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DublinCore.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_File.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_Image.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_MembershipTool.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_MetadataTool.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_PropertiesTool.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_RegistrationTool.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_SyndicationTool.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_join.py
  U   Products.CMFDefault/trunk/Products/CMFDefault/tests/test_utils.py

-=-
Modified: Products.CMFDefault/trunk/Products/CMFDefault/browser/content/tests/test_folder.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/browser/content/tests/test_folder.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/browser/content/tests/test_folder.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -49,7 +49,7 @@
         batch = self._makeOne()
         self.assertEqual(batch.expand_prefix('key'), 'key')
         batch = self._makeOne()
-        batch.prefix= 'form'
+        batch.prefix = 'form'
         self.assertEqual(batch.expand_prefix('key'), 'form.key')
 
     def test_page_count(self):
@@ -108,37 +108,37 @@
 
     def test_page_range(self):
         batch = self._makeOne()
-        self.assertEqual(batch.page_range(),
-                         [{'url': u'http://example.com?b_start=0', 'number': 1},
-                          {'url': u'http://example.com?b_start=25', 'number': 2}]
-                         )
+        self.assertEqual(
+            batch.page_range(),
+            [{'url': u'http://example.com?b_start=0', 'number': 1},
+             {'url': u'http://example.com?b_start=25', 'number': 2}])
         batch = self._makeOne(1000)
-        self.assertEqual(batch.page_range(),
-                         [{'url': u'http://example.com?b_start=0', 'number': 1},
-                          {'url': u'http://example.com?b_start=25', 'number': 2},
-                          {'url': u'http://example.com?b_start=50', 'number': 3},
-                          {'url': u'http://example.com?b_start=75', 'number': 4},
-                          {'url': u'http://example.com?b_start=100', 'number': 5},
-                          {'url': u'http://example.com?b_start=125', 'number': 6},
-                          {'url': u'http://example.com?b_start=150', 'number': 7},
-                          {'url': u'http://example.com?b_start=175', 'number': 8},
-                          {'url': u'http://example.com?b_start=200', 'number': 9},
-                          {'url': u'http://example.com?b_start=225', 'number': 10}]
-                         )
+        self.assertEqual(
+            batch.page_range(),
+            [{'url': u'http://example.com?b_start=0', 'number': 1},
+             {'url': u'http://example.com?b_start=25', 'number': 2},
+             {'url': u'http://example.com?b_start=50', 'number': 3},
+             {'url': u'http://example.com?b_start=75', 'number': 4},
+             {'url': u'http://example.com?b_start=100', 'number': 5},
+             {'url': u'http://example.com?b_start=125', 'number': 6},
+             {'url': u'http://example.com?b_start=150', 'number': 7},
+             {'url': u'http://example.com?b_start=175', 'number': 8},
+             {'url': u'http://example.com?b_start=200', 'number': 9},
+             {'url': u'http://example.com?b_start=225', 'number': 10}])
         batch = self._makeOne(1000)
         batch._getBatchStart = lambda: 250
-        self.assertEqual(batch.page_range(),
-                         [{'url': u'http://example.com?b_start=150', 'number': 7},
-                          {'url': u'http://example.com?b_start=175', 'number': 8},
-                          {'url': u'http://example.com?b_start=200', 'number': 9},
-                          {'url': u'http://example.com?b_start=225', 'number': 10},
-                          {'url': u'http://example.com?b_start=250', 'number': 11},
-                          {'url': u'http://example.com?b_start=275', 'number': 12},
-                          {'url': u'http://example.com?b_start=300', 'number': 13},
-                          {'url': u'http://example.com?b_start=325', 'number': 14},
-                          {'url': u'http://example.com?b_start=350', 'number': 15},
-                          {'url': u'http://example.com?b_start=375', 'number': 16}]
-                         )
+        self.assertEqual(
+            batch.page_range(),
+            [{'url': u'http://example.com?b_start=150', 'number': 7},
+             {'url': u'http://example.com?b_start=175', 'number': 8},
+             {'url': u'http://example.com?b_start=200', 'number': 9},
+             {'url': u'http://example.com?b_start=225', 'number': 10},
+             {'url': u'http://example.com?b_start=250', 'number': 11},
+             {'url': u'http://example.com?b_start=275', 'number': 12},
+             {'url': u'http://example.com?b_start=300', 'number': 13},
+             {'url': u'http://example.com?b_start=325', 'number': 14},
+             {'url': u'http://example.com?b_start=350', 'number': 15},
+             {'url': u'http://example.com?b_start=375', 'number': 16}])
 
 
 class FolderContentsViewTests(unittest.TestCase):
@@ -177,60 +177,56 @@
 
     def test_view(self):
         view = ContentsView(self.folder, TestRequest())
-        self.failUnless(IBrowserPublisher.providedBy(view))
+        self.assertTrue(IBrowserPublisher.providedBy(view))
 
     def test_up_info(self):
         view = ContentsView(self.folder, TestRequest())
-        self.assertEquals({'url':u'', 'id':u'Root', 'icon':u''},
-                            view.up_info())
+        self.assertEqual({'url': u'', 'id': u'Root', 'icon': u''},
+                         view.up_info())
 
     def test_list_batch_items(self):
         view = ContentsView(self.folder, TestRequest())
         view.content_fields()
-        self.assertEquals(view.listBatchItems, [])
+        self.assertEqual(view.listBatchItems, [])
 
     def test_is_orderable(self):
         view = ContentsView(self.folder, TestRequest())
-        self.failIf(view.is_orderable())
+        self.assertFalse(view.is_orderable())
 
     def test_sort_can_be_changed(self):
         view = ContentsView(self.folder, TestRequest())
-        self.failIf(view.can_sort_be_changed())
+        self.assertFalse(view.can_sort_be_changed())
 
     def test_empty_has_subobjects(self):
         view = ContentsView(self.folder, TestRequest())
-        self.failIf(view.has_subobjects())
+        self.assertFalse(view.has_subobjects())
 
     def test_has_subobjects(self):
         self._make_one()
         view = ContentsView(self.folder, TestRequest())
-        self.failUnless(view.has_subobjects())
+        self.assertTrue(view.has_subobjects())
 
     def test_check_clipboard_data(self):
         view = ContentsView(self.folder, TestRequest())
-        self.failIf(view.check_clipboard_data())
+        self.assertFalse(view.check_clipboard_data())
 
     def test_validate_items(self):
         """Cannot validate forms without widgets"""
         view = ContentsView(self.folder, TestRequest())
         self.assertRaises(AttributeError,
-                            view.validate_items, "", {'foo':'bar'})
+                          view.validate_items, "", {'foo': 'bar'})
 
     def test_get_ids(self):
         view = ContentsView(self.folder, TestRequest())
-        self.assertEquals(
-                        view._get_ids({'foo':'bar'}),
-                        [])
-        self.assertEquals(
-                        view._get_ids({'DummyItem1.select':True,
-                                       'DummyItem2.select':False,
-                                       'DummyItem3.select':True}),
-                        ['DummyItem1', 'DummyItem3'])
-        self.assertEquals(
-                        view._get_ids({'delta':True,
-                                       'delta':1}),
-                        []
-                        )
+        self.assertEqual(view._get_ids({'foo': 'bar'}),
+                         [])
+        self.assertEqual(view._get_ids({'DummyItem1.select': True,
+                                        'DummyItem2.select': False,
+                                        'DummyItem3.select': True}),
+                         ['DummyItem1', 'DummyItem3'])
+        self.assertEqual(view._get_ids({'delta': True,
+                                        'delta': 1}),
+                         [])
 
 
 class FolderViewTests(unittest.TestCase):

Modified: Products.CMFDefault/trunk/Products/CMFDefault/browser/membership/tests/test_members.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/browser/membership/tests/test_members.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/browser/membership/tests/test_members.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -111,28 +111,21 @@
 
     def test_get_ids(self):
         view = Manage(self.site, TestRequest())
-        self.assertEquals(
-                        view._get_ids({'foo':'bar'}),
-                        [])
-        self.assertEquals(
-                        sorted(
-                            view._get_ids({'DummyUser1.select':True,
-                                       'DummyUser2.select':False,
-                                       'DummyUser3.select':True})
-                            ),
-                        ['DummyUser1', 'DummyUser3']
-                        )
-        self.assertEquals(
-                        view._get_ids({'stupid.name.select.select':True}),
-                        ['stupid.name.select']
-        )
+        self.assertEqual(view._get_ids({'foo': 'bar'}),
+                         [])
+        self.assertEqual(sorted(view._get_ids({'DummyUser1.select': True,
+                                               'DummyUser2.select': False,
+                                               'DummyUser3.select': True})),
+                         ['DummyUser1', 'DummyUser3'])
+        self.assertEqual(view._get_ids({'stupid.name.select.select': True}),
+                         ['stupid.name.select'])
 
     def test_handle_select_for_deletion(self):
         view = Manage(self.site, TestRequest())
         self.assertTrue(view.guillotine == None)
         # Catch exception raised when template tries to render
         self.assertRaises(AttributeError,
-                view.handle_select_for_deletion, None, {"Alice.select":True})
+                view.handle_select_for_deletion, None, {"Alice.select": True})
         self.assertTrue(view.guillotine == "Alice")
 
     def test_handle_delete(self):
@@ -141,8 +134,7 @@
         self.assertFalse(self.mtool.listMembers() == [])
         # Catch exception raised when trying to redirect
         self.assertRaises(TypeError,
-                         view.handle_delete, None, {"Bob.select":True}
-                         )
+                          view.handle_delete, None, {"Bob.select": True})
         self.assertTrue(self.mtool.listMembers() == [])
 
 

Modified: Products.CMFDefault/trunk/Products/CMFDefault/browser/skins/tests/test_icons.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/browser/skins/tests/test_icons.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/browser/skins/tests/test_icons.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -68,31 +68,32 @@
     def test_show_icons_not_set(self):
         #Show action icons not set
         view = self._makeOne()
-        self.failIf(view._show_icons)
+        self.assertFalse(view._show_icons)
 
     def test_show_icons_enabled(self):
         #Show actions set to True
         site = self._makeSite()
         site.portal_properties.enable_actionicons = True
         view = self._makeOne(site)
-        self.failUnless(view._show_icons)
+        self.assertTrue(view._show_icons)
 
     def test_show_icons_disabled(self):
         #Show action icons set to False
         site = self._makeSite()
         site.portal_properties.enable_actionicons = False
         view = self._makeOne(site)
-        self.failIf(view._show_icons)
+        self.assertFalse(view._show_icons)
 
     def test_type_icons_with_action_icons_disabled(self):
         #Type actions should always be visible
         types = [DummyType("Document"), DummyType("Image")]
         site = self._makeSite(types=types)
         view = self._makeOne(site)
-        self.failIf(view.show_icons)
+        self.assertFalse(view.show_icons)
 
         css = view.types()
-        self.assertEqual(css,""".Document {background: url(http://example.com/Document.png) no-repeat 0.1em}
+        self.assertEqual(css, """\
+.Document {background: url(http://example.com/Document.png) no-repeat 0.1em}
 
 .Image {background: url(http://example.com/Image.png) no-repeat 0.1em}""")
 
@@ -102,10 +103,11 @@
         site = self._makeSite(types=types)
         site.portal_properties.enable_actionicons = True
         view = self._makeOne(site)
-        self.failUnless(view.show_icons)
+        self.assertTrue(view.show_icons)
 
         css = view.types()
-        self.assertEqual(css,""".Document {background: url(http://example.com/Document.png) no-repeat 0.1em}
+        self.assertEqual(css, """\
+.Document {background: url(http://example.com/Document.png) no-repeat 0.1em}
 
 .Image {background: url(http://example.com/Image.png) no-repeat 0.1em}""")
 
@@ -113,7 +115,7 @@
         #Action icons disabled. Image less styles should be returned.
         site = self._makeSite(actions=ACTIONS)
         view = self._makeOne(site)
-        self.failIf(view.show_icons)
+        self.assertFalse(view.show_icons)
 
         css = view.actions()
         self.assertEqual(css, """/* user actions */
@@ -143,7 +145,7 @@
         site = self._makeSite(actions=ACTIONS)
         site.portal_properties.enable_actionicons = True
         view = self._makeOne(site)
-        self.failUnless(view.show_icons)
+        self.assertTrue(view.show_icons)
 
         css = view.actions()
         self.assertEqual(css, """/* user actions */
@@ -207,10 +209,9 @@
 
 
 def DummyAction(name):
+    return {'id': name, 'icon': '%s.png' % name}
 
-    return {'id':name, 'icon':'%s.png' % name}
 
-
 ACTIONS = {'global': [DummyAction('Undo')],
            'user': [DummyAction('Login'), DummyAction('Logout')],
            'object': [DummyAction('Edit')],

Modified: Products.CMFDefault/trunk/Products/CMFDefault/browser/skins/tests/test_ursa.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/browser/skins/tests/test_ursa.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/browser/skins/tests/test_ursa.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -100,36 +100,36 @@
     def test_ptool(self):
         view = self._makeOne()
         tool = view.context.portal_properties
-        self.failUnless(view.ptool is tool)
+        self.assertTrue(view.ptool is tool)
 
     def test_utool(self):
         view = self._makeOne()
         tool = DummyURLTool()
         getSiteManager().registerUtility(tool, IURLTool)
-        self.failUnless(view.utool is tool)
+        self.assertTrue(view.utool is tool)
 
     def test_mtool(self):
         view = self._makeOne()
         tool = view.context.portal_membership
-        self.failUnless(view.mtool is tool)
+        self.assertTrue(view.mtool is tool)
 
     def test_atool(self):
         view = self._makeOne()
         tool = DummyActionsTool()
         getSiteManager().registerUtility(tool, IActionsTool)
-        self.failUnless(view.atool is tool)
+        self.assertTrue(view.atool is tool)
 
     def test_wtool(self):
         view = self._makeOne()
         tool = DummyWorkflowTool()
         getSiteManager().registerUtility(tool, IWorkflowTool)
-        self.failUnless(view.wtool is tool)
+        self.assertTrue(view.wtool is tool)
 
     def test_syndtool(self):
         view = self._makeOne()
         tool = DummyTool()
         getSiteManager().registerUtility(tool, ISyndicationTool)
-        self.failUnless(view.syndtool is tool)
+        self.assertTrue(view.syndtool is tool)
 
     def test_uidtool(self):
         view = self._makeOne()
@@ -171,7 +171,7 @@
         tool = DummyURLTool()
         tool.getPortalObject = lambda: portal
         getSiteManager().registerUtility(tool, IURLTool)
-        self.failUnless(view.portal_object is portal)
+        self.assertTrue(view.portal_object is portal)
 
     def test_portal_url(self):
         view = self._makeOne()
@@ -311,26 +311,26 @@
         tool = view.context.portal_membership
         member = DummyUser()
         tool.getAuthenticatedMember = lambda: member
-        self.failUnless(view.member is member)
+        self.assertTrue(view.member is member)
 
     def test_membersfolder(self):
         view = self._makeOne()
         tool = view.context.portal_membership
         membersfolder = object()
         tool.getMembersFolder = lambda: membersfolder
-        self.failUnless(view.membersfolder is membersfolder)
+        self.assertTrue(view.membersfolder is membersfolder)
 
     def test_isAnon_tool_returns_True(self):
         view = self._makeOne()
         tool = view.context.portal_membership
         tool.isAnonymousUser = lambda: True
-        self.failUnless(view.isAnon)
+        self.assertTrue(view.isAnon)
 
     def test_isAnon_tool_returns_False(self):
         view = self._makeOne()
         tool = view.context.portal_membership
         tool.isAnonymousUser = lambda: False
-        self.failIf(view.isAnon)
+        self.assertFalse(view.isAnon)
 
     def test_membername_anonymous(self):
         view = self._makeOne()
@@ -441,13 +441,18 @@
 
 
 class DummyContext:
+
     pass
 
+
 class DummyAction:
+
     def __init__(self, id):
         self.id = id
 
+
 class DummySite:
+
     def __init__(self, paths_to_contexts=()):
         self.paths_to_contexts = paths_to_contexts[:]
 
@@ -457,11 +462,15 @@
                 return context
         raise ValueError('Unknown path: %s' % path)
 
+
 class DummyPropertiesTool:
+
     def getProperty(self, id, d=None):
         return getattr(self, id, d)
 
+
 class DummyURLTool:
+
     def __init__(self, site=None, paths_to_contexts=()):
         self.site = site
         self.paths_to_contexts = paths_to_contexts[:]
@@ -477,10 +486,14 @@
                 return path
         raise ValueError('Unknown context: %s' % context)
 
+
 class DummyMembershipTool:
+
     pass
 
+
 class DummyActionsTool:
+
     def __init__(self, actions=None):
         if actions is None:
             actions = {}
@@ -489,20 +502,28 @@
     def listFilteredActionsFor(self, context):
         return self.actions
 
+
 class DummyWorkflowTool:
+
     review_state = 'DUMMY'
+
     def getInfoFor(self, context, key, default):
         if key == 'review_state':
             return self.review_state
 
+
 class DummyTool(object):
 
     pass
 
+
 class DummyUser:
+
     pass
 
+
 class DummyResponse:
+
     def __init__(self, **kw):
         self._orig_headers = kw.copy()
         self._set_headers = []
@@ -513,7 +534,9 @@
     def setHeader(self, key, value):
         self._set_headers.append((key, value))
 
+
 class DummyRequest:
+
     def __init__(self):
         self.RESPONSE = DummyResponse()
 

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DefaultWorkflow.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DefaultWorkflow.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DefaultWorkflow.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -65,7 +65,7 @@
         dummy = self.site._setObject('dummy', DummyContent())
 
         for action in ('submit', 'retract', 'publish', 'reject',):
-            self.assert_(wf.isActionSupported(dummy, action))
+            self.assertTrue(wf.isActionSupported(dummy, action))
 
     def test_isActionSupported_with_keywargs(self):
 
@@ -73,8 +73,8 @@
         dummy = self.site._setObject('dummy', DummyContent())
 
         for action in ('submit', 'retract', 'publish', 'reject',):
-            self.assert_(wf.isActionSupported(dummy, action,
-                                              arg1=1, arg2=2))
+            self.assertTrue(wf.isActionSupported(dummy, action,
+                                                 arg1=1, arg2=2))
 
     # XXX more tests...
 

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DiscussionTool.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DiscussionTool.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DiscussionTool.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -71,25 +71,27 @@
         acl_users = self.site._setObject('acl_users', DummyUserFolder())
         newSecurityManager(None, acl_users.all_powerful_Oz)
         dtool = self.dtool
-        foo = self.site._setObject( 'foo', DummyFolder() )
-        baz = foo._setObject( 'baz', DummyFolder() )
+        foo = self.site._setObject('foo', DummyFolder())
+        baz = foo._setObject('baz', DummyFolder())
 
         dtool.overrideDiscussionFor(foo, 1)
-        self.failUnless( hasattr(foo.aq_base, 'allow_discussion') )
+        self.assertTrue(hasattr(foo.aq_base, 'allow_discussion'))
         try:
             dtool.overrideDiscussionFor(baz, None)
         except KeyError:
             self.fail('CMF Collector issue #201 (acquisition bug): '
                       'KeyError raised')
         dtool.overrideDiscussionFor(foo, None)
-        self.failIf( hasattr(foo.aq_base, 'allow_discussion') )
+        self.assertFalse(hasattr(foo.aq_base, 'allow_discussion'))
 
         # https://bugs.launchpad.net/zope-cmf/+bug/162532: Don't break
         # if allow_discussion only exists at the class level
         class DummyContent:
             allow_discussion = False
-            def getId(self): return 'dummy'
 
+            def getId(self):
+                return 'dummy'
+
         dummy = DummyContent()
         try:
             dtool.overrideDiscussionFor(dummy, None)
@@ -102,31 +104,31 @@
         acl_users = self.site._setObject('acl_users', DummyUserFolder())
         newSecurityManager(None, acl_users.all_powerful_Oz)
         dtool = self.dtool
-        foo = self.site._setObject( 'foo', DummyFolder() )
-        baz = foo._setObject( 'baz', DummyFolder() )
+        foo = self.site._setObject('foo', DummyFolder())
+        baz = foo._setObject('baz', DummyFolder())
         dtool.overrideDiscussionFor(foo, 1)
 
-        self.failIf(dtool.isDiscussionAllowedFor(baz))
+        self.assertFalse(dtool.isDiscussionAllowedFor(baz))
 
         # Make sure isDiscussionAllowedFor does not blow up on items
         # that aren't content and/or discussable at all.
-        self.failIf(dtool.isDiscussionAllowedFor(self.ttool))
+        self.assertFalse(dtool.isDiscussionAllowedFor(self.ttool))
 
     def test_getDiscussionFor(self):
         dtool = self.dtool
-        foo = self.site._setObject( 'foo', DummyFolder() )
+        foo = self.site._setObject('foo', DummyFolder())
         foo.allow_discussion = 1
-        baz = foo._setObject( 'baz', DummyFolder() )
+        baz = foo._setObject('baz', DummyFolder())
         baz.allow_discussion = 1
 
-        self.failIf( hasattr(foo.aq_base, 'talkback') )
+        self.assertFalse(hasattr(foo.aq_base, 'talkback'))
         dtool.getDiscussionFor(foo)
-        self.failUnless( hasattr(foo.aq_base, 'talkback') )
-        self.failIf( hasattr(baz.aq_base, 'talkback') )
+        self.assertTrue(hasattr(foo.aq_base, 'talkback'))
+        self.assertFalse(hasattr(baz.aq_base, 'talkback'))
         dtool.getDiscussionFor(baz)
-        self.failUnless( hasattr(baz.aq_base, 'talkback'),
-                         'CMF Collector issue #119 (acquisition bug): '
-                         'talkback not created' )
+        self.assertTrue(hasattr(baz.aq_base, 'talkback'),
+                        'CMF Collector issue #119 (acquisition bug): '
+                        'talkback not created')
 
 
 def test_suite():

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_Discussions.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_Discussions.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_Discussions.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -92,87 +92,85 @@
     def _makeDummyContent(self, id, *args, **kw):
         return self.site._setObject(id, DummyContent(id, *args, **kw))
 
-    def test_policy( self ):
+    def test_policy(self):
         dtool = self.dtool
         ttool = self.ttool
         test = self._makeDummyContent('test')
         self.assertRaises(DiscussionNotAllowed, dtool.getDiscussionFor, test)
-        assert getattr( test, 'talkback', None ) is None
+        self.assertTrue(getattr(test, 'talkback', None) is None)
 
         test.allow_discussion = 1
-        assert dtool.getDiscussionFor(test)
-        assert test.talkback
+        self.assertTrue(dtool.getDiscussionFor(test))
+        self.assertTrue(test.talkback)
 
         del test.talkback
         del test.allow_discussion
         fti = FTIDATA_DUMMY[0].copy()
-        ttool._setObject( 'Dummy Content', FTI(**fti) )
+        ttool._setObject('Dummy Content', FTI(**fti))
         self.assertRaises(DiscussionNotAllowed, dtool.getDiscussionFor, test)
-        assert getattr( test, 'talkback', None ) is None
+        self.assertTrue(getattr(test, 'talkback', None) is None)
 
         ti = getattr(ttool, 'Dummy Content')
         ti.allow_discussion = 1
-        assert dtool.getDiscussionFor(test)
-        assert test.talkback
+        self.assertTrue(dtool.getDiscussionFor(test))
+        self.assertTrue(test.talkback)
 
         del test.talkback
         ti.allow_discussion = 0
         self.assertRaises(DiscussionNotAllowed, dtool.getDiscussionFor, test)
-        assert getattr( test, 'talkback', None ) is None
+        self.assertTrue(getattr(test, 'talkback', None) is None)
 
         test.allow_discussion = 1
-        assert dtool.getDiscussionFor(test)
-        assert test.talkback
+        self.assertTrue(dtool.getDiscussionFor(test))
+        self.assertTrue(test.talkback)
 
-    def test_nestedReplies( self ):
+    def test_nestedReplies(self):
         dtool = self.dtool
         test = self._makeDummyContent('test')
         test.allow_discussion = 1
         talkback = dtool.getDiscussionFor(test)
-        assert talkback._getDiscussable() == test
-        assert talkback._getDiscussable( outer=1 ) == test
-        assert not talkback.hasReplies( test )
-        assert len( talkback.getReplies() ) == 0
+        self.assertEqual(talkback._getDiscussable(), test)
+        self.assertEqual(talkback._getDiscussable(outer=1), test)
+        self.assertFalse(talkback.hasReplies(test))
+        self.assertEqual(len(talkback.getReplies()), 0)
 
-        reply_id = talkback.createReply( title='test', text='blah' )
-        assert talkback.hasReplies( test )
-        assert len( talkback.getReplies() ) == 1
-        assert talkback.getReply( reply_id )
+        reply_id = talkback.createReply(title='test', text='blah')
+        self.assertTrue(talkback.hasReplies(test))
+        self.assertEqual(len(talkback.getReplies()), 1)
+        self.assertTrue(talkback.getReply(reply_id))
 
         reply1 = talkback.getReplies()[0]
         items = talkback._container.items()
-        self.assertEqual( reply1.getId(), items[0][0] )
-        self.assertEqual( reply1.inReplyTo(), test )
-        self.assertEqual( reply1.listCreators(), ('dummy',) )
+        self.assertEqual(reply1.getId(), items[0][0])
+        self.assertEqual(reply1.inReplyTo(), test)
+        self.assertEqual(reply1.listCreators(), ('dummy',))
 
         parents = reply1.parentsInThread()
-        assert len( parents ) == 1
-        assert test in parents
+        self.assertEqual(len(parents), 1)
+        self.assertTrue(test in parents)
 
         talkback1 = dtool.getDiscussionFor(reply1)
-        assert talkback == talkback1
-        assert len( talkback1.getReplies() ) == 0
-        assert len( talkback.getReplies() ) == 1
+        self.assertEqual(talkback, talkback1)
+        self.assertEqual(len(talkback1.getReplies()), 0)
+        self.assertEqual(len(talkback.getReplies()), 1)
 
-        talkback1.createReply( title='test2'
-                             , text='blah2'
-                             )
-        assert len( talkback._container ) == 2
-        assert talkback1.hasReplies( reply1 )
-        assert len( talkback1.getReplies() ) == 1
-        assert len( talkback.getReplies() ) == 1
+        talkback1.createReply(title='test2', text='blah2')
+        self.assertEqual(len(talkback._container), 2)
+        self.assertTrue(talkback1.hasReplies(reply1))
+        self.assertEqual(len(talkback1.getReplies()), 1)
+        self.assertEqual(len(talkback.getReplies()), 1)
 
         reply2 = talkback1.getReplies()[0]
-        assert reply2.inReplyTo() == reply1
+        self.assertEqual(reply2.inReplyTo(), reply1)
 
         parents = reply2.parentsInThread()
-        assert len( parents ) == 2
-        assert parents[ 0 ] == test
-        assert parents[ 1 ] == reply1
+        self.assertEqual(len(parents), 2)
+        self.assertEqual(parents[0], test)
+        self.assertEqual(parents[1], reply1)
 
-        parents = reply2.parentsInThread( 1 )
-        assert len( parents ) == 1
-        assert parents[ 0 ] == reply1
+        parents = reply2.parentsInThread(1)
+        self.assertEqual(len(parents), 1)
+        self.assertEqual(parents[0], reply1)
 
     def test_itemCataloguing(self):
         ctool = CatalogTool()
@@ -182,42 +180,37 @@
         test = self._makeDummyContent('test', catalog=1)
         test.allow_discussion = 1
 
-        self.assertEqual( len(ctool), 1 )
-        self.failUnless(has_path(ctool, test.getPhysicalPath()))
+        self.assertEqual(len(ctool), 1)
+        self.assertTrue(has_path(ctool, test.getPhysicalPath()))
         talkback = dtool.getDiscussionFor(test)
-        self.assertEqual( talkback.getPhysicalPath(),
-                          ('', 'bar', 'site', 'test', 'talkback') )
-        talkback.createReply( title='test'
-                            , text='blah'
-                            )
-        self.assertEqual( len(ctool), 2 )
+        self.assertEqual(talkback.getPhysicalPath(),
+                         ('', 'bar', 'site', 'test', 'talkback'))
+        talkback.createReply(title='test', text='blah')
+        self.assertEqual(len(ctool), 2)
         for reply in talkback.getReplies():
-            self.failUnless(has_path(ctool, reply.getPhysicalPath()))
-            self.failUnless(has_path(ctool, '/bar/site/test/talkback/%s'
+            self.assertTrue(has_path(ctool, reply.getPhysicalPath()))
+            self.assertTrue(has_path(ctool, '/bar/site/test/talkback/%s'
                                             % reply.getId()))
 
         reply1 = talkback.getReplies()[0]
         path1 = '/'.join(reply1.getPhysicalPath())
-        self.assertEqual( ctool.getMetadataForUID(path1),
-                          {'in_reply_to': None} )
+        self.assertEqual(ctool.getMetadataForUID(path1), {'in_reply_to': None})
 
         talkback1 = dtool.getDiscussionFor(reply1)
-        talkback1.createReply( title='test2'
-                             , text='blah2'
-                             )
+        talkback1.createReply(title='test2', text='blah2')
         for reply in talkback.getReplies():
-            self.failUnless(has_path(ctool, reply.getPhysicalPath()))
-            self.failUnless(has_path(ctool, '/bar/site/test/talkback/%s'
+            self.assertTrue(has_path(ctool, reply.getPhysicalPath()))
+            self.assertTrue(has_path(ctool, '/bar/site/test/talkback/%s'
                                             % reply.getId()))
         for reply in talkback1.getReplies():
-            self.failUnless(has_path(ctool, reply.getPhysicalPath()))
-            self.failUnless(has_path(ctool, '/bar/site/test/talkback/%s'
+            self.assertTrue(has_path(ctool, reply.getPhysicalPath()))
+            self.assertTrue(has_path(ctool, '/bar/site/test/talkback/%s'
                                             % reply.getId()))
 
         reply2 = talkback1.getReplies()[0]
         path2 = '/'.join(reply2.getPhysicalPath())
-        self.assertEqual( ctool.getMetadataForUID(path2),
-                          {'in_reply_to': reply1.getId()} )
+        self.assertEqual(ctool.getMetadataForUID(path2),
+                         {'in_reply_to': reply1.getId()})
 
     def test_itemWorkflowNotification(self):
         from Products.CMFDefault.DiscussionItem import DiscussionItem
@@ -246,7 +239,7 @@
             else:
                 DiscussionItem.notifyWorkflowCreated = old_method
 
-    def test_deletePropagation( self ):
+    def test_deletePropagation(self):
         ctool = CatalogTool()
         getSiteManager().registerUtility(ctool, ICatalogTool)
         dtool = self.dtool
@@ -254,12 +247,10 @@
         test.allow_discussion = 1
 
         talkback = dtool.getDiscussionFor(test)
-        talkback.createReply( title='test'
-                            , text='blah'
-                            )
-        self.assertEqual( len(ctool), 2 )
+        talkback.createReply(title='test', text='blah')
+        self.assertEqual(len(ctool), 2)
         self.site._delObject('test')
-        self.assertEqual( len(ctool), 0 )
+        self.assertEqual(len(ctool), 0)
 
     def test_deleteReplies(self):
         dtool = self.dtool
@@ -314,9 +305,9 @@
         test.allow_discussion = 1
         dtool = self.dtool
         talkback = dtool.getDiscussionFor(test)
-        self.failUnless(hasattr(talkback, 'aq_base'))
+        self.assertTrue(hasattr(talkback, 'aq_base'))
         # Acquire REQUEST
-        self.failUnless(getattr(talkback, 'REQUEST'))
+        self.assertTrue(getattr(talkback, 'REQUEST'))
 
     def test_existingTalkbackIsWrapped(self):
         test = self._makeDummyContent('test')
@@ -324,9 +315,9 @@
         dtool = self.dtool
         dtool.getDiscussionFor(test)
         talkback = dtool.getDiscussionFor(test)
-        self.failUnless(hasattr(talkback, 'aq_base'))
+        self.assertTrue(hasattr(talkback, 'aq_base'))
         # Acquire REQUEST
-        self.failUnless(getattr(talkback, 'REQUEST'))
+        self.assertTrue(getattr(talkback, 'REQUEST'))
 
 
 def test_suite():

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DublinCore.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DublinCore.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_DublinCore.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -42,7 +42,7 @@
 
     if isinstance(t_val, long):
         # t_val must be IntType, not LongType
-        raise OverflowError("Date too big: %s" % `value`)
+        raise OverflowError("Date too big: %s" % repr(value))
 
     return t_val
 
@@ -82,46 +82,46 @@
         verifyClass(IMutableDublinCore, DefaultDublinCoreImpl)
 
     def test_notifyModified(self):
-        site = DummySite('site').__of__(self.root)
-        acl_users = site._setObject( 'acl_users', DummyUserFolder() )
-        site._setObject( 'portal_membership', MembershipTool() )
+        site = DummySite('site').__of__(self.app)
+        acl_users = site._setObject('acl_users', DummyUserFolder())
+        site._setObject('portal_membership', MembershipTool())
         newSecurityManager(None, acl_users.user_foo)
         item = self._makeDummyContent('item').__of__(site)
-        self.assertEqual( item.listCreators(), () )
+        self.assertEqual(item.listCreators(), ())
         item.setModificationDate(0)
         initial_date = item.ModificationDate()
 
         item.notifyModified()
-        self.assertEqual( item.listCreators(), ('user_foo',) )
-        self.assertNotEqual( item.ModificationDate(), initial_date )
+        self.assertEqual(item.listCreators(), ('user_foo',))
+        self.assertNotEqual(item.ModificationDate(), initial_date)
 
     def test_creators_methods(self):
-        site = DummySite('site').__of__(self.root)
-        acl_users = site._setObject( 'acl_users', DummyUserFolder() )
-        site._setObject( 'portal_membership', MembershipTool() )
+        site = DummySite('site').__of__(self.app)
+        acl_users = site._setObject('acl_users', DummyUserFolder())
+        site._setObject('portal_membership', MembershipTool())
         newSecurityManager(None, acl_users.user_foo)
         item = self._makeDummyContent('item').__of__(site)
-        self.assertEqual( item.listCreators(), () )
+        self.assertEqual(item.listCreators(), ())
 
         item.addCreator()
-        self.assertEqual( item.listCreators(), ('user_foo',) )
+        self.assertEqual(item.listCreators(), ('user_foo',))
         newSecurityManager(None, acl_users.user_bar)
         item.addCreator()
-        self.assertEqual( item.listCreators(), ('user_foo', 'user_bar') )
+        self.assertEqual(item.listCreators(), ('user_foo', 'user_bar'))
         item.addCreator()
-        self.assertEqual( item.listCreators(), ('user_foo', 'user_bar') )
+        self.assertEqual(item.listCreators(), ('user_foo', 'user_bar'))
         item.addCreator('user_baz')
-        self.assertEqual( item.listCreators(),
-                          ('user_foo', 'user_bar', 'user_baz') )
+        self.assertEqual(item.listCreators(),
+                         ('user_foo', 'user_bar', 'user_baz'))
         item.setCreators('user_bar')
-        self.assertEqual( item.listCreators(), ('user_bar',) )
-        item.setCreators( ('user_baz',) )
-        self.assertEqual( item.listCreators(), ('user_baz',) )
+        self.assertEqual(item.listCreators(), ('user_bar',))
+        item.setCreators(('user_baz',))
+        self.assertEqual(item.listCreators(), ('user_baz',))
 
     def test_creators_upgrade(self):
-        site = DummySite('site').__of__(self.root)
-        acl_users = site._setObject( 'acl_users', DummyUserFolder() )
-        site._setObject( 'portal_membership', MembershipTool() )
+        site = DummySite('site').__of__(self.app)
+        acl_users = site._setObject('acl_users', DummyUserFolder())
+        site._setObject('portal_membership', MembershipTool())
         newSecurityManager(None, acl_users.user_foo)
         item = self._makeDummyContent('item').__of__(site)
         item.manage_fixupOwnershipAfterAdd()
@@ -140,19 +140,19 @@
 
     def test_ceiling_parsable(self):
         # Test that a None ceiling date will be parsable by a DateIndex
-        site = DummySite('site').__of__(self.root)
+        site = DummySite('site').__of__(self.app)
         item = self._makeDummyContent('item').__of__(site)
         self.assertEqual(item.expiration_date, None)
-        self.assert_(_DateIndexConvert(item.expires()))
+        self.assertTrue(_DateIndexConvert(item.expires()))
 
     def test_publisher_no_metadata_tool(self):
-        site = DummySite('site').__of__(self.root)
+        site = DummySite('site').__of__(self.app)
         item = self._makeDummyContent('item').__of__(site)
         self.assertEqual(item.Publisher(), 'No publisher')
 
     def test_publisher_with_metadata_tool(self):
         PUBLISHER = 'Some Publisher'
-        site = DummySite('site').__of__(self.root)
+        site = DummySite('site').__of__(self.app)
         tool = DummyMetadataTool(publisher=PUBLISHER)
         getSiteManager().registerUtility(tool, IMetadataTool)
         item = self._makeDummyContent('item').__of__(site)
@@ -164,7 +164,7 @@
         # e.g. 4 hours further away from UTC, the DC date methods
         # should still return it in the local timezone so that all
         # user-visible dates can be compared to each other by eye.
-        site = DummySite('site').__of__(self.root)
+        site = DummySite('site').__of__(self.app)
         item = self._makeDummyContent('item').__of__(site)
         dates_and_methods = (
             ('modification_date', 'ModificationDate'),
@@ -181,7 +181,7 @@
                 setattr(item, datename, orig)
             orig_DC = getattr(item, dc_methodname)()
             # Change the timezone of the date.
-            local_offset = orig.tzoffset() % (3600*24)
+            local_offset = orig.tzoffset() % (3600 * 24)
             other_offset = (local_offset + offset) % 24
             otherzone = 'GMT+%d' % other_offset
             setattr(item, datename, orig.toZone(otherzone))

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_File.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_File.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_File.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -139,17 +139,19 @@
         self.assertEqual(len(data), len(ref))
         self.assertEqual(data, ref)
         # ICK!  'HTTPResponse.getHeader' doesn't case-flatten the key!
-        self.assertEqual(self.RESPONSE.getHeader('Content-Length'.lower())
-                        , str(len(ref)))
-        self.assertEqual(self.RESPONSE.getHeader('Content-Type'.lower())
-                        , 'application/octet-stream')
-        self.assertEqual(self.RESPONSE.getHeader('Last-Modified'.lower())
-                        , rfc1123_date(mod_time))
+        self.assertEqual(self.RESPONSE.getHeader('Content-Length'.lower()),
+                         str(len(ref)))
+        self.assertEqual(self.RESPONSE.getHeader('Content-Type'.lower()),
+                         'application/octet-stream')
+        self.assertEqual(self.RESPONSE.getHeader('Last-Modified'.lower()),
+                         rfc1123_date(mod_time))
 
     def test_caching(self):
         large_data = '0' * 100000
+
         def fake_response_write(data):
             return
+
         response_write = self.RESPONSE.write
         self.RESPONSE.write = fake_response_write
         cpm = DummyCachingManager()
@@ -159,15 +161,15 @@
         obj = obj.__of__(self.app)
         obj.index_html(self.REQUEST, self.RESPONSE)
         headers = self.RESPONSE.headers
-        self.failUnless(len(headers) >= original_len + 3)
-        self.failUnless('foo' in headers.keys())
-        self.failUnless('bar' in headers.keys())
+        self.assertTrue(len(headers) >= original_len + 3)
+        self.assertTrue('foo' in headers.keys())
+        self.assertTrue('bar' in headers.keys())
         self.assertEqual(headers['test_path'], '/test_file')
         self.RESPONSE.write = response_write
 
     def test_caching_policy_headers_are_canonical(self):
         """Ensure that headers set by the caching policy manager trump
-        any of the same name that from time to time may be set while 
+        any of the same name that from time to time may be set while
         rendering the object."""
         _path, ref = self._extractFile()
 
@@ -183,6 +185,7 @@
         self.assertEqual(headers['last-modified'],
                          "Sun, 06 Nov 1994 08:49:37 GMT")
 
+
 # We set up a new type of dummy caching manager that sets a bogus
 # last modified date.  This should be visible in the request
 class LMDummyCachingManager(DummyCachingManager):

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_Image.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_Image.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_Image.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -57,7 +57,7 @@
 
     def setUp(self):
         self.site = DummySite('site')
-        self.site._setObject( 'portal_membership', DummyTool() )
+        self.site._setObject('portal_membership', DummyTool())
 
     def test_interfaces(self):
         from Products.CMFDefault.interfaces import IFile
@@ -84,17 +84,17 @@
 
         testfile = open(TEST_JPG, 'rb')
         image.edit(file=testfile)
-        testfile.seek(0,2)
+        testfile.seek(0, 2)
         testfilesize = testfile.tell()
         testfile.close()
 
-        assert image.get_size() == testfilesize
+        self.assertEqual(image.get_size(), testfilesize)
 
         emptyfile = StringIO()
         image.edit(file=emptyfile)
 
-        assert image.get_size() > 0
-        assert image.get_size() == testfilesize
+        self.assertTrue(image.get_size() > 0)
+        self.assertEqual(image.get_size(), testfilesize)
 
     def test_Image_setFormat(self):
         # Setting the DC.format must also set the content_type property
@@ -140,52 +140,60 @@
         # Copy/pasting a File should reset wf state to private
         cb = self.site.manage_copyObjects(['file'])
         self.subfolder.manage_pasteObjects(cb)
-        review_state = self.workflow.getInfoFor(self.subfolder.file, 'review_state')
+        review_state = self.workflow.getInfoFor(self.subfolder.file,
+                                                'review_state')
         self.assertEqual(review_state, 'private')
 
     def test_File_CloneResetsWorkflowState(self):
         # Cloning a File should reset wf state to private
         self.subfolder.manage_clone(self.site.file, 'file')
-        review_state = self.workflow.getInfoFor(self.subfolder.file, 'review_state')
+        review_state = self.workflow.getInfoFor(self.subfolder.file,
+                                                'review_state')
         self.assertEqual(review_state, 'private')
 
     def test_File_CutPasteKeepsWorkflowState(self):
         # Cut/pasting a File should keep the wf state
         cb = self.site.manage_cutObjects(['file'])
         self.subfolder.manage_pasteObjects(cb)
-        review_state = self.workflow.getInfoFor(self.subfolder.file, 'review_state')
+        review_state = self.workflow.getInfoFor(self.subfolder.file,
+                                                'review_state')
         self.assertEqual(review_state, 'published')
 
     def test_File_RenameKeepsWorkflowState(self):
         # Renaming a File should keep the wf state
         self.site.manage_renameObjects(['file'], ['file2'])
-        review_state = self.workflow.getInfoFor(self.site.file2, 'review_state')
+        review_state = self.workflow.getInfoFor(self.site.file2,
+                                                'review_state')
         self.assertEqual(review_state, 'published')
 
     def test_Image_CopyPasteResetsWorkflowState(self):
         #  Copy/pasting an Image should reset wf state to private
         cb = self.site.manage_copyObjects(['image'])
         self.subfolder.manage_pasteObjects(cb)
-        review_state = self.workflow.getInfoFor(self.subfolder.image, 'review_state')
+        review_state = self.workflow.getInfoFor(self.subfolder.image,
+                                                'review_state')
         self.assertEqual(review_state, 'private')
 
     def test_Image_CloneResetsWorkflowState(self):
         # Cloning an Image should reset wf state to private
         self.subfolder.manage_clone(self.site.image, 'image')
-        review_state = self.workflow.getInfoFor(self.subfolder.image, 'review_state')
+        review_state = self.workflow.getInfoFor(self.subfolder.image,
+                                                'review_state')
         self.assertEqual(review_state, 'private')
 
     def test_Image_CutPasteKeepsWorkflowState(self):
         # Cut/pasting an Image should keep the wf state
         cb = self.site.manage_cutObjects(['image'])
         self.subfolder.manage_pasteObjects(cb)
-        review_state = self.workflow.getInfoFor(self.subfolder.image, 'review_state')
+        review_state = self.workflow.getInfoFor(self.subfolder.image,
+                                                'review_state')
         self.assertEqual(review_state, 'published')
 
     def test_Image_RenameKeepsWorkflowState(self):
         # Renaming an Image should keep the wf state
         self.site.manage_renameObjects(['image'], ['image2'])
-        review_state = self.workflow.getInfoFor(self.site.image2, 'review_state')
+        review_state = self.workflow.getInfoFor(self.site.image2,
+                                                'review_state')
         self.assertEqual(review_state, 'published')
 
 
@@ -245,17 +253,19 @@
         self.assertEqual(len(data), len(ref))
         self.assertEqual(data, ref)
         # ICK!  'HTTPResponse.getHeader' doesn't case-flatten the key!
-        self.assertEqual(self.RESPONSE.getHeader('Content-Length'.lower())
-                        , str(len(ref)))
-        self.assertEqual(self.RESPONSE.getHeader('Content-Type'.lower())
-                        , 'image/jpeg')
-        self.assertEqual(self.RESPONSE.getHeader('Last-Modified'.lower())
-                        , rfc1123_date(mod_time))
+        self.assertEqual(self.RESPONSE.getHeader('Content-Length'.lower()),
+                         str(len(ref)))
+        self.assertEqual(self.RESPONSE.getHeader('Content-Type'.lower()),
+                         'image/jpeg')
+        self.assertEqual(self.RESPONSE.getHeader('Last-Modified'.lower()),
+                         rfc1123_date(mod_time))
 
     def test_caching(self):
         large_data = '0' * 100000
+
         def fake_response_write(data):
             return
+
         response_write = self.RESPONSE.write
         self.RESPONSE.write = fake_response_write
         cpm = DummyCachingManager()
@@ -265,9 +275,9 @@
         obj = obj.__of__(self.app)
         obj.index_html(self.REQUEST, self.RESPONSE)
         headers = self.RESPONSE.headers
-        self.failUnless(len(headers) >= original_len + 3)
-        self.failUnless('foo' in headers.keys())
-        self.failUnless('bar' in headers.keys())
+        self.assertTrue(len(headers) >= original_len + 3)
+        self.assertTrue('foo' in headers.keys())
+        self.assertTrue('bar' in headers.keys())
         self.assertEqual(headers['test_path'], '/test_image')
         self.RESPONSE.write = response_write
 
@@ -277,7 +287,8 @@
         getSiteManager().registerUtility(cpm, ICachingPolicyManager)
         original_len = len(self.RESPONSE.headers)
         _path, ref = self._extractFile()
-        self.app.image = self._makeOne('test_image', 'test_image.gif', file=ref)
+        self.app.image = self._makeOne('test_image', 'test_image.gif',
+                                       file=ref)
         image = self.app.image
         transaction.savepoint(optimistic=True)
 
@@ -292,14 +303,14 @@
         self.assertEqual(self.RESPONSE.getStatus(), 304)
 
         headers = self.RESPONSE.headers
-        self.failUnless(len(headers) >= original_len + 3)
-        self.failUnless('foo' in headers.keys())
-        self.failUnless('bar' in headers.keys())
+        self.assertTrue(len(headers) >= original_len + 3)
+        self.assertTrue('foo' in headers.keys())
+        self.assertTrue('bar' in headers.keys())
         self.assertEqual(headers['test_path'], '/test_image')
 
     def test_caching_policy_headers_are_canonical(self):
         """Ensure that headers set by the caching policy manager trump
-        any of the same name that from time to time may be set while 
+        any of the same name that from time to time may be set while
         rendering the object."""
         _path, ref = self._extractFile()
 

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_MembershipTool.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_MembershipTool.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_MembershipTool.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -110,7 +110,7 @@
     def setUp(self):
         SecurityTest.setUp(self)
         self.site = DummySite('site').__of__(self.app)
-        self.site._setObject( 'portal_membership', self._makeOne() )
+        self.site._setObject('portal_membership', self._makeOne())
 
     def tearDown(self):
         cleanUp()
@@ -118,49 +118,49 @@
 
     def test_createMemberArea(self):
         mtool = self.site.portal_membership
-        members = self.site._setObject( 'Members', PortalFolder('Members') )
-        acl_users = self.site._setObject( 'acl_users', DummyUserFolder() )
+        members = self.site._setObject('Members', PortalFolder('Members'))
+        acl_users = self.site._setObject('acl_users', DummyUserFolder())
         wtool = DummyTool()
         getSiteManager().registerUtility(wtool, IWorkflowTool)
 
         # permission
         mtool.createMemberArea('user_foo')
-        self.failIf( hasattr(members.aq_self, 'user_foo') )
+        self.assertFalse(hasattr(members.aq_self, 'user_foo'))
         newSecurityManager(None, acl_users.user_bar)
         mtool.createMemberArea('user_foo')
-        self.failIf( hasattr(members.aq_self, 'user_foo') )
+        self.assertFalse(hasattr(members.aq_self, 'user_foo'))
         newSecurityManager(None, acl_users.user_foo)
         mtool.setMemberareaCreationFlag()
         mtool.createMemberArea('user_foo')
-        self.failIf( hasattr(members.aq_self, 'user_foo') )
+        self.assertFalse(hasattr(members.aq_self, 'user_foo'))
         newSecurityManager(None, acl_users.all_powerful_Oz)
         mtool.setMemberareaCreationFlag()
         mtool.createMemberArea('user_foo')
-        self.failUnless( hasattr(members.aq_self, 'user_foo') )
+        self.assertTrue(hasattr(members.aq_self, 'user_foo'))
 
         # default content
         f = members.user_foo
         ownership = acl_users.user_foo
-        localroles = ( ( 'user_foo', ('Owner',) ), )
-        self.assertEqual( f.Title(), "user_foo's Home" )
-        self.assertEqual( f.getOwner(), ownership )
-        self.assertEqual( f.get_local_roles(), localroles,
-                          'CMF Collector issue #162 (LocalRoles broken): %s'
-                          % str( f.get_local_roles() ) )
-        self.assertEqual( f.index_html.getOwner(), ownership,
-                          'CMF Collector issue #162 (Ownership broken): %s'
-                          % str( f.index_html.getOwner() ) )
-        self.assertEqual( f.index_html.get_local_roles(), localroles,
-                          'CMF Collector issue #162 (LocalRoles broken): %s'
-                          % str( f.index_html.get_local_roles() ) )
-        self.assertEqual( wtool.test_notified, f.index_html )
+        localroles = (('user_foo', ('Owner',)),)
+        self.assertEqual(f.Title(), "user_foo's Home")
+        self.assertEqual(f.getOwner(), ownership)
+        self.assertEqual(f.get_local_roles(), localroles,
+                         'CMF Collector issue #162 (LocalRoles broken): %s'
+                         % str(f.get_local_roles()))
+        self.assertEqual(f.index_html.getOwner(), ownership,
+                         'CMF Collector issue #162 (Ownership broken): %s'
+                         % str(f.index_html.getOwner()))
+        self.assertEqual(f.index_html.get_local_roles(), localroles,
+                         'CMF Collector issue #162 (LocalRoles broken): %s'
+                         % str(f.index_html.get_local_roles()))
+        self.assertEqual(wtool.test_notified, f.index_html)
 
         # acquisition
         self.site.user_bar = 'test attribute'
         newSecurityManager(None, acl_users.user_bar)
         mtool.createMemberArea('user_bar')
-        self.failUnless( hasattr(members.aq_self, 'user_bar'),
-                         'CMF Collector issue #102 (acquisition bug)' )
+        self.assertTrue(hasattr(members.aq_self, 'user_bar'),
+                        'CMF Collector issue #102 (acquisition bug)')
 
 
 def test_suite():

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_MetadataTool.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_MetadataTool.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_MetadataTool.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -22,118 +22,116 @@
 
 class TestMetadataElementPolicy(unittest.TestCase):
 
-    def _getTargetClass( self ):
+    def _getTargetClass(self):
         from Products.CMFDefault.MetadataTool import MetadataElementPolicy
         return MetadataElementPolicy
 
-    def _makeOne( self, *args, **kw ):
-        return self._getTargetClass()( *args, **kw )
+    def _makeOne(self, *args, **kw):
+        return self._getTargetClass()(*args, **kw)
 
-    def test_empty_single_valued( self ):
-        sv_policy = self._makeOne( 0 )
-        self.failIf( sv_policy.isMultiValued() )
-        self.failIf( sv_policy.isRequired() )
-        self.failIf( sv_policy.supplyDefault() )
-        self.failIf( sv_policy.defaultValue() )
-        self.failIf( sv_policy.enforceVocabulary() )
-        self.failIf( sv_policy.allowedVocabulary() )
+    def test_empty_single_valued(self):
+        sv_policy = self._makeOne(0)
+        self.assertFalse(sv_policy.isMultiValued())
+        self.assertFalse(sv_policy.isRequired())
+        self.assertFalse(sv_policy.supplyDefault())
+        self.assertFalse(sv_policy.defaultValue())
+        self.assertFalse(sv_policy.enforceVocabulary())
+        self.assertFalse(sv_policy.allowedVocabulary())
 
-    def test_edit_single_valued( self ):
-        sv_policy = self._makeOne( 0 )
-        sv_policy.edit( 1, 1, 'xxx', 0, '' )
-        self.failIf( sv_policy.isMultiValued() )
-        self.failUnless( sv_policy.isRequired() )
-        self.failUnless( sv_policy.supplyDefault() )
-        self.assertEquals( sv_policy.defaultValue(), 'xxx' )
-        self.failIf( sv_policy.enforceVocabulary() )
-        self.failIf( sv_policy.allowedVocabulary() )
+    def test_edit_single_valued(self):
+        sv_policy = self._makeOne(0)
+        sv_policy.edit(1, 1, 'xxx', 0, '')
+        self.assertFalse(sv_policy.isMultiValued())
+        self.assertTrue(sv_policy.isRequired())
+        self.assertTrue(sv_policy.supplyDefault())
+        self.assertEqual(sv_policy.defaultValue(), 'xxx')
+        self.assertFalse(sv_policy.enforceVocabulary())
+        self.assertFalse(sv_policy.allowedVocabulary())
 
-    def test_empty_multi_valued( self ):
-        mv_policy = self._makeOne( 1 )
-        self.failUnless( mv_policy.isMultiValued() )
-        self.failIf( mv_policy.isRequired() )
-        self.failIf( mv_policy.supplyDefault() )
-        self.failIf( mv_policy.defaultValue() )
-        self.failIf( mv_policy.enforceVocabulary() )
-        self.failIf( mv_policy.allowedVocabulary() )
+    def test_empty_multi_valued(self):
+        mv_policy = self._makeOne(1)
+        self.assertTrue(mv_policy.isMultiValued())
+        self.assertFalse(mv_policy.isRequired())
+        self.assertFalse(mv_policy.supplyDefault())
+        self.assertFalse(mv_policy.defaultValue())
+        self.assertFalse(mv_policy.enforceVocabulary())
+        self.assertFalse(mv_policy.allowedVocabulary())
 
-    def test_edit_multi_valued( self ):
-        mv_policy = self._makeOne( 1 )
-        mv_policy.edit( 1, 1, 'xxx', 1, ( 'xxx', 'yyy' ) )
-        self.failUnless( mv_policy.isMultiValued() )
-        self.failUnless( mv_policy.isRequired() )
-        self.failUnless( mv_policy.supplyDefault() )
-        self.assertEqual( mv_policy.defaultValue(), 'xxx' )
-        self.failUnless( mv_policy.enforceVocabulary() )
-        self.assertEqual( len( mv_policy.allowedVocabulary() ), 2 )
-        self.failUnless( 'xxx' in mv_policy.allowedVocabulary() )
-        self.failUnless( 'yyy' in mv_policy.allowedVocabulary() )
+    def test_edit_multi_valued(self):
+        mv_policy = self._makeOne(1)
+        mv_policy.edit(1, 1, 'xxx', 1, ('xxx', 'yyy'))
+        self.assertTrue(mv_policy.isMultiValued())
+        self.assertTrue(mv_policy.isRequired())
+        self.assertTrue(mv_policy.supplyDefault())
+        self.assertEqual(mv_policy.defaultValue(), 'xxx')
+        self.assertTrue(mv_policy.enforceVocabulary())
+        self.assertEqual(len(mv_policy.allowedVocabulary()), 2)
+        self.assertTrue('xxx' in mv_policy.allowedVocabulary())
+        self.assertTrue('yyy' in mv_policy.allowedVocabulary())
 
 
 class TestElementSpec(unittest.TestCase):
 
-    def _getTargetClass( self ):
+    def _getTargetClass(self):
         from Products.CMFDefault.MetadataTool import ElementSpec
         return ElementSpec
 
-    def _makeOne( self, *args, **kw ):
-        return self._getTargetClass()( *args, **kw )
+    def _makeOne(self, *args, **kw):
+        return self._getTargetClass()(*args, **kw)
 
-    def test_empty_single_valued( self ):
-        sv_spec = self._makeOne( 0 )
-        self.failIf( sv_spec.isMultiValued() )
-        self.assertEqual( sv_spec.getPolicy(), sv_spec.getPolicy( 'XYZ' ) )
+    def test_empty_single_valued(self):
+        sv_spec = self._makeOne(0)
+        self.assertFalse(sv_spec.isMultiValued())
+        self.assertEqual(sv_spec.getPolicy(), sv_spec.getPolicy('XYZ'))
         policies = sv_spec.listPolicies()
-        self.assertEqual( len( policies ), 1 )
-        self.assertEqual( policies[0][0], None )
+        self.assertEqual(len(policies), 1)
+        self.assertEqual(policies[0][0], None)
 
-    def test_empty_multi_valued( self ):
-        mv_spec = self._makeOne( 1 )
-        self.failUnless( mv_spec.isMultiValued() )
-        self.assertEqual( mv_spec.getPolicy(), mv_spec.getPolicy( 'XYZ' ) )
+    def test_empty_multi_valued(self):
+        mv_spec = self._makeOne(1)
+        self.assertTrue(mv_spec.isMultiValued())
+        self.assertEqual(mv_spec.getPolicy(), mv_spec.getPolicy('XYZ'))
         policies = mv_spec.listPolicies()
-        self.assertEqual( len( policies ), 1 )
-        self.assertEqual( policies[0][0], None )
+        self.assertEqual(len(policies), 1)
+        self.assertEqual(policies[0][0], None)
 
 
-
 class TestMetadataSchema(unittest.TestCase):
 
-    def _getTargetClass( self ):
+    def _getTargetClass(self):
         from Products.CMFDefault.MetadataTool import MetadataSchema
         return MetadataSchema
 
-    def _makeOne( self, *args, **kw ):
-        return self._getTargetClass()( *args, **kw )
+    def _makeOne(self, *args, **kw):
+        return self._getTargetClass()(*args, **kw)
 
 
 class TestMetadataTool(unittest.TestCase):
 
-    def _getTargetClass( self ):
+    def _getTargetClass(self):
         from Products.CMFDefault.MetadataTool import MetadataTool
         return MetadataTool
 
-    def _makeOne( self, *args, **kw ):
-        return self._getTargetClass()( *args, **kw )
+    def _makeOne(self, *args, **kw):
+        return self._getTargetClass()(*args, **kw)
 
-    def _makeTestObjects( self ):
-
+    def _makeTestObjects(self):
         from Products.CMFDefault.DublinCore import DefaultDublinCoreImpl
-        class Foo( DefaultDublinCoreImpl ):
 
+        class Foo(DefaultDublinCoreImpl):
+
             description = title = language = format = rights = ''
             subject = ()
 
-            def __init__( self ):
+            def __init__(self):
                 pass # skip DDCI's default values
 
-            def getPortalTypeName( self ):
+            def getPortalTypeName(self):
                 return 'Foo'
 
+        class Bar(Foo):
 
-        class Bar( Foo ):
-
-            def getPortalTypeName( self ):
+            def getPortalTypeName(self):
                 return 'Bar'
 
         return Foo(), Bar()
@@ -143,340 +141,337 @@
 
         verifyClass(IMetadataTool, self._getTargetClass())
 
-    def test_empty( self ):
+    def test_empty(self):
         from Products.CMFDefault.MetadataTool import _DCMI_ELEMENT_SPECS
 
         tool = self._makeOne()
-        self.failIf( tool.getPublisher() )
-        self.assertEqual( tool.getFullName( 'foo' ), 'foo' )
+        self.assertFalse(tool.getPublisher())
+        self.assertEqual(tool.getFullName('foo'), 'foo')
 
         dcmi = tool.DCMI
-        specs = list( dcmi.DCMI.listElementSpecs() )
-        defaults = list( _DCMI_ELEMENT_SPECS )
-        specs.sort(); defaults.sort()
+        specs = list(dcmi.DCMI.listElementSpecs())
+        defaults = list(_DCMI_ELEMENT_SPECS)
+        specs.sort()
+        defaults.sort()
 
-        self.assertEqual( len( specs ), len( defaults ) )
-        for i in range( len( specs ) ):
-            self.assertEqual( specs[i][0], defaults[i][0] )
-            self.assertEqual( specs[i][1].isMultiValued(), defaults[i][1] )
+        self.assertEqual(len(specs), len(defaults))
+        for i in range(len(specs)):
+            self.assertEqual(specs[i][0], defaults[i][0])
+            self.assertEqual(specs[i][1].isMultiValued(), defaults[i][1])
             policies = specs[i][1].listPolicies()
-            self.assertEqual( len( policies ), 1 )
-            self.failUnless( policies[0][0] is None )
+            self.assertEqual(len(policies), 1)
+            self.assertTrue(policies[0][0] is None)
 
-        self.failIf( dcmi.getElementSpec( 'Title' ).isMultiValued() )
-        self.failIf( dcmi.getElementSpec( 'Description' ).isMultiValued() )
-        self.failUnless( dcmi.getElementSpec( 'Subject' ).isMultiValued() )
-        self.failIf( dcmi.getElementSpec( 'Format' ).isMultiValued() )
-        self.failIf( dcmi.getElementSpec( 'Language' ).isMultiValued() )
-        self.failIf( dcmi.getElementSpec( 'Rights' ).isMultiValued() )
+        self.assertFalse(dcmi.getElementSpec('Title').isMultiValued())
+        self.assertFalse(dcmi.getElementSpec('Description').isMultiValued())
+        self.assertTrue(dcmi.getElementSpec('Subject').isMultiValued())
+        self.assertFalse(dcmi.getElementSpec('Format').isMultiValued())
+        self.assertFalse(dcmi.getElementSpec('Language').isMultiValued())
+        self.assertFalse(dcmi.getElementSpec('Rights').isMultiValued())
 
         try:
-            dummy = dcmi.getElementSpec( 'Foo' )
+            dummy = dcmi.getElementSpec('Foo')
         except KeyError:
             pass
         else:
-            self.failUnless( 0, "Expected KeyError" )
+            self.assertTrue(0, "Expected KeyError")
 
-        self.failIf( dcmi.listAllowedSubjects() )
-        self.failIf( dcmi.listAllowedFormats() )
-        self.failIf( dcmi.listAllowedLanguages() )
-        self.failIf( dcmi.listAllowedRights() )
+        self.assertFalse(dcmi.listAllowedSubjects())
+        self.assertFalse(dcmi.listAllowedFormats())
+        self.assertFalse(dcmi.listAllowedLanguages())
+        self.assertFalse(dcmi.listAllowedRights())
 
-    def test_DCMI_addElementSpec( self ):
+    def test_DCMI_addElementSpec(self):
         from Products.CMFDefault.MetadataTool import _DCMI_ELEMENT_SPECS
 
         tool = self._makeOne()
         dcmi = tool.DCMI
-        dcmi.addElementSpec( 'Rating', 1 )
-        self.assertEqual( len( dcmi.listElementSpecs() )
-                        , len( _DCMI_ELEMENT_SPECS ) + 1 )
-        rating = dcmi.getElementSpec( 'Rating' )
-        self.failUnless( rating.isMultiValued() )
+        dcmi.addElementSpec('Rating', 1)
+        self.assertEqual(len(dcmi.listElementSpecs()),
+                         len(_DCMI_ELEMENT_SPECS) + 1)
+        rating = dcmi.getElementSpec('Rating')
+        self.assertTrue(rating.isMultiValued())
 
-    def test_DCMI_removeElementSpec( self ):
+    def test_DCMI_removeElementSpec(self):
         from Products.CMFDefault.MetadataTool import _DCMI_ELEMENT_SPECS
 
         tool = self._makeOne()
         dcmi = tool.DCMI
-        dcmi.removeElementSpec( 'Rights' )
+        dcmi.removeElementSpec('Rights')
 
-        self.assertEqual( len( dcmi.listElementSpecs() )
-                        , len( _DCMI_ELEMENT_SPECS ) - 1
-                        )
+        self.assertEqual(len(dcmi.listElementSpecs()),
+                         len(_DCMI_ELEMENT_SPECS) - 1)
 
-        self.assertRaises( KeyError, dcmi.getElementSpec, 'Rights' )
-        self.assertRaises( KeyError, dcmi.removeElementSpec, 'Foo' )
+        self.assertRaises(KeyError, dcmi.getElementSpec, 'Rights')
+        self.assertRaises(KeyError, dcmi.removeElementSpec, 'Foo')
 
-    def test_simplePolicies( self ):
-
+    def test_simplePolicies(self):
         tool = self._makeOne()
         dcmi = tool.DCMI
-        tSpec = dcmi.getElementSpec( 'Title' )
+        tSpec = dcmi.getElementSpec('Title')
 
         # Fetch default policy.
-        tDef  = tSpec.getPolicy()
-        self.failIf( tDef.isRequired() )
-        self.failIf( tDef.supplyDefault() )
-        self.failIf( tDef.defaultValue() )
+        tDef = tSpec.getPolicy()
+        self.assertFalse(tDef.isRequired())
+        self.assertFalse(tDef.supplyDefault())
+        self.assertFalse(tDef.defaultValue())
 
         # Fetch (default) policy for a type.
-        tDoc  = tSpec.getPolicy( 'Document' )
+        tDoc = tSpec.getPolicy('Document')
         self.assertEqual(aq_base(tDoc), aq_base(tDef))
 
         # Changing default changes policies found from there.
-        tDef.edit( 1, 1, 'xyz', 0, () )
-        self.failUnless( tDef.isRequired() )
-        self.failUnless( tDef.supplyDefault() )
-        self.assertEqual( tDef.defaultValue(), 'xyz' )
-        self.failUnless( tDoc.isRequired() )
-        self.failUnless( tDoc.supplyDefault() )
-        self.assertEqual( tDoc.defaultValue(), 'xyz' )
+        tDef.edit(1, 1, 'xyz', 0, ())
+        self.assertTrue(tDef.isRequired())
+        self.assertTrue(tDef.supplyDefault())
+        self.assertEqual(tDef.defaultValue(), 'xyz')
+        self.assertTrue(tDoc.isRequired())
+        self.assertTrue(tDoc.supplyDefault())
+        self.assertEqual(tDoc.defaultValue(), 'xyz')
 
-        tSpec.addPolicy( 'Document' )
-        self.assertEqual( len( tSpec.listPolicies() ), 2 )
+        tSpec.addPolicy('Document')
+        self.assertEqual(len(tSpec.listPolicies()), 2)
 
-        tDoc  = tSpec.getPolicy( 'Document' )
+        tDoc = tSpec.getPolicy('Document')
         self.assertNotEqual(aq_base(tDoc), aq_base(tDef))
-        self.failIf( tDoc.isRequired() )
-        self.failIf( tDoc.supplyDefault() )
-        self.failIf( tDoc.defaultValue() )
+        self.assertFalse(tDoc.isRequired())
+        self.assertFalse(tDoc.supplyDefault())
+        self.assertFalse(tDoc.defaultValue())
 
-        tSpec.removePolicy( 'Document' )
-        tDoc  = tSpec.getPolicy( 'Document' )
+        tSpec.removePolicy('Document')
+        tDoc = tSpec.getPolicy('Document')
         self.assertEqual(aq_base(tDoc), aq_base(tDef))
-        self.failUnless( tDoc.isRequired() )
-        self.failUnless( tDoc.supplyDefault() )
-        self.assertEqual( tDoc.defaultValue(), 'xyz' )
+        self.assertTrue(tDoc.isRequired())
+        self.assertTrue(tDoc.supplyDefault())
+        self.assertEqual(tDoc.defaultValue(), 'xyz')
 
-    def test_multiValuedPolicies( self ):
-
+    def test_multiValuedPolicies(self):
         tool = self._makeOne()
         dcmi = tool.DCMI
-        sSpec = dcmi.getElementSpec( 'Subject' )
+        sSpec = dcmi.getElementSpec('Subject')
 
         # Fetch default policy.
-        sDef  = sSpec.getPolicy()
-        self.failIf( sDef.isRequired() )
-        self.failIf( sDef.supplyDefault() )
-        self.failIf( sDef.defaultValue() )
-        self.failIf( sDef.enforceVocabulary() )
-        self.failIf( sDef.allowedVocabulary() )
+        sDef = sSpec.getPolicy()
+        self.assertFalse(sDef.isRequired())
+        self.assertFalse(sDef.supplyDefault())
+        self.assertFalse(sDef.defaultValue())
+        self.assertFalse(sDef.enforceVocabulary())
+        self.assertFalse(sDef.allowedVocabulary())
 
         # Fetch (default) policy for a type.
-        sDoc  = sSpec.getPolicy( 'Document' )
+        sDoc = sSpec.getPolicy('Document')
         self.assertEqual(aq_base(sDoc), aq_base(sDef))
 
         # Changing default changes policies found from there.
-        sDef.edit( 1, 1, 'xyz', 1, ( 'foo', 'bar' ) )
-        self.failUnless( sDef.isRequired() )
-        self.failUnless( sDef.supplyDefault() )
-        self.assertEqual( sDef.defaultValue(), 'xyz' )
-        self.failUnless( sDoc.isRequired() )
-        self.failUnless( sDoc.supplyDefault() )
-        self.assertEqual( sDoc.defaultValue(), 'xyz' )
-        self.failUnless( sDef.enforceVocabulary() )
-        self.assertEqual( len( sDef.allowedVocabulary() ), 2 )
-        self.failUnless( 'foo' in sDef.allowedVocabulary() )
-        self.failUnless( 'bar' in sDef.allowedVocabulary() )
-        self.failUnless( sDoc.enforceVocabulary() )
-        self.assertEqual( len( sDoc.allowedVocabulary() ), 2 )
-        self.failUnless( 'foo' in sDoc.allowedVocabulary() )
-        self.failUnless( 'bar' in sDoc.allowedVocabulary() )
+        sDef.edit(1, 1, 'xyz', 1, ('foo', 'bar'))
+        self.assertTrue(sDef.isRequired())
+        self.assertTrue(sDef.supplyDefault())
+        self.assertEqual(sDef.defaultValue(), 'xyz')
+        self.assertTrue(sDoc.isRequired())
+        self.assertTrue(sDoc.supplyDefault())
+        self.assertEqual(sDoc.defaultValue(), 'xyz')
+        self.assertTrue(sDef.enforceVocabulary())
+        self.assertEqual(len(sDef.allowedVocabulary()), 2)
+        self.assertTrue('foo' in sDef.allowedVocabulary())
+        self.assertTrue('bar' in sDef.allowedVocabulary())
+        self.assertTrue(sDoc.enforceVocabulary())
+        self.assertEqual(len(sDoc.allowedVocabulary()), 2)
+        self.assertTrue('foo' in sDoc.allowedVocabulary())
+        self.assertTrue('bar' in sDoc.allowedVocabulary())
 
-        sSpec.addPolicy( 'Document' )
-        self.assertEqual( len( sSpec.listPolicies() ), 2 )
+        sSpec.addPolicy('Document')
+        self.assertEqual(len(sSpec.listPolicies()), 2)
 
-        sDoc  = sSpec.getPolicy( 'Document' )
+        sDoc = sSpec.getPolicy('Document')
         self.assertNotEqual(aq_base(sDoc), aq_base(sDef))
-        self.failIf( sDoc.isRequired() )
-        self.failIf( sDoc.supplyDefault() )
-        self.failIf( sDoc.defaultValue() )
-        self.failIf( sDoc.enforceVocabulary() )
-        self.failIf( sDoc.allowedVocabulary() )
+        self.assertFalse(sDoc.isRequired())
+        self.assertFalse(sDoc.supplyDefault())
+        self.assertFalse(sDoc.defaultValue())
+        self.assertFalse(sDoc.enforceVocabulary())
+        self.assertFalse(sDoc.allowedVocabulary())
 
-        sSpec.removePolicy( 'Document' )
-        sDoc  = sSpec.getPolicy( 'Document' )
+        sSpec.removePolicy('Document')
+        sDoc = sSpec.getPolicy('Document')
         self.assertEqual(aq_base(sDoc), aq_base(sDef))
-        self.failUnless( sDoc.isRequired() )
-        self.failUnless( sDoc.supplyDefault() )
-        self.assertEqual( sDoc.defaultValue(), 'xyz' )
-        self.failUnless( sDoc.enforceVocabulary() )
-        self.assertEqual( len( sDoc.allowedVocabulary() ), 2 )
-        self.failUnless( 'foo' in sDoc.allowedVocabulary() )
-        self.failUnless( 'bar' in sDoc.allowedVocabulary() )
+        self.assertTrue(sDoc.isRequired())
+        self.assertTrue(sDoc.supplyDefault())
+        self.assertEqual(sDoc.defaultValue(), 'xyz')
+        self.assertTrue(sDoc.enforceVocabulary())
+        self.assertEqual(len(sDoc.allowedVocabulary()), 2)
+        self.assertTrue('foo' in sDoc.allowedVocabulary())
+        self.assertTrue('bar' in sDoc.allowedVocabulary())
 
-    def test_vocabularies( self ):
+    def test_vocabularies(self):
         tool = self._makeOne()
         dcmi = tool.DCMI
-        fSpec   = dcmi.getElementSpec( 'Format' )
-        fDef    = fSpec.getPolicy()
-        formats = ( 'text/plain', 'text/html' )
-        fDef.edit( 0, 0, '', 0, ( 'text/plain', 'text/html' ) )
-        self.assertEqual( tool.listAllowedFormats(), formats )
+        fSpec = dcmi.getElementSpec('Format')
+        fDef = fSpec.getPolicy()
+        formats = ('text/plain', 'text/html')
+        fDef.edit(0, 0, '', 0, ('text/plain', 'text/html'))
+        self.assertEqual(tool.listAllowedFormats(), formats)
 
-        foo, bar = self._makeTestObjects()
+        foo, _bar = self._makeTestObjects()
 
-        self.assertEqual( tool.listAllowedFormats( foo ), formats )
+        self.assertEqual(tool.listAllowedFormats(foo), formats)
 
-        fSpec.addPolicy( 'Foo' )
-        self.failIf( tool.listAllowedFormats( foo ) )
+        fSpec.addPolicy('Foo')
+        self.assertFalse(tool.listAllowedFormats(foo))
 
-        foo_formats = ( 'image/jpeg', 'image/gif', 'image/png' )
-        fFoo        = fSpec.getPolicy( 'Foo' )
-        fFoo.edit( 0, 0, '', 0, foo_formats )
-        self.assertEqual( tool.listAllowedFormats( foo ), foo_formats )
+        foo_formats = ('image/jpeg', 'image/gif', 'image/png')
+        fFoo = fSpec.getPolicy('Foo')
+        fFoo.edit(0, 0, '', 0, foo_formats)
+        self.assertEqual(tool.listAllowedFormats(foo), foo_formats)
 
-    def test_initialValues_defaults( self ):
+    def test_initialValues_defaults(self):
         tool = self._makeOne()
-        foo, bar = self._makeTestObjects()
-        self.failIf( foo.Title() )
-        self.failIf( foo.Description() )
-        self.failIf( foo.Subject() )
-        self.failIf( foo.Format(), foo.Format() )
-        self.failIf( foo.Language() )
-        self.failIf( foo.Rights() )
+        foo, _bar = self._makeTestObjects()
+        self.assertFalse(foo.Title())
+        self.assertFalse(foo.Description())
+        self.assertFalse(foo.Subject())
+        self.assertFalse(foo.Format(), foo.Format())
+        self.assertFalse(foo.Language())
+        self.assertFalse(foo.Rights())
 
-        tool.setInitialMetadata( foo )
-        self.failIf( foo.Title() )
-        self.failIf( foo.Description() )
-        self.failIf( foo.Subject() )
-        self.failIf( foo.Format() )
-        self.failIf( foo.Language() )
-        self.failIf( foo.Rights() )
+        tool.setInitialMetadata(foo)
+        self.assertFalse(foo.Title())
+        self.assertFalse(foo.Description())
+        self.assertFalse(foo.Subject())
+        self.assertFalse(foo.Format())
+        self.assertFalse(foo.Language())
+        self.assertFalse(foo.Rights())
 
-    def test_initialValues_implicit( self ):
+    def test_initialValues_implicit(self):
         # Test default policy.
         tool = self._makeOne()
         dcmi = tool.DCMI
-        foo, bar = self._makeTestObjects()
-        fSpec   = dcmi.getElementSpec( 'Format' )
+        foo, _bar = self._makeTestObjects()
+        fSpec = dcmi.getElementSpec('Format')
         fPolicy = fSpec.getPolicy()
-        fPolicy.edit( 0, 1, 'text/plain', 0, () )
-        tool.setInitialMetadata( foo )
-        self.failIf( foo.Title() )
-        self.failIf( foo.Description() )
-        self.failIf( foo.Subject() )
-        self.assertEqual( foo.Format(), 'text/plain' )
-        self.failIf( foo.Language() )
-        self.failIf( foo.Rights() )
+        fPolicy.edit(0, 1, 'text/plain', 0, ())
+        tool.setInitialMetadata(foo)
+        self.assertFalse(foo.Title())
+        self.assertFalse(foo.Description())
+        self.assertFalse(foo.Subject())
+        self.assertEqual(foo.Format(), 'text/plain')
+        self.assertFalse(foo.Language())
+        self.assertFalse(foo.Rights())
 
-    def test_initialValues_explicit_raises_if_constraint_fails( self ):
+    def test_initialValues_explicit_raises_if_constraint_fails(self):
         from Products.CMFDefault.exceptions import MetadataError
 
         # Test type-specific policy.
         tool = self._makeOne()
         dcmi = tool.DCMI
-        foo, bar = self._makeTestObjects()
-        tSpec   = dcmi.getElementSpec( 'Title' )
-        tSpec.addPolicy( 'Foo' )
-        tPolicy = tSpec.getPolicy( foo.getPortalTypeName() )
-        tPolicy.edit( 1, 0, '', 0, () )
+        foo, _bar = self._makeTestObjects()
+        tSpec = dcmi.getElementSpec('Title')
+        tSpec.addPolicy('Foo')
+        tPolicy = tSpec.getPolicy(foo.getPortalTypeName())
+        tPolicy.edit(1, 0, '', 0, ())
 
-        self.assertRaises( MetadataError, tool.setInitialMetadata, foo )
+        self.assertRaises(MetadataError, tool.setInitialMetadata, foo)
 
-    def test_initialValues_explicit_mutliple_types( self ):
+    def test_initialValues_explicit_mutliple_types(self):
         tool = self._makeOne()
         dcmi = tool.DCMI
         foo, bar = self._makeTestObjects()
-        foo.setTitle( 'Foo title' )
+        foo.setTitle('Foo title')
 
-        fSpec   = dcmi.getElementSpec( 'Format' )
-        fSpec.addPolicy( foo.getPortalTypeName() )
-        fPolicy = fSpec.getPolicy( foo.getPortalTypeName() )
-        fPolicy.edit( 0, 1, 'text/plain', 0, () )
+        fSpec = dcmi.getElementSpec('Format')
+        fSpec.addPolicy(foo.getPortalTypeName())
+        fPolicy = fSpec.getPolicy(foo.getPortalTypeName())
+        fPolicy.edit(0, 1, 'text/plain', 0, ())
 
-        tool.setInitialMetadata( foo )
-        self.assertEqual( foo.Title(), 'Foo title' )
-        self.failIf( foo.Description() )
-        self.failIf( foo.Subject() )
-        self.assertEqual( foo.Format(), 'text/plain' )
-        self.failIf( foo.Language() )
-        self.failIf( foo.Rights() )
+        tool.setInitialMetadata(foo)
+        self.assertEqual(foo.Title(), 'Foo title')
+        self.assertFalse(foo.Description())
+        self.assertFalse(foo.Subject())
+        self.assertEqual(foo.Format(), 'text/plain')
+        self.assertFalse(foo.Language())
+        self.assertFalse(foo.Rights())
 
         #   Ensure Foo's policy doesn't interfere with other types.
-        tool.setInitialMetadata( bar )
-        self.failIf( bar.Title() )
-        self.failIf( bar.Description() )
-        self.failIf( bar.Subject() )
-        self.assertEqual( bar.Format(), '' )
-        self.failIf( bar.Language() )
-        self.failIf( bar.Rights() )
+        tool.setInitialMetadata(bar)
+        self.assertFalse(bar.Title())
+        self.assertFalse(bar.Description())
+        self.assertFalse(bar.Subject())
+        self.assertEqual(bar.Format(), '')
+        self.assertFalse(bar.Language())
+        self.assertFalse(bar.Rights())
 
-    def test_validation( self ):
+    def test_validation(self):
         from Products.CMFDefault.exceptions import MetadataError
 
         tool = self._makeOne()
-        foo, bar = self._makeTestObjects()
-        tool.setInitialMetadata( foo )
-        tool.validateMetadata( foo )
+        foo, _bar = self._makeTestObjects()
+        tool.setInitialMetadata(foo)
+        tool.validateMetadata(foo)
 
         dcmi = tool.DCMI
-        tSpec   = dcmi.getElementSpec( 'Title' )
-        tSpec.addPolicy( 'Foo' )
-        tPolicy = tSpec.getPolicy( foo.getPortalTypeName() )
-        tPolicy.edit( 1, 0, '', 0, () )
+        tSpec = dcmi.getElementSpec('Title')
+        tSpec.addPolicy('Foo')
+        tPolicy = tSpec.getPolicy(foo.getPortalTypeName())
+        tPolicy.edit(1, 0, '', 0, ())
 
-        self.assertRaises( MetadataError, tool.validateMetadata, foo )
+        self.assertRaises(MetadataError, tool.validateMetadata, foo)
 
-        foo.setTitle( 'Foo title' )
-        tool.validateMetadata( foo )
+        foo.setTitle('Foo title')
+        tool.validateMetadata(foo)
 
-    def test_addSchema_normal( self ):
+    def test_addSchema_normal(self):
         from Products.CMFDefault.MetadataTool import MetadataSchema
 
         tool = self._makeOne()
         before = tool.listSchemas()
-        self.assertEqual( len( before ), 1 )
-        self.assertEqual( before[0][0], 'DCMI' )
-        self.failUnless( isinstance( before[0][1], MetadataSchema ) )
+        self.assertEqual(len(before), 1)
+        self.assertEqual(before[0][0], 'DCMI')
+        self.assertTrue(isinstance(before[0][1], MetadataSchema))
 
-        tool.addSchema( 'Arbitrary' )
+        tool.addSchema('Arbitrary')
 
         after = tool.listSchemas()
-        self.assertEqual( len( after ), 2 )
-        self.assertEqual( after[0][0], 'DCMI' )
-        self.failUnless( isinstance( after[0][1], MetadataSchema ) )
-        self.assertEqual( after[1][0], 'Arbitrary' )
-        self.failUnless( isinstance( after[1][1], MetadataSchema ) )
+        self.assertEqual(len(after), 2)
+        self.assertEqual(after[0][0], 'DCMI')
+        self.assertTrue(isinstance(after[0][1], MetadataSchema))
+        self.assertEqual(after[1][0], 'Arbitrary')
+        self.assertTrue(isinstance(after[1][1], MetadataSchema))
 
-    def test_addSchema_duplicate( self ):
+    def test_addSchema_duplicate(self):
         tool = self._makeOne()
-        before = tool.listSchemas()
-        tool.addSchema( 'Arbitrary' )
-        self.assertRaises( KeyError, tool.addSchema, 'Arbitrary' )
-        self.assertRaises( KeyError, tool.addSchema, 'DCMI' )
+        tool.addSchema('Arbitrary')
+        self.assertRaises(KeyError, tool.addSchema, 'Arbitrary')
+        self.assertRaises(KeyError, tool.addSchema, 'DCMI')
 
-    def test_removeSchema_normal( self ):
+    def test_removeSchema_normal(self):
         tool = self._makeOne()
         before = tool.listSchemas()
-        self.assertEqual( len( before ), 1 )
-        self.assertEqual( before[0][0], 'DCMI' )
+        self.assertEqual(len(before), 1)
+        self.assertEqual(before[0][0], 'DCMI')
 
-        tool.addSchema( 'Arbitrary' )
-        tool.addSchema( 'Beneficent' )
-        tool.addSchema( 'Grouchy' )
+        tool.addSchema('Arbitrary')
+        tool.addSchema('Beneficent')
+        tool.addSchema('Grouchy')
 
         middle = tool.listSchemas()
-        self.assertEqual( len( middle ), 4 )
-        self.assertEqual( middle[0][0], 'DCMI' )
-        self.assertEqual( middle[1][0], 'Arbitrary' )
-        self.assertEqual( middle[2][0], 'Beneficent' )
-        self.assertEqual( middle[3][0], 'Grouchy' )
+        self.assertEqual(len(middle), 4)
+        self.assertEqual(middle[0][0], 'DCMI')
+        self.assertEqual(middle[1][0], 'Arbitrary')
+        self.assertEqual(middle[2][0], 'Beneficent')
+        self.assertEqual(middle[3][0], 'Grouchy')
 
-        tool.removeSchema( 'Beneficent' )
+        tool.removeSchema('Beneficent')
 
         after = tool.listSchemas()
-        self.assertEqual( len( after ), 3 )
-        self.assertEqual( after[0][0], 'DCMI' )
-        self.assertEqual( after[1][0], 'Arbitrary' )
-        self.assertEqual( after[2][0], 'Grouchy' )
+        self.assertEqual(len(after), 3)
+        self.assertEqual(after[0][0], 'DCMI')
+        self.assertEqual(after[1][0], 'Arbitrary')
+        self.assertEqual(after[2][0], 'Grouchy')
 
-    def test_removeSchema_invalid( self ):
+    def test_removeSchema_invalid(self):
         tool = self._makeOne()
-        self.assertRaises( KeyError, tool.removeSchema, 'DCMI' )
-        tool.addSchema( 'Arbitrary' )
-        tool.removeSchema( 'Arbitrary' )
-        self.assertRaises( KeyError, tool.removeSchema, 'Arbitrary' )
+        self.assertRaises(KeyError, tool.removeSchema, 'DCMI')
+        tool.addSchema('Arbitrary')
+        tool.removeSchema('Arbitrary')
+        self.assertRaises(KeyError, tool.removeSchema, 'Arbitrary')
 
 
 def test_suite():

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_PropertiesTool.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_PropertiesTool.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_PropertiesTool.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -34,14 +34,14 @@
 class PropertiedDummySite(PropertyManager, DummySite):
 
     _properties = (
-        {'id':'title', 'type':'string', 'mode': 'w'},
-        {'id':'description', 'type':'text', 'mode': 'w'},
-        {'id':'email_from_address', 'type':'string', 'mode': 'w'},
-        {'id':'email_from_name', 'type':'string', 'mode': 'w'},
-        {'id':'validate_email', 'type':'boolean', 'mode': 'w'},
-        {'id':'default_charset', 'type':'string', 'mode': 'w'},
-        {'id':'email_charset', 'type':'string', 'mode': 'w'},
-        {'id':'enable_permalink', 'type':'boolean', 'mode': 'w'},
+        {'id': 'title', 'type': 'string', 'mode': 'w'},
+        {'id': 'description', 'type': 'text', 'mode': 'w'},
+        {'id': 'email_from_address', 'type': 'string', 'mode': 'w'},
+        {'id': 'email_from_name', 'type': 'string', 'mode': 'w'},
+        {'id': 'validate_email', 'type': 'boolean', 'mode': 'w'},
+        {'id': 'default_charset', 'type': 'string', 'mode': 'w'},
+        {'id': 'email_charset', 'type': 'string', 'mode': 'w'},
+        {'id': 'enable_permalink', 'type': 'boolean', 'mode': 'w'},
         )
     title = description = email_from_address = email_from_name = ''
     default_charset = email_charset = ''
@@ -81,29 +81,28 @@
         # https://bugs.launchpad.net/zope-cmf/+bug/174246
         # PropertiesTool.editProperties fails with traceback due to
         # faulty invocation of the site's manage_changeProperties method
-        props = { 'email_from_name' : 'Test Admin'
-                , 'email_from_address' : 'test at example.com'
-                , 'description' : 'Test MailHost Description'
-                , 'title' : 'Test MailHost'
-                , 'smtp_server' : 'mail.example.com'
-                , 'validate_email' : True
-                , 'email_charset' : 'iso-8859-15'
-                , 'default_charset' : 'iso-8859-1'
-                , 'enable_permalink' : True
-                }
+        props = {'email_from_name': 'Test Admin',
+                 'email_from_address': 'test at example.com',
+                 'description': 'Test MailHost Description',
+                 'title': 'Test MailHost',
+                 'smtp_server': 'mail.example.com',
+                 'validate_email': True,
+                 'email_charset': 'iso-8859-15',
+                 'default_charset': 'iso-8859-1',
+                 'enable_permalink': True}
         tool = getUtility(IPropertiesTool)
         tool.editProperties(props)
 
         site_prop = self.site.getProperty
-        self.assertEquals(getUtility(IMailHost).smtp_host, 'mail.example.com')
-        self.assertEquals(site_prop('email_from_name'), 'Test Admin')
-        self.assertEquals(site_prop('email_from_address'), 'test at example.com')
-        self.assertEquals(site_prop('description'), 'Test MailHost Description')
-        self.assertEquals(site_prop('title'), 'Test MailHost')
-        self.assertEquals(site_prop('validate_email'), True)
-        self.assertEquals(site_prop('email_charset'), 'iso-8859-15')
-        self.assertEquals(site_prop('default_charset'), 'iso-8859-1')
-        self.assertEquals(site_prop('enable_permalink'), True)
+        self.assertEqual(getUtility(IMailHost).smtp_host, 'mail.example.com')
+        self.assertEqual(site_prop('email_from_name'), 'Test Admin')
+        self.assertEqual(site_prop('email_from_address'), 'test at example.com')
+        self.assertEqual(site_prop('description'), 'Test MailHost Description')
+        self.assertEqual(site_prop('title'), 'Test MailHost')
+        self.assertEqual(site_prop('validate_email'), True)
+        self.assertEqual(site_prop('email_charset'), 'iso-8859-15')
+        self.assertEqual(site_prop('default_charset'), 'iso-8859-1')
+        self.assertEqual(site_prop('enable_permalink'), True)
 
 
 def test_suite():

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_RegistrationTool.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_RegistrationTool.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_RegistrationTool.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -28,7 +28,7 @@
 
 class FauxMembershipTool(Implicit):
 
-    def getMemberById( self, username ):
+    def getMemberById(self, username):
         return None
 
 
@@ -65,13 +65,10 @@
         rtool = self._makeOne().__of__(self.app)
         getSiteManager().registerUtility(FauxMembershipTool(), IMembershipTool)
 
-        props = { 'email' : INJECTED_HEADERS
-                , 'username' : 'username'
-                }
-
+        props = {'email': INJECTED_HEADERS, 'username': 'username'}
         result = rtool.testPropertiesValidity(props, None)
 
-        self.failIf( result is None, 'Invalid e-mail passed inspection' )
+        self.assertFalse(result is None, 'Invalid e-mail passed inspection')
 
 
 def test_suite():

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_SyndicationTool.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_SyndicationTool.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_SyndicationTool.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -20,7 +20,6 @@
 from datetime import datetime
 from datetime import timedelta
 
-from DateTime.DateTime import DateTime
 from zope.component import getSiteManager
 from zope.component import queryAdapter
 from zope.interface import alsoProvides
@@ -132,8 +131,8 @@
 
         self.assertEqual(tool.period, 'daily')
         self.assertEqual(tool.frequency, 1)
-        self.failUnless(datetime.now() - tool.base < ONE_MINUTE)
-        self.failIf(tool.enabled)
+        self.assertTrue(datetime.now() - tool.base < ONE_MINUTE)
+        self.assertFalse(tool.enabled)
         self.assertEqual(tool.max_items, 15)
 
     def test_object_not_syndicatable(self):
@@ -216,7 +215,6 @@
 
         self.assertEqual(NOW.isoformat(), tool.getUpdateBase())
 
-
     def test_getUpdateBaseWithContext(self):
         NOW = datetime.now()
 
@@ -230,7 +228,6 @@
 
         self.assertEqual(NOW.isoformat(), tool.getUpdateBase(context))
 
-
     def test_getHTML4UpdateBase(self):
         NOW = datetime.now()
 

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_join.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_join.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_join.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -28,18 +28,15 @@
     def afterSetUp(self):
         setSite(self.app.site)
 
-    def test_join( self ):
+    def test_join(self):
         site = self.app.site
         member_id = 'test_user'
 
-        site.portal_registration.addMember( member_id
-                                          , 'zzyyzz'
-                                          , properties={ 'username': member_id
-                                                       , 'email' : 'foo at bar.com'
-                                                       }
-                                          )
+        site.portal_registration.addMember(member_id, 'zzyyzz',
+                                           properties={'username': member_id,
+                                                       'email': 'foo at bar.com'})
         u = site.acl_users.getUser(member_id)
-        self.failUnless(u)
+        self.assertTrue(u)
 
     def test_join_memberproperties(self):
         # Make sure the member data wrapper carries correct properties
@@ -47,29 +44,26 @@
         site = self.app.site
         member_id = 'test_user'
 
-        site.portal_registration.addMember( member_id
-                                          , 'zzyyzz'
-                                          , properties={ 'username': member_id
-                                                       , 'email' : 'foo at bar.com'
-                                                       }
-                                          )
+        site.portal_registration.addMember(member_id, 'zzyyzz',
+                                           properties={'username': member_id,
+                                                       'email': 'foo at bar.com'})
 
         m = site.portal_membership.getMemberById('test_user')
         self.assertEqual(m.getProperty('email'), 'foo at bar.com')
         self.assertEqual(m.getMemberId(), member_id)
         self.assertEqual(m.getRoles(), ('Member', 'Authenticated'))
 
-    def test_join_without_email( self ):
+    def test_join_without_email(self):
         site = self.app.site
 
         self.assertRaises(ValueError,
                           site.portal_registration.addMember,
                           'test_user',
                           'zzyyzz',
-                          properties={'username':'test_user', 'email': ''}
+                          properties={'username': 'test_user', 'email': ''}
                           )
 
-    def test_join_with_variable_id_policies( self ):
+    def test_join_with_variable_id_policies(self):
         site = self.app.site
         member_id = 'test.user'
 
@@ -78,22 +72,18 @@
                           site.portal_registration.addMember,
                           member_id,
                           'zzyyzz',
-                          properties={ 'username':'Test User'
-                                     , 'email': 'foo at bar.com'
-                                     }
+                          properties={'username': 'Test User',
+                                      'email': 'foo at bar.com'}
                           )
 
         # Now change the policy to allow "."
         new_pattern = "^[A-Za-z][A-Za-z0-9_\.]*$"
         site.portal_registration.manage_editIDPattern(new_pattern)
-        site.portal_registration.addMember( member_id
-                                          , 'zzyyzz'
-                                          , properties={ 'username': 'TestUser2'
-                                                       , 'email' : 'foo at bar.com'
-                                                       }
-                                          )
+        site.portal_registration.addMember(member_id, 'zzyyzz',
+                                           properties={'username': 'TestUser2',
+                                                       'email': 'foo at bar.com'})
         u = site.acl_users.getUser(member_id)
-        self.failUnless(u)
+        self.assertTrue(u)
 
 
 def test_suite():

Modified: Products.CMFDefault/trunk/Products/CMFDefault/tests/test_utils.py
===================================================================
--- Products.CMFDefault/trunk/Products/CMFDefault/tests/test_utils.py	2012-04-22 11:04:10 UTC (rev 125228)
+++ Products.CMFDefault/trunk/Products/CMFDefault/tests/test_utils.py	2012-04-22 11:04:25 UTC (rev 125229)
@@ -16,7 +16,6 @@
 import unittest
 
 
-
 class DefaultUtilsTests(unittest.TestCase):
 
     COMMON_HEADERS = '''Author: Tres Seaver
@@ -44,105 +43,95 @@
         from zope.component.testing import tearDown
         tearDown()
 
-    def test_parseHeadersBody_no_body( self ):
+    def test_parseHeadersBody_no_body(self):
         from Products.CMFDefault.utils import parseHeadersBody
 
-        headers, body = parseHeadersBody( '%s\n\n' % self.COMMON_HEADERS )
-        self.assertEqual( len( headers ), 2 )
-        self.failUnless( 'Author' in headers.keys() )
-        self.assertEqual( headers[ 'Author' ], 'Tres Seaver' )
-        self.failUnless( 'Title' in headers.keys() )
-        self.assertEqual( len( body ), 0 )
+        headers, body = parseHeadersBody('%s\n\n' % self.COMMON_HEADERS)
+        self.assertEqual(len(headers), 2)
+        self.assertTrue('Author' in headers.keys())
+        self.assertEqual(headers['Author'], 'Tres Seaver')
+        self.assertTrue('Title' in headers.keys())
+        self.assertEqual(len(body), 0)
 
-    def test_parseHeadersBody_continuation( self ):
+    def test_parseHeadersBody_continuation(self):
         from Products.CMFDefault.utils import parseHeadersBody
 
-        headers, body = parseHeadersBody( '%s\n%s\n\n'
-                                        % ( self.COMMON_HEADERS
-                                          , self.MULTILINE_DESCRIPTION
-                                          )
-                                        )
-        self.assertEqual( len( headers ), 3 )
-        self.failUnless( 'Description' in headers.keys() )
-        desc_len = len( headers[ 'Description' ].split('\n') )
-        self.assertEqual( desc_len, 2 )
-        self.assertEqual( len( body ), 0 )
+        headers, body = parseHeadersBody('%s\n%s\n\n'
+                                         % (self.COMMON_HEADERS,
+                                            self.MULTILINE_DESCRIPTION))
+        self.assertEqual(len(headers), 3)
+        self.assertTrue('Description' in headers.keys())
+        desc_len = len(headers['Description'].split('\n'))
+        self.assertEqual(desc_len, 2)
+        self.assertEqual(len(body), 0)
 
-    def test_parseHeadersBody_embedded_blank_line( self ):
+    def test_parseHeadersBody_embedded_blank_line(self):
         from Products.CMFDefault.utils import parseHeadersBody
 
-        headers, body = parseHeadersBody( '%s\n%s\n\n%s'
-                                        % ( self.COMMON_HEADERS
-                                          , self.MULTIPARAGRAPH_DESCRIPTION
-                                          , self.TEST_BODY
-                                          )
-                                        )
-        self.assertEqual( len( headers ), 3 )
-        self.failUnless( 'Description' in headers.keys() )
-        desc_lines = headers[ 'Description' ].split('\n')
-        desc_len = len( desc_lines )
-        self.assertEqual( desc_len, 3, desc_lines )
-        self.assertEqual( desc_lines[1], ' ' )
-        self.assertEqual( body, self.TEST_BODY )
+        headers, body = parseHeadersBody('%s\n%s\n\n%s'
+                                         % (self.COMMON_HEADERS,
+                                            self.MULTIPARAGRAPH_DESCRIPTION,
+                                            self.TEST_BODY))
+        self.assertEqual(len(headers), 3)
+        self.assertTrue('Description' in headers.keys())
+        desc_lines = headers['Description'].split('\n')
+        desc_len = len(desc_lines)
+        self.assertEqual(desc_len, 3, desc_lines)
+        self.assertEqual(desc_lines[1], ' ')
+        self.assertEqual(body, self.TEST_BODY)
 
-    def test_parseHeadersBody_body( self ):
+    def test_parseHeadersBody_body(self):
         from Products.CMFDefault.utils import parseHeadersBody
 
-        headers, body = parseHeadersBody( '%s\n\n%s'
-                                        % ( self.COMMON_HEADERS
-                                          , self.TEST_BODY
-                                          )
-                                        )
-        self.assertEqual( len( headers ), 2 )
-        self.assertEqual( body, self.TEST_BODY )
+        headers, body = parseHeadersBody('%s\n\n%s'
+                                         % (self.COMMON_HEADERS,
+                                            self.TEST_BODY))
+        self.assertEqual(len(headers), 2)
+        self.assertEqual(body, self.TEST_BODY)
 
-    def test_parseHeadersBody_body_malformed_terminator( self ):
+    def test_parseHeadersBody_body_malformed_terminator(self):
         from Products.CMFDefault.utils import parseHeadersBody
 
-        headers, body = parseHeadersBody( '%s\n \n%s'
-                                        % ( self.COMMON_HEADERS
-                                          , self.TEST_BODY
-                                          )
-                                        )
-        self.assertEqual( len( headers ), 2 )
-        self.assertEqual( body, self.TEST_BODY )
+        headers, body = parseHeadersBody('%s\n \n%s'
+                                         % (self.COMMON_HEADERS,
+                                            self.TEST_BODY))
+        self.assertEqual(len(headers), 2)
+        self.assertEqual(body, self.TEST_BODY)
 
-    def test_parseHeadersBody_preload( self ):
+    def test_parseHeadersBody_preload(self):
         from Products.CMFDefault.utils import parseHeadersBody
 
-        preloaded = { 'Author' : 'xxx', 'text_format' : 'structured_text' }
-        headers, body = parseHeadersBody( '%s\n%s\n\n%s'
-                                        % ( self.COMMON_HEADERS
-                                          , self.MULTILINE_DESCRIPTION
-                                          , self.TEST_BODY
-                                          )
-                                        , preloaded
-                                        )
-        self.assertEqual( len( headers ), 4 )
-        self.assertNotEqual( preloaded[ 'Author' ], headers[ 'Author' ] )
-        self.assertEqual( preloaded[ 'text_format' ], headers[ 'text_format' ] )
+        preloaded = {'Author': 'xxx', 'text_format': 'structured_text'}
+        headers, _body = parseHeadersBody('%s\n%s\n\n%s'
+                                          % (self.COMMON_HEADERS,
+                                             self.MULTILINE_DESCRIPTION,
+                                             self.TEST_BODY),
+                                          preloaded)
+        self.assertEqual(len(headers), 4)
+        self.assertNotEqual(preloaded['Author'], headers['Author'])
+        self.assertEqual(preloaded['text_format'], headers['text_format'])
 
     def test_scrubHTML_no_adapter_falls_back(self):
         from Products.CMFDefault.utils import scrubHTML
 
-        self.assertEqual( scrubHTML('<a href="foo.html">bar</a>'),
-                          '<a href="foo.html">bar</a>' )
-        self.assertEqual( scrubHTML('<b>bar</b>'),
-                          '<b>bar</b>' )
-        self.assertEqual( scrubHTML('<base href="" /><base>'),
-                          '<base href="" /><base />' )
-        self.assertEqual( scrubHTML('<blockquote>bar</blockquote>'),
-                          '<blockquote>bar</blockquote>' )
-        self.assertEqual( scrubHTML('<body bgcolor="#ffffff">bar</body>'),
-                          '<body bgcolor="#ffffff">bar</body>' )
-        self.assertEqual( scrubHTML('<br /><br>'),
-                          '<br /><br />' )
-        self.assertEqual( scrubHTML('<hr /><hr>'),
-                          '<hr /><hr />' )
-        self.assertEqual( scrubHTML('<img src="foo.png" /><img>'),
-                          '<img src="foo.png" /><img />' )
-        self.assertEqual( scrubHTML('<meta name="title" content="" /><meta>'),
-                          '<meta name="title" content="" /><meta />' )
+        self.assertEqual(scrubHTML('<a href="foo.html">bar</a>'),
+                         '<a href="foo.html">bar</a>')
+        self.assertEqual(scrubHTML('<b>bar</b>'),
+                         '<b>bar</b>')
+        self.assertEqual(scrubHTML('<base href="" /><base>'),
+                         '<base href="" /><base />')
+        self.assertEqual(scrubHTML('<blockquote>bar</blockquote>'),
+                         '<blockquote>bar</blockquote>')
+        self.assertEqual(scrubHTML('<body bgcolor="#ffffff">bar</body>'),
+                         '<body bgcolor="#ffffff">bar</body>')
+        self.assertEqual(scrubHTML('<br /><br>'),
+                         '<br /><br />')
+        self.assertEqual(scrubHTML('<hr /><hr>'),
+                         '<hr /><hr />')
+        self.assertEqual(scrubHTML('<img src="foo.png" /><img>'),
+                         '<img src="foo.png" /><img />')
+        self.assertEqual(scrubHTML('<meta name="title" content="" /><meta>'),
+                         '<meta name="title" content="" /><meta />')
 
     def test_scrubHTML_with_adapter(self):
         from zope.component.testing import setUp
@@ -155,35 +144,34 @@
 
         class _Scrubber:
             implements(IHTMLScrubber)
+
             def scrub(self, html):
                 return html.upper()
 
-
         setUp()
 
         sm = getSiteManager()
         try:
             sm.registerUtility(_Scrubber(), IHTMLScrubber)
-            self.assertEqual( scrubHTML('<a href="foo.html">bar</a>'),
-                            '<A HREF="FOO.HTML">BAR</A>' )
-            self.assertEqual( scrubHTML('<b>bar</b>'),
-                            '<B>BAR</B>' )
-            self.assertEqual( scrubHTML('<base href="" /><base>'),
-                            '<BASE HREF="" /><BASE>' )
-            self.assertEqual( scrubHTML('<blockquote>bar</blockquote>'),
-                            '<BLOCKQUOTE>BAR</BLOCKQUOTE>' )
-            self.assertEqual( scrubHTML('<body bgcolor="#ffffff">bar</body>'),
-                            '<BODY BGCOLOR="#FFFFFF">BAR</BODY>' )
-            self.assertEqual( scrubHTML('<br /><br>'),
-                            '<BR /><BR>' )
-            self.assertEqual( scrubHTML('<hr /><hr>'),
-                            '<HR /><HR>' )
-            self.assertEqual( scrubHTML('<img src="foo.png" /><img>'),
-                            '<IMG SRC="FOO.PNG" /><IMG>' )
-            self.assertEqual( scrubHTML(
-                                '<meta name="title" content="" /><meta>'),
-                            '<META NAME="TITLE" CONTENT="" /><META>' )
-
+            self.assertEqual(scrubHTML('<a href="foo.html">bar</a>'),
+                             '<A HREF="FOO.HTML">BAR</A>')
+            self.assertEqual(scrubHTML('<b>bar</b>'),
+                             '<B>BAR</B>')
+            self.assertEqual(scrubHTML('<base href="" /><base>'),
+                             '<BASE HREF="" /><BASE>')
+            self.assertEqual(scrubHTML('<blockquote>bar</blockquote>'),
+                             '<BLOCKQUOTE>BAR</BLOCKQUOTE>')
+            self.assertEqual(scrubHTML('<body bgcolor="#ffffff">bar</body>'),
+                             '<BODY BGCOLOR="#FFFFFF">BAR</BODY>')
+            self.assertEqual(scrubHTML('<br /><br>'),
+                             '<BR /><BR>')
+            self.assertEqual(scrubHTML('<hr /><hr>'),
+                             '<HR /><HR>')
+            self.assertEqual(scrubHTML('<img src="foo.png" /><img>'),
+                             '<IMG SRC="FOO.PNG" /><IMG>')
+            self.assertEqual(scrubHTML(
+                                     '<meta name="title" content="" /><meta>'),
+                             '<META NAME="TITLE" CONTENT="" /><META>')
         finally:
             tearDown()
 
@@ -195,16 +183,16 @@
         from Products.CMFCore.tests.base.content import STX_WITH_HTML
         from Products.CMFDefault.utils import bodyfinder
 
-        self.assertEqual( bodyfinder(FAUX_HTML_LEADING_TEXT),
-                          '\n  <h1>Not a lot here</h1>\n ' )
-        self.assertEqual( bodyfinder(SIMPLE_HTML),
-                          '\n  <h1>Not a lot here</h1>\n ' )
-        self.assertEqual( bodyfinder(SIMPLE_STRUCTUREDTEXT),
-                          SIMPLE_STRUCTUREDTEXT )
-        self.assertEqual( bodyfinder(SIMPLE_XHTML),
-                          '\n  <h1>Not a lot here</h1>\n ' )
-        self.assertEqual( bodyfinder(STX_WITH_HTML),
-                          '<p>Hello world, I am Bruce.</p>' )
+        self.assertEqual(bodyfinder(FAUX_HTML_LEADING_TEXT),
+                         '\n  <h1>Not a lot here</h1>\n ')
+        self.assertEqual(bodyfinder(SIMPLE_HTML),
+                         '\n  <h1>Not a lot here</h1>\n ')
+        self.assertEqual(bodyfinder(SIMPLE_STRUCTUREDTEXT),
+                         SIMPLE_STRUCTUREDTEXT)
+        self.assertEqual(bodyfinder(SIMPLE_XHTML),
+                         '\n  <h1>Not a lot here</h1>\n ')
+        self.assertEqual(bodyfinder(STX_WITH_HTML),
+                         '<p>Hello world, I am Bruce.</p>')
 
     def test_html_headcheck(self):
         from Products.CMFCore.tests.base.content import FAUX_HTML_LEADING_TEXT
@@ -214,47 +202,47 @@
         from Products.CMFCore.tests.base.content import STX_WITH_HTML
         from Products.CMFDefault.utils import html_headcheck
 
-        self.assertEqual( html_headcheck(FAUX_HTML_LEADING_TEXT), 0 )
-        self.assertEqual( html_headcheck(SIMPLE_HTML), 1 )
-        self.assertEqual( html_headcheck(SIMPLE_STRUCTUREDTEXT), 0 )
-        self.assertEqual( html_headcheck(SIMPLE_XHTML), 1 )
-        self.assertEqual( html_headcheck(STX_WITH_HTML), 0 )
+        self.assertEqual(html_headcheck(FAUX_HTML_LEADING_TEXT), 0)
+        self.assertEqual(html_headcheck(SIMPLE_HTML), 1)
+        self.assertEqual(html_headcheck(SIMPLE_STRUCTUREDTEXT), 0)
+        self.assertEqual(html_headcheck(SIMPLE_XHTML), 1)
+        self.assertEqual(html_headcheck(STX_WITH_HTML), 0)
 
     def test_tuplize(self):
         from Products.CMFDefault.utils import comma_split
         from Products.CMFDefault.utils import tuplize
-        wanted = ('one','two','three')
+        wanted = ('one', 'two', 'three')
 
-        self.assertEqual( tuplize('string', 'one two three'), wanted )
-        self.assertEqual( tuplize('unicode', u'one two three'), wanted )
-        self.assertEqual( tuplize('string', 'one,two,three', comma_split),
-                          wanted )
-        self.assertEqual( tuplize('list', ['one',' two','three ']), wanted )
-        self.assertEqual( tuplize('tuple', ('one','two','three')), wanted )
+        self.assertEqual(tuplize('string', 'one two three'), wanted)
+        self.assertEqual(tuplize('unicode', u'one two three'), wanted)
+        self.assertEqual(tuplize('string', 'one,two,three', comma_split),
+                         wanted)
+        self.assertEqual(tuplize('list', ['one', ' two', 'three ']), wanted)
+        self.assertEqual(tuplize('tuple', ('one', 'two', 'three')), wanted)
 
     def test_seq_strip(self):
         from Products.CMFDefault.utils import seq_strip
 
-        self.assertEqual( seq_strip(['one ', ' two', ' three ']),
-                          ['one','two','three'] )
-        self.assertEqual( seq_strip(('one ', ' two', ' three ')),
-                          ('one','two','three') )
+        self.assertEqual(seq_strip(['one ', ' two', ' three ']),
+                         ['one', 'two', 'three'])
+        self.assertEqual(seq_strip(('one ', ' two', ' three ')),
+                         ('one', 'two', 'three'))
 
     def test_html_marshal(self):
         from Products.CMFDefault.utils import html_marshal
 
-        self.assertEqual( html_marshal(foo=1), ( ('foo:int', 1), ) )
-        self.assertEqual( html_marshal(foo=1, bar='baz >&baz'),
-                          ( ('foo:int', 1), ('bar', 'baz >&baz') ) )
+        self.assertEqual(html_marshal(foo=1), (('foo:int', 1),))
+        self.assertEqual(html_marshal(foo=1, bar='baz >&baz'),
+                         (('foo:int', 1), ('bar', 'baz >&baz')))
 
     def test_toUnicode(self):
         from Products.CMFDefault.utils import toUnicode
 
-        self.assertEqual( toUnicode('foo'), u'foo' )
-        self.assertEqual( toUnicode( ('foo', 'bar'), 'ascii' ),
-                          (u'foo', u'bar') )
-        self.assertEqual( toUnicode( {'foo': 'bar'}, 'iso-8859-1' ),
-                          {'foo': u'bar'} )
+        self.assertEqual(toUnicode('foo'), u'foo')
+        self.assertEqual(toUnicode(('foo', 'bar'), 'ascii'),
+                         (u'foo', u'bar'))
+        self.assertEqual(toUnicode({'foo': 'bar'}, 'iso-8859-1'),
+                         {'foo': u'bar'})
 
     def test_checkEmailAddress(self):
         from Products.CMFDefault.exceptions import EmailAddressInvalid
@@ -285,70 +273,52 @@
                           'foo at -bar.example.com')
         # RFC 2821 local-part: max 64 characters
         self.assertRaises(EmailAddressInvalid, checkEmailAddress,
-                          'f'*63+'oo at example.com')
+                          'f' * 63 + 'oo at example.com')
         # RFC 2821 domain: max 255 characters
         self.assertRaises(EmailAddressInvalid, checkEmailAddress,
-                          'foo@'+'b'*242+'ar.example.com')
+                          'foo@' + 'b' * 242 + 'ar.example.com')
 
     def test_formatRFC822Headers_simple(self):
         from Products.CMFDefault.utils import formatRFC822Headers
 
-        HEADERS = [ ('Foo', 'foo')
-                  , ('Bar', 'bar')
-                  ]
+        HEADERS = [('Foo', 'foo'), ('Bar', 'bar')]
+        formatted = formatRFC822Headers(HEADERS)
 
-        formatted = formatRFC822Headers( HEADERS )
+        self.assertEqual(formatted, 'Foo: foo\r\nBar: bar')
 
-        self.assertEqual( formatted, 'Foo: foo\r\nBar: bar' )
-
     def test_formatRFC822Headers_empty(self):
         from Products.CMFDefault.utils import formatRFC822Headers
 
-        HEADERS = [ ('Foo', 'foo')
-                  , ('Bar', '')
-                  ]
+        HEADERS = [('Foo', 'foo'), ('Bar', '')]
+        formatted = formatRFC822Headers(HEADERS)
 
-        formatted = formatRFC822Headers( HEADERS )
+        self.assertEqual(formatted, 'Foo: foo\r\nBar: ')
 
-        self.assertEqual( formatted, 'Foo: foo\r\nBar: ' )
-
     def test_formatRFC822Headers_multiline(self):
         from Products.CMFDefault.utils import formatRFC822Headers
 
-        HEADERS = [ ('Foo', 'foo')
-                  , ('Bar', 'bar\nwith multiline')
-                  ]
+        HEADERS = [('Foo', 'foo'), ('Bar', 'bar\nwith multiline')]
+        formatted = formatRFC822Headers(HEADERS)
 
-        formatted = formatRFC822Headers( HEADERS )
+        self.assertEqual(formatted, 'Foo: foo\r\nBar: bar\r\n  with multiline')
 
-        self.assertEqual( formatted
-                        , 'Foo: foo\r\nBar: bar\r\n  with multiline' )
-
     def test_formatRFC822Headers_multiline_trailing_blank_line(self):
         from Products.CMFDefault.utils import formatRFC822Headers
 
-        HEADERS = [ ('Foo', 'foo')
-                  , ('Bar', 'bar\nwith multiline\n')
-                  ]
+        HEADERS = [('Foo', 'foo'), ('Bar', 'bar\nwith multiline\n')]
+        formatted = formatRFC822Headers(HEADERS)
 
-        formatted = formatRFC822Headers( HEADERS )
+        self.assertEqual(formatted, 'Foo: foo\r\nBar: bar\r\n  with multiline')
 
-        self.assertEqual( formatted
-                        , 'Foo: foo\r\nBar: bar\r\n  with multiline' )
-
     def test_formatRFC822Headers_multiline_intermediate_blank_line(self):
         from Products.CMFDefault.utils import formatRFC822Headers
 
-        HEADERS = [ ('Foo', 'foo')
-                  , ('Bar', 'bar\n\nwith multiline')
-                  ]
+        HEADERS = [('Foo', 'foo'), ('Bar', 'bar\n\nwith multiline')]
+        formatted = formatRFC822Headers(HEADERS)
 
-        formatted = formatRFC822Headers( HEADERS )
+        self.assertEqual(formatted,
+                         'Foo: foo\r\nBar: bar\r\n  \r\n  with multiline')
 
-        self.assertEqual( formatted
-                        , 'Foo: foo\r\nBar: bar\r\n  \r\n  with multiline' )
-
-
     def test_thousand_commas_integer(self):
         from Products.CMFDefault.utils import thousands_commas as FUT
         self.assertEqual(FUT(1), '1')



More information about the checkins mailing list