jQAssistant User Manual

<concept id="my-rules:MyConcept">
    <description>A human readable description of the concept.</description>
    <cypher><![CDATA[
        MATCH
          (m)-[]->(n)
          ...
        RETURN
          m, n
    ]]></cypher>
    <report primaryColumn="n" />
</concept>

MATCH
  (:Java:Type)-[:DECLARES]->(innerType:Java:Type)
CALL {
  WITH
    innerType
  SET
    innerType:Inner
} IN TRANSACTIONS
RETURN
  count(innerType) AS InnerTypes

MATCH
  (anonymousInnerTypes:Inner:Java:Type)
WHERE
  anonymousInnerTypes.name =~ ".*\\$[0-9]*"
CALL {
  WITH
    anonymousInnerTypes
  SET
    anonymousInnerTypes:Anonymous
} IN TRANSACTIONS
RETURN
  count(anonymousInnerTypes) AS AnonymousInnerTypes

MATCH
  (type:Java:Type)-[:IMPLEMENTS|EXTENDS*0..]->(superType:Java:Type)
CALL {
    WITH
      type, superType
    MERGE
      (superType)-[:ASSIGNABLE_FROM]->(type)
} IN TRANSACTIONS
RETURN
  count(*) AS AssignableTypes

MATCH
  (type:Java:Type)-[:DECLARES]->(member:Member),
  (superType:Java:Type)-[:DECLARES]->(superMember:Member),
  path=shortestPath((type)-[:EXTENDS|IMPLEMENTS*]->(superType))
WHERE
  type <> superType
  and member.name is null
  and superMember.name is not null
  and member.signature = superMember.signature
  and superMember.visibility <> "private"
WITH
  type, member, superType, superMember, length(path) as depth
ORDER BY
  depth asc
WITH
  member, head(collect(superMember)) as inheritedMember
CALL {
  WITH
    member, inheritedMember
  MERGE
    (member)-[:INHERITED_FROM]->(inheritedMember)
} IN TRANSACTIONS
RETURN
  count(*) as InheritedMembers

MATCH
  (type:Java:Type)-[:DECLARES]->(method:Method),
  (superType:Java:Type)-[:DECLARES]->(superMethod:Method),
  path=(type)-[:EXTENDS|IMPLEMENTS*]->(superType)
WHERE
  method.signature = superMethod.signature
  and superMethod.visibility <> "private"
  and not (
    (method)-[:INHERITED_FROM]->(:Method)
    or (superMethod)-[:INHERITED_FROM]->(:Method)
  )
WITH
  type, method, superType, superMethod, length(path) as depth
ORDER BY
  depth asc
WITH
  method, head(collect(superMethod)) as overriddenMethod
CALL {
  WITH
    method, overriddenMethod
  MERGE
    (method)-[:OVERRIDES]->(overriddenMethod)
} IN TRANSACTIONS
RETURN
  count(*) as OverriddenMethods

MATCH
  (method:Method)-[invokes:INVOKES]->(:Method)-[:INHERITED_FROM*0..1]->(invokedMethod:Method),
  (invokedMethod)<-[:OVERRIDES*0..]-(overridingMethod:Method)
WHERE NOT (                                     // exclude...
  overridingMethod.abstract is not null         // ...abstract methods
  or (overridingMethod)-[:INHERITED_FROM]->()   // ...inherited methods
)
WITH
  method, overridingMethod, coalesce(invokes.lineNumber, -1) as lineNumber
CALL {
  WITH
    method, overridingMethod, lineNumber
  MERGE
    (method)-[virtualInvokes:VIRTUAL_INVOKES{lineNumber:lineNumber}]->(overridingMethod)
} IN TRANSACTIONS
RETURN
  count(*) as VirtualInvokes

MATCH
  (type:Java:Type)-[:EXTENDS|IMPLEMENTS*]->(superType:Java:Type),
  (dependent:Java:Type)-[:DEPENDS_ON]->(superType)
WHERE NOT (
  superType.fqn = "java.lang.Object"
  or (dependent)-[:EXTENDS|IMPLEMENTS*]->(superType) // exclude types sharing the same super classes/interfaces
)
WITH
  dependent, collect(distinct type) as types
UNWIND
  types as type
CALL {
  WITH
    dependent, type
  MERGE
    (dependent)-[virtualDependsOn:VIRTUAL_DEPENDS_ON]->(type)
} IN TRANSACTIONS
RETURN
  count(*) AS VirtualDependsOn

