oval_graph.oval_tree.evaluate.one_is_false1() - Code Metrics - Inspection of "[WIP] Rework oval_node" - OpenSCAP/oval-graph - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#173)

by Jan

created 2021-03-05 15:06 UTC

oval_graph.oval_tree.evaluate.one_is_false1() A

↳ Parent: oval_graph.oval_tree.evaluate

Complexity

Conditions

Size

Total Lines	12
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
eloc	4
dl	0
loc	12
ccs	0
cts	2
cp	0
rs	10
c	0
b	0
f	0
cc	1
nop	1
crap	2

"""
    Function for evaluate OVAL operators.
"""


def oval_operator_and(result):
    """The AND operator produces a true result if every argument is true. If one or more arguments
       are false, the result of the AND is false. If one or more of the arguments are unknown, and
       if none of the arguments are false, then the AND operator produces a result of unknown.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            str. return values::

                true
                false
                error
                unknown
                noteval
    """
    out_result = None
    if (eq_zero(result, 'false_cnt')
            and greater_zero(result, 'true_cnt')
            and error_unknown_noteval_eq_zero(result)):
        out_result = 'true'
    elif greater_zero(result, 'false_cnt'):
        out_result = 'false'
    else:
        out_result = error_unknown_noteval_for_operators_and_or(result, 'and')
    return out_result


def oval_operator_one(result):
    """The ONE operator produces a true result if one and only one argument is true. If there are
       more than argument is true (or if there are no true arguments), the result of the ONE
       is false. If one or more of the arguments are unknown, then the ONE operator produces
       a result of unknown.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            str. return values::

                true
                false
                error
                unknown
                noteval
    """
    out_result = None
    if one_is_true(result):
        out_result = 'true'
    # Operator ONE has two cases of false
    elif one_is_false(result) or one_is_false1(result):
        out_result = 'false'
    elif one_is_error(result):
        out_result = 'error'
    elif one_is_unknown(result):
        out_result = 'unknown'
    elif one_is_noteval(result):
        out_result = 'noteval'
    return out_result


def oval_operator_or(result):
    """The OR operator produces a true result if one or more arguments is true. If every argument
       is false, the result of the OR is false. If one or more of the arguments are unknown and
       if none of arguments are true, then the OR operator produces a result of unknown.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            str. return values::

                true
                false
                error
                unknown
                noteval
    """
    out_result = None
    if greater_zero(result, 'true_cnt'):
        out_result = 'true'
    elif (eq_zero(result, 'true_cnt')
          and greater_zero(result, 'false_cnt')
          and error_unknown_noteval_eq_zero(result)):
        out_result = 'false'
    else:
        out_result = error_unknown_noteval_for_operators_and_or(result, 'or')
    return out_result


def oval_operator_xor(result):
    """XOR is defined to be true if an odd number of its arguments are true, and false otherwise.
       If any of the arguments are unknown, then the XOR operator produces a result of unknown.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            str. return values::

                true
                false
                error
                unknown
                noteval
    """
    out_result = None
    if ((result['true_cnt'] % 2) == 1
            and eq_zero_unknown_noteval_notappl(result)):
        out_result = 'true'
    elif ((result['true_cnt'] % 2) == 0
          and eq_zero_unknown_noteval_notappl(result)):
        out_result = 'false'
    elif greater_zero(result, 'error_cnt'):
        out_result = 'error'
    elif (eq_zero(result, 'error_cnt')
          and greater_zero(result, 'unknown_cnt')):
        out_result = 'unknown'
    elif (eq_zero(result, 'error_cnt')
          and eq_zero(result, 'unknown_cnt')
          and greater_zero(result, 'noteval_cnt')):
        out_result = 'noteval'
    return out_result


