public static CremaDataTable AddRandomTable(this CremaDataSet dataSet, string tableName)
{
var table = dataSet.Tables.Add(tableName);
table.AddRandomColumns(RandomUtility.Next(CremaDataTableExtensions.MinColumnCount, CremaDataTableExtensions.MaxColumnCount));
return(table);
}
public static async Task GenerateStandardContentAsync(this ITable table, Authentication authentication)
{
var content = table.Content;
await content.BeginEditAsync(authentication);
await content.EnterEditAsync(authentication);
await content.GenerateRowsAsync(authentication, RandomUtility.Next(10, 1000));
foreach (var item in content.Tables)
{
await item.Content.GenerateRowsAsync(authentication, RandomUtility.Next(10, 100));
}
try
{
await content.LeaveEditAsync(authentication);
await content.EndEditAsync(authentication);
}
catch
{
await content.CancelEditAsync(authentication);
}
}
public static void CreateTable(this CremaDataSet dataSet)
{
//var category = dataSet.Categories.Random();
var dataTable = dataSet.Tables.Add();
GenerateColumns(dataTable, RandomUtility.Next(3, 10));
if (RandomUtility.Within(25) == true)
{
dataTable.Comment = RandomUtility.NextString();
}
//dataTable.EndEdit();
while (RandomUtility.Within(10))
{
var childTable = dataTable.Childs.Add();
GenerateColumns(childTable, RandomUtility.Next(3, 10));
}
GenerateRows(dataTable, RandomUtility.Next(10, 100));
foreach (var item in dataTable.Childs)
{
GenerateRows(item, RandomUtility.Next(10, 100));
}
}
public static void ChildTableCreateTest(this IDataBase dataBase, Authentication authentication)
{
dataBase.Dispatcher.Invoke(() =>
{
var tableContext = dataBase.TableContext;
var table = tableContext.Tables.RandomOrDefault(item => item.Parent == null);
if (table == null || table.TemplatedParent != null)
{
return;
}
var template = table.NewTable(authentication);
try
{
template.SetTags(authentication, CremaRandomUtility.RandomTags());
template.SetComment(authentication, RandomUtility.NextString());
template.GenerateColumns(authentication, RandomUtility.Next(1, 10));
template.EndEdit(authentication);
}
catch
{
template.CancelEdit(authentication);
}
});
}
public static string GetRandomValue(this CremaDataType dataType)
{
if (dataType.Members.Any() == false)
{
throw new Exception(dataType.TypeName);
}
if (dataType.IsFlag == true)
{
long value = 0;
var count = RandomUtility.Next(1, dataType.Members.Count);
for (var i = 0; i < count; i++)
{
var index = RandomUtility.Next(dataType.Members.Count);
value |= dataType.Members[index].Value;
}
var textvalue = dataType.ConvertToString(value);
if (textvalue == string.Empty)
{
throw new Exception();
}
return(textvalue);
}
else
{
return(dataType.Members.Random().Name);
}
}
//[ActionTarget(ActionTargets.TableContent)]
//[ActionType(ActionTypes.Change)]
public static void TableContentEditManyTest(this IDataBase dataBase, Authentication authentication)
{
dataBase.Dispatcher.Invoke(() =>
{
var tableContext = dataBase.TableContext;
var table = tableContext.Tables.RandomOrDefault(item => item.Parent == null);
if (table == null)
{
return;
}
var content = table.Content;
content.EnterEdit(authentication);
var contents = EnumerableUtility.Friends(content, content.Childs);
try
{
contents.Random().EditRandom(authentication, RandomUtility.Next(1000));
content.LeaveEdit(authentication);
}
catch
{
content.LeaveEdit(authentication);
}
});
}
public static void TableTemplateEditTest(this IDataBase dataBase, Authentication authentication)
{
dataBase.Dispatcher.Invoke(() =>
{
var tableContext = dataBase.TableContext;
var table = tableContext.Tables.RandomOrDefault(item => item.TemplatedParent == null);
if (table == null || table.TemplatedParent != null || table.TableState != TableState.None)
{
return;
}
var template = table.Template;
template.BeginEdit(authentication);
try
{
template.EditRandom(authentication, RandomUtility.Next(5, 10));
template.EndEdit(authentication);
}
catch
{
template.CancelEdit(authentication);
}
});
}
public static void TableCreateTest(this IDataBase dataBase, Authentication authentication)
{
dataBase.Dispatcher.Invoke(() =>
{
var tableContext = dataBase.TableContext;
var category = tableContext.Categories.RandomOrDefault(item => item.VerifyAccessType(authentication, AccessType.Master));
if (category == null)
{
return;
}
var template = category.NewTable(authentication);
try
{
template.SetTags(authentication, CremaRandomUtility.RandomTags());
template.SetComment(authentication, RandomUtility.NextString());
template.GenerateColumns(authentication, RandomUtility.Next(1, 10));
template.EndEdit(authentication);
}
catch
{
template.CancelEdit(authentication);
}
});
}
public void StringToTimeSpan_Fail()
{
var value = RandomUtility.Next <TimeSpan>().TotalSeconds.ToString("R");
this.AddRows(value);
column.DataType = typeof(TimeSpan);
}
public async Task InvokeAsync(TaskContext context)
{
var authentication = context.Authentication;
var category = context.Target as ITableCategory;
var tables = category.GetService(typeof(ITableCollection)) as ITableCollection;
var categories = category.GetService(typeof(ITableCategoryCollection)) as ITableCategoryCollection;
if (context.IsCompleted(category) == true)
{
context.Pop(category);
}
else if (categories.Count < RandomUtility.Next(Math.Max(10, categories.Count + 1)))
{
await this.AddNewCategoryAsync(category, context);
context.Complete(category);
}
else if (tables.Count < RandomUtility.Next(Math.Max(10, tables.Count + 1)))
{
var template = await category.AddNewTableAsync(authentication);
context.Push(template);
}
else
{
context.Complete(category);
}
}
public void StringToDateTime_Fail()
{
var value = RandomUtility.Next <DateTime>().ToOADate().ToString("R");
this.AddRows(value);
column.DataType = typeof(DateTime);
}
public static string GetRandomString(this ITableColumn tableColumn)
{
if (tableColumn.DefaultValue != null && RandomUtility.Next(3) == 0)
{
return(null);
}
else if (tableColumn.AllowNull == true && RandomUtility.Next(4) == 0)
{
return(null);
}
else
{
var template = tableColumn.Template;
var dataType = tableColumn.DataType;
if (CremaDataTypeUtility.IsBaseType(dataType) == false)
{
var type = template.GetType(dataType);
return(type.GetRandomString());
}
else
{
var value = RandomUtility.Next(CremaDataTypeUtility.GetType(dataType));
return(CremaConvert.ChangeType(value, typeof(string)) as string);
}
}
}
public static object GetRandomValue(this CremaDataType dataType)
{
var typeInfo = dataType.TypeInfo;
if (typeInfo.Members.Length == 0)
{
throw new Exception(dataType.Name);
}
if (typeInfo.IsFlag == true)
{
long value = 0;
int count = RandomUtility.Next(1, typeInfo.Members.Length);
for (int i = 0; i < count; i++)
{
var index = RandomUtility.Next(typeInfo.Members.Length);
value |= typeInfo.Members[index].Value;
}
var textvalue = typeInfo.ConvertToString(value);
if (textvalue == string.Empty)
{
throw new Exception();
}
return(textvalue);
}
else
{
return(typeInfo.Members.Random().Name);
}
}
public static async Task <ITable> AddRandomChildTableAsync(this ITable table, Authentication authentication, DataBaseSettings settings)
{
var copyData = RandomUtility.NextBoolean();
var template = await table.NewTableAsync(authentication);
await template.InitializeRandomAsync(authentication);
await template.EndEditAsync(authentication);
if (template.Target is ITable[] tables)
{
foreach (var item in tables)
{
var minCount = settings.TableContext.MinRowCount;
var maxCount = settings.TableContext.MaxRowCount;
var count = RandomUtility.Next(minCount, maxCount);
await AddRandomRowsAsync(item, authentication, count);
}
return(tables.First());
}
else
{
throw new NotImplementedException();
}
}
public static void CreateTable(this ITableContext context, Authentication authentication)
{
var category = context.Categories.Random();
var template = category.NewTable(authentication);
GenerateColumns(template, authentication, RandomUtility.Next(3, 10));
if (RandomUtility.Within(25) == true)
{
template.SetComment(authentication, RandomUtility.NextString());
}
template.EndEdit(authentication);
var table = template.Table;
while (RandomUtility.Within(10))
{
var childTemplate = table.NewTable(authentication);
GenerateColumns(childTemplate, authentication, RandomUtility.Next(3, 10));
childTemplate.EndEdit(authentication);
}
var content = table.Content;
content.EnterEdit(authentication);
GenerateRows(content, authentication, RandomUtility.Next(10, 100));
foreach (var item in table.Childs)
{
GenerateRows(item.Content, authentication, RandomUtility.Next(10, 100));
}
content.LeaveEdit(authentication);
}
public void InvokeTask(TaskContext context)
{
var category = context.Target as ITableCategory;
category.Dispatcher.Invoke(() =>
{
var tables = category.GetService(typeof(ITableCollection)) as ITableCollection;
var categories = category.GetService(typeof(ITableCategoryCollection)) as ITableCategoryCollection;
if (context.IsCompleted(category) == true)
{
context.Pop(category);
}
else if (categories.Count < RandomUtility.Next(Math.Max(10, categories.Count + 1)))
{
this.AddNewCategory(category, context);
context.Complete(category);
}
else if (tables.Count < RandomUtility.Next(Math.Max(10, tables.Count + 1)))
{
var template = category.NewTable(context.Authentication);
context.Push(template);
}
else
{
context.Complete(category);
}
});
}
public void SetIndex(ITypeMember member, TaskContext context)
{
member.Dispatcher.Invoke(() =>
{
var index = RandomUtility.Next(member.Template.Count);
member.SetIndex(context.Authentication, index);
});
}
public static CremaDataTable CreateRandomTable(string prefix, string postfix)
{
var dataTable = new CremaDataTable(IdentifierUtility.Next(prefix, postfix));
dataTable.AddRandomColumns(RandomUtility.Next(MinColumnCount, MaxColumnCount));
dataTable.AddRandomRows(RandomUtility.Next(MinRowCount, MaxRowCount));
return(dataTable);
}
public void SetIndex(ITableColumn column, TaskContext context)
{
column.Dispatcher.Invoke(() =>
{
var index = RandomUtility.Next(column.Template.Count);
column.SetIndex(context.Authentication, index);
});
}
public static CremaDataTable AddRandomChild(this CremaDataTable dataTable)
{
var childTable = dataTable.Childs.Add(IdentifierUtility.Next(ChildPrefix, ChildPostfix));
childTable.AddRandomColumns(RandomUtility.Next(CremaDataTableExtensions.MinColumnCount, CremaDataTableExtensions.MaxColumnCount));
childTable.AddRandomRows(RandomUtility.Next(MinRowCount, MaxRowCount));
return(childTable);
}
public void SetDefaultValue()
{
this.attribute.DataType = CremaDataTypeUtility.GetBaseTypes().Random();
var newDefaultValue = RandomUtility.Next(this.attribute.DataType);
this.attribute.DefaultValue = newDefaultValue;
Assert.AreEqual(newDefaultValue, this.attribute.DefaultValue);
}
public void SetDefaultValueToAutoIncrementColumn_Fail()
{
this.column.DataType = CremaDataTypeUtility.GetBaseTypes().Random(item => CremaDataTypeUtility.CanUseAutoIncrement(item));
this.column.AutoIncrement = true;
var newDefaultValue = RandomUtility.Next(this.column.DataType);
this.column.DefaultValue = newDefaultValue;
Assert.AreEqual(newDefaultValue, this.column.DefaultValue);
}
public void DoubleToSingle()
{
var value1 = Convert.ChangeType(float.MinValue, typeof(double));
var value2 = Convert.ChangeType(float.MaxValue, typeof(double));
var value3 = Convert.ChangeType(RandomUtility.Next <float>(), typeof(double));
this.AddRows(value1, value2, value3);
column.DataType = typeof(float);
}
public static CremaDataType CreateRandomType(string prefix, string postfix)
{
var dataType = new CremaDataType(IdentifierUtility.Next(prefix, postfix));
dataType.IsFlag = RandomUtility.Within(25);
dataType.Comment = RandomUtility.Within(25) ? string.Empty : RandomUtility.NextString();
dataType.AddRandomMembers(RandomUtility.Next(CremaDataTypeExtensions.MinMemberCount, CremaDataTypeExtensions.MaxMemberCount));
return(dataType);
}
public void SetIndex()
{
var column = this.RandomOrDefault();
var index = RandomUtility.Next(column.Table.Columns.Count);
column.Index = index;
Assert.AreEqual(index, column.Index);
Assert.AreEqual(column, column.Table.Columns[index]);
}
public async Task AddNewUserAsync(IUserCategory category, TaskContext context)
{
var authentication = context.Authentication;
var index = RandomUtility.Next(int.MaxValue);
var authority = RandomUtility.NextEnum <Authority>();
var userID = $"{authority.ToString().ToLower()}_bot_{index}";
var userName = "******" + index;
await category.AddNewUserAsync(authentication, userID, ToSecureString("1111"), userName, authority);
}
public void StringToDateTime()
{
var value1 = DateTime.MinValue.ToString("o");
var value2 = DateTime.MaxValue.ToString("o");
var value3 = RandomUtility.Next <DateTime>().ToString("o");
this.AddRows(value1, value2, value3);
column.DataType = typeof(DateTime);
}
public void StringToTimeSpan()
{
var value1 = TimeSpan.MinValue.ToString();
var value2 = TimeSpan.MaxValue.ToString();
var value3 = RandomUtility.Next <TimeSpan>().ToString();
this.AddRows(value1, value2, value3);
column.DataType = typeof(TimeSpan);
}
public void SetEmptyDefaultValue()
{
var dataType = CremaDataTypeUtility.GetBaseTypes().Random();
var defaultValue = CremaConvert.ToString(RandomUtility.Next(dataType));
this.column.DefaultValue = defaultValue;
this.column.DataTypeName = dataType.GetTypeName();
this.column.DefaultValue = string.Empty;
Assert.AreEqual(DBNull.Value, this.column.DefaultValue);
}
public void AddMany()
{
var dataTable = new CremaDataTable();
var columnCount = RandomUtility.Next(1, 10);
for (var i = 0; i < columnCount; i++)
{
dataTable.Columns.Add();
}
Assert.AreEqual(columnCount, dataTable.Columns.Count);
}
