public void CanFormatInvolvedTablesWithAlternateKeys()
{
var involvedTables =
new List <InvolvedTable>
{
new InvolvedTable(
"Table1",
new[]
{
new AlternateKeyRowReference("AAA"),
new AlternateKeyRowReference("BBB")
}, "KEY"),
new InvolvedTable(
"Table2",
new[]
{
new AlternateKeyRowReference("111"),
new AlternateKeyRowReference("222")
}, "KEY")
};
string formatted = IssueUtils.FormatInvolvedTables(involvedTables);
Console.WriteLine(formatted);
Assert.AreEqual("[Table1:KEY]AAA||BBB;[Table2:KEY]111||222", formatted);
}
public void CanParseShortestValidTableString()
{
IList <InvolvedTable> tables = IssueUtils.ParseInvolvedTables("[T:F]1||2||3;[Y:G]A");
Assert.AreEqual(2, tables.Count);
InvolvedTable table1 = tables[0];
Assert.AreEqual("T", table1.TableName);
Assert.AreEqual("F", table1.KeyField);
IList <RowReference> rows1 = table1.RowReferences;
Assert.AreEqual(3, rows1.Count);
Assert.AreEqual("1", rows1[0].Key);
Assert.AreEqual("2", rows1[1].Key);
Assert.AreEqual("3", rows1[2].Key);
InvolvedTable table2 = tables[1];
Assert.AreEqual("Y", table2.TableName);
Assert.AreEqual("G", table2.KeyField);
IList <RowReference> rows2 = table2.RowReferences;
Assert.AreEqual(1, rows2.Count);
Assert.AreEqual("A", rows2[0].Key);
}
public void CanFormatInvolvedTablesWithOids()
{
var involvedTables =
new List <InvolvedTable>
{
new InvolvedTable(
"Table1",
new[]
{
new OIDRowReference(1),
new OIDRowReference(2)
}),
new InvolvedTable(
"Table2",
new[]
{
new OIDRowReference(1000),
new OIDRowReference(1001)
})
};
string formatted = IssueUtils.FormatInvolvedTables(involvedTables);
Console.WriteLine(formatted);
Assert.AreEqual("[Table1]1||2;[Table2]1000||1001", formatted);
}
public void CanParseInvolvedTablesWithOids()
{
IList <InvolvedTable> tables =
IssueUtils.ParseInvolvedTables("[Table1]1||2;[Table2]1000||1001");
Assert.AreEqual(2, tables.Count);
InvolvedTable table1 = tables[0];
Assert.AreEqual("Table1", table1.TableName);
Assert.IsNull(table1.KeyField);
IList <RowReference> rows1 = table1.RowReferences;
Assert.AreEqual(2, rows1.Count);
Assert.AreEqual(1, rows1[0].OID);
Assert.AreEqual(2, rows1[1].OID);
InvolvedTable table2 = tables[1];
Assert.AreEqual("Table2", table2.TableName);
Assert.IsNull(table2.KeyField);
IList <RowReference> rows2 = table2.RowReferences;
Assert.AreEqual(2, rows2.Count);
Assert.AreEqual(1000, rows2[0].OID);
Assert.AreEqual(1001, rows2[1].OID);
}
private IList <InvolvedTable> ParseInvolvedTables(
[NotNull] string involvedTablesString, Guid qualityConditionGuid)
{
IAlternateKeyConverter keyConverter =
_alternateKeyConverterProvider?.GetConverter(qualityConditionGuid);
return(IssueUtils.ParseInvolvedTables(involvedTablesString, keyConverter));
}
private static void AssertEqualKeys([NotNull] ICollection <InvolvedRow> involvedRows)
{
string involvedRowsKey = ExceptionObjectUtils.GetKey(involvedRows);
string involvedTablesKey = ExceptionObjectUtils.GetKey(
IssueUtils.GetInvolvedTables(involvedRows));
Console.WriteLine(@"Involved rows key: [{0}]", involvedRowsKey);
Console.WriteLine(@"Involved tables key: [{0}]", involvedTablesKey);
Assert.AreEqual(involvedRowsKey, involvedTablesKey);
}
public void CanGetInvolvedTablesKeyFastEnough()
{
var involvedRows = new List <InvolvedRow>
{
new InvolvedRow("Table2", 100),
new InvolvedRow("Table1", 1000),
new InvolvedRow("Table2", 200)
};
IEnumerable <InvolvedTable> involvedTables =
IssueUtils.GetInvolvedTables(involvedRows);
AssertFastEnough(() => ExceptionObjectUtils.GetKey(involvedTables), 10000, 0.1);
}
public void CanFormatInvolvedTableWithoutRows()
{
var involvedTables =
new List <InvolvedTable>
{
new InvolvedTable("Table1", new RowReference[] { })
};
string formatted = IssueUtils.FormatInvolvedTables(involvedTables);
Console.WriteLine(formatted);
Assert.AreEqual("[Table1]", formatted);
}
public void CanParseInvolvedTableWithKeyFieldNoIds()
{
IList <InvolvedTable> tables = IssueUtils.ParseInvolvedTables("[Table:FieldName]");
Assert.AreEqual(1, tables.Count);
InvolvedTable table = tables[0];
Assert.AreEqual("Table", table.TableName);
Assert.AreEqual("FieldName", table.KeyField);
IList <RowReference> rows = table.RowReferences;
Assert.AreEqual(0, rows.Count);
}
public void CanFormatInvolvedTablesWithoutRows()
{
var involvedTables =
new List <InvolvedTable>
{
new InvolvedTable("Table1", new RowReference[] { }),
new InvolvedTable("Table2", new RowReference[] { }, "KeyField"),
new InvolvedTable("Table3", new RowReference[] { })
};
string formatted = IssueUtils.FormatInvolvedTables(involvedTables);
Console.WriteLine(formatted);
// field name is omitted (not used, there are no row references)
Assert.AreEqual("[Table1];[Table2];[Table3]", formatted);
}
protected override bool MatchesCore(ExceptionObject exceptionObject,
QaError qaError)
{
double?errorDoubleValue1;
double?errorDoubleValue2;
string errorTextValue;
IssueUtils.GetValues(qaError.Values,
out errorDoubleValue1,
out errorDoubleValue2,
out errorTextValue);
const double toleranceFactor = 10;
double tolerance = exceptionObject.XYTolerance * toleranceFactor ?? 0;
return(Matches(exceptionObject.DoubleValue1, errorDoubleValue1, tolerance) &&
Matches(exceptionObject.DoubleValue2, errorDoubleValue2, tolerance) &&
Matches(exceptionObject.TextValue, errorTextValue));
}
private static void AssertFastEnough([NotNull] string involvedTables,
int count,
double maximumMilliseconds)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < count; i++)
{
IssueUtils.ParseInvolvedTables(involvedTables);
}
stopwatch.Stop();
long milliseconds = stopwatch.ElapsedMilliseconds;
double millisecondsPerOperation = (double)milliseconds / count;
Console.WriteLine(@"Parsing {0}: {1} ms", involvedTables, millisecondsPerOperation);
Assert.LessOrEqual(millisecondsPerOperation, maximumMilliseconds);
}
private static void ExpectException([NotNull] string involvedTablesString,
[CanBeNull] string expectedMessage)
{
try
{
IList <InvolvedTable> involvedTables =
IssueUtils.ParseInvolvedTables(involvedTablesString);
foreach (InvolvedTable involvedTable in involvedTables)
{
Console.WriteLine(@"- {0}", involvedTable);
}
Assert.Fail("Exception expected for invalid string: {0}", involvedTablesString);
}
catch (AssertionException exception)
{
Console.WriteLine(exception.Message);
if (expectedMessage != null)
{
Assert.AreEqual(expectedMessage, exception.Message);
}
}
}
public void CanParseEmptyTableString1()
{
IList <InvolvedTable> involvedTables = IssueUtils.ParseInvolvedTables(string.Empty);
Assert.AreEqual(0, involvedTables.Count);
}
