Split (1)

train · 303k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

rem stringlengths 0 322k	add stringlengths 0 2.05M	context stringlengths 8 228k
with codecs.open(expectations_file, "r", "utf-8") as file:	with codecs.open(expectations_path, "r", "utf-8") as file:	def test_expectations(self): """Returns the test expectations for this port.
overrides_file = self.path_from_chromium_base('webkit', 'tools',	overrides_path = self.path_from_chromium_base('webkit', 'tools',	def test_expectations_overrides(self): try: overrides_file = self.path_from_chromium_base('webkit', 'tools', 'layout_tests', 'test_expectations.txt') except AssertionError: return None if not os.path.exists(overrides_file): return None with codecs.open(overrides_file, "r", "utf-8") as file return file.read()
if not os.path.exists(overrides_file):	if not os.path.exists(overrides_path):	def test_expectations_overrides(self): try: overrides_file = self.path_from_chromium_base('webkit', 'tools', 'layout_tests', 'test_expectations.txt') except AssertionError: return None if not os.path.exists(overrides_file): return None with codecs.open(overrides_file, "r", "utf-8") as file return file.read()
with codecs.open(overrides_file, "r", "utf-8") as file	with codecs.open(overrides_path, "r", "utf-8") as file:	def test_expectations_overrides(self): try: overrides_file = self.path_from_chromium_base('webkit', 'tools', 'layout_tests', 'test_expectations.txt') except AssertionError: return None if not os.path.exists(overrides_file): return None with codecs.open(overrides_file, "r", "utf-8") as file return file.read()
return self._executive.run_command(command)	try: return self._executive.run_command(command) except OSError, e: _pretty_patch_available = False return "Failed to run PrettyPatch: %s" % e	def pretty_patch_text(self, diff_path): pretty_patch_path = self.path_from_webkit_base("BugsSite", "PrettyPatch") prettify_path = os.path.join(pretty_patch_path, "prettify.rb") command = ["ruby", "-I", pretty_patch_path, prettify_path, diff_path] return self._executive.run_command(command)
gl_func_name = func.GetGLFunctionName() if gl_func_name.startswith("gl"): gl_func_name = gl_func_name[2:] else: gl_func_name = func.name	gl_func_name = func.GetGLTestFunctionName()	def WriteInvalidUnitTest(self, func, file, test, extra = {}): """Writes a invalid unit test.""" arg_index = 0 for arg in func.GetOriginalArgs(): num_invalid_values = arg.GetNumInvalidValues() for value_index in range(0, num_invalid_values): arg_strings = [] parse_result = "kNoError" count = 0 for arg in func.GetOrigina...
def _write_into_file_at_path(self, file_path, byte_array): """This method assumes that byte_array is already encoded into the right format.""" with open(file_path, "wb") as file: file.write(byte_array)	def _write_into_file_at_path(self, file_path, contents, encoding=None): """Writes contents at file_path, using encoding.""" with codecs.open(file_path, "w", encoding) as file: file.write(contents)	def _write_into_file_at_path(self, file_path, byte_array): """This method assumes that byte_array is already encoded into the right format.""" with open(file_path, "wb") as file: file.write(byte_array)
self._write_into_file_at_path(actual_filename, output)	self._write_into_file_at_path(actual_filename, output, encoding)	def write_output_files(self, port, filename, file_type, output, expected, print_text_diffs=False): """Writes the test output, the expected output and optionally the diff between the two to files in the results directory.
self._write_into_file_at_path(expected_filename, expected)	self._write_into_file_at_path(expected_filename, expected, encoding)	def write_output_files(self, port, filename, file_type, output, expected, print_text_diffs=False): """Writes the test output, the expected output and optionally the diff between the two to files in the results directory.
self._write_into_file_at_path(diff_filename, diff.encode("utf-8"))	self._write_into_file_at_path(diff_filename, diff, encoding="utf-8")	def write_output_files(self, port, filename, file_type, output, expected, print_text_diffs=False): """Writes the test output, the expected output and optionally the diff between the two to files in the results directory.
self._write_into_file_at_path(wdiff_filename, wdiff.encode("utf-8"))	self._write_into_file_at_path(wdiff_filename, wdiff, encoding="utf-8")	def write_output_files(self, port, filename, file_type, output, expected, print_text_diffs=False): """Writes the test output, the expected output and optionally the diff between the two to files in the results directory.
self._write_into_file_at_path(pretty_patch_filename, pretty_patch.encode("utf-8"))	self._write_into_file_at_path(pretty_patch_filename, pretty_patch, encoding="utf-8")	def write_output_files(self, port, filename, file_type, output, expected, print_text_diffs=False): """Writes the test output, the expected output and optionally the diff between the two to files in the results directory.
class _GTestTextTestResult(unittest._TextTestResult): """A test result class that can print formatted text results to a stream. Results printed in conformance with gtest output format, like: [ RUN ] autofill.AutoFillTest.testAutofillInvalid: "test desc." [ OK ] autofill.AutoFillTest.testAutofillInvalid ...		def __del__(self): # python unittest module is setup such that the suite gets deleted before # the test cases, which is odd because our test cases depend on # initializtions like exitmanager, autorelease pool provided by the # suite. Forcibly delete the test cases before the suite. del self._tests pyautolib.PyUITestSui...
result = PyAutoTextTestRuner(verbosity=verbosity).run(pyauto_suite)	result = unittest.TextTestRunner(verbosity=verbosity).run(pyauto_suite)	def _Run(self): """Run the tests.""" if self._options.wait_for_debugger: raw_input('Attach debugger to process %s and hit <enter> ' % os.getpid())
def __init__(self):	def __init__(self, path):	def __init__(self): MultiCommandTool.__init__(self)
return __file__	return self._path	def path(self): return __file__
result = unittest.TextTestRunner(verbosity=verbosity).run(pyauto_suite)	result = PyAutoTextTestRuner(verbosity=verbosity).run(pyauto_suite)	def _Run(self): """Run the tests.""" if self._options.wait_for_debugger: raw_input('Attach debugger to process %s and hit <enter> ' % os.getpid())
if index or self.crashed or self.timed_out:	if index > 0 or self.crashed or self.timed_out:	def _read(self, timeout, size): """Internal routine that actually does the read.""" index = -1 out_fd = self._proc.stdout.fileno() err_fd = self._proc.stderr.fileno() select_fds = (out_fd, err_fd) deadline = time.time() + timeout while not self.timed_out and not self.crashed: # poll() is not threadsafe and can throw OS...
def __init__(self, port, platform, options): self._file_dir = port.path_from_chromium_base('webkit', 'tools', 'layout_tests') self._port = port	def __init__(self, running_port, platform, options): self._file_dir = running_port.path_from_chromium_base( 'webkit', 'tools', 'layout_tests')	def __init__(self, port, platform, options): self._file_dir = port.path_from_chromium_base('webkit', 'tools', 'layout_tests') self._port = port self._platform = platform self._options = options self._rebaselining_tests = [] self._rebaselined_tests = []
expectations_str = self._port.test_expectations()	expectations_str = self._rebaseline_port.test_expectations()	def __init__(self, port, platform, options): self._file_dir = port.path_from_chromium_base('webkit', 'tools', 'layout_tests') self._port = port self._platform = platform self._options = options self._rebaselining_tests = [] self._rebaselined_tests = []
test_expectations.TestExpectations(self._port,	test_expectations.TestExpectations(self._rebaseline_port,	def __init__(self, port, platform, options): self._file_dir = port.path_from_chromium_base('webkit', 'tools', 'layout_tests') self._port = port self._platform = platform self._options = options self._rebaselining_tests = [] self._rebaselined_tests = []
platform = self._port.test_platform_name_to_name(self._platform)	platform = self._rebaseline_port.test_platform_name_to_name( self._platform)	def _extract_and_add_new_baselines(self, archive_file): """Extract new baselines from archive and add them to SVN repository.
all_baselines = self._port.expected_baselines(test_filepath, suffix, True)	all_baselines = self._rebaseline_port.expected_baselines( test_filepath, suffix, True)	def _is_dup_baseline(self, new_baseline, baseline_path, test, suffix, platform): """Check whether a baseline is duplicate and can fallback to same baseline for another platform. For example, if a test has same baseline on linux and windows, then we only store windows baseline and linux baseline will fallback to the win...
if 'delta' not in perf_data[key] or 'var' not in perf_data[key]: bad_keys.append(key) if (not isinstance(perf_data[key]['delta'], int) and not isinstance(perf_data[key]['delta'], float)): bad_keys.append(key) if (not isinstance(perf_data[key]['var'], int) and not isinstance(perf_data[key]['var'], float)): bad_keys.appe...	if 'regress' in perf_data[key]: if 'improve' not in perf_data[key]: bad_keys.append(key) if (not isinstance(perf_data[key]['regress'], int) and not isinstance(perf_data[key]['regress'], float)): bad_keys.append(key) if (not isinstance(perf_data[key]['improve'], int) and not isinstance(perf_data[key]['improve'], float))...	def testPerfExpectations(self): perf_data = LoadData()
self._source_dir = layout_package.path_utils.GetAbsolutePath(	self._source_dir = layout_package.path_utils.get_absolute_path(	def __init__(self, options, args, test): # The known list of tests. # Recognise the original abbreviations as well as full executable names. self._test_list = { "base": self.TestBase, "base_unittests": self.TestBase, "browser": self.TestBrowser, "browser_tests": self.TestBrowser, "googleurl": self.TestG...
file_path = os.path.join(output_dir, ARCHIVE_DIR)	prefixed_archive_dir = (options.archive_prefix or "") + ARCHIVE_DIR file_path = os.path.join(output_dir, prefixed_archive_dir)	def MakeStagingDirectories(output_dir): """Creates a staging path for installer archive. If directory exists already, deletes the existing directory. """ file_path = os.path.join(output_dir, ARCHIVE_DIR) if os.path.exists(file_path): shutil.rmtree(file_path) os.makedirs(file_path) temp_file_path = os.path.join(output_...
temp_file_path = os.path.join(output_dir, TEMP_ARCHIVE_DIR)	prefixed_temp_archive_dir = (options.archive_prefix or "") + TEMP_ARCHIVE_DIR temp_file_path = os.path.join(output_dir, prefixed_temp_archive_dir)	def MakeStagingDirectories(output_dir): """Creates a staging path for installer archive. If directory exists already, deletes the existing directory. """ file_path = os.path.join(output_dir, ARCHIVE_DIR) if os.path.exists(file_path): shutil.rmtree(file_path) os.makedirs(file_path) temp_file_path = os.path.join(output_...
ret[new_name] = (correct_semantic_case(semantic) if semantic else old_name_and_type.split(' ')[2])	if semantic: ret[new_name] = correct_semantic_case(semantic) else: ret[new_name] = old_name_and_type.split(' ')[2]	def get_input_mapping(header): ret = dict() for l in header.splitlines(): if not l.startswith('//var'): continue old_name_and_type, semantic, new_name, _, _ = l.split(' : ') if '[' in new_name: new_name = new_name[:new_name.index('[')] if new_name.startswith('$'): new_name = new_name[1:] ret[new_name] = (correct_semant...
header, body = re.split(os.linesep*2, glsl_shader, 1) assert all(l.startswith('//') for l in header.splitlines())	if '\r\n' in glsl_shader: header, body = re.split('\r\n'2, glsl_shader, 1) else: header, body = re.split(os.linesep2, glsl_shader, 1) for l in header.splitlines(): assert l.startswith('//')	def fix_glsl(glsl_shader): header, body = re.split(os.linesep*2, glsl_shader, 1) assert all(l.startswith('//') for l in header.splitlines()) input_mapping = get_input_mapping(header) return header + '\n\n' + fix_glsl_body(body, input_mapping)
f = sys.stdin if options.file is None else open(options.file)	if options.file is None: f = sys.stdin else: f = open(options.file)	def main(cg_shader): matrixloadorder = get_matrixloadorder(cg_shader) glsl_vertex, glsl_fragment, log = cg_to_glsl(cg_shader) print log print fix_glsl(glsl_vertex) print print '// #o3d SplitMarker' print get_matrixloadorder(cg_shader).strip() print print fix_glsl(glsl_fragment)
("PageLoadTests", []),	("PerformanceTests", []),	def _should_file_trigger_build(target_platform, file): # The directories and patterns lists below map directory names or # regexp patterns to the bot platforms for which they should trigger a # build. Mapping to the empty list means that no builds should be # triggered on any platforms. Earlier directories/patterns tak...
src_dir = sys.argv[0]; if sys.platform != 'cygwin': src_dir = os.path.abspath(sys.argv[0]) print src_dir src_dir=os.path.join(os.path.dirname(os.path.dirname(os.path.dirname( os.path.dirname(src_dir)))))	src_dir = os.path.abspath(os.path.join(sys.path[0], '..', '..', '..'))	def main(): cmd = [sys.executable] src_dir = sys.argv[0]; if sys.platform != 'cygwin': src_dir = os.path.abspath(sys.argv[0]) print src_dir src_dir=os.path.join(os.path.dirname(os.path.dirname(os.path.dirname( os.path.dirname(src_dir))))) script_dir=os.path.join(src_dir, "third_party", "WebKit", "WebKitTools", "Scripts...
startup_pipe.write(struct.pack('@H', listen_port))	startup_pipe.write(struct.pack('=L', server_data_len)) startup_pipe.write(server_data_json)	def main(options, args): logfile = open('testserver.log', 'w') sys.stdout = FileMultiplexer(sys.stdout, logfile) sys.stderr = FileMultiplexer(sys.stderr, logfile) port = options.port if options.server_type == SERVER_HTTP: if options.cert: # let's make sure the cert file exists. if not os.path.isfile(options.cert): pr...
return self.path_from_chromium_base('webkit', 'tools', 'layout_tests', 'test_expectations.txt')	return self.path_from_webkit_base('LayoutTests', 'platform', 'chromium', 'test_expectations.txt')	def path_to_test_expectations_file(self): return self.path_from_chromium_base('webkit', 'tools', 'layout_tests', 'test_expectations.txt')
if splitter >= 0 and not string[splitter + 1] == '=':	if splitter >= 0 and not string[splitter + 1] == '=' and splitter < 80:	def __FindSplit(self, string): """Finds a place to split a string.""" splitter = string.find('=') if splitter >= 0 and not string[splitter + 1] == '=': return splitter parts = string.split('(') if len(parts) > 1: splitter = len(parts[0]) for ii in range(1, len(parts)): if not parts[ii - 1][-3:] == "if ": return splitte...
if not parts[ii - 1][-3:] == "if ":	if (not parts[ii - 1][-3:] == "if " and (len(parts[ii]) > 0 and not parts[ii][0] == ")") and splitter < 80):	def __FindSplit(self, string): """Finds a place to split a string.""" splitter = string.find('=') if splitter >= 0 and not string[splitter + 1] == '=': return splitter parts = string.split('(') if len(parts) > 1: splitter = len(parts[0]) for ii in range(1, len(parts)): if not parts[ii - 1][-3:] == "if ": return splitte...
file.Write(" EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT\n")	file.Write(" EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);\n")	def WriteCmdSizeTest(self, func, file): """Writes the size test for a command.""" file.Write(" EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT\n")
file.Write(" void Init(%s) {\n" % func.MakeTypedCmdArgString("_")) file.Write(" SetHeader(0); // TODO(gman): pass in correct size\n") args = func.GetCmdArgs() for arg in args: file.Write(" %s = _%s;\n" % (arg.name, arg.name)) file.Write(" }\n") file.Write("\n")	raise Error	def WriteImmediateCmdInit(self, func, file): """Writes the Init function for the immediate version of a command.""" file.Write(" void Init(%s) {\n" % func.MakeTypedCmdArgString("_")) file.Write(" SetHeader(0); // TODO(gman): pass in correct size\n") args = func.GetCmdArgs() for arg in args: file.Write(" %s = _%...
copy_args = func.MakeCmdArgString("_", False) file.Write(" void* Set(void* cmd%s) {\n" % func.MakeTypedCmdArgString("_", True)) file.Write(" // TODO(gman): compute correct size.\n") file.Write(" const uint32 size = ComputeSize(0);\n") file.Write(" static_cast<ValueType*>(cmd)->Init(%s);\n" % copy_args) file.W...	raise Error	def WriteImmediateCmdSet(self, func, file): """Writes the Set function for the immediate version of a command.""" copy_args = func.MakeCmdArgString("_", False) file.Write(" void* Set(void* cmd%s) {\n" % func.MakeTypedCmdArgString("_", True)) file.Write(" // TODO(gman): compute correct size.\n") file.Write(" cons...
file.Write(" GenGLObjects<GL%sHelper>(n, %s);\n" %	file.Write(" if (!GenGLObjects<GL%sHelper>(n, %s)) {\n" " return parse_error::kParseInvalidArguments;\n" " }\n" %	def WriteHandlerImplementation (self, func, file): """Overrriden from TypeHandler.""" file.Write(" GenGLObjects<GL%sHelper>(n, %s);\n" % (func.name, func.GetLastOriginalArg().name))