/*******************************************************************************
 * Copyright (c) 2009, 2018 SAP AG and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *     SAP AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.ocl.examples.impactanalyzer.tests.instanceScope;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.ECrossReferenceAdapter;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.ocl.ecore.ExpressionInOCL;
import org.eclipse.ocl.ecore.OCLExpression;
import org.eclipse.ocl.examples.impactanalyzer.ImpactAnalyzerFactory;
import org.eclipse.ocl.examples.impactanalyzer.benchmark.preparation.notifications.NotificationHelper;
import org.eclipse.ocl.examples.impactanalyzer.configuration.OptimizationActivation;
import org.eclipse.ocl.examples.impactanalyzer.testutils.BaseDepartmentTestWithOCL;
import org.eclipse.ocl.examples.impactanalyzer.util.OCLFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import company.Company;
import company.CompanyFactory;
import company.Department;
import company.Division;
import company.Employee;
import company.Freelance;
import company.Student;
import junit.framework.AssertionFailedError;


/**
 * Tests whether the right context instances are computed. This is done as follows: A simple instance of the company model is
 * created. Each test tests only one statement. The statement is analyzed and a set of relevant events is generated and reported
 * to IA. The IA compute the affected context instances with the help of the InstanceScopeAnalysis. This set is then compared to a
 * set of expected context instances.
 *
 */
public class RevPathComputationTest extends BaseDepartmentTestWithOCL {

	private Division div;
	private Department dep1;
	private Department dep2;
	private Employee e1;
	private Freelance e2;
	private Employee e3;
	private Freelance e4;
	private Employee boss1;
	private Employee boss2;
	private Employee director;
	private Employee secretary;
	private Student stud1;
	private Student stud2;
	private Company company;

	@Override
	@Before
	public void setUp() {

		super.setUp();
		createInstances();
	}

	@Override
	@After
	public void tearDown() {
		EcoreUtil.delete(this.div);
		EcoreUtil.delete(this.dep1);
		EcoreUtil.delete(this.dep2);
		EcoreUtil.delete(this.e1);
		EcoreUtil.delete(this.e2);
		EcoreUtil.delete(this.e3);
		EcoreUtil.delete(this.e4);
		EcoreUtil.delete(this.boss1);
		EcoreUtil.delete(this.boss2);
		EcoreUtil.delete(this.director);
		EcoreUtil.delete(this.secretary);
		EcoreUtil.delete(this.stud1);
		EcoreUtil.delete(this.stud2);
		super.tearDown();
	}

	@Test
	public void testAnalysisOfASimpleRecursiveOperation() {
		// construct something like "new HumbaClass1().m()"
		final Department d1 = CompanyFactory.eINSTANCE.createDepartment();
		d1.setName("d1");
		d1.setBudget(10000);
		final Department d2 = CompanyFactory.eINSTANCE.createDepartment();
		d2.setName("d2");
		d2.setBudget(10000);
		final Department d3 = CompanyFactory.eINSTANCE.createDepartment();
		d3.setName("d3");
		d3.setBudget(10000);
		final Department d4 = CompanyFactory.eINSTANCE.createDepartment();
		d4.setName("d4");
		d4.setBudget(10000);
		d1.getSubDepartment().add(d2);
		d2.getSubDepartment().add(d3);
		d2.getSubDepartment().add(d4);
		this.comp.eResource().getContents().add(d1);
		Notification noti = NotificationHelper.createAttributeChangeNotification(d4, departmentBudget,
				d4.getBudget(), d4.getBudget()+1000);
		Collection<EObject> instances = computeAffectedInstances(this.getSumBudgetLimitAST(), noti);
		compareInstances(instances, new EObject[] { d1, d2, d4 });
	}

