HybridCosimulation/DSL_SemanticAdaptation/be.uantwerpen.ansymo.semanticadaptation.cg.canonical.tests/src/be/uantwerpen/ansymo/semanticadaptation/cg/canonical/tests/SemanticAdaptationGeneratorTest.xtend

/*
 * generated by Xtext 2.10.0
 */
package be.uantwerpen.ansymo.semanticadaptation.cg.canonical.tests

import be.uantwerpen.ansymo.semanticadaptation.cg.canonical.SemanticAdaptationCanonicalGenerator
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Adaptation
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Assignment
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.AtomicUnity
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.BoolLiteral
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.CompositeOutputFunction
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.CustomControlRule
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Declaration
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.InnerFMU
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.MultiplyUnity
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Neg
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Port
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.SemanticAdaptation
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.SingleVarDeclaration
import be.uantwerpen.ansymo.semanticadaptation.semanticAdaptation.Variable
import be.uantwerpen.ansymo.semanticadaptation.tests.AbstractSemanticAdaptationTest
import be.uantwerpen.ansymo.semanticadaptation.tests.SemanticAdaptationInjectorProvider
import com.google.inject.Inject
import org.eclipse.emf.common.util.URI
import org.eclipse.xtext.generator.InMemoryFileSystemAccess
import org.eclipse.xtext.testing.InjectWith
import org.eclipse.xtext.testing.XtextRunner
import org.eclipse.xtext.testing.util.ParseHelper
import org.eclipse.xtext.util.IAcceptor
import org.eclipse.xtext.xbase.testing.CompilationTestHelper
import org.eclipse.xtext.xbase.testing.CompilationTestHelper.Result
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Ignore

@RunWith(XtextRunner)
@InjectWith(SemanticAdaptationInjectorProvider)
class SemanticAdaptationGeneratorTest extends AbstractSemanticAdaptationTest{
	
	@Inject extension ParseHelper<SemanticAdaptation>
	
