26 research outputs found
Necessary test cases for Decision Coverage and Modified Condition / Decision Coverage
Test coverage refers to the extent to which a given software verification activity satisfies its objectives. Several types of coverage analysis exist to check code correctness. Less strict analysis methods require fewer test cases to satisfy their requirements and consume less resources. Choosing test methods is a compromise between the code correctness and the available resources. However this selection should be based on quantitative consideration. In this paper we concern the Decision Coverage and the more strict Modified Condition / Decision Coverage. We examined several projects written in Ada programming language. Some of them are developed in the industry and the others are open source. We analyzed them in several aspects: Mc- Cabe metric, nesting and maximal argument number in decisions. We discuss how these aspects are affected by difference of the necessary test cases for these testing methods
4D Ariadne the Static Debugger of Java Programs
Development environments support the programmer in numerous ways from syntax highlighting to different refactoring and code generating methods. However, there are cases where these tools are limited or not usable, such as getting familiar with large and complex source codes written by a third person; finding the complexities of huge projects or finding semantic errors.In this paper we present our static analyzer tool, called 4D Ariadne, which concentrates on these problems. 4D Ariadne is a static debugger of Object Oriented applications written in Java programming language. It calculates data dependencies of objects being able to compute them both forward and backward. As 4D Ariadne provides only the direct influences to the user, it can be considered as an alternative of traditional debuggers, without executing the code. 4D Ariadne also provides dynamic call graphs representing polymorphic properties of objects
Subtle Methods in C++
Nowadays complex software systems are designed and implemented
with the help of the object-oriented paradigm principally.
However, object-oriented languages
support the object-oriented paradigm in different ways with
different constructs. C++ has a sophisticated inheritence
notation based on access modifiers. C++ distinguishes
virtual, pure virtual and non-virtual methods. Java uses
final classes and methods to disable inheritance. However,
Java does not support multiple inheritance. Eiffel allows
renaming inherited methods.
In this paper we present some method utilites for C++ to
create safer and more flexible object-oriented systems.
We present how the method renaming can be implemented.
We developed constructs to create final and unhidable
methods. These constructs are implemented with the help
of C++ template facilities. We present scenarios where
one can write safer code with our constructs
C++ exam methodology
The C++ programming language supports multiparadigm programming.
We can write programs in procedural, object-oriented, generic way at the
same time.
However, it is diïŹcult to ïŹgure out exercises for the terminal examinations
since not easy to separate the algorithmic cogitation from the knowledge of
the programming language. There are some basic elements that programmer
students have to know: constructors, parameter passing, objects, inheritance,
standard library, handling constants, copying objects, functions and member
functions, etc. Exercises must be multiparadigm according to the C++ language.
Using only one paradigm in C++ is not enough. This results in that
we have to distinguish the diïŹerent linguistic constructs on the basis of its
complexity.
Many questions are arisen in connection with the exercises of terminal
examinations. How can we gauge the procedural, the object-oriented, and
the generic paradigms at the same time? How can we gauge studentsâ C++
knowledge when we do not lay stress on the algorithmic cogitation? What
kind of exercises may be interesting by the Standard Template Library?
Which C++ constructs are reckoned to be more diïŹcult and which ones
considered to be easier? What are the most important ones? In this paper
we give answers to the previous questions, we describe our methodology to
assessment of studentsâ C++ knowledge in a semi-automatic grading way. We
also present exercise examples that worked out according to our methodology.
We take stock of studentsâ results in the paper
High-level Multicore Programming with C++11
Nowadays, one of the most important challenges in programming is the efficient usage of multicore processors. All modern programming languages support multicore programming at native or library level. C++11, the next standard of the C++ programming language, also supports multithreading at a low level. In this paper we argue for some extensions of the C++ Standard Template Library based on the features of C++11. These extensions enhance the standard library to be more powerful in the multicore realm. Our approach is based on functors and lambda expressions, which are major extensions in the language. We contribute three case studies: how to efficiently compose functors in pipelines, how to evaluate boolean operators in parallel, and how to efficiently accumulate over associative functors
C++ Standard Template Library by infinite iterators
The C++ Standard Template Library (STL) is an essential part of pro-
fessional C++ programs. STL is a type-safe template library that is based
on the generic programming paradigm and helps to avoid some possible dangerous
C++ constructs. With its usage, the eïŹciency, safety and quality of
the code is increased.
However, professional C++ programmers are eager for some missing STLrelated
opportunities. For instance, inïŹnite ranges are hardly supported by
C++ STL. STL does not contain iterators that use a predicate during traversal.
STLâs design is not good at all from the view of predicates. In this paper
we present some extensions of C++ STL that supports eïŹective generic programming.
We show scenarios where these extensions can be used pretty
gracefully. We present the implementation of our inïŹnite iterators
COMPARISON OF DC AND MC/DC CODE COVERAGES
ABSTRACT In software development testing plays the most important role to discover bugs and to verify that the product meets its requirements. This paper focuses on programs written in C++ programming language and analyses two important testing methods, the Decision Coverage and the more strict Modified Condition / Decision Coverage. We examine how the program characteristics -lines of code, McCabe metric, the number of the arguments in the decisions, deepness of the nested block -affect the number of necessary test cases of these testing methods. Choosing test methods is always a compromise between the code correctness and the available resources. Less strict ones require fewer test cases and consume less resources, however, they may discover fewer errors. Our results may help to chose between Decision Coverage and Modified Condition / Decision coverage