public void Init()
{
helper = new DummyHelper
{
ServerUtility = new StubServerUtility()
};
}
public void Init()
{
helper = new DummyHelper
{
ServerUtility = new StubServerUtility()
};
}
/// <summary>
/// 字典表查询
/// </summary>
/// <returns></returns>
public QueryData <Dummy> Retrieves()
{
if (string.IsNullOrEmpty(Order))
{
Order = "asc";
}
if (string.IsNullOrEmpty(Sort))
{
Sort = "Item1";
}
var data = DummyHelper.Retrieves();
if (!string.IsNullOrEmpty(Item1))
{
data = data.Where(t => t.Item1.Contains(Item1, StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(Item2))
{
data = data.Where(t => t.Item2.Contains(Item2, StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(Item3))
{
// 此列为数值型
data = data.Where(t => t.Item3.ToString() == Item3);
}
if (!string.IsNullOrEmpty(Search))
{
// 处理快捷搜索文本条件
data = data.Where(t => t.Item1.Contains(Search, StringComparison.OrdinalIgnoreCase) || t.Item2.Contains(Search, StringComparison.OrdinalIgnoreCase));
}
var ret = new QueryData <Dummy>();
ret.total = data.Count();
// 通过option.Sort属性判断对那列进行排序
switch (Sort)
{
case "Item1":
data = Order == "asc" ? data.OrderBy(t => t.Item1) : data.OrderByDescending(t => t.Item1);
break;
case "Item2":
data = Order == "asc" ? data.OrderBy(t => t.Item2) : data.OrderByDescending(t => t.Item2);
break;
case "Item3":
data = Order == "asc" ? data.OrderBy(t => t.Item3) : data.OrderByDescending(t => t.Item3);
break;
}
ret.rows = data.Skip(Offset).Take(Limit);
return(ret);
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
var type = ctorExpression.Type();
if (!type.IsResolved)
{
return(null);
}
var properties = type.GetClassType()?.Properties;
if (properties == null)
{
return(null);
}
var objectInitializer = ctorExpression.Initializer as IObjectInitializer ?? factory.CreateObjectInitializer();
var initializedProperties = new HashSet <string>(objectInitializer.MemberInitializers.OfType <IPropertyInitializer>().Select(x => x.MemberName));
var classDeclaration = provider.GetSelectedElement <IClassDeclaration>();
var hasTestBaseSuperType = classDeclaration.GetAllSuperTypes().Any(x => x.GetClassType()?.ShortName.Contains("TestBase") ?? false);
var dummyHelper = new DummyHelper();
var properiesToInitialize = new List <(string Name, string Value)>();
foreach (var property in properties.Where(x => !initializedProperties.Contains(x.ShortName)))
{
var propertyDummyValue = hasTestBaseSuperType
? dummyHelper.GetParamValue(property.Type, property.ShortName)
: "TODO";
properiesToInitialize.Add((Name: property.ShortName, Value: propertyDummyValue));
}
foreach (var(name, value) in properiesToInitialize)
{
var initializer = factory.CreateObjectPropertyInitializer(name, factory.CreateExpression("$0", value));
objectInitializer.AddMemberInitializerBefore(initializer, null);
}
ctorExpression.SetInitializer(objectInitializer);
return(null);
}
public void Cleanup()
{
Thread.Sleep(50); // wait for files to be released
// Attach updater log
if (File.Exists(UpdaterLogFilePath))
{
TestContext.AddTestAttachment(UpdaterLogFilePath, "Updater log");
}
// Delete dummy
DummyHelper.DeleteDummy();
// Delete storage
if (Directory.Exists(StorageDirPath))
{
Directory.Delete(StorageDirPath, true);
}
}
public async Task UpdateManager_PerformUpdateIfAvailableAsync_Test()
{
// Arrange
DummyHelper.SetupDummy(
Version.Parse("1.0.0.0"),
Version.Parse("1.0.0.0"), Version.Parse("2.0.0.0"), Version.Parse("3.0.0.0"));
// Assert current version
var oldVersion = await DummyHelper.GetDummyVersionAsync();
Assert.That(oldVersion, Is.EqualTo(Version.Parse("1.0.0.0")));
// Update dummy via Onova
await DummyHelper.UpdateDummyAsync();
// Assert current version again
var newVersion = await DummyHelper.GetDummyVersionAsync();
Assert.That(newVersion, Is.EqualTo(Version.Parse("3.0.0.0")));
}
public bool Delete([FromBody] IEnumerable <string> value) => DummyHelper.Delete(value);
public bool Post([FromBody] Dummy value) => DummyHelper.Save(value);
public void Init()
{
helper = new DummyHelper();
helper.ServerUtility = new StubServerUtility();
}
private void RunHelper(Object stateInfo)
{
var state = (State) stateInfo;
var startTime = DateTime.Now;
IAssertionHelper helper = new DummyHelper()
{
Assert = new Assert(),
Log = new Log()
};
object fixture = null;
var exceptions = new TestCycleExceptions();
Result finalResult = null;
try
{
fixture = _init(_type, _constructorArgs.Parameters);
var helpertemp = fixture as IAssertionHelper;
if (helpertemp != null)
{
helpertemp.Assert = helper.Assert;
helpertemp.Log = helper.Log;
helper = helpertemp;
}
if (_constructorArgs.Disposed)
{
throw new InvalidOperationException("Type ParameterSet Disposed Regenerated Tests to rerun");
}
if (_methodArgs.Disposed)
{
throw new InvalidOperationException(
"Method ParameterSet Disposed Regenerated Tests to rerun");
}
try
{
var result = _invoke(helper, _method, fixture, _methodArgs.Parameters);
//If the test method returns a boolean, true increments assertion
if (result as bool? ?? false)
{
helper.Assert.Okay();
}
//If the test method returns a boolean, false is fail
if (!(result as bool? ?? true))
{
helper.Assert.Fail("Test returned false.");
}
if (result is IReturnedResult)
{
finalResult = new Result(state.Platform,
startTime, DateTime.Now, result as IReturnedResult);
}
}
catch (Exception ex)
{
exceptions.Add(TestCycle.Test, ex);
}
}
catch (Exception ex)
{
exceptions.Add(TestCycle.Setup, ex);
}
finally
{
try
{
var disposable = fixture as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
catch (Exception ex)
{
exceptions.Add(TestCycle.Teardown, ex);
}
exceptions.WriteOutExceptions(helper);
state.Result = finalResult ?? new Result(state.Platform, exceptions.GetResult(helper), startTime, DateTime.Now, helper);
state.Event.Set();
}
}
private MockInfo[] GenerateNewMockInfos(IList <IParameter> callParams, ArgumentInfo[] existedArguments, CSharpElementFactory factory)
{
var existedArgumentsList = existedArguments.ToList();
var mockInfos = new List <MockInfo>();
var dummyHelper = new DummyHelper();
foreach (var callParam in callParams)
{
var isArray = callParam.Type is IArrayType;
var callParamType = callParam.Type;
var existArgument = existedArgumentsList.Pop(x => x.IsCSharpArgument && x.Type.IsImplicitlyConvertibleTo(callParam.Type, cSharpTypeConversionRule));
if (existArgument != null)
{
continue;
}
var ctorParamName = callParam.ShortName;
if (isArray)
{
var scalarType = callParamType.GetScalarType();
var singleName = GetSingleName(ctorParamName);
var arrayParamNames = Enumerable.Range(1, 2).Select(x => $"{singleName}{x}").ToArray();
var existedParamNames = new HashSet <string>(mockInfos.Select(x => x.Name));
while (true)
{
if (arrayParamNames.Any(x => existedParamNames.Contains(x)))
{
for (var i = 0; i < arrayParamNames.Length; ++i)
{
arrayParamNames[i] = $"{arrayParamNames[i]}{i + 1}";
}
}
else
{
break;
}
}
foreach (var arrayParamName in arrayParamNames)
{
// ReSharper disable once PossibleNullReferenceException
var expression = factory.CreateExpression("$0;", dummyHelper.GetParamValue(scalarType.ToIType(), arrayParamName));
mockInfos.Add(new MockInfo
{
Statement = factory.CreateStatement("var $0 = $1;", arrayParamName, expression),
Type = ((IArrayType)callParam.Type).ElementType,
Name = arrayParamName
});
}
mockInfos.Add(new MockInfo
{
Statement = factory.CreateStatement("var $0 = $1;", callParam.ShortName, factory.CreateExpression($"new[] {{ {string.Join(", ", arrayParamNames)} }}")),
Type = callParam.Type,
Name = callParam.ShortName
});
}
else
{
mockInfos.Add(new MockInfo
{
Statement = factory.CreateStatement("var $0 = $1;", callParam.ShortName, factory.CreateExpression("$0;", dummyHelper.GetParamValue(callParam.Type, callParam.ShortName))),
Type = callParam.Type,
Name = callParam.ShortName
});
}
}
return(mockInfos.ToArray());
}
