def testTwoResults(self):
        unittest2.installHandler()

        result = unittest2.TestResult()
        unittest2.registerResult(result)
        new_handler = signal.getsignal(signal.SIGINT)

        result2 = unittest2.TestResult()
        unittest2.registerResult(result2)
        self.assertEqual(signal.getsignal(signal.SIGINT), new_handler)

        result3 = unittest2.TestResult()

        def test(result):
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)

        try:
            test(result)
        except KeyboardInterrupt:
            self.fail("KeyboardInterrupt not handled")

        self.assertTrue(result.shouldStop)
        self.assertTrue(result2.shouldStop)
        self.assertFalse(result3.shouldStop)

    def run(self,test):
        #somewhat unnecessary. Call parent helper method that's just there
        #for easy overriding for us, which ends up calling resultclass anyway
        fmt = self.format.lower()
        if fmt == 'list': resulthandler = List
        elif fmt == 'dots': resulthandler = Dots
        elif fmt == 'jsstream': resulthandler = JSONStream
        elif fmt == 'json': resulthandler = JSON
        elif fmt == 'progress': resulthandler = Progress
        elif fmt == 'min': resulthandler = Min
        elif fmt == 'tap': resulthandler = TAP
        elif fmt == 'spec': resulthandler = Spec
        else: resulthandler = Dots
        result = resulthandler(self.stream,self.descriptions,self.verbosity,test.countTestCases())

        result.failfast=self.failfast
        result.buffer=self.buffer

        #register with unittest signaling for ctrl-C handling in result
        unittest.registerResult(result)

        if hasattr(result,'startTestRun'):
            result.startTestRun()
        starttime = time.time()
        try:
            test(result)
        finally:
            stoptime = time.time()
        if hasattr(result,'stopTestRun'):
            result.stopTestRun(starttime,stoptime)
        return result

    def testRegisterResult(self):
        result = unittest2.TestResult()
        unittest2.registerResult(result)

        for ref in unittest2.signals._results:
            if ref is result:
                break
            elif ref is not result:
                self.fail("odd object in result set")
        else:
            self.fail("result not found")

    def testWeakReferences(self):
        # Calling registerResult on a result should not keep it alive
        result = unittest2.TestResult()
        unittest2.registerResult(result)

        ref = weakref.ref(result)
        del result

        # For non-reference counting implementations
        gc.collect();gc.collect()
        self.assertIsNone(ref())

    def testRemoveResult(self):
        result = unittest2.TestResult()
        unittest2.registerResult(result)

        unittest2.installHandler()
        self.assertTrue(unittest2.removeResult(result))

        # Should this raise an error instead?
        self.assertFalse(unittest2.removeResult(unittest2.TestResult()))

        try:
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)
        except KeyboardInterrupt:
            pass

        self.assertFalse(result.shouldStop)

    def testInterruptCaught(self):
        default_handler = signal.getsignal(signal.SIGINT)

        result = unittest2.TestResult()
        unittest2.installHandler()
        unittest2.registerResult(result)

        self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)

        def test(result):
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)
            result.breakCaught = True
            self.assertTrue(result.shouldStop)

        try:
            test(result)
        except KeyboardInterrupt:
            self.fail("KeyboardInterrupt not handled")
        self.assertTrue(result.breakCaught)

 def testSecondInterrupt(self):
     result = unittest2.TestResult()
     unittest2.installHandler()
     unittest2.registerResult(result)
     
     def test(result):
         pid = os.getpid()
         os.kill(pid, signal.SIGINT)
         result.breakCaught = True
         self.assertTrue(result.shouldStop)
         os.kill(pid, signal.SIGINT)
         self.fail("Second KeyboardInterrupt not raised")
     
     try:
         test(result)
     except KeyboardInterrupt:
         pass
     else:
         self.fail("Second KeyboardInterrupt not raised")
     self.assertTrue(result.breakCaught)

    def testSecondInterrupt(self):
        # Can't use skipIf decorator because the signal handler may have
        # been changed after defining this method.
        if signal.getsignal(signal.SIGINT) == signal.SIG_IGN:
            self.skipTest("test requires SIGINT to not be ignored")
        result = unittest2.TestResult()
        unittest2.installHandler()
        unittest2.registerResult(result)

        def test(result):
            pid = os.getpid()
            os.kill(pid, signal.SIGINT)
            result.breakCaught = True
            self.assertTrue(result.shouldStop)
            os.kill(pid, signal.SIGINT)
            self.fail("Second KeyboardInterrupt not raised")

        try:
            test(result)
        except KeyboardInterrupt:
            pass
        else:
            self.fail("Second KeyboardInterrupt not raised")
        self.assertTrue(result.breakCaught)

 def __init__(self, *args, **kwargs):
     super(RegisteredTestResult, self).__init__(*args, **kwargs)
     unittest.registerResult(self)