Results 1 - 10
of
21
U.: Finding race conditions in erlang with quickcheck and pulse
- In: ICFP
, 2009
"... We address the problem of testing and debugging concurrent, dis-tributed Erlang applications. In concurrent programs, race condi-tions are a common class of bugs and are very hard to find in prac-tice. Traditional unit testing is normally unable to help finding all race conditions, because their occ ..."
Abstract
-
Cited by 11 (2 self)
- Add to MetaCart
(Show Context)
We address the problem of testing and debugging concurrent, dis-tributed Erlang applications. In concurrent programs, race condi-tions are a common class of bugs and are very hard to find in prac-tice. Traditional unit testing is normally unable to help finding all race conditions, because their occurrence depends so much on tim-ing. Therefore, race conditions are often found during system test-ing, where due to the vast amount of code under test, it is often hard to diagnose the error resulting from race conditions. We present three tools (QuickCheck, PULSE, and a visualizer) that in combi-nation can be used to test and debug concurrent programs in unit testing with a much better possibility of detecting race conditions. We evaluate our method on an industrial concurrent case study and illustrate how we find and analyze the race conditions. Categories and Subject Descriptors D.2.5 [Testing and Debug-ging]: Distributed debugging
Testing Noninterference, Quickly
"... Information-flow control mechanisms are difficult to design and labor intensive to prove correct. To reduce the time wasted on doomed proofs for broken definitions, we advocate modern random testing techniques for finding counterexamples during the design process. We show how to use QuickCheck, a pr ..."
Abstract
-
Cited by 8 (4 self)
- Add to MetaCart
(Show Context)
Information-flow control mechanisms are difficult to design and labor intensive to prove correct. To reduce the time wasted on doomed proofs for broken definitions, we advocate modern random testing techniques for finding counterexamples during the design process. We show how to use QuickCheck, a property-based random-testing tool, to guide the design of a simple informationflow abstract machine. We find that both sophisticated strategies for generating well-distributed random programs and readily falsifiable formulations of noninterference properties are critically important. We propose several approaches and evaluate their effectiveness on a collection of injected bugs of varying subtlety. We also present an effective technique for shrinking large counterexamples to minimal, easily comprehensible ones. Taken together, our best methods enable us to quickly and automatically generate simple counterexamples for all these bugs.
Testing Erlang Refactorings with QuickCheck
- In IFL2007
, 2007
"... Abstract. Refactoring is a technique for improving the design of existing programs without changing their behaviour. Wrangler is a tool built at the University of Kent to support Erlang program refactoring; the Wrangler tool is written in Erlang. In this paper we present the use of a novel testing t ..."
Abstract
-
Cited by 8 (4 self)
- Add to MetaCart
(Show Context)
Abstract. Refactoring is a technique for improving the design of existing programs without changing their behaviour. Wrangler is a tool built at the University of Kent to support Erlang program refactoring; the Wrangler tool is written in Erlang. In this paper we present the use of a novel testing tool, Quviq QuickCheck, for testing the implementation of Wrangler. QuickCheck is a specificationbased testing tool for Erlang. With QuickCheck, programs are tested by writing properties in a restricted logic, and using the tool these properties are tested in randomly generated test cases. This paper first gives overviews of Wrangler and Quviq QuickCheck, then discusses the various ways in which refactorings can be validated, and finally shows how QuickCheck can be used to test the correctness of refactorings in an efficient way. 1
From Test Cases to FSMs: Augmented Test-driven Development and Property Inference Thomas Arts
"... This paper uses the inference of finite state machines from EUnit test suites for Erlang programs to make two contributions. First, we show that the inferred FSMs provide feedback on the adequacy of the test suite that is developed incrementally during the test-driven development of a system. This i ..."
Abstract
-
Cited by 4 (3 self)
- Add to MetaCart
(Show Context)
This paper uses the inference of finite state machines from EUnit test suites for Erlang programs to make two contributions. First, we show that the inferred FSMs provide feedback on the adequacy of the test suite that is developed incrementally during the test-driven development of a system. This is novel because the feedback we give is independent of the implementation of the system. Secondly, we use FSM inference to develop QuickCheck properties for testing state-based systems. This has the effect of transforming a fixed set of tests into a property which can be tested using randomly generated data, substantially widening the coverage and scope of the tests. Categories and Subject Descriptors D. Software [D.2 SOFT-
H.: Finding counter examples in induction proofs
, 2008
"... Abstract. This paper addresses a problem arising in automated proof of invariants of transition systems, for example transition systems modelling distributed programs. Most of the time, the actual properties we want to prove are too weak to hold inductively, and auxiliary invariants need to be intro ..."
Abstract
-
Cited by 4 (1 self)
- Add to MetaCart
(Show Context)
Abstract. This paper addresses a problem arising in automated proof of invariants of transition systems, for example transition systems modelling distributed programs. Most of the time, the actual properties we want to prove are too weak to hold inductively, and auxiliary invariants need to be introduced. The problem is how to find these extra invariants. We propose a method where we find minimal counter examples to candidate invariants by means of automated random testing techniques. These counter examples can be inspected by a human user, and used to adapt the set of invariants at hand. We are able to find two different kinds of counter examples, either indicating (1) that the used invariants are too strong (a concrete trace of the system violates at least one of the invariants), or (2) that the used invariants are too weak (a concrete transition of the system does not maintain all invariants). We have developed and evaluated our method in the context of formally verifying an industrial-strength implementation of a fault-tolerant distributed leader election protocol. 1
Trace-based Reflexive Testing of OO Programs
, 2007
"... This paper presents an automatic trace-based unit testing approach to test Object Oriented programs. Most automated testing tools, test a class C by testing each of its methods in isolation. Such an approach works poorly if specifications are only partial, which is usually the case in practice. In c ..."
Abstract
-
Cited by 2 (0 self)
- Add to MetaCart
(Show Context)
This paper presents an automatic trace-based unit testing approach to test Object Oriented programs. Most automated testing tools, test a class C by testing each of its methods in isolation. Such an approach works poorly if specifications are only partial, which is usually the case in practice. In contrast, our approach generates sequences of calls to the methods of C that are checked on-the-fly. This is more interactive, and has the side effect that methods are checking each other. Although simple, it seems to work quite well, even when specifications are only partially provided. We implement the approach in a tool called T2. It targets Java. It can test internal errors, Hoare triple specifications, class invariant, and even temporal properties. Furthermore, T2 accepts ’in-code ’ specifications, these are specifications written in the specified class itself, and are written in plain Java; hence reducing the cost usually needed to maintain specifications to minimum. 1
Testing a distributed Wiki web application with QuickCheck
"... the non-exclusive right to publish the Work electronically and in a non-commercial purpose make it accessible on the Internet. The Author warrants that he/she is the author to the Work, and warrants that the Work does not contain text, pictures or other material that violates copyright law. The Auth ..."
Abstract
-
Cited by 1 (0 self)
- Add to MetaCart
(Show Context)
the non-exclusive right to publish the Work electronically and in a non-commercial purpose make it accessible on the Internet. The Author warrants that he/she is the author to the Work, and warrants that the Work does not contain text, pictures or other material that violates copyright law. The Author shall, when transferring the rights of the Work to a third party (for example a publisher or a company), acknowledge the third party about this agreement. If the Author has signed a copyright agreement with a third party regarding the Work, the Author warrants hereby that he/she has obtained any necessary permission from this third party to let Chalmers University of Technology and University of Gothenburg store the Work electronically and make it accessible on the Internet. Testing a distributed Wiki web application with QuickCheck.
Programming with enumerable sets of structures
- In OOPSLA
, 2015
"... We present an efficient, modular, and feature-rich framework for automated generation and validation of complex structures, suitable for tasks that explore a large space of structured values. Our framework is capable of exhaustive, incremental, parallel, and memoized enumeration from not only finite ..."
Abstract
-
Cited by 1 (0 self)
- Add to MetaCart
(Show Context)
We present an efficient, modular, and feature-rich framework for automated generation and validation of complex structures, suitable for tasks that explore a large space of structured values. Our framework is capable of exhaustive, incremental, parallel, and memoized enumeration from not only finite but also infinite domains, while providing fine-grained control over the process. Furthermore, the framework efficiently supports the inverse of enumeration (checking whether a structure can be generated and fast-forwarding to this structure to continue the enumeration) and lazy enumeration (achieving exhaustive testing without generating all structures). The foundation of efficient enumera-tion lies in both direct access to encoded structures, achieved with well-known and new pairing functions, and dependent enumeration, which embeds constraints into the enumeration to avoid backtracking. Our framework defines an algebra of enu-merators, with combinators for their composition that preserve exhaustiveness and efficiency. We have implemented our frame-work as a domain-specific language in Scala. Our experiments demonstrate better performance and shorter specifications by up to a few orders of magnitude compared to existing approaches.
A Zoom-Declarative Debugger for Sequential Erlang Programs (extended version)∗
, 2014
"... We present a declarative debugger for sequential Erlang programs. The tool is started by the user when a program produces some unexpected result. It automatically builds a computation tree representing the structure of the erroneous computation. The tree is then traversed asking questions to the use ..."
Abstract
-
Cited by 1 (1 self)
- Add to MetaCart
(Show Context)
We present a declarative debugger for sequential Erlang programs. The tool is started by the user when a program produces some unexpected result. It automatically builds a computation tree representing the structure of the erroneous computation. The tree is then traversed asking questions to the user about the validity of some nodes of the tree, which represent the results of intermediate subcomputations, until a bug in the program is found. The navigation process first concentrates in locating an erroneous function in the program. Then, the user can refine the granularity by zooming out the function, checking the values bound to variables and the if/case/try-catch branches taken during the execution. In order to represent the erroneous computation, a semantic calculus for sequential Core Erlang programs is proposed. The debugger uses an abbreviation of the proof trees in this calculus as debugging trees, which allows us to prove the soundness of the approach. The technique has been implemented in a tool publicly available. An exhaustive analysis of the usability of the tool is also presented.
A Declarative Debugger for Sequential Erlang Programs
"... Abstract. Declarative debuggers are semi-automatic debugging tools that abstract the execution details to focus on the program semantics. Erroneous computations are represented by suitable trees, which are tra-versed by asking questions to the user until a bug is found. This paper applies declarativ ..."
Abstract
-
Cited by 1 (1 self)
- Add to MetaCart
(Show Context)
Abstract. Declarative debuggers are semi-automatic debugging tools that abstract the execution details to focus on the program semantics. Erroneous computations are represented by suitable trees, which are tra-versed by asking questions to the user until a bug is found. This paper applies declarative debugging to the sequential subset of the language Erlang. The debugger takes the intermediate representation generated by Erlang systems, known as Core Erlang, and an initial error detected by the user, and locates an erroneous program function responsible for the error. In order to represent the erroneous computation, a semantic calculus for sequential Core Erlang programs is proposed. The debugger uses an abbreviation of the proof trees of this calculus as debugging trees, which allows us to prove the soundness of the approach. The technique has been implemented in a debugger tool publicly available.