MATCH
  (type:Java:Type)-[:DECLARES]->(method:Method),
  (type)-[:DECLARES]->(otherMethod:Method)
WHERE
  method <> otherMethod
  AND method.name = otherMethod.name
  AND method.signature <> otherMethod.signature
CALL {
  WITH method, otherMethod
  MERGE
    (method)-[:OVERLOADS]->(otherMethod)
} IN TRANSACTIONS
RETURN
  count(method) AS OverloadedMethods

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(dt:Java:Type)
WHERE
  dt.fqn='java.lang.Deprecated'
SET
  e:Deprecated
RETURN
  e AS DeprecatedElement

MATCH
  (exception)-[:EXTENDS*]->(t:Java:Type)
WHERE
  t.fqn = 'java.lang.Exception'
SET
  exception:Exception
RETURN
  exception AS Exception

MATCH
  (runtimeException)-[:EXTENDS*]->(t:Java:Type)
WHERE
  t.fqn = 'java.lang.RuntimeException'
SET
  runtimeException:RuntimeException
RETURN
  runtimeException AS RuntimeException

MATCH
  (throwable)-[:EXTENDS*]->(t:Java:Type)
WHERE
  t.fqn = 'java.lang.Error'
SET
  throwable:Error
RETURN
  throwable AS Error

MATCH
  (throwable)-[:EXTENDS*]->(t:Java:Type)
WHERE
  t.fqn = 'java.lang.Throwable'
SET
  throwable:Throwable
RETURN
  throwable AS Throwable

MATCH
  (:Artifact)-[:CONTAINS]->(type:Java:Type)
SET
  type.javaVersion=
    CASE type.byteCodeVersion
      WHEN 65 THEN "Java 21"
      WHEN 64 THEN "Java 20"
      WHEN 63 THEN "Java 19"
      WHEN 62 THEN "Java 18"
      WHEN 61 THEN "Java 17"
      WHEN 60 THEN "Java 16"
      WHEN 59 THEN "Java 15"
      WHEN 58 THEN "Java 14"
      WHEN 57 THEN "Java 13"
      WHEN 56 THEN "Java 12"
      WHEN 55 THEN "Java 11"
      WHEN 54 THEN "Java 10"
      WHEN 53 THEN "Java 9"
      WHEN 52 THEN "Java 8"
      WHEN 51 THEN "Java 7"
      WHEN 50 THEN "Java 6"
      WHEN 49 THEN "Java 5"
      WHEN 48 THEN "Java 1.4"
      WHEN 47 THEN "Java 1.3"
      WHEN 46 THEN "Java 1.2"
      WHEN 45 THEN "Java 1.1/1.0"
      ELSE "Unknown"
    END
RETURN
  count(type) as Types

MATCH
    (i:Java:Interface)-[:DECLARES]->(m:Member:Java:Method {abstract: true})
WITH
    i, count(m) AS methods
WHERE
    methods = 1
CALL {
  WITH
    i
  SET
    i:FunctionalInterface
} IN TRANSACTIONS
RETURN
  count(i) AS FunctionInterfaces

MATCH
  (type:Type:Java:Interface)-[:DECLARES]->(defaultMethod:Java:Method)
WHERE NOT
  defaultMethod.abstract is not null
SET
  defaultMethod:Default
RETURN
  defaultMethod AS DefaultMethod, type AS Interface

