TestLCS.test_string() - Code Metrics - j340m3/python-msquaredc - Measure and Improve Code Quality continuously with Scrutinizer

TestLCS.test_string() A
last analyzed 2018-04-10 22:12 UTC

↳ Parent: TestLCS

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
dl	0
loc	2
rs	10

import unittest

from msquaredc.utils import Decorator
from msquaredc.utils import lcs


class TestDecorator(unittest.TestCase):
    def test_init(self):
        self.assertIsNotNone(Decorator())

    def test_class_without_args(self):
        @Decorator
        class A:
            def a(self):
                return 2

        a_inst = A()

        self.assertIsNotNone(a_inst)
        self.assertEqual(a_inst.__class__.__name__, "A")
        self.assertEqual(a_inst.a(), 2)

    def test_method_without_args(self):
        @Decorator
        def A():
            return 3

        self.assertEqual(A(), 3)

    def test_arg_class_without_args(self):
        @Decorator
        class A:
            def __init__(self, b):
                self.b = b

            def a(self):
                return self.b

        a_inst = A(2)

        self.assertIsNotNone(a_inst)
        self.assertEqual(a_inst.__class__.__name__, "A")
        self.assertEqual(a_inst.a(), 2)

    def test_arg_method_without_args(self):
        @Decorator
        def A(a):
            return a

        self.assertEqual(A(3), 3)

    def test_class_with_args(self):
        @Decorator(1, k=2)
        class A:
            def a(self):
                return 2

        a_inst = A()

        self.assertIsNotNone(a_inst)
        self.assertEqual(a_inst.__class__.__name__, "A")
        self.assertEqual(a_inst.a(), 2)

    def test_method_with_args(self):
        @Decorator(1, k=2)
        def A():
            return 3

        self.assertEqual(A(), 3)

    def test_arg_class_with_args(self):
        @Decorator(1, k=2)
        class A:
            def __init__(self, b):
                self.b = b

            def a(self):
                return self.b

        a_inst = A(2)

        self.assertIsNotNone(a_inst)
        self.assertEqual(a_inst.__class__.__name__, "A")
        self.assertEqual(a_inst.a(), 2)

    def test_arg_method_without_args(self):
        @Decorator(1, k=2)
        def A(a):
            return a

        self.assertEqual(A(3), 3)

    def test_callable_as_decorator_arg_in_function(self):
        def f(a):
            return a * 2

        @Decorator(f, k=2)
        def A(a):
            return a

        self.assertEqual(A(3), 3)

    def test_callable_as_decorator_arg_in_class(self):
        def f(a):
            return a * 2

        @Decorator(f, k=2)
        class A:
            def __init__(self, b):
                self.b = b

            def a(self):
                return self.b

        a_inst = A(2)

        self.assertIsNotNone(a_inst)
        self.assertEqual(a_inst.__class__.__name__, "A")
        self.assertEqual(a_inst.a(), 2)

    def test_callable_everywhere_in_function(self):
        def f(a):
            return a * 2

        def ident(a):
            return a

        @Decorator(f, k=2)
        def A(a):
            return a

        self.assertEqual(A(ident(3)), 3)

    def test_callable_everywhere_in_class(self):
        def f(a):
            return a * 2

        def g(a):
            return a

        @Decorator(f, k=2)
        class A:
            def __init__(self, b):
                self.b = b

            def a(self):
                return self.b(2)

        a_inst = A(g)

        self.assertIsNotNone(a_inst)
        self.assertEqual(a_inst.__class__.__name__, "A")
        self.assertEqual(a_inst.a(), 2)

    def test_class_as_only_argument(self):
        class B:
            def __init__(self, *args, **kwargs):
                self.args = args
                self.kwargs = kwargs

        @Decorator(B, 4)
        class A:
            def a(self):
                return 2

        a_inst = A()

        self.assertIsNotNone(a_inst)
        self.assertEqual(a_inst.__class__.__name__, "A")
        self.assertEqual(a_inst.a(), 2)

    def test_class_decorator(self):
        class A(object):
            def __str__(self):
                return "Bla"

        a = Decorator.create_wrapping_class(A, {})
        self.assertEqual(str(a()), "Bla")
        self.assertEqual(a().__class__.__name__, "A")
        self.assertEqual(repr(a()).split("at 0x")[0], repr(A()).split("at 0x")[0])
        self.assertIsInstance(a(), A)
        self.assertEqual(repr(a), repr(A))

    def test_inheritance_in_class_decorator(self):
        class A(object):
            def a(self):
                return 2

        class B(A):
            def b(self):
                return 3

        b = Decorator.create_wrapping_class(B, {})

        class C(b):
            def c(self):
                return 4

        self.assertEqual(b().b(), 3)
        self.assertEqual(b().a(), 2)
        self.assertEqual(C().b(), 3)
        self.assertTrue(issubclass(C, B))
        self.assertTrue(issubclass(C, A))


class TestLCS(unittest.TestCase):
    def test_string(self):
        self.assertEqual(lcs("123123123", "352515"), "321")


if __name__ == "__main__":
    unittest.main()


