Query Development Tools in VIATRA

ViatraQueryTest. //Entry point
  test(SomeQuerySpecification::instance).
  and(AnotherQuerySpecification). // Patterns under test
  on(modelURI). // Instance models (optional; snapshot model references the input model)
  with(snapshot). // Compare prepared results stored by a snapshot model
  with(new ReteBackendFactory). // Compare results produced by the Rete engine
  assumeInputs. // checks whether the given snapshots and backend factories are valid for the patterns under test. Throws JUnit assumption error otherwise
  assertEquals // compute difference of each given snapshot and pattern executions. Throws JUnit assertion failure if differences occur

ViatraQueryTest. //Entry point
  test(SomeQuerySpecification::instance).
  and(AnotherQuerySpecification). // Patterns under test
  on(modelURI). // Instance models (optional; snapshot model references the input model)
  with(snapshot). // Compare prepared results stored by a snapshot model
  with(new ReteBackendFactory). // Compare results produced by the Rete engine
  assertEqualsThen. // assertEqualsThen does not return void
  modify(Type, [name=="John"], [age=35]). // The given operation is executed on each instance of the given type on which the given condition evaluates to true.
  with(snapshotAfterModification). // Any modify operation causes all previously loaded snapshots to be invalidated.
  assertEquals

public class CustomIntegerAccess extends JavaObjectAccess{

	public CustomIntegerAccess() {
		super(CustomInteger.class);
	}

        //Create Substitution object based on the CustomInteger object
	@Override
	public SerializedJavaObjectSubstitution toSubstitution(Object value) {
		SerializedJavaObjectSubstitution sub = SnapshotFactory.eINSTANCE.createSerializedJavaObjectSubstitution();
		if(value instanceof CustomInteger){
			sub.setType(getType().getName());
			sub.setValue(((CustomInteger) value).integerValue()+"");
		}
		return sub;
	}

        //Calculate hash code (needed for equality checking)
	@Override
	public int calculateHash(SerializedJavaObjectSubstitution substitution) {
		return Objects.hashCode(Integer.parseInt(substitution.getValue()));
	}

        //Check if two substitutions are equal (assuming they each define a 'CustomInteger')
	@Override
	public boolean equals(SerializedJavaObjectSubstitution a, SerializedJavaObjectSubstitution b) {
		if(a.getType().equals(getType().getName()) && b.getType().equals(getType().getName())){
			int aVal = Integer.parseInt(a.getValue());
			int bVal = Integer.parseInt(b.getValue());
			return aVal == bVal;
		}
		return false;
	}

}

    ...
    Map<String, JavaObjectAccess> objectAccess = Maps.newHashMap();
    map.put(CustomInteger.class.getName(),new CustomIntegerAccess());
    ViatraQueryTest.test(specs, new SnapshotHelper(objectAccess)).on(new EMFScope([MODEL])).with([SNAPSHOT]).assertEquals();
    ...

customMap.put(CyberPhysicalSystemPackage.Literals.APPLICATION_TYPE, [at | (at as ApplicationType).identifier])

ViatraQueryTest.test(ApplicationTypesQuerySpecification.instance, snapshotHelper(customMap))
          .on(new EMFScope([MODEL]))
          .with([SNAPSHOT])
          .assertEquals

<!-- use this in your project's pom.xml file -->
<properties>
    <!-- It is a good idea to specify VIATRA framework version once as
    a property (e.g. in the parent pom) and use that throughout the build -->
	<viatra.version>1.2.1</viatra.version>
</properties>

<dependencies>
	<dependency>
		<groupId>org.eclipse.viatra</groupId>
		<artifactId>viatra-query-runtime</artifactId>
		<version>${viatra.version}</version>
	</dependency>

	<!-- requires many more dependencies - only use if required -->
	<dependency>
		<groupId>org.eclipse.viatra</groupId>
		<artifactId>viatra-query-language</artifactId>
		<version>${viatra.version}</version>
	</dependency>
</dependencies>

<repositories>
	<repository>
		<id>viatra</id>
		<url>https://repo.eclipse.org/content/groups/viatra2/</url>
	</repository>
</repositories>

<pluginRepositories>
  <pluginRepository>
    <id>viatra</id>
    <url>https://repo.eclipse.org/content/groups/viatra/</url>
  </pluginRepository>
</pluginRepositories>
<build>
<plugins>
<!-- Using maven-clean-plugin to remove previously generated code -->
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-clean-plugin</artifactId>
  <version>2.5</version>
  <executions>
    <execution>
      <phase>clean</phase>
      <goals>
        <goal>clean</goal>
      </goals>
      <configuration>
        <filesets>
          <fileset>
            <!-- Generated code folder -->
            <directory>src-gen</directory>
            <includes>
              <include>**/*</include>
            </includes>
          </fileset>
        </filesets>
      </configuration>
    </execution>
  </executions>
</plugin>
<!-- Setting up generator -->
<plugin>
  <groupId>org.eclipse.viatra</groupId>
  <artifactId>viatra-maven-plugin</artifactId>
  <version>${viatra.version}</version>
  <!-- Binding execution to the code generation lifecycle phase -->
  <executions>
    <execution>
      <goals>
        <goal>generate</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <!-- Output directory - required -->
    <outputDirectory>src-gen</outputDirectory>
    <metamodels>
      <metamodel>
        <!-- Select one of the following depending on where is your metamodel defined -->

        <!-- (a) Java class for the EMF EPackage - use this if generated EMF code is in the classpath -->
        <packageClass>org.eclipse.viatra.examples.cps.cyberPhysicalSystem.CyberPhysicalSystemPackage</packageClass>
        <!-- (b) genmodel file used for generating the EMF model classes - use this if EMF model is in the same project -->
        <!-- <genmodelUri>model/model.genmodel</genmodelUri> -->
      </metamodel>
    </metamodels>
    <!-- Since 1.5, you can use the project dependencies instead of specific Maven dependencies - optional -->
    <useProjectDependencies>true</useProjectDependencies>
  </configuration>
  <dependencies>
    <!-- Dependency required for the cps domain project (that contains the generated EPackage), unless you set useProjectDependencies -->
    <dependency>
      <groupId>org.eclipse.viatra.examples.cps</groupId>
      <artifactId>org.eclipse.viatra.examples.cps.model</artifactId>
      <version>1.2.0</version>
    </dependency>
  </dependencies>
</plugin>
</plugins>
</build>