Java-Modellierungssprache - Wikipedia

Dieser Artikel erfordert die Aufmerksamkeit eines Experten zu diesem Thema . Fügen Sie dieser Vorlage einen Parameter reason oder einen talk hinzu, um das Problem mit dem Artikel zu erläutern. Berücksichtigen Sie beim Platzieren dieses Tags die Zuordnung dieser Anforderung zu einem WikiProject. ( Juli 2010 )

Die Java Modeling Language ( JML ) ist eine Spezifikationssprache für Java-Programme, die Vor- und Nachbedingungen und Invarianten des Hoare-Stils verwendet und dem Design nach dem Vertragsparadigma folgt. Spezifikationen werden als Java-Anmerkungskommentare in die Quelldateien geschrieben, die daher mit jedem Java-Compiler kompiliert werden können.

Verschiedene Überprüfungstools, z. B. ein Laufzeit-Assertion-Checker und die Extended Static Checker (ESC / Java) -Hilfesentwicklung.

Überblick [ edit ]

JML ist eine Spezifikationssprache für Verhaltensschnittstellen für Java-Module. JML bietet eine Semantik, um das Verhalten eines Java-Moduls formal zu beschreiben und Mehrdeutigkeiten hinsichtlich der Absichten der Modul-Designer zu vermeiden. JML erbt Ideen von Eiffel, Larch und dem Refinement Calculus mit dem Ziel, strenge formale Semantik bereitzustellen und gleichzeitig für jeden Java-Programmierer zugänglich zu sein. Es gibt verschiedene Tools, die die Verhaltensspezifikationen von JML nutzen. Da Spezifikationen als Anmerkungen in Java-Programmdateien geschrieben oder in separaten Spezifikationsdateien gespeichert werden können, können Java-Module mit JML-Spezifikationen mit jedem Java-Compiler unverändert kompiliert werden.

JML-Spezifikationen werden Java-Code in Form von Anmerkungen in Kommentaren hinzugefügt. Java-Kommentare werden als JML-Anmerkungen interpretiert, wenn sie mit einem @ -Zeichen beginnen. Das heißt, Kommentare des Formulars

 // @ 

oder

 / * @  @ * /

Die grundlegende JML-Syntax enthält die folgenden Schlüsselwörter

benötigt

Definiert eine Vorbedingung für die folgende Methode.

stellt sicher,

Definiert eine Nachbedingung für die folgende Methode.

Signale

Defines a Nachbedingung, wann eine bestimmte Ausnahme nach der folgenden Methode ausgelöst wird.

signals_only

Definiert, welche Ausnahmen ausgelöst werden dürfen, wenn die gegebene Vorbedingung gilt.

Zuweisbar

Definierbar, welche Felder sind darf nach der folgenden Methode zugewiesen werden.

pure

Erklärt eine Methode als nebenwirkungsfrei (wie zuweisbar nothing kann aber auch Ausnahmen werfen). Außerdem soll eine reine Methode immer entweder normal enden oder eine Ausnahme auslösen.

invariante

Definiert eine invariante Eigenschaft der Klasse.

loop_invariant

Definiert eine Schleifeninvariante für eine Schleife.

auch

Kombiniert Spezifikationsfälle und kann auch angeben, dass eine Methode Spezifikationen von ihren Supertypen erbt.

assert

Definiert eine JML-Assertion.

spec_public

Deklariert eine geschützte oder private Variable zu Spezifikationszwecken als public.

Basic JML stellt auch die folgenden Ausdrücke bereit

result

Ein Bezeichner für den Rückgabewert der folgenden Methode.

old ()

Ein Modifikator, der sich auf den Wert von [19659041] zum Zeitpunkt des Eintritts in eine Methode.

( forall ; ; )

Der universelle Quantifizierer

( exists ; ; )

Der existenzielle Quantifizierer

a ==> b

a impliziert b

a < == b

a wird implizit durch b

a <==> b

a a a beschrieben if b

