code for paperRealistic-Generation-SURE

3 files changed, 380 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/RealisticRunner/queries/ecore.vql b/Metrics/Metrics-Calculation/RealisticRunner/queries/ecore.vql
new file mode 100644
index 00000000..9ddb64c9
--- /dev/null
+++ b/Metrics/Metrics-Calculation/RealisticRunner/queries/ecore.vql
@@ -0,0 +1,33 @@
+package queries
+
+import epackage "http://www.eclipse.org/emf/2002/Ecore"
+
+pattern directSupertype(a: EClass, b:EClass) {
+        EClass.eSuperTypes(a,b);
+}
+
+@Constraint(key={a}, severity="error", message="error")
+pattern loopInInheritence(a: EClass) {
+        find directSupertype+(a,a);
+}
+
+pattern opposite(a:EReference, b: EReference) {
+        EReference.eOpposite(a,b);
+}
+@Constraint(key={a}, severity="error", message="error")
+pattern oppositeDifferentClass(a:EReference) {
+        EReference.eOpposite(a,b);
+        EReference.eContainingClass(a,aContaining);
+        EReference.eType(b,bTarget);
+        aContaining != bTarget;
+}
+
+@Constraint(key={a}, severity="error", message="error")
+pattern nonSymmetricOpposite(a:EReference, b:EReference) {
+        find opposite(a,b);
+        neg find opposite(b,a);
+}
+
+pattern superTypes(c1:EClass, c2:EClass){
+        EClass.eSuperTypes(c1,c2);
+}
diff --git a/Metrics/Metrics-Calculation/RealisticRunner/queries/github.vql b/Metrics/Metrics-Calculation/RealisticRunner/queries/github.vql
new file mode 100644
index 00000000..eda5f0f1
--- /dev/null
+++ b/Metrics/Metrics-Calculation/RealisticRunner/queries/github.vql
@@ -0,0 +1,121 @@
+package queries
+import epackage "sure.ghtorrent.github"
+
+pattern directParent(a : Commit, b: Commit) {
+        Commit.parents(a,b);
+}
+
+@Constraint(key={a}, severity="error", message="error")
+pattern loopInParent(a: Commit){
+ find directParent+(a,a);
+}
+
+pattern checkAction(i: Issue, e: IssueEvent, t: Action) {
+        Issue.issueevent(i, e);
+        IssueEvent.action(e, a);
+        a == t;
+}
+
+pattern checkUserAction(i: Issue, u: User, e: IssueEvent, t: Action) {
+        Issue.issueevent(i, e);
+        IssueEvent.user(e, u);
+        IssueEvent.action(e, a);
+        a == t;
+}
+
+pattern isReopen(i: Issue, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.action(e, a);
+        a == Action::REOPENED;
+}
+
+pattern isClose(i: Issue, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.action(e, a);
+        a == Action::CLOSED;
+}
+
+pattern isUnSubscribe(i: Issue, u: User, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.user(e, u);
+        IssueEvent.action(e, a);
+        a == Action::UNSUBSCRIBED;
+}
+
+pattern isSubscribe(i: Issue, u: User, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.user(e, u);
+        IssueEvent.action(e, a);
+        a == Action::SUBSCRIBED;
+}
+
+
+pattern pullRequestOfIssue(i: Issue, pr: PullRequest) {
+        Issue.pullrequest(i, pr);
+}
+
+//@Constraint(key={i}, severity="error", message="error")
+//pattern mergedIssueWithoutPr(i: Issue){
+//      find checkAction(i, _, Action::MERGED);
+//      neg find pullRequestOfIssue(i, _);
+//}
+
+@Constraint(key={i}, severity="error", message="error")
+pattern consecutiveClosesWithoutReopen(i: Issue) {
+        find checkAction(i, a1, Action::CLOSED);
+        find checkAction(i, a2, Action::CLOSED);
+        a1 != a2;
+        neg find isReopen(i, _);
+}
+
+
+@Constraint(key={i}, severity="error", message="error")
+pattern consecutiveReopensWithoutClose(i: Issue) {
+        find checkAction(i, a1, Action::REOPENED);
+        find checkAction(i, a2, Action::REOPENED);
+        a1 != a2;
+        neg find isClose(i, _);
+}
+
+//@Constraint(key={i, u}, severity="error", message="error")
+//pattern consecutiveSubWithoutUnSub(i: Issue, u: User) {
+//      find checkUserAction(i, u, a1, Action::SUBSCRIBED);
+//      find checkUserAction(i, u, a2, Action::SUBSCRIBED);
+//      a1 != a2;
+//      neg find isUnSubscribe(i, u, _);
+//}
+
+@Constraint(key={i, u}, severity="error", message="error")
+pattern consecutiveUnSubWithoutSub(i: Issue, u: User) {
+        find checkUserAction(i, u, a1, Action::UNSUBSCRIBED);
+        find checkUserAction(i, u, a2, Action::UNSUBSCRIBED);
+        a1 != a2;
+        neg find isSubscribe(i, u, _);
+}
+
+//pattern committer(c: Commit, u:User) {
+//      Commit.committer(c, u);
+//}
+//
+//pattern eventUser(e: IssueEvent, u:User){
+//      IssueEvent.user(e, u);
+//}
+//
+//@Constraint(key={c}, severity="error", message="error")
+//pattern noCommitter(c: Commit) {
+//      neg find committer(c, _);
+//}
+//
+//@Constraint(key={e}, severity="error", message="error")
+//pattern noUser(e: IssueEvent) {
+//      neg find eventUser(e, _);
+//}
+
+
+
+//1. issue with MERGED but no PullRequest
+//2. issue with 2 CLOSED events without a REOPENED event
+//3. issue with 2 REOPENED events without a CLOSED event
+//4. user-issue pair with 2 SUBSCRIBED events without an UNSUBSCRIBED event
+//5. user-issue pair with 2 UNSUBSCRIBED events without a SUBSCRIBED event
+//6. User MERGED/CLOSED/REOPENED issue without being a projectMember of the Project (Not possible under this condition)
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/RealisticRunner/queries/yakindu.vql b/Metrics/Metrics-Calculation/RealisticRunner/queries/yakindu.vql
new file mode 100644
index 00000000..0d863ed2
--- /dev/null
+++ b/Metrics/Metrics-Calculation/RealisticRunner/queries/yakindu.vql
@@ -0,0 +1,226 @@
+package hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu
+import epackage "hu.bme.mit.inf.yakindumm"
+
+/////////
+// Entry
+/////////
+
+pattern entryInRegion(r1 : Region, e1 : Entry) {
+        Region.vertices(r1, e1);
+}
+
+@Constraint(severity="error", message="error", key = {r1})
+pattern noEntryInRegion(r1 : Region) {
+        neg find entryInRegion(r1, _);
+}
+
+@Constraint(severity="error", message="error", key = {r})
+pattern multipleEntryInRegion(r : Region) {
+        find entryInRegion(r, e1);
+        find entryInRegion(r, e2);
+        e1 != e2;
+}
+
+pattern transition(t : Transition, src : Vertex, trg : Vertex) {
+        Transition.source(t, src);
+        Transition.target(t, trg);
+}
+
+@Constraint(severity="error", message="error", key = {e})
+pattern incomingToEntry(t : Transition, e : Entry) {
+        find transition(t, _, e);
+}
+
+@Constraint(severity="error", message="error", key = {e})
+pattern noOutgoingTransitionFromEntry(e : Entry) {
+        neg find transition(_, e, _);
+}
+
+@Constraint(severity="error", message="error", key = {e})
+pattern multipleTransitionFromEntry(e : Entry, t1 : Transition, t2: Transition) {
+        Entry.outgoingTransitions(e,t1);
+        Entry.outgoingTransitions(e,t2);
+        t1!=t2;
+}
+
+/////////
+// Exit
+/////////
+
+@Constraint(severity="error", message="error", key = {e})
+pattern outgoingFromExit(t : Transition, e : Exit) {
+        Exit.outgoingTransitions(e,t);
+}
+
+/////////
+// Final
+/////////
+
+@Constraint(severity="error", message="error", key = {f})
+pattern outgoingFromFinal(t : Transition, f : FinalState) {
+        FinalState.outgoingTransitions(f,t);
+}
+
+/////////
+// State vs Region
+/////////
+
+@Constraint(severity="error", message="error", key = {region})
+pattern noStateInRegion(region: Region) {
+        neg find StateInRegion(region,_);
+}
+pattern StateInRegion(region: Region, state: State) {
+        Region.vertices(region,state);
+}
+
+/////////
+// Choice
+/////////
+
+@Constraint(severity="error", message="error", key = {c})
+pattern choiceHasNoOutgoing(c : Choice) {
+        neg find transition(_, c, _);
+}
+
+@Constraint(severity="error", message="error", key = {c})
+pattern choiceHasNoIncoming(c: Choice) {
+        neg find transition(_, _, c);
+}
+
+/////////
+// Synchronization
+/////////
+
+//@Constraint(severity="error", message="error", key = {s})
+//pattern synchHasNoOutgoing(s : Synchronization) {
+//      neg find transition(_, s, _);
+//}
+//
+//@Constraint(severity="error", message="error", key = {s})
+//pattern synchHasNoIncoming(s : Synchronization) {
+//      neg find transition(_, _, s);
+//}
+//
+//@Constraint(severity="error", message="error", key = {s})
+//pattern SynchronizedIncomingInSameRegion(s : Synchronization, v1 : Vertex, v2 : Vertex) {
+//      find transition(t1, v1, s);
+//      find transition(t2, v2, s);
+//      t1!=t2;
+//      Region.vertices(r, v1);
+//      Region.vertices(r, v2);
+//} or {
+//      find transition(t1, s, v1);
+//      find transition(t2, s, v2);
+//      t1!=t2;
+//      Region.vertices(r, v1);
+//      Region.vertices(r, v2);
+//}
+//
+//@Constraint(severity="error", message="error", key = {s})
+//pattern notSynchronizingStates(s : Synchronization) {
+//      neg find hasMultipleOutgoingTrainsition(s);
+//      neg find hasMultipleIncomingTrainsition(s);
+//}
+
+//pattern hasMultipleOutgoingTrainsition(v : Synchronization) {
+//      find transition(_, v, trg1);
+//      find transition(_, v, trg2);
+//      trg1 != trg2;
+//}
+//
+//pattern hasMultipleIncomingTrainsition(v : Synchronization) {
+//      find transition(_, src1, v);
+//      find transition(_, src2, v);
+//      src1 != src2;
+//}
+//
+//@Constraint(severity="error", message="error", key = {s})
+//pattern SynchronizedRegionsAreNotSiblings(s : Synchronization, v1 : Vertex, v2 : Vertex) {
+//      find transition(_, v1, s);
+//      find transition(_, v2, s);
+//      CompositeElement.regions.vertices(r1, v1);
+//      CompositeElement.regions.vertices(r2, v2);
+//      r1 != r2;
+//} or {
+//      find transition(_, s, v1);
+//      find transition(_, s, v2);
+//      CompositeElement.regions.vertices(r1, v1);
+//      CompositeElement.regions.vertices(r2, v2);
+//      r1 != r2;
+//}
+
+///////////////////////////////
+// Extra
+//
+//@Constraint(severity="error", message="error", key = {s})
+//pattern SynchronizedRegionDoesNotHaveParent(s : Synchronization, v : Vertex) {
+//      find transition(_, v, s);
+//      neg find child(_,v);
+//} or {
+//      find transition(_, s, v);
+//      neg find child(_,v);
+//}
+
+pattern child(parent: CompositeElement, child: Vertex) {
+        CompositeElement.regions.vertices(parent, child);
+}
+
+//@Constraint(severity="error", message="error", key = {s})
+//pattern SynchronizedRegionDoesNotHaveMultipleRegions(s : Synchronization, v : Vertex) {
+//      find transition(_, v, s);
+//      find child(c,v);
+//      neg find hasMultipleRegions(c);
+//} or {
+//      find transition(_, s, v);
+//      find child(c,v);
+//      neg find hasMultipleRegions(c);
+//}
+
+
+pattern hasMultipleRegions(composite: CompositeElement) {
+        CompositeElement.regions(composite,region1);
+        CompositeElement.regions(composite,region2);
+        region1 != region2;
+}
+
+/**
+ * Simplifying model generation
+ */
+//@Constraint(severity="error", message="error", key = {s})
+//pattern synchThree(s: Synchronization) {
+//      Transition.target(t1,s);
+//      Transition.target(t2,s);
+//      Transition.target(t3,s);
+//      t1!=t2;
+//      t2!=t3;
+//      t1!=t3;
+//} or {
+//      Transition.source(t1,s);
+//      Transition.source(t2,s);
+//      Transition.source(t3,s);
+//      t1!=t2;
+//      t2!=t3;
+//      t1!=t3;
+//}
+
+/**
+ * Simplifying model generation
+ */
+//@Constraint(severity="error", message="error", key = {s1,s2})
+//pattern twoSynch(s1 : Synchronization, s2 : Synchronization) {
+//      Synchronization(s1);
+//      Synchronization(s2);
+//      s1 != s2;
+//}
+
+/**
+ * Model generation task: at least one synch
+ */
+//@Constraint(severity="error", message="error", key = {s})
+//pattern noSynch(s:Statechart) {
+//      Statechart(s);
+//      neg find synch(_);
+//}
+//pattern synch(s:Synchronization) {
+//      Synchronization(s);
+//}
\ No newline at end of file