public void NewWithDerivedTable()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var table = dataSet.Tables.Random(item => item.TemplateNamespace != string.Empty);
new CremaTemplate(table);
}
public CremaTemplateColumn_InTemplate_PropertyTest()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
this.template = new CremaTemplate(dataSet.Tables.Random(item => item.TemplateNamespace == string.Empty));
this.column = this.template.Columns.Random();
}
public void ChangeCremaType_Fail()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var table = new CremaDataTable();
try
{
table.Columns.Add(RandomUtility.NextIdentifier(), dataSet.Types.Random());
Assert.Inconclusive();
}
catch
{
}
Assert.IsFalse(table.Columns.Any());
var column = table.Columns.Add(RandomUtility.NextIdentifier());
try
{
column.CremaType = dataSet.Types.Random();
Assert.Inconclusive();
}
catch
{
}
Assert.IsNull(column.CremaType);
}
public void WriteToXmlWriter_ReadFromXmlReader()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var testSet = new CremaDataSet();
foreach (var item in dataSet.Tables)
{
if (item.TemplateNamespace != string.Empty)
{
continue;
}
var schemaBuilder = new StringBuilder();
var xmlBuilder = new StringBuilder();
using (var schemaWriter = XmlWriter.Create(schemaBuilder))
{
item.WriteXmlSchema(schemaWriter);
}
using (var xmlWriter = XmlWriter.Create(xmlBuilder))
{
item.WriteXml(xmlWriter);
}
try
{
using (var sr = new StringReader(schemaBuilder.ToString()))
using (var reader = XmlReader.Create(sr))
{
testSet.ReadXmlSchema(reader);
}
if (item.Columns.Where(i => i.CremaType != null).Any() == true)
{
Assert.Fail("테이블이 사용자타입을 사용하는 경우 읽어들이는데 실패를 해야함.");
}
}
catch
{
using var sr = new StringReader(schemaBuilder.ToString());
using var reader = XmlReader.Create(sr);
testSet.ReadXmlSchema(reader, new CremaTypeXmlResolver(dataSet, item.Namespace));
}
using (var sr = new StringReader(xmlBuilder.ToString()))
using (var reader = XmlReader.Create(sr))
{
testSet.ReadXml(reader);
}
}
foreach (var item in dataSet.Tables)
{
if (item.TemplateNamespace != string.Empty)
{
continue;
}
var newTable = testSet.Tables[item.Name];
CremaComparer.CompareTable(item, newTable);
}
}
public void ChangeRelationName()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var table = dataSet.Tables.Random(item => item.Childs.Any() && item.TemplatedParent == null && item.DerivedTables.Any());
table.TableName = RandomUtility.NextIdentifier();
var xml = table.GetXml();
}
public void RelationTestOnRenameChild()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var table = dataSet.Tables.Random(item => item.Childs.Any() && item.TemplatedParent == null);
var child = table.Childs.Random();
child.TableName = RandomUtility.NextIdentifier();
var xml = table.GetXml();
}
public void CreateWithCremaType()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
foreach (var item in dataSet.Types)
{
var column = new CremaDataColumn(RandomUtility.NextIdentifier(), item);
Assert.IsNotNull(column);
}
}
public void Change_CategoryTest()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var dataTable1 = dataSet.Tables.Random(item => item.TemplatedParent == null && item.Parent == null);
var modification = dataTable1.ModificationInfo;
Thread.Sleep(1000);
dataTable1.CategoryPath = RandomUtility.NextCategoryPath();
Assert.AreEqual(modification, dataTable1.ModificationInfo);
}
public void XmlSerializing()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
foreach (var item in dataSet.Types)
{
string xml = XmlSerializerUtility.GetString(item);
var newType = XmlSerializerUtility.ReadString <CremaDataType>(xml);
CremaComparer.CompareType(item, newType);
}
}
public void ContentsInfoAfterSetFields()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var row = dataSet.Tables.Random().Rows.RandomOrDefault();
if (row == null || row.SetRandomValue() == false)
{
return;
}
Assert.AreNotEqual(row.ModificationInfo, SignatureDate.Empty);
Assert.AreNotEqual(row.CreationInfo, row.ModificationInfo);
Assert.AreEqual(row.ModificationInfo, row.Table.ContentsInfo);
}
public void WriteToString_ReadFromString()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var testSet = new CremaDataSet();
foreach (var item in dataSet.Types)
{
string schema = item.GetXmlSchema();
testSet.ReadTypeString(schema);
var newType = testSet.Types[item.TypeName];
CremaComparer.CompareType(item, newType);
}
}
public void ModificationInfoAfterSetFields()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var type = dataSet.Types.Random();
var member = type.AddRandomMember();
if (member == null)
{
return;
}
Assert.AreEqual(member.CreationInfo, member.ModificationInfo);
Assert.AreEqual(member.ModificationInfo, type.ModificationInfo);
}
public void WriteToStream_ReadFromStream()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var testSet = new CremaDataSet();
foreach (var item in dataSet.Tables)
{
if (item.TemplateNamespace != string.Empty)
{
continue;
}
var schemaStream = new MemoryStream();
var xmlStream = new MemoryStream();
item.WriteXmlSchema(schemaStream);
item.WriteXml(xmlStream);
//try
//{
// schemaStream.Position = 0;
// testSet.ReadXmlSchema(schemaStream);
// if (item.Columns.Where(i => i.CremaType != null).Any() == true)
// Assert.Fail("테이블이 사용자타입을 사용하는 경우 읽어들이는데 실패를 해야함.");
//}
//catch
//{
// if (item.Columns.Where(i => i.CremaType != null).Any() == false)
// Assert.Fail("스키마 읽어들이는데 실패함");
schemaStream.Position = 0;
testSet.ReadXmlSchema(schemaStream, new CremaTypeXmlResolver(dataSet, item.Namespace));
//}
xmlStream.Position = 0;
testSet.ReadXml(xmlStream);
}
foreach (var item in dataSet.Tables)
{
if (item.TemplateNamespace != string.Empty)
{
continue;
}
var newTable = testSet.Tables[item.Name];
CremaComparer.CompareTable(item, newTable);
}
}
public void ModificationInfoAfterAddNew()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var type = dataSet.Types.Random();
var member = type.AddRandomMember();
if (member == null)
{
return;
}
Assert.AreNotEqual(member.CreationInfo, SignatureDate.Empty);
Assert.AreNotEqual(member.ModificationInfo, SignatureDate.Empty);
Assert.AreEqual(member.ModificationInfo, type.ModificationInfo);
}
public void WriteToTextWriter_ReaderFromTextReader()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var testSet = new CremaDataSet();
foreach (var item in dataSet.Types)
{
var sw = new StringWriter();
item.Write(sw);
var sr = new StringReader(sw.ToString());
testSet.ReadType(sr);
var newType = testSet.Types[item.TypeName];
CremaComparer.CompareType(item, newType);
}
}
public void AddToAnotherDataSet_Fail()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var testSet = new CremaDataSet();
foreach (var item in dataSet.Types)
{
try
{
testSet.Types.Add(item);
Assert.Fail("실패하지 않았습니다.");
}
catch
{
}
}
}
public void SetCremaType_Fail3()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var table = new CremaDataTable();
try
{
var column = table.Columns.Add("Column1", dataSet.Types.Random());
}
catch (CremaDataException)
{
}
catch
{
Assert.Inconclusive();
}
}
public void WriteToStream_ReadFromStream()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var testSet = new CremaDataSet();
foreach (var item in dataSet.Types)
{
var ms = new MemoryStream();
item.Write(ms);
ms.Position = 0;
testSet.ReadType(ms);
var newType = testSet.Types[item.TypeName];
CremaComparer.CompareType(item, newType);
}
}
public void AddNullToDataSet_Fail()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
try
{
CremaDataType type = null;
dataSet.Types.Add(type);
Assert.Fail("실패하지 않았습니다.");
}
catch (ArgumentNullException)
{
}
catch
{
Assert.Fail("잘못된 예외");
}
}
public void ContentsInfoAfterDelete()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var dataRow = dataSet.Tables.Random().Rows.RandomOrDefault();
if (dataRow == null)
{
return;
}
var table = dataRow.Table;
var modificationInfo = table.ContentsInfo;
Thread.Sleep(1000);
dataRow.Delete();
Assert.AreNotEqual(table.ContentsInfo, modificationInfo);
table.AcceptChanges();
}
public void WriteToXmlWriter_ReaderFromXmlReader()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var testSet = new CremaDataSet();
foreach (var item in dataSet.Types)
{
var sb = new StringBuilder();
var writer = XmlWriter.Create(sb);
item.Write(writer);
writer.Close();
var sr = new StringReader(sb.ToString());
var reader = XmlReader.Create(sr);
testSet.ReadType(reader);
var newType = testSet.Types[item.TypeName];
CremaComparer.CompareType(item, newType);
}
}
public void ContentsInfoAfterAddNew()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
for (int i = 0; i < 10; i++)
{
var table = dataSet.Tables.Random();
var row = table.AddRandomRow(false);
if (row == null)
{
continue;
}
Assert.AreNotEqual(row.CreationInfo, SignatureDate.Empty);
Assert.AreNotEqual(row.ModificationInfo, SignatureDate.Empty);
Assert.AreEqual(row.CreationInfo, row.ModificationInfo);
Assert.AreEqual(row.ModificationInfo, table.ContentsInfo);
}
}
public void RemoveUsingType()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var query = from table in dataSet.Tables
from column in table.Columns
where column.CremaType != null
select column;
var types = query.Select(item => item.CremaType).Distinct().ToArray();
var columns = query.ToArray();
foreach (var item in columns)
{
item.CremaType = null;
}
foreach (var item in types)
{
dataSet.Types.Remove(item);
}
}
public void ChangeDataType_Complex()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var query = from table in dataSet.Tables
where table.Parent == null && table.TemplateNamespace == string.Empty
from column in table.Columns
where column.DataType == typeof(int) && column.AutoIncrement == false
select column;
var columns = query.ToArray();
foreach (var item in columns)
{
item.DataType = typeof(string);
}
foreach (var item in columns)
{
item.DataType = typeof(int);
}
}
public void WriteToFile_ReadFromFile()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
var testSet = new CremaDataSet();
foreach (var item in dataSet.Types)
{
string schemaPath = PathUtility.GetTempFileName();
item.Write(schemaPath);
try
{
testSet.ReadType(schemaPath);
}
finally
{
FileUtility.Delete(schemaPath);
}
var newType = testSet.Types[item.TypeName];
CremaComparer.CompareType(item, newType);
}
}
public void WriteToFile_ReadFromFile()
{
var testSet = new CremaDataSet();
var dataSet = CremaDataSetExtensions.CreateRandomSet();
foreach (var item in dataSet.Tables)
{
var schemaPath = PathUtility.GetTempFileName();
var xmlPath = PathUtility.GetTempFileName();
try
{
if (item.TemplateNamespace == string.Empty)
{
item.WriteXmlSchema(schemaPath);
}
else
{
item.TemplatedParent.WriteXmlSchema(schemaPath);
}
item.WriteXml(xmlPath);
try
{
if (item.TemplateNamespace == string.Empty)
{
testSet.ReadXmlSchema(schemaPath);
}
else
{
testSet.ReadXmlSchema(schemaPath, new ItemName(item.CategoryPath, item.Name));
}
if (item.Columns.Where(i => i.CremaType != null).Any() == true)
{
Assert.Fail("테이블이 사용자타입을 사용하는 경우 읽어들이는데 실패를 해야함.");
}
}
catch
{
if (item.TemplateNamespace == string.Empty)
{
testSet.ReadXmlSchema(schemaPath, new CremaTypeXmlResolver(dataSet, item.Namespace));
}
else
{
testSet.ReadXmlSchema(schemaPath, new ItemName(item.CategoryPath, item.Name), new CremaTypeXmlResolver(dataSet, item.Namespace));
}
}
if (item.TemplateNamespace == string.Empty)
{
testSet.ReadXml(xmlPath);
}
else
{
testSet.ReadXml(xmlPath, new ItemName(item.CategoryPath, item.Name));
}
}
finally
{
FileUtility.Delete(schemaPath);
FileUtility.Delete(xmlPath);
}
}
foreach (var item in dataSet.Tables)
{
var newTable = testSet.Tables[item.Name];
CremaComparer.CompareTable(item, newTable);
}
}
public CremaTemplate_ComplexTest()
{
this.dataSet = CremaDataSetExtensions.CreateRandomSet();
}