def error_unknown_noteval_for_operators_and_or(result, operator):

    """Evaluates if the result match the values for error, unknown, noteval.

    Args:
            result (dict): Dictionary representing frequencies of values
            operator (str): Specifies for which operator is used

    Returns:
            str or None. return values::

                error
                unknown
                notappl
    """
    out_result = None
    value_for_check = 'false_cnt' if operator == 'and' else 'true_cnt'
    if (eq_zero(result, value_for_check)
            and greater_zero(result, 'error_cnt')):
        out_result = 'error'
    elif (eq_zero(result, value_for_check)
          and error_unknown_eq_zero(result)):
        out_result = 'unknown'
    elif (eq_zero(result, value_for_check)
          and error_unknown_eq_noteval_greater_zero(result)):
        out_result = 'noteval'
    return out_result


def eq_zero(result, cnt):
    """Evaluates if the value in the result is equal zero.

    Args:
            result (dict): Dictionary representing frequencies of values
            cnt (str): key for value in result

    Returns:
            bool.
    """
    return result[cnt] == 0


def eq_zero_duo(result, cnt0, cnt1):
    """Evaluates if the two values in the result is equal zero.

    Args:
            result (dict): Dictionary representing frequencies of values
            cnt0 (str): key for value in result
            cnt1 (str): key for value in result

    Returns:
            bool.
    """
    return result[cnt0] == 0 and result[cnt1] == 0


def greater_zero(result, cnt):
    """Evaluates if the value in the result is greater then zero.

    Args:
            result (dict): Dictionary representing frequencies of values
            cnt (str): key for value in result

    Returns:
            bool.
    """
    return result[cnt] > 0


def eq_or_greater_zero(result, cnt):
    """Evaluates if the value in the result is greater or equal zero.

    Args:
            result (dict): Dictionary representing frequencies of values
            cnt (str): key for value in result

    Returns:
            bool.
    """
    return result[cnt] >= 0


def eq_or_greater_zero_duo(result, cnt0, cnt1):
    """Evaluates if the two values in the result is greater or equal zero.

    Args:
            result (dict): Dictionary representing frequencies of values
            cnt0 (str): key for value in result
            cnt1 (str): key for value in result

    Returns:
            bool.
    """
    return result[cnt0] >= 0 and result[cnt1] >= 0


def smaller_than_two(result, cnt):
    """Evaluates if the value in the result is smaller than two.

    Args:
            result (dict): Dictionary representing frequencies of values
            cnt (str): key for value in result

    Returns:
            bool.
    """
    return result[cnt] < 2


def one_is_noteval(result):
    """Evaluates if the result match noteval for one operator.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (smaller_than_two(result, 'true_cnt')
            and eq_or_greater_zero_duo(result, 'false_cnt', 'notappl_cnt')
            and eq_zero_duo(result, 'error_cnt', 'unknown_cnt')
            and greater_zero(result, 'noteval_cnt'))


def one_is_unknown(result):
    """Evaluates if the result match unknown for one operator.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (smaller_than_two(result, 'true_cnt')
            and eq_or_greater_zero(result, 'false_cnt')
            and eq_zero(result, 'error_cnt')
            and result['unknown_cnt'] >= 1
            and eq_or_greater_zero_duo(result, 'noteval_cnt', 'notappl_cnt'))


def one_is_error(result):
    """Evaluates if the result match unknown for one operator.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (smaller_than_two(result, 'true_cnt')
            and eq_or_greater_zero(result, 'false_cnt')
            and greater_zero(result, 'error_cnt')
            and eq_or_greater_zero_unknown_noteval_notappl(result))


def one_is_false(result):
    """Evaluates if the result match false for one operator.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (eq_zero(result, 'true_cnt')
            and eq_or_greater_zero(result, 'false_cnt')
            and error_unknown_noteval_eq_zero(result)
            and result['notappl_cnt'] >= 0)


