DOCSLIB.ORG

A SpecistCation Language Design for the Java Modeling Language

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
A SpecistCation Language Design for the Java Modeling Language View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by Digital Repository @ Iowa State University Computer Science Technical Reports Computer Science 2008 A Specification Language Design for the Java Modeling Language (JML) Using Java 5 Annotations Kristina B. Taylor Iowa State University Follow this and additional works at: http://lib.dr.iastate.edu/cs_techreports Part of the Software Engineering Commons Recommended Citation Taylor, Kristina B., "A Specification Language Design for the Java Modeling Language (JML) Using Java 5 Annotations" (2008). Computer Science Technical Reports. 307. http://lib.dr.iastate.edu/cs_techreports/307 This Article is brought to you for free and open access by the Computer Science at Iowa State University Digital Repository. It has been accepted for inclusion in Computer Science Technical Reports by an authorized administrator of Iowa State University Digital Repository. For more information, please contact [email protected]. A Specification Language Design for the Java Modeling Language (JML) Using Java 5 Annotations Abstract Design by contract specification languages help programmers write their intentions for a piece of code in a formal mathematical language. Most programming languages do not have built-in syntax for such specifications, so many design by contract languages place specifications in comments. The aJ va Modeling Language (JML) is one such specification language for Java that uses comments to specify contracts. However, starting with version 5, Java has introduced annotations, a syntactical structure to place metadata in various places in the code. This thesis proposes an initial design to writing JML contracts in the Java 5 annotation syntax and evaluates several criteria in the areas of specification languages and Java language design: whether these annotations are expressive enough to take advantage of annotation simplicity and tool support, and whether the annotation syntax is expressive enough to support handling a large specification language such as JML. Keywords JML annotation specification Disciplines Software Engineering This article is available at Iowa State University Digital Repository: http://lib.dr.iastate.edu/cs_techreports/307 A specification language design for the Java Modeling Language (JML) using Java 5 annotations by Kristina Boysen Taylor A thesis submitted to the graduate faculty in partial fulfillment of the requirements for the degree of MASTER OF SCIENCE Major: Computer Science Program of Study Committee: Gary T. Leavens, Krishna Rajan, Major Professor Hridesh Rajan Iowa State University Ames, Iowa 2008 Copyright c Kristina Boysen Taylor, 2008. All rights reserved. ii DEDICATION To my parents, who raised me in a house filled with love and computers. To all of my friends over the years, who taught me that having fun is as important as working hard. And finally, to my husband, Travis, who kept me going with love and patience, even when it seemed as though I was facing the impossible. iii TABLE OF CONTENTS LIST OF TABLES . v LIST OF FIGURES . vi ABSTRACT . vii CHAPTER 1. OVERVIEW . 1 1.1 Introduction . 1 CHAPTER 2. REVIEW OF LITERATURE . 3 2.1 Background . 3 2.2 Related Work . 3 CHAPTER 3. LANGUAGE DESIGN . 5 3.1 Background . 5 3.2 Three Approaches . 5 3.2.1 The Single Annotation . 6 3.2.2 The Parameter Annotation . 6 3.2.3 The Clausal Annotation . 7 3.3 Discussion . 7 3.3.1 Consistency . 7 3.3.2 Readability . 8 3.3.3 Usability . 9 3.3.4 Extensibility . 9 3.3.5 Summary . 9 3.4 Use Cases . 10 3.4.1 Specification Definition Modifiers versus Specification Clauses . 10 3.4.2 Model Methods . 11 3.4.3 Specification Cases . 12 CHAPTER 4. IMPLEMENTATION . 14 4.1 Prework . 14 4.1.1 Resolving Syntax Tree Issues . 14 4.1.2 Writing Bytecode . 14 4.2 Adding an Additional Compiler Pass . 15 4.2.1 Resolving Annotation Types . 15 4.2.2 Walking the Abstract Syntax Tree . 15 4.3 Translating the Annotations . 16 4.3.1 Writing the Parser . 16 4.3.2 Integrating the Parsed Elements . 17 4.4 Conclusion . 19 iv CHAPTER 5. CASE STUDIES . 21 5.1 Two Small Test Cases . 21 5.2 One Large Test Case . 22 CHAPTER 6. USING JML ANNOTATIONS FOR VERIFICATION OF WEB-BASED DATAENTRY ......................................... 25 6.1 Abstract . 25 6.2 Introduction . 25 6.3 Significance . 25 6.4 Related Work . 26 6.5 Approach . 27 6.6 Results . 28 6.6.1 Checking Individual Properties . 28 6.6.2 Checking Properties on Form Submit . 29 6.7 Evaluation . 30 6.8 Conclusion . 31 CHAPTER 7. DISCUSSION AND SUMMARY . 33 7.1 Discussion . 33 7.1.1 Annotations as JML . 33 7.1.2 Annotations as Java Syntax . 34 7.2 Summary . 34 APPENDIX. ANNOTATION SYNTAX . 36 ACKNOWLEDGMENTS . 50 v LIST OF TABLES Table 7.1 JML2 vs. JML5 . 34 vi LIST OF FIGURES 1.1 JML2 Annotation Example . 2 1.2 JML5 Annotation Example . 2 3.1 Base Example . 5 3.2 Single Annotation Example . 6 3.3 Parameter Annotation Example . 6 3.4 Clausal Annotation Example . 7 3.5 Model and Invariant Base Example . 10 3.6 Model and Invariant Clausal Example . 10 3.7 Model Method Base Example . 11 3.8 Model Method Clausal Example . 12 3.9 Specification Case Base Example . 12 3.10 Specification Case Clausal Example . 13 3.11 Specification Case Clausal Example (with strings) . 13 4.1 Partial Package Resolution . 15 4.2 Annotation Accessor in JMethodDeclaration.java . 15 4.3 Grammar for jmlRequiresClause[] .................... 16 4.4 Partial JML Grammar . 16 4.5 Partial JML5 Grammar . 16 4.6 Grammar for jmlRepresentsClause[] ................... 17 4.7 Parser Method . 17 4.8 JMethodDeclaration.java . 18 4.9 JmlMethodDeclaration.java . 19 4.10 Visiting a JmlMethodDeclaration ..................... 20 5.1 MarkerAnnotations.java . 21 5.2 SingleElementAnnotations.java . 22 5.3 AAList.java . 23 5.4 AAList Incorrect Constructor . 24 6.1 Tapestry Template Example . 27 6.2 Tapestry Java Example . 28 6.3 Tapestry Web Form Example . 29 6.4 Transformed setMass(..) Method . 29 6.5 Tapestry Error Form . 30 6.6 Multiple Property Web Form . 31 6.7 Transformed onSubmitFromNewDose(..) Method . 32 6.8 Tapestry Error Form.
Load more

