OpenJML: Software verification for Java 7 using JML, OpenJDK, and Eclipse

@inproceedings{Cok2014OpenJMLSV,
  title={OpenJML: Software verification for Java 7 using JML, OpenJDK, and Eclipse},
  author={David R. Cok},
  booktitle={F-IDE},
  year={2014}
}
  • D. Cok
  • Published in F-IDE 25 April 2014
  • Computer Science
OpenJML is a tool for checking code and specifications of Java programs. We describe our experience building the tool on the foundation of JML, OpenJDK and Eclipse, as well as on many advances in specification-based software verification. The implementation demonstrates the value of integrating specification tools directly in the software development IDE and in automating as many tasks as possible. The tool, though still in progress, has now been used for several college-level courses on… 

Figures and Tables from this paper

Conformance test development with the Java modeling language

A model‐based development of a Technology Compatibility Kit test suite and a test execution tool for the draft safety‐critical Java profile specification and the design and elaboration of the concrete test cases are simplified.

SPEEDY: An Eclipse-based IDE for invariant inference

Building and using SPEEDY has confirmed earlier experience demonstrating the importance of showing and editing specifications in the IDEs that developers customarily use, automating as much of the production and checking of specifications as possible, and showing counterexample information directly in the source code editing environment.

Integrating Symbolic Execution, Debugging and Verification

A platform for tools based on symbolic execution and related to verification is presented, which offers a seamless integration into an IDE and furthers a usage in combination, and statistical evidence that the SED increases effectiveness of code reviews is gained from a controlled experiment.

Synthesis of verifiable concurrent Java components from formal models

This work considers the problem of generating a concurrent Java component from a high-level model of inter-process interaction and follows a realistic approach where the translation is semiautomatic (schemata for code generation) and the programmer still retains the power of coding or modifying parts of the code for the resource.

An Approach to Analyzing Execution Preservation in Java Program Refactoring

This paper proposes a new approach to checking behavior preservation properties of Java programs after applying design patterns and makes use of Java Modeling Language (JML) to represent and check if the refactored program neglects to preserve the external behavior.

Towards Full Proof Automation in Frama-C Using Auto-active Verification

An experience report on a complete functional verification of several C programs from the literature and real-life code using auto-active verification with the C software analysis platform Frama-C and its deductive verification plugin.

Contracts in the Wild: A Study of Java Programs

This paper catalogue 25 techniques and tools for lightweight contract checking in Java, and presents the results of an empirical study looking at a dataset extracted from the 200 most popular projects found on Maven Central, constituting roughly 351,034 KLOC.

Verifying Whiley Programs with Boogie

This work provides evidence that Boogie is (for the most part) sufficiently general to act as an intermediate language for a wide range of source languages and can verify significantly more programs than the native Whiley verifier which was custom-built for Whiley verification.

Practical Methods for Reasoning About Java 8's Functional Programming Features

New capabilities added to the Java Modeling Language and the OpenJML deductive program verification tool are described and it is found that the application under study used a small set of functional programming idioms; methods using these idioms could be verified by techniques that used only first-order logic.
...

References

SHOWING 1-10 OF 44 REFERENCES

ESC/Java2: Uniting ESC/Java and JML

It is intended that ESC/Java2 be used for further research in, and larger-scale case studies of, annotation and verification, and for studies in programmer productivity that may result from its integration with other tools that work with JML and Java.

ESC/Java2: Uniting ESC/Java and JML Progress and Issues in Building and Using ESC/Java2, Including a Case Study Involving the Use of the Tool to Verify Portions of an Internet Voting Tally System

It is intended that ESC/Java2 be used for further research in, and larger-scale case studies of, annotation and verification, and for studies in programmer productivity that may result from its integration with other tools that work with JML and Java.

Adapting JML to generic types and Java 1.6

The interactions between JML and the new features of Java 1.5 and 1.6 are analyzed, and appropriate changes to JML are proposed.

SPEEDY: An Eclipse-based IDE for invariant inference

Building and using SPEEDY has confirmed earlier experience demonstrating the importance of showing and editing specifications in the IDEs that developers customarily use, automating as much of the production and checking of specifications as possible, and showing counterexample information directly in the source code editing environment.

Practical pluggable types for java

The Checker Framework is introduced, which supports adding pluggable type systems to the Java language in a backward-compatible way and includes new Java syntax for expressing type qualifiers; declarative and procedural mechanisms for writing type-checking rules; and support for flow-sensitive local type qualifier inference and for polymorphism over types and qualifiers.

Reassessing JML’s Logical Foundation

Survey results indicate that developers are in favor of a semantics for assertions that is compatible with their current use in runtime checking, and hence consistent with a three-valued logic in which partial functions are modeled explicitly.

PLDI 2002: Extended static checking for Java

The Extended Static Checker for Java (ESC/Java) is introduced, an experimental compile-time program checker that finds common programming errors and provides programmers with a simple annotation language with which programmer design decisions can be expressed formally.

Extended static checking for Java

The Extended Static Checker for Java (ESC/Java) is introduced, an experimental compile-time program checker that finds common programming errors and provides programmers with a simple annotation language with which programmer design decisions can be expressed formally.

Verification of Object-Oriented Software. The KeY Approach - Foreword by K. Rustan M. Leino

This KeY book presents deductive verification in an expressive program logic, including two widely-used object-oriented specification languages (OCL and JML) and even an interface to natural language generation.

Preliminary Design of BML: A Behavioral Interface Specification Language for Java Bytecode

We present the Bytecode Modeling Language (BML), the Java bytecode cousin of JML. BML allows the application developer to specify the behaviour of an application in the form of annotations, directly