def one_is_false1(result):
    """Evaluates  if the result match false for one operator.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (result['true_cnt'] >= 2
            and eq_or_greater_zero_duo(result, 'false_cnt', 'error_cnt')
            and eq_or_greater_zero_unknown_noteval_notappl(result))


def one_is_true(result):
    """Evaluates if the result match true for one operator.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (result['true_cnt'] == 1
            and eq_or_greater_zero_duo(result, 'false_cnt', 'notappl_cnt')
            and error_unknown_noteval_eq_zero(result))


def eq_or_greater_zero_unknown_noteval_notappl(result):

    """Evaluates if counts of values unknown,
       noteval and notappl in result are equal or greater zero.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (eq_or_greater_zero(result, 'unknown_cnt')
            and eq_or_greater_zero(result, 'noteval_cnt')
            and eq_or_greater_zero(result, 'notappl_cnt'))


def eq_zero_unknown_noteval_notappl(result):
    """Evaluates if counts of values error,
       unknown and noteval in result are equal zero.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (eq_zero(result, 'error_cnt')
            and eq_zero(result, 'unknown_cnt')
            and eq_zero(result, 'noteval_cnt'))


def error_unknown_noteval_eq_zero(result):
    """Evaluates if counts of values error,
       noteval and unknown in result are equal zero.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (eq_zero(result, 'error_cnt')
            and eq_zero(result, 'unknown_cnt')
            and eq_zero(result, 'noteval_cnt'))


def error_unknown_eq_noteval_greater_zero(result):

    """Evaluates if counts of values in result for unknown,
       error are equal zero and for noteval is greater than zero.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (eq_zero(result, 'error_cnt')
            and eq_zero(result, 'unknown_cnt')
            and greater_zero(result, 'noteval_cnt'))


def error_unknown_eq_zero(result):
    """Evaluates if counts of values in result for
       error is equal zero and for unknown is greater than zero.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
    """
    return (eq_zero(result, 'error_cnt')
            and greater_zero(result, 'unknown_cnt'))


def is_notapp_result(result):
    """Evaluates if the counts of values in
       the result matches the notapp result.

    Args:
            result (dict): Dictionary representing frequencies of values

    Returns:
            bool.
     """
    return (result['notappl_cnt'] > 0
            and eq_zero(result, 'false_cnt')
            and error_unknown_noteval_eq_zero(result)
            and eq_zero(result, 'true_cnt'))


