/// <summary>
/// 构造函数
/// </summary>
/// <param name="availableMethodsType">包含公式中可用静态方法的类型</param>
/// <param name="variableCoercisonStrategy">默认变量值约束策略</param>
public FormulaEvaluator(
Type availableMethodsType,
IVariableCoercionStrategy variableCoercisonStrategy)
{
this.availableMethodsType = availableMethodsType;
this.executor = new CSharpExecutor(availableMethodsType, variableCoercisonStrategy);
}
public async Task <ValidationResult> Validate(Sql.Models.Problem problem, string solution)
{
var testCaseResults = new List <TestCaseResult>();
foreach (var testCase in problem.TestCases)
{
string solutionContent = string.Empty;
if (string.IsNullOrWhiteSpace(testCase.Input) ||
testCase.Input.Equals("None", StringComparison.OrdinalIgnoreCase) ||
testCase.Input.Equals("N\\A", StringComparison.OrdinalIgnoreCase) ||
testCase.Input.StartsWith("None", StringComparison.OrdinalIgnoreCase))
{
}
else
{
solutionContent = testCase.Input;
solutionContent += Environment.NewLine;
}
solutionContent += solution;
var csharpExectuor = new CSharpExecutor(_azureFunctionsService);
var output = await csharpExectuor.Execute(solutionContent);
testCaseResults.Add(new TestCaseResult(testCase.Output, output.Trim()));
}
return(new ValidationResult(testCaseResults));
}
protected override void Execute(NativeActivityContext context)
{
var result = new CSharpExecutor(Code)
.Use("System")
.Execute <TInput, TOutput>(Arguments.Get(context));
Result.Set(context, result);
}
public void ShouldExecute(string code, string session, string input, string expectedOutput)
{
IExecutor executor = new CSharpExecutor();
var ret = executor.Execute(session, code, int.MaxValue, input, out var output, out var message);
Assert.IsTrue(ret);
Assert.IsNotEmpty(output);
Assert.IsEmpty(message);
Assert.AreEqual(expectedOutput, output.Trim(), $"{expectedOutput} are not equal {output.Trim()}");
}
public async Task DoubleThrowWhenEvalDivideByZeroTest()
{
var evaluator = new CSharpExecutor(typeof(Math), new NullNotAllowedStrategy());
var fakeVarProvider = A.Fake <IVariableProvider>();
var context = new FormulaEvaluatingContext
{
VariableProvider = fakeVarProvider
};
var formula = "1.0/0";
await Assert.ThrowsAsync <DivideByZeroException>(() =>
evaluator.EvalAsync(formula, context)
);
}
public async Task EvalNonExistingVariableTest()
{
var evaluator = new CSharpExecutor(typeof(Math), new NullNotAllowedStrategy());
var fakeVarProvider = A.Fake <IVariableProvider>();
A.CallTo(() => fakeVarProvider.GetVarAsync("a"))
.Returns(Task.FromResult <double?>(null));
var context = new FormulaEvaluatingContext
{
VariableProvider = fakeVarProvider
};
var formula = "await Var(\"a\") + await Var(\"b\") + 3";
await Assert.ThrowsAsync <CoerceVariableFailException>(() =>
evaluator.EvalAsync(formula, context)
);
}
public async Task IntThrowWhenEvalDivideByZeroTest()
{
var evaluator = new CSharpExecutor(typeof(Math), new NullNotAllowedStrategy());
var fakeVarProvider = A.Fake <IVariableProvider>();
A.CallTo(() => fakeVarProvider.GetVarAsync("a"))
.Returns(0);
var context = new FormulaEvaluatingContext
{
VariableProvider = fakeVarProvider
};
var formula = "1/await Var(\"a\")";
await Assert.ThrowsAsync <DivideByZeroException>(() =>
evaluator.EvalAsync(formula, context)
);
}
public async Task EvalExpressionTest(string formula, double expected)
{
//var evaluator = new CSharpExecutor(new NullNotAllowedStrategy());
//var fakeVarProvider = A.Fake<IVariableProvider>();
//A.CallTo(() => fakeVarProvider.GetVarAsync("a", A<VariableCriteria>.That.IsNotNull()))
// .Returns(10);
//A.CallTo(() => fakeVarProvider.GetVarAsync("参数", A<VariableCriteria>.That.IsNotNull()))
// .Returns(20);
//A.CallTo(() => fakeVarProvider.GetVarAsync("PI", A<VariableCriteria>.That.IsNotNull()))
// .Returns(Math.PI);
//var context = new FormulaEvaluatingContext
//{
// VariableProvider = fakeVarProvider,
// DistrictIndicatorResolver = A.Fake<IDistrictIndicatorResolver>(),
//};
//var actual = await evaluator.EvalAsync(formula, context);
//Assert.Equal(expected, actual);
var evaluator = new CSharpExecutor(typeof(Math), new NullNotAllowedStrategy());
var fakeVarProvider = A.Fake <IVariableProvider>();
A.CallTo(() => fakeVarProvider.GetVarAsync("a"))
.Returns(10);
A.CallTo(() => fakeVarProvider.GetVarAsync("参数"))
.Returns(20);
A.CallTo(() => fakeVarProvider.GetVarAsync("PI"))
.Returns(Math.PI);
var context = new FormulaEvaluatingContext
{
VariableProvider = fakeVarProvider,
//DistrictIndicatorResolver = A.Fake<IDistrictIndicatorResolver>(),
};
var actual = await evaluator.EvalAsync(formula, context);
Assert.Equal(expected, actual);
}