MATCH
  (postConstruct:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(:Java:Type{fqn:"javax.annotation.PostConstruct"})
SET
  postConstruct:PostConstruct
RETURN
  postConstruct as PostConstruct

MATCH
  (preDestroy:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(:Java:Type{fqn:"javax.annotation.PreDestroy"})
SET
  preDestroy:PreDestroy
RETURN
  preDestroy as PreDestroy

MATCH
  (p:Package)-[:CONTAINS]->(t:Java:Type{sourceFileName: "package-info.java"}),
  (t)-[:ANNOTATED_BY]->(a:Annotation)
MERGE
  (p)-[:ANNOTATED_BY]->(a)
RETURN p

MATCH
  (generatedType:Java:Type)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(:Type{fqn:"lombok.Generated"})
SET
  generatedType:Generated
RETURN
  count(generatedType) as GeneratedTypes

MATCH
  (inner:Java:Type)-[requires:REQUIRES_TYPE_PARAMETER]->(requiredTypeParameter:TypeVariable),
  (outer:Java:Type)-[declares:DECLARES_TYPE_PARAMETER]->(declaredTypeParameter:TypeVariable),
  shortestPath((outer)-[:DECLARES*]->(inner))
WHERE
  outer <> inner
  and declaredTypeParameter.name = requiredTypeParameter.name
CALL {
  WITH
    requiredTypeParameter, declaredTypeParameter
  MERGE
    (requiredTypeParameter)-[:DECLARED_BY]->(declaredTypeParameter)
} IN TRANSACTIONS
RETURN
  count(*) as OuterTypeDeclarations

MATCH
  (parameterizedType:ParameterizedType)-[:OF_RAW_TYPE]->(rawType:Java:Type),
  (parameterizedType)-[hasActualTypeArgument:HAS_ACTUAL_TYPE_ARGUMENT]->(typeArgument),
  (rawType)-[declaresTypeParameter:DECLARES_TYPE_PARAMETER]->(typeParameter)
WHERE
  hasActualTypeArgument.index = declaresTypeParameter.index
CALL {
  WITH
    typeArgument, typeParameter
  MERGE
    (typeArgument)-[:DECLARED_BY]->(typeParameter)
} IN TRANSACTIONS
RETURN
  count(*) as TypeParameterDeclarations

MATCH
    (p1:Package)-[:CONTAINS]->(t1:Java:Type)-[dependsOn:DEPENDS_ON]->(t2:Java:Type)<-[:CONTAINS]-(p2:Package)
WHERE
    p1 <> p2
WITH
  p1, count(dependsOn) as weight, p2
CALL {
  WITH
    p1, weight, p2
  MERGE
    (p1)-[d:DEPENDS_ON]->(p2)
  SET
    d.weight = weight
} IN TRANSACTIONS
RETURN
  p1 AS package, COUNT(p2) AS PackageDependencies

MATCH
  (a1:Artifact)-[:CONTAINS]->(:Java:Type)-[dependsOn:DEPENDS_ON]->(t1:Java:Type),
  (a2:Artifact)-[:CONTAINS]->(t2:Java:Type)
WHERE
  a1 <> a2
  and t1.fqn = t2.fqn
WITH
  a1, count(dependsOn) as weight, a2
CALL {
  WITH
    a1, weight, a2
  MERGE
    (a1)-[d:DEPENDS_ON]->(a2)
  SET
    d.weight = weight
} IN TRANSACTIONS
RETURN
  a1 AS Artifact, COLLECT(DISTINCT a2.fqn) AS Dependencies

MATCH
    (p1:Package)-[:DEPENDS_ON]->(p2:Package),
    path=shortestPath((p2)-[:DEPENDS_ON*]->(p1))
WHERE
    p1<>p2
RETURN
    p1 as Package, nodes(path) as Cycle
ORDER BY
    Package.fqn

MATCH
    (a1:Artifact)-[:DEPENDS_ON]->(a2:Artifact),
    path=shortestPath((a2)-[:DEPENDS_ON*]->(a1))
WHERE
    a1<>a2
RETURN
    a1 as Artifact, nodes(path) as Cycle
ORDER BY
    Artifact.fqn

MATCH
  (artifact:Artifact)-[:CONTAINS]->(testClass:Java:Type)-[:DECLARES]->(testMethod:Java:Method:Test)
RETURN
  artifact as Artifact, testClass as TestClass, count(testMethod) as TestMethods
ORDER BY
  artifact.fqn, testClass.fqn

MATCH
  (artifact:Artifact)-[:CONTAINS]->(testClass:Java:Type)-[:DECLARES]->(:Java:Method:Test)
SET
  testClass:Test
RETURN
  artifact as Artifact, testClass as TestClass
ORDER BY
  artifact.fqn, testClass.fqn

MATCH
  (type:Java:Type)-[:DECLARES]->(assertMethod:Assert:Method)
RETURN
  type AS DeclaringType, count(assertMethod) as AssertMethods
ORDER BY
  type.fqn

MATCH
  (testClass:Java:Type)-[:DECLARES]->(testMethod:Test:Method)
OPTIONAL MATCH
  path=shortestPath((testMethod)-[:INVOKES|VIRTUAL_INVOKES*]->(assert:Method:Assert))
WITH
  testClass, testMethod, path
WHERE
  path is null
  or length(path) > $javaTestAssertMaxCallDepth
RETURN
  distinct testClass AS TestClass, testMethod AS TestMethod
ORDER BY
  testClass.fqn, testMethod.name

MATCH
  (a1:Artifact)-[:REQUIRES]->(t1:Java:Type)
WITH
  a1, t1, t1.fqn AS fqn
MATCH
  (a2:Artifact)-[:CONTAINS]->(t2:Java:Type)
WHERE
  t2.fqn = t1.fqn
CALL {
  WITH
    t1, t2
  MERGE
    (t1)-[:RESOLVES_TO]->(t2)
} IN TRANSACTIONS
RETURN
  count(*) AS ResolvedTypes

MATCH
  (t1:Java:Type)-[:RESOLVES_TO]->(t2:Java:Type),
  (t1)-[:DECLARES]->(m1),
  (t2)-[:DECLARES]->(m2)
WHERE
  (m1:Field or m1:Method)
  and m1.signature = m2.signature
CALL {
  WITH
    m1, m2
  MERGE
  (m1)-[:RESOLVES_TO]->(m2)
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedMembers

MATCH
  (t:Java:Type)-[dependsOn:DEPENDS_ON]->(t1:Java:Type)-[:RESOLVES_TO]->(t2:Java:Type)
CALL {
  WITH
    t, dependsOn, t2
  MERGE
    (t)-[dependsOn1:DEPENDS_ON]->(t2)
  SET
    dependsOn1=dependsOn,
    dependsOn1.resolved=true
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedDependencies

MATCH
  (t:Java:Type)-[extends:EXTENDS]->(t1:Java:Type)-[:RESOLVES_TO]->(t2:Java:Type)
CALL {
  WITH
    t, extends, t2
  MERGE
    (t)-[extends1:EXTENDS]->(t2)
  SET
    extends1=extends,
    extends1.resolved=true
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedSuperClass

MATCH
  (t:Java:Type)-[implements:IMPLEMENTS]->(t1:Java:Type)-[:RESOLVES_TO]->(t2:Java:Type)
CALL {
  WITH
    t, implements, t2
  MERGE
    (t)-[implements1:IMPLEMENTS]->(t2)
  SET
    implements1=implements,
    implements1.resolved=true
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedInterfaces

MATCH
  (f:Field)-[ofType:OF_TYPE]->(:Java:Type)-[:RESOLVES_TO]->(t:Java:Type)
CALL {
  WITH
    f, ofType, t
  MERGE
    (f)-[ofType1:OF_TYPE]->(t)
  SET
    ofType1=ofType,
    ofType1.resolved=true
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedFieldTypes

MATCH
  (m:Method)-[throws:THROWS]->(:Java:Type)-[:RESOLVES_TO]->(t:Java:Type)
CALL {
  WITH
    m, throws, t
  MERGE
    (m)-[throws1:THROWS]->(t)
  SET
    throws1=throws,
    throws1.resolved=true
}
RETURN
  count(*) as ResolvedExceptionTypes

MATCH
  (m:Method)-[returns:RETURNS]->(:Java:Type)-[:RESOLVES_TO]->(t:Java:Type)
CALL {
  WITH
    m, returns, t
  MERGE
    (m)-[returns1:RETURNS]->(t)
  SET
    returns1=returns,
    returns1.resolved=true
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedReturnTypes

MATCH
  (m:Parameter)-[ofType:OF_TYPE]->(:Java:Type)-[:RESOLVES_TO]->(t:Java:Type)
CALL {
  WITH
    m, ofType, t
  MERGE
    (m)-[ofType1:OF_TYPE]->(t)
  SET
    ofType1=ofType,
    ofType1.resolved=true
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedParameterTypes

MATCH
  (a:Annotation)-[ofType:OF_TYPE]->(:Java:Type)-[:RESOLVES_TO]->(t:Java:Type)
CALL {
  WITH
    a, ofType, t
  MERGE
    (a)-[ofType1:OF_TYPE]->(t)
  SET
    ofType1=ofType,
    ofType1.resolved=true
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedAnnotationTypes

MATCH
  (b:Bound)-[ofRawType:OF_RAW_TYPE]->(:Java:Type)-[:RESOLVES_TO]->(t:Java:Type)
CALL {
  WITH
    b, ofRawType, t
  MERGE
    (b)-[ofRawType1:OF_RAW_TYPE]->(t)
  SET
    ofRawType1=ofRawType,
    ofRawType1.resolved=true
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedRawTypes

MATCH
  (v:Value)-[is:IS]->(e)-[:RESOLVES_TO]->(e2)
CALL {
  WITH
    v, is, e2
  MERGE
    (v)-[is1:IS]->(e2)
  SET
    is1=is,
    is1.resolved=true
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedValueTypes

MATCH
  (m:Method)-[reads:READS]->(f1:Field)-[:RESOLVES_TO]->(f2:Field)
CALL {
  WITH
    m, reads, f2
  MERGE
    (m)-[reads1:READS {relationId: id(reads)}]->(f2)
  SET
    reads1=reads,
    reads1.resolved=true
  REMOVE
    reads1.relationId
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedReads

MATCH
  (m:Method)-[writes:WRITES]->(f1:Field)-[:RESOLVES_TO]->(f2:Field)
CALL {
  WITH
    m, writes, f2
  MERGE
    (m)-[writes1:WRITES {relationId: id(writes)}]->(f2)
  SET
    writes1=writes,
    writes1.resolved=true
  REMOVE
    writes1.relationId
} IN TRANSACTIONS
RETURN
  count(*) as ResolvedWrites

MATCH
  (m:Method)-[invokes:INVOKES]->(m1:Method)-[:RESOLVES_TO]->(m2:Method)
CALL {
  WITH
    m, invokes, m2
  MERGE
    (m)-[invokes1:INVOKES {relationId : id(invokes)}]->(m2)
  SET
    invokes1=invokes,
    invokes1.resolved=true
  REMOVE
    invokes1.relationId
  }
RETURN
  count(*) as ResolvedInvocations

MATCH
  ()-[r:RESOLVES_TO]->()
RETURN
  count(r) as ResolvedElements

<concept id="json:SingleColumn">
    <description>Creates a JSON report using a single column result.</description>
    <cypher><![CDATA[
        UNWIND
          ["a", "b"] as row
        RETURN
          row
    ]]></cypher>
    <report type="json"/>
</concept>

[
  "a",
  "b"
]

<concept id="json:Object">
    <description>Creates a JSON report for an object structure.</description>
    <cypher><![CDATA[
        RETURN
          {
            scalar: "Scalar Value",
            array: [
              "Array Item"
            ],
            object: {
                scalar: "Embedded Object"
            }
          } as row
    ]]></cypher>
    <report type="json"/>
</concept>

[
          {
            "scalar": "Scalar Value",
            "array": [
              "Array Item"
            ],
            "object": {
                "scalar": "Embedded Object"
            }
          }
]

<concept id="json:MultipleColumns">
    <description>Creates a JSON report using a multi-column result.</description>
    <cypher><![CDATA[
        UNWIND
          [
            {
                key: "key1",
                value: "value1"
            },
            {
                key: "key2",
                value: "value2"
            }
          ] as row
        RETURN
          row.key as key, row.value as value
    ]]></cypher>
    <report type="json"/>
</concept>

[
          {
            "key": "key1",
            "value": "value1"
          },
          {
            "key": "key2",
            "value": "value2"
          }
]

MATCH
  (c:Type:Class)-[:EXTENDS*]->(testCaseType:Type)
WHERE
  testCaseType.fqn = "junit.framework.TestCase"
SET
  c:Test:Junit3
RETURN
  c AS TestClass

MATCH
  (c:Class:Test:Junit3)-[:DECLARES]->(m:Method)
WHERE
  m.signature =~ "void test.*\\(.*\\)"
SET
  m:Test:Junit3
RETURN
  m AS Test, c AS TestClass

MATCH
  (c:Class:Test:Junit3)-[:DECLARES]->(m:Method)
WHERE
  m.signature = "void setUp()"
SET
  m:SetUp:Junit3
RETURN
  m AS SetUpMethod, c AS TestClass

MATCH
  (c:Class:Test:Junit3)-[:DECLARES]->(m:Method)
WHERE
  m.signature = "void tearDown()"
SET
  m:TearDown:Junit3
RETURN
  m AS TearDownMethod, c AS TestClass

MATCH
  (m:Method)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.Test"
SET
  m:Test:Junit4
RETURN
  m AS Test

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method:Junit4:Test)
SET
  c:Test:Junit4
RETURN
  c AS TestClass, COLLECT(m) AS TestMethods

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method:Junit4:Test)
RETURN
  c AS TestClass, COLLECT(m) AS TestMethods

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.Ignore"
SET
  e:Junit4:Ignore
RETURN
  e AS IgnoredElement

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.Before"
SET
  m:Junit4:Before
RETURN
  m AS BeforeMethod, c AS TestClass

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.After"
SET
  m:Junit4:After
RETURN
  m AS AfterMethod, c AS TestClass

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.BeforeClass"
SET
  m:Junit4:BeforeClass
RETURN
  m AS BeforeClassMethod, c AS TestClass

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.AfterClass"
SET
  m:Junit4:AfterClass
RETURN
  m AS AfterClassMethod, c AS TestClass

MATCH
  (assertType:Type)-[:DECLARES]->(assertMethod)
WHERE
  assertType.fqn = 'org.junit.Assert'
  and (
    assertMethod.signature =~ 'void assert.*'
    or assertMethod.signature =~ 'void fail.*'
  )
SET
  assertMethod:Junit4:Assert
RETURN
  assertMethod

MATCH
  (suite:Type)-[:ANNOTATED_BY]->(suiteClasses)-[:OF_TYPE]->(suiteClassesType:Type)
WHERE
  suiteClassesType.fqn = "org.junit.runners.Suite$SuiteClasses"
SET
  suite:Junit4:Suite
WITH
  suite, suiteClasses
MATCH
  (suiteClasses)-[:HAS]->(:Array:Value)-[:CONTAINS]->(Class:Value)-[:IS]->(testClass:Type)
MERGE
  (suite)-[c:CONTAINS_TESTCLASS]->(testClass)
RETURN
  suite, collect(testClass)

MATCH
    (source:Type:Junit4:Test)-[:DECLARES]->(target:Type)
SET
    target:Junit4:Test:Inner
RETURN
    target

MATCH
  (testType:Type)-[:DECLARES]->(testMethod:Test:Method),
  (testMethod)-[invocation:INVOKES*]->(assertMethod:Junit4:Assert:Method)
WHERE NOT (
    assertMethod.signature =~ 'void assert.*\\(java.lang.String,.*\\)'
    or assertMethod.signature = 'void fail(java.lang.String)'
)
RETURN
  invocation AS Invocation,
  testType AS DeclaringType,
  testMethod AS Method

MATCH
  (:Artifact)-[:CONTAINS]->(t:Type)-[:DECLARES]->(m:Test:Method)
WHERE NOT
  m:Junit4
RETURN
  t AS TestClass,
  m AS TestMethod

MATCH
  (:Artifact)-[:CONTAINS]->(t:Type)-[:DECLARES]->(m:Test:Method),
  (m)-[:INVOKES*..3]->(:Junit5:Assert:Method)
RETURN DISTINCT
  t AS TestClass,
  m AS TestMethod

MATCH
  (m:Method)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.Test"
SET
  m:Test:Junit5
RETURN
  m AS Test

MATCH
  (m:Method)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.RepeatedTest"
SET
  m:Repeated:Test:Junit5
RETURN
  m AS Test

MATCH
  (m:Method)-[:ANNOTATED_BY]-()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.params.ParameterizedTest"
SET
  m:Parameterized:Test:Junit5
RETURN
  m AS Test

MATCH
  (e)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.Disabled"
SET
  e:Junit5:Disabled
RETURN
  e AS IgnoredElement

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.BeforeEach"
SET
  m:Junit5:BeforeEach
RETURN
  m AS BeforeMethod, c AS TestClass

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.BeforeAll"
SET
  m:Junit5:BeforeAll
RETURN
  m AS BeforeClassMethod, c AS TestClass

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.AfterEach"
SET
  m:Junit5:AfterEach
RETURN
  m AS AfterEachMethod, c AS TestClass

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.AfterAll"
SET
  m:Junit5:AfterAll
RETURN
  m AS AfterClassMethod, c AS TestClass

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.TestTemplate"
SET
  m:Junit5:Test:Template
RETURN
  m AS AfterClassMethod, c AS TestClass

MATCH
  (meth:Java:Method:Junit5:Test)-[:ANNOTATED_BY]->(a:Annotation)
  -[:OF_TYPE]->(metaAnn:Java:Type:Annotation)
  -[:ANNOTATED_BY]->(tagAnn:Java:Annotation)
  -[:OF_TYPE]->(tagAnnType:Java:Type { name: 'Tag'})
SET
  meth:Tag
RETURN
  meth AS TestMethod

UNION

MATCH
   (meth:Java:Method:Junit5:Test)
    -[:ANNOTATED_BY]->(a:Annotation)
   -[:OF_TYPE]->(metaAnn:Annotation)
   -[:ANNOTATED_BY]->(tags:Annotation)
   -[:OF_TYPE]->(tagsType { fqn: 'org.junit.jupiter.api.Tags' }),

   (tags)-[:HAS]->(v:Array:Value)
   -[:CONTAINS]->(b:Annotation:Value)
   -[:OF_TYPE]->(tag:Type { fqn: 'org.junit.jupiter.api.Tag' })
SET
   meth:Tag
RETURN
   meth AS TestMethod

MATCH
  (c:Java:Type)-[:ANNOTATED_BY]->(a:Annotation)
  -[:OF_TYPE]->(metaAnn:Java:Type:Annotation)
  -[:ANNOTATED_BY]->(tagAnn:Java:Annotation)
  -[:OF_TYPE]->(tagAnnType:Java:Type { name: 'Tag'})
SET
  c:Tag:Junit5
RETURN
  c AS TaggedClass

UNION

MATCH
   (c:Java:Type)
   -[:ANNOTATED_BY]->(a:Annotation)
   -[:OF_TYPE]->(metaAnn:Annotation)
   -[:ANNOTATED_BY]->(tags:Annotation)
   -[:OF_TYPE]->(tagsType { fqn: 'org.junit.jupiter.api.Tags' }),

   (tags)-[:HAS]->(v:Array:Value)
   -[:CONTAINS]->(b:Annotation:Value)
   -[:OF_TYPE]->(tag:Type { fqn: 'org.junit.jupiter.api.Tag' })
SET
   c:Tag:Junit5
RETURN
   c AS TaggedClass

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method:Junit5:Test)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.Tag"
SET
  m:Junit5:Test:Tag
RETURN
  m AS TestMethod, c AS TestClass
UNION
MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method),
  (m:Method:Test:Junit5)-[:ANNOTATED_BY]->(a:Annotation)-[:OF_TYPE]->(tags:Type),
  (a)-[:HAS]->(v:Array:Value)-[:CONTAINS]->(b:Annotation:Value)-[:OF_TYPE]->(tag:Type)
WHERE
  tags.fqn="org.junit.jupiter.api.Tags"
  AND tag.fqn="org.junit.jupiter.api.Tag"
SET
  m:Junit5:Test:Tag
RETURN
  m AS TestMethod, c AS TestClass

MATCH
    (c:Type:Class)-[:DECLARES]->(m:Method),
    (m:Method)-[:ANNOTATED_BY]->(a:Annotation)-[:OF_TYPE]->(tags:Type),
    (a)-[:HAS]->(v:Array:Value)-[:CONTAINS]->(b:Annotation:Value)-[:OF_TYPE]->(tag:Type),
    (b)-[:HAS]->(tagValue:Value)

WHERE
    tags.fqn="org.junit.jupiter.api.Tags"
    AND tag.fqn="org.junit.jupiter.api.Tag"

WITH
    collect(distinct tagValue.value) AS tagValues, m

SET
    m.tags = tagValues

RETURN
    m

UNION

MATCH
    (c:Type:Class)-[:DECLARES]->(m:Method),
    (m:Method)-[:ANNOTATED_BY]->(a:Annotation)-[:OF_TYPE]->(t:Type),
    (a:Annotation)-[:HAS]->(v:Value)

WHERE
    t.fqn="org.junit.jupiter.api.Tag"

WITH
    collect(distinct v.value) as tagValues, m

SET
    m.tags = tagValues

RETURN
    m

MATCH
  (c:Type:Class)-[:ANNOTATED_BY]->()-[:OF_TYPE]->(a:Type)
WHERE
  a.fqn="org.junit.jupiter.api.Tag"
SET
  c:Junit5:Tag
RETURN
  c AS TestClass
UNION
MATCH
  (c:Type:Class)-[:ANNOTATED_BY]->(a:Annotation)-[:OF_TYPE]->(tags:Type),
  (a)-[:HAS]->(v:Array:Value)-[:CONTAINS]->(b:Annotation:Value)-[:OF_TYPE]->(tag:Type)
SET
  c:Junit5:Tag
RETURN
  c AS TestClass

MATCH
  (c:Type:Class)-[:ANNOTATED_BY]->(a:Annotation)-[:OF_TYPE]->(tag:Type),
  (c:Type:Class)-[:DECLARES]->(m:Method:Junit5:Test),
  // (m:Method)-[:ANNOTATED_BY]->(a:Annotation)-[:OF_TYPE]->(tag:Type),
  (a)-[:HAS]->(tagValue:Value)
WHERE
  tag.fqn="org.junit.jupiter.api.Tag"
WITH
  collect(distinct tagValue.value) AS tagValues, c
SET
  c.tags = tagValues, c:Test:Junit5
RETURN
  c
UNION
MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method:Test:Junit5),
  (c:Type:Class)-[:ANNOTATED_BY]->(a:Annotation)-[:OF_TYPE]->(tags:Type),
  (a)-[:HAS]->(v:Array:Value)-[:CONTAINS]->(b:Annotation:Value)-[:OF_TYPE]->(tag:Type),
  (b)-[:HAS]->(tagValue:Value)
WHERE
  tags.fqn="org.junit.jupiter.api.Tags"
  AND tag.fqn="org.junit.jupiter.api.Tag"
WITH
  collect(distinct tagValue.value) AS tagValues, c
SET
  c.tags = tagValues, c:Test:Junit5
RETURN
  c

MATCH
  (c:Type:Class)-[:DECLARES]->(m:Method:Junit5:Test)
SET
  c:Test:Junit5
RETURN
  c AS TestClass, COLLECT(m) AS TestMethods

MATCH
  (c:Type:Class)-[:ANNOTATED_BY]->(a:Annotation)-[:OF_TYPE]->(n:Type)
WHERE
  n.fqn = "org.junit.jupiter.api.Nested"
SET
  c:Junit5:Nested
RETURN
  c

MATCH
  (assertType:Type)-[:DECLARES]->(assertMethod)
WHERE
  assertType.fqn = 'org.junit.jupiter.api.Assertions'
  and (
   assertMethod.signature CONTAINS ' assert'
   or assertMethod.signature CONTAINS ' fail'
  )
SET
  assertMethod:Junit5:Assert
RETURN
  assertMethod

MATCH
  (testType:Type)-[:DECLARES]->(testMethod:Test:Method),
  (testMethod)-[invocation:INVOKES]->(assertMethod:Junit5:Assert:Method)
WHERE NOT (
  assertMethod.signature =~ 'void assert.*\\(.*java.lang.String\\)'
  or assertMethod.signature =~ 'void assert.*\\(.*java.util.function.Supplier\\)'
  or assertMethod.signature = 'java.lang.Object fail(java.lang.String)'
)
RETURN
  invocation AS Invocation,
  testType AS DeclaringType,
  testMethod AS Method

MATCH
  (:Artifact)-[:CONTAINS]->(t:Type)-[:DECLARES]->(m:Test:Method)
WHERE
  m:Junit3 OR m:Junit4
RETURN
  t AS TestClass,
  m AS TestMethod

MATCH
  (:Artifact)-[:CONTAINS]->(t:Type)-[:DECLARES]->(m:Test:Method),
  (m)-[:INVOKES*..3]->(:Junit4:Assert:Method)
RETURN DISTINCT
  t AS TestClass,
  m AS TestMethod

MATCH
  (testcase:TestCase)
WITH
  testcase
MATCH
  (testclass:Type)
WHERE
  testclass.fqn = testcase.className
MERGE
  (testcase)-[:DEFINED_BY]->(testclass)
RETURN
  testcase.name AS TestCase, testclass AS TestClass

MATCH
  (testcase:TestCase)-[:DEFINED_BY]->(testclass:Type),
  (testclass)-[:EXTENDS*0..]->(:Type)-[:DECLARES]->(testmethod:Method)
WHERE
  testmethod.name = testcase.name
MERGE
  (testcase)-[:IMPLEMENTED_BY]->(testmethod)
RETURN
  testcase.name AS TestCase, testmethod as TestMethod

MATCH
  (e)-[:ANNOTATED_BY]->(ignore:Annotation)-[:OF_TYPE]->(ignoreType:Type)
WHERE
  ignoreType.fqn= "org.junit.Ignore"
  AND NOT (ignore)-[:HAS]->(:Value{name:"value"})
RETURN
  e AS IgnoreWithoutMessage
UNION
MATCH
  (e)-[:ANNOTATED_BY]->(disabled:Annotation)-[:OF_TYPE]->(disabledType:Type)
WHERE
  disabledType.fqn = "org.junit.jupiter.api.Disabled"
  AND NOT (disabled)-[:HAS]->(:Value{name:"value"})
RETURN
  e AS IgnoreWithoutMessage

MATCH
  (testType:Type)-[:DECLARES]->(testMethod:Test:Method),
  (testMethod)-[invocation:INVOKES]->(assertMethod:Assert:Method)
WHERE NOT (
   assertMethod.signature =~ 'void assert.*\\(java.lang.String,.*\\)'
   or assertMethod.signature =~ '.* fail(java.lang.String)'
)
RETURN
  invocation AS Invocation,
  testType AS DeclaringType,
  testMethod AS Method

MATCH
  (testType:Type)-[:DECLARES]->(testMethod:Test:Method)
WHERE
  NOT (testMethod)-[:INVOKES|VIRTUAL_INVOKES*..3]->(:Method:Assert)
RETURN
  testType AS DeclaringType,
  testMethod AS Method