public void TestMachineDeferEventDeclarationWithExtraComma() { var test = @" namespace Foo { machine M { group G { start state S { defer e1,e2,; } } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected event identifier.", parser.GetParsingErrorLog()); }
public void TestUnexpectedTokenWithoutNamespace() { var test = "private"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Unexpected token.", parser.GetParsingErrorLog()); }
public void TestNamespaceDeclarationWithoutIdentifier() { var test = "namespace { }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected namespace identifier.", parser.GetParsingErrorLog()); }
public void TestIncorrectUsingDeclaration() { var test = "using System.Text"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected \";\".", parser.GetParsingErrorLog()); }
public void TestEventDeclarationWithoutNamespace() { var test = "event e;"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Must be declared inside a namespace.", parser.GetParsingErrorLog()); }
public void TestUsingDeclarationWithoutIdentifier() { var test = "using;"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected identifier.", parser.GetParsingErrorLog()); }
public void TestUnexpectedTokenWithoutNamespace() { var test = "private"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Unexpected token.", parser.GetParsingErrorLog()); }
public void TestPrivateEventDeclaration() { var test = @" namespace Foo { private event e; }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual(parser.GetParsingErrorLog(), "Event and machine declarations must be internal or public."); }
public void TestMachineDeclarationWithoutState() { var test = @" namespace Foo { machine M { } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("A machine must declare at least one state.", parser.GetParsingErrorLog()); }
public void TestInternalFieldDeclaration() { var test = @" namespace Foo { machine M { internal int k; start state S { } } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("A field or method cannot be internal.", parser.GetParsingErrorLog()); }
public void TestIntFieldDeclarationWithoutSemicolon() { var test = @" namespace Foo { machine M { int k start state S { } } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected \"(\" or \";\".", parser.GetParsingErrorLog()); }
public void TestEventDeclarationWithGenericError2() { var test = @" namespace Foo { event e<; }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Invalid generic expression.", parser.GetParsingErrorLog()); }
public void TestEntryDeclarationWithUnexpectedIdentifier() { var test = @" namespace Foo { machine M { start state S { entry Bar {} } } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected \"{\".", parser.GetParsingErrorLog()); }
public void TestMachineDeclarationWithTwoBodies() { var test = @" namespace Foo { machine M { start state S { } } { } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Unexpected token.", parser.GetParsingErrorLog()); }
public void TestMachineDeclarationWithMoreThanOneStartState() { var test = @" namespace Foo { machine M { start state S1 {} start state S2 { } start state S3 { } } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("A machine can declare only a single start state.", parser.GetParsingErrorLog()); }
public void TestMachineColdGroup() { var test = @" namespace Foo { machine M { cold group G { } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("A state group cannot be cold.", parser.GetParsingErrorLog()); }
public void TestDeferEventDeclarationWithoutComma() { var test = @" namespace Foo { machine M { start state S { defer e1 e2; } } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected \",\".", parser.GetParsingErrorLog()); }
public void TestStateDeclarationWithMoreThanOneExit() { var test = @" namespace Foo { machine M { start state S { exit{} exit {} } } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Duplicate exit declaration.", parser.GetParsingErrorLog()); }
public void TestMachineDeclarationWithoutStartState() { var test = @" namespace Foo { machine M { state S { } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("A machine must declare a start state.", parser.GetParsingErrorLog()); }
public void TestMonitorStateDeclarationWithMoreThanOneEntry() { var test = @" namespace Foo { monitor M { group G { start state S { entry {} entry{} } } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Duplicate entry declaration.", parser.GetParsingErrorLog()); }
public void TestMonitorOnEventGotoStateDeclarationWithoutState() { var test = @" namespace Foo { monitor M { group G { start state S1 { on e goto; } } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected state identifier.", parser.GetParsingErrorLog()); }
public void TestMonitorMethodInsideGroup() { var test = @" namespace Foo { monitor M { group G { void Bar() { } } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Unexpected token 'void'.", parser.GetParsingErrorLog()); }
public void TestMonitorEmptyNestedGroup() { var test = @" namespace Foo { monitor M { group G { group G2 { } } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("A state group must declare at least one state.", parser.GetParsingErrorLog()); }
public void TestProtectedEventDeclaration() { var test = @" namespace Foo { protected event e; }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Event and machine declarations must be internal or public.", parser.GetParsingErrorLog()); }
public void TestMachineOnEventDoActionDeclarationWithoutSemicolon() { var test = @" namespace Foo { machine M { start state S1 { on e do Bar } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected \";\".", parser.GetParsingErrorLog()); }
public void TestEventDeclarationWithoutNamespace() { var test = "event e;"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Must be declared inside a namespace.", parser.GetParsingErrorLog()); }
public void TestOnEventDoActionDeclarationWithoutAction() { var test = @" namespace Foo { machine M { start state S1 { on e do; } } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected action identifier.", parser.GetParsingErrorLog()); }
public void TestOnEventDeclarationWithoutHandler() { var test = @" namespace Foo { machine M { start state S1 { on e; } } }"; var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), false); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Expected \"do\", \"goto\" or \"push\".", parser.GetParsingErrorLog()); }
public void TestPublicFieldDeclaration() { var test = @" namespace Foo { machine M { public int k; start state S { } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("A field or method cannot be public.", parser.GetParsingErrorLog()); }
public void TestGenericDefaultEvent() { var test = @" namespace Foo { machine M { start state S { on default<int> goto S2; } } }"; ParsingOptions options = ParsingOptions.CreateDefault() .DisableThrowParsingException(); var parser = new PSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), options); var tokens = new PSharpLexer().Tokenize(test); var program = parser.ParseTokens(tokens); Assert.AreEqual("Invalid generic expression.", parser.GetParsingErrorLog()); }