#

# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Lesser General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Lesser General Public License for more details.

# 

# You should have received a copy of the GNU Lesser General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# Launch QEMU for SVP with a specified ROM image and core using a COM port for IO

# Uses Python's Popen class for process control.

# Test output is captured by invoking QEMU in -nographic mode. This redirects serial output to stdout which can then be PIPE'd

# using Popen.

# Tests which hang(or crash into the the crash debugger) are detected using a trivial 'watchdog'. IWBN to use e.g. 'select'

# with a timeout, but this won't work on Windoze, which only supports timeout's on sockets. If the watchdog timeouts out QEMU is killed.

# When the test suite runs to (recognizable) completion QEMU is killed. Unfortunately this appears to require an OS specific

# solution. NB unrecognized completion will result in the watchdog killing QEMU.

# QemuTestRunner collects  output into LineTimeInfo objects. These record the time at which each line was received. The time can be used as a crude

# measure of how long a test took to execute.

# The raw data gathered from running the tests can be retrieved using GetResults. This returns a list of LineTimeInfo objects.

import sys

mswindows = (sys.platform == "win32")

# import the following so we can kill QEMU

if mswindows:

#    import win32api

    import signal

else:

    import signal

import os

import time

import re

import subprocess

from subprocess import *

from stat import *

import watchdog

__all__ = ["QemuTestRunner"]

class LineTimeInfo(object):

    def __init__(self, line, atime):

        self.line = line

        self.time = atime

    def GetLine(self):

        return self.line

    def GetTime(self):

        return self.time

class QemuTestRunner(object):

    def __init__(self, qemupath, cpu, rompath, board = 'syborg', endOfTestFn=None, displayp=False, dataFile = None):

        """Create new QemuTestRunner instance."""

        self.qemupath = qemupath

        self.board = board

        self.cpu = cpu

        self.rompath = rompath

        self.endOfTestFn = endOfTestFn

        self.displayp = displayp

        #self.cmd = qemupath + " -M syborg -cpu " + cpu + " -kernel " + rompath + " -nographic"

        self.cmd = "%s -M %s -cpu %s -kernel %s -nographic" % (qemupath, board, cpu, rompath)

        self.endOfTestPattern = re.compile('RUNTESTS: Completed test script')

        self.lineTimeInfo = []

        self.id = None

        self.dataFile = dataFile

        self.watchdog = watchdog.WatchDog(900, lambda : self.KillSim())

    def Run(self):

        self.lineTimeInfo = []

        output = False

        self.timeStarted = time.gmtime()

        self.id = time.strftime("%d-%m%--%Y-%H-%M-%S", self.timeStarted)

        if self.dataFile != None:

            filename = self.dataFile + "-" + self.GetRunId() + "-data.txt"

            self.dataFileName = filename

            output = open(filename, 'wb')

        p = Popen( self.cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE )

        self.popen = p

        stdin = p.stdin

        stdout = p.stdout

        stop = False

        if self.displayp:

            print >> sys.stdout, self.cmd

        self.watchdog.Start()

        try:

            while p.poll() == None and not stop:

                line = stdout.readline()

                atime = time.clock()

                self.watchdog.Reset()

                if self.displayp and p.returncode == None:

                    print >> sys.stdout , line

                if output and p.returncode == None:

                    print >> output , line

                if p.returncode == None:

                    self.lineTimeInfo.append(LineTimeInfo(line, atime))

                    if self.endOfTestFn != None:

                        stop = self.endOfTestFn(line)

                    else:

                        stop = self.EndOfTestp(line)

        finally:

            self.timeEnded = time.gmtime()

            self.watchdog.Stop()

            if output:

                output.close()

            self.testSuiteFinished = stop;

        if p.returncode == None:

            self.KillSim()

            return True

        else:

            return False

    def GetDataFileName(self):

        return self.dataFileName

    def TestSuiteFinishedp(self):

        return self.testSuiteFinished

    def EndOfTestp(self, l):

        return re.match(self.endOfTestPattern,l) != None

    def KillSim(self):

#        if mswindows:

#            win32api.TerminateProcess(int(self.popen._handle), -1)

#        else:

            os.kill(slef.popen.pid, signal.SIGKILL)

    def GetResults(self):

        return self.lineTimeInfo

    def GetRomName(self):

        return self.rompath

    def GetRunId(self):

        return self.id

    def GetSummary(self):

        simStat = os.stat(self.qemupath)

        simSummary = "QEMU Executable: %s size: %d creation time: %d\n" % (self.qemupath, simStat[ST_SIZE], simStat[ST_CTIME])

        boardSummary ="Board: %s\n" %  self.board

        cpuSummary = "CPU: %s\n" % self.cpu

        romStat = os.stat(self.rompath)

        romSummary = "ROM image: %s size: %d creation date: %d\n" % (self.rompath, romStat[ST_SIZE], romStat[ST_CTIME])

        timeFormat = "%d-%m%--%Y %H:%M:%S"

        startTime = "Start time: " + time.strftime(timeFormat, self.timeStarted) + "\n"

        endTime = "End time: " + time.strftime(timeFormat, self.timeEnded) + "\n"

        status = "Testsuite did not complete\n"

        if self.TestSuiteFinishedp():

            status = "Testsuite completed\n"

        return simSummary + boardSummary + cpuSummary + romSummary + startTime + endTime + status

    def GetReportFileName(self):

        return self.GetRomName() + "-" + self.GetRunId() + "-results-summary.txt"

class PseudoRunner(QemuTestRunner):

    def __init__(self, input):

        #self.qemupath = qemupath

        #self.board = board

        #self.cpu = cpu

        #self.rompath = rompath

        #self.endOfTestFn = endOfTestFn

        #self.displayp = displayp

        #self.cmd = qemupath + " -M syborg -cpu " + cpu + " -kernel " + rompath + " -nographic"

        #self.endOfTestPattern = re.compile('RUNTESTS: Completed test script')

        self.lineTimeInfo = []

        #self.id = None

        self.dataFile = input

        for line in open(input):

            self.lineTimeInfo.append(LineTimeInfo(line, 0))

    def GetRomName(self):

        return "Unknown"

    def GetRunId(self):

        return None

    def GetSummary(self):

        return ""

    def GetReportFileName(self):

        return "Runtest-Summary.txt"