Merge change 7047

import unittest

import subprocess

import os

import sets

gArmInitialized = False

def compile(args):

    proc = subprocess.Popen(["acc"] + args, stderr=subprocess.PIPE, stdout=subprocess.PIPE)

def adb(args):

    return runCmd(["adb"] + args)

gArmInitialized = False

def setupArm():

    global gArmInitialized

    if gArmInitialized:

        return

    print "Setting up arm"

            adb(["push", os.path.join(root, f), os.path.join("/system/bin/accdata", root, f)])

    # Copy over compiler

    adb(["sync"])

    gArmInitialied = True

    gArmInitialized = True

def compileArm(args):

    setupArm()

            return i

    return commonLen

def compareSet(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):

    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):

    if p.startswith("data/"):

        p = "/system/bin/accdata/" + p

    return p

class TestACC(unittest.TestCase):

    def compileCheck(self, args, stdErrResult, stdOutResult=""):

    def compileCheckOld(self, args, stdErrResult, stdOutResult=""):

        out, err = compile(args)

        compare(out, stdOutResult)

        compare(err, stdErrResult)

        self.assertEqual(out, stdOutResult)

        self.assertEqual(err, stdErrResult)

    def checkResult(self, out, err, stdErrResult, stdOutResult=""):

        a1 = out.splitlines()

        a2 = err.splitlines()

        b2 = stdErrResult.splitlines()

        b1 = stdOutResult.splitlines()

        self.assertEqual(True, compareSet(a1,a2,b1,b2))

    def compileCheck(self, args, stdErrResult, stdOutResult="",

                     targets=['arm', 'x86']):

        targetSet = sets.ImmutableSet(targets)

        if '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 testCompileReturnVal(self):

        self.compileCheck(["data/otcc-ansi.c"], "")

    def testCompileOTCCANSII(self):

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

    def testRunReturnVal(self):

        self.compileCheck(["-R", "data/returnval-ansi.c"],

    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")

            "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")

            "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"],

            "testpassidf: 1 2 3\n"

            )

    def testArmRunReturnVal(self):

    def oldtestArmRunReturnVal(self):

        self.compileCheckArm(["-R", "/system/bin/accdata/data/returnval-ansi.c"],

            "Executing compiled code:\nresult: 42\n")