sowie Standard-Java-Syntax für logisch und, oder, und nicht. JML-Annotationen haben auch Zugriff auf Java-Objekte, Objektmethoden und Operatoren, die sich im Bereich der zu annotierenden Methode befinden und über eine entsprechende Sichtbarkeit verfügen. Diese werden kombiniert, um formale Spezifikationen für die Eigenschaften von Klassen, Feldern und Methoden bereitzustellen. Beispielsweise kann ein kommentiertes Beispiel für eine einfache Bankenklasse aussehen

  public   class   BankingExample 
  {
 
     public   static   final   int   MAX_BALANCE   1000  1000 ; ] private   / * @ spec_public @ * /   int   balance ; 
     private   / * @ spec_public @ * /   boolean   =   false ;  
 
     // @ öffentliches invariantes Gleichgewicht> = 0 && balance <= MAX_BALANCE; 
 
     // @ zuweisbares Gleichgewicht; 
     // @ sichert Gleichgewicht == 0; 
     public   BankingExample  () 
     {
         .  Bilanz   =   0 ; <betrag && betrag + kontostand <MAX_BALANCE; 
     // @ zuweisbarer Kontostand; 
     // @ sichert den Kontostand == alt (Kontostand) + Betrag; ] ( endgültig   int   Betrag ) 
     {
         this .  Bilanz [19659062] + =   Betrag ; 
    } 
 
     // @ erfordert 0 <Betrag && Betrag <= Saldo; 
     // @ zuweisbarer Saldo; 
     // @ sorgt für Saldo = = alt (Kontostand) - Betrag; 
     public   void   Lastschrift  ( final   int   Betrag ) 
     {19659084] 19659064].  balance   - =   betrag ; 
    } 
 
     // @ sichert gesperrt == wahr; 
     public   void   lockAccount   ] () 
     {
         Dies ist .  isLocked   =   true ; 
    } 
 
     // @ erfordert! IsLocked; 
     // @ sorgt für  result == balance; 
     // @ auch 
     // @ erfordert isLocked; 
     // @ signals_only BankingException; 
     public   / * @ pure @ * /   int   getBalance  ()   wirft   BankingException 
     {
        wenn   (!  diese .  9659161] {
                 return   Dies .  Gleichgewicht ; 
         
         else 
         {
                 werfen   neu [196590163] (); 
        } 
    } 
 } 

Die vollständige Dokumentation der JML-Syntax ist im JML-Referenzhandbuch verfügbar.

Werkzeugunterstützung [ edit ]

Eine Vielzahl von Werkzeugen stellt Funktionen bereit, die auf JML-Anmerkungen basieren. Die JML-Tools von Iowa State bieten einen Assertionsprüfungs-Compiler jmlc der JML-Annotationen in Laufzeitassertierungen konvertiert, einen Dokumentationsgenerator jmldoc der Javadoc-Dokumentation mit zusätzlichen Informationen aus JML-Annotationen erzeugt, und eine Einheit Test Generator Jmlunit der JUnit-Testcode aus JML-Annotationen generiert.

Unabhängige Gruppen arbeiten an Tools, die JML-Annotationen verwenden. Diese schließen ein:

• ESC / Java2 [1]ein erweiterter statischer Checker, der mithilfe von JML-Annotationen eine strengere statische Überprüfung durchführt, als ansonsten möglich ist.


• OpenJML erklärt sich selbst zum Nachfolger von ESC / Java2.


• Daikon, eine dynamische Invariante Generator.


• KeY, ein Open Source-Theorem-Prover mit einem JML-Frontend und einem Eclipse-Plug-In (JML-Editing) mit Unterstützung für die Syntaxhervorhebung von JML.


• Krakatoa, ein statisches Überprüfungswerkzeug, das auf dem basiert Warum eine Verifikationsplattform und der Coq-Beweisassistent.


• JMLEclipse, ein Plugin für die integrierte Eclipse-Entwicklungsumgebung mit Unterstützung für JML-Syntax und Schnittstellen zu verschiedenen Tools, die JML-Annotationen verwenden.


• Sireum / Kiasan, eine symbolische Ausführung Ein statischer Analysator, der JML als Vertragssprache unterstützt.


• JMLUnit, ein Tool zum Generieren von Dateien für die Ausführung von JUnit-Tests für JML-kommentierte Java-Dateien.


• TACO, ein Open-Source-Programmanalyse-Tool, das statisch arbeitet ks die Konformität eines Java-Programms mit seiner Java Modeling Language-Spezifikation.


• VerCors verifier

Referenzen [ edit

• Gary T. Leavens und Yoonsik Cheon. Design by Contract mit JML ; Entwurf des Tutorials.


• Gary T. Leavens, Albert L. Baker und Clyde Ruby. JML: Eine Notation für detailliertes Design ; in Haim Kilov, Bernhard Rumpe und Ian Simmonds (Herausgeber), Verhaltensspezifikationen von Unternehmen und Systemen Kluwer, 1999, Kapitel 12, Seiten 175-188.


• Gary T. Leavens, Erik Poll, Curtis Clifton, Yoonsik Cheon, Clyde Ruby, David Cok, Peter Müller, Joseph Kiniry, Patrice Chalin und Daniel M. Zimmerman. JML Reference Manual (DRAFT), September 2009. HTML


• Marieke Huisman, Wolfgang Ahrendt, Daniel Bruns und Martin Hentschel. Formale Spezifikation mit JML . 2014. download (CC-BY-NC-ND)

Externe Links [ edit ]