public void CanSetTheValueContainedByAReferenceToAString()
{
var reference = new ValueReferenceDefinitionBuilder().WithStartingValue("oldString").Build().CreateValueReference(engine);
reference.Set("newString");
Assert.AreEqual(reference.ValueAsString(), "newString");
}
public void TheStateOfAValueReferenceContainingANumerCanBeSaved()
{
var reference = new ValueReferenceDefinitionBuilder().WithStartingValue(new BigDouble(100)).Build().CreateValueReference(engine);
var serialized = reference.GetSnapshot();
Assert.AreEqual(new ValueReference.Snapshot("1", new BigDouble(100)), serialized);
}
public void CanSetTheValueContainedByAReferenceToABool()
{
var reference = new ValueReferenceDefinitionBuilder().WithStartingValue(true).Build().CreateValueReference(engine);
reference.Set(false);
Assert.IsFalse(reference.ValueAsBool());
}
public void TheStateOfAValueReferenceContainingADictionaryCanBeSaved()
{
var reference = new ValueReferenceDefinitionBuilder().WithStartingValue(new Dictionary <string, ValueReferenceDefinition>()).Build().CreateValueReference(engine);
var serialized = reference.GetSnapshot();
Assert.AreEqual(serialized, new ValueReference.Snapshot("1", new Dictionary <string, ValueReference.Snapshot>()));
}
public void TheStateOfAValueReferenceContainingAStringCanBeRecursivelySaved()
{
var reference = new ValueReferenceDefinitionBuilder().WithStartingValue(new Dictionary <string, ValueReferenceDefinition>()
{
{ "string", "aString" },
{ "number", new BigDouble(100) },
{ "bool", true },
{ "map", new Dictionary <string, ValueReferenceDefinition>()
{
{ "nestedString", "string" },
{ "nestedNumber", new BigDouble(10) },
{ "nestedBool", true }
} }
}).Build().CreateValueReference(engine);
var serialized = reference.GetSnapshot();
Assert.AreEqual(new Dictionary <string, ValueReference.Snapshot>()
{
{ "string", new ValueReference.Snapshot("1", "aString") },
{ "number", new ValueReference.Snapshot("2", new BigDouble(100)) },
{ "bool", new ValueReference.Snapshot("3", true) },
{
"map", new ValueReference.Snapshot("7", new Dictionary <string, ValueReference.Snapshot>()
{
{ "nestedString", new ValueReference.Snapshot("4", "string") },
{ "nestedNumber", new ValueReference.Snapshot("5", new BigDouble(10)) },
{ "nestedBool", new ValueReference.Snapshot("6", true) }
})
}
}, serialized.value);
Assert.AreEqual(serialized.internalId, reference.Id);
}
public void TheStateOfAValueReferenceCanBeRestoredFromABooleanSnapshot()
{
var reference = new ValueReferenceDefinitionBuilder().Build().CreateValueReference(engine);
reference.RestoreFromSnapshot(engine, new ValueReference.Snapshot("1", true));
Assert.AreEqual(true, reference.ValueAsBool());
}
public void TheStateOfAValueReferenceCanBeRestoredFromANumberSnapshot()
{
var reference = new ValueReferenceDefinitionBuilder().Build().CreateValueReference(engine);
reference.RestoreFromSnapshot(engine, new ValueReference.Snapshot("1", new BigDouble(11)));
Assert.AreEqual(new BigDouble(11), reference.ValueAsNumber());
}
public void CanSetTheValueContainedByAReferenceToANumber()
{
var reference = new ValueReferenceDefinitionBuilder().WithStartingValue(BigDouble.One).Build().CreateValueReference(engine);
reference.Set(new BigDouble(2));
Assert.AreEqual(reference.ValueAsNumber(), new BigDouble(2));
}
public void TheStateOfAValueReferenceCanBeRestoredFromAMapSnapshot()
{
var reference = new ValueReferenceDefinitionBuilder().Build().CreateValueReference(engine);
reference.RestoreFromSnapshot(engine, new ValueReference.Snapshot("1", new Dictionary <string, ValueReference.Snapshot>()));
Assert.AreEqual(new Dictionary <string, ValueReference>(), reference.ValueAsMap());
}
public void TheStateOfAValueReferenceContainingAStringCanBeSaved()
{
var reference = new ValueReferenceDefinitionBuilder().WithStartingValue("astring").Build().CreateValueReference(engine);
var serialized = reference.GetSnapshot();
Assert.AreEqual(serialized.value, "astring");
Assert.AreEqual(serialized.internalId, reference.Id);
}
public void CanSetTheValueContainedByAReferenceToAMap()
{
var initialDictionary = new Dictionary <string, ValueReferenceDefinition>();
var reference = new ValueReferenceDefinitionBuilder().WithStartingValue(initialDictionary).Build().CreateValueReference(engine);
var newDictionary = new Dictionary <string, ValueReference>();
reference.Set(newDictionary);
Assert.AreEqual(reference.ValueAsMap(), newDictionary);
}
public void ValueReferenceEqualsComparesUnderlyingValue()
{
var ref1 = new ValueReferenceDefinitionBuilder().WithStartingValue(true).Build().CreateValueReference(engine);
var ref2 = new ValueReferenceDefinitionBuilder().WithStartingValue(true).Build().CreateValueReference(engine);
Assert.AreEqual(ref1, ref2);
var ref3 = new ValueReferenceDefinitionBuilder().WithStartingValue("true").Build().CreateValueReference(engine);
Assert.AreNotEqual(ref1, ref3);
}
public void InstatiatesWithDefaultValueIfNonDefined()
{
var definition = new ValueReferenceDefinitionBuilder().Build();
var instantiated = definition.CreateValueReference(engine);
Assert.AreEqual(BigDouble.Zero, instantiated.ValueAsNumber());
Assert.AreEqual(false, instantiated.ValueAsBool());
Assert.AreEqual(null, instantiated.ValueAsMap());
Assert.AreEqual("0", instantiated.ValueAsString());
}
public void RawValueReturnsActualValue()
{
var booleanReference = new ValueReferenceDefinitionBuilder().WithStartingValue(true).Build().CreateValueReference(engine);
var numberReference = new ValueReferenceDefinitionBuilder().WithStartingValue(BigDouble.One).Build().CreateValueReference(engine);
var stringReference = new ValueReferenceDefinitionBuilder().WithStartingValue("string").Build().CreateValueReference(engine);
var mapReference = new ValueReferenceDefinitionBuilder().WithStartingValue(new Dictionary <string, ValueReferenceDefinition>()).Build().CreateValueReference(engine);
Assert.AreEqual(true, booleanReference.ValueAsRaw());
Assert.AreEqual(BigDouble.One, numberReference.ValueAsRaw());
Assert.AreEqual("string", stringReference.ValueAsRaw());
Assert.AreEqual(new Dictionary <string, ValueReference>(), mapReference.ValueAsRaw());
}
public void CanWatchANonExistantKeyInAMap()
{
var mapReference = new ValueReferenceDefinitionBuilder()
.WithStartingValue(new Dictionary <string, ValueReferenceDefinition>()).Build().CreateValueReference(engine);
var fooReference = mapReference.ValueAsMap()["foo"];
var watchListenerCalled = false;
fooReference.Watch(newFoo =>
{
watchListenerCalled = true;
});
Assert.IsTrue(watchListenerCalled);
}
public void CanDefineAnUpdaterAction()
{
var definition = new ValueReferenceDefinitionBuilder()
.WithUpdater((engine, parent, deltaTime, previousValue) => {
return((BigDouble)previousValue + BigDouble.One);
})
.Build();
var instantiated = definition.CreateValueReference(engine);
Assert.AreEqual(BigDouble.Zero, instantiated.ValueAsNumber());
instantiated.Update(engine, 1f);
Assert.AreEqual(BigDouble.One, instantiated.ValueAsNumber());
}
public void CanDefineAPostUpdateHook()
{
bool hookCalled = false;
Action <IdleEngine, float, object> hook = (engine, deltaTime, newValue) =>
{
hookCalled = true;
};
ValueReference reference = new ValueReferenceDefinitionBuilder()
.WithPostUpdateHook(hook)
.Build().CreateValueReference(engine);
reference.Update(engine, 0);
Assert.IsTrue(hookCalled);
}
public void AssigningAValueInAMapUpdatesTheParent()
{
var mapReference = new ValueReferenceDefinitionBuilder()
.WithStartingValue(new Dictionary <string, ValueReferenceDefinition>()).Build().CreateValueReference(engine);
var map = mapReference.ValueAsMap();
int watchListenerCalled = 0;
mapReference.Watch(updatedMap =>
{
watchListenerCalled++;
});
map["foo"].Set(BigDouble.One);
Assert.AreEqual(3, watchListenerCalled);
}
public void WatchListenerReceivesMapValueWhenChildUpdates()
{
var mapReference = new ValueReferenceDefinitionBuilder()
.WithStartingValue(new Dictionary <string, ValueReferenceDefinition>()).Build().CreateValueReference(engine);
var map = mapReference.ValueAsMap();
int watchListenerCalled = 0;
mapReference.Watch(updatedMap =>
{
Assert.IsNotNull(updatedMap as IDictionary <string, ValueReference>);
watchListenerCalled++;
});
map["foo"].Set(BigDouble.One);
Assert.AreEqual(3, watchListenerCalled);
}
public void ToStringDescribesContents()
{
var mapReference = new ValueReferenceDefinitionBuilder().WithStartingValue(new Dictionary <string, ValueReferenceDefinition>()).Build().CreateValueReference(engine);
Assert.AreEqual("Reference(containing map)", mapReference.ToString());
var stringReference = new ValueReferenceDefinitionBuilder().WithStartingValue("string").Build().CreateValueReference(engine);
Assert.AreEqual("Reference(containing string)", stringReference.ToString());
var boolReference = new ValueReferenceDefinitionBuilder().WithStartingValue(true).Build().CreateValueReference(engine);
Assert.AreEqual("Reference(containing boolean)", boolReference.ToString());
var numberReference = new ValueReferenceDefinitionBuilder().WithStartingValue(BigDouble.One).Build().CreateValueReference(engine);
Assert.AreEqual("Reference(containing number)", numberReference.ToString());
}
public void ChangingValueOfWatchedValueNotifiesListeners()
{
var valueReference = new ValueReferenceDefinitionBuilder().Build().CreateValueReference(engine);
int calls = 0;
valueReference.Watch(newValue =>
{
calls++;
if (calls == 1)
{
Assert.AreEqual(BigDouble.Zero, newValue);
}
else
{
Assert.AreEqual(BigDouble.One, newValue);
}
});
valueReference.Set(BigDouble.One);
Assert.AreEqual(2, calls);
}
public void WatchingForChangesReceivesCurrentValueImmediately()
{
var valueReference = new ValueReferenceDefinitionBuilder().Build().CreateValueReference(engine);
valueReference.Watch(newValue => Assert.AreEqual(BigDouble.Zero, newValue));
}
public void EqualsComparingValueReferenceToAnyOtherTypeAlwaysFalse()
{
var ref1 = new ValueReferenceDefinitionBuilder().WithStartingValue(true).Build().CreateValueReference(engine);
Assert.AreNotEqual(ref1, new Dictionary <string, string>());
}