	@Test def test_inferTypesAndUnits_sample1() { 
		__generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(sa.name == "outerFMU")
				Assert.assertTrue(sa.eAllContents.filter(Port).filter[p | p.name=="ext_input_port3"].head.unity instanceof MultiplyUnity)
				Assert.assertTrue(sa.eAllContents.filter(InnerFMU).filter[f | f.name=="innerFMU2"].head
							.eAllContents.filter(Port).filter[p | p.name=="innerFMU2__input_port1"].head.type == "Real")
				Assert.assertTrue(sa.eAllContents.filter(InnerFMU).filter[f | f.name=="innerFMU2"].head
							.eAllContents.filter(Port).filter[p | p.name=="innerFMU2__outout_port1"].head.type == "Real")
				Assert.assertTrue(sa.eAllContents.filter(InnerFMU).filter[f | f.name=="innerFMU2"].head
							.eAllContents.filter(Port).filter[p | p.name=="innerFMU2__outout_port1"].head.unity instanceof AtomicUnity)
				
			}
		}) }
	
	@Test def test_addInputPorts_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(sa.inports.filter[p | p.name=="innerFMU1__input_port2"].head.type == "Bool")
				
				Assert.assertTrue(sa.inports.filter[p | p.name=="innerFMU1__input_port1"].size == 0)
				
			}
		}) }
	
	@Test def test_addParams_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(sa.params.head.declarations.filter[p | p.name=="INIT_EXT_INPUT_PORT3"].head.type == "Real")
				Assert.assertTrue(sa.params.head.declarations.filter[p | p.name=="INIT_INNERFMU1__INPUT_PORT2"].head.expr instanceof BoolLiteral)
			}
		}) }
	
	@Test def test_addInVars_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(sa.in.globalInVars.head.declarations.filter[p | p.name=="stored__innerFMU2__input_port2"].head.type == "Bool")
				Assert.assertTrue(sa.in.globalInVars.head.declarations.filter[p | p.name=="stored__innerFMU2__input_port3"].head.expr instanceof Variable)
			}
		}) }
	
	@Test def test_addOutVars_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(sa.out.globalOutVars.head.declarations.filter[p | p.name=="stored__innerFMU1__output_port2"].head.type == "Integer")
			}
		}) }
	
	@Test def test_addExternal2InputPortStoredAssignments_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				val fistAssignment = sa.in.rules.head.statetransitionfunction.statements.head as Assignment
				Assert.assertTrue((fistAssignment.lvalue as Variable).ref instanceof SingleVarDeclaration)
				Assert.assertTrue((fistAssignment.expr as Variable).ref instanceof Port)
			}
		}) }
	
	
	@Test def test_addInternal2OutputPortStoredAssignments_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				var firstAssignment = sa.out.rules.head.statetransitionfunction.statements.head as Assignment
				Assert.assertNotEquals((firstAssignment.expr as Variable).owner.name, "outerFMU_BASE")
			}
		}) }
	
	@Test def test_addInRules_External2Internal_Assignments_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				val outFunction = sa.in.rules.head.outputfunction as CompositeOutputFunction
				//val firstAssignment = outFunction.statements.head as Assignment
				val assignment = outFunction.statements.filter[s | s instanceof Assignment && (s as Assignment).lvalue.ref.name == "innerFMU2__input_port1"]
				Assert.assertEquals(1, assignment.size)
				//Assert.assertTrue(firstAssignment.lvalue.ref.name == "innerFMU2__input_port1")
				Assert.assertTrue(((assignment.head as Assignment).expr as Variable).ref.name == "stored__innerFMU2__input_port1")
			}
		}) }
	
	
	@Test def test_addOutRules_Internal2External_Assignments_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				val outFunction = sa.out.rules.head.outputfunction as CompositeOutputFunction
				val firstAssignment = outFunction.statements.head as Assignment
				Assert.assertTrue(firstAssignment.lvalue.ref.name == "ext_output_port2")
				Assert.assertTrue((firstAssignment.expr as Variable).ref.name == "stored__innerFMU1__output_port2")
			}
		}) }
	
	@Test def test_removeInBindings_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(sa.inports.forall[p | p.targetdependency === null])
			}
		}) }
	
	@Test def test_removeOutBindings_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(sa.outports.forall[p | p.sourcedependency === null])
			}
		}) }
	
	@Test def test_addOutParams_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(sa.params.head.declarations.filter[p | p.name == "INIT_INNERFMU2__OUTPUT_PORT2"].size == 1)
			}
		}) }
	
	
	@Test def test_createCoSimStepInstructions_sample2() { __generate('input/canonical_generation/sample2.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head()
				Assert.assertTrue((sa.control.rule as CustomControlRule).controlRulestatements.filter[s | s instanceof Declaration].size>4)
			}
		}) }
	
	@Test def test_createInternalBindingAssignments_sample2() { __generate('input/canonical_generation/sample2.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head()
				Assert.assertTrue((sa.control.rule as CustomControlRule).controlRulestatements.filter[s | s instanceof Assignment].size>4)
			}
		}) }
	
	@Test def test_ReplacePortRefs_sample1() { __generate('input/canonical_generation/sample1.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(noPortRefsLeft_LHS(sa))
			}
		}) }
	
	@Test def test_ReplacePortRefs_windowsa() { __generate('input/power_window_case_study/window_sa.BASE.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				Assert.assertTrue(noPortRefsLeft_LHS(sa))
				val tauAssignment = ((sa.out.rules.head.outputfunction as CompositeOutputFunction).statements.get(1) as Assignment)
				Assert.assertFalse(((tauAssignment.expr as Neg).right as Variable).ref instanceof Port)
			}
		}) }
	
	def noPortRefsLeft_LHS(Adaptation sa){
		return sa.in.rules.forall[dr | 
					(dr.outputfunction as CompositeOutputFunction).statements.filter[s | s instanceof Assignment].forall[ s |
						(s as Assignment).expr.eAllContents.filter[v | v instanceof Variable].forall[ v |
							! ((v as Variable).ref instanceof Port)
						]
					]
				] &&
				(sa.control.rule as CustomControlRule).controlRulestatements.filter[s | s instanceof Assignment].forall[ s |
					(s as Assignment).expr.eAllContents.filter[v | v instanceof Variable].forall[ v |
						! ((v as Variable).ref instanceof Port)
					]
				] && 
				sa.out.rules.forall[dr | 
					(dr.outputfunction as CompositeOutputFunction).statements.filter[s | s instanceof Assignment].forall[ s |
						(s as Assignment).expr.eAllContents.filter[v | v instanceof Variable].forall[ v |
							! ((v as Variable).ref instanceof Port)
						]
					]
				]
	}
	
	@Test def test_ReplacePortRefs_sample2() { __generate('input/canonical_generation/sample2.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) {
				var Adaptation sa = t.resourceSet.resources.head.allContents.toIterable.filter(SemanticAdaptation).last.elements.filter(Adaptation).head
				noPortRefsLeft_LHS(sa)
			}
		}) }
	
	@Test def window_SA_parseNoExceptions() { __generate('input/power_window_case_study/window_sa.BASE.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) { }
		}) }
	
	@Test def window_SA_parseNoExceptions2() { __generate('input/power_window_case_study/window_sa_comp_units.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) { }
		}) }
	
	@Test def lazy_SA_parseNoExceptions() { __generate('input/power_window_case_study/lazy.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) { }
		}) }
	
	@Ignore
		@Test def rate_SA_parseNoExceptions() { __generate('input/power_window_case_study/rate.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) { }
		}) }
		
	@Ignore
	@Test def power_base_SA_parseNoExceptions() { __generate('input/power_window_case_study/power.BASE.sa', new IAcceptor<CompilationTestHelper.Result>(){
			override accept(Result t) { }
		}) }
	
	def void __generate(String filename, IAcceptor<CompilationTestHelper.Result> acceptor) {
		//readFile(filename).assertCompilesTo('oracles/power_window_case_study/lazy.BASE.sa')
		
		val adaptation = readFile(filename).parse
		val fileUri = URI.createFileURI(filename)
		val fsa = new InMemoryFileSystemAccess();
		val generator = new SemanticAdaptationCanonicalGenerator();
		
		generator.doGenerate(adaptation.elements.filter(Adaptation).head, fsa, fileUri);
	}
}