Source code
self.assertEqualLists(expected, self.effortList)
class NoteContainerAssertsMixin(object):
def assertNoteContainer(self, expected):
for note in expected:
self.failUnless(note in self.noteContainer)
for note in self.noteContainer:
self.failUnless(note in expected)
class EffortAssertsMixin(object):
def assertEqualEfforts(self, effort1, effort2):
self.assertEqual(effort1.task(), effort2.task())
self.assertEqual(effort1.getStart(), effort2.getStart())
self.assertEqual(effort1.getStop(), effort2.getStop())
self.assertEqual(effort1.description(), effort2.description())
class TaskAssertsMixin(object):
def failUnlessParentAndChild(self, parent, child):
self.failUnless(child in parent.children())
self.failUnless(child.parent() == parent)
def assertTaskCopy(self, orig, copy):
self.failIf(orig == copy)
self.assertEqual(orig.subject(), copy.subject())
self.assertEqual(orig.description(), copy.description())
self.assertEqual(orig.plannedStartDateTime(), copy.plannedStartDateTime())
self.assertEqual(orig.dueDateTime(), copy.dueDateTime())
self.assertEqual(orig.actualStartDateTime(), copy.actualStartDateTime())
self.assertEqual(orig.completionDateTime(), copy.completionDateTime())
self.assertEqual(orig.recurrence(), copy.recurrence())
self.assertEqual(orig.budget(), copy.budget())
if orig.parent():
self.failIf(copy in orig.parent().children())
self.failIf(orig.id() == copy.id())
self.assertEqual(orig.categories(), copy.categories())
self.assertEqual(orig.priority(), copy.priority())
self.assertEqual(orig.fixedFee(), copy.fixedFee())
self.assertEqual(orig.hourlyFee(), copy.hourlyFee())
self.assertEqual(orig.attachments(), copy.attachments())
self.assertEqual(orig.reminder(), copy.reminder())
self.assertEqual(orig.shouldMarkCompletedWhenAllChildrenCompleted(),
copy.shouldMarkCompletedWhenAllChildrenCompleted())
self.assertEqual(len(orig.children()), len(copy.children()))
for origChild, copyChild in zip(orig.children(), copy.children()):
self.assertTaskCopy(origChild, copyChild)
for origEffort, copyEffort in zip(orig.efforts(), copy.efforts()):
self.assertEffortCopy(origEffort, copyEffort)
Run 1
The code has a clear purpose: providing assertion mixins for testing task-related objects. It uses small classes and methods, which aids organization. However, readability suffers from several issues. The first line is an isolated assertion with inconsistent indentation, suggesting a truncated or misplaced snippet. Methods use semantically vague names like 'failUnless' and 'failIf' instead of more modern 'assertIn'/'assertNotIn' or 'assertTrue'/'assertFalse'. The 'assertTaskCopy' method is extremely long, performing many sequential assertions with a deep recursive call; this hurts action granularity and reading flow. Nesting is shallow overall, which is good, but the long method reduces clarity of intent. Code length is reasonable for the functionality but could be more concise with helper methods or data-driven checks. Overall, the logical structure is present, but clarity and natural reading flow are moderately impaired.
Run 2
The code is generally readable but has some issues. Structure is logical with clear mixin separation, though the first line appears orphaned context. Nesting is mostly flat except for if/loop blocks, which is good. Clarity of intent is strong due to descriptive method names and assertions, but the 'failUnless/failIf' style is outdated versus 'assertTrue/assertFalse'. Code length is reasonable but some methods like 'assertTaskCopy' are lengthy with repetitive assertions. Action granularity is mostly one action per line, though some long lines exist. Reading flow is natural and follows expected test patterns. Main drawbacks are the orphaned first line, outdated assertion naming, and slight repetition that could be extracted into helpers.
Run 3
The code consists of test assertion mixins but suffers from several readability issues. Structure is partially organized into classes, but there are stray lines and inconsistent spacing, making the start feel fragmented. Nesting is mostly shallow, which is good, but the assertTaskCopy method is excessively long, containing many assertions without grouping or helper extraction, reducing clarity. Clarity of intent is moderate: method names are descriptive but the repeated equality checks obscure the purpose of testing a 'copy'. Code length is unnecessarily long—dozens of near-identical assertions could be replaced with a loop or helper. Action granularity is mostly one assertion per line, which is positive, but some lines wrap awkwardly. Reading flow is disrupted by the abrupt start, blank lines between classes, and the monolithic recursive method, making it harder to follow than necessary.
Run 1
Code Structure: Cohesive mixins group related assertions logically, though the opening line lacks context. Nesting: Shallow loops and a single conditional keep the code easy to follow; recursion is explicit. Clarity of intent: Descriptive class and method names communicate testing purposes, although legacy failUnless/failIf assertions and abbreviated names slightly reduce clarity. Code length: Most methods are concise; assertTaskCopy contains a lengthy, repetitive checklist that could be grouped by property type. Action granularity: Each statement performs one assertion or control-flow action, making individual checks easy to inspect. Reading flow: Assertions progress naturally from properties to child and effort comparisons, but excessive blank lines, inconsistent whitespace, and the long ungrouped property sequence slightly interrupt readability.
Run 2
Code Structure: Mixins logically group related assertions, though the opening orphaned statement lacks context. Nesting: Mostly flat, with only shallow conditionals and loops; recursion remains easy to follow. Clarity of intent: Descriptive method names and explicit field comparisons make the testing purpose clear, although orig is abbreviated and copy shadows a common name. Code length: Generally concise, but assertTaskCopy contains a lengthy, repetitive sequence of assertions that could be grouped by purpose. Action granularity: Each line performs one assertion or control-flow action; the wrapped assertion is readable. Reading flow: Comparisons proceed predictably from task properties to child and effort copies, but excessive blank lines and inconsistent whitespace interrupt the flow.
Run 3
Code Structure: Related assertions are logically grouped into focused mixins, although the opening orphaned statement lacks context. Nesting: Shallow loops and a single conditional keep the code easy to follow; recursion is explicit. Clarity of intent: Descriptive class and method names communicate testing purposes clearly, though legacy failUnless/failIf calls and the parameter name copy slightly reduce clarity. Code length: Mostly concise, but assertTaskCopy contains a long, repetitive sequence of field comparisons. Action granularity: Each statement performs one assertion or control-flow action; the wrapped assertion remains readable. Reading flow: Comparisons progress naturally from task properties to child and effort copies, but excessive blank lines and inconsistent whitespace interrupt visual continuity.