From 1cfc2e98ffbba1dc2a489ad415c81264b76d8c14 Mon Sep 17 00:00:00 2001 From: 20001LastOrder Date: Sun, 15 Nov 2020 21:56:45 -0500 Subject: code for paper --- .../RealisticRunner/queries/ecore.vql | 33 +++ .../RealisticRunner/queries/github.vql | 121 +++++++++++ .../RealisticRunner/queries/yakindu.vql | 226 +++++++++++++++++++++ 3 files changed, 380 insertions(+) create mode 100644 Metrics/Metrics-Calculation/RealisticRunner/queries/ecore.vql create mode 100644 Metrics/Metrics-Calculation/RealisticRunner/queries/github.vql create mode 100644 Metrics/Metrics-Calculation/RealisticRunner/queries/yakindu.vql (limited to 'Metrics/Metrics-Calculation/RealisticRunner/queries') 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 -- cgit v1.2.3-54-g00ecf