The objective of this paper is to present a tool supporting dataflow coverage testing of Java programs. Code based ("white box") approach to testing can be divided into two main types: control flow coverage and data flow coverage methods. Dataflow testing was introduced for structural programming languages and later adopted for object languages. Among many tools supporting code based testing of object programs, only JaBUTi and DFC (Data Flow Coverage) support dataflow testing of Java programs. DFC is a tool implemented at the Institute of Computer Science Warsaw University of Technology as an Eclipse plug-in. DFC finds all definition-uses (def −u ) pairs in tested unit and provides also the def −u graph DUG for methods. After the execution of tests the information which def −u pairs were covered is shown. An example of usage of DFC and the comparison with JaBUTi data flow testing tool of Java program is also presented.
With the rapid growth of the complexity of software systems, the problem of integrating and maintaining legacy software is more relevant than ever. To overcome this problem, many methods for refactoring legacy code have already been proposed such as renaming classes or extracting interfaces. To perform a real modularization, methods have to be moved between classes. However, moving a single method is often not possible due to code dependencies. In this article we present an approach to modularize legacy software by moving multiple related class members. It is shown how to identify groups of class members with similar concerns. We present two different code patterns that the related members and their dependent classes must match to allow a relocation of the related members. We also demonstrate how our pattern-based approach for automated modularization of legacy software can be applied to two open source projects.
In a component-based software system the different components communicate with each other through their interfaces, possibly using adapters. Whenever the requirements or the environment change, the component-based software system must be adapted accordingly. We present a method that supports a systematic evolution of component-based software at the architectural level. It is based on operators and modification schemata that help to identify different architectural alternatives to realize the evolution task.
The main purpose of mutation testing approach is to check a test suite quality in terms of the adequacy to killing programs with inserted programming faults. We present advances in the C# mutation testing system that supports object-oriented mutation operators. The system enhancements related to functional requirements (mutation operators, avoiding generation of invalid and partially of equivalent mutants) and non-functional ones (speed-up using a new parser and reflection, space reduction storing mutant updates). Mutation testing of six widely used open source programs is discussed. The quality of the tests supplied with these programs was experimentally determined. Performance measures were evaluated to assess system enhancements (2-4 faster mutants creation, 10-100 times disk space reduction, tradeoff of time overhead for storing mutants of different size in a local or remote repository).
The aim has been to minimize regression test suites while retaining fault detection capability of the test suite admissible. An appropriate minimized test suite should exercise different execution paths within a program. However, minimization of test suites may result in significant fault detection loss. To alleviate the loss, a new bi-criteria heuristic algorithm, using cluster analysis of test cases execution profiles is proposed in this paper. Cluster analysis of execution profiles categorizes test cases according to their similarity in terms of exercising a certain coverage criterion. Considering additional coverage criteria the proposed algorithm samples some test cases from each cluster. These additional criteria exercise execution paths, different from those covered by the main testing criteria. Experiments on the Siemens suite manifest the applicability of the proposed approach and present interesting insights into the use of cluster analysis to the bi-criteria test suite reduction.
An extension of HTCPNs-based software tool for Internet systems modelling and evaluation has been proposed in the paper. After the extension the tool provides new possibilities for modelling and analysis of dynamic cluster reconfiguration algorithm. Some implementation details of the algorithm has been presented. The algorithm has been preliminary assessed by simulation.
This paper presents the performance analysis of interactive Internet systems, for which the time rate of system offer change is comparable to the users interaction time with the system. In this paper such systems class is called Interactive Internet Systems with Dynamically Changing Offers (IISDCO). In IISDCO systems an offer change may cause cancellation of the started but incomplete transactions. The necessity of cancellation can result from the sale of a set of resources (goods sold) which is getting exhausted or whose price has changed. This paper includes a performance analysis of an on-line stock exchange system (sample of IISDCO). For the analysis we used models in the form of Time Coloured Petri Nets (TCPNs). We also reviewed the proposed models on the example of the Internet on-line stock exchange system.
Scalable Store of Objects (SSO) should allow for storing and maintaining a huge number of objects distributed over many nodes of a network. RP*N is a structure which belongs to a family of order-preserving, Range Partitioning Scalable Distributed Data Structures (RP* SDDS). The architectures of SDDS were designed to store records. Different structures of objects and complicated dependences between objects are the cause that a new architecture for RP* is needed. The paper describes a new object-oriented version of RP*N architecture and its implementation for Java objects. This version can be used in a fast and scalable store of Java objects. Performance of the implementation is evaluated and compared with serialization of objects on a disk and storing objects as a main-memory collection.
Architectural design and design decisions are the key components of architectural knowledge. However, concerns, rationales, and risks should be also captured to prevent knowledge vaporization. So, how to deal with architectural knowledge in incremental knowledge refinement? We believe that usage of the knowledge repository system can support architecture evolution. In this paper, a model of knowledge repository is presented. In this model, the decision-centric approach is complemented with the architectural views to support indirect interrelations between design decisions. Support for agile development was one of the key aspects of the model design, therefore knowledge vaporisation might be reduced.
A considerably large class of multi-agent systems operate in distributed and real-time environments, and often their correctness specifications require us to express time-critical properties that depend on performed actions of the system. In the paper, we focus on the formal verification of such systems by means of the bounded model checking (BMC) method, where specifications are expressed in the existential fragment of the Real-Time Computation Tree Logic augmented to include standard epistemic operators.
Code based (“white box”) approach to testing can be divided into two main types: control flow coverage and data flow coverage methods. Dataflow testing was introduced for structural programming languages and later adopted for object languages. Among many tools supporting code based testing of object programs, only JaBUTi and DFC(Data Flow Coverage) support dataflow testing of Java programs. DFC is a tool implemented at the Institute of Computer Science Warsaw University of Technology as an Eclipse plug-in. The objective of this paper is to present dataflow coverage testing of Java programs supported by DFC. DFC finds all definition-uses pairs in tested unit and provides also the definition-uses graph for methods. After the execution of test information which def-uses pairs were covered is shown. An example of data flow testing of Java program is also presented.
Role-based Trust management (RT) languages are used for representing policies and credentials in decentralized, distributed access control systems. RT languages combine trust management and role-based access control features. A credential provides information about the keys, rights and qualifications from one or more trusted authorities. The paper presents a set-theoretic semantics of Role-based Trust management languages, which maps a role to a set of sets of entity names. The semantics applies not only to the basic language of the family RT 0, but also to a much more sophisticated RT T , which provides manifold roles and role-product operators to express threshold and separation-of-duty policies. A manifold role defines sets of entities whose cooperation satisfies the manifold role. It enables to express a such a condition, which need more than one member of a role to effectively fulfill the particular task.
This paper is devoted to the system modelling and information transfer to information system. The BiLingva (Bilingual Language) is a domain specific modelling language used to model event oriented information systems. Unlike many other modelling languages BiLingva allows unconstrained use of state diagram concepts and activities diagram concepts in the same diagram. This approach is most appropriate in this specific domain. In the second part of the paper authors analyze a new approach for transferring information system model in BiLingva language to the information system. It is proposed to make user friendly and model consistent configurable software that takes over information from BiLingva model. In the end this paper provides a few examples of running systems developed with this technology thus confirming usefulness of this approach.
It has been shown earlier that aspect-oriented change realization based on a two-level change type framework can be employed to deal with changes so they can be realized in a modular, pluggable, and reusable way. In this paper, this idea is extended towards enabling direct change manipulation using multi-paradigm design with feature modeling. For this, generally applicable change types are considered to be (small-scale) paradigms and expressed by feature models. Feature models of the Method Substitution and Performing Action After Event change types are presented as examples. In this form, generally applicable change types enter an adapted process of the transformational analysis to determine their application by their instantiation over an application domain feature model. The application of the transformational analysis in identifying the details of change interaction is presented.
This paper is dedicated to various aspects and perspectives of applying the smart technologies in software solutions. Based on experience acquired during software development projects, the author proposes criteria to evaluate the effectiveness of enhancing of existing products with smart technologies. The evaluation of effectiveness can be used to support decision making on implementing the smart technologies in existing products or products in development.
Business processes and business rules are implemented in almost all enterprise systems. Approaches used today to their implementation are very sensitive to changes. In the paper authors propose to separate business logic layer from business rule layer by introducing an integration layer. The connections between both parts are expressed in a dedicated for that purpose domain specific language (DSL). The definitions in DSL are further translated into working source code. The proof-of-concept implementation of the integration layer was done in the aspect oriented language (AOP) --- AspectJ. The AOP was selected because it fits well to encapsulate scattered and tangled source code implementing the connections between business logic and business rules with the source code implementing core business logic.
In this paper, we analyze how stream monotonicity classification can be adopted for the introduced developed model, which processes both temporal and negative events. As we show, information about stream monotonicity can be easily used to optimize individual stream operators as well as a full query plan. Comparing our stream engine with such engines as CEDR, STREAM and PIPES we demonstrate how a primary key constraint can be used in different types of the developed stream schemes. We implemented all of the above techniques in StreamAPAS.
This paper presents a novel method of using action-based planning for construction of enterprise integration solutions that utilize messaging technologies. More specifically, the presented method is able to generate a sequence of processing steps needed to transform input message flow(s) to specified output message flow(s), taking into account requirements in areas of throughput, availability, service monitoring, message ordering, and message content and format conversions. The method has been implemented as a research prototype. It has been evaluated using scenarios taken from the literature as well as from real-world experience of the authors.
In this paper, we give a new formalism for attributed graph rewrites resting on category theory and type theory. Our main goal is to offer a single theoretical foundation that embeds the rewrite of structural parts of graphs and attribute computations which has more expressive power for attribute computations as well.
This paper addresses the problem of describing and analyzing data manipulation within business process workflow specifications. We apply a model-driven approach. We begin with business requirement specifications, consisting of an ontology and an associated set of normative rules, that define the ways in which business processes can interact. We then transform this specification into a Petri Net workflow model and, separately, an Event B specification. The former models can be submitted to further behavioural analysis to ensure, for instance, satisfaction of liveness and safety properties. The latter specifications are important as we can use theorem proving techniques to check and refine data representation with respect to process evolution. An important property of the transformation is semantic equivalence between the Petri net model and Event-B model.
