test_oval_tree.get_tree.GetTree.simple_tree() - Code Metrics - Inspection of "Fixes search in the OVAL tree" - OpenSCAP/oval-graph - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#206)

by Jan

created 2021-08-02 09:59 UTC

test_oval_tree.get_tree.GetTree.simple_tree() A

↳ Parent: test_oval_tree.get_tree

Complexity

Conditions

Size

Total Lines	31
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	28
nop	0
dl	0
loc	31
rs	9.208
c	0
b	0
f	0

import json
from pathlib import Path

from oval_graph.oval_tree.oval_node import OvalNode


class GetTree():

    @staticmethod
    def simple_tree():
        return OvalNode(
            node_id=1,
            node_type='operator',
            value='and',
            children=[
                OvalNode(
                    node_id=2,
                    node_type='value',
                    value='true',
                ),
                OvalNode(
                    node_id=3,
                    node_type='value',
                    value='false',
                ),
                OvalNode(
                    node_id=4,
                    node_type='operator',
                    value='or',
                    children=[
                        OvalNode(
                            node_id=5,
                            node_type='value',
                            value='false',
                        ),
                        OvalNode(
                            node_id=6,
                            node_type='value',
                            value="true",
                        ),
                    ]
                )
            ]
        )

    @staticmethod
    def tree_true():
        return OvalNode(
            node_id=1,
            node_type='operator',
            value='and',
            children=[
                OvalNode(
                    node_id=2,
                    node_type='value',
                    value='true',
                )
            ]
        )

    @staticmethod
    def tree_false():
        return OvalNode(
            node_id=1,
            node_type='operator',
            value='and',
            children=[
                OvalNode(
                    node_id=2,
                    node_type='value',
                    value="false",
                ),
            ]
        )

    @staticmethod
    def tree_noteval():
        return OvalNode(
            node_id=1,
            node_type='operator',
            value='and',
            children=[
                OvalNode(
                    node_id=2,
                    node_type='value',
                    value='noteval',
                )
            ]
        )

    @staticmethod
    def tree_false_one_node():
        return OvalNode(
            node_id=1,
            node_type='value',
            value='false',
        )

    @staticmethod
    def tree_true_one_node():
        return OvalNode(
            node_id=1,
            node_type='value',
            value='true',
        )

    @staticmethod
    def tree_error_one_node():
        return OvalNode(
            node_id=1,
            node_type='value',
            value='error',
        )

    @staticmethod
    def negated_operator_node_false():
        return OvalNode(
            node_id=1,
            node_type='operator',
            value='and',
            negation=True,
            children=[
                OvalNode(
                    node_id=2,
                    node_type='value',
                    value='false',
                )
            ]
        )

    @staticmethod
    def negated_operator_node_true():
        return OvalNode(
            node_id=1,
            node_type='operator',
            value='and',
            negation=True,
            children=[
                OvalNode(
                    node_id=2,
                    node_type='value',
                    value='true',
                )
            ]
        )

    @staticmethod
    def negate_value_node_false():
        return OvalNode(
            node_id=1,
            node_type='operator',
            value='and',
            children=[
                OvalNode(
                    node_id=2,
                    node_type='value',
                    value="false",
                    negation=True,
                ),
            ]
        )

    @staticmethod
    def negate_value_node_true():
        return OvalNode(
            node_id=1,
            node_type='operator',
            value='and',
            children=[
                OvalNode(
                    node_id=2,
                    node_type='value',
                    value="true",
                    negation=True,
                ),
            ]
        )

    @staticmethod
    def negated_value_node_true():
        return OvalNode(
            node_id=2,
            node_type='value',
            value='true',
            negation=True,
        )

    @staticmethod
    def negated_value_node_false():
        return OvalNode(
            node_id=2,
            node_type='value',
            value='false',
            negation=True,
        )

    @staticmethod
    def uppercase_tree():
        return OvalNode(
            node_id=1,
            node_type="OPERATOR",
            value="AND",
            children=[
                OvalNode(
                    node_id=2,
                    node_type="VALUE",
                    value="TRUE",
                ),
                OvalNode(
                    node_id=3,
                    node_type="VALUE",
                    value="NOTAPPL",
                ),
            ]
        )

    @staticmethod
    def big_oval_tree():
        return OvalNode(
            node_id=1,
            node_type='operator',
            value='and',
            children=[
                OvalNode(
                    node_id=2,
                    node_type='value',
                    value="false",
                ),
                OvalNode(
                    node_id=3,
                    node_type='operator',
                    value="xor",
                    children=[
                        OvalNode(
                            node_id=4,
                            node_type='value',
                            value='true',
                        ),
                        OvalNode(
                            node_id=5,
                            node_type='operator',
                            value='one',
                            children=[
                                OvalNode(
                                    node_id=6,
                                    node_type='value',
                                    value='noteval',
                                ),
                                OvalNode(
                                    node_id=7,
                                    node_type='value',
                                    value='true',
                                ),
                                OvalNode(
                                    node_id=8,
                                    node_type='value',
                                    value='notappl',
                                ),
                            ]
                        ),
                        OvalNode(
                            node_id=9,
                            node_type='value',
                            value='error',
                        ),
                    ]
                ),
                OvalNode(
                    node_id=10,
                    node_type='operator',
                    value='or',
                    children=[
                        OvalNode(
                            node_id=11,
                            node_type='value',
                            value="unknown",
                        ),
                        OvalNode(
                            node_id=12,
                            node_type='value',
                            value="true",
                        ),
                    ]
                ),
            ]
        )

    # Degenered trees
    @staticmethod
    def bad_tree():
        """
            t
            |
            and
            |
            t
        """
        return OvalNode(
            node_id=1,
            node_type="value",
            value="true",
            children=[
                OvalNode(
                    node_id=2,
                    node_type="operator",
                    value="and",
                    children=[
                        OvalNode(
                            node_id=3,
                            node_type="value",
                            value="true",
                        ),
                    ]
                ),
            ]
        )

    @staticmethod
    def tree_only_or():
        """
            or
        """
        return OvalNode(
            node_id=1,
            node_type="operator",
            value='or',
        )

    @staticmethod
    def tree_only_and():
        """
            and
        """
        return OvalNode(
            node_id=1,
            node_type="operator",
            value='and',
        )

    @staticmethod
    def tree_with_bad_value_of_operator():
        return OvalNode(
            node_id=1,
            node_type="operator",
            value='nad',
        )

    @staticmethod
    def tree_with_bad_value_of_value():
        return OvalNode(
            node_id=1,
            node_type="value",
            value='and',
        )

    @staticmethod
    def tree_with_bad_type():
        return OvalNode(
            node_id=1,
            node_type="car",
            value='and',
        )

    @staticmethod
    def tree_with_bad_value_of_negation():
        return OvalNode(
            node_id=1,
            node_type="operator",
            value="true",
            children=[
                OvalNode(
                    node_id=2,
                    node_type="value",
                    value='true',
                    negation="random_string",
                )
            ]
        )

    @staticmethod
    def json_of_tree(src):
        path = Path(__file__).parent / src
        with open(path, 'r') as file_:
            return json.load(file_)


