public void AvrDataTableCopyTest()
{
QueryTableHeaderModel model = GetQueryTableHeaderModel();
var original = new AvrDataTable(model, 1024);
original.Rows.Add(original.NewRow(new object[original.Columns.DistinctCount]));
Assert.AreEqual(1, original.Rows.Count);
AvrDataTable copy = original.Copy();
Assert.IsNotNull(copy);
Assert.AreEqual(original.TableName, copy.TableName);
Assert.AreNotSame(copy, original);
Assert.IsTrue(copy.Rows.Count > 0);
for (int i = 0; i < original.Count; i++)
{
var row = (AvrDataRow)original[i];
var copyRow = (AvrDataRow)copy[i];
Assert.AreNotSame(row, copyRow);
Assert.IsNotNull(row.Array);
Assert.IsNotNull(copyRow.Array);
Assert.AreNotSame(row.Array, copyRow.Array);
Assert.AreEqual(row.Count, copyRow.Count);
for (int j = 0; j < row.Count; j++)
{
Assert.AreEqual(row[j], copyRow[j]);
}
}
}
public void AvrDataTableRejectChangesTest()
{
QueryTableHeaderModel model = GetQueryTableHeaderModel();
var table = new AvrDataTable(model, 1024);
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
Assert.AreEqual(2, table.Rows.Count);
table.RejectChanges();
Assert.AreEqual(0, table.Rows.Count);
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
Assert.AreEqual(2, table.Rows.Count);
table.AcceptChanges();
table.RejectChanges();
Assert.AreEqual(2, table.Rows.Count);
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
Assert.AreEqual(3, table.Rows.Count);
table.RejectChanges();
Assert.AreEqual(2, table.Rows.Count);
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
Assert.AreEqual(3, table.Rows.Count);
table.AcceptChanges();
table.RejectChanges();
Assert.AreEqual(3, table.Rows.Count);
}
public void AvrDataTableCloneTest()
{
QueryTableHeaderModel model = GetQueryTableHeaderModel();
var original = new AvrDataTable(model, 1024);
original.Rows.Add(original.NewRow(new object[original.Columns.DistinctCount]));
original.Rows.Add(original.NewRow(new object[original.Columns.DistinctCount]));
Assert.AreEqual(2, original.Rows.Count);
AvrDataTable clone = original.Clone();
Assert.IsNotNull(clone);
Assert.AreNotSame(clone, original);
Assert.AreEqual(0, clone.Rows.Count);
Assert.AreEqual(original.TableName, clone.TableName);
Assert.AreEqual(clone.Columns.Count, original.Columns.Count);
Assert.AreEqual(clone.Columns.DistinctCount, original.Columns.DistinctCount);
Assert.AreEqual(clone.Columns.Properties.Count, original.Columns.Properties.Count);
foreach (var column in original.Columns)
{
Assert.IsTrue(clone.Columns.Contains(column.ColumnName));
Assert.IsFalse(clone.Columns.Contains(column));
}
}
private static QueryTableHeaderModel GetQueryTableHeaderModel()
{
QueryTableModel tableModel = AvrDbHelper.GetQueryResult(49539640000000, "en", false);
var zippedHeader = new QueryTableHeaderDTO(tableModel.Header, 1, tableModel.BodyPackets.Count);
var original = new QueryTableHeaderModel(zippedHeader);
return(original);
}
public AvrDataTable(QueryTableHeaderModel headerModel, int capacity)
: base(capacity)
{
Utils.CheckNotNull(headerModel, "headerModel");
foreach (BaseColumnModel columnModel in headerModel.ColumnTypeByName)
{
Columns.Add(columnModel.Name, columnModel.Caption, columnModel.FinalType);
}
}
public void TestExecuteArchiveQuery()
{
QueryTableModel tableModel = AvrDbHelper.GetQueryResult(49539640000000, "en", true);
Assert.IsNotNull(tableModel);
IList <QueryTablePacketDTO> packets = tableModel.BodyPackets;
Assert.IsNotNull(packets);
Assert.IsNotNull(tableModel.Header);
Assert.AreEqual("en", tableModel.Language);
Assert.AreEqual(49539640000000, tableModel.QueryId);
Assert.IsTrue(packets.Count >= 1 * 2);
Assert.IsTrue(packets.Any(p => p.IsArchive));
Assert.IsTrue(packets.Any(p => !p.IsArchive));
var zippedHeader = new QueryTableHeaderDTO(tableModel.Header, 1, packets.Count);
var headerModel = new QueryTableHeaderModel(zippedHeader);
Assert.AreEqual(m_FieldCount, headerModel.ColumnCount);
}
public void QueryTableHeaderModelCloneTest()
{
QueryTableHeaderModel original = GetQueryTableHeaderModel();
QueryTableHeaderModel clone = original.Clone();
Assert.IsNotNull(clone);
Assert.AreNotSame(clone, original);
Assert.AreEqual(original.ColumnCount, clone.ColumnCount);
Assert.AreEqual(original.PacketCount, clone.PacketCount);
Assert.AreEqual(original.QueryCacheId, clone.QueryCacheId);
Assert.AreNotSame(original.ColumnTypeByName, clone.ColumnTypeByName);
Assert.AreEqual(original.ColumnTypeByName.Count, clone.ColumnTypeByName.Count);
for (int i = 0; i < original.ColumnTypeByName.Count; i++)
{
BaseColumnModel originalColumn = original.ColumnTypeByName[i];
BaseColumnModel cloneColumn = clone.ColumnTypeByName[i];
Assert.AreNotSame(originalColumn, cloneColumn);
Assert.AreEqual(originalColumn.Caption, cloneColumn.Caption);
Assert.AreEqual(originalColumn.FinalType, cloneColumn.FinalType);
Assert.AreEqual(originalColumn.InitilalType, cloneColumn.InitilalType);
Assert.AreEqual(originalColumn.Name, cloneColumn.Name);
}
Assert.AreNotSame(original.ColumnTypes, clone.ColumnTypes);
Assert.AreEqual(original.ColumnTypes.Length, clone.ColumnTypes.Length);
for (int i = 0; i < original.ColumnTypes.Length; i++)
{
Type originalType = original.ColumnTypes[i];
Type cloneType = clone.ColumnTypes[i];
Assert.AreEqual(originalType.Name, cloneType.Name);
}
}
public void GetCachedQueryTest()
{
AVRFacade facade;
using (new StopwathTransaction("AVRFacade .ctor"))
{
facade = new AVRFacade(m_Container);
}
QueryTableHeaderDTO headerDTO;
using (new StopwathTransaction("GetCachedQueryTableHeader"))
{
//fn_AVR_HumanCaseReport
headerDTO = facade.GetCachedQueryTableHeader(49539640000000, "en", false);
}
var headerModel = new QueryTableHeaderModel(headerDTO);
Assert.AreEqual(m_FieldCount, headerModel.ColumnCount);
Assert.IsTrue(headerModel.ColumnTypeByName.Exists(c => c.Name == "sflHC_FinalDiagnosis"));
Type stringType = headerModel.ColumnTypeByName.Find(c => c.Name == "sflHC_FinalDiagnosis").FinalType;
Assert.AreEqual(typeof(string), stringType);
Assert.IsTrue(headerModel.ColumnTypeByName.Exists(c => c.Name == "sflHC_FinalDiagnosisDate"));
stringType = headerModel.ColumnTypeByName.Find(c => c.Name == "sflHC_FinalDiagnosisDate").FinalType;
Assert.AreEqual(typeof(DateTime), stringType);
for (int i = 0; i < headerDTO.PacketCount; i++)
{
QueryTablePacketDTO packetDTO;
using (new StopwathTransaction("GetCachedQueryTablePacket " + i))
{
packetDTO = facade.GetCachedQueryTablePacket(headerModel.QueryCacheId, i, headerDTO.PacketCount);
}
QueryTablePacketDTO unzipped;
using (new StopwathTransaction(string.Format("-Unzip Packet #{0}", i)))
{
unzipped = BinaryCompressor.Unzip(packetDTO);
}
StreamTablePacketDTO unzippedStream;
using (new StopwathTransaction(string.Format("-Unzip Packet #{0} into stream", i)))
{
unzippedStream = BinaryCompressor.UnzipStream(packetDTO);
}
AvrDataTable deserialized = new AvrDataTable(headerModel, 10240);
using (new StopwathTransaction(string.Format("--Deserialize Packet #{0}", i)))
{
BinarySerializer.DeserializeBodyPacket(unzipped, headerModel.ColumnTypes, deserialized);
}
AvrDataTable deserializedStream = new AvrDataTable(headerModel, 10240);
using (new StopwathTransaction(string.Format("--Deserialize Packet #{0} into stream", i)))
{
BinarySerializer.DeserializeBodyPacket(unzippedStream, headerModel.ColumnTypes, deserializedStream);
}
Assert.AreNotSame(deserialized, deserializedStream);
Assert.AreEqual(deserialized.Count, deserializedStream.Count);
Assert.AreEqual(deserialized.Columns.Count, deserializedStream.Columns.Count);
int diagnosisIndex = headerModel.ColumnTypeByName
.Select(c => c.Name)
.TakeWhile(key => key != "sflHC_FinalDiagnosis")
.Count();
bool found = false;
for (int j = 0; j < deserialized.Count; j++)
{
var row = (AvrDataRowEx)deserialized[j];
var rowStream = (AvrDataRowEx)deserializedStream[j];
Assert.AreNotSame(row, rowStream);
Assert.AreEqual(row.Count, rowStream.Count);
for (int k = 0; k < row.Count; k++)
{
Assert.AreEqual(row[k], rowStream[k]);
}
if (row[diagnosisIndex].ToString() == "Smallpox")
{
found = true;
}
}
Assert.IsTrue(found);
}
}
