public void TestObjectWithPrimitiveList()
{
var nodeContainer = new NodeContainer();
var instance = new PrimitiveListClass {
Member1 = 3, Member2 = new List <string> {
"aaa", "bbb", "ccc"
}
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new IGraphNode[]
{
rootNode,
rootNode[nameof(PrimitiveListClass.Member1)],
rootNode[nameof(PrimitiveListClass.Member2)],
rootNode[nameof(PrimitiveListClass.Member2)].Target,
};
var expectedPaths = new GraphNodePath[4];
expectedPaths[0] = new GraphNodePath(rootNode);
expectedPaths[1] = expectedPaths[0].Clone();
expectedPaths[1].PushMember(nameof(PrimitiveListClass.Member1));
expectedPaths[2] = expectedPaths[0].Clone();
expectedPaths[2].PushMember(nameof(PrimitiveListClass.Member2));
expectedPaths[3] = expectedPaths[2].Clone();
expectedPaths[3].PushTarget();
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void TestSimpleObject()
{
var nodeContainer = new NodeContainer();
var instance = new SimpleClass {
Member1 = 3, Member2 = new SimpleClass()
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new IGraphNode[]
{
rootNode,
rootNode[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass.Member2)],
rootNode[nameof(SimpleClass.Member2)].Target,
rootNode[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member2)],
};
var expectedPaths = new GraphNodePath[6];
expectedPaths[0] = new GraphNodePath(rootNode);
expectedPaths[1] = new GraphNodePath(rootNode);
expectedPaths[1].PushMember(nameof(SimpleClass.Member1));
expectedPaths[2] = new GraphNodePath(rootNode);
expectedPaths[2].PushMember(nameof(SimpleClass.Member2));
expectedPaths[3] = expectedPaths[2].Clone();
expectedPaths[3].PushTarget();
expectedPaths[4] = expectedPaths[3].Clone();
expectedPaths[4].PushMember(nameof(SimpleClass.Member1));
expectedPaths[5] = expectedPaths[3].Clone();
expectedPaths[5].PushMember(nameof(SimpleClass.Member2));
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void PropertyVisitor_WhenChainingAdapters_RespectVisitation(int count, params VisitStatus[] statuses)
{
var container = new Container();
var expectedHasDefault = true;
foreach (var status in statuses)
{
if (status == VisitStatus.Stop)
{
expectedHasDefault = false;
break;
}
if (status == VisitStatus.Handled)
{
break;
}
}
var visitor = new TestVisitor(expectedHasDefault ? "0" : "");
foreach (var status in statuses)
{
visitor.AddAdapter(new ChainedAdapter(visitor, status));
}
PropertyContainer.Accept(visitor, ref container);
Assert.That(visitor.ToString(), Is.EqualTo(new string('0', count)));
}
public void CanReturnEmptyListIfNoOperandsFound()
{
//-- Arrange
DeriveClassFrom <object>()
.DefaultConstructor()
.ImplementInterface <AncestorRepository.IFewMethods>()
.Method(intf => intf.One).Implement(w => Static.Void(Console.WriteLine))
.AllMethods().Throw <NotImplementedException>()
.Flush();
var method = base.Class.GetAllMembers().OfType <MethodMember>().Single(m => m.Name == "One");
method.Write();
//-- Act
var visitor = new TestVisitor();
method.AcceptVisitor(visitor);
var visitedOperands = visitor.GetVisitedOperands();
//-- Assert
Assert.That(visitedOperands, Is.Empty);
}
public void TestObjectWithStruct()
{
var nodeContainer = new NodeContainer();
var instance = new StructClass {
Member1 = 3, Member2 = new Struct()
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new[]
{
rootNode,
rootNode.TryGetChild(nameof(StructClass.Member1)),
rootNode.TryGetChild(nameof(StructClass.Member2)),
rootNode.TryGetChild(nameof(StructClass.Member2)).TryGetChild(nameof(Struct.Member1)),
rootNode.TryGetChild(nameof(StructClass.Member2)).TryGetChild(nameof(Struct.Member2)),
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode),
new GraphNodePath(rootNode).PushMember(nameof(StructClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(StructClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(StructClass.Member2)).PushMember(nameof(Struct.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(StructClass.Member2)).PushMember(nameof(Struct.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void SnQuery_Visitor_Rewrite_CSrv()
{
var tree = new LogicalPredicate(
new []
{
new LogicalClause(new LogicalPredicate(
new [] {
new LogicalClause(new SimplePredicate("F1", new IndexValue("V1")), Occurence.Should),
new LogicalClause(new SimplePredicate("F2", new IndexValue("V2")), Occurence.Should)
}), Occurence.Must),
new LogicalClause(new LogicalPredicate(
new [] {
new LogicalClause(new SimplePredicate("F3", new IndexValue("V3")), Occurence.Should),
new LogicalClause(new RangePredicate("F4", null, new IndexValue(10), true, true), Occurence.Should),
}), Occurence.Must),
});
var visitor = new TestVisitor();
var rewritten = visitor.Visit(tree);
var dumper = new SnQueryToStringVisitor();
dumper.Visit(rewritten);
Assert.AreEqual("+(F1:V1 F2:V2222) +(F3:V3 F4:<10)", dumper.Output);
}
public void CanVisitThisAndFields()
{
//-- Arrange
Field <int> fieldOne;
DeriveClassFrom <object>()
.Field("m_One", out fieldOne)
.DefaultConstructor()
.ImplementInterface <AncestorRepository.IFewMethods>()
.Method <int, string>(intf => intf.Five).Implement((w, n) => {
fieldOne.Assign(n);
w.Return(fieldOne.Func <string>(x => x.ToString));
})
.AllMethods().Throw <NotImplementedException>()
.Flush();
var method = base.Class.GetAllMembers().OfType <MethodMember>().Single(m => m.Name == "Five");
method.Write();
//-- Act
var visitor = new TestVisitor();
method.AcceptVisitor(visitor);
var visitedOperandStrings = visitor.GetVisitedOperands().Select(op => op.ToString()).ToArray();
//-- Assert
CollectionAssert.Contains(visitedOperandStrings, "this");
CollectionAssert.Contains(visitedOperandStrings, "this.Field[m_One]");
}
public void TestSimpleObject()
{
var nodeContainer = new NodeContainer();
var instance = new SimpleClass { Member1 = 3, Member2 = new SimpleClass() };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new[]
{
rootNode,
rootNode.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass.Member2)),
rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target,
rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)),
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void CanVisitLocalsAndArguments()
{
//-- Arrange
DeriveClassFrom <object>()
.DefaultConstructor()
.ImplementInterface <AncestorRepository.IFewMethods>()
.Method <int, string>(intf => intf.Five).Implement((w, n) => {
var s = w.Local <string>();
s.Assign(n.Func <string>(x => x.ToString));
w.Return(s);
})
.AllMethods().Throw <NotImplementedException>()
.Flush();
var method = base.Class.GetAllMembers().OfType <MethodMember>().Single(m => m.Name == "Five");
method.Write();
//-- Act
var visitor = new TestVisitor();
method.AcceptVisitor(visitor);
var visitedOperandStrings = visitor.GetVisitedOperands().Select(op => op.ToString()).ToArray();
//-- Assert
CollectionAssert.Contains(visitedOperandStrings, "Loc0");
CollectionAssert.Contains(visitedOperandStrings, "Arg1[n]");
}
public void TestObjectWithPrimitiveList()
{
var nodeContainer = new NodeContainer();
var instance = new PrimitiveListClass {
Member1 = 3, Member2 = new List <string> {
"aaa", "bbb", "ccc"
}
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new IContentNode[]
{
rootNode,
rootNode[nameof(PrimitiveListClass.Member1)],
rootNode[nameof(PrimitiveListClass.Member2)],
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode),
new GraphNodePath(rootNode).PushMember(nameof(PrimitiveListClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(PrimitiveListClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void TestSimpleObject()
{
var nodeContainer = new NodeContainer();
var instance = new SimpleClass {
Member1 = 3, Member2 = new SimpleClass()
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new IContentNode[]
{
rootNode,
rootNode[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass.Member2)],
rootNode[nameof(SimpleClass.Member2)].Target,
rootNode[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member2)],
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
private TestVisitor RegisterTestLogVisitor(Type stateTypeToCheck)
{
var visitor = new TestVisitor(stateTypeToCheck);
new LogCollector(brain, visitor);
return(visitor);
}
public void TestCircularReference()
{
var nodeContainer = new NodeContainer();
var obj1 = new SimpleClass {
Member1 = 3
};
var obj2 = new SimpleClass {
Member1 = 3
};
obj1.Member2 = obj2;
obj2.Member2 = obj1;
var rootNode1 = nodeContainer.GetOrCreateNode(obj1);
var rootNode2 = nodeContainer.GetOrCreateNode(obj2);
var visitor = new TestVisitor();
visitor.Visit(rootNode1);
var expectedNodes = new IContentNode[]
{
rootNode1,
rootNode1[nameof(SimpleClass.Member1)],
rootNode1[nameof(SimpleClass.Member2)],
rootNode2,
rootNode2[nameof(SimpleClass.Member1)],
rootNode2[nameof(SimpleClass.Member2)],
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode1),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
visitor.Visit(rootNode2);
expectedNodes = new IContentNode[]
{
rootNode2,
rootNode2[nameof(SimpleClass.Member1)],
rootNode2[nameof(SimpleClass.Member2)],
rootNode1,
rootNode1[nameof(SimpleClass.Member1)],
rootNode1[nameof(SimpleClass.Member2)],
};
expectedPaths = new[]
{
new GraphNodePath(rootNode2),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void VisitTest()
{
TestVisitor visitor = new TestVisitor();
_testCommand.Visit(visitor);
Assert.IsInstanceOf(typeof(EmptyCommand), visitor.VisitedCommand);
}
public void PropertyVisitor_WithoutAdapters_CallsDefaultBehaviour()
{
var container = new Container();
var visitor = new TestVisitor("No adapters were reached");
PropertyContainer.Accept(visitor, ref container);
Assert.That(visitor.ToString(), Is.EqualTo("No adapters were reached"));
}
public void TestMultipleReferences()
{
var nodeContainer = new NodeContainer();
var commonObj = new SimpleClass();
var instance = new SimpleClass2 {
Member1 = 3, Member2 = new SimpleClass {
Member1 = 4, Member2 = commonObj
}, Member3 = new SimpleClass {
Member1 = 5, Member2 = commonObj
}
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new[]
{
rootNode,
rootNode.TryGetChild(nameof(SimpleClass2.Member1)),
rootNode.TryGetChild(nameof(SimpleClass2.Member2)),
rootNode.TryGetChild(nameof(SimpleClass2.Member2)).Target,
rootNode.TryGetChild(nameof(SimpleClass2.Member2)).Target.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass2.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)),
rootNode.TryGetChild(nameof(SimpleClass2.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)).Target,
rootNode.TryGetChild(nameof(SimpleClass2.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass2.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)),
rootNode.TryGetChild(nameof(SimpleClass2.Member3)),
rootNode.TryGetChild(nameof(SimpleClass2.Member3)).Target,
rootNode.TryGetChild(nameof(SimpleClass2.Member3)).Target.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass2.Member3)).Target.TryGetChild(nameof(SimpleClass.Member2)),
rootNode.TryGetChild(nameof(SimpleClass2.Member3)).Target.TryGetChild(nameof(SimpleClass.Member2)).Target,
rootNode.TryGetChild(nameof(SimpleClass2.Member3)).Target.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass2.Member3)).Target.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)),
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member2)).PushTarget(),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member3)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member3)).PushTarget(),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member3)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member3)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member3)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member3)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(SimpleClass2.Member3)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void PropertyVisitor_WithContravariantAdapters_CallsMostTyped()
{
var container = new ContainerWithInterface();
var visitor = new TestVisitor("");
visitor.AddAdapter(new ContravariantAdapter(visitor));
PropertyContainer.Accept(visitor, ref container);
Assert.That(visitor.ToString(), Is.EqualTo("ABA"));
}
public void TestValidateAlgorithm_NoName_NoThrow()
{
TestVisitor v = new TestVisitor();
JobXmlValidator visitor = new JobXmlValidator(v);
XNode xml = new XElement("algorithm");
visitor.VisitAlgorithm(xml);
Assert.IsFalse(v.VisitedAlgorithm);
}
public void VisitorTest()
{
var jsonGrammar = new JsonGrammar();
var result = jsonGrammar.Parser.Parse(json).Value;
var testVisitor = new TestVisitor();
testVisitor.Visit(result);
foreach (var property in testVisitor.GetType().GetFields().Where(f => f.FieldType == typeof(bool)))
Assert.IsTrue((bool)property.GetValue(testVisitor));
}
public void TestConstructor_ValidVisitor()
{
TestVisitor v = new TestVisitor();
XmlValidatorArgs args = new XmlValidatorArgs(v);
Assert.AreEqual(v, args.Visitor);
Assert.IsFalse(args.ThrowOnError);
Assert.IsNull(args.InputValidator);
Assert.IsNull(args.AlgorithmValidator);
}
public void ExecutorVisitorVisit_FuncCall_CreateFuncCallAST(string text)
{
var lexer = new Lexer(new StringSource(text));
var parser = new Parser(lexer);
var program = parser.Parse();
var testVisitor = new TestVisitor();
testVisitor.Visit(program);
Assert.AreEqual(text, writer.ToString());
}
public void Instantiation()
{
var visitor = new TestVisitor();
new LogCollector(brain, visitor);
env.Tick();
// Direction change will fire a log event which is captured by LogCollector
// and forwarded to TestVisitor.
Assert.True(visitor.Visited);
}
public void ExecutorVisitorVisit_IfStatement_CreateIfStatementAST(string text, string expected)
{
var lexer = new Lexer(new StringSource(text));
var parser = new Parser(lexer);
var program = parser.Parse();
var testVisitor = new TestVisitor();
testVisitor.Visit(program);
Assert.AreEqual(expected, writer.ToString());
}
public void PropertyVisitor_WithMixedAdapters_CanIterate()
{
var container = new MixedContainer();
var visitor = new TestVisitor("");
visitor.AddAdapter(new MixedContravariantAdapter(visitor));
visitor.AddAdapter(new MixedAdapter(visitor));
PropertyContainer.Accept(visitor, ref container);
Assert.That(visitor.ToString(), Is.EqualTo("AA"));
}
static void Main(string[] args)
{
Parser parser = new Parser(new Lexer("int test = 10; int anotherTest = 15;", getMatchers()));
TestVisitor visitor = new TestVisitor();
foreach (Ast ast in parser.Parse())
{
ast.Visit(visitor);
}
Console.Read();
}
public Expression Apply(Session session, Expression query)
{
var visitor = new TestVisitor();
var result = visitor.Visit(query);
if (visitor.ClosureRegistered())
{
session.Extensions.Set(new ClosureMarker());
}
return(result);
}
public void TestASTVisitor()
{
var testVisitor = new TestVisitor();
var plusOperator = AstContext.TranslationUnits
.SelectMany(u => u.Namespaces.Where(n => n.Name == "Math"))
.SelectMany(n => n.Classes.Where(c => c.Name == "Complex"))
.SelectMany(c => c.Methods.Where(m => m.OperatorKind == CXXOperatorKind.Plus))
.First();
Assert.IsTrue(plusOperator.Visit(testVisitor));
}
public void PropertyVisitor_WithWrappingAdapter_CallsAdapterAndDefault()
{
var container = new Container();
var visitor = new TestVisitor("Failure is inevitable");
visitor.AddAdapter(new WrappingAdapter(visitor));
PropertyContainer.Accept(visitor, ref container);
Assert.That(visitor.ToString(),
Is.EqualTo("This sentence: \"Failure is inevitable\" is simply not true"));
}
public void PropertyVisitor_WithExcludeAdapter_StopsVisitationWhenRequired()
{
var container = new ExcludeContainer();
var visitor = new TestVisitor("X");
visitor.AddAdapter(new ExcludeAdapter(visitor));
PropertyContainer.Accept(visitor, ref container);
Assert.That(visitor.ToString(), Does.Not.Contain("int"));
Assert.That(visitor.ToString(), Does.Contain("float"));
}
public void PropertyVisitor_WithInertAdapter_ContinuesAsExpected()
{
var container = new Container();
var visitor = new TestVisitor("");
visitor.AddAdapter(new MixedContravariantAdapter(visitor));
visitor.AddAdapter(new MixedAdapter(visitor));
visitor.AddAdapter(new MultiAdapter(visitor));
PropertyContainer.Accept(visitor, ref container);
Assert.That(visitor.ToString(), Is.EqualTo("IVisit<Container, int>"));
}
public void VisitorTest()
{
var jsonGrammar = new JsonGrammar();
var result = jsonGrammar.Parser.Parse(json).Value;
var testVisitor = new TestVisitor();
testVisitor.Visit(result);
foreach (var property in testVisitor.GetType().GetFields().Where(f => f.FieldType == typeof(bool)))
{
Assert.IsTrue((bool)property.GetValue(testVisitor));
}
}
public void TestObjectWithStructList()
{
var nodeContainer = new NodeContainer();
// We also test a null item in the list
var instance = new StructListClass {
Member1 = 3, Member2 = new List <Struct> {
new Struct(), new Struct()
}
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
Index index = new Index(0);
IContentNode tempQualifier = rootNode[nameof(StructListClass.Member2)];
Index index1 = new Index(0);
IContentNode tempQualifier1 = rootNode[nameof(StructListClass.Member2)];
Index index2 = new Index(0);
IContentNode tempQualifier2 = rootNode[nameof(StructListClass.Member2)];
Index index3 = new Index(1);
IContentNode tempQualifier3 = rootNode[nameof(StructListClass.Member2)];
Index index4 = new Index(1);
IContentNode tempQualifier4 = rootNode[nameof(StructListClass.Member2)];
Index index5 = new Index(1);
IContentNode tempQualifier5 = rootNode[nameof(StructListClass.Member2)];
var expectedNodes = new IContentNode[]
{
rootNode,
rootNode[nameof(StructListClass.Member1)],
rootNode[nameof(StructListClass.Member2)],
tempQualifier.IndexedTarget(index),
tempQualifier1.IndexedTarget(index1)[nameof(StructListClass.Member1)],
tempQualifier2.IndexedTarget(index2)[nameof(StructListClass.Member2)],
tempQualifier3.IndexedTarget(index3),
tempQualifier4.IndexedTarget(index4)[nameof(StructListClass.Member1)],
tempQualifier5.IndexedTarget(index5)[nameof(StructListClass.Member2)],
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(0)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(0)).PushMember(nameof(StructListClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(0)).PushMember(nameof(StructListClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(1)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(1)).PushMember(nameof(StructListClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(1)).PushMember(nameof(StructListClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void HtmlTree_VisitorTest() {
string html = "<html><head>" +
"<script>alert(\"boo!\")</script>" +
"<style>.a { color: red; }</style>" +
"</head>" +
"<body style=\"text:green\" onload=\"some_script\">" +
"</body></html>";
HtmlTree tree = ParseHtml(html);
var visitor = new TestVisitor();
tree.RootNode.Accept(visitor, parameter: null);
Assert.Equal(6, visitor.Count); // 5 + root node
}
public void TestEatDeclarationWithAssignment()
{
Token tmpToken;
ILineContext tmpContext;
List<Token> tokens = new List<Token>();
tmpToken = new Token(Global.DataType.VAR);
tmpToken.value = "var";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.IDENTIFIER);
tmpToken.value = "a";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.OPERATOR);
tmpToken.value = "=";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.INT);
tmpToken.value = "3";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.OPERATOR);
tmpToken.value = "+";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.INT);
tmpToken.value = "2";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.ENDSTATEMENT);
tokens.Add(tmpToken);
List<ILineContext> context = new List<ILineContext>();
for (int i = 0; i < 7; i++)
{
tmpContext = new LineContext(1, 1);
context.Add(tmpContext);
}
SyntaxAnalyzer syntaxAnalyer = new SyntaxAnalyzer();
TestVisitor testVisitor = new TestVisitor();
Base result = syntaxAnalyer.CheckSyntax(tokens, context, Global.InstructionSets.X86_64);
/*Assert.AreEqual(Global.ASTType.VAR_DECLARATION, result.GetChildren()[0].GetType());
Assert.AreEqual("a", result.GetChildren()[0].GetName());
Assert.AreEqual(Global.ASTType.ASSIGNMENT, result.GetChildren()[1].GetType());*/
}
public void CanInheritVisitor()
{
var log = LogManager.Create("repo");
var repos = new java.util.ArrayList();
var mgr = CeylonUtils.makeRepositoryManager(repos, OutRepoLocation, log);
var tcb = new TypeCheckerBuilder();
tcb.verbose(true);
tcb.setRepositoryManager(mgr);
var srcFile = new java.io.File("hello.ceylon");
tcb.addSrcDirectory(srcFile);
var tc = tcb.getTypeChecker();
tc.process();
var v = new TestVisitor(log);
foreach(var unit in tc.getPhasedUnits().getPhasedUnits().Enumerate<PhasedUnit>())
{
unit.getCompilationUnit().visit(v);
}
}
public void TestObjectWithStructList()
{
var nodeContainer = new NodeContainer();
// We also test a null item in the list
var instance = new StructListClass { Member1 = 3, Member2 = new List<Struct> { new Struct(), new Struct() } };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
Index index = new Index(0);
IGraphNode tempQualifier = rootNode.TryGetChild(nameof(StructListClass.Member2));
Index index1 = new Index(0);
IGraphNode tempQualifier1 = rootNode.TryGetChild(nameof(StructListClass.Member2));
Index index2 = new Index(0);
IGraphNode tempQualifier2 = rootNode.TryGetChild(nameof(StructListClass.Member2));
Index index3 = new Index(1);
IGraphNode tempQualifier3 = rootNode.TryGetChild(nameof(StructListClass.Member2));
Index index4 = new Index(1);
IGraphNode tempQualifier4 = rootNode.TryGetChild(nameof(StructListClass.Member2));
Index index5 = new Index(1);
IGraphNode tempQualifier5 = rootNode.TryGetChild(nameof(StructListClass.Member2));
var expectedNodes = new[]
{
rootNode,
rootNode.TryGetChild(nameof(StructListClass.Member1)),
rootNode.TryGetChild(nameof(StructListClass.Member2)),
tempQualifier.IndexedTarget(index),
tempQualifier1.IndexedTarget(index1).TryGetChild(nameof(StructListClass.Member1)),
tempQualifier2.IndexedTarget(index2).TryGetChild(nameof(StructListClass.Member2)),
tempQualifier3.IndexedTarget(index3),
tempQualifier4.IndexedTarget(index4).TryGetChild(nameof(StructListClass.Member1)),
tempQualifier5.IndexedTarget(index5).TryGetChild(nameof(StructListClass.Member2)),
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(0)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(0)).PushMember(nameof(StructListClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(0)).PushMember(nameof(StructListClass.Member2)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(1)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(1)).PushMember(nameof(StructListClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(StructListClass.Member2)).PushIndex(new Index(1)).PushMember(nameof(StructListClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void TestExpressionPlus()
{
Token tmpToken;
ILineContext tmpContext;
List<Token> tokens = new List<Token>();
tmpToken = new Token(Global.DataType.VAR);
tmpToken.value = "var";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.IDENTIFIER);
tmpToken.value = "a";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.OPERATOR);
tmpToken.value = "=";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.INT);
tmpToken.value = "3";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.OPERATOR);
tmpToken.value = "+";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.INT);
tmpToken.value = "2";
tokens.Add(tmpToken);
tmpToken = new Token(Global.DataType.ENDSTATEMENT);
tokens.Add(tmpToken);
List<ILineContext> context = new List<ILineContext>();
for (int i = 0; i < 7; i++)
{
tmpContext = new LineContext(1, 1);
context.Add(tmpContext);
}
SyntaxAnalyzer syntaxAnalyer = new SyntaxAnalyzer();
TestVisitor testVisitor = new TestVisitor();
Base result = syntaxAnalyer.CheckSyntax(tokens, context, Global.InstructionSets.X86_64);
Assert.AreEqual(new VarDeclaration(null).GetType(), result.Children[0].GetType());
Assert.AreEqual("a", ((VarDeclaration)result.Children[0]).Name.Name);
Assert.AreEqual(new Assignment(null).GetType(), result.Children[1].GetType());
Assert.AreEqual("a", ((Assignment) result.Children[1]).LHS.Name);
Assert.AreEqual(new PlusExp(null, null, null).GetType(), ((Assignment)result.Children[1]).RHS.GetType());
Assert.AreEqual(new Int64Literal(null, null).GetType(), ((PlusExp)((Assignment)result.Children[1]).RHS).e1.GetType());
Assert.AreEqual(new Int64Literal(null, null).GetType(), ((PlusExp)((Assignment)result.Children[1]).RHS).e2.GetType());
Assert.AreEqual("3", ((Int64Literal) ((PlusExp) ((Assignment)result.Children[1]).RHS).e1).Value);
Assert.AreEqual("2", ((Int64Literal)((PlusExp)((Assignment)result.Children[1]).RHS).e2).Value);
}
public void TestObjectWithPrimitiveList()
{
var nodeContainer = new NodeContainer();
var instance = new PrimitiveListClass { Member1 = 3, Member2 = new List<string> { "aaa", "bbb", "ccc" } };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new[]
{
rootNode,
rootNode.TryGetChild(nameof(PrimitiveListClass.Member1)),
rootNode.TryGetChild(nameof(PrimitiveListClass.Member2)),
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode),
new GraphNodePath(rootNode).PushMember(nameof(PrimitiveListClass.Member1)),
new GraphNodePath(rootNode).PushMember(nameof(PrimitiveListClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void SetUp()
{
_visitor = new TestVisitor();
_parser = new SqlCmdParser(_visitor);
}
private static void VerifyNodesAndPath(IReadOnlyList<IGraphNode> expectedNodes, IReadOnlyList<GraphNodePath> expectedPaths, TestVisitor visitor)
{
Assert.AreEqual(expectedNodes.Count, visitor.Result.Count);
Assert.AreEqual(expectedPaths.Count, visitor.Result.Count);
for (var i = 0; i < expectedNodes.Count; i++)
{
Assert.AreEqual(expectedNodes[i], visitor.Result[i].Item1);
Assert.AreEqual(expectedPaths[i], visitor.Result[i].Item2);
}
}
public void VisitTest()
{
TestVisitor visitor = new TestVisitor();
_testCommand.Visit(visitor);
Assert.IsInstanceOf(typeof(EmptyCommand), visitor.VisitedCommand);
}
public void TestCircularReference()
{
var nodeContainer = new NodeContainer();
var obj1 = new SimpleClass { Member1 = 3 };
var obj2 = new SimpleClass { Member1 = 3 };
obj1.Member2 = obj2;
obj2.Member2 = obj1;
var rootNode1 = nodeContainer.GetOrCreateNode(obj1);
var rootNode2 = nodeContainer.GetOrCreateNode(obj2);
var visitor = new TestVisitor();
visitor.Visit(rootNode1);
var expectedNodes = new[]
{
rootNode1,
rootNode1.TryGetChild(nameof(SimpleClass.Member1)),
rootNode1.TryGetChild(nameof(SimpleClass.Member2)),
rootNode2,
rootNode2.TryGetChild(nameof(SimpleClass.Member1)),
rootNode2.TryGetChild(nameof(SimpleClass.Member2)),
};
var expectedPaths = new[]
{
new GraphNodePath(rootNode1),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode1).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
visitor.Visit(rootNode2);
expectedNodes = new[]
{
rootNode2,
rootNode2.TryGetChild(nameof(SimpleClass.Member1)),
rootNode2.TryGetChild(nameof(SimpleClass.Member2)),
rootNode1,
rootNode1.TryGetChild(nameof(SimpleClass.Member1)),
rootNode1.TryGetChild(nameof(SimpleClass.Member2)),
};
expectedPaths = new[]
{
new GraphNodePath(rootNode2),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(rootNode2).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