	@Test
	public void testBossHighestSalaryEmployeeSalaryChange() {

		// context Department inv BossHighestSalary:
		// self.employee->select(
		// e|e.salary >= self.boss.salary)->size() <= 1
		debugPrintln("Testing BossHighestSalaryEmployeeSalaryChange\n");
		Notification noti;
		// change salary of an employee
		noti = NotificationHelper.createAttributeChangeNotification(this.e1, this.employeeSalary, this.e1.getSalary(),
				this.e1.getSalary()+1);
		Collection<EObject> instances = computeAffectedInstances(this.getBossHighestSalaryAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });
	}

	@Test
	public void testBossHighestSalaryBossSalaryChange() {

		// context Department inv BossHighestSalary:
		// self.employee->select(
		// e|e.salary >= self.boss.salary)->size() <= 1
		debugPrintln("Testing BossHighestSalaryBossSalaryChange\n");
		Notification noti;

		Collection<EObject> instances;

		// change salary of the boss
		noti = NotificationHelper.createAttributeChangeNotification(this.boss1, this.employeeSalary, this.boss1
				.getSalary(), this.boss1.getSalary()+1);
		instances = computeAffectedInstances(this.getBossHighestSalaryAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });

	}

	@Test
	public void testBossHighestSalaryAddEmployee() {

		// context Department inv BossHighestSalary:
		// self.employee->select(
		// e|e.salary >= self.boss.salary)->size() <= 1
		debugPrintln("Testing BossHighestSalaryAddEmployee\n");
		Notification noti;

		Collection<EObject> instances;
		// add new employee
		noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.employeeRef, CompanyFactory.eINSTANCE
				.createEmployee());
		instances = computeAffectedInstances(this.getBossHighestSalaryAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });
	}

	@Test
	public void testBossHighestSalaryAddBoss() {

		// context Department inv BossHighestSalary:
		// self.employee->select(
		// e|e.salary >= self.boss.salary)->size() <= 1
		debugPrintln("Testing BossHighestSalaryAddBoss\n");
		Notification noti;

		Collection<EObject> instances;

		// add new boss
		noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.bossRef, this.boss2);
		instances = computeAffectedInstances(this.getBossHighestSalaryAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });
		debugPrintln("--------------------------------------------------\n");
	}

	@Test
	public void testBossIsOldestEmployeeAgeChange() {

		// context Employee inv BossIsOldest:
		// self.age <= self.employer.boss.age
		debugPrintln("Testing BossIsOldestEmployeeAgeChange\n");
		Collection<EObject> instances;
		Notification noti;

		// change age of an employee
		noti = NotificationHelper.createAttributeChangeNotification(this.e2, this.employeeAge, this.e2.getAge(),
				this.e2.getAge()+1);
		instances = computeAffectedInstances(this.getBossIsOldestAST(), noti);
		compareInstances(instances, new EObject[] { this.e2 });
	}

	@Test
	public void testBossIsOldestBossAgeChange() {

		// context Employee inv BossIsOldest:
		// self.age <= self.employer.boss.age
		debugPrintln("Testing BossIsOldestBossAgeChange\n");
		Collection<EObject> instances;
		Notification noti;

		// change age of the boss
		noti = NotificationHelper.createAttributeChangeNotification(this.boss1, this.employeeAge, this.boss1.getAge(),
				this.boss1.getAge()+1);
		instances = computeAffectedInstances(this.getBossIsOldestAST(), noti);
		compareInstances(instances, new EObject[] { this.e1, this.e2, this.boss1, this.stud1 });

	}

	@Test
	public void testBossIsOldestAddEmployee() {

		// context Employee inv BossIsOldest:
		// self.age <= self.employer.boss.age
		debugPrintln("Testing BossIsOldestAddEmployee\n");
		Set<EObject> expectedInstances = new HashSet<EObject>();
		expectedInstances.add(this.e2);

		Collection<EObject> instances;
		Notification noti;

		// add new employee
		noti = NotificationHelper.createReferenceAddNotification(this.e1, this.employerRef, this.dep2);
		instances = computeAffectedInstances(this.getBossIsOldestAST(), noti);
		compareInstances(instances, new EObject[] { this.e1 });

	}

	@Test
	public void testBossIsOldestAddBoss() {

		// context Employee inv BossIsOldest:
		// self.age <= self.employer.boss.age
		debugPrintln("Testing BossIsOldestAddBoss\n");
		Set<EObject> expectedInstances = new HashSet<EObject>();
		expectedInstances.add(this.e2);

		Collection<EObject> instances;
		Notification noti;

		// add new boss
		noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.bossRef, this.boss2);
		instances = computeAffectedInstances(this.getBossIsOldestAST(), noti);
		compareInstances(instances, new EObject[] { this.e1, this.e2, this.boss1, this.stud1 });

		debugPrintln("--------------------------------------------------\n");
	}

	@Test
	public void testNotBossFreelance() {

		// context Department
		// inv NotBossFreelance:
		// not self.boss.oclIsTypeOf(Freelance)
		debugPrintln("Testing NotBossFreelance\n");
		Notification noti = null;

		// add new boss
		noti = NotificationHelper.createReferenceAddNotification(this.dep2, this.bossRef, this.boss1);
		Collection<EObject> instances = computeAffectedInstances(this.getNotBossFreelanceAST(), noti);
		compareInstances(instances, new EObject[] { this.dep2 });
		debugPrintln("--------------------------------------------------\n");
	}

	@Test
	public void testOldEmployeeEmployeeAgeChange() {

		// context Department
		// inv OldEmployee:
		// self.employee->exists(e | e.age > 45)
		debugPrintln("Testing OldEmployeeEmployeeAgeChange\n");

		Notification noti;
		Collection<EObject> instances;
		// change age of an employee
		noti = NotificationHelper.createAttributeChangeNotification(this.e2, this.employeeAge, this.e2.getAge(),
				this.e2.getAge()+30);
		instances = computeAffectedInstances(this.getOldEmployeeAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });

	}

	@Test
	public void testOldEmployeeBossAgeChange() {

		// context Department
		// inv OldEmployee:
		// self.employee->exists(e | e.age > 45)
		debugPrintln("Testing OldEmployeeBossAgeChange\n");

		Notification noti;
		Collection<EObject> instances;
		// change age of the boss
		noti = NotificationHelper.createAttributeChangeNotification(this.boss1, this.employeeAge, this.boss1.getAge(),
				this.boss1.getAge()+30);
		instances = computeAffectedInstances(this.getOldEmployeeAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });
	}

	@Test
	public void testOldEmployeeAddEmployee() {

		// context Department
		// inv OldEmployee:
		// self.employee->exists(e | e.age > 45)
		debugPrintln("Testing OldEmployeeAddEmployee\n");

		Notification noti;
		Collection<EObject> instances;

		Employee newEmployee = CompanyFactory.eINSTANCE.createEmployee();
		newEmployee.setAge(46);
		// add new employee
		noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.employeeRef, newEmployee);
		instances = computeAffectedInstances(this.getOldEmployeeAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });
		debugPrintln("--------------------------------------------------\n");
	}

	@Test
	public void testUniqueNamesEmployeeNameChange() {

		// context Employee
		// inv UniqueNames:
		// Employee.allInstances()->forAll(e |
		// e <> self implies e.name <> self.name)
		debugPrintln("Testing UniqueNamesEmployeeNameChange\n");

		// change name of an employee
		// this does not trigger the allInstances change handling
		Notification noti = NotificationHelper.createAttributeChangeNotification(this.e2, this.employeeName, this.e2.getName(),
				this.e2.getName()+"Humba");

		Collection<EObject> instances = computeAffectedInstances(this.getUniqueNamesAST(), noti);
		compareInstances(instances, new EObject[] { this.e1, this.e2, this.e3, this.e4, this.boss1, this.boss2, this.director,
				this.secretary, this.stud1, this.stud2 });
	}

	@Test
	public void testUniqueNamesEmployeeAdd() {

		// context Employee
		// inv UniqueNames:
		// Employee.allInstances()->forAll(e |
		// e <> self implies e.name <> self.name)
		debugPrintln("Testing UniqueNamesEmployeeAdd\n");

		// add a new employee
		Employee newEmployee = CompanyFactory.eINSTANCE.createEmployee();
		Notification noti = NotificationHelper.createElementAddNotification( rs.getResources().iterator().next(), null, newEmployee);

		Collection<EObject> instances = computeAffectedInstances(this.getUniqueNamesAST(), noti);
		compareInstances(instances, new EObject[] { this.e1, this.e2, this.e3, this.e4, this.boss1, this.boss2, this.director,
				this.secretary, this.stud1, this.stud2, newEmployee });
		// remove the added employee to prevent him from appearing in other test cases
		EcoreUtil.delete(newEmployee);
	}

	@Test
	public void testUniqueNamesEmployeeRemove() {
		// context Employee
		// inv UniqueNames:
		// Employee.allInstances()->forAll(e |
		// e <> self implies e.name <> self.name)
		debugPrintln("Testing UniqueNamesEmployeeRemove\n");
		// remove an employee
		Notification noti = NotificationHelper.createElementDeleteNotification( this.e1 );
		Collection<EObject> instances = computeAffectedInstances(this.getUniqueNamesAST(), noti);
		compareInstances(instances, new EObject[] { this.e2, this.e3, this.e4, this.boss1, this.boss2, this.director,
				this.secretary, this.stud1, this.stud2});

		debugPrintln("--------------------------------------------------\n");
	}

	@Test
	public void testValidAssignment() {

		// context Freelance
		// inv ValidAssignment:
		// self.assignment >= 5 and self.assignment <= 30
		debugPrintln("Testing ValidAssignment\n");

		// change age of an employee far enough
		Notification noti = NotificationHelper.createAttributeChangeNotification(this.e4, this.freelanceAssignment,
				this.e4.getAssignment(), 31);
		Collection<EObject> instances = computeAffectedInstances(this.getValidAssignmentAST(), noti);
		compareInstances(instances, new EObject[] { this.e4 });

		// change age of an employee not far enough
		Notification noti2 = NotificationHelper.createAttributeChangeNotification(this.e4, this.freelanceAssignment,
				this.e4.getAssignment(), 29);
		Collection<EObject> instances2 = computeAffectedInstances(this.getValidAssignmentAST(), noti2);
		compareInstances(instances2, new EObject[] { });
		debugPrintln("--------------------------------------------------\n");

	}

	@Test
	public void testMaxJuniorsEmployeeAgeChange() {

		// context Department inv MaxJuniors:
		// self.employee->select(e|e.age < 25)->size() < self.maxJuniors
		debugPrintln("Testing MaxJuniorsEmployeeAgeChange\n");
		Notification noti;
		Collection<EObject> instances;
		// change age of an employee so that it now falls under 25
		noti = NotificationHelper.createAttributeChangeNotification(this.e2, this.employeeAge, this.e2.getAge(),
				23);
		instances = computeAffectedInstances(this.getMaxJuniorsAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });

		// change age of an employee so that it does not fall under 25
		noti = NotificationHelper.createAttributeChangeNotification(this.e2, this.employeeAge, this.e2.getAge(),
				this.e2.getAge()+1);
		instances = computeAffectedInstances(this.getMaxJuniorsAST(), noti);
		compareInstances(instances, new EObject[] { });
	}

	@Test
	public void testMaxJuniorsDepartmentMaxJuniorsChange() {

		// context Department inv MaxJuniors:
		// self.employee->select(e|e.age < 25)->size() < self.maxJuniors
		debugPrintln("Testing MaxJuniorsDepartmentMaxJuniorsChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change maxJuniors of a Department
		noti = NotificationHelper.createAttributeChangeNotification(this.dep1, this.departmentMaxJuniors, this.dep1
				.getMaxJuniors(), this.dep1.getMaxJuniors()+1);
		instances = computeAffectedInstances(this.getMaxJuniorsAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });

	}

	@Test
	public void testMaxJuniorsAddEmployee() {

		// context Department inv MaxJuniors:
		// self.employee->select(e|e.age < 25)->size() < self.maxJuniors
		debugPrintln("Testing MaxJuniorsAddEmployee\n");
		Notification noti;
		Collection<EObject> instances;

		// add new employee
		noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.employeeRef, CompanyFactory.eINSTANCE
				.createEmployee());
		instances = computeAffectedInstances(this.getMaxJuniorsAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });

		debugPrintln("--------------------------------------------------\n");

	}

	@Test
	public void testNastyConstraintAddDepartment() {

		// context Division
		// inv nasty:
		// self.department->collect(d|
		// d.employee->including(d.boss)).salary->sum() < budget";
		debugPrintln("Testing nastyAddDepartment\n");

		Notification noti;
		Collection<EObject> instances;

		// add new department
		noti = NotificationHelper.createReferenceAddNotification(this.div, this.departmentRef, CompanyFactory.eINSTANCE
				.createDepartment());
		instances = computeAffectedInstances(this.getNastyConstraintAST(), noti);
		compareInstances(instances, new EObject[] { this.div });

	}

	@Test
	public void testNastyConstraintAddEmployee() {

		// context Division
		// inv nasty:
		// self.department->collect(d|
		// d.employee->including(d.boss)).salary->sum() < budget";
		debugPrintln("Testing nastyAddEmployee\n");

		Notification noti;
		Collection<EObject> instances;

		// add new employee
		noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.employeeRef, CompanyFactory.eINSTANCE
				.createEmployee());
		instances = computeAffectedInstances(this.getNastyConstraintAST(), noti);
		compareInstances(instances, new EObject[] { this.div });

	}

	@Test
	public void testNastyConstraintAddBoss() {

		// context Division
		// inv nasty:
		// self.department->collect(d|
		// d.employee->including(d.boss)).salary->sum() < budget";
		debugPrintln("Testing nastyAddBoss\n");
		Notification noti;
		Collection<EObject> instances;

		// add new boss
		noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.bossRef, this.boss2);
		instances = computeAffectedInstances(this.getNastyConstraintAST(), noti);
		compareInstances(instances, new EObject[] { this.div });

	}

	@Test
	public void testNastyConstraintEmployeeSalaryChange() {

		// context Division
		// inv nasty:
		// self.department->collect(d|
		// d.employee->including(d.boss)).salary->sum() < budget";
		debugPrintln("Testing nastyEmployeeSalaryChange\n");

		Notification noti;
		Collection<EObject> instances;

		// change salary of an employee
		noti = NotificationHelper.createAttributeChangeNotification(this.e1, this.employeeSalary, this.e1.getSalary(),
				this.e1.getSalary()+1);
		instances = computeAffectedInstances(this.getNastyConstraintAST(), noti);
		compareInstances(instances, new EObject[] { this.div });

	}

	@Test
	public void testNastyConstraintBossSalaryChange() {

		// context Division
		// inv nasty:
		// self.department->collect(d|
		// d.employee->including(d.boss)).salary->sum() < budget";
		debugPrintln("Testing nastyBossSalaryChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change salary of the boss
		noti = NotificationHelper.createAttributeChangeNotification(this.boss1, this.employeeSalary, this.boss1
				.getSalary(), this.boss1.getSalary()+1);
		instances = computeAffectedInstances(this.getNastyConstraintAST(), noti);
		compareInstances(instances, new EObject[] { this.div });

	}

	@Test
	public void testNastyConstraintDivisionBudgetChange() {

		// context Division
		// inv nasty:
		// self.department->collect(d|
		// d.employee->including(d.boss)).salary->sum() < budget";
		debugPrintln("Testing nastyDivisionBudgetChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change budget of the division
		noti = NotificationHelper.createAttributeChangeNotification(this.div, this.divisionBudget,
				this.div.getBudget(), this.div.getBudget()+1);
		instances = computeAffectedInstances(this.getNastyConstraintAST(), noti);
		compareInstances(instances, new EObject[] { this.div });

		debugPrintln("--------------------------------------------------\n");
	}

	@Test
	public void testSecretaryOlderThanBossAddDirector() {

		// context Employee \n"
		// inv secretaryOlderThanBoss: \n"
		// if self.directed->notEmpty() and \n"
		// not self.secretary.oclIsUndefined() then \n"
		// self.age < self.secretary.age \n"
		// else true \n"
		// endif";
		debugPrintln("Testing secretaryOlderThanBossAddDirector\n");
		Notification noti;
		Collection<EObject> instances;

		// add new director
		noti = NotificationHelper.createReferenceAddNotification(this.director, this.directedRef, CompanyFactory.eINSTANCE.createDivision());
		instances = computeAffectedInstances(this.getSecretaryOlderThanBossAST(), noti);
		compareInstances(instances, new EObject[] { this.director });
	}

	@Test
	public void testSecretaryOlderThanBossRemoveDirector() {

		// context Employee \n"
		// inv secretaryOlderThanBoss: \n"
		// if self.directed->notEmpty() and \n"
		// not self.secretary.oclIsUndefined() then \n"
		// self.age < self.secretary.age \n"
		// else true \n"
		// endif";
		debugPrintln("Testing secretaryOlderThanBossRemoveDirector\n");
		Notification noti;
		Collection<EObject> instances;

		// remove director
		noti = NotificationHelper.createReferenceRemoveNotification(this.director, this.directedRef, this.div);
		instances = computeAffectedInstances(this.getSecretaryOlderThanBossAST(), noti);
		compareInstances(instances, new EObject[] { this.director });

	}

	@Test
	public void testSecretaryOlderThanBossDirectorSecretaryChange() {

		// context Employee \n"
		// inv secretaryOlderThanBoss: \n"
		// if self.directed->notEmpty() and \n"
		// not self.secretary.oclIsUndefined() then \n"
		// self.age < self.secretary.age \n"
		// else true \n"
		// endif";
		debugPrintln("Testing secretaryOlderThanBossDirectorSecretaryChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change secretary of the director
		Employee newEmployee = CompanyFactory.eINSTANCE.createEmployee();
		noti = NotificationHelper.createReferenceChangeNotification(this.director, this.employeeSecretary, this.director
				.getSecretary(), newEmployee);
		instances = computeAffectedInstances(this.getSecretaryOlderThanBossAST(), noti);
		compareInstances(instances, new EObject[] { this.director });

	}

	@Test
	public void testSecretaryOlderThanBossSecretaryAgeChange() {

		// context Employee \n"
		// inv secretaryOlderThanBoss: \n"
		// if self.directed->notEmpty() and \n"
		// not self.secretary.oclIsUndefined() then \n"
		// self.age < self.secretary.age \n"
		// else true \n"
		// endif";
		debugPrintln("Testing secretaryOlderThanBossSecretaryAgeChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change age of secretary
		noti = NotificationHelper.createAttributeChangeNotification(this.secretary, this.employeeAge, this.secretary
				.getAge(), this.secretary.getAge()+1);
		instances = computeAffectedInstances(this.getSecretaryOlderThanBossAST(), noti);
		if (OptimizationActivation.getOption().isUnusedDetectionActive()) {
			compareInstances(instances, new EObject[] {} ); // change is in unused if-branch
		} else {
			compareInstances(instances, new EObject[] { this.director, this.secretary });
		}
	}

	@Test
	public void testSecretaryOlderThanBossDirectorAgeChange() {

		// context Employee \n"
		// inv secretaryOlderThanBoss: \n"
		// if self.directed->notEmpty() and \n"
		// not self.secretary.oclIsUndefined() then \n"
		// self.age < self.secretary.age \n"
		// else true \n"
		// endif";
		debugPrintln("Testing secretaryOlderThanBossDirectorAgeChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change age of director
		noti = NotificationHelper.createAttributeChangeNotification(this.director, this.employeeAge, this.director
				.getAge(), this.director.getAge()+1);
		instances = computeAffectedInstances(this.getSecretaryOlderThanBossAST(), noti);
		compareInstances(instances, new EObject[] { this.director });

		debugPrintln("--------------------------------------------------\n");
	}

	@Test
	public void testBoss10YearsOlderThanJuniorEmployeeAgeChange() {

		// context Department \n"
		// inv boss10YearsOlderThanJunior: \n"
		// let t:Tuple(boss:Employee,junior:Employee)="
		// Tuple{boss=self.boss, junior=self.employee->sortedBy(age)->first()} in \n"
		// t.boss.age > t.junior.age + 10";
		debugPrintln("Testing boss10YearsOlderThanJuniorEmployeeAgeChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change age of employee
		noti = NotificationHelper.createAttributeChangeNotification(this.e1, this.employeeAge, 42, 1);
		instances = computeAffectedInstances(this.getBoss10YearsOlderThanJuniorAST(), noti);
		compareInstances(instances, new EObject[] { this.e1.getEmployer() });
	}

	@Test
	public void testBoss10YearsOlderThanJuniorBossAgeChange() {

		// context Department \n"
		// inv boss10YearsOlderThanJunior: \n"
		// let t:Tuple(boss:Employee,junior:Employee)="
		// Tuple{boss=self.boss, junior=self.employee->sortedBy(age)->first()} in \n"
		// t.boss.age > t.junior.age + 10";
		debugPrintln("Testing boss10YearsOlderThanJuniorBossAgeChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change age of boss
		noti = NotificationHelper.createAttributeChangeNotification(this.boss1, this.employeeAge, 42, 52);
		instances = computeAffectedInstances(this.getBoss10YearsOlderThanJuniorAST(), noti);
		compareInstances(instances, new EObject[] { this.e1.getEmployer() });

		debugPrintln("--------------------------------------------------\n");
	}

	@Test
	public void testCompareBossSalaryToJuniorSalaryBossChange() {
		// context Department \n"
		// inv compareBossSalaryToJuniorSalary: \n"
		// let t:Tuple(boss:Tuple(person:Employee, salary:Integer), junior:Tuple(person:Employee, salary:Integer))="
		// Tuple{Tuple{self.boss, self.boss.salary}, Tuple{self.employee->sortedBy(age)->first(),
		// self.employee->sortedBy(age)->first().salary}} in \n"
		// t.boss.person <> t.junior.person implies t.boss.salary > t.junior.salary + 100";
		debugPrintln("Testing compareBossSalaryToJuniorSalaryBossChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change boss of department
		noti = NotificationHelper.createReferenceChangeNotification(this.dep1, this.bossRef, CompanyFactory.eINSTANCE
				.createEmployee(), this.e1);
		instances = computeAffectedInstances(this.getCompareBossSalaryToJuniorSalaryAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });
	}

	@Test
	public void testCompareBossSalaryToJuniorSalaryEmployeeSalaryChange() {
		// context Department \n"
		// inv compareBossSalaryToJuniorSalary: \n"
		// let t:Tuple(boss:Tuple(person:Employee, salary:Integer), junior:Tuple(person:Employee, salary:Integer))="
		// Tuple{Tuple{self.boss, self.boss.salary}, Tuple{self.employee->sortedBy(age)->first(),
		// self.employee->sortedBy(age)->first().salary}} in \n"
		// t.boss.person <> t.junior.person implies t.boss.salary > t.junior.salary + 100";
		debugPrintln("Testing compareBossSalaryToJuniorSalaryEmployeeSalaryChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change salary of employee
		noti = NotificationHelper
				.createAttributeChangeNotification(this.e1, this.employeeSalary, 1234, 12345);
		instances = computeAffectedInstances(this.getCompareBossSalaryToJuniorSalaryAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });
	}

	@Test
	public void testCompareBossSalaryToJuniorSalaryEmployeeAgeChange() {
		// context Department \n"
		// inv compareBossSalaryToJuniorSalary: \n"
		// let t:Tuple(boss:Tuple(person:Employee, salary:Integer), junior:Tuple(person:Employee, salary:Integer))="
		// Tuple{Tuple{self.boss, self.boss.salary}, Tuple{self.employee->sortedBy(age)->first(),
		// self.employee->sortedBy(age)->first().salary}} in \n"
		// t.boss.person <> t.junior.person implies t.boss.salary > t.junior.salary + 100";
		debugPrintln("Testing compareBossSalaryToJuniorSalaryEmployeeAgeChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change age of employee
		noti = NotificationHelper.createAttributeChangeNotification(this.e1, this.employeeAge, 23, 34);
		instances = computeAffectedInstances(this.getCompareBossSalaryToJuniorSalaryAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });
	}

	@Test
	public void testCompareBossSalaryToJuniorSalaryEmployeeAdd() {
		// context Department \n"
		// inv compareBossSalaryToJuniorSalary: \n"
		// let t:Tuple(boss:Tuple(person:Employee, salary:Integer), junior:Tuple(person:Employee, salary:Integer))="
		// Tuple{Tuple{self.boss, self.boss.salary}, Tuple{self.employee->sortedBy(age)->first(),
		// self.employee->sortedBy(age)->first().salary}} in \n"
		// t.boss.person <> t.junior.person implies t.boss.salary > t.junior.salary + 100";
		debugPrintln("Testing compareBossSalaryToJuniorSalaryEmployeeAdd\n");
		Notification noti;
		Collection<EObject> instances;

		// add new employee
		noti = NotificationHelper.createReferenceChangeNotification(this.dep1, this.employeeRef, null, this.e3);
		instances = computeAffectedInstances(this.getCompareBossSalaryToJuniorSalaryAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });
	}

	@Test
	public void testCompareBossSalaryToJuniorSalaryEmployeeRemove() {
		// context Department \n"
		// inv compareBossSalaryToJuniorSalary: \n"
		// let t:Tuple(boss:Tuple(person:Employee, salary:Integer), junior:Tuple(person:Employee, salary:Integer))="
		// Tuple{Tuple{self.boss, self.boss.salary}, Tuple{self.employee->sortedBy(age)->first(),
		// self.employee->sortedBy(age)->first().salary}} in \n"
		// t.boss.person <> t.junior.person implies t.boss.salary > t.junior.salary + 100";
		debugPrintln("Testing compareBossSalaryToJuniorSalaryEmployeeRemove\n");
		Notification noti;
		Collection<EObject> instances;

		// remove employee
		noti = NotificationHelper.createReferenceChangeNotification(this.dep1, this.employeeRef, this.e1, null);
		instances = computeAffectedInstances(this.getCompareBossSalaryToJuniorSalaryAST(), noti);
		compareInstances(instances, new EObject[] { this.dep1 });

		debugPrintln("--------------------------------------------------\n");

	}

	@Test
	public void testEmployeeInSameDepartmentAsInternEmployeeAdd() {
		// context Employee \n"
		// inv employeeInSameDepartmentAsIntern: \n"
		// self.employer = self.intern.employer";

		debugPrintln("Testing employeeInSameDepartmentAsInternEmployeeAdd\n");
		// add Employee
		final Employee newEmployee = CompanyFactory.eINSTANCE.createEmployee();
		final boolean[] result = new boolean[1];
		newEmployee.setIntern(this.stud2);
		newEmployee.eAdapters().add(new AdapterImpl() {
			@Override
			public void notifyChanged(Notification notification) {
				Collection<EObject> instances = computeAffectedInstances(getEmployeeInSameDepartmentAsInternAST(), notification);
				try {
					compareInstances(instances, new EObject[] { newEmployee });
					result[0] = true;
				} catch (AssertionFailedError e) {
					result[0] = false;
				}
			}
		});
		this.dep1.getEmployee().add(newEmployee);
		assertTrue(result[0]);
		// this notification is actually an ElementLifeCycleEvent which is not handled correctly atm
		// noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.employeeRef, newEmployee);
	}

	@Test
	public void testEmployeeInSameDepartmentAsInternEmployeeInternChange() {
		// context Employee \n"
		// inv employeeInSameDepartmentAsIntern: \n"
		// self.employer = self.intern.employer";

		debugPrintln("Testing employeeInSameDepartmentAsInternEmployeeInternChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change intern reference
		Student newStudent = CompanyFactory.eINSTANCE.createStudent();
		newStudent.setEmployer(dep2);
		noti = NotificationHelper.createReferenceChangeNotification(this.e1, this.internRef, this.stud1, newStudent);
		instances = computeAffectedInstances(this.getEmployeeInSameDepartmentAsInternAST(), noti);
		compareInstances(instances, new EObject[] { this.e1 });

	}

	@Test
	public void testEmployeeInSameDepartmentAsInternEmployeeEmployerChange() {
		// context Employee \n"
		// inv employeeInSameDepartmentAsIntern: \n"
		// self.employer = self.intern.employer";

		debugPrintln("Testing employeeInSameDepartmentAsInternEmployeeEmployerChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change employer reference
		noti = NotificationHelper.createReferenceChangeNotification(this.e1, this.employerRef, this.dep1, this.dep2);
		instances = computeAffectedInstances(this.getEmployeeInSameDepartmentAsInternAST(), noti);
		compareInstances(instances, new EObject[] { this.e1 });

	}

	@Test
	public void testEmployeeInSameDepartmentAsInternStudentEmployerChange() {
		// context Employee \n"
		// inv employeeInSameDepartmentAsIntern: \n"
		// self.employer = self.intern.employer";

		debugPrintln("Testing employeeInSameDepartmentAsInternStudentEmployerChange\n");
		Notification noti;
		Collection<EObject> instances;

		// change employer reference
		noti = NotificationHelper.createReferenceChangeNotification(this.stud1, this.employerRef, this.dep1, this.dep2);
		instances = computeAffectedInstances(this.getEmployeeInSameDepartmentAsInternAST(), noti);
		// since student is a subclass of employee (and therefore could have own interns), the impact of the above change also
		// includes stud1
		compareInstances(instances, new EObject[] { this.e1, this.stud1 });

		debugPrintln("--------------------------------------------------\n");

	}

	@Test
	public void testCheckForBob() {

		debugPrintln("Testing checkForBob\n");
		Notification noti;
		Collection<EObject> instances;

		// change employee name
		noti = NotificationHelper.createAttributeChangeNotification(this.e1, this.employeeName, "e1", "Bob");
		instances = computeAffectedInstances(this.getCheckForBobAST(), noti);
		compareInstances(instances, new EObject[] { this.e1 , this.e2, this.e3, this.e4, this.secretary, this.boss1, this.boss2, this.director, this.stud1, this.stud2});

		debugPrintln("--------------------------------------------------\n");

	}

	@Test
	public void testDerivedPropertyHandlingIndirect(){
		debugPrintln("Testing derivedPropertyHandling\n");
		Notification noti;
		Collection<EObject> instances;

		// Make e1 the employee of the month of div by making him the employee of the month of dep1.
		// That should influence the derived property Department.employeesOfTheMonth but this feature isn't implemented by default.
		noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.departmentEmployeeOfTheMonth, this.e1);
		instances = computeAffectedInstances(this.getLimitEmployeesOfTheMonthAST(), noti);
		compareInstances(instances, new EObject[] {this.div});
	}

	@Test
	public void testDerivedPropertyHandlingDirect() {
		Notification noti;

		// Make e1 the employee of the month of div by directly manipulating the derived property.
		// Since the derived property is unmodifiable, this should return null.
		debugPrintln("The following warning is intended.");
		noti = NotificationHelper.createReferenceAddNotification(this.div, this.divisionEmployeesOfTheMonth, this.e1);
		assertTrue(noti == null);
	}

	@Test
	public void testNestedDerivation() {
		Notification noti;
		Collection<EObject> instances;

		// Make e1 the employee of the month of div by making him the employee of the month of dep1.
		// That should influence the derived property Department.employeesOfTheMonth but this feature isn't implemented by default.
		noti = NotificationHelper.createReferenceAddNotification(this.dep1, this.departmentEmployeeOfTheMonth, this.e1);
		instances = computeAffectedInstances(this.getNestedDerivationAST(), noti);
		compareInstances(instances, new EObject[] {this.div});
	}

	@Test
	public void testNonLinearDerivationPositive() {
		Notification noti;
		Collection<EObject> instances;

		//Use a derived property with a derivation expression that contains a branch (Department.biggestNumberOfStudentsOrFreelancers)
		//and see if a change in the unused branch causes an impact.
		//After the instance creation dep2 has 1 freelance.
		//We add another one which will influence the biggestNumberOfStudentsOrFreelancers attribute of dep2 since it has only 1 student.
		noti = NotificationHelper.createReferenceAddNotification(this.dep2, this.employeeRef, this.e2);
		instances = computeAffectedInstances(this.getNonLinearDerivationAST(), noti);
		compareInstances(instances, new EObject[] {this.dep2});
	}

	@Test
	public void testNonLinearDerivationNegative() {
		Notification noti;
		Collection<EObject> instances;

		//Use a derived property with a derivation expression that contains a branch (Department.biggestNumberOfStudentsOrFreelancers)
		//and see if a change in the unused branch causes an impact.
		//After the instance creation dep2 has 1 freelance.
		//We add two more and afterwards we add 1 student which will not influence the biggestNumberOfStudentsOrFreelancers
		//attribute of dep2 since it has more freelancers than students.
		e2.setEmployer(dep2);
		boss1.setEmployer(dep2);

		noti = NotificationHelper.createReferenceAddNotification(this.dep2, this.employeeRef, this.stud1);
		instances = computeAffectedInstances(this.getNonLinearDerivationAST(), noti);
		compareInstances(instances, new EObject[] {/*this.dep2 should not be in the impact since the derived property didn't and couldn't change but this can only be determined if unusedChecks are enabled*/});
		debugPrintln("Enable unusedChecks to get rid of this extra context instance.");
	}

	@Test
	public void testlongNavigationWithDerivation() {
		// derived property handling has so far only been implemented for the traceback-step approach
		if (OptimizationActivation.getOption().isTracebackStepISAActive()) {
			Notification noti;
			Collection<EObject> instances;

			// The tested constraint makes sure, the context of the constraint and of the derivation expression differ.
			// The constraints sorts all departments of all divisions of a company by their biggestNumberOfStudentsOrFreelancers
			// attribute and checks if the last one in the collection has less than 5 students and freelancers.
			// Dep2 initially has 2 freelancers, resulting in the highest value for the biggestNumberOfStudentsOrFreelancers attribute.
			// We add another freelancer to generate an impact for this constraint.

			noti = NotificationHelper.createReferenceAddNotification(this.dep2, this.employeeRef, this.e2);
			instances = computeAffectedInstances(this.getlongNavigationWithDerivationAST(), noti);
			compareInstances(instances, new EObject[] {this.company});

			debugPrintln("--------------------------------------------------\n");
		}
	}

	// @Test
	// public void testDepartmentAlwaysInDivision(){
	//
	// // context Department \n"
	// // inv departmentMustHaveDivision: \n"
	// // self.department2division->notEmpty()";
	// debugPrintln("Testing departmentAlwaysInDivision\n");
	// Set<OCLExpression> stmts = new HashSet<OCLExpression>();
	// stmts.add(this.getdepartmentMustHaveDivisionAST());
	//
	//
	//
	// Notification noti;
	// Collection<EObject> instances;
	//
	// // create new department
	// EObject newElem = this.comp.getEFactoryInstance().create(this.department);
	// noti = NotificationHelper.createNewElementAddToResourceNotification(newElem, rs.getResources().iterator().next());
	// instances = computeAffectedInstances(TODO, noti);
	// compareInstances( instances, new EObject[] { newElem } );
	// // add department to division
	// // remove department from division
	// }

	/**
	 * Creates an instance of the company model ie 2 instances of Department with e employees and one boss each.
	 */
	private void createInstances() {

		this.rs = new ResourceSetImpl();
		Resource r = this.rs.createResource(URI.createURI("http://rev/path/computation/test"));
		r.eAdapters().add(new ECrossReferenceAdapter());
		this.rs.getResources().add(r);

		this.company = CompanyFactory.eINSTANCE.createCompany();
		r.getContents().add(this.company);

		this.div = CompanyFactory.eINSTANCE.createDivision();
		this.div.setBudget(1234567);
		this.div.setName("Div1");
		this.div.setCompany(this.company);
		r.getContents().add(this.div);

		this.director = CompanyFactory.eINSTANCE.createEmployee();
		this.director.setAge(42);
		this.director.setName("Director");
		this.director.setDirected(this.div);
		this.director.setSalary(1234);
		this.div.setDirector(this.director);

		this.secretary = CompanyFactory.eINSTANCE.createEmployee();
		this.secretary.setAge(55);
		this.secretary.setName("Secretary");
		this.secretary.setSalary(1234);
		this.secretary.setEmployer(this.dep1);
		this.director.setSecretary(this.secretary);

		this.dep1 = CompanyFactory.eINSTANCE.createDepartment();
		this.dep1.setName("Dep1");
		this.dep1.setBudget(12345567);
		this.dep1.setMaxJuniors(5);
		this.e1 = CompanyFactory.eINSTANCE.createEmployee();
		this.e1.setAge(42);
		this.e1.setName("e1");
		this.e1.setEmployer(this.dep1);
		this.e1.setSalary(1234);
		this.e2 = CompanyFactory.eINSTANCE.createFreelance();
		this.e2.setAge(42);
		this.e2.setName("e2");
		this.e2.setAssignment(9);
		this.e2.setEmployer(this.dep1);
		this.e2.setSalary(1234);
		this.boss1 = CompanyFactory.eINSTANCE.createFreelance();
		this.boss1.setAge(43);
		this.boss1.setName("boss1");
		this.boss1.setEmployer(this.dep1);
		this.boss1.setManaged(this.dep1);
		this.boss1.setSalary(1234);
		this.dep1.setBoss(this.boss1);

		this.stud1 = CompanyFactory.eINSTANCE.createStudent();
		this.stud1.setAge(22);
		this.stud1.setName("stud1");
		this.stud1.setSalary(234);
		this.stud1.setEmployer(this.dep1);
		this.e1.setIntern(this.stud1);

		this.dep2 = CompanyFactory.eINSTANCE.createDepartment();
		this.dep2.setName("Dep2");
		this.dep2.setBudget(12345567);
		this.dep2.setMaxJuniors(5);

		this.e3 = CompanyFactory.eINSTANCE.createEmployee();
		this.e3.setAge(42);
		this.e3.setName("e3");
		this.e3.setEmployer(this.dep2);
		this.e3.setSalary(1234);
		this.e4 = CompanyFactory.eINSTANCE.createFreelance();
		this.e4.setAge(42);
		this.e4.setName("e4");
		this.e2.setAssignment(9);
		this.e4.setEmployer(this.dep2);
		this.e4.setSalary(1234);
		this.boss2 = CompanyFactory.eINSTANCE.createEmployee();
		this.boss2.setAge(44);
		this.boss2.setName("boss2");
		this.boss2.setEmployer(this.dep2);
		this.boss2.setManaged(this.dep2);
		this.boss2.setSalary(2345);
		this.dep2.setBoss(this.boss2);

		this.stud2 = CompanyFactory.eINSTANCE.createStudent();
		this.stud2.setAge(23);
		this.stud2.setName("stud2");
		this.stud2.setSalary(234);
		this.stud2.setEmployer(this.dep2);
		this.e3.setIntern(this.stud2);

		this.div.getDepartment().add(this.dep1);
		this.div.getDepartment().add(this.dep2);

	}

	/**
	 * Computes the set of affected context instances for event <tt>evt</tt>.
	 *
	 * @param expressions
	 *            list of the effected {@link OCLExpression}s
	 * @param noti
	 *            the event
	 * @param context
	 * @return a Collection of {@link EObject}s representing the affected context instances.
	 */
	private Collection<EObject> computeAffectedInstances(ExpressionInOCL eiocl, Notification noti) {
		return ImpactAnalyzerFactory.INSTANCE.createImpactAnalyzer((OCLExpression) eiocl.getBodyExpression(),
				(EClass) eiocl.getContextVariable().getType(), /* notifyOnNewContextElements */ false,
				OCLFactory.getInstance())
				.getContextObjects(noti);
	}

	/**
	 * @param instances
	 * @param expectedInstances
	 */
	private void compareInstances(Collection<EObject> instances, EObject[] expectedInstances) {
		Set<EObject> expected = new HashSet<EObject>();
		for (int i = 0; i < expectedInstances.length; i++) {
			expected.add(expectedInstances[i]);
		}
		if (instances.containsAll(expected) && instances.size() == expected.size()) {
			debugPrintln(">> SUCCESS exact match\n");
		} else if (instances.containsAll(expected) && instances.size() != expected.size()) {
			debugPrintln(">> SUCCESS \n excess context instances:\n");
			instances.removeAll(expected);
			for (Iterator<EObject> i = instances.iterator(); i.hasNext();) {
				debugPrintln(i.next() + "\n");
			}
		} else {
			debugPrintln(">> FAILURE\n");
			expected.removeAll(instances);
			for (EObject o : expected) {
				debugPrint(o + " not in result");
			}
			debugPrintln("");
			fail("Returned instances does not match expected instances!");
		}
	}

	// /**
	// * Unfortunately not all features can be tested with the department model
	// */
	// private void extendModel( ) {
	//
	// for some tests we need some additional classes
	// MofClass a = this.mofPackage.getModel().getMofClass().createMofClass();
	// a.setName("A");
	// MofClass b = this.mofPackage.getModel().getMofClass().createMofClass();
	// a.setName("B");
	// MofClass c = this.mofPackage.getModel().getMofClass().createMofClass();
	// a.setName("C");
	// MofClass d = this.mofPackage.getModel().getMofClass().createMofClass();
	// a.setName("D");
	// // B is a subtype of A
	// b.getSupertypes().add(a);
	// // D-B-Association
	// Association db = this.mofPackage.getModel().getAssociation().createAssociation();
	// db.setName("DB-Assocation");
	// AssociationEnd toB = this.mofPackage.getModel().getAssociationEnd().createAssociationEnd();
	// toB.setName("toB");
	// toB.setType(b);
	// toB.setMultiplicity(this.mofPackage.getModel().createMultiplicityType(0,-1,true,true));
	// db.getContents().add(toB);
	// AssociationEnd toD = this.mofPackage.getModel().getAssociationEnd().createAssociationEnd();
	// toB.setName("toD");
	// toB.setType(d);
	// toB.setMultiplicity(this.mofPackage.getModel().createMultiplicityType(0,-1,true,true));
	// db.getContents().add(toD);
	// // A-C-Association
	// Association ac = this.mofPackage.getModel().getAssociation().createAssociation();
	// ac.setName("DB-Assocation");
	// AssociationEnd toC = this.mofPackage.getModel().getAssociationEnd().createAssociationEnd();
	// toC.setName("toC");
	// toC.setType(c);
	// toC.setMultiplicity(this.mofPackage.getModel().createMultiplicityType(0,-1,true,true));
	// ac.getContents().add(toC);
	// AssociationEnd toA = this.mofPackage.getModel().getAssociationEnd().createAssociationEnd();
	// toA.setName("toA");
	// toA.setType(a);
	// toA.setMultiplicity(this.mofPackage.getModel().createMultiplicityType(0,-1,true,true));
	// ac.getContents().add(toA);
	// this.companyPackage.getContents().add(a);
	// this.companyPackage.getContents().add(b);
	// this.companyPackage.getContents().add(c);
	// this.companyPackage.getContents().add(d);
	// this.companyPackage.getContents().add(ac);
	// this.companyPackage.getContents().add(db);
	// }
}