1			"""
2			Function for evaluate OVAL operators.
3			"""
4
5
6			def oval_operator_and(result):
7			"""The AND operator produces a true result if every argument is true. If one or more arguments
8			are false, the result of the AND is false. If one or more of the arguments are unknown, and
9			if none of the arguments are false, then the AND operator produces a result of unknown.
10
11			Args:
12			result (dict): Dictionary representing frequencies of values
13
14			Returns:
15			str. return values::
16
17			true
18			false
19			error
20			unknown
21			noteval
22			"""
23			out_result = None
24			if (eq_zero(result, 'false_cnt')
25			and greater_zero(result, 'true_cnt')
26			and error_unknown_noteval_eq_zero(result)):
27			out_result = 'true'
28			elif greater_zero(result, 'false_cnt'):
29			out_result = 'false'
30			else:
31			out_result = error_unknown_noteval_for_operators_and_or(result, 'and')
32			return out_result
33
34
35			def oval_operator_one(result):
36			"""The ONE operator produces a true result if one and only one argument is true. If there are
37			more than argument is true (or if there are no true arguments), the result of the ONE
38			is false. If one or more of the arguments are unknown, then the ONE operator produces
39			a result of unknown.
40
41			Args:
42			result (dict): Dictionary representing frequencies of values
43
44			Returns:
45			str. return values::
46
47			true
48			false
49			error
50			unknown
51			noteval
52			"""
53			out_result = None
54			if one_is_true(result):
55			out_result = 'true'
56			# Operator ONE has two cases of false
57			elif one_is_false(result) or one_is_false1(result):
58			out_result = 'false'
59			elif one_is_error(result):
60			out_result = 'error'
61			elif one_is_unknown(result):
62			out_result = 'unknown'
63			elif one_is_noteval(result):
64			out_result = 'noteval'
65			return out_result
66
67
68			def oval_operator_or(result):
69			"""The OR operator produces a true result if one or more arguments is true. If every argument
70			is false, the result of the OR is false. If one or more of the arguments are unknown and
71			if none of arguments are true, then the OR operator produces a result of unknown.
72
73			Args:
74			result (dict): Dictionary representing frequencies of values
75
76			Returns:
77			str. return values::
78
79			true
80			false
81			error
82			unknown
83			noteval
84			"""
85			out_result = None
86			if greater_zero(result, 'true_cnt'):
87			out_result = 'true'
88			elif (eq_zero(result, 'true_cnt')
89			and greater_zero(result, 'false_cnt')
90			and error_unknown_noteval_eq_zero(result)):
91			out_result = 'false'
92			else:
93			out_result = error_unknown_noteval_for_operators_and_or(result, 'or')
94			return out_result
95
96
97			def oval_operator_xor(result):
98			"""XOR is defined to be true if an odd number of its arguments are true, and false otherwise.
99			If any of the arguments are unknown, then the XOR operator produces a result of unknown.
100
101			Args:
102			result (dict): Dictionary representing frequencies of values
103
104			Returns:
105			str. return values::
106
107			true
108			false
109			error
110			unknown
111			noteval
112			"""
113			out_result = None
114			if ((result['true_cnt'] % 2) == 1
115			and eq_zero_unknown_noteval_notappl(result)):
116			out_result = 'true'
117			elif ((result['true_cnt'] % 2) == 0
118			and eq_zero_unknown_noteval_notappl(result)):
119			out_result = 'false'
120			elif greater_zero(result, 'error_cnt'):
121			out_result = 'error'
122			elif (eq_zero(result, 'error_cnt')
123			and greater_zero(result, 'unknown_cnt')):
124			out_result = 'unknown'
125			elif (eq_zero(result, 'error_cnt')
126			and eq_zero(result, 'unknown_cnt')
127			and greater_zero(result, 'noteval_cnt')):
128			out_result = 'noteval'
129			return out_result
130
131
132			def error_unknown_noteval_for_operators_and_or(result, operator):
			0 ignored issues – show Coding Style Naming introduced 2020-12-17 11:40 UTC by Report Bug Copy Issue Report Function name "error_unknown_noteval_for_operators_and_or" doesn't conform to '[a-z_][a-z0-9_]2,30$' pattern ('[a-z_][a-z0-9_]2,30$' pattern) This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
