def testMethodWith(self):
statement = "print(\"a\", value = \"1\");"
stmt = self.parse(statement, OParser.statement)
self.assertIsNotNone(stmt)
writer = CodeWriter(Dialect.O, Context.newGlobalContext())
stmt.toDialect(writer)
self.assertEquals(statement, str(writer) + ";")
def testMethodWith(self):
statement = "print \"a\" with \"1\" as value"
stmt = self.parse(statement, ECleverParser.statement)
self.assertIsNotNone(stmt)
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
stmt.toDialect(writer)
self.assertEquals(statement, str(writer))
def testSimpleDictLiteral(self):
statement = "< \"john\" : 1234, eric : 5678 >"
literal = self.parse(statement, OParser.literal_expression)
self.assertIsNotNone(literal)
self.assertIsInstance(literal, DictLiteral)
writer = CodeWriter(Dialect.O, Context.newGlobalContext())
literal.toDialect(writer)
self.assertEquals('<"john":1234, eric:5678>', str(writer))
def testNativeSymbol(self):
statement = 'ENTITY_1 = "1";'
symbol = self.parse(statement, OParser.native_symbol)
self.assertIsNotNone(symbol)
self.assertIsInstance(symbol, NativeSymbol)
writer = CodeWriter(Dialect.O, Context.newGlobalContext())
symbol.toDialect(writer)
self.assertEquals(statement, str(writer) + ";")
def testNativeSymbol(self):
statement = "ENTITY_1 with \"1\" as value"
symbol = self.parse(statement, ECleverParser.native_symbol)
self.assertIsNotNone(symbol)
self.assertIsInstance(symbol, NativeSymbol)
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
symbol.toDialect(writer)
self.assertEquals(statement, str(writer))
def testRange(self):
statement = "[1..100]"
rl = self.parse(statement, OParser.range_literal)
self.assertIsNotNone(rl)
self.assertEquals("1", str(rl.getFirst()))
self.assertEquals("100", str(rl.getLast()))
writer = CodeWriter(Dialect.O, Context.newGlobalContext())
rl.toDialect(writer)
self.assertEquals(statement, str(writer))
def testComplexArgumentAssignment(self):
statement = "\"person\" + p.name as value"
as_ = self.parse(statement,ECleverParser.argument_assignment)
self.assertEquals("value",as_.getName())
exp = as_.getExpression()
self.assertIsInstance(exp, PlusExpression)
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
as_.toDialect(writer)
self.assertEquals(statement, str(writer))
def testCanParseAndTranslateMultilineElements(self):
jsx = "return <a>\n\t<b/>\n\t<b/>\n</a>"
parser = ECleverParser(text=jsx)
stmt = parser.doParse(parser.return_statement, True)
self.assertIsNotNone(stmt.expression)
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
stmt.toDialect(writer)
out = str(writer)
self.assertEqual(jsx, out)
def testSimpleArgumentAssignment(self):
statement = "p.name as value"
as_ = self.parse(statement,ECleverParser.argument_assignment)
self.assertEquals("value",as_.getName())
exp = as_.getExpression()
self.assertIsNotNone(exp)
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
as_.toDialect(writer)
self.assertEquals("p.name as value",str(writer))
def testCanParseAndTranslateMultilineAttributes(self):
jsx = "return <a \n\tx=\"abc\"\n\ty=\"def\"\n\tz=\"stuff\" />"
parser = ECleverParser(text=jsx)
stmt = parser.doParse(parser.return_statement, True)
self.assertIsNotNone(stmt.expression)
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
stmt.toDialect(writer)
out = str(writer)
self.assertEqual(jsx, out)
def testArgumentAssignmentList1Arg(self):
statement = "with \"person\" + p.name as value"
ls = self.parse(statement, ECleverParser.argument_assignment_list)
as_ = ls[0]
self.assertEqual("value", as_.getName())
exp = as_.getExpression()
self.assertIsInstance(exp, PlusExpression)
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
as_.toDialect(writer)
self.assertEqual("\"person\" + p.name as value", str(writer))
def testMethod1Extended1Statement(self):
statement = "method printName ( Object(name) o ) { print ( value = \"object\" + o.name ); }"
ad = self.parse(statement, OParser.concrete_method_declaration)
self.assertIsNotNone(ad)
self.assertEquals("printName", ad.getName())
self.assertIsNotNone(ad.parameters)
expected = ExtendedParameter(CategoryType("Object"), "o", IdentifierList("name"))
self.assertTrue(expected in ad.parameters)
self.assertIsNotNone(ad.getStatements())
writer = CodeWriter(Dialect.O, Context.newGlobalContext())
ad.getStatements()[0].toDialect(writer)
self.assertEquals("print(value = \"object\" + o.name)", str(writer))
def testMethod1Array1Statement(self):
statement = "method printName ( Option[] options ) { print ( value = \"array\" + options ); }"
ad = self.parse(statement, OParser.concrete_method_declaration)
self.assertIsNotNone(ad)
self.assertEquals("printName", ad.getName())
self.assertIsNotNone(ad.parameters)
expected = CategoryParameter(ListType(CategoryType("Option")), "options")
self.assertTrue(expected in ad.parameters)
self.assertIsNotNone(ad.getStatements())
writer = CodeWriter(Dialect.O, Context.newGlobalContext())
ad.getStatements()[0].toDialect(writer)
self.assertEquals("print(value = \"array\" + options)", str(writer))
def testMethod1Parameter1Statement(self):
statement = "method printName ( Person p ) { print ( value = \"person\" + p.name); }"
ad = self.parse(statement, OParser.concrete_method_declaration)
self.assertIsNotNone(ad)
self.assertEquals("printName", ad.getName())
self.assertIsNotNone(ad.parameters)
expected = CategoryParameter(CategoryType("Person"), "p")
self.assertTrue(expected in ad.parameters)
self.assertIsNotNone(ad.getStatements())
writer = CodeWriter(Dialect.O, Context.newGlobalContext())
ad.getStatements()[0].toDialect(writer)
self.assertEquals("print(value = \"person\" + p.name)", str(writer))
def testMethod1Array1Statement(self):
statement = "define printName as method receiving Option[] options doing:\r\n" \
+ "\tprint with \"array\" + args as value"
ad = self.parse(statement,ECleverParser.concrete_method_declaration)
self.assertIsNotNone(ad)
self.assertEquals("printName",ad.getName())
self.assertIsNotNone(ad.parameters)
expected = CategoryParameter(ListType(CategoryType("Option")), "options")
self.assertTrue(expected in ad.parameters)
self.assertIsNotNone(ad.getStatements())
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
ad.getStatements()[0].toDialect(writer)
self.assertEquals("print with \"array\" + args as value",str(writer))
def testMethodCallWith(self):
statement = "print with \"person\" + p.name as value"
mc = self.parse(statement,ECleverParser.method_call_statement)
self.assertIsNotNone(mc)
self.assertEquals("print",mc.caller.getName())
self.assertIsNotNone(mc.arguments)
arg = mc.arguments[0]
self.assertEquals("value",arg.getName())
exp = arg.getExpression()
self.assertIsInstance(exp, PlusExpression)
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
mc.toDialect(writer)
self.assertEquals("print with \"person\" + p.name as value",str(writer))
def testMethod1Extended1Statement(self):
statement = "define printName as method receiving Object o with attribute name doing:\r\n" \
+ "\tprint with \"object\" + o.name as value"
ad = self.parse(statement,ECleverParser.concrete_method_declaration)
self.assertIsNotNone(ad)
self.assertEquals("printName",ad.getName())
self.assertIsNotNone(ad.parameters)
expected = ExtendedParameter(CategoryType("Object"), "o", IdentifierList("name"))
self.assertTrue(expected in ad.parameters)
self.assertIsNotNone(ad.getStatements())
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
ad.getStatements()[0].toDialect(writer)
self.assertEquals("print with \"object\" + o.name as value",str(writer))
def testMethod1Parameter1Statement(self):
statement = "define printName as method receiving Person p doing:\r\n" \
+ "\tprint with \"person\" + p.name as value"
ad = self.parse(statement, ECleverParser.concrete_method_declaration)
self.assertIsNotNone(ad)
self.assertEqual("printName", ad.getName())
self.assertIsNotNone(ad.parameters)
expected = CategoryParameter(CategoryType("Person"), "p")
self.assertTrue(expected in ad.parameters)
self.assertIsNotNone(ad.getStatements())
writer = CodeWriter(Dialect.E, Context.newGlobalContext())
ad.getStatements()[0].toDialect(writer)
self.assertEqual("print with \"person\" + p.name as value",
str(writer))
def compareResourceEOE(self, resourceName):
expected = self.getResourceAsString(resourceName, 'r')
# print(expected)
# parse e source code
dle = self.parseEString(expected)
context = Context.newGlobalContext()
dle.register(context)
# rewrite as o
writer = CodeWriter(Dialect.O, context)
dle.toDialect(writer)
o = str(writer)
# print(o)
# parse o source code
dlo = self.parseOString(o)
context = Context.newGlobalContext()
dlo.register(context)
# rewrite as e
writer = CodeWriter(Dialect.E, context)
dlo.toDialect(writer)
actual = str(writer)
# print(actual)
# ensure equivalent
self.assertEquivalent(expected, actual)
def compareResourceEME(self, resourceName):
expected = self.getResourceAsString(resourceName, 'r')
# print(expected)
# parse e source code
dle = self.parseEString(expected)
context = Context.newGlobalContext()
dle.register(context)
# rewrite as p
writer = CodeWriter(Dialect.M, context)
dle.toDialect(writer)
p = unicode(writer)
# print(p)
# parse p source code
dlp = self.parseMString(p)
context = Context.newGlobalContext()
dlp.register(context)
# rewrite as e
writer = CodeWriter(Dialect.E, context)
dlp.toDialect(writer)
actual = unicode(writer)
# print(actual)
# ensure equivalent
self.assertEquivalent(expected, actual)
def compareResourceOMO(self, resourceName):
expected = self.getResourceAsString(resourceName, 'r')
# print(expected)
# parse o source code
dlo = self.parseOString(expected)
context = Context.newGlobalContext()
dlo.register(context)
# rewrite as p
writer = CodeWriter(Dialect.M, context)
dlo.toDialect(writer)
p = str(writer)
# print(p)
# parse p source code
dlp = self.parseMString(p)
context = Context.newGlobalContext()
dlp.register(context)
# rewrite as o
writer = CodeWriter(Dialect.O, context)
dlp.toDialect(writer)
actual = str(writer)
# print(actual)
# ensure equivalent
self.assertEquivalent(expected, actual)
def loadDependency(self, name):
if self.coreContext is None:
self.coreContext = Context.newGlobalContext()
allStmts = None
files = self.listLibraryFiles(name)
if files is not None:
for file in files:
resourceName = name + "/" + file
stmts = self.parseResource(resourceName)
if allStmts is None:
allStmts = stmts
else:
allStmts.extend(stmts)
allStmts.register(self.coreContext)
def testSystemOutPrint(self):
parser = ECleverParser(text='print(objects=value,end="")')
parser._input.tokenSource.addLF = False
tree = parser.python_statement()
builder = EPromptoBuilder(parser)
walker = ParseTreeWalker()
walker.walk(builder, tree)
statement = builder.getNodeValue(tree)
context = Context.newGlobalContext()
arg = CategoryParameter(TextType.instance, "value")
arg.register(context)
context.setValue("value", TextLiteral('"test"')) # StringLiteral trims enclosing quotes
result = statement.interpret(context, None, None) # no module
self.assertIsNone(result)
self.assertEqual("test", Out.read())
def test3Minuses(self):
exp = self.parseExpression("1-2-3-4")
context = Context.newGlobalContext()
value = exp.interpret(context)
self.assertEquals(-8, value.IntegerValue())
def test2Plus3Minuses(self):
exp = self.parseExpression("1+2-3+4-5-6")
context = Context.newGlobalContext()
value = exp.interpret(context)
self.assertEquals(-7, value.IntegerValue())
def test1Star1Plus(self):
exp = self.parseExpression("1*2+3")
context = Context.newGlobalContext()
value = exp.interpret(context)
self.assertEquals(5, value.IntegerValue())
def setUp(self):
self.context = Context.newGlobalContext()
def __str__(self):
return self.toString(Context.newGlobalContext())