internal static object ParseCommandId(ExtensionNode codon)
{
string id = codon.Id;
if (id.StartsWith("@"))
{
return(id.Substring(1));
}
return(id);
/* Type enumType = null;
* string typeName = id;
*
* int i = id.LastIndexOf (".");
* if (i != -1)
* typeName = id.Substring (0,i);
*
* enumType = codon.Addin.GetType (typeName);
*
* if (enumType == null)
* enumType = Type.GetType (typeName);
*
* if (enumType == null)
* enumType = typeof(Command).Assembly.GetType (typeName);
*
* if (enumType == null || !enumType.IsEnum)
* throw new InvalidOperationException ("Could not find an enum type for the command '" + id + "'.");
*
* try {
* return Enum.Parse (enumType, id.Substring (i+1));
* } catch {
* throw new InvalidOperationException ("Could not find an enum value for the command '" + id + "'.");
* }*/
}
public void TestGetExtensionNode()
{
ExtensionNode writer = AddinManager.GetExtensionNode("/SimpleApp/Writers/HelloWorldExtension.HelloWorldWriter");
Assert.IsNotNull(writer, "t1");
Assert.IsTrue(writer is TypeExtensionNode, "t2");
Assert.AreEqual(0, writer.ChildNodes.Count, "t3");
Assert.IsNotNull(writer.Addin, "t3");
Assert.AreEqual("SimpleApp.HelloWorldExtension", writer.Addin.Id, "t4");
Assert.IsTrue(writer.HasId, "t5");
Assert.AreEqual("HelloWorldExtension.HelloWorldWriter", writer.Id, "t6");
Assert.AreEqual("/SimpleApp/Writers/HelloWorldExtension.HelloWorldWriter", writer.Path, "t7");
TypeExtensionNode tn = (TypeExtensionNode)writer;
object ob = tn.CreateInstance() as IWriter;
Assert.IsNotNull(ob, "t8");
ob = tn.CreateInstance(typeof(IWriter)) as IWriter;
Assert.IsNotNull(ob, "t9");
try
{
ob = tn.CreateInstance(typeof(string)) as IWriter;
}
catch (InvalidOperationException)
{
}
}
public void TestGetExtensionPointRootNode()
{
ExtensionNode node = AddinManager.GetExtensionNode("/SimpleApp/Writers");
Assert.IsNotNull(node, "root node is null");
Assert.AreEqual(4, node.ChildNodes.Count, "Node count");
}
protected override void OnChildNodeRemoved(ExtensionNode node)
{
PolicyResourceNode res = (PolicyResourceNode)node;
polSet.RemoveAll(res.AddedKeys);
base.OnChildNodeRemoved(node);
}
private TExtension findReceiveBridge(ExtensionNode input)
{
//finds the extension that the receiveBridge belongs to
TExtension result = null;
int extensionCounter = 0;
while (extensionCounter < this.terminal.extensionLength() && result == null)
{
int receiveCoutner = 0;
while (receiveCoutner < this.terminal.extensionAt(extensionCounter).ReceiveNodes.Length&& result == null)
{
if (input.Equals(this.terminal.extensionAt(extensionCounter).ReceiveNodes[receiveCoutner]))
{
result = this.terminal.extensionAt(extensionCounter);
}
receiveCoutner++;
}
extensionCounter++;
}
return(result);
}
public int StartApplication(string appId, string[] parameters)
{
ExtensionNode node = AddinManager.GetExtensionNode("/MonoDevelop/Core/Applications/" + appId);
if (node == null)
{
throw new InstallException("Application not found: " + appId);
}
ApplicationExtensionNode apnode = node as ApplicationExtensionNode;
if (apnode == null)
{
throw new Exception("Invalid node type");
}
IApplication app = (IApplication)apnode.CreateInstance();
try {
return(app.Run(parameters));
} catch (Exception ex) {
Console.WriteLine(ex.Message);
LoggingService.LogFatalError(ex.ToString());
return(-1);
}
}
/// <summary>
/// Scan a single assembly for extensions marked by ExtensionAttribute.
/// For each extension, create an ExtensionNode and link it to the
/// correct ExtensionPoint.
/// </summary>
private void FindExtensionsInAssembly(string assemblyName)
{
var module = AssemblyDefinition.ReadAssembly(assemblyName).MainModule;
foreach (var type in module.GetTypes())
{
foreach (var attr in type.CustomAttributes)
{
if (attr.AttributeType.FullName == "NUnit.Engine.Extensibility.ExtensionAttribute")
{
var node = new ExtensionNode(assemblyName, type.FullName);
foreach (var x in attr.Properties)
{
switch (x.Name)
{
case "Path":
node.Path = x.Argument.Value as string;
break;
case "Description":
node.Description = x.Argument.Value as string;
break;
}
}
_extensions.Add(node);
ExtensionPoint ep;
if (node.Path == null)
{
ep = DeduceExtensionPointFromType(type);
if (ep == null)
{
string msg = string.Format(
"Unable to deduce ExtensionPoint for Type {0}. Specify Path on ExtensionAttribute to resolve.",
type.FullName);
throw new NUnitEngineException(msg);
}
node.Path = ep.Path;
}
else
{
ep = GetExtensionPoint(node.Path);
if (ep == null)
{
string msg = string.Format(
"Unable to locate ExtensionPoint for Type {0}. The Path {1} cannot be found.",
type.FullName,
node.Path);
throw new NUnitEngineException(msg);
}
}
ep.Install(node);
}
}
}
}
protected override void Visit(ExtensionNode node)
{
Nodes.Add(node);
PushFrame(new List <Node>(), new TFrameData());
Accept(node.Body);
node.Body = Nodes;
PopFrame();
}
protected override void OnChildNodeRemoved(ExtensionNode node)
{
PolicyResourceNode res = (PolicyResourceNode)node;
using (System.IO.StreamReader reader = res.GetStream())
polSet.RemoveSerializedPolicies(reader);
base.OnChildNodeRemoved(node);
}
protected override void Visit(ExtensionNode node)
{
this.Nodes.Add(node);
this.PushFrame(new List <Node>(), Activator.CreateInstance <TFrameData>());
base.Accept(node.Body);
node.Body = this.Nodes;
this.PopFrame();
}
public void TestGetUnknownExtensionNode()
{
ExtensionNode node = AddinManager.GetExtensionNode("/SimpleApp/Writers/Unknown");
Assert.IsNull(node, "t1");
node = AddinManager.GetExtensionNode("/SimpleApp/Writers/SomeFile/Unknown");
Assert.IsNull(node, "t2");
}
internal static object ParseCommandId(ExtensionNode codon)
{
string id = codon.Id;
if (id.StartsWith("@"))
{
return((object)id.Substring(1));
}
return((object)id);
}
protected override void Visit(ExtensionNode extensionNode)
{
var extensionChunk = new ExtensionChunk {
Extension = extensionNode.Extension, Position = Locate(extensionNode)
};
Chunks.Add(extensionChunk);
using (new Frame(this, extensionChunk.Body))
extensionNode.Extension.VisitNode(this, extensionNode.Body, Chunks);
}
public bool removeSendBridge(ExtensionNode send)
{
bool result = this.sendNodes.Remove(send);
if (result)
{
this.OnSendBridgeRemove?.Invoke();
}
return(result);
}
public bool removeReceiveBridge(ExtensionNode rec)
{
bool result = this.receiveNodes.Remove(rec);
if (result)
{
this.OnReceiveBridgeRemove?.Invoke();
}
return(result);
}
protected override void Visit(ExtensionNode node)
{
ExtensionNode item = new ExtensionNode(node.Element, node.Extension);
this.PushFrame();
this._frame.Nodes = item.Body;
base.Accept(node.Body);
this.PopFrame();
this.Nodes.Add(item);
}
protected override void Visit(ExtensionNode extensionNode)
{
ExtensionChunk item = new ExtensionChunk {
Extension = extensionNode.Extension,
Position = this.Locate(extensionNode)
};
this.Chunks.Add(item);
using (new Frame(this, item.Body))
{
extensionNode.Extension.VisitNode(this, extensionNode.Body, this.Chunks);
}
}
protected override void Visit(ExtensionNode node)
{
var reconstructed = new ExtensionNode(node.Element, node.Extension);
PushFrame();
_frame.Nodes = reconstructed.Body;
Accept(node.Body);
PopFrame();
Nodes.Add(reconstructed);
}
internal static object ParseCommandId(ExtensionNode codon)
{
string id = codon.Id;
if (id.StartsWith("@", StringComparison.Ordinal))
{
return(id.Substring(1));
}
else
{
return(id);
}
}
protected override void Visit(ElementNode node)
{
if (this.IsContainingElement(node.Name, node.Namespace))
{
this.PushSpecial(node);
if (node.IsEmptyElement)
{
this.PopSpecial(node.Name);
}
}
else if (this.IsNonContainingElement(node.Name, node.Namespace))
{
this.PushSpecial(node);
this.PopSpecial(node.Name);
}
else
{
ISparkExtension extension;
if (this.TryCreateExtension(node, out extension))
{
ExtensionNode item = new ExtensionNode(node, extension);
this.Nodes.Add(item);
if (!node.IsEmptyElement)
{
this._extensionNodes.Push(item);
this._stack.Push(this.Nodes);
this._nodes = item.Body;
}
}
else if (this.IsPartialFileElement(node.Name, node.Namespace))
{
List <AttributeNode> attributeNodes = new List <AttributeNode>(node.Attributes)
{
new AttributeNode("file", "_" + NameUtility.GetName(node.Name))
};
ElementNode element = new ElementNode("use", attributeNodes, node.IsEmptyElement)
{
OriginalNode = node
};
this.PushSpecial(element);
if (node.IsEmptyElement)
{
this.PopSpecial("use");
}
}
else
{
this.Add(node);
}
}
}
public void TestInit()
{
var r = new ExtensionNode();
r.Key = "0a0c".HexToBytes();
var b = new BranchNode();
var l1 = new ExtensionNode();
l1.Key = new byte[] { 0x01 };
var l2 = new ExtensionNode();
l2.Key = new byte[] { 0x09 };
var v1 = new LeafNode();
v1.Value = "abcd".HexToBytes();
var v2 = new LeafNode();
v2.Value = "2222".HexToBytes();
var v3 = new LeafNode();
v3.Value = Encoding.ASCII.GetBytes("hello");
var h1 = new HashNode();
h1.Hash = v3.GetHash();
var l3 = new ExtensionNode();
l3.Next = h1;
l3.Key = "0e".HexToBytes();
r.Next = b;
b.Children[0] = l1;
l1.Next = v1;
b.Children[9] = l2;
l2.Next = v2;
b.Children[10] = l3;
root = r;
var store = new MemoryStore();
var db = new MPTDb(store);
this.rootHash = root.GetHash();
db.Put(r);
db.Put(b);
db.Put(l1);
db.Put(l2);
db.Put(l3);
db.Put(v1);
db.Put(v2);
db.Put(v3);
this.mptdb = store;
}
static void RemoveRule(ExtensionNode extNode)
{
if (extNode is CategoryNode)
{
foreach (ExtensionNode child in extNode.ChildNodes)
{
RemoveRule(child);
}
return;
}
var node = (AnalysisRuleAddinNode)extNode;
rulesByInput.Remove(node.Input, node);
}
public void TestGetProof()
{
var r = new ExtensionNode();
r.Key = "0a0c".HexToBytes();
var b = new BranchNode();
var l1 = new ExtensionNode();
l1.Key = new byte[] { 0x01 };
var l2 = new ExtensionNode();
l2.Key = new byte[] { 0x09 };
var v1 = new LeafNode();
v1.Value = "abcd".HexToBytes();
var v2 = new LeafNode();
v2.Value = "2222".HexToBytes();
var v3 = new LeafNode();
v3.Value = Encoding.ASCII.GetBytes("hello");
var h1 = new HashNode();
h1.Hash = v3.GetHash();
var l3 = new ExtensionNode();
l3.Next = h1;
l3.Key = "0e".HexToBytes();
r.Next = b;
b.Children[0] = l1;
l1.Next = v1;
b.Children[9] = l2;
l2.Next = v2;
b.Children[10] = l3;
var mpt = new MPTTrie(rootHash, mptdb);
Assert.AreEqual(r.GetHash().ToString(), mpt.GetRoot().ToString());
var result = mpt.GetProof("ac01".HexToBytes(), out HashSet <byte[]> proof);
Assert.IsTrue(result);
Assert.AreEqual(4, proof.Count);
Assert.IsTrue(proof.Contains(b.Encode()));
Assert.IsTrue(proof.Contains(r.Encode()));
Assert.IsTrue(proof.Contains(l1.Encode()));
Assert.IsTrue(proof.Contains(v1.Encode()));
}
public bool CanLoadFrom(string path)
{
ExtensionNode node = GetNodeForPath(path);
if (node != null)
{
var loader = node.ExtensionObject as IProjectLoader;
if (loader.CanLoadFrom(path))
{
return(true);
}
}
return(false);
}
public void TestDataExtensionWithAttribute()
{
ExtensionNodeList nodes = AddinManager.GetExtensionNodes("/SimpleApp/DataExtensionWithAttribute");
Assert.AreEqual(2, nodes.Count, "Node count");
ExtensionNode <SimpleExtensionAttribute> n1 = nodes [0] as ExtensionNode <SimpleExtensionAttribute>;
ExtensionNode <SimpleExtensionAttribute> n2 = nodes [1] as ExtensionNode <SimpleExtensionAttribute>;
Assert.IsNotNull(n1);
Assert.IsNotNull(n2);
Assert.AreEqual("test3", n1.Data.Name, "t1");
Assert.AreEqual(true, n1.Data.Value, "t2");
Assert.AreEqual("test4", n2.Data.Name, "t1");
Assert.AreEqual(false, n2.Data.Value, "t2");
}
private IProject LoadFrom(string path)
{
ExtensionNode node = GetNodeForPath(path);
if (node != null)
{
var loader = node.ExtensionObject as IProjectLoader;
if (loader.CanLoadFrom(path))
{
return(loader.LoadFrom(path));
}
}
return(null);
}
protected override void Visit(ElementNode node)
{
ISparkExtension extension;
if (IsContainingElement(node.Name, node.Namespace))
{
PushSpecial(node);
if (node.IsEmptyElement)
{
PopSpecial(node.Name);
}
}
else if (IsNonContainingElement(node.Name, node.Namespace))
{
PushSpecial(node);
PopSpecial(node.Name);
}
else if (TryCreateExtension(node, out extension))
{
ExtensionNode extensionNode = new ExtensionNode(node, extension);
Nodes.Add(extensionNode);
if (!node.IsEmptyElement)
{
_extensionNodes.Push(extensionNode);
_stack.Push(Nodes);
_nodes = extensionNode.Body;
}
}
else if (IsPartialFileElement(node.Name, node.Namespace))
{
var attributes = new List <AttributeNode>(node.Attributes);
attributes.Add(new AttributeNode("file", "_" + NameUtility.GetName(node.Name)));
var useFile = new ElementNode("use", attributes, node.IsEmptyElement)
{
OriginalNode = node
};
PushSpecial(useFile);
if (node.IsEmptyElement)
{
PopSpecial("use");
}
}
else
{
Add(node);
}
}
public void TestExtensionWithChildren()
{
ExtensionNodeList nodes = AddinManager.GetExtensionNodes("/SimpleApp/NodeWithChildren");
Assert.AreEqual(2, nodes.Count, "Node count");
ExtensionNode n1 = nodes [0];
ExtensionNode n2 = nodes [1];
Assert.AreEqual("node1", n1.Id, "t1");
Assert.AreEqual(3, n1.ChildNodes.Count, "n1 node count");
Assert.AreEqual("child1", n1.ChildNodes[0].Id, "t1.1");
Assert.AreEqual("child1.1", n1.ChildNodes[1].Id, "t1.2");
Assert.AreEqual("child2", n1.ChildNodes[2].Id, "t1.3");
Assert.AreEqual("node2", n2.Id, "t2");
}
public void TestTryDelete()
{
var r1 = new ExtensionNode();
r1.Key = "0a0c0001".HexToBytes();
var r = new ExtensionNode();
r.Key = "0a0c".HexToBytes();
var b = new BranchNode();
r.Next = b;
var l1 = new ExtensionNode();
l1.Key = new byte[] { 0x01 };
var v1 = new LeafNode();
v1.Value = "abcd".HexToBytes();
l1.Next = v1;
b.Children[0] = l1;
var l2 = new ExtensionNode();
l2.Key = new byte[] { 0x09 };
var v2 = new LeafNode();
v2.Value = "2222".HexToBytes();
l2.Next = v2;
b.Children[9] = l2;
r1.Next = v1;
Assert.AreEqual("0xdea3ab46e9461e885ed7091c1e533e0a8030b248d39cbc638962394eaca0fbb3", r1.GetHash().ToString());
Assert.AreEqual("0x93e8e1ffe2f83dd92fca67330e273bcc811bf64b8f8d9d1b25d5e7366b47d60d", r.GetHash().ToString());
var mpt = new MPTTrie(rootHash, mptdb);
var result = true;
result = mpt.TryGet("ac99".HexToBytes(), out byte[] value);
Assert.IsTrue(result);
result = mpt.TryDelete("ac99".HexToBytes());
Assert.IsTrue(result);
result = mpt.TryDelete("acae".HexToBytes());
Assert.IsTrue(result);
Assert.AreEqual("0xdea3ab46e9461e885ed7091c1e533e0a8030b248d39cbc638962394eaca0fbb3", mpt.GetRoot().ToString());
}
static void AddRule(ExtensionNode extNode)
{
if (extNode is CategoryNode)
{
foreach (ExtensionNode child in extNode.ChildNodes)
{
AddRule(child);
}
return;
}
if (extNode is AnalysisRuleAddinNode)
{
var node = (AnalysisRuleAddinNode)extNode;
rulesByInput.Add(node.Input, node);
}
}
public Addin Read(Assembly ass, string manifest)
{
var a = new Addin();
var xml = new XmlDocument();
xml.LoadXml(manifest);
string ns = xml.DocumentElement.NamespaceURI;
foreach (XmlNode c in xml.FirstChild.ChildNodes)
{
if (c.Name == "meta")
{
foreach (XmlNode meta in c.ChildNodes)
{
switch (meta.Name)
{
case "author":
a.Author = meta.InnerText;
break;
case "version":
a.Version = meta.InnerText;
break;
case "name":
a.Name = meta.InnerText;
break;
case "icon":
a.IconPath = meta.InnerText;
break;
}
}
}
else if (c.Name == "extension")
{
var en = new ExtensionNode();
en.Path = c.Attributes["path"].Value;
foreach (XmlNode cc in c.ChildNodes)
{
if (cc.Name == "command")
{
string cls = cc.Attributes["class"].Value.Replace("{namespace}", ns);
en.Commands.Add(cls, Activator.CreateInstance(ass.GetType(cls)));
}
else
{
var ec = new ExtensionCommand { Name = cc.Name };
ec.atts = cc.Attributes;
ec.reference = cc;
en.Nodes.Add(ec);
}
}
a.ExtensionNodes.Add(en);
}
else if (c.Name == "dependencies")
{
foreach (XmlNode dc in c.ChildNodes)
{
if (dc.Name == "dependency")
{
if (File.Exists(dc.Attributes["path"].Value))
{
a.Dependencies.Add(File.ReadAllBytes(dc.Attributes["path"].Value));
}
else
{
throw new AddinException(
"Dependency '" + dc.Attributes["path"].Value + "' does not exist!");
}
}
}
}
}
return a;
}
