/**
* Copyright 2011-2012 Universite Joseph Fourier, LIG, ADELE team
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package fr.imag.adele.apam.tests.helpers;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import fr.imag.adele.apam.CST;
import fr.imag.adele.apam.Component;
import fr.imag.adele.apam.Implementation;
import fr.imag.adele.apam.Instance;
import fr.imag.adele.apam.Link;
import fr.imag.adele.apam.Specification;
import fr.imag.adele.apam.declarations.AtomicImplementationDeclaration;
import fr.imag.adele.apam.declarations.ImplementationDeclaration;
/**
* Constains utility functions that are used by the test
*
* @author jander
*/
public abstract class TestUtils {
private boolean apamReady = false;
public static long waitPeriod = 200;
public static long RESOLVE_TIMEOUT = 3000;
protected void auxDisconectWires(Instance instance) {
for (Link wire : instance.getRawLinks()) {
wire.remove();
}
}
protected Instance auxListInstanceReferencedBy(Object instance) {
waitForApam();
return CST.componentBroker.getInstService(instance);
}
protected List<Instance> auxListInstanceReferencedBy(String prefix, Collection instances) {
waitForApam();
List<Instance> res = new ArrayList<Instance>();
for (Object instance : instances) {
Instance i = CST.componentBroker.getInstService(instance);
res.add(i);
System.out.println(String.format("%sInstance name %s ( oid: %s ) ",
prefix, i.getName(), i.getServiceObject()));
}
return res;
}
protected void auxListInstances() {
auxListInstances("\t");
}
protected void auxListInstances(String prefix) {
waitForApam();
System.out.println(String.format(
"%s------------ Instances (Total:%d) -------------", prefix,
CST.componentBroker.getInsts().size()));
for (Instance i : CST.componentBroker.getInsts()) {
System.out.println(String.format("%sInstance name %s ( oid: %s ) ",
prefix, i.getName(), i.getServiceObject()));
}
System.out.println(String.format(
"%s------------ /Instances -------------", prefix));
}
protected void auxListProperties(Component component) {
this.auxListProperties("\t\t", component);
}
protected void auxListProperties(String prefix, Component component) {
System.out.println(String.format(
"%s------------ Properties -------------", prefix));
for (Map.Entry<String, Object> entry : component.getAllProperties()
.entrySet()) {
System.out.print(entry.getKey() + "=" + entry.getValue());
if (!entry.getValue().equals(component.getProperty(entry.getKey()))) {
System.out.print("(" + component.getProperty(entry.getKey())
+ ")");
}
System.out.println("");
}
System.out.println(String.format(
"%s------------ /Properties -------------", prefix));
}
protected List<Instance> auxLookForInstanceOf(String... clazz) {
waitForApam();
List<Instance> pool = new ArrayList<Instance>();
for (Instance i : CST.componentBroker.getInsts()) {
ImplementationDeclaration apamImplDecl = i.getImpl()
.getImplDeclaration();
if (apamImplDecl instanceof AtomicImplementationDeclaration) {
AtomicImplementationDeclaration atomicInitialInstance = (AtomicImplementationDeclaration) apamImplDecl;
for (String classname : clazz) {
if (atomicInitialInstance.getClassName().equals(classname)) {
pool.add(i);
}
}
}
}
return pool;
}
public void waitForApam() {
waitForApam(RESOLVE_TIMEOUT);
}
public void waitForApam(long timeout) {
long sleep = 0;
while (!apamReady && sleep < timeout) {
if (CST.componentBroker != null && CST.apamResolver != null
&& CST.apam != null) {
apamReady = true;
} else {
try {
Thread.sleep(waitPeriod);
} catch (Exception exc) {
exc.printStackTrace();
}
}
sleep += waitPeriod;
}
}
protected Component waitForComponentByName(Component client,
String componentName) {
return waitForComponentByName(client, componentName, RESOLVE_TIMEOUT);
}
protected Component waitForComponentByName(Component client,
String componentName, long timeout) {
waitForApam();
Component comp = CST.apamResolver.findComponentByName(client,
componentName);
long sleep = 0;
while (sleep < timeout && comp == null) {
try {
Thread.sleep(waitPeriod);
} catch (Exception exc) {
exc.printStackTrace();
}
sleep += waitPeriod;
if (CST.apamResolver != null) {
comp = CST.apamResolver.findComponentByName(client,
componentName);
}
}
return comp;
}
protected Implementation waitForImplByName(Component client,
String componentName) {
return waitForImplByName(client, componentName, RESOLVE_TIMEOUT);
}
protected Implementation waitForImplByName(Component client, String componentName, long timeout) {
waitForApam();
Implementation impl = CST.apamResolver.findImplByName(client, componentName);
long sleep = 0;
while (sleep < timeout && impl == null) {
try {
Thread.sleep(waitPeriod);
} catch (Exception exc) {
exc.printStackTrace();
}
sleep += waitPeriod;
if (CST.apamResolver != null) {
impl = CST.apamResolver.findImplByName(client, componentName);
}
}
return impl;
}
protected Instance waitForInstByName(Component client, String componentName) {
return waitForInstByName(client, componentName, RESOLVE_TIMEOUT);
}
protected Instance waitForInstByName(Component client, String componentName, long timeout) {
waitForApam();
Instance inst = CST.apamResolver.findInstByName(client, componentName);
long sleep = 0;
while (sleep < timeout && inst == null) {
try {
Thread.sleep(waitPeriod);
} catch (Exception exc) {
exc.printStackTrace();
}
sleep += waitPeriod;
if (CST.apamResolver != null) {
inst = CST.apamResolver.findInstByName(client, componentName);
}
}
return inst;
}
protected Specification waitForSpecByName(Component client,
String componentName) {
return waitForSpecByName(client, componentName, RESOLVE_TIMEOUT);
}
protected Specification waitForSpecByName(Component client,
String componentName, long timeout) {
waitForApam();
Specification spec = CST.apamResolver.findSpecByName(client,
componentName);
long sleep = 0;
while (sleep < timeout && spec == null) {
try {
Thread.sleep(waitPeriod);
} catch (Exception exc) {
exc.printStackTrace();
}
sleep += waitPeriod;
if (CST.apamResolver != null) {
spec = CST.apamResolver.findSpecByName(client, componentName);
}
}
return spec;
}
}