public void Compare_NullAndValue_False()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare(null, "(value)");
Assert.That(result.AreEqual, Is.False);
}
public void Compare_StringAndValue_True()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare("2013-10-16", "(value)");
Assert.That(result.AreEqual, Is.True);
}
public int Compare(IndexValue x, IndexValue y)
{
if (x.Type == y.Type)
{
switch (x.Type)
{
case IndexValueType.Null:
return(0);
case IndexValueType.DateTime:
return(DateTimeComparer.Compare((DateTime)x.Value, (DateTime)y.Value));
case IndexValueType.Integer:
return(IntegerComparer.Compare((Int32)x.Value, (Int32)y.Value));
case IndexValueType.Number:
return(NumberComparer.Compare((double)x.Value, (double)y.Value));
case IndexValueType.String:
return(StringComparer.Compare((string)x.Value, (string)y.Value));
case IndexValueType.Bool:
return(BoolComparer.Compare((bool)x.Value, (bool)y.Value));
default:
Verify.Argument(true, "Attempt to compare illegal values, {0} and {1}", x.Value, y.Value);
throw null;
}
}
return(Comparer <int> .Default.Compare((int)x.Type, (int)y.Type));
}
public void Compare_NullAndString_False()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare(null, new DateTime(2013, 10, 16));
Assert.That(result.AreEqual, Is.False);
}
public void Compare_yyyymmddWithRoundingToSeconds_True()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare("2013-10-08 01:00:05.557", "2013-10-08 01:00:05.850"
, new DateTimeRounding(new TimeSpan(0,0,1), Rounding.RoundingStyle.Round));
Assert.That(result.AreEqual, Is.True);
}
public void Compare_ValidDateAndAny_True()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare("2013-10-16", "(any)");
Assert.That(result.AreEqual, Is.True);
}
public void Compare_ddmmyyyy_True()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare("16/10/2013", new DateTime(2013, 10, 16));
Assert.That(result.AreEqual, Is.True);
}
public void Compare_mmddyyyyhhmmss_True()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare("10/16/2013 00:00:00", new DateTime(2013, 10, 16));
Assert.That(result.AreEqual, Is.True);
}
public void Compare_yyyymmddWithToleranceInMilliSeconds_False()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare("2013-10-08 01:00:00.500", "2013-10-08 01:00:00.850", "00:00:00.125");
Assert.That(result.AreEqual, Is.False);
}
public void Compare_xxxxyyyy_True()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare("2013-10-16", new DateTime(2013, 10, 16));
Assert.That(result.AreEqual, Is.True);
}
public void Compare_NullAndAny_True()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare(null, "(any)");
Assert.That(result.AreEqual, Is.True);
}
public void Compare_yyyymmddWithToleranceInHours_False()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare("2013-10-09", "2013-10-08 01:00:00", "22:30:00");
Assert.That(result.AreEqual, Is.False);
}
public void Compare_NullAndNullPlaceHolder_True()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare(null, "(null)");
Assert.That(result.AreEqual, Is.True);
}
public void Compare_yyyymmddWithToleranceInDays_True()
{
var comparer = new DateTimeComparer();
var result = comparer.Compare("2013-10-09", "2013-10-08", "1");
Assert.That(result.AreEqual, Is.True);
}
public async Task Calendars_AddOrUpdateEvents_HandlesUTC()
{
var calendarEvent = GetTestEvent();
var calendar = new Calendar {
Name = _calendarName
};
var calendarEventUtc = new CalendarEvent
{
Name = calendarEvent.Name,
Start = calendarEvent.Start.ToUniversalTime(),
End = calendarEvent.End.ToUniversalTime()
};
await _service.AddOrUpdateCalendarAsync(calendar);
await _service.AddOrUpdateEventAsync(calendar, calendarEventUtc);
var eventFromId = await _service.GetEventByIdAsync(calendarEventUtc.ExternalID);
Assert.AreEqual(0, _dateTimeComparer.Compare(calendarEvent.Start, eventFromId.Start), "Event start times differ");
Assert.AreEqual(0, _dateTimeComparer.Compare(calendarEvent.End, eventFromId.End), "Event end times differ");
}
protected override bool ApplyWithReference(object reference, object x)
{
var cpr = new DateTimeComparer();
return(cpr.Compare(x, reference).AreEqual);
}
private static void _verifySame(State state)
{
object left = state.Left;
object right = state.Right;
string crumb = state.Crumb;
int maxDepth = state.MaxDepth;
var log = state.Log;
int depth = state.CurrentDepth;
log.Info(state.ToString(), state.CurrentDepth);
if (depth > maxDepth)
{
var msg = $"Maximum object depth of {state.MaxDepth} exceeded. {crumb}";
throw new VerifyException(msg, "NA", "NA", "NA");
}
if (NullComparer.BothNull(state))
{
return;
}
var properties = PropertyHelper.ComparableProperties(left, right);
foreach (var prop in properties)
{
var name = prop.Name;
var propCrumb = $"{crumb}.{name}";
var newstate = state.CreateChildState(prop.Type, name, prop.LHS, prop.RHS, propCrumb);
// NULLS
// -----
if (NullComparer.BothNull(newstate))
{
continue;
}
//DATETIME
// -------
if (DateTimeComparer.Compare(newstate))
{
continue;
}
//TIMESPAN
// -------
if (TimeSpanComparer.Compare(newstate))
{
continue;
}
// STRING COMPARABLE
// -----------------
if (StringComparer.CompareByStrings(newstate))
{
continue;
}
// LISTS
if (name.Contains("IList`"))
{
continue;
}
// CLASS
// -----
_verifySame(newstate);
}
}
private IEnumerable <DataRow> CompareValues(DataRow rx, DataRow ry)
{
var nonMatchingValueRows = new List <DataRow>();
var isRowOnError = false;
for (int i = 0; i < rx.Table.Columns.Count; i++)
{
if (Settings.GetColumnRole(i) == ColumnRole.Value)
{
//Null management
if (rx.IsNull(i) || ry.IsNull(i))
{
if (!rx.IsNull(i) || !ry.IsNull(i))
{
ry.SetColumnError(i, ry.IsNull(i) ? rx[i].ToString() : "(null)");
if (!isRowOnError)
{
isRowOnError = true;
nonMatchingValueRows.Add(ry);
}
}
}
//(value) management
else if (rx[i].ToString() == "(value)" || ry[i].ToString() == "(value)")
{
if (rx.IsNull(i) || ry.IsNull(i))
{
ry.SetColumnError(i, rx[i].ToString());
if (!isRowOnError)
{
isRowOnError = true;
nonMatchingValueRows.Add(ry);
}
}
}
//Not Null management
else
{
ComparerResult result = null;
//Numeric
if (Settings.GetColumnType(i) == ColumnType.Numeric)
{
//Convert to decimal
if (Settings.IsRounding(i))
{
result = numericComparer.Compare(rx[i], ry[i], Settings.GetRounding(i));
}
else
{
result = numericComparer.Compare(rx[i], ry[i], Settings.GetTolerance(i));
}
}
//Date and Time
else if (Settings.GetColumnType(i) == ColumnType.DateTime)
{
//Convert to dateTime
if (Settings.IsRounding(i))
{
result = dateTimeComparer.Compare(rx[i], ry[i], Settings.GetRounding(i));
}
else
{
result = dateTimeComparer.Compare(rx[i], ry[i], Settings.GetTolerance(i));
}
}
//Boolean
else if (Settings.GetColumnType(i) == ColumnType.Boolean)
{
//Convert to bool
result = booleanComparer.Compare(rx[i], ry[i]);
}
//Text
else
{
result = textComparer.Compare(rx[i], ry[i]);
}
//If are not equal then we need to set the message in the ColumnError.
if (!result.AreEqual)
{
ry.SetColumnError(i, result.Message);
if (!isRowOnError)
{
isRowOnError = true;
nonMatchingValueRows.Add(ry);
}
}
}
}
}
return(nonMatchingValueRows);
}
protected ResultSetCompareResult doCompare(DataTable x, DataTable y)
{
var chrono = DateTime.Now;
var columnsCount = Math.Max(y.Columns.Count, x.Columns.Count);
if (Settings == null)
{
BuildDefaultSettings(columnsCount);
}
else
{
Settings.ApplyTo(columnsCount);
}
Settings.ConsoleDisplay();
WriteSettingsToDataTableProperties(y, Settings);
WriteSettingsToDataTableProperties(x, Settings);
CheckSettingsAndDataTable(y, Settings);
CheckSettingsAndDataTable(x, Settings);
CheckSettingsAndFirstRow(y, Settings);
CheckSettingsAndFirstRow(x, Settings);
var keyComparer = new DataRowKeysComparer(Settings, x.Columns.Count);
CalculateHashValues(x, xDict, keyComparer, false);
CalculateHashValues(y, yDict, keyComparer, true);
chrono = DateTime.Now;
List <CompareHelper> missingRows;
{
var missingRowKeys = xDict.Keys.Except(yDict.Keys);
missingRows = new List <CompareHelper>(missingRowKeys.Count());
foreach (Int64 i in missingRowKeys)
{
missingRows.Add(xDict[i]);
}
}
Trace.WriteLineIf(NBiTraceSwitch.TraceInfo, string.Format("Missing rows: {0} [{1}]", missingRows.Count(), DateTime.Now.Subtract(chrono).ToString(@"d\d\.hh\h\:mm\m\:ss\s\ \+fff\m\s")));
chrono = DateTime.Now;
List <CompareHelper> unexpectedRows;
{
var unexpectedRowKeys = yDict.Keys.Except(xDict.Keys);
unexpectedRows = new List <CompareHelper>(unexpectedRowKeys.Count());
foreach (Int64 i in unexpectedRowKeys)
{
unexpectedRows.Add(yDict[i]);
}
}
Trace.WriteLineIf(NBiTraceSwitch.TraceInfo, string.Format("Unexpected rows: {0} [{1}]", unexpectedRows.Count(), DateTime.Now.Subtract(chrono).ToString(@"d\d\.hh\h\:mm\m\:ss\s\ \+fff\m\s")));
chrono = DateTime.Now;
List <CompareHelper> keyMatchingRows;
{
var keyMatchingRowKeys = xDict.Keys.Intersect(yDict.Keys);
keyMatchingRows = new List <CompareHelper>(keyMatchingRowKeys.Count());
foreach (Int64 i in keyMatchingRowKeys)
{
keyMatchingRows.Add(xDict[i]);
}
}
Trace.WriteLineIf(NBiTraceSwitch.TraceInfo, string.Format("Rows with a matching key and not duplicated: {0} [{1}]", keyMatchingRows.Count(), DateTime.Now.Subtract(chrono).ToString(@"d\d\.hh\h\:mm\m\:ss\s\ \+fff\m\s")));
chrono = DateTime.Now;
var nonMatchingValueRows = new List <DataRow>();
// If all of the columns make up the key, then we already know which rows match and which don't.
// So there is no need to continue testing
if (Settings.KeysDef != ResultSetComparisonSettings.KeysChoice.All)
{
foreach (var rxHelper in keyMatchingRows)
{
var ryHelper = yDict[rxHelper.KeysHashed];
//if (ryHelper.ValuesHashed == rxHelper.ValuesHashed)
//{
// // quick shortcut. If the hash of the values matches, then there is no further need to test
// continue;
//}
var rx = rxHelper.DataRowObj;
var ry = ryHelper.DataRowObj;
for (int i = 0; i < rx.Table.Columns.Count; i++)
{
if (Settings.IsValue(i))
{
//Null management
if (rx.IsNull(i) || ry.IsNull(i))
{
if (!rx.IsNull(i) || !ry.IsNull(i))
{
ry.SetColumnError(i, ry.IsNull(i) ? rx[i].ToString() : "(null)");
if (!nonMatchingValueRows.Contains(ry))
{
nonMatchingValueRows.Add(ry);
}
}
}
//(value) management
else if (rx[i].ToString() == "(value)" || ry[i].ToString() == "(value)")
{
if (rx.IsNull(i) || ry.IsNull(i))
{
ry.SetColumnError(i, rx[i].ToString());
if (!nonMatchingValueRows.Contains(ry))
{
nonMatchingValueRows.Add(ry);
}
}
}
//Not Null management
else
{
ComparerResult result = null;
//Numeric
if (Settings.IsNumeric(i))
{
//Convert to decimal
if (Settings.IsRounding(i))
{
result = numericComparer.Compare(rx[i], ry[i], Settings.GetRounding(i));
}
else
{
result = numericComparer.Compare(rx[i], ry[i], Settings.GetTolerance(i));
}
}
//Date and Time
else if (Settings.IsDateTime(i))
{
//Convert to dateTime
if (Settings.IsRounding(i))
{
result = dateTimeComparer.Compare(rx[i], ry[i], Settings.GetRounding(i));
}
else
{
result = dateTimeComparer.Compare(rx[i], ry[i], Settings.GetTolerance(i));
}
}
//Boolean
else if (Settings.IsBoolean(i))
{
//Convert to bool
result = booleanComparer.Compare(rx[i], ry[i]);
}
//Text
else
{
result = textComparer.Compare(rx[i], ry[i]);
}
//If are not equal then we need to set the message in the ColumnError.
if (!result.AreEqual)
{
ry.SetColumnError(i, result.Message);
if (!nonMatchingValueRows.Contains(ry))
{
nonMatchingValueRows.Add(ry);
}
}
}
}
}
}
}
Trace.WriteLineIf(NBiTraceSwitch.TraceInfo, string.Format("Rows with a matching key but without matching value: {0} [{1}]", nonMatchingValueRows.Count(), DateTime.Now.Subtract(chrono).ToString(@"d\d\.hh\h\:mm\m\:ss\s\ \+fff\m\s")));
var duplicatedRows = new List <DataRow>(); // Dummy place holder
return(ResultSetCompareResult.Build(
missingRows.Select(a => a.DataRowObj).ToList(),
unexpectedRows.Select(a => a.DataRowObj).ToList(),
duplicatedRows,
keyMatchingRows.Select(a => a.DataRowObj).ToList(),
nonMatchingValueRows
));
}
private void CompareValues(List <CompareHelper> keyMatchingRows, List <DataRow> nonMatchingValueRows)
{
if (Settings.KeysDef != ResultSetComparisonSettings.KeysChoice.All)
{
foreach (var rxHelper in keyMatchingRows)
{
var ryHelper = yDict[rxHelper.Keys];
//if (ryHelper.ValuesHashed == rxHelper.ValuesHashed)
//{
// // quick shortcut. If the hash of the values matches, then there is no further need to test
// continue;
//}
var rx = rxHelper.DataRowObj;
var ry = ryHelper.DataRowObj;
var isRowOnError = false;
for (int i = 0; i < rx.Table.Columns.Count; i++)
{
if (Settings.GetColumnRole(i) == ColumnRole.Value)
{
//Any management
if (rx[i].ToString() != "(any)" && ry[i].ToString() != "(any)")
{
//Null management
if (rx.IsNull(i) || ry.IsNull(i))
{
if ((!rx.IsNull(i) && rx[i].ToString() != "(blank)") || (!ry.IsNull(i) && ry[i].ToString() != "(blank)"))
{
ry.SetColumnError(i, ry.IsNull(i) ? rx[i].ToString() : "(null)");
if (!isRowOnError)
{
isRowOnError = true;
nonMatchingValueRows.Add(ry);
}
}
}
//(value) management
else if (rx[i].ToString() == "(value)" || ry[i].ToString() == "(value)")
{
if (rx.IsNull(i) || ry.IsNull(i))
{
ry.SetColumnError(i, rx[i].ToString());
if (!isRowOnError)
{
isRowOnError = true;
nonMatchingValueRows.Add(ry);
}
}
}
//Not Null management
else
{
ComparerResult result = null;
//Numeric
if (Settings.GetColumnType(i) == ColumnType.Numeric)
{
//Convert to decimal
if (Settings.IsRounding(i))
{
result = numericComparer.Compare(rx[i], ry[i], Settings.GetRounding(i));
}
else
{
result = numericComparer.Compare(rx[i], ry[i], Settings.GetTolerance(i));
}
}
//Date and Time
else if (Settings.GetColumnType(i) == ColumnType.DateTime)
{
//Convert to dateTime
if (Settings.IsRounding(i))
{
result = dateTimeComparer.Compare(rx[i], ry[i], Settings.GetRounding(i));
}
else
{
result = dateTimeComparer.Compare(rx[i], ry[i], Settings.GetTolerance(i));
}
}
//Boolean
else if (Settings.GetColumnType(i) == ColumnType.Boolean)
{
//Convert to bool
result = booleanComparer.Compare(rx[i], ry[i]);
}
//Text
else
{
result = textComparer.Compare(rx[i], ry[i]);
}
//If are not equal then we need to set the message in the ColumnError.
if (!result.AreEqual)
{
ry.SetColumnError(i, result.Message);
if (!isRowOnError)
{
isRowOnError = true;
nonMatchingValueRows.Add(ry);
}
}
}
}
}
}
}
}
}
public void Compare_StringAndAny_ArgumentException()
{
var comparer = new DateTimeComparer();
Assert.Throws <NBiException>(delegate { comparer.Compare("Not a date", "(any)"); });
}
public override bool Apply(object x)
{
var cpr = new DateTimeComparer();
return(cpr.Compare(x, Reference).AreEqual);
}
public bool Compare(object x, object y)
{
var cpr = new DateTimeComparer();
return(cpr.Compare(x, y).AreEqual);
}