ff096c1b7b
Previously we were looking for test files with this pattern: test_* I added *_test.[cc|cpp] and *_unittest.[cc|cpp] The search also scan all the subdirectories of the build_path from the test definition. I added a filtering stage where missing tests are ignored. For instance we may have a source file that has not been built for the target, in which case it is ignored when we run the target tests. In android_build.py I added 4 helper functions to get access to the build environment: - GetHostBin - GetProductOut - GetTargetSystemBin - GetHostOsArch Replace all the hardcoded linux-x86 strings with the value returned by GetHostOsArch.
151 lines
4.3 KiB
Python
Executable File
151 lines
4.3 KiB
Python
Executable File
#!/usr/bin/python2.4
|
|
#
|
|
#
|
|
# Copyright 2007, The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
# System imports
|
|
import os
|
|
import signal
|
|
import subprocess
|
|
import threading
|
|
import time
|
|
|
|
# local imports
|
|
import android_build
|
|
import errors
|
|
import logger
|
|
|
|
_abort_on_error = False
|
|
|
|
def SetAbortOnError(abort=True):
|
|
"""Sets behavior of RunCommand to throw AbortError if command process returns
|
|
a negative error code"""
|
|
global _abort_on_error
|
|
_abort_on_error = abort
|
|
|
|
def RunCommand(cmd, timeout_time=None, retry_count=3, return_output=True):
|
|
"""Spawns a subprocess to run the given shell command, and checks for
|
|
timeout_time. If return_output is True, the output of the command is returned
|
|
as a string. Otherwise, output of command directed to stdout """
|
|
|
|
result = None
|
|
while True:
|
|
try:
|
|
result = RunOnce(cmd, timeout_time=timeout_time,
|
|
return_output=return_output)
|
|
except errors.WaitForResponseTimedOutError:
|
|
if retry_count == 0:
|
|
raise
|
|
retry_count -= 1
|
|
logger.Log("No response for %s, retrying" % cmd)
|
|
else:
|
|
# Success
|
|
return result
|
|
|
|
def RunOnce(cmd, timeout_time=None, return_output=True):
|
|
start_time = time.time()
|
|
so = []
|
|
pid = []
|
|
global _abort_on_error
|
|
error_occurred = False
|
|
|
|
def Run():
|
|
if return_output:
|
|
output_dest = subprocess.PIPE
|
|
else:
|
|
# None means direct to stdout
|
|
output_dest = None
|
|
pipe = subprocess.Popen(
|
|
cmd,
|
|
executable='/bin/bash',
|
|
stdout=output_dest,
|
|
stderr=subprocess.STDOUT,
|
|
shell=True)
|
|
pid.append(pipe.pid)
|
|
try:
|
|
output = pipe.communicate()[0]
|
|
if output is not None and len(output) > 0:
|
|
so.append(output)
|
|
except OSError, e:
|
|
logger.SilentLog("failed to retrieve stdout from: %s" % cmd)
|
|
logger.Log(e)
|
|
so.append("ERROR")
|
|
error_occurred = True
|
|
if pipe.returncode < 0:
|
|
logger.SilentLog("Error: %s was terminated by signal %d" %(cmd,
|
|
pipe.returncode))
|
|
error_occurred = True
|
|
|
|
t = threading.Thread(target=Run)
|
|
t.start()
|
|
|
|
break_loop = False
|
|
while not break_loop:
|
|
if not t.isAlive():
|
|
break_loop = True
|
|
|
|
# Check the timeout
|
|
if (not break_loop and timeout_time is not None
|
|
and time.time() > start_time + timeout_time):
|
|
try:
|
|
os.kill(pid[0], signal.SIGKILL)
|
|
except OSError:
|
|
# process already dead. No action required.
|
|
pass
|
|
|
|
logger.SilentLog("about to raise a timeout for: %s" % cmd)
|
|
raise errors.WaitForResponseTimedOutError
|
|
if not break_loop:
|
|
time.sleep(0.1)
|
|
|
|
t.join()
|
|
|
|
if _abort_on_error and error_occurred:
|
|
raise errors.AbortError
|
|
|
|
return "".join(so)
|
|
|
|
|
|
def RunHostCommand(binary, valgrind=False):
|
|
"""Run a command on the host (opt using valgrind).
|
|
|
|
Runs the host binary and returns the exit code.
|
|
If successfull, the output (stdout and stderr) are discarded,
|
|
but printed in case of error.
|
|
The command can be run under valgrind in which case all the
|
|
output are always discarded.
|
|
|
|
Args:
|
|
binary: basename of the file to be run. It is expected to be under
|
|
out/host/<os>-<arch>/bin.
|
|
valgrind: If True the command will be run under valgrind.
|
|
|
|
Returns:
|
|
The command exit code (int)
|
|
"""
|
|
full_path = os.path.join(android_build.GetHostBin(), binary)
|
|
if not valgrind:
|
|
subproc = subprocess.Popen(full_path, stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT)
|
|
subproc.wait()
|
|
if subproc.returncode != 0: # In case of error print the output
|
|
print subproc.communicate()[0]
|
|
return subproc.returncode
|
|
else:
|
|
subproc = subprocess.Popen(["/usr/bin/valgrind", "-q", full_path],
|
|
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
|
subproc.wait()
|
|
return subproc.returncode
|