Recommended publications
  • The Java Modeling Language
    The Java Modeling Language Software Fiável Mestrado em Engenharia Informática Mestrado em Informática Faculdade de Ciências da Universidade de Lisboa 2015/2016 Vasco T. Vasconcelos, Antónia Lopes Software Fiável The Java Modeling Language Contracts I The key ingredient of Design by contract, software design methodology promoted by Bertrand Meyer and the Eiffel programming language in 1986. I Inspired by assertions of Hoare logic, contracts place special obligations on both clients and suppliers of a procedure or method. I What does a method require from it’s caller? I What does the method ensure? Software Fiável The Java Modeling Language DBC DBC key idea is to associate a specification with every software element. These specifications (or contracts) govern the interaction of the element with the rest of the world. I Forces the programmer to write exactly what the method does and needs I No need to program defensively (defensive checks can be exensive and increases the complexity of the code of the method and worsen its maintainability) I Assigns blame: specifies who is to blame for not keeping the contract I Provides a standard way to document classes: client programmers are provided with a proper description of the interface properties of a class that is stripped of all implementation information but retains the essential usage information: the contract. Software Fiável The Java Modeling Language Language support for Contracts Language support for contracts exists in different forms: I Eiffel is an object-oriented language that includes contracts I JML adds contracts to the Java language. JML specifications are conventional Java boolean expressions, with a few extensions I Spec# adds contracts to C# I Code Contracts is an API (part of .NET) to author contracts In this course we focus on JML.
    [Show full text]
  • Génération Automatique De Tests Unitaires Avec Praspel, Un Langage De Spécification Pour PHP the Art of Contract-Based Testing in PHP with Praspel
    CORE Metadata, citation and similar papers at core.ac.uk Provided by HAL - Université de Franche-Comté G´en´erationautomatique de tests unitaires avec Praspel, un langage de sp´ecificationpour PHP Ivan Enderlin To cite this version: Ivan Enderlin. G´en´eration automatique de tests unitaires avec Praspel, un langage de sp´ecificationpour PHP. Informatique et langage [cs.CL]. Universit´ede Franche-Comt´e,2014. Fran¸cais. <NNT : 2014BESA2067>. <tel-01093355v2> HAL Id: tel-01093355 https://hal.inria.fr/tel-01093355v2 Submitted on 19 Oct 2016 HAL is a multi-disciplinary open access L'archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destin´eeau d´ep^otet `ala diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publi´esou non, lished or not. The documents may come from ´emanant des ´etablissements d'enseignement et de teaching and research institutions in France or recherche fran¸caisou ´etrangers,des laboratoires abroad, or from public or private research centers. publics ou priv´es. Thèse de Doctorat école doctorale sciences pour l’ingénieur et microtechniques UNIVERSITÉ DE FRANCHE-COMTÉ No X X X THÈSE présentée par Ivan Enderlin pour obtenir le Grade de Docteur de l’Université de Franche-Comté K 8 k Génération automatique de tests unitaires avec Praspel, un langage de spécification pour PHP The Art of Contract-based Testing in PHP with Praspel Spécialité Informatique Instituts Femto-ST (département DISC) et INRIA (laboratoire LORIA) Soutenue publiquement
    [Show full text]
  • Annotation File Format Specification
    Annotation File Format Specification https://checkerframework.org/annotation-file-utilities/ September 1, 2021 Contents 1 Purpose: External storage of annotations 1 2 Grammar 2 2.1 Grammar conventions . 2 2.2 Java file grammar . 2 2.2.1 Package definitions . 3 2.2.2 Class definitions . 3 2.2.3 Field definitions . 5 2.2.4 Method definitions . 5 2.3 Bytecode Locations . 6 2.3.1 Bytecode offsets . 7 2.3.2 Source code indexes . 7 2.3.3 Code locations grammar . 7 2.3.4 AST paths . 9 2.4 Annotations . 15 2.4.1 Annotation definitions . 15 2.4.2 Annotation uses . 15 3 Example 17 4 Types and values 17 5 Alternative formats 19 1 Purpose: External storage of annotations Java annotations are meta-data about Java program elements, as in \@Deprecated class Date f ... g". Ordinarily, Java annotations are written in the source code of a .java Java source file. When javac compiles the source code, it inserts the annotations in the resulting .class file (as \attributes"). Sometimes, it is convenient to specify the annotations outside the source code or the .class file. • When source code is not available, a textual file provides a format for writing and storing annotations that is much easier to read and modify than a .class file. Even if the eventual purpose is to insert the annotations in the .class file, the annotations must be specified in some textual format first. • Even when source code is available, sometimes it should not be changed, yet annotations must be stored somewhere for use by tools.
    [Show full text]
  • Aspectj in Action, Second Edition
    Introducing AspectJ This chapter covers ■ Writing an AspectJ “Hello, world!” application ■ Becoming familiar with the AspectJ language ■ Weaving mechanisms ■ Integrating with Spring In chapter 1, we focused on general concepts in AOP. With those behind us, we can now look at one specific AOP implementation: AspectJ. AspectJ is an aspect- oriented extension to the Java programming language. Like any AOP implementa- tion, AspectJ consists of two parts: the language specification, which defines the grammar and semantics of the language; and the language implementation, which includes weavers that take various forms such as a compiler and a linker. A weaver produces byte code that conforms to the Java byte-code specification, allowing any compliant Java virtual machine (VM) to execute those class files. The language implementation also offers support for integrated development environments (IDEs), to simplify building and debugging applications. AspectJ started and initially grew as a special language that extends the Java lan- guage with new keywords. It also provided a special compiler that could understand those extensions. But recently, a lot has changed in its form as a language, as well as 27 Licensed to Manning Marketing <[email protected]> 28 CHAPTER 2 Introducing AspectJ in the weaver. First, AspectJ offers an alternative syntax based on the Java annotation facil- ity to express crosscutting constructs. This lets you use a plain Java compiler instead of the special compiler. Second, AspectJ offers new options for weaving classes with aspects. Finally, it has gained a strong foothold in the Spring Framework with several integration options. All these changes have made adoption of AspectJ easier than ever before.
    [Show full text]
  • The Java Modeling Language
    The Java Modeling language JML Erik Poll Digital Security Radboud University Nijmegen JML • formal specification language for sequential Java by Gary Leavens et. al. – to specify behaviour of Java classes & interfaces – to record detailed design decisions by adding annotations to Java source code in Design-By- Contract style, using eg. pre/postconditions and invariants • Design goal: meant to be usable by any Java programmer Lots of info on http://www.jmlspecs.org Erik Poll, JML introduction - CHARTER meeting - 2 to make JML easy to use • JML annotations added as special Java comments, between /*@ .. @*/ or after //@ • JML specs can be in .java files, or in separate .jml files • Properties specified using Java syntax, extended with some operators \old( ), \result, \forall, \exists, ==> , .. and some keywords requires, ensures, invariant, .... Erik Poll, JML introduction - CHARTER meeting - 3 JML example public class ePurse{ private int balance; //@ invariant 0 <= balance && balance < 500; //@ requires amount >= 0; //@ ensures balance <= \old(balance); public debit(int amount) { if (amount > balance) { throw (new BankException("No way"));} balance = balance – amount; } Erik Poll, JML introduction - CHARTER meeting - 4 What can you do with this? • documentation/specification – record detailed design decisions & document assumptions (and hence obligations!) – precise, unambiguous documentation • parsed & type checked • use tools for – runtime assertion checking • eg when testing code – compile time (static) analyses • up to full formal program
    [Show full text]
  • Advanced-Java.Pdf
    Advanced java i Advanced java Advanced java ii Contents 1 How to create and destroy objects 1 1.1 Introduction......................................................1 1.2 Instance Construction.................................................1 1.2.1 Implicit (Generated) Constructor.......................................1 1.2.2 Constructors without Arguments.......................................1 1.2.3 Constructors with Arguments........................................2 1.2.4 Initialization Blocks.............................................2 1.2.5 Construction guarantee............................................3 1.2.6 Visibility...................................................4 1.2.7 Garbage collection..............................................4 1.2.8 Finalizers...................................................5 1.3 Static initialization..................................................5 1.4 Construction Patterns.................................................5 1.4.1 Singleton...................................................6 1.4.2 Utility/Helper Class.............................................7 1.4.3 Factory....................................................7 1.4.4 Dependency Injection............................................8 1.5 Download the Source Code..............................................9 1.6 What’s next......................................................9 2 Using methods common to all objects 10 2.1 Introduction...................................................... 10 2.2 Methods equals and hashCode...........................................
    [Show full text]
  • Inversion of Control in Spring – Using Annotation
    Inversion of Control in Spring – Using Annotation In this chapter, we will configure Spring beans and the Dependency Injection using annotations. Spring provides support for annotation-based container configuration. We will go through bean management using stereotypical annotations and bean scope using annotations. We will then take a look at an annotation called @Required, which allows us to specify which dependencies are actually required. We will also see annotation-based dependency injections and life cycle annotations. We will use the autowired annotation to wire up dependencies in the same way as we did using XML in the previous chapter. You will then learn how to add dependencies by type and by name. We will also use qualifier to narrow down Dependency Injections. We will also understand how to perform Java-based configuration in Spring. We will then try to listen to and publish events in Spring. We will also see how to reference beans using Spring Expression Language (SpEL), invoke methods using SpEL, and use operators with SpEL. We will then discuss regular expressions using SpEL. Spring provides text message and internationalization, which we will learn to implement in our application. Here's a list of the topics covered in this chapter: • Container configuration using annotations • Java-based configuration in Spring • Event handling in Spring • Text message and internationalization [ 1 ] Inversion of Control in Spring – Using Annotation Container configuration using annotation Container configuration using Spring XML sometimes raises the possibility of delays in application development and maintenance due to size and complexity. To solve this issue, the Spring Framework supports container configuration using annotations without the need of a separate XML definition.
    [Show full text]
  • Type Annotations Specification
    Type Annotations Specification (JSR 308) Michael D. Ernst [email protected] May 2, 2013 The JSR 308 webpage is http://types.cs.washington.edu/jsr308/. It contains the latest version of this document, along with other information such as a FAQ, the reference implementation, and sample annotation processors. Contents 1 Introduction 2 2 Java language syntax extensions 2 2.1 Source locations for annotations on types . 2 2.1.1 Implicit type uses are not annotatable . 5 2.1.2 Not all type names are annotatable . 5 2.2 Java language grammar changes . 6 2.2.1 Syntax of array annotations . 8 2.2.2 Syntax of annotations on qualified types . 9 2.3 Target meta-annotations for type annotations . 9 3 Class file format extensions 11 3.1 The type annotation structure . 12 3.2 The target type field: the type of annotated element . 13 3.3 The target info field: identifying a program element . 13 3.3.1 Type parameters . 13 3.3.2 Class supertypes: extends and implements clauses . 14 3.3.3 Type parameter bounds . 14 3.3.4 Method return type, receiver, and fields . 15 3.3.5 Method formal parameters . 15 3.3.6 throws clauses . 15 3.3.7 Local variables and resource variables . 15 3.3.8 Exception parameters (catch clauses) . 16 3.3.9 Type tests, object creation, and method/constructor references . 16 3.3.10 Casts and type arguments to constructor/method invocation/references . 16 3.4 The type path structure: Identifying part of a compound type . 17 A Examples of classfile structure 18 A.1 Examples of type parameter bounds .
    [Show full text]
  • You Say 'JML' ? Wikipedia (En)
    You say 'JML' ? Wikipedia (en) PDF generated using the open source mwlib toolkit. See http://code.pediapress.com/ for more information. PDF generated at: Mon, 06 Jan 2014 09:58:42 UTC Contents Articles Java Modeling Language 1 Design by contract 5 Formal methods 10 References Article Sources and Contributors 15 Image Sources, Licenses and Contributors 16 Article Licenses License 17 Java Modeling Language 1 Java Modeling Language The Java Modeling Language (JML) is a specification language for Java programs, using Hoare style pre- and postconditions and invariants, that follows the design by contract paradigm. Specifications are written as Java annotation comments to the source files, which hence can be compiled with any Java compiler. Various verification tools, such as a runtime assertion checker and the Extended Static Checker (ESC/Java) aid development. Overview JML is a behavioural interface specification language for Java modules. JML provides semantics to formally describe the behavior of a Java module, preventing ambiguity with regard to the module designers' intentions. JML inherits ideas from Eiffel, Larch and the Refinement Calculus, with the goal of providing rigorous formal semantics while still being accessible to any Java programmer. Various tools are available that make use of JML's behavioral specifications. Because specifications can be written as annotations in Java program files, or stored in separate specification files, Java modules with JML specifications can be compiled unchanged with any Java compiler. Syntax JML specifications are added to Java code in the form of annotations in comments. Java comments are interpreted as JML annotations when they begin with an @ sign.
    [Show full text]
  • Java Class Annotation Example
    Java Class Annotation Example Bud etherealizing her matriarch inimitably, unwavering and decayed. Antimonious and regulation Rog violated almost anywhere, though Saunderson tosses his Creon outdating. Which Roland disinhuming so ordinarily that Westleigh tooth her opposites? It is class to classes are pretty easy to reflection to list to catch, company or property to generate mock for? First method of java example. The java are given list of bibliography. Default annotations example, java code examples of the compiler to be applied to json. The new project for extracting information to create web sites without editions but i go into the annotated bibliography paper, we welcome to isolate the mechanics of using. Parsing the examples can be used from open source and. We will utilize the class analyzes the same type declaration etc at runtime reflection methods or evaluative lists the suite itself which are. Nice explanation about the front controller, we added and then issues a class of the information, management example demonstrates how can be executed and. There are working standalone spring boot application into system proposed here, because of annotations. Its annotations example annotation examples java. Hibernate does not to class or specify java example of fundamental never hurt or not. Read from java class acts as each article has been designed with examples select then we learned about? We made as classes that class or examples of annotation example classes or an earlier article example it tells spring. The table pointing back to interface. From java example is applied only contains a second argument. Junit provides a test cases, we want specific warnings and ideas into our newsletter for an understanding takt time in.
    [Show full text]
  • Vysoke´Ucˇenítechnicke´V Brneˇ Automaticka´Tvorba
    VYSOKE´ UCˇ ENI´ TECHNICKE´ V BRNEˇ BRNO UNIVERSITY OF TECHNOLOGY FAKULTA INFORMACˇ NI´CH TECHNOLOGII´ U´ STAV POCˇ ´ITACˇ OVE´ GRAFIKY A MULTIME´ DII´ FACULTY OF INFORMATION TECHNOLOGY DEPARTMENT OF COMPUTER GRAPHICS AND MULTIMEDIA AUTOMATICKA´ TVORBA GRAFICKE´ HO ROZHRANI´ PRO VZDA´ LENY´ PRˇ ´ISTUP AUTOMATIC USER INTERFACE DESIGN FOR REMOTE ACCESS DIPLOMOVA´ PRA´ CE MASTER’S THESIS AUTOR PRA´ CE Bc. JAN KORITˇA´ K AUTHOR VEDOUCI´ PRA´ CE Doc. Dr. Ing. PAVEL ZEMCˇ ´IK SUPERVISOR BRNO 2011 Abstrakt Tato práce zkoumá možnosti abstrakce grafického uživatelského rozhraní a automatizace procesu jeho návrhu a tvorby za provozu aplikace. Dùraz je kladen na možnost ovládání apli- kace na dálku pøes počítačovou síť a tedy na delegaci procesu tvorby rozhraní na vzdálený stroj obsluhovaný uživatelem. Práce analyzuje souèasné přístupy a metody pro generování rozhraní. V rámci práce byl navržen a implementován systém pro automatické generování uživatelského rozhraní vzdálené aplikace na základě specifikovaného datového modelu. Abstract This thesis explores the possibilities of abstraction of graphical user interface and auto- mation of its design and development process at runtime. Emphasis is placed on possibility of remote control over computer network and accordingly on delegation of the interface creation on the human operated remote machine. The thesis analyzes contemporary appro- aches to and methods of interface generation. As a goal of the thesis a system for automatic user interface generation for remote applications was designed and implemented.
    [Show full text]
  • Introduction to JML the Java Modeling Language
    Goal: JML should be easy to use for any Java programmer. Outline of this tutorial First • introduction to JML Introduction to JML • overview of tool support for JML, esp. runtime assertion checking (using jmlrac) and extended static David Cok, Joe Kiniry, and Erik Poll checking ESC/Java2 Then Eastman Kodak Company, University College Dublin, • ESC/Java2: Use and Features and Radboud University Nijmegen • ESC/Java2: Warnings • Specification tips and pitfalls • Advanced JML: more tips and pitfalls interspersed with demos. David Cok, Joe Kiniry & Erik Poll - ESC/Java2 & JML Tutorial – p.1/30 David Cok, Joe Kiniry & Erik Poll - ESC/Java2 & JML Tutorial – p.2/30 JML by Gary Leavens et al. Formal specification language for Java • to specify behaviour of Java classes • to record design &implementation decisions The Java Modeling Language by adding assertions to Java source code, eg • preconditions JML • postconditions • invariants www.jmlspecs.org as in Eiffel (Design by Contract), but more expressive. David Cok, Joe Kiniry & Erik Poll - ESC/Java2 & JML Tutorial – p.3/30 David Cok, Joe Kiniry & Erik Poll - ESC/Java2 & JML Tutorial – p.4/30 JML by Gary Leavens et al. JML Formal specification language for Java To make JML easy to use: to specify behaviour of Java classes • • JML assertions are added as comments in .java file, • to record design &implementation decisions between /*@ . @*/, or after //@, by adding assertions to Java source code, eg • Properties are specified as Java boolean expressions, extended with a few operators (nold, nforall, nresult, • preconditions . ). • postconditions • using a few keywords (requires, ensures, • invariants signals, assignable, pure, invariant, non null, .
    [Show full text]