133			"""Evaluates if the result match the values for error, unknown, noteval.
134
135			Args:
136			result (dict): Dictionary representing frequencies of values
137			operator (str): Specifies for which operator is used
138
139			Returns:
140			str or None. return values::
141
142			error
143			unknown
144			notappl
145			"""
146			out_result = None
147			value_for_check = 'false_cnt' if operator == 'and' else 'true_cnt'
148			if (eq_zero(result, value_for_check)
149			and greater_zero(result, 'error_cnt')):
150			out_result = 'error'
151			elif (eq_zero(result, value_for_check)
152			and error_unknown_eq_zero(result)):
153			out_result = 'unknown'
154			elif (eq_zero(result, value_for_check)
155			and error_unknown_eq_noteval_greater_zero(result)):
156			out_result = 'noteval'
157			return out_result
158
159
160			def eq_zero(result, cnt):
161			"""Evaluates if the value in the result is equal zero.
162
163			Args:
164			result (dict): Dictionary representing frequencies of values
165			cnt (str): key for value in result
166
167			Returns:
168			bool.
169			"""
170			return result[cnt] == 0
171
172
173			def eq_zero_duo(result, cnt0, cnt1):
174			"""Evaluates if the two values in the result is equal zero.
175
176			Args:
177			result (dict): Dictionary representing frequencies of values
178			cnt0 (str): key for value in result
179			cnt1 (str): key for value in result
180
181			Returns:
182			bool.
183			"""
184			return result[cnt0] == 0 and result[cnt1] == 0
185
186
187			def greater_zero(result, cnt):
188			"""Evaluates if the value in the result is greater then zero.
189
190			Args:
191			result (dict): Dictionary representing frequencies of values
192			cnt (str): key for value in result
193
194			Returns:
195			bool.
196			"""
197			return result[cnt] > 0
198
199
200			def eq_or_greater_zero(result, cnt):
201			"""Evaluates if the value in the result is greater or equal zero.
202
203			Args:
204			result (dict): Dictionary representing frequencies of values
205			cnt (str): key for value in result
206
207			Returns:
208			bool.
209			"""
210			return result[cnt] >= 0
211
212
213			def eq_or_greater_zero_duo(result, cnt0, cnt1):
214			"""Evaluates if the two values in the result is greater or equal zero.
215
216			Args:
217			result (dict): Dictionary representing frequencies of values
218			cnt0 (str): key for value in result
219			cnt1 (str): key for value in result
220
221			Returns:
222			bool.
223			"""
224			return result[cnt0] >= 0 and result[cnt1] >= 0
225
226
227			def smaller_than_two(result, cnt):
228			"""Evaluates if the value in the result is smaller than two.
229
230			Args:
231			result (dict): Dictionary representing frequencies of values
232			cnt (str): key for value in result
233
234			Returns:
235			bool.
236			"""
237			return result[cnt] < 2
238
239
240			def one_is_noteval(result):
241			"""Evaluates if the result match noteval for one operator.
242
243			Args:
244			result (dict): Dictionary representing frequencies of values
245
246			Returns:
247			bool.
248			"""
249			return (smaller_than_two(result, 'true_cnt')
250			and eq_or_greater_zero_duo(result, 'false_cnt', 'notappl_cnt')
251			and eq_zero_duo(result, 'error_cnt', 'unknown_cnt')
252			and greater_zero(result, 'noteval_cnt'))
253
254
255			def one_is_unknown(result):
256			"""Evaluates if the result match unknown for one operator.
257
258			Args:
259			result (dict): Dictionary representing frequencies of values
260
261			Returns:
262			bool.
263			"""
264			return (smaller_than_two(result, 'true_cnt')
265			and eq_or_greater_zero(result, 'false_cnt')
266			and eq_zero(result, 'error_cnt')
267			and result['unknown_cnt'] >= 1
268			and eq_or_greater_zero_duo(result, 'noteval_cnt', 'notappl_cnt'))
269
270
271			def one_is_error(result):
272			"""Evaluates if the result match unknown for one operator.
273
274			Args:
275			result (dict): Dictionary representing frequencies of values
276
277			Returns:
278			bool.
279			"""
280			return (smaller_than_two(result, 'true_cnt')
281			and eq_or_greater_zero(result, 'false_cnt')
282			and greater_zero(result, 'error_cnt')
283			and eq_or_greater_zero_unknown_noteval_notappl(result))
284
285
286			def one_is_false(result):
287			"""Evaluates if the result match false for one operator.
288
289			Args:
290			result (dict): Dictionary representing frequencies of values
291
292			Returns:
293			bool.
294			"""
295			return (eq_zero(result, 'true_cnt')
296			and eq_or_greater_zero(result, 'false_cnt')
297			and error_unknown_noteval_eq_zero(result)
298			and result['notappl_cnt'] >= 0)
299
300
301			def one_is_false1(result):
302			"""Evaluates if the result match false for one operator.
303
304			Args:
305			result (dict): Dictionary representing frequencies of values
306
307			Returns:
308			bool.
309			"""
310			return (result['true_cnt'] >= 2
311			and eq_or_greater_zero_duo(result, 'false_cnt', 'error_cnt')
312			and eq_or_greater_zero_unknown_noteval_notappl(result))
313
314
315			def one_is_true(result):
316			"""Evaluates if the result match true for one operator.
317
318			Args:
319			result (dict): Dictionary representing frequencies of values
320
321			Returns:
322			bool.
323			"""
324			return (result['true_cnt'] == 1
325			and eq_or_greater_zero_duo(result, 'false_cnt', 'notappl_cnt')
326			and error_unknown_noteval_eq_zero(result))
327
328
329			def eq_or_greater_zero_unknown_noteval_notappl(result):
			0 ignored issues – show Coding Style Naming introduced 2020-12-17 11:40 UTC by Report Bug Copy Issue Report Function name "eq_or_greater_zero_unknown_noteval_notappl" doesn't conform to '[a-z_][a-z0-9_]2,30$' pattern ('[a-z_][a-z0-9_]2,30$' pattern) This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
