/// <summary>
/// Builds and returns a collection of <see cref="IEqualityRule{T}"/>.
/// </summary>
/// <returns>The rules.</returns>
/// <param name="allBuilders">A collection of all rule-builders.</param>
public override IEnumerable <IEqualityRule <TParent> > GetRules(IEnumerable <RuleBuilder <TParent> > allBuilders)
{
var fieldRule = new EqualityRule <object>(Comparer(), Name);
var valueProvider = new ReflectionFieldValueProvider <TParent, object>(Field);
var parentRule = new ParentEqualityRule <TParent, object>(valueProvider, fieldRule);
return(new[] { parentRule });
}
/// <summary>
/// Builds and returns a collection of <see cref="IEqualityRule{T}"/>.
/// </summary>
/// <returns>The rules.</returns>
/// <param name="allBuilders">A collection of all rule-builders.</param>
public override IEnumerable <IEqualityRule <TParent> > GetRules(IEnumerable <RuleBuilder <TParent> > allBuilders)
{
var delegateRule = new EqualityRule <TValue>(Comparer(), Name);
var valueProvider = new DelegateValueProvider <TParent, TValue>(Delegate);
var parentRule = new ParentEqualityRule <TParent, TValue>(valueProvider, delegateRule);
return(new[] { parentRule });
}
public void GetEqualityResult_includes_values_in_result([Frozen] IEqualityComparer <string> comparer,
EqualityRule <string> sut,
string a,
string b)
{
var result = sut.GetEqualityResult(a, b);
Assert.That(result?.RuleResults?.FirstOrDefault()?.ValueA, Is.EqualTo(a), "First value");
Assert.That(result?.RuleResults?.FirstOrDefault()?.ValueB, Is.EqualTo(b), "Second value");
}
public void GetEqualityResult_returns_equals_result_when_instances_are_equal([Frozen] IEqualityComparer <string> comparer,
EqualityRule <string> sut,
string a,
string b)
{
Mock.Get(comparer).Setup(x => x.Equals(a, b)).Returns(true);
var result = sut.GetEqualityResult(a, b);
Assert.That(result?.AreEqual, Is.True);
}
public void GetHashCode_returns_result_from_comparer([Frozen] IEqualityComparer <string> comparer,
EqualityRule <string> sut,
string str,
int hashCode)
{
Mock.Get(comparer).Setup(x => x.GetHashCode(str)).Returns(hashCode);
var result = sut.GetHashCode(str);
Assert.That(result, Is.EqualTo(hashCode));
}
public void Equals_returns_false_if_comparison_throws([Frozen] IEqualityComparer <string> comparer,
EqualityRule <string> sut,
string a,
string b)
{
Mock.Get(comparer).Setup(x => x.Equals(a, b)).Throws <InvalidOperationException>();
var result = sut.Equals(a, b);
Assert.That(result, Is.False);
}
public void Equals_returns_result_from_comparer([Frozen] IEqualityComparer <string> comparer,
EqualityRule <string> sut,
string a,
string b)
{
Mock.Get(comparer).Setup(x => x.Equals(a, b)).Returns(true);
var result = sut.Equals(a, b);
Assert.That(result, Is.True);
}
private Func <DynamicMessageElement, bool> createCompiledRuleFunc(SupportDataTypeEnum supportedDataType, string op, string right)
{
EqualityRule rule;
switch (supportedDataType)
{
case SupportDataTypeEnum.Bool:
rule = new EqualityRule("StringValue", AlarmRuleItemEngineUtility.GetEqualityOperation(op), right.ToLower());
break;
case SupportDataTypeEnum.Numeric:
decimal rightValue = Decimal.Parse(right);
if (rightValue >= 0)
{
rule = new EqualityRule("DecimalValue", AlarmRuleItemEngineUtility.GetEqualityOperation(op), right);
}
else
{
rule = new EqualityRule("DecimalValue", AlarmRuleItemEngineUtility.GetEqualityOperation(op), "0-" + Decimal.Negate(rightValue).ToString());
}
break;
case SupportDataTypeEnum.String:
rule = new EqualityRule("StringValue", AlarmRuleItemEngineUtility.GetEqualityOperation(op), right);
break;
default:
throw new NotSupportedException();
}
RuleBase rb = null;
using (var mem = new MemoryStream())
{
Serializer.Serialize(mem, rule);
mem.Position = 0;
rb = Serializer.Deserialize <RuleBase>(mem);
}
string ruleText;
Func <DynamicMessageElement, bool> compiledRule = rb.CompileRule <DynamicMessageElement>(out ruleText);
//_consoleLog.MessageAlarmDebug("----ruleText={0}", ruleText);
//_consoleLog.MessageAlarmDebug("----ruleText="+ruleText);
return(compiledRule);
}
private Func <DynamicMessageElement, bool> createCompiledRuleFunc(SupportDataTypeEnum isDecimalType, string op, string right)
{
EqualityRule rule;
switch (isDecimalType)
{
case SupportDataTypeEnum.Bool:
rule = new EqualityRule("StringValue", AlarmRuleItemEngineUtility.GetEqualityOperation(op), right.ToLower());
break;
case SupportDataTypeEnum.Numeric:
rule = new EqualityRule("DecimalValue", AlarmRuleItemEngineUtility.GetEqualityOperation(op), right);
break;
case SupportDataTypeEnum.String:
rule = new EqualityRule("StringValue", AlarmRuleItemEngineUtility.GetEqualityOperation(op), right);
break;
default:
throw new NotSupportedException();
}
RuleBase rb = null;
using (var mem = new MemoryStream())
{
Serializer.Serialize(mem, rule);
mem.Position = 0;
rb = Serializer.Deserialize <RuleBase>(mem);
}
string ruleText;
Func <DynamicMessageElement, bool> compiledRule = rb.CompileRule <DynamicMessageElement>(out ruleText);
ConsoleLog.WriteMessageAlarmLogToConsole("----ruleText={0}", ruleText);
return(compiledRule);
}
