https://wiki.uni-due.de/jack/api.php?action=feedcontributions&feedformat=atom&user=StrieweJACK Wiki - Benutzerbeiträge [de]2026-08-10T15:30:15ZBenutzerbeiträgeMediaWiki 1.39.10https://wiki.uni-due.de/jack/index.php?title=GReQL_Regeln&diff=12782GReQL Regeln2026-05-20T14:30:51Z<p>Striewe: /* Beispiele für statische Prüfregeln für Java-Code */</p>
<hr />
<div>== Beispiele für statische Prüfregeln für Java-Code ==<br />
=== Codestil ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{MethodDeclaration}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
not x.constructor<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Methodennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Methodennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{TypeDeclaration}<br />
with<br />
not (x.name=capitalizeFirst(x.name))<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Klassennamen, die nicht mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach klein geschriebenen Klassennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{VariableDeclarationFragment}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
isEmpty(from m : V{Modifier} with x &lt;--&amp;{FieldDeclaration} --> m and m.name="final" report m end)<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Variablennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Variablennamen, wobei als "final" deklarierte Klassenvariablen ausgelassen werden.<br />
<br />
=== Einfache Inhalte ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
s.content = "\"Zeichenkette\""<br />
report 0 end<br />
</query><br />
<feedback>Deine Lösung verwendet nicht den String "Zeichenkette".</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal mit einem vorgegebenen Inhalt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
length(s.content) > 4<br />
report s.line as "line" end<br />
</query><br />
<feedback>Du verwendest in Zeile {line} ein festes String-Literal. Ist deine Lösung allgemeingültig?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal der Länge 4 oder länger (inklusive Anführungszeichen) und meldet es mit Angabe der Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from p : V{PackageDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Paketdefinition">Deine Lösung beinhaltet eine package-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Paketdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query> from p : V{ImportDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Importdefinition"> Deine Lösung beinhaltet eine import-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Importdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from u : V{CompilationUnit}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
x.name="exit" and<br />
y.name="System"<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>Der Aufruf von "System.exit()" in der Datei {name} in Zeile {line} ist nicht gestattet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.exit()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x : V{MethodInvocation}, y, z : V{SimpleName}<br />
with<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameName} y and<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameQualifier} z and<br />
(x.name="print" or x.name="println") and<br />
y.name="out" and z.name="System"<br />
report x.line as "line" end<br />
</query><br />
<feedback>You have a print statement in line {line}. Are you sure you want to print to console instead of returning?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.out.print()</code> oder <code>System.out.println()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
=== Kontrollstrukturen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m.name="m" and<br />
isEmpty(m -->{Child}*&amp;{WhileStatement}) and<br />
isEmpty(m -->{Child}*&amp;{DoStatement}) and<br />
isEmpty(m -->{Child}*&amp;{ForStatement}) and<br />
isEmpty(m -->{Child}*&amp;{EnhancedForStatement})<br />
report 0 end<br />
</query><br />
<feedback>In der Methode "m()" wird kein Schleifenkonstrukt verwendet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> ein beliebiges Schleifenkonstrukt enthält.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
( not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block} -->{Child}))<br />
) and<br />
( not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block} -->{Child}))<br />
)<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} enthält das if-Statement in Zeile {line} in beiden Zweigen keinen Code und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die nur leere Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) and<br />
isEmpty(x -->{IfStatementElseStatement}&amp;{Statement})<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} endet das if-Statement in Zeile {line} hinter der Bedingung sofort mit einem Semikolon. Die Bedingung ist dadurch wirkungslos und die folgende Anweisung wird immer ausgeführt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die keine Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{WhileStatement}<br />
with<br />
not isEmpty(u -->* x -->{WhileStatementBody}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block}) and<br />
isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block} -->{Child}))<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} besteht die while-Schleife in Zeile {line} nur aus einer Abbruchbedingung und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer while-Schleife, die nur aus einer Abbruchbedingung besteht und meldet eine solche Schleife als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from m : V{MethodDeclaration}, n : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration})* n and<br />
n -->{Child}*&amp;{MethodInvocation} -->{Access} m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck"> Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet. Dabei ist es egal, ob sich die Methode direkt selber aufruft, oder über einen oder mehrere Zwischenschritte aufgerufen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration}) m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck">Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet und sich insbesondere ohne Zwischenschritte über andere Methoden selber wieder aufruft.<br />
<br />
=== Attribute ===<br />
<syntaxhighlight lang="xml" line="1"><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, f : V{FieldDeclaration}, m1 : V{Modifier}, s : V{SimpleType}, v : V{VariableDeclarationFragment} with<br />
t.name="A" and<br />
f --> m1 and f --> s and f --> v and<br />
m1.name="private" and<br />
s.name="B" and<br />
v.name="attr"<br />
report 0 end</query><br />
<feedback>Das private Attribut "attr" vom Typ "B" in der Klasse "A" fehlt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel prüft, ob Klasse <code>A</code> ein privates Attribut vom Objekttyp <code>B</code> mit Namen <code>attr</code> enthält.<br />
<br />
<syntaxhighlight lang="xml" line="1"><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, f : V{FieldDeclaration}, m1 : V{Modifier}, p : V{PrimitiveType}, v : V{VariableDeclarationFragment} with<br />
t.name="A" and<br />
f --> m1 and f --> p and f --> v and<br />
m1.name="private" and<br />
p.name="int" and<br />
v.name="attr"<br />
report 0 end</query><br />
<feedback>Das private Attribut "attr" vom Typ "int" in der Klasse "A" fehlt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel prüft, ob Klasse <code>A</code> ein privates Attribut vom primitiven Typ <code>int</code> mit Namen <code>attr</code> enthält.<br />
<br />
<syntaxhighlight lang="xml" line="1"><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, f : V{FieldDeclaration}, m1,m2 : V{Modifier}, p : V{PrimitiveType}, v : V{VariableDeclarationFragment} with<br />
t.name="A" and<br />
f --> m1 and f-->m2 and m1&lt;>m2 and f --> p and f --> v and<br />
((m1.name="private" and m2.name="static") or (m2.name="private" and m1.name="static")) and<br />
p.name="int" and<br />
v.name="attr"<br />
report 0 end</query><br />
<feedback>Das private, statische Attribut "attr" vom Typ "int" in der Klasse "A" fehlt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel prüft, ob Klasse <code>A</code> ein privates, statisches Attribut vom primitiven Typ <code>int</code> mit Namen <code>attr</code> enthält.<br />
<br />
=== Methoden ===<br />
<syntaxhighlight lang="xml" line="1"><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "public static String method(int)")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "public static String method(int param)" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, wobei der Name des Methodenparameters unerheblich ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "int method()") and<br />
isEmpty(m -->{Child}&amp;{Modifier})<br />
report 0 end<br />
</query><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, mo : V{Modifier}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "int method()") and<br />
m --> mo and not (mo.name="private")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "int method()" in der Klasse "A" fehlt oder ist mit dem Modifier "private" versehen. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, die nicht mit dem Modifier private versehen ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
m.name="m" and<br />
m -->{MethodDeclarationReturnType} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Signatur">Der Methode "public B&lt;C&gt; m()" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode m mit parametrisierten Rückgabetyp B<C> enthält.<br />
<br />
=== Vererbungshierarchie ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
st.name="B" and<br />
t -->{TypeDeclarationSuperclassType} st<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A ist nicht als Unterklasse von B modelliert.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A direkte Unterklasse von Klasse B ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes} st and<br />
st.name="B"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B&lt;C&gt;.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B<C> implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="3"><br />
<query>from u : V{TypeDeclaration}, s : V{SimpleType}<br />
with<br />
((u -->{TypeDeclarationSuperclassType} s and s.name="Thread") or<br />
(u -->{TypeDeclarationSuperInterfaceTypes} s and s.name="Runnable")) and<br />
u.name="A"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte entweder das Interface "Runnable" implementieren oder von "Thread" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface Runnable implementiert oder von Thread erbt.<br />
<br />
=== Aufrufbeziehungen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "B.m()" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode B.m aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}, z : V{VariableDeclarationStatement}, f : V{VariableDeclarationFragment}, t : V{SimpleType}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u -->* z -->{VariableDeclarationStatementType} t and<br />
u -->* z -->{VariableDeclarationStatementFragments} f and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name=f.name and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "m()" auf einem Objekt vom Typ "B" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A Methode m auf einem Objekt vom Typ B aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from u : V{TypeDeclaration}, m : V{MethodDeclaration}, x : V{ClassInstanceCreation}, t : V{SimpleType}<br />
with<br />
u -->{Child}* m -->* x -->{ClassInstanceCreationType} t and<br />
u.name="A" and<br />
m.name="m" and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" muss in Methode m() mindestens eine Instanz von "B" erzeugt werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A in Methode m eine Instanz von Klasse B erstellt.<br />
<br />
== Beispiele für statische Prüfregeln für UML-Modelle im XMI2-Format ==<br />
=== Klassendiagramme ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback prefix="Hinweis">Im Diagramm sind die "B" eines "A" als eigene Klasse abgebildet. Das kannst du durch eine bessere Modellierung vermeiden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft ebenfalls, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind, definiert dies aber als unerwünschte Situation mit entsprechendem Feedback.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}, z: V{Property}<br />
with<br />
x --> z and<br />
z --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B" and<br />
isDefined(z.lower) and z.lower="1" and (not isDefined(z.upper) or z.upper="1")<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" mit der Kardinalität 1 oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation mit Kardinalität 1 (jedes A kennt genau ein B) verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b : V{Class}, p: V{Property}<br />
with<br />
isEmpty(a -->&amp;{Property} -->&amp;{Association}) and<br />
b --> p and<br />
isDefined(p.aggregation) and p.aggregation="composite"<br />
report 1 end<br />
</query><br />
<feedback>Es sollte im Diagramm zwei Klassen geben, bei denen die eine keine weiteren Bestandteile hat, während die andere weitere Bestandteile gemäß der Komposition hat.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse ohne ausgehende Assoziationen gibt und eine weitere, die mindestens eine ausgehende Komposition hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Property}, z : V{PrimitiveType}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and y.name="b" and<br />
y --> z and<br />
isDefined(z.name) and z.name="String"<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll ein Attribut für die Eigenschaft "b" bereitstellen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse "A" mit dem Attribut "b" vom Typ "String" gibt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Operation}, z: V{Parameter}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and stringLevenshteinDistance(y.name, "ausführen")&lt;3 and<br />
y --> z<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll eine Methode bereitstellen, mit der sie etwas ausführen kann.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel prüft, ob es im Modell eine Klasse "A" mit einer Operation gibt, deren Name "ausführen" oder ähnlich lautet.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>let c := count(from y : V{Operation} with isDefined(y.name) report y end) in<br />
from x : set(1)<br />
with<br />
c&lt;>7<br />
report c as "count" end<br />
</query><br />
<feedback>Das Diagramm sollte genau 7 Methoden enthalten, enthält aber {count}.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell genau 7 Methoden enthält und gibt im Falle einer anderen Anzahl diese im Feedback mit aus.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x.isAbstract and<br />
not isEmpty(x &lt;--&amp;{Generalization})<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte eine abstrakte Klasse "A" enthalten, von der mindestens eine Klasse erbt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine abstrakte Klasse "A" enthält, auf die in mindestens einer Generalisierung verwiesen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b,c,d : V{Class}<br />
with<br />
isDefined(a.name) and a.name="A" and<br />
isDefined(b.name) and b.name="B" and<br />
isDefined(c.name) and c.name="C" and<br />
isDefined(d.name) and d.name="D" and<br />
a --> V{Generalization} --> d and<br />
b --> V{Generalization} --> d and<br />
c --> V{Generalization} --> d<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte Klassen "A", "B" und "C" enthalten, die von einer gemeinsamen Oberklasse "D" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine Klasse "D" enthält, die drei direkte Unterklassen "A", "B" und "C" hat.<br />
<br />
== Beispiele für statische Prüfregeln für EPML ==<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x: V{Event}<br />
with<br />
isEmpty(x &lt;--)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt kein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph kein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="5"><br />
<query> from x,y: V{Event}<br />
with<br />
isEmpty(x &lt;--) and<br />
isEmpty(y &lt;--) and<br />
not (x=y)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt mehr als ein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph mehr als ein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="3"><br />
<query> from x,y: V{Element, ^Connector}<br />
with<br />
not (x.name="") and<br />
x.name = y.name and<br />
not (x = y)<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Es gibt mindestens zwei Elemente mit demselben Namen ("{name}").</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob es der Graph Elemente mit demselben Namen besitzt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Element, ^Connector}, y1, y2 : V{Element}<br />
with<br />
x --> y1 and<br />
x --> y2 and<br />
not (y1=y2)<br />
report x.name as "xName", x.id as "xID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Das Element "{xName}" (ID {xID}) hat mehr als einen Ausgang.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob ein Event oder Funktion mehr als einen Ausgang hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Connector}, y: V{Connector}<br />
with<br />
not (x.name="") and<br />
not (y.name="") and<br />
x --> y<br />
report x.name as "xName", y.name as "yName", x.id as "xID", y.id as "yID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Es dürfen keine zwei Konnektoren direkt aufeinander folgen. Es folgt jedoch "{yName}" (ID {yID}) direkt auf "{xName}" (ID {xID}).</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob 2 Konnektoren aufeinander folgen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x: V{Element, ^Connector}<br />
with<br />
contains(x.name, " and ") or<br />
contains(x.name, "+") or<br />
contains(x.name, " und ")<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Der Name "{name}" sieht danach aus, als wenn hier zwei Events bzw. Funktionen in einem Element zusammengefasst wurden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob der Graph möglicherweise Zeichen bzw. Wörter besitzt die mehrere Funktionen/Events in einem Element verbinden.<br />
<br />
[[Category:R-GReQL]][[category:Benutzerhandbuch]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQL_Regeln&diff=12422GReQL Regeln2025-09-12T08:05:44Z<p>Striewe: /* Einfache Inhalte */</p>
<hr />
<div>== Beispiele für statische Prüfregeln für Java-Code ==<br />
=== Codestil ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{MethodDeclaration}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
not x.constructor<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Methodennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Methodennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{TypeDeclaration}<br />
with<br />
not (x.name=capitalizeFirst(x.name))<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Klassennamen, die nicht mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach klein geschriebenen Klassennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{VariableDeclarationFragment}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
isEmpty(from m : V{Modifier} with x &lt;--&amp;{FieldDeclaration} --> m and m.name="final" report m end)<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Variablennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Variablennamen, wobei als "final" deklarierte Klassenvariablen ausgelassen werden.<br />
<br />
=== Einfache Inhalte ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
s.content = "\"Zeichenkette\""<br />
report 0 end<br />
</query><br />
<feedback>Deine Lösung verwendet nicht den String "Zeichenkette".</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal mit einem vorgegebenen Inhalt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
length(s.content) > 4<br />
report s.line as "line" end<br />
</query><br />
<feedback>Du verwendest in Zeile {line} ein festes String-Literal. Ist deine Lösung allgemeingültig?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal der Länge 4 oder länger (inklusive Anführungszeichen) und meldet es mit Angabe der Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from p : V{PackageDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Paketdefinition">Deine Lösung beinhaltet eine package-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Paketdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query> from p : V{ImportDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Importdefinition"> Deine Lösung beinhaltet eine import-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Importdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from u : V{CompilationUnit}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
x.name="exit" and<br />
y.name="System"<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>Der Aufruf von "System.exit()" in der Datei {name} in Zeile {line} ist nicht gestattet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.exit()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x : V{MethodInvocation}, y, z : V{SimpleName}<br />
with<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameName} y and<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameQualifier} z and<br />
(x.name="print" or x.name="println") and<br />
y.name="out" and z.name="System"<br />
report x.line as "line" end<br />
</query><br />
<feedback>You have a print statement in line {line}. Are you sure you want to print to console instead of returning?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.out.print()</code> oder <code>System.out.println()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
=== Kontrollstrukturen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m.name="m" and<br />
isEmpty(m -->{Child}*&amp;{WhileStatement}) and<br />
isEmpty(m -->{Child}*&amp;{DoStatement}) and<br />
isEmpty(m -->{Child}*&amp;{ForStatement}) and<br />
isEmpty(m -->{Child}*&amp;{EnhancedForStatement})<br />
report 0 end<br />
</query><br />
<feedback>In der Methode "m()" wird kein Schleifenkonstrukt verwendet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> ein beliebiges Schleifenkonstrukt enthält.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
( not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block} -->{Child}))<br />
) and<br />
( not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block} -->{Child}))<br />
)<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} enthält das if-Statement in Zeile {line} in beiden Zweigen keinen Code und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die nur leere Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) and<br />
isEmpty(x -->{IfStatementElseStatement}&amp;{Statement})<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} endet das if-Statement in Zeile {line} hinter der Bedingung sofort mit einem Semikolon. Die Bedingung ist dadurch wirkungslos und die folgende Anweisung wird immer ausgeführt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die keine Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{WhileStatement}<br />
with<br />
not isEmpty(u -->* x -->{WhileStatementBody}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block}) and<br />
isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block} -->{Child}))<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} besteht die while-Schleife in Zeile {line} nur aus einer Abbruchbedingung und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer while-Schleife, die nur aus einer Abbruchbedingung besteht und meldet eine solche Schleife als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from m : V{MethodDeclaration}, n : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration})* n and<br />
n -->{Child}*&amp;{MethodInvocation} -->{Access} m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck"> Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet. Dabei ist es egal, ob sich die Methode direkt selber aufruft, oder über einen oder mehrere Zwischenschritte aufgerufen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration}) m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck">Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet und sich insbesondere ohne Zwischenschritte über andere Methoden selber wieder aufruft.<br />
<br />
=== Methoden ===<br />
<syntaxhighlight lang="xml" line="1"><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "public static String method(int)")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "public static String method(int param)" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, wobei der Name des Methodenparameters unerheblich ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "int method()") and<br />
isEmpty(m -->{Child}&amp;{Modifier})<br />
report 0 end<br />
</query><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, mo : V{Modifier}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "int method()") and<br />
m --> mo and not (mo.name="private")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "int method()" in der Klasse "A" fehlt oder ist mit dem Modifier "private" versehen. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, die nicht mit dem Modifier private versehen ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
m.name="m" and<br />
m -->{MethodDeclarationReturnType} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Signatur">Der Methode "public B&lt;C&gt; m()" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode m mit parametrisierten Rückgabetyp B<C> enthält.<br />
<br />
=== Vererbungshierarchie ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
st.name="B" and<br />
t -->{TypeDeclarationSuperclassType} st<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A ist nicht als Unterklasse von B modelliert.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A direkte Unterklasse von Klasse B ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes} st and<br />
st.name="B"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B&lt;C&gt;.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B<C> implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="3"><br />
<query>from u : V{TypeDeclaration}, s : V{SimpleType}<br />
with<br />
((u -->{TypeDeclarationSuperclassType} s and s.name="Thread") or<br />
(u -->{TypeDeclarationSuperInterfaceTypes} s and s.name="Runnable")) and<br />
u.name="A"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte entweder das Interface "Runnable" implementieren oder von "Thread" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface Runnable implementiert oder von Thread erbt.<br />
<br />
=== Aufrufbeziehungen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "B.m()" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode B.m aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}, z : V{VariableDeclarationStatement}, f : V{VariableDeclarationFragment}, t : V{SimpleType}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u -->* z -->{VariableDeclarationStatementType} t and<br />
u -->* z -->{VariableDeclarationStatementFragments} f and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name=f.name and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "m()" auf einem Objekt vom Typ "B" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A Methode m auf einem Objekt vom Typ B aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from u : V{TypeDeclaration}, m : V{MethodDeclaration}, x : V{ClassInstanceCreation}, t : V{SimpleType}<br />
with<br />
u -->{Child}* m -->* x -->{ClassInstanceCreationType} t and<br />
u.name="A" and<br />
m.name="m" and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" muss in Methode m() mindestens eine Instanz von "B" erzeugt werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A in Methode m eine Instanz von Klasse B erstellt.<br />
<br />
== Beispiele für statische Prüfregeln für UML-Modelle im XMI2-Format ==<br />
=== Klassendiagramme ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback prefix="Hinweis">Im Diagramm sind die "B" eines "A" als eigene Klasse abgebildet. Das kannst du durch eine bessere Modellierung vermeiden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft ebenfalls, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind, definiert dies aber als unerwünschte Situation mit entsprechendem Feedback.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}, z: V{Property}<br />
with<br />
x --> z and<br />
z --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B" and<br />
isDefined(z.lower) and z.lower="1" and (not isDefined(z.upper) or z.upper="1")<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" mit der Kardinalität 1 oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation mit Kardinalität 1 (jedes A kennt genau ein B) verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b : V{Class}, p: V{Property}<br />
with<br />
isEmpty(a -->&amp;{Property} -->&amp;{Association}) and<br />
b --> p and<br />
isDefined(p.aggregation) and p.aggregation="composite"<br />
report 1 end<br />
</query><br />
<feedback>Es sollte im Diagramm zwei Klassen geben, bei denen die eine keine weiteren Bestandteile hat, während die andere weitere Bestandteile gemäß der Komposition hat.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse ohne ausgehende Assoziationen gibt und eine weitere, die mindestens eine ausgehende Komposition hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Property}, z : V{PrimitiveType}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and y.name="b" and<br />
y --> z and<br />
isDefined(z.name) and z.name="String"<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll ein Attribut für die Eigenschaft "b" bereitstellen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse "A" mit dem Attribut "b" vom Typ "String" gibt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Operation}, z: V{Parameter}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and stringLevenshteinDistance(y.name, "ausführen")&lt;3 and<br />
y --> z<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll eine Methode bereitstellen, mit der sie etwas ausführen kann.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel prüft, ob es im Modell eine Klasse "A" mit einer Operation gibt, deren Name "ausführen" oder ähnlich lautet.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>let c := count(from y : V{Operation} with isDefined(y.name) report y end) in<br />
from x : set(1)<br />
with<br />
c&lt;>7<br />
report c as "count" end<br />
</query><br />
<feedback>Das Diagramm sollte genau 7 Methoden enthalten, enthält aber {count}.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell genau 7 Methoden enthält und gibt im Falle einer anderen Anzahl diese im Feedback mit aus.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x.isAbstract and<br />
not isEmpty(x &lt;--&amp;{Generalization})<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte eine abstrakte Klasse "A" enthalten, von der mindestens eine Klasse erbt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine abstrakte Klasse "A" enthält, auf die in mindestens einer Generalisierung verwiesen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b,c,d : V{Class}<br />
with<br />
isDefined(a.name) and a.name="A" and<br />
isDefined(b.name) and b.name="B" and<br />
isDefined(c.name) and c.name="C" and<br />
isDefined(d.name) and d.name="D" and<br />
a --> V{Generalization} --> d and<br />
b --> V{Generalization} --> d and<br />
c --> V{Generalization} --> d<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte Klassen "A", "B" und "C" enthalten, die von einer gemeinsamen Oberklasse "D" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine Klasse "D" enthält, die drei direkte Unterklassen "A", "B" und "C" hat.<br />
<br />
== Beispiele für statische Prüfregeln für EPML ==<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x: V{Event}<br />
with<br />
isEmpty(x &lt;--)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt kein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph kein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="5"><br />
<query> from x,y: V{Event}<br />
with<br />
isEmpty(x &lt;--) and<br />
isEmpty(y &lt;--) and<br />
not (x=y)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt mehr als ein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph mehr als ein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="3"><br />
<query> from x,y: V{Element, ^Connector}<br />
with<br />
not (x.name="") and<br />
x.name = y.name and<br />
not (x = y)<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Es gibt mindestens zwei Elemente mit demselben Namen ("{name}").</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob es der Graph Elemente mit demselben Namen besitzt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Element, ^Connector}, y1, y2 : V{Element}<br />
with<br />
x --> y1 and<br />
x --> y2 and<br />
not (y1=y2)<br />
report x.name as "xName", x.id as "xID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Das Element "{xName}" (ID {xID}) hat mehr als einen Ausgang.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob ein Event oder Funktion mehr als einen Ausgang hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Connector}, y: V{Connector}<br />
with<br />
not (x.name="") and<br />
not (y.name="") and<br />
x --> y<br />
report x.name as "xName", y.name as "yName", x.id as "xID", y.id as "yID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Es dürfen keine zwei Konnektoren direkt aufeinander folgen. Es folgt jedoch "{yName}" (ID {yID}) direkt auf "{xName}" (ID {xID}).</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob 2 Konnektoren aufeinander folgen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x: V{Element, ^Connector}<br />
with<br />
contains(x.name, " and ") or<br />
contains(x.name, "+") or<br />
contains(x.name, " und ")<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Der Name "{name}" sieht danach aus, als wenn hier zwei Events bzw. Funktionen in einem Element zusammengefasst wurden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob der Graph möglicherweise Zeichen bzw. Wörter besitzt die mehrere Funktionen/Events in einem Element verbinden.<br />
<br />
[[Category:R-GReQL]][[category:Benutzerhandbuch]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Publikationen&diff=12303Publikationen2025-06-18T13:57:14Z<p>Striewe: </p>
<hr />
<div>Hier finden Sie eine Auflistungen aller Veröffentlichungen rund um das e-Assessment System JACK. Wenn Sie noch Veröffentlichungen kennen, die hier nicht aufgelistet sind melden Sie diese bitte [mailto:jack@paluno.uni-due.de per Mail] an uns.<br />
<br />
=== 2025 ===<br />
* Christoph Olbricht, Melanie Schypula: '''Digitales Lehren und Lernen mit Moodle und JACK.''' In: Nicole Auferkorte-Michaelis, Maiken Bonnes, Patrick Hintze, Julia Liebscher (Hrsg.): ''Prüfungen digital gestalten'', 2025, Verlag Barbara Budrich, S. 115-124.<br />
* Michael Striewe: '''Automatic Item Generation Integrated into the E-Assessment-System JACK.''' In: ''Proceedings of the 17th International Conference on Computer Supported Education (CSEDU 2025)'', 2025, Volume 1, pages 747-753. https://doi.org/10.5220/0013454600003932<br />
<br />
=== 2024 ===<br />
* Katrin Schüssler, Michael Striewe, Daniel Püschner, Arne Lützen, Michael Goedicke, Michael Giese, Maik Walpuski: '''Developing and evaluating an e-learning and e-assessment tool for organic chemistry in higher education.''' In: ''Front. Educ.'' 9:1355078. https://doi.org/10.3389/feduc.2024.1355078<br />
<br />
=== 2023 ===<br />
* Janine Langerbein, Till Massing, Jens Klenke, Michael Striewe, Michael Goedicke and Christoph Hanck: '''A Data Mining Approach for Detecting Collusion in Unproctored Online Exams.''' In: Mingyu Feng, Tanja Käser and Partha Talukdar (eds.): ''Proceedings of the 16th International Conference on Educational Data Mining'', International Educational Data Mining Society, 2023, 6-16. https://zenodo.org/records/8157692<br />
* Carolin Eitemüller, Florian Trauten, Michael Striewe and Maik Walpuski: '''Digitalization of Multistep Chemistry Exercises with Automated Formative Feedback'''. ''Journal of Science Education and Technology'', 2023. https://link.springer.com/article/10.1007/s10956-023-10043-2<br />
* Michael Striewe: '''Strukturformeln für Moleküle zeichnen und differenziertes Feedback erhalten: Eine integrierte Lösung im Rahmen des E-Assessment-Systems JACK.''' In: ''DELFI 2023, Die 21. Fachtagung Bildungstechnologien der Gesellschaft für Informatik e.V.'', 11.-13. September 2023, Aachen , 2023 , 273-274. https://dl.gi.de/items/79ac4858-1bdb-44d3-b5bf-60861ee6dc2d<br />
* Michael Striewe: '''Domain-Specific Automatic Item Generation for Higher Competence Levels: A Comparative Study on Three Cases.''' In: ''Methodologies and Intelligent Systems for Technology Enhanced Learning, 13th International Conference'', 2023, 152-159. https://link.springer.com/chapter/10.1007/978-3-031-41226-4_16<br />
* Michael Striewe: '''Architectural Revision of the E-Assessment System JACK.''' In: Thais Batista, Tomás Bures, Claudia Raibulet and Henry Muccini (eds.): ''Proceedings of ECSA 2022 Tracks and Workshops'', Springer, 2023, 19-26. https://link.springer.com/chapter/10.1007/978-3-031-36889-9_3<br />
* Jens Klenke, Till Massing, Natalie Reckmann, Janine Langerbein, Benjamin Otto, Michael Goedicke, Christoph Hanck: '''Effects of Early Warning Emails on Student Performance.''' In: ''Proceedings of the 15th International Conference on Computer Supported Education – Volume 1: CSEDU'', 225-232, 2023. https://www.scitepress.org/PublicationsDetail.aspx?ID=yvNJsCbTjyE=&t=1<br />
* Lukas Glaser, Michael Striewe: '''Modularisierung als Schlüssel zur Skalierung - Erfahrungen aus der Entwicklung des E-Assessment-Systems JACK.''' In: ''Workshops der 21. Fachtagung Bildungstechnologien (DELFI)'', Gesellschaft für Informatik e.V., 2023, 149-155. https://dl.gi.de/items/84131453-c22f-498b-9102-be1926ea5525<br />
<br />
=== 2022 ===<br />
* Peter Hubwieser, Johannes Krugel, Mike Talbot, Michael Striewe, Michael Goedicke and Christoph Olbricht. '''Empirical Definition of Object-oriented Programming Competencies.''' Technical report, Leibniz Universität Hannover, 2022. https://www.repo.uni-hannover.de/handle/123456789/12059<br />
<br />
=== 2021 ===<br />
* Till Massing, Natalie Reckmann, Alexander Blasberg, Benjamin Otto, Christoph Hanck and Michael Goedicke: '''When is the best time to learn? - Evidence from an introductory statistics course.''' ''Open Education Studies'', Volume 3, Number 1, 2021, 84-95. https://www.degruyter.com/document/doi/10.1515/edu-2020-0144/html<br />
* Silke Kirberg, Michael Striewe and Indira Ceylan: '''Interoperable Lernumgebung JACK im Projekt Harness.nrw - Textuelles Feedback in skalierbaren Programmieraufgaben.''' In: ''Bildung in der digitalen Transformation, Tagungsband zur GMW-Jahrestagung 2021'', 2021, 205-206.<br />
* Michael Striewe: '''Design Patterns for Submission Evaluation within E-Assessment Systems.''' In: ''26th European Conference on Pattern Languages of Programs EuroPLoP'21'', 2021, 32:1-32:10. https://dl.acm.org/doi/10.1145/3489449.3490010<br />
* Erwin Amann and Sylvi Rzepka: '''The Effect of Goal-Setting Prompts in a Blended Learning Environment: Evidence from a Field Experiment.''' Technical Report, University of Potsdam, 2021. https://publishup.uni-potsdam.de/files/49347/cepa25.pdf<br />
<br />
=== 2020 ===<br />
* Justin Timm, Benjamin Otto, Thilo Schramm, Michael Striewe, Philipp Schmiemann and Michael Goedicke: '''Technical Aspects of Automated Item Generation for Blended Learning Environments in Biology.''' ''i-com'', Volume 1, Number 19, April 2020, 3-15. https://www.degruyter.com/document/doi/10.1515/icom-2020-0001/html<br />
* Johannes Krugel, Peter Hubwieser, Michael Goedicke, Michael Striewe, Mike Talbot, Christoph Olbricht, Melanie Schypula and Simon Zettler: '''Automated Measurement of Competencies and Generation of Feedback in Object-Oriented Programming Courses.''' In: ''2020 IEEE Global Engineering Education Conference'', EDUCON 2020, Porto, Portugal, April 27-30, 2020, 2020, 329-338. https://ieeexplore.ieee.org/document/9125323<br />
* Michael Striewe, Florian Trauten and Carolin Eitemüller: '''Aufgaben mit automatischem Feedback zu chemischen Atom-Orbitalschemata.''' In: Raphael Zender, Dirk Ifenthaler, Thiemo Leonhardt and Clara Schumacher (eds.): ''DELFI 2020 – Die 18. Fachtagung Bildungstechnologien der Gesellschaft für Informatik e.V.'', Gesellschaft für Informatik e.V. , Bonn , 2020 , 109-119.<br />
<br />
=== 2019 ===<br />
* Justin Timm, Benjamin Otto, Thilo Schramm, Michael Striewe, Philipp Schmiemann and Michael Goedicke: '''Technische Aspekte der automatischen Aufgabengenerierung für Blended Learning Angebote in der Biologie.''' In: Niels Pinkwart and Johannes Konert (eds.): ''DELFI 2019 - Die 17. Fachtagung Bildungstechnologien'', Gesellschaft für Informatik e.V., Bonn, 2019, 91-102. https://dl.gi.de/items/6ea46885-ae2b-4ef4-bfad-d83c8bc0b584<br />
* Till Massing, Natalie Reckmann, Benjamin Otto, Alexander Blasberg, Christoph Hanck and Michael Goedicke: '''Quantitative Methodenkompetenzen im Praxissemester in Lehramtsstudiengängen.''' In: ''DeLFI 2019 - Die 17. Fachtagung Bildungstechnologien'', 16.-19. September 2019, Berlin, 2019, 327-328. https://dl.gi.de/items/935d861d-eabf-4cc3-82cb-be4c328e5d34<br />
* Sebastian Pobel and Michael Striewe: '''Domain-Specific Extensions for an E-Assessment System.''' In: Michael A. Herzog, Zuzana Kubincová, Peng Han and Marco Temperini (eds.): ''Advances in Web-Based Learning - ICWL 2019'', Springer International Publishing, Cham, 2019, 327-331. https://link.springer.com/chapter/10.1007/978-3-030-35758-0_32<br />
* Christoph Olbricht: '''Trace-Vergleich zur Feedback-Erzeugung im automatisierten E-Assessment-System JACK.''' In: ''Proceedings of the Fourth Workshop "Automatische Bewertung von Programmieraufgaben" (ABP 2019)'', Essen, Germany, 2019, 11-18. https://doi.org/10.18420/abp2019-2<br />
<br />
=== 2018 ===<br />
* Michael Striewe and Michael Goedicke: '''Automatische Generierung von Aufgaben zum Codeverständnis.''' In: ''DeLFI 2018 - Die 16. E-Learning Fachtagung Informatik der Gesellschaft für Informatik e. V.'', Volume 284 of Lecture Notes in Informatics, 2018, 153-164.<br />
* Melanie Schypula, Nils Schwinning and Michael Goedicke: '''Formative und summative E-Assessments mit JACK im Rahmen eines Mathematik-Vorkurses.''' In: Isabell van Ackeren, Michael Kerres and Sandrina Heinrich (eds.): ''Flexibles Lernen mit digitalen Medien'', Waxmann Verlag GmbH, 2018, 234-244.<br />
* Nils Schwinning, Michael Striewe, Till Massing, Christoph Hanck and Michael Goedicke: '''Towards digitalisation of summative and formative assessments in academic teaching of statistics.''' In: ''Reprint from the Fifth International Conference on Learning and Teaching in Computing and Engineering (LaTiCE 2017)'', 2018.<br />
* Till Massing, Nils Schwinning, Michael Striewe, Christoph Hanck and Michael Goedicke: '''E-Assessment Using Variable-Content Exercises in Mathematical Statistics.''' ''Journal of Statistics Education'', Volume 26, Number 3, 2018, 174-189. https://www.tandfonline.com/doi/full/10.1080/10691898.2018.1518121<br />
* Till Massing, Natalie Reckmann, Benjamin Otto, Kim J. Hermann, Christoph Hanck and Michael Goedicke: '''Klausurprognose mit Hilfe von E-Assessment-Nutzerdaten.''' In: ''DeLFI 2018 - Die 16. E-Learning Fachtagung Informatik der Gesellschaft für Informatik e. V.'', Volume 284 of Lecture Notes in Informatics, 2018, 171-176.<br />
* Raoul Deuss, Christine Lippens and Michael Striewe: '''Best of Two Worlds: Using Two Assessment Tools in One Course.''' In: ''Technology Enhanced Assessment - 21st International Conference'', TEA 2018, Amsterdam, The Netherlands, December 10-11, 2018, Revised Selected Papers, 2018, 121-139. https://link.springer.com/chapter/10.1007/978-3-030-25264-9_9<br />
* Michael Striewe: '''Dynamic Generation of Assessment Items Using Wikidata.''' In: ''Technology Enhanced Assessment - 21st International Conference'', TEA 2018, Amsterdam, The Netherlands, December 10-11, 2018, Revised Selected Papers, 2018, 1-15. https://link.springer.com/chapter/10.1007/978-3-030-25264-9_1<br />
* Michael Striewe: '''Towards a Pattern Catalogue for E-Assessment System Integration.''' In: ''Combined Proceedings of the Workshops of the German Software Engineering Conference 2018 (SE 2018)'', Ulm, Germany, March 06, 2018., 2018, 62-65.<br />
* Michael Striewe and Matthias Kramer: '''Empirische Untersuchungen von Lückentext-Items zur Beherrschung der Syntax einer Programmiersprache.''' In: ''Hochschuldidaktik der Informatik (HDI 2018)'', Volume 12 of Commentarii informaticae didacticae (CID), 2018, 101-115.<br />
<br />
=== 2017 ===<br />
* Benjamin Otto and Michael Goedicke: '''Auf dem Weg zu variablen Programmieraufgaben: Requirements Engineering anhand didaktischer Aspekte.''' In: ''3rd Workshop on "Automatische Bewertung von Programmieraufgaben" (ABP 2017)'', 2017.<br />
* Peter Hubwieser, Marc Berges, Michael Striewe and Michael Goedicke: '''Towards Competency Based Testing and Feedback.''' In: ''Proceedings of IEEE Global Engineering Education Conference (EDUCON)'', 2017, 517-526. https://ieeexplore.ieee.org/document/7942896<br />
* Michael Goedicke and Michael Striewe: '''10 Jahre automatische Bewertung von Programmieraufgaben mit JACK – Rückblick und Ausblick.''' In: ''7,5. HDI-Workshop des GI-Fachbereichs Informatik und Ausbildung / Didaktik der Informatik'', 2017. https://dl.gi.de/items/baff53cf-b9b0-4138-9eda-b4676f908818<br />
* Michael Striewe: '''Integration von externen Werkzeugen über die IMS-LTI-Schnittstelle.''' In: Moodle Kompetenzzentrum der Universität Duisburg-Essen (eds.): ''Moodle in der Praxis - Szenarien für die Hochschullehre. 12 Jahre Moodle an der Universität Duisburg-Essen'', DuEPublico, 2017, 92-97.<br />
* Michael Striewe, Matthias Kramer and Michael Goedicke: '''Ein Lückentext-Test zur Beherrschung einer Programmiersprache.''' In: ''DeLFI 2017 – Die 15. e-Learning Fachtagung Informatik der Gesellschaft für Informatik'', Volume 273 of Lecture Notes in Informatics, 2017, 261-266. <br />
* Benjamin Otto, Till Massing, Nils Schwinning, Natalie Reckmann, Alexander Blasberg, Sandy Schumann, Christoph Hanck and Michael Goedicke: '''Evaluation einer Statistiklehrveranstaltung mit dem JACK R-Modul.''' In: ''DeLFI 2017 – Die 15. e-Learning Fachtagung Informatik der Gesellschaft für Informatik'', Volume 273 of Lecture Notes in Informatics, 2017, 75-86.<br />
<br />
=== 2016 ===<br />
* Marc Berges, Michael Striewe, Philipp Shah, Michael Goedicke and Peter Hubwieser: '''Towards deriving programming competencies from student errors.''' In: ''2016 International Conference on Learning and Teaching in Computing and Engineering (LaTICE)'', March 2016, 19-23. https://ieeexplore.ieee.org/document/7743146<br />
* Michael Fellmann, Peter Fettke, Constantin Houy, Peter Loos, Andreas Oberweis, Andreas Schoknecht, Michael Striewe, Tom Thaler and Meike Ullrich: '''Evaluation automatisierter Ansätze für die Bewertung von Modellierungsaufgaben.''' In: ''DeLFI 2016 - Die 14. E-Learning Fachtagung Informatik'', Volume 262 of LNI, 2016, 203-214.<br />
* Melanie Schypula, Nils Schwinning, Alina Doekels and Michael Goedicke: '''Beobachtungen zum Abbruchverhalten von Studierenden in einem webbasierten Mathematik-Vorkurs.''' In: ''DeLFI 2016 - Die 14. E-Learning Fachtagung Informatik'', Volume 262 of LNI, 2016, 221-232.<br />
* Michael Striewe: '''An architecture for modular grading and feedback generation for complex exercises.''' ''Science of Computer Programming'', Volume 129, 2016, 35-47. https://www.sciencedirect.com/science/article/pii/S0167642316300260?via%3Dihub<br />
<br />
=== 2015 ===<br />
* Melanie Schypula, Filiz Kurt-Karaoglu, Nils Schwinning, Michael Striewe, Björn Zurmaar and Michael Goedicke: '''Aufwand und Nutzen parametrisierbarer, pfadbasierter Aufgaben.''' In: ''Proceedings of DeLFI 2015: Die 13. e-Learning Fachtagung Informatik'', 2015 .<br />
* Nils Schwinning, Michael Striewe, Marinko Savija and Michael Goedicke: '''On Flexible Multiple Choice Questions with Parameters.''' In: ''Proceedings of the 14th European Conference on e-Learning (ECEL-2015)'', 2015. <br />
* Filiz Kurt-Karaoglu, Nils Schwinning, Michael Striewe, Björn Zurmaar and Michael Goedicke: '''A Framework for Generic Exercises with Mathematical Content.''' In: ''Proceedings of the International Conference on Learning and Teaching in Computing and Engineering (LaTiCE 2015)'', 2015, 70-75. https://ieeexplore.ieee.org/document/7126234<br />
* Michael Striewe, Björn Zurmaar and Michael Goedicke: '''Evolution of the E-Assessment Framework JACK.''' In: ''Gemeinsamer Tagungsband der Workshops der Tagung Software Engineering 2015'', Dresden, Germany, 17.-18. März 2015., 2015, 118-120.<br />
* Tim Kocher, Ulrike Haß, Bernhard Schröder: '''<JACK:lin> - Linguistische Module für das E-Assessment mit JACK.''' In: ''Proceedings of the International Conference of the German Society for Computational Linguistics and Language Technology'', 2015, 170-171. https://konvens.org/proceedings/2015/GSCL-201528.pdf<br />
* Mario D'Amico: '''Konzeption universeller .NET-Prüfkomponenten für das E-Assessment-System JACK.''' In: ''Proceedings of the Second Workshop "Automatische Bewertung von Programmieraufgaben"'', 2015. https://ceur-ws.org/Vol-1496/paper1.pdf<br />
* Enno Lohmann: '''Erweiterung eines E-Assessment-Systems um eine Prüfkomponente für die Programmiersprache Python.''' In: ''Proceedings of the Second Workshop "Automatische Bewertung von Programmieraufgaben"'', 2015. https://ceur-ws.org/Vol-1496/paper2.pdf<br />
<br />
=== 2014 ===<br />
* Nils Schwinning, Melanie Schypula, Michael Striewe and Michael Goedicke: '''Concepts and Realisations of Flexible Exercise Design and Feedback Generation in an e-Assessment System for Mathematics.''' In: ''Joint Proceedings of the MathUI, OpenMath and ThEdu Workshops and Work in Progress track at CICM, co-located with Conferences on Intelligent Computer Mathematics (CICM 2014)'', 2014.<br />
* Filiz Kurt-Karaoglu, Patrick Hintze, Melanie Schypula, Nils Schwinning, Michael Striewe, Björn Zurmaar and Michael Goedicke: '''Begleitende E-Assessments als Unterstützung großer Grundlagenveranstaltungen in der Studieneingangsphase.''' In: ''Grundfragen Multimedialen Lehrens und Lernens 2014'', 2014, 150-163.<br />
* Michael Goedicke, Filiz Kurt-Karaoglu, Nils Schwinning, Melanie Schypula and Michael Striewe. '''Zweiter Jahresbericht zum Projekt "Bildungsgerechtigkeit im Fokus" (Teilprojekt 1.2 - "Blended Learning") an der Fakultät für Wirtschaftswissenschaften.''' Technical report, Universität Duisburg-Essen, 2014.<br />
* Nils Schwinning, C. Neugebauer, K. Winter, S. Krusekamp, Michael Striewe, Filiz Kurt-Karaoglu and Michael Goedicke: '''JACK und MaStEr: Universitätsübergreifende Weiterentwicklung zweier Mathematik-Vorkurs-Konzepte mit computerbasierter Diagnose und Förderung.''' In: ''Tagungsband Hansekolloquium 2014'', 2014.<br />
* Michael Striewe and Michael Goedicke: '''Automated Assessment of UML Activity Diagrams.''' In: ''Proceedings of the 2014 conference on Innovation & technology in computer science education (ITiCSE 2014)'', 2014, 336. http://dx.doi.org/10.1145/2591708.2602657<br />
* Michael Striewe and Michael Goedicke: '''Code reading exercises using run time traces.''' In: ''Proceedings of the 2014 conference on Innovation & technology in computer science education (ITiCSE 2014)'', 2014, 346. http://dx.doi.org/10.1145/2591708.2602658<br />
[[Kategorie:Hauptseiten]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GenerateSimpleSentence&diff=11996GenerateSimpleSentence2024-11-13T11:57:08Z<p>Striewe: </p>
<hr />
<div>=== Zugehörige Evaluatoren ===<br />
* '''MathEvaluator'''<br />
<br />
=== Beschreibung ===<br />
Die Funktion ''generateSimpleSentence'' generiert einen einfachen (englischen) Satz. Dafür benötigt sie vier Parameter. Der erste Parameter ist das Subjekt, der zweite Parameter ist das Verb, der dritte Parameter ist das Objekt und der vierte Parameter gibt die Zeitform des zu generierenden Satzes.<br />
<br />
=== Syntax ===<br />
generateSimpleSentence(String subjekt, String verb, String objekt, String zeit)<br />
<br />
=== Parameter ===<br />
* '''subjekt''' - das Subjekt in Grundform des zu generierenden Satzes<br />
* '''verb''' - das Verb in Grundform des zu generierenden Satzes<br />
* '''objekt''' - das Objekt in Grundform des zu generierenden Satzes<br />
* '''zeit''' - die Zeitform, in die der Satz generiert werden soll<br />
<br />
Subjekt und Objekt werden als Parameter immer im Singular angegeben. Der Generator setzt das Objekt immer automatisch in den Plural.<br />
<br />
Folgende Zeitformen stehen zur Verfügung:<br />
<br />
* Vergangenheit: "past simple", "past progressive", "past perfect", "past perfect progressive"<br />
* Gegenwart: "present simple", "present progressive", "present perfect", "present perfect progressive"<br />
* Zukunft: "future simple", "future progressive", "future perfect", "future perfect progressive"<br />
<br />
=== Return Value ===<br />
* Gibt den generierten Satz als String zurück.<br />
<br />
=== Beispiele ===<br />
==== Standardfälle ====<br />
generateSimpleSentence('woman','eat','orange','present simple') --> returns 'The woman eats oranges.'<br />
<br />
generateSimpleSentence('woman','eat','orange','past simple') --> returns 'The woman ate oranges.'<br />
<br />
==== Benutzung mit Variablen ====<br />
generateSimpleSentence('woman','eat','orange', [var=a])<br />
<br />
generateSimpleSentence([var=b],'eat', [var=c],'present simple')<br />
<br />
==== Benutzung mit studentischer Eingabe ====<br />
'''Jack2:'''<br />
generateSimpleSentence('woman','eat','orange', [pos=1])<br />
<br />
generateSimpleSentence([pos=1],'eat', [var=c],'present simple')<br />
<br />
'''Jack3:'''<br />
generateSimpleSentence('woman','eat','orange', [input=fillin1])<br />
<br />
generateSimpleSentence([input=fillin1],'eat', [var=c],'present simple')<br />
<br />
=== Hinweise ===<br />
* Es werden nur englische Sätze generiert.<br />
* Der Satz wird durch das Generatorsystem SimpleNLG generier, das nur mit Wörtern umgehen kann, die sich in seinem Lexikon befinden.<br />
** Die Funktion [[chooseWordsExistingInLexicon]] kann genutzt werden, um aus einer Liste von Wörtern diejenigen zu erhalten, die SimpleNLG kennt.<br />
* Wenn Variablen genutzt werden muss darauf geachtet werden, dass diese die Voraussetzung erfüllen.<br />
* Wenn die Eingabe der Studierenden genutzt wird muss auch hier darauf geachtet werden, dass die Voraussetzungen erfüllt sind und ob diese an der Stelle genutzt werden können.<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Zeichenkettenfunktionen]][[Kategorie:JACK2]][[Kategorie:JACK3]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Molek%C3%BCl_(JACK3)&diff=11878Molekül (JACK3)2024-10-16T18:23:48Z<p>Striewe: /* Variablen */</p>
<hr />
<div>Der Aufgabentyp "Molekül" ermöglich es Lehrenden nach bestimmten Molekülen, Reaktionsgleichungen oder ähnlichem zu fragen. Die Studierenden müssen dann die passende Struktur mithilfe eines Editors zeichnen. Dieser Aufgabentyp befindet sich derzeit noch im Aufbau, so dass spezielle Features in zukünftigen Versionen erweitert, verändert oder ergänzt werden können.<br />
<br />
Der Aufgabentyp nutzt an verschiedenen Stellen die InChI-Notation (https://de.wikipedia.org/wiki/International_Chemical_Identifier), um Moleküle zu repräsentieren. Die Analyse studentischer Eingaben ist aber nicht auf Informationen beschränkt, die in InChI-Strings abgebildet werden können.<br />
<br />
===Aufgabeninhalt===<br />
In dem Bereich Aufgabeninhalt wird der Aufgabentext erstellt und spezifische Eingaben für den jeweiligen Aufgabenteil gemacht.<br />
* '''Titel:''' Hier kann optional der Name des Aufgabenteils eingetragen werden.<br />
* '''Aufgabentext:''' Im Aufgabentext steht die Aufgabenstellung. Der Editor für den Aufgabetext lässt sich öffnen in dem man reinklickt. In dem Fließtext kann Latex-Code verwendet werden, indem man diesen mit $-Zeichen einspannt. Der Editor bietet einige Formatierungen an wie z.B. fett, kursiv und unterstrichen. Einfache Tabellen können auch mithilfe des Editors erstellt werden. Wenn man den Button ''source code'' [[File:Icon-source_code.jpg|35px]] verwendet kann man HTML-Code nutzen. Über den Button '''Ressource Einfügen''' lässt sich ein hochgeladenes Bild oder ein Link in den Aufgabentext einfügen.<br />
[[File:Molekuel_Aufgabentext.JPG|center|thumb|800px|Aufgabentext für eine Molekül Aufgabe]]<br />
* '''Konfiguration des Editors:''' Hier können verschiedenen Einstellungen vorgenommen werden, mit denen die verfügbaren Funktionen des Molekül-Editors für die studentische Eingabe eingeschränkt werden können. Es besteht jeweils die Möglichkeit, zwischen einer Standardeinstellung und einer individuellen Einstellung pro Aufgabe zu wählen. Admins können zudem alternative Voreinstellungen definieren. Siehe dazu "[[Konfiguration des Kekulé-Editors]]".<br />
** '''Editor auf das Ändern von Farben beschränken:''' Wird hier ein Haken gesetzt, können Lernende im Editor nur noch das Molekül farbig markieren. Zudem wird das Molekül mit einer höheren Strichstärke dargestellt, sodass Markierungen besser ersichtlich sind. Andere Arten der Manipulation sowie auch das Erstellen neuer Moleküle ist dann nicht mehr möglich. Diese Option kann sinnvoll sein, wenn der Student Bereiche im Molekül farblich markieren soll, aber ansonsten keine Änderungen am Molekül vornehmen darf.<br />
* '''Voreingestelltes Molekül im Editor:''' Hier kann eine Vorbelegung für den Editor erstellt werden, die den Studierenden beim Betreten der Aufgabe angezeigt wird. Klicken Sie rechts auf das Stift-Symbol, um einen Moleküleditor zu öffnen und die Vorbelegung zu erstellen oder zu ändern. In der Übersicht wird die Vorbelegung als InChI-String angezeigt. Es bleiben aber auch alle weiteren Bestandteile (z. B. Reaktionspfeile) erhalten, selbst wenn sie nicht im InChI-String abgebildet werden können.<br />
<br />
===Feedback===<br />
Beim Feedback stehen verschiedene Standardoptionen und spezielle Features zur Verfügung.<br />
* '''Gewichtung des Aufgabenteils:''' Gewichtung der Punktzahl eines Aufgabenteils innerhalb der Aufgabe.<br />
* '''Aufgabentext:''' Zur Übersicht und besseren Erstellung des Feedbacks wird der Aufgabentext hier nochmal angezeigt.<br />
* '''Erweiterte Eingabeanalyse:''' Die erweiterte Eingabeanalyse ist derzeit im Aufbau. Es stehen mehrere Funktion zur Verfügung.<br />
** '''Reaktionen in der Eingabe analysieren''': Es wird nach Reaktionspfeilen gesucht und die gefundene Moleküle in Bezug auf diese Reaktionen ausgewertet und zugeordnet. Dadurch entstehen zusätzliche Variablen, die im Folgenden in den Feedback-Regeln genutzt werden können (siehe unten). Das System nutzt zur Erkennung und Zuordnung gewisse Suchbereiche vor und nach sowie über und unter den Reaktionspfeilen.<br />
** '''Annotationen an Molekülen analysieren:'''<br />
** '''Farbige Markierung in Molekülen analysieren:''' Es können Markierungen für das/die Moleküle definiert werden. Die Markierungen bestehen aus einem Namen und der Markierung (Eingabe über den Kekule-Editor). Für die Markierung steht das voreingestellte Molekül zur Verfügung. Pro erstellter Markierung wird eine Variable erzeugt, die im Folgenden in den Feedback-Regeln genutzt werden kann (siehe unten). Das System prüft nicht auf den Farbton, sondern nur ob der Bereich eingefärbt wurde.<br />
* '''Erwartete Lösung:''' Hier wird die Formel der richtigen Lösung eingetragen. Klicken Sie rechts auf das Stift-Symbol, um einen Moleküleditor zu öffnen und die erwartete Lösung zu erstellen oder zu ändern. In der Übersicht wird die erwartete Lösung als InChI-String angezeigt.<br />
[[File:Molekuel_erwarteteEingabe.JPG|center|thumb|800px|Die erwartete Eingabe in InChI-Code]]<br />
* '''Feedback bei korrekter Antwort:''' Der Feedbacktext, der ausgegeben werden soll, wenn die Eingabe der erwarteten Lösung entspricht. Das System prüft dazu, ob die studentische Eingabe genau dieselben InChI-Strings enthält wie die erwartete Lösung. Die Reihenfolge der Eingabe sowie die Position auf der Zeichenfläche wird dabei ignoriert.<br />
* '''Feedback bei falscher Antwort:''' Der Feedbacktext, der ausgegeben wird, wenn die studentische Eingabe nicht der erwarteten Lösung entspricht.<br />
* '''Weitere Feedbacks (optional):''' Analog zum Aufgabentyp [[Fill-In (JACK3)|Fill-In]] können weitere Regeln angegeben werden, die jeweils Feedback auslösen. Anders als bei der erwarteten Lösung steht hier kein Molekül-Editor zur Verfügung. Stattdessen müssen passende [[Evaluator]]-Funktionen genutzt werden, um die studentische Eingabe zu analysieren. Diese steht dazu als Variablen der Form <code>[input=...]</code> zur Verfügung (siehe unten).<br />
* '''Feedback beim Überspringen:''' Der Lehrende kann jeden Fill-In oder Drop-Down Aufgabenteil zum Überspringen anbieten. Dazu muss zunächst der Haken gesetzt werden. Danach gibt es noch die Möglichkeit einen Text den Lernenden anzuzeigen, wenn dieser diesen Aufgabenteil übersprungen hat. Den Text kann man ändern indem man entweder in das Textfeld klickt oder den [[File:Icon-Pencil.jpg|22px]]-Button nutzt.<br />
<br />
{{JACK3:Hinweise}}<br />
<br />
===Verknüpfungen===<br />
* '''Nächster Aufgabenteil (Standard):''' In dem Drop-Down Feld wird der nächste Zustand ausgewählt, in die die Aufgabe sein soll, wenn der Lernende eine Lösung eingereicht hat. Dieses wird immer dann durchgeführt, wenn keine andere Aktion zutrifft. Es gibt die folgenden Möglichkeiten: <br />
** '''Ende der Aufgabe:''' Die Aufgabe ist mit der Aktion des Lernenden beendet.<br />
** '''Aufgabenteil wiederholen:''' Der Aufgabenteil wird wiederholt. Der Lernende kann ein weiteres Ergebnis einreichen. Diese Aktion kann man z.B. bei Übungsaufgaben benutzen, wenn der Lernende eine Aufgabe solange wiederholen soll, bis das richtige Ergebnis eingereicht wurde.<br />
** '''#x (x ist dabei ein beliebiger Aufgabenteil dieser Aufgabe):''' Der entsprechende Aufgabenteil wird als nächstes angezeigt. Wenn man die Aufgabenteilnummer des aktuellen Aufgabenteils wählt wird dieser Aufgabenteil neu aufgerufen.<br />
<br />
* '''Weitere nächste Aufgabenteile (optional):''' Hier kann die nächste Aktion dynamisch eingestellt werden, d.h. sie kann abhängig von der Variablen Konstelation sein oder von der Eingabe des Lernenden.<br />
* '''Nächster Aufgabenteil beim Überspringen (optional):''' Hier wird eingestellt welcher nächste Aufgabenteil angezeigt werden soll, wennn der Lernende den Aufgabenteil übersprungen hat. Diese Einstellungsmöglichkeit steht nur zur Verfügung, wenn der Haken im Tab Feedback fürs Überspringen gesetzt wurde.<br />
<br />
{{JACK3:Variablenupdates}}<br />
<br />
{{JACK3:Dateien für Studierende}}<br />
<br />
===Studentische Eingabe===<br />
Die studentische Eingabe erfolgt über den Molekül-Editor von Kekule, indem man mit einigen Hilfsmitteln die Moleküle zeichnen kann. Die studentische Lösung des oben genannten Beispiels würde dann wie folgt aussehen:<br />
[[File:Molekuel_studentischeEingabe.JPG|center|thumb|800px|Editor zur studentischen Eingabe eine Moleküls]]<br />
<br />
=== Variablen ===<br />
Die folgenden [[Variablen (JACK3)|JACK-Variablen]] stehen speziell im Aufgabentyp "Molekül" für '''jede''' studentische Einreichung zur Verfügung:<br />
{| class="wikitable"<br />
|-<br />
! Name !! Beschreibung<br />
|-<br />
| <code>[input=inchi]</code>|| Enthält eine Liste von Strings, die jeweils einem InChI-String eines eingegebenen Molekül entsprechen.<br />
|-<br />
| <code>[input=inchi_X]</code> (mit X = 1,2,...)|| Enthält jeweils einen InChI-String aus der studentischen Eingabe.<br />
|}<br />
<br />
Die folgenden Variablen stehen '''zusätzlich''' zur Verfügung, wenn die '''erweiterte Eingabeanalyse''' genutzt wurde:<br />
<br />
{| class="wikitable"<br />
|-<br />
! Name !! Beschreibung<br />
|-<br />
| <code>[check=reactions]</code>|| Anzahl der erkannten Reaktionen (entspricht der Anzahl der gefundenen Reaktionspfeile).<br />
|-<br />
| <code>[check=reactionType_X]</code> (mit X = 1,2,...)|| Typ der jeweiligen Reaktion entsprechend des im Editor verwendeten Reaktionspfeils.<br />
|-<br />
| <code>[check=educts_X]</code> (mit X = 1,2,...)|| Liste von Strings, die jeweils einem InChI-String eines Moleküls entsprechen, das als Edukt der jeweiligen Reaktion erkannt wurde.<br />
|-<br />
| <code>[check=products_X]</code> (mit X = 1,2,...)|| Liste von Strings, die jeweils einem InChI-String eines Moleküls entsprechen, das als Produkt der jeweiligen Reaktion erkannt wurde.<br />
|-<br />
| <code>[check=minorEducts_X]</code> (mit X = 1,2,...)|| Liste von Strings, die jeweils einem InChI-String eines Moleküls entsprechen, das als anorganisches Edukt oder sonstige Information oberhalb des Reaktionspfeils (z. B. "Hitze") der jeweiligen Reaktion erkannt wurde.<br />
|-<br />
| <code>[check=minorProducts_X]</code> (mit X = 1,2,...)|| Liste von Strings, die jeweils einem InChI-String eines Moleküls entsprechen, das als anorganisches Produkt oder sonstige Information unterhalb des Reaktionspfeils der jeweiligen Reaktion erkannt wurde.<br />
|-<br />
|<br />
|-<br />
| <code>[check=foundColoring_<NameDerMarkierung>]</code>|| True, wenn die benannte Markierung in der Eingabe enthalten ist. False, wenn die Markierung nicht in der Eingabe enthalten ist.<br />
|-<br />
| <code>[check=foundUnexpectedColoring]</code>|| True, wenn min. 1 Markierung gefunden wurde, die nicht vom Lehrenden im Feedback definiert wurde.<br />
|}<br />
[[category:Benutzerhandbuch]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Nomenklaturen_(JACK3)&diff=11877Nomenklaturen (JACK3)2024-10-16T18:14:34Z<p>Striewe: </p>
<hr />
<div>Für die Abfrage von Fachbegriffen steht der Aufgabentyp "Freitext" zur Verfügung. Bei diesem Aufgabentyp können die Lernenden in einem kurzen Textfeld Text eingeben und dieser wird bei der Abgabe gespeichert. Mit seiner Darstellungsweise und seinen Einstellungen stellt der Aufgabentyp einen Mittelweg aus den Aufgabentypen "[[Freitext (JACK3)|Freitext]]" und "[[Fill-In (JACK3)|Fill-In]]" dar: Das Eingabefeld ist deutlich keiner als bei Freitext und verdeutlicht den Lernenden damit, dass nur eine kurze Eingabe erforderlich ist. Zudem sind die Einstellungsmöglichkeiten für Lehrende begrenzter als bei Fill-In, so dass Aufgaben schneller eingerichtet werde können.<br />
<br />
Dieser Aufgabentyp kann mit manuellem oder regelbasiertem Feedback verwendet werden. Zusätzlich steht derzeit ein spezieller Checker zur Verfügung, der Teile der IUPAC-Nomenklatur der organischen Chemie beherrscht. Weitere Checker sind für die Zukunft geplant.<br />
<br />
===Aufgabeninhalt===<br />
In dem Bereich Aufgabeninhalt wird der Aufgabentext erstellt und spezifische Eingaben für den jeweiligen Aufgabenteil gemacht.<br />
* '''Titel:''' Hier kann optional der Name des Aufgabenteils eingetragen werden.<br />
* '''Aufgabentext:''' Im Aufgabentext steht die Aufgabenstellung. Der Editor für den Aufgabetext lässt sich öffnen, indem man reinklickt. In dem Fließtext kann Latex-Code verwendet werden, indem man diesen mit $-Zeichen einspannt. Der Editor bietet einige Formatierungen an wie z.B. fett, kursiv und unterstrichen. Einfache Tabellen können auch mithilfe des Editors erstellt werden. Wenn man den Button ''source code'' [[File:Icon-source_code.jpg|35px]] verwendet kann man HTML-Code nutzen. Über den Button '''Ressource Einfügen''' lässt sich ein hochgeladenes Bild oder ein Link in den Aufgabentext einfügen.<br />
* '''Musterlösung:''' Die Eingabe einer Musterlösung ist nur erforderlich, wenn der Aufgabentyp mit einem speziellen Checker genutzt werden soll.<br />
<br />
===Feedback===<br />
In dem Tab Feedback können Texte und Evaluierungsregeln für das Feedback definiert werden.<br />
*'''Gewichtung der Stufe:''' Gewichtung der Punktzahl eines Aufgabenteils innerhalb der Aufgabe.<br />
*'''Automatisches Bewertungsmodul:''' Falls ein spezieller Checker genutzt werden soll, kann dieser hier ausgewählt werden. Falls ein Checker ausgewählt wird, wird die Überprüfung durch den Checker immer vor der Auswertung weiterer, optionaler Feedback-Regeln durchgeführt.<br />
** Derzeit steht nur ein Checker zur '''IUPAC'''-Nomenklatur zur Verfügung. Der Checker überprüft, ob die Eingabe mit der Musterlösung übereinstimmt und erzeugt automatisches Feedback, dass den Stamm, die Substituenten, die funktionale Gruppe und die stereochemischen Eigenschaften berücksichtigt.<br />
*'''Weitere Feedbacks (optional):''' Alternativ oder ergänzend zum Einsatz der automatischen Bewertung können an dieser Stelle weitere Feedbacks mit Evaluierungsregeln definiert werden. Weitere Feedbacks können immer über den Button '''Feedback Regel anlegen''' hinzugefügt werden.<br />
**'''Evaluator Regel:''' Hier wird die Evaluator-Regel eingetragen. Wenn diese zutrifft wird das Feedback ausgegeben. Die studentische Eingabe steht in der Variablen <code>[input=studentInput]</code> zur Verfügung. Wenn eine automatisches Bewertungsmodul genutzt wurde, stehen möglicherweise weitere Variablen zur Verfügung (siehe weiter unten unter [[#Variablen|Variablen]]).<br />
**'''Domäne:''' Mit der Angabe der Domäne gibt man an welchen Evaluator man mit der Regel anspricht. Im Moment wird ein Mathe und ein Chemie Evaluator von Jack3 unterstützt.<br />
**'''Punkte:''' Jedes Feedback kann zwischen 0 und 100 Punkten geben. Dabei ist zu beachten, dass mehr als ein Feedback wiedergegeben werden kann. Dabei werden alle Punkte zusammengerechnet. Jack3 deckelt die Punkte auf 100.<br />
**'''Feedback:''' Der Text, der unter Feedback hinterlegt ist, wird dem Lehrenden angezeigt, wenn das Feedback zutrifft.<br />
** '''terminales Feedback:''' Jack3 geht alle Feedbacks unter '''Weitere Feedbacks (optional)''' der Reihe nach durch, d.h. es wird oben in der Liste angefangen, und gibt alle zutreffenden raus. Bei den Feedbacks, die mit Terminal markiert sind wird die Suche abgebrochen, wenn diese zutreffen. Es ist also wichtig darauf zu achten in welcher Reihenfolge die Feedbacks stehen. Es macht also Sinn zunächst die Feedbacks aufzulisten, die mit terminal markiert sind und danach die anderen Feedbacks. Die richtige Lösung wird auch mit terminal markiert und bekommt 100 Punkte.<br />
*'''Überspringen:''' Wie bei allen anderen Aufgabentypen kann auch im Aufgabentyp "Nomenklaturen" das Überspringen angeboten werden. Dazu muss zunächst der Haken gesetzt werden. Danach gibt es noch die Möglichkeit einen Text den Lernenden anzuzeigen, wenn dieser diesen Aufgabenteil übersprungen hat. Den Text kann man entweder durch Klicken in das Textfeld oder über den Icon [[File:Icon-Pencil.jpg|22px]] hinzufügen.<br />
[[File:Ueberspringen.JPG|center|thumb|800px|Feedback beim Überspringen]]<br />
<br />
Statt das automatische Bewertungsmodul oder weitere Feedbacks zu nutzen, kann der Aufgabentyp auch manuell bewertet werden. Wie man [[Manuelles Feedback (JACK3)|manuelles Feedback]] an eine Einreichung setzt wird [[Manuelles Feedback (JACK3)|hier]] beschrieben.<br />
<br />
{{JACK3:Hinweise}}<br />
<br />
===Verknüpfungen===<br />
* '''Nächster Aufgabenteil (Standard):''' In dem Drop-Down Feld wird der nächste Zustand ausgewählt, in die die Aufgabe sein soll, wenn der Lernende eine Lösung eingereicht hat. Dieses wird immer dann durchgeführt, wenn keine andere Aktion zutrifft. Es gibt die folgenden Möglichkeiten: <br />
** '''Ende der Aufgabe:''' Die Aufgabe ist mit der Aktion des Lernenden beendet.<br />
** '''Aufgabenteil wiederholen:''' Der Aufgabenteil wird wiederholt. Der Lernende kann ein weiteres Ergebnis einreichen. Bei diesem Aufgabentyp ist zu beachten, dass im Moment nicht direkt Feedback gegeben wird.<br />
** '''#x (x ist dabei ein beliebiger Aufgabenteil dieser Aufgabe):''' Der entsprechende Aufgabenteil wird als nächstes angezeigt. Wenn man die Aufgabenteilnummer des aktuellen Aufgabenteils wählt wird dieser Aufgabenteil neu aufgerufen.<br />
* '''Weitere nächste Aufgabenteile (optional):''' Hier kann die nächste Aktion dynamisch eingestellt werden, d.h. sie kann abhängig von der Variablen Konstellation sein oder von der Eingabe des Lernenden.<br />
* '''Nächster Aufgabenteil beim Überspringen (optional):''' Hier wird eingestellt welcher nächste Aufgabenteil angezeigt werden soll, wenn der Lernende den Aufgabenteil übersprungen hat. Diese Einstellungsmöglichkeit steht nur zur Verfügung, wenn der Haken im Tab Feedback fürs Überspringen gesetzt wurde.<br />
<br />
{{JACK3:Variablenupdates}}<br />
<br />
{{JACK3:Dateien für Studierende}}<br />
<br />
===Variablen===<br />
Wird für die Bewertung das automatische Bewertungsmodul zur IUPAC-Nomenklatur verwendent, stehen die folgenden [[Variablen (JACK3)|JACK-Variablen]] für die Erstellung von Feedbackregeln zur Verfügung:<br />
<br />
{| class="wikitable"<br />
|-<br />
! Name!! Beschreibung<br />
|-<br />
|<code>[check=mainNameCorrect]</code>||Enthält "true", wenn der Stamm der Eingabe mit der Musterlösung übereinstimmt, sonst "false".<br />
|-<br />
|<code>[check=fctGroupCorrect]</code>||Enthält "true", wenn die funktionale Gruppe der Eingabe mit der Musterlösung übereinstimmt, sonst "false".<br />
|-<br />
|<code>[check=substituentsCorrect]</code>||Enthält "true", wenn die Substituenten der Eingabe in Anzahl, Art und Position mit der Musterlösung übereinstimmen, sonst "false".<br />
|-<br />
|<code>[check=stereodescriptorsCorrect]</code>||Enthält "true", wenn die Stereodeskriptoren der Eingabe in Anzahl und Art mit der Musterlösung übereinstimmen, sonst "false".<br />
|}<br />
<br />
[[category:Benutzerhandbuch]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Benutzerhandbuch_(JACK3)&diff=11870Benutzerhandbuch (JACK3)2024-10-15T09:00:56Z<p>Striewe: /* Aufgaben erstellen / testen */</p>
<hr />
<div>Dies ist das Benutzerhandbuch der neuesten Version JACK3. Hier finden Sie alle wichtigen Information von "Wie erstelle ich eine Aufgabe?" über "Wie lasse ich meine Studierende die Aufgaben bearbeiten?" bis "Wie lässt sich in die studentische Abgaben einsehen?".<br />
Bitte beachten Sie, dass dies noch in Arbeit ist und noch nicht vollständig ist. Es kommen noch weitere Abschnitte hinzu und andere werden noch ausgebaut.<br />
<br />
==Schnelleinstieg==<br />
[[Schnelleinstieg (JACK3)|Hier]] ist eine Anleitung für den Schnelleinstieg in JACK3. Mit dieser Anleitung lässt sich schnell eine Aufgabe erstellen und diese Studierende zur Verfügung stellen. Dabei werden nur die wichtigsten Einstellungen betrachtet. Für weitere Details stehen die folgenden Seiten zur Verfügung.<br />
<br />
Zum schnellen Finden einzelner Seiten kann auch die [[:Category:Benutzerhandbuch|A-Z]] Liste genutzt werden.<br />
<br />
==Allgemeine Informationen und Hinweise zum Start==<br />
Beschreibung der globalen Einstellungen, die ein Nutzer in JACK3 tätigen kann. <br />
Nachdem Aufrufen von JACK3 erscheint zunächst die [[Login (JACK3)|Login]] Seite, auf der man sich in das e-Assessment System JACK3 einloggen können. JACK3 Terminologie kann im [[Glossar (JACK3)|Glossar]] nachgeschlagen werden.<br />
* [[Hauptseite (JACK3)|Hauptseite]] - Erklärung der [[Hauptseite (JACK3)|Hauptseite]], die nach dem Einloggen in das E-Assessment System JACK erscheint.<br />
* [[Mein Account (JACK3)|Mein Account]] - Einstellungsmöglichkeiten des eigenen Benutzerskontos.<br />
* [[Verfügbare Kurse (JACK3)|Verfügbare Kurse]] - Unter [[Verfügbare Kurse (JACK3)|Verfügbare Kurse]] können Lehrende Kursangebote erstellen, die dann von den Studierenden bearbeitet werden. Studierende sehen hier alle [[Kursangebot (Studierendensicht)|Kursangebote]], die sie bearbeiten können.<br />
* [[Meine Teilnahmen (JACK3)|Meine Teilnahmen]] - Hier erscheinen die aktuell laufenden Kurse.<br />
* [[Mein Arbeitsbereich (JACK3)|Mein Arbeitsbereich]] - Kurse und Aufgaben werden in diesem Bereich erstellt.<br />
* [[Spracheinstellung (JACK3)|Spracheinstellung]] - Die Spracheinstellung wirkt sich nur global auf die Seiten aus und nicht auf die Aufgaben selber.<br />
* [[Glossar (JACK3)|Grundlegende Konzepte / Glossar]] - Erklärung der Grundlegenden Konzepte in JACK3, die zum Teil für die Benutzung sehr wichtig sind.<br />
* [[Variablen (JACK3)|Variablen]] - Variablentypen von JACK3 (insb. Aufgaben-Variablen) und die Verwendung<br />
<br />
==Aufgaben erstellen / testen==<br />
In diesem Abschnitt wird alles beschrieben, was sich mit einer einzelnen Aufgabe beschäftigt. Es beginnt mit globalen Einstellungen für eine Aufgabe, die Erstellung der verschiedenen Aufgabentypen, bis zum Testen der erstellten Aufgabe.<br />
* [[Aufgaben Konfiguration (JACK3)|Aufgaben Konfigurationen / Einstellungen]]<br />
** [[Aufgaben Einstellungen (JACK3)|Einstellungen]] - globalen Einstellungen der Aufgabe<br />
** [[Variablenkonfiguration (JACK3)|Variablenkonfiguration]]<br />
** [[JSXGraph (JACK3)|Dynamische, grafische Inhalte]]<br />
** [[Aufgabenteile (JACK3)|Aufgabenteile]] - alle möglichen Aufgabenformate in JACK3 werden hier beschrieben<br />
*** [[Atomorbitale (JACK3)|Atomorbitale]] - Erstellen von Atomorbitalschemas<br />
*** [[Dateiupload (JACK3)|Dateiupload]] - Hochladen von Datei(en)<br />
*** [[Fill-In (JACK3)|Fill-In / Drop-Down/ Molekül]] - Lückentext, Eingabefelder, Drop-Down und Molekül Felder<br />
*** [[Freitext (JACK3)|Freitext]] - Textfeld für die Eingabe von Texten, ohne Checker<br />
*** [[Java (JACK3)|Java]] - Programmieraufgaben in Java<br />
*** [[Molekül (JACK3)|Molekül]]<br />
*** [[Multiple-Choice (JACK3)|Multiple-Choice]] - Multiple-Choice und Single-Choice möglich<br />
*** [[MC-Table (JACK3)|Multiple-Choice Tabelle]]<br />
*** [[Nomenklaturen (JACK3)|Nomenklaturen]] - Abfrage von Fachterminologie mit manueller oder automatischer Überprüfung<br />
*** [[Python (JACK3)|Python]] - Programmieraufgaben in Python<br />
*** [[R (JACK3)|R]]<br />
*** [[UML (JACK3)|UML]]<br />
** [[Grafische Darstellung (JACK3)|Grafische Darstellung der Aufgabenteile]] - Ansicht wie die verschiedenen Aufgabenteile miteinander verbunden sind.<br />
** [[Dateien (JACK3)|Dateien]]<br />
** [[Aufgaben Statistik (JACK3)|Statistik]]<br />
* [[Aufgaben testen (JACK3)|Aufgabe testen]] - Beschreibung wie eine Aufgabe getestet werden kann, bevor sie Studierenden gezeigt wird.<br />
<br />
==Kurse / Kursangebote erstellen==<br />
In diesem Abschnitt werden Kurse und Kursangebote beschrieben. Wichtig hier ist auch das Zusammespiel der beiden.<br />
* [[Kurs Einstellungen (JACK3)|Kurs Einstellungen]] - Im Kurs werden die Aufgaben zusammengestellt.<br />
* [[Kursangebot Einstellungen (JACK3)|Kursangebot Einstellungen]] - Im Kursangebot werden die Sichtbarkeiten eingestellt.<br />
'''Mögliche Szenarien''': Kursangebote können für verschiedene Zwecke eingesetzt werden. Auf den folgenden Seiten werden gängige Einsatzszenarien mit Schritt-für-Schritt-Anleitungen erläutert. Es ist jedoch zu beachten, dass Einstellungen ggf. individuell angepasst und getestet werden müssen<br />
*[[Kursanmeldung (JACK3)|Kursanmeldung]] - Reines Anmeldesystem ohne Aufgaben, z.B. für die Anmeldung zu einer mündlichen Prüfung.<br />
*[[Übungskurs erstellen (JACK3)|Übungskurs]] - Übungsaufgaben, um Inhalte aus der Vorlesung zu üben.<br />
*[[Prüfung erstellen (JACK3)|Prüfung]] - Prüfung oder Klausur mit JACK3 erstellen.<br />
<br />
==Statistiken / Prüfungsergebnisse==<br />
Beschreibung der Einsicht in die Bearbeitungen von den Studierenden.<br />
*[[Einsicht in Ergebnisse in Aufgaben (JACK3)|Ergebnisse ansehen in Aufgaben]]<br />
*[[Manuelles Feedback (JACK3)|Manuelles Feedback]] - An jeder Einreichung einer Aufgabe und einer Kursbearbeitung kann das automatische Feedback von JACK und die vergebene Punktzahl überschrieben werden.<br />
*[[Einsicht in Ergebnisse in Kursangeboten (JACK3)|Ergebnisse ansehen in Kursangeboten]]<br />
<br />
==Anmeldeoptionen / Nutzer Verwaltung / Rechte Konzept==<br />
*[[Kursangebot Einstellungen (JACK3)#Zugangsbeschränkung|Verlinkung von Kursen über den öffentlichen Link]]<br />
* [[LTI Anbindung (JACK3)|Moodle Anbindung]] - Erklärung wie sich ein Kursangebot in JACK3 in einen Moodle Kurs einbinden lässt.<br />
*[[Rechtekonzept (JACK3)|Rechtekonzept]] und [[Rechte bearbeiten (JACK3)|Rechte bearbeiten]] - Erklärung der verschiedenen Rechte in JACK3.<br />
*[[Verwaltung (JACK3)|Verwaltung]] - Verwaltungsmöglichkeiten eines Admins.<br />
<br />
==Import / Export==<br />
*[[Inhalte exportieren (JACK3)|Inhalte exportieren]] - Es können nur Inhalte von [[Mein Arbeitsbereich (JACK3)|Mein Arbeitsbereich]] heruntergeladen werden.<br />
*[[Aufgaben aus Jack2 importieren (JACK3)|Aufgaben aus JACK2 importieren]]<br />
**[[Evaluator-Änderungen von JACK2 nach JACK3]]<br />
*[[Inhalte importieren (JACK3)|Inhalte importieren]]<br />
[[Kategorie:JACK3]]<br />
[[Kategorie:Benutzerhandbuch]]<br />
[[Kategorie:Hauptseiten]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Nomenklaturen_(JACK3)&diff=11868Nomenklaturen (JACK3)2024-10-12T17:45:34Z<p>Striewe: Die Seite wurde neu angelegt: „Für die Abfrage von Fachbegriffen steht der Aufgabentyp "Freitext" zur Verfügung. Bei diesem Aufgabentyp können die Lernenden in einem kurzen Textfeld Text eingeben und dieser wird bei der Abgabe gespeichert. Mit seiner Darstellungsweise und seinen Einstellungen stellt der Aufgabentyp einen Mittelweg aus den Aufgabentypen "Freitext" und "Fill-In" dar: Das Eingabefeld ist deutlich keiner als bei Freitext und verd…“</p>
<hr />
<div>Für die Abfrage von Fachbegriffen steht der Aufgabentyp "Freitext" zur Verfügung. Bei diesem Aufgabentyp können die Lernenden in einem kurzen Textfeld Text eingeben und dieser wird bei der Abgabe gespeichert. Mit seiner Darstellungsweise und seinen Einstellungen stellt der Aufgabentyp einen Mittelweg aus den Aufgabentypen "[[Freitext (JACK3)|Freitext]]" und "[[Fill-In (JACK3)|Fill-In]]" dar: Das Eingabefeld ist deutlich keiner als bei Freitext und verdeutlicht den Lernenden damit, dass nur eine kurze Eingabe erforderlich ist. Zudem sind die Einstellungsmöglichkeiten für Lehrende begrenzter als bei Fill-In, so dass Aufgaben schneller eingerichtet werde können.<br />
<br />
Dieser Aufgabentyp kann mit manuellem oder regelbasiertem Feedback verwendet werden. Zusätzlich steht derzeit ein spezieller Checker zur Verfügung, der Teile der IUPAC-Nomenklatur der organischen Chemie beherrscht. Weitere Checker sind für die Zukunft geplant.<br />
<br />
===Aufgabeninhalt===<br />
In dem Bereich Aufgabeninhalt wird der Aufgabentext erstellt und spezifische Eingaben für den jeweiligen Aufgabenteil gemacht.<br />
* '''Titel:''' Hier kann optional der Name des Aufgabenteils eingetragen werden.<br />
* '''Aufgabentext:''' Im Aufgabentext steht die Aufgabenstellung. Der Editor für den Aufgabetext lässt sich öffnen, indem man reinklickt. In dem Fließtext kann Latex-Code verwendet werden, indem man diesen mit $-Zeichen einspannt. Der Editor bietet einige Formatierungen an wie z.B. fett, kursiv und unterstrichen. Einfache Tabellen können auch mithilfe des Editors erstellt werden. Wenn man den Button ''source code'' [[File:Icon-source_code.jpg|35px]] verwendet kann man HTML-Code nutzen. Über den Button '''Ressource Einfügen''' lässt sich ein hochgeladenes Bild oder ein Link in den Aufgabentext einfügen.<br />
* '''Musterlösung:''' Die Eingabe einer Musterlösung ist nur erforderlich, wenn der Aufgabentyp mit einem speziellen Checker genutzt werden soll.<br />
<br />
===Feedback===<br />
In dem Tab Feedback können Texte und Evaluierungsregeln für das Feedback definiert werden.<br />
*'''Gewichtung der Stufe:''' Gewichtung der Punktzahl eines Aufgabenteils innerhalb der Aufgabe.<br />
*'''Automatisches Bewertungsmodul:''' Falls ein spezieller Checker genutzt werden soll, kann dieser hier ausgewählt werden. Falls ein Checker ausgewählt wird, wird die Überprüfung durch den Checker immer vor der Auswertung weiterer, optionaler Feedback-Regeln durchgeführt.<br />
** Derzeit steht nur ein Checker zur '''IUPAC'''-Nomenklatur zur Verfügung. Der Checker überprüft, ob die Eingabe mit der Musterlösung übereinstimmt und erzeugt automatisches Feedback, dass den Stamm, die Substituenten, die funktionale Gruppe und die stereochemischen Eigenschaften berücksichtigt.<br />
*'''Weitere Feedbacks (optional):''' Alternativ oder ergänzend zum Einsatz der automatischen Bewertung können an dieser Stelle weitere Feedbacks mit Evaluierungsregeln definiert werden. Weitere Feedbacks können immer über den Button '''Feedback Regel anlegen''' hinzugefügt werden.<br />
**'''Evaluator Regel:''' Hier wird die Evaluator-Regel eingetragen. Wenn diese zutrifft wird das Feedback ausgegeben. Die die studentische Eingabe steht in der Variablen <code>[input=studentInput]</code> zur Verfügung.<br />
**'''Domäne:''' Mit der Angabe der Domäne gibt man an welchen Evaluator man mit der Regel anspricht. Im Moment wird ein Mathe und ein Chemie Evaluator von Jack3 unterstützt.<br />
**'''Punkte:''' Jedes Feedback kann zwischen 0 und 100 Punkten geben. Dabei ist zu beachten, dass mehr als ein Feedback wiedergegeben werden kann. Dabei werden alle Punkte zusammengerechnet. Jack3 deckelt die Punkte auf 100.<br />
**'''Feedback:''' Der Text, der unter Feedback hinterlegt ist, wird dem Lehrenden angezeigt, wenn das Feedback zutrifft.<br />
** '''terminales Feedback:''' Jack3 geht alle Feedbacks unter '''Weitere Feedbacks (optional)''' der Reihe nach durch, d.h. es wird oben in der Liste angefangen, und gibt alle zutreffenden raus. Bei den Feedbacks, die mit Terminal markiert sind wird die Suche abgebrochen, wenn diese zutreffen. Es ist also wichtig darauf zu achten in welcher Reihenfolge die Feedbacks stehen. Es macht also Sinn zunächst die Feedbacks aufzulisten, die mit terminal markiert sind und danach die anderen Feedbacks. Die richtige Lösung wird auch mit terminal markiert und bekommt 100 Punkte.<br />
*'''Überspringen:''' Wie bei allen anderen Aufgabentypen kann auch im Aufgabentyp "Nomenklaturen" das Überspringen angeboten werden. Dazu muss zunächst der Haken gesetzt werden. Danach gibt es noch die Möglichkeit einen Text den Lernenden anzuzeigen, wenn dieser diesen Aufgabenteil übersprungen hat. Den Text kann man entweder durch Klicken in das Textfeld oder über den Icon [[File:Icon-Pencil.jpg|22px]] hinzufügen.<br />
[[File:Ueberspringen.JPG|center|thumb|800px|Feedback beim Überspringen]]<br />
<br />
Statt das automatische Bewertungsmodul oder weitere Feedbacks zu nutzen, kann der Aufgabentyp auch manuell bewertet werden. Wie man [[Manuelles Feedback (JACK3)|manuelles Feedback]] an eine Einreichung setzt wird [[Manuelles Feedback (JACK3)|hier]] beschrieben.<br />
<br />
{{JACK3:Hinweise}}<br />
<br />
===Verknüpfungen===<br />
* '''Nächster Aufgabenteil (Standard):''' In dem Drop-Down Feld wird der nächste Zustand ausgewählt, in die die Aufgabe sein soll, wenn der Lernende eine Lösung eingereicht hat. Dieses wird immer dann durchgeführt, wenn keine andere Aktion zutrifft. Es gibt die folgenden Möglichkeiten: <br />
** '''Ende der Aufgabe:''' Die Aufgabe ist mit der Aktion des Lernenden beendet.<br />
** '''Aufgabenteil wiederholen:''' Der Aufgabenteil wird wiederholt. Der Lernende kann ein weiteres Ergebnis einreichen. Bei diesem Aufgabentyp ist zu beachten, dass im Moment nicht direkt Feedback gegeben wird.<br />
** '''#x (x ist dabei ein beliebiger Aufgabenteil dieser Aufgabe):''' Der entsprechende Aufgabenteil wird als nächstes angezeigt. Wenn man die Aufgabenteilnummer des aktuellen Aufgabenteils wählt wird dieser Aufgabenteil neu aufgerufen.<br />
* '''Weitere nächste Aufgabenteile (optional):''' Hier kann die nächste Aktion dynamisch eingestellt werden, d.h. sie kann abhängig von der Variablen Konstellation sein oder von der Eingabe des Lernenden.<br />
* '''Nächster Aufgabenteil beim Überspringen (optional):''' Hier wird eingestellt welcher nächste Aufgabenteil angezeigt werden soll, wenn der Lernende den Aufgabenteil übersprungen hat. Diese Einstellungsmöglichkeit steht nur zur Verfügung, wenn der Haken im Tab Feedback fürs Überspringen gesetzt wurde.<br />
<br />
{{JACK3:Variablenupdates}}<br />
<br />
{{JACK3:Dateien für Studierende}}<br />
<br />
[[category:Benutzerhandbuch]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQL_Regeln&diff=11685GReQL Regeln2024-08-26T18:10:16Z<p>Striewe: /* Codestil */</p>
<hr />
<div>== Beispiele für statische Prüfregeln für Java-Code ==<br />
=== Codestil ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{MethodDeclaration}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
not x.constructor<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Methodennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Methodennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{TypeDeclaration}<br />
with<br />
not (x.name=capitalizeFirst(x.name))<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Klassennamen, die nicht mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach klein geschriebenen Klassennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{VariableDeclarationFragment}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
isEmpty(from m : V{Modifier} with x &lt;--&amp;{FieldDeclaration} --> m and m.name="final" report m end)<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Variablennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Variablennamen, wobei als "final" deklarierte Klassenvariablen ausgelassen werden.<br />
<br />
=== Einfache Inhalte ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
s.content = "\"Zeichenkette\""<br />
report 0 end<br />
</query><br />
<feedback>Deine Lösung verwendet nicht den String "Zeichenkette".</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal mit einem vorgegebenen Inhalt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
stringLength(s.content) > 4<br />
report s.line as "line" end<br />
</query><br />
<feedback>Du verwendest in Zeile {line} ein festes String-Literal. Ist deine Lösung allgemeingültig?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal der Länge 4 oder länger (inklusive Anführungszeichen) und meldet es mit Angabe der Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from p : V{PackageDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Paketdefinition">Deine Lösung beinhaltet eine package-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Paketdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query> from p : V{ImportDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Importdefinition"> Deine Lösung beinhaltet eine import-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Importdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from u : V{CompilationUnit}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
x.name="exit" and<br />
y.name="System"<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>Der Aufruf von "System.exit()" in der Datei {name} in Zeile {line} ist nicht gestattet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.exit()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x : V{MethodInvocation}, y, z : V{SimpleName}<br />
with<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameName} y and<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameQualifier} z and<br />
(x.name="print" or x.name="println") and<br />
y.name="out" and z.name="System"<br />
report x.line as "line" end<br />
</query><br />
<feedback>You have a print statement in line {line}. Are you sure you want to print to console instead of returning?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.out.print()</code> oder <code>System.out.println()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
=== Kontrollstrukturen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m.name="m" and<br />
isEmpty(m -->{Child}*&amp;{WhileStatement}) and<br />
isEmpty(m -->{Child}*&amp;{DoStatement}) and<br />
isEmpty(m -->{Child}*&amp;{ForStatement}) and<br />
isEmpty(m -->{Child}*&amp;{EnhancedForStatement})<br />
report 0 end<br />
</query><br />
<feedback>In der Methode "m()" wird kein Schleifenkonstrukt verwendet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> ein beliebiges Schleifenkonstrukt enthält.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
( not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block} -->{Child}))<br />
) and<br />
( not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block} -->{Child}))<br />
)<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} enthält das if-Statement in Zeile {line} in beiden Zweigen keinen Code und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die nur leere Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) and<br />
isEmpty(x -->{IfStatementElseStatement}&amp;{Statement})<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} endet das if-Statement in Zeile {line} hinter der Bedingung sofort mit einem Semikolon. Die Bedingung ist dadurch wirkungslos und die folgende Anweisung wird immer ausgeführt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die keine Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{WhileStatement}<br />
with<br />
not isEmpty(u -->* x -->{WhileStatementBody}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block}) and<br />
isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block} -->{Child}))<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} besteht die while-Schleife in Zeile {line} nur aus einer Abbruchbedingung und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer while-Schleife, die nur aus einer Abbruchbedingung besteht und meldet eine solche Schleife als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from m : V{MethodDeclaration}, n : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration})* n and<br />
n -->{Child}*&amp;{MethodInvocation} -->{Access} m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck"> Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet. Dabei ist es egal, ob sich die Methode direkt selber aufruft, oder über einen oder mehrere Zwischenschritte aufgerufen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration}) m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck">Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet und sich insbesondere ohne Zwischenschritte über andere Methoden selber wieder aufruft.<br />
<br />
=== Methoden ===<br />
<syntaxhighlight lang="xml" line="1"><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "public static String method(int)")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "public static String method(int param)" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, wobei der Name des Methodenparameters unerheblich ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "int method()") and<br />
isEmpty(m -->{Child}&amp;{Modifier})<br />
report 0 end<br />
</query><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, mo : V{Modifier}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "int method()") and<br />
m --> mo and not (mo.name="private")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "int method()" in der Klasse "A" fehlt oder ist mit dem Modifier "private" versehen. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, die nicht mit dem Modifier private versehen ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
m.name="m" and<br />
m -->{MethodDeclarationReturnType} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Signatur">Der Methode "public B&lt;C&gt; m()" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode m mit parametrisierten Rückgabetyp B<C> enthält.<br />
<br />
=== Vererbungshierarchie ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
st.name="B" and<br />
t -->{TypeDeclarationSuperclassType} st<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A ist nicht als Unterklasse von B modelliert.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A direkte Unterklasse von Klasse B ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes} st and<br />
st.name="B"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B&lt;C&gt;.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B<C> implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="3"><br />
<query>from u : V{TypeDeclaration}, s : V{SimpleType}<br />
with<br />
((u -->{TypeDeclarationSuperclassType} s and s.name="Thread") or<br />
(u -->{TypeDeclarationSuperInterfaceTypes} s and s.name="Runnable")) and<br />
u.name="A"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte entweder das Interface "Runnable" implementieren oder von "Thread" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface Runnable implementiert oder von Thread erbt.<br />
<br />
=== Aufrufbeziehungen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "B.m()" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode B.m aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}, z : V{VariableDeclarationStatement}, f : V{VariableDeclarationFragment}, t : V{SimpleType}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u -->* z -->{VariableDeclarationStatementType} t and<br />
u -->* z -->{VariableDeclarationStatementFragments} f and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name=f.name and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "m()" auf einem Objekt vom Typ "B" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A Methode m auf einem Objekt vom Typ B aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from u : V{TypeDeclaration}, m : V{MethodDeclaration}, x : V{ClassInstanceCreation}, t : V{SimpleType}<br />
with<br />
u -->{Child}* m -->* x -->{ClassInstanceCreationType} t and<br />
u.name="A" and<br />
m.name="m" and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" muss in Methode m() mindestens eine Instanz von "B" erzeugt werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A in Methode m eine Instanz von Klasse B erstellt.<br />
<br />
== Beispiele für statische Prüfregeln für UML-Modelle im XMI2-Format ==<br />
=== Klassendiagramme ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback prefix="Hinweis">Im Diagramm sind die "B" eines "A" als eigene Klasse abgebildet. Das kannst du durch eine bessere Modellierung vermeiden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft ebenfalls, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind, definiert dies aber als unerwünschte Situation mit entsprechendem Feedback.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}, z: V{Property}<br />
with<br />
x --> z and<br />
z --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B" and<br />
isDefined(z.lower) and z.lower="1" and (not isDefined(z.upper) or z.upper="1")<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" mit der Kardinalität 1 oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation mit Kardinalität 1 (jedes A kennt genau ein B) verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b : V{Class}, p: V{Property}<br />
with<br />
isEmpty(a -->&amp;{Property} -->&amp;{Association}) and<br />
b --> p and<br />
isDefined(p.aggregation) and p.aggregation="composite"<br />
report 1 end<br />
</query><br />
<feedback>Es sollte im Diagramm zwei Klassen geben, bei denen die eine keine weiteren Bestandteile hat, während die andere weitere Bestandteile gemäß der Komposition hat.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse ohne ausgehende Assoziationen gibt und eine weitere, die mindestens eine ausgehende Komposition hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Property}, z : V{PrimitiveType}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and y.name="b" and<br />
y --> z and<br />
isDefined(z.name) and z.name="String"<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll ein Attribut für die Eigenschaft "b" bereitstellen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse "A" mit dem Attribut "b" vom Typ "String" gibt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Operation}, z: V{Parameter}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and stringLevenshteinDistance(y.name, "ausführen")&lt;3 and<br />
y --> z<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll eine Methode bereitstellen, mit der sie etwas ausführen kann.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel prüft, ob es im Modell eine Klasse "A" mit einer Operation gibt, deren Name "ausführen" oder ähnlich lautet.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>let c := count(from y : V{Operation} with isDefined(y.name) report y end) in<br />
from x : set(1)<br />
with<br />
c&lt;>7<br />
report c as "count" end<br />
</query><br />
<feedback>Das Diagramm sollte genau 7 Methoden enthalten, enthält aber {count}.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell genau 7 Methoden enthält und gibt im Falle einer anderen Anzahl diese im Feedback mit aus.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x.isAbstract and<br />
not isEmpty(x &lt;--&amp;{Generalization})<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte eine abstrakte Klasse "A" enthalten, von der mindestens eine Klasse erbt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine abstrakte Klasse "A" enthält, auf die in mindestens einer Generalisierung verwiesen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b,c,d : V{Class}<br />
with<br />
isDefined(a.name) and a.name="A" and<br />
isDefined(b.name) and b.name="B" and<br />
isDefined(c.name) and c.name="C" and<br />
isDefined(d.name) and d.name="D" and<br />
a --> V{Generalization} --> d and<br />
b --> V{Generalization} --> d and<br />
c --> V{Generalization} --> d<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte Klassen "A", "B" und "C" enthalten, die von einer gemeinsamen Oberklasse "D" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine Klasse "D" enthält, die drei direkte Unterklassen "A", "B" und "C" hat.<br />
<br />
== Beispiele für statische Prüfregeln für EPML ==<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x: V{Event}<br />
with<br />
isEmpty(x &lt;--)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt kein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph kein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="5"><br />
<query> from x,y: V{Event}<br />
with<br />
isEmpty(x &lt;--) and<br />
isEmpty(y &lt;--) and<br />
not (x=y)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt mehr als ein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph mehr als ein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="3"><br />
<query> from x,y: V{Element, ^Connector}<br />
with<br />
not (x.name="") and<br />
x.name = y.name and<br />
not (x = y)<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Es gibt mindestens zwei Elemente mit demselben Namen ("{name}").</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob es der Graph Elemente mit demselben Namen besitzt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Element, ^Connector}, y1, y2 : V{Element}<br />
with<br />
x --> y1 and<br />
x --> y2 and<br />
not (y1=y2)<br />
report x.name as "xName", x.id as "xID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Das Element "{xName}" (ID {xID}) hat mehr als einen Ausgang.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob ein Event oder Funktion mehr als einen Ausgang hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Connector}, y: V{Connector}<br />
with<br />
not (x.name="") and<br />
not (y.name="") and<br />
x --> y<br />
report x.name as "xName", y.name as "yName", x.id as "xID", y.id as "yID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Es dürfen keine zwei Konnektoren direkt aufeinander folgen. Es folgt jedoch "{yName}" (ID {yID}) direkt auf "{xName}" (ID {xID}).</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob 2 Konnektoren aufeinander folgen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x: V{Element, ^Connector}<br />
with<br />
contains(x.name, " and ") or<br />
contains(x.name, "+") or<br />
contains(x.name, " und ")<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Der Name "{name}" sieht danach aus, als wenn hier zwei Events bzw. Funktionen in einem Element zusammengefasst wurden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob der Graph möglicherweise Zeichen bzw. Wörter besitzt die mehrere Funktionen/Events in einem Element verbinden.<br />
<br />
[[Category:R-GReQL]][[category:Benutzerhandbuch]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQL_Regeln&diff=10062GReQL Regeln2024-03-21T10:15:02Z<p>Striewe: /* Klassendiagramme */</p>
<hr />
<div>== Beispiele für statische Prüfregeln für Java-Code ==<br />
=== Codestil ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{MethodDeclaration}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
x.constructor="false"<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Methodennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Methodennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{TypeDeclaration}<br />
with<br />
not (x.name=capitalizeFirst(x.name))<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Klassennamen, die nicht mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach klein geschriebenen Klassennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{VariableDeclarationFragment}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
isEmpty(from m : V{Modifier} with x &lt;--&amp;{FieldDeclaration} --> m and m.name="final" report m end)<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Variablennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Variablennamen, wobei als "final" deklarierte Klassenvariablen ausgelassen werden.<br />
<br />
=== Einfache Inhalte ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
s.content = "\"Zeichenkette\""<br />
report 0 end<br />
</query><br />
<feedback>Deine Lösung verwendet nicht den String "Zeichenkette".</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal mit einem vorgegebenen Inhalt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
stringLength(s.content) > 4<br />
report s.line as "line" end<br />
</query><br />
<feedback>Du verwendest in Zeile {line} ein festes String-Literal. Ist deine Lösung allgemeingültig?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal der Länge 4 oder länger (inklusive Anführungszeichen) und meldet es mit Angabe der Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from p : V{PackageDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Paketdefinition">Deine Lösung beinhaltet eine package-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Paketdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query> from p : V{ImportDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Importdefinition"> Deine Lösung beinhaltet eine import-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Importdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from u : V{CompilationUnit}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
x.name="exit" and<br />
y.name="System"<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>Der Aufruf von "System.exit()" in der Datei {name} in Zeile {line} ist nicht gestattet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.exit()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x : V{MethodInvocation}, y, z : V{SimpleName}<br />
with<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameName} y and<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameQualifier} z and<br />
(x.name="print" or x.name="println") and<br />
y.name="out" and z.name="System"<br />
report x.line as "line" end<br />
</query><br />
<feedback>You have a print statement in line {line}. Are you sure you want to print to console instead of returning?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.out.print()</code> oder <code>System.out.println()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
=== Kontrollstrukturen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m.name="m" and<br />
isEmpty(m -->{Child}*&amp;{WhileStatement}) and<br />
isEmpty(m -->{Child}*&amp;{DoStatement}) and<br />
isEmpty(m -->{Child}*&amp;{ForStatement}) and<br />
isEmpty(m -->{Child}*&amp;{EnhancedForStatement})<br />
report 0 end<br />
</query><br />
<feedback>In der Methode "m()" wird kein Schleifenkonstrukt verwendet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> ein beliebiges Schleifenkonstrukt enthält.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
( not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block} -->{Child}))<br />
) and<br />
( not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block} -->{Child}))<br />
)<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} enthält das if-Statement in Zeile {line} in beiden Zweigen keinen Code und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die nur leere Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) and<br />
isEmpty(x -->{IfStatementElseStatement}&amp;{Statement})<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} endet das if-Statement in Zeile {line} hinter der Bedingung sofort mit einem Semikolon. Die Bedingung ist dadurch wirkungslos und die folgende Anweisung wird immer ausgeführt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die keine Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{WhileStatement}<br />
with<br />
not isEmpty(u -->* x -->{WhileStatementBody}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block}) and<br />
isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block} -->{Child}))<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} besteht die while-Schleife in Zeile {line} nur aus einer Abbruchbedingung und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer while-Schleife, die nur aus einer Abbruchbedingung besteht und meldet eine solche Schleife als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from m : V{MethodDeclaration}, n : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration})* n and<br />
n -->{Child}*&amp;{MethodInvocation} -->{Access} m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck"> Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet. Dabei ist es egal, ob sich die Methode direkt selber aufruft, oder über einen oder mehrere Zwischenschritte aufgerufen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration}) m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck">Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet und sich insbesondere ohne Zwischenschritte über andere Methoden selber wieder aufruft.<br />
<br />
=== Methoden ===<br />
<syntaxhighlight lang="xml" line="1"><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "public static String method(int)")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "public static String method(int param)" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, wobei der Name des Methodenparameters unerheblich ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "int method()") and<br />
isEmpty(m -->{Child}&amp;{Modifier})<br />
report 0 end<br />
</query><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, mo : V{Modifier}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
hasSignature(m, "int method()") and<br />
m --> mo and not (mo.name="private")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "int method()" in der Klasse "A" fehlt oder ist mit dem Modifier "private" versehen. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, die nicht mit dem Modifier private versehen ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations1} m and<br />
m.name="m" and<br />
m -->{MethodDeclarationReturnType} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Signatur">Der Methode "public B&lt;C&gt; m()" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode m mit parametrisierten Rückgabetyp B<C> enthält.<br />
<br />
=== Vererbungshierarchie ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
st.name="B" and<br />
t -->{TypeDeclarationSuperclassType} st<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A ist nicht als Unterklasse von B modelliert.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A direkte Unterklasse von Klasse B ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes} st and<br />
st.name="B"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B&lt;C&gt;.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B<C> implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="3"><br />
<query>from u : V{TypeDeclaration}, s : V{SimpleType}<br />
with<br />
((u -->{TypeDeclarationSuperclassType} s and s.name="Thread") or<br />
(u -->{TypeDeclarationSuperInterfaceTypes} s and s.name="Runnable")) and<br />
u.name="A"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte entweder das Interface "Runnable" implementieren oder von "Thread" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface Runnable implementiert oder von Thread erbt.<br />
<br />
=== Aufrufbeziehungen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "B.m()" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode B.m aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}, z : V{VariableDeclarationStatement}, f : V{VariableDeclarationFragment}, t : V{SimpleType}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u -->* z -->{VariableDeclarationStatementType} t and<br />
u -->* z -->{VariableDeclarationStatementFragments} f and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name=f.name and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "m()" auf einem Objekt vom Typ "B" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A Methode m auf einem Objekt vom Typ B aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from u : V{TypeDeclaration}, m : V{MethodDeclaration}, x : V{ClassInstanceCreation}, t : V{SimpleType}<br />
with<br />
u -->{Child}* m -->* x -->{ClassInstanceCreationType} t and<br />
u.name="A" and<br />
m.name="m" and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" muss in Methode m() mindestens eine Instanz von "B" erzeugt werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A in Methode m eine Instanz von Klasse B erstellt.<br />
<br />
== Beispiele für statische Prüfregeln für UML-Modelle im XMI2-Format ==<br />
=== Klassendiagramme ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback prefix="Hinweis">Im Diagramm sind die "B" eines "A" als eigene Klasse abgebildet. Das kannst du durch eine bessere Modellierung vermeiden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft ebenfalls, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind, definiert dies aber als unerwünschte Situation mit entsprechendem Feedback.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}, z: V{Property}<br />
with<br />
x --> z and<br />
z --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B" and<br />
isDefined(z.lower) and z.lower="1" and (not isDefined(z.upper) or z.upper="1")<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" mit der Kardinalität 1 oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation mit Kardinalität 1 (jedes A kennt genau ein B) verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b : V{Class}, p: V{Property}<br />
with<br />
isEmpty(a -->&amp;{Property} -->&amp;{Association}) and<br />
b --> p and<br />
isDefined(p.aggregation) and p.aggregation="composite"<br />
report 1 end<br />
</query><br />
<feedback>Es sollte im Diagramm zwei Klassen geben, bei denen die eine keine weiteren Bestandteile hat, während die andere weitere Bestandteile gemäß der Komposition hat.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse ohne ausgehende Assoziationen gibt und eine weitere, die mindestens eine ausgehende Komposition hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Property}, z : V{PrimitiveType}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and y.name="b" and<br />
y --> z and<br />
isDefined(z.name) and z.name="String"<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll ein Attribut für die Eigenschaft "b" bereitstellen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse "A" mit dem Attribut "b" vom Typ "String" gibt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Operation}, z: V{Parameter}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and stringLevenshteinDistance(y.name, "ausführen")&lt;3 and<br />
y --> z<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll eine Methode bereitstellen, mit der sie etwas ausführen kann.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel prüft, ob es im Modell eine Klasse "A" mit einer Operation gibt, deren Name "ausführen" oder ähnlich lautet.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>let c := count(from y : V{Operation} with isDefined(y.name) report y end) in<br />
from x : set(1)<br />
with<br />
c&lt;>7<br />
report c as "count" end<br />
</query><br />
<feedback>Das Diagramm sollte genau 7 Methoden enthalten, enthält aber {count}.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell genau 7 Methoden enthält und gibt im Falle einer anderen Anzahl diese im Feedback mit aus.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x.isAbstract and<br />
not isEmpty(x &lt;--&amp;{Generalization})<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte eine abstrakte Klasse "A" enthalten, von der mindestens eine Klasse erbt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine abstrakte Klasse "A" enthält, auf die in mindestens einer Generalisierung verwiesen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b,c,d : V{Class}<br />
with<br />
isDefined(a.name) and a.name="A" and<br />
isDefined(b.name) and b.name="B" and<br />
isDefined(c.name) and c.name="C" and<br />
isDefined(d.name) and d.name="D" and<br />
a --> V{Generalization} --> d and<br />
b --> V{Generalization} --> d and<br />
c --> V{Generalization} --> d<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte Klassen "A", "B" und "C" enthalten, die von einer gemeinsamen Oberklasse "D" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine Klasse "D" enthält, die drei direkte Unterklassen "A", "B" und "C" hat.<br />
<br />
== Beispiele für statische Prüfregeln für EPML ==<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x: V{Event}<br />
with<br />
isEmpty(x &lt;--)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt kein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph kein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="5"><br />
<query> from x,y: V{Event}<br />
with<br />
isEmpty(x &lt;--) and<br />
isEmpty(y &lt;--) and<br />
not (x=y)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt mehr als ein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph mehr als ein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="3"><br />
<query> from x,y: V{Element, ^Connector}<br />
with<br />
not (x.name="") and<br />
x.name = y.name and<br />
not (x = y)<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Es gibt mindestens zwei Elemente mit demselben Namen ("{name}").</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob es der Graph Elemente mit demselben Namen besitzt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Element, ^Connector}, y1, y2 : V{Element}<br />
with<br />
x --> y1 and<br />
x --> y2 and<br />
not (y1=y2)<br />
report x.name as "xName", x.id as "xID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Das Element "{xName}" (ID {xID}) hat mehr als einen Ausgang.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob ein Event oder Funktion mehr als einen Ausgang hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Connector}, y: V{Connector}<br />
with<br />
not (x.name="") and<br />
not (y.name="") and<br />
x --> y<br />
report x.name as "xName", y.name as "yName", x.id as "xID", y.id as "yID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Es dürfen keine zwei Konnektoren direkt aufeinander folgen. Es folgt jedoch "{yName}" (ID {yID}) direkt auf "{xName}" (ID {xID}).</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob 2 Konnektoren aufeinander folgen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x: V{Element, ^Connector}<br />
with<br />
contains(x.name, " and ") or<br />
contains(x.name, "+") or<br />
contains(x.name, " und ")<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Der Name "{name}" sieht danach aus, als wenn hier zwei Events bzw. Funktionen in einem Element zusammengefasst wurden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob der Graph möglicherweise Zeichen bzw. Wörter besitzt die mehrere Funktionen/Events in einem Element verbinden.<br />
<br />
[[Category:R-GReQL]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=True&diff=10061True2024-03-13T12:11:06Z<p>Striewe: </p>
<hr />
<div>{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion im JACK3 System.}}<br />
== Zugehörige Evaluatoren ==<br />
* '''ChemEvaluator'''<br />
* '''MathEvaluator'''<br />
<br />
=== Beschreibung ===<br />
''true'' gibt den Boolschen Wahrheitswert ''True'' bzw. ''Wahr'' zurück.<br />
<br />
=== Syntax ===<br />
true()<br />
<br />
=== Return Value ===<br />
* Gibt ein [[Objekt]] zurück.<br />
<br />
=== Beispiele ===<br />
true() --> True<br />
<br />
true() || false() --> True<br />
<br />
=== Hinweise ===<br />
* Als Gegenstück gibt die Funktion [[false|false()]] ''False'' zurück.<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Kategorie:JACK3]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=False&diff=10060False2024-03-13T12:11:04Z<p>Striewe: </p>
<hr />
<div>{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion im JACK3 System.}}<br />
== Zugehörige Evaluatoren ==<br />
* '''ChemEvaluator'''<br />
* '''MathEvaluator'''<br />
<br />
=== Beschreibung ===<br />
''false'' gibt den Boolschen Wahrheitswert ''False'' bzw. ''Falsch'' zurück.<br />
<br />
=== Syntax ===<br />
false()<br />
<br />
=== Return Value ===<br />
* Gibt ein [[Objekt]] zurück.<br />
<br />
=== Beispiele ===<br />
false() --> False<br />
<br />
false() && true() --> False<br />
<br />
=== Hinweis ====<br />
* Als Gegenstück gibt die Funktion [[true|true()]] ''True'' zurück.<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Kategorie:JACK3]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=IsEmpty&diff=10059IsEmpty2024-03-13T12:08:45Z<p>Striewe: </p>
<hr />
<div>==Zugehörige Evaluatoren==<br />
*'''ChemEvaluator'''<br />
*'''MathEvaluator'''<br />
== Beschreibung ==<br />
Die Funktion ''isEmpty'' prüft ob ein gegebenes Objekt leer ist, also entweder keine Zeichen oder ausschließlich Leerzeichen beinhaltet, oder Leere Boxen, wie in Matritzen zu finden. Die Funktion erwartet ein Objekt und gibt einen Boolean zurück. <br />
<br />
=== Syntax ===<br />
isEmpty([[Objekt]] objekt)<br />
<br />
=== Parameter ===<br />
* '''objekt''' - [[Objekt]], das auf leeren Inhalt geprüft wird<br />
<br />
=== Return Value ===<br />
* Gibt einen [[Boolean]] zurück<br />
<br />
=== Beispiele ===<br />
==== Standardfälle ====<br />
'''Jack2:'''<br />
isEmpty(' ') --> returns true<br />
<br />
isEmpty('nichtleer') --> returns false<br />
<br />
'''Jack3:'''<br />
isEmpty( ) --> returns true<br />
<br />
isEmpty(' ') --> returns false<br />
<br />
isEmpty('nichtleer') --> returns false<br />
<br />
==== Benutzung von Variablen (Beispiele) ====<br />
isEmpty([input=fillin1])<br />
<br />
isEmpty([var=a])<br />
<br />
=== Hinweise ===<br />
* Anführungsstriche werden als Zeichenkette interpretiert, daher wird es nicht als leer gesehen.<br />
* Ein Leerzeichen wird in JACK3 nicht mehr als leer interpretiert.<br />
* Für die Überprüfung, ob die Platzhalter bei Formeln durch den Formeleditor leer gelassen wurde, steht die Funktion [[containsEditorPlaceholder|containsEditorPlaceholder()]] zur Verfügung.<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Kategorie:Testfunktionen]][[Kategorie:JACK2]][[Kategorie:JACK3]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=True&diff=10058True2024-03-13T11:46:06Z<p>Striewe: </p>
<hr />
<div>== Zugehörige Evaluatoren ==<br />
* '''ChemEvaluator'''<br />
* '''MathEvaluator'''<br />
<br />
=== Beschreibung ===<br />
''true'' gibt True zurück.<br />
<br />
=== Syntax ===<br />
true()<br />
<br />
=== Return Value ===<br />
* Gibt ein [[Objekt]] zurück.<br />
<br />
=== Beispiele ===<br />
true() --> True<br />
<br />
true() || false() --> True<br />
<br />
=== Hinweise ===<br />
<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=False&diff=10057False2024-03-13T11:45:45Z<p>Striewe: </p>
<hr />
<div>{{Vorlage:Warnung|Warnung=Diese Seite beinhaltet eine Evaluator-Funktion im JACK3 System.}}<br />
== Zugehörige Evaluatoren ==<br />
* '''ChemEvaluator'''<br />
* '''MathEvaluator'''<br />
<br />
=== Beschreibung ===<br />
''false'' gibt falsch zurück.<br />
<br />
=== Syntax ===<br />
false()<br />
<br />
=== Return Value ===<br />
* Gibt ein [[Objekt]] zurück.<br />
<br />
=== Beispiele ===<br />
false() --> False<br />
<br />
false() && true() --> False<br />
<br />
=== Hinweis ====<br />
* Als alternative gibt die Funktion [[true|true()]] ''True'' zurück.<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Kategorie:JACK3]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=BooleanOr&diff=10056BooleanOr2024-03-13T11:45:16Z<p>Striewe: </p>
<hr />
<div>==Zugehörige Evaluatoren==<br />
*'''ChemEvaluator'''<br />
*'''MathEvaluator'''<br />
===Beschreibung===<br />
Die Funktion ''BooleanOr'' ("||") vergleicht zwei Aussagen auf ''true'' oder ''false''. Es wird nur dann ''false'' zurückgegeben, wenn beide Aussagen ''false'' sind.<br />
<br />
===Syntax===<br />
x || y<br />
or(x,y)<br />
<br />
===Parameter===<br />
* '''x''' - [[Boolean]]<br />
* '''y''' - [[Boolean]]<br />
<br />
===Return Value===<br />
* Gibt einen Boolean zurück.<br />
<br />
===Beispiele===<br />
==== Standardfälle ====<br />
1 || 1 --> returns true<br />
<br />
0 || 1 --> returns true<br />
<br />
1 || 0 --> returns true<br />
<br />
0 || 0 --> returns false<br />
<br />
(2+4==6) || (3+3==6) --> returns true<br />
<br />
==== Benutzung mit Variablen ====<br />
<br />
[var=a] || [var=b]<br />
<br />
===Hinweise===<br />
* Es werden zwei boolsche Ausdrücke erwartet.<br />
* Diese Funktion ist ein binärer Operator.<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Category:Operator]][[Kategorie:Booleanfunktionen]][[Kategorie:JACK2]][[Kategorie:JACK3]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=BooleanNot&diff=10055BooleanNot2024-03-13T11:44:59Z<p>Striewe: </p>
<hr />
<div>==Zugehörige Evaluatoren==<br />
*'''ChemEvaluator'''<br />
*'''MathEvaluator'''<br />
===Beschreibung===<br />
Die Funktion ''BooleanNot'' (!) testet ob eine Aussage wahr oder falsch ist. <br />
<br />
===Syntax===<br />
!a<br />
not(a)<br />
<br />
===Parameter===<br />
* '''a''' - boolean<br />
<br />
===Return Value===<br />
* Gibt einen Boolean zurück.<br />
<br />
===Beispiele===<br />
==== Standardfälle ====<br />
!0 --> returns true<br />
<br />
!1 --> returns false<br />
<br />
!(3+4==6) --> returns true<br />
<br />
==== Benutzung mit Variablen ====<br />
<br />
![var=a]<br />
<br />
===Hinweise===<br />
* Wenn der Boolean b ''true'' ist gibt !b ''false'' zurück.<br />
* Diese Funktion ist ein unärer Operator.<br />
* Weitere unäre Operatoren sind [[unaryMinus]] und [[unaryPlus]]. <br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Category:Operator]][[Kategorie:Booleanfunktionen]][[Kategorie:JACK2]][[Kategorie:JACK3]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=BooleanAnd&diff=10054BooleanAnd2024-03-13T11:44:39Z<p>Striewe: </p>
<hr />
<div>==Zugehörige Evaluatoren==<br />
*'''ChemEvaluator'''<br />
*'''MathEvaluator'''<br />
===Beschreibung===<br />
Die Funktion ''BooleanAnd'' ("&&") aus der Bool'schen Algebra vergleicht zwei Aussagen auf "true" oder "false". Der Ausdruck x && y gibt true zurück, wenn x und y beide true sind, ansonsten wird immer false zurückgegeben.<br />
<br />
Achtung: In XML Dateien muss das Zeichen & durch &''amp''; ersetz werden!<br />
<br />
===Syntax===<br />
x && y<br />
and(x,y)<br />
<br />
===Parameter===<br />
* '''x''' - [[Boolean]]<br />
* '''y''' - [[Boolean]]<br />
<br />
===Return Value===<br />
* Gibt einen Boolean zurück.<br />
<br />
===Beispiele===<br />
==== Standardfälle ====<br />
1 && 1 --> returns true<br />
<br />
0 && 1 --> returns false<br />
<br />
1 && 0 --> returns false<br />
<br />
0 && 0 --> returns false<br />
<br />
(2+4==6) && (3+3==6) --> returns true<br />
<br />
==== Benutzung mit Variablen ====<br />
<br />
[var=a] && [var=b]<br />
<br />
===Hinweise===<br />
* Es werden zwei boolsche Ausdrücke erwartet.<br />
* Diese Funktion ist ein binärer Operator.<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Category:Operator]][[Kategorie:Booleanfunktionen]][[Kategorie:JACK2]][[Kategorie:JACK3]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=IsEmpty&diff=10053IsEmpty2024-03-13T11:25:36Z<p>Striewe: /* Benutzung von Variablen */</p>
<hr />
<div>==Zugehörige Evaluatoren==<br />
*'''ChemEvaluator'''<br />
*'''MathEvaluator'''<br />
== Beschreibung ==<br />
Die Funktion ''isEmpty'' prüft ob ein gegebenes Objekt leer ist, also entweder keine Zeichen oder ausschließlich Leerzeichen beinhaltet, oder Leere Boxen, wie in Matritzen zu finden. Die Funktion erwartet ein Objekt und gibt einen Boolean zurück. <br />
<br />
=== Syntax ===<br />
isEmpty([[Objekt]] objekt)<br />
<br />
=== Parameter ===<br />
* '''objekt''' - [[Objekt]], das auf leeren Inhalt geprüft wird<br />
<br />
=== Return Value ===<br />
* Gibt einen [[Boolean]] zurück<br />
<br />
=== Beispiele ===<br />
==== Standardfälle ====<br />
'''Jack2:'''<br />
isEmpty(' ') --> returns true<br />
<br />
isEmpty('nichtleer') --> returns false<br />
<br />
'''Jack3:'''<br />
isEmpty( ) --> returns true<br />
<br />
isEmpty(' ') --> returns false<br />
<br />
isEmpty('nichtleer') --> returns false<br />
<br />
==== Benutzung von Variablen (Beispiele) ====<br />
isEmpty([input=fillin1])<br />
<br />
isEmpty([var=a])<br />
<br />
=== Hinweise ===<br />
* Anführungsstriche werden als Zeichenkette interpretiert, daher wird es nicht als leer gesehen.<br />
* Ein Leerzeichen wird in JACK3 nicht mehr als leer interpretiert.<br />
* Für die Überprüfung, ob die Platzhalter bei Formeln durch den Formeleditor leer gelassen wurde, steht die Funktion [[containsEditorPlaceholder|containsEditorPlaceholder()]] zur Verfügung.<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Kategorie:Testfunktionen]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=StringLiteral_(R-GReQL)&diff=10052StringLiteral (R-GReQL)2024-03-12T15:37:30Z<p>Striewe: </p>
<hr />
<div>StringLiteral stellt eine Zeichenkette dar. Der Knoten besitzt ein Attribut "value", in dem der Wert gespeichert ist. Der Knoten wird in der Abbildung in blau dargestellt. [[Datei:6Literals.png|mini|<code>var4 <- 10; var5 <- 10.5; var6 <- "String"; var7 <- 'String'</code>]]<br />
<br />
Der Knoten ist Teil der [[R-GReQL-Grammatik|GReQL-Grammatik]] für den [[StaticRChecker]].<br />
<br />
= Beispiel =<br />
<br />
<code>var <- <u>"String"</u></code><br />
<br />
<code>var <- <u>'String'</u></code><br />
<br />
= Hinweise =<br />
<br />
Der Wert von StringLiteral ist die Zeichenkette einschließlich ihrer Anführungszeichen. Da Anführungszeichen auch in GReQL-Regeln genutzt werden, um Zeichenketten zu kennzeichnen, müssen die zum StringLiteral gehörenden Anführungszeichen mit einem Backslash (<code>\</code>) escaped werden.<br />
<br />
Beispiel:<br />
<br />
<pre>from<br />
s2:V{StringLiteral} with<br />
s2.value="\"test\""<br />
report 0 end</pre><br />
<br />
[[Category:R-GReQL]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Versionshistorie_(JACK3)&diff=9645Versionshistorie (JACK3)2024-01-17T08:00:56Z<p>Striewe: </p>
<hr />
<div>==Januar 2024==<br />
===Version 0.10.0===<br />
Highlights in Version 0.10.0:<br />
* Mit dem R-Taschenrechner hat ein weiteres Hilfsmittel für Studierende Einzug in JACK gehalten.<br />
* TinyMCE ist der neue Editor zum Bearbeiten von formatiertem Text in JACK. Er hat den CKEditor vollständig abgelöst.<br />
* Schlägt die Variablenbelegung in einer Aufgabe fehl, so werden nun bis zu zwei weitere Versuche unternommen, die Aufgabe doch noch korrekt zu initialisieren. So führen selten auftretende Fehler nicht zur Unbearbeitbarkeit der Aufgabe für Studierende.<br />
* Variableninhalte lassen sich nun einfach per Klick kopieren.<br />
* Feedback in MC Aufgaben lässt sich nun auch nachträglich ändern.<br />
* Der persönlicher Ordner kann nicht mehr direkt geteilt werden. Nur dessen Unterordner lassen sich mit anderen Nutzern teilen.<br />
* Die Teilaufgaben einer Aufgabe lassen sich nun umsortieren.<br />
<br />
Hinzu kommen div. kleinere Fixes, viele davon im Zusammenhang mit dem JACK 2 Importer und dem neuen Theme, das in der letzten Version hinzugekommen ist.<br />
<br />
Ihre bearbeiteten Issues:<br />
* Absoluter Abzug von Punkten bei Hinweisen<br />
* Mehrere Aufgaben gleichzeitig verschieben<br />
* Bei Verschieben des Feedbacks verschwindet Feedbacktext<br />
* R Checker, Testfall Gruppen werden ungewollt dupliziert<br />
* Verschieben von Aufgaben in einen anderen Ordner<br />
* Darstellung von den Check-Boxen in MC Aufgaben<br />
* Neues Theme: Grafik überdeckt Editieroption bei MC Stages<br />
* Scrollbar bei Feedback innerhalb der Debug-Optionen<br />
<br />
==Oktober 2023==<br />
===Version 0.9.0===<br />
Die Version enthält ein neues Theme auf Basis einer neuen Version des UI-Frameworks. Es hat sich nur die Optik leicht geändert; Bedienelemente sind nach wie vor an den vertrauten Stellen zu finden. Einzige Ausnahme: Die Kursbearbeitung für Studierende wurde leicht überarbeitet, sodass Funktionen zum Kurs beenden oder neustarten etc. jetzt hoffentlich besser platziert sind und weniger zu Verwechslungen einladen.<br />
<br />
Dazu haben wir wie üblich ihre zahlreichen Verbesserungsvorschläge und Fehler bearbeitet:<br />
* Formatierungsfehler bzgl. Vorzeichen behoben.<br />
* Probleme mit mathematisch belegten Zeichen behoben.<br />
* Problem bei der Faktorisierung in Sage behoben.<br />
* Problem bei Summen- und Produktbildung behoben.<br />
* Der Formeleditor kann jetzt auch f(x) verarbeiten.<br />
* Imaginäranteil von komplexen Zahlen wird wieder erkannt.<br />
* Probleme mit der Eulerschen Zahl behoben.<br />
* In der Teilnehmerübersicht kann jetzt auch nach Profilfeldern wie bspw. der Matrikelnummer gefiltert werden.<br />
<br />
==September 2023==<br />
===Version 0.8.1===<br />
Neuerungen in dieser Version:<br />
* Chemische Formeln können nun asynchron geprüft werden.<br />
* Tags von Aufgaben werden nun mit im- und exportiert.<br />
* Mit LaTeX gesetzte Formeln können nun per Klick gezoomt werden.<br />
* Die Namen hochgeladener Ressourcen werden nun vor Studierenden verborgen.<br />
* Viele Detailverbesserungen in der Benutzeroberfläche.<br />
<br />
Ihre gemeldeten Fehler und Verbesserungsvorschläge:<br />
* Die Spaltenbreite in MCTable Aufgaben ist nun dynamisch.<br />
* Die sporadische Sperrung der R-Konsole bei der Anforderung von Hinweisen ist nun behoben.<br />
* Dropdownfelder und Formeleditoren beeinflussen sich nicht mehr gegenseitig.<br />
* Feedback lässt sich auch bei mehrstufigen Aufgaben nun umbenennen.<br />
<br />
==Mai 2023==<br />
===Version 0.7.1===<br />
Neuerungen in dieser Version:<br />
* Mit dem Stufentyp MCTable kehrt ein alter Bekannter aus JACK 2 wieder in den Schoß der JACK Familie zurück.<br />
* Der Aufgabeneditor hat jetzt ein Werkzeugmenü, über das auch der freie Moleküleditor verfügbar ist.<br />
* Mit dem Validator haben wir ein Werkzeug hinzugefügt, dass vor typischen Fehlern und Fehlkonfigurationen in Aufgaben und Kursen warnt.<br />
* Der Ex- und Import von Kursen ist jetzt möglich.<br />
* Es lassen sich jetzt auch Java Aufgaben aus JACK 2 importieren.<br />
<br />
Ihre gemeldeten Fehler und Verbesserungsvorschläge:<br />
* Das automatische Scrollen beim Einreichen wurde verbessert.<br />
* Mehrere Aufgaben können nun gleichzeitig verschoben werden.<br />
* Der Countdown funktioniert jetzt auch beim schnellen Aufgabenwechsel wieder.<br />
* Bilder werden nun automatisch skaliert, sodass sie das Layout nicht stören.<br />
<br />
Organisatorische Neuerungen:<br />
* Prüfungen brauchen nun nicht mehr im Wiki eingetragen zu werden. Eine formlose E-Mail an das JACK Team reicht.<br />
* Unser Wiki liegt jetzt auf dem Wikiserver der Universität und lässt sich nach wie vor über die bekannte Domäne jack-community.org erreichen.<br />
* Wir werden den Issuetracker für unsere JACK Tester auf das Gitlab der Universität umziehen, um es leichter erreichbar für alle Mitarbeiterinnen und Mitarbeiter der Universität zu machen. Mehr Infos zum Umzug werden Sie bald separat erhalten.<br />
<br />
==März 2023==<br />
===Version 0.6.1===<br />
Die folgenden neuen Features wurden realisiert:<br />
* Neuer Stufentyp: Freitextaufgaben<br />
* Neuer Stufentyp: Datei(en) hochladen<br />
* Neuer Stufentyp: Atomorbitalschemata<br />
* Feedbackregeln können nun eingeklappt werden<br />
* Diverse Detailverbesserungen<br />
<br />
Zudem haben wir einige Issues lösen können:<br />
* Automatisches Anpassen der Größe von Bildern.<br />
* Löschen von Tags aktiviert Speichernbutton nicht.<br />
* Vorausgefüllter Code ist beschränkt bzgl. der Länge.<br />
* Mehrere R-Stufen in einer Aufgabe.<br />
* Kursbearbeitung kaputt, wenn Aufgabe daraus gelöscht wurde.<br />
* Probleme beim Import von JACK 2 Aufgaben mit Dateianhängen.<br />
<br />
Kleinere Änderungen gab es bei den Namensräume für Variablen:<br />
* In den Stufentypen Java, Python und UML wurden die input Variablen nach check verschoben.<br />
* Bei Multiple Choice Stufen wurden die Variablen mcStageCorrectTicks, mcStageIncorrectTicks und mcStageTotalTicks in den Namensraum check verschoben<br />
<br />
==September 2022==<br />
===Version 0.4.0===<br />
Folgende Neuerungen sind eingeflossen:<br />
* Aufgaben im Fehlerzustand lassen sich jetzt neustarten.<br />
* Mehr Informationen zu Einreichungen von Studierenden<br />
* Verbesserungen am Moleküleditor<br />
* Verbesserungen bei der Bewertung von R-Aufgaben<br />
<br />
Wir haben zudem die folgenden Issues gelöst:<br />
* Import von R-Aufgaben ohne Variablen<br />
* Verschieben von Feedback<br />
* Formatierungsfehler bei Plus Minus<br />
* EqualsExpression wird mit Strings angelegt<br />
* Feedback wird in eine Concat-Umgebung konvertiert<br />
* Tags lassen sich nicht einschalten<br />
<br />
==Juli 2022==<br />
===Version 0.3.0===<br />
Folgende Issues wurden seit dem letzten Release gelöst:<br />
* Das Duplizieren von Kursen schlägt fehl.<br />
* Nur ein Formeleditor soll gleichzeitig sichtbar sein.<br />
* Alignment von Antwortboxen bei MC-Aufgaben mit Bildern als Antwortmöglichkeiten.<br />
* Darstellung lange MC-Optionen.<br />
<br />
Außerdem gab es zahlreiche Verbesserungen im JACK 2 Importer sowie in der Benutzeroberfläche.<br />
<br />
==Mai 2022==<br />
===Version 0.2.0===<br />
Neben technischen Umbauten und neuen Stufentypen, sind wieder zahlreiche Fehler behoben worden, unter anderem die folgenden Issues:<br />
* Variable mit einleitenden $-Zeichen für LATEX-Code wird zu "<br />
* JACK2 MC-Aufgabe mit Graphen importierbar, aber Graphen werden nicht angezeigt<br />
* Tags in alphabetischer Reihenfolge anzeigen<br />
* Kein Import einer JACK2 Aufgabe aus S05 nach JACK3 mit Bild<br />
* Aufgabenimport nicht möglich<br />
* Angabe der E-Mail Adresse oder Matrikelnummer in der Kursangebots-Statistik<br />
* Import von Aufgaben mit einem freigegeben Account<br />
<br />
==Februar 2022==<br />
===Version 0.1.0===<br />
In diesem Release wurde insbesondere der Mechanismus für Feedback-Regeln in Fill-In-Aufgaben überarbeitet, sodass beispielsweise die Überprüfung auf leere Felder deutlich bequemer erfolgen kann. Zudem haben wir das Rechtesystem erweitert, sodass eine bessere Aufteilung der Aufgaben in der Lehre ermöglicht wird. Außerdem haben wir diverse ihrer Wünsche und Fehlermeldungen bearbeitet.<br />
* Formatierung von Variablen im Text von Aufgaben<br />
* Auswerten von R-Aufgaben vor dem Einreichen<br />
* Falsche Palette beim Import von JACK 2 Aufgaben<br />
* Verbesserungen beim Layout von Kursen.<br />
* Probleme beim Import von Aufgaben mit Bildern<br />
* Formatierung von Variablen im Text von Aufgaben.</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Konfiguration_des_Kekul%C3%A9-Editors_(JACK3)&diff=9319Konfiguration des Kekulé-Editors (JACK3)2023-11-14T14:29:20Z<p>Striewe: </p>
<hr />
<div>Der web-basierte Editor für die studentische Eingabe im Aufgabwentyp "[[Molekül (JACK3)|Molekül]]" kann umfangreich konfiguriert werden, um Studierenden möglichst genau die Funktionen zur Verfügung zu stellen, die sie zur Bearbeitung der Aufgabe benötigen.<br />
<br />
Die Konfiguration kann dabei entweder durch einen Administrator zentral für die gesamte JACK-Instanz oder durch Lehrende individuell pro Aufgabe erfolgen.<br />
<br />
==Einstellungen für den Editor für Studierende==<br />
===Einstellung für die allgemeinen Tool-Buttons===<br />
<br />
Diese Einstellungen legen fest, welche Buttons in der oberen Leiste des Editors verfügbar sind, also z. B. Laden, Speichern, Undo und Redo.<br />
<br />
Um eine individuelle Konfiguration pro Aufgabe anzulegen, wählen Lehrende "Angepasst" und erstellen einen Eintrag der folgenden Form im Textfeld:<br />
<br />
<syntaxhighlight lang="json"><br />
["newDoc", "undo", "redo", "copy", "cut", "paste"]<br />
</syntaxhighlight><br />
<br />
Die verfügbaren Namen der einzelnen Buttons können der Demo-Seite des Kekulé-Editors entnommen werden: http://partridgejiang.github.io/Kekule.js/demos/demoLauncher.html?id=composerCustomization<br />
<br />
Um die Standardeinstellung der gesamten JACK-Instanz zu ändern, legen Administratoren im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleCommonToolButtons" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : ["newDoc", "undo", "redo", "copy", "cut", "paste"]<br />
}<br />
</syntaxhighlight><br />
<br />
Der Eintrag <code>default</code> ist dabei fest vorgesehen für die Änderung der Standardeinstellung. Es können weitere Voreinstellungen mit frei gewählten Namen angelegt werden:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : ["newDoc", "undo", "redo", "copy", "cut", "paste"],<br />
"minimal" : ["undo", "copy", "cut", "paste"]<br />
}<br />
</syntaxhighlight><br />
<br />
Diese können von Lehrenden dann alternativ zur Standardeinstellung und der Anpassung pro Aufgabe gewählt werden. Wird vom Administrator kein Eintrag für <code>default</code> hinterlegt, gilt die Standardeinstellung des Editors.<br />
<br />
Unabhängig von den gewählten Einstellung zeigt JACK ab Version 0.10.0 für Studierende niemand die Editor-Buttons zum Ändern der Einstellungen und zum Öffnen des Objekt-Inspektors an.<br />
<br />
===Einstellungen für die chemischen Tool-Buttons===<br />
<br />
Diese Einstellungen legen fest, welche Buttons in der linken und unteren Leiste des Editors verfügbar sind, also z. B. zum Erstellen von Bindungen und Atomen.<br />
<br />
Um eine individuelle Konfiguration pro Aufgabe anzulegen, wählen Lehrende "Angepasst" und erstellen einen Eintrag der folgenden Form im Textfeld:<br />
<br />
<syntaxhighlight lang="json"><br />
[<br />
{<br />
"name": "manipulate",<br />
"attached": [ "manipulateMarquee", "manipulateLasso", "manipulateAncestor", "dragScroll", "toggleSelect" ]<br />
},<br />
"erase",<br />
{<br />
"name": "bond",<br />
"attached": [ "bondSingle", "bondDouble", "bondTriple", "bondWedgeUp", "bondWedgeDown", "chain", "trackInput" ]<br />
},<br />
{<br />
"name": "atomAndFormula",<br />
"attached": [ "methane", "atom" ]<br />
},<br />
{<br />
"name": "ring",<br />
"attached": [ "ring3", "ring4", "ring5", "ring6", "flexRing", "ringAr6" ]<br />
},<br />
{<br />
"name": "charge",<br />
"attached": [ "chargeClear", "chargePositive", "chargeNegative" ]<br />
}<br />
]<br />
</syntaxhighlight><br />
<br />
Die verfügbaren Namen der einzelnen Buttons können der Demo-Seite des Kekulé-Editors entnommen werden: http://partridgejiang.github.io/Kekule.js/demos/demoLauncher.html?id=composerCustomization<br />
<br />
Um die Standardeinstellung der gesamten JACK-Instanz zu ändern, legen Administratoren im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleChemToolButtons" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : [<br />
{<br />
"name": "manipulate",<br />
"attached": [ "manipulateMarquee", "manipulateLasso", "manipulateAncestor", "dragScroll", "toggleSelect" ]<br />
},<br />
"erase",<br />
{<br />
"name": "bond",<br />
"attached": [ "bondSingle", "bondDouble", "bondTriple", "bondWedgeUp", "bondWedgeDown", "chain", "trackInput" ]<br />
},<br />
{<br />
"name": "atomAndFormula",<br />
"attached": [ "methane", "atom" ]<br />
},<br />
{<br />
"name": "ring",<br />
"attached": [ "ring3", "ring4", "ring5", "ring6", "flexRing", "ringAr6" ]<br />
},<br />
{<br />
"name": "charge",<br />
"attached": [ "chargeClear", "chargePositive", "chargeNegative" ]<br />
}<br />
]}<br />
</syntaxhighlight><br />
<br />
Der Eintrag <code>default</code> ist dabei fest vorgesehen für die Änderung der Standardeinstellung. Wie bei den allgemeinen Buttons können weitere Voreinstellungen mit frei gewählten Namen angelegt werden, die dann von Lehrenden alternativ zur Standardeinstellung und der Anpassung pro Aufgabe gewählt werden können. Wird vom Administrator kein Eintrag für <code>default</code> hinterlegt, gilt die Standardeinstellung des Editors.<br />
<br />
===Einstellungen für die verfügbaren Object Modifier===<br />
<br />
Diese Einstellungen legen fest, welche zusätzlichen Buttons in der unteren Leiste des Editors verfügbar sind, wenn ein Element im Editor ausgewählt ist.<br />
<br />
Um eine individuelle Konfiguration pro Aufgabe anzulegen, wählen Lehrende "Angepasst" und erstellen einen Eintrag der folgenden Form im Textfeld:<br />
<br />
<syntaxhighlight lang="json"><br />
["general", "chemStruct", "glyph", "style", "misc"]<br />
</syntaxhighlight><br />
<br />
Die verfügbaren Namen der einzelnen Buttons können der Demo-Seite des Kekulé-Editors entnommen werden: http://partridgejiang.github.io/Kekule.js/demos/demoLauncher.html?id=composerCustomization<br />
<br />
Um die Standardeinstellung der gesamten JACK-Instanz zu ändern, legen Administratoren im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleAllowedObjModifierCategories" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : ["general", "chemStruct", "glyph", "style", "misc"]<br />
}<br />
</syntaxhighlight><br />
<br />
Der Eintrag <code>default</code> ist dabei fest vorgesehen für die Änderung der Standardeinstellung. Wie bei den allgemeinen Buttons können weitere Voreinstellungen mit frei gewählten Namen angelegt werden, die dann von Lehrenden alternativ zur Standardeinstellung und der Anpassung pro Aufgabe gewählt werden können. Wird vom Administrator kein Eintrag für <code>default</code> hinterlegt, gilt die Standardeinstellung des Editors.<br />
<br />
===Einstellungen für verfügbare Bindungsformen===<br />
<br />
Diese Einstellungen legen fest, welche Bindungsformen '''in den zusätzlichen Buttons''' in der unteren Leiste des Editors verfügbar sind. Bei Bindungsformen, die eigenen Buttons haben, müssen ggf. auch deren Einstellungen (siehe oben) konfiguriert werden. Dasselbe gilt für die Verfügbarkeit von Bindungen über Hotkeys (siehe unten).<br />
<br />
Um eine individuelle Konfiguration pro Aufgabe anzulegen, wählen Lehrende "Angepasst" und erstellen einen Eintrag der folgenden Form im Textfeld:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"single": true,<br />
"double": true,<br />
"triple": false,<br />
"quad": false,<br />
"explicitAromatic": true,<br />
"up": true,<br />
"upInverted": true,<br />
"down": true,<br />
"downInverted": true,<br />
"upOrDown": true,<br />
"eOrZ": true,<br />
"closer": false,<br />
"ionic": false,<br />
"coordinate": false,<br />
"metallic": false,<br />
"hydrogen": false,<br />
"transition": false<br />
}<br />
</syntaxhighlight><br />
<br />
Diese Auflistung enthält alle verfügbaren Namen von Bindungen, die jeweils über <code>true</code> oder <code>false</code> aktiviert bzw. deaktiviert werden können.<br />
<br />
Um die Standardeinstellung der gesamten JACK-Instanz zu ändern, legen Administratoren im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleAvailableBondForms" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : {<br />
"single": true,<br />
"double": true,<br />
"triple": false,<br />
"quad": false,<br />
"explicitAromatic": true,<br />
"up": true,<br />
"upInverted": true,<br />
"down": true,<br />
"downInverted": true,<br />
"upOrDown": true,<br />
"eOrZ": true,<br />
"closer": false,<br />
"ionic": false,<br />
"coordinate": false,<br />
"metallic": false,<br />
"hydrogen": false,<br />
"transition": false<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Der Eintrag <code>default</code> ist dabei fest vorgesehen für die Änderung der Standardeinstellung. Wie bei den allgemeinen Buttons können weitere Voreinstellungen mit frei gewählten Namen angelegt werden, die dann von Lehrenden alternativ zur Standardeinstellung und der Anpassung pro Aufgabe gewählt werden können. Wird vom Administrator kein Eintrag für <code>default</code> hinterlegt, gilt die Standardeinstellung des Editors.<br />
<br />
===Einstellungen für verfügbare nicht-atomare Strukturelemente===<br />
<br />
Diese Einstellungen legen fest, welche zusätzlichen Strukturelemente außer Atomen in den zusätzlichen Buttons in der unteren Leiste des Editors verfügbar sind. Bei Elementen, die auch über Hotkeys gesetzt werden können, müssen ggf. auch deren Einstellungen (siehe unten) konfiguriert werden.<br />
<br />
Um eine individuelle Konfiguration pro Aufgabe anzulegen, wählen Lehrende "Angepasst" und erstellen einen Eintrag der folgenden Form im Textfeld:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"RGroup": true,<br />
"pseudoatomDummy": true,<br />
"pseudoatomHetero": true,<br />
"pseudoatomAny": true,<br />
"variableAtomList": false,<br />
"variableAtomNotList": false<br />
}<br />
</syntaxhighlight><br />
<br />
Diese Auflistung enthält alle verfügbaren Namen von nicht-atomaren Elementen, die jeweils über <code>true</code> oder <code>false</code> aktiviert bzw. deaktiviert werden können.<br />
<br />
Um die Standardeinstellung der gesamten JACK-Instanz zu ändern, legen Administratoren im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleAvailableNonAtomTypes" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default": {<br />
"RGroup": true,<br />
"pseudoatomDummy": true,<br />
"pseudoatomHetero": true,<br />
"pseudoatomAny": true,<br />
"variableAtomList": false,<br />
"variableAtomNotList": false<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Der Eintrag <code>default</code> ist dabei fest vorgesehen für die Änderung der Standardeinstellung. Wie bei den allgemeinen Buttons können weitere Voreinstellungen mit frei gewählten Namen angelegt werden, die dann von Lehrenden alternativ zur Standardeinstellung und der Anpassung pro Aufgabe gewählt werden können. Wird vom Administrator kein Eintrag für <code>default</code> hinterlegt, gilt die Standardeinstellung des Editors.<br />
<br />
===Standard für die Anzeige von Wasserstoffatomen===<br />
<br />
Diese Einstellung legt fest, ob alle Wasserstoffatome angezeigt werden oder die Standardeinstellung des Editors verwendet wird, die Wasserstoffatome nur in bestimmten Fällen anzeigt. Die Festlegung kann nur pro Aufgabe getroffen werden und nicht durch einen Administrator für die gesamte JACK-Instanz.<br />
<br />
==Einstellungen für alle Editoren==<br />
===Hotkeys===<br />
Administratoren können die Liste der verfügbaren Hotkeys für alle Editoren (d. h. sowohl für Studierende als auch Lehrende) ändern. Sie legen dazu im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleHotkeys" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
[<br />
{ "key": "c", "action": "atom_C" },<br />
{ "key": "h", "action": "atom_H" },<br />
{ "key": "o", "action": "atom_O" },<br />
{ "key": "n", "action": "atom_N" },<br />
{ "key": "p", "action": "atom_P" },<br />
{ "key": "s", "action": "atom_S" },<br />
{ "key": "f", "action": "atom_F" },<br />
{ "key": "Shift+C", "action": "atom_Cl" },<br />
{ "key": "b", "action": "atom_Br" },<br />
{ "key": "i", "action": "atom_I" },<br />
{ "key": "Shift+B", "action": "atom_B" },<br />
{ "key": "k", "action": "atom_K" },<br />
{ "key": "Shift+N", "action": "atom_Na" },<br />
{ "key": "d", "action": "atom_D" },<br />
{ "key": "m", "action": "subgroup_methyl" },<br />
{ "key": "e", "action": "subgroup_ethyl" },<br />
{ "key": "t", "action": "subgroup_TMS" },<br />
{ "key": "Shift+P", "action": "subgroup_phenyl" },<br />
{ "key": "Shift+T", "action": "subgroup_OTs" },<br />
{ "key": "Shift+E", "action": "subgroup_COOCH3" },<br />
{ "key": "a", "action": "atom_any" },<br />
{ "key": "q", "action": "atom_hetero" },<br />
{ "key": "l", "action": "atom_variable" },<br />
{ "key": "r", "action": "subgroup_R" },<br />
{ "key": "1", "action": "bond_single" },<br />
{ "key": "2", "action": "bond_double" },<br />
{ "key": "3", "action": "bond_triple" },<br />
{ "key": "4", "action": "bond_quad" },<br />
{ "key": "b", "action": "bond_closer" },<br />
{ "key": "w", "action": "bond_up" },<br />
{ "key": "h", "action": "bond_down" },<br />
{ "key": "Shift+W", "action": "bond_down" },<br />
{ "key": "y", "action": "bond_upOrDown" },<br />
{ "key": "Ctrl+A", "action": "selectAll" },<br />
{ "key": "Ctrl+C", "action": "copy" },<br />
{ "key": "Ctrl+X", "action": "cut" },<br />
{ "key": "Ctrl+V", "action": "paste" },<br />
{ "key": "Ctrl+Z", "action": "undo" },<br />
{ "key": "Ctrl+Shift+Z", "action": "redo" },<br />
{ "key": "+", "action": "zoomIn" },<br />
{ "key": "-", "action": "zoomOut" },<br />
{ "key": "Delete", "action": "eraseSelection" },<br />
{ "key": "Backspace", "action": "eraseSelection" }<br />
]<br />
</syntaxhighlight><br />
<br />
Diese Auflistung enthält alle verfügbaren Namen von Aktionen, denen ein Hotkey zugewiesen werden kann. Einträge können weggelassen werden, wenn die entsprechende Aktion nicht per Hotkey verfügbar sein soll.</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Konfiguration_des_Kekul%C3%A9-Editors_(JACK3)&diff=9318Konfiguration des Kekulé-Editors (JACK3)2023-11-14T14:08:33Z<p>Striewe: </p>
<hr />
<div>Der web-basierte Editor für die studentische Eingabe im Aufgabwentyp "[[Molekül (JACK3)|Molekül]]" kann umfangreich konfiguriert werden, um Studierenden möglichst genau die Funktionen zur Verfügung zu stellen, die sie zur Bearbeitung der Aufgabe benötigen.<br />
<br />
Die Konfiguration kann dabei entweder durch einen Administrator zentrale für die gesamte JACK-Instanz oder durch Lehrende individuell pro Aufgabe erfolgen.<br />
<br />
===Einstellung für die allgemeinen Tool-Buttons===<br />
<br />
Diese Einstellungen legen fest, welche Buttons in der oberen Leiste des Editors verfügbar sind, also z. B. Laden, Speichern, Undo und Redo.<br />
<br />
Um eine individuelle Konfiguration pro Aufgabe anzulegen, wählen Lehrende "Angepasst" und erstellen einen Eintrag der folgenden Form im Textfeld:<br />
<br />
<syntaxhighlight lang="json"><br />
["newDoc", "undo", "redo", "copy", "cut", "paste"]<br />
</syntaxhighlight><br />
<br />
Die verfügbaren Namen der einzelnen Buttons können der Demo-Seite des Kekulé-Editors entnommen werden: http://partridgejiang.github.io/Kekule.js/demos/demoLauncher.html?id=composerCustomization<br />
<br />
Um die Standardeinstellung der gesamten JACK-Instanz zu ändern, legen Administratoren im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleCommonToolButtons" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : ["newDoc", "undo", "redo", "copy", "cut", "paste"]<br />
}<br />
</syntaxhighlight><br />
<br />
Der Eintrag <code>default</code> ist dabei fest vorgesehen für die Änderung der Standardeinstellung. Es können weitere Voreinstellungen mit frei gewählten Namen angelegt werden:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : ["newDoc", "undo", "redo", "copy", "cut", "paste"],<br />
"minimal" : ["undo", "copy", "cut", "paste"]<br />
}<br />
</syntaxhighlight><br />
<br />
Diese können von Lehrenden dann alternativ zur Standardeinstellung und der Anpassung pro Aufgabe gewählt werden. Wird vom Administrator kein Eintrag für <code>default</code> hinterlegt, gilt die Standardeinstellung des Editors.<br />
<br />
Unabhängig von den gewählten Einstellung zeigt JACK ab Version 0.10.0 für Studierende niemand die Editor-Buttons zum Ändern der Einstellungen und zum Öffnen des Objekt-Inspektors an.<br />
<br />
===Einstellungen für die chemischen Tool-Buttons===<br />
<br />
Diese Einstellungen legen fest, welche Buttons in der linken und unteren Leiste des Editors verfügbar sind, also z. B. zum Erstellen von Bindungen und Atomen.<br />
<br />
Um eine individuelle Konfiguration pro Aufgabe anzulegen, wählen Lehrende "Angepasst" und erstellen einen Eintrag der folgenden Form im Textfeld:<br />
<br />
<syntaxhighlight lang="json"><br />
[<br />
{<br />
"name": "manipulate",<br />
"attached": [ "manipulateMarquee", "manipulateLasso", "manipulateAncestor", "dragScroll", "toggleSelect" ]<br />
},<br />
"erase",<br />
{<br />
"name": "bond",<br />
"attached": [ "bondSingle", "bondDouble", "bondTriple", "bondWedgeUp", "bondWedgeDown", "chain", "trackInput" ]<br />
},<br />
{<br />
"name": "atomAndFormula",<br />
"attached": [ "methane", "atom" ]<br />
},<br />
{<br />
"name": "ring",<br />
"attached": [ "ring3", "ring4", "ring5", "ring6", "flexRing", "ringAr6" ]<br />
},<br />
{<br />
"name": "charge",<br />
"attached": [ "chargeClear", "chargePositive", "chargeNegative" ]<br />
}<br />
]<br />
</syntaxhighlight><br />
<br />
Die verfügbaren Namen der einzelnen Buttons können der Demo-Seite des Kekulé-Editors entnommen werden: http://partridgejiang.github.io/Kekule.js/demos/demoLauncher.html?id=composerCustomization<br />
<br />
Um die Standardeinstellung der gesamten JACK-Instanz zu ändern, legen Administratoren im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleChemToolButtons" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : [<br />
{<br />
"name": "manipulate",<br />
"attached": [ "manipulateMarquee", "manipulateLasso", "manipulateAncestor", "dragScroll", "toggleSelect" ]<br />
},<br />
"erase",<br />
{<br />
"name": "bond",<br />
"attached": [ "bondSingle", "bondDouble", "bondTriple", "bondWedgeUp", "bondWedgeDown", "chain", "trackInput" ]<br />
},<br />
{<br />
"name": "atomAndFormula",<br />
"attached": [ "methane", "atom" ]<br />
},<br />
{<br />
"name": "ring",<br />
"attached": [ "ring3", "ring4", "ring5", "ring6", "flexRing", "ringAr6" ]<br />
},<br />
{<br />
"name": "charge",<br />
"attached": [ "chargeClear", "chargePositive", "chargeNegative" ]<br />
}<br />
]}<br />
</syntaxhighlight><br />
<br />
Der Eintrag <code>default</code> ist dabei fest vorgesehen für die Änderung der Standardeinstellung. Wie bei den allgemeinen Buttons können weitere Voreinstellungen mit frei gewählten Namen angelegt werden, die dann von Lehrenden alternativ zur Standardeinstellung und der Anpassung pro Aufgabe gewählt werden können. Wird vom Administrator kein Eintrag für <code>default</code> hinterlegt, gilt die Standardeinstellung des Editors.<br />
<br />
===Einstellungen für die verfügbaren Object Modifier===<br />
<br />
Diese Einstellungen legen fest, welche zusätzlichen Buttons in der unteren Leiste des Editors verfügbar sind, wenn ein Element im Editor ausgewählt ist.<br />
<br />
Um eine individuelle Konfiguration pro Aufgabe anzulegen, wählen Lehrende "Angepasst" und erstellen einen Eintrag der folgenden Form im Textfeld:<br />
<br />
<syntaxhighlight lang="json"><br />
["general", "chemStruct", "glyph", "style", "misc"]<br />
</syntaxhighlight><br />
<br />
Die verfügbaren Namen der einzelnen Buttons können der Demo-Seite des Kekulé-Editors entnommen werden: http://partridgejiang.github.io/Kekule.js/demos/demoLauncher.html?id=composerCustomization<br />
<br />
Um die Standardeinstellung der gesamten JACK-Instanz zu ändern, legen Administratoren im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleAllowedObjModifierCategories" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : ["general", "chemStruct", "glyph", "style", "misc"]<br />
}<br />
</syntaxhighlight><br />
<br />
Der Eintrag <code>default</code> ist dabei fest vorgesehen für die Änderung der Standardeinstellung. Wie bei den allgemeinen Buttons können weitere Voreinstellungen mit frei gewählten Namen angelegt werden, die dann von Lehrenden alternativ zur Standardeinstellung und der Anpassung pro Aufgabe gewählt werden können. Wird vom Administrator kein Eintrag für <code>default</code> hinterlegt, gilt die Standardeinstellung des Editors.</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Konfiguration_des_Kekul%C3%A9-Editors_(JACK3)&diff=9317Konfiguration des Kekulé-Editors (JACK3)2023-11-14T14:00:18Z<p>Striewe: Die Seite wurde neu angelegt: „Der web-basierte Editor für die studentische Eingabe im Aufgabwentyp "Molekül" kann umfangreich konfiguriert werden, um Studierenden möglichst genau die Funktionen zur Verfügung zu stellen, die sie zur Bearbeitung der Aufgabe benötigen. Die Konfiguration kann dabei entweder durch einen Administrator zentrale für die gesamte JACK-Instanz oder durch Lehrende individuell pro Aufgabe erfolgen. ===Einstellung für die allgemeinen T…“</p>
<hr />
<div>Der web-basierte Editor für die studentische Eingabe im Aufgabwentyp "[[Molekül (JACK3)|Molekül]]" kann umfangreich konfiguriert werden, um Studierenden möglichst genau die Funktionen zur Verfügung zu stellen, die sie zur Bearbeitung der Aufgabe benötigen.<br />
<br />
Die Konfiguration kann dabei entweder durch einen Administrator zentrale für die gesamte JACK-Instanz oder durch Lehrende individuell pro Aufgabe erfolgen.<br />
<br />
===Einstellung für die allgemeinen Tool-Buttons===<br />
<br />
Diese Einstellungen legen fest, welche Buttons in der oberen Leiste des Editors verfügbar sind, also z. B. Laden, Speichern, Undo und Redo.<br />
<br />
Um eine individuelle Konfiguration pro Aufgabe anzulegen, wählen Lehrende "Angepasst" und erstellen einen Eintrag der folgenden Form im Textfeld:<br />
<br />
<syntaxhighlight lang="json"><br />
["newDoc", "undo", "redo", "copy", "cut", "paste"]<br />
</syntaxhighlight><br />
<br />
Die verfügbaren Namen der einzelnen Buttons können der Demo-Seite des Kekulé-Editors entnommen werden: http://partridgejiang.github.io/Kekule.js/demos/demoLauncher.html?id=composerCustomization<br />
<br />
Um die Standardeinstellung der gesamten JACK-Instanz zu ändern, legen Administratoren im Bereich "Verwaltung -> Konfiguration" einen Eintrag mit Schlüssel "kekuleCommonToolButtons" und einem Wert der folgenden Form an:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : ["newDoc", "undo", "redo", "copy", "cut", "paste"]<br />
}<br />
</syntaxhighlight><br />
<br />
Der Eintrag <code>default</code> ist dabei fest vorgesehen für die Änderung der Standardeinstellung. Es können weitere Voreinstellungen mit frei gewählten Namen angelegt werden:<br />
<br />
<syntaxhighlight lang="json"><br />
{<br />
"default" : ["newDoc", "undo", "redo", "copy", "cut", "paste"],<br />
"minimal" : ["undo", "copy", "cut", "paste"]<br />
}<br />
</syntaxhighlight><br />
<br />
Diese können von Lehrenden dann alternativ zur Standardeinstellung und der Anpassung pro Aufgabe gewählt werden. Wird vom Administrator kein Eintrag für <code>default</code> hinterlegt, gilt die Standardeinstellung des Editors.<br />
<br />
Unabhängig von den gewählten Einstellung zeigt JACK ab Version 0.10.0 für Studierende niemand die Editor-Buttons zum Ändern der Einstellungen und zum Öffnen des Objekt-Inspektors an.</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Molek%C3%BCl_(JACK3)&diff=9316Molekül (JACK3)2023-11-14T13:42:04Z<p>Striewe: </p>
<hr />
<div>Der Aufgabentyp "Molekül" ermöglich es Lehrenden nach bestimmten Molekülen, Reaktionsgleichungen oder ähnlichem zu fragen. Die Studierenden müssen dann die passende Struktur mithilfe eines Editors zeichnen. Dieser Aufgabentyp befindet sich derzeit noch im Aufbau, so dass spezielle Features in zukünftigen Versionen erweitert, verändert oder ergänmzt werden können.<br />
<br />
Der Aufgabentyp nutzt an verschiedenen Stellen die InChI-Notation (https://de.wikipedia.org/wiki/International_Chemical_Identifier), um Moleküle zu repräsentieren. Die Analyse studentischer Eingaben ist aber nicht auf Informationen beschränkt, die in InChI-Strings abgebildet werden können.<br />
<br />
===Aufgabeninhalt===<br />
* '''Titel:''' Hier kann optional der Name der Stufe eingetragen werden.<br />
* '''Aufgabentext:''' Im Aufgabentext steht die Aufgabenstellung. Mithilfe des Editors lässt sich die Aufgabenstellung einfach darstellen.<br />
[[Datei:Molekuel_Aufgabentext.JPG|center]]<br />
* '''Konfiguration des Editors:''' Hier können verschiedenen Einstellungen vorgenommen werden, mit denen die verfügbaren Funktionen des Molekül-Editors für die studentische Eingabe eingeschränkt werden können. Es besteht jeweils die Möglichkeit, zwischen einer Standardeinstellung und einer individuellen Einstellung pro Aufgabe zu wählen. Admins können zudem alternative Voreinstellungen definieren. Siehe dazu "[[Konfiguration des Kekulé-Editors]]".<br />
* '''Voreingestelltes Molekül im Editor:''' Hier kann eine Vorbelegung für den Editor erstellt werden, die den Studierenden beim Betreten der Aufgabe angezeigt wird. Klicken Sie rechts auf das Stift-Symbol, um einen Moleküleditor zu öffnen und die Vorbelegung zu erstellen oder zu ändern. In der Übersicht wird die Vorbelegung als InChI-String angezeigt. Es bleiben aber auch alle weiteren Bestandteile (z. B. Reaktionspfeile) erhalten, selbst wenn sie nicht im InChI-String abgebildet werden können.<br />
<br />
===Feedback===<br />
Beim Feedback stehen verschiedene Standardoptionen und spezielle Features zur Verfügung.<br />
* '''Gewichtung des Aufgabenteils:''' Gewichtung der Punktzahl einer Stufe innerhalb der Aufgabe.<br />
* '''Aufgabentext:''' Zur Übersicht und besseren Erstellung des Feedbacks wird der Aufgabentext hier nochmal angezeigt.<br />
* '''Erweiterte Eingabeanalyse:''' Die erweitere Eingabeanalyse ist derzeit im Aufbau. Es steht nur eine Funktion zur Verfügung, die nach Reaktionspfeilen sucht und die gefundenen Moleküle in Bezug auf diese Reaktionen auswertet und zuordnet. Dadurch entstehen zusätzliche Variablen, die im Folgenden in den Feedback-Regeln genutzt werden können (siehe unten). Das System nutzt zur Erkennung und Zuordnung gewisse Suchbereiche vor und nach sowie über und unter den Reaktionspfeilen.<br />
* '''Erwartete Lösung:''' Hier wird die Formel der richtigen Lösung eingetragen. Klicken Sie rechts auf das Stift-Symbol, um einen Moleküleditor zu öffnen und die erwartete Lösung zu erstellen oder zu ändern. In der Übersicht wird die erwartete Lösung als InChI-String angezeigt.<br />
[[Datei:Molekuel_erwarteteEingabe.JPG|center]]<br />
* '''Feedback bei korrekter Antwort:''' Der Feedbacktext, der ausgegeben werden soll, wenn die Eingabe der erwarteten Lösung entspricht. Das System prüft dazu, ob die studentische Eingabe genau dieselben InChI-Strings enthält wie die erwartete Lösung. Die Reihenfolge der Eingabe sowie die Position auf der Zeichenfläche wird dabei ignoriert.<br />
* '''Feedback bei falscher Antwort:''' Der Feedbacktext, der ausgegeben wird, wenn die studentische Eingabe nicht der erwarteten Lösung entspricht.<br />
* '''Weitere Feedbacks (optional):''' Analog zum Aufgabentyp "[[Fill-In]]" können weitere Regeln angegeben werden, die jeweils Feedback auslösen. Anders als bei der erwarteten Lösung steht hier kein Molekül-Editor zur Verfügung. Stattdessen müssen passende [[Evaluator]]-Funktionen genutzt werden, um die studentische Eingabe zu analysieren. Diese steht dazu als Variablen der Form <code>[input=...]</code> zur Verfügung (siehe unten).<br />
* '''Feedback beim Überspringen:''' Der Lehrende kann jede Fill-In oder Drop-Down Stufe zum Überspringen anbieten. Dazu muss zunächst der Haken gesetzt werden. Danach gibt es noch die Möglichkeit einen Text den Lernenden anzuzeigen, wenn dieser diese Stufe übersprungen hat. Den Text kann man wieder über die Icons Schlüssel oder Stift hinzufügen.<br />
<br />
===Hinweise===<br />
Jede Stufe kann beliebig viele Hinweise anbieten. Alle weiteren Information wie man Hinweise angibt sind [[Hinweise (JACK3)|hier]] zu finden.<br />
<br />
===Verknüpfungen===<br />
* '''Nächster Aufgabenteil (Standard):''' In dem Drop-Down Feld wird der nächste Zustand ausgewählt, in die die Aufgabe sein soll, wenn der Lernende eine Lösung eingereicht hat. Dieses wird immer dann durchgeführt, wenn keine andere Aktion zutrifft. Es gibt die folgenden Möglichkeiten: <br />
** '''Ende der Aufgabe:''' Die Aufgabe ist mit der Aktion des Lernenden beendet.<br />
** '''Aufgabenteil wiederholen:''' Der Aufgabenteil wird wiederholt. Der Lernende kann ein weiteres Ergebnis einreichen. Diese Aktion kann man z.B. bei Übungsaufgaben benutzen, wenn der Lernende eine Aufgabe solange wiederholen soll, bis das richtige Ergebnis eingereicht wurde.<br />
** '''#x (x ist dabei eine beliebige Stufe dieser Aufgabe):''' Die entsprechende Stufe wird als nächstes angezeigt. Wenn man die Stufennummer der aktuellen Stufe wählt wird diese Stufe neu aufgerufen.<br />
<br />
* '''Weitere nächste Aufgabenteile (optional):''' Hier kann die nächste Aktion dynamisch eingestellt werden, d.h. sie kann abhängig von der Variablen Konstelation sein oder von der Eingabe des Lernenden.<br />
* '''Nächster Aufgabenteil beim Überspringen (optional):''' Hier wird eingestellt welcher nächste Aufgabenteil angezeigt werden soll, wennn der Lernende die Stufe übersprungen hat. Diese Einstellungsmöglichkeit steht nur zur Verfügung, wenn der Haken im Tab Feedback fürs Überspringen gesetzt wurde.<br />
<br />
===Variablenupdates===<br />
Die Variablenupdates stehen nur zur Verfügung, wenn die Aufgabe auch Variablen hat. Es gelten die [[Variablenupdates (JACK3)|allgemeinen Informationen zum Anlegen von Variablenupdates]].<br />
<br />
Die folgenden Variablen stehen speziell im Aufgabentyp "Molekül" für '''jede''' studentische Einreichung zur Verfügung:<br />
<br />
{| class="wikitable"<br />
|-<br />
! Name !! Beschreibung<br />
|-<br />
| <code>[input=inchi]</code>|| Enthält eine Liste von Strings, die jeweils einem InChI-String eines eingegebenen Molekül entsprechen.<br />
|-<br />
| <code>[input=inchi_X]</code> (mit X = 1,2,...)|| Enthält jeweils einen InChI-String aus der studentischen Eingabe.<br />
|}<br />
<br />
Die folgenden Variablen stehen '''zusätzlich''' zur Verfügung, wenn die '''erweiterte Eingabeanalyse''' genutzt wurde:<br />
<br />
{| class="wikitable"<br />
|-<br />
! Name !! Beschreibung<br />
|-<br />
| <code>[check=reactions]</code>|| Anzahl der erkannten Reaktionen (entspricht der Anzahl der gefundenen Reaktionspfeile).<br />
|-<br />
| <code>[check=reactionType_X]</code> (mit X = 1,2,...)|| Typ der jeweiligen Reaktion entsprechend des im Editor verwendeten Reaktionspfeils.<br />
|-<br />
| <code>[check=educts_X]</code> (mit X = 1,2,...)|| Liste von Strings, die jeweils einem InChI-String eines Moleküls entsprechen, das als Edukt der jeweiligen Reaktion erkannt wurde.<br />
|-<br />
| <code>[check=products_X]</code> (mit X = 1,2,...)|| Liste von Strings, die jeweils einem InChI-String eines Moleküls entsprechen, das als Produkt der jeweiligen Reaktion erkannt wurde.<br />
|-<br />
| <code>[check=minorEducts_X]</code> (mit X = 1,2,...)|| Liste von Strings, die jeweils einem InChI-String eines Moleküls entsprechen, das als anorganisches Edukt oder sonstige Information oberhalb des Reaktionspfeils (z. B. "Hitze") der jeweiligen Reaktion erkannt wurde.<br />
|-<br />
| <code>[check=minorProducts_X]</code> (mit X = 1,2,...)|| Liste von Strings, die jeweils einem InChI-String eines Moleküls entsprechen, das als anorganisches Produkt oder sonstige Information unterhalb des Reaktionspfeils der jeweiligen Reaktion erkannt wurde.<br />
|}<br />
<br />
===studentische Eingabe===<br />
Die studentische Eingabe erfolgt über den Molekül-Editor von Kekule, indem man mit einigen Hilfsmitteln die Moleküle zeichnen kann. Die studentische Lösung des oben genannten Beispiels würde dann wie folgt aussehen:<br />
[[Datei:Molekuel_studentischeEingabe.JPG|center]]<br />
<br />
<br />
[[category:Benutzerhandbuch]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Versionshistorie_(JACK3)&diff=9080Versionshistorie (JACK3)2023-10-17T06:32:59Z<p>Striewe: </p>
<hr />
<div>==Oktober 2023==<br />
===Version 0.9.0===<br />
Die Version enthält ein neues Theme auf Basis einer neuen Version des UI-Frameworks. Es hat sich nur die Optik leicht geändert; Bedienelemente sind nach wie vor an den vertrauten Stellen zu finden. Einzige Ausnahme: Die Kursbearbeitung für Studierende wurde leicht überarbeitet, sodass Funktionen zum Kurs beenden oder neustarten etc. jetzt hoffentlich besser platziert sind und weniger zu Verwechslungen einladen.<br />
<br />
Dazu haben wir wie üblich ihre zahlreichen Verbesserungsvorschläge und Fehler bearbeitet:<br />
* Formatierungsfehler bzgl. Vorzeichen behoben.<br />
* Probleme mit mathematisch belegten Zeichen behoben.<br />
* Problem bei der Faktorisierung in Sage behoben.<br />
* Problem bei Summen- und Produktbildung behoben.<br />
* Der Formeleditor kann jetzt auch f(x) verarbeiten.<br />
* Imaginäranteil von komplexen Zahlen wird wieder erkannt.<br />
* Probleme mit der Eulerschen Zahl behoben.<br />
* In der Teilnehmerübersicht kann jetzt auch nach Profilfeldern wie bspw. der Matrikelnummer gefiltert werden.<br />
<br />
==September 2023==<br />
===Version 0.8.1===<br />
Neuerungen in dieser Version:<br />
* Chemische Formeln können nun asynchron geprüft werden.<br />
* Tags von Aufgaben werden nun mit im- und exportiert.<br />
* Mit LaTeX gesetzte Formeln können nun per Klick gezoomt werden.<br />
* Die Namen hochgeladener Ressourcen werden nun vor Studierenden verborgen.<br />
* Viele Detailverbesserungen in der Benutzeroberfläche.<br />
<br />
Ihre gemeldeten Fehler und Verbesserungsvorschläge:<br />
* Die Spaltenbreite in MCTable Aufgaben ist nun dynamisch.<br />
* Die sporadische Sperrung der R-Konsole bei der Anforderung von Hinweisen ist nun behoben.<br />
* Dropdownfelder und Formeleditoren beeinflussen sich nicht mehr gegenseitig.<br />
* Feedback lässt sich auch bei mehrstufigen Aufgaben nun umbenennen.<br />
<br />
==Mai 2023==<br />
===Version 0.7.1===<br />
Neuerungen in dieser Version:<br />
* Mit dem Stufentyp MCTable kehrt ein alter Bekannter aus JACK 2 wieder in den Schoß der JACK Familie zurück.<br />
* Der Aufgabeneditor hat jetzt ein Werkzeugmenü, über das auch der freie Moleküleditor verfügbar ist.<br />
* Mit dem Validator haben wir ein Werkzeug hinzugefügt, dass vor typischen Fehlern und Fehlkonfigurationen in Aufgaben und Kursen warnt.<br />
* Der Ex- und Import von Kursen ist jetzt möglich.<br />
* Es lassen sich jetzt auch Java Aufgaben aus JACK 2 importieren.<br />
<br />
Ihre gemeldeten Fehler und Verbesserungsvorschläge:<br />
* Das automatische Scrollen beim Einreichen wurde verbessert.<br />
* Mehrere Aufgaben können nun gleichzeitig verschoben werden.<br />
* Der Countdown funktioniert jetzt auch beim schnellen Aufgabenwechsel wieder.<br />
* Bilder werden nun automatisch skaliert, sodass sie das Layout nicht stören.<br />
<br />
Organisatorische Neuerungen:<br />
* Prüfungen brauchen nun nicht mehr im Wiki eingetragen zu werden. Eine formlose E-Mail an das JACK Team reicht.<br />
* Unser Wiki liegt jetzt auf dem Wikiserver der Universität und lässt sich nach wie vor über die bekannte Domäne jack-community.org erreichen.<br />
* Wir werden den Issuetracker für unsere JACK Tester auf das Gitlab der Universität umziehen, um es leichter erreichbar für alle Mitarbeiterinnen und Mitarbeiter der Universität zu machen. Mehr Infos zum Umzug werden Sie bald separat erhalten.<br />
<br />
==März 2023==<br />
===Version 0.6.1===<br />
Die folgenden neuen Features wurden realisiert:<br />
* Neuer Stufentyp: Freitextaufgaben<br />
* Neuer Stufentyp: Datei(en) hochladen<br />
* Neuer Stufentyp: Atomorbitalschemata<br />
* Feedbackregeln können nun eingeklappt werden<br />
* Diverse Detailverbesserungen<br />
<br />
Zudem haben wir einige Issues lösen können:<br />
* Automatisches Anpassen der Größe von Bildern.<br />
* Löschen von Tags aktiviert Speichernbutton nicht.<br />
* Vorausgefüllter Code ist beschränkt bzgl. der Länge.<br />
* Mehrere R-Stufen in einer Aufgabe.<br />
* Kursbearbeitung kaputt, wenn Aufgabe daraus gelöscht wurde.<br />
* Probleme beim Import von JACK 2 Aufgaben mit Dateianhängen.<br />
<br />
Kleinere Änderungen gab es bei den Namensräume für Variablen:<br />
* In den Stufentypen Java, Python und UML wurden die input Variablen nach check verschoben.<br />
* Bei Multiple Choice Stufen wurden die Variablen mcStageCorrectTicks, mcStageIncorrectTicks und mcStageTotalTicks in den Namensraum check verschoben<br />
<br />
==September 2022==<br />
===Version 0.4.0===<br />
Folgende Neuerungen sind eingeflossen:<br />
* Aufgaben im Fehlerzustand lassen sich jetzt neustarten.<br />
* Mehr Informationen zu Einreichungen von Studierenden<br />
* Verbesserungen am Moleküleditor<br />
* Verbesserungen bei der Bewertung von R-Aufgaben<br />
<br />
Wir haben zudem die folgenden Issues gelöst:<br />
* Import von R-Aufgaben ohne Variablen<br />
* Verschieben von Feedback<br />
* Formatierungsfehler bei Plus Minus<br />
* EqualsExpression wird mit Strings angelegt<br />
* Feedback wird in eine Concat-Umgebung konvertiert<br />
* Tags lassen sich nicht einschalten<br />
<br />
==Juli 2022==<br />
===Version 0.3.0===<br />
Folgende Issues wurden seit dem letzten Release gelöst:<br />
* Das Duplizieren von Kursen schlägt fehl.<br />
* Nur ein Formeleditor soll gleichzeitig sichtbar sein.<br />
* Alignment von Antwortboxen bei MC-Aufgaben mit Bildern als Antwortmöglichkeiten.<br />
* Darstellung lange MC-Optionen.<br />
<br />
Außerdem gab es zahlreiche Verbesserungen im JACK 2 Importer sowie in der Benutzeroberfläche.<br />
<br />
==Mai 2022==<br />
===Version 0.2.0===<br />
Neben technischen Umbauten und neuen Stufentypen, sind wieder zahlreiche Fehler behoben worden, unter anderem die folgenden Issues:<br />
* Variable mit einleitenden $-Zeichen für LATEX-Code wird zu "<br />
* JACK2 MC-Aufgabe mit Graphen importierbar, aber Graphen werden nicht angezeigt<br />
* Tags in alphabetischer Reihenfolge anzeigen<br />
* Kein Import einer JACK2 Aufgabe aus S05 nach JACK3 mit Bild<br />
* Aufgabenimport nicht möglich<br />
* Angabe der E-Mail Adresse oder Matrikelnummer in der Kursangebots-Statistik<br />
* Import von Aufgaben mit einem freigegeben Account<br />
<br />
==Februar 2022==<br />
===Version 0.1.0===<br />
In diesem Release wurde insbesondere der Mechanismus für Feedback-Regeln in Fill-In-Aufgaben überarbeitet, sodass beispielsweise die Überprüfung auf leere Felder deutlich bequemer erfolgen kann. Zudem haben wir das Rechtesystem erweitert, sodass eine bessere Aufteilung der Aufgaben in der Lehre ermöglicht wird. Außerdem haben wir diverse ihrer Wünsche und Fehlermeldungen bearbeitet.<br />
* Formatierung von Variablen im Text von Aufgaben<br />
* Auswerten von R-Aufgaben vor dem Einreichen<br />
* Falsche Palette beim Import von JACK 2 Aufgaben<br />
* Verbesserungen beim Layout von Kursen.<br />
* Probleme beim Import von Aufgaben mit Bildern<br />
* Formatierung von Variablen im Text von Aufgaben.</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Equals&diff=9045Equals2023-09-25T08:29:43Z<p>Striewe: /* Benutzung von Variablen */</p>
<hr />
<div>==Zugehörige Evaluatoren==<br />
*'''MathEvaluator'''<br />
=== Beschreibung ===<br />
Die Funktion ''equals'' vergleicht zwei Zeichenketten auf ihre exakte Übereinstimmung. Die Funktion erwartet zwei Strings und gibt einen Boolean zurück.<br />
<br />
=== Syntax ===<br />
equals([[Zeichenkette]] zeichenkette1, [[Zeichenkette]] zeichenkette2)<br />
Die Zeichenketten sollten in einfachen Anführungszeichen stehen, da sonst bei Rechenausdrücken das Ergebnis verglichen wird.<br />
<br />
=== Parameter ===<br />
* '''zeichenkette1''' - erste zu vergleichende Zeichenkette<br />
* '''zeichenkette2''' - zweite zu vergleichende Zeichenkette<br />
<br />
=== Return Value ===<br />
* Gibt einen [[Boolean]] zurück<br />
<br />
=== Beispiele ===<br />
==== Standardfälle ====<br />
equals('hallo','hallo') --> returns true<br />
equals('JACK','jack') --> returns false<br />
equals('2', 'sqrt(4)') --> returns false<br />
equals(2, sqrt(4)) --> returns true<br />
<br />
==== Benutzung von Variablen ====<br />
equals([input=antwort1],'text')<br />
equals('text',[var=a])<br />
equals([var=b],[input=antwort2])<br />
<br />
=== Hinweise ===<br />
* Es wird zwischen Groß- und Kleinschreibung unterschieden.<br />
* Die Funktion ''equals'' vergleicht zwei strings, auch Leerzeichen werden gezählt.<br />
<br />
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Zeichenkettenfunktionen]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Versionshistorie_(JACK3)&diff=9003Versionshistorie (JACK3)2023-09-19T06:15:53Z<p>Striewe: </p>
<hr />
<div>==September 2023==<br />
===Version 0.8.1===<br />
Neuerungen in dieser Version:<br />
* Chemische Formeln können nun asynchron geprüft werden.<br />
* Tags von Aufgaben werden nun mit im- und exportiert.<br />
* Mit LaTeX gesetzte Formeln können nun per Klick gezoomt werden.<br />
* Die Namen hochgeladener Ressourcen werden nun vor Studierenden verborgen.<br />
* Viele Detailverbesserungen in der Benutzeroberfläche.<br />
<br />
Ihre gemeldeten Fehler und Verbesserungsvorschläge:<br />
* Die Spaltenbreite in MCTable Aufgaben ist nun dynamisch.<br />
* Die sporadische Sperrung der R-Konsole bei der Anforderung von Hinweisen ist nun behoben.<br />
* Dropdownfelder und Formeleditoren beeinflussen sich nicht mehr gegenseitig.<br />
* Feedback lässt sich auch bei mehrstufigen Aufgaben nun umbenennen.<br />
<br />
==Mai 2023==<br />
===Version 0.7.1===<br />
Neuerungen in dieser Version:<br />
* Mit dem Stufentyp MCTable kehrt ein alter Bekannter aus JACK 2 wieder in den Schoß der JACK Familie zurück.<br />
* Der Aufgabeneditor hat jetzt ein Werkzeugmenü, über das auch der freie Moleküleditor verfügbar ist.<br />
* Mit dem Validator haben wir ein Werkzeug hinzugefügt, dass vor typischen Fehlern und Fehlkonfigurationen in Aufgaben und Kursen warnt.<br />
* Der Ex- und Import von Kursen ist jetzt möglich.<br />
* Es lassen sich jetzt auch Java Aufgaben aus JACK 2 importieren.<br />
<br />
Ihre gemeldeten Fehler und Verbesserungsvorschläge:<br />
* Das automatische Scrollen beim Einreichen wurde verbessert.<br />
* Mehrere Aufgaben können nun gleichzeitig verschoben werden.<br />
* Der Countdown funktioniert jetzt auch beim schnellen Aufgabenwechsel wieder.<br />
* Bilder werden nun automatisch skaliert, sodass sie das Layout nicht stören.<br />
<br />
Organisatorische Neuerungen:<br />
* Prüfungen brauchen nun nicht mehr im Wiki eingetragen zu werden. Eine formlose E-Mail an das JACK Team reicht.<br />
* Unser Wiki liegt jetzt auf dem Wikiserver der Universität und lässt sich nach wie vor über die bekannte Domäne jack-community.org erreichen.<br />
* Wir werden den Issuetracker für unsere JACK Tester auf das Gitlab der Universität umziehen, um es leichter erreichbar für alle Mitarbeiterinnen und Mitarbeiter der Universität zu machen. Mehr Infos zum Umzug werden Sie bald separat erhalten.<br />
<br />
==März 2023==<br />
===Version 0.6.1===<br />
Die folgenden neuen Features wurden realisiert:<br />
* Neuer Stufentyp: Freitextaufgaben<br />
* Neuer Stufentyp: Datei(en) hochladen<br />
* Neuer Stufentyp: Atomorbitalschemata<br />
* Feedbackregeln können nun eingeklappt werden<br />
* Diverse Detailverbesserungen<br />
<br />
Zudem haben wir einige Issues lösen können:<br />
* Automatisches Anpassen der Größe von Bildern.<br />
* Löschen von Tags aktiviert Speichernbutton nicht.<br />
* Vorausgefüllter Code ist beschränkt bzgl. der Länge.<br />
* Mehrere R-Stufen in einer Aufgabe.<br />
* Kursbearbeitung kaputt, wenn Aufgabe daraus gelöscht wurde.<br />
* Probleme beim Import von JACK 2 Aufgaben mit Dateianhängen.<br />
<br />
Kleinere Änderungen gab es bei den Namensräume für Variablen:<br />
* In den Stufentypen Java, Python und UML wurden die input Variablen nach check verschoben.<br />
* Bei Multiple Choice Stufen wurden die Variablen mcStageCorrectTicks, mcStageIncorrectTicks und mcStageTotalTicks in den Namensraum check verschoben<br />
<br />
==September 2022==<br />
===Version 0.4.0===<br />
Folgende Neuerungen sind eingeflossen:<br />
* Aufgaben im Fehlerzustand lassen sich jetzt neustarten.<br />
* Mehr Informationen zu Einreichungen von Studierenden<br />
* Verbesserungen am Moleküleditor<br />
* Verbesserungen bei der Bewertung von R-Aufgaben<br />
<br />
Wir haben zudem die folgenden Issues gelöst:<br />
* Import von R-Aufgaben ohne Variablen<br />
* Verschieben von Feedback<br />
* Formatierungsfehler bei Plus Minus<br />
* EqualsExpression wird mit Strings angelegt<br />
* Feedback wird in eine Concat-Umgebung konvertiert<br />
* Tags lassen sich nicht einschalten<br />
<br />
==Juli 2022==<br />
===Version 0.3.0===<br />
Folgende Issues wurden seit dem letzten Release gelöst:<br />
* Das Duplizieren von Kursen schlägt fehl.<br />
* Nur ein Formeleditor soll gleichzeitig sichtbar sein.<br />
* Alignment von Antwortboxen bei MC-Aufgaben mit Bildern als Antwortmöglichkeiten.<br />
* Darstellung lange MC-Optionen.<br />
<br />
Außerdem gab es zahlreiche Verbesserungen im JACK 2 Importer sowie in der Benutzeroberfläche.<br />
<br />
==Mai 2022==<br />
===Version 0.2.0===<br />
Neben technischen Umbauten und neuen Stufentypen, sind wieder zahlreiche Fehler behoben worden, unter anderem die folgenden Issues:<br />
* Variable mit einleitenden $-Zeichen für LATEX-Code wird zu "<br />
* JACK2 MC-Aufgabe mit Graphen importierbar, aber Graphen werden nicht angezeigt<br />
* Tags in alphabetischer Reihenfolge anzeigen<br />
* Kein Import einer JACK2 Aufgabe aus S05 nach JACK3 mit Bild<br />
* Aufgabenimport nicht möglich<br />
* Angabe der E-Mail Adresse oder Matrikelnummer in der Kursangebots-Statistik<br />
* Import von Aufgaben mit einem freigegeben Account<br />
<br />
==Februar 2022==<br />
===Version 0.1.0===<br />
In diesem Release wurde insbesondere der Mechanismus für Feedback-Regeln in Fill-In-Aufgaben überarbeitet, sodass beispielsweise die Überprüfung auf leere Felder deutlich bequemer erfolgen kann. Zudem haben wir das Rechtesystem erweitert, sodass eine bessere Aufteilung der Aufgaben in der Lehre ermöglicht wird. Außerdem haben wir diverse ihrer Wünsche und Fehlermeldungen bearbeitet.<br />
* Formatierung von Variablen im Text von Aufgaben<br />
* Auswerten von R-Aufgaben vor dem Einreichen<br />
* Falsche Palette beim Import von JACK 2 Aufgaben<br />
* Verbesserungen beim Layout von Kursen.<br />
* Probleme beim Import von Aufgaben mit Bildern<br />
* Formatierung von Variablen im Text von Aufgaben.</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQL-Typegraph_f%C3%BCr_Java&diff=8974GReQL-Typegraph für Java2023-08-25T10:54:49Z<p>Striewe: </p>
<hr />
<div>Grundsätzlich folgt der Typegraph für GReQL-Queries zu Java der Java Language Specification für Java 8. Der Syntaxgraph wird durch den Eclipse-Parser erzeugt und verwendet die entsprechenden Namen für die Syntaxelemente. An einigen Stellen gibt es kleine Vereinfachungen und Erweiterungen.<br />
<br />
== Typegraph-Definitionen == <br />
<br />
=== Knotentypen ===<br />
<br />
Alle Knoten erben vom abstrakten Typen <code>Node</code>. Zwei spezielle Knoten werden durch den Eclipse-Parser erzeugt und bilden die Wurzel und das erste Kind-Element des Syntaxbaumes.<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Node;<br />
VertexClass IJavaProject: Node { name:String };<br />
VertexClass IPackageFragment: Node { name:String };<br />
</syntaxhighlight><br />
<br />
Alle Sprachelemente von Java erben von <code>Element</code> und erhalten darüber eine Zuordnung zu einer Zeilennummer.<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Element: Node { line:Integer };<br />
VertexClass AnonymousClassDeclaration:Element;<br />
VertexClass CatchClause:Element;<br />
VertexClass Comment:Element;<br />
VertexClass CompilationUnit:Element { name:String };<br />
VertexClass Dimension:Element;<br />
VertexClass ImportDeclaration:Element { name:String, onDemand:Boolean, static:Boolean };<br />
VertexClass Javadoc:Element;<br />
VertexClass MemberRef:Element;<br />
VertexClass MemberValuePair:Element;<br />
VertexClass MethodRef:Element;<br />
VertexClass MethodRefParameter:Element { varargs:Boolean };<br />
VertexClass Modifier:Element { name:String };<br />
VertexClass PackageDeclaration:Element { name:String };<br />
VertexClass TagElement:Element { name:String };<br />
VertexClass TextElement:Element { content:String };<br />
VertexClass TypeParameter:Element;<br />
</syntaxhighlight><br />
<br />
Deklarationen innerhalb einer Klasse (im Gegensatz zu den oben enthaltenen Import-Deklarationen) erben vom Typ <code>BodyDeclaration</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass BodyDeclaration:Element;<br />
VertexClass AnnotationTypeMemberDeclaration:BodyDeclaration;<br />
VertexClass FieldDeclaration:BodyDeclaration;<br />
VertexClass MethodDeclaration:BodyDeclaration { name:String, constructor:Boolean, dimension:Integer };<br />
VertexClass EnumConstantDeclaration:BodyDeclaration;<br />
VertexClass Initializer:BodyDeclaration;<br />
</syntaxhighlight><br />
<br />
Die Klassendekelartionen selber erben vom Typ <code>AbstractTypeDeclaration</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass AbstractTypeDeclaration:BodyDeclaration;<br />
VertexClass AnnotationTypeDeclaration:AbstractTypeDeclaration;<br />
VertexClass TypeDeclaration:AbstractTypeDeclaration { name:String, interface:Boolean };<br />
VertexClass EnumDeclaration:AbstractTypeDeclaration;<br />
</syntaxhighlight><br />
<br />
In Typ-Referenzen kommen Unterklassen von <code>Type</code> zum Einsatz, ggf. auch von dessen Unterklasse <code>AnnotatableType</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Type:Element;<br />
VertexClass ArrayType:Type { dimensions:Integer };<br />
VertexClass IntersectionType:Type;<br />
VertexClass ParameterizedType:Type { name:String };<br />
VertexClass UnionType:Type; <br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass AnnotatableType:Type;<br />
VertexClass PrimitiveType:AnnotatableType { name:String };<br />
VertexClass SimpleType:AnnotatableType { name:String };<br />
VertexClass QualifiedType:AnnotatableType { name:String };<br />
VertexClass NameQualifiedType:AnnotatableType { name:String };<br />
VertexClass WildcardType:AnnotatableType { upperBound:Boolean };<br />
</syntaxhighlight><br />
<br />
Variablen können einzeln oder als sogenanntes Fragment deklariert werden:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass VariableDeclaration:Element;<br />
VertexClass SingleVariableDeclaration:VariableDeclaration { name:String, varargs:Boolean, dimension:Integer };<br />
VertexClass VariableDeclarationFragment:VariableDeclaration { name:String, dimension:Integer };<br />
</syntaxhighlight><br />
<br />
Alle Anweisungen erben von <code>Statement</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Statement:Element;<br />
VertexClass AssertStatement:Statement;<br />
VertexClass Block:Statement;<br />
VertexClass BreakStatement:Statement { name:String };<br />
VertexClass ConstructorInvocation:Statement;<br />
VertexClass ContinueStatement:Statement { name:String };<br />
VertexClass DoStatement:Statement;<br />
VertexClass EmptyStatement:Statement;<br />
VertexClass EnhancedForStatement:Statement;<br />
VertexClass ExpressionStatement:Statement;<br />
VertexClass ForStatement:Statement;<br />
VertexClass IfStatement:Statement;<br />
VertexClass LabeledStatement:Statement;<br />
VertexClass ReturnStatement:Statement;<br />
VertexClass SuperConstructorInvocation:Statement;<br />
VertexClass SwitchCase:Statement;<br />
VertexClass SwitchStatement:Statement;<br />
VertexClass SynchronizedStatement:Statement;<br />
VertexClass ThrowStatement:Statement;<br />
VertexClass TryStatement:Statement;<br />
VertexClass TypeDeclarationStatement:Statement;<br />
VertexClass VariableDeclarationStatement:Statement;<br />
VertexClass WhileStatement:Statement;<br />
</syntaxhighlight><br />
<br />
Alle Ausdrücke erben von <code>Expression</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Expression:Element;<br />
VertexClass ArrayAccess:Expression;<br />
VertexClass ArrayCreation:Expression;<br />
VertexClass ArrayInitializer:Expression;<br />
VertexClass Assignment:Expression { name:String };<br />
VertexClass BooleanLiteral:Expression { content:String };<br />
VertexClass CastExpression:Expression;<br />
VertexClass CharacterLiteral:Expression { content:String };<br />
VertexClass ClassInstanceCreation:Expression;<br />
VertexClass ConditionalExpression:Expression;<br />
VertexClass FieldAccess:Expression;<br />
VertexClass InfixExpression:Expression { name:String };<br />
VertexClass InstanceofExpression:Expression;<br />
VertexClass LambdaExpression:Expression { parantheses:Boolean };<br />
VertexClass MethodInvocation:Expression { name:String };<br />
VertexClass NullLiteral:Expression;<br />
VertexClass NumberLiteral:Expression { content:String };<br />
VertexClass ParenthesizedExpression:Expression;<br />
VertexClass PostfixExpression:Expression { name:String };<br />
VertexClass PrefixExpression:Expression { name:String };<br />
VertexClass StringLiteral:Expression { content:String };<br />
VertexClass SuperFieldAccess:Expression;<br />
VertexClass SuperMethodInvocation:Expression { name:String };<br />
VertexClass ThisExpression:Expression;<br />
VertexClass TypeLiteral:Expression;<br />
VertexClass VariableDeclarationExpression:Expression;<br />
</syntaxhighlight><br />
<br />
In Variablen und Methoden-Referenzen kommen Unterklassen von <code>Name</code> zum Einsatz:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Name:Expression;<br />
VertexClass SimpleName:Name { name:String };<br />
VertexClass QualifiedName:Name;<br />
</syntaxhighlight><br />
<br />
Annotationen erben von <code>Annotation</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Annotation:Expression;<br />
VertexClass MarkerAnnotation:Annotation;<br />
VertexClass NormalAnnotation:Annotation;<br />
VertexClass SingleMemberAnnotation:Annotation;<br />
</syntaxhighlight><br />
<br />
Methoden-Referenzen erben von <code>MethodReference</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass MethodReference:Expression;<br />
VertexClass CreationReference:MethodReference;<br />
VertexClass ExpressionMethodReference:MethodReference;<br />
VertexClass SuperMethodReference:MethodReference { name:String };<br />
VertexClass TypeMethodReference:MethodReference { name:String };<br />
</syntaxhighlight><br />
<br />
=== Kantentypen ===<br />
<br />
Die Verbindung zwischen Knoten hat auch jeweils einen Kantentyp, der sich aus den beteiligten Typen (oder ggf. deren Obertypen) ergibt. Alle Beziehungen sind als Eltern-Kind-Beziehung definiert, die die Baumstruktur abbildet. Hat ein Eltern-Knoten mehrere Kinder, sind diese entsprechend ihrer Reihenfolge im Code über ein Attribut der Kante durchnummeriert:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract EdgeClass Child from Node (0,1) to Node (0,*) { position:Integer } ;<br />
EdgeClass AnnotationTypeDeclarationAnnotations:Child from AnnotationTypeDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass AnnotationTypeDeclarationBodyDeclarations:Child from AnnotationTypeDeclaration (1,1) to AnnotationTypeMemberDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass AnnotationTypeDeclarationModifiers:Child from AnnotationTypeDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass AnnotationTypeDeclarationName:Child from AnnotationTypeDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass AnnotationTypeMemberDeclarationAnnotations:Child from AnnotationTypeMemberDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass AnnotationTypeMemberDeclarationDefault:Child from AnnotationTypeMemberDeclaration (1,1) to Expression (0,1) role default;<br />
EdgeClass AnnotationTypeMemberDeclarationModifiers:Child from AnnotationTypeMemberDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass AnnotationTypeMemberDeclarationName:Child from AnnotationTypeMemberDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass AnnotationTypeMemberDeclarationType:Child from AnnotationTypeMemberDeclaration (1,1) to Type (0,1) role type;<br />
EdgeClass AnonymousClassDeclarationBodyDeclarations:Child from AnonymousClassDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass ArrayAccessArray:Child from ArrayAccess (1,1) to Expression (0,1) role array;<br />
EdgeClass ArrayAccessIndex:Child from ArrayAccess (1,1) to Expression (0,1) role index;<br />
EdgeClass ArrayCreationDimensions:Child from ArrayCreation (1,1) to Expression (0,*) role dimensions;<br />
EdgeClass ArrayCreationInitializer:Child from ArrayCreation (1,1) to ArrayInitializer (0,1) role initializer;<br />
EdgeClass ArrayCreationType:Child from ArrayCreation (1,1) to ArrayType (0,1) role type;<br />
EdgeClass ArrayInitializerExpressions:Child from ArrayInitializer (1,1) to Expression (0,*) role expressions;<br />
EdgeClass ArrayTypeComponentType:Child from ArrayType (1,1) to Type (0,1) role elementType;<br />
EdgeClass AssertStatementMessage:Child from AssertStatement (1,1) to Expression (0,1) role message;<br />
EdgeClass AssignmentLeftHandSide:Child from Assignment (1,1) to Expression (0,1) role leftHandSide;<br />
EdgeClass AssignmentRightHandSide:Child from Assignment (1,1) to Expression (0,1) role rightHandSide;<br />
EdgeClass BlockStatements:Child from Block (1,1) to Statement (0,*) role statements;<br />
EdgeClass BodyDeclarationJavadoc:Child from BodyDeclaration (1,1) to Javadoc (0,1) role javadoc;<br />
EdgeClass CastExpressionType:Child from CastExpression (1,1) to Type (0,1) role type;<br />
EdgeClass CatchClauseBody:Child from CatchClause (1,1) to Block (0,*) role body;<br />
EdgeClass CatchClauseException:Child from CatchClause (1,1) to SingleVariableDeclaration (0,*) role exception;<br />
EdgeClass ClassInstanceCreationAnonymousClassDecl:Child from ClassInstanceCreation (1,1) to AnonymousClassDeclaration (0,1) role anonymousClassDeclaration;<br />
EdgeClass ClassInstanceCreationArguments:Child from ClassInstanceCreation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass ClassInstanceCreationType:Child from ClassInstanceCreation (1,1) to Type (0,1) role type;<br />
EdgeClass CompilationUnitImports:Child from CompilationUnit (1,1) to ImportDeclaration (0,*) role imports;<br />
EdgeClass CompilationUnitPackage:Child from CompilationUnit (1,1) to PackageDeclaration (0,*) role package;<br />
EdgeClass CompilationUnitTypes:Child from CompilationUnit (1,1) to AbstractTypeDeclaration (0,*) role types;<br />
EdgeClass ConditionalExpressionElseExpression:Child from ConditionalExpression (1,1) to Expression (0,1) role elseExpression;<br />
EdgeClass ConditionalExpressionThenExpression:Child from ConditionalExpression (1,1) to Expression (0,1) role thenExpression;<br />
EdgeClass ConstructorInvocationArguments:Child from ConstructorInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass ConstructorInvocationTypeArguments:Child from ConstructorInvocation (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass CreationReferenceTypeArguments:Child from CreationReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass CreationReferenceType:Child from CreationReference (1,1) to Type (0,1) role type;<br />
EdgeClass DimensionAnnotations:Child from Dimension (1,1) to Annotation (0,*) role annotations;<br />
EdgeClass DoStatementBody:Child from DoStatement (1,1) to Block (0,1) role body;<br />
EdgeClass ElementExpression:Child from Element (1,1) to Expression (0,*) role expression;<br />
EdgeClass EnhancedForStatementBody:Child from EnhancedForStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass EnhancedForStatementParameter:Child from EnhancedForStatement (1,1) to SingleVariableDeclaration (0,1) role parameter;<br />
EdgeClass EnumConstantDeclarationAnonymousClassDeclaration:Child from EnumConstantDeclaration (1,1) to AnonymousClassDeclaration (0,1) role anonymousClassDeclaration;<br />
EdgeClass EnumConstantDeclarationAnnotations:Child from EnumConstantDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass EnumConstantDeclarationArguments:Child from EnumConstantDeclaration (1,1) to Expression (0,*) role arguments;<br />
EdgeClass EnumConstantDeclarationModifiers:Child from EnumConstantDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass EnumConstantDeclarationName:Child from EnumConstantDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass EnumDeclarationAnnotations:Child from EnumDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass EnumDeclarationBodyDeclaration:Child from EnumDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass EnumDeclarationEnumConstants:Child from EnumDeclaration (1,1) to EnumConstantDeclaration (0,*) role enumConstants;<br />
EdgeClass EnumDeclarationModifiers:Child from EnumDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass EnumDeclarationName:Child from EnumDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass EnumDeclarationSuperInterfaceTypes:Child from EnumDeclaration (1,1) to Type (0,*) role superInterfaceTypes; <br />
EdgeClass ExpressionMethodReferenceArguments:Child from ExpressionMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass ExpressionMethodReferenceName:Child from ExpressionMethodReference (1,1) to SimpleName (0,1) role name;<br />
EdgeClass FieldAccessName:Child from FieldAccess (1,1) to SimpleName (0,1) role name;<br />
EdgeClass FieldDeclarationAnnotation:Child from FieldDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass FieldDeclarationFragments:Child from FieldDeclaration (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass FieldDeclarationModifiers:Child from FieldDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass FieldDeclarationType:Child from FieldDeclaration (1,1) to Type (0,1) role type;<br />
EdgeClass ForStatementBody:Child from ForStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass ForStatementInitializers:Child from ForStatement (1,1) to Expression (0,*) role initializers;<br />
EdgeClass ForStatementUpdaters:Child from ForStatement (1,1) to Expression (0,*) role updaters;<br />
EdgeClass IfStatementElseStatement:Child from IfStatement (1,1) to Statement (0,1) role elseStatement;<br />
EdgeClass IfStatementThenStatement:Child from IfStatement (1,1) to Statement (0,1) role thenStatement;<br />
EdgeClass IJavaProjectFragements:Child from IJavaProject (1,1) to IPackageFragment (0,*) role fragments;<br />
EdgeClass IJavaProjectUnits:Child from IJavaProject (1,1) to CompilationUnit (0,*) role units;<br />
EdgeClass InfixExpressionExtendedOperands:Child from InfixExpression (1,1) to Expression (0,*) role extendedOperands;<br />
EdgeClass InfixExpressionLeftOperand:Child from InfixExpression (1,1) to Expression (0,1) role leftOperand;<br />
EdgeClass InfixExpressionRightOperand:Child from InfixExpression (1,1) to Expression (0,1) role rightOperand;<br />
EdgeClass InitializerAnnotation:Child from Initializer (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass InitializerBody:Child from Initializer (1,1) to Block (0,1) role body;<br />
EdgeClass InitializerModifiers:Child from Initializer (1,1) to Modifier(0,*) role modifiers2;<br />
EdgeClass IntersectionTypeTypes:Child from IntersectionType (1,1) to Type (0,*) role types;<br />
EdgeClass InstanceofExpressionLeftOperand:Child from InstanceofExpression (1,1) to Expression (0,1) role leftOperand;<br />
EdgeClass InstanceofExpressionRightOperand:Child from InstanceofExpression (1,1) to Type (0,1) role rightOperand;<br />
EdgeClass IPackageFragmentUnits:Child from IPackageFragment (1,1) to CompilationUnit (0,*) role units;<br />
EdgeClass JavadocTags:Child from Javadoc (1,1) to TagElement (0,*) role tags;<br />
EdgeClass LambdaExpressionBody:Child from LambdaExpression (1,1) to Element (0,1) role body;<br />
EdgeClass LambdaExpressionParameters:Child from LambdaExpression (1,1) to VariableDeclaration (0,*) role parameters;<br />
EdgeClass LabeledStatementBody:Child from LabeledStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass LabeledStatementLabel:Child from LabeledStatement (1,1) to SimpleName (0,1) role label;<br />
EdgeClass MarkerAnnotationTypeName:Child from MarkerAnnotation (1,1) to SimpleName (0,*) role typeName;<br />
EdgeClass MemberRefName:Child from MemberRef (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MemberRefQualifier:Child from MemberRef (1,1) to Name (0,1) role qualifier;<br />
EdgeClass MemberValuePairName:Child from MemberValuePair (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MemberValuePairValue:Child from MemberValuePair (1,1) to Expression (0,1) role value;<br />
EdgeClass MethodDeclarationAnnotation:Child from MethodDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass MethodDeclarationBody:Child from MethodDeclaration (1,1) to Block (0,1) role body;<br />
EdgeClass MethodDeclarationModifiers:Child from MethodDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass MethodDeclarationParameters:Child from MethodDeclaration (1,1) to SingleVariableDeclaration (0,*) role parameters;<br />
EdgeClass MethodDeclarationReceiverQualifier:Child from MethodDeclaration (1,1) to SimpleName (0,1) role receiverQualifier;<br />
EdgeClass MethodDeclarationReceiverType:Child from MethodDeclaration (1,1) to Type (0,1) role receiverType;<br />
EdgeClass MethodDeclarationReturnType:Child from MethodDeclaration (1,1) to Type (0,1) role returnType2;<br />
EdgeClass MethodDeclarationThrownExceptions:Child from MethodDeclaration (1,1) to Type (0,*) role thrownExceptionTypes;<br />
EdgeClass MethodDeclarationTypeParameters:Child from MethodDeclaration (1,1) to TypeParameter (0,*) role typeParameters;<br />
EdgeClass MethodInvocationArguments:Child from MethodInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass MethodRefName:Child from MethodRef (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MethodRefParameters:Child from MethodRef (1,1) to MethodRefParameter (0,*) role parameters;<br />
EdgeClass MethodRefQualifier:Child from MethodRef (1,1) to Name (0,1) role qualifier;<br />
EdgeClass MethodRefParameterName:Child from MethodRefParameter (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MethodRefParameterType:Child from MethodRefParameter (1,1) to Type (0,1) role type;<br />
EdgeClass NormalAnnotationTypeName:Child from NormalAnnotation (1,1) to Name (0,1) role typeName;<br />
EdgeClass NormalAnnotationValues:Child from NormalAnnotation (1,1) to MemberValuePair (0,*) role values;<br />
EdgeClass ParameterizedTypeType:Child from ParameterizedType (1,1) to SimpleType (0,1) role type;<br />
EdgeClass ParameterizedTypeTypeArguments:Child from ParameterizedType (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass PostfixExpressionOperand:Child from PostfixExpression (1,1) to SimpleName (0,1) role operand;<br />
EdgeClass PrefixExpressionOperand:Child from PrefixExpression (1,1) to Expression (0,1) role operand;<br />
EdgeClass QualifiedNameName:Child from QualifiedName (1,1) to SimpleName (0,1) role name;<br />
EdgeClass QualifiedNameQualifier:Child from QualifiedName (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SimpleNameValues:Child from SimpleName (1,1) to MethodDeclaration (0,*) role values;<br />
EdgeClass SimpleTypeAnnotation:Child from SimpleType (1,1) to Annotation (0,*) role annotations;<br />
EdgeClass SimpleTypeName:Child from SimpleType (1,1) to Name (0,1) role name2;<br />
EdgeClass SingleMemberAnnotationTypeName:Child from SingleMemberAnnotation (1,1) to SimpleName (0,1) role typeName;<br />
EdgeClass SingleMemberAnnotationValue:Child from SingleMemberAnnotation (1,1) to Expression (0,1) role value;<br />
EdgeClass SingleVariableDeclarationAnnotation:Child from SingleVariableDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass SingleVariableDeclarationExtraDimensions:Child from SingleVariableDeclaration (1,1) to Dimension (0,*) role extraDimensions2;<br />
EdgeClass SingleVariableDeclarationInitializer:Child from SingleVariableDeclaration (1,1) to Expression (0,1) role initializer;<br />
EdgeClass SingleVariableDeclarationModifiers:Child from SingleVariableDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass SingleVariableDeclarationType:Child from SingleVariableDeclaration (1,1) to Type (0,*) role type;<br />
EdgeClass SingleVariableDeclarationVarargsAnnotations:Child from SingleVariableDeclaration (1,1) to Annotation (0,*) role varargsAnnotations;<br />
EdgeClass SuperConstructorInvocationArgument:Child from SuperConstructorInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass SuperConstructorInvocationTypeArguments:Child from SuperConstructorInvocation (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass SuperFieldAccessName:Child from SuperFieldAccess (1,1) to SimpleName (0,1) role name;<br />
EdgeClass SuperFieldAccessQualifier:Child from SuperFieldAccess(1,1) to Name (0,1) role qualifier;<br />
EdgeClass SuperMethodInvocationArguments:Child from SuperMethodInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass SuperMethodInvocationQualifier:Child from SuperMethodInvocation (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SuperMethodReferenceArguments:Child from SuperMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass SuperMethodReferenceQualifier:Child from SuperMethodReference (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SwitchStatementStatements:Child from SwitchStatement (1,1) to Statement (0,*) role statements;<br />
EdgeClass SynchronizedStatementBlock:Child from SynchronizedStatement (1,1) to Block (0,1) role body;<br />
EdgeClass TagElementFragments1:Child from TagElement (1,1) to TextElement (0,*) role fragments1;<br />
EdgeClass TagElementFragments2:Child from TagElement (1,1) to Name (0,*) role fragments2;<br />
EdgeClass TagElementFragments3:Child from TagElement (1,1) to MethodRef (0,*) role fragments3;<br />
EdgeClass TagElementFragments4:Child from TagElement (1,1) to MemberRef (0,*) role fragments4;<br />
EdgeClass TagElementFragments5:Child from TagElement (1,1) to TagElement (0,*) role fragments5;<br />
EdgeClass ThisExpressionQualifier:Child from ThisExpression (1,1) to Name (0,1) role qualifier;<br />
EdgeClass TryStatementBody:Child from TryStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass TryStatementCatchClauses:Child from TryStatement (1,1) to CatchClause (0,*) role catchClauses;<br />
EdgeClass TryStatementFinally:Child from TryStatement (1,1) to Block (0,1) role finally;<br />
EdgeClass TryStatementResources:Child from TryStatement (1,1) to VariableDeclarationExpression (0,*) role resources;<br />
EdgeClass TypeDeclarationAnnotation:Child from TypeDeclaration (1,1) to Annotation (0,*) role modifiers2;<br />
EdgeClass TypeDeclarationBodyDeclarations1:Child from TypeDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass TypeDeclarationModifiers:Child from TypeDeclaration (1,1) to Modifier (0,*) role modifiers1;<br />
EdgeClass TypeDeclarationSuperclassType:Child from TypeDeclaration (1,1) to Type (0,1) role superclassType;<br />
EdgeClass TypeDeclarationSuperInterfaceTypes:Child from TypeDeclaration (1,1) to Type (0,*) role superInterfaceTypes;<br />
EdgeClass TypeDeclarationTypeParameters:Child from TypeDeclaration (1,1) to TypeParameter (0,*) role typeParameters;<br />
EdgeClass TypeLiteralType:Child from TypeLiteral (1,1) to Type (0,1) role type;<br />
EdgeClass TypeMethodReferenceArguments:Child from TypeMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass TypeMethodReferenceType:Child from TypeMethodReference (1,1) to Type (0,1) role type;<br />
EdgeClass TypeParameterName:Child from TypeParameter (1,1) to SimpleName (0,1) role name;<br />
EdgeClass TypeParameterType:Child from TypeParameter (1,1) to Type (0,*) role typeBounds;<br />
EdgeClass UnionTypeTypes:Child from UnionType (1,1) to Type (0,*) role types;<br />
EdgeClass VariableDeclarationExpressionAnnotation:Child from VariableDeclarationExpression (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass VariableDeclarationExpressionFragments:Child from VariableDeclarationExpression (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass VariableDeclarationExpressionModifiers:Child from VariableDeclarationExpression (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass VariableDeclarationExpressionType:Child from VariableDeclarationExpression (1,1) to Type (0,1) role type;<br />
EdgeClass VariableDeclarationFragmentInitializer:Child from VariableDeclarationFragment (1,1) to Expression (0,1) role initializer;<br />
EdgeClass VariableDeclarationStatementFragments:Child from VariableDeclarationStatement (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass VariableDeclarationStatementModifier:Child from VariableDeclarationStatement (1,1) to Modifier (0,*) role modifiers;<br />
EdgeClass VariableDeclarationStatementType:Child from VariableDeclarationStatement (1,1) to Type (0,1) role type;<br />
EdgeClass WhileStatementBody:Child from WhileStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass WildcardTypeBound1:Child from WildcardType (1,1) to ParameterizedType (0,*) role bound1;<br />
EdgeClass WildcardTypeBound2:Child from WildcardType (1,1) to SimpleType (0,*) role bound2;<br />
</syntaxhighlight><br />
<br />
JACK erzeugt zusätzliche Kanten vom Typ <code>Access </code>, mit denen vom Zugriff auf ein Element auf dessen Deklaration verwiesen wird. Diese Kanten sind nicht Teil des Syntaxbaumes, sondern erweitern ihn zu einem Graph. Sie stehen nur zur Verfügung, wenn Zugriff und Deklaration innerhalb des geparsten Codes liegen:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract EdgeClass Access from Node (0,1) to Node (0,*);<br />
EdgeClass ExpressionAccess1:Access from Expression (1,1) to BodyDeclaration (0,*) role access1;<br />
EdgeClass ExpressionAccess2:Access from Expression (1,1) to VariableDeclaration (0,*) role access2;<br />
EdgeClass TypeAccess:Access from Type (1,1) to TypeDeclaration (0,*) role access;<br />
</syntaxhighlight><br />
<br />
== Beispiel ==<br />
<br />
Exemplarischer Code in Java:<br />
<br />
<syntaxhighlight lang="Java" line="line"><br />
<br />
public class Computer {<br />
<br />
public Computer(int price) {<br />
this.price = price;<br />
}<br />
<br />
private int price = 0;<br />
<br />
public int getPrice() {<br />
return price;<br />
}<br />
<br />
public static Computer[] getSortedByPrice(Computer[] computers) {<br />
for (int n = computers.length; n > 1; n--) {<br />
for (int i = 0; i < n - 1; i++) {<br />
if (computers[i].price > computers[i + 1].price) {<br />
Computer swapComputer = computers[i + 1];<br />
computers[i + 1] = computers[i];<br />
computers[i] = swapComputer;<br />
}<br />
}<br />
}<br />
return computers;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Zugehöriger Syntaxgraph:<br />
<br />
[[Datei:syntaxgraph-computer.png|600px|thumb|left]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQL-Typegraph_f%C3%BCr_Java&diff=8973GReQL-Typegraph für Java2023-08-25T10:52:51Z<p>Striewe: </p>
<hr />
<div>Grundsätzlich folgt der Typegraph für GReQL-Queries zu Java der Java Language Specification für Java 8. Der Syntaxgraph wird durch den Eclipse-Parser erzeugt und verwendet die entsprechenden Namen für die Syntaxelemente. An einigen Stellen gibt es kleine Vereinfachungen und Erweiterungen.<br />
<br />
== Typegraph-Definitionen == <br />
<br />
=== Knotentypen ===<br />
<br />
Alle Knoten erben vom abstrakten Typen <code>Node</code>. Zwei spezielle Knoten werden durch den Eclipse-Parser erzeugt und bilden die Wurzel und das erste Kind-Element des Syntaxbaumes.<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Node;<br />
VertexClass IJavaProject: Node { name:String };<br />
VertexClass IPackageFragment: Node { name:String };<br />
</syntaxhighlight><br />
<br />
Alle Sprachelemente von Java erben von <code>Element</code> und erhalten darüber eine Zuordnung zu einer Zeilennummer.<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Element: Node { line:Integer };<br />
VertexClass AnonymousClassDeclaration:Element;<br />
VertexClass CatchClause:Element;<br />
VertexClass Comment:Element;<br />
VertexClass CompilationUnit:Element { name:String };<br />
VertexClass Dimension:Element;<br />
VertexClass ImportDeclaration:Element { name:String, onDemand:Boolean, static:Boolean };<br />
VertexClass Javadoc:Element;<br />
VertexClass MemberRef:Element;<br />
VertexClass MemberValuePair:Element;<br />
VertexClass MethodRef:Element;<br />
VertexClass MethodRefParameter:Element { varargs:Boolean };<br />
VertexClass Modifier:Element { name:String };<br />
VertexClass PackageDeclaration:Element { name:String };<br />
VertexClass TagElement:Element { name:String };<br />
VertexClass TextElement:Element { content:String };<br />
VertexClass TypeParameter:Element;<br />
</syntaxhighlight><br />
<br />
Deklarationen innerhalb einer Klasse (im Gegensatz zu den oben enthaltenen Import-Deklarationen) erben vom Typ <code>BodyDeclaration</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass BodyDeclaration:Element;<br />
VertexClass AnnotationTypeMemberDeclaration:BodyDeclaration;<br />
VertexClass FieldDeclaration:BodyDeclaration;<br />
VertexClass MethodDeclaration:BodyDeclaration { name:String, constructor:Boolean, dimension:Integer };<br />
VertexClass EnumConstantDeclaration:BodyDeclaration;<br />
VertexClass Initializer:BodyDeclaration;<br />
</syntaxhighlight><br />
<br />
Die Klassendekelartionen selber erben vom Typ <code>AbstractTypeDeclaration</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass AbstractTypeDeclaration:BodyDeclaration;<br />
VertexClass AnnotationTypeDeclaration:AbstractTypeDeclaration;<br />
VertexClass TypeDeclaration:AbstractTypeDeclaration { name:String, interface:Boolean };<br />
VertexClass EnumDeclaration:AbstractTypeDeclaration;<br />
</syntaxhighlight><br />
<br />
In Typ-Referenzen kommen Unterklassen von <code>Type</code> zum Einsatz, ggf. auch von dessen Unterklasse <code>AnnotatableType</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Type:Element;<br />
VertexClass ArrayType:Type { dimensions:Integer };<br />
VertexClass IntersectionType:Type;<br />
VertexClass ParameterizedType:Type { name:String };<br />
VertexClass UnionType:Type; <br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass AnnotatableType:Type;<br />
VertexClass PrimitiveType:AnnotatableType { name:String };<br />
VertexClass SimpleType:AnnotatableType { name:String };<br />
VertexClass QualifiedType:AnnotatableType { name:String };<br />
VertexClass NameQualifiedType:AnnotatableType { name:String };<br />
VertexClass WildcardType:AnnotatableType { upperBound:Boolean };<br />
</syntaxhighlight><br />
<br />
Variablen können einzeln oder als sogenanntes Fragment deklariert werden:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass VariableDeclaration:Element;<br />
VertexClass SingleVariableDeclaration:VariableDeclaration { name:String, varargs:Boolean, dimension:Integer };<br />
VertexClass VariableDeclarationFragment:VariableDeclaration { name:String, dimension:Integer };<br />
</syntaxhighlight><br />
<br />
Alle Anweisungen erben von <code>Statement</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Statement:Element;<br />
VertexClass AssertStatement:Statement;<br />
VertexClass Block:Statement;<br />
VertexClass BreakStatement:Statement { name:String };<br />
VertexClass ConstructorInvocation:Statement;<br />
VertexClass ContinueStatement:Statement { name:String };<br />
VertexClass DoStatement:Statement;<br />
VertexClass EmptyStatement:Statement;<br />
VertexClass EnhancedForStatement:Statement;<br />
VertexClass ExpressionStatement:Statement;<br />
VertexClass ForStatement:Statement;<br />
VertexClass IfStatement:Statement;<br />
VertexClass LabeledStatement:Statement;<br />
VertexClass ReturnStatement:Statement;<br />
VertexClass SuperConstructorInvocation:Statement;<br />
VertexClass SwitchCase:Statement;<br />
VertexClass SwitchStatement:Statement;<br />
VertexClass SynchronizedStatement:Statement;<br />
VertexClass ThrowStatement:Statement;<br />
VertexClass TryStatement:Statement;<br />
VertexClass TypeDeclarationStatement:Statement;<br />
VertexClass VariableDeclarationStatement:Statement;<br />
VertexClass WhileStatement:Statement;<br />
</syntaxhighlight><br />
<br />
Alle Ausdrücke erben von <code>Expression</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Expression:Element;<br />
VertexClass ArrayAccess:Expression;<br />
VertexClass ArrayCreation:Expression;<br />
VertexClass ArrayInitializer:Expression;<br />
VertexClass Assignment:Expression { name:String };<br />
VertexClass BooleanLiteral:Expression { content:String };<br />
VertexClass CastExpression:Expression;<br />
VertexClass CharacterLiteral:Expression { content:String };<br />
VertexClass ClassInstanceCreation:Expression;<br />
VertexClass ConditionalExpression:Expression;<br />
VertexClass FieldAccess:Expression;<br />
VertexClass InfixExpression:Expression { name:String };<br />
VertexClass InstanceofExpression:Expression;<br />
VertexClass LambdaExpression:Expression { parantheses:Boolean };<br />
VertexClass MethodInvocation:Expression { name:String };<br />
VertexClass NullLiteral:Expression;<br />
VertexClass NumberLiteral:Expression { content:String };<br />
VertexClass ParenthesizedExpression:Expression;<br />
VertexClass PostfixExpression:Expression { name:String };<br />
VertexClass PrefixExpression:Expression { name:String };<br />
VertexClass StringLiteral:Expression { content:String };<br />
VertexClass SuperFieldAccess:Expression;<br />
VertexClass SuperMethodInvocation:Expression { name:String };<br />
VertexClass ThisExpression:Expression;<br />
VertexClass TypeLiteral:Expression;<br />
VertexClass VariableDeclarationExpression:Expression;<br />
</syntaxhighlight><br />
<br />
In Variablen und Methoden-Referenzen kommen Unterklassen von <code>Name</code> zum Einsatz:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Name:Expression;<br />
VertexClass SimpleName:Name { name:String };<br />
VertexClass QualifiedName:Name;<br />
</syntaxhighlight><br />
<br />
Annotationen erben von <code>Annotation</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Annotation:Expression;<br />
VertexClass MarkerAnnotation:Annotation;<br />
VertexClass NormalAnnotation:Annotation;<br />
VertexClass SingleMemberAnnotation:Annotation;<br />
</syntaxhighlight><br />
<br />
Methoden-Referenzen erben von <code>MethodReference</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass MethodReference:Expression;<br />
VertexClass CreationReference:MethodReference;<br />
VertexClass ExpressionMethodReference:MethodReference;<br />
VertexClass SuperMethodReference:MethodReference { name:String };<br />
VertexClass TypeMethodReference:MethodReference { name:String };<br />
</syntaxhighlight><br />
<br />
=== Kantentypen ===<br />
<br />
Die Verbindung zwischen Knoten hat auch jeweils einen Kantentyp, der sich aus den beteiligten Typen (oder ggf. deren Obertypen) ergibt. Alle Beziehungen sind als Eltern-Kind-Beziehung definiert, die die Baumstruktur abbildet. Hat ein Eltern-Knoten mehrere Kinder, sind diese entsprechend ihrer Reihenfolge im Code über ein Attribut der Kante durchnummeriert:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract EdgeClass Child from Node (0,1) to Node (0,*) { position:Integer } ;<br />
EdgeClass AnnotationTypeDeclarationAnnotations:Child from AnnotationTypeDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass AnnotationTypeDeclarationBodyDeclarations:Child from AnnotationTypeDeclaration (1,1) to AnnotationTypeMemberDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass AnnotationTypeDeclarationModifiers:Child from AnnotationTypeDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass AnnotationTypeDeclarationName:Child from AnnotationTypeDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass AnnotationTypeMemberDeclarationAnnotations:Child from AnnotationTypeMemberDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass AnnotationTypeMemberDeclarationDefault:Child from AnnotationTypeMemberDeclaration (1,1) to Expression (0,1) role default;<br />
EdgeClass AnnotationTypeMemberDeclarationModifiers:Child from AnnotationTypeMemberDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass AnnotationTypeMemberDeclarationName:Child from AnnotationTypeMemberDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass AnnotationTypeMemberDeclarationType:Child from AnnotationTypeMemberDeclaration (1,1) to Type (0,1) role type;<br />
EdgeClass AnonymousClassDeclarationBodyDeclarations:Child from AnonymousClassDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass ArrayAccessArray:Child from ArrayAccess (1,1) to Expression (0,1) role array;<br />
EdgeClass ArrayAccessIndex:Child from ArrayAccess (1,1) to Expression (0,1) role index;<br />
EdgeClass ArrayCreationDimensions:Child from ArrayCreation (1,1) to Expression (0,*) role dimensions;<br />
EdgeClass ArrayCreationInitializer:Child from ArrayCreation (1,1) to ArrayInitializer (0,1) role initializer;<br />
EdgeClass ArrayCreationType:Child from ArrayCreation (1,1) to ArrayType (0,1) role type;<br />
EdgeClass ArrayInitializerExpressions:Child from ArrayInitializer (1,1) to Expression (0,*) role expressions;<br />
EdgeClass ArrayTypeComponentType:Child from ArrayType (1,1) to Type (0,1) role elementType;<br />
EdgeClass AssertStatementMessage:Child from AssertStatement (1,1) to Expression (0,1) role message;<br />
EdgeClass AssignmentLeftHandSide:Child from Assignment (1,1) to Expression (0,1) role leftHandSide;<br />
EdgeClass AssignmentRightHandSide:Child from Assignment (1,1) to Expression (0,1) role rightHandSide;<br />
EdgeClass BlockStatements:Child from Block (1,1) to Statement (0,*) role statements;<br />
EdgeClass BodyDeclarationJavadoc:Child from BodyDeclaration (1,1) to Javadoc (0,1) role javadoc;<br />
EdgeClass CastExpressionType:Child from CastExpression (1,1) to Type (0,1) role type;<br />
EdgeClass CatchClauseBody:Child from CatchClause (1,1) to Block (0,*) role body;<br />
EdgeClass CatchClauseException:Child from CatchClause (1,1) to SingleVariableDeclaration (0,*) role exception;<br />
EdgeClass ClassInstanceCreationAnonymousClassDecl:Child from ClassInstanceCreation (1,1) to AnonymousClassDeclaration (0,1) role anonymousClassDeclaration;<br />
EdgeClass ClassInstanceCreationArguments:Child from ClassInstanceCreation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass ClassInstanceCreationType:Child from ClassInstanceCreation (1,1) to Type (0,1) role type;<br />
EdgeClass CompilationUnitImports:Child from CompilationUnit (1,1) to ImportDeclaration (0,*) role imports;<br />
EdgeClass CompilationUnitPackage:Child from CompilationUnit (1,1) to PackageDeclaration (0,*) role package;<br />
EdgeClass CompilationUnitTypes:Child from CompilationUnit (1,1) to AbstractTypeDeclaration (0,*) role types;<br />
EdgeClass ConditionalExpressionElseExpression:Child from ConditionalExpression (1,1) to Expression (0,1) role elseExpression;<br />
EdgeClass ConditionalExpressionThenExpression:Child from ConditionalExpression (1,1) to Expression (0,1) role thenExpression;<br />
EdgeClass ConstructorInvocationArguments:Child from ConstructorInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass ConstructorInvocationTypeArguments:Child from ConstructorInvocation (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass CreationReferenceTypeArguments:Child from CreationReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass CreationReferenceType:Child from CreationReference (1,1) to Type (0,1) role type;<br />
EdgeClass DimensionAnnotations:Child from Dimension (1,1) to Annotation (0,*) role annotations;<br />
EdgeClass DoStatementBody:Child from DoStatement (1,1) to Block (0,1) role body;<br />
EdgeClass ElementExpression:Child from Element (1,1) to Expression (0,*) role expression;<br />
EdgeClass EnhancedForStatementBody:Child from EnhancedForStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass EnhancedForStatementParameter:Child from EnhancedForStatement (1,1) to SingleVariableDeclaration (0,1) role parameter;<br />
EdgeClass EnumConstantDeclarationAnonymousClassDeclaration:Child from EnumConstantDeclaration (1,1) to AnonymousClassDeclaration (0,1) role anonymousClassDeclaration;<br />
EdgeClass EnumConstantDeclarationAnnotations:Child from EnumConstantDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass EnumConstantDeclarationArguments:Child from EnumConstantDeclaration (1,1) to Expression (0,*) role arguments;<br />
EdgeClass EnumConstantDeclarationModifiers:Child from EnumConstantDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass EnumConstantDeclarationName:Child from EnumConstantDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass EnumDeclarationAnnotations:Child from EnumDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass EnumDeclarationBodyDeclaration:Child from EnumDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass EnumDeclarationEnumConstants:Child from EnumDeclaration (1,1) to EnumConstantDeclaration (0,*) role enumConstants;<br />
EdgeClass EnumDeclarationModifiers:Child from EnumDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass EnumDeclarationName:Child from EnumDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass EnumDeclarationSuperInterfaceTypes:Child from EnumDeclaration (1,1) to Type (0,*) role superInterfaceTypes; <br />
EdgeClass ExpressionMethodReferenceArguments:Child from ExpressionMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass ExpressionMethodReferenceName:Child from ExpressionMethodReference (1,1) to SimpleName (0,1) role name;<br />
EdgeClass FieldAccessName:Child from FieldAccess (1,1) to SimpleName (0,1) role name;<br />
EdgeClass FieldDeclarationAnnotation:Child from FieldDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass FieldDeclarationFragments:Child from FieldDeclaration (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass FieldDeclarationModifiers:Child from FieldDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass FieldDeclarationType:Child from FieldDeclaration (1,1) to Type (0,1) role type;<br />
EdgeClass ForStatementBody:Child from ForStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass ForStatementInitializers:Child from ForStatement (1,1) to Expression (0,*) role initializers;<br />
EdgeClass ForStatementUpdaters:Child from ForStatement (1,1) to Expression (0,*) role updaters;<br />
EdgeClass IfStatementElseStatement:Child from IfStatement (1,1) to Statement (0,1) role elseStatement;<br />
EdgeClass IfStatementThenStatement:Child from IfStatement (1,1) to Statement (0,1) role thenStatement;<br />
EdgeClass IJavaProjectFragements:Child from IJavaProject (1,1) to IPackageFragment (0,*) role fragments;<br />
EdgeClass IJavaProjectUnits:Child from IJavaProject (1,1) to CompilationUnit (0,*) role units;<br />
EdgeClass InfixExpressionExtendedOperands:Child from InfixExpression (1,1) to Expression (0,*) role extendedOperands;<br />
EdgeClass InfixExpressionLeftOperand:Child from InfixExpression (1,1) to Expression (0,1) role leftOperand;<br />
EdgeClass InfixExpressionRightOperand:Child from InfixExpression (1,1) to Expression (0,1) role rightOperand;<br />
EdgeClass InitializerAnnotation:Child from Initializer (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass InitializerBody:Child from Initializer (1,1) to Block (0,1) role body;<br />
EdgeClass InitializerModifiers:Child from Initializer (1,1) to Modifier(0,*) role modifiers2;<br />
EdgeClass IntersectionTypeTypes:Child from IntersectionType (1,1) to Type (0,*) role types;<br />
EdgeClass InstanceofExpressionLeftOperand:Child from InstanceofExpression (1,1) to Expression (0,1) role leftOperand;<br />
EdgeClass InstanceofExpressionRightOperand:Child from InstanceofExpression (1,1) to Type (0,1) role rightOperand;<br />
EdgeClass IPackageFragmentUnits:Child from IPackageFragment (1,1) to CompilationUnit (0,*) role units;<br />
EdgeClass JavadocTags:Child from Javadoc (1,1) to TagElement (0,*) role tags;<br />
EdgeClass LambdaExpressionBody:Child from LambdaExpression (1,1) to Element (0,1) role body;<br />
EdgeClass LambdaExpressionParameters:Child from LambdaExpression (1,1) to VariableDeclaration (0,*) role parameters;<br />
EdgeClass LabeledStatementBody:Child from LabeledStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass LabeledStatementLabel:Child from LabeledStatement (1,1) to SimpleName (0,1) role label;<br />
EdgeClass MarkerAnnotationTypeName:Child from MarkerAnnotation (1,1) to SimpleName (0,*) role typeName;<br />
EdgeClass MemberRefName:Child from MemberRef (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MemberRefQualifier:Child from MemberRef (1,1) to Name (0,1) role qualifier;<br />
EdgeClass MemberValuePairName:Child from MemberValuePair (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MemberValuePairValue:Child from MemberValuePair (1,1) to Expression (0,1) role value;<br />
EdgeClass MethodDeclarationAnnotation:Child from MethodDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass MethodDeclarationBody:Child from MethodDeclaration (1,1) to Block (0,1) role body;<br />
EdgeClass MethodDeclarationModifiers:Child from MethodDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass MethodDeclarationParameters:Child from MethodDeclaration (1,1) to SingleVariableDeclaration (0,*) role parameters;<br />
EdgeClass MethodDeclarationReceiverQualifier:Child from MethodDeclaration (1,1) to SimpleName (0,1) role receiverQualifier;<br />
EdgeClass MethodDeclarationReceiverType:Child from MethodDeclaration (1,1) to Type (0,1) role receiverType;<br />
EdgeClass MethodDeclarationReturnType:Child from MethodDeclaration (1,1) to Type (0,1) role returnType2;<br />
EdgeClass MethodDeclarationThrownExceptions:Child from MethodDeclaration (1,1) to Type (0,*) role thrownExceptionTypes;<br />
EdgeClass MethodDeclarationTypeParameters:Child from MethodDeclaration (1,1) to TypeParameter (0,*) role typeParameters;<br />
EdgeClass MethodInvocationArguments:Child from MethodInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass MethodRefName:Child from MethodRef (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MethodRefParameters:Child from MethodRef (1,1) to MethodRefParameter (0,*) role parameters;<br />
EdgeClass MethodRefQualifier:Child from MethodRef (1,1) to Name (0,1) role qualifier;<br />
EdgeClass MethodRefParameterName:Child from MethodRefParameter (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MethodRefParameterType:Child from MethodRefParameter (1,1) to Type (0,1) role type;<br />
EdgeClass NormalAnnotationTypeName:Child from NormalAnnotation (1,1) to Name (0,1) role typeName;<br />
EdgeClass NormalAnnotationValues:Child from NormalAnnotation (1,1) to MemberValuePair (0,*) role values;<br />
EdgeClass ParameterizedTypeType:Child from ParameterizedType (1,1) to SimpleType (0,1) role type;<br />
EdgeClass ParameterizedTypeTypeArguments:Child from ParameterizedType (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass PostfixExpressionOperand:Child from PostfixExpression (1,1) to SimpleName (0,1) role operand;<br />
EdgeClass PrefixExpressionOperand:Child from PrefixExpression (1,1) to Expression (0,1) role operand;<br />
EdgeClass QualifiedNameName:Child from QualifiedName (1,1) to SimpleName (0,1) role name;<br />
EdgeClass QualifiedNameQualifier:Child from QualifiedName (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SimpleNameValues:Child from SimpleName (1,1) to MethodDeclaration (0,*) role values;<br />
EdgeClass SimpleTypeAnnotation:Child from SimpleType (1,1) to Annotation (0,*) role annotations;<br />
EdgeClass SimpleTypeName:Child from SimpleType (1,1) to Name (0,1) role name2;<br />
EdgeClass SingleMemberAnnotationTypeName:Child from SingleMemberAnnotation (1,1) to SimpleName (0,1) role typeName;<br />
EdgeClass SingleMemberAnnotationValue:Child from SingleMemberAnnotation (1,1) to Expression (0,1) role value;<br />
EdgeClass SingleVariableDeclarationAnnotation:Child from SingleVariableDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass SingleVariableDeclarationExtraDimensions:Child from SingleVariableDeclaration (1,1) to Dimension (0,*) role extraDimensions2;<br />
EdgeClass SingleVariableDeclarationInitializer:Child from SingleVariableDeclaration (1,1) to Expression (0,1) role initializer;<br />
EdgeClass SingleVariableDeclarationModifiers:Child from SingleVariableDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass SingleVariableDeclarationType:Child from SingleVariableDeclaration (1,1) to Type (0,*) role type;<br />
EdgeClass SingleVariableDeclarationVarargsAnnotations:Child from SingleVariableDeclaration (1,1) to Annotation (0,*) role varargsAnnotations;<br />
EdgeClass SuperConstructorInvocationArgument:Child from SuperConstructorInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass SuperConstructorInvocationTypeArguments:Child from SuperConstructorInvocation (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass SuperFieldAccessName:Child from SuperFieldAccess (1,1) to SimpleName (0,1) role name;<br />
EdgeClass SuperFieldAccessQualifier:Child from SuperFieldAccess(1,1) to Name (0,1) role qualifier;<br />
EdgeClass SuperMethodInvocationArguments:Child from SuperMethodInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass SuperMethodInvocationQualifier:Child from SuperMethodInvocation (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SuperMethodReferenceArguments:Child from SuperMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass SuperMethodReferenceQualifier:Child from SuperMethodReference (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SwitchStatementStatements:Child from SwitchStatement (1,1) to Statement (0,*) role statements;<br />
EdgeClass SynchronizedStatementBlock:Child from SynchronizedStatement (1,1) to Block (0,1) role body;<br />
EdgeClass TagElementFragments1:Child from TagElement (1,1) to TextElement (0,*) role fragments1;<br />
EdgeClass TagElementFragments2:Child from TagElement (1,1) to Name (0,*) role fragments2;<br />
EdgeClass TagElementFragments3:Child from TagElement (1,1) to MethodRef (0,*) role fragments3;<br />
EdgeClass TagElementFragments4:Child from TagElement (1,1) to MemberRef (0,*) role fragments4;<br />
EdgeClass TagElementFragments5:Child from TagElement (1,1) to TagElement (0,*) role fragments5;<br />
EdgeClass ThisExpressionQualifier:Child from ThisExpression (1,1) to Name (0,1) role qualifier;<br />
EdgeClass TryStatementBody:Child from TryStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass TryStatementCatchClauses:Child from TryStatement (1,1) to CatchClause (0,*) role catchClauses;<br />
EdgeClass TryStatementFinally:Child from TryStatement (1,1) to Block (0,1) role finally;<br />
EdgeClass TryStatementResources:Child from TryStatement (1,1) to VariableDeclarationExpression (0,*) role resources;<br />
EdgeClass TypeDeclarationAnnotation:Child from TypeDeclaration (1,1) to Annotation (0,*) role modifiers2;<br />
EdgeClass TypeDeclarationBodyDeclarations1:Child from TypeDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass TypeDeclarationModifiers:Child from TypeDeclaration (1,1) to Modifier (0,*) role modifiers1;<br />
EdgeClass TypeDeclarationSuperclassType:Child from TypeDeclaration (1,1) to Type (0,1) role superclassType;<br />
EdgeClass TypeDeclarationSuperInterfaceTypes:Child from TypeDeclaration (1,1) to Type (0,*) role superInterfaceTypes;<br />
EdgeClass TypeDeclarationTypeParameters:Child from TypeDeclaration (1,1) to TypeParameter (0,*) role typeParameters;<br />
EdgeClass TypeLiteralType:Child from TypeLiteral (1,1) to Type (0,1) role type;<br />
EdgeClass TypeMethodReferenceArguments:Child from TypeMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass TypeMethodReferenceType:Child from TypeMethodReference (1,1) to Type (0,1) role type;<br />
EdgeClass TypeParameterName:Child from TypeParameter (1,1) to SimpleName (0,1) role name;<br />
EdgeClass TypeParameterType:Child from TypeParameter (1,1) to Type (0,*) role typeBounds;<br />
EdgeClass UnionTypeTypes:Child from UnionType (1,1) to Type (0,*) role types;<br />
EdgeClass VariableDeclarationExpressionAnnotation:Child from VariableDeclarationExpression (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass VariableDeclarationExpressionFragments:Child from VariableDeclarationExpression (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass VariableDeclarationExpressionModifiers:Child from VariableDeclarationExpression (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass VariableDeclarationExpressionType:Child from VariableDeclarationExpression (1,1) to Type (0,1) role type;<br />
EdgeClass VariableDeclarationFragmentInitializer:Child from VariableDeclarationFragment (1,1) to Expression (0,1) role initializer;<br />
EdgeClass VariableDeclarationStatementFragments:Child from VariableDeclarationStatement (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass VariableDeclarationStatementModifier:Child from VariableDeclarationStatement (1,1) to Modifier (0,*) role modifiers;<br />
EdgeClass VariableDeclarationStatementType:Child from VariableDeclarationStatement (1,1) to Type (0,1) role type;<br />
EdgeClass WhileStatementBody:Child from WhileStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass WildcardTypeBound1:Child from WildcardType (1,1) to ParameterizedType (0,*) role bound1;<br />
EdgeClass WildcardTypeBound2:Child from WildcardType (1,1) to SimpleType (0,*) role bound2;<br />
</syntaxhighlight><br />
<br />
JACK erzeugt zusätzliche Kanten vom Typ <code>Access </code>, mit denen vom Zugriff auf ein Element auf dessen Deklaration verwiesen wird. Diese Kanten sind nicht Teil des Syntaxbaumes, sondern erweitern ihn zu einem Graph. Sie stehen nur zur Verfügung, wenn Zugriff und Deklaration innerhalb des geparsten Codes liegen:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract EdgeClass Access from Node (0,1) to Node (0,*);<br />
EdgeClass ExpressionAccess1:Access from Expression (1,1) to BodyDeclaration (0,*) role access1;<br />
EdgeClass ExpressionAccess2:Access from Expression (1,1) to VariableDeclaration (0,*) role access2;<br />
EdgeClass TypeAccess:Access from Type (1,1) to TypeDeclaration (0,*) role access;<br />
</syntaxhighlight><br />
<br />
== Beispiel ==<br />
<br />
Exemplarischer Code in Java:<br />
<br />
<syntaxhighlight lang="Java" line="line"><br />
<br />
public class Computer {<br />
<br />
public Computer(int price) {<br />
this.price = price;<br />
}<br />
<br />
private int price = 0;<br />
<br />
public int getPrice() {<br />
return price;<br />
}<br />
<br />
public static Computer[] getSortedByPrice(Computer[] computers) {<br />
for (int n = computers.length; n > 1; n--) {<br />
for (int i = 0; i < n - 1; i++) {<br />
if (computers[i].price > computers[i + 1].price) {<br />
Computer swapComputer = computers[i + 1];<br />
computers[i + 1] = computers[i];<br />
computers[i] = swapComputer;<br />
}<br />
}<br />
}<br />
return computers;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Zugehöriger Syntaxgraph:<br />
<br />
[[Datei:syntaxgraph-computer.png]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQL-Typegraph_f%C3%BCr_Java&diff=8972GReQL-Typegraph für Java2023-08-25T10:40:31Z<p>Striewe: </p>
<hr />
<div>Grundsätzlich folgt der Typegraph für GReQL-Queries zu Java der Java Language Specification für Java 8. Der Syntaxgraph wird durch den Eclipse-Parser erzeugt und verwendet die entsprechenden Namen für die Syntaxelemente. An einigen Stellen gibt es kleine Vereinfachungen und Erweiterungen.<br />
<br />
== Typegraph-Definitionen == <br />
<br />
=== Knotentypen ===<br />
<br />
Alle Knoten erben vom abstrakten Typen <code>Node</code>. Zwei spezielle Knoten werden durch den Eclipse-Parser erzeugt und bilden die Wurzel und das erste Kind-Element des Syntaxbaumes.<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Node;<br />
VertexClass IJavaProject: Node { name:String };<br />
VertexClass IPackageFragment: Node { name:String };<br />
</syntaxhighlight><br />
<br />
Alle Sprachelemente von Java erben von <code>Element</code> und erhalten darüber eine Zuordnung zu einer Zeilennummer.<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Element: Node { line:Integer };<br />
VertexClass AnonymousClassDeclaration:Element;<br />
VertexClass CatchClause:Element;<br />
VertexClass Comment:Element;<br />
VertexClass CompilationUnit:Element { name:String };<br />
VertexClass Dimension:Element;<br />
VertexClass ImportDeclaration:Element { name:String, onDemand:Boolean, static:Boolean };<br />
VertexClass Javadoc:Element;<br />
VertexClass MemberRef:Element;<br />
VertexClass MemberValuePair:Element;<br />
VertexClass MethodRef:Element;<br />
VertexClass MethodRefParameter:Element { varargs:Boolean };<br />
VertexClass Modifier:Element { name:String };<br />
VertexClass PackageDeclaration:Element { name:String };<br />
VertexClass TagElement:Element { name:String };<br />
VertexClass TextElement:Element { content:String };<br />
VertexClass TypeParameter:Element;<br />
</syntaxhighlight><br />
<br />
Deklarationen innerhalb einer Klasse (im Gegensatz zu den oben enthaltenen Import-Deklarationen) erben vom Typ <code>BodyDeclaration</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass BodyDeclaration:Element;<br />
VertexClass AnnotationTypeMemberDeclaration:BodyDeclaration;<br />
VertexClass FieldDeclaration:BodyDeclaration;<br />
VertexClass MethodDeclaration:BodyDeclaration { name:String, constructor:Boolean, dimension:Integer };<br />
VertexClass EnumConstantDeclaration:BodyDeclaration;<br />
VertexClass Initializer:BodyDeclaration;<br />
</syntaxhighlight><br />
<br />
Die Klassendekelartionen selber erben vom Typ <code>AbstractTypeDeclaration</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass AbstractTypeDeclaration:BodyDeclaration;<br />
VertexClass AnnotationTypeDeclaration:AbstractTypeDeclaration;<br />
VertexClass TypeDeclaration:AbstractTypeDeclaration { name:String, interface:Boolean };<br />
VertexClass EnumDeclaration:AbstractTypeDeclaration;<br />
</syntaxhighlight><br />
<br />
In Typ-Referenzen kommen Unterklassen von <code>Type</code> zum Einsatz, ggf. auch von dessen Unterklasse <code>AnnotatableType</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Type:Element;<br />
VertexClass ArrayType:Type { dimensions:Integer };<br />
VertexClass IntersectionType:Type;<br />
VertexClass ParameterizedType:Type { name:String };<br />
VertexClass UnionType:Type; <br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass AnnotatableType:Type;<br />
VertexClass PrimitiveType:AnnotatableType { name:String };<br />
VertexClass SimpleType:AnnotatableType { name:String };<br />
VertexClass QualifiedType:AnnotatableType { name:String };<br />
VertexClass NameQualifiedType:AnnotatableType { name:String };<br />
VertexClass WildcardType:AnnotatableType { upperBound:Boolean };<br />
</syntaxhighlight><br />
<br />
Variablen können einzeln oder als sogenanntes Fragment deklariert werden:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass VariableDeclaration:Element;<br />
VertexClass SingleVariableDeclaration:VariableDeclaration { name:String, varargs:Boolean, dimension:Integer };<br />
VertexClass VariableDeclarationFragment:VariableDeclaration { name:String, dimension:Integer };<br />
</syntaxhighlight><br />
<br />
Alle Anweisungen erben von <code>Statement</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Statement:Element;<br />
VertexClass AssertStatement:Statement;<br />
VertexClass Block:Statement;<br />
VertexClass BreakStatement:Statement { name:String };<br />
VertexClass ConstructorInvocation:Statement;<br />
VertexClass ContinueStatement:Statement { name:String };<br />
VertexClass DoStatement:Statement;<br />
VertexClass EmptyStatement:Statement;<br />
VertexClass EnhancedForStatement:Statement;<br />
VertexClass ExpressionStatement:Statement;<br />
VertexClass ForStatement:Statement;<br />
VertexClass IfStatement:Statement;<br />
VertexClass LabeledStatement:Statement;<br />
VertexClass ReturnStatement:Statement;<br />
VertexClass SuperConstructorInvocation:Statement;<br />
VertexClass SwitchCase:Statement;<br />
VertexClass SwitchStatement:Statement;<br />
VertexClass SynchronizedStatement:Statement;<br />
VertexClass ThrowStatement:Statement;<br />
VertexClass TryStatement:Statement;<br />
VertexClass TypeDeclarationStatement:Statement;<br />
VertexClass VariableDeclarationStatement:Statement;<br />
VertexClass WhileStatement:Statement;<br />
</syntaxhighlight><br />
<br />
Alle Ausdrücke erben von <code>Expression</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Expression:Element;<br />
VertexClass ArrayAccess:Expression;<br />
VertexClass ArrayCreation:Expression;<br />
VertexClass ArrayInitializer:Expression;<br />
VertexClass Assignment:Expression { name:String };<br />
VertexClass BooleanLiteral:Expression { content:String };<br />
VertexClass CastExpression:Expression;<br />
VertexClass CharacterLiteral:Expression { content:String };<br />
VertexClass ClassInstanceCreation:Expression;<br />
VertexClass ConditionalExpression:Expression;<br />
VertexClass FieldAccess:Expression;<br />
VertexClass InfixExpression:Expression { name:String };<br />
VertexClass InstanceofExpression:Expression;<br />
VertexClass LambdaExpression:Expression { parantheses:Boolean };<br />
VertexClass MethodInvocation:Expression { name:String };<br />
VertexClass NullLiteral:Expression;<br />
VertexClass NumberLiteral:Expression { content:String };<br />
VertexClass ParenthesizedExpression:Expression;<br />
VertexClass PostfixExpression:Expression { name:String };<br />
VertexClass PrefixExpression:Expression { name:String };<br />
VertexClass StringLiteral:Expression { content:String };<br />
VertexClass SuperFieldAccess:Expression;<br />
VertexClass SuperMethodInvocation:Expression { name:String };<br />
VertexClass ThisExpression:Expression;<br />
VertexClass TypeLiteral:Expression;<br />
VertexClass VariableDeclarationExpression:Expression;<br />
</syntaxhighlight><br />
<br />
In Variablen und Methoden-Referenzen kommen Unterklassen von <code>Name</code> zum Einsatz:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Name:Expression;<br />
VertexClass SimpleName:Name { name:String };<br />
VertexClass QualifiedName:Name;<br />
</syntaxhighlight><br />
<br />
Annotationen erben von <code>Annotation</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass Annotation:Expression;<br />
VertexClass MarkerAnnotation:Annotation;<br />
VertexClass NormalAnnotation:Annotation;<br />
VertexClass SingleMemberAnnotation:Annotation;<br />
</syntaxhighlight><br />
<br />
Methoden-Referenzen erben von <code>MethodReference</code>:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract VertexClass MethodReference:Expression;<br />
VertexClass CreationReference:MethodReference;<br />
VertexClass ExpressionMethodReference:MethodReference;<br />
VertexClass SuperMethodReference:MethodReference { name:String };<br />
VertexClass TypeMethodReference:MethodReference { name:String };<br />
</syntaxhighlight><br />
<br />
=== Kantentypen ===<br />
<br />
Die Verbindung zwischen Knoten hat auch jeweils einen Kantentyp, der sich aus den beteiligten Typen (oder ggf. deren Obertypen) ergibt. Alle Beziehungen sind als Eltern-Kind-Beziehung definiert, die die Baumstruktur abbildet. Hat ein Eltern-Knoten mehrere Kinder, sind diese entsprechend ihrer Reihenfolge im Code über ein Attribut der Kante durchnummeriert:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract EdgeClass Child from Node (0,1) to Node (0,*) { position:Integer } ;<br />
EdgeClass AnnotationTypeDeclarationAnnotations:Child from AnnotationTypeDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass AnnotationTypeDeclarationBodyDeclarations:Child from AnnotationTypeDeclaration (1,1) to AnnotationTypeMemberDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass AnnotationTypeDeclarationModifiers:Child from AnnotationTypeDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass AnnotationTypeDeclarationName:Child from AnnotationTypeDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass AnnotationTypeMemberDeclarationAnnotations:Child from AnnotationTypeMemberDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass AnnotationTypeMemberDeclarationDefault:Child from AnnotationTypeMemberDeclaration (1,1) to Expression (0,1) role default;<br />
EdgeClass AnnotationTypeMemberDeclarationModifiers:Child from AnnotationTypeMemberDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass AnnotationTypeMemberDeclarationName:Child from AnnotationTypeMemberDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass AnnotationTypeMemberDeclarationType:Child from AnnotationTypeMemberDeclaration (1,1) to Type (0,1) role type;<br />
EdgeClass AnonymousClassDeclarationBodyDeclarations:Child from AnonymousClassDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass ArrayAccessArray:Child from ArrayAccess (1,1) to Expression (0,1) role array;<br />
EdgeClass ArrayAccessIndex:Child from ArrayAccess (1,1) to Expression (0,1) role index;<br />
EdgeClass ArrayCreationDimensions:Child from ArrayCreation (1,1) to Expression (0,*) role dimensions;<br />
EdgeClass ArrayCreationInitializer:Child from ArrayCreation (1,1) to ArrayInitializer (0,1) role initializer;<br />
EdgeClass ArrayCreationType:Child from ArrayCreation (1,1) to ArrayType (0,1) role type;<br />
EdgeClass ArrayInitializerExpressions:Child from ArrayInitializer (1,1) to Expression (0,*) role expressions;<br />
EdgeClass ArrayTypeComponentType:Child from ArrayType (1,1) to Type (0,1) role elementType;<br />
EdgeClass AssertStatementMessage:Child from AssertStatement (1,1) to Expression (0,1) role message;<br />
EdgeClass AssignmentLeftHandSide:Child from Assignment (1,1) to Expression (0,1) role leftHandSide;<br />
EdgeClass AssignmentRightHandSide:Child from Assignment (1,1) to Expression (0,1) role rightHandSide;<br />
EdgeClass BlockStatements:Child from Block (1,1) to Statement (0,*) role statements;<br />
EdgeClass BodyDeclarationJavadoc:Child from BodyDeclaration (1,1) to Javadoc (0,1) role javadoc;<br />
EdgeClass CastExpressionType:Child from CastExpression (1,1) to Type (0,1) role type;<br />
EdgeClass CatchClauseBody:Child from CatchClause (1,1) to Block (0,*) role body;<br />
EdgeClass CatchClauseException:Child from CatchClause (1,1) to SingleVariableDeclaration (0,*) role exception;<br />
EdgeClass ClassInstanceCreationAnonymousClassDecl:Child from ClassInstanceCreation (1,1) to AnonymousClassDeclaration (0,1) role anonymousClassDeclaration;<br />
EdgeClass ClassInstanceCreationArguments:Child from ClassInstanceCreation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass ClassInstanceCreationType:Child from ClassInstanceCreation (1,1) to Type (0,1) role type;<br />
EdgeClass CompilationUnitImports:Child from CompilationUnit (1,1) to ImportDeclaration (0,*) role imports;<br />
EdgeClass CompilationUnitPackage:Child from CompilationUnit (1,1) to PackageDeclaration (0,*) role package;<br />
EdgeClass CompilationUnitTypes:Child from CompilationUnit (1,1) to AbstractTypeDeclaration (0,*) role types;<br />
EdgeClass ConditionalExpressionElseExpression:Child from ConditionalExpression (1,1) to Expression (0,1) role elseExpression;<br />
EdgeClass ConditionalExpressionThenExpression:Child from ConditionalExpression (1,1) to Expression (0,1) role thenExpression;<br />
EdgeClass ConstructorInvocationArguments:Child from ConstructorInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass ConstructorInvocationTypeArguments:Child from ConstructorInvocation (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass CreationReferenceTypeArguments:Child from CreationReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass CreationReferenceType:Child from CreationReference (1,1) to Type (0,1) role type;<br />
EdgeClass DimensionAnnotations:Child from Dimension (1,1) to Annotation (0,*) role annotations;<br />
EdgeClass DoStatementBody:Child from DoStatement (1,1) to Block (0,1) role body;<br />
EdgeClass ElementExpression:Child from Element (1,1) to Expression (0,*) role expression;<br />
EdgeClass EnhancedForStatementBody:Child from EnhancedForStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass EnhancedForStatementParameter:Child from EnhancedForStatement (1,1) to SingleVariableDeclaration (0,1) role parameter;<br />
EdgeClass EnumConstantDeclarationAnonymousClassDeclaration:Child from EnumConstantDeclaration (1,1) to AnonymousClassDeclaration (0,1) role anonymousClassDeclaration;<br />
EdgeClass EnumConstantDeclarationAnnotations:Child from EnumConstantDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass EnumConstantDeclarationArguments:Child from EnumConstantDeclaration (1,1) to Expression (0,*) role arguments;<br />
EdgeClass EnumConstantDeclarationModifiers:Child from EnumConstantDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass EnumConstantDeclarationName:Child from EnumConstantDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass EnumDeclarationAnnotations:Child from EnumDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass EnumDeclarationBodyDeclaration:Child from EnumDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass EnumDeclarationEnumConstants:Child from EnumDeclaration (1,1) to EnumConstantDeclaration (0,*) role enumConstants;<br />
EdgeClass EnumDeclarationModifiers:Child from EnumDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass EnumDeclarationName:Child from EnumDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass EnumDeclarationSuperInterfaceTypes:Child from EnumDeclaration (1,1) to Type (0,*) role superInterfaceTypes; <br />
EdgeClass ExpressionMethodReferenceArguments:Child from ExpressionMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass ExpressionMethodReferenceName:Child from ExpressionMethodReference (1,1) to SimpleName (0,1) role name;<br />
EdgeClass FieldAccessName:Child from FieldAccess (1,1) to SimpleName (0,1) role name;<br />
EdgeClass FieldDeclarationAnnotation:Child from FieldDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass FieldDeclarationFragments:Child from FieldDeclaration (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass FieldDeclarationModifiers:Child from FieldDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass FieldDeclarationType:Child from FieldDeclaration (1,1) to Type (0,1) role type;<br />
EdgeClass ForStatementBody:Child from ForStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass ForStatementInitializers:Child from ForStatement (1,1) to Expression (0,*) role initializers;<br />
EdgeClass ForStatementUpdaters:Child from ForStatement (1,1) to Expression (0,*) role updaters;<br />
EdgeClass IfStatementElseStatement:Child from IfStatement (1,1) to Statement (0,1) role elseStatement;<br />
EdgeClass IfStatementThenStatement:Child from IfStatement (1,1) to Statement (0,1) role thenStatement;<br />
EdgeClass IJavaProjectFragements:Child from IJavaProject (1,1) to IPackageFragment (0,*) role fragments;<br />
EdgeClass IJavaProjectUnits:Child from IJavaProject (1,1) to CompilationUnit (0,*) role units;<br />
EdgeClass InfixExpressionExtendedOperands:Child from InfixExpression (1,1) to Expression (0,*) role extendedOperands;<br />
EdgeClass InfixExpressionLeftOperand:Child from InfixExpression (1,1) to Expression (0,1) role leftOperand;<br />
EdgeClass InfixExpressionRightOperand:Child from InfixExpression (1,1) to Expression (0,1) role rightOperand;<br />
EdgeClass InitializerAnnotation:Child from Initializer (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass InitializerBody:Child from Initializer (1,1) to Block (0,1) role body;<br />
EdgeClass InitializerModifiers:Child from Initializer (1,1) to Modifier(0,*) role modifiers2;<br />
EdgeClass IntersectionTypeTypes:Child from IntersectionType (1,1) to Type (0,*) role types;<br />
EdgeClass InstanceofExpressionLeftOperand:Child from InstanceofExpression (1,1) to Expression (0,1) role leftOperand;<br />
EdgeClass InstanceofExpressionRightOperand:Child from InstanceofExpression (1,1) to Type (0,1) role rightOperand;<br />
EdgeClass IPackageFragmentUnits:Child from IPackageFragment (1,1) to CompilationUnit (0,*) role units;<br />
EdgeClass JavadocTags:Child from Javadoc (1,1) to TagElement (0,*) role tags;<br />
EdgeClass LambdaExpressionBody:Child from LambdaExpression (1,1) to Element (0,1) role body;<br />
EdgeClass LambdaExpressionParameters:Child from LambdaExpression (1,1) to VariableDeclaration (0,*) role parameters;<br />
EdgeClass LabeledStatementBody:Child from LabeledStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass LabeledStatementLabel:Child from LabeledStatement (1,1) to SimpleName (0,1) role label;<br />
EdgeClass MarkerAnnotationTypeName:Child from MarkerAnnotation (1,1) to SimpleName (0,*) role typeName;<br />
EdgeClass MemberRefName:Child from MemberRef (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MemberRefQualifier:Child from MemberRef (1,1) to Name (0,1) role qualifier;<br />
EdgeClass MemberValuePairName:Child from MemberValuePair (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MemberValuePairValue:Child from MemberValuePair (1,1) to Expression (0,1) role value;<br />
EdgeClass MethodDeclarationAnnotation:Child from MethodDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass MethodDeclarationBody:Child from MethodDeclaration (1,1) to Block (0,1) role body;<br />
EdgeClass MethodDeclarationModifiers:Child from MethodDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass MethodDeclarationParameters:Child from MethodDeclaration (1,1) to SingleVariableDeclaration (0,*) role parameters;<br />
EdgeClass MethodDeclarationReceiverQualifier:Child from MethodDeclaration (1,1) to SimpleName (0,1) role receiverQualifier;<br />
EdgeClass MethodDeclarationReceiverType:Child from MethodDeclaration (1,1) to Type (0,1) role receiverType;<br />
EdgeClass MethodDeclarationReturnType:Child from MethodDeclaration (1,1) to Type (0,1) role returnType2;<br />
EdgeClass MethodDeclarationThrownExceptions:Child from MethodDeclaration (1,1) to Type (0,*) role thrownExceptionTypes;<br />
EdgeClass MethodDeclarationTypeParameters:Child from MethodDeclaration (1,1) to TypeParameter (0,*) role typeParameters;<br />
EdgeClass MethodInvocationArguments:Child from MethodInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass MethodRefName:Child from MethodRef (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MethodRefParameters:Child from MethodRef (1,1) to MethodRefParameter (0,*) role parameters;<br />
EdgeClass MethodRefQualifier:Child from MethodRef (1,1) to Name (0,1) role qualifier;<br />
EdgeClass MethodRefParameterName:Child from MethodRefParameter (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MethodRefParameterType:Child from MethodRefParameter (1,1) to Type (0,1) role type;<br />
EdgeClass NormalAnnotationTypeName:Child from NormalAnnotation (1,1) to Name (0,1) role typeName;<br />
EdgeClass NormalAnnotationValues:Child from NormalAnnotation (1,1) to MemberValuePair (0,*) role values;<br />
EdgeClass ParameterizedTypeType:Child from ParameterizedType (1,1) to SimpleType (0,1) role type;<br />
EdgeClass ParameterizedTypeTypeArguments:Child from ParameterizedType (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass PostfixExpressionOperand:Child from PostfixExpression (1,1) to SimpleName (0,1) role operand;<br />
EdgeClass PrefixExpressionOperand:Child from PrefixExpression (1,1) to Expression (0,1) role operand;<br />
EdgeClass QualifiedNameName:Child from QualifiedName (1,1) to SimpleName (0,1) role name;<br />
EdgeClass QualifiedNameQualifier:Child from QualifiedName (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SimpleNameValues:Child from SimpleName (1,1) to MethodDeclaration (0,*) role values;<br />
EdgeClass SimpleTypeAnnotation:Child from SimpleType (1,1) to Annotation (0,*) role annotations;<br />
EdgeClass SimpleTypeName:Child from SimpleType (1,1) to Name (0,1) role name2;<br />
EdgeClass SingleMemberAnnotationTypeName:Child from SingleMemberAnnotation (1,1) to SimpleName (0,1) role typeName;<br />
EdgeClass SingleMemberAnnotationValue:Child from SingleMemberAnnotation (1,1) to Expression (0,1) role value;<br />
EdgeClass SingleVariableDeclarationAnnotation:Child from SingleVariableDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass SingleVariableDeclarationExtraDimensions:Child from SingleVariableDeclaration (1,1) to Dimension (0,*) role extraDimensions2;<br />
EdgeClass SingleVariableDeclarationInitializer:Child from SingleVariableDeclaration (1,1) to Expression (0,1) role initializer;<br />
EdgeClass SingleVariableDeclarationModifiers:Child from SingleVariableDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass SingleVariableDeclarationType:Child from SingleVariableDeclaration (1,1) to Type (0,*) role type;<br />
EdgeClass SingleVariableDeclarationVarargsAnnotations:Child from SingleVariableDeclaration (1,1) to Annotation (0,*) role varargsAnnotations;<br />
EdgeClass SuperConstructorInvocationArgument:Child from SuperConstructorInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass SuperConstructorInvocationTypeArguments:Child from SuperConstructorInvocation (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass SuperFieldAccessName:Child from SuperFieldAccess (1,1) to SimpleName (0,1) role name;<br />
EdgeClass SuperFieldAccessQualifier:Child from SuperFieldAccess(1,1) to Name (0,1) role qualifier;<br />
EdgeClass SuperMethodInvocationArguments:Child from SuperMethodInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass SuperMethodInvocationQualifier:Child from SuperMethodInvocation (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SuperMethodReferenceArguments:Child from SuperMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass SuperMethodReferenceQualifier:Child from SuperMethodReference (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SwitchStatementStatements:Child from SwitchStatement (1,1) to Statement (0,*) role statements;<br />
EdgeClass SynchronizedStatementBlock:Child from SynchronizedStatement (1,1) to Block (0,1) role body;<br />
EdgeClass TagElementFragments1:Child from TagElement (1,1) to TextElement (0,*) role fragments1;<br />
EdgeClass TagElementFragments2:Child from TagElement (1,1) to Name (0,*) role fragments2;<br />
EdgeClass TagElementFragments3:Child from TagElement (1,1) to MethodRef (0,*) role fragments3;<br />
EdgeClass TagElementFragments4:Child from TagElement (1,1) to MemberRef (0,*) role fragments4;<br />
EdgeClass TagElementFragments5:Child from TagElement (1,1) to TagElement (0,*) role fragments5;<br />
EdgeClass ThisExpressionQualifier:Child from ThisExpression (1,1) to Name (0,1) role qualifier;<br />
EdgeClass TryStatementBody:Child from TryStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass TryStatementCatchClauses:Child from TryStatement (1,1) to CatchClause (0,*) role catchClauses;<br />
EdgeClass TryStatementFinally:Child from TryStatement (1,1) to Block (0,1) role finally;<br />
EdgeClass TryStatementResources:Child from TryStatement (1,1) to VariableDeclarationExpression (0,*) role resources;<br />
EdgeClass TypeDeclarationAnnotation:Child from TypeDeclaration (1,1) to Annotation (0,*) role modifiers2;<br />
EdgeClass TypeDeclarationBodyDeclarations1:Child from TypeDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass TypeDeclarationModifiers:Child from TypeDeclaration (1,1) to Modifier (0,*) role modifiers1;<br />
EdgeClass TypeDeclarationSuperclassType:Child from TypeDeclaration (1,1) to Type (0,1) role superclassType;<br />
EdgeClass TypeDeclarationSuperInterfaceTypes:Child from TypeDeclaration (1,1) to Type (0,*) role superInterfaceTypes;<br />
EdgeClass TypeDeclarationTypeParameters:Child from TypeDeclaration (1,1) to TypeParameter (0,*) role typeParameters;<br />
EdgeClass TypeLiteralType:Child from TypeLiteral (1,1) to Type (0,1) role type;<br />
EdgeClass TypeMethodReferenceArguments:Child from TypeMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass TypeMethodReferenceType:Child from TypeMethodReference (1,1) to Type (0,1) role type;<br />
EdgeClass TypeParameterName:Child from TypeParameter (1,1) to SimpleName (0,1) role name;<br />
EdgeClass TypeParameterType:Child from TypeParameter (1,1) to Type (0,*) role typeBounds;<br />
EdgeClass UnionTypeTypes:Child from UnionType (1,1) to Type (0,*) role types;<br />
EdgeClass VariableDeclarationExpressionAnnotation:Child from VariableDeclarationExpression (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass VariableDeclarationExpressionFragments:Child from VariableDeclarationExpression (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass VariableDeclarationExpressionModifiers:Child from VariableDeclarationExpression (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass VariableDeclarationExpressionType:Child from VariableDeclarationExpression (1,1) to Type (0,1) role type;<br />
EdgeClass VariableDeclarationFragmentInitializer:Child from VariableDeclarationFragment (1,1) to Expression (0,1) role initializer;<br />
EdgeClass VariableDeclarationStatementFragments:Child from VariableDeclarationStatement (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass VariableDeclarationStatementModifier:Child from VariableDeclarationStatement (1,1) to Modifier (0,*) role modifiers;<br />
EdgeClass VariableDeclarationStatementType:Child from VariableDeclarationStatement (1,1) to Type (0,1) role type;<br />
EdgeClass WhileStatementBody:Child from WhileStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass WildcardTypeBound1:Child from WildcardType (1,1) to ParameterizedType (0,*) role bound1;<br />
EdgeClass WildcardTypeBound2:Child from WildcardType (1,1) to SimpleType (0,*) role bound2;<br />
</syntaxhighlight><br />
<br />
JACK erzeugt zusätzliche Kanten vom Typ <code>Access </code>, mit denen vom Zugriff auf ein Element auf dessen Deklaration verwiesen wird. Diese Kanten sind nicht Teil des Syntaxbaumes, sondern erweitern ihn zu einem Graph. Sie stehen nur zur Verfügung, wenn Zugriff und Deklaration innerhalb des geparsten Codes liegen:<br />
<syntaxhighlight lang="text" line="line"><br />
abstract EdgeClass Access from Node (0,1) to Node (0,*);<br />
EdgeClass ExpressionAccess1:Access from Expression (1,1) to BodyDeclaration (0,*) role access1;<br />
EdgeClass ExpressionAccess2:Access from Expression (1,1) to VariableDeclaration (0,*) role access2;<br />
EdgeClass TypeAccess:Access from Type (1,1) to TypeDeclaration (0,*) role access;<br />
</syntaxhighlight><br />
<br />
== Beispiel ==<br />
<br />
Exemplarischer Code in Java:<br />
<br />
<syntaxhighlight lang="Java" line="line"><br />
<br />
public class Computer {<br />
<br />
public Computer(int price) {<br />
this.price = price;<br />
}<br />
<br />
private int price = 0;<br />
<br />
public int getPrice() {<br />
return price;<br />
}<br />
<br />
public static Computer[] getSortedByPrice(Computer[] computers) {<br />
for (int n = computers.length; n > 1; n--) {<br />
for (int i = 0; i < n - 1; i++) {<br />
if (computers[i].price > computers[i + 1].price) {<br />
Computer swapComputer = computers[i + 1];<br />
computers[i + 1] = computers[i];<br />
computers[i] = swapComputer;<br />
}<br />
}<br />
}<br />
return computers;<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Zugehöriger Syntaxgraph:<br />
<br />
[[Datei:syntaxgraph-computer.jpeg]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Datei:Syntaxgraph-computer.png&diff=8971Datei:Syntaxgraph-computer.png2023-08-25T10:32:54Z<p>Striewe: </p>
<hr />
<div></div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Datei:Syntaxgraph-computer.jpeg&diff=8970Datei:Syntaxgraph-computer.jpeg2023-08-25T10:18:19Z<p>Striewe: </p>
<hr />
<div></div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQL-Typegraph_f%C3%BCr_Java&diff=8969GReQL-Typegraph für Java2023-08-25T08:21:33Z<p>Striewe: Die Seite wurde neu angelegt: „Grundsätzlich folgt der Typegraph für GReQL-Queries zu Java der Java Language Specification für Java 8. Der Syntaxgraph wird durch den Eclipse-Parser erzeugt und verwendet die entsprechenden Namen für die Syntaxelemente. An einigen Stellen gibt es kleine Vereinfachungen und Erweiterungen. Alle Knoten erben vom abstrakten Typen <code>Node</code>. Zwei spezielle Knoten werden durch den Eclipse-Parser erzeugt und bilden die Wurzel und das erste Kind-Ele…“</p>
<hr />
<div>Grundsätzlich folgt der Typegraph für GReQL-Queries zu Java der Java Language Specification für Java 8. Der Syntaxgraph wird durch den Eclipse-Parser erzeugt und verwendet die entsprechenden Namen für die Syntaxelemente. An einigen Stellen gibt es kleine Vereinfachungen und Erweiterungen.<br />
<br />
Alle Knoten erben vom abstrakten Typen <code>Node</code>. Zwei spezielle Knoten werden durch den Eclipse-Parser erzeugt und bilden die Wurzel und das erste Kind-Element des Syntaxbaumes.<br />
<syntaxhighlight line='line'><br />
abstract VertexClass Node;<br />
VertexClass IJavaProject: Node { name:String };<br />
VertexClass IPackageFragment: Node { name:String };<br />
</syntaxhighlight><br />
<br />
Alle Sprachelemente von Java erben von <code>Element</code> und erhalten darüber eine Zuordnung zu einer Zeilennummer.<br />
<syntaxhighlight line='line'><br />
abstract VertexClass Element: Node { line:Integer };<br />
VertexClass AnonymousClassDeclaration:Element;<br />
VertexClass CatchClause:Element;<br />
VertexClass Comment:Element;<br />
VertexClass CompilationUnit:Element { name:String };<br />
VertexClass Dimension:Element;<br />
VertexClass ImportDeclaration:Element { name:String, onDemand:Boolean, static:Boolean };<br />
VertexClass Javadoc:Element;<br />
VertexClass MemberRef:Element;<br />
VertexClass MemberValuePair:Element;<br />
VertexClass MethodRef:Element;<br />
VertexClass MethodRefParameter:Element { varargs:Boolean };<br />
VertexClass Modifier:Element { name:String };<br />
VertexClass PackageDeclaration:Element { name:String };<br />
VertexClass TagElement:Element { name:String };<br />
VertexClass TextElement:Element { content:String };<br />
VertexClass TypeParameter:Element;<br />
</syntaxhighlight><br />
<br />
Deklarationen innerhalb einer Klasse (im Gegensatz zu den oben enthaltenen Import-Deklarationen) erben vom Typ <code>BodyDeclaration</code>:<br />
<syntaxhighlight line='line'><br />
abstract VertexClass BodyDeclaration:Element;<br />
VertexClass AnnotationTypeMemberDeclaration:BodyDeclaration;<br />
VertexClass FieldDeclaration:BodyDeclaration;<br />
VertexClass MethodDeclaration:BodyDeclaration { name:String, constructor:Boolean, dimension:Integer };<br />
VertexClass EnumConstantDeclaration:BodyDeclaration;<br />
VertexClass Initializer:BodyDeclaration;<br />
</syntaxhighlight><br />
<br />
Die Klassendekelartionen selber erben vom Typ <code>AbstractTypeDeclaration</code>:<br />
<syntaxhighlight line='line'><br />
abstract VertexClass AbstractTypeDeclaration:BodyDeclaration;<br />
VertexClass AnnotationTypeDeclaration:AbstractTypeDeclaration;<br />
VertexClass TypeDeclaration:AbstractTypeDeclaration { name:String, interface:Boolean };<br />
VertexClass EnumDeclaration:AbstractTypeDeclaration;<br />
</syntaxhighlight><br />
<br />
In Typ-Referenzen kommen Unterklassen von <code>Type</code> zum Einsatz, ggf. auch von dessen Unterklasse <code>AnnotatableType</code>:<br />
<syntaxhighlight line='line'><br />
abstract VertexClass Type:Element;<br />
VertexClass ArrayType:Type { dimensions:Integer };<br />
VertexClass IntersectionType:Type;<br />
VertexClass ParameterizedType:Type { name:String };<br />
VertexClass UnionType:Type; <br />
</syntaxhighlight><br />
<br />
<syntaxhighlight line='line'><br />
abstract VertexClass AnnotatableType:Type;<br />
VertexClass PrimitiveType:AnnotatableType { name:String };<br />
VertexClass SimpleType:AnnotatableType { name:String };<br />
VertexClass QualifiedType:AnnotatableType { name:String };<br />
VertexClass NameQualifiedType:AnnotatableType { name:String };<br />
VertexClass WildcardType:AnnotatableType { upperBound:Boolean };<br />
</syntaxhighlight><br />
<br />
Variablen können einzeln oder als sogenanntes Fragment deklariert werden:<br />
<syntaxhighlight line='line'><br />
abstract VertexClass VariableDeclaration:Element;<br />
VertexClass SingleVariableDeclaration:VariableDeclaration { name:String, varargs:Boolean, dimension:Integer };<br />
VertexClass VariableDeclarationFragment:VariableDeclaration { name:String, dimension:Integer };<br />
</syntaxhighlight><br />
<br />
Alle Anweisungen erben von <code>Statement</code>:<br />
<syntaxhighlight line='line'><br />
abstract VertexClass Statement:Element;<br />
VertexClass AssertStatement:Statement;<br />
VertexClass Block:Statement;<br />
VertexClass BreakStatement:Statement { name:String };<br />
VertexClass ConstructorInvocation:Statement;<br />
VertexClass ContinueStatement:Statement { name:String };<br />
VertexClass DoStatement:Statement;<br />
VertexClass EmptyStatement:Statement;<br />
VertexClass EnhancedForStatement:Statement;<br />
VertexClass ExpressionStatement:Statement;<br />
VertexClass ForStatement:Statement;<br />
VertexClass IfStatement:Statement;<br />
VertexClass LabeledStatement:Statement;<br />
VertexClass ReturnStatement:Statement;<br />
VertexClass SuperConstructorInvocation:Statement;<br />
VertexClass SwitchCase:Statement;<br />
VertexClass SwitchStatement:Statement;<br />
VertexClass SynchronizedStatement:Statement;<br />
VertexClass ThrowStatement:Statement;<br />
VertexClass TryStatement:Statement;<br />
VertexClass TypeDeclarationStatement:Statement;<br />
VertexClass VariableDeclarationStatement:Statement;<br />
VertexClass WhileStatement:Statement;<br />
</syntaxhighlight><br />
<br />
Alle Ausdrücke erben von <code>Expression</code>:<br />
<syntaxhighlight line='line'><br />
abstract VertexClass Expression:Element;<br />
VertexClass ArrayAccess:Expression;<br />
VertexClass ArrayCreation:Expression;<br />
VertexClass ArrayInitializer:Expression;<br />
VertexClass Assignment:Expression { name:String };<br />
VertexClass BooleanLiteral:Expression { content:String };<br />
VertexClass CastExpression:Expression;<br />
VertexClass CharacterLiteral:Expression { content:String };<br />
VertexClass ClassInstanceCreation:Expression;<br />
VertexClass ConditionalExpression:Expression;<br />
VertexClass FieldAccess:Expression;<br />
VertexClass InfixExpression:Expression { name:String };<br />
VertexClass InstanceofExpression:Expression;<br />
VertexClass LambdaExpression:Expression { parantheses:Boolean };<br />
VertexClass MethodInvocation:Expression { name:String };<br />
VertexClass NullLiteral:Expression;<br />
VertexClass NumberLiteral:Expression { content:String };<br />
VertexClass ParenthesizedExpression:Expression;<br />
VertexClass PostfixExpression:Expression { name:String };<br />
VertexClass PrefixExpression:Expression { name:String };<br />
VertexClass StringLiteral:Expression { content:String };<br />
VertexClass SuperFieldAccess:Expression;<br />
VertexClass SuperMethodInvocation:Expression { name:String };<br />
VertexClass ThisExpression:Expression;<br />
VertexClass TypeLiteral:Expression;<br />
VertexClass VariableDeclarationExpression:Expression;<br />
</syntaxhighlight><br />
<br />
In Variablen und Methoden-Referenzen kommen Unterklassen von <code>Name</code> zum Einsatz:<br />
<syntaxhighlight line='line'><br />
abstract VertexClass Name:Expression;<br />
VertexClass SimpleName:Name { name:String };<br />
VertexClass QualifiedName:Name;<br />
</syntaxhighlight><br />
<br />
Annotationen erben von <code>Annotation</code>:<br />
<syntaxhighlight line='line'><br />
abstract VertexClass Annotation:Expression;<br />
VertexClass MarkerAnnotation:Annotation;<br />
VertexClass NormalAnnotation:Annotation;<br />
VertexClass SingleMemberAnnotation:Annotation;<br />
</syntaxhighlight><br />
<br />
Methoden-Referenzen erben von <code>MethodReference</code>:<br />
<syntaxhighlight line='line'><br />
abstract VertexClass MethodReference:Expression;<br />
VertexClass CreationReference:MethodReference;<br />
VertexClass ExpressionMethodReference:MethodReference;<br />
VertexClass SuperMethodReference:MethodReference { name:String };<br />
VertexClass TypeMethodReference:MethodReference { name:String };<br />
</syntaxhighlight><br />
<br />
Die Verbindung zwischen Knoten hat auch jeweils einen Kantentyp, der sich aus den beteiligten Typen (oder ggf. deren Obertypen) ergibt. Alle Beziehungen sind als Eltern-Kind-Beziehung definiert, die die Baumstruktur abbildet. Hat ein Eltern-Knoten mehrere Kinder, sind diese entsprechend ihrer Reihenfolge im Code über ein Attribut der Kante durchnummeriert:<br />
<syntaxhighlight line='line'><br />
abstract EdgeClass Child from Node (0,1) to Node (0,*) { position:Integer } ;<br />
EdgeClass AnnotationTypeDeclarationAnnotations:Child from AnnotationTypeDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass AnnotationTypeDeclarationBodyDeclarations:Child from AnnotationTypeDeclaration (1,1) to AnnotationTypeMemberDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass AnnotationTypeDeclarationModifiers:Child from AnnotationTypeDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass AnnotationTypeDeclarationName:Child from AnnotationTypeDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass AnnotationTypeMemberDeclarationAnnotations:Child from AnnotationTypeMemberDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass AnnotationTypeMemberDeclarationDefault:Child from AnnotationTypeMemberDeclaration (1,1) to Expression (0,1) role default;<br />
EdgeClass AnnotationTypeMemberDeclarationModifiers:Child from AnnotationTypeMemberDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass AnnotationTypeMemberDeclarationName:Child from AnnotationTypeMemberDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass AnnotationTypeMemberDeclarationType:Child from AnnotationTypeMemberDeclaration (1,1) to Type (0,1) role type;<br />
EdgeClass AnonymousClassDeclarationBodyDeclarations:Child from AnonymousClassDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass ArrayAccessArray:Child from ArrayAccess (1,1) to Expression (0,1) role array;<br />
EdgeClass ArrayAccessIndex:Child from ArrayAccess (1,1) to Expression (0,1) role index;<br />
EdgeClass ArrayCreationDimensions:Child from ArrayCreation (1,1) to Expression (0,*) role dimensions;<br />
EdgeClass ArrayCreationInitializer:Child from ArrayCreation (1,1) to ArrayInitializer (0,1) role initializer;<br />
EdgeClass ArrayCreationType:Child from ArrayCreation (1,1) to ArrayType (0,1) role type;<br />
EdgeClass ArrayInitializerExpressions:Child from ArrayInitializer (1,1) to Expression (0,*) role expressions;<br />
EdgeClass ArrayTypeComponentType:Child from ArrayType (1,1) to Type (0,1) role elementType;<br />
EdgeClass AssertStatementMessage:Child from AssertStatement (1,1) to Expression (0,1) role message;<br />
EdgeClass AssignmentLeftHandSide:Child from Assignment (1,1) to Expression (0,1) role leftHandSide;<br />
EdgeClass AssignmentRightHandSide:Child from Assignment (1,1) to Expression (0,1) role rightHandSide;<br />
EdgeClass BlockStatements:Child from Block (1,1) to Statement (0,*) role statements;<br />
EdgeClass BodyDeclarationJavadoc:Child from BodyDeclaration (1,1) to Javadoc (0,1) role javadoc;<br />
EdgeClass CastExpressionType:Child from CastExpression (1,1) to Type (0,1) role type;<br />
EdgeClass CatchClauseBody:Child from CatchClause (1,1) to Block (0,*) role body;<br />
EdgeClass CatchClauseException:Child from CatchClause (1,1) to SingleVariableDeclaration (0,*) role exception;<br />
EdgeClass ClassInstanceCreationAnonymousClassDecl:Child from ClassInstanceCreation (1,1) to AnonymousClassDeclaration (0,1) role anonymousClassDeclaration;<br />
EdgeClass ClassInstanceCreationArguments:Child from ClassInstanceCreation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass ClassInstanceCreationType:Child from ClassInstanceCreation (1,1) to Type (0,1) role type;<br />
EdgeClass CompilationUnitImports:Child from CompilationUnit (1,1) to ImportDeclaration (0,*) role imports;<br />
EdgeClass CompilationUnitPackage:Child from CompilationUnit (1,1) to PackageDeclaration (0,*) role package;<br />
EdgeClass CompilationUnitTypes:Child from CompilationUnit (1,1) to AbstractTypeDeclaration (0,*) role types;<br />
EdgeClass ConditionalExpressionElseExpression:Child from ConditionalExpression (1,1) to Expression (0,1) role elseExpression;<br />
EdgeClass ConditionalExpressionThenExpression:Child from ConditionalExpression (1,1) to Expression (0,1) role thenExpression;<br />
EdgeClass ConstructorInvocationArguments:Child from ConstructorInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass ConstructorInvocationTypeArguments:Child from ConstructorInvocation (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass CreationReferenceTypeArguments:Child from CreationReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass CreationReferenceType:Child from CreationReference (1,1) to Type (0,1) role type;<br />
EdgeClass DimensionAnnotations:Child from Dimension (1,1) to Annotation (0,*) role annotations;<br />
EdgeClass DoStatementBody:Child from DoStatement (1,1) to Block (0,1) role body;<br />
EdgeClass ElementExpression:Child from Element (1,1) to Expression (0,*) role expression;<br />
EdgeClass EnhancedForStatementBody:Child from EnhancedForStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass EnhancedForStatementParameter:Child from EnhancedForStatement (1,1) to SingleVariableDeclaration (0,1) role parameter;<br />
EdgeClass EnumConstantDeclarationAnonymousClassDeclaration:Child from EnumConstantDeclaration (1,1) to AnonymousClassDeclaration (0,1) role anonymousClassDeclaration;<br />
EdgeClass EnumConstantDeclarationAnnotations:Child from EnumConstantDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass EnumConstantDeclarationArguments:Child from EnumConstantDeclaration (1,1) to Expression (0,*) role arguments;<br />
EdgeClass EnumConstantDeclarationModifiers:Child from EnumConstantDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass EnumConstantDeclarationName:Child from EnumConstantDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass EnumDeclarationAnnotations:Child from EnumDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass EnumDeclarationBodyDeclaration:Child from EnumDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass EnumDeclarationEnumConstants:Child from EnumDeclaration (1,1) to EnumConstantDeclaration (0,*) role enumConstants;<br />
EdgeClass EnumDeclarationModifiers:Child from EnumDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass EnumDeclarationName:Child from EnumDeclaration (1,1) to SimpleName (0,1) role name;<br />
EdgeClass EnumDeclarationSuperInterfaceTypes:Child from EnumDeclaration (1,1) to Type (0,*) role superInterfaceTypes; <br />
EdgeClass ExpressionMethodReferenceArguments:Child from ExpressionMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass ExpressionMethodReferenceName:Child from ExpressionMethodReference (1,1) to SimpleName (0,1) role name;<br />
EdgeClass FieldAccessName:Child from FieldAccess (1,1) to SimpleName (0,1) role name;<br />
EdgeClass FieldDeclarationAnnotation:Child from FieldDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass FieldDeclarationFragments:Child from FieldDeclaration (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass FieldDeclarationModifiers:Child from FieldDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass FieldDeclarationType:Child from FieldDeclaration (1,1) to Type (0,1) role type;<br />
EdgeClass ForStatementBody:Child from ForStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass ForStatementInitializers:Child from ForStatement (1,1) to Expression (0,*) role initializers;<br />
EdgeClass ForStatementUpdaters:Child from ForStatement (1,1) to Expression (0,*) role updaters;<br />
EdgeClass IfStatementElseStatement:Child from IfStatement (1,1) to Statement (0,1) role elseStatement;<br />
EdgeClass IfStatementThenStatement:Child from IfStatement (1,1) to Statement (0,1) role thenStatement;<br />
EdgeClass IJavaProjectFragements:Child from IJavaProject (1,1) to IPackageFragment (0,*) role fragments;<br />
EdgeClass IJavaProjectUnits:Child from IJavaProject (1,1) to CompilationUnit (0,*) role units;<br />
EdgeClass InfixExpressionExtendedOperands:Child from InfixExpression (1,1) to Expression (0,*) role extendedOperands;<br />
EdgeClass InfixExpressionLeftOperand:Child from InfixExpression (1,1) to Expression (0,1) role leftOperand;<br />
EdgeClass InfixExpressionRightOperand:Child from InfixExpression (1,1) to Expression (0,1) role rightOperand;<br />
EdgeClass InitializerAnnotation:Child from Initializer (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass InitializerBody:Child from Initializer (1,1) to Block (0,1) role body;<br />
EdgeClass InitializerModifiers:Child from Initializer (1,1) to Modifier(0,*) role modifiers2;<br />
EdgeClass IntersectionTypeTypes:Child from IntersectionType (1,1) to Type (0,*) role types;<br />
EdgeClass InstanceofExpressionLeftOperand:Child from InstanceofExpression (1,1) to Expression (0,1) role leftOperand;<br />
EdgeClass InstanceofExpressionRightOperand:Child from InstanceofExpression (1,1) to Type (0,1) role rightOperand;<br />
EdgeClass IPackageFragmentUnits:Child from IPackageFragment (1,1) to CompilationUnit (0,*) role units;<br />
EdgeClass JavadocTags:Child from Javadoc (1,1) to TagElement (0,*) role tags;<br />
EdgeClass LambdaExpressionBody:Child from LambdaExpression (1,1) to Element (0,1) role body;<br />
EdgeClass LambdaExpressionParameters:Child from LambdaExpression (1,1) to VariableDeclaration (0,*) role parameters;<br />
EdgeClass LabeledStatementBody:Child from LabeledStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass LabeledStatementLabel:Child from LabeledStatement (1,1) to SimpleName (0,1) role label;<br />
EdgeClass MarkerAnnotationTypeName:Child from MarkerAnnotation (1,1) to SimpleName (0,*) role typeName;<br />
EdgeClass MemberRefName:Child from MemberRef (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MemberRefQualifier:Child from MemberRef (1,1) to Name (0,1) role qualifier;<br />
EdgeClass MemberValuePairName:Child from MemberValuePair (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MemberValuePairValue:Child from MemberValuePair (1,1) to Expression (0,1) role value;<br />
EdgeClass MethodDeclarationAnnotation:Child from MethodDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass MethodDeclarationBody:Child from MethodDeclaration (1,1) to Block (0,1) role body;<br />
EdgeClass MethodDeclarationModifiers:Child from MethodDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass MethodDeclarationParameters:Child from MethodDeclaration (1,1) to SingleVariableDeclaration (0,*) role parameters;<br />
EdgeClass MethodDeclarationReceiverQualifier:Child from MethodDeclaration (1,1) to SimpleName (0,1) role receiverQualifier;<br />
EdgeClass MethodDeclarationReceiverType:Child from MethodDeclaration (1,1) to Type (0,1) role receiverType;<br />
EdgeClass MethodDeclarationReturnType:Child from MethodDeclaration (1,1) to Type (0,1) role returnType2;<br />
EdgeClass MethodDeclarationThrownExceptions:Child from MethodDeclaration (1,1) to Type (0,*) role thrownExceptionTypes;<br />
EdgeClass MethodDeclarationTypeParameters:Child from MethodDeclaration (1,1) to TypeParameter (0,*) role typeParameters;<br />
EdgeClass MethodInvocationArguments:Child from MethodInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass MethodRefName:Child from MethodRef (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MethodRefParameters:Child from MethodRef (1,1) to MethodRefParameter (0,*) role parameters;<br />
EdgeClass MethodRefQualifier:Child from MethodRef (1,1) to Name (0,1) role qualifier;<br />
EdgeClass MethodRefParameterName:Child from MethodRefParameter (1,1) to SimpleName (0,1) role name;<br />
EdgeClass MethodRefParameterType:Child from MethodRefParameter (1,1) to Type (0,1) role type;<br />
EdgeClass NormalAnnotationTypeName:Child from NormalAnnotation (1,1) to Name (0,1) role typeName;<br />
EdgeClass NormalAnnotationValues:Child from NormalAnnotation (1,1) to MemberValuePair (0,*) role values;<br />
EdgeClass ParameterizedTypeType:Child from ParameterizedType (1,1) to SimpleType (0,1) role type;<br />
EdgeClass ParameterizedTypeTypeArguments:Child from ParameterizedType (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass PostfixExpressionOperand:Child from PostfixExpression (1,1) to SimpleName (0,1) role operand;<br />
EdgeClass PrefixExpressionOperand:Child from PrefixExpression (1,1) to Expression (0,1) role operand;<br />
EdgeClass QualifiedNameName:Child from QualifiedName (1,1) to SimpleName (0,1) role name;<br />
EdgeClass QualifiedNameQualifier:Child from QualifiedName (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SimpleNameValues:Child from SimpleName (1,1) to MethodDeclaration (0,*) role values;<br />
EdgeClass SimpleTypeAnnotation:Child from SimpleType (1,1) to Annotation (0,*) role annotations;<br />
EdgeClass SimpleTypeName:Child from SimpleType (1,1) to Name (0,1) role name2;<br />
EdgeClass SingleMemberAnnotationTypeName:Child from SingleMemberAnnotation (1,1) to SimpleName (0,1) role typeName;<br />
EdgeClass SingleMemberAnnotationValue:Child from SingleMemberAnnotation (1,1) to Expression (0,1) role value;<br />
EdgeClass SingleVariableDeclarationAnnotation:Child from SingleVariableDeclaration (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass SingleVariableDeclarationExtraDimensions:Child from SingleVariableDeclaration (1,1) to Dimension (0,*) role extraDimensions2;<br />
EdgeClass SingleVariableDeclarationInitializer:Child from SingleVariableDeclaration (1,1) to Expression (0,1) role initializer;<br />
EdgeClass SingleVariableDeclarationModifiers:Child from SingleVariableDeclaration (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass SingleVariableDeclarationType:Child from SingleVariableDeclaration (1,1) to Type (0,*) role type;<br />
EdgeClass SingleVariableDeclarationVarargsAnnotations:Child from SingleVariableDeclaration (1,1) to Annotation (0,*) role varargsAnnotations;<br />
EdgeClass SuperConstructorInvocationArgument:Child from SuperConstructorInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass SuperConstructorInvocationTypeArguments:Child from SuperConstructorInvocation (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass SuperFieldAccessName:Child from SuperFieldAccess (1,1) to SimpleName (0,1) role name;<br />
EdgeClass SuperFieldAccessQualifier:Child from SuperFieldAccess(1,1) to Name (0,1) role qualifier;<br />
EdgeClass SuperMethodInvocationArguments:Child from SuperMethodInvocation (1,1) to Expression (0,*) role arguments;<br />
EdgeClass SuperMethodInvocationQualifier:Child from SuperMethodInvocation (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SuperMethodReferenceArguments:Child from SuperMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass SuperMethodReferenceQualifier:Child from SuperMethodReference (1,1) to Name (0,1) role qualifier;<br />
EdgeClass SwitchStatementStatements:Child from SwitchStatement (1,1) to Statement (0,*) role statements;<br />
EdgeClass SynchronizedStatementBlock:Child from SynchronizedStatement (1,1) to Block (0,1) role body;<br />
EdgeClass TagElementFragments1:Child from TagElement (1,1) to TextElement (0,*) role fragments1;<br />
EdgeClass TagElementFragments2:Child from TagElement (1,1) to Name (0,*) role fragments2;<br />
EdgeClass TagElementFragments3:Child from TagElement (1,1) to MethodRef (0,*) role fragments3;<br />
EdgeClass TagElementFragments4:Child from TagElement (1,1) to MemberRef (0,*) role fragments4;<br />
EdgeClass TagElementFragments5:Child from TagElement (1,1) to TagElement (0,*) role fragments5;<br />
EdgeClass ThisExpressionQualifier:Child from ThisExpression (1,1) to Name (0,1) role qualifier;<br />
EdgeClass TryStatementBody:Child from TryStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass TryStatementCatchClauses:Child from TryStatement (1,1) to CatchClause (0,*) role catchClauses;<br />
EdgeClass TryStatementFinally:Child from TryStatement (1,1) to Block (0,1) role finally;<br />
EdgeClass TryStatementResources:Child from TryStatement (1,1) to VariableDeclarationExpression (0,*) role resources;<br />
EdgeClass TypeDeclarationAnnotation:Child from TypeDeclaration (1,1) to Annotation (0,*) role modifiers2;<br />
EdgeClass TypeDeclarationBodyDeclarations1:Child from TypeDeclaration (1,1) to BodyDeclaration (0,*) role bodyDeclarations;<br />
EdgeClass TypeDeclarationModifiers:Child from TypeDeclaration (1,1) to Modifier (0,*) role modifiers1;<br />
EdgeClass TypeDeclarationSuperclassType:Child from TypeDeclaration (1,1) to Type (0,1) role superclassType;<br />
EdgeClass TypeDeclarationSuperInterfaceTypes:Child from TypeDeclaration (1,1) to Type (0,*) role superInterfaceTypes;<br />
EdgeClass TypeDeclarationTypeParameters:Child from TypeDeclaration (1,1) to TypeParameter (0,*) role typeParameters;<br />
EdgeClass TypeLiteralType:Child from TypeLiteral (1,1) to Type (0,1) role type;<br />
EdgeClass TypeMethodReferenceArguments:Child from TypeMethodReference (1,1) to Type (0,*) role typeArguments;<br />
EdgeClass TypeMethodReferenceType:Child from TypeMethodReference (1,1) to Type (0,1) role type;<br />
EdgeClass TypeParameterName:Child from TypeParameter (1,1) to SimpleName (0,1) role name;<br />
EdgeClass TypeParameterType:Child from TypeParameter (1,1) to Type (0,*) role typeBounds;<br />
EdgeClass UnionTypeTypes:Child from UnionType (1,1) to Type (0,*) role types;<br />
EdgeClass VariableDeclarationExpressionAnnotation:Child from VariableDeclarationExpression (1,1) to Annotation (0,*) role modifiers1;<br />
EdgeClass VariableDeclarationExpressionFragments:Child from VariableDeclarationExpression (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass VariableDeclarationExpressionModifiers:Child from VariableDeclarationExpression (1,1) to Modifier (0,*) role modifiers2;<br />
EdgeClass VariableDeclarationExpressionType:Child from VariableDeclarationExpression (1,1) to Type (0,1) role type;<br />
EdgeClass VariableDeclarationFragmentInitializer:Child from VariableDeclarationFragment (1,1) to Expression (0,1) role initializer;<br />
EdgeClass VariableDeclarationStatementFragments:Child from VariableDeclarationStatement (1,1) to VariableDeclarationFragment (0,*) role fragments;<br />
EdgeClass VariableDeclarationStatementModifier:Child from VariableDeclarationStatement (1,1) to Modifier (0,*) role modifiers;<br />
EdgeClass VariableDeclarationStatementType:Child from VariableDeclarationStatement (1,1) to Type (0,1) role type;<br />
EdgeClass WhileStatementBody:Child from WhileStatement (1,1) to Statement (0,1) role body;<br />
EdgeClass WildcardTypeBound1:Child from WildcardType (1,1) to ParameterizedType (0,*) role bound1;<br />
EdgeClass WildcardTypeBound2:Child from WildcardType (1,1) to SimpleType (0,*) role bound2;<br />
</syntaxhighlight><br />
<br />
JACK erzeugt zusätzliche Kanten vom Typ <code>Access </code>, mit denen vom Zugriff auf ein Element auf dessen Deklaration verwiesen wird. Diese Kanten sind nicht Teil des Syntaxbaumes, sondern erweitern ihn zu einem Graph. Sie stehen nur zur Verfügung, wenn Zugriff und Deklaration innerhalb des geparsten Codes liegen:<br />
<syntaxhighlight line='line'><br />
abstract EdgeClass Access from Node (0,1) to Node (0,*);<br />
EdgeClass ExpressionAccess1:Access from Expression (1,1) to BodyDeclaration (0,*) role access1;<br />
EdgeClass ExpressionAccess2:Access from Expression (1,1) to VariableDeclaration (0,*) role access2;<br />
EdgeClass TypeAccess:Access from Type (1,1) to TypeDeclaration (0,*) role access;<br />
</syntaxhighlight></div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQLJavaChecker&diff=8968GReQLJavaChecker2023-08-25T08:06:46Z<p>Striewe: </p>
<hr />
<div>Der GReQLJavaChecker ermöglicht statische Checks auf Programmcode und verwendet dazu Abfragen auf dem Syntaxgraphen. Um einen statischen Check mit dem Checker durchzuführen, müssen die zu untersuchenden Dateien in der Liste "Source Files" ausgewählt werden und eine einzelne Datei mit Prüfregeln ("Rule File") angegeben werden. Die Regeln werden in dieser Datei im XML-Format organisiert und verwenden die Sprache GReQL für Abfragen auf dem Syntaxbaum.<br />
<br />
=== Beispiele und Eigenschaften von Regeln ===<br />
Als erstes Element im XML Dokument muss <checkerrules> stehen, entsprechend muss </checkerrules> als letztes Element in dem XML Dokument sein.<br />
<br />
Zwei beispielhafte Abfragen in dieser Sprache sehen so aus:<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{WhileStatement} with<br />
not isEmpty(u -->* x -->{WhileStatementBody}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block}) and<br />
isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block} -->{Child}))<br />
report u.name as "name", x.line as "line" end</query><br />
<feedback>In der Datei {name} besteht die while-Schleife in Zeile {line} nur aus einer<br />
Abbruchbedingung und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration} with<br />
t.name="Miniprojekt2" and<br />
t -->{TypeDeclarationBodyDeclarations2} m and<br />
hasSignature(m, "public static String geometrie1(int)")<br />
report 0 end</query><br />
<feedback prefix="Signaturcheck">Die Methode "public static String geometrie1(int laenge)" in<br />
der Klasse "Miniprojekt2" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
<br />
Die obere Regel ist vom Typ "absence", d.h. sie definiert einen Codestruktur, die nicht in der untersuchten Lösung vorkommen soll. Als Abfrage wird eine Struktur aus Elementen des Syntaxbaums definiert. Als Meldung wird ein String definiert, der zur Fehlerliste hinzugefügt wird, wenn die in der Abfrage definierte Struktur gefunden wird. Dabei dienen {name} und {line} als Platzhalter für Werte, die in der Abfrage in der report-Klausel ausgegeben wurden. Die zweite Regel ist vom Typ "presence" und definiert folglich eine Codestruktur, die in der untersuchten Lösung vorkommen soll. D.h., in diesem Fall wird die definierte Fehlermeldung ausgegeben, wenn die in der Abfrage definierte Struktur nicht auftritt. Folglich können in dieser Regel auch keine Platzhalter in der Ausgabe verwendet werden.<br />
<br />
''&rarr; Details zu den verwendeten GReQL-Bezeichnern:'' [[GReQL-Typegraph für Java]]<br />
<br />
Die Funktion <code>hasSignature</code> ist eine spezielle, von JACK bereitgestellte Erweiterung der GReQL-Syntax, die eine bequeme Überprüfung von Methodensignaturen ermöglicht. Wie im Beispiel dargestellt, braucht die übergebene Zeichenkette keine vollständige Methodensignatur zu sein, sondern es reicht die Angabe der zu überprüfenden Bestandteile. D.h., Namen der Methodenparameter können ebenso entfallen wie Modifier oder der Rückgabetyp. Es ist allerdings nicht möglich, nur Modifier anzugeben und keinen Rückgabetyp.<br />
<br />
''&rarr; Weitere Beispiele:'' [[GReQL Regeln]]<br />
<br />
=== Auswertung eines Regelsatzes ===<br />
Bei der Durchführung des statischen Checks wird zunächst der abstrakte Syntaxgraph der abgegebenen Lösung erzeugt und anschließend alle Regeln angewendet. Alle erzeugten Fehlernachrichten werden als Ausgabe des statischen Tests gesammelt. Die vergebene Punktzahl ergibt sich aus den Punkten der einzelnen Regeln, wobei die Gesamtsumme der Punkte in der Regeldatei stets auf 100 normiert wird. D.h., im oben gezeigten Beispiel erhält eine korrekte Lösung 100 Punkte, während eine Lösung, die die erste Regel verletzt, nur 67 Punkte erhält. Tritt während des Checks ein technischer Fehler auf, wird der Check abgebrochen und die Lösung mit einem "internal error" als fehlerhaft markiert.<br />
<br />
=== Versionsunterschiede ===<br />
Je nach eingesetzter Checker-Version müssen einige Abfragen zur Code-Struktur leicht unterschiedlich formuliert werden. Dies betrifft insbesondere die beiden Checker-Versionen, die in JACK 2 und JACK 3 zum Einsatz kommen.<br />
<br />
{| class="wikitable"<br />
|-<br />
! Art der Änderung !! Alt (insb. JACK 2) !! Neu (insb. JACK 3 und Moodle-Plugin)<br />
|-<br />
| Geänderter Kantentyp || <code>TypeDeclarationBodyDeclarations2</code> || <code>TypeDeclarationBodyDeclarations1</code><br />
|-<br />
| Geänderter Kantentyp || <code>TypeDeclarationSuperclassType2</code> || <code>TypeDeclarationSuperclassType</code><br />
|-<br />
| Geänderter Kantentyp || <code>ParameterizedTypeTypeArguments1</code><br><code>ParameterizedTypeTypeArguments2</code> || <code>ParameterizedTypeTypeArguments</code><br />
|-<br />
| Geänderter Kantentyp || <code>TypeDeclarationSuperInterfaceTypes1</code><br><code>TypeDeclarationSuperInterfaceTypes2</code> || <code>TypeDeclarationSuperInterfaceTypes</code><br />
|-<br />
| Erweiterte Funktion || Die Funktion <code>hasSignature</code> kann nicht auf geworfene Exceptions prüfen || Die Prüfung ist möglich<br />
|}<br />
<br />
==Tools==<br />
[[Media:GReQL-Referencecard.pdf|GReQL-Referencecard]]<br />
<br />
[[category:Checker]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQL_Regeln&diff=8710GReQL Regeln2023-07-12T06:43:09Z<p>Striewe: /* Codestil */</p>
<hr />
<div>== Beispiele für statische Prüfregeln für Java-Code ==<br />
=== Codestil ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{MethodDeclaration}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
x.constructor="false"<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Methodennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Methodennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{TypeDeclaration}<br />
with<br />
not (x.name=capitalizeFirst(x.name))<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Klassennamen, die nicht mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach klein geschriebenen Klassennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{VariableDeclarationFragment}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
isEmpty(from m : V{Modifier} with x &lt;--&amp;{FieldDeclaration} --> m and m.name="final" report m end)<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Variablennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Variablennamen, wobei als "final" deklarierte Klassenvariablen ausgelassen werden.<br />
<br />
=== Einfache Inhalte ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
s.content = "\"Zeichenkette\""<br />
report 0 end<br />
</query><br />
<feedback>Deine Lösung verwendet nicht den String "Zeichenkette".</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal mit einem vorgegebenen Inhalt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
stringLength(s.content) > 4<br />
report s.line as "line" end<br />
</query><br />
<feedback>Du verwendest in Zeile {line} ein festes String-Literal. Ist deine Lösung allgemeingültig?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal der Länge 4 oder länger (inklusive Anführungszeichen) und meldet es mit Angabe der Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from p : V{PackageDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Paketdefinition">Deine Lösung beinhaltet eine package-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Paketdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query> from p : V{ImportDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Importdefinition"> Deine Lösung beinhaltet eine import-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Importdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from u : V{CompilationUnit}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
x.name="exit" and<br />
y.name="System"<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>Der Aufruf von "System.exit()" in der Datei {name} in Zeile {line} ist nicht gestattet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.exit()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x : V{MethodInvocation}, y, z : V{SimpleName}<br />
with<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameName} y and<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameQualifier} z and<br />
(x.name="print" or x.name="println") and<br />
y.name="out" and z.name="System"<br />
report x.line as "line" end<br />
</query><br />
<feedback>You have a print statement in line {line}. Are you sure you want to print to console instead of returning?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.out.print()</code> oder <code>System.out.println()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
=== Kontrollstrukturen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m.name="m" and<br />
isEmpty(m -->{Child}*&amp;{WhileStatement}) and<br />
isEmpty(m -->{Child}*&amp;{DoStatement}) and<br />
isEmpty(m -->{Child}*&amp;{ForStatement}) and<br />
isEmpty(m -->{Child}*&amp;{EnhancedForStatement})<br />
report 0 end<br />
</query><br />
<feedback>In der Methode "m()" wird kein Schleifenkonstrukt verwendet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> ein beliebiges Schleifenkonstrukt enthält.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
( not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block} -->{Child}))<br />
) and<br />
( not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block} -->{Child}))<br />
)<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} enthält das if-Statement in Zeile {line} in beiden Zweigen keinen Code und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die nur leere Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) and<br />
isEmpty(x -->{IfStatementElseStatement}&amp;{Statement})<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} endet das if-Statement in Zeile {line} hinter der Bedingung sofort mit einem Semikolon. Die Bedingung ist dadurch wirkungslos und die folgende Anweisung wird immer ausgeführt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die keine Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{WhileStatement}<br />
with<br />
not isEmpty(u -->* x -->{WhileStatementBody}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block}) and<br />
isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block} -->{Child}))<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} besteht die while-Schleife in Zeile {line} nur aus einer Abbruchbedingung und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer while-Schleife, die nur aus einer Abbruchbedingung besteht und meldet eine solche Schleife als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from m : V{MethodDeclaration}, n : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration})* n and<br />
n -->{Child}*&amp;{MethodInvocation} -->{Access} m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck"> Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet. Dabei ist es egal, ob sich die Methode direkt selber aufruft, oder über einen oder mehrere Zwischenschritte aufgerufen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration}) m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck">Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet und sich insbesondere ohne Zwischenschritte über andere Methoden selber wieder aufruft.<br />
<br />
=== Methoden ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations2} m and<br />
hasSignature(m, "public static String method(int)")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "public static String method(int param)" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, wobei der Name des Methodenparameters unerheblich ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations2} m and<br />
hasSignature(m, "int method()") and<br />
isEmpty(m -->{Child}&amp;{Modifier})<br />
report 0 end<br />
</query><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, mo : V{Modifier}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations2} m and<br />
hasSignature(m, "int method()") and<br />
m --> mo and not (mo.name="private")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "int method()" in der Klasse "A" fehlt oder ist mit dem Modifier "private" versehen. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, die nicht mit dem Modifier private versehen ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations2} m and<br />
m.name="m" and<br />
m -->{MethodDeclarationReturnType} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments1} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Signatur">Der Methode "public B&lt;C&gt; m()" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode m mit parametrisierten Rückgabetyp B<C> enthält.<br />
<br />
=== Vererbungshierarchie ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
st.name="B" and<br />
t -->{TypeDeclarationSuperclassType2} st<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A ist nicht als Unterklasse von B modelliert.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A direkte Unterklasse von Klasse B ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes2} st and<br />
st.name="B"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes1} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments1} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B&lt;C&gt;.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B<C> implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="3"><br />
<query>from u : V{TypeDeclaration}, s : V{SimpleType}<br />
with<br />
((u -->{TypeDeclarationSuperclassType2} s and s.name="Thread") or<br />
(u -->{TypeDeclarationSuperInterfaceTypes2} s and s.name="Runnable")) and<br />
u.name="A"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte entweder das Interface "Runnable" implementieren oder von "Thread" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface Runnable implementiert oder von Thread erbt.<br />
<br />
=== Aufrufbeziehungen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "B.m()" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode B.m aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}, z : V{VariableDeclarationStatement}, f : V{VariableDeclarationFragment}, t : V{SimpleType}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u -->* z -->{VariableDeclarationStatementType} t and<br />
u -->* z -->{VariableDeclarationStatementFragments} f and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name=f.name and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "m()" auf einem Objekt vom Typ "B" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A Methode m auf einem Objekt vom Typ B aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from u : V{TypeDeclaration}, m : V{MethodDeclaration}, x : V{ClassInstanceCreation}, t : V{SimpleType}<br />
with<br />
u -->{Child}* m -->* x -->{ClassInstanceCreationType} t and<br />
u.name="A" and<br />
m.name="m" and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" muss in Methode m() mindestens eine Instanz von "B" erzeugt werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A in Methode m eine Instanz von Klasse B erstellt.<br />
<br />
== Beispiele für statische Prüfregeln für UML-Modelle im XMI2-Format ==<br />
=== Klassendiagramme ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback prefix="Hinweis">Im Diagramm sind die "B" eines "A" als eigene Klasse abgebildet. Das kannst du durch eine bessere Modellierung vermeiden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft ebenfalls, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind, definiert dies aber als unerwünschte Situation mit entsprechendem Feedback.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}, z: V{Property}<br />
with<br />
x --> z and<br />
z --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B" and<br />
isDefined(z.lower) and z.lower="1" and (not isDefined(z.upper) or z.upper="1")<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" mit der Kardinalität 1 oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation mit Kardinalität 1 (jedes A kennt genau ein B) verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b : V{Class}, p: V{Property}<br />
with<br />
isEmpty(a -->&amp;{Property} -->&amp;{Association}) and<br />
b --> p and<br />
isDefined(p.aggregation) and p.aggregation="composite"<br />
report 1 end<br />
</query><br />
<feedback>Es sollte im Diagramm zwei Klassen geben, bei denen die eine keine weiteren Bestandteile hat, während die andere weitere Bestandteile gemäß der Komposition hat.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse ohne ausgehende Assoziationen gibt und eine weitere, die mindestens eine ausgehende Komposition hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Property}, z : V{PrimitiveType}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and y.name="b" and<br />
y --> z and<br />
isDefined(z.name) and z.name="String"<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll ein Attribut für die Eigenschaft "b" bereitstellen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse "A" mit dem Attribut "b" vom Typ "String" gibt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Operation}, z: V{Parameter}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and stringLevenshteinDistance(y.name, "ausführen")&lt;3 and<br />
y --> z<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll eine Methode bereitstellen, mit der sie etwas ausführen kann.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel prüft, ob es im Modell eine Klasse "A" mit einer Operation gibt, deren Name "ausführen" oder ähnlich lautet.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>let c := count(from y : V{Operation} with isDefined(y.name) report y end) in<br />
from x : set(1)<br />
with<br />
c&lt;>7<br />
report c as "count" end<br />
</query><br />
<feedback>Das Diagramm sollte genau 7 Methoden enthalten, enthält aber {count}.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell genau 7 Methoden enthält und gibt im Falle einer anderen Anzahl diese im Feedback mit aus.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}<br />
with<br />
isDefined(x.name) and x.name=A" and<br />
x.isAbstract and<br />
not isEmpty(x &lt;--&amp;{Generalization})<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte eine abstrakte Klasse "A" enthalten, von der mindestens eine Klasse erbt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine abstrakte Klasse "A" enthält, auf die in mindestens einer Generalisierung verwiesen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b,c,d : V{Class}<br />
with<br />
isDefined(a.name) and a.name="A" and<br />
isDefined(b.name) and b.name="B" and<br />
isDefined(c.name) and c.name="C" and<br />
isDefined(d.name) and d.name="D" and<br />
a --> V{Generalization} --> d and<br />
b --> V{Generalization} --> d and<br />
c --> V{Generalization} --> d<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte Klassen "A", "B" und "C" enthalten, die von einer gemeinsamen Oberklasse "D" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine Klasse "D" enthält, die drei direkte Unterklassen "A", "B" und "C" hat.<br />
<br />
== Beispiele für statische Prüfregeln für EPML ==<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x: V{Event}<br />
with<br />
isEmpty(x &lt;--)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt kein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph kein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="5"><br />
<query> from x,y: V{Event}<br />
with<br />
isEmpty(x &lt;--) and<br />
isEmpty(y &lt;--) and<br />
not (x=y)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt mehr als ein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph mehr als ein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="3"><br />
<query> from x,y: V{Element, ^Connector}<br />
with<br />
not (x.name="") and<br />
x.name = y.name and<br />
not (x = y)<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Es gibt mindestens zwei Elemente mit demselben Namen ("{name}").</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob es der Graph Elemente mit demselben Namen besitzt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Element, ^Connector}, y1, y2 : V{Element}<br />
with<br />
x --> y1 and<br />
x --> y2 and<br />
not (y1=y2)<br />
report x.name as "xName", x.id as "xID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Das Element "{xName}" (ID {xID}) hat mehr als einen Ausgang.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob ein Event oder Funktion mehr als einen Ausgang hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Connector}, y: V{Connector}<br />
with<br />
not (x.name="") and<br />
not (y.name="") and<br />
x --> y<br />
report x.name as "xName", y.name as "yName", x.id as "xID", y.id as "yID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Es dürfen keine zwei Konnektoren direkt aufeinander folgen. Es folgt jedoch "{yName}" (ID {yID}) direkt auf "{xName}" (ID {xID}).</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob 2 Konnektoren aufeinander folgen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x: V{Element, ^Connector}<br />
with<br />
contains(x.name, " and ") or<br />
contains(x.name, "+") or<br />
contains(x.name, " und ")<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Der Name "{name}" sieht danach aus, als wenn hier zwei Events bzw. Funktionen in einem Element zusammengefasst wurden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob der Graph möglicherweise Zeichen bzw. Wörter besitzt die mehrere Funktionen/Events in einem Element verbinden.<br />
<br />
[[Category:R-GReQL]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=GReQL_Regeln&diff=8709GReQL Regeln2023-07-12T06:41:15Z<p>Striewe: /* Beispiele für statische Prüfregeln für UML-Modelle im XMI2-Format */</p>
<hr />
<div>== Beispiele für statische Prüfregeln für Java-Code ==<br />
=== Codestil ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{MethodDeclaration}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
x.constructor="false"<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Methodennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Methodennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{TypeDeclaration}<br />
with<br />
not (x.name=capitalizeFirst(x.name))<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Klassennamen, die nicht mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach klein geschriebenen Klassennamen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x : V{VariableDeclarationFragment}<br />
with<br />
x.name=capitalizeFirst(x.name) and<br />
isEmpty(from m : V{Modifier} with x <nowiki>&amp;lt;--&amp;amp;{FieldDeclaration} --&amp;gt;</nowiki> m and m.name="final" report m end)<br />
report 0 end<br />
</query><br />
<feedback prefix="Hinweis (ohne Punktabzug)">Du verwendest Variablennamen, die mit einem Großbuchstaben beginnen. Das ist möglich, aber es entspricht nicht dem üblichen Programmierstil für Java.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach groß geschriebenen Variablennamen, wobei als "final" deklarierte Klassenvariablen ausgelassen werden.<br />
<br />
=== Einfache Inhalte ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
s.content = "\"Zeichenkette\""<br />
report 0 end<br />
</query><br />
<feedback>Deine Lösung verwendet nicht den String "Zeichenkette".</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal mit einem vorgegebenen Inhalt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from m : V{MethodDeclaration}, s : V{StringLiteral}<br />
with<br />
m.name="m" and<br />
m -->{Child}* s and<br />
stringLength(s.content) > 4<br />
report s.line as "line" end<br />
</query><br />
<feedback>Du verwendest in Zeile {line} ein festes String-Literal. Ist deine Lösung allgemeingültig?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht in der Methode <code>m</code> nach einem String-Literal der Länge 4 oder länger (inklusive Anführungszeichen) und meldet es mit Angabe der Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from p : V{PackageDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Paketdefinition">Deine Lösung beinhaltet eine package-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Paketdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query> from p : V{ImportDeclaration}<br />
report 0 end<br />
</query><br />
<feedback prefix="Importdefinition"> Deine Lösung beinhaltet eine import-Angabe. Bitte entferne diese.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Importdefinitionen und meldet diese als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from u : V{CompilationUnit}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
x.name="exit" and<br />
y.name="System"<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>Der Aufruf von "System.exit()" in der Datei {name} in Zeile {line} ist nicht gestattet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.exit()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x : V{MethodInvocation}, y, z : V{SimpleName}<br />
with<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameName} y and<br />
x -->{ElementExpression}&amp;{QualifiedName} -->{QualifiedNameQualifier} z and<br />
(x.name="print" or x.name="println") and<br />
y.name="out" and z.name="System"<br />
report x.line as "line" end<br />
</query><br />
<feedback>You have a print statement in line {line}. Are you sure you want to print to console instead of returning?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach Aufrufen von <code>System.out.print()</code> oder <code>System.out.println()</code> und melde diese unter Angabe von Klasse und Zeilennummer als Fehler.<br />
<br />
=== Kontrollstrukturen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m.name="m" and<br />
isEmpty(m -->{Child}*&amp;{WhileStatement}) and<br />
isEmpty(m -->{Child}*&amp;{DoStatement}) and<br />
isEmpty(m -->{Child}*&amp;{ForStatement}) and<br />
isEmpty(m -->{Child}*&amp;{EnhancedForStatement})<br />
report 0 end<br />
</query><br />
<feedback>In der Methode "m()" wird kein Schleifenkonstrukt verwendet.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> ein beliebiges Schleifenkonstrukt enthält.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
( not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{Block} -->{Child}))<br />
) and<br />
( not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block}) and isEmpty(u -->* x -->{IfStatementElseStatement}&amp;{Block} -->{Child}))<br />
)<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} enthält das if-Statement in Zeile {line} in beiden Zweigen keinen Code und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die nur leere Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{IfStatement}<br />
with<br />
not isEmpty(u -->* x -->{IfStatementThenStatement}&amp;{EmptyStatement}) and<br />
isEmpty(x -->{IfStatementElseStatement}&amp;{Statement})<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} endet das if-Statement in Zeile {line} hinter der Bedingung sofort mit einem Semikolon. Die Bedingung ist dadurch wirkungslos und die folgende Anweisung wird immer ausgeführt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer if-Anweisung, die keine Zweige enthält und meldet eine solche Anweisung als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="2"><br />
<query>from u : V{CompilationUnit}, x : V{WhileStatement}<br />
with<br />
not isEmpty(u -->* x -->{WhileStatementBody}&amp;{EmptyStatement}) or<br />
(not isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block}) and<br />
isEmpty(u -->* x -->{WhileStatementBody}&amp;{Block} -->{Child}))<br />
report u.name as "name", x.line as "line" end<br />
</query><br />
<feedback>In der Datei {name} besteht die while-Schleife in Zeile {line} nur aus einer Abbruchbedingung und ist dadurch sinnlos.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel sucht nach einer while-Schleife, die nur aus einer Abbruchbedingung besteht und meldet eine solche Schleife als Fehler.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from m : V{MethodDeclaration}, n : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration})* n and<br />
n -->{Child}*&amp;{MethodInvocation} -->{Access} m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck"> Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet. Dabei ist es egal, ob sich die Methode direkt selber aufruft, oder über einen oder mehrere Zwischenschritte aufgerufen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from m : V{MethodDeclaration}<br />
with<br />
m (-->{Child}*&amp;{MethodInvocation} -->{Access}&amp;{MethodDeclaration}) m and<br />
m.name="m"<br />
report 0 end<br />
</query><br />
<feedback prefix="Rekursionscheck">Die Methode "m()" enthält nicht die geforderte Rekursion.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Methode <code>m</code> rekursiv arbeitet und sich insbesondere ohne Zwischenschritte über andere Methoden selber wieder aufruft.<br />
<br />
=== Methoden ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations2} m and<br />
hasSignature(m, "public static String method(int)")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "public static String method(int param)" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, wobei der Name des Methodenparameters unerheblich ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations2} m and<br />
hasSignature(m, "int method()") and<br />
isEmpty(m -->{Child}&amp;{Modifier})<br />
report 0 end<br />
</query><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, mo : V{Modifier}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations2} m and<br />
hasSignature(m, "int method()") and<br />
m --> mo and not (mo.name="private")<br />
report 0 end<br />
</query><br />
<feedback prefix="Signaturcheck">Die Methode "int method()" in der Klasse "A" fehlt oder ist mit dem Modifier "private" versehen. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode mit einer bestimmten Signatur enthält, die nicht mit dem Modifier private versehen ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, m : V{MethodDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationBodyDeclarations2} m and<br />
m.name="m" and<br />
m -->{MethodDeclarationReturnType} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments1} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Signatur">Der Methode "public B&lt;C&gt; m()" in der Klasse "A" fehlt. Hast du die vorgegebene Methodensignatur veraendert?</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode m mit parametrisierten Rückgabetyp B<C> enthält.<br />
<br />
=== Vererbungshierarchie ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
st.name="B" and<br />
t -->{TypeDeclarationSuperclassType2} st<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A ist nicht als Unterklasse von B modelliert.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A direkte Unterklasse von Klasse B ist.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, st : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes2} st and<br />
st.name="B"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="1"><br />
<query>from t : V{TypeDeclaration}, pt : V{ParameterizedType}, ptt : V{SimpleType}, pta : V{SimpleType}<br />
with<br />
t.name="A" and<br />
t -->{TypeDeclarationSuperInterfaceTypes1} pt and<br />
pt -->{ParameterizedTypeType} ptt and<br />
ptt.name="B" and<br />
pt -->{ParameterizedTypeTypeArguments1} pta and<br />
pta.name="C"<br />
report 0 end<br />
</query><br />
<feedback prefix="Typhierarchie">A implementiert nicht das Interface B&lt;C&gt;.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface B<C> implementiert.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="3"><br />
<query>from u : V{TypeDeclaration}, s : V{SimpleType}<br />
with<br />
((u -->{TypeDeclarationSuperclassType2} s and s.name="Thread") or<br />
(u -->{TypeDeclarationSuperInterfaceTypes2} s and s.name="Runnable")) and<br />
u.name="A"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte entweder das Interface "Runnable" implementieren oder von "Thread" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A das Interface Runnable implementiert oder von Thread erbt.<br />
<br />
=== Aufrufbeziehungen ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "B.m()" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A eine Methode B.m aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from u : V{TypeDeclaration}, x : V{MethodInvocation}, y : V{SimpleName}, z : V{VariableDeclarationStatement}, f : V{VariableDeclarationFragment}, t : V{SimpleType}<br />
with<br />
u -->* x -->{ElementExpression} y and<br />
u -->* z -->{VariableDeclarationStatementType} t and<br />
u -->* z -->{VariableDeclarationStatementFragments} f and<br />
u.name="A" and<br />
x.name="m" and<br />
y.name=f.name and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" sollte "m()" auf einem Objekt vom Typ "B" aufgerufen werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A Methode m auf einem Objekt vom Typ B aufruft.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="4"><br />
<query>from u : V{TypeDeclaration}, m : V{MethodDeclaration}, x : V{ClassInstanceCreation}, t : V{SimpleType}<br />
with<br />
u -->{Child}* m -->* x -->{ClassInstanceCreationType} t and<br />
u.name="A" and<br />
m.name="m" and<br />
t.name="B"<br />
report 0 end<br />
</query><br />
<feedback>In der Klasse "A" muss in Methode m() mindestens eine Instanz von "B" erzeugt werden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob Klasse A in Methode m eine Instanz von Klasse B erstellt.<br />
<br />
== Beispiele für statische Prüfregeln für UML-Modelle im XMI2-Format ==<br />
=== Klassendiagramme ===<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="0"><br />
<query>from x,y : V{Class}<br />
with<br />
x --> V{Property} --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B"<br />
report 1 end<br />
</query><br />
<feedback prefix="Hinweis">Im Diagramm sind die "B" eines "A" als eigene Klasse abgebildet. Das kannst du durch eine bessere Modellierung vermeiden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft ebenfalls, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation verbunden sind, definiert dies aber als unerwünschte Situation mit entsprechendem Feedback.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="11"><br />
<query>from x,y : V{Class}, z: V{Property}<br />
with<br />
x --> z and<br />
z --> V{Association} &lt;-- V{Property} &lt;-- y and<br />
isDefined(x.name) and x.name="A" and<br />
isDefined(y.name) and y.name="B" and<br />
isDefined(z.lower) and z.lower="1" and (not isDefined(z.upper) or z.upper="1")<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm enthält keine Beziehung zwischen einem "A" und einem "B" mit der Kardinalität 1 oder keine Klassen mit diesen Namen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell zwei Klassen "A" und "B" enthält, die über eine Assoziation mit Kardinalität 1 (jedes A kennt genau ein B) verbunden sind.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b : V{Class}, p: V{Property}<br />
with<br />
isEmpty(a -->&amp;{Property} -->&amp;{Association}) and<br />
b --> p and<br />
isDefined(p.aggregation) and p.aggregation="composite"<br />
report 1 end<br />
</query><br />
<feedback>Es sollte im Diagramm zwei Klassen geben, bei denen die eine keine weiteren Bestandteile hat, während die andere weitere Bestandteile gemäß der Komposition hat.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse ohne ausgehende Assoziationen gibt und eine weitere, die mindestens eine ausgehende Komposition hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Property}, z : V{PrimitiveType}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and y.name="b" and<br />
y --> z and<br />
isDefined(z.name) and z.name="String"<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll ein Attribut für die Eigenschaft "b" bereitstellen.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob es im Modell eine Klasse "A" mit dem Attribut "b" vom Typ "String" gibt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}, y : V{Operation}, z: V{Parameter}<br />
with<br />
isDefined(x.name) and x.name="A" and<br />
x --> y and<br />
isDefined(y.name) and stringLevenshteinDistance(y.name, "ausführen")&lt;3 and<br />
y --> z<br />
report 1 end<br />
</query><br />
<feedback>Ein "A" soll eine Methode bereitstellen, mit der sie etwas ausführen kann.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel prüft, ob es im Modell eine Klasse "A" mit einer Operation gibt, deren Name "ausführen" oder ähnlich lautet.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>let c := count(from y : V{Operation} with isDefined(y.name) report y end) in<br />
from x : set(1)<br />
with<br />
c&lt;>7<br />
report c as "count" end<br />
</query><br />
<feedback>Das Diagramm sollte genau 7 Methoden enthalten, enthält aber {count}.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell genau 7 Methoden enthält und gibt im Falle einer anderen Anzahl diese im Feedback mit aus.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x : V{Class}<br />
with<br />
isDefined(x.name) and x.name=A" and<br />
x.isAbstract and<br />
not isEmpty(x &lt;--&amp;{Generalization})<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte eine abstrakte Klasse "A" enthalten, von der mindestens eine Klasse erbt.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine abstrakte Klasse "A" enthält, auf die in mindestens einer Generalisierung verwiesen wird.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from a,b,c,d : V{Class}<br />
with<br />
isDefined(a.name) and a.name="A" and<br />
isDefined(b.name) and b.name="B" and<br />
isDefined(c.name) and c.name="C" and<br />
isDefined(d.name) and d.name="D" and<br />
a --> V{Generalization} --> d and<br />
b --> V{Generalization} --> d and<br />
c --> V{Generalization} --> d<br />
report 1 end<br />
</query><br />
<feedback>Das Diagramm sollte Klassen "A", "B" und "C" enthalten, die von einer gemeinsamen Oberklasse "D" erben.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel überprüft, ob das Modell eine Klasse "D" enthält, die drei direkte Unterklassen "A", "B" und "C" hat.<br />
<br />
== Beispiele für statische Prüfregeln für EPML ==<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="presence" points="5"><br />
<query>from x: V{Event}<br />
with<br />
isEmpty(x &lt;--)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt kein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph kein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="5"><br />
<query> from x,y: V{Event}<br />
with<br />
isEmpty(x &lt;--) and<br />
isEmpty(y &lt;--) and<br />
not (x=y)<br />
report 0 end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundelemente">Es gibt mehr als ein Startevent.</feedback><br />
</rule> <br />
</syntaxhighlight><br />
Diese Regel testet, ob der gegebene Graph mehr als ein Startevent hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="3"><br />
<query> from x,y: V{Element, ^Connector}<br />
with<br />
not (x.name="") and<br />
x.name = y.name and<br />
not (x = y)<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Es gibt mindestens zwei Elemente mit demselben Namen ("{name}").</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob es der Graph Elemente mit demselben Namen besitzt.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Element, ^Connector}, y1, y2 : V{Element}<br />
with<br />
x --> y1 and<br />
x --> y2 and<br />
not (y1=y2)<br />
report x.name as "xName", x.id as "xID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Das Element "{xName}" (ID {xID}) hat mehr als einen Ausgang.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob ein Event oder Funktion mehr als einen Ausgang hat.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="4"><br />
<query>from x: V{Connector}, y: V{Connector}<br />
with<br />
not (x.name="") and<br />
not (y.name="") and<br />
x --> y<br />
report x.name as "xName", y.name as "yName", x.id as "xID", y.id as "yID" end<br />
</query><br />
<feedback prefix="Fehlerhafte Grundstruktur">Es dürfen keine zwei Konnektoren direkt aufeinander folgen. Es folgt jedoch "{yName}" (ID {yID}) direkt auf "{xName}" (ID {xID}).</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob 2 Konnektoren aufeinander folgen.<br />
<br />
<syntaxhighlight lang="xml" line='line'><br />
<rule type="absence" points="1"><br />
<query>from x: V{Element, ^Connector}<br />
with<br />
contains(x.name, " and ") or<br />
contains(x.name, "+") or<br />
contains(x.name, " und ")<br />
report x.name as "name" end<br />
</query><br />
<feedback prefix="Anmerkung zur Namensgebung">Der Name "{name}" sieht danach aus, als wenn hier zwei Events bzw. Funktionen in einem Element zusammengefasst wurden.</feedback><br />
</rule><br />
</syntaxhighlight><br />
Diese Regel testet, ob der Graph möglicherweise Zeichen bzw. Wörter besitzt die mehrere Funktionen/Events in einem Element verbinden.<br />
<br />
[[Category:R-GReQL]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Hauptseite&diff=8627Hauptseite2023-06-12T14:15:56Z<p>Striewe: </p>
<hr />
<div>__NOTOC__<br />
Herzlich Willkommenen im JACK-Wiki für Lehrende. In diesem Nachschlagewerk finden Sie eine umfassende Dokumentation über die Funktionen und die Arbeitsweise von JACK. Bei weitergehenden Fragen können Sie sich jederzeit [mailto:jack@paluno.uni-due.de per E-Mail] an uns wenden.<br />
<br />
== JACK 3 ==<br />
JACK 3 ist die aktuelle Version des Übungs- und Prüfungssystems JACK, die an der Universität Duisburg-Essen und weiteren Hochschulen im Produktivbetrieb eingesetzt wird.<br />
<br />
<div style="display:flex; flex-wrap:wrap; row-gap:10px; column-gap:10px; width:100%; color:white;"><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Benutzerhandbuch|<span style="color:white; font-size:140%; font-weight:bold; text-decoration:underline;">JACK 3 Benutzerhandbuch</span>]]</p><p>Das Benutzerhandbuch erklärt alle Einstellungsmöglichkeiten und Funktionen von JACK. Es bietet eine umfassende Referenz für alle, die JACK intensiv nutzen möchten.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Versionshistorie (JACK3)|<span style="color:white; font-size:140%; font-weight:bold; text-decoration:underline;">JACK 3 Versionshistorie</span>]]</p><p>Die Versionshistorie listet die neuesten JACK-Versionen und die darin neu eingeführten Features auf. Schauen Sie regelmäßig hier vorbei, um neue Möglichkeiten zu entdecken.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[https://jack-demo.s3.uni-due.de <span style="color:white; font-size:140%; font-weight:bold; text-decoration:underline;">JACK 3 Demoserver</span>]</p><p>Auf unserem Demoserver können Sie das System aus Studierendensicht erleben. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de <span style="color:white; text-decoration:underline;">per E-Mail</span>], um das System auch aus Lehrendensicht kennenzulernen.</p></div><br />
</div><br />
<br />
== Kontakt und Support ==<br />
<br />
=== Mailingliste ===<br />
Über unsere Mailingliste halten wir Sie über aktuelle Entwicklungen auf dem Laufenden. Sie können sich selbständig [https://lists.uni-due.de/mailman/listinfo/jack-announce in die Liste eintragen], um jederzeit über Updates und andere, wichtige Neuerungen informiert zu werden.<br />
<br />
=== Anmeldung von Prüfungsterminen ===<br />
Wenn Sie eine Prüfung mit JACK durchführen möchten, melden Sie uns die Prüfung bitte [mailto:jack@paluno.uni-due.de per Mail] an. Nur so kann sichergestellt werden, dass Sie technischen Support bei der Durchführung der Prüfung erhalten und zur Prüfungszeit keine Wartungsarbeiten durchgeführt werden, die die Durchführung der Prüfung behindern könnten.<br />
<br />
== JACK 2 ==<br />
JACK 2 ist die von einigen unserer Kunden noch eingesetzte Vorgängerversion von JACK 3. Mittelfristig ist eine Ablösung aller noch im Einsatz befindlichen Produktivsysteme von JACK2 vorgesehen. In JACK 2 werden ''keine neuen Funktionen'' mehr umgesetzt und es ist nur noch begrenzter technischer und inhaltlicher Support verfügbar. Für den Umzug von JACK 2 auf JACK 3 stehen Import-Funktionen und weitere Unterstützung zur Verfügung.<br />
<br />
'''Weiterführende Links'''<br />
* [[JACK 2 Benutzerhandbuch]]<br />
* [[Evaluator|Der JACK 2 Evaluator]]<br />
* [[Versionshistorie (Jack2)|JACK 2 Versionshistorie]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Versionshistorie_(JACK3)&diff=8626Versionshistorie (JACK3)2023-06-12T14:10:48Z<p>Striewe: </p>
<hr />
<div>==Mai 2023==<br />
===Version 0.7.1===<br />
Neuerungen in dieser Version:<br />
* Mit dem Stufentyp MCTable kehrt ein alter Bekannter aus JACK 2 wieder in den Schoß der JACK Familie zurück.<br />
* Der Aufgabeneditor hat jetzt ein Werkzeugmenü, über das auch der freie Moleküleditor verfügbar ist.<br />
* Mit dem Validator haben wir ein Werkzeug hinzugefügt, dass vor typischen Fehlern und Fehlkonfigurationen in Aufgaben und Kursen warnt.<br />
* Der Ex- und Import von Kursen ist jetzt möglich.<br />
* Es lassen sich jetzt auch Java Aufgaben aus JACK 2 importieren.<br />
<br />
Ihre gemeldeten Fehler und Verbesserungsvorschläge:<br />
* Das automatische Scrollen beim Einreichen wurde verbessert.<br />
* Mehrere Aufgaben können nun gleichzeitig verschoben werden.<br />
* Der Countdown funktioniert jetzt auch beim schnellen Aufgabenwechsel wieder.<br />
* Bilder werden nun automatisch skaliert, sodass sie das Layout nicht stören.<br />
<br />
Organisatorische Neuerungen:<br />
* Prüfungen brauchen nun nicht mehr im Wiki eingetragen zu werden. Eine formlose E-Mail an das JACK Team reicht.<br />
* Unser Wiki liegt jetzt auf dem Wikiserver der Universität und lässt sich nach wie vor über die bekannte Domäne jack-community.org erreichen.<br />
* Wir werden den Issuetracker für unsere JACK Tester auf das Gitlab der Universität umziehen, um es leichter erreichbar für alle Mitarbeiterinnen und Mitarbeiter der Universität zu machen. Mehr Infos zum Umzug werden Sie bald separat erhalten.<br />
<br />
==März 2023==<br />
===Version 0.6.1===<br />
Die folgenden neuen Features wurden realisiert:<br />
* Neuer Stufentyp: Freitextaufgaben<br />
* Neuer Stufentyp: Datei(en) hochladen<br />
* Neuer Stufentyp: Atomorbitalschemata<br />
* Feedbackregeln können nun eingeklappt werden<br />
* Diverse Detailverbesserungen<br />
<br />
Zudem haben wir einige Issues lösen können:<br />
* Automatisches Anpassen der Größe von Bildern.<br />
* Löschen von Tags aktiviert Speichernbutton nicht.<br />
* Vorausgefüllter Code ist beschränkt bzgl. der Länge.<br />
* Mehrere R-Stufen in einer Aufgabe.<br />
* Kursbearbeitung kaputt, wenn Aufgabe daraus gelöscht wurde.<br />
* Probleme beim Import von JACK 2 Aufgaben mit Dateianhängen.<br />
<br />
Kleinere Änderungen gab es bei den Namensräume für Variablen:<br />
* In den Stufentypen Java, Python und UML wurden die input Variablen nach check verschoben.<br />
* Bei Multiple Choice Stufen wurden die Variablen mcStageCorrectTicks, mcStageIncorrectTicks und mcStageTotalTicks in den Namensraum check verschoben<br />
<br />
==September 2022==<br />
===Version 0.4.0===<br />
Folgende Neuerungen sind eingeflossen:<br />
* Aufgaben im Fehlerzustand lassen sich jetzt neustarten.<br />
* Mehr Informationen zu Einreichungen von Studierenden<br />
* Verbesserungen am Moleküleditor<br />
* Verbesserungen bei der Bewertung von R-Aufgaben<br />
<br />
Wir haben zudem die folgenden Issues gelöst:<br />
* Import von R-Aufgaben ohne Variablen<br />
* Verschieben von Feedback<br />
* Formatierungsfehler bei Plus Minus<br />
* EqualsExpression wird mit Strings angelegt<br />
* Feedback wird in eine Concat-Umgebung konvertiert<br />
* Tags lassen sich nicht einschalten<br />
<br />
==Juli 2022==<br />
===Version 0.3.0===<br />
Folgende Issues wurden seit dem letzten Release gelöst:<br />
* Das Duplizieren von Kursen schlägt fehl.<br />
* Nur ein Formeleditor soll gleichzeitig sichtbar sein.<br />
* Alignment von Antwortboxen bei MC-Aufgaben mit Bildern als Antwortmöglichkeiten.<br />
* Darstellung lange MC-Optionen.<br />
<br />
Außerdem gab es zahlreiche Verbesserungen im JACK 2 Importer sowie in der Benutzeroberfläche.<br />
<br />
==Mai 2022==<br />
===Version 0.2.0===<br />
Neben technischen Umbauten und neuen Stufentypen, sind wieder zahlreiche Fehler behoben worden, unter anderem die folgenden Issues:<br />
* Variable mit einleitenden $-Zeichen für LATEX-Code wird zu "<br />
* JACK2 MC-Aufgabe mit Graphen importierbar, aber Graphen werden nicht angezeigt<br />
* Tags in alphabetischer Reihenfolge anzeigen<br />
* Kein Import einer JACK2 Aufgabe aus S05 nach JACK3 mit Bild<br />
* Aufgabenimport nicht möglich<br />
* Angabe der E-Mail Adresse oder Matrikelnummer in der Kursangebots-Statistik<br />
* Import von Aufgaben mit einem freigegeben Account<br />
<br />
==Februar 2022==<br />
===Version 0.1.0===<br />
In diesem Release wurde insbesondere der Mechanismus für Feedback-Regeln in Fill-In-Aufgaben überarbeitet, sodass beispielsweise die Überprüfung auf leere Felder deutlich bequemer erfolgen kann. Zudem haben wir das Rechtesystem erweitert, sodass eine bessere Aufteilung der Aufgaben in der Lehre ermöglicht wird. Außerdem haben wir diverse ihrer Wünsche und Fehlermeldungen bearbeitet.<br />
* Formatierung von Variablen im Text von Aufgaben<br />
* Auswerten von R-Aufgaben vor dem Einreichen<br />
* Falsche Palette beim Import von JACK 2 Aufgaben<br />
* Verbesserungen beim Layout von Kursen.<br />
* Probleme beim Import von Aufgaben mit Bildern<br />
* Formatierung von Variablen im Text von Aufgaben.</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Versionshistorie_(JACK3)&diff=8625Versionshistorie (JACK3)2023-06-12T14:09:22Z<p>Striewe: Die Seite wurde neu angelegt: „==Mai 2023== ===Version 0.7.1=== Neuerungen in dieser Version: * Mit dem Stufentyp MCTable kehrt ein alter Bekannter aus JACK 2 wieder in den Schoß der JACK Familie zurück. * Der Aufgabeneditor hat jetzt ein Werkzeugmenü, über das auch der freie Moleküleditor verfügbar ist. * Mit dem Validator haben wir ein Werkzeug hinzugefügt, dass vor typischen Fehlern und Fehlkonfigurationen in Aufgaben und Kursen warnt. * Der Ex- und Import von Kursen ist jetz…“</p>
<hr />
<div>==Mai 2023==<br />
===Version 0.7.1===<br />
Neuerungen in dieser Version:<br />
* Mit dem Stufentyp MCTable kehrt ein alter Bekannter aus JACK 2 wieder in den Schoß der JACK Familie zurück.<br />
* Der Aufgabeneditor hat jetzt ein Werkzeugmenü, über das auch der freie Moleküleditor verfügbar ist.<br />
* Mit dem Validator haben wir ein Werkzeug hinzugefügt, dass vor typischen Fehlern und Fehlkonfigurationen in Aufgaben und Kursen warnt.<br />
* Der Ex- und Import von Kursen ist jetzt möglich.<br />
* Es lassen sich jetzt auch Java Aufgaben aus JACK 2 importieren.<br />
<br />
Ihre gemeldeten Fehler und Verbesserungsvorschläge:<br />
* Das automatische Scrollen beim Einreichen wurde verbessert.<br />
* Mehrere Aufgaben können nun gleichzeitig verschoben werden.<br />
* Der Countdown funktioniert jetzt auch beim schnellen Aufgabenwechsel wieder.<br />
* Bilder werden nun automatisch skaliert, sodass sie das Layout nicht stören.<br />
<br />
Organisatorische Neuerungen:<br />
* Prüfungen brauchen nun nicht mehr im Wiki eingetragen zu werden. Eine formlose E-Mail an das JACK Team reicht.<br />
* Unser Wiki liegt jetzt auf dem Wikiserver der Universität und lässt sich nach wie vor über die bekannte Domäne jack-community.org erreichen.<br />
* Wir werden den Issuetracker für unsere JACK Tester auf das Gitlab der Universität umziehen, um es leichter erreichbar für alle Mitarbeiterinnen und Mitarbeiter der Universität zu machen. Mehr Infos zum Umzug werden Sie bald separat erhalten.<br />
<br />
==März 2023==<br />
===Version 0.6.1===<br />
Die folgenden neuen Features wurden realisiert:<br />
* Neuer Stufentyp: Freitextaufgaben<br />
* Neuer Stufentyp: Datei(en) hochladen<br />
* Neuer Stufentyp: Atomorbitalschemata<br />
* Feedbackregeln können nun eingeklappt werden<br />
* Diverse Detailverbesserungen<br />
<br />
Zudem haben wir einige Issues lösen können:<br />
* Automatisches Anpassen der Größe von Bildern.<br />
* Löschen von Tags aktiviert Speichernbutton nicht.<br />
* Vorausgefüllter Code ist beschränkt bzgl. der Länge.<br />
* Mehrere R-Stufen in einer Aufgabe.<br />
* Kursbearbeitung kaputt, wenn Aufgabe daraus gelöscht wurde.<br />
* Probleme beim Import von JACK 2 Aufgaben mit Dateianhängen.<br />
<br />
Kleinere Änderungen gab es bei den Namensräume für Variablen:<br />
* In den Stufentypen Java, Python und UML wurden die input Variablen nach check verschoben.<br />
* Bei Multiple Choice Stufen wurden die Variablen mcStageCorrectTicks, mcStageIncorrectTicks und mcStageTotalTicks in den Namensraum check verschoben<br />
<br />
==September 2022==<br />
===Version 0.4.0===<br />
Folgende Neuerungen sind eingeflossen:<br />
* Aufgaben im Fehlerzustand lassen sich jetzt neustarten.<br />
* Mehr Informationen zu Einreichungen von Studierenden<br />
* Verbesserungen am Moleküleditor<br />
* Verbesserungen bei der Bewertung von R-Aufgaben<br />
<br />
Wir haben zudem die folgenden Issues gelöst:<br />
* Import von R-Aufgaben ohne Variablen<br />
* Verschieben von Feedback<br />
* Formatierungsfehler bei Plus Minus<br />
* EqualsExpression wird mit Strings angelegt<br />
* Feedback wird in eine Concat-Umgebung konvertiert<br />
* Tags lassen sich nicht einschalten<br />
<br />
==Juli 2022==<br />
===Version 0.3.0===<br />
Folgende Issues wurden seit dem letzten Release gelöst:<br />
* Das Duplizieren von Kursen schlägt fehl.<br />
* Nur ein Formeleditor soll gleichzeitig sichtbar sein.<br />
* Alignment von Antwortboxen bei MC-Aufgaben mit Bildern als Antwortmöglichkeiten.<br />
* Darstellung lange MC-Optionen.<br />
<br />
Außerdem gab es zahlreiche Verbesserungen im JACK 2 Importer sowie in der Benutzeroberfläche.<br />
<br />
==Mai 2022==<br />
===Version 0.2.0===<br />
Neben technischen Umbauten und neuen Stufentypen, sind wieder zahlreiche Fehler behoben worden, unter anderem die folgenden Issues:<br />
* Variable mit einleitenden $-Zeichen für LATEX-Code wird zu "<br />
* JACK2 MC-Aufgabe mit Graphen importierbar, aber Graphen werden nicht angezeigt<br />
* Tags in alphabetischer Reihenfolge anzeigen<br />
* Kein Import einer JACK2 Aufgabe aus S05 nach JACK3 mit Bild<br />
* Aufgabenimport nicht möglich<br />
* Angabe der E-Mail Adresse oder Matrikelnummer in der Kursangebots-Statistik<br />
* Import von Aufgaben mit einem freigegeben Account</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Benutzer:Striewe/Testseite&diff=8624Benutzer:Striewe/Testseite2023-06-12T13:57:53Z<p>Striewe: </p>
<hr />
<div>__NOTOC__<br />
Herzlich Willkommenen im JACK-Wiki für Lehrende. In diesem Nachschlagewerk finden Sie eine umfassende Dokumentation über die Funktionen und die Arbeitsweise von JACK. Bei weitergehenden Fragen können Sie sich jederzeit [mailto:jack@paluno.uni-due.de per E-Mail] an uns wenden.<br />
<br />
== JACK 3 ==<br />
JACK 3 ist die aktuelle Version des Übungs- und Prüfungssystems JACK, die an der Universität Duisburg-Essen und weiteren Hochschulen im Produktivbetrieb eingesetzt wird.<br />
<br />
<div style="display:flex; flex-wrap:wrap; row-gap:10px; column-gap:10px; width:100%; color:white;"><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Benutzerhandbuch|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Benutzerhandbuch</span>]]</p><p>Das Benutzerhandbuch erklärt alle Einstellungsmöglichkeiten und Funktionen von JACK. Es bietet eine umfassende Referenz für alle, die JACK intensiv nutzen möchten.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Schnelleinstieg (JACK3)|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Schnelleinstieg</span>]]</p><p>Nutzen Sie den Schnelleinstieg, um in wenigen Schritten erste Inhalte in JACK anzulegen. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de|<span style="color:white;">per E-Mail</span>], um eine Schulung für einen persönlichen Einstieg zu erhalten.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Versionshistorie (JACK3)|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Versionshistorie</span>]]</p><p>Die Versionshistorie listet die neuesten JACK-Versionen und die darin neu eingeführten Features auf. Schauen Sie regelmäßig hier vorbei, um neue Möglichkeiten zu entdecken.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[https://jack-demo.s3.uni-due.de <span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Demoserver</span>]</p><p>Auf unserem Demoserver können Sie das System aus Studierendensicht erleben. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de <span style="color:white;">per E-Mail</span>], um das System auch aus Lehrendensicht kennenzulernen.</p></div><br />
</div><br />
<br />
== Kontakt und Support ==<br />
<br />
=== Mailingliste ===<br />
Über unsere Mailingliste halten wir Sie über aktuelle Entwicklungen auf dem Laufenden. Sie können sich selbständig [https://lists.uni-due.de/mailman/listinfo/jack-announce in die Liste eintragen], um jederzeit über Updates und andere, wichtige Neuerungen informiert zu werden.<br />
<br />
=== Anmeldung von Prüfungsterminen ===<br />
Wenn Sie eine Prüfung mit JACK durchführen möchten, melden Sie uns die Prüfung bitte [mailto:jack@paluno.uni-due.de per Mail] an. Nur so kann sichergestellt werden, dass Sie technischen Support bei der Durchführung der Prüfung erhalten und zur Prüfungszeit keine Wartungsarbeiten durchgeführt werden, die die Durchführung der Prüfung behindern könnten.<br />
<br />
== JACK 2 ==<br />
JACK 2 ist die von einigen unserer Kunden noch eingesetzte Vorgängerversion von JACK 3. Mittelfristig ist eine Ablösung aller noch im Einsatz befindlichen Produktivsysteme von JACK2 vorgesehen. In JACK 2 werden ''keine neuen Funktionen'' mehr umgesetzt und es ist nur noch begrenzter technischer und inhaltlicher Support verfügbar. Für den Umzug von JACK 2 auf JACK 3 stehen Import-Funktionen und weitere Unterstützung zur Verfügung.<br />
<br />
'''Weiterführende Links'''<br />
* [[JACK 2 Benutzerhandbuch]]<br />
* [[Evaluator|Der JACK 2 Evaluator]]<br />
* [[Versionshistorie (Jack2)|JACK 2 Versionshistorie]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Neuigkeiten&diff=8623Neuigkeiten2023-06-12T13:52:53Z<p>Striewe: Weiterleitungsziel von Neuigkeiten (Jack2) nach Versionshistorie (Jack2) geändert</p>
<hr />
<div>#WEITERLEITUNG [[Versionshistorie (Jack2)]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Neuigkeiten_(Jack2)&diff=8622Neuigkeiten (Jack2)2023-06-12T13:52:26Z<p>Striewe: Striewe verschob die Seite Neuigkeiten (Jack2) nach Versionshistorie (Jack2)</p>
<hr />
<div>#WEITERLEITUNG [[Versionshistorie (Jack2)]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Versionshistorie_(Jack2)&diff=8621Versionshistorie (Jack2)2023-06-12T13:52:26Z<p>Striewe: Striewe verschob die Seite Neuigkeiten (Jack2) nach Versionshistorie (Jack2)</p>
<hr />
<div>== Februar 2022 ==<br />
==== JACK 2.6.11 ====<br />
* Die Fehler, die die Bewertung von Aufgaben verhindert haben (Bewertungen wurden nicht für die entsprechende Einreichung verbucht), wurden behoben.<br />
* Fehler beim Aktivieren des Prüfungsmodus wurden behoben.<br />
* R-Aufgaben werden nach dem Betreten nicht mehr direkt als "Bearbeitet" angezeigt, sondern erst nach einer Einreichung.<br />
* Die Anzahl der Lösungen wird nun korrekt im Excel-Export angezeigt.<br />
* Verbesserungen des Excel-Exportes von R-Aufgaben:<br />
** Im Excel-Export von R-Aufgaben ist jetzt bei den Hinweisen(H) "N/A" eingetragen.<br />
** Die bislang fehlende Punktezahl wird jetzt bei "Stufe 1" eingetragen.<br />
** R-Aufgaben tauchen nicht mehr im Tabellenblatt "fillInDetails" auf.<br />
* Ein Fehler, der das Anzeigen von Hinweisen in R-Aufgaben verhindert hat, wurde behoben.<br />
* Ein Fehler, durch den die Aufgabenliste eines Kurses in einer Aufgabenbearbeitung angezeigt wurde, wurde behoben.<br />
* Der Fehler, der Kurse mit Zeitlimit noch vor Ablauf der Zeit nicht mehr bearbeitbar gemacht hat, wurde behoben.<br />
* Aufgaben mit gleichem Namen sind im Excel-Export nun durch das Hinzufügen ihrer Ids unterscheidbar.<br />
<br />
== August 2021 ==<br />
==== ''02.August 2021'': JACK 2.6.8 ====<br />
* Beim Importieren von fehlerhaften Aufgaben wird nun eine für den Nutzer brauchbare Fehlermeldung ausgegeben.<br />
* Ein Fehler, der die Bearbeitung einer R-Aufgabe verhindern konnte, wurde behoben.<br />
* Ein Fehler, bei dem das Betrachten einer R-Aufgabe im Lösungsüberblick eine Einreichung verursacht hat, wurde behoben.<br />
* Starten einer AES-Aufgabe zeigt nun nicht mehr die solutionData aus einer vorher bearbeiteten R-Aufgabe an.<br />
<br />
== Juli 2021 ==<br />
==== ''12.Juli 2021'': JACK 2.6.8 ====<br />
* Wurde mithilfe der "Zurück-Funktion" des Browsers während der Bearbeitung einer Aufgabe die Seite gewechselt, wurden Einreichungen in speziellen Fällen nicht mehr angenommen. Passen Aufgabe und Einreichung nicht zusammen, wird den Studierenden nun eine Fehlerseite mit Anweisungen angezeigt. Die Dokumentation der Fehlerseite finden Sie [[Navigations-Fehlerseite| hier]].<br />
* Aufgaben werden nun nicht mehr zu Unrecht als "zu spät eingereicht" gewertet.<br />
* Zeilen, die in R-Aufgaben nur eine Leerstelle enthalten, verursachen nun keinen Fehler mehr.<br />
<br />
== März 2021 ==<br />
==== ''01.März 2021'': JACK 2.6.6====<br />
* Verspätete Einreichungen oder interne Fehler verschlechtern den Kursdurchschnitt nicht mehr<br />
* Kurse enden nun nicht mehr verfrüht.<br />
* Fehlender Auslöser für die Erstellung von BackendJobs wurde ergänzt.<br />
* Ein Fehler, der bei der Aktualisierung des Kursdurchschnittes auftrat, wurde behoben.<br />
* Die Sortierung der Kursaufgaben in der Kursbearbeitung findet nun alphabetisch statt.<br />
* Lösungsüberblick kann nun, wenn vom Lehrenden deaktiviert, nicht mehr exportiert werden (teilweise als Hotfix bereits verteilt).<br />
* Aufgaben lassen sich nun durch "Alle erneut checken" wieder erneut überprüfen.<br />
* Nicht-abgeschlossene Kursabgaben werden nun in der Kursstatistik miteinbezogen.<br />
* Im Lösungsüberblick werden Einreichungen der 53. Kalenderwoche nicht mehr falsch einsortiert.<br />
<br />
== Dezember 2020 ==<br />
====''16.Dezember 2020'': JACK 2.6.5====<br />
* Evaluatorregeln in Prüfungen akzeptieren nun 4096 Zeichen.<br />
* Meldung bei der Authentifizierung auf Moodle überarbeitet.<br />
* Wenn die Umleitung in Moodle nicht korrekt funktioniert, wird nun der korrekte Fehler angezeigt<br />
* Fehlende Vorlagen in der Aufgabenliste eines Kurses von Moodle heraus wurden der Ansicht hinzugefügt<br />
<br />
== Juli 2020 ==<br />
==== ''15.Juli 2020'': JACK 2.6.4====<br />
* Ein Fehler, der beim Testen einer Aufgabe, nachdem sie auf einem speziellen Weg aufgerufen worden ist, aufgetreten ist, wurde behoben.<br />
* Die Palette der Mathematik-Didaktikern wurde repariert.<br />
* Die im Hintergrund genutzte Java-Version wurde aktualisiert.<br />
* Aufgaben in Kursen werden nun geordnet aufgelistet.<br />
<br />
== Januar 2020 ==<br />
* ''16.Januar 2020'':'''JACK 2.6.3'''<br />
Fixes:<br />
*Hinweisbutton in R-Aufgaben ist nicht mehr anwählbar, wenn keine Hinweise mehr verfügbar sind<br />
*Fehlenden Button "Aufgabe beenden und zum Lösungsüberblick" im Hauptmenü bei Formbased Aufgaben eingefügt (in Moodle)<br />
*Link zum Lösungsüberblick im Hauptmenü bei Kursen eingefügt (in Moodle)<br />
*Eingabe der Art <code>-(-2)</code> werden nicht mehr vom Formulaeditor geändert<br />
*Multiplikationen der Form <code>(x+1)(x-1)</code> werden auch ohne Malzeichen evaluiert<br />
* Beim Befehl <code>eval</code> wird nicht mehr der Rechenweg angezeigt, wenn ein Ergebnis nicht ausrechenbar ist<br />
<br />
OrbitalChecker:<br />
*Spezielles Feedback für das Element Niob<br />
*Check um Hund'sche Regeln erweitert<br />
<br />
Formulaeditor:<br />
*Palette für Mathematikdidaktiker hinzugefügt<br />
<br />
== Oktober 2019 ==<br />
* ''31. September 2019'': '''JACK 2.6.2'''<br />
Evaluator:<br />
<br />
* Versionsnummer wurde von 3.1.13 auf 3.1.14 geändert.<br />
<br />
OrbitalChecker:<br />
<br />
* Eine zusätzliche Überprüfung zur Füllung der Orbitale wurde hinzugefügt.<br />
* Die Standardantworten für den OrbitalChecker wurden überarbeitet.<br />
<br />
Generelles:<br />
<br />
* Eine Lücke im Rechtesystem wurde geschlossen.<br />
* Nutzer bekommen nur noch Aufgaben in der Suche angezeigt, für die sie autorisiert sind.<br />
* Nutzer, die sich anonym einloggen, bekommen nun einen zufällig generierten Namen.<br />
== September 2019 ==<br />
* ''19. September 2019'': ''' JACK 2.6.1'''<br />
<br />
* Einige Fehlernachrichten vom InstantOrbitalChecker wurden überarbeitet<br />
* Der Verweis zur Startseite wird nun ausgeblendet, wenn der Nutzer über Moodle authentifiziert wurde.<br />
* Ein Fehler der während einer Prüfung auftreten kann wurde behoben.<br />
* Für die Dropbox-Anbindung wird nur noch der Token verwendet.<br />
* Ein Fehler, der dazu führte, dass die Chemie-Palette nicht mehr mit den Fill-In Feldern verknüpft war, wurde behoben.<br />
* Die Hinweise bei R-Aufgaben sollten nun nicht mehr beim Wechseln der Aufgabe übernommen werden.<br />
* Eine zusätzliche Feedback-Option wurde für den InstantOrbitalChecker hinzugefügt.<br />
* Eine fehlende Leerstelle zwischen "Frage" und der Nummer der Frage wurden hinzugefügt.<br />
* Eine überflüssige Leerstelle bei der Anzeige des Aufgabennamens (beim bearbeiten der Aufgabe) wurde entfernt.<br />
* In Kursen mit nicht-Formbased Aufgaben sollte der Wert "Durchschnittspunkte" im Lösungsüberblick des Kurses nun (korrekt) berechnet werden.<br />
* Das Feature "Distraktoranalyse" ist bis auf weiteres nicht mehr nutzbar. **Variablen sollten nun nicht mehr mithilfe von "McIndex-Variablen" ( https://jack-community.org/wiki/index.php?title=McIndex-Variablen ) gesetzt werden.**<br />
<br />
== Juni 2019 ==<br />
* ''10.Juli 2019'': '''JACK 2.6.0'''<br />
<br />
Erweiterungen:<br />
<br />
* Ein neuer Aufgabentyp "Orbitalmodell" (inkl. eines dazugehörigen Editors) wurde als Stufentyp von Formbased-Aufgaben hinzugefügt.<br />
<br />
Änderungen:<br />
<br />
* Die Evaluierungsregel wird nicht mehr bei der Erstellung von Formbased-Aufgaben angezeigt, da diese bei der Bepunktung einer Aufgabe nicht beachtet wird.<br />
* Ist die Evaluierungsregel ungültig, wird nun ein Fehler angezeigt.<br />
* Das Exportieren von Ergebnissen als Excel-Tabelle wird nur noch bis 255 Spalten unterstützt. Bei 256 oder mehr Spalten werden nur die Ersten 255 Spalten in einer Exel-Tabelle ausgegeben und eine Fehlernachricht wird angezeigt.<br />
* Die Ergebnisübersicht wurde überarbeitet und zeigt nun nicht mehr jede Einreichung, sondern nur noch die Letzte.<br />
* Einige Standardpaletten wurden überarbeitet. Eine Übersicht über die aktuellen Standardpaletten und einen Hinweis zu den Symbolen, die im Moment nicht ausgewertet werden können, finden Sie auf: https://jack-community.org/wiki/index.php/Standardpaletten <br />
* Die ID einer Ressource wird nun auf der Seite "Aufgabe bearbeiten" angezeigt.<br />
<br />
Fixes:<br />
<br />
* Das Auswerten von R-Code, in dem vom Lernenden eine Funktion definiert wird, ist nun möglich.<br />
* Der experimentelle Kurs "Adaptiver Kurs" ist nun über Moodle absolvierbar.<br />
* Der experimentelle Kurs "Adaptiver Kurs" gibt nun die angedachten Werte als Referenzwerte aus.<br />
* Ein Fehler, der bei der Evaluierung eines Betrages auftreten konnte, wurde behoben.<br />
* Ein Fehler beim Exportieren von Lösungen eines Nutzers als Zip-Datei wurde behoben.<br />
* SCList Aufgaben können nun in Prüfungen mehrfach eingereicht werden.<br />
* Das Filtern nach Matrikelnummern ist nun wieder möglich.<br />
* Aufgaben mit einem bestimmten Fehler in der exerciseChain können wieder über die Übersicht erreichen werden.<br />
* Ein Fehler, der bei der Navigation in der Oberfläche auftreten kann, wurde behoben.<br />
* Ein Fehler, der die Knöpfe zur Navigation zwischen den Fragen einer Aufgabe fehlen ließ, wurde behoben.<br />
* Beim Absolvieren von Kursen in JACK (nicht von Moodle aus) ist nun nicht mehr fälschlicherweise der Knopf "Vorherige Aufgabe" bzw. "Nächste Aufgabe" anwählbar (falls es eine nächste Aufgabe gibt, ist er natürlich immer noch anwählbar)<br />
<br />
== Januar 2019 ==<br />
* ''10.Januar 2019'': '''JACK 2.5.6'''<br />
*Das Variabalen- und Evaluator-Feld wird dem Lehrenden nun in allen FormBased-Aufgaben angezeigt<br />
*Man kann den Formulaeditor nun auch pro Stage einbinden<br />
*Als Admin kann man nun die Namen der eingeloggten User sehen<br />
*Fehlermeldungen für Aufgaben, von denen man Besitzer ist, werden einem angezeigt<br />
*Neue Math-Evaluatorfunktionen : arccosh, arccot, arccoth, arccsc, arccsch, arcsec, arcsech, arcsinh, arctan, arctanh, cosh, cot, coth, csc, csch, sec, sech, sinh, tanh<br />
*Adaptiver Kursmodus: Ausgabe der Fähigkeit und des geschätzten Fehlers möglich<br />
*Neue Funktion im ChemEvaluator: Particle<br />
<br />
== August 2018 ==<br />
* ''29. August 2018'': '''JACK 2.5'''<br />
** Der Lösungsüberblick zu Kursen ist nun in den Kurseinstellungen ein- und ausschaltbar. Standardmäßig sind diese bei schon existierenden Kursen sichtbar. <br />
** Der '''Evaluator''' unterstützt nun auch OpenChem mithilfe des [[ChemEvaluator]]s:<br />
*** arith1: [[Plus]], [[Times]], [[UnaryMinus]], [[UnaryPlus]]<br />
*** chemistry1: [[CheckOxidationState]], [[CheckStateOfMatter]], [[CompareNumberOfAtoms]], [[ConsistOf]], [[Contains]]<br />
*** list1: [[List]]<br />
*** logic1: [[And]], [[False]], [[Not]], [[Or]], [[True]]<br />
*** molecule1: [[AtomarrayElement]], [[Atomarray]], [[Charge]], [[Molecule]], [[OxidationState]], [[StateOfMatter]]<br />
*** nums1: [[E]], [[PI]]<br />
*** periodictable_group1 - 18<br />
*** testterminal_jack: [[IsEmpty]]<br />
*** variable_jack: [[Exercise]], [[FillIn]]<br />
** Des Weiteren verhält sich das Zeichen „/“ in Mathematik-Formeln nun exakt (d.h. als Bruch). Möchte man eine Dezimalzahl erzeugen, so kann man den „:“-Operator nutzen. <br />
*** Neue MathEvaluator-Funktionen: [[IsVector]], [[IsNVector]], [[GetFromMatrix]], [[GetFromVector]]<br />
<br />
== Juni 2018 ==<br />
* ''13. Juni 2018'': Die [[:Kategorie:Testfunktionen|Testfunktionen]] des Evaluators haben Zuwachs bekommen: Mit [[IsVector]] und [[IsNVector]] können nun Vektoren überprüft werden.<br />
* ''6. Juni 2018'': Die Dokumentation für den [[TracingChecker]] und den [[KovidaChecker (Jack2)|KovidaChecker]] für Programmieraufgaben ist nun auch in diesem Wiki verfügbar.<br />
* ''5. Juni 2018'': Die meisten JACK-Instanzen wurden eine neue Version mit vielen kleinen Fehlerkorrekturen und Verbesserungen aktualisiert.<br />
<br />
== April 2018 ==<br />
* ''25. April 2018'': Mit der neuen Evaluator-Funktion [[ImplodeList]] können nun Listen in Zeichenketten verwandelt werden.<br />
<br />
== November 2017 ==<br />
* ''20. November 2017'': Der Evaluator 2.0 läuft nun auch auf http://jack.s3.uni-due.de. Hinweise zu notwendigen Änderungen an formularbasierten Aufgaben findet man unter [[Migration zur Evaluator 2 Syntax]]<br />
<br />
== Oktober 2017 ==<br />
* ''04. Oktober 2017'': Die Funktionen des [[Evaluator|Evaluators]] sind nun in diesem Wiki kategorisiert. Eine Übersicht aller Kategorien findet man unter [[:Kategorie:Evaluatorfunktionenkategorie|Evaluatorfunktionenkategorien]]<br />
<br />
== September 2017 ==<br />
* ''29. September 2017'': Auf der Spielwiese läuft seit heute Version 2 vom [[Evaluator]]. Neu ist insbesondere, dass Lehrende in den Funktionen anstatt CAS-Syntax sogenannte [[:Kategorie:Konstruktoren|Konstruktoren]] verwendet werden müssen. Dies zieht ggf. Änderungen nach sich, z.B. an der Funktion [[equalsExpr]].<br />
<br />
== August 2017 ==<br />
* ''30. August 2017'': In [[Checker#InstantFillInChecker|Fill-In-Aufgaben]] können die Warnungen des Checkers bei leerer Eingabe unterdrückt werden. Die Dokumentation dazu findet man im Artikel [[Stage]] in der Erläuterung des Tags '''exercise'''. Bisher kann dieses Feature nur auf der Spielwiese verwendet werden.<br />
* ''29. August 2017'': Sage läuft jetzt in JACK auf Version 8.0<br />
* ''29. August 2017'': [[Checker#InstantFillInChecker|Fill-In-Aufgaben]] erhalten eine [[Evaluator-Konsole]] für Lehrende, um Aufgaben einfacher Testen zu können.<br />
<br />
== Juli 2017 ==<br />
* ''5. Juli 2017'': Der Server jack-server05.s3.uni-due.de (Spielwiese) wird ab ca. 14:45 Uhr offline sein um ihn zu aktualisieren. Bis ca. 16 Uhr sollten alle Maßnahmen abgeschlossen und der Server wieder verfügbar sein. Vielen Dank für ihr Verständnis!<br />
<br />
== Juni 2017 ==<br />
* ''29. Juni 2017'': Eine neue stabile Version findet sich auf allen JACK-Servern, eine neue Testversion (2.4.2) befindet sich auf der Spielwiesen-Instanz! Im Wesentlichen beinhaltet die neue Version zahlreiche Bugfixes.<br />
* ''19. Juni 2017'': Herzlich Willkommen auf dem Feature-News-Ticker. Auf dieser Seite stellen wir in Zukunft neue Features innerhalb von JACK vor und dokumentieren ihre Verwendung. Bitte schauen Sie also regelmäßig rein.<br />
<br />
[[Category:Hauptseiten]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Benutzer:Striewe/Testseite&diff=8620Benutzer:Striewe/Testseite2023-06-12T13:50:31Z<p>Striewe: </p>
<hr />
<div>__NOTOC__<br />
Herzlich Willkommenen im JACK-Wiki für Lehrende. In diesem Nachschlagewerk finden Sie eine umfassende Dokumentation über die Funktionen und die Arbeitsweise von JACK. Bei weitergehenden Fragen können Sie sich jederzeit [mailto:jack@paluno.uni-due.de per E-Mail] an uns wenden.<br />
<br />
== JACK 3 ==<br />
JACK 3 ist die aktuelle Version des Übungs- und Prüfungssystems JACK, die an der Universität Duisburg-Essen und weiteren Hochschulen im Produktivbetrieb eingesetzt wird.<br />
<br />
<div style="display:flex; flex-wrap:wrap; row-gap:10px; column-gap:10px; width:100%; color:white;"><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Benutzerhandbuch|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Benutzerhandbuch</span>]]</p><p>Das Benutzerhandbuch erklärt alle Einstellungsmöglichkeiten und Funktionen von JACK. Es bietet eine umfassende Referenz für alle, die JACK intensiv nutzen möchten.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Schnelleinstieg (JACK3)|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Schnelleinstieg</span>]]</p><p>Nutzen Sie den Schnelleinstieg, um in wenigen Schritten erste Inhalte in JACK anzulegen. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de|<span style="color:white;">per E-Mail</span>], um eine Schulung für einen persönlichen Einstieg zu erhalten.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Versionshistorie (JACK3)|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Versionshistorie</span>]]</p><p>Die Versionshistorie listet die neuesten JACK-Versionen und die darin neu eingeführten Features auf. Schauen Sie regelmäßig hier vorbei, um neue Möglichkeiten zu entdecken.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[https://jack-demo.s3.uni-due.de <span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Demoserver</span>]</p><p>Auf unserem Demoserver können Sie das System aus Studierendensicht erleben. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de <span style="color:white;">per E-Mail</span>], um das System auch aus Lehrendensicht kennenzulernen.</p></div><br />
</div><br />
<br />
== Kontakt und Support ==<br />
<br />
=== Mailingliste ===<br />
Über unsere Mailingliste halten wir Sie über aktuelle Entwicklungen auf dem Laufenden. Sie können sich selbständig [https://lists.uni-due.de/mailman/listinfo/jack-announce in die Liste eintragen], um jederzeit über Updates und andere, wichtige Neuerungen informiert zu werden.<br />
<br />
=== Anmeldung von Prüfungsterminen ===<br />
Wenn Sie eine Prüfung mit JACK durchführen möchten, melden Sie uns die Prüfung bitte [mailto:jack@paluno.uni-due.de per Mail] an. Nur so kann sichergestellt werden, dass Sie technischen Support bei der Durchführung der Prüfung erhalten und zur Prüfungszeit keine Wartungsarbeiten durchgeführt werden, die die Durchführung der Prüfung behindern könnten.<br />
<br />
== JACK 2 ==<br />
JACK 2 ist die von einigen unserer Kunden noch eingesetzte Vorgängerversion von JACK 3. Mittelfristig ist eine Ablösung aller noch im Einsatz befindlichen Produktivsysteme von JACK2 vorgesehen. In JACK 2 werden ''keine neuen Funktionen'' mehr umgesetzt und es ist nur noch begrenzter technischer und inhaltlicher Support verfügbar. Für den Umzug von JACK 2 auf JACK 3 stehen Import-Funktionen und weitere Unterstützung zur Verfügung.<br />
<br />
'''Weiterführende Links'''<br />
* [[JACK 2 Benutzerhandbuch]]<br />
* [[Evaluator|Der JACK 2 Evaluator]]<br />
* [[Neuigkeiten|JACK 2 Versionshistorie]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Benutzer:Striewe/Testseite&diff=8421Benutzer:Striewe/Testseite2023-06-01T11:04:59Z<p>Striewe: </p>
<hr />
<div>__NOTOC__<br />
Herzlich Willkommenen im JACK-Wiki für Lehrende. In diesem Nachschlagewerk finden Sie eine umfassende Dokumentation über die Funktionen und die Arbeitsweise von JACK. Bei weitergehenden Fragen können Sie sich jederzeit [mailto:jack@paluno.uni-due.de per E-Mail] an uns wenden.<br />
<br />
== JACK 3 ==<br />
JACK 3 ist die aktuelle Version des Übungs- und Prüfungssystems JACK, die an der Universität Duisburg-Essen und weiteren Hochschulen im Produktivbetrieb eingesetzt wird.<br />
<br />
<div style="display:flex; flex-wrap:wrap; row-gap:10px; column-gap:10px; width:100%; color:white;"><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Benutzerhandbuch|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Benutzerhandbuch</span>]]</p><p>Das Benutzerhandbuch erklärt alle Einstellungsmöglichkeiten und Funktionen von JACK. Es bietet eine umfassende Referenz für alle, die JACK intensiv nutzen möchten.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Schnelleinstieg (JACK3)|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Schnelleinstieg</span>]]</p><p>Nutzen Sie den Schnelleinstieg, um in wenigen Schritten erste Inhalte in JACK anzulegen. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de|<span style="color:white;">per E-Mail</span>], um eine Schulung für einen persönlichen Einstieg zu erhalten.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Versionshistorie (JACK3)|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Versionshistorie</span>]]</p><p>Die Versionshistorie listet die neuesten JACK-Versionen und die darin neu eingeführten Features auf. Schauen Sie regelmäßig hier vorbei, um neue Möglichkeiten zu entdecken.</p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[https://jack-demo.s3.uni-due.de|<span style="color:white; font-size:140%; font-weight:bold;">JACK 3 Demoserver</span>]</p><p>Auf unserem Demoserver können Sie das System aus Studierendensicht erleben. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de|<span style="color:white;">per E-Mail</span>], um das System auch aus Lehrendensicht kennenzulernen.</p></div><br />
</div><br />
<br />
== Kontakt und Support ==<br />
<br />
=== Mailingliste ===<br />
Über unsere Mailingliste halten wir Sie über aktuelle Entwicklungen auf dem Laufenden. Sie können sich selbständig [https://lists.uni-due.de/mailman/listinfo/jack-announce in die Liste eintragen], um jederzeit über Updates und andere, wichtige Neuerungen informiert zu werden.<br />
<br />
=== Anmeldung von Prüfungsterminen ===<br />
Wenn Sie eine Prüfung mit JACK durchführen möchten, melden Sie uns die Prüfung bitte [mailto:jack@paluno.uni-due.de per Mail] an. Nur so kann sichergestellt werden, dass Sie technischen Support bei der Durchführung der Prüfung erhalten und zur Prüfungszeit keine Wartungsarbeiten durchgeführt werden, die die Durchführung der Prüfung behindern könnten.<br />
<br />
== JACK 2 ==<br />
JACK 2 ist die von einigen unserer Kunden noch eingesetzte Vorgängerversion von JACK 3. Mittelfristig ist eine Ablösung aller noch im Einsatz befindlichen Produktivsysteme von JACK2 vorgesehen. In JACK 2 werden ''keine neuen Funktionen'' mehr umgesetzt und es ist nur noch begrenzter technischer und inhaltlicher Support verfügbar. Für den Umzug von JACK 2 auf JACK 3 stehen Import-Funktionen und weitere Unterstützung zur Verfügung.<br />
<br />
'''Weiterführende Links'''<br />
* [[JACK 2 Benutzerhandbuch]]<br />
* [[Evaluator|Der JACK 2 Evaluator]]<br />
* [[Neuigkeiten|JACK 2 Versionshistorie]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Benutzer:Striewe/Testseite&diff=8420Benutzer:Striewe/Testseite2023-06-01T10:34:13Z<p>Striewe: </p>
<hr />
<div>__NOTOC__<br />
Herzlich Willkommenen im JACK-Wiki für Lehrende. In diesem Nachschlagewerk finden Sie eine umfassende Dokumentation über die Funktionen und die Arbeitsweise von JACK. Bei weitergehenden Fragen können Sie sich jederzeit [mailto:jack@paluno.uni-due.de per E-Mail] an uns wenden.<br />
<br />
== JACK 3 ==<br />
JACK 3 ist die aktuelle Version des Übungs- und Prüfungssystems JACK, die an der Universität Duisburg-Essen und weiteren Hochschulen im Produktivbetrieb eingesetzt wird.<br />
<br />
<div style="display:flex; flex-wrap:wrap; row-gap:10px; column-gap:10px; width:100%; color:white;"><br />
<div class="uniBlueBox"><p>[[Benutzerhandbuch|<span style="color:white; font-size:130%; font-weight:bold;">JACK 3 Benutzerhandbuch</span>]]</p><p></p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Schnelleinstieg|<span style="color:white; font-size:130%; font-weight:bold;">JACK 3 Schnelleinstieg</span>]]</p><p></p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Versionshistorie|<span style="color:white; font-size:130%; font-weight:bold;">JACK 3 Versionshistorie</span>]]</p><p></p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[https://jack-demo.s3.uni-due.de|<span style="color:white; font-size:130%; font-weight:bold;">JACK 3 Demoserver</span>]</p><p>Auf unserem Demoserver können Sie das System bereits aus Studierendensicht testen. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de|<span style="color:white;">per E-Mail</span>], um das System auch aus Lehrendensicht zu begutachten.</p></div><br />
</div><br />
<br />
'''Weiterführende Links'''<br />
* [[Benutzerhandbuch|JACK 3 Benutzerhandbuch]]<br />
* [https://jack-demo.s3.uni-due.de JACK 3 Demoserver]<br />
<br />
== Kontakt und Support ==<br />
<br />
=== Mailingliste ===<br />
Über unsere Mailingliste halten wir Sie über aktuelle Entwicklungen auf dem Laufenden. Sie können sich selbständig [https://lists.uni-due.de/mailman/listinfo/jack-announce in die Liste eintragen], um jederzeit über Updates und andere, wichtige Neuerungen informiert zu werden.<br />
<br />
=== Anmeldung von Prüfungsterminen ===<br />
Wenn Sie eine Prüfung mit JACK durchführen möchten, melden Sie uns die Prüfung bitte [mailto:jack@paluno.uni-due.de per Mail] an. Nur so kann sichergestellt werden, dass Sie technischen Support bei der Durchführung der Prüfung erhalten und zur Prüfungszeit keine Wartungsarbeiten durchgeführt werden, die die Durchführung der Prüfung behindern könnten.<br />
<br />
== JACK 2 ==<br />
JACK 2 ist die von einigen unserer Kunden noch eingesetzte Vorgängerversion von JACK 3. Mittelfristig ist eine Ablösung aller noch im Einsatz befindlichen Produktivsysteme von JACK2 vorgesehen. In JACK 2 werden ''keine neuen Funktionen'' mehr umgesetzt und es ist nur noch begrenzter technischer und inhaltlicher Support verfügbar. Für den Umzug von JACK 2 auf JACK 3 stehen Import-Funktionen und weitere Unterstützung zur Verfügung.<br />
<br />
'''Weiterführende Links'''<br />
* [[JACK 2 Benutzerhandbuch]]<br />
* [[Evaluator|Der JACK 2 Evaluator]]<br />
* [[Neuigkeiten|JACK 2 Versionshistorie]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Benutzer:Striewe/common.css&diff=8419Benutzer:Striewe/common.css2023-06-01T10:33:08Z<p>Striewe: Die Seite wurde neu angelegt: „div.uniBlueBox {min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;}“</p>
<hr />
<div>div.uniBlueBox {min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;}</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Benutzer:Striewe/Testseite&diff=8418Benutzer:Striewe/Testseite2023-06-01T08:24:46Z<p>Striewe: </p>
<hr />
<div>__NOTOC__<br />
Herzlich Willkommenen im JACK-Wiki für Lehrende. In diesem Nachschlagewerk finden Sie eine umfassende Dokumentation über die Funktionen und die Arbeitsweise von JACK. Bei weitergehenden Fragen können Sie sich jederzeit [mailto:jack@paluno.uni-due.de per E-Mail] an uns wenden.<br />
<br />
== JACK 3 ==<br />
JACK 3 ist die aktuelle Version des Übungs- und Prüfungssystems JACK, die an der Universität Duisburg-Essen und weiteren Hochschulen im Produktivbetrieb eingesetzt wird.<br />
<br />
<div style="display:flex; flex-wrap:wrap; row-gap:10px; column-gap:10px; width:100%; color:white;"><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Benutzerhandbuch|<span style="color:white; font-size:130%; font-weight:bold;">JACK 3 Benutzerhandbuch</span>]]</p><p></p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Schnelleinstieg|<span style="color:white; font-size:130%; font-weight:bold;">JACK 3 Schnelleinstieg</span>]]</p><p></p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[[Versionshistorie|<span style="color:white; font-size:130%; font-weight:bold;">JACK 3 Versionshistorie</span>]]</p><p></p></div><br />
<div style="min-width: 300px; text-align: center; min-height: 50px; background-color: #004c93; flex-grow:1; flex-basis:0; padding:10px;"><p>[https://jack-demo.s3.uni-due.de|<span style="color:white; font-size:130%; font-weight:bold;">JACK 3 Demoserver</span>]</p><p>Auf unserem Demoserver können Sie das System bereits aus Studierendensicht testen. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de|<span style="color:white;">per E-Mail</span>], um das System auch aus Lehrendensicht zu begutachten.</p></div><br />
</div><br />
<br />
'''Weiterführende Links'''<br />
* [[Benutzerhandbuch|JACK 3 Benutzerhandbuch]]<br />
* [https://jack-demo.s3.uni-due.de JACK 3 Demoserver]<br />
<br />
== Kontakt und Support ==<br />
<br />
=== Mailingliste ===<br />
Über unsere Mailingliste halten wir Sie über aktuelle Entwicklungen auf dem Laufenden. Sie können sich selbständig [https://lists.uni-due.de/mailman/listinfo/jack-announce in die Liste eintragen], um jederzeit über Updates und andere, wichtige Neuerungen informiert zu werden.<br />
<br />
=== Anmeldung von Prüfungsterminen ===<br />
Wenn Sie eine Prüfung mit JACK durchführen möchten, melden Sie uns die Prüfung bitte [mailto:jack@paluno.uni-due.de per Mail] an. Nur so kann sichergestellt werden, dass Sie technischen Support bei der Durchführung der Prüfung erhalten und zur Prüfungszeit keine Wartungsarbeiten durchgeführt werden, die die Durchführung der Prüfung behindern könnten.<br />
<br />
== JACK 2 ==<br />
JACK 2 ist die von einigen unserer Kunden noch eingesetzte Vorgängerversion von JACK 3. Mittelfristig ist eine Ablösung aller noch im Einsatz befindlichen Produktivsysteme von JACK2 vorgesehen. In JACK 2 werden ''keine neuen Funktionen'' mehr umgesetzt und es ist nur noch begrenzter technischer und inhaltlicher Support verfügbar. Für den Umzug von JACK 2 auf JACK 3 stehen Import-Funktionen und weitere Unterstützung zur Verfügung.<br />
<br />
'''Weiterführende Links'''<br />
* [[JACK 2 Benutzerhandbuch]]<br />
* [[Evaluator|Der JACK 2 Evaluator]]<br />
* [[Neuigkeiten|JACK 2 Versionshistorie]]</div>Striewehttps://wiki.uni-due.de/jack/index.php?title=Benutzer:Striewe/Testseite&diff=8417Benutzer:Striewe/Testseite2023-06-01T07:18:30Z<p>Striewe: </p>
<hr />
<div>__NOTOC__<br />
Herzlich Willkommenen im JACK-Wiki für Lehrende. In diesem Nachschlagewerk finden Sie eine umfassende Dokumentation über die Funktionen und die Arbeitsweise von JACK. Bei weitergehenden Fragen können Sie sich jederzeit [mailto:jack@paluno.uni-due.de per E-Mail] an uns wenden.<br />
<br />
== JACK 3 ==<br />
JACK 3 ist die aktuelle Version des Übungs- und Prüfungssystems JACK, die an der Universität Duisburg-Essen und weiteren Hochschulen im Produktivbetrieb eingesetzt wird. Auf unserem [https://jack-demo.s3.uni-due.de/ Demoserver] können Sie das System bereits aus Studierendensicht testen. Kontaktieren Sie uns [mailto:jack@paluno.uni-due.de per E-Mail], um das System auch aus Lehrendensicht zu begutachten.<br />
<br />
<div style="display:flex; flex-wrap:wrap; row-gap:10px; column-gap:10px; width:100%; "><br />
<div style="min-width: 400px; text-align: center; height: 100px; background-color: #fef6e7; flex-grow:1;">[[Benutzerhandbuch|JACK 3 Benutzerhandbuch]]</div><br />
<div style="min-width: 400px; text-align: center; height: 100px; background-color: #fef6e7; flex-grow:1;">[[Schnelleinstieg|JACK 3 Schnelleinstieg]]</div><br />
<div style="min-width: 400px; text-align: center; height: 100px; background-color: #fef6e7; flex-grow:1;">[[Versionshistorie|JACK 3 Versionshistorie]]</div><br />
<div style="min-width: 400px; text-align: center; height: 100px; background-color: #fef6e7; flex-grow:1;">[https://jack-demo.s3.uni-due.de JACK 3 Demoserver]</div><br />
</div><br />
<br />
'''Weiterführende Links'''<br />
* [[Benutzerhandbuch|JACK 3 Benutzerhandbuch]]<br />
* [https://jack-demo.s3.uni-due.de JACK 3 Demoserver]<br />
<br />
== Kontakt und Support ==<br />
<br />
=== Mailingliste ===<br />
Über unsere Mailingliste halten wir Sie über aktuelle Entwicklungen auf dem Laufenden. Sie können sich selbständig [https://lists.uni-due.de/mailman/listinfo/jack-announce in die Liste eintragen], um jederzeit über Updates und andere, wichtige Neuerungen informiert zu werden.<br />
<br />
=== Anmeldung von Prüfungsterminen ===<br />
Wenn Sie eine Prüfung mit JACK durchführen möchten, melden Sie uns die Prüfung bitte [mailto:jack@paluno.uni-due.de per Mail] an. Nur so kann sichergestellt werden, dass Sie technischen Support bei der Durchführung der Prüfung erhalten und zur Prüfungszeit keine Wartungsarbeiten durchgeführt werden, die die Durchführung der Prüfung behindern könnten.<br />
<br />
== JACK 2 ==<br />
JACK 2 ist die von einigen unserer Kunden noch eingesetzte Vorgängerversion von JACK 3. Mittelfristig ist eine Ablösung aller noch im Einsatz befindlichen Produktivsysteme von JACK2 vorgesehen. In JACK 2 werden ''keine neuen Funktionen'' mehr umgesetzt und es ist nur noch begrenzter technischer und inhaltlicher Support verfügbar. Für den Umzug von JACK 2 auf JACK 3 stehen Import-Funktionen und weitere Unterstützung zur Verfügung.<br />
<br />
'''Weiterführende Links'''<br />
* [[JACK 2 Benutzerhandbuch]]<br />
* [[Evaluator|Der JACK 2 Evaluator]]<br />
* [[Neuigkeiten|JACK 2 Versionshistorie]]</div>Striewe