public void testRssReader()
{
rule targetRule = new rule();
ruleItemRss rss = (ruleItemRss) targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItemRss)));
rss._options.url = "file://" + Path.GetFullPath(Properties.Settings.Default.testDataPath) + @"\test.rss";
rss.pinInfo["trigger"].value.data = true;
targetRule.start();
rss.evaluate();
targetRule.advanceDelta();
Assert.AreEqual("hi <3", rss.pinInfo["feed Title"].value.data);
Assert.AreEqual("Hello World", rss.pinInfo["feed Content"].value.data);
rss.pinInfo["trigger"].value.data = true;
rss.evaluate();
targetRule.advanceDelta();
Assert.AreEqual("test entry", rss.pinInfo["feed Title"].value.data);
Assert.AreEqual("Test 'details'", rss.pinInfo["feed Content"].value.data);
targetRule.stop();
rss._options.url = "file://" + Path.GetFullPath(Properties.Settings.Default.testDataPath) + @"\test.atom";
targetRule.start();
rss.evaluate();
targetRule.advanceDelta();
Assert.AreEqual("Atom-Powered Robots Run Amok", rss.pinInfo["feed Title"].value.data);
Assert.AreEqual("Some text.", rss.pinInfo["feed Content"].value.data);
rss.evaluate();
targetRule.advanceDelta();
Assert.AreEqual("lol", rss.pinInfo["feed Title"].value.data);
Assert.AreEqual("test", rss.pinInfo["feed Content"].value.data);
targetRule.stop();
}
public void testProcessRuleItems()
{
rule targetRule = new rule();
ruleItem_runexe runexe = (ruleItem_runexe)targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_runexe)));
ruleItem_isProcessRunning isRunning = (ruleItem_isProcessRunning)targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_isProcessRunning)));
ruleItem_killProcess killProcess = (ruleItem_killProcess)targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_killProcess)));
runexe.fileToRun = @"C:\Windows\system32\cmd.exe";
isRunning.processName = "cmd";
killProcess.name = "cmd";
runexe.pinInfo["input1"].value.data = true;
targetRule.start();
runexe.evaluate();
targetRule.advanceDelta();
isRunning.pinInfo["trigger"].value.data = true;
isRunning.evaluate();
targetRule.advanceDelta();
bool running = isRunning.pinInfo["output1"].value.asBoolean();
for(int i = 0; i < 20 && !running;i++ )
{
isRunning.evaluate();
targetRule.advanceDelta();
running = isRunning.pinInfo["output1"].value.asBoolean();
if (!running)
Thread.Sleep(20);
}
Assert.AreEqual(running, true);
killProcess.pinInfo["input1"].value.data = true;
killProcess.evaluate();
targetRule.advanceDelta();
isRunning.evaluate();
targetRule.advanceDelta();
running = isRunning.pinInfo["output1"].value.asBoolean();
Assert.AreEqual(running, false);
}
public void testHTMLStripper()
{
string html = @"<p><style>font{blah: x }</style>llololol<b>bolded</b><script>alert('x');</script></p>";
rule targetRule = new rule();
ruleItem_HTMLStripper htmlStripper = (ruleItem_HTMLStripper)targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_HTMLStripper)));
htmlStripper.pinInfo["input"].value.data = html;
htmlStripper.evaluate();
targetRule.advanceDelta();
string value = (string) htmlStripper.pinInfo["output"].value.data;
Assert.AreEqual(value,"llolololbolded");
}
public ctlRule()
{
this.InitializeComponent();
this._rule = new rule();
this.currentLine = new lineChain();
// done for unitTests
if (Parent == null) Parent = new Form();
#if DEBUG
this.showDebugInfoToolStripMenuItem.Visible = true;
#endif
}
public void testStartRunRuleItem()
{
rule foo = new rule();
ruleItemBase newItem = foo.addRuleItem(new ruleItemInfo(typeof(ruleItem_startRun)));
foo.start();
Assert.AreEqual(false, newItem.pinInfo["StartOfSim"].value.data);
foo.advanceDelta();
Assert.AreEqual(true, newItem.pinInfo["StartOfSim"].value.data);
foo.advanceDelta();
Assert.AreEqual(false, newItem.pinInfo["StartOfSim"].value.data);
foo.stop();
}
public void renameRuleTest()
{
rule toRename = new rule("Heresy");
toRename.changeName("","Love");
Assert.IsFalse(File.Exists("Love.rule"));
Assert.IsFalse(File.Exists("Heresy.rule"));
toRename.changeName("","Hurt");
toRename.saveToDisk("Hurt.rule");
Assert.IsTrue(File.Exists("Hurt.rule"));
toRename.changeName("","Pain");
Assert.IsTrue(File.Exists("Pain.rule"));
File.Delete("Pain.rule");
}
public void testStartRunRuleItemLinkedToDebugItem()
{
rule targetRule = new rule();
ruleItemBase startItem = targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_startRun)));
ruleItemBase debugItem = targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_debug)));
lineChain newChain = new lineChain();
startItem.pinInfo["StartOfSim"].connectTo(newChain.serial, debugItem.pinInfo["input"]);
targetRule.AddLineChainToGlobalPool(newChain);
targetRule.start();
Assert.AreEqual(false, startItem.pinInfo["StartOfSim"].value.data);
Assert.AreEqual(tristate.noValue, debugItem.pinInfo["input"].value.data);
targetRule.advanceDelta();
Assert.AreEqual(true, startItem.pinInfo["StartOfSim"].value.data);
Assert.AreEqual(tristate.yes, debugItem.pinInfo["input"].value.data);
targetRule.advanceDelta();
Assert.AreEqual(false, startItem.pinInfo["StartOfSim"].value.data);
Assert.AreEqual(tristate.no, debugItem.pinInfo["input"].value.data);
targetRule.stop();
}
private void onCloseRuleEditorDialog(rule closeThis)
{
// Flag the rule as no longer open in an editor.
// Find the Rule in the listView
ListViewItem ruleItem = findRuleItem(closeThis);
if (ruleItem == null)
{
MessageBox.Show("Unable to mark rule as not-being-edited - can't find it in listView control");
return;
}
// mark the listView item as not being open in the editor any more
ruleItem.SubItems[2].Text = false.ToString();
}
public void testSwitchRuleItem()
{
rule targetRule = new rule();
ruleItem_switch switchRule = (ruleItem_switch)targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_switch)));
targetRule.start();
//test bools
switchRule.pinInfo["inputTrue"].value.data = true;
switchRule.pinInfo["inputFalse"].value.data = false;
switchRule.pinInfo["switch"].value.data = false;
//must start as tristate and noValue
Assert.IsInstanceOfType(switchRule.pinInfo["output"].value.data, typeof(tristate));
Assert.AreEqual(switchRule.pinInfo["output"].value.data,tristate.noValue);
switchRule.evaluate();
targetRule.advanceDelta();
Assert.IsInstanceOfType(switchRule.pinInfo["output"].value.data, typeof(bool));
Assert.IsFalse((bool) switchRule.pinInfo["output"].value.data);
switchRule.pinInfo["switch"].value.data = true;
switchRule.evaluate();
targetRule.advanceDelta();
Assert.IsTrue((bool) switchRule.pinInfo["output"].value.data);
//test string and bool
switchRule.pinInfo["inputFalse"].valueType = typeof(pinDataString);
switchRule.pinInfo["inputFalse"].recreateValue();
switchRule.pinInfo["inputFalse"].value.data = "True";
switchRule.pinInfo["switch"].value.data = false;
switchRule.evaluate();
targetRule.advanceDelta();
Assert.IsInstanceOfType(switchRule.pinInfo["output"].value.data, typeof(string));
Assert.AreEqual(switchRule.pinInfo["output"].value.data, "True");
switchRule.pinInfo["switch"].value.data = true;
switchRule.evaluate();
targetRule.advanceDelta();
Assert.IsInstanceOfType(switchRule.pinInfo["output"].value.data, typeof(bool));
Assert.IsTrue((bool) switchRule.pinInfo["output"].value.data);
//test int and bool
switchRule.pinInfo["inputFalse"].valueType = typeof(pinDataNumber);
switchRule.pinInfo["inputFalse"].recreateValue();
switchRule.pinInfo["inputFalse"].value.data = new GenericNumber<short>(255);
switchRule.pinInfo["switch"].value.data = false;
switchRule.evaluate();
targetRule.advanceDelta();
Assert.IsInstanceOfType(switchRule.pinInfo["output"].value.data, typeof(INumber));
Assert.AreEqual(switchRule.pinInfo["output"].value.data, new GenericNumber<short>(255));
switchRule.pinInfo["switch"].value.data = true;
switchRule.evaluate();
targetRule.advanceDelta();
Assert.IsInstanceOfType(switchRule.pinInfo["output"].value.data, typeof(bool));
Assert.AreEqual(switchRule.pinInfo["output"].value.data, true);
//bool and tristate
switchRule.pinInfo["inputFalse"].valueType = typeof(pinDataTristate);
switchRule.pinInfo["inputFalse"].recreateValue();
switchRule.pinInfo["inputFalse"].value.data = tristate.yes;
switchRule.pinInfo["switch"].value.data = false;
switchRule.evaluate();
targetRule.advanceDelta();
Assert.IsInstanceOfType(switchRule.pinInfo["output"].value.data, typeof(tristate));
Assert.AreEqual(switchRule.pinInfo["output"].value.data, tristate.yes);
targetRule.stop();
}
public void testStartRunRuleItemSplitter()
{
rule targetRule = new rule();
ruleItemBase spliter = targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_splitter)));
targetRule.start();
spliter.pinInfo["input1"].value.data = false;
spliter.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(false, spliter.pinInfo["output1"].value.data);
Assert.AreEqual(false, spliter.pinInfo["output2"].value.data);
spliter.pinInfo["input1"].value.data = true;
spliter.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(true, spliter.pinInfo["output1"].value.data);
Assert.AreEqual(true, spliter.pinInfo["output2"].value.data);
spliter.pinInfo["input1"].valueType = typeof(pinDataString);
spliter.pinInfo["input1"].recreateValue();
spliter.pinInfo["input1"].value.data = "lol";
spliter.evaluate();
targetRule.advanceDelta();
Assert.AreEqual("lol", spliter.pinInfo["output1"].value.data);
Assert.AreEqual("lol", spliter.pinInfo["output2"].value.data);
spliter.pinInfo["input1"].valueType = typeof(pinDataTristate);
spliter.pinInfo["input1"].recreateValue();
spliter.pinInfo["input1"].value.data = tristate.yes;
spliter.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(tristate.yes, spliter.pinInfo["output1"].value.data);
Assert.AreEqual(tristate.yes, spliter.pinInfo["output2"].value.data);
}
public void testStartRunRuleItemNot()
{
rule targetRule = new rule();
ruleItemBase debugItem = targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_not)));
targetRule.start();
debugItem.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(tristate.noValue, debugItem.pinInfo["output1"].value.data);
debugItem.pinInfo["input1"].value.data = false;
debugItem.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(tristate.yes, debugItem.pinInfo["output1"].value.data);
debugItem.pinInfo["input1"].value.data = true;
debugItem.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(tristate.no, debugItem.pinInfo["output1"].value.data);
}
public void testStartRunRuleItemOr()
{
rule targetRule = new rule();
ruleItemBase orGate = targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_or)));
targetRule.start();
orGate.pinInfo["input1"].value.data = false;
orGate.pinInfo["input2"].value.data = false;
orGate.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(false, orGate.pinInfo["output1"].value.asBoolean());
orGate.pinInfo["input1"].value.data = true;
orGate.pinInfo["input2"].value.data = false;
orGate.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(true, orGate.pinInfo["output1"].value.asBoolean());
orGate.pinInfo["input1"].value.data = false;
orGate.pinInfo["input2"].value.data = true;
orGate.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(true, orGate.pinInfo["output1"].value.asBoolean());
orGate.pinInfo["input1"].value.data = true;
orGate.pinInfo["input2"].value.data = true;
orGate.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(true, orGate.pinInfo["output1"].value.asBoolean());
}
/// <summary>
/// Update a rows 'status' and status icon
/// </summary>
/// <param name="toUpdate">The rule to update</param>
private void updateRuleIcon(rule toUpdate)
{
ListViewItem itemToUpdate = findRuleItem(toUpdate);
if (itemToUpdate == null)
{
MessageBox.Show("Unable to update rule '" + toUpdate.name + "'");
return;
}
itemToUpdate.Text = toUpdate.state.ToString();
switch (toUpdate.state)
{
case ruleState.stopped:
itemToUpdate.ImageKey = "Pause.bmp";
break;
case ruleState.running:
itemToUpdate.ImageKey = "Run.bmp";
break;
case ruleState.errored:
itemToUpdate.ImageKey = "Critical.bmp";
break;
default:
throw new ArgumentOutOfRangeException("Invalid rule state");
}
}
public void testStartRunRuleItemAnd()
{
rule targetRule = new rule();
ruleItemBase andGate = targetRule.addRuleItem(new ruleItemInfo(typeof(ruleItem_and)));
targetRule.start();
andGate.pinInfo["input1"].value.data = false;
andGate.pinInfo["input2"].value.data = false;
andGate.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(false, andGate.pinInfo["output1"].value.data);
andGate.pinInfo["input1"].value.data = true;
andGate.pinInfo["input2"].value.data = false;
andGate.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(false, andGate.pinInfo["output1"].value.data);
andGate.pinInfo["input1"].value.data = false;
andGate.pinInfo["input2"].value.data = true;
andGate.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(false, andGate.pinInfo["output1"].value.data);
andGate.pinInfo["input1"].value.data = true;
andGate.pinInfo["input2"].value.data = true;
andGate.evaluate();
targetRule.advanceDelta();
Assert.AreEqual(true, andGate.pinInfo["output1"].value.data);
}
public void loadRule(rule toLoad)
{
this.stop();
this._rule = toLoad;
this.addRuleItemControlsAfterDeserialisation();
}
public List<IRule> getAllRules(bool forceReload)
{
if (_ruleList != null && !forceReload)
return _ruleList;
FileInfo[] fileList;
try
{
DirectoryInfo rulesDir = new DirectoryInfo(_rulesPath);
fileList = rulesDir.GetFiles();
}
catch(Exception ex)
{
throw new IOException("Unable to read rule files from " + _rulesPath, ex);
}
var newList = new List<IRule>(fileList.Length);
foreach (FileInfo thisFile in fileList)
{
try
{
StreamReader thisFileReader;
XmlSerializer mySer = new XmlSerializer(typeof(rule));
using (thisFileReader = new StreamReader(thisFile.FullName))
{
// Add our rule name to our listView, with a .tag() set to the rule object itself.
newList.Add((rule)mySer.Deserialize(thisFileReader));
}
}
catch
{
rule r = new rule(thisFile.Name.Substring(0,thisFile.Name.IndexOf('.')));
r.state = ruleState.errored;
r.addError(new fileReadError(thisFile.FullName));
newList.Add(r);
}
}
lock (_ruleLock)
_ruleList = newList;
return _ruleList;
}
private ListViewItem findRuleItem(rule toFind)
{
// Pull item out of listView
// todo: Is there a better way of doing this?
foreach (ListViewItem thisListViewItem in lstRules.Items)
{
if (thisListViewItem.SubItems[1].Text == toFind.name)
return thisListViewItem;
}
return null;
}
private void addNewRule(rule toAdd)
{
// if the rule is toolbox promoted it shouldn't appear in the list of runnable rules instead add it to the custom toolbox list
// which will be added to the rule editors box
if (toAdd.toolboxPromoted)
{
// _customToolbox.Add(new ruleItemCustom(toAdd));
}
else
{
// Create a new rule, and add it to our listView.
// Add the new rule's state and name as columns, and the rule object itself as a tag.
ListViewItem newItem = new ListViewItem();
toAdd.onStatusUpdate += updateRuleIcon;
newItem.SubItems.Add(toAdd.name);
newItem.SubItems.Add(false.ToString());
if (toAdd.isErrored)
newItem.SubItems.Add(toAdd.getError().Message);
newItem.Tag = toAdd;
lstRules.Items.Add(newItem);
updateRuleIcon(toAdd);
}
}
public void testSerialisationOfRuleWithTwoRuleItemWithPinsConnected()
{
rule rule = new rule("test");
lineChain line = new lineChain();
ruleItemInfo myInfo = new ruleItemInfo();
myInfo.itemType = ruleItemType.RuleItem;
myInfo.ruleItemBaseType = typeof(ruleItem_and);
ruleItemBase andItem = rule.addRuleItem(myInfo);
ruleItemGuid andGuid = andItem.serial;
ruleItemInfo myInfo2 = new ruleItemInfo();
myInfo2.itemType = ruleItemType.RuleItem;
myInfo2.ruleItemBaseType = typeof(ruleItem_desktopMessage);
ruleItemBase messageItem = rule.addRuleItem(myInfo2);
ruleItemGuid messageGuid = messageItem.serial;
messageItem.pinInfo["trigger"].parentRuleItem = messageGuid;
messageItem.pinInfo["trigger"].connectTo(line.serial,andItem.pinInfo["output1"]);
andItem.pinInfo["output1"].connectTo(line.serial, messageItem.pinInfo["trigger"]);
andItem.pinInfo["output1"].parentRuleItem = andGuid;
rule.AddLineChainToGlobalPool(line);
String serialised = rule.serialise();
rule = rule.deserialise(serialised);
Assert.AreEqual("test", rule.name);
Assert.AreEqual(1, rule.lineChainCount);
Assert.AreEqual(2, rule.ruleItems.Count);
andItem = rule.ruleItems[andGuid.id.ToString()];
messageItem = rule.ruleItems[messageGuid.id.ToString()];
Assert.IsInstanceOfType(andItem, typeof(ruleItem_and));
Assert.IsInstanceOfType(messageItem, typeof(ruleItem_desktopMessage));
Assert.AreEqual(1, messageItem.pinInfo.Count);
Assert.AreEqual(3, andItem.pinInfo.Count);
Assert.AreEqual(line.serial.id.ToString(), messageItem.pinInfo["trigger"].parentLineChain.id.ToString());
Assert.AreEqual(line.serial.id.ToString(), andItem.pinInfo["output1"].parentLineChain.id.ToString());
Assert.AreEqual(andItem.pinInfo["output1"].serial.id.ToString(), messageItem.pinInfo["trigger"].linkedTo.id.ToString());
Assert.AreEqual(messageItem.pinInfo["trigger"].serial.id.ToString(), andItem.pinInfo["output1"].linkedTo.id.ToString());
Assert.AreEqual(typeof(pinDataBool), andItem.pinInfo["output1"].valueType);
Assert.AreEqual(typeof(pinDataBool), messageItem.pinInfo["trigger"].valueType) ;
}
private void onSaveRule(rule saveThis)
{
// Find the Rule in the listView
ListViewItem ruleItem = findRuleItem(saveThis);
if (ruleItem == null)
{
DialogResult result;
frmQuestion frm = new frmQuestion("New Rule");
if ((result = frm.ShowDialog(this)) != DialogResult.OK)
{
MessageBox.Show("Unable to save rule");
return;
}
while (findRuleItem(frm.result) != null && result == DialogResult.OK)
result = frm.ShowDialog(this);
if (result == DialogResult.Cancel)
return;
saveThis.changeName(_myOptions.rulesPath,frm.result);
addNewRule(saveThis);
}
else
{
// mark the listView item as not being open in the editor any more
ruleItem.SubItems[2].Text = false.ToString();
// Stash our rule object in the listViewItem.
ruleItem.Tag = saveThis;
}
}
public void deserialiseRule(string serialised)
{
this._rule = rule.deserialise(serialised);
this.Parent.Width = this._rule.preferredWidth;
this.Parent.Height = this._rule.preferredHeight;
}
