libacc/tests/test.py - platform/system/core - Gitiles

 #
 # Test the acc compiler

 import unittest
 import subprocess
 import os
 import sets

 gArmInitialized = False

 def compile(args):
     proc = subprocess.Popen(["acc"] + args, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
     result = proc.communicate()
     return result

 def runCmd(args):
     proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     result = proc.communicate()
     return result[0].strip()

 def which(item):
     return runCmd(["which", item])

 def fileType(item):
     return runCmd(["file", item])

 def outputCanRun():
     ft = fileType(which("acc"))
     return ft.find("ELF 32-bit LSB executable, Intel 80386") >= 0

 def adb(args):
     return runCmd(["adb"] + args)

 def setupArm():
     global gArmInitialized
     if gArmInitialized:
         return
     print "Setting up arm"
     adb(["remount"])
     adb(["shell", "rm", "/system/bin/acc"])
     adb(["shell", "mkdir", "/system/bin/accdata"])
     adb(["shell", "mkdir", "/system/bin/accdata/data"])
     # Clear out old data TODO: handle recursion
     adb(["shell", "rm", "/system/bin/accdata/data/*"])
     # Copy over data
     for root, dirs, files in os.walk("data"):
         for d in dirs:
             adb(["shell", "mkdir", os.path.join(root, d)])
         for f in files:
             adb(["push", os.path.join(root, f), os.path.join("/system/bin/accdata", root, f)])
     # Copy over compiler
     adb(["sync"])
     gArmInitialized = True

 def compileArm(args):
     setupArm()
     proc = subprocess.Popen(["adb", "shell", "/system/bin/acc"] + args, stdout=subprocess.PIPE)
     result = proc.communicate()
     return result[0].replace("\r","")

 def compare(a, b):
     if a != b:
         firstDiff = firstDifference(a, b)
         print "Strings differ at character %d. Common: %s. Difference '%s' != '%s'" % (
             firstDiff, a[0:firstDiff], safeAccess(a, firstDiff), safeAccess(b, firstDiff))

 def safeAccess(s, i):
     if 0 <= i < len(s):
         return s[i]
     else:
         return '?'

 def firstDifference(a, b):
     commonLen = min(len(a), len(b))
     for i in xrange(0, commonLen):
         if a[i] != b[i]:
             return i
     return commonLen

 # a1 and a2 are the expected stdout and stderr.
 # b1 and b2 are the actual stdout and stderr.
 # Compare the two, sets. Allow any individual line
 # to appear in either stdout or stderr. This is because
 # the way we obtain output on the ARM combines both
 # streams into one sequence.

 def compareOuput(a1,a2,b1,b2):
     while True:
         totalLen = len(a1) + len(a2) + len(b1) + len(b2)
         a1, b1 = matchCommon(a1, b1)
         a1, b2 = matchCommon(a1, b2)
         a2, b1 = matchCommon(a2, b1)
         a2, b2 = matchCommon(a2, b2)
         newTotalLen = len(a1) + len(a2) + len(b1) + len(b2)
         if newTotalLen == 0:
             return True
         if newTotalLen == totalLen:
             print "Failed at %d %d %d %d" % (len(a1), len(a2), len(b1), len(b2))
             print "a1", a1
             print "a2", a2
             print "b1", b1
             print "b2", b2
             return False

 def matchCommon(a, b):
     """Remove common items from the beginning of a and b,
        return just the tails that are different."""
     while len(a) > 0 and len(b) > 0 and a[0] == b[0]:
         a = a[1:]
         b = b[1:]
     return a, b

 def rewritePaths(args):
     return [rewritePath(x) for x in args]

 def rewritePath(p):
     """Take a path that's correct on the x86 and convert to a path
        that's correct on ARM."""
     if p.startswith("data/"):
         p = "/system/bin/accdata/" + p
     return p

 class TestACC(unittest.TestCase):

     def checkResult(self, out, err, stdErrResult, stdOutResult=""):
         a1 = out.splitlines()
         a2 = err.splitlines()
         b2 = stdErrResult.splitlines()
         b1 = stdOutResult.splitlines()
         self.assertEqual(True, compareOuput(a1,a2,b1,b2))

     def compileCheck(self, args, stdErrResult, stdOutResult="",
                      targets=['arm', 'x86']):
         targetSet = sets.ImmutableSet(targets)
         if False and 'x86' in targetSet:
             out, err = compile(args)
             self.checkResult(out, err, stdErrResult, stdOutResult)
         if 'arm' in targetSet:
             out = compileArm(rewritePaths(args))
             self.checkResult(out, "", stdErrResult, stdOutResult)

     def compileCheckArm(self, args, result):
         self.assertEqual(compileArm(args), result)

     def testCompileReturnVal(self):
         self.compileCheck(["data/returnval-ansi.c"], "")

     def testCompileOTCCANSII(self):
         self.compileCheck(["data/otcc-ansi.c"], "", "", ['x86'])

     def testRunReturnVal(self):
         self.compileCheck(["-R", "data/returnval-ansi.c"],
         "Executing compiled code:\nresult: 42\n")

     def testStringLiteralConcatenation(self):
         self.compileCheck(["-R", "data/testStringConcat.c"],
         "Executing compiled code:\nresult: 13\n", "Hello, world\n")

     def testRunOTCCANSI(self):
         self.compileCheck(["-R", "data/otcc-ansi.c", "data/returnval.c"],
             "Executing compiled code:\notcc-ansi.c: About to execute compiled code:\natcc-ansi.c: result: 42\nresult: 42\n", "",
              ['x86'])

     def testRunOTCCANSI2(self):
         self.compileCheck(["-R", "data/otcc-ansi.c", "data/otcc.c", "data/returnval.c"],
             "Executing compiled code:\notcc-ansi.c: About to execute compiled code:\notcc.c: about to execute compiled code.\natcc-ansi.c: result: 42\nresult: 42\n", "",['x86'])

     def testRunConstants(self):
         self.compileCheck(["-R", "data/constants.c"],
             "Executing compiled code:\nresult: 12\n",
             "0 = 0\n010 = 8\n0x10 = 16\n'\\a' = 7\n'\\b' = 8\n'\\f' = 12\n'\\n' = 10\n'\\r' = 13\n'\\t' = 9\n'\\v' = 11\n'\\\\' = 92\n'\\'' = 39\n" +
             "'\\\"' = 34\n'\\?' = 63\n'\\0' = 0\n'\\1' = 1\n'\\12' = 10\n'\\123' = 83\n'\\x0' = 0\n'\\x1' = 1\n'\\x12' = 18\n'\\x123' = 291\n'\\x1f' = 31\n'\\x1F' = 31\n")

     def testRunFloat(self):
         self.compileCheck(["-R", "data/float.c"],
             "Executing compiled code:\nresult: 0\n",
             """Constants: 0 0 0 0.01 0.01 0.1 10 10 0.1
 int: 1 float: 2.2 double: 3.3
  ftoi(1.4f)=1
  dtoi(2.4)=2
  itof(3)=3
  itod(4)=4
 globals: 1 2 3 4
 args: 1 2 3 4
 locals: 1 2 3 4
 cast rval: 2 4
 cast lval: 1.1 2 3.3 4
 """)

     def testRunFlops(self):
         self.compileCheck(["-R", "data/flops.c"],
             """Executing compiled code:
 result: 0""",
 """-1.1 = -1.1
 !1.2 = 0
 !0 = 1
 double op double:
 1 + 2 = 3
 1 - 2 = -1
 1 * 2 = 2
 1 / 2 = 0.5
 float op float:
 1 + 2 = 3
 1 - 2 = -1
 1 * 2 = 2
 1 / 2 = 0.5
 double op float:
 1 + 2 = 3
 1 - 2 = -1
 1 * 2 = 2
 1 / 2 = 0.5
 double op int:
 1 + 2 = 3
 1 - 2 = -1
 1 * 2 = 2
 1 / 2 = 0.5
 int op double:
 1 + 2 = 3
 1 - 2 = -1
 1 * 2 = 2
 1 / 2 = 0.5
 double op double:
 1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
 1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
 2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
 double op float:
 1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
 1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
 2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
 float op float:
 1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
 1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
 2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
 int op double:
 1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
 1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
 2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
 double op int:
 1 op 2: < 1   <= 1   == 0   >= 0   > 0   != 1
 1 op 1: < 0   <= 1   == 1   >= 1   > 0   != 0
 2 op 1: < 0   <= 0   == 0   >= 1   > 1   != 1
 branching: 1 0 1
 testpassi: 1 2 3 4 5 6 7 8 9 10 11 12
 testpassf: 1 2 3 4 5 6 7 8 9 10 11 12
 testpassd: 1 2 3 4 5 6 7 8 9 10 11 12
 testpassi: 1 2 3 4 5 6 7 8 9 10 11 12
 testpassf: 1 2 3 4 5 6 7 8 9 10 11 12
 testpassd: 1 2 3 4 5 6 7 8 9 10 11 12
 testpassi: 1 2 3 4 5 6 7 8 9 10 11 12
 testpassf: 1 2 3 4 5 6 7 8 9 10 11 12
 testpassd: 1 2 3 4 5 6 7 8 9 10 11 12
 testpassidf: 1 2 3
 """)
     def testCasts(self):
         self.compileCheck(["-R", "data/casts.c"],
             """Executing compiled code:
 result: 0""", """Reading from a pointer: 3 3
 Writing to a pointer: 4
 Testing casts: 3 3 4.5 4
 Testing reading (int*): 4
 Testing writing (int*): 8 9
 Testing reading (char*): 0x78 0x56 0x34 0x12
 Testing writing (char*): 0x87654321
 f(10)
 Function pointer result: 70
 Testing read/write (float*): 8.8 9.9
 Testing read/write (double*): 8.8 9.9
 """)

     def testChar(self):
         self.compileCheck(["-R", "data/char.c"], """Executing compiled code:
 result: 0""", """a = 99, b = 41
 ga = 100, gb = 44""")

     def testPointerArithmetic(self):
         self.compileCheck(["-R", "data/pointers.c"], """Executing compiled code:
 result: 0""", """Pointer difference: 1 4
 Pointer addition: 2
 Pointer comparison to zero: 0 0 1
 Pointer comparison: 1 0 0 0 1
 """)
     def testRollo3(self):
         self.compileCheck(["-R", "data/rollo3.c"], """Executing compiled code:
 result: 10""", """""")

     def testFloatDouble(self):
         self.compileCheck(["-R", "data/floatdouble.c"], """Executing compiled code:
 result: 0""", """0.002 0.1 10""")

     def testIncDec(self):
         self.compileCheck(["-R", "data/inc.c"], """Executing compiled code:
 0
 1
 2
 1
 result: 0
 ""","""""")

     def testIops(self):
         self.compileCheck(["-R", "data/iops.c"], """Executing compiled code:
 result: 0""", """Literals: 1 -1
 ++
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 --
 10
 9
 8
 7
 6
 5
 4
 3
 2
 1
 0
 """)

     def testFilm    (self):
         self.compileCheck(["-R", "data/film.c"], """Executing compiled code:
 result: 0""", """testing...
 Total bad: 0
 """)
 if __name__ == '__main__':
     if not outputCanRun():
         print "Many tests are expected to fail, because acc is not a 32-bit x86 Linux executable."
     unittest.main()
	#
	# Test the acc compiler

	import unittest
	import subprocess
	import os
	import sets

	gArmInitialized = False

	def compile(args):
	proc = subprocess.Popen(["acc"] + args, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
	result = proc.communicate()
	return result

	def runCmd(args):
	proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
	result = proc.communicate()
	return result[0].strip()

	def which(item):
	return runCmd(["which", item])

	def fileType(item):
	return runCmd(["file", item])

	def outputCanRun():
	ft = fileType(which("acc"))
	return ft.find("ELF 32-bit LSB executable, Intel 80386") >= 0

	def adb(args):
	return runCmd(["adb"] + args)

	def setupArm():
	global gArmInitialized
	if gArmInitialized:
	return
	print "Setting up arm"
	adb(["remount"])
	adb(["shell", "rm", "/system/bin/acc"])
	adb(["shell", "mkdir", "/system/bin/accdata"])
	adb(["shell", "mkdir", "/system/bin/accdata/data"])
	# Clear out old data TODO: handle recursion
	adb(["shell", "rm", "/system/bin/accdata/data/*"])
	# Copy over data
	for root, dirs, files in os.walk("data"):
	for d in dirs:
	adb(["shell", "mkdir", os.path.join(root, d)])
	for f in files:
	adb(["push", os.path.join(root, f), os.path.join("/system/bin/accdata", root, f)])
	# Copy over compiler
	adb(["sync"])
	gArmInitialized = True

	def compileArm(args):
	setupArm()
	proc = subprocess.Popen(["adb", "shell", "/system/bin/acc"] + args, stdout=subprocess.PIPE)
	result = proc.communicate()
	return result[0].replace("\r","")

	def compare(a, b):
	if a != b:
	firstDiff = firstDifference(a, b)
	print "Strings differ at character %d. Common: %s. Difference '%s' != '%s'" % (
	firstDiff, a[0:firstDiff], safeAccess(a, firstDiff), safeAccess(b, firstDiff))

	def safeAccess(s, i):
	if 0 <= i < len(s):
	return s[i]
	else:
	return '?'

	def firstDifference(a, b):
	commonLen = min(len(a), len(b))
	for i in xrange(0, commonLen):
	if a[i] != b[i]:
	return i
	return commonLen

	# a1 and a2 are the expected stdout and stderr.
	# b1 and b2 are the actual stdout and stderr.
	# Compare the two, sets. Allow any individual line
	# to appear in either stdout or stderr. This is because
	# the way we obtain output on the ARM combines both
	# streams into one sequence.

	def compareOuput(a1,a2,b1,b2):
	while True:
	totalLen = len(a1) + len(a2) + len(b1) + len(b2)
	a1, b1 = matchCommon(a1, b1)
	a1, b2 = matchCommon(a1, b2)
	a2, b1 = matchCommon(a2, b1)
	a2, b2 = matchCommon(a2, b2)
	newTotalLen = len(a1) + len(a2) + len(b1) + len(b2)
	if newTotalLen == 0:
	return True
	if newTotalLen == totalLen:
	print "Failed at %d %d %d %d" % (len(a1), len(a2), len(b1), len(b2))
	print "a1", a1
	print "a2", a2
	print "b1", b1
	print "b2", b2
	return False

	def matchCommon(a, b):
	"""Remove common items from the beginning of a and b,
	return just the tails that are different."""
	while len(a) > 0 and len(b) > 0 and a[0] == b[0]:
	a = a[1:]
	b = b[1:]
	return a, b

	def rewritePaths(args):
	return [rewritePath(x) for x in args]

	def rewritePath(p):
	"""Take a path that's correct on the x86 and convert to a path
	that's correct on ARM."""
	if p.startswith("data/"):
	p = "/system/bin/accdata/" + p
	return p

	class TestACC(unittest.TestCase):

	def checkResult(self, out, err, stdErrResult, stdOutResult=""):
	a1 = out.splitlines()
	a2 = err.splitlines()
	b2 = stdErrResult.splitlines()
	b1 = stdOutResult.splitlines()
	self.assertEqual(True, compareOuput(a1,a2,b1,b2))

	def compileCheck(self, args, stdErrResult, stdOutResult="",
	targets=['arm', 'x86']):
	targetSet = sets.ImmutableSet(targets)
	if False and 'x86' in targetSet:
	out, err = compile(args)
	self.checkResult(out, err, stdErrResult, stdOutResult)
	if 'arm' in targetSet:
	out = compileArm(rewritePaths(args))
	self.checkResult(out, "", stdErrResult, stdOutResult)

	def compileCheckArm(self, args, result):
	self.assertEqual(compileArm(args), result)

	def testCompileReturnVal(self):
	self.compileCheck(["data/returnval-ansi.c"], "")

	def testCompileOTCCANSII(self):
	self.compileCheck(["data/otcc-ansi.c"], "", "", ['x86'])

	def testRunReturnVal(self):
	self.compileCheck(["-R", "data/returnval-ansi.c"],
	"Executing compiled code:\nresult: 42\n")

	def testStringLiteralConcatenation(self):
	self.compileCheck(["-R", "data/testStringConcat.c"],
	"Executing compiled code:\nresult: 13\n", "Hello, world\n")

	def testRunOTCCANSI(self):
	self.compileCheck(["-R", "data/otcc-ansi.c", "data/returnval.c"],
	"Executing compiled code:\notcc-ansi.c: About to execute compiled code:\natcc-ansi.c: result: 42\nresult: 42\n", "",
	['x86'])

	def testRunOTCCANSI2(self):
	self.compileCheck(["-R", "data/otcc-ansi.c", "data/otcc.c", "data/returnval.c"],
	"Executing compiled code:\notcc-ansi.c: About to execute compiled code:\notcc.c: about to execute compiled code.\natcc-ansi.c: result: 42\nresult: 42\n", "",['x86'])

	def testRunConstants(self):
	self.compileCheck(["-R", "data/constants.c"],
	"Executing compiled code:\nresult: 12\n",
	"0 = 0\n010 = 8\n0x10 = 16\n'\\a' = 7\n'\\b' = 8\n'\\f' = 12\n'\\n' = 10\n'\\r' = 13\n'\\t' = 9\n'\\v' = 11\n'\\\\' = 92\n'\\'' = 39\n" +
	"'\\\"' = 34\n'\\?' = 63\n'\\0' = 0\n'\\1' = 1\n'\\12' = 10\n'\\123' = 83\n'\\x0' = 0\n'\\x1' = 1\n'\\x12' = 18\n'\\x123' = 291\n'\\x1f' = 31\n'\\x1F' = 31\n")

	def testRunFloat(self):
	self.compileCheck(["-R", "data/float.c"],
	"Executing compiled code:\nresult: 0\n",
	"""Constants: 0 0 0 0.01 0.01 0.1 10 10 0.1
	int: 1 float: 2.2 double: 3.3
	ftoi(1.4f)=1
	dtoi(2.4)=2
	itof(3)=3
	itod(4)=4
	globals: 1 2 3 4
	args: 1 2 3 4
	locals: 1 2 3 4
	cast rval: 2 4
	cast lval: 1.1 2 3.3 4
	""")

	def testRunFlops(self):
	self.compileCheck(["-R", "data/flops.c"],
	"""Executing compiled code:
	result: 0""",
	"""-1.1 = -1.1
	!1.2 = 0
	!0 = 1
	double op double:
	1 + 2 = 3
	1 - 2 = -1
	1 * 2 = 2
	1 / 2 = 0.5
	float op float:
	1 + 2 = 3
	1 - 2 = -1
	1 * 2 = 2
	1 / 2 = 0.5
	double op float:
	1 + 2 = 3
	1 - 2 = -1
	1 * 2 = 2
	1 / 2 = 0.5
	double op int:
	1 + 2 = 3
	1 - 2 = -1
	1 * 2 = 2
	1 / 2 = 0.5
	int op double:
	1 + 2 = 3
	1 - 2 = -1
	1 * 2 = 2
	1 / 2 = 0.5
	double op double:
	1 op 2: < 1 <= 1 == 0 >= 0 > 0 != 1
	1 op 1: < 0 <= 1 == 1 >= 1 > 0 != 0
	2 op 1: < 0 <= 0 == 0 >= 1 > 1 != 1
	double op float:
	1 op 2: < 1 <= 1 == 0 >= 0 > 0 != 1
	1 op 1: < 0 <= 1 == 1 >= 1 > 0 != 0
	2 op 1: < 0 <= 0 == 0 >= 1 > 1 != 1
	float op float:
	1 op 2: < 1 <= 1 == 0 >= 0 > 0 != 1
	1 op 1: < 0 <= 1 == 1 >= 1 > 0 != 0
	2 op 1: < 0 <= 0 == 0 >= 1 > 1 != 1
	int op double:
	1 op 2: < 1 <= 1 == 0 >= 0 > 0 != 1
	1 op 1: < 0 <= 1 == 1 >= 1 > 0 != 0
	2 op 1: < 0 <= 0 == 0 >= 1 > 1 != 1
	double op int:
	1 op 2: < 1 <= 1 == 0 >= 0 > 0 != 1
	1 op 1: < 0 <= 1 == 1 >= 1 > 0 != 0
	2 op 1: < 0 <= 0 == 0 >= 1 > 1 != 1
	branching: 1 0 1
	testpassi: 1 2 3 4 5 6 7 8 9 10 11 12
	testpassf: 1 2 3 4 5 6 7 8 9 10 11 12
	testpassd: 1 2 3 4 5 6 7 8 9 10 11 12
	testpassi: 1 2 3 4 5 6 7 8 9 10 11 12
	testpassf: 1 2 3 4 5 6 7 8 9 10 11 12
	testpassd: 1 2 3 4 5 6 7 8 9 10 11 12
	testpassi: 1 2 3 4 5 6 7 8 9 10 11 12
	testpassf: 1 2 3 4 5 6 7 8 9 10 11 12
	testpassd: 1 2 3 4 5 6 7 8 9 10 11 12
	testpassidf: 1 2 3
	""")
	def testCasts(self):
	self.compileCheck(["-R", "data/casts.c"],
	"""Executing compiled code:
	result: 0""", """Reading from a pointer: 3 3
	Writing to a pointer: 4
	Testing casts: 3 3 4.5 4
	Testing reading (int*): 4
	Testing writing (int*): 8 9
	Testing reading (char*): 0x78 0x56 0x34 0x12
	Testing writing (char*): 0x87654321
	f(10)
	Function pointer result: 70
	Testing read/write (float*): 8.8 9.9
	Testing read/write (double*): 8.8 9.9
	""")

	def testChar(self):
	self.compileCheck(["-R", "data/char.c"], """Executing compiled code:
	result: 0""", """a = 99, b = 41
	ga = 100, gb = 44""")

	def testPointerArithmetic(self):
	self.compileCheck(["-R", "data/pointers.c"], """Executing compiled code:
	result: 0""", """Pointer difference: 1 4
	Pointer addition: 2
	Pointer comparison to zero: 0 0 1
	Pointer comparison: 1 0 0 0 1
	""")
	def testRollo3(self):
	self.compileCheck(["-R", "data/rollo3.c"], """Executing compiled code:
	result: 10""", """""")

	def testFloatDouble(self):
	self.compileCheck(["-R", "data/floatdouble.c"], """Executing compiled code:
	result: 0""", """0.002 0.1 10""")

	def testIncDec(self):
	self.compileCheck(["-R", "data/inc.c"], """Executing compiled code:
	0
	1
	2
	1
	result: 0
	""","""""")

	def testIops(self):
	self.compileCheck(["-R", "data/iops.c"], """Executing compiled code:
	result: 0""", """Literals: 1 -1
	++
	0
	1
	2
	3
	4
	5
	6
	7
	8
	9
	--
	10
	9
	8
	7
	6
	5
	4
	3
	2
	1
	0
	""")

	def testFilm (self):
	self.compileCheck(["-R", "data/film.c"], """Executing compiled code:
	result: 0""", """testing...
	Total bad: 0
	""")
	if __name__ == '__main__':
	if not outputCanRun():
	print "Many tests are expected to fail, because acc is not a 32-bit x86 Linux executable."
	unittest.main()