private void AssertSchedules(IDictionary <String, long> schedules, Object[][] expected)
{
ScopeTestHelper.AssertEquals(expected.Length, schedules.Count);
ICollection <int> matchNumber = new HashSet <int>();
foreach (KeyValuePair <string, long> entry in schedules)
{
bool matchFound = false;
for (int i = 0; i < expected.Length; i++)
{
if (matchNumber.Contains(i))
{
continue;
}
if (expected[i][0].Equals(entry.Key))
{
matchFound = true;
matchNumber.Add(i);
if (expected[i][1] == null && entry.Value == null)
{
continue;
}
if (!expected[i][1].Equals(entry.Value))
{
ScopeTestHelper.Fail("Failed to match value for key '" + entry.Key + "' expected '" + expected[i][i] + "' received '" + entry.Value + "'");
}
}
}
if (!matchFound)
{
ScopeTestHelper.Fail("Failed to find key '" + entry.Key + "'");
}
}
}
/// <summary>Asserts that exactly one remove stream event was received and no insert stream events, resets the listener clearing all state and returns the received event. </summary>
/// <returns>single remove-stream event</returns>
public object AssertOneGetOldAndReset()
{
ScopeTestHelper.AssertTrue("Listener invocation not received but expected", _isInvoked);
ScopeTestHelper.AssertEquals("Mismatch in the number of invocations", 1, _newDataList.Count);
ScopeTestHelper.AssertEquals("Mismatch in the number of invocations", 1, _oldDataList.Count);
if (_lastOldData == null)
{
ScopeTestHelper.Fail("No old-data events received");
}
ScopeTestHelper.AssertEquals("Mismatch in the number of old-data events", 1, _lastOldData.Length);
ScopeTestHelper.AssertNull("Expected no new-data events", _lastNewData);
object lastNew = _lastOldData[0];
Reset();
return(lastNew);
}
private static void AssertConsistencyRecursive(
EventBean eventBean,
ISet<EventType> alreadySeenTypes)
{
AssertConsistencyRecursive(eventBean.EventType, alreadySeenTypes);
var properties = eventBean.EventType.PropertyDescriptors;
for (var i = 0; i < properties.Count; i++) {
var failedMessage = "failed assertion for property '" + properties[i].PropertyName + "' ";
var propertyName = properties[i].PropertyName;
// assert getter
if (!properties[i].IsRequiresIndex && !properties[i].IsRequiresMapKey) {
var getter = eventBean.EventType.GetGetter(propertyName);
var resultGetter = getter.Get(eventBean);
var resultGet = eventBean.Get(propertyName);
if (resultGetter == null && resultGet == null) {
// fine
}
else if (resultGet is XmlNodeList) {
ScopeTestHelper.AssertEquals(
failedMessage,
((XmlNodeList) resultGet).Count,
((XmlNodeList) resultGetter).Count);
}
else if (resultGet.GetType().IsArray) {
ScopeTestHelper.AssertEquals(
failedMessage,
((Array) resultGet).Length,
((Array) resultGetter).Length);
}
else {
ScopeTestHelper.AssertEquals(failedMessage, resultGet, resultGetter);
}
if (resultGet != null) {
if (resultGet is EventBean[] || resultGet is EventBean) {
ScopeTestHelper.AssertTrue(properties[i].IsFragment);
}
else {
var resultType = resultGet.GetType();
var propertyType = properties[i].PropertyType.GetBoxedType();
if ((resultType != propertyType) &&
!TypeHelper.IsSubclassOrImplementsInterface(resultType, propertyType)) {
ScopeTestHelper.Fail(failedMessage);
}
}
}
}
// fragment
if (!properties[i].IsFragment) {
ScopeTestHelper.AssertNull(failedMessage, eventBean.GetFragment(propertyName));
continue;
}
var fragmentType = eventBean.EventType.GetFragmentType(propertyName);
ScopeTestHelper.AssertNotNull(failedMessage, fragmentType);
// fragment can be null
var fragment = eventBean.GetFragment(propertyName);
if (fragment == null) {
return;
}
if (!fragmentType.IsIndexed) {
ScopeTestHelper.AssertTrue(failedMessage, fragment is EventBean);
var fragmentEvent = (EventBean) fragment;
AssertConsistencyRecursive(fragmentEvent, alreadySeenTypes);
}
else {
ScopeTestHelper.AssertTrue(failedMessage, fragment is EventBean[]);
var events = (EventBean[]) fragment;
ScopeTestHelper.AssertTrue(failedMessage, events.Length > 0);
foreach (var theEvent in events) {
AssertConsistencyRecursive(theEvent, alreadySeenTypes);
}
}
}
}
