public static String Pretty(Db.Rule.Compare operation)
{
var sb = new StringBuilder();
switch (operation)
{
case Rule.Compare.Equal:
sb.Append("==");
break;
case Rule.Compare.NotEqual:
sb.Append("!=");
break;
case Rule.Compare.Greater:
sb.Append(">");
break;
case Rule.Compare.Less:
sb.Append("<");
break;
default:
sb.Append("??");
break;
}
return(sb.ToString());
}
private void Verify(Db.Rule.Compare op
, String left
, String right
, bool expected
)
{
var msg = new System.Text.StringBuilder();
try
{
var rule = new Db.Rule(-1 // not in db, so no id
, -1 // not in db, so no step
, "variable name irrelevant for RC.Applies()"
, op
, left
, TestUtil.RANDOM.Next() // order also irrelvant for this test
, Step.NO_NEXT_STEP
);
msg.Append("Rule with operator ");
msg.Append(op);
msg.Append(" [");
msg.Append(left);
msg.Append("] vs [");
msg.Append(right);
msg.Append("] we expect to evaulate to ");
msg.Append(expected);
bool result = RuleCalculator.Applies(rule, right);
if (result != expected)
{
Console.WriteLine(msg);
}
Assert.That(result == expected, msg.ToString());
}
catch (Exception ex)
{
Console.WriteLine(msg);
Console.WriteLine("but it threw: " + ex);
throw;
}
}
public void UnknownOperatorThrows()
{
Console.WriteLine("--> UnknownOperatorThrows()");
Dictionary <int, bool> expectedList = null;
try
{
expectedList = new Dictionary <int, bool>()
{
{ (int)Db.Rule.Compare.Equal, false }
, { (int)Db.Rule.Compare.NotEqual, false }
, { (int)Db.Rule.Compare.Greater, false }
, { (int)Db.Rule.Compare.Less, false }
, { (int)Db.Rule.Compare.Less + 1, true }
, { (int)Db.Rule.Compare.Equal - 1, true }
, { TestUtil.RANDOM.Next(int.MinValue, 0), true }
, { TestUtil.RANDOM.Next(100, int.MaxValue), true }
};
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
foreach (var i in expectedList.Keys)
{
var expected = expectedList[i];
Console.WriteLine(i + ") " + expected);
String msg = "";
try
{
Db.Rule.Compare op = (Db.Rule.Compare)i;
bool verifyShouldReturn = false;
switch (op)
{
case Db.Rule.Compare.Equal:
verifyShouldReturn = true;
break;
case Db.Rule.Compare.NotEqual:
case Db.Rule.Compare.Less:
case Db.Rule.Compare.Greater:
verifyShouldReturn = false;
break;
default:
// doesn't really matter; we want
// it to throw
break;
}
Verify(op, "same", "same", verifyShouldReturn);
}
catch (Exception ex)
{
msg = ex.Message;
}
if (expected)
{
Assert.That(msg != "", "we expected an exception to be thrown for " + i);
Assert.That(msg.Contains("unknown rule comparison"));
Assert.That(msg.Contains(i.ToString()));
}
else
{
Assert.That(String.IsNullOrEmpty(msg)
, "we didn't expect an exception for "
+ i
+ " but we got one anyway: "
+ msg
);
}
}
}