1			import unittest
2
3			from msquaredc.utils import Decorator
4			from msquaredc.utils import lcs
5
6
7			class TestDecorator(unittest.TestCase):
8			def test_init(self):
9			self.assertIsNotNone(Decorator())
10
11			def test_class_without_args(self):
12			@Decorator
13			class A:
14			def a(self):
15			return 2
16
17			a_inst = A()
18
19			self.assertIsNotNone(a_inst)
20			self.assertEqual(a_inst.__class__.__name__, "A")
21			self.assertEqual(a_inst.a(), 2)
22
23			def test_method_without_args(self):
24			@Decorator
25			def A():
26			return 3
27
28			self.assertEqual(A(), 3)
29
30			def test_arg_class_without_args(self):
31			@Decorator
32			class A:
33			def __init__(self, b):
34			self.b = b
35
36			def a(self):
37			return self.b
38
39			a_inst = A(2)
40
41			self.assertIsNotNone(a_inst)
42			self.assertEqual(a_inst.__class__.__name__, "A")
43			self.assertEqual(a_inst.a(), 2)
44
45			def test_arg_method_without_args(self):
46			@Decorator
47			def A(a):
48			return a
49
50			self.assertEqual(A(3), 3)
51
52			def test_class_with_args(self):
53			@Decorator(1, k=2)
54			class A:
55			def a(self):
56			return 2
57
58			a_inst = A()
59
60			self.assertIsNotNone(a_inst)
61			self.assertEqual(a_inst.__class__.__name__, "A")
62			self.assertEqual(a_inst.a(), 2)
63
64			def test_method_with_args(self):
65			@Decorator(1, k=2)
66			def A():
67			return 3
68
69			self.assertEqual(A(), 3)
70
71			def test_arg_class_with_args(self):
72			@Decorator(1, k=2)
73			class A:
74			def __init__(self, b):
75			self.b = b
76
77			def a(self):
78			return self.b
79
80			a_inst = A(2)
81
82			self.assertIsNotNone(a_inst)
83			self.assertEqual(a_inst.__class__.__name__, "A")
84			self.assertEqual(a_inst.a(), 2)
85
86			def test_arg_method_without_args(self):
87			@Decorator(1, k=2)
88			def A(a):
89			return a
90
91			self.assertEqual(A(3), 3)
92
93			def test_callable_as_decorator_arg_in_function(self):
94			def f(a):
95			return a * 2
96
97			@Decorator(f, k=2)
98			def A(a):
99			return a
100
101			self.assertEqual(A(3), 3)
102
103			def test_callable_as_decorator_arg_in_class(self):
104			def f(a):
105			return a * 2
106
107			@Decorator(f, k=2)
108			class A:
109			def __init__(self, b):
110			self.b = b
111
112			def a(self):
113			return self.b
114
115			a_inst = A(2)
116
117			self.assertIsNotNone(a_inst)
118			self.assertEqual(a_inst.__class__.__name__, "A")
119			self.assertEqual(a_inst.a(), 2)
120
121			def test_callable_everywhere_in_function(self):
122			def f(a):
123			return a * 2
124
125			def ident(a):
126			return a
127
128			@Decorator(f, k=2)
129			def A(a):
130			return a
131
132			self.assertEqual(A(ident(3)), 3)
133
134			def test_callable_everywhere_in_class(self):
135			def f(a):
136			return a * 2
137
138			def g(a):
139			return a
140
141			@Decorator(f, k=2)
142			class A:
143			def __init__(self, b):
144			self.b = b
145
146			def a(self):
147			return self.b(2)
148
149			a_inst = A(g)
150
151			self.assertIsNotNone(a_inst)
152			self.assertEqual(a_inst.__class__.__name__, "A")
153			self.assertEqual(a_inst.a(), 2)
154
155			def test_class_as_only_argument(self):
156			class B:
157			def __init__(self, args, *kwargs):
158			self.args = args
159			self.kwargs = kwargs
160
161			@Decorator(B, 4)
162			class A:
163			def a(self):
164			return 2
165
166			a_inst = A()
167
168			self.assertIsNotNone(a_inst)
169			self.assertEqual(a_inst.__class__.__name__, "A")
170			self.assertEqual(a_inst.a(), 2)
171
172			def test_class_decorator(self):
173			class A(object):
174			def __str__(self):
175			return "Bla"
176
177			a = Decorator.create_wrapping_class(A, {})
178			self.assertEqual(str(a()), "Bla")
179			self.assertEqual(a().__class__.__name__, "A")
180			self.assertEqual(repr(a()).split("at 0x")[0], repr(A()).split("at 0x")[0])
181			self.assertIsInstance(a(), A)
182			self.assertEqual(repr(a), repr(A))
183
184			def test_inheritance_in_class_decorator(self):
185			class A(object):
186			def a(self):
187			return 2
188
189			class B(A):
190			def b(self):
191			return 3
192
193			b = Decorator.create_wrapping_class(B, {})
194
195			class C(b):
196			def c(self):
197			return 4
198
199			self.assertEqual(b().b(), 3)
200			self.assertEqual(b().a(), 2)
201			self.assertEqual(C().b(), 3)
202			self.assertTrue(issubclass(C, B))
203			self.assertTrue(issubclass(C, A))
204
205
206			class TestLCS(unittest.TestCase):
207			def test_string(self):
208			self.assertEqual(lcs("123123123", "352515"), "321")
209
210
211			if __name__ == "__main__":
212			unittest.main()
213

j340m3 / python-msquaredc

TestLCS.test_string() A last analyzed 2018-04-10 22:12 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

TestLCS.test_string() A
last analyzed 2018-04-10 22:12 UTC