Beispiel #1
0
    def test_sanity(self):
        '''
        Sanity checks to ensure all exceptions implemented can be created/thrown/etc
        in the standard ways.
        '''
        #build up a list of all valid exceptions
        import exceptions
        #special cases - do not test these like everything else
        special_types = [
            "UnicodeTranslateError", "UnicodeEncodeError", "UnicodeDecodeError"
        ]
        exception_types = [
            x for x in list(exceptions.__dict__.keys())
            if x.startswith("__") == False and special_types.count(x) == 0
        ]
        exception_types = [eval("exceptions." + x) for x in exception_types]

        #run a few sanity checks
        for exception_type in exception_types:
            except_list = [exception_type(), exception_type("a single param")]

            for t_except in except_list:
                try:
                    raise t_except
                except exception_type as e:
                    pass

                str_except = str(t_except)

                #there is no __getstate__ method of exceptions...
                self.assertTrue(not hasattr(t_except, '__getstate__'))

        #special cases
        encode_except = exceptions.UnicodeEncodeError("1", "2", 3, 4, "5")
        self.assertEqual(encode_except.encoding, "1")
        self.assertEqual(encode_except.object, "2")
        self.assertEqual(encode_except.start, 3)
        self.assertEqual(encode_except.end, 4)
        self.assertEqual(encode_except.reason, "5")
        self.assertEqual(encode_except.message, "")

        #CodePlex Work Item 356
        #self.assertRaises(TypeError, exceptions.UnicodeDecodeError, "1", u"2", 3, 4, "e")
        exceptions.UnicodeDecodeError("1", "2", 3, 4, "e")

        decode_except = exceptions.UnicodeDecodeError("1", "2", 3, 4, "5")
        self.assertEqual(decode_except.encoding, "1")
        self.assertEqual(decode_except.object, "2")
        self.assertEqual(decode_except.start, 3)
        self.assertEqual(decode_except.end, 4)
        self.assertEqual(decode_except.reason, "5")
        self.assertEqual(decode_except.message, "")

        translate_except = exceptions.UnicodeTranslateError("1", 2, 3, "4")
        self.assertEqual(translate_except.object, "1")
        self.assertEqual(translate_except.start, 2)
        self.assertEqual(translate_except.end, 3)
        self.assertEqual(translate_except.reason, "4")
        self.assertEqual(translate_except.message, "")
        self.assertEqual(translate_except.encoding, None)
Beispiel #2
0
def test_cp945():
    #--sanity
    try:
        x = 1 / 0
        Fail("should have been division by zero error")
    except Exception as e:
        temp_msg = e.message

    x_pickled = pickle.dumps(e)
    x_unpickled = pickle.loads(x_pickled)
    AreEqual(x_unpickled.message, temp_msg)

    #--comprehensive
    import exceptions

    special_types = [
        "UnicodeTranslateError", "UnicodeEncodeError", "UnicodeDecodeError"
    ]
    exception_types = [
        x for x in list(exceptions.__dict__.keys())
        if x.startswith("__") == False and special_types.count(x) == 0
    ]
    exception_types = [eval("exceptions." + x) for x in exception_types]

    for exception_type in exception_types:
        except_list = [exception_type(), exception_type("a single param")]

        for t_except in except_list:
            try:
                raise t_except
            except exception_type as e:
                temp_msg = e.message

            x_pickled = pickle.dumps(e)
            x_unpickled = pickle.loads(x_pickled)
            AreEqual(x_unpickled.message, temp_msg)

    #--special cases
    if not is_silverlight:
        for e in [
                exceptions.UnicodeEncodeError("1", "2", 3, 4, "5"),
                exceptions.UnicodeDecodeError("1", "2", 3, 4, "5"),
                exceptions.UnicodeTranslateError("1", 2, 3, "4")
        ]:
            x_pickled = pickle.dumps(e)
            x_unpickled = pickle.loads(x_pickled)
            AreEqual(x_unpickled.object, e.object)
Beispiel #3
0
        AreEqual(encode_except.reason, "5")
        AreEqual(encode_except.message, "")
        
        #CodePlex Work Item 356
        #AssertError(TypeError, exceptions.UnicodeDecodeError, "1", u"2", 3, 4, "e")
        exceptions.UnicodeDecodeError("1", "2", 3, 4, "e")
        
        decode_except = exceptions.UnicodeDecodeError("1", "2", 3, 4, "5")
        AreEqual(decode_except.encoding, "1")
        AreEqual(decode_except.object, "2")
        AreEqual(decode_except.start, 3)
        AreEqual(decode_except.end, 4)
        AreEqual(decode_except.reason, "5")
        AreEqual(decode_except.message, "")
        
        translate_except = exceptions.UnicodeTranslateError(u"1", 2, 3, "4")
        AreEqual(translate_except.object, u"1")
        AreEqual(translate_except.start, 2)
        AreEqual(translate_except.end, 3)
        AreEqual(translate_except.reason, "4")
        AreEqual(translate_except.message, "")
        AreEqual(translate_except.encoding, None)

def test_nested_exceptions():
    try:
        raise Exception()
    except Exception, e:
        # PushException
        try:
            raise TypeError
        except TypeError, te: