scholarly journals Negative Effects of Bytecode Instrumentation on Java Source Code Coverage

2016 ◽  
Author(s):  
David Tengeri ◽  
Ferenc Horvath ◽  
Arpad Beszedes ◽  
Tamas Gergely ◽  
Tibor Gyimothy
Keyword(s):  
Source Code ◽  
Negative Effects ◽  
Code Coverage ◽  
Bytecode Instrumentation

GECOJAP: A novel source-code preprocessing technique to improve code coverage

2018 ◽  
Vol 55 ◽  
pp. 27-46 ◽  
Author(s):  
Sangharatna Godboley ◽  
Arpita Dutta ◽  
Durga Prasad Mohapatra ◽  
Rajib Mall
Keyword(s):  
Source Code ◽  
Code Coverage ◽  
Preprocessing Technique

A Cyclomatic Complexity Visual Tool For Simple Source Code Coverage

2017 ◽  
Vol 7 (5) ◽  
pp. 136-141
Author(s):  
Omar M. Sallabi ◽  
◽  
Ahmad R. Benhalloum ◽  
Mohamed A. Hagal ◽  
◽  
...  
Keyword(s):  
Source Code ◽  
Code Coverage ◽  
Visual Tool ◽  
Cyclomatic Complexity

scholarly journals Supporting Unit Test Generation via Automated Isolation

2017 ◽  
Vol 61 (2) ◽  
pp. 116 ◽  
Author(s):  
Dávid Honfi ◽  
Zoltán Micskei
Keyword(s):  
Open Source ◽  
Test Generation ◽  
Symbolic Execution ◽  
Source Code ◽  
Unit Test ◽  
Prototype Implementation ◽  
Code Coverage ◽  
Novel Approach ◽  
Dynamic Symbolic Execution

Testing is a significantly time-consuming, yet commonly employed activity to improve the quality of software. Thus, techniques like dynamic symbolic execution were proposed for generating tests only from source code. However, current approaches usually could not create thorough tests for software units with dependencies (e.g. calls to file system or external services). In this paper, we present a novel approach that synthesizes an isolation sandbox, which interacts with the test generator to increase the covered behaviour in the unit under test. The approach automatically transforms the code of the unit under test, and lets the test generator choose values for parameters in the calls to dependencies. The paper presents a prototype implementation that collaborates with the IntelliTest test generator. The automated isolation is evaluated on source code from open-source projects. The results show that the approach can significantly increase the code coverage achieved by the generated tests.

scholarly journals Transforming Source Code to Mathematical Relations for Performance Evaluation

2015 ◽  
Vol 15 (2) ◽  
pp. 7
Author(s):  
Habib Izadkhah
Keyword(s):  
Performance Evaluation ◽  
Discrete Time ◽  
Software Quality ◽  
Source Code ◽  
Object Oriented ◽  
Negative Effects ◽  
Mathematical Relationship ◽  
Speed Up ◽  
Distributed Execution ◽  
Mathematical Relations

Assessing software quality attributes (such as performance, reliability, and security) from source code is of the utmost importance. The performance of a software system can be improved by its parallel and distributed execution. The aim of the parallel and distributed execution is to speed up by providing the maximum possible concurrency in executing the distributed segments. It is a well known fact that distributing a program cannot be always caused speeding up the execution of it; in some cases, this distribution can have negative effects on the running time of the program. Therefore, before distributing a source code, it should be specified whether its distribution could cause maximum possible concurrency or not. The existing methods and tools cannot achieve this aim from the source code. In this paper, we propose a mathematical relationship for object oriented programs that statically analyze the program by verifying the type of synchronous and asynchronous calls inside the source code. Then, we model the invocations of the software methods by Discrete Time Markov Chains (DTMC). Using the properties of DTMC and the proposed mathematical relationship, we will determine whether or not the source code can be distributed on homogeneous processors. The experimental results showed that we can specify whether the program is distributable or not, before deploying it on the distributed systems.

scholarly journals Code coverage differences of Java bytecode and source code instrumentation tools

2017 ◽  
Vol 27 (1) ◽  
pp. 79-123 ◽  
Author(s):  
Ferenc Horváth ◽  
Tamás Gergely ◽  
Árpád Beszédes ◽  
Dávid Tengeri ◽  
Gergő Balogh ◽  
...  
Keyword(s):  
Source Code ◽  
Code Coverage ◽  
Java Bytecode ◽  
Code Instrumentation

scholarly journals Trace Generation and Deterministic Execution for Concurrent Programs

2016 ◽  
Author(s):  
Paulo Souza ◽  
Raphael Batista ◽  
Simone Souza ◽  
Rafael Prado ◽  
George Dourado ◽  
...  
Keyword(s):  
Shared Memory ◽  
Message Passing ◽  
Source Code ◽  
Concurrent Programs ◽  
Code Coverage ◽  
Coverage Testing ◽  
Point To Point ◽  
New Algorithms

This paper proposes new algorithms for generation of trace files and deterministic execution of concurrent programs under test. The proposed algorithms are essential to automate the coverage testing of concurrent programs and allow to execute new synchronizations automatically, increasing the source code coverage with focus on non-determinism, and edges of communication and synchronization. Our algorithms consider programs with multiple paradigms of communication and synchronization (collective, blocking and non-blocking point-to-point message passing, and shared memory). We validate our algorithms by means of experiments based on nine representative benchmarks, which exercise non-trivial aspects of synchronization found in real applications. Our algorithms have a robust behaviour and meet their objectives. We also highlight the overhead generated with the algorithms.

scholarly journals Obtaining and Visualization of the Topological Functioning Model from the UML Model

2015 ◽  
Vol 18 (1) ◽  
pp. 43-51
Author(s):  
Viktoria Ovchinnikova
Keyword(s):  
Reverse Engineering ◽  
Source Code ◽  
Domain Model ◽  
Software System ◽  
Negative Effects ◽  
Business People ◽  
Short Overview

Abstract A domain model can provide compact information about its corresponding software system for business people. If the software system exists without its domain model and documentation it is time-consuming to understand its behavior and structure only from the code. Reverse Engineering (RE) tools can be used for obtaining behavior and structure of the software system from source code. After that the domain model can be created. A short overview and an example of obtaining the domain model, Topological Functioning Model (TFM), from source code are provided in the paper. Positive and negative effects of the process of TFM backward derivation are also discussed.

Sign in / Sign up

Export Citation Format

Share Document