@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testRemoveObserver() {
// create some observers, add them to yoVariable
int nObservers = 5;
createVariableChangeListeners(nObservers);
addAllListenersToYoVariable();
// let yoVariable notify observers. Assert that they got the event.
yoVariable.notifyVariableChangedListeners();
for (TestVariableChangedListener observer : variableChangedListeners) {
assertEquals(observer.getLastVariableChanged(), yoVariable);
}
// Remove and reset observers. Let yoVariable notify observers again. Assert that the observers
// didn't notice anything.
for (VariableChangedListener observer : variableChangedListeners) {
yoVariable.removeVariableChangedListener(observer);
}
resetAllObservers();
yoVariable.notifyVariableChangedListeners();
for (TestVariableChangedListener observer : this.variableChangedListeners) {
assertNull(observer.getLastVariableChanged());
}
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testNotifyVaribaleChangeListeners() {
// create a bunch of Observers
@SuppressWarnings("unused")
int nObservers = 5;
createVariableChangeListeners(5);
// add them to the YoVariable
yoVariable.removeAllVariableChangedListeners();
addAllListenersToYoVariable();
// create an observer that's not supposed to be notified.
TestVariableChangedListener hearNoEvil = new TestVariableChangedListener();
// make sure there's no event stored in the observers before we set
for (TestVariableChangedListener listener : variableChangedListeners) {
assertNull(listener.getLastVariableChanged());
}
assertNull(hearNoEvil.getLastVariableChanged());
// now notify and check if the observers catch on
yoVariable.notifyVariableChangedListeners();
for (TestVariableChangedListener observer : variableChangedListeners) {
assertEquals(observer.getLastVariableChanged(), yoVariable);
}
// make sure hearNoEvil is unaware
assertNull(hearNoEvil.getLastVariableChanged());
}
@Override
public void onNewData(ByteBuffer decompressed) {
long timestamp = decompressed.getLong();
LongBuffer data = decompressed.asLongBuffer();
for (int i = 0; i < variables.size(); i++) {
YoVariable<?> variable = variables.get(i);
long previousValue = variable.getValueAsLongBits();
long newValue = data.get();
variable.setValueFromLongBits(newValue, false);
if (previousValue != newValue) {
ArrayList<VariableChangedListener> changedListeners =
variable.getVariableChangedListeners();
if (changedListeners != null) {
for (int listener = 0; listener < changedListeners.size(); listener++) {
VariableChangedListener changedListener = changedListeners.get(listener);
if (!(changedListener instanceof LogControlVariableChangeListener)) {
changedListener.variableChanged(variable);
}
}
}
}
}
for (int i = 0; i < jointStates.size(); i++) {
jointStates.get(i).update(data);
}
listener.receivedTimestampAndData(timestamp, decompressed);
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testGetYoVariableRegistry() {
YoVariableRegistry registry = yoVariable.getYoVariableRegistry();
assertNotNull(registry);
assertEquals(registry, this.registry);
assertEquals(registry.getVariable(yoVariable.getName()), yoVariable);
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testAddVariableChangeListener() {
// remove all observers, then add one new observer, and check if it can be removed without
// exceptions.
yoVariable.removeAllVariableChangedListeners();
TestVariableChangedListener listener = new TestVariableChangedListener();
yoVariable.addVariableChangedListener(listener);
yoVariable.removeVariableChangedListener(listener);
}
@DeployableTestMethod
@Test(timeout = 5000)
public void testWritingAndReadingADataFileWithLotsOfVariables()
throws IOException, RepeatDataBufferEntryException {
File fileOne = new File(TEST_DIRECTORY + "fileOne.data.gz");
if (fileOne.exists()) fileOne.delete();
long seed = 1776L;
int numberOfVariables = 2000; // 12000 for when testing long files for efficiency;
Random random = new Random(seed);
ArrayList<YoVariable<?>> variables = createALargeNumberOfVariables(random, numberOfVariables);
YoVariableList originalVarList = new YoVariableList("originalVarList");
originalVarList.addVariables(variables);
int bufferSize = 50;
DataBuffer dataBuffer = new DataBuffer(bufferSize);
dataBuffer.addVariables(variables);
for (int i = 0; i < bufferSize / 2; i++) {
dataBuffer.setDataAtIndexToYoVariableValues();
dataBuffer.tick(1);
}
dataBuffer.setInOutPointFullBuffer();
Robot robot = new Robot("testWritingRobot");
writeALongDataFile(fileOne, dataBuffer, variables, robot);
System.out.println("Wrote File. Now reading it.");
DataFileReader dataFileReader = new DataFileReader(fileOne);
YoVariableList newVarList = new YoVariableList("newVarList");
YoVariableRegistry registry = new YoVariableRegistry("rootRegistry");
DataBuffer newDataBuffer = new DataBuffer();
dataFileReader.readData(newVarList, registry, newDataBuffer);
assertEquals(originalVarList.size(), newVarList.size());
for (int i = 0; i < originalVarList.size(); i++) {
YoVariable<?> originalVariable = originalVarList.getVariable(i);
YoVariable<?> newVariable = newVarList.getVariable(originalVariable.getName());
assertFalse(originalVariable == newVariable);
assertEquals(originalVariable.getValueAsDouble(), newVariable.getValueAsDouble(), 1e-7);
}
fileOne.delete();
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testFullNameEndsWith() {
assertTrue(yoVariable.fullNameEndsWithCaseInsensitive("robot.testRegistry.variableOne"));
assertTrue(yoVariable.fullNameEndsWithCaseInsensitive("testRegistry.variableOne"));
assertTrue(yoVariable.fullNameEndsWithCaseInsensitive("variableOne"));
assertTrue(!yoVariable.fullNameEndsWithCaseInsensitive("bot.testRegistry.variableOne"));
assertTrue(!yoVariable.fullNameEndsWithCaseInsensitive(".testRegistry.variableOne"));
assertTrue(!yoVariable.fullNameEndsWithCaseInsensitive("gistry.variableOne"));
assertTrue(!yoVariable.fullNameEndsWithCaseInsensitive("ableOne"));
assertTrue(!yoVariable.fullNameEndsWithCaseInsensitive("robot.testRegistr"));
assertTrue(yoVariable.fullNameEndsWithCaseInsensitive("robot.testRegistry.VARIABLEONE"));
assertFalse(yoVariable.fullNameEndsWithCaseInsensitive("Robot.testRegistry.variableOne"));
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testGetName1() {
StringBuffer buffer = new StringBuffer();
yoVariable.getName(buffer);
assertEquals(buffer.toString(), "variableOne");
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testGetDescription() {
DoubleYoVariable descrVariable = new DoubleYoVariable("booleanVar", "Description", registry);
assertEquals(descrVariable.getDescription(), "Description");
assertNotNull(yoVariable.getDescription());
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testRemoveObserverNonExistent1() {
// make sure removing an observer that wasn't added throws an exception.
try {
yoVariable.removeVariableChangedListener(new TestVariableChangedListener());
fail();
} catch (NoSuchElementException e) {
// pass.
}
}
@DeployableTestMethod
@Test(timeout = 5000)
public void testWritingAndReadingALongStateFile() throws IOException {
File fileOne = new File(TEST_DIRECTORY + "fileOne.state");
if (fileOne.exists()) fileOne.delete();
long seed = 1776L;
int numberOfVariables = 2000; // 12000 for when testing long files for efficiency;
Random random = new Random(seed);
ArrayList<YoVariable<?>> variables = createALargeNumberOfVariables(random, numberOfVariables);
YoVariableList originalVarList = new YoVariableList("originalVarList");
originalVarList.addVariables(variables);
writeALongStateFile(fileOne, variables);
DataFileReader dataFileReader = new DataFileReader(fileOne);
YoVariableList newVarList = new YoVariableList("newVarList");
boolean createMissingVariables = true;
boolean printErrorForMissingVariables = false;
YoVariableRegistry registry = new YoVariableRegistry("root");
dataFileReader.readState(
newVarList, createMissingVariables, printErrorForMissingVariables, registry);
assertEquals(originalVarList.size(), newVarList.size());
for (int i = 0; i < originalVarList.size(); i++) {
YoVariable<?> originalVariable = originalVarList.getVariable(i);
YoVariable<?> newVariable = newVarList.getVariable(originalVariable.getName());
assertFalse(originalVariable == newVariable);
assertEquals(originalVariable.getValueAsDouble(), newVariable.getValueAsDouble(), 1e-7);
}
fileOne.delete();
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000, expected = NoSuchElementException.class)
public void testRemoveObserverNonExistent2() {
// make sure removing an observer that wasn't added throws an exception.
// try
{
createVariableChangeListeners(5);
addAllListenersToYoVariable();
yoVariable.removeVariableChangedListener(new TestVariableChangedListener());
// fail();
}
// catch (NoSuchElementException e)
{
// pass.
}
}
private void addAllListenersToYoVariable() {
for (TestVariableChangedListener observer : variableChangedListeners) {
yoVariable.addVariableChangedListener(observer);
}
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testGetName() {
assertEquals(yoVariable.getName(), "variableOne");
}
@ContinuousIntegrationTest(estimatedDuration = 0.0)
@Test(timeout = 300000)
public void testGetFullNameWithNameSpace() {
assertEquals(yoVariable.getFullNameWithNameSpace(), "robot.testRegistry.variableOne");
}
public boolean compare(SimulationConstructionSet scs1, SimulationConstructionSet scs2) {
// compare variables
YoVariable var0 = getRootJoint(scs1).getQx();
YoVariable var1 = getRootJoint(scs2).getQx();
return (MathTools.epsilonEquals(var0.getValueAsDouble(), var1.getValueAsDouble(), epsilon));
}