lsm/Orchard
1
0
Fork 0
mirror of https://github.com/OrchardCMS/Orchard.git synced 2025-10-15 19:54:57 +08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

More renames and re-org

Browse Source 
--HG--
branch : dev
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/AbstractSyntaxTree.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/AbstractSyntaxTree.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/AstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/AstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/BinaryAstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/BinaryAstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ConstantAstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/ConstantAstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ErrorAstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/ErrorAstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/IAstNodeWithToken.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/IAstNodeWithToken.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/UnaryAstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/UnaryAstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Lexer.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Lexer.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Parser.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Parser.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Terminal.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Token.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/TerminalKind.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/TokenKind.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Tokenizer.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Tokenizer.cs
This commit is contained in:
Renaud Paquay
2010-11-27 17:56:32 -08:00
parent 847cf5fb66
commit 289ba2ff5e
20 changed files with 198 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/Orchard.Tests.Modules/SimpleScripting/EvaluatorTests.cs
View File

@@ -1,5 +1,6 @@
using NUnit.Framework;
using Orchard.Widgets.SimpleScripting;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Tests.Modules.SimpleScriptingTests {
[TestFixture]

36
src/Orchard.Tests.Modules/SimpleScripting/ParserTests.cs
View File

@@ -2,6 +2,8 @@
using System.Diagnostics;
using NUnit.Framework;
using Orchard.Widgets.SimpleScripting;
using Orchard.Widgets.SimpleScripting.Ast;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Tests.Modules.SimpleScriptingTests {
[TestFixture]
@@ -18,7 +20,7 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandBinaryExpressions() {
var tree = new Parser("true+true").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Plus,
"binop", TokenKind.Plus,
"const", true,
"const", true,
});
@@ -28,9 +30,9 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandOperatorPrecedence() {
var tree = new Parser("1+2*3").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Plus,
"binop", TokenKind.Plus,
"const", 1,
"binop", TerminalKind.Mul,
"binop", TokenKind.Mul,
"const", 2,
"const", 3,
});
@@ -40,8 +42,8 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandOperatorPrecedence2() {
var tree = new Parser("1*2+3").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Plus,
"binop", TerminalKind.Mul,
"binop", TokenKind.Plus,
"binop", TokenKind.Mul,
"const", 1,
"const", 2,
"const", 3,
@@ -52,8 +54,8 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandOperatorPrecedence3() {
var tree = new Parser("not true or true").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Or,
"unop", TerminalKind.Not,
"binop", TokenKind.Or,
"unop", TokenKind.Not,
"const", true,
"const", true,
});
@@ -63,8 +65,8 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandOperatorPrecedence4() {
var tree = new Parser("not (true or true)").Parse();
CheckTree(tree, new object[] {
"unop", TerminalKind.Not,
"binop", TerminalKind.Or,
"unop", TokenKind.Not,
"binop", TokenKind.Or,
"const", true,
"const", true,
});
@@ -74,9 +76,9 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandParenthesis() {
var tree = new Parser("1*(2+3)").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Mul,
"binop", TokenKind.Mul,
"const", 1,
"binop", TerminalKind.Plus,
"binop", TokenKind.Plus,
"const", 2,
"const", 3,
});
@@ -86,13 +88,13 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandComplexExpressions() {
var tree = new Parser("not 1 * (2 / 4 * 6 + (3))").Parse();
CheckTree(tree, new object[] {
"unop", TerminalKind.Not,
"binop", TerminalKind.Mul,
"unop", TokenKind.Not,
"binop", TokenKind.Mul,
"const", 1,
"binop", TerminalKind.Plus,
"binop", TerminalKind.Div,
"binop", TokenKind.Plus,
"binop", TokenKind.Div,
"const", 2,
"binop", TerminalKind.Mul,
"binop", TokenKind.Mul,
"const", 4,
"const", 6,
"const", 3,
@@ -103,7 +105,7 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldContainErrorExpressions() {
var tree = new Parser("1 + not 3").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Plus,
"binop", TokenKind.Plus,
"const", 1,
"error",
});

51
src/Orchard.Tests.Modules/SimpleScripting/TokenizerTests.cs
View File

@@ -1,5 +1,6 @@
using NUnit.Framework;
using Orchard.Widgets.SimpleScripting;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Tests.Modules.SimpleScriptingTests {
[TestFixture]
@@ -7,70 +8,70 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void LexerShouldProcessSingleQuotedStringLiteral() {
TestStringLiteral(@"'toto'", @"toto", TerminalKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\'to'", @"to'to", TerminalKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\\to'", @"to\to", TerminalKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\ato'", @"to\ato", TerminalKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'toto'", @"toto", TokenKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\'to'", @"to'to", TokenKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\\to'", @"to\to", TokenKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\ato'", @"to\ato", TokenKind.SingleQuotedStringLiteral);
}
[Test]
public void LexerShouldProcessStringLiteral() {
TestStringLiteral(@"""toto""", @"toto", TerminalKind.StringLiteral);
TestStringLiteral(@"""to\'to""", @"to'to", TerminalKind.StringLiteral);
TestStringLiteral(@"""to\\to""", @"to\to", TerminalKind.StringLiteral);
TestStringLiteral(@"""to\ato""", @"toato", TerminalKind.StringLiteral);
TestStringLiteral(@"""toto""", @"toto", TokenKind.StringLiteral);
TestStringLiteral(@"""to\'to""", @"to'to", TokenKind.StringLiteral);
TestStringLiteral(@"""to\\to""", @"to\to", TokenKind.StringLiteral);
TestStringLiteral(@"""to\ato""", @"toato", TokenKind.StringLiteral);
}
private void TestStringLiteral(string value, string expected, TerminalKind expectedTerminalKind) {
private void TestStringLiteral(string value, string expected, TokenKind expectedTokenKind) {
var lexer = new Tokenizer(value);
var token1 = lexer.NextToken();
Assert.That(token1.Kind, Is.EqualTo(expectedTerminalKind));
Assert.That(token1.Kind, Is.EqualTo(expectedTokenKind));
Assert.That(token1.Value, Is.EqualTo(expected));
var token2 = lexer.NextToken();
Assert.That(token2.Kind, Is.EqualTo(TerminalKind.Eof));
Assert.That(token2.Kind, Is.EqualTo(TokenKind.Eof));
}
[Test]
public void LexerShouldProcessReservedWords() {
TestReservedWord("true", true, TerminalKind.True);
TestReservedWord("false", false, TerminalKind.False);
TestReservedWord("not", null, TerminalKind.Not);
TestReservedWord("and", null, TerminalKind.And);
TestReservedWord("or", null, TerminalKind.Or);
TestReservedWord("true", true, TokenKind.True);
TestReservedWord("false", false, TokenKind.False);
TestReservedWord("not", null, TokenKind.Not);
TestReservedWord("and", null, TokenKind.And);
TestReservedWord("or", null, TokenKind.Or);
}
private void TestReservedWord(string expression, object value, TerminalKind expectedTerminalKind) {
private void TestReservedWord(string expression, object value, TokenKind expectedTokenKind) {
var lexer = new Tokenizer(expression);
var token1 = lexer.NextToken();
Assert.That(token1.Kind, Is.EqualTo(expectedTerminalKind));
Assert.That(token1.Kind, Is.EqualTo(expectedTokenKind));
Assert.That(token1.Value, Is.EqualTo(value));
var token2 = lexer.NextToken();
Assert.That(token2.Kind, Is.EqualTo(TerminalKind.Eof));
Assert.That(token2.Kind, Is.EqualTo(TokenKind.Eof));
}
[Test]
public void LexerShouldProcesSequenceOfTokens() {
CheckTokenSequence("true false", TerminalKind.True, TerminalKind.False);
CheckTokenSequence("true toto false", TerminalKind.True, TerminalKind.Identifier, TerminalKind.False);
CheckTokenSequence("true false", TokenKind.True, TokenKind.False);
CheckTokenSequence("true toto false", TokenKind.True, TokenKind.Identifier, TokenKind.False);
}
[Test]
public void LexerShouldProcesSequenceOfTokens2() {
CheckTokenSequence("1+2*3", TerminalKind.Integer, TerminalKind.Plus, TerminalKind.Integer, TerminalKind.Mul, TerminalKind.Integer);
CheckTokenSequence("1+2*3", TokenKind.Integer, TokenKind.Plus, TokenKind.Integer, TokenKind.Mul, TokenKind.Integer);
}
private void CheckTokenSequence(string expression, params TerminalKind[] terminalKinds) {
private void CheckTokenSequence(string expression, params TokenKind[] tokenKinds) {
var lexer = new Tokenizer(expression);
foreach (var kind in terminalKinds) {
foreach (var kind in tokenKinds) {
var token = lexer.NextToken();
Assert.That(token.Kind, Is.EqualTo(kind));
}
var token2 = lexer.NextToken();
Assert.That(token2.Kind, Is.EqualTo(TerminalKind.Eof));
Assert.That(token2.Kind, Is.EqualTo(TokenKind.Eof));
}
}
}