From eaedc71b2b8968c6caf31334f26f0d39be320ae6 Mon Sep 17 00:00:00 2001 From: Logan Miller Date: Tue, 22 Sep 2020 19:37:37 -0600 Subject: [PATCH 1/2] provide more specific test file location --- Src/IronPythonTest/Cases/CaseGenerator.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/Src/IronPythonTest/Cases/CaseGenerator.cs b/Src/IronPythonTest/Cases/CaseGenerator.cs index 3af8327b3..917ede67c 100644 --- a/Src/IronPythonTest/Cases/CaseGenerator.cs +++ b/Src/IronPythonTest/Cases/CaseGenerator.cs @@ -62,6 +62,7 @@ public IEnumerator GetEnumerator() { .SetCategory(category) .SetName(name) .Returns(0); + result.Properties.Add("_CodeFilePath", testcase.Path); var runIgnored = !string.IsNullOrWhiteSpace(TestContext.Parameters["RUN_IGNORED"]); From 6b6dcbd5d78f1cad0661ab8e6f3603c20a424d33 Mon Sep 17 00:00:00 2001 From: Logan Miller Date: Tue, 22 Sep 2020 19:38:28 -0600 Subject: [PATCH 2/2] Replace assertUnreachable with fail #880 --- Tests/interop/net/method/test_operators.py | 10 ++-- Tests/interop/net/type/test_reachtype.py | 6 +-- Tests/modules/io_related/test_cPickle.py | 2 +- Tests/modules/misc/test__weakref.py | 6 +-- Tests/modules/type_related/test__struct.py | 2 +- Tests/test_builtinfunc.py | 60 +++++++++++----------- Tests/test_class.py | 40 +++++++-------- Tests/test_cliclass.py | 20 ++++---- Tests/test_delegate.py | 2 +- Tests/test_file.py | 6 +-- Tests/test_function.py | 8 +-- Tests/test_isinstance.py | 4 +- Tests/test_kwarg.py | 6 +-- Tests/test_list.py | 2 +- Tests/test_namebinding.py | 2 +- Tests/test_number.py | 2 +- Tests/test_property.py | 2 +- Tests/test_syntax.py | 8 +-- Tests/test_tuple.py | 2 +- 19 files changed, 95 insertions(+), 95 deletions(-) diff --git a/Tests/interop/net/method/test_operators.py b/Tests/interop/net/method/test_operators.py index 622071cef..f77db0ba9 100644 --- a/Tests/interop/net/method/test_operators.py +++ b/Tests/interop/net/method/test_operators.py @@ -28,22 +28,22 @@ def test_all_ops(self): z = AllOpsClass(-6) #if x: pass - #else: self.assertUnreachable() + #else: self.fail("Unreachable code reached") # #Flag.Check(100) # - #if z: self.assertUnreachable() + #if z: self.fail("Unreachable code reached") #else: pass # #Flag.Check(100) # - #if not x: self.assertUnreachable() + #if not x: self.fail("Unreachable code reached") #else: pass # #Flag.Check(100) # #if not z: pass - #else: self.assertUnreachable() + #else: self.fail("Unreachable code reached") # #Flag.Check(100) @@ -288,4 +288,4 @@ def test_python_style(self): self.assertEqual(AllOpsClass.__gt__(x, y), True); Flag.Check(310) self.assertEqual(AllOpsClass.__ge__(x, y), True); Flag.Check(340) -run_test(__name__) \ No newline at end of file +run_test(__name__) diff --git a/Tests/interop/net/type/test_reachtype.py b/Tests/interop/net/type/test_reachtype.py index a1a089665..1b3ea1852 100644 --- a/Tests/interop/net/type/test_reachtype.py +++ b/Tests/interop/net/type/test_reachtype.py @@ -73,7 +73,7 @@ def test_interesting_names_as_class_name(self): def test_nothing_public(self): try: import NothingPublic - self.assertUnreachable() + self.fail("Unreachable code reached") except ImportError: pass @@ -129,7 +129,7 @@ def test_type_without_namespace(self): # internal type try: import InternalRefTypeWithoutNS - self.assertUnreachable() + self.fail("Unreachable code reached") except ImportError: pass @@ -206,7 +206,7 @@ def test_type_causing_load_exception(self): B = 10 try: from PossibleLoadException import B - self.assertUnreachable() + self.fail("Unreachable code reached") except ImportError: pass diff --git a/Tests/modules/io_related/test_cPickle.py b/Tests/modules/io_related/test_cPickle.py index 16fa23bd5..c575ed18e 100644 --- a/Tests/modules/io_related/test_cPickle.py +++ b/Tests/modules/io_related/test_cPickle.py @@ -631,7 +631,7 @@ def persistent_load(id): # exceptions vary between cPickle & Pickle try: up.load() - self.assertUnreachable() + self.fail("Unreachable code reached") except Exception as e: pass diff --git a/Tests/modules/misc/test__weakref.py b/Tests/modules/misc/test__weakref.py index 7a89e8b13..56d25fa3e 100644 --- a/Tests/modules/misc/test__weakref.py +++ b/Tests/modules/misc/test__weakref.py @@ -79,7 +79,7 @@ class C: pass try: type(wr).__add__.__get__(wr, None)() # object is dead, should throw except: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") # kwarg call @@ -100,14 +100,14 @@ def __add__(self, other): try: type(x).__sub__.__get(x, None)('abc') except AttributeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") if is_cli: # cli accepts kw-args everywhere # calling non-existent method should raise attribute error (kw-arg version) try: type(x).__sub__.__get(x, None)(other='abc') except AttributeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") def test_slot_repr(self): class C: pass diff --git a/Tests/modules/type_related/test__struct.py b/Tests/modules/type_related/test__struct.py index 0c9d95c73..818d92f56 100644 --- a/Tests/modules/type_related/test__struct.py +++ b/Tests/modules/type_related/test__struct.py @@ -190,7 +190,7 @@ def test_new_init(self): a = _struct.Struct('c') try: a.__init__('bad') - self.assertUnreachable() + self.fail("Unreachable code reached") except _struct.error as e: pass diff --git a/Tests/test_builtinfunc.py b/Tests/test_builtinfunc.py index efc90535a..10f889bfe 100644 --- a/Tests/test_builtinfunc.py +++ b/Tests/test_builtinfunc.py @@ -552,22 +552,22 @@ def test_eval(self): try: eval('1+') - self.assertUnreachable() + self.fail("Unreachable code reached") except Exception as exp: pass else: - self.assertUnreachable() + self.fail("Unreachable code reached") # gh1636 - don't use self.assertRaises since it hides the error zzz = 1 try: eval("zzz", {}) - self.assertUnreachable() + self.fail("Unreachable code reached") except NameError: pass try: eval("zzz", {}, None) - self.assertUnreachable() + self.fail("Unreachable code reached") except NameError: pass @@ -791,11 +791,11 @@ def test_round(self): try: round(number=2.5, ndigits=1.1) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as err: self.assertEqual("'float' object cannot be interpreted as an integer", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") # type implements __round__ # correct number of arguments @@ -814,47 +814,47 @@ def test_round(self): # too many arguments try: round(roundable, 1, 2) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as err: self.assertEqual("round() takes at most 2 arguments (3 given)", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") # type does not implement __round__ # too few arguments try: round(self.NotRoundable()) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as err: self.assertEqual("type NotRoundable doesn't define __round__ method", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") # correct number of arguments try: round(self.NotRoundable(), 1) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as err: self.assertEqual("type NotRoundable doesn't define __round__ method", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") try: round(number=self.NotRoundable(), ndigits=1) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as err: self.assertEqual("type NotRoundable doesn't define __round__ method", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") # too many arguments try: round(self.NotRoundable(), 1, 2) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as err: self.assertEqual("round() takes at most 2 arguments (3 given)", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") self.assertEqualAndCheckType(round(3), 3, int) self.assertEqualAndCheckType(round(3, 0), 3, int) @@ -892,51 +892,51 @@ def test_round(self): try: round(number=2, ndigits=1.1) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as err: self.assertEqual("'float' object cannot be interpreted as an integer", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") try: round(number=111111111111111111111111111111, ndigits=1.1) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as err: self.assertEqual("'float' object cannot be interpreted as an integer", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") try: round(float('nan')) - self.assertUnreachable() + self.fail("Unreachable code reached") except ValueError as err: self.assertEqual("cannot convert float NaN to integer", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") try: round(float('inf')) - self.assertUnreachable() + self.fail("Unreachable code reached") except OverflowError as err: self.assertEqual("cannot convert float infinity to integer", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") try: round(float('-inf')) - self.assertUnreachable() + self.fail("Unreachable code reached") except OverflowError as err: self.assertEqual("cannot convert float infinity to integer", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") try: round(sys.float_info.max, -307) - self.assertUnreachable() + self.fail("Unreachable code reached") except OverflowError as err: self.assertEqual("rounded value too large to represent", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") actual = round(float('inf'), 1) self.assertTrue(math.isinf(actual) and actual > 0) @@ -981,11 +981,11 @@ def test_round(self): try: round(5.5, self.NonIntegralIndex()) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as err: self.assertEqual("__index__ returned non-int (type str)", str(err)) else: - self.assertUnreachable() + self.fail("Unreachable code reached") def test_cp16000(self): class K(object): diff --git a/Tests/test_class.py b/Tests/test_class.py index 9f0f3b1bf..7afda335b 100644 --- a/Tests/test_class.py +++ b/Tests/test_class.py @@ -515,7 +515,7 @@ def CheckDictionary(C): if object in C.__bases__: try: C.__dict__[2] = '2' - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass self.assertEqual(2 in C.__dict__, False) @@ -536,7 +536,7 @@ class OldClass: pass else: try: C.__dict__ = {} - self.assertUnreachable() + self.fail("Unreachable code reached") except AttributeError: pass @@ -736,13 +736,13 @@ class N(C,B,A): pass try: class N(A, B,C): pass - self.assertUnreachable("impossible MRO created") + self.fail("Unreachable code reached: impossible MRO created") except TypeError: pass try: class N(A, A): pass - self.assertUnreachable("can't dervie from the same base type twice") + self.fail("Unreachable code reached: can't dervie from the same base type twice") except TypeError: pass @@ -850,7 +850,7 @@ class H(E): pass try: class H(A,B,E): pass - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass @@ -978,7 +978,7 @@ def NegativeTest(method, testCase): try: eval(testCase) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as e: pass @@ -1016,7 +1016,7 @@ def NegativeTest(method, testCase): try: exec(testCase, globals(), locals()) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass @@ -1049,7 +1049,7 @@ def NegativeTest(method, testCase): try: eval(testCase) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass @@ -1078,7 +1078,7 @@ def NegativeTest(method, testCase): try: eval(testCase) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass @@ -1106,7 +1106,7 @@ def NegativeTest(method, testCase): try: eval(testCase) - self.assertUnreachable() + self.fail("Unreachable code reached") except (TypeError, ValueError) as e: self.assertEqual(e.args[0].find('returned') == -1, True) # shouldn't have returned '__complex__ returned ...' @@ -1328,7 +1328,7 @@ class foo(object): try: class C(object): __slots__ = x - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass @@ -1546,13 +1546,13 @@ class CycleB: pass try: CycleA.__bases__ = (CycleA,) - self.self.assertUnreachable() + self.self.fail("Unreachable code reached") except TypeError: pass try: CycleA.__bases__ = (CycleB,) CycleB.__bases__ = (CycleA,) - self.self.assertUnreachable() + self.self.fail("Unreachable code reached") except TypeError: pass @@ -1624,7 +1624,7 @@ class foo(object): pass a = foo() try: a.__dict__ = x - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass def test_default_new_init(self): @@ -1770,7 +1770,7 @@ def __hash__(self): return 1<<35 def test_NoneSelf(seld): try: set.add(None) - self.self.assertUnreachable() + self.self.fail("Unreachable code reached") except TypeError: pass @@ -1808,19 +1808,19 @@ def test_property(self): prop = property() try: prop.fget = self.test_classmethod except TypeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") try: prop.fdel = self.test_classmethod except TypeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") try: prop.__doc__ = 'abc' except TypeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") try: prop.fset = self.test_classmethod except TypeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") @unittest.skipUnless(is_cli, 'IronPython specific test') def test_override_mro(self): @@ -3717,4 +3717,4 @@ def __init__(self, x): # unittest.main(defaultTest='test_suite') -run_test(__name__) \ No newline at end of file +run_test(__name__) diff --git a/Tests/test_cliclass.py b/Tests/test_cliclass.py index 8816f8461..5ec36ddcc 100644 --- a/Tests/test_cliclass.py +++ b/Tests/test_cliclass.py @@ -193,7 +193,7 @@ class OldClass: pass else: try: C.__dict__ = {} - self.assertUnreachable() + self.fail("Unreachable code reached") except AttributeError: pass @@ -242,12 +242,12 @@ def test_generic_TypeGroup(self): try: System.IComparable[int, int] except ValueError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") try: System.EventHandler(None) except TypeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") def handler(): pass @@ -255,7 +255,7 @@ def handler(): try: System.EventHandler(handler)("sender", None) except TypeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") def handler(s,a): pass @@ -275,7 +275,7 @@ def CompareTo(self, other): try: class MyDerivedClass(genericTypes): pass except TypeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") # Use a TypeGroup to index a TypeGroup t = genericTypes[System.IComparable] @@ -283,7 +283,7 @@ class MyDerivedClass(genericTypes): pass try: System.IComparable[genericTypes] except TypeError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") def test_generic_only_TypeGroup(self): from IronPythonTest import BinderTest @@ -454,7 +454,7 @@ class foo: pass if prop.Name == 'abc': break else: - self.assertUnreachable() + self.fail("Unreachable code reached") def test_char(self): for x in range(256): @@ -531,7 +531,7 @@ def test_explicit_interfaces(self): try: IOverrideTestInterface.__setitem__(otdc, 2, 3) except NotImplementedError: pass - else: self.assertUnreachable() + else: self.fail("Unreachable code reached") def test_field_helpers(self): from IronPythonTest import OverrideTestDerivedClass @@ -826,8 +826,8 @@ def test_nonzero(self): from System import Single, Byte, SByte, Int16, UInt16, Int64, UInt64 for t in [Single, Byte, SByte, Int16, UInt16, Int64, UInt64]: self.assertTrue(hasattr(t, '__nonzero__')) - if t(0): self.assertUnreachable() - if not t(1): self.assertUnreachable() + if t(0): self.fail("Unreachable code reached") + if not t(1): self.fail("Unreachable code reached") def test_virtual_event(self): from IronPythonTest import VirtualEvent, OverrideVirtualEvent, SimpleDelegate, UseEvent diff --git a/Tests/test_delegate.py b/Tests/test_delegate.py index 7a2701500..f5a4f7732 100644 --- a/Tests/test_delegate.py +++ b/Tests/test_delegate.py @@ -313,7 +313,7 @@ def identity(x): return x try: pts = ParameterizedThreadStart(foo.baz) pts("Hello") - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass # SuperDelegate Tests diff --git a/Tests/test_file.py b/Tests/test_file.py index 3ea22ef8e..818f93c87 100644 --- a/Tests/test_file.py +++ b/Tests/test_file.py @@ -557,7 +557,7 @@ def test_overwrite_readonly(self): except IOError as e: pass else: - self.assertUnreachable() # should throw + self.fail("Unreachable code reached") # should throw #any other exceptions fail def test_inheritance_kwarg_override(self): @@ -771,14 +771,14 @@ def test_errors(self): except Exception as e: self.assertEqual(e.errno, 2) else: - self.assertUnreachable() + self.fail("Unreachable code reached") try: open('path_too_long' * 100) except Exception as e: self.assertEqual(e.errno, 2) else: - self.assertUnreachable() + self.fail("Unreachable code reached") def test_write_bytes(self): fname = "temp_ip_%d" % os.getpid() diff --git a/Tests/test_function.py b/Tests/test_function.py index da8163573..4c95fba10 100644 --- a/Tests/test_function.py +++ b/Tests/test_function.py @@ -623,13 +623,13 @@ class B(A): pass # invalid super cases try: x = super(B, 'abc') - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass try: super(B,A) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass @@ -934,12 +934,12 @@ def f(): pass try: f(*(1, )) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass try: f(**{'abc':'def'}) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass diff --git a/Tests/test_isinstance.py b/Tests/test_isinstance.py index 666c3979b..0b6cce709 100644 --- a/Tests/test_isinstance.py +++ b/Tests/test_isinstance.py @@ -804,7 +804,7 @@ class D(B,A): pass try: class E(C,D): pass - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass @@ -815,7 +815,7 @@ def test_type_call_kwargs(self): def test_bad_addition(self): try: 2.0 + "2.0" - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass def test_class_property(self): diff --git a/Tests/test_kwarg.py b/Tests/test_kwarg.py index 8a162c48d..eb0f21438 100644 --- a/Tests/test_kwarg.py +++ b/Tests/test_kwarg.py @@ -539,7 +539,7 @@ def test_negTestFunc_badKwArgs(self): def test_NewSetCls(self): try: NewAll(cls=NewAll) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass @@ -650,7 +650,7 @@ def foo(**kw): pass # should raise because only strings are allowed try: foo(**{2:3}) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass @@ -669,7 +669,7 @@ def f(a, b): return a, b try: f(**{'a':2, 'b':3, 'c':4}) - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass diff --git a/Tests/test_list.py b/Tests/test_list.py index df4f1d356..d81e7626a 100644 --- a/Tests/test_list.py +++ b/Tests/test_list.py @@ -335,7 +335,7 @@ def test_inplace_addition(self): for left_operand, right_operand in neg_cases: try: left_operand += right_operand - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError: pass diff --git a/Tests/test_namebinding.py b/Tests/test_namebinding.py index 915864efe..8e62cabd2 100644 --- a/Tests/test_namebinding.py +++ b/Tests/test_namebinding.py @@ -914,7 +914,7 @@ def test_delete_builting_func(self): try: del pow - self.assertUnreachable("should have thrown") + self.fail("Unreachable code reached: should have thrown") except NameError: pass def test_class_var(self): diff --git a/Tests/test_number.py b/Tests/test_number.py index 4d22e632c..9ede13729 100644 --- a/Tests/test_number.py +++ b/Tests/test_number.py @@ -240,7 +240,7 @@ def __pos__(self): self.assertEqual(None == False, False) self.assertEqual(None == True, False) - if None: self.assertUnreachable("none shouldn't be true") + if None: self.fail("Unreachable code reached: none shouldn't be true") a = None if a: self.assertEqual(False, True) diff --git a/Tests/test_property.py b/Tests/test_property.py index 127a28b3a..44fe8035a 100644 --- a/Tests/test_property.py +++ b/Tests/test_property.py @@ -217,7 +217,7 @@ def test_class_assign(self): property in the class dictionary""" class x(object): def set(self, value): - self.assertUnreachable() + self.fail("Unreachable code reached") prop = property(lambda x:42, set) x.prop = 42 diff --git a/Tests/test_syntax.py b/Tests/test_syntax.py index b7d015f48..9fa3e877b 100644 --- a/Tests/test_syntax.py +++ b/Tests/test_syntax.py @@ -16,7 +16,7 @@ def run_compile_test(self, code, msg, lineno): self.assertEqual(e.lineno, lineno) self.assertEqual(e.filename, filename) else: - self.assertUnreachable("Expected exception, got none") + self.fail("Unreachable code reached: Expected exception, got none") def test_compile(self): @@ -627,7 +627,7 @@ def test_error_parameters(self): #print repr(input), flags try: code3 = compile(input, "dummy", "single", flags, 1) - self.assertUnreachable() + self.fail("Unreachable code reached") except SyntaxError as err: self.assertEqual(err.args, res) @@ -637,7 +637,7 @@ def test_error_parameters(self): def f(): x = 3 y = 5""") - self.assertUnreachable() + self.fail("Unreachable code reached") except IndentationError as e: self.assertEqual(e.lineno, 2) @@ -814,4 +814,4 @@ def test_syntax_warnings(self): self.assertEqual(trapper.messages, [":2: SyntaxWarning: name 'x' is assigned to before global declaration"]) -run_test(__name__) \ No newline at end of file +run_test(__name__) diff --git a/Tests/test_tuple.py b/Tests/test_tuple.py index 5ce13cbf7..58ce45f97 100644 --- a/Tests/test_tuple.py +++ b/Tests/test_tuple.py @@ -110,7 +110,7 @@ def test_tuple_cli_interactions(self): def test_sequence_assign(self): try: a, b = None - self.assertUnreachable() + self.fail("Unreachable code reached") except TypeError as e: self.assertEqual(e.args[0], "'NoneType' object is not iterable")