330			"""Evaluates if counts of values unknown,
331			noteval and notappl in result are equal or greater zero.
332
333			Args:
334			result (dict): Dictionary representing frequencies of values
335
336			Returns:
337			bool.
338			"""
339			return (eq_or_greater_zero(result, 'unknown_cnt')
340			and eq_or_greater_zero(result, 'noteval_cnt')
341			and eq_or_greater_zero(result, 'notappl_cnt'))
342
343
344			def eq_zero_unknown_noteval_notappl(result):
345			"""Evaluates if counts of values error,
346			unknown and noteval in result are equal zero.
347
348			Args:
349			result (dict): Dictionary representing frequencies of values
350
351			Returns:
352			bool.
353			"""
354			return (eq_zero(result, 'error_cnt')
355			and eq_zero(result, 'unknown_cnt')
356			and eq_zero(result, 'noteval_cnt'))
357
358
359			def error_unknown_noteval_eq_zero(result):
360			"""Evaluates if counts of values error,
361			noteval and unknown in result are equal zero.
362
363			Args:
364			result (dict): Dictionary representing frequencies of values
365
366			Returns:
367			bool.
368			"""
369			return (eq_zero(result, 'error_cnt')
370			and eq_zero(result, 'unknown_cnt')
371			and eq_zero(result, 'noteval_cnt'))
372
373
374			def error_unknown_eq_noteval_greater_zero(result):
			0 ignored issues – show Coding Style Naming introduced 2020-12-17 11:40 UTC by Report Bug Copy Issue Report Function name "error_unknown_eq_noteval_greater_zero" doesn't conform to '[a-z_][a-z0-9_]2,30$' pattern ('[a-z_][a-z0-9_]2,30$' pattern) This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
375			"""Evaluates if counts of values in result for unknown,
376			error are equal zero and for noteval is greater than zero.
377
378			Args:
379			result (dict): Dictionary representing frequencies of values
380
381			Returns:
382			bool.
383			"""
384			return (eq_zero(result, 'error_cnt')
385			and eq_zero(result, 'unknown_cnt')
386			and greater_zero(result, 'noteval_cnt'))
387
388
389			def error_unknown_eq_zero(result):
390			"""Evaluates if counts of values in result for
391			error is equal zero and for unknown is greater than zero.
392
393			Args:
394			result (dict): Dictionary representing frequencies of values
395
396			Returns:
397			bool.
398			"""
399			return (eq_zero(result, 'error_cnt')
400			and greater_zero(result, 'unknown_cnt'))
401
402
403			def is_notapp_result(result):
404			"""Evaluates if the counts of values in
405			the result matches the notapp result.
406
407			Args:
408			result (dict): Dictionary representing frequencies of values
409
410			Returns:
411			bool.
412			"""
413			return (result['notappl_cnt'] > 0
414			and eq_zero(result, 'false_cnt')
415			and error_unknown_noteval_eq_zero(result)
416			and eq_zero(result, 'true_cnt'))
417

OpenSCAP / oval-graph

Pull Request — master (#173)

oval_graph.oval_tree.evaluate.one_is_false1() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like