/// <summary>
/// Acquisition thread
/// Awaits for trigger;
/// After configured period send appropriate command to MdbSim for each point type
/// </summary>
private void Acquisition_DoWork()
{
while (true)
{
try
{
acquisitionTrigger.WaitOne();
DO_REG_sekunde++;
HR_INT_sekunde++;
if (DO_REG_sekunde == ConfigReader.Instance.GetAcquisitionInterval("DigOut"))
{
ModbusReadCommandParameters p = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_COILS, ConfigReader.Instance.GetStartAddress("DigOut"), ConfigReader.Instance.GetNumberOfRegisters("DigOut"));;
ModbusFunction fn = FunctionFactory.CreateModbusFunction(p);
this.commandExecutor.EnqueueCommand(fn);
DO_REG_sekunde = 0;
}
if (HR_INT_sekunde == ConfigReader.Instance.GetAcquisitionInterval("AnaOut"))
{
ModbusReadCommandParameters p = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_HOLDING_REGISTERS, ConfigReader.Instance.GetStartAddress("AnaOut"), ConfigReader.Instance.GetNumberOfRegisters("AnaOut"));;
ModbusFunction fn = FunctionFactory.CreateModbusFunction(p);
this.commandExecutor.EnqueueCommand(fn);
HR_INT_sekunde = 0;
}
}
catch (Exception ex)
{
string message = $"{ex.TargetSite.ReflectedType.Name}.{ex.TargetSite.Name}: {ex.Message}";
stateUpdater.LogMessage(message);
}
}
}
public static Func <DbDataReader, ExpandoObject> Get(DbDataReader reader,
string tableName,
IDbConnection connection,
IDbTransaction transaction)
{
var result = (Func <DbDataReader, ExpandoObject>)null;
var key = (long)Enumerable.Range(0, reader.FieldCount)
.Select(reader.GetName)
.Join(".")
.GetHashCode();
if (tableName != null)
{
key += tableName.GetHashCode();
}
if (string.IsNullOrEmpty(connection?.ConnectionString) == false)
{
key += connection.ConnectionString.GetHashCode();
}
if (m_cache.TryGetValue(key, out result) == false)
{
result = FunctionFactory.GetDataReaderToExpandoObjectConverterFunction(reader, tableName, connection, transaction);
m_cache.TryAdd(key, result);
}
return(result);
}
/// <summary>
/// Method that is executed when write button is clicked on control window;
/// Method should create write command parameters and provide it to FunctionFactory
/// </summary>
/// <param name="obj">Not used</param>
private void WriteCommand_Execute(object obj)
{
try
{
ModbusWriteCommandParameters mdb = null;
switch (Type)
{
case PointType.DIGITAL_OUTPUT:
mdb = new ModbusWriteCommandParameters(6, (byte)ModbusFunctionCode.WRITE_SINGLE_COIL, Address, commandedValue);
break;
case PointType.ANALOG_OUTPUT:
mdb = new ModbusWriteCommandParameters(6, (byte)ModbusFunctionCode.WRITE_SINGLE_REGISTER, Address, commandedValue);
break;
}
ModbusFunction fn = FunctionFactory.CreateModbusFunction(mdb);
this.commandExecutor.EnqueueCommand(fn);
}
catch (Exception ex)
{
string message = $"{ex.TargetSite.ReflectedType.Name}.{ex.TargetSite.Name}: {ex.Message}";
this.stateUpdater.LogMessage(message);
}
}
private static void ReadEvaluationSchemeConfig(
JsonElement configElem,
out Func <double, double> fn,
out ParamSamplingInfo paramSamplingInfo,
out double gradientMseWeight)
{
// Get the customEvaluationSchemeConfig section.
if (!configElem.TryGetProperty("customEvaluationSchemeConfig", out JsonElement evalSchemeElem))
{
throw new Exception("customEvaluationSchemeConfig not defined.");
}
// Read function ID.
string functionIdStr = JsonReadMandatoryUtils.ReadStringMandatory(evalSchemeElem, "functionId");
FunctionId functionId = (FunctionId)Enum.Parse(typeof(FunctionId), functionIdStr);
fn = FunctionFactory.GetFunction(functionId);
// Read sample interval min and max, and sample resolution.
double sampleIntervalMin = JsonReadMandatoryUtils.ReadDoubleMandatory(evalSchemeElem, "sampleIntervalMin");
double sampleIntervalMax = JsonReadMandatoryUtils.ReadDoubleMandatory(evalSchemeElem, "sampleIntervalMax");
int sampleResolution = JsonReadMandatoryUtils.ReadIntMandatory(evalSchemeElem, "sampleResolution");
paramSamplingInfo = new ParamSamplingInfo(sampleIntervalMin, sampleIntervalMax, sampleResolution);
// Read the weight to apply to the gradientMse readings in the final fitness score.
// 0 means don't use the gradient measurements, 1 means give them equal weight to the y position readings at each x sample point.
gradientMseWeight = JsonReadMandatoryUtils.ReadDoubleMandatory(evalSchemeElem, "gradientMseWeight");
}
public static Action <DbCommand, IList <TEntity> > Get(string cacheKey,
IEnumerable <DbField> inputFields,
IEnumerable <DbField> outputFields,
int batchSize,
IDbSetting dbSetting)
{
var key = (long)cacheKey.GetHashCode() + batchSize.GetHashCode();
if (inputFields?.Any() == true)
{
foreach (var field in inputFields)
{
key += field.GetHashCode();
}
}
if (outputFields?.Any() == true)
{
foreach (var field in outputFields)
{
key += field.GetHashCode();
}
}
var func = (Action <DbCommand, IList <TEntity> >)null;
if (m_cache.TryGetValue(key, out func) == false)
{
func = FunctionFactory.GetDataEntitiesDbCommandParameterSetterFunction <TEntity>(inputFields, outputFields, batchSize, dbSetting);
m_cache.TryAdd(key, func);
}
return(func);
}
/// <summary>
/// Method that is executed when read button is clicked on control window;
/// Method should create read command parameters and provide it to FunctionFactory
/// </summary>
/// <param name="obj">Not used</param>
private void ReadCommand_Execute(object obj)
{
try
{
ConfigReader reader = ConfigReader.Instance;
ModbusReadCommandParameters mdb = null;
if (Type == PointType.ANALOG_INPUT)
{
mdb = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_INPUT_REGISTERS, Address, 1);
}
if (Type == PointType.DIGITAL_OUTPUT)
{
mdb = new ModbusReadCommandParameters(6, (byte)Type, Address, 1);
}
if (Type == PointType.DIGITAL_INPUT)
{
mdb = new ModbusReadCommandParameters(6, (byte)Type, Address, 1);
}
if (Type == PointType.ANALOG_OUTPUT)
{
mdb = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_HOLDING_REGISTERS, Address, 1);
}
ModbusFunction fn = FunctionFactory.CreateModbusFunction(mdb);
this.commandExecutor.EnqueueCommand(fn);
}
catch (Exception ex)
{
string message = $"{ex.TargetSite.ReflectedType.Name}.{ex.TargetSite.Name}: {ex.Message}";
this.stateUpdater.LogMessage(message);
}
}
public static Action <DbCommand, TEntity> Get(string cacheKey,
IEnumerable <DbField> inputFields,
IEnumerable <DbField> outputFields)
{
var key = (long)cacheKey.GetHashCode();
var func = (Action <DbCommand, TEntity>)null;
if (inputFields != null)
{
foreach (var field in inputFields)
{
key += field.GetHashCode();
}
}
if (outputFields != null)
{
foreach (var field in outputFields)
{
key += field.GetHashCode();
}
}
if (m_cache.TryGetValue(key, out func) == false)
{
func = FunctionFactory.GetDataEntityDbCommandParameterSetterFunction <TEntity>(inputFields, outputFields);
m_cache.TryAdd(key, func);
}
return(func);
}
private void ReadCommand_Execute(object obj)
{
try
{
// TODO implement
ModbusReadCommandParameters p = null;
switch (type)
{
case PointType.DO_REG:
p = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_COILS, address, 1);
break;
case PointType.DI_REG:
p = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_DISCRETE_INPUTS, address, 1);
break;
case PointType.IN_REG:
p = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_INPUT_REGISTERS, address, 1);
break;
}
ModbusFunction fn = FunctionFactory.CreateModbusFunction(p);
this.commandExecutor.ExecuteCommand(fn);
}
catch (Exception ex)
{
string message = $"{ex.TargetSite.ReflectedType.Name}.{ex.TargetSite.Name}: {ex.Message}";
this.stateUpdater.LogMessage(message);
}
}
static ComplexExpressionTreeBuilderExtensionsTests()
{
var targetAssembly = Assembly.LoadFrom("TAlex.MathCore.ComplexExpressions.Extensions.dll");
ConstantFactory = new ConstantFlyweightFactory <object>();
ConstantFactory.LoadFromAssemblies(new List <Assembly> {
targetAssembly
});
FunctionFactory = new FunctionFactory <object>();
FunctionFactory.LoadFromAssemblies(new List <Assembly> {
targetAssembly
});
ExpressionTreeBuilder = new ComplexExpressionTreeBuilder
{
ConstantFactory = ConstantFactory,
FunctionFactory = FunctionFactory
};
FunctionsTestCasesData = FunctionFactory.GetMetadata().Select(x =>
{
var d = new TestCaseData(x);
d.SetName(String.Format("ShouldContainsCorrectedExampleUsages: {0}", x.DisplayName));
return(d);
}).ToList();
}
/// <summary>
/// Reads <see cref="Control"/> statement and modifies the context.
/// </summary>
/// <param name="statement">A statement to process.</param>
/// <param name="context">Expression context.</param>
/// <param name="validation">Validation.</param>
/// <param name="validate">Validate.</param>
public void Read(Control statement, EvaluationContext context, SpiceNetlistValidationResult validation, bool validate)
{
if (statement.Parameters == null)
{
throw new ArgumentNullException(nameof(statement));
}
foreach (Parameter param in statement.Parameters)
{
if (param is Models.Netlist.Spice.Objects.Parameters.AssignmentParameter assignmentParameter)
{
if (!assignmentParameter.HasFunctionSyntax)
{
string parameterName = assignmentParameter.Name;
string parameterExpression = assignmentParameter.Value;
try
{
SetParameter(parameterName, parameterExpression, context);
}
catch (Exception e)
{
if (validate)
{
validation.Add(
new ValidationEntry(
ValidationEntrySource.Reader,
ValidationEntryLevel.Warning,
$"Problem with setting param `{assignmentParameter.Name}` with expression =`{assignmentParameter.Value}`",
statement.LineInfo,
exception: e));
}
}
}
else
{
FunctionFactory factory = new FunctionFactory();
context.AddFunction(
assignmentParameter.Name,
assignmentParameter.Value,
assignmentParameter.Arguments,
factory.Create(
assignmentParameter.Name,
assignmentParameter.Arguments,
assignmentParameter.Value));
}
}
else
{
validation.Add(
new ValidationEntry(
ValidationEntrySource.Reader,
ValidationEntryLevel.Warning,
".PARAM supports only assignments",
statement.LineInfo));
}
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.AddSingleton <IFunction>(FunctionFactory.BuildFunction(Configuration));
services.AddSingleton <ICompiler>(new DefaultCompiler(new DefaultParser(), new DefaultReferencesManager()));
services.AddSingleton <IInvoker>(new DefaultInvoker());
}
/// <summary>
/// Executes an analog write command.
/// </summary>
/// <param name="configItem">The configuration item.</param>
/// <param name="transactionId">The transaction identifier.</param>
/// <param name="remoteUnitAddress">The remote unit address.</param>
/// <param name="pointAddress">The point address.</param>
/// <param name="value">The value.</param>
private void ExecuteAnalogCommand(IConfigItem configItem, ushort transactionId, byte remoteUnitAddress, ushort pointAddress, int value)
{
ushort raw = eguConverter.ConvertToRaw(configItem.ScaleFactor, configItem.Deviation, value);
ModbusWriteCommandParameters p = new ModbusWriteCommandParameters(6, (byte)ModbusFunctionCode.WRITE_SINGLE_REGISTER, pointAddress, (ushort)raw, transactionId, remoteUnitAddress);
IModbusFunction fn = FunctionFactory.CreateModbusFunction(p);
this.functionExecutor.EnqueueCommand(fn);
}
public static Func <DbDataReader, TEntity> Get(DbDataReader reader)
{
if (m_func == null)
{
m_func = FunctionFactory.GetDataReaderToDataEntityFunction <TEntity>(reader);
}
return(m_func);
}
public static Func <DbDataReader, TEntity> Get(DbDataReader reader, IDbConnection connection, IDbTransaction transaction)
{
if (m_func == null)
{
m_func = FunctionFactory.GetDataReaderToDataEntityConverterFunction <TEntity>(reader, connection, transaction);
}
return(m_func);
}
public void TestAve()
{
IFunction func = FunctionFactory.Create(CalcEnum.Ave);
func.Add(100);
func.Add(200);
Assert.AreEqual(func.GetValue(), 150);
}
public void TestCount()
{
IFunction func = FunctionFactory.Create(CalcEnum.Count);
func.Add(1);
func.Add(1);
Assert.AreEqual(func.GetValue(), 2);
}
public static Func <DbDataReader, ExpandoObject> Get(DbDataReader reader)
{
if (m_func == null)
{
m_func = FunctionFactory.GetDataReaderToExpandoObjectFunction(reader);
}
return(m_func);
}
public static void CompileFunction(string language, string functionFileName, string moduleName, string functionHandler)
{
FunctionFactory factory = new FunctionFactory(BASE_PATH, PACKAGES_SUBPATH);
string functionPath = factory.CreateEnvironmentPath(BASE_PATH, language, functionFileName);
IFunction function = factory.CompileFunction(functionPath, moduleName, functionHandler);
Environment.SetEnvironmentVariable("BASE_PATH", functionPath);
Environment.SetEnvironmentVariable("PUBLISH_PATH", ".");
}
public void KTest()
{
Point3D x = null; // TODO: Initialize to an appropriate value
double expected = 0F; // TODO: Initialize to an appropriate value
double actual;
actual = FunctionFactory.K(x);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
var function = FunctionFactory.GetFunction(Configuration);
var timeout = FunctionFactory.GetFunctionTimeout(Configuration);
services.AddTransient <IInvoker>(_ => new CompiledFunctionInvoker(function, timeout));
services.AddSingleton <IParameterHandler>(new DefaultParameterHandler(Configuration));
}
public DataTypeValue Evaluate(EvaluationContext ctx, string SchemeID)
{
IList <DataTypeValue> rets = new List <DataTypeValue>();
foreach (IEvaluatable e in this._evaluatable)
{
rets.Add(e.Evaluate(ctx, SchemeID));
}
return(FunctionFactory.Evaluate(this._functionId, rets.ToArray(), ctx));
}
public void QTest()
{
Point3D x = new Point3D(1, 1, 1); // TODO: Initialize to an appropriate value
Point3D ksi = new Point3D(0, 0, 0); // TODO: Initialize to an appropriate value
double expected = 1 / (4 * Math.PI * Math.Sqrt(3)); // TODO: Initialize to an appropriate value
double actual;
actual = FunctionFactory.Q(x, ksi);
Assert.IsTrue(Math.Abs(expected - actual) < Eps);
}
public void Q1Test()
{
Point3D x = new Point3D(1, 1, 1);
Point3D ksi = new Point3D(0, 0, 0);
double expected = -1 / (4 * Math.PI * Math.Sqrt(3) * Math.Sqrt(3) * Math.Sqrt(3));
double actual;
actual = FunctionFactory.Q1(x, ksi);
Assert.AreEqual(expected, actual);
}
public void CalculateOutputStepTest()
{
// 0 0 1 => 0
// 1 1 1 => 1
// 1 0 1 => 1
// 0 1 1 => 0
// test
// 1 0 0 => ?
var weightAdjust = new Func <TrainingCalcModel, double>((m) =>
{
return(m.Error * m.Input * m.ActualOutput * (1 - m.ActualOutput));
});
var inputNodes1 = new InputLayer()
{
new InputNode(0), // { InValue = 0 });
new InputNode(1), // { InValue = 0 });
new InputNode(2) // { InValue = 1 });
};
var outnode = new OutputNode(1, FunctionFactory.GetActivationFunction(eActivationFunc.Step), weightAdjust);
outnode.AddInputNodes(inputNodes1);
outnode.Bias = 0.0;
for (int x = 0; x < 100000; x++)
{
inputNodes1.SetInput(new double[] { 0.0, 0.0, 1.0 });
outnode.CalculateOutput();
outnode.AdjustWeights(0);
inputNodes1.SetInput(new double[] { 1.0, 1.0, 1.0 });
outnode.CalculateOutput();
outnode.AdjustWeights(1);
inputNodes1.SetInput(new double[] { 1.0, 0.0, 1.0 });
outnode.CalculateOutput();
outnode.AdjustWeights(1);
inputNodes1.SetInput(new double[] { 0.0, 1.0, 1.0 });
outnode.CalculateOutput();
outnode.AdjustWeights(0);
}
outnode.SetInput(new double[] { 1.0, 0.0, 0.0 });
outnode.CalculateOutput();
var outp = outnode.Output;
Assert.IsTrue(outp == 1);
outnode.SetInput(new double[] { 0.0, 0.0, 0.0 });
outnode.CalculateOutput();
outp = outnode.Output;
Assert.IsTrue(outp == 0.0);
}
/// <summary>
/// Acquisition thread
/// Awaits for trigger;
/// After configured period send appropriate command to MdbSim for each point type
///
/// Kao uslov za while petlju korititi acquisitionStopSignal da bi se akvizicioni thread ugasio kada se aplikacija ugasi
/// </summary>
private void Acquisition_DoWork()
{
ConfigReader cr = ConfigReader.Instance;
int cnt = 0;
int DigOut = cr.GetAcquisitionInterval("DigOut");
int DigIn = cr.GetAcquisitionInterval("DigIn");
int AnaOut = cr.GetAcquisitionInterval("AnaOut");
int AnaIn = cr.GetAcquisitionInterval("AnaIn");
ModbusReadCommandParameters mrcp = null;
ModbusFunction fn = null;
while (true)
{
if (cnt % DigOut == 0)
{
mrcp = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_COILS, cr.GetStartAddress("DigOut"), cr.GetNumberOfRegisters("DigOut"));
fn = FunctionFactory.CreateModbusFunction(mrcp);
this.commandExecutor.EnqueueCommand(fn);
}
if (cnt % DigIn == 0)
{
mrcp = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_DISCRETE_INPUTS, cr.GetStartAddress("DigIn"), cr.GetNumberOfRegisters("DigIn"));
fn = FunctionFactory.CreateModbusFunction(mrcp);
this.commandExecutor.EnqueueCommand(fn);
}
if (cnt % AnaOut == 0)
{
mrcp = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_HOLDING_REGISTERS, cr.GetStartAddress("AnaOut"), cr.GetNumberOfRegisters("AnaOut"));
fn = FunctionFactory.CreateModbusFunction(mrcp);
this.commandExecutor.EnqueueCommand(fn);
}
if (cnt % AnaIn == 0)
{
mrcp = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_INPUT_REGISTERS, cr.GetStartAddress("AnaIn"), cr.GetNumberOfRegisters("AnaIn"));
fn = FunctionFactory.CreateModbusFunction(mrcp);
this.commandExecutor.EnqueueCommand(fn);
}
try
{
acquisitionTrigger.WaitOne();
cnt++;
}
catch (Exception ex)
{
string message = $"{ex.TargetSite.ReflectedType.Name}.{ex.TargetSite.Name}: {ex.Message}";
stateUpdater.LogMessage(message);
}
}
}
public void FunctionsAreContiniousTest()
{
var bound = new ParallelepipedNearBound();
foreach (var point in bound.CornerPoints)
{
var x = FunctionFactory.G(point);
var y = FunctionFactory.Gother(point);
Assert.AreEqual(x, y);
}
}
public void Given_Handler_Function_ShouldBe_Created()
{
var handler = this._fixture.ArrangeRegistrationHandler();
var logger = this._fixture.ArrangeLog();
var factory = new FunctionFactory(handler);
var function = factory.Create <IFooFunction>(logger);
function.Log.Should().NotBeNull();
}
public static Action <TEntity, object> Get(Field field)
{
var key = (long)typeof(TEntity).FullName.GetHashCode() + field.Name.GetHashCode();
var func = (Action <TEntity, object>)null;
if (cache.TryGetValue(key, out func) == false)
{
func = FunctionFactory.GetDataEntityPropertyValueSetterFunction <TEntity>(field);
cache.TryAdd(key, func);
}
return(func);
}
private void Acquisition_DoWork()
{
int cnt = 0;
ConfigReader cr = ConfigReader.Instance;
int DOCnt = cr.GetAcquisitionIntervalForPointType(PointType.DIGITAL_OUTPUT);
int DICnt = cr.GetAcquisitionIntervalForPointType(PointType.DIGITAL_INPUT);
int AICnt = cr.GetAcquisitionIntervalForPointType(PointType.ANALOG_INPUT);
int AOCnt = cr.GetAcquisitionIntervalForPointType(PointType.ANALOG_OUTPUT);
while (true)
{
//// TODO implement
if (cnt % DOCnt == 0)
{
// TODO implement
ModbusReadCommandParameters mcp = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_COILS, cr.GetStartAddressForPointType(PointType.DIGITAL_OUTPUT), cr.GetNumberOfRegistersForPointType(PointType.DIGITAL_OUTPUT));
ModbusFunction fn = FunctionFactory.CreateModbusFunction(mcp);
this.commandExecutor.EnqueueCommand(fn);
}
if (cnt % DICnt == 0)
{
ModbusReadCommandParameters mcp = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_DISCRETE_INPUTS, cr.GetStartAddressForPointType(PointType.DIGITAL_INPUT), cr.GetNumberOfRegistersForPointType(PointType.DIGITAL_INPUT));
ModbusFunction fn = FunctionFactory.CreateModbusFunction(mcp);
this.commandExecutor.EnqueueCommand(fn);
}
if (cnt % AOCnt == 0)
{
ModbusReadCommandParameters mcp = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_HOLDING_REGISTERS, cr.GetStartAddressForPointType(PointType.ANALOG_OUTPUT), cr.GetNumberOfRegistersForPointType(PointType.ANALOG_OUTPUT));
ModbusFunction fn = FunctionFactory.CreateModbusFunction(mcp);
this.commandExecutor.EnqueueCommand(fn);
}
if (cnt % AICnt == 0)
{
ModbusReadCommandParameters mcp = new ModbusReadCommandParameters(6, (byte)ModbusFunctionCode.READ_INPUT_REGISTERS, cr.GetStartAddressForPointType(PointType.ANALOG_INPUT), cr.GetNumberOfRegistersForPointType(PointType.ANALOG_INPUT));
ModbusFunction fn = FunctionFactory.CreateModbusFunction(mcp);
this.commandExecutor.EnqueueCommand(fn);
}
try
{
acquisitionTrigger.WaitOne();
cnt++;
}
catch (Exception ex)
{
string message = $"{ex.TargetSite.ReflectedType.Name}.{ex.TargetSite.Name}: {ex.Message}";
stateUpdater.LogMessage(message);
}
}
}
public void Given_ModuleTypeGeneric_Property_ShouldNotThrow_Exception()
{
var logger = new Mock <ILogger>();
var factory = new FunctionFactory <FakeModule>();
var service = factory.Create <IFakeFunctionWithILogger, ILogger>(logger.Object);
service.Should().NotBeNull();
service.Should().BeAssignableTo <IFakeFunctionWithILogger>();
service.Log.Should().BeAssignableTo <ILogger>();
}
static ComplexExpressionTreeBuilderExtensionsTests()
{
var targetAssembly = Assembly.LoadFrom("TAlex.MathCore.ComplexExpressions.Extensions.dll");
ConstantFactory = new ConstantFlyweightFactory<object>();
ConstantFactory.LoadFromAssemblies(new List<Assembly> { targetAssembly });
FunctionFactory = new FunctionFactory<object>();
FunctionFactory.LoadFromAssemblies(new List<Assembly> { targetAssembly });
ExpressionTreeBuilder = new ComplexExpressionTreeBuilder
{
ConstantFactory = ConstantFactory,
FunctionFactory = FunctionFactory
};
FunctionsTestCasesData = FunctionFactory.GetMetadata().Select(x =>
{
var d = new TestCaseData(x);
d.SetName(String.Format("ShouldContainsCorrectedExampleUsages: {0}", x.DisplayName));
return d;
}).ToList();
}
public FunctionFactoryTests()
{
this.testee = new FunctionFactory();
}
