def test_native_case_alternate_datastream(self):
# Create the file manually, since tempfile doesn't support ADS.
tempdir = unicode(tempfile.mkdtemp(prefix='trace_inputs'))
try:
tempdir = trace_inputs.get_native_path_case(tempdir)
basename = 'foo.txt'
filename = basename + ':Zone.Identifier'
filepath = os.path.join(tempdir, filename)
open(filepath, 'w').close()
self.assertEqual(filepath,
trace_inputs.get_native_path_case(filepath))
data_suffix = ':$DATA'
self.assertEqual(
filepath + data_suffix,
trace_inputs.get_native_path_case(filepath + data_suffix))
open(filepath + '$DATA', 'w').close()
self.assertEqual(
filepath + data_suffix,
trace_inputs.get_native_path_case(filepath + data_suffix))
# Ensure the ADS weren't created as separate file. You love NTFS, don't
# you?
self.assertEqual([basename], os.listdir(tempdir))
finally:
shutil.rmtree(tempdir)
def test_native_case_windows(self):
if sys.platform != 'win32':
return
windows_path = os.environ['SystemRoot']
self.assertEquals(
trace_inputs.get_native_path_case(windows_path.lower()),
trace_inputs.get_native_path_case(windows_path.upper()))
def test_native_case_windows(self):
if sys.platform != 'win32':
return
windows_path = os.environ['SystemRoot']
self.assertEquals(
trace_inputs.get_native_path_case(windows_path.lower()),
trace_inputs.get_native_path_case(windows_path.upper()))
def test_native_case_non_existing(self):
# Make sure it doesn't throw on non-existing files.
non_existing = 'trace_input_test_this_file_should_not_exist'
path = os.path.expanduser('~/' + non_existing)
self.assertFalse(os.path.exists(path))
path = trace_inputs.get_native_path_case(ROOT_DIR) + os.path.sep
self.assertEqual(trace_inputs.get_native_path_case(path), path)
def test_native_case_symlink_wrong_case(self):
actual = trace_inputs.get_native_path_case(
os.path.join(ROOT_DIR, 'data', 'trace_inputs'))
self.assertEquals('trace_inputs', os.path.basename(actual))
# Make sure the symlink is not resolved.
actual = trace_inputs.get_native_path_case(
os.path.join(ROOT_DIR, 'data', 'trace_inputs', 'Files2'))
self.assertEquals('files2', os.path.basename(actual))
def test_native_case_symlink_right_case(self):
actual = trace_inputs.get_native_path_case(
os.path.join(BASE_DIR, 'trace_inputs'))
self.assertEqual('trace_inputs', os.path.basename(actual))
# Make sure the symlink is not resolved.
actual = trace_inputs.get_native_path_case(
os.path.join(BASE_DIR, 'trace_inputs', 'files2'))
self.assertEqual('files2', os.path.basename(actual))
def test_native_case_symlink_wrong_case(self):
actual = trace_inputs.get_native_path_case(
os.path.join(ROOT_DIR, 'data', 'trace_inputs'))
self.assertEquals('trace_inputs', os.path.basename(actual))
# Make sure the symlink is not resolved.
actual = trace_inputs.get_native_path_case(
os.path.join(ROOT_DIR, 'data', 'trace_inputs', 'Files2'))
self.assertEquals('files2', os.path.basename(actual))
def test_native_case_not_sensitive(self):
# The home directory is almost guaranteed to have mixed upper/lower case
# letters on both Windows and OSX.
# This test also ensures that the output is independent on the input
# string case.
path = os.path.expanduser('~')
self.assertTrue(os.path.isdir(path))
# This test assumes the variable is in the native path case on disk, this
# should be the case. Verify this assumption:
self.assertEquals(path, trace_inputs.get_native_path_case(path))
self.assertEquals(trace_inputs.get_native_path_case(path.lower()),
trace_inputs.get_native_path_case(path.upper()))
def test_native_case_not_sensitive_non_existent(self):
# This test also ensures that the output is independent on the input
# string case.
non_existing = os.path.join(
'trace_input_test_this_dir_should_not_exist', 'really not', '')
path = os.path.expanduser(os.path.join('~', non_existing))
self.assertFalse(os.path.exists(path))
lower = trace_inputs.get_native_path_case(path.lower())
upper = trace_inputs.get_native_path_case(path.upper())
# Make sure non-existing element is not modified:
self.assertTrue(lower.endswith(non_existing.lower()))
self.assertTrue(upper.endswith(non_existing.upper()))
self.assertEquals(lower[:-len(non_existing)], upper[:-len(non_existing)])
def test_native_case_not_sensitive(self):
# The home directory is almost guaranteed to have mixed upper/lower case
# letters on both Windows and OSX.
# This test also ensures that the output is independent on the input
# string case.
path = os.path.expanduser('~')
self.assertTrue(os.path.isdir(path))
# This test assumes the variable is in the native path case on disk, this
# should be the case. Verify this assumption:
self.assertEquals(path, trace_inputs.get_native_path_case(path))
self.assertEquals(
trace_inputs.get_native_path_case(path.lower()),
trace_inputs.get_native_path_case(path.upper()))
def test_native_case_not_sensitive_non_existent(self):
# This test also ensures that the output is independent on the input
# string case.
non_existing = os.path.join(
'trace_input_test_this_dir_should_not_exist', 'really not', '')
path = os.path.expanduser(os.path.join(u'~', non_existing))
path = path.replace('/', os.path.sep)
self.assertFalse(os.path.exists(path))
lower = trace_inputs.get_native_path_case(path.lower())
upper = trace_inputs.get_native_path_case(path.upper())
# Make sure non-existing element is not modified:
self.assertTrue(lower.endswith(non_existing.lower()))
self.assertTrue(upper.endswith(non_existing.upper()))
self.assertEqual(lower[:-len(non_existing)], upper[:-len(non_existing)])
def test_native_case_not_sensitive(self):
# The home directory is almost guaranteed to have mixed upper/lower case
# letters on both Windows and OSX.
# This test also ensures that the output is independent on the input
# string case.
path = os.path.expanduser(u'~')
self.assertTrue(os.path.isdir(path))
path = path.replace('/', os.path.sep)
if sys.platform == 'win32':
# Make sure the drive letter is upper case for consistency.
path = path[0].upper() + path[1:]
# This test assumes the variable is in the native path case on disk, this
# should be the case. Verify this assumption:
self.assertEqual(path, trace_inputs.get_native_path_case(path))
self.assertEqual(trace_inputs.get_native_path_case(path.lower()),
trace_inputs.get_native_path_case(path.upper()))
def parse_args(self, *args, **kwargs):
"""Makes sure the paths make sense.
On Windows, / and \ are often mixed together in a path.
"""
options, args = OptionParserWithLogging.parse_args(self, *args, **kwargs)
if not self.allow_interspersed_args and args:
self.error('Unsupported argument: %s' % args)
options.variables = dict(options.variables)
if self.require_result and not options.result:
self.error('--result is required.')
if options.result and not options.result.endswith('.results'):
self.error('--result value must end with \'.results\'')
if options.result:
options.result = os.path.abspath(options.result.replace('/', os.path.sep))
if options.isolate:
options.isolate = trace_inputs.get_native_path_case(
os.path.abspath(
options.isolate.replace('/', os.path.sep)))
if options.outdir:
options.outdir = os.path.abspath(
options.outdir.replace('/', os.path.sep))
return options, args
def setUp(self):
self.temp_file = None
self.initial_cwd = ROOT_DIR
if sys.platform == 'win32':
# Windows has no kernel mode concept of current working directory.
self.initial_cwd = None
# There's 2 kinds of references to python, self.executable,
# self.real_executable. It depends how python was started and on which OS.
self.executable = unicode(sys.executable)
if sys.platform == 'darwin':
# /usr/bin/python is a thunk executable that decides which version of
# python gets executed.
suffix = '.'.join(map(str, sys.version_info[0:2]))
if os.access(self.executable + suffix, os.X_OK):
# So it'll look like /usr/bin/python2.7
self.executable += suffix
self.real_executable = trace_inputs.get_native_path_case(
self.executable)
if sys.platform == 'darwin':
# Interestingly, only OSX does resolve the symlink manually before
# starting the executable.
if os.path.islink(self.real_executable):
self.real_executable = os.path.normpath(
os.path.join(
os.path.dirname(self.real_executable),
os.readlink(self.real_executable)))
def test_native_case_not_sensitive(self):
# The home directory is almost guaranteed to have mixed upper/lower case
# letters on both Windows and OSX.
# This test also ensures that the output is independent on the input
# string case.
path = os.path.expanduser(u'~')
self.assertTrue(os.path.isdir(path))
path = path.replace('/', os.path.sep)
if sys.platform == 'win32':
# Make sure the drive letter is upper case for consistency.
path = path[0].upper() + path[1:]
# This test assumes the variable is in the native path case on disk, this
# should be the case. Verify this assumption:
self.assertEqual(path, trace_inputs.get_native_path_case(path))
self.assertEqual(
trace_inputs.get_native_path_case(path.lower()),
trace_inputs.get_native_path_case(path.upper()))
def test_native_case_symlink_wrong_case(self):
base_dir = trace_inputs.get_native_path_case(BASE_DIR)
trace_inputs_dir = os.path.join(base_dir, 'trace_inputs')
actual = trace_inputs.get_native_path_case(trace_inputs_dir)
self.assertEqual(trace_inputs_dir, actual)
# Make sure the symlink is not resolved.
data = os.path.join(trace_inputs_dir, 'Files2')
actual = trace_inputs.get_native_path_case(data)
self.assertEqual(os.path.join(trace_inputs_dir, 'files2'), actual)
data = os.path.join(trace_inputs_dir, 'Files2', '')
actual = trace_inputs.get_native_path_case(data)
self.assertEqual(os.path.join(trace_inputs_dir, 'files2', ''),
actual)
data = os.path.join(trace_inputs_dir, 'Files2', 'Child1.py')
actual = trace_inputs.get_native_path_case(data)
# TODO(maruel): Should be child1.py.
self.assertEqual(
os.path.join(trace_inputs_dir, 'files2', 'Child1.py'), actual)
def setUp(self):
self.tempdir = None
self.trace_inputs_path = os.path.join(ROOT_DIR, 'trace_inputs.py')
# Wraps up all the differences between OSes here.
# - Windows doesn't track initial_cwd.
# - OSX replaces /usr/bin/python with /usr/bin/python2.7.
self.cwd = os.path.join(ROOT_DIR, u'tests')
self.initial_cwd = unicode(self.cwd)
self.expected_cwd = unicode(ROOT_DIR)
if sys.platform == 'win32':
# Not supported on Windows.
self.initial_cwd = None
self.expected_cwd = None
# There's 3 kinds of references to python, self.executable,
# self.real_executable and self.naked_executable. It depends how python was
# started.
self.executable = sys.executable
if sys.platform == 'darwin':
# /usr/bin/python is a thunk executable that decides which version of
# python gets executed.
suffix = '.'.join(map(str, sys.version_info[0:2]))
if os.access(self.executable + suffix, os.X_OK):
# So it'll look like /usr/bin/python2.7
self.executable += suffix
import trace_inputs
self.real_executable = trace_inputs.get_native_path_case(
unicode(self.executable))
self.tempdir = trace_inputs.get_native_path_case(
unicode(tempfile.mkdtemp(prefix='trace_smoke_test')))
self.log = os.path.join(self.tempdir, 'log')
trace_inputs = None
# self.naked_executable will only be naked on Windows.
self.naked_executable = unicode(sys.executable)
if sys.platform == 'win32':
self.naked_executable = os.path.basename(sys.executable)
def setUp(self):
self.tempdir = None
self.trace_inputs_path = os.path.join(ROOT_DIR, 'trace_inputs.py')
# Wraps up all the differences between OSes here.
# - Windows doesn't track initial_cwd.
# - OSX replaces /usr/bin/python with /usr/bin/python2.7.
self.cwd = os.path.join(ROOT_DIR, u'tests')
self.initial_cwd = unicode(self.cwd)
self.expected_cwd = unicode(ROOT_DIR)
if sys.platform == 'win32':
# Not supported on Windows.
self.initial_cwd = None
self.expected_cwd = None
# There's 3 kinds of references to python, self.executable,
# self.real_executable and self.naked_executable. It depends how python was
# started.
self.executable = sys.executable
if sys.platform == 'darwin':
# /usr/bin/python is a thunk executable that decides which version of
# python gets executed.
suffix = '.'.join(map(str, sys.version_info[0:2]))
if os.access(self.executable + suffix, os.X_OK):
# So it'll look like /usr/bin/python2.7
self.executable += suffix
import trace_inputs
self.real_executable = trace_inputs.get_native_path_case(
unicode(self.executable))
self.tempdir = trace_inputs.get_native_path_case(
unicode(tempfile.mkdtemp(prefix='trace_smoke_test')))
self.log = os.path.join(self.tempdir, 'log')
trace_inputs = None
# self.naked_executable will only be naked on Windows.
self.naked_executable = unicode(sys.executable)
if sys.platform == 'win32':
self.naked_executable = os.path.basename(sys.executable)
def test_native_case_symlink_wrong_case(self):
base_dir = trace_inputs.get_native_path_case(BASE_DIR)
trace_inputs_dir = os.path.join(base_dir, 'trace_inputs')
actual = trace_inputs.get_native_path_case(trace_inputs_dir)
self.assertEqual(trace_inputs_dir, actual)
# Make sure the symlink is not resolved.
data = os.path.join(trace_inputs_dir, 'Files2')
actual = trace_inputs.get_native_path_case(data)
self.assertEqual(
os.path.join(trace_inputs_dir, 'files2'), actual)
data = os.path.join(trace_inputs_dir, 'Files2', '')
actual = trace_inputs.get_native_path_case(data)
self.assertEqual(
os.path.join(trace_inputs_dir, 'files2', ''), actual)
data = os.path.join(trace_inputs_dir, 'Files2', 'Child1.py')
actual = trace_inputs.get_native_path_case(data)
# TODO(maruel): Should be child1.py.
self.assertEqual(
os.path.join(trace_inputs_dir, 'files2', 'Child1.py'), actual)
def test_native_case_alternate_datastream(self):
# Create the file manually, since tempfile doesn't support ADS.
tempdir = unicode(tempfile.mkdtemp(prefix='trace_inputs'))
try:
tempdir = trace_inputs.get_native_path_case(tempdir)
basename = 'foo.txt'
filename = basename + ':Zone.Identifier'
filepath = os.path.join(tempdir, filename)
open(filepath, 'w').close()
self.assertEqual(filepath, trace_inputs.get_native_path_case(filepath))
data_suffix = ':$DATA'
self.assertEqual(
filepath + data_suffix,
trace_inputs.get_native_path_case(filepath + data_suffix))
open(filepath + '$DATA', 'w').close()
self.assertEqual(
filepath + data_suffix,
trace_inputs.get_native_path_case(filepath + data_suffix))
# Ensure the ADS weren't created as separate file. You love NTFS, don't
# you?
self.assertEqual([basename], os.listdir(tempdir))
finally:
shutil.rmtree(tempdir)
def test_trace(self):
expected = self._gen_dict_full_gyp()
results = self._execute_trace(self.get_child_command(True))
actual = results.flatten()
self.assertTrue(actual['root'].pop('pid'))
self.assertTrue(actual['root']['children'][0].pop('pid'))
self.assertEqual(expected, actual)
files = [
u'tests/trace_inputs/child1.py'.replace('/', os.path.sep),
u'tests/trace_inputs/child2.py'.replace('/', os.path.sep),
u'tests/trace_inputs/files1/'.replace('/', os.path.sep),
u'tests/trace_inputs/test_file.txt'.replace('/', os.path.sep),
u'tests/trace_inputs_smoke_test.py'.replace('/', os.path.sep),
u'trace_inputs.py',
]
def blacklist(f):
return f.endswith(('.pyc', 'do_not_care.txt', '.git', '.svn'))
simplified = trace_inputs.extract_directories(
trace_inputs.get_native_path_case(unicode(ROOT_DIR)),
results.files,
blacklist)
self.assertEqual(files, [f.path for f in simplified])
def setUp(self):
self.temp_file = None
self.initial_cwd = ROOT_DIR
if sys.platform == 'win32':
# Windows has no kernel mode concept of current working directory.
self.initial_cwd = None
# There's 2 kinds of references to python, self.executable,
# self.real_executable. It depends how python was started and on which OS.
self.executable = unicode(sys.executable)
if sys.platform == 'darwin':
# /usr/bin/python is a thunk executable that decides which version of
# python gets executed.
suffix = '.'.join(map(str, sys.version_info[0:2]))
if os.access(self.executable + suffix, os.X_OK):
# So it'll look like /usr/bin/python2.7
self.executable += suffix
self.real_executable = trace_inputs.get_native_path_case(self.executable)
# Make sure there's no environment variable that could do side effects.
os.environ.pop('GTEST_SHARD_INDEX', '')
os.environ.pop('GTEST_TOTAL_SHARDS', '')
def test_trace(self):
expected = self._gen_dict_full_gyp()
results = self._execute_trace(self.get_child_command(True))
actual = results.flatten()
self.assertTrue(actual['root'].pop('pid'))
self.assertTrue(actual['root']['children'][0].pop('pid'))
self.assertEqual(expected, actual)
files = [
u'tests/trace_inputs/child1.py'.replace('/', os.path.sep),
u'tests/trace_inputs/child2.py'.replace('/', os.path.sep),
u'tests/trace_inputs/files1/'.replace('/', os.path.sep),
u'tests/trace_inputs/test_file.txt'.replace('/', os.path.sep),
u'tests/trace_inputs_smoke_test.py'.replace('/', os.path.sep),
u'trace_inputs.py',
]
def blacklist(f):
return f.endswith(('.pyc', 'do_not_care.txt', '.git', '.svn'))
simplified = trace_inputs.extract_directories(
trace_inputs.get_native_path_case(unicode(ROOT_DIR)),
results.files, blacklist)
self.assertEqual(files, [f.path for f in simplified])
def setUp(self):
self.temp_file = None
self.initial_cwd = ROOT_DIR
if sys.platform == 'win32':
# Windows has no kernel mode concept of current working directory.
self.initial_cwd = None
# There's 2 kinds of references to python, self.executable,
# self.real_executable. It depends how python was started and on which OS.
self.executable = unicode(sys.executable)
if sys.platform == 'darwin':
# /usr/bin/python is a thunk executable that decides which version of
# python gets executed.
suffix = '.'.join(map(str, sys.version_info[0:2]))
if os.access(self.executable + suffix, os.X_OK):
# So it'll look like /usr/bin/python2.7
self.executable += suffix
self.real_executable = trace_inputs.get_native_path_case(
self.executable)
# Make sure there's no environment variable that could do side effects.
os.environ.pop('GTEST_SHARD_INDEX', '')
os.environ.pop('GTEST_TOTAL_SHARDS', '')
def test_simple(self):
file_handle, self.temp_file = tempfile.mkstemp(
prefix='trace_test_cases_test')
os.close(file_handle)
cmd = [
sys.executable,
os.path.join(ROOT_DIR, 'trace_test_cases.py'),
# Forces 4 parallel jobs.
'--jobs', '4',
'--out', self.temp_file,
]
if VERBOSE:
cmd.extend(['-v'] * 3)
cmd.append(TARGET_PATH)
logging.debug(' '.join(cmd))
proc = subprocess.Popen(
cmd,
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
universal_newlines=True,
cwd=ROOT_DIR)
out, err = proc.communicate() or ('', '') # pylint is confused.
self.assertEqual(0, proc.returncode, (out, err))
lines = out.splitlines()
expected_out_re = [
r'Tracing\.\.\.',
r'\[1/4\] +\d+\.\d\ds .+',
r'\[2/4\] +\d+\.\d\ds .+',
r'\[3/4\] +\d+\.\d\ds .+',
r'\[4/4\] +\d+\.\d\ds .+',
r'Reading trace logs\.\.\.',
]
self.assertEqual(len(expected_out_re), len(lines), lines)
for index in range(len(expected_out_re)):
self.assertTrue(
re.match('^%s$' % expected_out_re[index], lines[index]),
'%d: %s\n%r\n%s' % (
index, expected_out_re[index], lines[index], out))
# Junk is printed on win32.
if sys.platform != 'win32' and not VERBOSE:
self.assertEqual('', err)
with open(self.temp_file, 'r') as f:
content = f.read()
try:
result = json.loads(content)
except:
print repr(content)
raise
test_cases = {
'Baz.Fail': 1,
'Foo.Bar1': 0,
'Foo.Bar2': 0,
'Foo.Bar3': 0,
}
self.assertEqual(dict, result.__class__)
self.assertEqual(sorted(test_cases), sorted(result))
for index, test_case in enumerate(sorted(result)):
actual = result[test_case]
self.assertEqual(
[u'duration', u'output', u'returncode', u'trace'], sorted(actual))
self.assertGreater(actual['duration'], 0.0000001)
self.assertEqual(test_cases[test_case], actual['returncode'])
expected_output = (
'Note: Google Test filter = %s\n' % test_case +
'\n' +
gtest_fake_base.get_test_output(test_case) +
'\n' +
gtest_fake_base.get_footer(1, 1) +
'\n')
# On Windows, actual['output'] is unprocessed so it will contain CRLF.
output = actual['output']
if sys.platform == 'win32':
output = output.replace('\r\n', '\n')
self.assertEqual(expected_output, output, repr(output))
expected_trace = {
u'root': {
u'children': [],
u'command': [
self.executable, TARGET_PATH, '--gtest_filter=' + test_case,
],
u'executable': trace_inputs.get_native_path_case(
unicode(self.executable)),
u'initial_cwd': ROOT_DIR,
},
}
if sys.platform == 'win32':
expected_trace['root']['initial_cwd'] = None
self.assertGreater(actual['trace']['root'].pop('pid'), 1)
self.assertGreater(len(actual['trace']['root'].pop('files')), 10)
self.assertEqual(expected_trace, actual['trace'])
def test_native_case_end_with_dot_os_path_sep(self):
path = trace_inputs.get_native_path_case(ROOT_DIR + os.path.sep)
self.assertEqual(
trace_inputs.get_native_path_case(path + '.' + os.path.sep),
path)
def test_native_case_end_with_os_path_sep(self): # Make sure the trailing os.path.sep is kept. path = trace_inputs.get_native_path_case(ROOT_DIR) + os.path.sep self.assertEqual(trace_inputs.get_native_path_case(path), path)
def load(cls, data):
out = super(SavedState, cls).load(data)
if out.isolate_file:
out.isolate_file = trace_inputs.get_native_path_case(out.isolate_file)
return out
def test_simple(self):
file_handle, self.temp_file = tempfile.mkstemp(
prefix='trace_test_cases_test')
os.close(file_handle)
cmd = [
sys.executable,
os.path.join(ROOT_DIR, 'trace_test_cases.py'),
# Forces 4 parallel jobs.
'--jobs',
'4',
'--out',
self.temp_file,
]
if VERBOSE:
cmd.extend(['-v'] * 3)
cmd.append(TARGET_PATH)
logging.debug(' '.join(cmd))
proc = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True,
cwd=ROOT_DIR)
out, err = proc.communicate() or ('', '') # pylint is confused.
self.assertEqual(0, proc.returncode, (out, err))
lines = out.splitlines()
expected_out_re = [
r'Tracing\.\.\.',
r'\[1/4\] +\d+\.\d\ds .+',
r'\[2/4\] +\d+\.\d\ds .+',
r'\[3/4\] +\d+\.\d\ds .+',
r'\[4/4\] +\d+\.\d\ds .+',
r'Reading trace logs\.\.\.',
]
self.assertEqual(len(expected_out_re), len(lines), lines)
for index in range(len(expected_out_re)):
self.assertTrue(
re.match('^%s$' % expected_out_re[index],
lines[index]), '%d: %s\n%r\n%s' %
(index, expected_out_re[index], lines[index], out))
# Junk is printed on win32.
if sys.platform != 'win32' and not VERBOSE:
self.assertEqual('', err)
with open(self.temp_file, 'r') as f:
content = f.read()
try:
result = json.loads(content)
except:
print repr(content)
raise
test_cases = {
'Baz.Fail': 1,
'Foo.Bar1': 0,
'Foo.Bar2': 0,
'Foo.Bar3': 0,
}
self.assertEqual(dict, result.__class__)
self.assertEqual(sorted(test_cases), sorted(result))
for index, test_case in enumerate(sorted(result)):
actual = result[test_case]
self.assertEqual([u'duration', u'output', u'returncode', u'trace'],
sorted(actual))
self.assertGreater(actual['duration'], 0.0000001)
self.assertEqual(test_cases[test_case], actual['returncode'])
expected_output = ('Note: Google Test filter = %s\n' % test_case +
'\n' + gtest_fake_base.get_test_output(
test_case, 'Fail' in test_case) + '\n' +
gtest_fake_base.get_footer(1, 1) + '\n')
# On Windows, actual['output'] is unprocessed so it will contain CRLF.
output = actual['output']
if sys.platform == 'win32':
output = output.replace('\r\n', '\n')
self.assertEqual(expected_output, output, repr(output))
expected_trace = {
u'root': {
u'children': [],
u'command': [
self.executable,
TARGET_PATH,
'--gtest_filter=' + test_case,
],
u'executable':
trace_inputs.get_native_path_case(unicode(
self.executable)),
u'initial_cwd':
ROOT_DIR,
},
}
if sys.platform == 'win32':
expected_trace['root']['initial_cwd'] = None
self.assertGreater(actual['trace']['root'].pop('pid'), 1)
self.assertGreater(len(actual['trace']['root'].pop('files')), 10)
self.assertEqual(expected_trace, actual['trace'])
