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

Bunch of renames and class re-organization

Browse Source 
--HG--
branch : dev
rename : src/Orchard.Tests.Modules/SimpleScriptingTests/ExpressionEvaluatorTests.cs => src/Orchard.Tests.Modules/SimpleScripting/EvaluatorTests.cs
rename : src/Orchard.Tests.Modules/SimpleScriptingTests/ExpressionParserTests.cs => src/Orchard.Tests.Modules/SimpleScripting/ParserTests.cs
rename : src/Orchard.Tests.Modules/SimpleScriptingTests/SimpleScriptingTests.cs => src/Orchard.Tests.Modules/SimpleScripting/SimpleScriptingTests.cs
rename : src/Orchard.Tests.Modules/SimpleScriptingTests/ExpressionTokenizerTests.cs => src/Orchard.Tests.Modules/SimpleScripting/TokenizerTests.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/TokenKind.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/AbstractSyntaxTree.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/TokenKind.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/IAstNodeWithToken.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ExpressionLexer.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Lexer.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ExpressionParser.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Parser.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/TokenKind.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/TerminalKind.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ExpressionTokenizer.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Tokenizer.cs
This commit is contained in:
Renaud Paquay
2010-11-27 17:49:12 -08:00
parent 93835cba2a
commit 19504f2d40
19 changed files with 758 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/Orchard.Tests.Modules/Orchard.Tests.Modules.csproj
View File

@@ -135,10 +135,10 @@
</ItemGroup>
<ItemGroup>
<Compile Include="CodeGeneration\Commands\CodeGenerationCommandsTests.cs" />
<Compile Include="SimpleScriptingTests\ExpressionEvaluatorTests.cs" />
<Compile Include="SimpleScriptingTests\ExpressionParserTests.cs" />
<Compile Include="SimpleScriptingTests\ExpressionTokenizerTests.cs" />
<Compile Include="SimpleScriptingTests\SimpleScriptingTests.cs" />
<Compile Include="SimpleScripting\EvaluatorTests.cs" />
<Compile Include="SimpleScripting\ParserTests.cs" />
<Compile Include="SimpleScripting\TokenizerTests.cs" />
<Compile Include="SimpleScripting\SimpleScriptingTests.cs" />
<Compile Include="DatabaseEnabledTestsBase.cs" />
<Compile Include="Media\Extensions\LongExtensionsTests.cs" />
<EmbeddedResource Include="Packaging\HelloDriver.cs.txt" />

13
src/Orchard.Tests.Modules/SimpleScripting/EvaluatorTests.cs Normal file
View File

@@ -0,0 +1,13 @@
using NUnit.Framework;
using Orchard.Widgets.SimpleScripting;
namespace Orchard.Tests.Modules.SimpleScriptingTests {
[TestFixture]
public class EvaluatorTests {
[Test]
public void EvaluateSimpleConstant() {
var tree = new Parser("1*2+3").Parse();
}
}
}

78
src/Orchard.Tests.Modules/SimpleScriptingTests/ExpressionParserTests.cs → src/Orchard.Tests.Modules/SimpleScripting/ParserTests.cs
View File