1			import json
2			from pathlib import Path
3
4			from oval_graph.oval_tree.oval_node import OvalNode
5
6
7			class GetTree():
8
9			@staticmethod
10			def simple_tree():
11			return OvalNode(
12			node_id=1,
13			node_type='operator',
14			value='and',
15			children=[
16			OvalNode(
17			node_id=2,
18			node_type='value',
19			value='true',
20			),
21			OvalNode(
22			node_id=3,
23			node_type='value',
24			value='false',
25			),
26			OvalNode(
27			node_id=4,
28			node_type='operator',
29			value='or',
30			children=[
31			OvalNode(
32			node_id=5,
33			node_type='value',
34			value='false',
35			),
36			OvalNode(
37			node_id=6,
38			node_type='value',
39			value="true",
40			),
41			]
42			)
43			]
44			)
45
46			@staticmethod
47			def tree_true():
48			return OvalNode(
49			node_id=1,
50			node_type='operator',
51			value='and',
52			children=[
53			OvalNode(
54			node_id=2,
55			node_type='value',
56			value='true',
57			)
58			]
59			)
60
61			@staticmethod
62			def tree_false():
63			return OvalNode(
64			node_id=1,
65			node_type='operator',
66			value='and',
67			children=[
68			OvalNode(
69			node_id=2,
70			node_type='value',
71			value="false",
72			),
73			]
74			)
75
76			@staticmethod
77			def tree_noteval():
78			return OvalNode(
79			node_id=1,
80			node_type='operator',
81			value='and',
82			children=[
83			OvalNode(
84			node_id=2,
85			node_type='value',
86			value='noteval',
87			)
88			]
89			)
90
91			@staticmethod
92			def tree_false_one_node():
93			return OvalNode(
94			node_id=1,
95			node_type='value',
96			value='false',
97			)
98
99			@staticmethod
100			def tree_true_one_node():
101			return OvalNode(
102			node_id=1,
103			node_type='value',
104			value='true',
105			)
106
107			@staticmethod
108			def tree_error_one_node():
109			return OvalNode(
110			node_id=1,
111			node_type='value',
112			value='error',
113			)
114
115			@staticmethod
116			def negated_operator_node_false():
117			return OvalNode(
118			node_id=1,
119			node_type='operator',
120			value='and',
121			negation=True,
122			children=[
123			OvalNode(
124			node_id=2,
125			node_type='value',
126			value='false',
127			)
128			]
129			)
130
131			@staticmethod
132			def negated_operator_node_true():
133			return OvalNode(
134			node_id=1,
135			node_type='operator',
136			value='and',
137			negation=True,
138			children=[
139			OvalNode(
140			node_id=2,
141			node_type='value',
142			value='true',
143			)
144			]
145			)
146
147			@staticmethod
148			def negate_value_node_false():
149			return OvalNode(
150			node_id=1,
151			node_type='operator',
152			value='and',
153			children=[
154			OvalNode(
155			node_id=2,
156			node_type='value',
157			value="false",
158			negation=True,
159			),
160			]
161			)
162
163			@staticmethod
164			def negate_value_node_true():
165			return OvalNode(
166			node_id=1,
167			node_type='operator',
168			value='and',
169			children=[
170			OvalNode(
171			node_id=2,
172			node_type='value',
173			value="true",
174			negation=True,
175			),
176			]
177			)
178
179			@staticmethod
180			def negated_value_node_true():
181			return OvalNode(
182			node_id=2,
183			node_type='value',
184			value='true',
185			negation=True,
186			)
187
188			@staticmethod
189			def negated_value_node_false():
190			return OvalNode(
191			node_id=2,
192			node_type='value',
193			value='false',
194			negation=True,
195			)
196
197			@staticmethod
198			def uppercase_tree():
199			return OvalNode(
200			node_id=1,
201			node_type="OPERATOR",
202			value="AND",
203			children=[
204			OvalNode(
205			node_id=2,
206			node_type="VALUE",
207			value="TRUE",
208			),
209			OvalNode(
210			node_id=3,
211			node_type="VALUE",
212			value="NOTAPPL",
213			),
214			]
215			)
216
217			@staticmethod
218			def big_oval_tree():
219			return OvalNode(
220			node_id=1,
221			node_type='operator',
222			value='and',
223			children=[
224			OvalNode(
225			node_id=2,
226			node_type='value',
227			value="false",
228			),
229			OvalNode(
230			node_id=3,
231			node_type='operator',
232			value="xor",
233			children=[
234			OvalNode(
235			node_id=4,
236			node_type='value',
237			value='true',
238			),
239			OvalNode(
240			node_id=5,
241			node_type='operator',
242			value='one',
243			children=[
244			OvalNode(
245			node_id=6,
246			node_type='value',
247			value='noteval',
248			),
249			OvalNode(
250			node_id=7,
251			node_type='value',
252			value='true',
253			),
254			OvalNode(
255			node_id=8,
256			node_type='value',
257			value='notappl',
258			),
259			]
260			),
261			OvalNode(
262			node_id=9,
263			node_type='value',
264			value='error',
265			),
266			]
267			),
268			OvalNode(
269			node_id=10,
270			node_type='operator',
271			value='or',
272			children=[
273			OvalNode(
274			node_id=11,
275			node_type='value',
276			value="unknown",
277			),
278			OvalNode(
279			node_id=12,
280			node_type='value',
281			value="true",
282			),
283			]
284			),
285			]
286			)
287
288			# Degenered trees
289			@staticmethod
290			def bad_tree():
291			"""
292			t
293			\|
294			and
295			\|
296			t
297			"""
298			return OvalNode(
299			node_id=1,
300			node_type="value",
301			value="true",
302			children=[
303			OvalNode(
304			node_id=2,
305			node_type="operator",
306			value="and",
307			children=[
308			OvalNode(
309			node_id=3,
310			node_type="value",
311			value="true",
312			),
313			]
314			),
315			]
316			)
317
318			@staticmethod
319			def tree_only_or():
320			"""
321			or
322			"""
323			return OvalNode(
324			node_id=1,
325			node_type="operator",
326			value='or',
327			)
328
329			@staticmethod
330			def tree_only_and():
331			"""
332			and
333			"""
334			return OvalNode(
335			node_id=1,
336			node_type="operator",
337			value='and',
338			)
339
340			@staticmethod
341			def tree_with_bad_value_of_operator():
342			return OvalNode(
343			node_id=1,
344			node_type="operator",
345			value='nad',
346			)
347
348			@staticmethod
349			def tree_with_bad_value_of_value():
350			return OvalNode(
351			node_id=1,
352			node_type="value",
353			value='and',
354			)
355
356			@staticmethod
357			def tree_with_bad_type():
358			return OvalNode(
359			node_id=1,
360			node_type="car",
361			value='and',
362			)
363
364			@staticmethod
365			def tree_with_bad_value_of_negation():
366			return OvalNode(
367			node_id=1,
368			node_type="operator",
369			value="true",
370			children=[
371			OvalNode(
372			node_id=2,
373			node_type="value",
374			value='true',
375			negation="random_string",
376			)
377			]
378			)
379
380			@staticmethod
381			def json_of_tree(src):
382			path = Path(__file__).parent / src
383			with open(path, 'r') as file_:
384			return json.load(file_)
385

OpenSCAP / oval-graph

Pull Request — master (#206)

test_oval_tree.get_tree.GetTree.simple_tree() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like