@@ -5,10 +5,10 @@ using Orchard.Widgets.SimpleScripting;
namespace Orchard.Tests.Modules.SimpleScriptingTests {
[TestFixture]
public class ExpressionParserTests {
public class ParserTests {
[Test]
public void ParserShouldUnderstandConstantExpressions() {
var tree = new ExpressionParser("true").Parse();
var tree = new Parser("true").Parse();
CheckTree(tree, new object[] {
"const", true,
});
@@ -16,9 +16,9 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void ParserShouldUnderstandBinaryExpressions() {
var tree = new ExpressionParser("true+true").Parse();
var tree = new Parser("true+true").Parse();
CheckTree(tree, new object[] {
"binop", TokenKind.Plus,
"binop", TerminalKind.Plus,
"const", true,
"const", true,
});
@@ -26,11 +26,11 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void ParserShouldUnderstandOperatorPrecedence() {
var tree = new ExpressionParser("1+2*3").Parse();
var tree = new Parser("1+2*3").Parse();
CheckTree(tree, new object[] {
"binop", TokenKind.Plus,
"binop", TerminalKind.Plus,
"const", 1,
"binop", TokenKind.Mul,
"binop", TerminalKind.Mul,
"const", 2,
"const", 3,
});
@@ -38,10 +38,10 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void ParserShouldUnderstandOperatorPrecedence2() {
var tree = new ExpressionParser("1*2+3").Parse();
var tree = new Parser("1*2+3").Parse();
CheckTree(tree, new object[] {
"binop", TokenKind.Plus,
"binop", TokenKind.Mul,
"binop", TerminalKind.Plus,
"binop", TerminalKind.Mul,
"const", 1,
"const", 2,
"const", 3,
@@ -50,10 +50,10 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void ParserShouldUnderstandOperatorPrecedence3() {
var tree = new ExpressionParser("not true or true").Parse();
var tree = new Parser("not true or true").Parse();
CheckTree(tree, new object[] {
"binop", TokenKind.Or,
"unop", TokenKind.Not,
"binop", TerminalKind.Or,
"unop", TerminalKind.Not,
"const", true,
"const", true,
});
@@ -61,10 +61,10 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void ParserShouldUnderstandOperatorPrecedence4() {
var tree = new ExpressionParser("not (true or true)").Parse();
var tree = new Parser("not (true or true)").Parse();
CheckTree(tree, new object[] {
"unop", TokenKind.Not,
"binop", TokenKind.Or,
"unop", TerminalKind.Not,
"binop", TerminalKind.Or,
"const", true,
"const", true,
});
@@ -72,11 +72,11 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void ParserShouldUnderstandParenthesis() {
var tree = new ExpressionParser("1*(2+3)").Parse();
var tree = new Parser("1*(2+3)").Parse();
CheckTree(tree, new object[] {
"binop", TokenKind.Mul,
"binop", TerminalKind.Mul,
"const", 1,
"binop", TokenKind.Plus,
"binop", TerminalKind.Plus,
"const", 2,
"const", 3,
});
@@ -84,15 +84,15 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void ParserShouldUnderstandComplexExpressions() {
var tree = new ExpressionParser("not 1 * (2 / 4 * 6 + (3))").Parse();
var tree = new Parser("not 1 * (2 / 4 * 6 + (3))").Parse();
CheckTree(tree, new object[] {
"unop", TokenKind.Not,
"binop", TokenKind.Mul,
"unop", TerminalKind.Not,
"binop", TerminalKind.Mul,
"const", 1,
"binop", TokenKind.Plus,
"binop", TokenKind.Div,
"binop", TerminalKind.Plus,
"binop", TerminalKind.Div,
"const", 2,
"binop", TokenKind.Mul,
"binop", TerminalKind.Mul,
"const", 4,
"const", 6,
"const", 3,
@@ -101,15 +101,15 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void ParserShouldContainErrorExpressions() {
var tree = new ExpressionParser("1 + not 3").Parse();
var tree = new Parser("1 + not 3").Parse();
CheckTree(tree, new object[] {
"binop", TokenKind.Plus,
"binop", TerminalKind.Plus,
"const", 1,
"error",
});
}
private void CheckTree(ExpressionTree tree, object[] objects) {
private void CheckTree(AbstractSyntaxTree tree, object[] objects) {
Assert.That(tree, Is.Not.Null);
Assert.That(tree.Root, Is.Not.Null);
@@ -118,39 +118,39 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
Assert.That(index, Is.EqualTo(objects.Length));
}
private void CheckExpression(ExpressionTree.Expression expression, int indent, object[] objects, ref int index) {
private void CheckExpression(AstNode astNode, int indent, object[] objects, ref int index) {
var exprName = (string)objects[index++];
Type type = null;
switch(exprName) {
case "const":
type = typeof(ExpressionTree.ConstantExpression);
type = typeof(ConstantAstNode);
break;
case "binop":
type = typeof(ExpressionTree.BinaryExpression);
type = typeof(BinaryAstNode);
break;
case "unop":
type = typeof(ExpressionTree.UnaryExpression);
type = typeof(UnaryAstNode);
break;
case "error":
type = typeof(ExpressionTree.ErrorExpression);
type = typeof(ErrorAstNode);
break;
}
Trace.WriteLine(string.Format("{0}: {1}{2} (Current: {3})", indent, new string(' ', indent * 2), type.Name, expression));
Trace.WriteLine(string.Format("{0}: {1}{2} (Current: {3})", indent, new string(' ', indent * 2), type.Name, astNode));
Assert.That(expression.GetType(), Is.EqualTo(type));
Assert.That(astNode.GetType(), Is.EqualTo(type));
if (exprName == "const") {
Assert.That((expression as ExpressionTree.ConstantExpression).Value, Is.EqualTo(objects[index++]));
Assert.That((astNode as ConstantAstNode).Value, Is.EqualTo(objects[index++]));
}
else if (exprName == "binop") {
Assert.That((expression as ExpressionTree.BinaryExpression).Operator.Kind, Is.EqualTo(objects[index++]));
Assert.That((astNode as BinaryAstNode).Operator.Kind, Is.EqualTo(objects[index++]));
}
else if (exprName == "unop") {
Assert.That((expression as ExpressionTree.UnaryExpression).Operator.Kind, Is.EqualTo(objects[index++]));
Assert.That((astNode as UnaryAstNode).Operator.Kind, Is.EqualTo(objects[index++]));
}
foreach(var child in expression.Children) {
foreach(var child in astNode.Children) {
CheckExpression(child, indent + 1, objects, ref index);
}
}

16
src/Orchard.Tests.Modules/SimpleScripting/SimpleScriptingTests.cs Normal file
View File

@@ -0,0 +1,16 @@
using System.Linq;
using NUnit.Framework;
using Orchard.Tests.Stubs;
using Orchard.Widgets.Services;
using Orchard.Widgets.SimpleScripting;
namespace Orchard.Tests.Modules.SimpleScripting {
[TestFixture]
public class SimpleScriptingTests {
[Test]
public void EngineUnderstandsPrimitiveValues() {
//var engine = new ScriptingEngine(Enumerable.Empty<IRuleProvider>(), new StubCacheManager());
//Assert.That(engine.Matches("true"), Is.True);
}
}
}

76
src/Orchard.Tests.Modules/SimpleScripting/TokenizerTests.cs Normal file
View File

@@ -0,0 +1,76 @@
using NUnit.Framework;
using Orchard.Widgets.SimpleScripting;
namespace Orchard.Tests.Modules.SimpleScriptingTests {
[TestFixture]
public class TokenizerTests {
[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);
}
[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);
}
private void TestStringLiteral(string value, string expected, TerminalKind expectedTerminalKind) {
var lexer = new Tokenizer(value);
var token1 = lexer.NextToken();
Assert.That(token1.Kind, Is.EqualTo(expectedTerminalKind));
Assert.That(token1.Value, Is.EqualTo(expected));
var token2 = lexer.NextToken();
Assert.That(token2.Kind, Is.EqualTo(TerminalKind.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);
}
private void TestReservedWord(string expression, object value, TerminalKind expectedTerminalKind) {
var lexer = new Tokenizer(expression);
var token1 = lexer.NextToken();
Assert.That(token1.Kind, Is.EqualTo(expectedTerminalKind));
Assert.That(token1.Value, Is.EqualTo(value));
var token2 = lexer.NextToken();
Assert.That(token2.Kind, Is.EqualTo(TerminalKind.Eof));
}
[Test]
public void LexerShouldProcesSequenceOfTokens() {
CheckTokenSequence("true false", TerminalKind.True, TerminalKind.False);
CheckTokenSequence("true toto false", TerminalKind.True, TerminalKind.Identifier, TerminalKind.False);
}
[Test]
public void LexerShouldProcesSequenceOfTokens2() {
CheckTokenSequence("1+2*3", TerminalKind.Integer, TerminalKind.Plus, TerminalKind.Integer, TerminalKind.Mul, TerminalKind.Integer);
}
private void CheckTokenSequence(string expression, params TerminalKind[] terminalKinds) {
var lexer = new Tokenizer(expression);
foreach (var kind in terminalKinds) {
var token = lexer.NextToken();
Assert.That(token.Kind, Is.EqualTo(kind));
}
var token2 = lexer.NextToken();
Assert.That(token2.Kind, Is.EqualTo(TerminalKind.Eof));
}
}
}