137353 2014-10-02 12:27:33 -0700 Add --json flag to test-webkitpy to emit JSON formatted test results on stdout 2014-10-15 13:56:22 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 jake.nielsen.webkit jake.nielsen.webkit cjerdonek commit-queue dbates glenn oldest_to_newest 1038939 0 jake.nielsen.webkit 2014-10-02 12:27:33 -0700 test-webkitpy can optionally take in --results-dir and put a json file outlining its results into the specified directory 1039095 1 239171 jake.nielsen.webkit 2014-10-02 18:49:29 -0700 Created attachment 239171 Adds the appropriate mechanisms to allow test-webkitpy to generate a json file of its results in a specified directory 1039097 2 commit-queue 2014-10-02 18:52:02 -0700 Attachment 239171 did not pass style-queue: ERROR: Tools/Scripts/webkitpy/test/results.py:26: expected 2 blank lines, found 1 [pep8/E302] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:27: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:28: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:29: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:31: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:32: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:33: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:34: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:35: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:36: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:38: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:39: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:40: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:41: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:43: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:44: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:46: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:47: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:49: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:50: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:54: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:55: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:56: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:57: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:59: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:60: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:61: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:62: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:64: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:65: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:67: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:68: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:70: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:71: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:73: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:74: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:76: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:77: indentation contains tabs [pep8/W191] [5] ERROR: Tools/Scripts/webkitpy/test/results.py:78: blank line at end of file [pep8/W391] [5] Total errors found: 39 in 9 files If any of these errors are false positives, please file a bug against check-webkit-style. 1039099 3 239173 jake.nielsen.webkit 2014-10-02 19:01:29 -0700 Created attachment 239173 Fixes help message for --results-dir option, and addresses stylebot's issues 1039239 4 239173 dbates 2014-10-03 09:50:39 -0700 Comment on attachment 239173 Fixes help message for --results-dir option, and addresses stylebot's issues I'm unclear of the motivation for this change from reading the bug description (comment #0) and change log entry. Can you elaborate on it, including the intended audience of the JSON file? 1039284 5 jake.nielsen.webkit 2014-10-03 11:42:59 -0700 (In reply to comment #4) > (From update of attachment 239173 [details]) > I'm unclear of the motivation for this change from reading the bug description (comment #0) and change log entry. Can you elaborate on it, including the intended audience of the JSON file? Sure. We want the webkit buildbot page (and in particular results.html) to be able to display the results of the python unit tests. We want EWS bubbles for them as well. JSC and webkit-perl tests are going to follow suite as well. 1039325 6 239227 jake.nielsen.webkit 2014-10-03 13:43:47 -0700 Created attachment 239227 Removes the TestResult(s) class. 1039346 7 239227 dbates 2014-10-03 14:23:24 -0700 Comment on attachment 239227 Removes the TestResult(s) class. View in context: https://bugs.webkit.org/attachment.cgi?id=239227&action=review > Tools/ChangeLog:7 > + We should add a description to this change log entry that describers the reasoning behind this change based on your remark in comment #5 because the bug title doesn't explain the reasoning for this change. > Tools/Scripts/webkitpy/common/webkit_finder.py:39 > + def webkit_results_dir(self): > + path_to_build_dir = self._filesystem.join(self.webkit_base(), "WebKitBuild") > + configuration_dir = self._filesystem.read_text_file(self._filesystem.join(path_to_build_dir, "Configuration")) > + return self._filesystem.join(path_to_build_dir, configuration_dir) > + This will not work for people that specify a custom build directory path using the environment variable WEBKIT_OUTPUTDIR (see second paragraph on <http://www.webkit.org/building/build.html>). Notice we have existing logic to compute the correct build directory in Config.build_directory(). Can we make use of this functionality? > Tools/Scripts/webkitpy/test/main.py:108 > + parser.add_option('-r', '--results-dir', action='store', default="", I don't see the value in abbreviating the word "directory" as "dir". Moreover, --results-dir is inconsistent with the naming of the command line option --results-directory used in existing tools for a similar purpose, including run-webkit-tests. > Tools/Scripts/webkitpy/test/main.py:109 > + help='specifies a directory in which to generate a json file that contains the results of the tests') Nit: json => JSON (JSON is an acronym for JavaScript Object Notation). 1039646 8 239311 jake.nielsen.webkit 2014-10-05 19:58:54 -0700 Created attachment 239311 Adds the results.py file back (with significant changes) and adds results_unittest.py After some discussion with Dan in person, we decided that since the class in results.py will be reused very shortly, it's worth including in this patch. 1039647 9 239311 jake.nielsen.webkit 2014-10-05 19:59:57 -0700 Comment on attachment 239311 Adds the results.py file back (with significant changes) and adds results_unittest.py Didn't address all of Dan's comments. 1039651 10 jake.nielsen.webkit 2014-10-05 21:43:00 -0700 Constructing this Config object is taking a lot longer than I though it would. I'll come back to this tomorrow. 1039779 11 239345 jake.nielsen.webkit 2014-10-06 11:57:32 -0700 Created attachment 239345 Adds Config object logic, and changes runtest.py to make sure it doesn't accidentally circumvent mock injection 1040237 12 239345 dbates 2014-10-08 01:40:34 -0700 Comment on attachment 239345 Adds Config object logic, and changes runtest.py to make sure it doesn't accidentally circumvent mock injection View in context: https://bugs.webkit.org/attachment.cgi?id=239345&action=review > Tools/ChangeLog:8 > + The webkit buildbot page's results.html file should contain results Nit: webkit => WebKit > Tools/ChangeLog:9 > + for the python unit tests (and soon to be others), as should the EWS Nit: python => Python > Tools/ChangeLog:31 > + in an equivelant TestSuiteResults object. Nit: equivelant => equivalent > Tools/Scripts/webkitpy/test/main.py:78 > + self._filesystem = filesystem or FileSystem() Notice that Finder stores the passed FileSystem object in the public instance variable, Finder.filesystem. It seems sufficient to go through Finder to get the FileSystem object instead of explicitly storing a reference to it in a private instance variable (i.e. self.finder.filesystem). > Tools/Scripts/webkitpy/test/main.py:107 > + parser.add_option('-r', '--results-directory', action='store', default="", Nit: " => ' (double quote) to (single quote) for the empty string literal defined as the default value of parameter default. > Tools/Scripts/webkitpy/test/main.py:170 > + self._filesystem.write_text_file(self._filesystem.join(self._options.results_directory, "results.json"), test_runner.test_suite_results.test_suite_results_to_json_string()) Nit: " => ' (double quote) to (single quotes) for the string literal 'results.json'. > Tools/Scripts/webkitpy/test/results.py:26 > +class TestSuiteResults(object): This class is OK as-is. Having said that it seems sufficient to have non-member functions that deserialize and serialize test result data as opposed to defining a class with such functionality. > Tools/Scripts/webkitpy/test/results.py:44 > + test_result_dict['did_pass'] = test_result_tuple[1] I take it that did_pass cannot be inferred from the values of failure_messages and error_messages? > Tools/Scripts/webkitpy/test/results.py:54 > + self.list_of_test_results = initial_list_of_test_results Would it make sense to make self.list_of_test_results a private instance variable? Or remove list_of_failed_test_results() and list_of_errored_test_results()? I mean, it seems unnecessary to both expose all the tests and provide convenience methods to filter the tests as a client can perform the filtering themselves. > Tools/Scripts/webkitpy/test/runner.py:59 > + self.test_suite_results.add_test_result(test_name=test_name, did_pass=not bool(failures + errors), failure_messages=failures, error_messages=errors) Nit: I suggest removing the parameter name for the first argument (test_name) as its purpose is clear from the name of its argument (the local variable named test_name): self.test_suite_results.add_test_result(test_name, did_pass=not bool(failures + errors), failure_messages=failures, error_messages=errors) See my question about did_pass in TestSuiteResults.test_suite_results_to_json_string(). If did_pass can be inferred from the values of failure_messages and error_messages then we can further simplify this line of code. > Tools/Scripts/webkitpy/tool/steps/runtests.py:73 > + filesystem = self._tool.filesystem > + port_name = self._tool.deprecated_port().name() > + > + if not type(port_name) is str: > + port_name = port_name.__name__ > + > + config = Config(self._tool.executive, filesystem, port_name) > + > + python_unittests_results_dir = filesystem.join(config.build_directory(config.default_configuration()), "python-unittest-results") > + filesystem.maybe_make_directory(python_unittests_results_dir) > > python_unittests_command = self._tool.deprecated_port().run_python_unittests_command() > + python_unittests_command.append("--results-directory") > + python_unittests_command.append(python_unittests_results_dir) > + I envisioned calling Config.build_directory() through an instance of class Port. In particular, I envisioned adding a method to class Port similar to Port.default_results_directory(), say Port.python_unittest_results_directory(), that returned the path to the Python unit tests results directory: def python_unittest_results_directory(self): return self._build_path('python-unittest-results') Then we can write this code to have the form: ... if not self._options.non_interactive: filesystem = self._tool.filesystem python_unittest_results_directory = self._tool.port_factory.get().python_unittest_results_directory() filesystem.maybe_make_directory(python_unittests_results_dir) # FIXME: We should teach the commit-queue and the EWS how to run these tests. python_unittests_command = self._tool.deprecated_port().run_python_unittests_command() python_unittests_command.extend(['--results-directory', python_unittest_results_directory]) ... If we have Tools/Scripts/webkitpy/test/main.py create the specified results directory (if it does not already exist) then we can remove the call to FileSystem.maybe_make_directory() and simplify this code to have the form: ... if not self._options.non_interactive: # FIXME: We should teach the commit-queue and the EWS how to run these tests. python_unittests_command = self._tool.deprecated_port().run_python_unittests_command() python_unittests_command.extend(['--results-directory', self._tool.port_factory.get().python_unittest_results_directory()]) ... 1040418 13 dbates 2014-10-08 14:49:13 -0700 I thought about the approach proposed by this patch some more. Notice that the Python unit test runner has an existing abstraction (webkitpy.test.Printer) for formatting and writing test result output. Can we make use of the class webkitpy.test.Printer to support emitting JSON output? In particular, can we either extend the class webkitpy.test.Printer to support emitting JSON-formatted output or define a subclass of it than does such formatting? 1041079 14 239662 jake.nielsen.webkit 2014-10-10 17:44:53 -0700 Created attachment 239662 Changes to the --json flag solution to the problem, as discussed in person. 1041095 15 239662 dbates 2014-10-10 20:45:12 -0700 Comment on attachment 239662 Changes to the --json flag solution to the problem, as discussed in person. View in context: https://bugs.webkit.org/attachment.cgi?id=239662&action=review > Tools/Scripts/webkitpy/test/main.py:120 > + self.printer = JSONPrinter(self._stream_override or sys.stdout, self._options) How did you come the decision to emit the JSON output to standard output by default given that we emit the human readable output to standard error by default? > Tools/Scripts/webkitpy/test/main.py:124 > + self.printer.print_started_test_suite("Python Unit Tests") How did you come to the decision to emit this text? > Tools/Scripts/webkitpy/test/printers/human_readable_printer.py:111 > + elif not test_did_pass: > + lines = [] > + suffix = ' failed' > + self.num_failures += 1 We will never execute this code since we handle the cases when failures and errors are non-empty lists (above) and "not test_did_pass" only evaluates to true if either failures or errors is a non-empty list. > Tools/Scripts/webkitpy/test/printers/json_printer.py:76 > + def print_started_test_suite(self, test_suite_name): > + self.stream.write("{") > + self.stream.write("\"suite_name\" : \"%s\",\n" % test_suite_name) > + self.stream.write("\"list_of_tests\" : [\n") > + > + def write_update(self, msg): > + pass > + > + def print_started_test(self, source, test_name): > + pass > + > + def print_finished_test(self, source, test_name, test_did_pass, test_time, failures, errors): > + self._number_of_tests_run += 1 > + if not self._first_test_flag: > + self.stream.write(",\n") > + > + test_dict = {} > + test_dict["test_name"] = test_name > + test_dict["test_did_pass"] = test_did_pass > + test_dict["failures"] = failures > + test_dict["errors"] = errors > + > + self.stream.write(json.dumps(test_dict)) > + > + self._first_test_flag = False > + > + def print_result(self, run_time): > + self.stream.write("],\n\"test_run_time\" : %s,\n\"number_of_tests_run\" : %s}" % (run_time, self._number_of_tests_run)) How did you come to the decision to piecewise write the JSON data to the stream? I suggest that we build the test_dict structure in memory and then implement print_result() to write the result of json.dump(test_dict) to stream self.stream. The benefit of this approach is that we do not need to explicitly emit any JSON markup ourself in print_started_test_suite() or print_finished_test(), which is brittle and error prone. > Tools/Scripts/webkitpy/test/runner.py:65 > + self.printer.print_finished_test(source, test_name, not bool(failures + errors), delay, failures, errors) I don't see the value of the new argument, tests_did_pass, given that the printer is passed the list of failures and errors and can compute tests_did_pass itself. 1041289 16 jake.nielsen.webkit 2014-10-13 10:00:45 -0700 (In reply to comment #15) > (From update of attachment 239662 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=239662&action=review > > > Tools/Scripts/webkitpy/test/main.py:120 > > + self.printer = JSONPrinter(self._stream_override or sys.stdout, self._options) > > How did you come the decision to emit the JSON output to standard output by default given that we emit the human readable output to standard error by default? This is a pretty standard choice for command line tools that you expect to be redirecting to files or piping to other programs. It allows errors to still be reported on stderr without malforming the JSON. > > > Tools/Scripts/webkitpy/test/main.py:124 > > + self.printer.print_started_test_suite("Python Unit Tests") > > How did you come to the decision to emit this text? The JSON file should have some notion of what test suite it originated from. This is the way I chose to do it. in the results.py solution this was part of the constructor. > > > Tools/Scripts/webkitpy/test/printers/human_readable_printer.py:111 > > + elif not test_did_pass: > > + lines = [] > > + suffix = ' failed' > > + self.num_failures += 1 > > We will never execute this code since we handle the cases when failures and errors are non-empty lists (above) and "not test_did_pass" only evaluates to true if either failures or errors is a non-empty list. We won't here, but we will in the bindings test. The bindings test has no notion of failures and errors, only whether a test passed or not. > > > Tools/Scripts/webkitpy/test/printers/json_printer.py:76 > > + def print_started_test_suite(self, test_suite_name): > > + self.stream.write("{") > > + self.stream.write("\"suite_name\" : \"%s\",\n" % test_suite_name) > > + self.stream.write("\"list_of_tests\" : [\n") > > + > > + def write_update(self, msg): > > + pass > > + > > + def print_started_test(self, source, test_name): > > + pass > > + > > + def print_finished_test(self, source, test_name, test_did_pass, test_time, failures, errors): > > + self._number_of_tests_run += 1 > > + if not self._first_test_flag: > > + self.stream.write(",\n") > > + > > + test_dict = {} > > + test_dict["test_name"] = test_name > > + test_dict["test_did_pass"] = test_did_pass > > + test_dict["failures"] = failures > > + test_dict["errors"] = errors > > + > > + self.stream.write(json.dumps(test_dict)) > > + > > + self._first_test_flag = False > > + > > + def print_result(self, run_time): > > + self.stream.write("],\n\"test_run_time\" : %s,\n\"number_of_tests_run\" : %s}" % (run_time, self._number_of_tests_run)) > > How did you come to the decision to piecewise write the JSON data to the stream? I suggest that we build the test_dict structure in memory and then implement print_result() to write the result of json.dump(test_dict) to stream self.stream. The benefit of this approach is that we do not need to explicitly emit any JSON markup ourself in print_started_test_suite() or print_finished_test(), which is brittle and error prone. I'll go change that. > > > Tools/Scripts/webkitpy/test/runner.py:65 > > + self.printer.print_finished_test(source, test_name, not bool(failures + errors), delay, failures, errors) > > I don't see the value of the new argument, tests_did_pass, given that the printer is passed the list of failures and errors and can compute tests_did_pass itself. In this test, you're correct, it's redundant. In the bindings tests it's not. 1041333 17 239739 jake.nielsen.webkit 2014-10-13 12:58:46 -0700 Created attachment 239739 Changes to use the _print_results_as_json method, as discussed in person. 1041379 18 239739 dbates 2014-10-13 15:27:23 -0700 Comment on attachment 239739 Changes to use the _print_results_as_json method, as discussed in person. View in context: https://bugs.webkit.org/attachment.cgi?id=239739&action=review > Tools/ChangeLog:4 > + on stdout Nit: on => to > Tools/ChangeLog:11 > + Adds the read method to MockFile to allow the stdout of test_webkitpy > + to be redirected without causing erroneous test failures. For you consideration, I suggest adding a remark about the test(s) that failed without this change. > Tools/Scripts/webkitpy/port/server_process_unittest.py:71 > + # This means EOF Although it can be implied that this comment is with respect to the line above it given the length of the body of this function, it would be better to be explicit about this relationship and either move the comment to actually be above the return statement (line 70) or inline the comment on the same line as the return statement. You may also want to consider writing out End of file instead of abbreviating it as EOF to be explicit even though I suspect our audience is familiar with the abbreviation of EOF to mean End of file. > Tools/Scripts/webkitpy/test/main.py:36 > import time > import traceback > import unittest > +import operator > +import json Please order the imports in this file such that they are sorted according to the output of the UNIX sort command. > Tools/Scripts/webkitpy/test/main.py:108 > + help='emit JSON formatted test results on stdout') Nit: on => to The word "emit" in this help message can be taken as a synonym for the verb "output". I suggest that we use the word "write" instead of the word "emit" to refer to the action of writing JSON output so as to be consistent with the language suggested for the word "output" on p.114 of the Apple Style Guide (April 2013), <https://help.apple.com/asg/mac/2013/ASG_2013.pdf>. > Tools/Scripts/webkitpy/test/main.py:128 > + def _print_results_as_json(self, stream, test_names, failures, errors): It is sufficient to make this a non-member function. I don't see the need to make this a member function that takes a parameter called self as this method does not make use of any instance data. > Tools/Scripts/webkitpy/test/main.py:135 > + results['tests'] = sorted(test_names) :( It is OK to include a list of the names of all the tests we ran assuming we address the inefficiency of this line (see my remark on line 176 for more details). I wish we could avoid including such a list in the JSON output as it guarantees that the size of the JSON file is at least proportional to the total number of tests ran. In contrast, the JSON output for the layout tests results, full_results.json, is proportional to the number of tests that failed (including flaky tests). I know you mentioned in person today (10/13) that you felt that knowing the names of all tests than ran is necessary to identify flaky tests. It would great if we could find a way to identify flaky tests without having to include the names of all the tests that ran in the JSON output. Can we derived this data from the list of tests that failed (failures), the list of the tests that had a Python error (errors) and/or other metrics? Notice that we have logic to identify flaky tests when generating the layout test results JSON output without necessitating inserting a list of the names of all the tests that ran in the JSON output. You mentioned you were unhappy with this approach, but I don't recall the reason. It would be beneficial to understand how the shortcomings (what are they?) of the test flakiness detection we use for layout test results and future flakiness detection for Python unit tests (do we know of any flaky tests?) are overcome by including in the JSON output a list of the names of all the tests that ran. > Tools/Scripts/webkitpy/test/main.py:136 > + Nit: I don't feel that this empty line improves the readability of this function. I suggest removing it. > Tools/Scripts/webkitpy/test/main.py:137 > + stream.write(json.dumps(results)) Notice that json.dump() (intentional omission of the 's' in the word "dumps") takes a File-like object as output (*). I suggest we take advantage of this convenience API and write this line as: json.dump(results, stream) On another note, you may want to consider specifying the keyword argument separators=(',', ':') towards generating more compact JSON output (since we envision the primary consumer being another computer program/web page as opposed to a human being). This would also make the separators used in this JSON output consistent with the separators used in the JSON output for the layout test results, full_results.json. (*) See <https://docs.python.org/2/library/json.html#basic-usage> for more details on the usage of json.dump(). > Tools/Scripts/webkitpy/test/main.py:176 > + self._print_results_as_json(sys.stdout, parallel_tests + serial_tests, test_runner.failures, test_runner.errors) This is inefficient. In particular, it is space and time inefficient to concatenate the list parallel_tests and serial_tests, which allocates a new list, given we are going to sort this concatenated list using sorted(), which also allocates a new list. Either we should pass an iterator (i.e. itertools.chain(parallel_tests, serial_tests)) for the second argument to _print_results_as_json() or we should modify _print_results_as_json() so that it sorts tests_names in-place (i.e. use test_names.sort()). If we choose the latter approach, then I suggest we add a docstring (**) that explains the purpose of _print_results_as_json() and documents that it mutates the argument test_names. (**) See <http://legacy.python.org/dev/peps/pep-0257/> for more details on docstrings. 1041402 19 jake.nielsen.webkit 2014-10-13 16:22:09 -0700 (In reply to comment #18) > (From update of attachment 239739 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=239739&action=review > > > Tools/ChangeLog:4 > > + on stdout > > Nit: on => to > > > Tools/ChangeLog:11 > > + Adds the read method to MockFile to allow the stdout of test_webkitpy > > + to be redirected without causing erroneous test failures. > > For you consideration, I suggest adding a remark about the test(s) that failed without this change. > > > Tools/Scripts/webkitpy/port/server_process_unittest.py:71 > > + # This means EOF > > Although it can be implied that this comment is with respect to the line above it given the length of the body of this function, it would be better to be explicit about this relationship and either move the comment to actually be above the return statement (line 70) or inline the comment on the same line as the return statement. You may also want to consider writing out End of file instead of abbreviating it as EOF to be explicit even though I suspect our audience is familiar with the abbreviation of EOF to mean End of file. > > > Tools/Scripts/webkitpy/test/main.py:36 > > import time > > import traceback > > import unittest > > +import operator > > +import json > > Please order the imports in this file such that they are sorted according to the output of the UNIX sort command. > > > Tools/Scripts/webkitpy/test/main.py:108 > > + help='emit JSON formatted test results on stdout') > > Nit: on => to > > The word "emit" in this help message can be taken as a synonym for the verb "output". I suggest that we use the word "write" instead of the word "emit" to refer to the action of writing JSON output so as to be consistent with the language suggested for the word "output" on p.114 of the Apple Style Guide (April 2013), <https://help.apple.com/asg/mac/2013/ASG_2013.pdf>. > > > Tools/Scripts/webkitpy/test/main.py:128 > > + def _print_results_as_json(self, stream, test_names, failures, errors): > > It is sufficient to make this a non-member function. I don't see the need to make this a member function that takes a parameter called self as this method does not make use of any instance data. > > > Tools/Scripts/webkitpy/test/main.py:135 > > + results['tests'] = sorted(test_names) > > :( It is OK to include a list of the names of all the tests we ran assuming we address the inefficiency of this line (see my remark on line 176 for more details). I wish we could avoid including such a list in the JSON output as it guarantees that the size of the JSON file is at least proportional to the total number of tests ran. In contrast, the JSON output for the layout tests results, full_results.json, is proportional to the number of tests that failed (including flaky tests). I know you mentioned in person today (10/13) that you felt that knowing the names of all tests than ran is necessary to identify flaky tests. It would great if we could find a way to identify flaky tests without having to include the names of all the tests that ran in the JSON output. Can we derived this data from the list of tests that failed (failures), the list of the tests that had a Python error (errors) and/or other metrics? Notice that we have logic to identify flaky tests when generating the layout test results JSON output without necessitating inserting a list of the names of all the tests that ran in the JSON output. You mentioned you were unhappy with this approach, but I don't recall the reason. It would be beneficial to understand how the shortcomings (what are they?) of the test flakiness detection we use for layout test results and future flakiness detection for Python unit tests (do we know of any flaky tests?) are overcome by including in the JSON output a list of the names of all the tests that ran. I think decimating the data irreversibly is a mistake. It's impossible to know when a particular test was added to the suite unless you have more than just a list of failures. The simplest way we could do this is simply by storing the list of test names. Furthermore, the layout-test-results directory, which gets archived in its entirety every time the buildbots run layout test, is 73 megabytes large. In contrast the complete json file containing the list of tests of test-webkitpy is 0.124 megabytes. That's a mere 0.17% change in the archive size. I really don't think this is worth fighting about. > > > Tools/Scripts/webkitpy/test/main.py:136 > > + > > Nit: I don't feel that this empty line improves the readability of this function. I suggest removing it. > > > Tools/Scripts/webkitpy/test/main.py:137 > > + stream.write(json.dumps(results)) > > Notice that json.dump() (intentional omission of the 's' in the word "dumps") takes a File-like object as output (*). I suggest we take advantage of this convenience API and write this line as: > > json.dump(results, stream) > > On another note, you may want to consider specifying the keyword argument separators=(',', ':') towards generating more compact JSON output (since we envision the primary consumer being another computer program/web page as opposed to a human being). This would also make the separators used in this JSON output consistent with the separators used in the JSON output for the layout test results, full_results.json. > > (*) See <https://docs.python.org/2/library/json.html#basic-usage> for more details on the usage of json.dump(). > > > Tools/Scripts/webkitpy/test/main.py:176 > > + self._print_results_as_json(sys.stdout, parallel_tests + serial_tests, test_runner.failures, test_runner.errors) > > This is inefficient. In particular, it is space and time inefficient to concatenate the list parallel_tests and serial_tests, which allocates a new list, given we are going to sort this concatenated list using sorted(), which also allocates a new list. Either we should pass an iterator (i.e. itertools.chain(parallel_tests, serial_tests)) for the second argument to _print_results_as_json() or we should modify _print_results_as_json() so that it sorts tests_names in-place (i.e. use test_names.sort()). If we choose the latter approach, then I suggest we add a docstring (**) that explains the purpose of _print_results_as_json() and documents that it mutates the argument test_names. > > (**) See <http://legacy.python.org/dev/peps/pep-0257/> for more details on docstrings. (In reply to comment #18) > (From update of attachment 239739 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=239739&action=review > > > Tools/ChangeLog:4 > > + on stdout > > Nit: on => to > > > Tools/ChangeLog:11 > > + Adds the read method to MockFile to allow the stdout of test_webkitpy > > + to be redirected without causing erroneous test failures. > > For you consideration, I suggest adding a remark about the test(s) that failed without this change. > > > Tools/Scripts/webkitpy/port/server_process_unittest.py:71 > > + # This means EOF > > Although it can be implied that this comment is with respect to the line above it given the length of the body of this function, it would be better to be explicit about this relationship and either move the comment to actually be above the return statement (line 70) or inline the comment on the same line as the return statement. You may also want to consider writing out End of file instead of abbreviating it as EOF to be explicit even though I suspect our audience is familiar with the abbreviation of EOF to mean End of file. > > > Tools/Scripts/webkitpy/test/main.py:36 > > import time > > import traceback > > import unittest > > +import operator > > +import json > > Please order the imports in this file such that they are sorted according to the output of the UNIX sort command. > > > Tools/Scripts/webkitpy/test/main.py:108 > > + help='emit JSON formatted test results on stdout') > > Nit: on => to > > The word "emit" in this help message can be taken as a synonym for the verb "output". I suggest that we use the word "write" instead of the word "emit" to refer to the action of writing JSON output so as to be consistent with the language suggested for the word "output" on p.114 of the Apple Style Guide (April 2013), <https://help.apple.com/asg/mac/2013/ASG_2013.pdf>. > > > Tools/Scripts/webkitpy/test/main.py:128 > > + def _print_results_as_json(self, stream, test_names, failures, errors): > > It is sufficient to make this a non-member function. I don't see the need to make this a member function that takes a parameter called self as this method does not make use of any instance data. > > > Tools/Scripts/webkitpy/test/main.py:135 > > + results['tests'] = sorted(test_names) > > :( It is OK to include a list of the names of all the tests we ran assuming we address the inefficiency of this line (see my remark on line 176 for more details). I wish we could avoid including such a list in the JSON output as it guarantees that the size of the JSON file is at least proportional to the total number of tests ran. In contrast, the JSON output for the layout tests results, full_results.json, is proportional to the number of tests that failed (including flaky tests). I know you mentioned in person today (10/13) that you felt that knowing the names of all tests than ran is necessary to identify flaky tests. It would great if we could find a way to identify flaky tests without having to include the names of all the tests that ran in the JSON output. Can we derived this data from the list of tests that failed (failures), the list of the tests that had a Python error (errors) and/or other metrics? Notice that we have logic to identify flaky tests when generating the layout test results JSON output without necessitating inserting a list of the names of all the tests that ran in the JSON output. You mentioned you were unhappy with this approach, but I don't recall the reason. It would be beneficial to understand how the shortcomings (what are they?) of the test flakiness detection we use for layout test results and future flakiness detection for Python unit tests (do we know of any flaky tests?) are overcome by including in the JSON output a list of the names of all the tests that ran. > > > Tools/Scripts/webkitpy/test/main.py:136 > > + > > Nit: I don't feel that this empty line improves the readability of this function. I suggest removing it. > > > Tools/Scripts/webkitpy/test/main.py:137 > > + stream.write(json.dumps(results)) > > Notice that json.dump() (intentional omission of the 's' in the word "dumps") takes a File-like object as output (*). I suggest we take advantage of this convenience API and write this line as: > > json.dump(results, stream) > > On another note, you may want to consider specifying the keyword argument separators=(',', ':') towards generating more compact JSON output (since we envision the primary consumer being another computer program/web page as opposed to a human being). This would also make the separators used in this JSON output consistent with the separators used in the JSON output for the layout test results, full_results.json. > > (*) See <https://docs.python.org/2/library/json.html#basic-usage> for more details on the usage of json.dump(). > > > Tools/Scripts/webkitpy/test/main.py:176 > > + self._print_results_as_json(sys.stdout, parallel_tests + serial_tests, test_runner.failures, test_runner.errors) > > This is inefficient. In particular, it is space and time inefficient to concatenate the list parallel_tests and serial_tests, which allocates a new list, given we are going to sort this concatenated list using sorted(), which also allocates a new list. Either we should pass an iterator (i.e. itertools.chain(parallel_tests, serial_tests)) for the second argument to _print_results_as_json() or we should modify _print_results_as_json() so that it sorts tests_names in-place (i.e. use test_names.sort()). If we choose the latter approach, then I suggest we add a docstring (**) that explains the purpose of _print_results_as_json() and documents that it mutates the argument test_names. > > (**) See <http://legacy.python.org/dev/peps/pep-0257/> for more details on docstrings. 1041411 20 239759 jake.nielsen.webkit 2014-10-13 16:46:52 -0700 Created attachment 239759 Fixes as per comments. 1041413 21 jake.nielsen.webkit 2014-10-13 16:48:12 -0700 Sigh, disregard that last patch. My bad. 1041415 22 239760 jake.nielsen.webkit 2014-10-13 16:50:12 -0700 Created attachment 239760 The patch I intended to post last time... 1041456 23 dbates 2014-10-13 20:55:51 -0700 (In reply to comment #19) > > > Tools/Scripts/webkitpy/test/main.py:135 > > > + results['tests'] = sorted(test_names) > > > > :( It is OK to include a list of the names of all the tests we ran assuming we address the inefficiency of this line (see my remark on line 176 for more details). I wish we could avoid including such a list in the JSON output as it guarantees that the size of the JSON file is at least proportional to the total number of tests ran. In contrast, the JSON output for the layout tests results, full_results.json, is proportional to the number of tests that failed (including flaky tests). I know you mentioned in person today (10/13) that you felt that knowing the names of all tests than ran is necessary to identify flaky tests. It would great if we could find a way to identify flaky tests without having to include the names of all the tests that ran in the JSON output. Can we derived this data from the list of tests that failed (failures), the list of the tests that had a Python error (errors) and/or other metrics? Notice that we have logic to identify flaky tests when generating the layout test results JSON output without necessitating inserting a list of the names of all the tests that ran in the JSON output. You mentioned you were unhappy with this approach, but I don't recall the reason. It would be beneficial to understand how the shortcomings (what are they?) of the test flakiness detection we use for layout test results and future flakiness detection for Python unit tests (do we know of any flaky tests?) are overcome by including in the JSON output a list of the names of all the tests that ran. > I think decimating the data irreversibly is a mistake. It's impossible to know when a particular test was added to the suite unless you have more than just a list of failures. The simplest way we could do this is simply by storing the list of test names. Can the JSON output be composed of the following of the tests that passed, the tests that failed (expected result differs from actual result) and the tests that failed because of a Python error? Or will it make it more straightforward to implement the JavaScript front-end code if the JSON output is composed of the tests that failed (expected result differs from actual result), tests that failed because of a Python error, and all the tests that ran? Notice that the list of all the tests than ran includes the tests the failed (expected result differs from actual result) and the tests that failed because of a Python error. 1041458 24 239760 dbates 2014-10-13 21:01:20 -0700 Comment on attachment 239760 The patch I intended to post last time... Thank you for updating the patch. 1041894 25 239877 jake.nielsen.webkit 2014-10-15 10:46:25 -0700 Created attachment 239877 Removes redundant test names from the list of tests To address any efficiency concerns, I ran some tests with randomly generated test names, and a random subset of failures and errors. 10,000 test names, 1000 errors/failures. For comparison, there are presently 1430 unit tests in the test-webkitpy test suite. Here are the results (time measured in seconds): [563]jacob_nielsen: ~/GitRepos/WorkRepos/OpenSource/Tools/Scripts $ python ./JsonPerformanceTest.py Average time: 0.022092668[564]jacob_nielsen: ~/GitRepos/WorkRepos/OpenSource/Tools/Scripts $ python ./JsonPerformanceTest.py Average time: 0.02275959[565]jacob_nielsen: ~/GitRepos/WorkRepos/OpenSource/Tools/Scripts $ python ./JsonPerformanceTest.py Average time: 0.0233933[566]jacob_nielsen: ~/GitRepos/WorkRepos/OpenSource/Tools/Scripts $ 1041897 26 commit-queue 2014-10-15 10:48:48 -0700 Attachment 239877 did not pass style-queue: ERROR: Tools/Scripts/webkitpy/test/main.py:77: expected 2 blank lines, found 1 [pep8/E302] [5] Total errors found: 1 in 3 files If any of these errors are false positives, please file a bug against check-webkit-style. 1041899 27 239878 jake.nielsen.webkit 2014-10-15 10:51:37 -0700 Created attachment 239878 Fixes style issues 1041923 28 239878 dbates 2014-10-15 12:42:02 -0700 Comment on attachment 239878 Fixes style issues View in context: https://bugs.webkit.org/attachment.cgi?id=239878&action=review > Tools/Scripts/webkitpy/test/main.py:85 > + results['tests'] = sorted(set(all_test_names) - set(map(operator.itemgetter(0), failures)) - set(map(operator.itemgetter(0), errors))) I suggest we name the dictionary key 'passes' since it now represents the list of tests that pass. For completeness, there's probably a more space and time efficient way to compute the list of passing tests. Regardless, this approach to computing the list of passing tests should be sufficient for our purposes. 1041926 29 239884 jake.nielsen.webkit 2014-10-15 12:46:14 -0700 Created attachment 239884 Dictionary key change 1041952 30 239884 commit-queue 2014-10-15 13:56:17 -0700 Comment on attachment 239884 Dictionary key change Clearing flags on attachment: 239884 Committed r174743: <http://trac.webkit.org/changeset/174743> 1041953 31 commit-queue 2014-10-15 13:56:22 -0700 All reviewed patches have been landed. Closing bug. 239171 2014-10-02 18:49:29 -0700 2014-10-02 19:01:29 -0700 Adds the appropriate mechanisms to allow test-webkitpy to generate a json file of its results in a specified directory 0001-Make-test-webkitpy-generate-a-json-file-of-its-resul.patch text/plain 18792 jake.nielsen.webkit RnJvbSBjZjFkNWFiOWRiYTM1YTRhYjk5NmQyMzY2MGU0YTIxN2Y0ZWQ5ZTNlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBUaHUsIDIgT2N0IDIwMTQgMTg6Mzc6NTMgLTA3MDAKU3ViamVjdDogW1BBVENIXSBN YWtlIHRlc3Qtd2Via2l0cHkgZ2VuZXJhdGUgYSBqc29uIGZpbGUgb2YgaXRzIHJlc3VsdHMKIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzczNTMKClJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgoKKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi93ZWJraXRfZmluZGVy LnB5OgpBZGRzIGEgbWV0aG9kIHRvIG1ha2UgaXQgZWFzaWVyIHRvIGZpbmQgdGhlIHdlYmtpdCBy ZXN1bHRzIGRpcmVjdG9yeS4KKFdlYktpdEZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIpOgoqIFNj cmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5OgpBZGRzIHRoZSAtLXJlc3VsdHMtZGlyIG9wdGlv biwgYW5kIGFkZHMgbG9naWMgdG8gZHVtcCBhIGpzb24gZmlsZSBvZgp0aGUgcmVzdWx0cyBpZiAt LXJlc3VsdHMtZGlyIGhhcyBiZWVuIHNwZWNpZmllZC4KKFRlc3Rlci5fX2luaXRfXyk6CihUZXN0 ZXIuX3BhcnNlX2FyZ3MpOgooVGVzdGVyLl9ydW5fdGVzdHMpOgoqIFNjcmlwdHMvd2Via2l0cHkv dGVzdC9yZXN1bHRzLnB5OiBBZGRlZC4KUHJvdmlkZXMgYSBjbGFzcyB0byBlbmNhcHN1bGF0ZSB0 ZXN0IHJlc3VsdHMsIGFuZCB0byBhZGQgaXNvbGF0aW9uCmJldHdlZW4gdGhlIGpzb24gZmlsZSBh bmQgdGhlIHJlc3Qgb2Ygd2Via2l0cHkuCihUZXN0UmVzdWx0KToKKFRlc3RSZXN1bHQudGVzdF9y ZXN1bHRfZnJvbV9qc29uX2RpY3QpOgooVGVzdFJlc3VsdC50ZXN0X3Jlc3VsdF90b19qc29uX2Rp Y3QpOgooVGVzdFJlc3VsdC5fX2luaXRfXyk6CihUZXN0UmVzdWx0LnRlc3RfbmFtZSk6CihUZXN0 UmVzdWx0LmZhaWx1cmVzKToKKFRlc3RSZXN1bHQuZXJyb3JzKToKKFRlc3RSZXN1bHRzKToKKFRl c3RSZXN1bHRzLnRlc3RfcmVzdWx0c19mcm9tX2pzb25fZGljdCk6CihUZXN0UmVzdWx0cy50ZXN0 X3Jlc3VsdHNfdG9fanNvbl9kaWN0KToKKFRlc3RSZXN1bHRzLl9faW5pdF9fKToKKFRlc3RSZXN1 bHRzLmFkZF90ZXN0X3Jlc3VsdCk6CihUZXN0UmVzdWx0cy5saXN0X29mX3Rlc3RfcmVzdWx0cyk6 CihUZXN0UmVzdWx0cy5saXN0X29mX2ZhaWxlZF90ZXN0X3Jlc3VsdHMpOgooVGVzdFJlc3VsdHMu bGlzdF9vZl9lcnJvcmVkX3Rlc3RfcmVzdWx0cyk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1 bm5lci5weToKVGVhY2hlcyBydW5uZXIucHkgdG8gdXNlIFRlc3RSZXN1bHQgb2JqZWN0cyBpbnN0 ZWFkIG9mIGp1c3Qgc3R1ZmZpbmcKZXZlcnl0aGluZyBpbnRvIHR1cGxlcyBhbmQgbGlzdHMuCihS dW5uZXIuX19pbml0X18pOgooUnVubmVyLmhhbmRsZSk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0 L3J1bm5lcl91bml0dGVzdC5weToKVGVhY2hlcyB0ZXN0X3J1biBob3cgdG8gdXNlIFRlc3RSZXN1 bHRzIG9iamVjdHMuCihSdW5uZXJUZXN0LnRlc3RfcnVuKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rv b2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHk6ClVwZGF0ZXMgdGhlIHRlc3RfbGFuZF9j b3doYW5kIHRlc3QgdG8gcHJvcGVybHkgYW50aWNpcGF0ZSB3aGF0IFJ1blRlc3QKc2hvdWxkIGJl IHN0ZG91dGluZy4KKHRlc3RfbGFuZF9jb3doYW5kKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wv c3RlcHMvcnVudGVzdHMucHk6ClRlYWNoZXMgUnVuVGVzdHMgdG8gcGFzcyBhIC0tcmVzdWx0cy1k aXIgdG8gdGVzdC13ZWJraXRweS4KKFJ1blRlc3RzLnJ1bik6CiogU2NyaXB0cy93ZWJraXRweS90 b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5OgpVcGRhdGVzIHRoZSB0ZXN0X3J1bnRlc3RzX2Fy Z3MgdGVzdCB0byBwcm9wZXJseSBhbnRpY2lwYXRlIHdoYXQgUnVuVGVzdApzaG91bGQgYmUgc3Rk b3V0aW5nLgooU3RlcHNUZXN0LnRlc3RfcnVudGVzdHNfYXJncyk6Ci0tLQogVG9vbHMvQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCA1NCArKysrKysrKysrKysr KysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHkgICAgIHwg IDUgKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAgICAgICAg IHwgMTAgKystCiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5weSAgICAgICAg ICAgICB8IDc4ICsrKysrKysrKysrKysrKysrKysrKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dGVzdC9ydW5uZXIucHkgICAgICAgICAgICAgIHwgMTIgKystLQogVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90ZXN0L3J1bm5lcl91bml0dGVzdC5weSAgICAgfCAgNiArLQogLi4uL3dlYmtpdHB5L3Rv b2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHkgICAgfCAgNiArLQogVG9vbHMvU2NyaXB0 cy93ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5ICAgICAgfCAgOSArKysKIC4uLi9TY3Jp cHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkgIHwgIDYgKy0KIDkgZmls ZXMgY2hhbmdlZCwgMTcyIGluc2VydGlvbnMoKyksIDE0IGRlbGV0aW9ucygtKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5CgpkaWZmIC0t Z2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDRmNDNiZWMuLmQ5 NDRmZjggMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cK QEAgLTEsMyArMSw1NyBAQAorMjAxNC0xMC0wMiAgSmFrZSBOaWVsc2VuICA8amFjb2JfbmllbHNl bkBhcHBsZS5jb20+CisKKyAgICAgICAgTWFrZSB0ZXN0LXdlYmtpdHB5IGdlbmVyYXRlIGEganNv biBmaWxlIG9mIGl0cyByZXN1bHRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xMzczNTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHk6 CisgICAgICAgIEFkZHMgYSBtZXRob2QgdG8gbWFrZSBpdCBlYXNpZXIgdG8gZmluZCB0aGUgd2Vi a2l0IHJlc3VsdHMgZGlyZWN0b3J5LgorICAgICAgICAoV2ViS2l0RmluZGVyLndlYmtpdF9yZXN1 bHRzX2Rpcik6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHk6CisgICAg ICAgIEFkZHMgdGhlIC0tcmVzdWx0cy1kaXIgb3B0aW9uLCBhbmQgYWRkcyBsb2dpYyB0byBkdW1w IGEganNvbiBmaWxlIG9mCisgICAgICAgIHRoZSByZXN1bHRzIGlmIC0tcmVzdWx0cy1kaXIgaGFz IGJlZW4gc3BlY2lmaWVkLgorICAgICAgICAoVGVzdGVyLl9faW5pdF9fKToKKyAgICAgICAgKFRl c3Rlci5fcGFyc2VfYXJncyk6CisgICAgICAgIChUZXN0ZXIuX3J1bl90ZXN0cyk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS90ZXN0L3Jlc3VsdHMucHk6IEFkZGVkLgorICAgICAgICBQcm92 aWRlcyBhIGNsYXNzIHRvIGVuY2Fwc3VsYXRlIHRlc3QgcmVzdWx0cywgYW5kIHRvIGFkZCBpc29s YXRpb24KKyAgICAgICAgYmV0d2VlbiB0aGUganNvbiBmaWxlIGFuZCB0aGUgcmVzdCBvZiB3ZWJr aXRweS4KKyAgICAgICAgKFRlc3RSZXN1bHQpOgorICAgICAgICAoVGVzdFJlc3VsdC50ZXN0X3Jl c3VsdF9mcm9tX2pzb25fZGljdCk6CisgICAgICAgIChUZXN0UmVzdWx0LnRlc3RfcmVzdWx0X3Rv X2pzb25fZGljdCk6CisgICAgICAgIChUZXN0UmVzdWx0Ll9faW5pdF9fKToKKyAgICAgICAgKFRl c3RSZXN1bHQudGVzdF9uYW1lKToKKyAgICAgICAgKFRlc3RSZXN1bHQuZmFpbHVyZXMpOgorICAg ICAgICAoVGVzdFJlc3VsdC5lcnJvcnMpOgorICAgICAgICAoVGVzdFJlc3VsdHMpOgorICAgICAg ICAoVGVzdFJlc3VsdHMudGVzdF9yZXN1bHRzX2Zyb21fanNvbl9kaWN0KToKKyAgICAgICAgKFRl c3RSZXN1bHRzLnRlc3RfcmVzdWx0c190b19qc29uX2RpY3QpOgorICAgICAgICAoVGVzdFJlc3Vs dHMuX19pbml0X18pOgorICAgICAgICAoVGVzdFJlc3VsdHMuYWRkX3Rlc3RfcmVzdWx0KToKKyAg ICAgICAgKFRlc3RSZXN1bHRzLmxpc3Rfb2ZfdGVzdF9yZXN1bHRzKToKKyAgICAgICAgKFRlc3RS ZXN1bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cyk6CisgICAgICAgIChUZXN0UmVzdWx0 cy5saXN0X29mX2Vycm9yZWRfdGVzdF9yZXN1bHRzKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L3Rlc3QvcnVubmVyLnB5OgorICAgICAgICBUZWFjaGVzIHJ1bm5lci5weSB0byB1c2UgVGVz dFJlc3VsdCBvYmplY3RzIGluc3RlYWQgb2YganVzdCBzdHVmZmluZworICAgICAgICBldmVyeXRo aW5nIGludG8gdHVwbGVzIGFuZCBsaXN0cy4KKyAgICAgICAgKFJ1bm5lci5fX2luaXRfXyk6Cisg ICAgICAgIChSdW5uZXIuaGFuZGxlKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rlc3Qv cnVubmVyX3VuaXR0ZXN0LnB5OgorICAgICAgICBUZWFjaGVzIHRlc3RfcnVuIGhvdyB0byB1c2Ug VGVzdFJlc3VsdHMgb2JqZWN0cy4KKyAgICAgICAgKFJ1bm5lclRlc3QudGVzdF9ydW4pOgorICAg ICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91bml0dGVzdC5w eToKKyAgICAgICAgVXBkYXRlcyB0aGUgdGVzdF9sYW5kX2Nvd2hhbmQgdGVzdCB0byBwcm9wZXJs eSBhbnRpY2lwYXRlIHdoYXQgUnVuVGVzdAorICAgICAgICBzaG91bGQgYmUgc3Rkb3V0aW5nLgor ICAgICAgICAodGVzdF9sYW5kX2Nvd2hhbmQpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkv dG9vbC9zdGVwcy9ydW50ZXN0cy5weToKKyAgICAgICAgVGVhY2hlcyBSdW5UZXN0cyB0byBwYXNz IGEgLS1yZXN1bHRzLWRpciB0byB0ZXN0LXdlYmtpdHB5LgorICAgICAgICAoUnVuVGVzdHMucnVu KToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3Qu cHk6CisgICAgICAgIFVwZGF0ZXMgdGhlIHRlc3RfcnVudGVzdHNfYXJncyB0ZXN0IHRvIHByb3Bl cmx5IGFudGljaXBhdGUgd2hhdCBSdW5UZXN0CisgICAgICAgIHNob3VsZCBiZSBzdGRvdXRpbmcu CisgICAgICAgIChTdGVwc1Rlc3QudGVzdF9ydW50ZXN0c19hcmdzKToKKwogMjAxNC0xMC0wMiAg Q2FybG9zIEFsYmVydG8gTG9wZXogUGVyZXogIDxjbG9wZXpAaWdhbGlhLmNvbT4KIAogICAgICAg ICBbR1RLXSBbSkhCdWlsZF0gU3dpdGNoIHNvdXJjZXdhcmUub3JnIG1pcnJvciB0byBodHRwLgpk aWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vd2Via2l0X2ZpbmRlci5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHkKaW5kZXgg N2I5YzAxNC4uNTQyZWFhOCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vd2Via2l0X2ZpbmRlci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi93 ZWJraXRfZmluZGVyLnB5CkBAIC0zMiw2ICszMiwxMSBAQCBjbGFzcyBXZWJLaXRGaW5kZXIob2Jq ZWN0KToKICAgICAgICAgc2VsZi5fZmlsZXN5c3RlbSA9IGZpbGVzeXN0ZW0KICAgICAgICAgc2Vs Zi5fd2Via2l0X2Jhc2UgPSBOb25lCiAKKyAgICBkZWYgd2Via2l0X3Jlc3VsdHNfZGlyKHNlbGYp OgorICAgICAgICBwYXRoX3RvX2J1aWxkX2RpciA9IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxm LndlYmtpdF9iYXNlKCksICJXZWJLaXRCdWlsZCIpCisgICAgICAgIGNvbmZpZ3VyYXRpb25fZGly ID0gc2VsZi5fZmlsZXN5c3RlbS5yZWFkX3RleHRfZmlsZShzZWxmLl9maWxlc3lzdGVtLmpvaW4o cGF0aF90b19idWlsZF9kaXIsICJDb25maWd1cmF0aW9uIikpCisgICAgICAgIHJldHVybiBzZWxm Ll9maWxlc3lzdGVtLmpvaW4ocGF0aF90b19idWlsZF9kaXIsIGNvbmZpZ3VyYXRpb25fZGlyKQor CiAgICAgZGVmIHdlYmtpdF9iYXNlKHNlbGYpOgogICAgICAgICAiIiJSZXR1cm5zIHRoZSBhYnNv bHV0ZSBwYXRoIHRvIHRoZSB0b3Agb2YgdGhlIFdlYktpdCB0cmVlLgogCmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdGVzdC9tYWluLnB5CmluZGV4IGY1MThiNTEuLjEzYTZjNjYgMTAwNjQ0Ci0tLSBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdGVzdC9tYWluLnB5CkBAIC0zMiw3ICszMiw5IEBAIGltcG9ydCBzeXMKIGltcG9ydCB0aW1l CiBpbXBvcnQgdHJhY2ViYWNrCiBpbXBvcnQgdW5pdHRlc3QKK2ltcG9ydCBqc29uCiAKK2Zyb20g d2Via2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktpdEZpbmRlcgogZnJvbSB3 ZWJraXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZpbGVTeXN0ZW0KIGZyb20g d2Via2l0cHkudGVzdC5maW5kZXIgaW1wb3J0IEZpbmRlcgogZnJvbSB3ZWJraXRweS50ZXN0LnBy aW50ZXIgaW1wb3J0IFByaW50ZXIKQEAgLTc0LDcgKzc2LDggQEAgZGVmIG1haW4oKToKIAogY2xh c3MgVGVzdGVyKG9iamVjdCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIGZpbGVzeXN0ZW09Tm9u ZSk6Ci0gICAgICAgIHNlbGYuZmluZGVyID0gRmluZGVyKGZpbGVzeXN0ZW0gb3IgRmlsZVN5c3Rl bSgpKQorICAgICAgICBzZWxmLl9maWxlc3lzdGVtID0gZmlsZXN5c3RlbSBvciBGaWxlU3lzdGVt KCkKKyAgICAgICAgc2VsZi5maW5kZXIgPSBGaW5kZXIoc2VsZi5fZmlsZXN5c3RlbSkKICAgICAg ICAgc2VsZi5wcmludGVyID0gUHJpbnRlcihzeXMuc3RkZXJyKQogICAgICAgICBzZWxmLl9vcHRp b25zID0gTm9uZQogCkBAIC0xMDIsNiArMTA1LDggQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAg ICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2Rpc3BsYXkgcGVyLXRlc3QgZXhlY3V0aW9u IHRpbWUgKGltcGxpZXMgLS12ZXJib3NlKScpCiAgICAgICAgIHBhcnNlci5hZGRfb3B0aW9uKCct dicsICctLXZlcmJvc2UnLCBhY3Rpb249J2NvdW50JywgZGVmYXVsdD0wLAogICAgICAgICAgICAg ICAgICAgICAgICAgICBoZWxwPSd2ZXJib3NlIG91dHB1dCAoc3BlY2lmeSBvbmNlIGZvciBpbmRp dmlkdWFsIHRlc3QgcmVzdWx0cywgdHdpY2UgZm9yIGRlYnVnIG1lc3NhZ2VzKScpCisgICAgICAg IHBhcnNlci5hZGRfb3B0aW9uKCctcicsICctLXJlc3VsdHMtZGlyJywgYWN0aW9uPSdzdG9yZScs IGRlZmF1bHQ9IiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2Rpc3BsYXkgcGVy LXRlc3QgZXhlY3V0aW9uIHRpbWUgKGltcGxpZXMgLS12ZXJib3NlKScpCiAKICAgICAgICAgcGFy c2VyLmVwaWxvZyA9ICgnW2FyZ3MuLi5dIGlzIGFuIG9wdGlvbmFsIGxpc3Qgb2YgbW9kdWxlcywg dGVzdF9jbGFzc2VzLCBvciBpbmRpdmlkdWFsIHRlc3RzLiAnCiAgICAgICAgICAgICAgICAgICAg ICAgICAgJ0lmIG5vIGFyZ3MgYXJlIGdpdmVuLCBhbGwgdGhlIHRlc3RzIHdpbGwgYmUgcnVuLicp CkBAIC0xNjIsNiArMTY3LDkgQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAKICAgICAgICAgc2Vs Zi5wcmludGVyLnByaW50X3Jlc3VsdCh0aW1lLnRpbWUoKSAtIHN0YXJ0KQogCisgICAgICAgIGlm IHNlbGYuX29wdGlvbnMucmVzdWx0c19kaXI6CisgICAgICAgICAgICBzZWxmLl9maWxlc3lzdGVt LndyaXRlX3RleHRfZmlsZShzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1 bHRzX2RpciwgInJlc3VsdHMuanNvbiIpLCBqc29uLmR1bXBzKHRlc3RfcnVubmVyLnRlc3RfcmVz dWx0cy50ZXN0X3Jlc3VsdHNfdG9fanNvbl9kaWN0KCkpKQorCiAgICAgICAgIGlmIHNlbGYuX29w dGlvbnMuY292ZXJhZ2U6CiAgICAgICAgICAgICBjb3Yuc3RvcCgpCiAgICAgICAgICAgICBjb3Yu c2F2ZSgpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM3ZWM0MDYKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5weQpAQCAtMCwwICsxLDc4IEBACisjIENvcHly aWdodCAoQykgMjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorIyBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyMgYXJlIG1ldDoKKyMgMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisj IDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlIGNvcHlyaWdodAorIyAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorIyAgICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMg VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVU T1JTIGBgQVMgSVMnJyBBTkQKKyMgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyMgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFS RQorIyBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUgorIyBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCisjIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RT IE9SCisjIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSCisjIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksCisjIE9SIFRP UlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKK2ltcG9ydCBsb2dnaW5nCitfbG9nID0g bG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCisKK2NsYXNzIFRlc3RSZXN1bHQob2JqZWN0KToK KwlAY2xhc3NtZXRob2QKKwlkZWYgdGVzdF9yZXN1bHRfZnJvbV9qc29uX2RpY3QoY2xzLCBqc29u X2RpY3QpOgorCQlyZXR1cm4gY2xzKGpzb25fZGljdFsndGVzdF9uYW1lJ10sIGpzb25fZGljdFsn ZmFpbHVyZXMnXSwganNvbl9kaWN0WydlcnJvcnMnXSkKKworCWRlZiB0ZXN0X3Jlc3VsdF90b19q c29uX2RpY3Qoc2VsZik6CisJCWpzb25fZGljdCA9IHt9CisJCWpzb25fZGljdFsndGVzdF9uYW1l J10gPSBzZWxmLl90ZXN0X25hbWUKKwkJanNvbl9kaWN0WydmYWlsdXJlcyddID0gc2VsZi5fZmFp bHVyZXMKKwkJanNvbl9kaWN0WydlcnJvcnMnXSA9IHNlbGYuX2Vycm9ycworCQlyZXR1cm4ganNv bl9kaWN0CisKKwlkZWYgX19pbml0X18oc2VsZiwgdGVzdF9uYW1lLCBmYWlsdXJlcz1Ob25lLCBl cnJvcnM9Tm9uZSk6CisJCXNlbGYuX3Rlc3RfbmFtZSA9IHRlc3RfbmFtZQorCQlzZWxmLl9mYWls dXJlcyA9IGZhaWx1cmVzCisJCXNlbGYuX2Vycm9ycyA9IGVycm9ycworCisJZGVmIHRlc3RfbmFt ZShzZWxmKToKKwkJcmV0dXJuIHNlbGYuX3Rlc3RfbmFtZQorCisJZGVmIGZhaWx1cmVzKHNlbGYp OgorCQlyZXR1cm4gc2VsZi5fZmFpbHVyZXMKKworCWRlZiBlcnJvcnMoc2VsZik6CisJCXJldHVy biBzZWxmLl9lcnJvcnMKKworCitjbGFzcyBUZXN0UmVzdWx0cyhvYmplY3QpOgorCUBjbGFzc21l dGhvZAorCWRlZiB0ZXN0X3Jlc3VsdHNfZnJvbV9qc29uX2RpY3QoY2xzLCBqc29uX2RpY3QpOgor CQlsaXN0X29mX3Rlc3RfcmVzdWx0cyA9IFtUZXN0UmVzdWx0LnRlc3RfcmVzdWx0X2Zyb21fanNv bl9kaWN0KGpzb25fcmVzdWx0KSBmb3IganNvbl9yZXN1bHQgaW4ganNvbl9kaWN0WydsaXN0X29m X3Rlc3RfcmVzdWx0cyddXQorCQlyZXR1cm4gY2xzKGxpc3Rfb2ZfdGVzdF9yZXN1bHRzKQorCisJ ZGVmIHRlc3RfcmVzdWx0c190b19qc29uX2RpY3Qoc2VsZik6CisJCWpzb25fZGljdCA9IHt9CisJ CWpzb25fZGljdFsnbGlzdF9vZl90ZXN0X3Jlc3VsdHMnXSA9IFtyZXN1bHQudGVzdF9yZXN1bHRf dG9fanNvbl9kaWN0KCkgZm9yIHJlc3VsdCBpbiBzZWxmLl9saXN0X29mX3Rlc3RfcmVzdWx0c10K KwkJcmV0dXJuIGpzb25fZGljdAorCisJZGVmIF9faW5pdF9fKHNlbGYsIGxpc3Rfb2ZfdGVzdF9y ZXN1bHRzPVtdKToKKwkJc2VsZi5fbGlzdF9vZl90ZXN0X3Jlc3VsdHMgPSBsaXN0X29mX3Rlc3Rf cmVzdWx0cworCisJZGVmIGFkZF90ZXN0X3Jlc3VsdChzZWxmLCB0ZXN0KToKKwkJc2VsZi5fbGlz dF9vZl90ZXN0X3Jlc3VsdHMuYXBwZW5kKHRlc3QpCisKKwlkZWYgbGlzdF9vZl90ZXN0X3Jlc3Vs dHMoc2VsZik6CisJCXJldHVybiBzZWxmLl9saXN0X29mX3Rlc3RfcmVzdWx0cworCisJZGVmIGxp c3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cyhzZWxmKToKKwkJcmV0dXJuIFtyZXN1bHQgZm9yIHJl c3VsdCBpbiBzZWxmLl9saXN0X29mX3Rlc3RfcmVzdWx0cyBpZiByZXN1bHQuZmFpbHVyZXMoKV0K KworCWRlZiBsaXN0X29mX2Vycm9yZWRfdGVzdF9yZXN1bHRzKHNlbGYpOgorCQlyZXR1cm4gW3Jl c3VsdCBmb3IgcmVzdWx0IGluIHNlbGYuX2xpc3Rfb2ZfdGVzdF9yZXN1bHRzIGlmIHJlc3VsdC5l cnJvcnMoKV0KKwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5l ci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHkKaW5kZXggZDNmNTc2 NC4uN2Q0OTQ0YiAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5l ci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyLnB5CkBAIC0yNyw2 ICsyNyw3IEBAIGltcG9ydCB0aW1lCiBpbXBvcnQgdW5pdHRlc3QKIAogZnJvbSB3ZWJraXRweS5j b21tb24gaW1wb3J0IG1lc3NhZ2VfcG9vbAorZnJvbSB3ZWJraXRweS50ZXN0LnJlc3VsdHMgaW1w b3J0IFRlc3RSZXN1bHQsIFRlc3RSZXN1bHRzCiAKIF90ZXN0X2Rlc2NyaXB0aW9uID0gcmUuY29t cGlsZSgiKFx3KykgXCgoW1x3Ll0rKVwpIikKIApAQCAtNDAsOSArNDEsNyBAQCBjbGFzcyBSdW5u ZXIob2JqZWN0KToKICAgICBkZWYgX19pbml0X18oc2VsZiwgcHJpbnRlciwgbG9hZGVyKToKICAg ICAgICAgc2VsZi5wcmludGVyID0gcHJpbnRlcgogICAgICAgICBzZWxmLmxvYWRlciA9IGxvYWRl cgotICAgICAgICBzZWxmLnRlc3RzX3J1biA9IDAKLSAgICAgICAgc2VsZi5lcnJvcnMgPSBbXQot ICAgICAgICBzZWxmLmZhaWx1cmVzID0gW10KKyAgICAgICAgc2VsZi50ZXN0X3Jlc3VsdHMgPSBU ZXN0UmVzdWx0cygpCiAgICAgICAgIHNlbGYud29ya2VyX2ZhY3RvcnkgPSBsYW1iZGEgY2FsbGVy OiBfV29ya2VyKGNhbGxlciwgc2VsZi5sb2FkZXIpCiAKICAgICBkZWYgcnVuKHNlbGYsIHRlc3Rf bmFtZXMsIG51bV93b3JrZXJzKToKQEAgLTU3LDExICs1Niw4IEBAIGNsYXNzIFJ1bm5lcihvYmpl Y3QpOgogICAgICAgICAgICAgc2VsZi5wcmludGVyLnByaW50X3N0YXJ0ZWRfdGVzdChzb3VyY2Us IHRlc3RfbmFtZSkKICAgICAgICAgICAgIHJldHVybgogCi0gICAgICAgIHNlbGYudGVzdHNfcnVu ICs9IDEKLSAgICAgICAgaWYgZmFpbHVyZXM6Ci0gICAgICAgICAgICBzZWxmLmZhaWx1cmVzLmFw cGVuZCgodGVzdF9uYW1lLCBmYWlsdXJlcykpCi0gICAgICAgIGlmIGVycm9yczoKLSAgICAgICAg ICAgIHNlbGYuZXJyb3JzLmFwcGVuZCgodGVzdF9uYW1lLCBlcnJvcnMpKQorICAgICAgICBzZWxm LnRlc3RfcmVzdWx0cy5hZGRfdGVzdF9yZXN1bHQoVGVzdFJlc3VsdCh0ZXN0X25hbWUsIGZhaWx1 cmVzLCBlcnJvcnMpKQorCiAgICAgICAgIHNlbGYucHJpbnRlci5wcmludF9maW5pc2hlZF90ZXN0 KHNvdXJjZSwgdGVzdF9uYW1lLCBkZWxheSwgZmFpbHVyZXMsIGVycm9ycykKIAogCmRpZmYgLS1n aXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0LnB5IGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lcl91bml0dGVzdC5weQppbmRleCA5OTUwNzBi Li5hOWM2MWVjIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVy X3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXJfdW5p dHRlc3QucHkKQEAgLTkyLDYgKzkyLDYgQEAgY2xhc3MgUnVubmVyVGVzdCh1bml0dGVzdC5UZXN0 Q2FzZSk6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKCd0ZXN0MyAoRm9vKScsICdFJywg J3Rlc3QzXG5lcnJlZCcpKQogICAgICAgICBydW5uZXIgPSBSdW5uZXIoUHJpbnRlcihzdHJlYW0s IG9wdGlvbnMpLCBsb2FkZXIpCiAgICAgICAgIHJ1bm5lci5ydW4oWydGb28udGVzdDEnLCAnRm9v LnRlc3QyJywgJ0Zvby50ZXN0MyddLCAxKQotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHJ1bm5l ci50ZXN0c19ydW4sIDMpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci5mYWls dXJlcyksIDEpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci5lcnJvcnMpLCAx KQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5uZXIudGVzdF9yZXN1bHRzLmxpc3Rf b2ZfdGVzdF9yZXN1bHRzKCkpLCAzKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5u ZXIudGVzdF9yZXN1bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cygpKSwgMSkKKyAgICAg ICAgc2VsZi5hc3NlcnRFcXVhbChsZW4ocnVubmVyLnRlc3RfcmVzdWx0cy5saXN0X29mX2Vycm9y ZWRfdGVzdF9yZXN1bHRzKCkpLCAxKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5CmluZGV4IDU5YjUyZWEuLjBh YzZkMDYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9k b3dubG9hZF91bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29t bWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHkKQEAgLTM0LDYgKzM0LDggQEAgZnJvbSB3ZWJraXRw eS50b29sLmNvbW1hbmRzLmNvbW1hbmR0ZXN0IGltcG9ydCBDb21tYW5kc1Rlc3QKIGZyb20gd2Vi a2l0cHkudG9vbC5jb21tYW5kcy5kb3dubG9hZCBpbXBvcnQgKgogZnJvbSB3ZWJraXRweS50b29s Lm1vY2t0b29sIGltcG9ydCBNb2NrT3B0aW9ucywgTW9ja1Rvb2wKIGZyb20gd2Via2l0cHkuY29t bW9uLmNoZWNrb3V0LmNoZWNrb3V0X21vY2sgaW1wb3J0IE1vY2tDaGVja291dAorZnJvbSB3ZWJr aXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZpbGVTeXN0ZW0KK2Zyb20gd2Vi a2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktpdEZpbmRlcgogCiAKIGNsYXNz IEFic3RyYWN0Um9sbG91dFByZXBDb21tYW5kVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CkBAIC0x NTYsNiArMTU4LDggQEAgVXBkYXRpbmcgYnVnIDUwMDAwCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1 YWwobW9ja190b29sLmNoZWNrb3V0KCkubW9kaWZpZWRfY2hhbmdlbG9ncy5jYWxsX2NvdW50LCAx KQogCiAgICAgZGVmIHRlc3RfbGFuZF9jb3doYW5kKHNlbGYpOgorICAgICAgICBmaWxlc3lzdGVt ID0gRmlsZVN5c3RlbSgpCisgICAgICAgIHdlYmtpdF9maW5kZXIgPSBXZWJLaXRGaW5kZXIoZmls ZXN5c3RlbSkKICAgICAgICAgZXhwZWN0ZWRfbG9ncyA9ICIiIk1PQ0sgcnVuX2FuZF90aHJvd19p Zl9mYWlsOiBbJ21vY2stcHJlcGFyZS1DaGFuZ2VMb2cnLCAnLS1lbWFpbD1NT0NLIGVtYWlsJywg Jy0tbWVyZ2UtYmFzZT1Ob25lJywgJ01vY2tGaWxlMSddLCBjd2Q9L21vY2stY2hlY2tvdXQKIE1P Q0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ21vY2stY2hlY2std2Via2l0LXN0eWxlJywgJy0t Z2l0LWNvbW1pdCcsICdNT0NLIGdpdCBjb21taXQnLCAnLS1kaWZmLWZpbGVzJywgJ01vY2tGaWxl MScsICctLWZpbHRlcicsICctY2hhbmdlbG9nJ10sIGN3ZD0vbW9jay1jaGVja291dAogTU9DSyBy dW5fY29tbWFuZDogWydydWJ5JywgJy1JJywgJy9tb2NrLWNoZWNrb3V0L1dlYnNpdGVzL2J1Z3Mu d2Via2l0Lm9yZy9QcmV0dHlQYXRjaCcsICcvbW9jay1jaGVja291dC9XZWJzaXRlcy9idWdzLndl YmtpdC5vcmcvUHJldHR5UGF0Y2gvcHJldHRpZnkucmInXSwgY3dkPU5vbmUsIGlucHV0PVBhdGNo MQpAQCAtMTY0LDcgKzE2OCw3IEBAIFdhcyB0aGF0IGRpZmYgY29ycmVjdD8KIEJ1aWxkaW5nIFdl YktpdAogTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnbW9jay1idWlsZC13ZWJraXQnXSwg Y3dkPS9tb2NrLWNoZWNrb3V0LCBlbnY9eydMQ19BTEwnOiAnQycsICdURVJNJzogJ25vbmUnLCAn TU9DS19FTlZJUk9OX0NPUFknOiAnMSd9CiBSdW5uaW5nIFB5dGhvbiB1bml0IHRlc3RzCi1NT0NL IHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLXRlc3Qtd2Via2l0cHknXSwgY3dkPS9tb2Nr LWNoZWNrb3V0CitNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLXRlc3Qtd2Via2l0 cHknLCAnLS1yZXN1bHRzLWRpcicsIHUnIiIiICsgZmlsZXN5c3RlbS5qb2luKHdlYmtpdF9maW5k ZXIud2Via2l0X3Jlc3VsdHNfZGlyKCksICJweXRob24tdW5pdHRlc3QtcmVzdWx0cyIpICsgIiIi J10sIGN3ZD0vbW9jay1jaGVja291dAogUnVubmluZyBQZXJsIHVuaXQgdGVzdHMKIE1PQ0sgcnVu X2FuZF90aHJvd19pZl9mYWlsOiBbJ21vY2stdGVzdC13ZWJraXRwZXJsJ10sIGN3ZD0vbW9jay1j aGVja291dAogUnVubmluZyBKYXZhU2NyaXB0Q29yZSB0ZXN0cwpkaWZmIC0tZ2l0IGEvVG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5IGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5CmluZGV4IGE0NTYyOGIuLmM0OWY0Y2MgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0cy5weQor KysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMucHkKQEAgLTMz LDYgKzMzLDggQEAgaW1wb3J0IHN5cwogZnJvbSB3ZWJraXRweS50b29sLnN0ZXBzLmFic3RyYWN0 c3RlcCBpbXBvcnQgQWJzdHJhY3RTdGVwCiBmcm9tIHdlYmtpdHB5LnRvb2wuc3RlcHMub3B0aW9u cyBpbXBvcnQgT3B0aW9ucwogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmV4ZWN1dGl2ZSBp bXBvcnQgU2NyaXB0RXJyb3IKK2Zyb20gd2Via2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1w b3J0IFdlYktpdEZpbmRlcgorZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0g aW1wb3J0IEZpbGVTeXN0ZW0KIAogX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKF9fbmFtZV9fKQog CkBAIC01NSw4ICs1NywxNSBAQCBjbGFzcyBSdW5UZXN0cyhBYnN0cmFjdFN0ZXApOgogCiAgICAg ICAgIGlmIG5vdCBzZWxmLl9vcHRpb25zLm5vbl9pbnRlcmFjdGl2ZToKICAgICAgICAgICAgICMg RklYTUU6IFdlIHNob3VsZCB0ZWFjaCB0aGUgY29tbWl0LXF1ZXVlIGFuZCB0aGUgRVdTIGhvdyB0 byBydW4gdGhlc2UgdGVzdHMuCisgICAgICAgICAgICBmaWxlc3lzdGVtID0gRmlsZVN5c3RlbSgp CisgICAgICAgICAgICB3ZWJraXRfZmluZGVyID0gV2ViS2l0RmluZGVyKGZpbGVzeXN0ZW0pCisg ICAgICAgICAgICBweXRob25fdW5pdHRlc3RzX3Jlc3VsdHNfZGlyID0gZmlsZXN5c3RlbS5qb2lu KHdlYmtpdF9maW5kZXIud2Via2l0X3Jlc3VsdHNfZGlyKCksICJweXRob24tdW5pdHRlc3QtcmVz dWx0cyIpCisgICAgICAgICAgICBmaWxlc3lzdGVtLm1heWJlX21ha2VfZGlyZWN0b3J5KHB5dGhv bl91bml0dGVzdHNfcmVzdWx0c19kaXIpCiAKICAgICAgICAgICAgIHB5dGhvbl91bml0dGVzdHNf Y29tbWFuZCA9IHNlbGYuX3Rvb2wuZGVwcmVjYXRlZF9wb3J0KCkucnVuX3B5dGhvbl91bml0dGVz dHNfY29tbWFuZCgpCisgICAgICAgICAgICBweXRob25fdW5pdHRlc3RzX2NvbW1hbmQuYXBwZW5k KCItLXJlc3VsdHMtZGlyIikKKyAgICAgICAgICAgIHB5dGhvbl91bml0dGVzdHNfY29tbWFuZC5h cHBlbmQocHl0aG9uX3VuaXR0ZXN0c19yZXN1bHRzX2RpcikKKwogICAgICAgICAgICAgaWYgcHl0 aG9uX3VuaXR0ZXN0c19jb21tYW5kOgogICAgICAgICAgICAgICAgIF9sb2cuaW5mbygiUnVubmlu ZyBQeXRob24gdW5pdCB0ZXN0cyIpCiAgICAgICAgICAgICAgICAgc2VsZi5fdG9vbC5leGVjdXRp dmUucnVuX2FuZF90aHJvd19pZl9mYWlsKHB5dGhvbl91bml0dGVzdHNfY29tbWFuZCwgY3dkPXNl bGYuX3Rvb2wuc2NtKCkuY2hlY2tvdXRfcm9vdCkKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weQppbmRleCBiMWUyYmYxLi4yYWYwMWU0 IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5p dHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBzX3Vu aXR0ZXN0LnB5CkBAIC0zMSw2ICszMSw4IEBAIGltcG9ydCB1bml0dGVzdAogZnJvbSB3ZWJraXRw eS5jb21tb24uc3lzdGVtLm91dHB1dGNhcHR1cmUgaW1wb3J0IE91dHB1dENhcHR1cmUKIGZyb20g d2Via2l0cHkuY29tbW9uLmNvbmZpZy5wb3J0cyBpbXBvcnQgRGVwcmVjYXRlZFBvcnQKIGZyb20g d2Via2l0cHkudG9vbC5tb2NrdG9vbCBpbXBvcnQgTW9ja09wdGlvbnMsIE1vY2tUb29sCitmcm9t IHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0uZmlsZXN5c3RlbSBpbXBvcnQgRmlsZVN5c3RlbQorZnJv bSB3ZWJraXRweS5jb21tb24ud2Via2l0X2ZpbmRlciBpbXBvcnQgV2ViS2l0RmluZGVyCiAKIGZy b20gd2Via2l0cHkudG9vbCBpbXBvcnQgc3RlcHMKIApAQCAtOTYsNiArOTgsOCBAQCBjbGFzcyBT dGVwc1Rlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICBzZWxmLl9hc3NlcnRfc3RlcF9v dXRwdXRfd2l0aF9idWcoc3RlcHMuRW5zdXJlQnVnSXNPcGVuQW5kQXNzaWduZWQsIDUwMDAyLCBl eHBlY3RlZF9sb2dzKQogCiAgICAgZGVmIHRlc3RfcnVudGVzdHNfYXJncyhzZWxmKToKKyAgICAg ICAgZmlsZXN5c3RlbSA9IEZpbGVTeXN0ZW0oKQorICAgICAgICB3ZWJraXRfZmluZGVyID0gV2Vi S2l0RmluZGVyKGZpbGVzeXN0ZW0pCiAgICAgICAgIG1vY2tfb3B0aW9ucyA9IHNlbGYuX3N0ZXBf b3B0aW9ucygpCiAgICAgICAgIG1vY2tfb3B0aW9ucy5ub25faW50ZXJhY3RpdmUgPSBGYWxzZQog ICAgICAgICBzdGVwID0gc3RlcHMuUnVuVGVzdHMoTW9ja1Rvb2wobG9nX2V4ZWN1dGl2ZT1UcnVl KSwgbW9ja19vcHRpb25zKQpAQCAtMTA0LDcgKzEwOCw3IEBAIGNsYXNzIFN0ZXBzVGVzdCh1bml0 dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgIHRvb2wuX2RlcHJlY2F0ZWRfcG9ydCA9IERlcHJlY2F0 ZWRQb3J0KCkKICAgICAgICAgc3RlcCA9IHN0ZXBzLlJ1blRlc3RzKHRvb2wsIG1vY2tfb3B0aW9u cykKICAgICAgICAgZXhwZWN0ZWRfbG9ncyA9ICIiIlJ1bm5pbmcgUHl0aG9uIHVuaXQgdGVzdHMK LU1PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ1Rvb2xzL1NjcmlwdHMvdGVzdC13ZWJraXRw eSddLCBjd2Q9L21vY2stY2hlY2tvdXQKK01PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ1Rv b2xzL1NjcmlwdHMvdGVzdC13ZWJraXRweScsICctLXJlc3VsdHMtZGlyJywgdSciIiIgKyBmaWxl c3lzdGVtLmpvaW4od2Via2l0X2ZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIoKSwgInB5dGhvbi11 bml0dGVzdC1yZXN1bHRzIikgKyAiIiInXSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBSdW5uaW5nIFBl cmwgdW5pdCB0ZXN0cwogTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnVG9vbHMvU2NyaXB0 cy90ZXN0LXdlYmtpdHBlcmwnXSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBSdW5uaW5nIEphdmFTY3Jp cHRDb3JlIHRlc3RzCi0tIAoxLjkuMyAoQXBwbGUgR2l0LTUwKQoK 239173 2014-10-02 19:01:29 -0700 2014-10-03 13:43:47 -0700 Fixes help message for --results-dir option, and addresses stylebot's issues 0001-Make-test-webkitpy-generate-a-json-file-of-its-resul.patch text/plain 19011 jake.nielsen.webkit RnJvbSAyODFkMWU3OTM4NTJhMzYxODEwNzA2NjlmNmY1Y2U4ZjU4MDhjMjIyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBUaHUsIDIgT2N0IDIwMTQgMTg6Mzc6NTMgLTA3MDAKU3ViamVjdDogW1BBVENIXSBN YWtlIHRlc3Qtd2Via2l0cHkgZ2VuZXJhdGUgYSBqc29uIGZpbGUgb2YgaXRzIHJlc3VsdHMKIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzczNTMKClJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgoKKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi93ZWJraXRfZmluZGVy LnB5OgpBZGRzIGEgbWV0aG9kIHRvIG1ha2UgaXQgZWFzaWVyIHRvIGZpbmQgdGhlIHdlYmtpdCBy ZXN1bHRzIGRpcmVjdG9yeS4KKFdlYktpdEZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIpOgoqIFNj cmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5OgpBZGRzIHRoZSAtLXJlc3VsdHMtZGlyIG9wdGlv biwgYW5kIGFkZHMgbG9naWMgdG8gZHVtcCBhIGpzb24gZmlsZSBvZgp0aGUgcmVzdWx0cyBpZiAt LXJlc3VsdHMtZGlyIGhhcyBiZWVuIHNwZWNpZmllZC4KKFRlc3Rlci5fX2luaXRfXyk6CihUZXN0 ZXIuX3BhcnNlX2FyZ3MpOgooVGVzdGVyLl9ydW5fdGVzdHMpOgoqIFNjcmlwdHMvd2Via2l0cHkv dGVzdC9yZXN1bHRzLnB5OiBBZGRlZC4KUHJvdmlkZXMgYSBjbGFzcyB0byBlbmNhcHN1bGF0ZSB0 ZXN0IHJlc3VsdHMsIGFuZCB0byBhZGQgaXNvbGF0aW9uCmJldHdlZW4gdGhlIGpzb24gZmlsZSBh bmQgdGhlIHJlc3Qgb2Ygd2Via2l0cHkuCihUZXN0UmVzdWx0KToKKFRlc3RSZXN1bHQudGVzdF9y ZXN1bHRfZnJvbV9qc29uX2RpY3QpOgooVGVzdFJlc3VsdC50ZXN0X3Jlc3VsdF90b19qc29uX2Rp Y3QpOgooVGVzdFJlc3VsdC5fX2luaXRfXyk6CihUZXN0UmVzdWx0LnRlc3RfbmFtZSk6CihUZXN0 UmVzdWx0LmZhaWx1cmVzKToKKFRlc3RSZXN1bHQuZXJyb3JzKToKKFRlc3RSZXN1bHRzKToKKFRl c3RSZXN1bHRzLnRlc3RfcmVzdWx0c19mcm9tX2pzb25fZGljdCk6CihUZXN0UmVzdWx0cy50ZXN0 X3Jlc3VsdHNfdG9fanNvbl9kaWN0KToKKFRlc3RSZXN1bHRzLl9faW5pdF9fKToKKFRlc3RSZXN1 bHRzLmFkZF90ZXN0X3Jlc3VsdCk6CihUZXN0UmVzdWx0cy5saXN0X29mX3Rlc3RfcmVzdWx0cyk6 CihUZXN0UmVzdWx0cy5saXN0X29mX2ZhaWxlZF90ZXN0X3Jlc3VsdHMpOgooVGVzdFJlc3VsdHMu bGlzdF9vZl9lcnJvcmVkX3Rlc3RfcmVzdWx0cyk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1 bm5lci5weToKVGVhY2hlcyBydW5uZXIucHkgdG8gdXNlIFRlc3RSZXN1bHQgb2JqZWN0cyBpbnN0 ZWFkIG9mIGp1c3Qgc3R1ZmZpbmcKZXZlcnl0aGluZyBpbnRvIHR1cGxlcyBhbmQgbGlzdHMuCihS dW5uZXIuX19pbml0X18pOgooUnVubmVyLmhhbmRsZSk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0 L3J1bm5lcl91bml0dGVzdC5weToKVGVhY2hlcyB0ZXN0X3J1biBob3cgdG8gdXNlIFRlc3RSZXN1 bHRzIG9iamVjdHMuCihSdW5uZXJUZXN0LnRlc3RfcnVuKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rv b2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHk6ClVwZGF0ZXMgdGhlIHRlc3RfbGFuZF9j b3doYW5kIHRlc3QgdG8gcHJvcGVybHkgYW50aWNpcGF0ZSB3aGF0IFJ1blRlc3QKc2hvdWxkIGJl IHN0ZG91dGluZy4KKHRlc3RfbGFuZF9jb3doYW5kKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wv c3RlcHMvcnVudGVzdHMucHk6ClRlYWNoZXMgUnVuVGVzdHMgdG8gcGFzcyBhIC0tcmVzdWx0cy1k aXIgdG8gdGVzdC13ZWJraXRweS4KKFJ1blRlc3RzLnJ1bik6CiogU2NyaXB0cy93ZWJraXRweS90 b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5OgpVcGRhdGVzIHRoZSB0ZXN0X3J1bnRlc3RzX2Fy Z3MgdGVzdCB0byBwcm9wZXJseSBhbnRpY2lwYXRlIHdoYXQgUnVuVGVzdApzaG91bGQgYmUgc3Rk b3V0aW5nLgooU3RlcHNUZXN0LnRlc3RfcnVudGVzdHNfYXJncyk6Ci0tLQogVG9vbHMvQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCA1NCArKysrKysrKysrKysr KysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHkgICAgIHwg IDUgKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAgICAgICAg IHwgMTAgKystCiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5weSAgICAgICAg ICAgICB8IDc4ICsrKysrKysrKysrKysrKysrKysrKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dGVzdC9ydW5uZXIucHkgICAgICAgICAgICAgIHwgMTIgKystLQogVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90ZXN0L3J1bm5lcl91bml0dGVzdC5weSAgICAgfCAgNiArLQogLi4uL3dlYmtpdHB5L3Rv b2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHkgICAgfCAgNiArLQogVG9vbHMvU2NyaXB0 cy93ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5ICAgICAgfCAgOSArKysKIC4uLi9TY3Jp cHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkgIHwgIDYgKy0KIDkgZmls ZXMgY2hhbmdlZCwgMTcyIGluc2VydGlvbnMoKyksIDE0IGRlbGV0aW9ucygtKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5CgpkaWZmIC0t Z2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDRmNDNiZWMuLmQ5 NDRmZjggMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cK QEAgLTEsMyArMSw1NyBAQAorMjAxNC0xMC0wMiAgSmFrZSBOaWVsc2VuICA8amFjb2JfbmllbHNl bkBhcHBsZS5jb20+CisKKyAgICAgICAgTWFrZSB0ZXN0LXdlYmtpdHB5IGdlbmVyYXRlIGEganNv biBmaWxlIG9mIGl0cyByZXN1bHRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xMzczNTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHk6 CisgICAgICAgIEFkZHMgYSBtZXRob2QgdG8gbWFrZSBpdCBlYXNpZXIgdG8gZmluZCB0aGUgd2Vi a2l0IHJlc3VsdHMgZGlyZWN0b3J5LgorICAgICAgICAoV2ViS2l0RmluZGVyLndlYmtpdF9yZXN1 bHRzX2Rpcik6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHk6CisgICAg ICAgIEFkZHMgdGhlIC0tcmVzdWx0cy1kaXIgb3B0aW9uLCBhbmQgYWRkcyBsb2dpYyB0byBkdW1w IGEganNvbiBmaWxlIG9mCisgICAgICAgIHRoZSByZXN1bHRzIGlmIC0tcmVzdWx0cy1kaXIgaGFz IGJlZW4gc3BlY2lmaWVkLgorICAgICAgICAoVGVzdGVyLl9faW5pdF9fKToKKyAgICAgICAgKFRl c3Rlci5fcGFyc2VfYXJncyk6CisgICAgICAgIChUZXN0ZXIuX3J1bl90ZXN0cyk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS90ZXN0L3Jlc3VsdHMucHk6IEFkZGVkLgorICAgICAgICBQcm92 aWRlcyBhIGNsYXNzIHRvIGVuY2Fwc3VsYXRlIHRlc3QgcmVzdWx0cywgYW5kIHRvIGFkZCBpc29s YXRpb24KKyAgICAgICAgYmV0d2VlbiB0aGUganNvbiBmaWxlIGFuZCB0aGUgcmVzdCBvZiB3ZWJr aXRweS4KKyAgICAgICAgKFRlc3RSZXN1bHQpOgorICAgICAgICAoVGVzdFJlc3VsdC50ZXN0X3Jl c3VsdF9mcm9tX2pzb25fZGljdCk6CisgICAgICAgIChUZXN0UmVzdWx0LnRlc3RfcmVzdWx0X3Rv X2pzb25fZGljdCk6CisgICAgICAgIChUZXN0UmVzdWx0Ll9faW5pdF9fKToKKyAgICAgICAgKFRl c3RSZXN1bHQudGVzdF9uYW1lKToKKyAgICAgICAgKFRlc3RSZXN1bHQuZmFpbHVyZXMpOgorICAg ICAgICAoVGVzdFJlc3VsdC5lcnJvcnMpOgorICAgICAgICAoVGVzdFJlc3VsdHMpOgorICAgICAg ICAoVGVzdFJlc3VsdHMudGVzdF9yZXN1bHRzX2Zyb21fanNvbl9kaWN0KToKKyAgICAgICAgKFRl c3RSZXN1bHRzLnRlc3RfcmVzdWx0c190b19qc29uX2RpY3QpOgorICAgICAgICAoVGVzdFJlc3Vs dHMuX19pbml0X18pOgorICAgICAgICAoVGVzdFJlc3VsdHMuYWRkX3Rlc3RfcmVzdWx0KToKKyAg ICAgICAgKFRlc3RSZXN1bHRzLmxpc3Rfb2ZfdGVzdF9yZXN1bHRzKToKKyAgICAgICAgKFRlc3RS ZXN1bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cyk6CisgICAgICAgIChUZXN0UmVzdWx0 cy5saXN0X29mX2Vycm9yZWRfdGVzdF9yZXN1bHRzKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L3Rlc3QvcnVubmVyLnB5OgorICAgICAgICBUZWFjaGVzIHJ1bm5lci5weSB0byB1c2UgVGVz dFJlc3VsdCBvYmplY3RzIGluc3RlYWQgb2YganVzdCBzdHVmZmluZworICAgICAgICBldmVyeXRo aW5nIGludG8gdHVwbGVzIGFuZCBsaXN0cy4KKyAgICAgICAgKFJ1bm5lci5fX2luaXRfXyk6Cisg ICAgICAgIChSdW5uZXIuaGFuZGxlKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rlc3Qv cnVubmVyX3VuaXR0ZXN0LnB5OgorICAgICAgICBUZWFjaGVzIHRlc3RfcnVuIGhvdyB0byB1c2Ug VGVzdFJlc3VsdHMgb2JqZWN0cy4KKyAgICAgICAgKFJ1bm5lclRlc3QudGVzdF9ydW4pOgorICAg ICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91bml0dGVzdC5w eToKKyAgICAgICAgVXBkYXRlcyB0aGUgdGVzdF9sYW5kX2Nvd2hhbmQgdGVzdCB0byBwcm9wZXJs eSBhbnRpY2lwYXRlIHdoYXQgUnVuVGVzdAorICAgICAgICBzaG91bGQgYmUgc3Rkb3V0aW5nLgor ICAgICAgICAodGVzdF9sYW5kX2Nvd2hhbmQpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkv dG9vbC9zdGVwcy9ydW50ZXN0cy5weToKKyAgICAgICAgVGVhY2hlcyBSdW5UZXN0cyB0byBwYXNz IGEgLS1yZXN1bHRzLWRpciB0byB0ZXN0LXdlYmtpdHB5LgorICAgICAgICAoUnVuVGVzdHMucnVu KToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3Qu cHk6CisgICAgICAgIFVwZGF0ZXMgdGhlIHRlc3RfcnVudGVzdHNfYXJncyB0ZXN0IHRvIHByb3Bl cmx5IGFudGljaXBhdGUgd2hhdCBSdW5UZXN0CisgICAgICAgIHNob3VsZCBiZSBzdGRvdXRpbmcu CisgICAgICAgIChTdGVwc1Rlc3QudGVzdF9ydW50ZXN0c19hcmdzKToKKwogMjAxNC0xMC0wMiAg Q2FybG9zIEFsYmVydG8gTG9wZXogUGVyZXogIDxjbG9wZXpAaWdhbGlhLmNvbT4KIAogICAgICAg ICBbR1RLXSBbSkhCdWlsZF0gU3dpdGNoIHNvdXJjZXdhcmUub3JnIG1pcnJvciB0byBodHRwLgpk aWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vd2Via2l0X2ZpbmRlci5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHkKaW5kZXgg N2I5YzAxNC4uNTQyZWFhOCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vd2Via2l0X2ZpbmRlci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi93 ZWJraXRfZmluZGVyLnB5CkBAIC0zMiw2ICszMiwxMSBAQCBjbGFzcyBXZWJLaXRGaW5kZXIob2Jq ZWN0KToKICAgICAgICAgc2VsZi5fZmlsZXN5c3RlbSA9IGZpbGVzeXN0ZW0KICAgICAgICAgc2Vs Zi5fd2Via2l0X2Jhc2UgPSBOb25lCiAKKyAgICBkZWYgd2Via2l0X3Jlc3VsdHNfZGlyKHNlbGYp OgorICAgICAgICBwYXRoX3RvX2J1aWxkX2RpciA9IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxm LndlYmtpdF9iYXNlKCksICJXZWJLaXRCdWlsZCIpCisgICAgICAgIGNvbmZpZ3VyYXRpb25fZGly ID0gc2VsZi5fZmlsZXN5c3RlbS5yZWFkX3RleHRfZmlsZShzZWxmLl9maWxlc3lzdGVtLmpvaW4o cGF0aF90b19idWlsZF9kaXIsICJDb25maWd1cmF0aW9uIikpCisgICAgICAgIHJldHVybiBzZWxm Ll9maWxlc3lzdGVtLmpvaW4ocGF0aF90b19idWlsZF9kaXIsIGNvbmZpZ3VyYXRpb25fZGlyKQor CiAgICAgZGVmIHdlYmtpdF9iYXNlKHNlbGYpOgogICAgICAgICAiIiJSZXR1cm5zIHRoZSBhYnNv bHV0ZSBwYXRoIHRvIHRoZSB0b3Agb2YgdGhlIFdlYktpdCB0cmVlLgogCmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdGVzdC9tYWluLnB5CmluZGV4IGY1MThiNTEuLjYzN2NlOWMgMTAwNjQ0Ci0tLSBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdGVzdC9tYWluLnB5CkBAIC0zMiw3ICszMiw5IEBAIGltcG9ydCBzeXMKIGltcG9ydCB0aW1l CiBpbXBvcnQgdHJhY2ViYWNrCiBpbXBvcnQgdW5pdHRlc3QKK2ltcG9ydCBqc29uCiAKK2Zyb20g d2Via2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktpdEZpbmRlcgogZnJvbSB3 ZWJraXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZpbGVTeXN0ZW0KIGZyb20g d2Via2l0cHkudGVzdC5maW5kZXIgaW1wb3J0IEZpbmRlcgogZnJvbSB3ZWJraXRweS50ZXN0LnBy aW50ZXIgaW1wb3J0IFByaW50ZXIKQEAgLTc0LDcgKzc2LDggQEAgZGVmIG1haW4oKToKIAogY2xh c3MgVGVzdGVyKG9iamVjdCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIGZpbGVzeXN0ZW09Tm9u ZSk6Ci0gICAgICAgIHNlbGYuZmluZGVyID0gRmluZGVyKGZpbGVzeXN0ZW0gb3IgRmlsZVN5c3Rl bSgpKQorICAgICAgICBzZWxmLl9maWxlc3lzdGVtID0gZmlsZXN5c3RlbSBvciBGaWxlU3lzdGVt KCkKKyAgICAgICAgc2VsZi5maW5kZXIgPSBGaW5kZXIoc2VsZi5fZmlsZXN5c3RlbSkKICAgICAg ICAgc2VsZi5wcmludGVyID0gUHJpbnRlcihzeXMuc3RkZXJyKQogICAgICAgICBzZWxmLl9vcHRp b25zID0gTm9uZQogCkBAIC0xMDIsNiArMTA1LDggQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAg ICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2Rpc3BsYXkgcGVyLXRlc3QgZXhlY3V0aW9u IHRpbWUgKGltcGxpZXMgLS12ZXJib3NlKScpCiAgICAgICAgIHBhcnNlci5hZGRfb3B0aW9uKCct dicsICctLXZlcmJvc2UnLCBhY3Rpb249J2NvdW50JywgZGVmYXVsdD0wLAogICAgICAgICAgICAg ICAgICAgICAgICAgICBoZWxwPSd2ZXJib3NlIG91dHB1dCAoc3BlY2lmeSBvbmNlIGZvciBpbmRp dmlkdWFsIHRlc3QgcmVzdWx0cywgdHdpY2UgZm9yIGRlYnVnIG1lc3NhZ2VzKScpCisgICAgICAg IHBhcnNlci5hZGRfb3B0aW9uKCctcicsICctLXJlc3VsdHMtZGlyJywgYWN0aW9uPSdzdG9yZScs IGRlZmF1bHQ9IiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3NwZWNpZmllcyBh IGRpcmVjdG9yeSBpbiB3aGljaCB0byBnZW5lcmF0ZSBhIGpzb24gZmlsZSB0aGF0IGNvbnRhaW5z IHRoZSByZXN1bHRzIG9mIHRoZSB0ZXN0cycpCiAKICAgICAgICAgcGFyc2VyLmVwaWxvZyA9ICgn W2FyZ3MuLi5dIGlzIGFuIG9wdGlvbmFsIGxpc3Qgb2YgbW9kdWxlcywgdGVzdF9jbGFzc2VzLCBv ciBpbmRpdmlkdWFsIHRlc3RzLiAnCiAgICAgICAgICAgICAgICAgICAgICAgICAgJ0lmIG5vIGFy Z3MgYXJlIGdpdmVuLCBhbGwgdGhlIHRlc3RzIHdpbGwgYmUgcnVuLicpCkBAIC0xNjIsNiArMTY3 LDkgQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAKICAgICAgICAgc2VsZi5wcmludGVyLnByaW50 X3Jlc3VsdCh0aW1lLnRpbWUoKSAtIHN0YXJ0KQogCisgICAgICAgIGlmIHNlbGYuX29wdGlvbnMu cmVzdWx0c19kaXI6CisgICAgICAgICAgICBzZWxmLl9maWxlc3lzdGVtLndyaXRlX3RleHRfZmls ZShzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1bHRzX2RpciwgInJlc3Vs dHMuanNvbiIpLCBqc29uLmR1bXBzKHRlc3RfcnVubmVyLnRlc3RfcmVzdWx0cy50ZXN0X3Jlc3Vs dHNfdG9fanNvbl9kaWN0KCkpKQorCiAgICAgICAgIGlmIHNlbGYuX29wdGlvbnMuY292ZXJhZ2U6 CiAgICAgICAgICAgICBjb3Yuc3RvcCgpCiAgICAgICAgICAgICBjb3Yuc2F2ZSgpCmRpZmYgLS1n aXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5weSBiL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLmMyMmZiNDEKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L3Rlc3QvcmVzdWx0cy5weQpAQCAtMCwwICsxLDc4IEBACisjIENvcHlyaWdodCAoQykgMjAxNCBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyMgYXJlIG1ldDoKKyMgMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuICBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor IyAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorIyAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBB TkQKKyMgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyMgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorIyBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUgorIyBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCisjIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SCisjIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KSBIT1dFVkVSCisjIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksCisjIE9SIFRPUlQgKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF CisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisKK2ltcG9ydCBsb2dnaW5nCitfbG9nID0gbG9nZ2luZy5nZXRMb2dn ZXIoX19uYW1lX18pCisKKworY2xhc3MgVGVzdFJlc3VsdChvYmplY3QpOgorICAgIEBjbGFzc21l dGhvZAorICAgIGRlZiB0ZXN0X3Jlc3VsdF9mcm9tX2pzb25fZGljdChjbHMsIGpzb25fZGljdCk6 CisgICAgICAgIHJldHVybiBjbHMoanNvbl9kaWN0Wyd0ZXN0X25hbWUnXSwganNvbl9kaWN0Wydm YWlsdXJlcyddLCBqc29uX2RpY3RbJ2Vycm9ycyddKQorCisgICAgZGVmIHRlc3RfcmVzdWx0X3Rv X2pzb25fZGljdChzZWxmKToKKyAgICAgICAganNvbl9kaWN0ID0ge30KKyAgICAgICAganNvbl9k aWN0Wyd0ZXN0X25hbWUnXSA9IHNlbGYuX3Rlc3RfbmFtZQorICAgICAgICBqc29uX2RpY3RbJ2Zh aWx1cmVzJ10gPSBzZWxmLl9mYWlsdXJlcworICAgICAgICBqc29uX2RpY3RbJ2Vycm9ycyddID0g c2VsZi5fZXJyb3JzCisgICAgICAgIHJldHVybiBqc29uX2RpY3QKKworICAgIGRlZiBfX2luaXRf XyhzZWxmLCB0ZXN0X25hbWUsIGZhaWx1cmVzPU5vbmUsIGVycm9ycz1Ob25lKToKKyAgICAgICAg c2VsZi5fdGVzdF9uYW1lID0gdGVzdF9uYW1lCisgICAgICAgIHNlbGYuX2ZhaWx1cmVzID0gZmFp bHVyZXMKKyAgICAgICAgc2VsZi5fZXJyb3JzID0gZXJyb3JzCisKKyAgICBkZWYgdGVzdF9uYW1l KHNlbGYpOgorICAgICAgICByZXR1cm4gc2VsZi5fdGVzdF9uYW1lCisKKyAgICBkZWYgZmFpbHVy ZXMoc2VsZik6CisgICAgICAgIHJldHVybiBzZWxmLl9mYWlsdXJlcworCisgICAgZGVmIGVycm9y cyhzZWxmKToKKyAgICAgICAgcmV0dXJuIHNlbGYuX2Vycm9ycworCisKK2NsYXNzIFRlc3RSZXN1 bHRzKG9iamVjdCk6CisgICAgQGNsYXNzbWV0aG9kCisgICAgZGVmIHRlc3RfcmVzdWx0c19mcm9t X2pzb25fZGljdChjbHMsIGpzb25fZGljdCk6CisgICAgICAgIGxpc3Rfb2ZfdGVzdF9yZXN1bHRz ID0gW1Rlc3RSZXN1bHQudGVzdF9yZXN1bHRfZnJvbV9qc29uX2RpY3QoanNvbl9yZXN1bHQpIGZv ciBqc29uX3Jlc3VsdCBpbiBqc29uX2RpY3RbJ2xpc3Rfb2ZfdGVzdF9yZXN1bHRzJ11dCisgICAg ICAgIHJldHVybiBjbHMobGlzdF9vZl90ZXN0X3Jlc3VsdHMpCisKKyAgICBkZWYgdGVzdF9yZXN1 bHRzX3RvX2pzb25fZGljdChzZWxmKToKKyAgICAgICAganNvbl9kaWN0ID0ge30KKyAgICAgICAg anNvbl9kaWN0WydsaXN0X29mX3Rlc3RfcmVzdWx0cyddID0gW3Jlc3VsdC50ZXN0X3Jlc3VsdF90 b19qc29uX2RpY3QoKSBmb3IgcmVzdWx0IGluIHNlbGYuX2xpc3Rfb2ZfdGVzdF9yZXN1bHRzXQor ICAgICAgICByZXR1cm4ganNvbl9kaWN0CisKKyAgICBkZWYgX19pbml0X18oc2VsZiwgbGlzdF9v Zl90ZXN0X3Jlc3VsdHM9W10pOgorICAgICAgICBzZWxmLl9saXN0X29mX3Rlc3RfcmVzdWx0cyA9 IGxpc3Rfb2ZfdGVzdF9yZXN1bHRzCisKKyAgICBkZWYgYWRkX3Rlc3RfcmVzdWx0KHNlbGYsIHRl c3QpOgorICAgICAgICBzZWxmLl9saXN0X29mX3Rlc3RfcmVzdWx0cy5hcHBlbmQodGVzdCkKKwor ICAgIGRlZiBsaXN0X29mX3Rlc3RfcmVzdWx0cyhzZWxmKToKKyAgICAgICAgcmV0dXJuIHNlbGYu X2xpc3Rfb2ZfdGVzdF9yZXN1bHRzCisKKyAgICBkZWYgbGlzdF9vZl9mYWlsZWRfdGVzdF9yZXN1 bHRzKHNlbGYpOgorICAgICAgICByZXR1cm4gW3Jlc3VsdCBmb3IgcmVzdWx0IGluIHNlbGYuX2xp c3Rfb2ZfdGVzdF9yZXN1bHRzIGlmIHJlc3VsdC5mYWlsdXJlcygpXQorCisgICAgZGVmIGxpc3Rf b2ZfZXJyb3JlZF90ZXN0X3Jlc3VsdHMoc2VsZik6CisgICAgICAgIHJldHVybiBbcmVzdWx0IGZv ciByZXN1bHQgaW4gc2VsZi5fbGlzdF9vZl90ZXN0X3Jlc3VsdHMgaWYgcmVzdWx0LmVycm9ycygp XQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lci5weSBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHkKaW5kZXggZDNmNTc2NC4uN2Q0OTQ0 YiAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lci5weQorKysg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyLnB5CkBAIC0yNyw2ICsyNyw3IEBA IGltcG9ydCB0aW1lCiBpbXBvcnQgdW5pdHRlc3QKIAogZnJvbSB3ZWJraXRweS5jb21tb24gaW1w b3J0IG1lc3NhZ2VfcG9vbAorZnJvbSB3ZWJraXRweS50ZXN0LnJlc3VsdHMgaW1wb3J0IFRlc3RS ZXN1bHQsIFRlc3RSZXN1bHRzCiAKIF90ZXN0X2Rlc2NyaXB0aW9uID0gcmUuY29tcGlsZSgiKFx3 KykgXCgoW1x3Ll0rKVwpIikKIApAQCAtNDAsOSArNDEsNyBAQCBjbGFzcyBSdW5uZXIob2JqZWN0 KToKICAgICBkZWYgX19pbml0X18oc2VsZiwgcHJpbnRlciwgbG9hZGVyKToKICAgICAgICAgc2Vs Zi5wcmludGVyID0gcHJpbnRlcgogICAgICAgICBzZWxmLmxvYWRlciA9IGxvYWRlcgotICAgICAg ICBzZWxmLnRlc3RzX3J1biA9IDAKLSAgICAgICAgc2VsZi5lcnJvcnMgPSBbXQotICAgICAgICBz ZWxmLmZhaWx1cmVzID0gW10KKyAgICAgICAgc2VsZi50ZXN0X3Jlc3VsdHMgPSBUZXN0UmVzdWx0 cygpCiAgICAgICAgIHNlbGYud29ya2VyX2ZhY3RvcnkgPSBsYW1iZGEgY2FsbGVyOiBfV29ya2Vy KGNhbGxlciwgc2VsZi5sb2FkZXIpCiAKICAgICBkZWYgcnVuKHNlbGYsIHRlc3RfbmFtZXMsIG51 bV93b3JrZXJzKToKQEAgLTU3LDExICs1Niw4IEBAIGNsYXNzIFJ1bm5lcihvYmplY3QpOgogICAg ICAgICAgICAgc2VsZi5wcmludGVyLnByaW50X3N0YXJ0ZWRfdGVzdChzb3VyY2UsIHRlc3RfbmFt ZSkKICAgICAgICAgICAgIHJldHVybgogCi0gICAgICAgIHNlbGYudGVzdHNfcnVuICs9IDEKLSAg ICAgICAgaWYgZmFpbHVyZXM6Ci0gICAgICAgICAgICBzZWxmLmZhaWx1cmVzLmFwcGVuZCgodGVz dF9uYW1lLCBmYWlsdXJlcykpCi0gICAgICAgIGlmIGVycm9yczoKLSAgICAgICAgICAgIHNlbGYu ZXJyb3JzLmFwcGVuZCgodGVzdF9uYW1lLCBlcnJvcnMpKQorICAgICAgICBzZWxmLnRlc3RfcmVz dWx0cy5hZGRfdGVzdF9yZXN1bHQoVGVzdFJlc3VsdCh0ZXN0X25hbWUsIGZhaWx1cmVzLCBlcnJv cnMpKQorCiAgICAgICAgIHNlbGYucHJpbnRlci5wcmludF9maW5pc2hlZF90ZXN0KHNvdXJjZSwg dGVzdF9uYW1lLCBkZWxheSwgZmFpbHVyZXMsIGVycm9ycykKIAogCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS90ZXN0L3J1bm5lcl91bml0dGVzdC5weQppbmRleCA5OTUwNzBiLi5hOWM2MWVj IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0 LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXJfdW5pdHRlc3QucHkK QEAgLTkyLDYgKzkyLDYgQEAgY2xhc3MgUnVubmVyVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgKCd0ZXN0MyAoRm9vKScsICdFJywgJ3Rlc3QzXG5l cnJlZCcpKQogICAgICAgICBydW5uZXIgPSBSdW5uZXIoUHJpbnRlcihzdHJlYW0sIG9wdGlvbnMp LCBsb2FkZXIpCiAgICAgICAgIHJ1bm5lci5ydW4oWydGb28udGVzdDEnLCAnRm9vLnRlc3QyJywg J0Zvby50ZXN0MyddLCAxKQotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHJ1bm5lci50ZXN0c19y dW4sIDMpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci5mYWlsdXJlcyksIDEp Ci0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci5lcnJvcnMpLCAxKQorICAgICAg ICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5uZXIudGVzdF9yZXN1bHRzLmxpc3Rfb2ZfdGVzdF9y ZXN1bHRzKCkpLCAzKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5uZXIudGVzdF9y ZXN1bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cygpKSwgMSkKKyAgICAgICAgc2VsZi5h c3NlcnRFcXVhbChsZW4ocnVubmVyLnRlc3RfcmVzdWx0cy5saXN0X29mX2Vycm9yZWRfdGVzdF9y ZXN1bHRzKCkpLCAxKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2Nv bW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29s L2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5CmluZGV4IDU5YjUyZWEuLjBhYzZkMDYgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91 bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93 bmxvYWRfdW5pdHRlc3QucHkKQEAgLTM0LDYgKzM0LDggQEAgZnJvbSB3ZWJraXRweS50b29sLmNv bW1hbmRzLmNvbW1hbmR0ZXN0IGltcG9ydCBDb21tYW5kc1Rlc3QKIGZyb20gd2Via2l0cHkudG9v bC5jb21tYW5kcy5kb3dubG9hZCBpbXBvcnQgKgogZnJvbSB3ZWJraXRweS50b29sLm1vY2t0b29s IGltcG9ydCBNb2NrT3B0aW9ucywgTW9ja1Rvb2wKIGZyb20gd2Via2l0cHkuY29tbW9uLmNoZWNr b3V0LmNoZWNrb3V0X21vY2sgaW1wb3J0IE1vY2tDaGVja291dAorZnJvbSB3ZWJraXRweS5jb21t b24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZpbGVTeXN0ZW0KK2Zyb20gd2Via2l0cHkuY29t bW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktpdEZpbmRlcgogCiAKIGNsYXNzIEFic3RyYWN0 Um9sbG91dFByZXBDb21tYW5kVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CkBAIC0xNTYsNiArMTU4 LDggQEAgVXBkYXRpbmcgYnVnIDUwMDAwCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobW9ja190 b29sLmNoZWNrb3V0KCkubW9kaWZpZWRfY2hhbmdlbG9ncy5jYWxsX2NvdW50LCAxKQogCiAgICAg ZGVmIHRlc3RfbGFuZF9jb3doYW5kKHNlbGYpOgorICAgICAgICBmaWxlc3lzdGVtID0gRmlsZVN5 c3RlbSgpCisgICAgICAgIHdlYmtpdF9maW5kZXIgPSBXZWJLaXRGaW5kZXIoZmlsZXN5c3RlbSkK ICAgICAgICAgZXhwZWN0ZWRfbG9ncyA9ICIiIk1PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBb J21vY2stcHJlcGFyZS1DaGFuZ2VMb2cnLCAnLS1lbWFpbD1NT0NLIGVtYWlsJywgJy0tbWVyZ2Ut YmFzZT1Ob25lJywgJ01vY2tGaWxlMSddLCBjd2Q9L21vY2stY2hlY2tvdXQKIE1PQ0sgcnVuX2Fu ZF90aHJvd19pZl9mYWlsOiBbJ21vY2stY2hlY2std2Via2l0LXN0eWxlJywgJy0tZ2l0LWNvbW1p dCcsICdNT0NLIGdpdCBjb21taXQnLCAnLS1kaWZmLWZpbGVzJywgJ01vY2tGaWxlMScsICctLWZp bHRlcicsICctY2hhbmdlbG9nJ10sIGN3ZD0vbW9jay1jaGVja291dAogTU9DSyBydW5fY29tbWFu ZDogWydydWJ5JywgJy1JJywgJy9tb2NrLWNoZWNrb3V0L1dlYnNpdGVzL2J1Z3Mud2Via2l0Lm9y Zy9QcmV0dHlQYXRjaCcsICcvbW9jay1jaGVja291dC9XZWJzaXRlcy9idWdzLndlYmtpdC5vcmcv UHJldHR5UGF0Y2gvcHJldHRpZnkucmInXSwgY3dkPU5vbmUsIGlucHV0PVBhdGNoMQpAQCAtMTY0 LDcgKzE2OCw3IEBAIFdhcyB0aGF0IGRpZmYgY29ycmVjdD8KIEJ1aWxkaW5nIFdlYktpdAogTU9D SyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnbW9jay1idWlsZC13ZWJraXQnXSwgY3dkPS9tb2Nr LWNoZWNrb3V0LCBlbnY9eydMQ19BTEwnOiAnQycsICdURVJNJzogJ25vbmUnLCAnTU9DS19FTlZJ Uk9OX0NPUFknOiAnMSd9CiBSdW5uaW5nIFB5dGhvbiB1bml0IHRlc3RzCi1NT0NLIHJ1bl9hbmRf dGhyb3dfaWZfZmFpbDogWydtb2NrLXRlc3Qtd2Via2l0cHknXSwgY3dkPS9tb2NrLWNoZWNrb3V0 CitNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLXRlc3Qtd2Via2l0cHknLCAnLS1y ZXN1bHRzLWRpcicsIHUnIiIiICsgZmlsZXN5c3RlbS5qb2luKHdlYmtpdF9maW5kZXIud2Via2l0 X3Jlc3VsdHNfZGlyKCksICJweXRob24tdW5pdHRlc3QtcmVzdWx0cyIpICsgIiIiJ10sIGN3ZD0v bW9jay1jaGVja291dAogUnVubmluZyBQZXJsIHVuaXQgdGVzdHMKIE1PQ0sgcnVuX2FuZF90aHJv d19pZl9mYWlsOiBbJ21vY2stdGVzdC13ZWJraXRwZXJsJ10sIGN3ZD0vbW9jay1jaGVja291dAog UnVubmluZyBKYXZhU2NyaXB0Q29yZSB0ZXN0cwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90 b29sL3N0ZXBzL3J1bnRlc3RzLnB5CmluZGV4IGE0NTYyOGIuLmM0OWY0Y2MgMTAwNjQ0Ci0tLSBh L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0cy5weQorKysgYi9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMucHkKQEAgLTMzLDYgKzMzLDgg QEAgaW1wb3J0IHN5cwogZnJvbSB3ZWJraXRweS50b29sLnN0ZXBzLmFic3RyYWN0c3RlcCBpbXBv cnQgQWJzdHJhY3RTdGVwCiBmcm9tIHdlYmtpdHB5LnRvb2wuc3RlcHMub3B0aW9ucyBpbXBvcnQg T3B0aW9ucwogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmV4ZWN1dGl2ZSBpbXBvcnQgU2Ny aXB0RXJyb3IKK2Zyb20gd2Via2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktp dEZpbmRlcgorZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZp bGVTeXN0ZW0KIAogX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKF9fbmFtZV9fKQogCkBAIC01NSw4 ICs1NywxNSBAQCBjbGFzcyBSdW5UZXN0cyhBYnN0cmFjdFN0ZXApOgogCiAgICAgICAgIGlmIG5v dCBzZWxmLl9vcHRpb25zLm5vbl9pbnRlcmFjdGl2ZToKICAgICAgICAgICAgICMgRklYTUU6IFdl IHNob3VsZCB0ZWFjaCB0aGUgY29tbWl0LXF1ZXVlIGFuZCB0aGUgRVdTIGhvdyB0byBydW4gdGhl c2UgdGVzdHMuCisgICAgICAgICAgICBmaWxlc3lzdGVtID0gRmlsZVN5c3RlbSgpCisgICAgICAg ICAgICB3ZWJraXRfZmluZGVyID0gV2ViS2l0RmluZGVyKGZpbGVzeXN0ZW0pCisgICAgICAgICAg ICBweXRob25fdW5pdHRlc3RzX3Jlc3VsdHNfZGlyID0gZmlsZXN5c3RlbS5qb2luKHdlYmtpdF9m aW5kZXIud2Via2l0X3Jlc3VsdHNfZGlyKCksICJweXRob24tdW5pdHRlc3QtcmVzdWx0cyIpCisg ICAgICAgICAgICBmaWxlc3lzdGVtLm1heWJlX21ha2VfZGlyZWN0b3J5KHB5dGhvbl91bml0dGVz dHNfcmVzdWx0c19kaXIpCiAKICAgICAgICAgICAgIHB5dGhvbl91bml0dGVzdHNfY29tbWFuZCA9 IHNlbGYuX3Rvb2wuZGVwcmVjYXRlZF9wb3J0KCkucnVuX3B5dGhvbl91bml0dGVzdHNfY29tbWFu ZCgpCisgICAgICAgICAgICBweXRob25fdW5pdHRlc3RzX2NvbW1hbmQuYXBwZW5kKCItLXJlc3Vs dHMtZGlyIikKKyAgICAgICAgICAgIHB5dGhvbl91bml0dGVzdHNfY29tbWFuZC5hcHBlbmQocHl0 aG9uX3VuaXR0ZXN0c19yZXN1bHRzX2RpcikKKwogICAgICAgICAgICAgaWYgcHl0aG9uX3VuaXR0 ZXN0c19jb21tYW5kOgogICAgICAgICAgICAgICAgIF9sb2cuaW5mbygiUnVubmluZyBQeXRob24g dW5pdCB0ZXN0cyIpCiAgICAgICAgICAgICAgICAgc2VsZi5fdG9vbC5leGVjdXRpdmUucnVuX2Fu ZF90aHJvd19pZl9mYWlsKHB5dGhvbl91bml0dGVzdHNfY29tbWFuZCwgY3dkPXNlbGYuX3Rvb2wu c2NtKCkuY2hlY2tvdXRfcm9vdCkKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv dG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9v bC9zdGVwcy9zdGVwc191bml0dGVzdC5weQppbmRleCBiMWUyYmYxLi4yYWYwMWU0IDEwMDY0NAot LS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkK KysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5 CkBAIC0zMSw2ICszMSw4IEBAIGltcG9ydCB1bml0dGVzdAogZnJvbSB3ZWJraXRweS5jb21tb24u c3lzdGVtLm91dHB1dGNhcHR1cmUgaW1wb3J0IE91dHB1dENhcHR1cmUKIGZyb20gd2Via2l0cHku Y29tbW9uLmNvbmZpZy5wb3J0cyBpbXBvcnQgRGVwcmVjYXRlZFBvcnQKIGZyb20gd2Via2l0cHku dG9vbC5tb2NrdG9vbCBpbXBvcnQgTW9ja09wdGlvbnMsIE1vY2tUb29sCitmcm9tIHdlYmtpdHB5 LmNvbW1vbi5zeXN0ZW0uZmlsZXN5c3RlbSBpbXBvcnQgRmlsZVN5c3RlbQorZnJvbSB3ZWJraXRw eS5jb21tb24ud2Via2l0X2ZpbmRlciBpbXBvcnQgV2ViS2l0RmluZGVyCiAKIGZyb20gd2Via2l0 cHkudG9vbCBpbXBvcnQgc3RlcHMKIApAQCAtOTYsNiArOTgsOCBAQCBjbGFzcyBTdGVwc1Rlc3Qo dW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICBzZWxmLl9hc3NlcnRfc3RlcF9vdXRwdXRfd2l0 aF9idWcoc3RlcHMuRW5zdXJlQnVnSXNPcGVuQW5kQXNzaWduZWQsIDUwMDAyLCBleHBlY3RlZF9s b2dzKQogCiAgICAgZGVmIHRlc3RfcnVudGVzdHNfYXJncyhzZWxmKToKKyAgICAgICAgZmlsZXN5 c3RlbSA9IEZpbGVTeXN0ZW0oKQorICAgICAgICB3ZWJraXRfZmluZGVyID0gV2ViS2l0RmluZGVy KGZpbGVzeXN0ZW0pCiAgICAgICAgIG1vY2tfb3B0aW9ucyA9IHNlbGYuX3N0ZXBfb3B0aW9ucygp CiAgICAgICAgIG1vY2tfb3B0aW9ucy5ub25faW50ZXJhY3RpdmUgPSBGYWxzZQogICAgICAgICBz dGVwID0gc3RlcHMuUnVuVGVzdHMoTW9ja1Rvb2wobG9nX2V4ZWN1dGl2ZT1UcnVlKSwgbW9ja19v cHRpb25zKQpAQCAtMTA0LDcgKzEwOCw3IEBAIGNsYXNzIFN0ZXBzVGVzdCh1bml0dGVzdC5UZXN0 Q2FzZSk6CiAgICAgICAgIHRvb2wuX2RlcHJlY2F0ZWRfcG9ydCA9IERlcHJlY2F0ZWRQb3J0KCkK ICAgICAgICAgc3RlcCA9IHN0ZXBzLlJ1blRlc3RzKHRvb2wsIG1vY2tfb3B0aW9ucykKICAgICAg ICAgZXhwZWN0ZWRfbG9ncyA9ICIiIlJ1bm5pbmcgUHl0aG9uIHVuaXQgdGVzdHMKLU1PQ0sgcnVu X2FuZF90aHJvd19pZl9mYWlsOiBbJ1Rvb2xzL1NjcmlwdHMvdGVzdC13ZWJraXRweSddLCBjd2Q9 L21vY2stY2hlY2tvdXQKK01PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ1Rvb2xzL1Njcmlw dHMvdGVzdC13ZWJraXRweScsICctLXJlc3VsdHMtZGlyJywgdSciIiIgKyBmaWxlc3lzdGVtLmpv aW4od2Via2l0X2ZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIoKSwgInB5dGhvbi11bml0dGVzdC1y ZXN1bHRzIikgKyAiIiInXSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBSdW5uaW5nIFBlcmwgdW5pdCB0 ZXN0cwogTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnVG9vbHMvU2NyaXB0cy90ZXN0LXdl YmtpdHBlcmwnXSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBSdW5uaW5nIEphdmFTY3JpcHRDb3JlIHRl c3RzCi0tIAoxLjkuMyAoQXBwbGUgR2l0LTUwKQoK 239227 2014-10-03 13:43:47 -0700 2014-10-05 19:58:54 -0700 Removes the TestResult(s) class. 0001-Make-test-webkitpy-generate-a-json-file-of-its-resul.patch text/plain 11924 jake.nielsen.webkit RnJvbSA2ZGY3OTI5MjI2ZWExZDAyNTVlMzNlNjg5OTIzYjlkZDdhYjRmMjlhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBGcmksIDMgT2N0IDIwMTQgMTM6NDE6NTQgLTA3MDAKU3ViamVjdDogW1BBVENIXSBN YWtlIHRlc3Qtd2Via2l0cHkgZ2VuZXJhdGUgYSBqc29uIGZpbGUgb2YgaXRzIHJlc3VsdHMKIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzczNTMKClJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgoKKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi93ZWJraXRfZmluZGVy LnB5OgpBZGRzIGEgbWV0aG9kIHRvIG1ha2UgaXQgZWFzaWVyIHRvIGZpbmQgdGhlIHdlYmtpdCBy ZXN1bHRzIGRpcmVjdG9yeS4KKFdlYktpdEZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIpOgoqIFNj cmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5OgpBZGRzIHRoZSAtLXJlc3VsdHMtZGlyIG9wdGlv biwgYW5kIGFkZHMgbG9naWMgdG8gZHVtcCBhIGpzb24gZmlsZSBvZgp0aGUgcmVzdWx0cyBpZiAt LXJlc3VsdHMtZGlyIGhhcyBiZWVuIHNwZWNpZmllZC4KKFRlc3Rlci5fX2luaXRfXyk6CihUZXN0 ZXIuX3BhcnNlX2FyZ3MpOgooVGVzdGVyLl9ydW5fdGVzdHMpOgoqIFNjcmlwdHMvd2Via2l0cHkv dGVzdC9ydW5uZXIucHk6CihSdW5uZXIuX19pbml0X18pOgooUnVubmVyLmhhbmRsZSk6CiogU2Ny aXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5OgoodGVzdF9s YW5kX2Nvd2hhbmQpOgoqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0cy5weToK VGVhY2hlcyBSdW5UZXN0cyB0byBwYXNzIGEgLS1yZXN1bHRzLWRpciB0byB0ZXN0LXdlYmtpdHB5 LgooUnVuVGVzdHMucnVuKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5p dHRlc3QucHk6ClVwZGF0ZXMgdGhlIHRlc3RfcnVudGVzdHNfYXJncyB0ZXN0IHRvIHByb3Blcmx5 IGFudGljaXBhdGUgd2hhdCBSdW5UZXN0CnNob3VsZCBiZSBzdGRvdXRpbmcuCihTdGVwc1Rlc3Qu dGVzdF9ydW50ZXN0c19hcmdzKToKLS0tCiBUb29scy9DaGFuZ2VMb2cgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8IDI5ICsrKysrKysrKysrKysrKysrKysrKysKIFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHkgICAgIHwgIDUgKysrKwogVG9v bHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHkgICAgICAgICAgICAgICAgfCAxMCArKysr KysrLQogVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lci5weSAgICAgICAgICAgICAg fCAgNCArKysKIC4uLi93ZWJraXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5 ICAgIHwgIDYgKysrKy0KIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0 cy5weSAgICAgIHwgIDkgKysrKysrKwogLi4uL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9z dGVwc191bml0dGVzdC5weSAgfCAgNiArKysrLQogNyBmaWxlcyBjaGFuZ2VkLCA2NiBpbnNlcnRp b25zKCspLCAzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rv b2xzL0NoYW5nZUxvZwppbmRleCA0ZjQzYmVjLi4wY2I0ZTM5IDEwMDY0NAotLS0gYS9Ub29scy9D aGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTQtMTAt MDMgIEpha2UgTmllbHNlbiAgPGphY29iX25pZWxzZW5AYXBwbGUuY29tPgorCisgICAgICAgIE1h a2UgdGVzdC13ZWJraXRweSBnZW5lcmF0ZSBhIGpzb24gZmlsZSBvZiBpdHMgcmVzdWx0cworICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM3MzUzCisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBTY3JpcHRzL3dl YmtpdHB5L2NvbW1vbi93ZWJraXRfZmluZGVyLnB5OgorICAgICAgICBBZGRzIGEgbWV0aG9kIHRv IG1ha2UgaXQgZWFzaWVyIHRvIGZpbmQgdGhlIHdlYmtpdCByZXN1bHRzIGRpcmVjdG9yeS4KKyAg ICAgICAgKFdlYktpdEZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIpOgorICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvdGVzdC9tYWluLnB5OgorICAgICAgICBBZGRzIHRoZSAtLXJlc3VsdHMtZGly IG9wdGlvbiwgYW5kIGFkZHMgbG9naWMgdG8gZHVtcCBhIGpzb24gZmlsZSBvZgorICAgICAgICB0 aGUgcmVzdWx0cyBpZiAtLXJlc3VsdHMtZGlyIGhhcyBiZWVuIHNwZWNpZmllZC4KKyAgICAgICAg KFRlc3Rlci5fX2luaXRfXyk6CisgICAgICAgIChUZXN0ZXIuX3BhcnNlX2FyZ3MpOgorICAgICAg ICAoVGVzdGVyLl9ydW5fdGVzdHMpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9y dW5uZXIucHk6CisgICAgICAgIChSdW5uZXIuX19pbml0X18pOgorICAgICAgICAoUnVubmVyLmhh bmRsZSk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2Fk X3VuaXR0ZXN0LnB5OgorICAgICAgICAodGVzdF9sYW5kX2Nvd2hhbmQpOgorICAgICAgICAqIFNj cmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0cy5weToKKyAgICAgICAgVGVhY2hlcyBS dW5UZXN0cyB0byBwYXNzIGEgLS1yZXN1bHRzLWRpciB0byB0ZXN0LXdlYmtpdHB5LgorICAgICAg ICAoUnVuVGVzdHMucnVuKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMv c3RlcHNfdW5pdHRlc3QucHk6CisgICAgICAgIFVwZGF0ZXMgdGhlIHRlc3RfcnVudGVzdHNfYXJn cyB0ZXN0IHRvIHByb3Blcmx5IGFudGljaXBhdGUgd2hhdCBSdW5UZXN0CisgICAgICAgIHNob3Vs ZCBiZSBzdGRvdXRpbmcuCisgICAgICAgIChTdGVwc1Rlc3QudGVzdF9ydW50ZXN0c19hcmdzKToK KwogMjAxNC0xMC0wMiAgQ2FybG9zIEFsYmVydG8gTG9wZXogUGVyZXogIDxjbG9wZXpAaWdhbGlh LmNvbT4KIAogICAgICAgICBbR1RLXSBbSkhCdWlsZF0gU3dpdGNoIHNvdXJjZXdhcmUub3JnIG1p cnJvciB0byBodHRwLgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24v d2Via2l0X2ZpbmRlci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9m aW5kZXIucHkKaW5kZXggN2I5YzAxNC4uNTQyZWFhOCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9jb21tb24vd2Via2l0X2ZpbmRlci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2NvbW1vbi93ZWJraXRfZmluZGVyLnB5CkBAIC0zMiw2ICszMiwxMSBAQCBjbGFzcyBX ZWJLaXRGaW5kZXIob2JqZWN0KToKICAgICAgICAgc2VsZi5fZmlsZXN5c3RlbSA9IGZpbGVzeXN0 ZW0KICAgICAgICAgc2VsZi5fd2Via2l0X2Jhc2UgPSBOb25lCiAKKyAgICBkZWYgd2Via2l0X3Jl c3VsdHNfZGlyKHNlbGYpOgorICAgICAgICBwYXRoX3RvX2J1aWxkX2RpciA9IHNlbGYuX2ZpbGVz eXN0ZW0uam9pbihzZWxmLndlYmtpdF9iYXNlKCksICJXZWJLaXRCdWlsZCIpCisgICAgICAgIGNv bmZpZ3VyYXRpb25fZGlyID0gc2VsZi5fZmlsZXN5c3RlbS5yZWFkX3RleHRfZmlsZShzZWxmLl9m aWxlc3lzdGVtLmpvaW4ocGF0aF90b19idWlsZF9kaXIsICJDb25maWd1cmF0aW9uIikpCisgICAg ICAgIHJldHVybiBzZWxmLl9maWxlc3lzdGVtLmpvaW4ocGF0aF90b19idWlsZF9kaXIsIGNvbmZp Z3VyYXRpb25fZGlyKQorCiAgICAgZGVmIHdlYmtpdF9iYXNlKHNlbGYpOgogICAgICAgICAiIiJS ZXR1cm5zIHRoZSBhYnNvbHV0ZSBwYXRoIHRvIHRoZSB0b3Agb2YgdGhlIFdlYktpdCB0cmVlLgog CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5weSBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CmluZGV4IGY1MThiNTEuLjU3NmI3NTIgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CisrKyBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CkBAIC0zMiw3ICszMiw5IEBAIGltcG9ydCBz eXMKIGltcG9ydCB0aW1lCiBpbXBvcnQgdHJhY2ViYWNrCiBpbXBvcnQgdW5pdHRlc3QKK2ltcG9y dCBqc29uCiAKK2Zyb20gd2Via2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktp dEZpbmRlcgogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZp bGVTeXN0ZW0KIGZyb20gd2Via2l0cHkudGVzdC5maW5kZXIgaW1wb3J0IEZpbmRlcgogZnJvbSB3 ZWJraXRweS50ZXN0LnByaW50ZXIgaW1wb3J0IFByaW50ZXIKQEAgLTc0LDcgKzc2LDggQEAgZGVm IG1haW4oKToKIAogY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYs IGZpbGVzeXN0ZW09Tm9uZSk6Ci0gICAgICAgIHNlbGYuZmluZGVyID0gRmluZGVyKGZpbGVzeXN0 ZW0gb3IgRmlsZVN5c3RlbSgpKQorICAgICAgICBzZWxmLl9maWxlc3lzdGVtID0gZmlsZXN5c3Rl bSBvciBGaWxlU3lzdGVtKCkKKyAgICAgICAgc2VsZi5maW5kZXIgPSBGaW5kZXIoc2VsZi5fZmls ZXN5c3RlbSkKICAgICAgICAgc2VsZi5wcmludGVyID0gUHJpbnRlcihzeXMuc3RkZXJyKQogICAg ICAgICBzZWxmLl9vcHRpb25zID0gTm9uZQogCkBAIC0xMDIsNiArMTA1LDggQEAgY2xhc3MgVGVz dGVyKG9iamVjdCk6CiAgICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2Rpc3BsYXkgcGVy LXRlc3QgZXhlY3V0aW9uIHRpbWUgKGltcGxpZXMgLS12ZXJib3NlKScpCiAgICAgICAgIHBhcnNl ci5hZGRfb3B0aW9uKCctdicsICctLXZlcmJvc2UnLCBhY3Rpb249J2NvdW50JywgZGVmYXVsdD0w LAogICAgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSd2ZXJib3NlIG91dHB1dCAoc3BlY2lm eSBvbmNlIGZvciBpbmRpdmlkdWFsIHRlc3QgcmVzdWx0cywgdHdpY2UgZm9yIGRlYnVnIG1lc3Nh Z2VzKScpCisgICAgICAgIHBhcnNlci5hZGRfb3B0aW9uKCctcicsICctLXJlc3VsdHMtZGlyJywg YWN0aW9uPSdzdG9yZScsIGRlZmF1bHQ9IiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgIGhl bHA9J3NwZWNpZmllcyBhIGRpcmVjdG9yeSBpbiB3aGljaCB0byBnZW5lcmF0ZSBhIGpzb24gZmls ZSB0aGF0IGNvbnRhaW5zIHRoZSByZXN1bHRzIG9mIHRoZSB0ZXN0cycpCiAKICAgICAgICAgcGFy c2VyLmVwaWxvZyA9ICgnW2FyZ3MuLi5dIGlzIGFuIG9wdGlvbmFsIGxpc3Qgb2YgbW9kdWxlcywg dGVzdF9jbGFzc2VzLCBvciBpbmRpdmlkdWFsIHRlc3RzLiAnCiAgICAgICAgICAgICAgICAgICAg ICAgICAgJ0lmIG5vIGFyZ3MgYXJlIGdpdmVuLCBhbGwgdGhlIHRlc3RzIHdpbGwgYmUgcnVuLicp CkBAIC0xNjIsNiArMTY3LDkgQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAKICAgICAgICAgc2Vs Zi5wcmludGVyLnByaW50X3Jlc3VsdCh0aW1lLnRpbWUoKSAtIHN0YXJ0KQogCisgICAgICAgIGlm IHNlbGYuX29wdGlvbnMucmVzdWx0c19kaXI6CisgICAgICAgICAgICBzZWxmLl9maWxlc3lzdGVt LndyaXRlX3RleHRfZmlsZShzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1 bHRzX2RpciwgInJlc3VsdHMuanNvbiIpLCBqc29uLmR1bXBzKHRlc3RfcnVubmVyLnRlc3RfcmVz dWx0cykpCisKICAgICAgICAgaWYgc2VsZi5fb3B0aW9ucy5jb3ZlcmFnZToKICAgICAgICAgICAg IGNvdi5zdG9wKCkKICAgICAgICAgICAgIGNvdi5zYXZlKCkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rl c3QvcnVubmVyLnB5CmluZGV4IGQzZjU3NjQuLjBlZmU1NWIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS90ZXN0L3J1bm5lci5weQpAQCAtNDMsNiArNDMsNyBAQCBjbGFzcyBSdW5uZXIob2JqZWN0KToK ICAgICAgICAgc2VsZi50ZXN0c19ydW4gPSAwCiAgICAgICAgIHNlbGYuZXJyb3JzID0gW10KICAg ICAgICAgc2VsZi5mYWlsdXJlcyA9IFtdCisgICAgICAgIHNlbGYudGVzdF9yZXN1bHRzID0gW10K ICAgICAgICAgc2VsZi53b3JrZXJfZmFjdG9yeSA9IGxhbWJkYSBjYWxsZXI6IF9Xb3JrZXIoY2Fs bGVyLCBzZWxmLmxvYWRlcikKIAogICAgIGRlZiBydW4oc2VsZiwgdGVzdF9uYW1lcywgbnVtX3dv cmtlcnMpOgpAQCAtNjIsNiArNjMsOSBAQCBjbGFzcyBSdW5uZXIob2JqZWN0KToKICAgICAgICAg ICAgIHNlbGYuZmFpbHVyZXMuYXBwZW5kKCh0ZXN0X25hbWUsIGZhaWx1cmVzKSkKICAgICAgICAg aWYgZXJyb3JzOgogICAgICAgICAgICAgc2VsZi5lcnJvcnMuYXBwZW5kKCh0ZXN0X25hbWUsIGVy cm9ycykpCisKKyAgICAgICAgc2VsZi50ZXN0X3Jlc3VsdHMuYXBwZW5kKCh0ZXN0X25hbWUsIGZh aWx1cmVzLCBlcnJvcnMpKQorCiAgICAgICAgIHNlbGYucHJpbnRlci5wcmludF9maW5pc2hlZF90 ZXN0KHNvdXJjZSwgdGVzdF9uYW1lLCBkZWxheSwgZmFpbHVyZXMsIGVycm9ycykKIAogCmRpZmYg LS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93bmxvYWRfdW5p dHRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93bmxvYWRf dW5pdHRlc3QucHkKaW5kZXggNTliNTJlYS4uMGFjNmQwNiAxMDA2NDQKLS0tIGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5CisrKyBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91bml0dGVzdC5weQpA QCAtMzQsNiArMzQsOCBAQCBmcm9tIHdlYmtpdHB5LnRvb2wuY29tbWFuZHMuY29tbWFuZHRlc3Qg aW1wb3J0IENvbW1hbmRzVGVzdAogZnJvbSB3ZWJraXRweS50b29sLmNvbW1hbmRzLmRvd25sb2Fk IGltcG9ydCAqCiBmcm9tIHdlYmtpdHB5LnRvb2wubW9ja3Rvb2wgaW1wb3J0IE1vY2tPcHRpb25z LCBNb2NrVG9vbAogZnJvbSB3ZWJraXRweS5jb21tb24uY2hlY2tvdXQuY2hlY2tvdXRfbW9jayBp bXBvcnQgTW9ja0NoZWNrb3V0Citmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0uZmlsZXN5c3Rl bSBpbXBvcnQgRmlsZVN5c3RlbQorZnJvbSB3ZWJraXRweS5jb21tb24ud2Via2l0X2ZpbmRlciBp bXBvcnQgV2ViS2l0RmluZGVyCiAKIAogY2xhc3MgQWJzdHJhY3RSb2xsb3V0UHJlcENvbW1hbmRU ZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKQEAgLTE1Niw2ICsxNTgsOCBAQCBVcGRhdGluZyBidWcg NTAwMDAKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChtb2NrX3Rvb2wuY2hlY2tvdXQoKS5tb2Rp ZmllZF9jaGFuZ2Vsb2dzLmNhbGxfY291bnQsIDEpCiAKICAgICBkZWYgdGVzdF9sYW5kX2Nvd2hh bmQoc2VsZik6CisgICAgICAgIGZpbGVzeXN0ZW0gPSBGaWxlU3lzdGVtKCkKKyAgICAgICAgd2Vi a2l0X2ZpbmRlciA9IFdlYktpdEZpbmRlcihmaWxlc3lzdGVtKQogICAgICAgICBleHBlY3RlZF9s b2dzID0gIiIiTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnbW9jay1wcmVwYXJlLUNoYW5n ZUxvZycsICctLWVtYWlsPU1PQ0sgZW1haWwnLCAnLS1tZXJnZS1iYXNlPU5vbmUnLCAnTW9ja0Zp bGUxJ10sIGN3ZD0vbW9jay1jaGVja291dAogTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsn bW9jay1jaGVjay13ZWJraXQtc3R5bGUnLCAnLS1naXQtY29tbWl0JywgJ01PQ0sgZ2l0IGNvbW1p dCcsICctLWRpZmYtZmlsZXMnLCAnTW9ja0ZpbGUxJywgJy0tZmlsdGVyJywgJy1jaGFuZ2Vsb2cn XSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBNT0NLIHJ1bl9jb21tYW5kOiBbJ3J1YnknLCAnLUknLCAn L21vY2stY2hlY2tvdXQvV2Vic2l0ZXMvYnVncy53ZWJraXQub3JnL1ByZXR0eVBhdGNoJywgJy9t b2NrLWNoZWNrb3V0L1dlYnNpdGVzL2J1Z3Mud2Via2l0Lm9yZy9QcmV0dHlQYXRjaC9wcmV0dGlm eS5yYiddLCBjd2Q9Tm9uZSwgaW5wdXQ9UGF0Y2gxCkBAIC0xNjQsNyArMTY4LDcgQEAgV2FzIHRo YXQgZGlmZiBjb3JyZWN0PwogQnVpbGRpbmcgV2ViS2l0CiBNT0NLIHJ1bl9hbmRfdGhyb3dfaWZf ZmFpbDogWydtb2NrLWJ1aWxkLXdlYmtpdCddLCBjd2Q9L21vY2stY2hlY2tvdXQsIGVudj17J0xD X0FMTCc6ICdDJywgJ1RFUk0nOiAnbm9uZScsICdNT0NLX0VOVklST05fQ09QWSc6ICcxJ30KIFJ1 bm5pbmcgUHl0aG9uIHVuaXQgdGVzdHMKLU1PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ21v Y2stdGVzdC13ZWJraXRweSddLCBjd2Q9L21vY2stY2hlY2tvdXQKK01PQ0sgcnVuX2FuZF90aHJv d19pZl9mYWlsOiBbJ21vY2stdGVzdC13ZWJraXRweScsICctLXJlc3VsdHMtZGlyJywgdSciIiIg KyBmaWxlc3lzdGVtLmpvaW4od2Via2l0X2ZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIoKSwgInB5 dGhvbi11bml0dGVzdC1yZXN1bHRzIikgKyAiIiInXSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBSdW5u aW5nIFBlcmwgdW5pdCB0ZXN0cwogTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnbW9jay10 ZXN0LXdlYmtpdHBlcmwnXSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBSdW5uaW5nIEphdmFTY3JpcHRD b3JlIHRlc3RzCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMv cnVudGVzdHMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMu cHkKaW5kZXggYTQ1NjI4Yi4uYzQ5ZjRjYyAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv dG9vbC9zdGVwcy9ydW50ZXN0cy5weQpAQCAtMzMsNiArMzMsOCBAQCBpbXBvcnQgc3lzCiBmcm9t IHdlYmtpdHB5LnRvb2wuc3RlcHMuYWJzdHJhY3RzdGVwIGltcG9ydCBBYnN0cmFjdFN0ZXAKIGZy b20gd2Via2l0cHkudG9vbC5zdGVwcy5vcHRpb25zIGltcG9ydCBPcHRpb25zCiBmcm9tIHdlYmtp dHB5LmNvbW1vbi5zeXN0ZW0uZXhlY3V0aXZlIGltcG9ydCBTY3JpcHRFcnJvcgorZnJvbSB3ZWJr aXRweS5jb21tb24ud2Via2l0X2ZpbmRlciBpbXBvcnQgV2ViS2l0RmluZGVyCitmcm9tIHdlYmtp dHB5LmNvbW1vbi5zeXN0ZW0uZmlsZXN5c3RlbSBpbXBvcnQgRmlsZVN5c3RlbQogCiBfbG9nID0g bG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCiAKQEAgLTU1LDggKzU3LDE1IEBAIGNsYXNzIFJ1 blRlc3RzKEFic3RyYWN0U3RlcCk6CiAKICAgICAgICAgaWYgbm90IHNlbGYuX29wdGlvbnMubm9u X2ludGVyYWN0aXZlOgogICAgICAgICAgICAgIyBGSVhNRTogV2Ugc2hvdWxkIHRlYWNoIHRoZSBj b21taXQtcXVldWUgYW5kIHRoZSBFV1MgaG93IHRvIHJ1biB0aGVzZSB0ZXN0cy4KKyAgICAgICAg ICAgIGZpbGVzeXN0ZW0gPSBGaWxlU3lzdGVtKCkKKyAgICAgICAgICAgIHdlYmtpdF9maW5kZXIg PSBXZWJLaXRGaW5kZXIoZmlsZXN5c3RlbSkKKyAgICAgICAgICAgIHB5dGhvbl91bml0dGVzdHNf cmVzdWx0c19kaXIgPSBmaWxlc3lzdGVtLmpvaW4od2Via2l0X2ZpbmRlci53ZWJraXRfcmVzdWx0 c19kaXIoKSwgInB5dGhvbi11bml0dGVzdC1yZXN1bHRzIikKKyAgICAgICAgICAgIGZpbGVzeXN0 ZW0ubWF5YmVfbWFrZV9kaXJlY3RvcnkocHl0aG9uX3VuaXR0ZXN0c19yZXN1bHRzX2RpcikKIAog ICAgICAgICAgICAgcHl0aG9uX3VuaXR0ZXN0c19jb21tYW5kID0gc2VsZi5fdG9vbC5kZXByZWNh dGVkX3BvcnQoKS5ydW5fcHl0aG9uX3VuaXR0ZXN0c19jb21tYW5kKCkKKyAgICAgICAgICAgIHB5 dGhvbl91bml0dGVzdHNfY29tbWFuZC5hcHBlbmQoIi0tcmVzdWx0cy1kaXIiKQorICAgICAgICAg ICAgcHl0aG9uX3VuaXR0ZXN0c19jb21tYW5kLmFwcGVuZChweXRob25fdW5pdHRlc3RzX3Jlc3Vs dHNfZGlyKQorCiAgICAgICAgICAgICBpZiBweXRob25fdW5pdHRlc3RzX2NvbW1hbmQ6CiAgICAg ICAgICAgICAgICAgX2xvZy5pbmZvKCJSdW5uaW5nIFB5dGhvbiB1bml0IHRlc3RzIikKICAgICAg ICAgICAgICAgICBzZWxmLl90b29sLmV4ZWN1dGl2ZS5ydW5fYW5kX3Rocm93X2lmX2ZhaWwocHl0 aG9uX3VuaXR0ZXN0c19jb21tYW5kLCBjd2Q9c2VsZi5fdG9vbC5zY20oKS5jaGVja291dF9yb290 KQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBzX3Vu aXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBzX3VuaXR0 ZXN0LnB5CmluZGV4IGIxZTJiZjEuLjJhZjAxZTQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkKQEAgLTMxLDYgKzMxLDggQEAg aW1wb3J0IHVuaXR0ZXN0CiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0ub3V0cHV0Y2FwdHVy ZSBpbXBvcnQgT3V0cHV0Q2FwdHVyZQogZnJvbSB3ZWJraXRweS5jb21tb24uY29uZmlnLnBvcnRz IGltcG9ydCBEZXByZWNhdGVkUG9ydAogZnJvbSB3ZWJraXRweS50b29sLm1vY2t0b29sIGltcG9y dCBNb2NrT3B0aW9ucywgTW9ja1Rvb2wKK2Zyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5maWxl c3lzdGVtIGltcG9ydCBGaWxlU3lzdGVtCitmcm9tIHdlYmtpdHB5LmNvbW1vbi53ZWJraXRfZmlu ZGVyIGltcG9ydCBXZWJLaXRGaW5kZXIKIAogZnJvbSB3ZWJraXRweS50b29sIGltcG9ydCBzdGVw cwogCkBAIC05Niw2ICs5OCw4IEBAIGNsYXNzIFN0ZXBzVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6 CiAgICAgICAgIHNlbGYuX2Fzc2VydF9zdGVwX291dHB1dF93aXRoX2J1ZyhzdGVwcy5FbnN1cmVC dWdJc09wZW5BbmRBc3NpZ25lZCwgNTAwMDIsIGV4cGVjdGVkX2xvZ3MpCiAKICAgICBkZWYgdGVz dF9ydW50ZXN0c19hcmdzKHNlbGYpOgorICAgICAgICBmaWxlc3lzdGVtID0gRmlsZVN5c3RlbSgp CisgICAgICAgIHdlYmtpdF9maW5kZXIgPSBXZWJLaXRGaW5kZXIoZmlsZXN5c3RlbSkKICAgICAg ICAgbW9ja19vcHRpb25zID0gc2VsZi5fc3RlcF9vcHRpb25zKCkKICAgICAgICAgbW9ja19vcHRp b25zLm5vbl9pbnRlcmFjdGl2ZSA9IEZhbHNlCiAgICAgICAgIHN0ZXAgPSBzdGVwcy5SdW5UZXN0 cyhNb2NrVG9vbChsb2dfZXhlY3V0aXZlPVRydWUpLCBtb2NrX29wdGlvbnMpCkBAIC0xMDQsNyAr MTA4LDcgQEAgY2xhc3MgU3RlcHNUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAgdG9v bC5fZGVwcmVjYXRlZF9wb3J0ID0gRGVwcmVjYXRlZFBvcnQoKQogICAgICAgICBzdGVwID0gc3Rl cHMuUnVuVGVzdHModG9vbCwgbW9ja19vcHRpb25zKQogICAgICAgICBleHBlY3RlZF9sb2dzID0g IiIiUnVubmluZyBQeXRob24gdW5pdCB0ZXN0cwotTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6 IFsnVG9vbHMvU2NyaXB0cy90ZXN0LXdlYmtpdHB5J10sIGN3ZD0vbW9jay1jaGVja291dAorTU9D SyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnVG9vbHMvU2NyaXB0cy90ZXN0LXdlYmtpdHB5Jywg Jy0tcmVzdWx0cy1kaXInLCB1JyIiIiArIGZpbGVzeXN0ZW0uam9pbih3ZWJraXRfZmluZGVyLndl YmtpdF9yZXN1bHRzX2RpcigpLCAicHl0aG9uLXVuaXR0ZXN0LXJlc3VsdHMiKSArICIiIiddLCBj d2Q9L21vY2stY2hlY2tvdXQKIFJ1bm5pbmcgUGVybCB1bml0IHRlc3RzCiBNT0NLIHJ1bl9hbmRf dGhyb3dfaWZfZmFpbDogWydUb29scy9TY3JpcHRzL3Rlc3Qtd2Via2l0cGVybCddLCBjd2Q9L21v Y2stY2hlY2tvdXQKIFJ1bm5pbmcgSmF2YVNjcmlwdENvcmUgdGVzdHMKLS0gCjEuOS4zIChBcHBs ZSBHaXQtNTApCgo= 239311 2014-10-05 19:58:54 -0700 2014-10-06 11:57:32 -0700 Adds the results.py file back (with significant changes) and adds results_unittest.py 0001-Make-test-webkitpy-generate-a-json-file-of-its-resul.patch text/plain 23941 jake.nielsen.webkit RnJvbSAxZGQ0ZTUzMzMxYmJlZmUyMjU5ZmU2ZDQ5YWNmNjVlMGE1OGU3ZjAxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBTdW4sIDUgT2N0IDIwMTQgMTk6NTU6NDEgLTA3MDAKU3ViamVjdDogW1BBVENIXSBN YWtlIHRlc3Qtd2Via2l0cHkgZ2VuZXJhdGUgYSBqc29uIGZpbGUgb2YgaXRzIHJlc3VsdHMKIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzczNTMKClJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgoKKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi93ZWJraXRfZmluZGVy LnB5OgpBZGRzIGEgbWV0aG9kIHRvIG1ha2UgaXQgZWFzaWVyIHRvIGZpbmQgdGhlIHdlYmtpdCBy ZXN1bHRzIGRpcmVjdG9yeS4KKFdlYktpdEZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIpOgoqIFNj cmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5OgpBZGRzIHRoZSAtLXJlc3VsdHMtZGlyIG9wdGlv biwgYW5kIGFkZHMgbG9naWMgdG8gZHVtcCBhIGpzb24gZmlsZSBvZgp0aGUgcmVzdWx0cyBpZiAt LXJlc3VsdHMtZGlyIGhhcyBiZWVuIHNwZWNpZmllZC4KKFRlc3Rlci5fX2luaXRfXyk6CihUZXN0 ZXIuX3BhcnNlX2FyZ3MpOgooVGVzdGVyLl9ydW5fdGVzdHMpOgoqIFNjcmlwdHMvd2Via2l0cHkv dGVzdC9yZXN1bHRzLnB5OiBBZGRlZC4KUHJvdmlkZXMgYSBjbGFzcyB0byBlbmNhcHN1bGF0ZSB0 ZXN0IHJlc3VsdHMsIGFuZCB0byBhZGQgaXNvbGF0aW9uCmJldHdlZW4gdGhlIGpzb24gZmlsZSBh bmQgdGhlIHJlc3Qgb2Ygd2Via2l0cHkuCihUZXN0U3VpdGVSZXN1bHRzKToKKFRlc3RTdWl0ZVJl c3VsdHMudGVzdF9zdWl0ZV9yZXN1bHRzX2Zyb21fanNvbl9zdHJpbmcpOgooVGVzdFN1aXRlUmVz dWx0cy50ZXN0X3N1aXRlX3Jlc3VsdHNfdG9fanNvbl9zdHJpbmcpOgooVGVzdFN1aXRlUmVzdWx0 cy5fX2luaXRfXyk6CihUZXN0U3VpdGVSZXN1bHRzLmFkZF90ZXN0X3Jlc3VsdCk6CihUZXN0U3Vp dGVSZXN1bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cyk6CihUZXN0U3VpdGVSZXN1bHRz Lmxpc3Rfb2ZfZXJyb3JlZF90ZXN0X3Jlc3VsdHMpOgoqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9y ZXN1bHRzX3VuaXR0ZXN0LnB5OiBBZGRlZC4KQWRkcyBhIHRlc3QgdG8gbWFrZSBzdXJlIHRoYXQg c2VyaWFsaXphdGlvbiBhbmQgc3Vic2VxdWVudCBkZXNlcmlhbGl6YXRpb24gcmVzdWx0CmluIGFu IGVxdWl2ZWxhbnQgVGVzdFN1aXRlUmVzdWx0cyBvYmplY3QuCkFsc28gYWRkcyBhIHRlc3QgdG8g Y2F0Y2ggYSBidWcgdGhhdCBjYXVzZWQgc29tZSBzdGF0ZSB0byBibGVlZApiZXR3ZWVuIFRlc3RT dWl0ZVJlc3VsdHMgb2JqZWN0cy4KKFRlc3RTdWl0ZVJlc3VsdHNUZXN0KToKKFRlc3RTdWl0ZVJl c3VsdHNUZXN0LnRlc3RfanNvbl9zZXJpYWxpemF0aW9uX2FuZF9kZXNlcmlhbGl6YXRpb24pOgoo VGVzdFN1aXRlUmVzdWx0c1Rlc3QudGVzdF9zdWl0ZV9yZXN1bHRzX211dHVhbF9pbmRlcGVuZGVu Y2UpOgoqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHk6ClRlYWNoZXMgcnVubmVyLnB5 IHRvIHVzZSBUZXN0U3VpdGVSZXN1bHRzIG9iamVjdHMgaW5zdGVhZCBvZiBqdXN0IHN0dWZmaW5n CmV2ZXJ5dGhpbmcgaW50byB0dXBsZXMgYW5kIGxpc3RzLgooUnVubmVyLl9faW5pdF9fKToKKFJ1 bm5lci5oYW5kbGUpOgoqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXJfdW5pdHRlc3QucHk6 ClRlYWNoZXMgdGVzdF9ydW4gaG93IHRvIHVzZSBUZXN0U3VpdGVSZXN1bHRzIG9iamVjdHMuCihS dW5uZXJUZXN0LnRlc3RfcnVuKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93 bmxvYWRfdW5pdHRlc3QucHk6ClVwZGF0ZXMgdGhlIHRlc3RfbGFuZF9jb3doYW5kIHRlc3QgdG8g cHJvcGVybHkgYW50aWNpcGF0ZSB3aGF0IFJ1blRlc3QKc2hvdWxkIGJlIHN0ZG91dGluZy4KKHRl c3RfbGFuZF9jb3doYW5kKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMu cHk6ClRlYWNoZXMgUnVuVGVzdHMgdG8gcGFzcyBhIC0tcmVzdWx0cy1kaXIgdG8gdGVzdC13ZWJr aXRweS4KKFJ1blRlc3RzLnJ1bik6CiogU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBz X3VuaXR0ZXN0LnB5OgpVcGRhdGVzIHRoZSB0ZXN0X3J1bnRlc3RzX2FyZ3MgdGVzdCB0byBwcm9w ZXJseSBhbnRpY2lwYXRlIHdoYXQgUnVuVGVzdApzaG91bGQgYmUgc3Rkb3V0aW5nLgooU3RlcHNU ZXN0LnRlc3RfcnVudGVzdHNfYXJncyk6Ci0tLQogVG9vbHMvQ2hhbmdlTG9nICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgfCA1NCArKysrKysrKysrKysrKysrKysKIFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHkgICAgIHwgIDUgKysKIFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAgICAgICAgIHwgMTAgKysrLQog VG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3Jlc3VsdHMucHkgICAgICAgICAgICAgfCA2NiAr KysrKysrKysrKysrKysrKysrKysrCiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0 c191bml0dGVzdC5weSAgICB8IDU1ICsrKysrKysrKysrKysrKysrKwogVG9vbHMvU2NyaXB0cy93 ZWJraXRweS90ZXN0L3J1bm5lci5weSAgICAgICAgICAgICAgfCAxMiArKy0tCiBUb29scy9TY3Jp cHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0LnB5ICAgICB8ICA4ICstLQogLi4uL3dl YmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHkgICAgfCAgNiArLQogVG9v bHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5ICAgICAgfCAgOSArKysK IC4uLi9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkgIHwgIDYg Ky0KIDEwIGZpbGVzIGNoYW5nZWQsIDIxNiBpbnNlcnRpb25zKCspLCAxNSBkZWxldGlvbnMoLSkK IGNyZWF0ZSBtb2RlIDEwMDY0NCBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5w eQogY3JlYXRlIG1vZGUgMTAwNjQ0IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRz X3VuaXR0ZXN0LnB5CgpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdl TG9nCmluZGV4IDRmNDNiZWMuLmFlYjhmNzQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZwor KysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1NyBAQAorMjAxNC0xMC0wNSAgSmFrZSBO aWVsc2VuICA8amFjb2JfbmllbHNlbkBhcHBsZS5jb20+CisKKyAgICAgICAgTWFrZSB0ZXN0LXdl YmtpdHB5IGdlbmVyYXRlIGEganNvbiBmaWxlIG9mIGl0cyByZXN1bHRzCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzczNTMKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29t bW9uL3dlYmtpdF9maW5kZXIucHk6CisgICAgICAgIEFkZHMgYSBtZXRob2QgdG8gbWFrZSBpdCBl YXNpZXIgdG8gZmluZCB0aGUgd2Via2l0IHJlc3VsdHMgZGlyZWN0b3J5LgorICAgICAgICAoV2Vi S2l0RmluZGVyLndlYmtpdF9yZXN1bHRzX2Rpcik6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRw eS90ZXN0L21haW4ucHk6CisgICAgICAgIEFkZHMgdGhlIC0tcmVzdWx0cy1kaXIgb3B0aW9uLCBh bmQgYWRkcyBsb2dpYyB0byBkdW1wIGEganNvbiBmaWxlIG9mCisgICAgICAgIHRoZSByZXN1bHRz IGlmIC0tcmVzdWx0cy1kaXIgaGFzIGJlZW4gc3BlY2lmaWVkLgorICAgICAgICAoVGVzdGVyLl9f aW5pdF9fKToKKyAgICAgICAgKFRlc3Rlci5fcGFyc2VfYXJncyk6CisgICAgICAgIChUZXN0ZXIu X3J1bl90ZXN0cyk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90ZXN0L3Jlc3VsdHMucHk6 IEFkZGVkLgorICAgICAgICBQcm92aWRlcyBhIGNsYXNzIHRvIGVuY2Fwc3VsYXRlIHRlc3QgcmVz dWx0cywgYW5kIHRvIGFkZCBpc29sYXRpb24KKyAgICAgICAgYmV0d2VlbiB0aGUganNvbiBmaWxl IGFuZCB0aGUgcmVzdCBvZiB3ZWJraXRweS4KKyAgICAgICAgKFRlc3RTdWl0ZVJlc3VsdHMpOgor ICAgICAgICAoVGVzdFN1aXRlUmVzdWx0cy50ZXN0X3N1aXRlX3Jlc3VsdHNfZnJvbV9qc29uX3N0 cmluZyk6CisgICAgICAgIChUZXN0U3VpdGVSZXN1bHRzLnRlc3Rfc3VpdGVfcmVzdWx0c190b19q c29uX3N0cmluZyk6CisgICAgICAgIChUZXN0U3VpdGVSZXN1bHRzLl9faW5pdF9fKToKKyAgICAg ICAgKFRlc3RTdWl0ZVJlc3VsdHMuYWRkX3Rlc3RfcmVzdWx0KToKKyAgICAgICAgKFRlc3RTdWl0 ZVJlc3VsdHMubGlzdF9vZl9mYWlsZWRfdGVzdF9yZXN1bHRzKToKKyAgICAgICAgKFRlc3RTdWl0 ZVJlc3VsdHMubGlzdF9vZl9lcnJvcmVkX3Rlc3RfcmVzdWx0cyk6CisgICAgICAgICogU2NyaXB0 cy93ZWJraXRweS90ZXN0L3Jlc3VsdHNfdW5pdHRlc3QucHk6IEFkZGVkLgorICAgICAgICBBZGRz IGEgdGVzdCB0byBtYWtlIHN1cmUgdGhhdCBzZXJpYWxpemF0aW9uIGFuZCBzdWJzZXF1ZW50IGRl c2VyaWFsaXphdGlvbiByZXN1bHQKKyAgICAgICAgaW4gYW4gZXF1aXZlbGFudCBUZXN0U3VpdGVS ZXN1bHRzIG9iamVjdC4KKyAgICAgICAgQWxzbyBhZGRzIGEgdGVzdCB0byBjYXRjaCBhIGJ1ZyB0 aGF0IGNhdXNlZCBzb21lIHN0YXRlIHRvIGJsZWVkCisgICAgICAgIGJldHdlZW4gVGVzdFN1aXRl UmVzdWx0cyBvYmplY3RzLgorICAgICAgICAoVGVzdFN1aXRlUmVzdWx0c1Rlc3QpOgorICAgICAg ICAoVGVzdFN1aXRlUmVzdWx0c1Rlc3QudGVzdF9qc29uX3NlcmlhbGl6YXRpb25fYW5kX2Rlc2Vy aWFsaXphdGlvbik6CisgICAgICAgIChUZXN0U3VpdGVSZXN1bHRzVGVzdC50ZXN0X3N1aXRlX3Jl c3VsdHNfbXV0dWFsX2luZGVwZW5kZW5jZSk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90 ZXN0L3J1bm5lci5weToKKyAgICAgICAgVGVhY2hlcyBydW5uZXIucHkgdG8gdXNlIFRlc3RTdWl0 ZVJlc3VsdHMgb2JqZWN0cyBpbnN0ZWFkIG9mIGp1c3Qgc3R1ZmZpbmcKKyAgICAgICAgZXZlcnl0 aGluZyBpbnRvIHR1cGxlcyBhbmQgbGlzdHMuCisgICAgICAgIChSdW5uZXIuX19pbml0X18pOgor ICAgICAgICAoUnVubmVyLmhhbmRsZSk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90ZXN0 L3J1bm5lcl91bml0dGVzdC5weToKKyAgICAgICAgVGVhY2hlcyB0ZXN0X3J1biBob3cgdG8gdXNl IFRlc3RTdWl0ZVJlc3VsdHMgb2JqZWN0cy4KKyAgICAgICAgKFJ1bm5lclRlc3QudGVzdF9ydW4p OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91bml0 dGVzdC5weToKKyAgICAgICAgVXBkYXRlcyB0aGUgdGVzdF9sYW5kX2Nvd2hhbmQgdGVzdCB0byBw cm9wZXJseSBhbnRpY2lwYXRlIHdoYXQgUnVuVGVzdAorICAgICAgICBzaG91bGQgYmUgc3Rkb3V0 aW5nLgorICAgICAgICAodGVzdF9sYW5kX2Nvd2hhbmQpOgorICAgICAgICAqIFNjcmlwdHMvd2Vi a2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0cy5weToKKyAgICAgICAgVGVhY2hlcyBSdW5UZXN0cyB0 byBwYXNzIGEgLS1yZXN1bHRzLWRpciB0byB0ZXN0LXdlYmtpdHB5LgorICAgICAgICAoUnVuVGVz dHMucnVuKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5p dHRlc3QucHk6CisgICAgICAgIFVwZGF0ZXMgdGhlIHRlc3RfcnVudGVzdHNfYXJncyB0ZXN0IHRv IHByb3Blcmx5IGFudGljaXBhdGUgd2hhdCBSdW5UZXN0CisgICAgICAgIHNob3VsZCBiZSBzdGRv dXRpbmcuCisgICAgICAgIChTdGVwc1Rlc3QudGVzdF9ydW50ZXN0c19hcmdzKToKKwogMjAxNC0x MC0wMiAgQ2FybG9zIEFsYmVydG8gTG9wZXogUGVyZXogIDxjbG9wZXpAaWdhbGlhLmNvbT4KIAog ICAgICAgICBbR1RLXSBbSkhCdWlsZF0gU3dpdGNoIHNvdXJjZXdhcmUub3JnIG1pcnJvciB0byBo dHRwLgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vd2Via2l0X2Zp bmRlci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHkK aW5kZXggN2I5YzAxNC4uNTQyZWFhOCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9jb21tb24vd2Via2l0X2ZpbmRlci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2Nv bW1vbi93ZWJraXRfZmluZGVyLnB5CkBAIC0zMiw2ICszMiwxMSBAQCBjbGFzcyBXZWJLaXRGaW5k ZXIob2JqZWN0KToKICAgICAgICAgc2VsZi5fZmlsZXN5c3RlbSA9IGZpbGVzeXN0ZW0KICAgICAg ICAgc2VsZi5fd2Via2l0X2Jhc2UgPSBOb25lCiAKKyAgICBkZWYgd2Via2l0X3Jlc3VsdHNfZGly KHNlbGYpOgorICAgICAgICBwYXRoX3RvX2J1aWxkX2RpciA9IHNlbGYuX2ZpbGVzeXN0ZW0uam9p bihzZWxmLndlYmtpdF9iYXNlKCksICJXZWJLaXRCdWlsZCIpCisgICAgICAgIGNvbmZpZ3VyYXRp b25fZGlyID0gc2VsZi5fZmlsZXN5c3RlbS5yZWFkX3RleHRfZmlsZShzZWxmLl9maWxlc3lzdGVt LmpvaW4ocGF0aF90b19idWlsZF9kaXIsICJDb25maWd1cmF0aW9uIikpCisgICAgICAgIHJldHVy biBzZWxmLl9maWxlc3lzdGVtLmpvaW4ocGF0aF90b19idWlsZF9kaXIsIGNvbmZpZ3VyYXRpb25f ZGlyKQorCiAgICAgZGVmIHdlYmtpdF9iYXNlKHNlbGYpOgogICAgICAgICAiIiJSZXR1cm5zIHRo ZSBhYnNvbHV0ZSBwYXRoIHRvIHRoZSB0b3Agb2YgdGhlIFdlYktpdCB0cmVlLgogCmRpZmYgLS1n aXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5weSBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvdGVzdC9tYWluLnB5CmluZGV4IGY1MThiNTEuLjdhMzZiYjUgMTAwNjQ0Ci0tLSBh L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvdGVzdC9tYWluLnB5CkBAIC0zMiw3ICszMiw5IEBAIGltcG9ydCBzeXMKIGltcG9y dCB0aW1lCiBpbXBvcnQgdHJhY2ViYWNrCiBpbXBvcnQgdW5pdHRlc3QKK2ltcG9ydCBqc29uCiAK K2Zyb20gd2Via2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktpdEZpbmRlcgog ZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZpbGVTeXN0ZW0K IGZyb20gd2Via2l0cHkudGVzdC5maW5kZXIgaW1wb3J0IEZpbmRlcgogZnJvbSB3ZWJraXRweS50 ZXN0LnByaW50ZXIgaW1wb3J0IFByaW50ZXIKQEAgLTc0LDcgKzc2LDggQEAgZGVmIG1haW4oKToK IAogY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIGZpbGVzeXN0 ZW09Tm9uZSk6Ci0gICAgICAgIHNlbGYuZmluZGVyID0gRmluZGVyKGZpbGVzeXN0ZW0gb3IgRmls ZVN5c3RlbSgpKQorICAgICAgICBzZWxmLl9maWxlc3lzdGVtID0gZmlsZXN5c3RlbSBvciBGaWxl U3lzdGVtKCkKKyAgICAgICAgc2VsZi5maW5kZXIgPSBGaW5kZXIoc2VsZi5fZmlsZXN5c3RlbSkK ICAgICAgICAgc2VsZi5wcmludGVyID0gUHJpbnRlcihzeXMuc3RkZXJyKQogICAgICAgICBzZWxm Ll9vcHRpb25zID0gTm9uZQogCkBAIC0xMDIsNiArMTA1LDggQEAgY2xhc3MgVGVzdGVyKG9iamVj dCk6CiAgICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2Rpc3BsYXkgcGVyLXRlc3QgZXhl Y3V0aW9uIHRpbWUgKGltcGxpZXMgLS12ZXJib3NlKScpCiAgICAgICAgIHBhcnNlci5hZGRfb3B0 aW9uKCctdicsICctLXZlcmJvc2UnLCBhY3Rpb249J2NvdW50JywgZGVmYXVsdD0wLAogICAgICAg ICAgICAgICAgICAgICAgICAgICBoZWxwPSd2ZXJib3NlIG91dHB1dCAoc3BlY2lmeSBvbmNlIGZv ciBpbmRpdmlkdWFsIHRlc3QgcmVzdWx0cywgdHdpY2UgZm9yIGRlYnVnIG1lc3NhZ2VzKScpCisg ICAgICAgIHBhcnNlci5hZGRfb3B0aW9uKCctcicsICctLXJlc3VsdHMtZGlyJywgYWN0aW9uPSdz dG9yZScsIGRlZmF1bHQ9IiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3NwZWNp ZmllcyBhIGRpcmVjdG9yeSBpbiB3aGljaCB0byBnZW5lcmF0ZSBhIGpzb24gZmlsZSB0aGF0IGNv bnRhaW5zIHRoZSByZXN1bHRzIG9mIHRoZSB0ZXN0cycpCiAKICAgICAgICAgcGFyc2VyLmVwaWxv ZyA9ICgnW2FyZ3MuLi5dIGlzIGFuIG9wdGlvbmFsIGxpc3Qgb2YgbW9kdWxlcywgdGVzdF9jbGFz c2VzLCBvciBpbmRpdmlkdWFsIHRlc3RzLiAnCiAgICAgICAgICAgICAgICAgICAgICAgICAgJ0lm IG5vIGFyZ3MgYXJlIGdpdmVuLCBhbGwgdGhlIHRlc3RzIHdpbGwgYmUgcnVuLicpCkBAIC0xNjIs NiArMTY3LDkgQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAKICAgICAgICAgc2VsZi5wcmludGVy LnByaW50X3Jlc3VsdCh0aW1lLnRpbWUoKSAtIHN0YXJ0KQogCisgICAgICAgIGlmIHNlbGYuX29w dGlvbnMucmVzdWx0c19kaXI6CisgICAgICAgICAgICBzZWxmLl9maWxlc3lzdGVtLndyaXRlX3Rl eHRfZmlsZShzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1bHRzX2Rpciwg InJlc3VsdHMuanNvbiIpLCB0ZXN0X3J1bm5lci50ZXN0X3N1aXRlX3Jlc3VsdHMudGVzdF9zdWl0 ZV9yZXN1bHRzX3RvX2pzb25fc3RyaW5nKCkpCisKICAgICAgICAgaWYgc2VsZi5fb3B0aW9ucy5j b3ZlcmFnZToKICAgICAgICAgICAgIGNvdi5zdG9wKCkKICAgICAgICAgICAgIGNvdi5zYXZlKCkK ZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5IGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3Jlc3VsdHMucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uNThiZDFmNAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5CkBAIC0wLDAgKzEsNjYgQEAKKyMgQ29weXJpZ2h0IChD KSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisj IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucworIyBhcmUgbWV0OgorIyAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgMi4gIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29w eXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisjICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorIworIyBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBB UyBJUycnIEFORAorIyBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorIyBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisjIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SCisjIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwKKyMgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IKKyMg U0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIKKyMgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwKKyMgT1IgVE9SVCAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworaW1wb3J0IGpzb24KK2ltcG9ydCBsb2dnaW5nCitf bG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCisKK2NsYXNzIFRlc3RTdWl0ZVJlc3Vs dHMob2JqZWN0KToKKyAgICBAY2xhc3NtZXRob2QKKyAgICBkZWYgdGVzdF9zdWl0ZV9yZXN1bHRz X2Zyb21fanNvbl9zdHJpbmcoY2xzLCBqc29uX3N0cmluZyk6CisgICAgICAgIGpzb25fZGljdCA9 IGpzb24ubG9hZHMoanNvbl9zdHJpbmcpCisgICAgICAgIGxpc3Rfb2ZfdGVzdF9yZXN1bHRzID0g W10KKyAgICAgICAgZm9yIHRlc3RfcmVzdWx0X2RpY3QgaW4ganNvbl9kaWN0WydsaXN0X29mX3Rl c3RfcmVzdWx0cyddOgorICAgICAgICAgICAgdGVzdF9yZXN1bHRfdHVwbGUgPSAodGVzdF9yZXN1 bHRfZGljdFsndGVzdF9uYW1lJ10sdGVzdF9yZXN1bHRfZGljdFsnZGlkX3Bhc3MnXSx0ZXN0X3Jl c3VsdF9kaWN0WydmYWlsdXJlX21lc3NhZ2VzJ10sdGVzdF9yZXN1bHRfZGljdFsnZXJyb3JfbWVz c2FnZXMnXSkKKyAgICAgICAgICAgIGxpc3Rfb2ZfdGVzdF9yZXN1bHRzLmFwcGVuZCh0ZXN0X3Jl c3VsdF90dXBsZSkKKworICAgICAgICByZXR1cm4gY2xzKGpzb25fZGljdFsndGVzdF9zdWl0ZV9u YW1lJ10sIGxpc3Rfb2ZfdGVzdF9yZXN1bHRzKQorCisgICAgZGVmIHRlc3Rfc3VpdGVfcmVzdWx0 c190b19qc29uX3N0cmluZyhzZWxmKToKKyAgICAgICAganNvbl9kaWN0ID0ge30KKyAgICAgICAg anNvbl9kaWN0Wyd0ZXN0X3N1aXRlX25hbWUnXSA9IHNlbGYudGVzdF9zdWl0ZV9uYW1lCisgICAg ICAgIGpzb25fZGljdFsnbGlzdF9vZl90ZXN0X3Jlc3VsdHMnXSA9IFtdCisgICAgICAgIGZvciB0 ZXN0X3Jlc3VsdF90dXBsZSBpbiBzZWxmLmxpc3Rfb2ZfdGVzdF9yZXN1bHRzOgorICAgICAgICAg ICAgdGVzdF9yZXN1bHRfZGljdCA9IHt9CisgICAgICAgICAgICB0ZXN0X3Jlc3VsdF9kaWN0Wyd0 ZXN0X25hbWUnXSA9IHRlc3RfcmVzdWx0X3R1cGxlWzBdCisgICAgICAgICAgICB0ZXN0X3Jlc3Vs dF9kaWN0WydkaWRfcGFzcyddID0gdGVzdF9yZXN1bHRfdHVwbGVbMV0KKyAgICAgICAgICAgIHRl c3RfcmVzdWx0X2RpY3RbJ2ZhaWx1cmVfbWVzc2FnZXMnXSA9IHRlc3RfcmVzdWx0X3R1cGxlWzJd CisgICAgICAgICAgICB0ZXN0X3Jlc3VsdF9kaWN0WydlcnJvcl9tZXNzYWdlcyddID0gdGVzdF9y ZXN1bHRfdHVwbGVbM10KKyAgICAgICAgICAgIGpzb25fZGljdFsnbGlzdF9vZl90ZXN0X3Jlc3Vs dHMnXS5hcHBlbmQodGVzdF9yZXN1bHRfZGljdCkKKyAgICAgICAganNvbl9kaWN0WydudW1iZXJf b2ZfdGVzdHNfcnVuJ10gPSBsZW4oc2VsZi5saXN0X29mX3Rlc3RfcmVzdWx0cykKKyAgICAgICAg cmV0dXJuIGpzb24uZHVtcHMoanNvbl9kaWN0KQorCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHRl c3Rfc3VpdGVfbmFtZSwgaW5pdGlhbF9saXN0X29mX3Rlc3RfcmVzdWx0cz1Ob25lKToKKyAgICAg ICAgc2VsZi50ZXN0X3N1aXRlX25hbWUgPSB0ZXN0X3N1aXRlX25hbWUKKyAgICAgICAgaWYgaW5p dGlhbF9saXN0X29mX3Rlc3RfcmVzdWx0czoKKyAgICAgICAgICAgIHNlbGYubGlzdF9vZl90ZXN0 X3Jlc3VsdHMgPSBpbml0aWFsX2xpc3Rfb2ZfdGVzdF9yZXN1bHRzCisgICAgICAgIGVsc2U6Cisg ICAgICAgICAgICBzZWxmLmxpc3Rfb2ZfdGVzdF9yZXN1bHRzID0gW10KKworICAgIGRlZiBhZGRf dGVzdF9yZXN1bHQoc2VsZiwgdGVzdF9uYW1lLCBkaWRfcGFzcywgZmFpbHVyZV9tZXNzYWdlcz1O b25lLCBlcnJvcl9tZXNzYWdlcz1Ob25lKToKKyAgICAgICAgc2VsZi5saXN0X29mX3Rlc3RfcmVz dWx0cy5hcHBlbmQoKHRlc3RfbmFtZSwgZGlkX3Bhc3MsIGZhaWx1cmVfbWVzc2FnZXMsIGVycm9y X21lc3NhZ2VzKSkKKworICAgIGRlZiBsaXN0X29mX2ZhaWxlZF90ZXN0X3Jlc3VsdHMoc2VsZik6 CisgICAgICAgIHJldHVybiBbcmVzdWx0IGZvciByZXN1bHQgaW4gc2VsZi5saXN0X29mX3Rlc3Rf cmVzdWx0cyBpZiByZXN1bHRbMl1dCisKKyAgICBkZWYgbGlzdF9vZl9lcnJvcmVkX3Rlc3RfcmVz dWx0cyhzZWxmKToKKyAgICAgICAgcmV0dXJuIFtyZXN1bHQgZm9yIHJlc3VsdCBpbiBzZWxmLmxp c3Rfb2ZfdGVzdF9yZXN1bHRzIGlmIHJlc3VsdFszXV0KZGlmZiAtLWdpdCBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90ZXN0L3Jlc3VsdHNfdW5pdHRlc3QucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uZjczYTA5NwotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdGVzdC9yZXN1bHRzX3VuaXR0ZXN0LnB5CkBAIC0wLDAgKzEsNTUgQEAKKyMgQ29weXJpZ2h0 IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworIyBhcmUgbWV0OgorIyAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgMi4g IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisjICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorIworIyBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMg YGBBUyBJUycnIEFORAorIyBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorIyBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisj IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SCisjIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwKKyMgREFNQUdFUyAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IK KyMgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIKKyMgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJ TElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwKKyMgT1IgVE9SVCAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworaW1wb3J0IHVuaXR0ZXN0CisKK2Zyb20gd2Vi a2l0cHkudGVzdC5yZXN1bHRzIGltcG9ydCBUZXN0U3VpdGVSZXN1bHRzCisKKworY2xhc3MgVGVz dFN1aXRlUmVzdWx0c1Rlc3QodW5pdHRlc3QuVGVzdENhc2UpOgorICAgIGRlZiB0ZXN0X2pzb25f c2VyaWFsaXphdGlvbl9hbmRfZGVzZXJpYWxpemF0aW9uKHNlbGYpOgorICAgIAl0ZXN0X3N1aXRl X3Jlc3VsdHMgPSBUZXN0U3VpdGVSZXN1bHRzKCJUZXN0IFRlc3QgU3VpdGUiKQorICAgICAgICB0 ZXN0X3N1aXRlX3Jlc3VsdHMuYWRkX3Rlc3RfcmVzdWx0KHRlc3RfbmFtZT0iRmlyc3QgVGVzdCIs ZGlkX3Bhc3M9VHJ1ZSwgZmFpbHVyZV9tZXNzYWdlcz1bXSwgZXJyb3JfbWVzc2FnZXM9W10pCisg ICAgICAgIHRlc3Rfc3VpdGVfcmVzdWx0cy5hZGRfdGVzdF9yZXN1bHQodGVzdF9uYW1lPSJTZWNv bmQgVGVzdCIsZGlkX3Bhc3M9RmFsc2UsIGZhaWx1cmVfbWVzc2FnZXM9WyJGYWlsdXJlIE1lc3Nh Z2UiXSwgZXJyb3JfbWVzc2FnZXM9W10pCisgICAgICAgIHRlc3Rfc3VpdGVfcmVzdWx0cy5hZGRf dGVzdF9yZXN1bHQodGVzdF9uYW1lPSJUaGlyZCBUZXN0IixkaWRfcGFzcz1GYWxzZSwgZmFpbHVy ZV9tZXNzYWdlcz1bXSwgZXJyb3JfbWVzc2FnZXM9WyJFcnJvciBNZXNzYWdlIl0pCisgICAgICAg IHRlc3Rfc3VpdGVfcmVzdWx0cy5hZGRfdGVzdF9yZXN1bHQodGVzdF9uYW1lPSJGb3VydGggVGVz dCIsZGlkX3Bhc3M9RmFsc2UsIGZhaWx1cmVfbWVzc2FnZXM9WyJGYWlsdXJlIE1lc3NhZ2UiXSwg ZXJyb3JfbWVzc2FnZXM9WyJFcnJvciBNZXNzYWdlIl0pCisKKyAgICAgICAgdGVzdF9zdWl0ZV9y ZXN1bHRzX2pzb25fc3RyaW5nID0gdGVzdF9zdWl0ZV9yZXN1bHRzLnRlc3Rfc3VpdGVfcmVzdWx0 c190b19qc29uX3N0cmluZygpCisgICAgICAgIHNlY29uZF90ZXN0X3N1aXRlX3Jlc3VsdHMgPSBU ZXN0U3VpdGVSZXN1bHRzLnRlc3Rfc3VpdGVfcmVzdWx0c19mcm9tX2pzb25fc3RyaW5nKHRlc3Rf c3VpdGVfcmVzdWx0c19qc29uX3N0cmluZykKKworICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHRl c3Rfc3VpdGVfcmVzdWx0cy50ZXN0X3N1aXRlX25hbWUsIHNlY29uZF90ZXN0X3N1aXRlX3Jlc3Vs dHMudGVzdF9zdWl0ZV9uYW1lKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGxlbih0ZXN0X3N1 aXRlX3Jlc3VsdHMubGlzdF9vZl90ZXN0X3Jlc3VsdHMpLDQpCisgICAgICAgIHNlbGYuYXNzZXJ0 RXF1YWwobGVuKHNlY29uZF90ZXN0X3N1aXRlX3Jlc3VsdHMubGlzdF9vZl90ZXN0X3Jlc3VsdHMp LDQpCisKKyAgICAgICAgZm9yIHRlc3RfaW5kZXggaW4gcmFuZ2UoMCw0KToKKyAgICAgICAgCWZp cnN0X3Rlc3RfcmVzdWx0ID0gdGVzdF9zdWl0ZV9yZXN1bHRzLmxpc3Rfb2ZfdGVzdF9yZXN1bHRz W3Rlc3RfaW5kZXhdCisgICAgICAgIAlzZWNvbmRfdGVzdF9yZXN1bHQgPSBzZWNvbmRfdGVzdF9z dWl0ZV9yZXN1bHRzLmxpc3Rfb2ZfdGVzdF9yZXN1bHRzW3Rlc3RfaW5kZXhdCisKKyAgICAgICAg CWZvciB0dXBsZV9pbmRleCBpbiByYW5nZSgwLDQpOgorICAgICAgICAJCXNlbGYuYXNzZXJ0RXF1 YWwoZmlyc3RfdGVzdF9yZXN1bHRbdHVwbGVfaW5kZXhdLCBzZWNvbmRfdGVzdF9yZXN1bHRbdHVw bGVfaW5kZXhdKQorCisgICAgZGVmIHRlc3Rfc3VpdGVfcmVzdWx0c19tdXR1YWxfaW5kZXBlbmRl bmNlKHNlbGYpOgorICAgIAlmaXJzdF9zdWl0ZV9yZXN1bHRzID0gVGVzdFN1aXRlUmVzdWx0cygi VGVzdCBUZXN0IFN1aXRlIikKKyAgICAgICAgZmlyc3Rfc3VpdGVfcmVzdWx0cy5hZGRfdGVzdF9y ZXN1bHQodGVzdF9uYW1lPSJGaXJzdCBUZXN0IixkaWRfcGFzcz1UcnVlLCBmYWlsdXJlX21lc3Nh Z2VzPVtdLCBlcnJvcl9tZXNzYWdlcz1bXSkKKworICAgIAlzZWNvbmRfc3VpdGVfcmVzdWx0cyA9 IFRlc3RTdWl0ZVJlc3VsdHMoIlNlY29uZCBUZXN0IFRlc3QgU3VpdGUiKQorICAgIAlzZWxmLmFz c2VydEVxdWFsKGxlbihzZWNvbmRfc3VpdGVfcmVzdWx0cy5saXN0X29mX3Rlc3RfcmVzdWx0cyks MCkKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHkgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyLnB5CmluZGV4IGQzZjU3NjQuLjk4YmZk YzAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHkKKysr IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lci5weQpAQCAtMjcsNiArMjcsNyBA QCBpbXBvcnQgdGltZQogaW1wb3J0IHVuaXR0ZXN0CiAKIGZyb20gd2Via2l0cHkuY29tbW9uIGlt cG9ydCBtZXNzYWdlX3Bvb2wKK2Zyb20gd2Via2l0cHkudGVzdC5yZXN1bHRzIGltcG9ydCBUZXN0 U3VpdGVSZXN1bHRzCiAKIF90ZXN0X2Rlc2NyaXB0aW9uID0gcmUuY29tcGlsZSgiKFx3KykgXCgo W1x3Ll0rKVwpIikKIApAQCAtNDAsOSArNDEsNyBAQCBjbGFzcyBSdW5uZXIob2JqZWN0KToKICAg ICBkZWYgX19pbml0X18oc2VsZiwgcHJpbnRlciwgbG9hZGVyKToKICAgICAgICAgc2VsZi5wcmlu dGVyID0gcHJpbnRlcgogICAgICAgICBzZWxmLmxvYWRlciA9IGxvYWRlcgotICAgICAgICBzZWxm LnRlc3RzX3J1biA9IDAKLSAgICAgICAgc2VsZi5lcnJvcnMgPSBbXQotICAgICAgICBzZWxmLmZh aWx1cmVzID0gW10KKyAgICAgICAgc2VsZi50ZXN0X3N1aXRlX3Jlc3VsdHMgPSBUZXN0U3VpdGVS ZXN1bHRzKCJQeXRob24gVW5pdCBUZXN0cyIpCiAgICAgICAgIHNlbGYud29ya2VyX2ZhY3Rvcnkg PSBsYW1iZGEgY2FsbGVyOiBfV29ya2VyKGNhbGxlciwgc2VsZi5sb2FkZXIpCiAKICAgICBkZWYg cnVuKHNlbGYsIHRlc3RfbmFtZXMsIG51bV93b3JrZXJzKToKQEAgLTU3LDExICs1Niw4IEBAIGNs YXNzIFJ1bm5lcihvYmplY3QpOgogICAgICAgICAgICAgc2VsZi5wcmludGVyLnByaW50X3N0YXJ0 ZWRfdGVzdChzb3VyY2UsIHRlc3RfbmFtZSkKICAgICAgICAgICAgIHJldHVybgogCi0gICAgICAg IHNlbGYudGVzdHNfcnVuICs9IDEKLSAgICAgICAgaWYgZmFpbHVyZXM6Ci0gICAgICAgICAgICBz ZWxmLmZhaWx1cmVzLmFwcGVuZCgodGVzdF9uYW1lLCBmYWlsdXJlcykpCi0gICAgICAgIGlmIGVy cm9yczoKLSAgICAgICAgICAgIHNlbGYuZXJyb3JzLmFwcGVuZCgodGVzdF9uYW1lLCBlcnJvcnMp KQorICAgICAgICBzZWxmLnRlc3Rfc3VpdGVfcmVzdWx0cy5hZGRfdGVzdF9yZXN1bHQodGVzdF9u YW1lPXRlc3RfbmFtZSxkaWRfcGFzcz1ub3QgYm9vbChmYWlsdXJlcyArIGVycm9ycyksIGZhaWx1 cmVfbWVzc2FnZXM9ZmFpbHVyZXMsIGVycm9yX21lc3NhZ2VzPWVycm9ycykKKwogICAgICAgICBz ZWxmLnByaW50ZXIucHJpbnRfZmluaXNoZWRfdGVzdChzb3VyY2UsIHRlc3RfbmFtZSwgZGVsYXks IGZhaWx1cmVzLCBlcnJvcnMpCiAKIApkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS90ZXN0L3J1bm5lcl91bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9y dW5uZXJfdW5pdHRlc3QucHkKaW5kZXggOTk1MDcwYi4uMzIxNzU0OSAxMDA2NDQKLS0tIGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lcl91bml0dGVzdC5weQorKysgYi9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0LnB5CkBAIC0yOSw3ICsyOSw2IEBA IGZyb20gd2Via2l0cHkudG9vbC5tb2NrdG9vbCBpbXBvcnQgTW9ja09wdGlvbnMKIGZyb20gd2Vi a2l0cHkudGVzdC5wcmludGVyIGltcG9ydCBQcmludGVyCiBmcm9tIHdlYmtpdHB5LnRlc3QucnVu bmVyIGltcG9ydCBSdW5uZXIKIAotCiBjbGFzcyBGYWtlTW9kdWxlU3VpdGUob2JqZWN0KToKICAg ICBkZWYgX19pbml0X18oc2VsZiwgbmFtZSwgcmVzdWx0LCBtc2cpOgogICAgICAgICBzZWxmLm5h bWUgPSBuYW1lCkBAIC05Miw2ICs5MSw3IEBAIGNsYXNzIFJ1bm5lclRlc3QodW5pdHRlc3QuVGVz dENhc2UpOgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICgndGVzdDMgKEZvbyknLCAnRScs ICd0ZXN0M1xuZXJyZWQnKSkKICAgICAgICAgcnVubmVyID0gUnVubmVyKFByaW50ZXIoc3RyZWFt LCBvcHRpb25zKSwgbG9hZGVyKQogICAgICAgICBydW5uZXIucnVuKFsnRm9vLnRlc3QxJywgJ0Zv by50ZXN0MicsICdGb28udGVzdDMnXSwgMSkKLSAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChydW5u ZXIudGVzdHNfcnVuLCAzKQotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5uZXIuZmFp bHVyZXMpLCAxKQotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5uZXIuZXJyb3JzKSwg MSkKKworICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5uZXIudGVzdF9zdWl0ZV9yZXN1 bHRzLmxpc3Rfb2ZfdGVzdF9yZXN1bHRzKSwgMykKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChs ZW4ocnVubmVyLnRlc3Rfc3VpdGVfcmVzdWx0cy5saXN0X29mX2ZhaWxlZF90ZXN0X3Jlc3VsdHMo KSksIDEpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci50ZXN0X3N1aXRlX3Jl c3VsdHMubGlzdF9vZl9lcnJvcmVkX3Rlc3RfcmVzdWx0cygpKSwgMSkKZGlmZiAtLWdpdCBhL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91bml0dGVzdC5weSBi L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91bml0dGVzdC5w eQppbmRleCA1OWI1MmVhLi4wYWM2ZDA2IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L3Rvb2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5CkBAIC0zNCw2ICsz NCw4IEBAIGZyb20gd2Via2l0cHkudG9vbC5jb21tYW5kcy5jb21tYW5kdGVzdCBpbXBvcnQgQ29t bWFuZHNUZXN0CiBmcm9tIHdlYmtpdHB5LnRvb2wuY29tbWFuZHMuZG93bmxvYWQgaW1wb3J0ICoK IGZyb20gd2Via2l0cHkudG9vbC5tb2NrdG9vbCBpbXBvcnQgTW9ja09wdGlvbnMsIE1vY2tUb29s CiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5jaGVja291dC5jaGVja291dF9tb2NrIGltcG9ydCBNb2Nr Q2hlY2tvdXQKK2Zyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5maWxlc3lzdGVtIGltcG9ydCBG aWxlU3lzdGVtCitmcm9tIHdlYmtpdHB5LmNvbW1vbi53ZWJraXRfZmluZGVyIGltcG9ydCBXZWJL aXRGaW5kZXIKIAogCiBjbGFzcyBBYnN0cmFjdFJvbGxvdXRQcmVwQ29tbWFuZFRlc3QodW5pdHRl c3QuVGVzdENhc2UpOgpAQCAtMTU2LDYgKzE1OCw4IEBAIFVwZGF0aW5nIGJ1ZyA1MDAwMAogICAg ICAgICBzZWxmLmFzc2VydEVxdWFsKG1vY2tfdG9vbC5jaGVja291dCgpLm1vZGlmaWVkX2NoYW5n ZWxvZ3MuY2FsbF9jb3VudCwgMSkKIAogICAgIGRlZiB0ZXN0X2xhbmRfY293aGFuZChzZWxmKToK KyAgICAgICAgZmlsZXN5c3RlbSA9IEZpbGVTeXN0ZW0oKQorICAgICAgICB3ZWJraXRfZmluZGVy ID0gV2ViS2l0RmluZGVyKGZpbGVzeXN0ZW0pCiAgICAgICAgIGV4cGVjdGVkX2xvZ3MgPSAiIiJN T0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLXByZXBhcmUtQ2hhbmdlTG9nJywgJy0t ZW1haWw9TU9DSyBlbWFpbCcsICctLW1lcmdlLWJhc2U9Tm9uZScsICdNb2NrRmlsZTEnXSwgY3dk PS9tb2NrLWNoZWNrb3V0CiBNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLWNoZWNr LXdlYmtpdC1zdHlsZScsICctLWdpdC1jb21taXQnLCAnTU9DSyBnaXQgY29tbWl0JywgJy0tZGlm Zi1maWxlcycsICdNb2NrRmlsZTEnLCAnLS1maWx0ZXInLCAnLWNoYW5nZWxvZyddLCBjd2Q9L21v Y2stY2hlY2tvdXQKIE1PQ0sgcnVuX2NvbW1hbmQ6IFsncnVieScsICctSScsICcvbW9jay1jaGVj a291dC9XZWJzaXRlcy9idWdzLndlYmtpdC5vcmcvUHJldHR5UGF0Y2gnLCAnL21vY2stY2hlY2tv dXQvV2Vic2l0ZXMvYnVncy53ZWJraXQub3JnL1ByZXR0eVBhdGNoL3ByZXR0aWZ5LnJiJ10sIGN3 ZD1Ob25lLCBpbnB1dD1QYXRjaDEKQEAgLTE2NCw3ICsxNjgsNyBAQCBXYXMgdGhhdCBkaWZmIGNv cnJlY3Q/CiBCdWlsZGluZyBXZWJLaXQKIE1PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ21v Y2stYnVpbGQtd2Via2l0J10sIGN3ZD0vbW9jay1jaGVja291dCwgZW52PXsnTENfQUxMJzogJ0Mn LCAnVEVSTSc6ICdub25lJywgJ01PQ0tfRU5WSVJPTl9DT1BZJzogJzEnfQogUnVubmluZyBQeXRo b24gdW5pdCB0ZXN0cwotTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnbW9jay10ZXN0LXdl YmtpdHB5J10sIGN3ZD0vbW9jay1jaGVja291dAorTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6 IFsnbW9jay10ZXN0LXdlYmtpdHB5JywgJy0tcmVzdWx0cy1kaXInLCB1JyIiIiArIGZpbGVzeXN0 ZW0uam9pbih3ZWJraXRfZmluZGVyLndlYmtpdF9yZXN1bHRzX2RpcigpLCAicHl0aG9uLXVuaXR0 ZXN0LXJlc3VsdHMiKSArICIiIiddLCBjd2Q9L21vY2stY2hlY2tvdXQKIFJ1bm5pbmcgUGVybCB1 bml0IHRlc3RzCiBNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLXRlc3Qtd2Via2l0 cGVybCddLCBjd2Q9L21vY2stY2hlY2tvdXQKIFJ1bm5pbmcgSmF2YVNjcmlwdENvcmUgdGVzdHMK ZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0cy5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0cy5weQppbmRleCBh NDU2MjhiLi5jNDlmNGNjIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wv c3RlcHMvcnVudGVzdHMucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBz L3J1bnRlc3RzLnB5CkBAIC0zMyw2ICszMyw4IEBAIGltcG9ydCBzeXMKIGZyb20gd2Via2l0cHku dG9vbC5zdGVwcy5hYnN0cmFjdHN0ZXAgaW1wb3J0IEFic3RyYWN0U3RlcAogZnJvbSB3ZWJraXRw eS50b29sLnN0ZXBzLm9wdGlvbnMgaW1wb3J0IE9wdGlvbnMKIGZyb20gd2Via2l0cHkuY29tbW9u LnN5c3RlbS5leGVjdXRpdmUgaW1wb3J0IFNjcmlwdEVycm9yCitmcm9tIHdlYmtpdHB5LmNvbW1v bi53ZWJraXRfZmluZGVyIGltcG9ydCBXZWJLaXRGaW5kZXIKK2Zyb20gd2Via2l0cHkuY29tbW9u LnN5c3RlbS5maWxlc3lzdGVtIGltcG9ydCBGaWxlU3lzdGVtCiAKIF9sb2cgPSBsb2dnaW5nLmdl dExvZ2dlcihfX25hbWVfXykKIApAQCAtNTUsOCArNTcsMTUgQEAgY2xhc3MgUnVuVGVzdHMoQWJz dHJhY3RTdGVwKToKIAogICAgICAgICBpZiBub3Qgc2VsZi5fb3B0aW9ucy5ub25faW50ZXJhY3Rp dmU6CiAgICAgICAgICAgICAjIEZJWE1FOiBXZSBzaG91bGQgdGVhY2ggdGhlIGNvbW1pdC1xdWV1 ZSBhbmQgdGhlIEVXUyBob3cgdG8gcnVuIHRoZXNlIHRlc3RzLgorICAgICAgICAgICAgZmlsZXN5 c3RlbSA9IEZpbGVTeXN0ZW0oKQorICAgICAgICAgICAgd2Via2l0X2ZpbmRlciA9IFdlYktpdEZp bmRlcihmaWxlc3lzdGVtKQorICAgICAgICAgICAgcHl0aG9uX3VuaXR0ZXN0c19yZXN1bHRzX2Rp ciA9IGZpbGVzeXN0ZW0uam9pbih3ZWJraXRfZmluZGVyLndlYmtpdF9yZXN1bHRzX2RpcigpLCAi cHl0aG9uLXVuaXR0ZXN0LXJlc3VsdHMiKQorICAgICAgICAgICAgZmlsZXN5c3RlbS5tYXliZV9t YWtlX2RpcmVjdG9yeShweXRob25fdW5pdHRlc3RzX3Jlc3VsdHNfZGlyKQogCiAgICAgICAgICAg ICBweXRob25fdW5pdHRlc3RzX2NvbW1hbmQgPSBzZWxmLl90b29sLmRlcHJlY2F0ZWRfcG9ydCgp LnJ1bl9weXRob25fdW5pdHRlc3RzX2NvbW1hbmQoKQorICAgICAgICAgICAgcHl0aG9uX3VuaXR0 ZXN0c19jb21tYW5kLmFwcGVuZCgiLS1yZXN1bHRzLWRpciIpCisgICAgICAgICAgICBweXRob25f dW5pdHRlc3RzX2NvbW1hbmQuYXBwZW5kKHB5dGhvbl91bml0dGVzdHNfcmVzdWx0c19kaXIpCisK ICAgICAgICAgICAgIGlmIHB5dGhvbl91bml0dGVzdHNfY29tbWFuZDoKICAgICAgICAgICAgICAg ICBfbG9nLmluZm8oIlJ1bm5pbmcgUHl0aG9uIHVuaXQgdGVzdHMiKQogICAgICAgICAgICAgICAg IHNlbGYuX3Rvb2wuZXhlY3V0aXZlLnJ1bl9hbmRfdGhyb3dfaWZfZmFpbChweXRob25fdW5pdHRl c3RzX2NvbW1hbmQsIGN3ZD1zZWxmLl90b29sLnNjbSgpLmNoZWNrb3V0X3Jvb3QpCmRpZmYgLS1n aXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkKaW5k ZXggYjFlMmJmMS4uMmFmMDFlNCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90 b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv dG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weQpAQCAtMzEsNiArMzEsOCBAQCBpbXBvcnQgdW5p dHRlc3QKIGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5vdXRwdXRjYXB0dXJlIGltcG9ydCBP dXRwdXRDYXB0dXJlCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5jb25maWcucG9ydHMgaW1wb3J0IERl cHJlY2F0ZWRQb3J0CiBmcm9tIHdlYmtpdHB5LnRvb2wubW9ja3Rvb2wgaW1wb3J0IE1vY2tPcHRp b25zLCBNb2NrVG9vbAorZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1w b3J0IEZpbGVTeXN0ZW0KK2Zyb20gd2Via2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1wb3J0 IFdlYktpdEZpbmRlcgogCiBmcm9tIHdlYmtpdHB5LnRvb2wgaW1wb3J0IHN0ZXBzCiAKQEAgLTk2 LDYgKzk4LDggQEAgY2xhc3MgU3RlcHNUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAg c2VsZi5fYXNzZXJ0X3N0ZXBfb3V0cHV0X3dpdGhfYnVnKHN0ZXBzLkVuc3VyZUJ1Z0lzT3BlbkFu ZEFzc2lnbmVkLCA1MDAwMiwgZXhwZWN0ZWRfbG9ncykKIAogICAgIGRlZiB0ZXN0X3J1bnRlc3Rz X2FyZ3Moc2VsZik6CisgICAgICAgIGZpbGVzeXN0ZW0gPSBGaWxlU3lzdGVtKCkKKyAgICAgICAg d2Via2l0X2ZpbmRlciA9IFdlYktpdEZpbmRlcihmaWxlc3lzdGVtKQogICAgICAgICBtb2NrX29w dGlvbnMgPSBzZWxmLl9zdGVwX29wdGlvbnMoKQogICAgICAgICBtb2NrX29wdGlvbnMubm9uX2lu dGVyYWN0aXZlID0gRmFsc2UKICAgICAgICAgc3RlcCA9IHN0ZXBzLlJ1blRlc3RzKE1vY2tUb29s KGxvZ19leGVjdXRpdmU9VHJ1ZSksIG1vY2tfb3B0aW9ucykKQEAgLTEwNCw3ICsxMDgsNyBAQCBj bGFzcyBTdGVwc1Rlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICB0b29sLl9kZXByZWNh dGVkX3BvcnQgPSBEZXByZWNhdGVkUG9ydCgpCiAgICAgICAgIHN0ZXAgPSBzdGVwcy5SdW5UZXN0 cyh0b29sLCBtb2NrX29wdGlvbnMpCiAgICAgICAgIGV4cGVjdGVkX2xvZ3MgPSAiIiJSdW5uaW5n IFB5dGhvbiB1bml0IHRlc3RzCi1NT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydUb29scy9T Y3JpcHRzL3Rlc3Qtd2Via2l0cHknXSwgY3dkPS9tb2NrLWNoZWNrb3V0CitNT0NLIHJ1bl9hbmRf dGhyb3dfaWZfZmFpbDogWydUb29scy9TY3JpcHRzL3Rlc3Qtd2Via2l0cHknLCAnLS1yZXN1bHRz LWRpcicsIHUnIiIiICsgZmlsZXN5c3RlbS5qb2luKHdlYmtpdF9maW5kZXIud2Via2l0X3Jlc3Vs dHNfZGlyKCksICJweXRob24tdW5pdHRlc3QtcmVzdWx0cyIpICsgIiIiJ10sIGN3ZD0vbW9jay1j aGVja291dAogUnVubmluZyBQZXJsIHVuaXQgdGVzdHMKIE1PQ0sgcnVuX2FuZF90aHJvd19pZl9m YWlsOiBbJ1Rvb2xzL1NjcmlwdHMvdGVzdC13ZWJraXRwZXJsJ10sIGN3ZD0vbW9jay1jaGVja291 dAogUnVubmluZyBKYXZhU2NyaXB0Q29yZSB0ZXN0cwotLSAKMS45LjMgKEFwcGxlIEdpdC01MCkK Cg== 239345 2014-10-06 11:57:32 -0700 2014-10-10 17:44:53 -0700 Adds Config object logic, and changes runtest.py to make sure it doesn't accidentally circumvent mock injection 0001-Make-test-webkitpy-generate-a-JSON-file-of-its-resul.patch text/plain 21460 jake.nielsen.webkit RnJvbSAzZjc5MTQ2NmQwYTI0OWI3NDllZmNiNzhmNjE1M2U0ZGNkYjdlNjcwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBNb24sIDYgT2N0IDIwMTQgMTE6NTU6MTggLTA3MDAKU3ViamVjdDogW1BBVENIXSBN YWtlIHRlc3Qtd2Via2l0cHkgZ2VuZXJhdGUgYSBKU09OIGZpbGUgb2YgaXRzIHJlc3VsdHMKIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzczNTMKClJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgoKVGhlIHdlYmtpdCBidWlsZGJvdCBwYWdlJ3MgcmVzdWx0cy5odG1s IGZpbGUgc2hvdWxkIGNvbnRhaW4gcmVzdWx0cwpmb3IgdGhlIHB5dGhvbiB1bml0IHRlc3RzIChh bmQgc29vbiB0byBiZSBvdGhlcnMpLCBhcyBzaG91bGQgdGhlIEVXUwpidWJibGVzLiBUaGV5IHdp bGwgY29uc3VtZSB0aGUgSlNPTiBmaWxlIGNyZWF0ZWQgaW4gdGhpcyBwYXRjaCB0bwphY2hpZXZl IHRob3NlIGVuZHMuCgoqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5OgpBZGRzIHRoZSAt LXJlc3VsdHMtZGlyZWN0b3J5IG9wdGlvbiwgYW5kIGFkZHMgbG9naWMgdG8gZHVtcCBhIEpTT04g ZmlsZSBvZgp0aGUgcmVzdWx0cyBpZiAtLXJlc3VsdHMtZGlyZWN0b3J5IGhhcyBiZWVuIHNwZWNp ZmllZC4KKFRlc3Rlci5fX2luaXRfXyk6CihUZXN0ZXIuX3BhcnNlX2FyZ3MpOgooVGVzdGVyLl9y dW5fdGVzdHMpOgoqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5OiBBZGRlZC4KUHJv dmlkZXMgYSBjbGFzcyB0byBlbmNhcHN1bGF0ZSB0ZXN0IHJlc3VsdHMsIGFuZCB0byBhZGQgaXNv bGF0aW9uCmJldHdlZW4gdGhlIEpTT04gZmlsZSBhbmQgdGhlIHJlc3Qgb2Ygd2Via2l0cHkuCihU ZXN0U3VpdGVSZXN1bHRzKToKKFRlc3RTdWl0ZVJlc3VsdHMudGVzdF9zdWl0ZV9yZXN1bHRzX2Zy b21fanNvbl9zdHJpbmcpOgooVGVzdFN1aXRlUmVzdWx0cy50ZXN0X3N1aXRlX3Jlc3VsdHNfdG9f anNvbl9zdHJpbmcpOgooVGVzdFN1aXRlUmVzdWx0cy5fX2luaXRfXyk6CihUZXN0U3VpdGVSZXN1 bHRzLmFkZF90ZXN0X3Jlc3VsdCk6CihUZXN0U3VpdGVSZXN1bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rl c3RfcmVzdWx0cyk6CihUZXN0U3VpdGVSZXN1bHRzLmxpc3Rfb2ZfZXJyb3JlZF90ZXN0X3Jlc3Vs dHMpOgoqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzX3VuaXR0ZXN0LnB5OiBBZGRlZC4K QWRkcyBhIHRlc3QgdG8gbWFrZSBzdXJlIHRoYXQgc2VyaWFsaXphdGlvbiBhbmQgc3Vic2VxdWVu dCBkZXNlcmlhbGl6YXRpb24gcmVzdWx0CmluIGFuIGVxdWl2ZWxhbnQgVGVzdFN1aXRlUmVzdWx0 cyBvYmplY3QuCkFsc28gYWRkcyBhIHRlc3QgdG8gY2F0Y2ggYSBidWcgdGhhdCBjYXVzZWQgc29t ZSBzdGF0ZSB0byBibGVlZApiZXR3ZWVuIFRlc3RTdWl0ZVJlc3VsdHMgb2JqZWN0cy4KKFRlc3RT dWl0ZVJlc3VsdHNUZXN0KToKKFRlc3RTdWl0ZVJlc3VsdHNUZXN0LnRlc3RfanNvbl9zZXJpYWxp emF0aW9uX2FuZF9kZXNlcmlhbGl6YXRpb24pOgooVGVzdFN1aXRlUmVzdWx0c1Rlc3QudGVzdF9z dWl0ZV9yZXN1bHRzX211dHVhbF9pbmRlcGVuZGVuY2UpOgoqIFNjcmlwdHMvd2Via2l0cHkvdGVz dC9ydW5uZXIucHk6ClRlYWNoZXMgcnVubmVyLnB5IHRvIHVzZSBUZXN0U3VpdGVSZXN1bHRzIG9i amVjdHMgaW5zdGVhZCBvZiBqdXN0IHN0dWZmaW5nCmV2ZXJ5dGhpbmcgaW50byB0dXBsZXMgYW5k IGxpc3RzLgooUnVubmVyLl9faW5pdF9fKToKKFJ1bm5lci5oYW5kbGUpOgoqIFNjcmlwdHMvd2Vi a2l0cHkvdGVzdC9ydW5uZXJfdW5pdHRlc3QucHk6ClRlYWNoZXMgdGVzdF9ydW4gaG93IHRvIHVz ZSBUZXN0U3VpdGVSZXN1bHRzIG9iamVjdHMuCihSdW5uZXJUZXN0LnRlc3RfcnVuKToKKiBTY3Jp cHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHk6ClVwZGF0ZXMg dGhlIHRlc3RfbGFuZF9jb3doYW5kIHRlc3QgdG8gcHJvcGVybHkgYW50aWNpcGF0ZSB3aGF0IFJ1 blRlc3QKc2hvdWxkIGJlIHN0ZG91dGluZy4KKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMv cnVudGVzdHMucHk6ClRlYWNoZXMgUnVuVGVzdHMgdG8gcGFzcyBhIC0tcmVzdWx0cy1kaXJlY3Rv cnkgdG8gdGVzdC13ZWJraXRweS4KKFJ1blRlc3RzLnJ1bik6CiogU2NyaXB0cy93ZWJraXRweS90 b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5OgpVcGRhdGVzIHRoZSB0ZXN0X3J1bnRlc3RzX2Fy Z3MgdGVzdCB0byBwcm9wZXJseSBhbnRpY2lwYXRlIHdoYXQgUnVuVGVzdApzaG91bGQgYmUgc3Rk b3V0aW5nLgooU3RlcHNUZXN0LnRlc3RfcnVudGVzdHNfYXJncyk6Ci0tLQogVG9vbHMvQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCA1NSArKysrKysrKysrKysr KysrKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAgICAgICAg IHwgIDkgKystCiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5weSAgICAgICAg ICAgICB8IDY1ICsrKysrKysrKysrKysrKysrKysrKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dGVzdC9yZXN1bHRzX3VuaXR0ZXN0LnB5ICAgIHwgNTUgKysrKysrKysrKysrKysrKysrCiBUb29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyLnB5ICAgICAgICAgICAgICB8IDEyICsrLS0K IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXJfdW5pdHRlc3QucHkgICAgIHwgIDcg KystCiAuLi4vd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91bml0dGVzdC5weSAgICB8 ICAzICstCiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMucHkgICAg ICB8IDE0ICsrKysrCiAuLi4vU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBzX3VuaXR0 ZXN0LnB5ICB8ICA1ICstCiA5IGZpbGVzIGNoYW5nZWQsIDIxMCBpbnNlcnRpb25zKCspLCAxNSBk ZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rl c3QvcmVzdWx0cy5weQogY3JlYXRlIG1vZGUgMTAwNjQ0IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dGVzdC9yZXN1bHRzX3VuaXR0ZXN0LnB5CgpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIv VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDRmNDNiZWMuLjM3Yzg3OWQgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1OCBAQAorMjAxNC0x MC0wNiAgSmFrZSBOaWVsc2VuICA8amFjb2JfbmllbHNlbkBhcHBsZS5jb20+CisKKyAgICAgICAg TWFrZSB0ZXN0LXdlYmtpdHB5IGdlbmVyYXRlIGEgSlNPTiBmaWxlIG9mIGl0cyByZXN1bHRzCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzczNTMKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGUgd2Via2l0 IGJ1aWxkYm90IHBhZ2UncyByZXN1bHRzLmh0bWwgZmlsZSBzaG91bGQgY29udGFpbiByZXN1bHRz CisgICAgICAgIGZvciB0aGUgcHl0aG9uIHVuaXQgdGVzdHMgKGFuZCBzb29uIHRvIGJlIG90aGVy cyksIGFzIHNob3VsZCB0aGUgRVdTCisgICAgICAgIGJ1YmJsZXMuIFRoZXkgd2lsbCBjb25zdW1l IHRoZSBKU09OIGZpbGUgY3JlYXRlZCBpbiB0aGlzIHBhdGNoIHRvCisgICAgICAgIGFjaGlldmUg dGhvc2UgZW5kcy4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5Ogor ICAgICAgICBBZGRzIHRoZSAtLXJlc3VsdHMtZGlyZWN0b3J5IG9wdGlvbiwgYW5kIGFkZHMgbG9n aWMgdG8gZHVtcCBhIEpTT04gZmlsZSBvZgorICAgICAgICB0aGUgcmVzdWx0cyBpZiAtLXJlc3Vs dHMtZGlyZWN0b3J5IGhhcyBiZWVuIHNwZWNpZmllZC4KKyAgICAgICAgKFRlc3Rlci5fX2luaXRf Xyk6CisgICAgICAgIChUZXN0ZXIuX3BhcnNlX2FyZ3MpOgorICAgICAgICAoVGVzdGVyLl9ydW5f dGVzdHMpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5OiBBZGRl ZC4KKyAgICAgICAgUHJvdmlkZXMgYSBjbGFzcyB0byBlbmNhcHN1bGF0ZSB0ZXN0IHJlc3VsdHMs IGFuZCB0byBhZGQgaXNvbGF0aW9uCisgICAgICAgIGJldHdlZW4gdGhlIEpTT04gZmlsZSBhbmQg dGhlIHJlc3Qgb2Ygd2Via2l0cHkuCisgICAgICAgIChUZXN0U3VpdGVSZXN1bHRzKToKKyAgICAg ICAgKFRlc3RTdWl0ZVJlc3VsdHMudGVzdF9zdWl0ZV9yZXN1bHRzX2Zyb21fanNvbl9zdHJpbmcp OgorICAgICAgICAoVGVzdFN1aXRlUmVzdWx0cy50ZXN0X3N1aXRlX3Jlc3VsdHNfdG9fanNvbl9z dHJpbmcpOgorICAgICAgICAoVGVzdFN1aXRlUmVzdWx0cy5fX2luaXRfXyk6CisgICAgICAgIChU ZXN0U3VpdGVSZXN1bHRzLmFkZF90ZXN0X3Jlc3VsdCk6CisgICAgICAgIChUZXN0U3VpdGVSZXN1 bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cyk6CisgICAgICAgIChUZXN0U3VpdGVSZXN1 bHRzLmxpc3Rfb2ZfZXJyb3JlZF90ZXN0X3Jlc3VsdHMpOgorICAgICAgICAqIFNjcmlwdHMvd2Vi a2l0cHkvdGVzdC9yZXN1bHRzX3VuaXR0ZXN0LnB5OiBBZGRlZC4KKyAgICAgICAgQWRkcyBhIHRl c3QgdG8gbWFrZSBzdXJlIHRoYXQgc2VyaWFsaXphdGlvbiBhbmQgc3Vic2VxdWVudCBkZXNlcmlh bGl6YXRpb24gcmVzdWx0CisgICAgICAgIGluIGFuIGVxdWl2ZWxhbnQgVGVzdFN1aXRlUmVzdWx0 cyBvYmplY3QuCisgICAgICAgIEFsc28gYWRkcyBhIHRlc3QgdG8gY2F0Y2ggYSBidWcgdGhhdCBj YXVzZWQgc29tZSBzdGF0ZSB0byBibGVlZAorICAgICAgICBiZXR3ZWVuIFRlc3RTdWl0ZVJlc3Vs dHMgb2JqZWN0cy4KKyAgICAgICAgKFRlc3RTdWl0ZVJlc3VsdHNUZXN0KToKKyAgICAgICAgKFRl c3RTdWl0ZVJlc3VsdHNUZXN0LnRlc3RfanNvbl9zZXJpYWxpemF0aW9uX2FuZF9kZXNlcmlhbGl6 YXRpb24pOgorICAgICAgICAoVGVzdFN1aXRlUmVzdWx0c1Rlc3QudGVzdF9zdWl0ZV9yZXN1bHRz X211dHVhbF9pbmRlcGVuZGVuY2UpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9y dW5uZXIucHk6CisgICAgICAgIFRlYWNoZXMgcnVubmVyLnB5IHRvIHVzZSBUZXN0U3VpdGVSZXN1 bHRzIG9iamVjdHMgaW5zdGVhZCBvZiBqdXN0IHN0dWZmaW5nCisgICAgICAgIGV2ZXJ5dGhpbmcg aW50byB0dXBsZXMgYW5kIGxpc3RzLgorICAgICAgICAoUnVubmVyLl9faW5pdF9fKToKKyAgICAg ICAgKFJ1bm5lci5oYW5kbGUpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5u ZXJfdW5pdHRlc3QucHk6CisgICAgICAgIFRlYWNoZXMgdGVzdF9ydW4gaG93IHRvIHVzZSBUZXN0 U3VpdGVSZXN1bHRzIG9iamVjdHMuCisgICAgICAgIChSdW5uZXJUZXN0LnRlc3RfcnVuKToKKyAg ICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3Qu cHk6CisgICAgICAgIFVwZGF0ZXMgdGhlIHRlc3RfbGFuZF9jb3doYW5kIHRlc3QgdG8gcHJvcGVy bHkgYW50aWNpcGF0ZSB3aGF0IFJ1blRlc3QKKyAgICAgICAgc2hvdWxkIGJlIHN0ZG91dGluZy4K KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMucHk6CisgICAg ICAgIFRlYWNoZXMgUnVuVGVzdHMgdG8gcGFzcyBhIC0tcmVzdWx0cy1kaXJlY3RvcnkgdG8gdGVz dC13ZWJraXRweS4KKyAgICAgICAgKFJ1blRlc3RzLnJ1bik6CisgICAgICAgICogU2NyaXB0cy93 ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5OgorICAgICAgICBVcGRhdGVzIHRo ZSB0ZXN0X3J1bnRlc3RzX2FyZ3MgdGVzdCB0byBwcm9wZXJseSBhbnRpY2lwYXRlIHdoYXQgUnVu VGVzdAorICAgICAgICBzaG91bGQgYmUgc3Rkb3V0aW5nLgorICAgICAgICAoU3RlcHNUZXN0LnRl c3RfcnVudGVzdHNfYXJncyk6CisKIDIwMTQtMTAtMDIgIENhcmxvcyBBbGJlcnRvIExvcGV6IFBl cmV6ICA8Y2xvcGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dUS10gW0pIQnVpbGRdIFN3aXRj aCBzb3VyY2V3YXJlLm9yZyBtaXJyb3IgdG8gaHR0cC4KZGlmZiAtLWdpdCBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvdGVzdC9tYWluLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L21h aW4ucHkKaW5kZXggZjUxOGI1MS4uYTFlMjQzMSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS90ZXN0L21haW4ucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L21h aW4ucHkKQEAgLTMyLDYgKzMyLDcgQEAgaW1wb3J0IHN5cwogaW1wb3J0IHRpbWUKIGltcG9ydCB0 cmFjZWJhY2sKIGltcG9ydCB1bml0dGVzdAoraW1wb3J0IGpzb24KIAogZnJvbSB3ZWJraXRweS5j b21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZpbGVTeXN0ZW0KIGZyb20gd2Via2l0cHku dGVzdC5maW5kZXIgaW1wb3J0IEZpbmRlcgpAQCAtNzQsNyArNzUsOCBAQCBkZWYgbWFpbigpOgog CiBjbGFzcyBUZXN0ZXIob2JqZWN0KToKICAgICBkZWYgX19pbml0X18oc2VsZiwgZmlsZXN5c3Rl bT1Ob25lKToKLSAgICAgICAgc2VsZi5maW5kZXIgPSBGaW5kZXIoZmlsZXN5c3RlbSBvciBGaWxl U3lzdGVtKCkpCisgICAgICAgIHNlbGYuX2ZpbGVzeXN0ZW0gPSBmaWxlc3lzdGVtIG9yIEZpbGVT eXN0ZW0oKQorICAgICAgICBzZWxmLmZpbmRlciA9IEZpbmRlcihzZWxmLl9maWxlc3lzdGVtKQog ICAgICAgICBzZWxmLnByaW50ZXIgPSBQcmludGVyKHN5cy5zdGRlcnIpCiAgICAgICAgIHNlbGYu X29wdGlvbnMgPSBOb25lCiAKQEAgLTEwMiw2ICsxMDQsOCBAQCBjbGFzcyBUZXN0ZXIob2JqZWN0 KToKICAgICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0nZGlzcGxheSBwZXItdGVzdCBleGVj dXRpb24gdGltZSAoaW1wbGllcyAtLXZlcmJvc2UpJykKICAgICAgICAgcGFyc2VyLmFkZF9vcHRp b24oJy12JywgJy0tdmVyYm9zZScsIGFjdGlvbj0nY291bnQnLCBkZWZhdWx0PTAsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgIGhlbHA9J3ZlcmJvc2Ugb3V0cHV0IChzcGVjaWZ5IG9uY2UgZm9y IGluZGl2aWR1YWwgdGVzdCByZXN1bHRzLCB0d2ljZSBmb3IgZGVidWcgbWVzc2FnZXMpJykKKyAg ICAgICAgcGFyc2VyLmFkZF9vcHRpb24oJy1yJywgJy0tcmVzdWx0cy1kaXJlY3RvcnknLCBhY3Rp b249J3N0b3JlJywgZGVmYXVsdD0iIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0n c3BlY2lmaWVzIGEgZGlyZWN0b3J5IGluIHdoaWNoIHRvIGdlbmVyYXRlIGEganNvbiBmaWxlIHRo YXQgY29udGFpbnMgdGhlIHJlc3VsdHMgb2YgdGhlIHRlc3RzJykKIAogICAgICAgICBwYXJzZXIu ZXBpbG9nID0gKCdbYXJncy4uLl0gaXMgYW4gb3B0aW9uYWwgbGlzdCBvZiBtb2R1bGVzLCB0ZXN0 X2NsYXNzZXMsIG9yIGluZGl2aWR1YWwgdGVzdHMuICcKICAgICAgICAgICAgICAgICAgICAgICAg ICAnSWYgbm8gYXJncyBhcmUgZ2l2ZW4sIGFsbCB0aGUgdGVzdHMgd2lsbCBiZSBydW4uJykKQEAg LTE2Miw2ICsxNjYsOSBAQCBjbGFzcyBUZXN0ZXIob2JqZWN0KToKIAogICAgICAgICBzZWxmLnBy aW50ZXIucHJpbnRfcmVzdWx0KHRpbWUudGltZSgpIC0gc3RhcnQpCiAKKyAgICAgICAgaWYgc2Vs Zi5fb3B0aW9ucy5yZXN1bHRzX2RpcmVjdG9yeToKKyAgICAgICAgICAgIHNlbGYuX2ZpbGVzeXN0 ZW0ud3JpdGVfdGV4dF9maWxlKHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl9vcHRpb25zLnJl c3VsdHNfZGlyZWN0b3J5LCAicmVzdWx0cy5qc29uIiksIHRlc3RfcnVubmVyLnRlc3Rfc3VpdGVf cmVzdWx0cy50ZXN0X3N1aXRlX3Jlc3VsdHNfdG9fanNvbl9zdHJpbmcoKSkKKwogICAgICAgICBp ZiBzZWxmLl9vcHRpb25zLmNvdmVyYWdlOgogICAgICAgICAgICAgY292LnN0b3AoKQogICAgICAg ICAgICAgY292LnNhdmUoKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0 L3Jlc3VsdHMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5weQpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hMmIyZWRiCi0tLSAvZGV2L251bGwKKysr IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3Jlc3VsdHMucHkKQEAgLTAsMCArMSw2NSBA QAorIyBDb3B5cmlnaHQgKEMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor IworIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisjIGFyZSBtZXQ6CisjIDEuICBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyAg ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorIyAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyMgICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisjCisjIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRT IENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5ECisjIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisjIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRSBBUkUKKyMgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBP UiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IKKyMgQU5ZIERJUkVDVCwgSU5ESVJFQ1Qs IElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTAorIyBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUgorIyBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUgorIyBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LAorIyBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCitpbXBvcnQganNvbgor CisKK2NsYXNzIFRlc3RTdWl0ZVJlc3VsdHMob2JqZWN0KToKKyAgICBAY2xhc3NtZXRob2QKKyAg ICBkZWYgdGVzdF9zdWl0ZV9yZXN1bHRzX2Zyb21fanNvbl9zdHJpbmcoY2xzLCBqc29uX3N0cmlu Zyk6CisgICAgICAgIGpzb25fZGljdCA9IGpzb24ubG9hZHMoanNvbl9zdHJpbmcpCisgICAgICAg IGxpc3Rfb2ZfdGVzdF9yZXN1bHRzID0gW10KKyAgICAgICAgZm9yIHRlc3RfcmVzdWx0X2RpY3Qg aW4ganNvbl9kaWN0WydsaXN0X29mX3Rlc3RfcmVzdWx0cyddOgorICAgICAgICAgICAgdGVzdF9y ZXN1bHRfdHVwbGUgPSAodGVzdF9yZXN1bHRfZGljdFsndGVzdF9uYW1lJ10sIHRlc3RfcmVzdWx0 X2RpY3RbJ2RpZF9wYXNzJ10sIHRlc3RfcmVzdWx0X2RpY3RbJ2ZhaWx1cmVfbWVzc2FnZXMnXSwg dGVzdF9yZXN1bHRfZGljdFsnZXJyb3JfbWVzc2FnZXMnXSkKKyAgICAgICAgICAgIGxpc3Rfb2Zf dGVzdF9yZXN1bHRzLmFwcGVuZCh0ZXN0X3Jlc3VsdF90dXBsZSkKKworICAgICAgICByZXR1cm4g Y2xzKGpzb25fZGljdFsndGVzdF9zdWl0ZV9uYW1lJ10sIGxpc3Rfb2ZfdGVzdF9yZXN1bHRzKQor CisgICAgZGVmIHRlc3Rfc3VpdGVfcmVzdWx0c190b19qc29uX3N0cmluZyhzZWxmKToKKyAgICAg ICAganNvbl9kaWN0ID0ge30KKyAgICAgICAganNvbl9kaWN0Wyd0ZXN0X3N1aXRlX25hbWUnXSA9 IHNlbGYudGVzdF9zdWl0ZV9uYW1lCisgICAgICAgIGpzb25fZGljdFsnbGlzdF9vZl90ZXN0X3Jl c3VsdHMnXSA9IFtdCisgICAgICAgIGZvciB0ZXN0X3Jlc3VsdF90dXBsZSBpbiBzZWxmLmxpc3Rf b2ZfdGVzdF9yZXN1bHRzOgorICAgICAgICAgICAgdGVzdF9yZXN1bHRfZGljdCA9IHt9CisgICAg ICAgICAgICB0ZXN0X3Jlc3VsdF9kaWN0Wyd0ZXN0X25hbWUnXSA9IHRlc3RfcmVzdWx0X3R1cGxl WzBdCisgICAgICAgICAgICB0ZXN0X3Jlc3VsdF9kaWN0WydkaWRfcGFzcyddID0gdGVzdF9yZXN1 bHRfdHVwbGVbMV0KKyAgICAgICAgICAgIHRlc3RfcmVzdWx0X2RpY3RbJ2ZhaWx1cmVfbWVzc2Fn ZXMnXSA9IHRlc3RfcmVzdWx0X3R1cGxlWzJdCisgICAgICAgICAgICB0ZXN0X3Jlc3VsdF9kaWN0 WydlcnJvcl9tZXNzYWdlcyddID0gdGVzdF9yZXN1bHRfdHVwbGVbM10KKyAgICAgICAgICAgIGpz b25fZGljdFsnbGlzdF9vZl90ZXN0X3Jlc3VsdHMnXS5hcHBlbmQodGVzdF9yZXN1bHRfZGljdCkK KyAgICAgICAganNvbl9kaWN0WydudW1iZXJfb2ZfdGVzdHNfcnVuJ10gPSBsZW4oc2VsZi5saXN0 X29mX3Rlc3RfcmVzdWx0cykKKyAgICAgICAgcmV0dXJuIGpzb24uZHVtcHMoanNvbl9kaWN0KQor CisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHRlc3Rfc3VpdGVfbmFtZSwgaW5pdGlhbF9saXN0X29m X3Rlc3RfcmVzdWx0cz1Ob25lKToKKyAgICAgICAgc2VsZi50ZXN0X3N1aXRlX25hbWUgPSB0ZXN0 X3N1aXRlX25hbWUKKyAgICAgICAgaWYgaW5pdGlhbF9saXN0X29mX3Rlc3RfcmVzdWx0czoKKyAg ICAgICAgICAgIHNlbGYubGlzdF9vZl90ZXN0X3Jlc3VsdHMgPSBpbml0aWFsX2xpc3Rfb2ZfdGVz dF9yZXN1bHRzCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBzZWxmLmxpc3Rfb2ZfdGVzdF9y ZXN1bHRzID0gW10KKworICAgIGRlZiBhZGRfdGVzdF9yZXN1bHQoc2VsZiwgdGVzdF9uYW1lLCBk aWRfcGFzcywgZmFpbHVyZV9tZXNzYWdlcz1Ob25lLCBlcnJvcl9tZXNzYWdlcz1Ob25lKToKKyAg ICAgICAgc2VsZi5saXN0X29mX3Rlc3RfcmVzdWx0cy5hcHBlbmQoKHRlc3RfbmFtZSwgZGlkX3Bh c3MsIGZhaWx1cmVfbWVzc2FnZXMsIGVycm9yX21lc3NhZ2VzKSkKKworICAgIGRlZiBsaXN0X29m X2ZhaWxlZF90ZXN0X3Jlc3VsdHMoc2VsZik6CisgICAgICAgIHJldHVybiBbcmVzdWx0IGZvciBy ZXN1bHQgaW4gc2VsZi5saXN0X29mX3Rlc3RfcmVzdWx0cyBpZiByZXN1bHRbMl1dCisKKyAgICBk ZWYgbGlzdF9vZl9lcnJvcmVkX3Rlc3RfcmVzdWx0cyhzZWxmKToKKyAgICAgICAgcmV0dXJuIFty ZXN1bHQgZm9yIHJlc3VsdCBpbiBzZWxmLmxpc3Rfb2ZfdGVzdF9yZXN1bHRzIGlmIHJlc3VsdFsz XV0KZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzX3VuaXR0 ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3Jlc3VsdHNfdW5pdHRlc3QucHkK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTVhMTlhZgotLS0gL2Rldi9udWxs CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzX3VuaXR0ZXN0LnB5CkBA IC0wLDAgKzEsNTUgQEAKKyMgQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworIyBhcmUgbWV0OgorIyAx LiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisj ICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExF IElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORAorIyBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRAorIyBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisjIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxM IEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SCisjIEFOWSBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwKKyMgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IKKyMgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIKKyMgQ0FVU0VE IEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwKKyMgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKwor aW1wb3J0IHVuaXR0ZXN0CisKK2Zyb20gd2Via2l0cHkudGVzdC5yZXN1bHRzIGltcG9ydCBUZXN0 U3VpdGVSZXN1bHRzCisKKworY2xhc3MgVGVzdFN1aXRlUmVzdWx0c1Rlc3QodW5pdHRlc3QuVGVz dENhc2UpOgorICAgIGRlZiB0ZXN0X2pzb25fc2VyaWFsaXphdGlvbl9hbmRfZGVzZXJpYWxpemF0 aW9uKHNlbGYpOgorICAgICAgICB0ZXN0X3N1aXRlX3Jlc3VsdHMgPSBUZXN0U3VpdGVSZXN1bHRz KCJUZXN0IFRlc3QgU3VpdGUiKQorICAgICAgICB0ZXN0X3N1aXRlX3Jlc3VsdHMuYWRkX3Rlc3Rf cmVzdWx0KHRlc3RfbmFtZT0iRmlyc3QgVGVzdCIsIGRpZF9wYXNzPVRydWUsIGZhaWx1cmVfbWVz c2FnZXM9W10sIGVycm9yX21lc3NhZ2VzPVtdKQorICAgICAgICB0ZXN0X3N1aXRlX3Jlc3VsdHMu YWRkX3Rlc3RfcmVzdWx0KHRlc3RfbmFtZT0iU2Vjb25kIFRlc3QiLCBkaWRfcGFzcz1GYWxzZSwg ZmFpbHVyZV9tZXNzYWdlcz1bIkZhaWx1cmUgTWVzc2FnZSJdLCBlcnJvcl9tZXNzYWdlcz1bXSkK KyAgICAgICAgdGVzdF9zdWl0ZV9yZXN1bHRzLmFkZF90ZXN0X3Jlc3VsdCh0ZXN0X25hbWU9IlRo aXJkIFRlc3QiLCBkaWRfcGFzcz1GYWxzZSwgZmFpbHVyZV9tZXNzYWdlcz1bXSwgZXJyb3JfbWVz c2FnZXM9WyJFcnJvciBNZXNzYWdlIl0pCisgICAgICAgIHRlc3Rfc3VpdGVfcmVzdWx0cy5hZGRf dGVzdF9yZXN1bHQodGVzdF9uYW1lPSJGb3VydGggVGVzdCIsIGRpZF9wYXNzPUZhbHNlLCBmYWls dXJlX21lc3NhZ2VzPVsiRmFpbHVyZSBNZXNzYWdlIl0sIGVycm9yX21lc3NhZ2VzPVsiRXJyb3Ig TWVzc2FnZSJdKQorCisgICAgICAgIHRlc3Rfc3VpdGVfcmVzdWx0c19qc29uX3N0cmluZyA9IHRl c3Rfc3VpdGVfcmVzdWx0cy50ZXN0X3N1aXRlX3Jlc3VsdHNfdG9fanNvbl9zdHJpbmcoKQorICAg ICAgICBzZWNvbmRfdGVzdF9zdWl0ZV9yZXN1bHRzID0gVGVzdFN1aXRlUmVzdWx0cy50ZXN0X3N1 aXRlX3Jlc3VsdHNfZnJvbV9qc29uX3N0cmluZyh0ZXN0X3N1aXRlX3Jlc3VsdHNfanNvbl9zdHJp bmcpCisKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCh0ZXN0X3N1aXRlX3Jlc3VsdHMudGVzdF9z dWl0ZV9uYW1lLCBzZWNvbmRfdGVzdF9zdWl0ZV9yZXN1bHRzLnRlc3Rfc3VpdGVfbmFtZSkKKyAg ICAgICAgc2VsZi5hc3NlcnRFcXVhbChsZW4odGVzdF9zdWl0ZV9yZXN1bHRzLmxpc3Rfb2ZfdGVz dF9yZXN1bHRzKSwgNCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChsZW4oc2Vjb25kX3Rlc3Rf c3VpdGVfcmVzdWx0cy5saXN0X29mX3Rlc3RfcmVzdWx0cyksIDQpCisKKyAgICAgICAgZm9yIHRl c3RfaW5kZXggaW4gcmFuZ2UoMCwgNCk6CisgICAgICAgICAgICBmaXJzdF90ZXN0X3Jlc3VsdCA9 IHRlc3Rfc3VpdGVfcmVzdWx0cy5saXN0X29mX3Rlc3RfcmVzdWx0c1t0ZXN0X2luZGV4XQorICAg ICAgICAgICAgc2Vjb25kX3Rlc3RfcmVzdWx0ID0gc2Vjb25kX3Rlc3Rfc3VpdGVfcmVzdWx0cy5s aXN0X29mX3Rlc3RfcmVzdWx0c1t0ZXN0X2luZGV4XQorCisgICAgICAgICAgICBmb3IgdHVwbGVf aW5kZXggaW4gcmFuZ2UoMCwgNCk6CisgICAgICAgICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChm aXJzdF90ZXN0X3Jlc3VsdFt0dXBsZV9pbmRleF0sIHNlY29uZF90ZXN0X3Jlc3VsdFt0dXBsZV9p bmRleF0pCisKKyAgICBkZWYgdGVzdF9zdWl0ZV9yZXN1bHRzX211dHVhbF9pbmRlcGVuZGVuY2Uo c2VsZik6CisgICAgICAgIGZpcnN0X3N1aXRlX3Jlc3VsdHMgPSBUZXN0U3VpdGVSZXN1bHRzKCJU ZXN0IFRlc3QgU3VpdGUiKQorICAgICAgICBmaXJzdF9zdWl0ZV9yZXN1bHRzLmFkZF90ZXN0X3Jl c3VsdCh0ZXN0X25hbWU9IkZpcnN0IFRlc3QiLCBkaWRfcGFzcz1UcnVlLCBmYWlsdXJlX21lc3Nh Z2VzPVtdLCBlcnJvcl9tZXNzYWdlcz1bXSkKKworICAgICAgICBzZWNvbmRfc3VpdGVfcmVzdWx0 cyA9IFRlc3RTdWl0ZVJlc3VsdHMoIlNlY29uZCBUZXN0IFRlc3QgU3VpdGUiKQorICAgICAgICBz ZWxmLmFzc2VydEVxdWFsKGxlbihzZWNvbmRfc3VpdGVfcmVzdWx0cy5saXN0X29mX3Rlc3RfcmVz dWx0cyksIDApCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVy LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lci5weQppbmRleCBkM2Y1NzY0 Li5lNjBjYzg0IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVy LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHkKQEAgLTI3LDYg KzI3LDcgQEAgaW1wb3J0IHRpbWUKIGltcG9ydCB1bml0dGVzdAogCiBmcm9tIHdlYmtpdHB5LmNv bW1vbiBpbXBvcnQgbWVzc2FnZV9wb29sCitmcm9tIHdlYmtpdHB5LnRlc3QucmVzdWx0cyBpbXBv cnQgVGVzdFN1aXRlUmVzdWx0cwogCiBfdGVzdF9kZXNjcmlwdGlvbiA9IHJlLmNvbXBpbGUoIihc dyspIFwoKFtcdy5dKylcKSIpCiAKQEAgLTQwLDkgKzQxLDcgQEAgY2xhc3MgUnVubmVyKG9iamVj dCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIHByaW50ZXIsIGxvYWRlcik6CiAgICAgICAgIHNl bGYucHJpbnRlciA9IHByaW50ZXIKICAgICAgICAgc2VsZi5sb2FkZXIgPSBsb2FkZXIKLSAgICAg ICAgc2VsZi50ZXN0c19ydW4gPSAwCi0gICAgICAgIHNlbGYuZXJyb3JzID0gW10KLSAgICAgICAg c2VsZi5mYWlsdXJlcyA9IFtdCisgICAgICAgIHNlbGYudGVzdF9zdWl0ZV9yZXN1bHRzID0gVGVz dFN1aXRlUmVzdWx0cygiUHl0aG9uIFVuaXQgVGVzdHMiKQogICAgICAgICBzZWxmLndvcmtlcl9m YWN0b3J5ID0gbGFtYmRhIGNhbGxlcjogX1dvcmtlcihjYWxsZXIsIHNlbGYubG9hZGVyKQogCiAg ICAgZGVmIHJ1bihzZWxmLCB0ZXN0X25hbWVzLCBudW1fd29ya2Vycyk6CkBAIC01NywxMSArNTYs OCBAQCBjbGFzcyBSdW5uZXIob2JqZWN0KToKICAgICAgICAgICAgIHNlbGYucHJpbnRlci5wcmlu dF9zdGFydGVkX3Rlc3Qoc291cmNlLCB0ZXN0X25hbWUpCiAgICAgICAgICAgICByZXR1cm4KIAot ICAgICAgICBzZWxmLnRlc3RzX3J1biArPSAxCi0gICAgICAgIGlmIGZhaWx1cmVzOgotICAgICAg ICAgICAgc2VsZi5mYWlsdXJlcy5hcHBlbmQoKHRlc3RfbmFtZSwgZmFpbHVyZXMpKQotICAgICAg ICBpZiBlcnJvcnM6Ci0gICAgICAgICAgICBzZWxmLmVycm9ycy5hcHBlbmQoKHRlc3RfbmFtZSwg ZXJyb3JzKSkKKyAgICAgICAgc2VsZi50ZXN0X3N1aXRlX3Jlc3VsdHMuYWRkX3Rlc3RfcmVzdWx0 KHRlc3RfbmFtZT10ZXN0X25hbWUsIGRpZF9wYXNzPW5vdCBib29sKGZhaWx1cmVzICsgZXJyb3Jz KSwgZmFpbHVyZV9tZXNzYWdlcz1mYWlsdXJlcywgZXJyb3JfbWVzc2FnZXM9ZXJyb3JzKQorCiAg ICAgICAgIHNlbGYucHJpbnRlci5wcmludF9maW5pc2hlZF90ZXN0KHNvdXJjZSwgdGVzdF9uYW1l LCBkZWxheSwgZmFpbHVyZXMsIGVycm9ycykKIAogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS90ZXN0L3J1bm5lcl91bml0dGVzdC5weQppbmRleCA5OTUwNzBiLi4xMGM3MTcxIDEwMDY0NAot LS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0LnB5CisrKyBi L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXJfdW5pdHRlc3QucHkKQEAgLTkyLDYg KzkyLDcgQEAgY2xhc3MgUnVubmVyVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgKCd0ZXN0MyAoRm9vKScsICdFJywgJ3Rlc3QzXG5lcnJlZCcpKQog ICAgICAgICBydW5uZXIgPSBSdW5uZXIoUHJpbnRlcihzdHJlYW0sIG9wdGlvbnMpLCBsb2FkZXIp CiAgICAgICAgIHJ1bm5lci5ydW4oWydGb28udGVzdDEnLCAnRm9vLnRlc3QyJywgJ0Zvby50ZXN0 MyddLCAxKQotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHJ1bm5lci50ZXN0c19ydW4sIDMpCi0g ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci5mYWlsdXJlcyksIDEpCi0gICAgICAg IHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci5lcnJvcnMpLCAxKQorCisgICAgICAgIHNlbGYu YXNzZXJ0RXF1YWwobGVuKHJ1bm5lci50ZXN0X3N1aXRlX3Jlc3VsdHMubGlzdF9vZl90ZXN0X3Jl c3VsdHMpLCAzKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5uZXIudGVzdF9zdWl0 ZV9yZXN1bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cygpKSwgMSkKKyAgICAgICAgc2Vs Zi5hc3NlcnRFcXVhbChsZW4ocnVubmVyLnRlc3Rfc3VpdGVfcmVzdWx0cy5saXN0X29mX2Vycm9y ZWRfdGVzdF9yZXN1bHRzKCkpLCAxKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5CmluZGV4IDU5YjUyZWEuLjVh OTE4NjkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9k b3dubG9hZF91bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29t bWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHkKQEAgLTE2Myw4ICsxNjMsOSBAQCBNT0NLOiB1c2Vy Lm9wZW5fdXJsOiBmaWxlOi8vLi4uCiBXYXMgdGhhdCBkaWZmIGNvcnJlY3Q/CiBCdWlsZGluZyBX ZWJLaXQKIE1PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ21vY2stYnVpbGQtd2Via2l0J10s IGN3ZD0vbW9jay1jaGVja291dCwgZW52PXsnTENfQUxMJzogJ0MnLCAnVEVSTSc6ICdub25lJywg J01PQ0tfRU5WSVJPTl9DT1BZJzogJzEnfQorTU9DSyBydW5fY29tbWFuZDogWydwZXJsJywgJ1Rv b2xzL1NjcmlwdHMvd2Via2l0LWJ1aWxkLWRpcmVjdG9yeScsICctLWNvbmZpZ3VyYXRpb24nLCAn LS1yZWxlYXNlJywgJy0tTW9ja1BvcnQnXSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBSdW5uaW5nIFB5 dGhvbiB1bml0IHRlc3RzCi1NT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLXRlc3Qt d2Via2l0cHknXSwgY3dkPS9tb2NrLWNoZWNrb3V0CitNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFp bDogWydtb2NrLXRlc3Qtd2Via2l0cHknLCAnLS1yZXN1bHRzLWRpcmVjdG9yeScsICdNT0NLIG91 dHB1dCBvZiBjaGlsZCBwcm9jZXNzL3B5dGhvbi11bml0dGVzdC1yZXN1bHRzJ10sIGN3ZD0vbW9j ay1jaGVja291dAogUnVubmluZyBQZXJsIHVuaXQgdGVzdHMKIE1PQ0sgcnVuX2FuZF90aHJvd19p Zl9mYWlsOiBbJ21vY2stdGVzdC13ZWJraXRwZXJsJ10sIGN3ZD0vbW9jay1jaGVja291dAogUnVu bmluZyBKYXZhU2NyaXB0Q29yZSB0ZXN0cwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29s L3N0ZXBzL3J1bnRlc3RzLnB5CmluZGV4IGE0NTYyOGIuLjNmYTAxZWMgMTAwNjQ0Ci0tLSBhL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0cy5weQorKysgYi9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMucHkKQEAgLTMzLDYgKzMzLDcgQEAg aW1wb3J0IHN5cwogZnJvbSB3ZWJraXRweS50b29sLnN0ZXBzLmFic3RyYWN0c3RlcCBpbXBvcnQg QWJzdHJhY3RTdGVwCiBmcm9tIHdlYmtpdHB5LnRvb2wuc3RlcHMub3B0aW9ucyBpbXBvcnQgT3B0 aW9ucwogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmV4ZWN1dGl2ZSBpbXBvcnQgU2NyaXB0 RXJyb3IKK2Zyb20gd2Via2l0cHkucG9ydC5jb25maWcgaW1wb3J0IENvbmZpZwogCiBfbG9nID0g bG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCiAKQEAgLTU1LDggKzU2LDIxIEBAIGNsYXNzIFJ1 blRlc3RzKEFic3RyYWN0U3RlcCk6CiAKICAgICAgICAgaWYgbm90IHNlbGYuX29wdGlvbnMubm9u X2ludGVyYWN0aXZlOgogICAgICAgICAgICAgIyBGSVhNRTogV2Ugc2hvdWxkIHRlYWNoIHRoZSBj b21taXQtcXVldWUgYW5kIHRoZSBFV1MgaG93IHRvIHJ1biB0aGVzZSB0ZXN0cy4KKyAgICAgICAg ICAgIGZpbGVzeXN0ZW0gPSBzZWxmLl90b29sLmZpbGVzeXN0ZW0KKyAgICAgICAgICAgIHBvcnRf bmFtZSA9IHNlbGYuX3Rvb2wuZGVwcmVjYXRlZF9wb3J0KCkubmFtZSgpCisKKyAgICAgICAgICAg IGlmIG5vdCB0eXBlKHBvcnRfbmFtZSkgaXMgc3RyOgorICAgICAgICAgICAgICAgIHBvcnRfbmFt ZSA9IHBvcnRfbmFtZS5fX25hbWVfXworCisgICAgICAgICAgICBjb25maWcgPSBDb25maWcoc2Vs Zi5fdG9vbC5leGVjdXRpdmUsIGZpbGVzeXN0ZW0sIHBvcnRfbmFtZSkKKworICAgICAgICAgICAg cHl0aG9uX3VuaXR0ZXN0c19yZXN1bHRzX2RpciA9IGZpbGVzeXN0ZW0uam9pbihjb25maWcuYnVp bGRfZGlyZWN0b3J5KGNvbmZpZy5kZWZhdWx0X2NvbmZpZ3VyYXRpb24oKSksICJweXRob24tdW5p dHRlc3QtcmVzdWx0cyIpCisgICAgICAgICAgICBmaWxlc3lzdGVtLm1heWJlX21ha2VfZGlyZWN0 b3J5KHB5dGhvbl91bml0dGVzdHNfcmVzdWx0c19kaXIpCiAKICAgICAgICAgICAgIHB5dGhvbl91 bml0dGVzdHNfY29tbWFuZCA9IHNlbGYuX3Rvb2wuZGVwcmVjYXRlZF9wb3J0KCkucnVuX3B5dGhv bl91bml0dGVzdHNfY29tbWFuZCgpCisgICAgICAgICAgICBweXRob25fdW5pdHRlc3RzX2NvbW1h bmQuYXBwZW5kKCItLXJlc3VsdHMtZGlyZWN0b3J5IikKKyAgICAgICAgICAgIHB5dGhvbl91bml0 dGVzdHNfY29tbWFuZC5hcHBlbmQocHl0aG9uX3VuaXR0ZXN0c19yZXN1bHRzX2RpcikKKwogICAg ICAgICAgICAgaWYgcHl0aG9uX3VuaXR0ZXN0c19jb21tYW5kOgogICAgICAgICAgICAgICAgIF9s b2cuaW5mbygiUnVubmluZyBQeXRob24gdW5pdCB0ZXN0cyIpCiAgICAgICAgICAgICAgICAgc2Vs Zi5fdG9vbC5leGVjdXRpdmUucnVuX2FuZF90aHJvd19pZl9mYWlsKHB5dGhvbl91bml0dGVzdHNf Y29tbWFuZCwgY3dkPXNlbGYuX3Rvb2wuc2NtKCkuY2hlY2tvdXRfcm9vdCkKZGlmZiAtLWdpdCBh L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weSBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weQppbmRleCBi MWUyYmYxLi42ZTQ1ODQyIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wv c3RlcHMvc3RlcHNfdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29s L3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5CkBAIC0xMDMsOCArMTAzLDkgQEAgY2xhc3MgU3RlcHNU ZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAgIyBGSVhNRTogV2Ugc2hvdWxkbid0IHVz ZSBhIHJlYWwgcG9ydC1vYmplY3QgaGVyZSwgYnV0IHRoZXJlIGlzIHRvbyBtdWNoIHRvIG1vY2sg YXQgdGhlIG1vbWVudC4KICAgICAgICAgdG9vbC5fZGVwcmVjYXRlZF9wb3J0ID0gRGVwcmVjYXRl ZFBvcnQoKQogICAgICAgICBzdGVwID0gc3RlcHMuUnVuVGVzdHModG9vbCwgbW9ja19vcHRpb25z KQotICAgICAgICBleHBlY3RlZF9sb2dzID0gIiIiUnVubmluZyBQeXRob24gdW5pdCB0ZXN0cwot TU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnVG9vbHMvU2NyaXB0cy90ZXN0LXdlYmtpdHB5 J10sIGN3ZD0vbW9jay1jaGVja291dAorICAgICAgICBleHBlY3RlZF9sb2dzID0gIiIiTU9DSyBy dW5fY29tbWFuZDogWydwZXJsJywgJ1Rvb2xzL1NjcmlwdHMvd2Via2l0LWJ1aWxkLWRpcmVjdG9y eScsICctLWNvbmZpZ3VyYXRpb24nLCAnLS1yZWxlYXNlJywgJy0tRGVwcmVjYXRlZFBvcnQnXSwg Y3dkPS9tb2NrLWNoZWNrb3V0CitSdW5uaW5nIFB5dGhvbiB1bml0IHRlc3RzCitNT0NLIHJ1bl9h bmRfdGhyb3dfaWZfZmFpbDogWydUb29scy9TY3JpcHRzL3Rlc3Qtd2Via2l0cHknLCAnLS1yZXN1 bHRzLWRpcmVjdG9yeScsICdNT0NLIG91dHB1dCBvZiBjaGlsZCBwcm9jZXNzL3B5dGhvbi11bml0 dGVzdC1yZXN1bHRzJ10sIGN3ZD0vbW9jay1jaGVja291dAogUnVubmluZyBQZXJsIHVuaXQgdGVz dHMKIE1PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ1Rvb2xzL1NjcmlwdHMvdGVzdC13ZWJr aXRwZXJsJ10sIGN3ZD0vbW9jay1jaGVja291dAogUnVubmluZyBKYXZhU2NyaXB0Q29yZSB0ZXN0 cwotLSAKMS45LjMgKEFwcGxlIEdpdC01MCkKCg== 239662 2014-10-10 17:44:53 -0700 2014-10-13 12:58:46 -0700 Changes to the --json flag solution to the problem, as discussed in person. 0001-Make-test-webkitpy-generate-a-JSON-file-of-its-resul.patch text/plain 46862 jake.nielsen.webkit RnJvbSA4YmMwYjI0ZWNkZTg4ZGZiODAzZjIxNTFiNDVhYzI4ZGI1MWRlMWJmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBGcmksIDEwIE9jdCAyMDE0IDE3OjQyOjQ4IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0g TWFrZSB0ZXN0LXdlYmtpdHB5IGdlbmVyYXRlIGEgSlNPTiBmaWxlIG9mIGl0cyByZXN1bHRzCiBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM3MzUzCgpSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KClRoZSB3ZWJraXQgYnVpbGRib3QgcGFnZSdzIHJlc3VsdHMuaHRt bCBmaWxlIHNob3VsZCBjb250YWluIHJlc3VsdHMKZm9yIHRoZSBweXRob24gdW5pdCB0ZXN0cyAo YW5kIHNvb24gdG8gYmUgb3RoZXJzKSwgYXMgc2hvdWxkCnRoZSBFV1MgYnViYmxlcy4gVGhleSB3 aWxsIGNvbnN1bWUgdGhlIEpTT04gZmlsZSBjcmVhdGVkIGluIHRoaXMKcGF0Y2ggdG8gYWNoaWV2 ZSB0aG9zZSBlbmRzLgoKKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvcG9ydHNfbW9j ay5weToKQWRkcyB0aGUgTW9ja1BvcnRGYWN0b3J5IGNsYXNzIHdoaWNoIGlzIHVzZWQgaW4gdW5p dCB0ZXN0cyB0byBtYWtlCnN1cmUgdGhhdCBwb3J0LXNwZWNpZmljIHRleHQgZG9lc24ndCBlbmQg dXAgaW4gdW5pdCB0ZXN0IG1vY2sgdGV4dApvdXRwdXQuIEFsc28gYWRkcyB0aGUgcHl0aG9uX3Vu aXR0ZXN0X3Jlc3VsdHNfZGlyZWN0b3J5IHRvIE1vY2tQb3J0LgooTW9ja1BvcnRGYWN0b3J5KToK KE1vY2tQb3J0RmFjdG9yeS5fX2luaXRfXyk6CihNb2NrUG9ydEZhY3RvcnkuZ2V0KToKKE1vY2tQ b3J0LnB5dGhvbl91bml0dGVzdF9yZXN1bHRzX2RpcmVjdG9yeSk6CiogU2NyaXB0cy93ZWJraXRw eS9wb3J0L2Jhc2UucHk6CkFkZHMgY29udmVuaWVuY2UgbWV0aG9kIHRvIGxldCBSdW5UZXN0cyBk ZXRlcm1pbmUgd2hlcmUgaXQgc2hvdWxkIGJlCnB1dHRpbmcgdGVzdCByZXN1bHRzLgooUG9ydC5w eXRob25fdW5pdHRlc3RfcmVzdWx0c19kaXJlY3RvcnkpOgoqIFNjcmlwdHMvd2Via2l0cHkvcG9y dC9zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5weToKQWRkcyBhIG1vY2sgcmVhZCBtZXRob2QgdG8g TW9ja0ZpbGUuCihNb2NrRmlsZS5yZWFkKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5w eToKQWRkcyB0aGUgLS1qc29uIG9wdGlvbiB0byBzZW5kIEpTT04gZm9ybWF0dGVkIG91dHB1dCB0 byBzdGRvdXQuCihUZXN0ZXIuX19pbml0X18pOgooVGVzdGVyLl9wYXJzZV9hcmdzKToKKFRlc3Rl ci5ydW4pOgoqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluX3VuaXR0ZXN0LnB5OgooVGVzdGVy VGVzdC50ZXN0X25vX3Rlc3RzX2ZvdW5kKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcHJpbnRl cnMvX19pbml0X18ucHk6IEFkZGVkLgoqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9o dW1hbl9yZWFkYWJsZV9wcmludGVyLnB5OiBSZW5hbWVkIGZyb20gVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90ZXN0L3ByaW50ZXIucHkuCkFkZHMgSHVtYW5SZWFkYWJsZVByaW50ZXIsIHdoaWNoIGlu aGVyaXRzIGZyb20gQWJzdHJhY3RQcmludGVyLgpIdW1hblJlYWRhYmxlUHJpbnRlciBwcm9kdWNl cyB0aGUgc2FtZSBvdXRwdXQgdGhhdCBQcmludGVyIGRpZCBwcmlvcgp0byB0aGlzIHBhdGNoLgoo SHVtYW5SZWFkYWJsZVByaW50ZXIpOgooSHVtYW5SZWFkYWJsZVByaW50ZXIuX19pbml0X18pOgoo SHVtYW5SZWFkYWJsZVByaW50ZXIuY29uZmlndXJlKToKKEh1bWFuUmVhZGFibGVQcmludGVyLmNv bmZpZ3VyZS5maWx0ZXJfcmVjb3Jkcyk6CihIdW1hblJlYWRhYmxlUHJpbnRlci53cml0ZV91cGRh dGUpOgooSHVtYW5SZWFkYWJsZVByaW50ZXIucHJpbnRfc3RhcnRlZF90ZXN0X3N1aXRlKToKKEh1 bWFuUmVhZGFibGVQcmludGVyLnByaW50X3N0YXJ0ZWRfdGVzdCk6CihIdW1hblJlYWRhYmxlUHJp bnRlci5wcmludF9maW5pc2hlZF90ZXN0KToKKEh1bWFuUmVhZGFibGVQcmludGVyLl90ZXN0X2xp bmUpOgooSHVtYW5SZWFkYWJsZVByaW50ZXIucHJpbnRfcmVzdWx0KToKKiBTY3JpcHRzL3dlYmtp dHB5L3Rlc3QvcHJpbnRlcnMvanNvbl9wcmludGVyLnB5OiBBZGRlZC4KSlNPTlByaW50ZXIsIHdo aWNoIGFsc28gaW5oZXJpdHMgZnJvbSBBYnN0cmFjdFByaW50ZXIgcHJvZHVjZXMKb3V0cHV0IGlu IEpTT04gZm9ybWF0IHNvIHRoYXQgaXQgY2FuIGJlIHVzZWQgdG8KY3JlYXRlIHRoZSByZXN1bHRz Lmpzb24gZmlsZSwgd2hpY2ggaXMgdGhlIGVuZCBnb2FsIG9mIHRoaXMgcGF0Y2guCihKU09OUHJp bnRlcik6CihKU09OUHJpbnRlci5fX2luaXRfXyk6CihKU09OUHJpbnRlci5jb25maWd1cmUpOgoo SlNPTlByaW50ZXIucHJpbnRfc3RhcnRlZF90ZXN0X3N1aXRlKToKKEpTT05QcmludGVyLndyaXRl X3VwZGF0ZSk6CihKU09OUHJpbnRlci5wcmludF9zdGFydGVkX3Rlc3QpOgooSlNPTlByaW50ZXIu cHJpbnRfZmluaXNoZWRfdGVzdCk6CihKU09OUHJpbnRlci5wcmludF9yZXN1bHQpOgoqIFNjcmlw dHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9hYnN0cmFjdF9wcmludGVyLnB5OiBBZGRlZC4KKEFi c3RyYWN0UHJpbnRlcik6CihBYnN0cmFjdFByaW50ZXIuX19pbml0X18pOgooQWJzdHJhY3RQcmlu dGVyLl9zdWJjbGFzc19tdXN0X2ltcGxlbWVudCk6CihBYnN0cmFjdFByaW50ZXIuY29uZmlndXJl KToKKEFic3RyYWN0UHJpbnRlci5wcmludF9zdGFydGVkX3Rlc3Rfc3VpdGUpOgooQWJzdHJhY3RQ cmludGVyLndyaXRlX3VwZGF0ZSk6CihBYnN0cmFjdFByaW50ZXIucHJpbnRfc3RhcnRlZF90ZXN0 KToKKEFic3RyYWN0UHJpbnRlci5wcmludF9maW5pc2hlZF90ZXN0KToKKEFic3RyYWN0UHJpbnRl ci5wcmludF9yZXN1bHQpOgooX0NhcHR1cmVBbmRQYXNzVGhyb3VnaFN0cmVhbSk6CihfQ2FwdHVy ZUFuZFBhc3NUaHJvdWdoU3RyZWFtLl9faW5pdF9fKToKKF9DYXB0dXJlQW5kUGFzc1Rocm91Z2hT dHJlYW0ud3JpdGUpOgooX0NhcHR1cmVBbmRQYXNzVGhyb3VnaFN0cmVhbS5fbWVzc2FnZV9pc19m cm9tX3BkYik6CihfQ2FwdHVyZUFuZFBhc3NUaHJvdWdoU3RyZWFtLmZsdXNoKToKKF9DYXB0dXJl QW5kUGFzc1Rocm91Z2hTdHJlYW0uZ2V0dmFsdWUpOgoqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9y dW5uZXIucHk6CihSdW5uZXIuaGFuZGxlKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVy X3VuaXR0ZXN0LnB5OgooUnVubmVyVGVzdC50ZXN0X3J1bik6CiogU2NyaXB0cy93ZWJraXRweS90 b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5OgooTW9ja1BvcnRGYWN0b3J5KToKKE1v Y2tQb3J0RmFjdG9yeS5fX2luaXRfXyk6CihNb2NrUG9ydEZhY3RvcnkuZ2V0KToKKiBTY3JpcHRz L3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMucHk6Ck1ha2VzIFJ1blRlc3RzLnJ1bigpIHN0 aWNrIHRoZSByZXN1bHRzIG9mIHRlc3Rfd2Via2l0cHkgaW50byBhIEpTT04KZmlsZQooUnVuVGVz dHMucnVuKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHk6 CihTdGVwc1Rlc3QudGVzdF9ydW50ZXN0c19hcmdzKToKLS0tCiBUb29scy9DaGFuZ2VMb2cgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICA5MiArKysrKysrKysKIFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NvbmZpZy9wb3J0c19tb2NrLnB5IHwgIDEwICsKIFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvcG9ydC9iYXNlLnB5ICAgICAgICAgICAgICAgIHwgICAzICsKIC4u Li93ZWJraXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5ICAgICAgIHwgICAzICsK IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAgICAgICAgIHwgIDIx ICstCiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbl91bml0dGVzdC5weSAgICAgICB8 ICAgMyArLQogVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3ByaW50ZXIucHkgICAgICAgICAg ICAgfCAyMTQgLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rl c3QvcHJpbnRlcnMvX19pbml0X18ucHkgICB8ICAgMSArCiAuLi4vd2Via2l0cHkvdGVzdC9wcmlu dGVycy9hYnN0cmFjdF9wcmludGVyLnB5ICAgICB8IDEyMCArKysrKysrKysrKysKIC4uLi90ZXN0 L3ByaW50ZXJzL2h1bWFuX3JlYWRhYmxlX3ByaW50ZXIucHkgICAgICAgIHwgMTYwICsrKysrKysr KysrKysrKwogLi4uL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9qc29uX3ByaW50ZXIu cHkgfCAgNzYgKysrKysrKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHkg ICAgICAgICAgICAgIHwgICAyICstCiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVy X3VuaXR0ZXN0LnB5ICAgICB8ICAgNCArLQogLi4uL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93 bmxvYWRfdW5pdHRlc3QucHkgICAgfCAgMTMgKy0KIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9v bC9zdGVwcy9ydW50ZXN0cy5weSAgICAgIHwgIDExICstCiAuLi4vU2NyaXB0cy93ZWJraXRweS90 b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5ICB8ICAgNyArLQogMTYgZmlsZXMgY2hhbmdlZCwg NTEyIGluc2VydGlvbnMoKyksIDIyOCBkZWxldGlvbnMoLSkKIGRlbGV0ZSBtb2RlIDEwMDY0NCBU b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcHJpbnRlci5weQogY3JlYXRlIG1vZGUgMTAwNjQ0 IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9fX2luaXRfXy5weQogY3JlYXRl IG1vZGUgMTAwNjQ0IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9hYnN0cmFj dF9wcmludGVyLnB5CiBjcmVhdGUgbW9kZSAxMDA2NDQgVG9vbHMvU2NyaXB0cy93ZWJraXRweS90 ZXN0L3ByaW50ZXJzL2h1bWFuX3JlYWRhYmxlX3ByaW50ZXIucHkKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcHJpbnRlcnMvanNvbl9wcmludGVyLnB5Cgpk aWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDE2YjVh YjUuLjViN2Y1N2QgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFu Z2VMb2cKQEAgLTEsMyArMSw5NSBAQAorMjAxNC0xMC0xMCAgSmFrZSBOaWVsc2VuICA8amFjb2Jf bmllbHNlbkBhcHBsZS5jb20+CisKKyAgICAgICAgTWFrZSB0ZXN0LXdlYmtpdHB5IGdlbmVyYXRl IGEgSlNPTiBmaWxlIG9mIGl0cyByZXN1bHRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMzczNTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBUaGUgd2Via2l0IGJ1aWxkYm90IHBhZ2UncyByZXN1bHRzLmh0 bWwgZmlsZSBzaG91bGQgY29udGFpbiByZXN1bHRzCisgICAgICAgIGZvciB0aGUgcHl0aG9uIHVu aXQgdGVzdHMgKGFuZCBzb29uIHRvIGJlIG90aGVycyksIGFzIHNob3VsZAorICAgICAgICB0aGUg RVdTIGJ1YmJsZXMuIFRoZXkgd2lsbCBjb25zdW1lIHRoZSBKU09OIGZpbGUgY3JlYXRlZCBpbiB0 aGlzCisgICAgICAgIHBhdGNoIHRvIGFjaGlldmUgdGhvc2UgZW5kcy4KKworICAgICAgICAqIFNj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NvbmZpZy9wb3J0c19tb2NrLnB5OgorICAgICAgICBBZGRz IHRoZSBNb2NrUG9ydEZhY3RvcnkgY2xhc3Mgd2hpY2ggaXMgdXNlZCBpbiB1bml0IHRlc3RzIHRv IG1ha2UKKyAgICAgICAgc3VyZSB0aGF0IHBvcnQtc3BlY2lmaWMgdGV4dCBkb2Vzbid0IGVuZCB1 cCBpbiB1bml0IHRlc3QgbW9jayB0ZXh0CisgICAgICAgIG91dHB1dC4gQWxzbyBhZGRzIHRoZSBw eXRob25fdW5pdHRlc3RfcmVzdWx0c19kaXJlY3RvcnkgdG8gTW9ja1BvcnQuCisgICAgICAgIChN b2NrUG9ydEZhY3RvcnkpOgorICAgICAgICAoTW9ja1BvcnRGYWN0b3J5Ll9faW5pdF9fKToKKyAg ICAgICAgKE1vY2tQb3J0RmFjdG9yeS5nZXQpOgorICAgICAgICAoTW9ja1BvcnQucHl0aG9uX3Vu aXR0ZXN0X3Jlc3VsdHNfZGlyZWN0b3J5KToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Bv cnQvYmFzZS5weToKKyAgICAgICAgQWRkcyBjb252ZW5pZW5jZSBtZXRob2QgdG8gbGV0IFJ1blRl c3RzIGRldGVybWluZSB3aGVyZSBpdCBzaG91bGQgYmUKKyAgICAgICAgcHV0dGluZyB0ZXN0IHJl c3VsdHMuCisgICAgICAgIChQb3J0LnB5dGhvbl91bml0dGVzdF9yZXN1bHRzX2RpcmVjdG9yeSk6 CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0 LnB5OgorICAgICAgICBBZGRzIGEgbW9jayByZWFkIG1ldGhvZCB0byBNb2NrRmlsZS4KKyAgICAg ICAgKE1vY2tGaWxlLnJlYWQpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWlu LnB5OgorICAgICAgICBBZGRzIHRoZSAtLWpzb24gb3B0aW9uIHRvIHNlbmQgSlNPTiBmb3JtYXR0 ZWQgb3V0cHV0IHRvIHN0ZG91dC4KKyAgICAgICAgKFRlc3Rlci5fX2luaXRfXyk6CisgICAgICAg IChUZXN0ZXIuX3BhcnNlX2FyZ3MpOgorICAgICAgICAoVGVzdGVyLnJ1bik6CisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS90ZXN0L21haW5fdW5pdHRlc3QucHk6CisgICAgICAgIChUZXN0ZXJU ZXN0LnRlc3Rfbm9fdGVzdHNfZm91bmQpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVz dC9wcmludGVycy9fX2luaXRfXy5weTogQWRkZWQuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRw eS90ZXN0L3ByaW50ZXJzL2h1bWFuX3JlYWRhYmxlX3ByaW50ZXIucHk6IFJlbmFtZWQgZnJvbSBU b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcHJpbnRlci5weS4KKyAgICAgICAgQWRkcyBIdW1h blJlYWRhYmxlUHJpbnRlciwgd2hpY2ggaW5oZXJpdHMgZnJvbSBBYnN0cmFjdFByaW50ZXIuCisg ICAgICAgIEh1bWFuUmVhZGFibGVQcmludGVyIHByb2R1Y2VzIHRoZSBzYW1lIG91dHB1dCB0aGF0 IFByaW50ZXIgZGlkIHByaW9yCisgICAgICAgIHRvIHRoaXMgcGF0Y2guCisgICAgICAgIChIdW1h blJlYWRhYmxlUHJpbnRlcik6CisgICAgICAgIChIdW1hblJlYWRhYmxlUHJpbnRlci5fX2luaXRf Xyk6CisgICAgICAgIChIdW1hblJlYWRhYmxlUHJpbnRlci5jb25maWd1cmUpOgorICAgICAgICAo SHVtYW5SZWFkYWJsZVByaW50ZXIuY29uZmlndXJlLmZpbHRlcl9yZWNvcmRzKToKKyAgICAgICAg KEh1bWFuUmVhZGFibGVQcmludGVyLndyaXRlX3VwZGF0ZSk6CisgICAgICAgIChIdW1hblJlYWRh YmxlUHJpbnRlci5wcmludF9zdGFydGVkX3Rlc3Rfc3VpdGUpOgorICAgICAgICAoSHVtYW5SZWFk YWJsZVByaW50ZXIucHJpbnRfc3RhcnRlZF90ZXN0KToKKyAgICAgICAgKEh1bWFuUmVhZGFibGVQ cmludGVyLnByaW50X2ZpbmlzaGVkX3Rlc3QpOgorICAgICAgICAoSHVtYW5SZWFkYWJsZVByaW50 ZXIuX3Rlc3RfbGluZSk6CisgICAgICAgIChIdW1hblJlYWRhYmxlUHJpbnRlci5wcmludF9yZXN1 bHQpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9qc29uX3ByaW50 ZXIucHk6IEFkZGVkLgorICAgICAgICBKU09OUHJpbnRlciwgd2hpY2ggYWxzbyBpbmhlcml0cyBm cm9tIEFic3RyYWN0UHJpbnRlciBwcm9kdWNlcyAKKyAgICAgICAgb3V0cHV0IGluIEpTT04gZm9y bWF0IHNvIHRoYXQgaXQgY2FuIGJlIHVzZWQgdG8KKyAgICAgICAgY3JlYXRlIHRoZSByZXN1bHRz Lmpzb24gZmlsZSwgd2hpY2ggaXMgdGhlIGVuZCBnb2FsIG9mIHRoaXMgcGF0Y2guCisgICAgICAg IChKU09OUHJpbnRlcik6CisgICAgICAgIChKU09OUHJpbnRlci5fX2luaXRfXyk6CisgICAgICAg IChKU09OUHJpbnRlci5jb25maWd1cmUpOgorICAgICAgICAoSlNPTlByaW50ZXIucHJpbnRfc3Rh cnRlZF90ZXN0X3N1aXRlKToKKyAgICAgICAgKEpTT05QcmludGVyLndyaXRlX3VwZGF0ZSk6Cisg ICAgICAgIChKU09OUHJpbnRlci5wcmludF9zdGFydGVkX3Rlc3QpOgorICAgICAgICAoSlNPTlBy aW50ZXIucHJpbnRfZmluaXNoZWRfdGVzdCk6CisgICAgICAgIChKU09OUHJpbnRlci5wcmludF9y ZXN1bHQpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9hYnN0cmFj dF9wcmludGVyLnB5OiBBZGRlZC4KKyAgICAgICAgKEFic3RyYWN0UHJpbnRlcik6CisgICAgICAg IChBYnN0cmFjdFByaW50ZXIuX19pbml0X18pOgorICAgICAgICAoQWJzdHJhY3RQcmludGVyLl9z dWJjbGFzc19tdXN0X2ltcGxlbWVudCk6CisgICAgICAgIChBYnN0cmFjdFByaW50ZXIuY29uZmln dXJlKToKKyAgICAgICAgKEFic3RyYWN0UHJpbnRlci5wcmludF9zdGFydGVkX3Rlc3Rfc3VpdGUp OgorICAgICAgICAoQWJzdHJhY3RQcmludGVyLndyaXRlX3VwZGF0ZSk6CisgICAgICAgIChBYnN0 cmFjdFByaW50ZXIucHJpbnRfc3RhcnRlZF90ZXN0KToKKyAgICAgICAgKEFic3RyYWN0UHJpbnRl ci5wcmludF9maW5pc2hlZF90ZXN0KToKKyAgICAgICAgKEFic3RyYWN0UHJpbnRlci5wcmludF9y ZXN1bHQpOgorICAgICAgICAoX0NhcHR1cmVBbmRQYXNzVGhyb3VnaFN0cmVhbSk6CisgICAgICAg IChfQ2FwdHVyZUFuZFBhc3NUaHJvdWdoU3RyZWFtLl9faW5pdF9fKToKKyAgICAgICAgKF9DYXB0 dXJlQW5kUGFzc1Rocm91Z2hTdHJlYW0ud3JpdGUpOgorICAgICAgICAoX0NhcHR1cmVBbmRQYXNz VGhyb3VnaFN0cmVhbS5fbWVzc2FnZV9pc19mcm9tX3BkYik6CisgICAgICAgIChfQ2FwdHVyZUFu ZFBhc3NUaHJvdWdoU3RyZWFtLmZsdXNoKToKKyAgICAgICAgKF9DYXB0dXJlQW5kUGFzc1Rocm91 Z2hTdHJlYW0uZ2V0dmFsdWUpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5u ZXIucHk6CisgICAgICAgIChSdW5uZXIuaGFuZGxlKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0LnB5OgorICAgICAgICAoUnVubmVyVGVzdC50ZXN0X3J1 bik6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3Vu aXR0ZXN0LnB5OgorICAgICAgICAoTW9ja1BvcnRGYWN0b3J5KToKKyAgICAgICAgKE1vY2tQb3J0 RmFjdG9yeS5fX2luaXRfXyk6CisgICAgICAgIChNb2NrUG9ydEZhY3RvcnkuZ2V0KToKKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMucHk6CisgICAgICAgIE1h a2VzIFJ1blRlc3RzLnJ1bigpIHN0aWNrIHRoZSByZXN1bHRzIG9mIHRlc3Rfd2Via2l0cHkgaW50 byBhIEpTT04KKyAgICAgICAgZmlsZQorICAgICAgICAoUnVuVGVzdHMucnVuKToKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHk6CisgICAgICAg IChTdGVwc1Rlc3QudGVzdF9ydW50ZXN0c19hcmdzKToKKwogMjAxNC0xMC0wOCAgQnJlbnQgRnVs Z2hhbSAgPGJmdWxnaGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBbV2luXSBSZXNvbHZlIHZhcmlv dXMgc3RhdGljIGFuYWx5emVyIHdhcm5pbmdzIGluIFRvb2xzLgpkaWZmIC0tZ2l0IGEvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL3BvcnRzX21vY2sucHkgYi9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvcG9ydHNfbW9jay5weQppbmRleCA3Nzk3OTZjLi41 YmZmZGJiIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcv cG9ydHNfbW9jay5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcv cG9ydHNfbW9jay5weQpAQCAtMjcsMTAgKzI3LDIwIEBACiAjIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAKIAorY2xh c3MgTW9ja1BvcnRGYWN0b3J5KG9iamVjdCk6CisgICAgZGVmIF9faW5pdF9fKHNlbGYpOgorICAg ICAgICBzZWxmLm1vY2tfcG9ydCA9IE1vY2tQb3J0KCkKKworICAgIGRlZiBnZXQoc2VsZik6Cisg ICAgICAgIHJldHVybiBzZWxmLm1vY2tfcG9ydAorCiBjbGFzcyBNb2NrUG9ydChvYmplY3QpOgog ICAgIGRlZiBuYW1lKHNlbGYpOgogICAgICAgICByZXR1cm4gIk1vY2tQb3J0IgogCisgICAgZGVm IHB5dGhvbl91bml0dGVzdF9yZXN1bHRzX2RpcmVjdG9yeShzZWxmKToKKyAgICAgICAgcmV0dXJu ICJtb2NrX3B5dGhvbl91bml0dGVzdF9yZXN1bHRzX2RpcmVjdG9yeSIKKwogICAgIGRlZiBjaGVj a193ZWJraXRfc3R5bGVfY29tbWFuZChzZWxmKToKICAgICAgICAgcmV0dXJuIFsibW9jay1jaGVj ay13ZWJraXQtc3R5bGUiXQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Bv cnQvYmFzZS5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9iYXNlLnB5CmluZGV4IDkw NzRmNzguLjk2Mjc2MjkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9i YXNlLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9iYXNlLnB5CkBAIC03ODIs NiArNzgyLDkgQEAgY2xhc3MgUG9ydChvYmplY3QpOgogICAgICAgICAgICAgc2VsZi5fcmVzdWx0 c19kaXJlY3RvcnkgPSBzZWxmLl9maWxlc3lzdGVtLmFic3BhdGgob3B0aW9uX3ZhbCkKICAgICAg ICAgcmV0dXJuIHNlbGYuX3Jlc3VsdHNfZGlyZWN0b3J5CiAKKyAgICBkZWYgcHl0aG9uX3VuaXR0 ZXN0X3Jlc3VsdHNfZGlyZWN0b3J5KHNlbGYpOgorICAgICAgICByZXR1cm4gc2VsZi5fYnVpbGRf cGF0aCgncHl0aG9uLXVuaXR0ZXN0LXJlc3VsdHMnKQorCiAgICAgZGVmIHBlcmZfcmVzdWx0c19k aXJlY3Rvcnkoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9idWlsZF9wYXRoKCkKIApkaWZm IC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0 ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0 ZXN0LnB5CmluZGV4IDZlMDAxOTkuLjUyY2M3YmEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvcG9ydC9zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5weQorKysgYi9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkKQEAgLTY2LDYgKzY2 LDkgQEAgY2xhc3MgTW9ja0ZpbGUob2JqZWN0KToKICAgICAgICAgc2VsZi5fc2VydmVyX3Byb2Nl c3MuYnJva2VuX3BpcGVzLmFwcGVuZChzZWxmKQogICAgICAgICByYWlzZSBJT0Vycm9yCiAKKyAg ICBkZWYgcmVhZChzZWxmKToKKyAgICAgICAgcmV0dXJuICIiCisKICAgICBkZWYgY2xvc2Uoc2Vs Zik6CiAgICAgICAgIHNlbGYuY2xvc2VkID0gVHJ1ZQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9t YWluLnB5CmluZGV4IGNiMGVmMTUuLmFjZTQ3OGQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvdGVzdC9tYWluLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9t YWluLnB5CkBAIC0zNSw3ICszNSw5IEBAIGltcG9ydCB1bml0dGVzdAogCiBmcm9tIHdlYmtpdHB5 LmNvbW1vbi5zeXN0ZW0uZmlsZXN5c3RlbSBpbXBvcnQgRmlsZVN5c3RlbQogZnJvbSB3ZWJraXRw eS50ZXN0LmZpbmRlciBpbXBvcnQgRmluZGVyCi1mcm9tIHdlYmtpdHB5LnRlc3QucHJpbnRlciBp bXBvcnQgUHJpbnRlcgorZnJvbSB3ZWJraXRweS50ZXN0LnByaW50ZXJzLmh1bWFuX3JlYWRhYmxl X3ByaW50ZXIgaW1wb3J0IEh1bWFuUmVhZGFibGVQcmludGVyCitmcm9tIHdlYmtpdHB5LnRlc3Qu cHJpbnRlcnMuanNvbl9wcmludGVyIGltcG9ydCBKU09OUHJpbnRlcgorCiBmcm9tIHdlYmtpdHB5 LnRlc3QucnVubmVyIGltcG9ydCBSdW5uZXIsIHVuaXRfdGVzdF9uYW1lCiAKIF9sb2cgPSBsb2dn aW5nLmdldExvZ2dlcihfX25hbWVfXykKQEAgLTczLDkgKzc1LDEwIEBAIGRlZiBtYWluKCk6CiAK IAogY2xhc3MgVGVzdGVyKG9iamVjdCk6Ci0gICAgZGVmIF9faW5pdF9fKHNlbGYsIGZpbGVzeXN0 ZW09Tm9uZSk6CisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHN0cmVhbV9vdmVycmlkZT1Ob25lLCBh cmdzX292ZXJyaWRlPU5vbmUsIGZpbGVzeXN0ZW09Tm9uZSk6CiAgICAgICAgIHNlbGYuZmluZGVy ID0gRmluZGVyKGZpbGVzeXN0ZW0gb3IgRmlsZVN5c3RlbSgpKQotICAgICAgICBzZWxmLnByaW50 ZXIgPSBQcmludGVyKHN5cy5zdGRlcnIpCisgICAgICAgIHNlbGYuX3N0cmVhbV9vdmVycmlkZSA9 IHN0cmVhbV9vdmVycmlkZQorICAgICAgICBzZWxmLl9hcmdzX292ZXJyaWRlID0gYXJnc19vdmVy cmlkZQogICAgICAgICBzZWxmLl9vcHRpb25zID0gTm9uZQogCiAgICAgZGVmIGFkZF90cmVlKHNl bGYsIHRvcF9kaXJlY3RvcnksIHN0YXJ0aW5nX3N1YmRpcmVjdG9yeT1Ob25lKToKQEAgLTEwMiw2 ICsxMDUsOSBAQCBjbGFzcyBUZXN0ZXIob2JqZWN0KToKICAgICAgICAgICAgICAgICAgICAgICAg ICAgaGVscD0nZGlzcGxheSBwZXItdGVzdCBleGVjdXRpb24gdGltZSAoaW1wbGllcyAtLXZlcmJv c2UpJykKICAgICAgICAgcGFyc2VyLmFkZF9vcHRpb24oJy12JywgJy0tdmVyYm9zZScsIGFjdGlv bj0nY291bnQnLCBkZWZhdWx0PTAsCiAgICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3Zl cmJvc2Ugb3V0cHV0IChzcGVjaWZ5IG9uY2UgZm9yIGluZGl2aWR1YWwgdGVzdCByZXN1bHRzLCB0 d2ljZSBmb3IgZGVidWcgbWVzc2FnZXMpJykKKyAgICAgICAgcGFyc2VyLmFkZF9vcHRpb24oJy1z JywgJy0tanNvbicsIGFjdGlvbj0nc3RvcmVfdHJ1ZScsIGRlZmF1bHQ9RmFsc2UsCisgICAgICAg ICAgICAgICAgICAgICAgICAgIGhlbHA9J2Zvcm1hdHMgdGhlIG91dHB1dCBhcyBhIGpzb24gc3Ry aW5nJykKKwogCiAgICAgICAgIHBhcnNlci5lcGlsb2cgPSAoJ1thcmdzLi4uXSBpcyBhbiBvcHRp b25hbCBsaXN0IG9mIG1vZHVsZXMsIHRlc3RfY2xhc3Nlcywgb3IgaW5kaXZpZHVhbCB0ZXN0cy4g JwogICAgICAgICAgICAgICAgICAgICAgICAgICdJZiBubyBhcmdzIGFyZSBnaXZlbiwgYWxsIHRo ZSB0ZXN0cyB3aWxsIGJlIHJ1bi4nKQpAQCAtMTA5LDggKzExNSwxMyBAQCBjbGFzcyBUZXN0ZXIo b2JqZWN0KToKICAgICAgICAgcmV0dXJuIHBhcnNlci5wYXJzZV9hcmdzKGFyZ3YpCiAKICAgICBk ZWYgcnVuKHNlbGYpOgotICAgICAgICBzZWxmLl9vcHRpb25zLCBhcmdzID0gc2VsZi5fcGFyc2Vf YXJncygpCi0gICAgICAgIHNlbGYucHJpbnRlci5jb25maWd1cmUoc2VsZi5fb3B0aW9ucykKKyAg ICAgICAgc2VsZi5fb3B0aW9ucywgYXJncyA9IHNlbGYuX3BhcnNlX2FyZ3Moc2VsZi5fYXJnc19v dmVycmlkZSkKKyAgICAgICAgaWYgc2VsZi5fb3B0aW9ucy5qc29uOgorICAgICAgICAgICAgc2Vs Zi5wcmludGVyID0gSlNPTlByaW50ZXIoc2VsZi5fc3RyZWFtX292ZXJyaWRlIG9yIHN5cy5zdGRv dXQsIHNlbGYuX29wdGlvbnMpCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBzZWxmLnByaW50 ZXIgPSBIdW1hblJlYWRhYmxlUHJpbnRlcihzZWxmLl9zdHJlYW1fb3ZlcnJpZGUgb3Igc3lzLnN0 ZGVyciwgc2VsZi5fb3B0aW9ucykKKworICAgICAgICBzZWxmLnByaW50ZXIucHJpbnRfc3RhcnRl ZF90ZXN0X3N1aXRlKCJQeXRob24gVW5pdCBUZXN0cyIpCiAKICAgICAgICAgc2VsZi5maW5kZXIu Y2xlYW5fdHJlZXMoKQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3Qv bWFpbl91bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluX3VuaXR0 ZXN0LnB5CmluZGV4IDJhNDgyNDMuLmE1NDUzMWMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvdGVzdC9tYWluX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdGVzdC9tYWluX3VuaXR0ZXN0LnB5CkBAIC01MSw4ICs1MSw4IEBAIGNsYXNzIFRlc3RTdHVi cyh1bml0dGVzdC5UZXN0Q2FzZSk6CiBjbGFzcyBUZXN0ZXJUZXN0KHVuaXR0ZXN0LlRlc3RDYXNl KToKIAogICAgIGRlZiB0ZXN0X25vX3Rlc3RzX2ZvdW5kKHNlbGYpOgotICAgICAgICB0ZXN0ZXIg PSBUZXN0ZXIoKQogICAgICAgICBlcnJvcnMgPSBTdHJpbmdJTy5TdHJpbmdJTygpCisgICAgICAg IHRlc3RlciA9IFRlc3RlcihzdHJlYW1fb3ZlcnJpZGU9ZXJyb3JzLCBhcmdzX292ZXJyaWRlPVtd KQogCiAgICAgICAgICMgSGVyZSB3ZSBuZWVkIHRvIHJlbW92ZSBhbnkgZXhpc3RpbmcgbG9nIGhh bmRsZXJzIHNvIHRoYXQgdGhleQogICAgICAgICAjIGRvbid0IGxvZyB0aGUgbWVzc2FnZXMgd2Vi a2l0cHkudGVzdCB3aGlsZSB3ZSdyZSB0ZXN0aW5nIGl0LgpAQCAtNjAsNyArNjAsNiBAQCBjbGFz cyBUZXN0ZXJUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAgcm9vdF9oYW5kbGVycyA9 IHJvb3RfbG9nZ2VyLmhhbmRsZXJzCiAgICAgICAgIHJvb3RfbG9nZ2VyLmhhbmRsZXJzID0gW10K IAotICAgICAgICB0ZXN0ZXIucHJpbnRlci5zdHJlYW0gPSBlcnJvcnMKICAgICAgICAgdGVzdGVy LmZpbmRlci5maW5kX25hbWVzID0gbGFtYmRhIGFyZ3MsIHJ1bl9hbGw6IFtdCiAgICAgICAgIG9j ID0gT3V0cHV0Q2FwdHVyZSgpCiAgICAgICAgIHRyeToKZGlmZiAtLWdpdCBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvdGVzdC9wcmludGVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0 L3ByaW50ZXIucHkKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGQwMzY0MjguLjAwMDAw MDAKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3ByaW50ZXIucHkKKysrIC9kZXYv bnVsbApAQCAtMSwyMTQgKzAsMCBAQAotIyBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlLCBJbmMu Ci0jIENvcHlyaWdodCAoQykgMjAxMCBDaHJpcyBKZXJkb25layAoY2plcmRvbmVrQHdlYmtpdC5v cmcpCi0jCi0jIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAotIyBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSMgYXJlIG1ldDoKLSMgMS4gIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 Ci0jICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCi0jIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotIyAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQotIyAgICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KLSMKLSMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFO RCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQKLSMgQU5ZIEVYUFJFU1MgT1IgSU1QTElF RCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQK LSMgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFSRQotIyBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUgotIyBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCi0j IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBT VUJTVElUVVRFIEdPT0RTIE9SCi0jIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSCi0jIENBVVNFRCBBTkQgT04g QU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksCi0jIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCi0jIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0KLWltcG9ydCBT dHJpbmdJTwotaW1wb3J0IGxvZ2dpbmcKLQotZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtIGlt cG9ydCBvdXRwdXRjYXB0dXJlCi1mcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0uc3lzdGVtaG9z dCBpbXBvcnQgU3lzdGVtSG9zdAotZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMudmlld3MubWV0 ZXJlZF9zdHJlYW0gaW1wb3J0IE1ldGVyZWRTdHJlYW0KLWZyb20gd2Via2l0cHkudG9vbC5ncmFt bWFyIGltcG9ydCBwbHVyYWxpemUKLQotX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKF9fbmFtZV9f KQotCi0KLWNsYXNzIFByaW50ZXIob2JqZWN0KToKLSAgICBkZWYgX19pbml0X18oc2VsZiwgc3Ry ZWFtLCBvcHRpb25zPU5vbmUpOgotICAgICAgICBzZWxmLnN0cmVhbSA9IHN0cmVhbQotICAgICAg ICBzZWxmLm1ldGVyID0gTm9uZQotICAgICAgICBzZWxmLm9wdGlvbnMgPSBvcHRpb25zCi0gICAg ICAgIHNlbGYubnVtX3Rlc3RzID0gMAotICAgICAgICBzZWxmLm51bV9zdGFydGVkID0gMAotICAg ICAgICBzZWxmLm51bV9lcnJvcnMgPSAwCi0gICAgICAgIHNlbGYubnVtX2ZhaWx1cmVzID0gMAot ICAgICAgICBzZWxmLnJ1bm5pbmdfdGVzdHMgPSBbXQotICAgICAgICBzZWxmLmNvbXBsZXRlZF90 ZXN0cyA9IFtdCi0gICAgICAgIGlmIG9wdGlvbnM6Ci0gICAgICAgICAgICBzZWxmLmNvbmZpZ3Vy ZShvcHRpb25zKQotCi0gICAgZGVmIGNvbmZpZ3VyZShzZWxmLCBvcHRpb25zKToKLSAgICAgICAg c2VsZi5vcHRpb25zID0gb3B0aW9ucwotCi0gICAgICAgIGlmIG9wdGlvbnMudGltaW5nOgotICAg ICAgICAgICAgIyAtLXRpbWluZyBpbXBsaWVzIC0tdmVyYm9zZQotICAgICAgICAgICAgb3B0aW9u cy52ZXJib3NlID0gbWF4KG9wdGlvbnMudmVyYm9zZSwgMSkKLQotICAgICAgICBsb2dfbGV2ZWwg PSBsb2dnaW5nLklORk8KLSAgICAgICAgaWYgb3B0aW9ucy5xdWlldDoKLSAgICAgICAgICAgIGxv Z19sZXZlbCA9IGxvZ2dpbmcuV0FSTklORwotICAgICAgICBlbGlmIG9wdGlvbnMudmVyYm9zZSA9 PSAyOgotICAgICAgICAgICAgbG9nX2xldmVsID0gbG9nZ2luZy5ERUJVRwotCi0gICAgICAgIHNl bGYubWV0ZXIgPSBNZXRlcmVkU3RyZWFtKHNlbGYuc3RyZWFtLCAob3B0aW9ucy52ZXJib3NlID09 IDIpLAotICAgICAgICAgICAgbnVtYmVyX29mX2NvbHVtbnM9U3lzdGVtSG9zdCgpLnBsYXRmb3Jt LnRlcm1pbmFsX3dpZHRoKCkpCi0KLSAgICAgICAgaGFuZGxlciA9IGxvZ2dpbmcuU3RyZWFtSGFu ZGxlcihzZWxmLnN0cmVhbSkKLSAgICAgICAgIyBXZSBjb25zdHJhaW4gdGhlIGxldmVsIG9uIHRo ZSBoYW5kbGVyIHJhdGhlciB0aGFuIG9uIHRoZSByb290Ci0gICAgICAgICMgbG9nZ2VyIGl0c2Vs Zi4gIFRoaXMgaXMgcHJvYmFibHkgYmV0dGVyIGJlY2F1c2UgdGhlIGhhbmRsZXIgaXMKLSAgICAg ICAgIyBjb25maWd1cmVkIGFuZCBrbm93biBvbmx5IHRvIHRoaXMgbW9kdWxlLCB3aGVyZWFzIHRo ZSByb290IGxvZ2dlcgotICAgICAgICAjIGlzIGFuIG9iamVjdCBzaGFyZWQgKGFuZCBwb3RlbnRp YWxseSBtb2RpZmllZCkgYnkgbWFueSBtb2R1bGVzLgotICAgICAgICAjIE1vZGlmeWluZyB0aGUg aGFuZGxlciwgdGhlbiwgaXMgbGVzcyBpbnRydXNpdmUgYW5kIGxlc3MgbGlrZWx5IHRvCi0gICAg ICAgICMgaW50ZXJmZXJlIHdpdGggbW9kaWZpY2F0aW9ucyBtYWRlIGJ5IG90aGVyIG1vZHVsZXMg KGUuZy4gaW4gdW5pdAotICAgICAgICAjIHRlc3RzKS4KLSAgICAgICAgaGFuZGxlci5uYW1lID0g X19uYW1lX18KLSAgICAgICAgaGFuZGxlci5zZXRMZXZlbChsb2dfbGV2ZWwpCi0gICAgICAgIGZv cm1hdHRlciA9IGxvZ2dpbmcuRm9ybWF0dGVyKCIlKG1lc3NhZ2UpcyIpCi0gICAgICAgIGhhbmRs ZXIuc2V0Rm9ybWF0dGVyKGZvcm1hdHRlcikKLQotICAgICAgICBsb2dnZXIgPSBsb2dnaW5nLmdl dExvZ2dlcigpCi0gICAgICAgIGxvZ2dlci5hZGRIYW5kbGVyKGhhbmRsZXIpCi0gICAgICAgIGxv Z2dlci5zZXRMZXZlbChsb2dnaW5nLk5PVFNFVCkKLQotICAgICAgICAjIEZpbHRlciBvdXQgbW9z dCB3ZWJraXRweSBtZXNzYWdlcy4KLSAgICAgICAgIwotICAgICAgICAjIE1lc3NhZ2VzIGNhbiBi ZSBzZWxlY3RpdmVseSByZS1lbmFibGVkIGZvciB0aGlzIHNjcmlwdCBieSB1cGRhdGluZwotICAg ICAgICAjIHRoaXMgbWV0aG9kIGFjY29yZGluZ2x5LgotICAgICAgICBkZWYgZmlsdGVyX3JlY29y ZHMocmVjb3JkKToKLSAgICAgICAgICAgICIiIkZpbHRlciBvdXQgYXV0b2luc3RhbGwgYW5kIG5v bi10aGlyZC1wYXJ0eSB3ZWJraXRweSBtZXNzYWdlcy4iIiIKLSAgICAgICAgICAgICMgRklYTUU6 IEZpZ3VyZSBvdXQgYSB3YXkgbm90IHRvIHVzZSBzdHJpbmdzIGhlcmUsIGZvciBleGFtcGxlIGJ5 Ci0gICAgICAgICAgICAjICAgICAgICB1c2luZyBzeW50YXggbGlrZSB3ZWJraXRweS50ZXN0Ll9f bmFtZV9fLiAgV2Ugd2FudCB0byBiZQotICAgICAgICAgICAgIyAgICAgICAgc3VyZSBub3QgdG8g aW1wb3J0IGFueSBub24tUHl0aG9uIDIuNCBjb2RlLCB0aG91Z2gsIHVudGlsCi0gICAgICAgICAg ICAjICAgICAgICBhZnRlciB0aGUgdmVyc2lvbi1jaGVja2luZyBjb2RlIGhhcyBleGVjdXRlZC4K LSAgICAgICAgICAgIGlmIChyZWNvcmQubmFtZS5zdGFydHN3aXRoKCJ3ZWJraXRweS5jb21tb24u c3lzdGVtLmF1dG9pbnN0YWxsIikgb3IKLSAgICAgICAgICAgICAgICByZWNvcmQubmFtZS5zdGFy dHN3aXRoKCJ3ZWJraXRweS50ZXN0IikpOgotICAgICAgICAgICAgICAgIHJldHVybiBUcnVlCi0g ICAgICAgICAgICBpZiByZWNvcmQubmFtZS5zdGFydHN3aXRoKCJ3ZWJraXRweSIpOgotICAgICAg ICAgICAgICAgIHJldHVybiBGYWxzZQotICAgICAgICAgICAgcmV0dXJuIFRydWUKLQotICAgICAg ICB0ZXN0aW5nX2ZpbHRlciA9IGxvZ2dpbmcuRmlsdGVyKCkKLSAgICAgICAgdGVzdGluZ19maWx0 ZXIuZmlsdGVyID0gZmlsdGVyX3JlY29yZHMKLQotICAgICAgICAjIERpc3BsYXkgYSBtZXNzYWdl IHNvIGRldmVsb3BlcnMgYXJlIG5vdCBteXN0aWZpZWQgYXMgdG8gd2h5Ci0gICAgICAgICMgbG9n Z2luZyBkb2VzIG5vdCB3b3JrIGluIHRoZSB1bml0IHRlc3RzLgotICAgICAgICBfbG9nLmluZm8o IlN1cHByZXNzaW5nIG1vc3Qgd2Via2l0cHkgbG9nZ2luZyB3aGlsZSBydW5uaW5nIHVuaXQgdGVz dHMuIikKLSAgICAgICAgaGFuZGxlci5hZGRGaWx0ZXIodGVzdGluZ19maWx0ZXIpCi0KLSAgICAg ICAgaWYgc2VsZi5vcHRpb25zLnBhc3NfdGhyb3VnaDoKLSAgICAgICAgICAgIG91dHB1dGNhcHR1 cmUuT3V0cHV0Q2FwdHVyZS5zdHJlYW1fd3JhcHBlciA9IF9DYXB0dXJlQW5kUGFzc1Rocm91Z2hT dHJlYW0KLQotICAgIGRlZiB3cml0ZV91cGRhdGUoc2VsZiwgbXNnKToKLSAgICAgICAgc2VsZi5t ZXRlci53cml0ZV91cGRhdGUobXNnKQotCi0gICAgZGVmIHByaW50X3N0YXJ0ZWRfdGVzdChzZWxm LCBzb3VyY2UsIHRlc3RfbmFtZSk6Ci0gICAgICAgIHNlbGYucnVubmluZ190ZXN0cy5hcHBlbmQo dGVzdF9uYW1lKQotICAgICAgICBpZiBsZW4oc2VsZi5ydW5uaW5nX3Rlc3RzKSA+IDE6Ci0gICAg ICAgICAgICBzdWZmaXggPSAnICgrJWQpJyAlIChsZW4oc2VsZi5ydW5uaW5nX3Rlc3RzKSAtIDEp Ci0gICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBzdWZmaXggPSAnJwotCi0gICAgICAgIGlmIHNl bGYub3B0aW9ucy52ZXJib3NlOgotICAgICAgICAgICAgd3JpdGUgPSBzZWxmLm1ldGVyLndyaXRl X3VwZGF0ZQotICAgICAgICBlbHNlOgotICAgICAgICAgICAgd3JpdGUgPSBzZWxmLm1ldGVyLndy aXRlX3Rocm90dGxlZF91cGRhdGUKLQotICAgICAgICB3cml0ZShzZWxmLl90ZXN0X2xpbmUoc2Vs Zi5ydW5uaW5nX3Rlc3RzWzBdLCBzdWZmaXgpKQotCi0gICAgZGVmIHByaW50X2ZpbmlzaGVkX3Rl c3Qoc2VsZiwgc291cmNlLCB0ZXN0X25hbWUsIHRlc3RfdGltZSwgZmFpbHVyZXMsIGVycm9ycyk6 Ci0gICAgICAgIHdyaXRlID0gc2VsZi5tZXRlci53cml0ZWxuCi0gICAgICAgIGlmIGZhaWx1cmVz OgotICAgICAgICAgICAgbGluZXMgPSBmYWlsdXJlc1swXS5zcGxpdGxpbmVzKCkgKyBbJyddCi0g ICAgICAgICAgICBzdWZmaXggPSAnIGZhaWxlZDonCi0gICAgICAgICAgICBzZWxmLm51bV9mYWls dXJlcyArPSAxCi0gICAgICAgIGVsaWYgZXJyb3JzOgotICAgICAgICAgICAgbGluZXMgPSBlcnJv cnNbMF0uc3BsaXRsaW5lcygpICsgWycnXQotICAgICAgICAgICAgc3VmZml4ID0gJyBlcnJlZDon Ci0gICAgICAgICAgICBzZWxmLm51bV9lcnJvcnMgKz0gMQotICAgICAgICBlbHNlOgotICAgICAg ICAgICAgc3VmZml4ID0gJyBwYXNzZWQnCi0gICAgICAgICAgICBsaW5lcyA9IFtdCi0gICAgICAg ICAgICBpZiBzZWxmLm9wdGlvbnMudmVyYm9zZToKLSAgICAgICAgICAgICAgICB3cml0ZSA9IHNl bGYubWV0ZXIud3JpdGVsbgotICAgICAgICAgICAgZWxzZToKLSAgICAgICAgICAgICAgICB3cml0 ZSA9IHNlbGYubWV0ZXIud3JpdGVfdGhyb3R0bGVkX3VwZGF0ZQotICAgICAgICBpZiBzZWxmLm9w dGlvbnMudGltaW5nOgotICAgICAgICAgICAgc3VmZml4ICs9ICcgJS40ZnMnICUgdGVzdF90aW1l Ci0KLSAgICAgICAgc2VsZi5udW1fc3RhcnRlZCArPSAxCi0KLSAgICAgICAgaWYgdGVzdF9uYW1l ID09IHNlbGYucnVubmluZ190ZXN0c1swXToKLSAgICAgICAgICAgIHNlbGYuY29tcGxldGVkX3Rl c3RzLmluc2VydCgwLCBbdGVzdF9uYW1lLCBzdWZmaXgsIGxpbmVzXSkKLSAgICAgICAgZWxzZToK LSAgICAgICAgICAgIHNlbGYuY29tcGxldGVkX3Rlc3RzLmFwcGVuZChbdGVzdF9uYW1lLCBzdWZm aXgsIGxpbmVzXSkKLSAgICAgICAgc2VsZi5ydW5uaW5nX3Rlc3RzLnJlbW92ZSh0ZXN0X25hbWUp Ci0KLSAgICAgICAgZm9yIHRlc3RfbmFtZSwgbXNnLCBsaW5lcyBpbiBzZWxmLmNvbXBsZXRlZF90 ZXN0czoKLSAgICAgICAgICAgIGlmIGxpbmVzOgotICAgICAgICAgICAgICAgIHNlbGYubWV0ZXIu d3JpdGVsbihzZWxmLl90ZXN0X2xpbmUodGVzdF9uYW1lLCBtc2cpKQotICAgICAgICAgICAgICAg IGZvciBsaW5lIGluIGxpbmVzOgotICAgICAgICAgICAgICAgICAgICBzZWxmLm1ldGVyLndyaXRl bG4oJyAgJyArIGxpbmUpCi0gICAgICAgICAgICBlbHNlOgotICAgICAgICAgICAgICAgIHdyaXRl KHNlbGYuX3Rlc3RfbGluZSh0ZXN0X25hbWUsIG1zZykpCi0gICAgICAgIHNlbGYuY29tcGxldGVk X3Rlc3RzID0gW10KLQotICAgIGRlZiBfdGVzdF9saW5lKHNlbGYsIHRlc3RfbmFtZSwgc3VmZml4 KToKLSAgICAgICAgZm9ybWF0X3N0cmluZyA9ICdbJWQvJWRdICVzJXMnCi0gICAgICAgIHN0YXR1 c19saW5lID0gZm9ybWF0X3N0cmluZyAlIChzZWxmLm51bV9zdGFydGVkLCBzZWxmLm51bV90ZXN0 cywgdGVzdF9uYW1lLCBzdWZmaXgpCi0gICAgICAgIGlmIGxlbihzdGF0dXNfbGluZSkgPiBzZWxm Lm1ldGVyLm51bWJlcl9vZl9jb2x1bW5zKCk6Ci0gICAgICAgICAgICBvdmVyZmxvd19jb2x1bW5z ID0gbGVuKHN0YXR1c19saW5lKSAtIHNlbGYubWV0ZXIubnVtYmVyX29mX2NvbHVtbnMoKQotICAg ICAgICAgICAgZWxsaXBzaXMgPSAnLi4uJwotICAgICAgICAgICAgaWYgbGVuKHRlc3RfbmFtZSkg PCBvdmVyZmxvd19jb2x1bW5zICsgbGVuKGVsbGlwc2lzKSArIDM6Ci0gICAgICAgICAgICAgICAg IyBXZSBkb24ndCBoYXZlIGVub3VnaCBzcGFjZSBldmVuIGlmIHdlIGVsaWRlLCBqdXN0IHNob3cg dGhlIHRlc3QgbWV0aG9kIG5hbWUuCi0gICAgICAgICAgICAgICAgdGVzdF9uYW1lID0gdGVzdF9u YW1lLnNwbGl0KCcuJylbLTFdCi0gICAgICAgICAgICBlbHNlOgotICAgICAgICAgICAgICAgIG5l d19sZW5ndGggPSBsZW4odGVzdF9uYW1lKSAtIG92ZXJmbG93X2NvbHVtbnMgLSBsZW4oZWxsaXBz aXMpCi0gICAgICAgICAgICAgICAgcHJlZml4ID0gaW50KG5ld19sZW5ndGggLyAyKQotICAgICAg ICAgICAgICAgIHRlc3RfbmFtZSA9IHRlc3RfbmFtZVs6cHJlZml4XSArIGVsbGlwc2lzICsgdGVz dF9uYW1lWy0obmV3X2xlbmd0aCAtIHByZWZpeCk6XQotICAgICAgICByZXR1cm4gZm9ybWF0X3N0 cmluZyAlIChzZWxmLm51bV9zdGFydGVkLCBzZWxmLm51bV90ZXN0cywgdGVzdF9uYW1lLCBzdWZm aXgpCi0KLSAgICBkZWYgcHJpbnRfcmVzdWx0KHNlbGYsIHJ1bl90aW1lKToKLSAgICAgICAgd3Jp dGUgPSBzZWxmLm1ldGVyLndyaXRlbG4KLSAgICAgICAgd3JpdGUoJ1JhbiAlcyBpbiAlLjNmcycg JSAocGx1cmFsaXplKHNlbGYubnVtX3N0YXJ0ZWQsICJ0ZXN0IiksIHJ1bl90aW1lKSkKLSAgICAg ICAgaWYgc2VsZi5udW1fZmFpbHVyZXMgb3Igc2VsZi5udW1fZXJyb3JzOgotICAgICAgICAgICAg d3JpdGUoJ0ZBSUxFRCAoZmFpbHVyZXM9JWQsIGVycm9ycz0lZClcbicgJSAoc2VsZi5udW1fZmFp bHVyZXMsIHNlbGYubnVtX2Vycm9ycykpCi0gICAgICAgIGVsc2U6Ci0gICAgICAgICAgICB3cml0 ZSgnXG5PS1xuJykKLQotCi1jbGFzcyBfQ2FwdHVyZUFuZFBhc3NUaHJvdWdoU3RyZWFtKG9iamVj dCk6Ci0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHN0cmVhbSk6Ci0gICAgICAgIHNlbGYuX2J1ZmZl ciA9IFN0cmluZ0lPLlN0cmluZ0lPKCkKLSAgICAgICAgc2VsZi5fc3RyZWFtID0gc3RyZWFtCi0K LSAgICBkZWYgd3JpdGUoc2VsZiwgbXNnKToKLSAgICAgICAgc2VsZi5fc3RyZWFtLndyaXRlKG1z ZykKLQotICAgICAgICAjIE5vdGUgdGhhdCB3ZSBkb24ndCB3YW50IHRvIGNhcHR1cmUgYW55IG91 dHB1dCBnZW5lcmF0ZWQgYnkgdGhlIGRlYnVnZ2VyCi0gICAgICAgICMgYmVjYXVzZSB0aGF0IGNv dWxkIGNhdXNlIHRoZSByZXN1bHRzIG9mIGNhcHR1cmVfb3V0cHV0KCkgdG8gYmUgaW52YWxpZC4K LSAgICAgICAgaWYgbm90IHNlbGYuX21lc3NhZ2VfaXNfZnJvbV9wZGIoKToKLSAgICAgICAgICAg IHNlbGYuX2J1ZmZlci53cml0ZShtc2cpCi0KLSAgICBkZWYgX21lc3NhZ2VfaXNfZnJvbV9wZGIo c2VsZik6Ci0gICAgICAgICMgV2Ugd2lsbCBhc3N1bWUgdGhhdCBpZiB0aGUgcGRiIG1vZHVsZSBp cyBpbiB0aGUgc3RhY2sgdGhlbiB0aGUgb3V0cHV0Ci0gICAgICAgICMgaXMgYmVpbmcgZ2VuZXJh dGVkIGJ5IHRoZSBweXRob24gZGVidWdnZXIgKG9yIHRoZSB1c2VyIGNhbGxpbmcgc29tZXRoaW5n Ci0gICAgICAgICMgZnJvbSBpbnNpZGUgdGhlIGRlYnVnZ2VyKS4KLSAgICAgICAgaW1wb3J0IGlu c3BlY3QKLSAgICAgICAgaW1wb3J0IHBkYgotICAgICAgICBzdGFjayA9IGluc3BlY3Quc3RhY2so KQotICAgICAgICByZXR1cm4gYW55KGZyYW1lWzFdID09IHBkYi5fX2ZpbGVfXy5yZXBsYWNlKCcu cHljJywgJy5weScpIGZvciBmcmFtZSBpbiBzdGFjaykKLQotICAgIGRlZiBmbHVzaChzZWxmKToK LSAgICAgICAgc2VsZi5fc3RyZWFtLmZsdXNoKCkKLQotICAgIGRlZiBnZXR2YWx1ZShzZWxmKToK LSAgICAgICAgcmV0dXJuIHNlbGYuX2J1ZmZlci5nZXR2YWx1ZSgpCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcHJpbnRlcnMvX19pbml0X18ucHkgYi9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L3Rlc3QvcHJpbnRlcnMvX19pbml0X18ucHkKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uZWY2NWJlZQotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9fX2luaXRfXy5weQpAQCAtMCwwICsxIEBACisjIFJl cXVpcmVkIGZvciBQeXRob24gdG8gc2VhcmNoIHRoaXMgZGlyZWN0b3J5IGZvciBtb2R1bGUgZmls ZXMKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9hYnN0 cmFjdF9wcmludGVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3ByaW50ZXJzL2Fi c3RyYWN0X3ByaW50ZXIucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWQ3 MGFkZAotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmlu dGVycy9hYnN0cmFjdF9wcmludGVyLnB5CkBAIC0wLDAgKzEsMTIwIEBACisjIENvcHlyaWdodCAo QykgMjAxMiBHb29nbGUsIEluYy4KKyMgQ29weXJpZ2h0IChDKSAyMDEwIENocmlzIEplcmRvbmVr IChjamVyZG9uZWtAd2Via2l0Lm9yZykKKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworIyBh cmUgbWV0OgorIyAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgMi4gIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisjICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORAorIyBB TlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRAorIyBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisjIERJU0NMQUlNRUQuIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S CisjIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwKKyMgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IKKyMgU0VSVklDRVM7IExPU1Mg T0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VW RVIKKyMgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwKKyMgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKworaW1wb3J0IFN0cmluZ0lPCitpbXBvcnQgbG9nZ2luZworCitmcm9tIHdlYmtp dHB5LmNvbW1vbi5zeXN0ZW0gaW1wb3J0IG91dHB1dGNhcHR1cmUKK2Zyb20gd2Via2l0cHkuY29t bW9uLnN5c3RlbS5zeXN0ZW1ob3N0IGltcG9ydCBTeXN0ZW1Ib3N0Citmcm9tIHdlYmtpdHB5Lmxh eW91dF90ZXN0cy52aWV3cy5tZXRlcmVkX3N0cmVhbSBpbXBvcnQgTWV0ZXJlZFN0cmVhbQorZnJv bSB3ZWJraXRweS50b29sLmdyYW1tYXIgaW1wb3J0IHBsdXJhbGl6ZQorCitfbG9nID0gbG9nZ2lu Zy5nZXRMb2dnZXIoX19uYW1lX18pCisKKworY2xhc3MgQWJzdHJhY3RQcmludGVyKG9iamVjdCk6 CisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHN0cmVhbSwgb3B0aW9ucz1Ob25lKToKKyAgICAgICAg c2VsZi5zdHJlYW0gPSBzdHJlYW0KKyAgICAgICAgc2VsZi5vcHRpb25zID0gb3B0aW9ucworICAg ICAgICBzZWxmLmhhbmRsZXIgPSBOb25lCisgICAgICAgIHNlbGYuY29uZmlndXJlKG9wdGlvbnMp CisKKyAgICBkZWYgX3N1YmNsYXNzX211c3RfaW1wbGVtZW50KHNlbGYpOgorICAgICAgICByYWlz ZSBFeGNlcHRpb24oIlN1YmNsYXNzZXMgbXVzdCBpbXBsZW1lbnQgdGhpcyBtZXRob2QiKQorCisg ICAgZGVmIGNvbmZpZ3VyZShzZWxmLCBvcHRpb25zKToKKyAgICAgICAgc2VsZi5vcHRpb25zID0g b3B0aW9ucworCisgICAgICAgIGlmIG9wdGlvbnMudGltaW5nOgorICAgICAgICAgICAgIyAtLXRp bWluZyBpbXBsaWVzIC0tdmVyYm9zZQorICAgICAgICAgICAgb3B0aW9ucy52ZXJib3NlID0gbWF4 KG9wdGlvbnMudmVyYm9zZSwgMSkKKworICAgICAgICBsb2dfbGV2ZWwgPSBsb2dnaW5nLklORk8K KyAgICAgICAgaWYgb3B0aW9ucy5xdWlldDoKKyAgICAgICAgICAgIGxvZ19sZXZlbCA9IGxvZ2dp bmcuV0FSTklORworICAgICAgICBlbGlmIG9wdGlvbnMudmVyYm9zZSA9PSAyOgorICAgICAgICAg ICAgbG9nX2xldmVsID0gbG9nZ2luZy5ERUJVRworCisgICAgICAgIHNlbGYuaGFuZGxlciA9IGxv Z2dpbmcuU3RyZWFtSGFuZGxlcihzZWxmLnN0cmVhbSkKKyAgICAgICAgIyBXZSBjb25zdHJhaW4g dGhlIGxldmVsIG9uIHRoZSBoYW5kbGVyIHJhdGhlciB0aGFuIG9uIHRoZSByb290CisgICAgICAg ICMgbG9nZ2VyIGl0c2VsZi4gIFRoaXMgaXMgcHJvYmFibHkgYmV0dGVyIGJlY2F1c2UgdGhlIGhh bmRsZXIgaXMKKyAgICAgICAgIyBjb25maWd1cmVkIGFuZCBrbm93biBvbmx5IHRvIHRoaXMgbW9k dWxlLCB3aGVyZWFzIHRoZSByb290IGxvZ2dlcgorICAgICAgICAjIGlzIGFuIG9iamVjdCBzaGFy ZWQgKGFuZCBwb3RlbnRpYWxseSBtb2RpZmllZCkgYnkgbWFueSBtb2R1bGVzLgorICAgICAgICAj IE1vZGlmeWluZyB0aGUgaGFuZGxlciwgdGhlbiwgaXMgbGVzcyBpbnRydXNpdmUgYW5kIGxlc3Mg bGlrZWx5IHRvCisgICAgICAgICMgaW50ZXJmZXJlIHdpdGggbW9kaWZpY2F0aW9ucyBtYWRlIGJ5 IG90aGVyIG1vZHVsZXMgKGUuZy4gaW4gdW5pdAorICAgICAgICAjIHRlc3RzKS4KKyAgICAgICAg c2VsZi5oYW5kbGVyLm5hbWUgPSBfX25hbWVfXworICAgICAgICBzZWxmLmhhbmRsZXIuc2V0TGV2 ZWwobG9nX2xldmVsKQorICAgICAgICBmb3JtYXR0ZXIgPSBsb2dnaW5nLkZvcm1hdHRlcigiJSht ZXNzYWdlKXMiKQorICAgICAgICBzZWxmLmhhbmRsZXIuc2V0Rm9ybWF0dGVyKGZvcm1hdHRlcikK KworICAgICAgICBsb2dnZXIgPSBsb2dnaW5nLmdldExvZ2dlcigpCisgICAgICAgIGxvZ2dlci5h ZGRIYW5kbGVyKHNlbGYuaGFuZGxlcikKKyAgICAgICAgbG9nZ2VyLnNldExldmVsKGxvZ2dpbmcu Tk9UU0VUKQorCisgICAgICAgIGlmIHNlbGYub3B0aW9ucy5wYXNzX3Rocm91Z2g6CisgICAgICAg ICAgICBvdXRwdXRjYXB0dXJlLk91dHB1dENhcHR1cmUuc3RyZWFtX3dyYXBwZXIgPSBfQ2FwdHVy ZUFuZFBhc3NUaHJvdWdoU3RyZWFtCisKKyAgICBkZWYgcHJpbnRfc3RhcnRlZF90ZXN0X3N1aXRl KHNlbGYsIHRlc3Rfc3VpdGVfbmFtZSk6CisgICAgICAgIHNlbGYuX3N1YmNsYXNzX211c3RfaW1w bGVtZW50KCkKKworICAgIGRlZiB3cml0ZV91cGRhdGUoc2VsZiwgbXNnKToKKyAgICAgICAgc2Vs Zi5fc3ViY2xhc3NfbXVzdF9pbXBsZW1lbnQoKQorCisgICAgZGVmIHByaW50X3N0YXJ0ZWRfdGVz dChzZWxmLCBzb3VyY2UsIHRlc3RfbmFtZSk6CisgICAgICAgIHNlbGYuX3N1YmNsYXNzX211c3Rf aW1wbGVtZW50KCkKKworICAgIGRlZiBwcmludF9maW5pc2hlZF90ZXN0KHNlbGYsIHNvdXJjZSwg dGVzdF9uYW1lLCB0ZXN0X2RpZF9wYXNzLCB0ZXN0X3RpbWUsIGZhaWx1cmVzLCBlcnJvcnMpOgor ICAgICAgICBzZWxmLl9zdWJjbGFzc19tdXN0X2ltcGxlbWVudCgpCisKKyAgICBkZWYgcHJpbnRf cmVzdWx0KHNlbGYsIHJ1bl90aW1lKToKKyAgICAgICAgc2VsZi5fc3ViY2xhc3NfbXVzdF9pbXBs ZW1lbnQoKQorCisKK2NsYXNzIF9DYXB0dXJlQW5kUGFzc1Rocm91Z2hTdHJlYW0ob2JqZWN0KToK KyAgICBkZWYgX19pbml0X18oc2VsZiwgc3RyZWFtKToKKyAgICAgICAgc2VsZi5fYnVmZmVyID0g U3RyaW5nSU8uU3RyaW5nSU8oKQorICAgICAgICBzZWxmLl9zdHJlYW0gPSBzdHJlYW0KKworICAg IGRlZiB3cml0ZShzZWxmLCBtc2cpOgorICAgICAgICBzZWxmLl9zdHJlYW0ud3JpdGUobXNnKQor CisgICAgICAgICMgTm90ZSB0aGF0IHdlIGRvbid0IHdhbnQgdG8gY2FwdHVyZSBhbnkgb3V0cHV0 IGdlbmVyYXRlZCBieSB0aGUgZGVidWdnZXIKKyAgICAgICAgIyBiZWNhdXNlIHRoYXQgY291bGQg Y2F1c2UgdGhlIHJlc3VsdHMgb2YgY2FwdHVyZV9vdXRwdXQoKSB0byBiZSBpbnZhbGlkLgorICAg ICAgICBpZiBub3Qgc2VsZi5fbWVzc2FnZV9pc19mcm9tX3BkYigpOgorICAgICAgICAgICAgc2Vs Zi5fYnVmZmVyLndyaXRlKG1zZykKKworICAgIGRlZiBfbWVzc2FnZV9pc19mcm9tX3BkYihzZWxm KToKKyAgICAgICAgIyBXZSB3aWxsIGFzc3VtZSB0aGF0IGlmIHRoZSBwZGIgbW9kdWxlIGlzIGlu IHRoZSBzdGFjayB0aGVuIHRoZSBvdXRwdXQKKyAgICAgICAgIyBpcyBiZWluZyBnZW5lcmF0ZWQg YnkgdGhlIHB5dGhvbiBkZWJ1Z2dlciAob3IgdGhlIHVzZXIgY2FsbGluZyBzb21ldGhpbmcKKyAg ICAgICAgIyBmcm9tIGluc2lkZSB0aGUgZGVidWdnZXIpLgorICAgICAgICBpbXBvcnQgaW5zcGVj dAorICAgICAgICBpbXBvcnQgcGRiCisgICAgICAgIHN0YWNrID0gaW5zcGVjdC5zdGFjaygpCisg ICAgICAgIHJldHVybiBhbnkoZnJhbWVbMV0gPT0gcGRiLl9fZmlsZV9fLnJlcGxhY2UoJy5weWMn LCAnLnB5JykgZm9yIGZyYW1lIGluIHN0YWNrKQorCisgICAgZGVmIGZsdXNoKHNlbGYpOgorICAg ICAgICBzZWxmLl9zdHJlYW0uZmx1c2goKQorCisgICAgZGVmIGdldHZhbHVlKHNlbGYpOgorICAg ICAgICByZXR1cm4gc2VsZi5fYnVmZmVyLmdldHZhbHVlKCkKZGlmZiAtLWdpdCBhL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9odW1hbl9yZWFkYWJsZV9wcmludGVyLnB5IGIv VG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3ByaW50ZXJzL2h1bWFuX3JlYWRhYmxlX3ByaW50 ZXIucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjcxODY1NAotLS0gL2Rl di9udWxsCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9odW1hbl9y ZWFkYWJsZV9wcmludGVyLnB5CkBAIC0wLDAgKzEsMTYwIEBACisjIENvcHlyaWdodCAoQykgMjAx MiBHb29nbGUsIEluYy4KKyMgQ29weXJpZ2h0IChDKSAyMDEwIENocmlzIEplcmRvbmVrIChjamVy ZG9uZWtAd2Via2l0Lm9yZykKKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworIyBhcmUgbWV0 OgorIyAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisjICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORAorIyBBTlkgRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBUSEUgSU1QTElFRAorIyBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisjIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SCisjIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwKKyMgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IKKyMgU0VSVklDRVM7IExPU1MgT0YgVVNF LCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIKKyMg Q0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwKKyMgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KKworaW1wb3J0IFN0cmluZ0lPCitpbXBvcnQgbG9nZ2luZworCitmcm9tIHdlYmtpdHB5LmNv bW1vbi5zeXN0ZW0gaW1wb3J0IG91dHB1dGNhcHR1cmUKK2Zyb20gd2Via2l0cHkuY29tbW9uLnN5 c3RlbS5zeXN0ZW1ob3N0IGltcG9ydCBTeXN0ZW1Ib3N0Citmcm9tIHdlYmtpdHB5LmxheW91dF90 ZXN0cy52aWV3cy5tZXRlcmVkX3N0cmVhbSBpbXBvcnQgTWV0ZXJlZFN0cmVhbQorZnJvbSB3ZWJr aXRweS50b29sLmdyYW1tYXIgaW1wb3J0IHBsdXJhbGl6ZQorZnJvbSB3ZWJraXRweS50ZXN0LnBy aW50ZXJzLmFic3RyYWN0X3ByaW50ZXIgaW1wb3J0IEFic3RyYWN0UHJpbnRlcgorCitfbG9nID0g bG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCisKKworY2xhc3MgSHVtYW5SZWFkYWJsZVByaW50 ZXIoQWJzdHJhY3RQcmludGVyKToKKyAgICBkZWYgX19pbml0X18oc2VsZiwgc3RyZWFtLCBvcHRp b25zPU5vbmUpOgorICAgICAgICBzdXBlcihIdW1hblJlYWRhYmxlUHJpbnRlciwgc2VsZikuX19p bml0X18oc3RyZWFtLCBvcHRpb25zKQorICAgICAgICBzZWxmLnJ1bm5pbmdfdGVzdHMgPSBbXQor ICAgICAgICBzZWxmLmNvbXBsZXRlZF90ZXN0cyA9IFtdCisgICAgICAgIHNlbGYubnVtX3Rlc3Rz ID0gMAorICAgICAgICBzZWxmLm51bV9zdGFydGVkID0gMAorICAgICAgICBzZWxmLm51bV9lcnJv cnMgPSAwCisgICAgICAgIHNlbGYubnVtX2ZhaWx1cmVzID0gMAorCisgICAgZGVmIGNvbmZpZ3Vy ZShzZWxmLCBvcHRpb25zKToKKyAgICAgICAgc3VwZXIoSHVtYW5SZWFkYWJsZVByaW50ZXIsIHNl bGYpLmNvbmZpZ3VyZShvcHRpb25zKQorCisgICAgICAgIHNlbGYubWV0ZXIgPSBNZXRlcmVkU3Ry ZWFtKHNlbGYuc3RyZWFtLCAob3B0aW9ucy52ZXJib3NlID09IDIpLAorICAgICAgICAgICAgbnVt YmVyX29mX2NvbHVtbnM9U3lzdGVtSG9zdCgpLnBsYXRmb3JtLnRlcm1pbmFsX3dpZHRoKCkpCisK KyAgICAgICAgIyBGaWx0ZXIgb3V0IG1vc3Qgd2Via2l0cHkgbWVzc2FnZXMuCisgICAgICAgICMK KyAgICAgICAgIyBNZXNzYWdlcyBjYW4gYmUgc2VsZWN0aXZlbHkgcmUtZW5hYmxlZCBmb3IgdGhp cyBzY3JpcHQgYnkgdXBkYXRpbmcKKyAgICAgICAgIyB0aGlzIG1ldGhvZCBhY2NvcmRpbmdseS4K KyAgICAgICAgZGVmIGZpbHRlcl9yZWNvcmRzKHJlY29yZCk6CisgICAgICAgICAgICAiIiJGaWx0 ZXIgb3V0IGF1dG9pbnN0YWxsIGFuZCBub24tdGhpcmQtcGFydHkgd2Via2l0cHkgbWVzc2FnZXMu IiIiCisgICAgICAgICAgICAjIEZJWE1FOiBGaWd1cmUgb3V0IGEgd2F5IG5vdCB0byB1c2Ugc3Ry aW5ncyBoZXJlLCBmb3IgZXhhbXBsZSBieQorICAgICAgICAgICAgIyAgICAgICAgdXNpbmcgc3lu dGF4IGxpa2Ugd2Via2l0cHkudGVzdC5fX25hbWVfXy4gIFdlIHdhbnQgdG8gYmUKKyAgICAgICAg ICAgICMgICAgICAgIHN1cmUgbm90IHRvIGltcG9ydCBhbnkgbm9uLVB5dGhvbiAyLjQgY29kZSwg dGhvdWdoLCB1bnRpbAorICAgICAgICAgICAgIyAgICAgICAgYWZ0ZXIgdGhlIHZlcnNpb24tY2hl Y2tpbmcgY29kZSBoYXMgZXhlY3V0ZWQuCisgICAgICAgICAgICBpZiAocmVjb3JkLm5hbWUuc3Rh cnRzd2l0aCgid2Via2l0cHkuY29tbW9uLnN5c3RlbS5hdXRvaW5zdGFsbCIpIG9yCisgICAgICAg ICAgICAgICAgcmVjb3JkLm5hbWUuc3RhcnRzd2l0aCgid2Via2l0cHkudGVzdCIpKToKKyAgICAg ICAgICAgICAgICByZXR1cm4gVHJ1ZQorICAgICAgICAgICAgaWYgcmVjb3JkLm5hbWUuc3RhcnRz d2l0aCgid2Via2l0cHkiKToKKyAgICAgICAgICAgICAgICByZXR1cm4gRmFsc2UKKyAgICAgICAg ICAgIHJldHVybiBUcnVlCisKKyAgICAgICAgdGVzdGluZ19maWx0ZXIgPSBsb2dnaW5nLkZpbHRl cigpCisgICAgICAgIHRlc3RpbmdfZmlsdGVyLmZpbHRlciA9IGZpbHRlcl9yZWNvcmRzCisKKyAg ICAgICAgIyBEaXNwbGF5IGEgbWVzc2FnZSBzbyBkZXZlbG9wZXJzIGFyZSBub3QgbXlzdGlmaWVk IGFzIHRvIHdoeQorICAgICAgICAjIGxvZ2dpbmcgZG9lcyBub3Qgd29yayBpbiB0aGUgdW5pdCB0 ZXN0cy4KKworICAgICAgICBfbG9nLmluZm8oIlN1cHByZXNzaW5nIG1vc3Qgd2Via2l0cHkgbG9n Z2luZyB3aGlsZSBydW5uaW5nIHVuaXQgdGVzdHMuIikKKyAgICAgICAgc2VsZi5oYW5kbGVyLmFk ZEZpbHRlcih0ZXN0aW5nX2ZpbHRlcikKKworICAgIGRlZiB3cml0ZV91cGRhdGUoc2VsZiwgbXNn KToKKyAgICAgICAgc2VsZi5tZXRlci53cml0ZV91cGRhdGUobXNnKQorCisgICAgZGVmIHByaW50 X3N0YXJ0ZWRfdGVzdF9zdWl0ZShzZWxmLCB0ZXN0X3N1aXRlX25hbWUpOgorICAgICAgICBzZWxm Lm1ldGVyLndyaXRlbG4oIkJlZ2lubmluZyAiICsgdGVzdF9zdWl0ZV9uYW1lKQorCisgICAgZGVm IHByaW50X3N0YXJ0ZWRfdGVzdChzZWxmLCBzb3VyY2UsIHRlc3RfbmFtZSk6CisgICAgICAgIHNl bGYucnVubmluZ190ZXN0cy5hcHBlbmQodGVzdF9uYW1lKQorICAgICAgICBpZiBsZW4oc2VsZi5y dW5uaW5nX3Rlc3RzKSA+IDE6CisgICAgICAgICAgICBzdWZmaXggPSAnICgrJWQpJyAlIChsZW4o c2VsZi5ydW5uaW5nX3Rlc3RzKSAtIDEpCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBzdWZm aXggPSAnJworCisgICAgICAgIGlmIHNlbGYub3B0aW9ucy52ZXJib3NlOgorICAgICAgICAgICAg d3JpdGUgPSBzZWxmLm1ldGVyLndyaXRlX3VwZGF0ZQorICAgICAgICBlbHNlOgorICAgICAgICAg ICAgd3JpdGUgPSBzZWxmLm1ldGVyLndyaXRlX3Rocm90dGxlZF91cGRhdGUKKworICAgICAgICB3 cml0ZShzZWxmLl90ZXN0X2xpbmUoc2VsZi5ydW5uaW5nX3Rlc3RzWzBdLCBzdWZmaXgpKQorCisg ICAgZGVmIHByaW50X2ZpbmlzaGVkX3Rlc3Qoc2VsZiwgc291cmNlLCB0ZXN0X25hbWUsIHRlc3Rf ZGlkX3Bhc3MsIHRlc3RfdGltZSwgZmFpbHVyZXMsIGVycm9ycyk6CisgICAgICAgIHdyaXRlID0g c2VsZi5tZXRlci53cml0ZWxuCisgICAgICAgIGlmIGZhaWx1cmVzOgorICAgICAgICAgICAgbGlu ZXMgPSBmYWlsdXJlc1swXS5zcGxpdGxpbmVzKCkgKyBbJyddCisgICAgICAgICAgICBzdWZmaXgg PSAnIGZhaWxlZDonCisgICAgICAgICAgICBzZWxmLm51bV9mYWlsdXJlcyArPSAxCisgICAgICAg IGVsaWYgZXJyb3JzOgorICAgICAgICAgICAgbGluZXMgPSBlcnJvcnNbMF0uc3BsaXRsaW5lcygp ICsgWycnXQorICAgICAgICAgICAgc3VmZml4ID0gJyBlcnJlZDonCisgICAgICAgICAgICBzZWxm Lm51bV9lcnJvcnMgKz0gMQorICAgICAgICBlbGlmIG5vdCB0ZXN0X2RpZF9wYXNzOgorICAgICAg ICAgICAgbGluZXMgPSBbXQorICAgICAgICAgICAgc3VmZml4ID0gJyBmYWlsZWQnCisgICAgICAg ICAgICBzZWxmLm51bV9mYWlsdXJlcyArPSAxCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBz dWZmaXggPSAnIHBhc3NlZCcKKyAgICAgICAgICAgIGxpbmVzID0gW10KKyAgICAgICAgICAgIGlm IHNlbGYub3B0aW9ucy52ZXJib3NlOgorICAgICAgICAgICAgICAgIHdyaXRlID0gc2VsZi5tZXRl ci53cml0ZWxuCisgICAgICAgICAgICBlbHNlOgorICAgICAgICAgICAgICAgIHdyaXRlID0gc2Vs Zi5tZXRlci53cml0ZV90aHJvdHRsZWRfdXBkYXRlCisgICAgICAgIGlmIHNlbGYub3B0aW9ucy50 aW1pbmc6CisgICAgICAgICAgICBzdWZmaXggKz0gJyAlLjRmcycgJSB0ZXN0X3RpbWUKKworICAg ICAgICBzZWxmLm51bV9zdGFydGVkICs9IDEKKworICAgICAgICBpZiB0ZXN0X25hbWUgPT0gc2Vs Zi5ydW5uaW5nX3Rlc3RzWzBdOgorICAgICAgICAgICAgc2VsZi5jb21wbGV0ZWRfdGVzdHMuaW5z ZXJ0KDAsIFt0ZXN0X25hbWUsIHN1ZmZpeCwgbGluZXNdKQorICAgICAgICBlbHNlOgorICAgICAg ICAgICAgc2VsZi5jb21wbGV0ZWRfdGVzdHMuYXBwZW5kKFt0ZXN0X25hbWUsIHN1ZmZpeCwgbGlu ZXNdKQorICAgICAgICBzZWxmLnJ1bm5pbmdfdGVzdHMucmVtb3ZlKHRlc3RfbmFtZSkKKworICAg ICAgICBmb3IgdGVzdF9uYW1lLCBtc2csIGxpbmVzIGluIHNlbGYuY29tcGxldGVkX3Rlc3RzOgor ICAgICAgICAgICAgaWYgbGluZXM6CisgICAgICAgICAgICAgICAgc2VsZi5tZXRlci53cml0ZWxu KHNlbGYuX3Rlc3RfbGluZSh0ZXN0X25hbWUsIG1zZykpCisgICAgICAgICAgICAgICAgZm9yIGxp bmUgaW4gbGluZXM6CisgICAgICAgICAgICAgICAgICAgIHNlbGYubWV0ZXIud3JpdGVsbignICAn ICsgbGluZSkKKyAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgd3JpdGUoc2VsZi5f dGVzdF9saW5lKHRlc3RfbmFtZSwgbXNnKSkKKyAgICAgICAgc2VsZi5jb21wbGV0ZWRfdGVzdHMg PSBbXQorCisgICAgZGVmIF90ZXN0X2xpbmUoc2VsZiwgdGVzdF9uYW1lLCBzdWZmaXgpOgorICAg ICAgICBmb3JtYXRfc3RyaW5nID0gJ1slZC8lZF0gJXMlcycKKyAgICAgICAgc3RhdHVzX2xpbmUg PSBmb3JtYXRfc3RyaW5nICUgKHNlbGYubnVtX3N0YXJ0ZWQsIHNlbGYubnVtX3Rlc3RzLCB0ZXN0 X25hbWUsIHN1ZmZpeCkKKyAgICAgICAgaWYgbGVuKHN0YXR1c19saW5lKSA+IHNlbGYubWV0ZXIu bnVtYmVyX29mX2NvbHVtbnMoKToKKyAgICAgICAgICAgIG92ZXJmbG93X2NvbHVtbnMgPSBsZW4o c3RhdHVzX2xpbmUpIC0gc2VsZi5tZXRlci5udW1iZXJfb2ZfY29sdW1ucygpCisgICAgICAgICAg ICBlbGxpcHNpcyA9ICcuLi4nCisgICAgICAgICAgICBpZiBsZW4odGVzdF9uYW1lKSA8IG92ZXJm bG93X2NvbHVtbnMgKyBsZW4oZWxsaXBzaXMpICsgMzoKKyAgICAgICAgICAgICAgICAjIFdlIGRv bid0IGhhdmUgZW5vdWdoIHNwYWNlIGV2ZW4gaWYgd2UgZWxpZGUsIGp1c3Qgc2hvdyB0aGUgdGVz dCBtZXRob2QgbmFtZS4KKyAgICAgICAgICAgICAgICB0ZXN0X25hbWUgPSB0ZXN0X25hbWUuc3Bs aXQoJy4nKVstMV0KKyAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgbmV3X2xlbmd0 aCA9IGxlbih0ZXN0X25hbWUpIC0gb3ZlcmZsb3dfY29sdW1ucyAtIGxlbihlbGxpcHNpcykKKyAg ICAgICAgICAgICAgICBwcmVmaXggPSBpbnQobmV3X2xlbmd0aCAvIDIpCisgICAgICAgICAgICAg ICAgdGVzdF9uYW1lID0gdGVzdF9uYW1lWzpwcmVmaXhdICsgZWxsaXBzaXMgKyB0ZXN0X25hbWVb LShuZXdfbGVuZ3RoIC0gcHJlZml4KTpdCisgICAgICAgIHJldHVybiBmb3JtYXRfc3RyaW5nICUg KHNlbGYubnVtX3N0YXJ0ZWQsIHNlbGYubnVtX3Rlc3RzLCB0ZXN0X25hbWUsIHN1ZmZpeCkKKwor ICAgIGRlZiBwcmludF9yZXN1bHQoc2VsZiwgcnVuX3RpbWUpOgorICAgICAgICB3cml0ZSA9IHNl bGYubWV0ZXIud3JpdGVsbgorICAgICAgICB3cml0ZSgnUmFuICVzIGluICUuM2ZzJyAlIChwbHVy YWxpemUoc2VsZi5udW1fc3RhcnRlZCwgInRlc3QiKSwgcnVuX3RpbWUpKQorICAgICAgICBpZiBz ZWxmLm51bV9mYWlsdXJlcyBvciBzZWxmLm51bV9lcnJvcnM6CisgICAgICAgICAgICB3cml0ZSgn RkFJTEVEIChmYWlsdXJlcz0lZCwgZXJyb3JzPSVkKVxuJyAlIChzZWxmLm51bV9mYWlsdXJlcywg c2VsZi5udW1fZXJyb3JzKSkKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIHdyaXRlKCdcbk9L XG4nKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3ByaW50ZXJzL2pz b25fcHJpbnRlci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9qc29u X3ByaW50ZXIucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjZjZjBhYgot LS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9wcmludGVycy9q c29uX3ByaW50ZXIucHkKQEAgLTAsMCArMSw3NiBAQAorIyBDb3B5cmlnaHQgKEMpIDIwMTIgR29v Z2xlLCBJbmMuCisjIENvcHlyaWdodCAoQykgMjAxMCBDaHJpcyBKZXJkb25layAoY2plcmRvbmVr QHdlYmtpdC5vcmcpCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyMgYXJlIG1ldDoKKyMg MS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorIyAgICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQor IyAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQKKyMgQU5ZIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhF IElNUExJRUQKKyMgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorIyBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFM TCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUgorIyBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFV RU5USUFMCisjIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SCisjIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSCisjIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksCisjIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisK K2ltcG9ydCBTdHJpbmdJTworaW1wb3J0IGxvZ2dpbmcKK2ltcG9ydCBqc29uCisKK2Zyb20gd2Vi a2l0cHkuY29tbW9uLnN5c3RlbS5zeXN0ZW1ob3N0IGltcG9ydCBTeXN0ZW1Ib3N0Citmcm9tIHdl YmtpdHB5LnRlc3QucHJpbnRlcnMuYWJzdHJhY3RfcHJpbnRlciBpbXBvcnQgQWJzdHJhY3RQcmlu dGVyCisKK19sb2cgPSBsb2dnaW5nLmdldExvZ2dlcihfX25hbWVfXykKKworCitjbGFzcyBKU09O UHJpbnRlcihBYnN0cmFjdFByaW50ZXIpOgorICAgIGRlZiBfX2luaXRfXyhzZWxmLCBzdHJlYW0s IG9wdGlvbnM9Tm9uZSk6CisgICAgICAgIHNlbGYuX2ZpcnN0X3Rlc3RfZmxhZyA9IFRydWUKKyAg ICAgICAgc2VsZi5fbnVtYmVyX29mX3Rlc3RzX3J1biA9IDAKKyAgICAgICAgc3VwZXIoSlNPTlBy aW50ZXIsIHNlbGYpLl9faW5pdF9fKHN0cmVhbSwgb3B0aW9ucykKKworICAgIGRlZiBjb25maWd1 cmUoc2VsZiwgb3B0aW9ucyk6CisgICAgICAgIHN1cGVyKEpTT05QcmludGVyLCBzZWxmKS5jb25m aWd1cmUob3B0aW9ucykKKworICAgICAgICB0ZXN0aW5nX2ZpbHRlciA9IGxvZ2dpbmcuRmlsdGVy KCkKKyAgICAgICAgdGVzdGluZ19maWx0ZXIuZmlsdGVyID0gbGFtYmRhIHJlY29yZDogRmFsc2UK KworICAgICAgICAjU3F1ZWxjaCBsb2dnaW5nIGFsdG9nZXRoZXIgc29hcyBub3QgdG8gaW50ZXJy dXB0IHRoZSBqc29uIG91dHB1dAorICAgICAgICBzZWxmLmhhbmRsZXIuYWRkRmlsdGVyKHRlc3Rp bmdfZmlsdGVyKQorCisgICAgZGVmIHByaW50X3N0YXJ0ZWRfdGVzdF9zdWl0ZShzZWxmLCB0ZXN0 X3N1aXRlX25hbWUpOgorICAgICAgICBzZWxmLnN0cmVhbS53cml0ZSgieyIpCisgICAgICAgIHNl bGYuc3RyZWFtLndyaXRlKCJcInN1aXRlX25hbWVcIiA6IFwiJXNcIixcbiIgJSB0ZXN0X3N1aXRl X25hbWUpCisgICAgICAgIHNlbGYuc3RyZWFtLndyaXRlKCJcImxpc3Rfb2ZfdGVzdHNcIiA6IFtc biIpCisKKyAgICBkZWYgd3JpdGVfdXBkYXRlKHNlbGYsIG1zZyk6CisgICAgICAgIHBhc3MKKwor ICAgIGRlZiBwcmludF9zdGFydGVkX3Rlc3Qoc2VsZiwgc291cmNlLCB0ZXN0X25hbWUpOgorICAg ICAgICBwYXNzCisKKyAgICBkZWYgcHJpbnRfZmluaXNoZWRfdGVzdChzZWxmLCBzb3VyY2UsIHRl c3RfbmFtZSwgdGVzdF9kaWRfcGFzcywgdGVzdF90aW1lLCBmYWlsdXJlcywgZXJyb3JzKToKKyAg ICAgICAgc2VsZi5fbnVtYmVyX29mX3Rlc3RzX3J1biArPSAxCisgICAgICAgIGlmIG5vdCBzZWxm Ll9maXJzdF90ZXN0X2ZsYWc6CisgICAgICAgICAgICBzZWxmLnN0cmVhbS53cml0ZSgiLFxuIikK KworICAgICAgICB0ZXN0X2RpY3QgPSB7fQorICAgICAgICB0ZXN0X2RpY3RbInRlc3RfbmFtZSJd ID0gdGVzdF9uYW1lCisgICAgICAgIHRlc3RfZGljdFsidGVzdF9kaWRfcGFzcyJdID0gdGVzdF9k aWRfcGFzcworICAgICAgICB0ZXN0X2RpY3RbImZhaWx1cmVzIl0gPSBmYWlsdXJlcworICAgICAg ICB0ZXN0X2RpY3RbImVycm9ycyJdID0gZXJyb3JzCisKKyAgICAgICAgc2VsZi5zdHJlYW0ud3Jp dGUoanNvbi5kdW1wcyh0ZXN0X2RpY3QpKQorCisgICAgICAgIHNlbGYuX2ZpcnN0X3Rlc3RfZmxh ZyA9IEZhbHNlCisKKyAgICBkZWYgcHJpbnRfcmVzdWx0KHNlbGYsIHJ1bl90aW1lKToKKyAgICAg ICAgc2VsZi5zdHJlYW0ud3JpdGUoIl0sXG5cInRlc3RfcnVuX3RpbWVcIiA6ICVzLFxuXCJudW1i ZXJfb2ZfdGVzdHNfcnVuXCIgOiAlc30iICUgKHJ1bl90aW1lLCBzZWxmLl9udW1iZXJfb2ZfdGVz dHNfcnVuKSkKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIu cHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyLnB5CmluZGV4IGQzZjU3NjQu LjJjMDQyZmEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIu cHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lci5weQpAQCAtNjIsNyAr NjIsNyBAQCBjbGFzcyBSdW5uZXIob2JqZWN0KToKICAgICAgICAgICAgIHNlbGYuZmFpbHVyZXMu YXBwZW5kKCh0ZXN0X25hbWUsIGZhaWx1cmVzKSkKICAgICAgICAgaWYgZXJyb3JzOgogICAgICAg ICAgICAgc2VsZi5lcnJvcnMuYXBwZW5kKCh0ZXN0X25hbWUsIGVycm9ycykpCi0gICAgICAgIHNl bGYucHJpbnRlci5wcmludF9maW5pc2hlZF90ZXN0KHNvdXJjZSwgdGVzdF9uYW1lLCBkZWxheSwg ZmFpbHVyZXMsIGVycm9ycykKKyAgICAgICAgc2VsZi5wcmludGVyLnByaW50X2ZpbmlzaGVkX3Rl c3Qoc291cmNlLCB0ZXN0X25hbWUsIG5vdCBib29sKGZhaWx1cmVzICsgZXJyb3JzKSwgZGVsYXks IGZhaWx1cmVzLCBlcnJvcnMpCiAKIAogY2xhc3MgX1dvcmtlcihvYmplY3QpOgpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lcl91bml0dGVzdC5weSBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXJfdW5pdHRlc3QucHkKaW5kZXggOTk1MDcwYi4u ODA1OTQ4NSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lcl91 bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0 ZXN0LnB5CkBAIC0yNiw3ICsyNiw3IEBAIGltcG9ydCByZQogaW1wb3J0IHVuaXR0ZXN0CiAKIGZy b20gd2Via2l0cHkudG9vbC5tb2NrdG9vbCBpbXBvcnQgTW9ja09wdGlvbnMKLWZyb20gd2Via2l0 cHkudGVzdC5wcmludGVyIGltcG9ydCBQcmludGVyCitmcm9tIHdlYmtpdHB5LnRlc3QucHJpbnRl cnMuaHVtYW5fcmVhZGFibGVfcHJpbnRlciBpbXBvcnQgSHVtYW5SZWFkYWJsZVByaW50ZXIKIGZy b20gd2Via2l0cHkudGVzdC5ydW5uZXIgaW1wb3J0IFJ1bm5lcgogCiAKQEAgLTkwLDcgKzkwLDcg QEAgY2xhc3MgUnVubmVyVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgIGxvYWRlciA9 IEZha2VMb2FkZXIoKCd0ZXN0MSAoRm9vKScsICcuJywgJycpLAogICAgICAgICAgICAgICAgICAg ICAgICAgICAgICgndGVzdDIgKEZvbyknLCAnRicsICd0ZXN0MlxuZmFpbGVkJyksCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgKCd0ZXN0MyAoRm9vKScsICdFJywgJ3Rlc3QzXG5lcnJlZCcp KQotICAgICAgICBydW5uZXIgPSBSdW5uZXIoUHJpbnRlcihzdHJlYW0sIG9wdGlvbnMpLCBsb2Fk ZXIpCisgICAgICAgIHJ1bm5lciA9IFJ1bm5lcihIdW1hblJlYWRhYmxlUHJpbnRlcihzdHJlYW0s IG9wdGlvbnMpLCBsb2FkZXIpCiAgICAgICAgIHJ1bm5lci5ydW4oWydGb28udGVzdDEnLCAnRm9v LnRlc3QyJywgJ0Zvby50ZXN0MyddLCAxKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHJ1bm5l ci50ZXN0c19ydW4sIDMpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci5mYWls dXJlcyksIDEpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFu ZHMvZG93bmxvYWRfdW5pdHRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29t bWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHkKaW5kZXggNTliNTJlYS4uZjNhMTk4YiAxMDA2NDQK LS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0 ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9h ZF91bml0dGVzdC5weQpAQCAtMjksNiArMjksNyBAQAogaW1wb3J0IHVuaXR0ZXN0CiAKIGZyb20g d2Via2l0cHkuY29tbW9uLnN5c3RlbS5vdXRwdXRjYXB0dXJlIGltcG9ydCBPdXRwdXRDYXB0dXJl Citmcm9tIHdlYmtpdHB5LmNvbW1vbi5jb25maWcucG9ydHNfbW9jayBpbXBvcnQgTW9ja1BvcnQK IGZyb20gd2Via2l0cHkudGhpcmRwYXJ0eS5tb2NrIGltcG9ydCBNb2NrCiBmcm9tIHdlYmtpdHB5 LnRvb2wuY29tbWFuZHMuY29tbWFuZHRlc3QgaW1wb3J0IENvbW1hbmRzVGVzdAogZnJvbSB3ZWJr aXRweS50b29sLmNvbW1hbmRzLmRvd25sb2FkIGltcG9ydCAqCkBAIC0zNiw2ICszNywxNSBAQCBm cm9tIHdlYmtpdHB5LnRvb2wubW9ja3Rvb2wgaW1wb3J0IE1vY2tPcHRpb25zLCBNb2NrVG9vbAog ZnJvbSB3ZWJraXRweS5jb21tb24uY2hlY2tvdXQuY2hlY2tvdXRfbW9jayBpbXBvcnQgTW9ja0No ZWNrb3V0CiAKIAorY2xhc3MgTW9ja1BvcnRGYWN0b3J5KG9iamVjdCk6CisgICAgZGVmIF9faW5p dF9fKHNlbGYpOgorICAgICAgICBzZWxmLm1vY2tfcG9ydCA9IE1vY2tQb3J0KCkKKworICAgIGRl ZiBnZXQoc2VsZik6CisgICAgICAgIHJldHVybiBzZWxmLm1vY2tfcG9ydAorCisKKwogY2xhc3Mg QWJzdHJhY3RSb2xsb3V0UHJlcENvbW1hbmRUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICBk ZWYgdGVzdF9jb21taXRfaW5mbyhzZWxmKToKICAgICAgICAgY29tbWFuZCA9IEFic3RyYWN0Um9s bG91dFByZXBDb21tYW5kKCkKQEAgLTE2NCw3ICsxNzQsNyBAQCBXYXMgdGhhdCBkaWZmIGNvcnJl Y3Q/CiBCdWlsZGluZyBXZWJLaXQKIE1PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ21vY2st YnVpbGQtd2Via2l0J10sIGN3ZD0vbW9jay1jaGVja291dCwgZW52PXsnTENfQUxMJzogJ0MnLCAn VEVSTSc6ICdub25lJywgJ01PQ0tfRU5WSVJPTl9DT1BZJzogJzEnfQogUnVubmluZyBQeXRob24g dW5pdCB0ZXN0cwotTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnbW9jay10ZXN0LXdlYmtp dHB5J10sIGN3ZD0vbW9jay1jaGVja291dAorTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsn bW9jay10ZXN0LXdlYmtpdHB5JywgJy0tanNvbiddLCBjd2Q9L21vY2stY2hlY2tvdXQKIFJ1bm5p bmcgUGVybCB1bml0IHRlc3RzCiBNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLXRl c3Qtd2Via2l0cGVybCddLCBjd2Q9L21vY2stY2hlY2tvdXQKIFJ1bm5pbmcgSmF2YVNjcmlwdENv cmUgdGVzdHMKQEAgLTE4MCw2ICsxOTAsNyBAQCBDb21taXR0ZWQgcjQ5ODI0OiA8aHR0cDovL3Ry YWMud2Via2l0Lm9yZy9jaGFuZ2VzZXQvNDk4MjQ+CiBObyBidWcgaWQgcHJvdmlkZWQuCiAiIiIK ICAgICAgICAgbW9ja190b29sID0gTW9ja1Rvb2wobG9nX2V4ZWN1dGl2ZT1UcnVlKQorICAgICAg ICBtb2NrX3Rvb2wucG9ydF9mYWN0b3J5ID0gTW9ja1BvcnRGYWN0b3J5KCkKICAgICAgICAgc2Vs Zi5hc3NlcnRfZXhlY3V0ZV9vdXRwdXRzKExhbmRDb3doYW5kKCksIFs1MDAwMF0sIG9wdGlvbnM9 c2VsZi5fZGVmYXVsdF9vcHRpb25zKCksIGV4cGVjdGVkX2xvZ3M9ZXhwZWN0ZWRfbG9ncywgdG9v bD1tb2NrX3Rvb2wpCiAKICAgICAgICAgZXhwZWN0ZWRfbG9ncyA9ICJsYW5kLWNvd2JveSBpcyBk ZXByZWNhdGVkLCB1c2UgbGFuZC1jb3doYW5kIGluc3RlYWQuXG4iICsgZXhwZWN0ZWRfbG9ncwpk aWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5 IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5CmluZGV4IGE0 NTYyOGIuLjRhYzI2ZWIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9z dGVwcy9ydW50ZXN0cy5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMv cnVudGVzdHMucHkKQEAgLTMwLDYgKzMwLDcgQEAgaW1wb3J0IGxvZ2dpbmcKIGltcG9ydCBvcwog aW1wb3J0IHBsYXRmb3JtCiBpbXBvcnQgc3lzCisKIGZyb20gd2Via2l0cHkudG9vbC5zdGVwcy5h YnN0cmFjdHN0ZXAgaW1wb3J0IEFic3RyYWN0U3RlcAogZnJvbSB3ZWJraXRweS50b29sLnN0ZXBz Lm9wdGlvbnMgaW1wb3J0IE9wdGlvbnMKIGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5leGVj dXRpdmUgaW1wb3J0IFNjcmlwdEVycm9yCkBAIC01NCwxMiArNTUsMjAgQEAgY2xhc3MgUnVuVGVz dHMoQWJzdHJhY3RTdGVwKToKICAgICAgICAgICAgIHJldHVybgogCiAgICAgICAgIGlmIG5vdCBz ZWxmLl9vcHRpb25zLm5vbl9pbnRlcmFjdGl2ZToKKyAgICAgICAgICAgIGZpbGVzeXN0ZW0gPSBz ZWxmLl90b29sLmZpbGVzeXN0ZW0KKworICAgICAgICAgICAgcHl0aG9uX3VuaXR0ZXN0X3Jlc3Vs dHNfZGlyZWN0b3J5ID0gc2VsZi5fdG9vbC5wb3J0X2ZhY3RvcnkuZ2V0KCkucHl0aG9uX3VuaXR0 ZXN0X3Jlc3VsdHNfZGlyZWN0b3J5KCkKKyAgICAgICAgICAgIGZpbGVzeXN0ZW0ubWF5YmVfbWFr ZV9kaXJlY3RvcnkocHl0aG9uX3VuaXR0ZXN0X3Jlc3VsdHNfZGlyZWN0b3J5KQorCiAgICAgICAg ICAgICAjIEZJWE1FOiBXZSBzaG91bGQgdGVhY2ggdGhlIGNvbW1pdC1xdWV1ZSBhbmQgdGhlIEVX UyBob3cgdG8gcnVuIHRoZXNlIHRlc3RzLgogCiAgICAgICAgICAgICBweXRob25fdW5pdHRlc3Rz X2NvbW1hbmQgPSBzZWxmLl90b29sLmRlcHJlY2F0ZWRfcG9ydCgpLnJ1bl9weXRob25fdW5pdHRl c3RzX2NvbW1hbmQoKQorICAgICAgICAgICAgcHl0aG9uX3VuaXR0ZXN0c19jb21tYW5kLmV4dGVu ZChbJy0tanNvbiddKQorCiAgICAgICAgICAgICBpZiBweXRob25fdW5pdHRlc3RzX2NvbW1hbmQ6 CiAgICAgICAgICAgICAgICAgX2xvZy5pbmZvKCJSdW5uaW5nIFB5dGhvbiB1bml0IHRlc3RzIikK LSAgICAgICAgICAgICAgICBzZWxmLl90b29sLmV4ZWN1dGl2ZS5ydW5fYW5kX3Rocm93X2lmX2Zh aWwocHl0aG9uX3VuaXR0ZXN0c19jb21tYW5kLCBjd2Q9c2VsZi5fdG9vbC5zY20oKS5jaGVja291 dF9yb290KQorICAgICAgICAgICAgICAgIG91dHB1dCA9IHNlbGYuX3Rvb2wuZXhlY3V0aXZlLnJ1 bl9hbmRfdGhyb3dfaWZfZmFpbChweXRob25fdW5pdHRlc3RzX2NvbW1hbmQsIHF1aWV0PVRydWUs IGN3ZD1zZWxmLl90b29sLnNjbSgpLmNoZWNrb3V0X3Jvb3QpCisgICAgICAgICAgICAgICAgZmls ZXN5c3RlbS53cml0ZV90ZXh0X2ZpbGUoZmlsZXN5c3RlbS5qb2luKHB5dGhvbl91bml0dGVzdF9y ZXN1bHRzX2RpcmVjdG9yeSwgInJlc3VsdHMuanNvbiIpLCBvdXRwdXQpCiAKICAgICAgICAgICAg IHBlcmxfdW5pdHRlc3RzX2NvbW1hbmQgPSBzZWxmLl90b29sLmRlcHJlY2F0ZWRfcG9ydCgpLnJ1 bl9wZXJsX3VuaXR0ZXN0c19jb21tYW5kKCkKICAgICAgICAgICAgIGlmIHBlcmxfdW5pdHRlc3Rz X2NvbW1hbmQ6CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMv c3RlcHNfdW5pdHRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3Rl cHNfdW5pdHRlc3QucHkKaW5kZXggYjFlMmJmMS4uYTg2NTUwZCAxMDA2NDQKLS0tIGEvVG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weQpAQCAtMzEsNiAr MzEsNyBAQCBpbXBvcnQgdW5pdHRlc3QKIGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5vdXRw dXRjYXB0dXJlIGltcG9ydCBPdXRwdXRDYXB0dXJlCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5jb25m aWcucG9ydHMgaW1wb3J0IERlcHJlY2F0ZWRQb3J0CiBmcm9tIHdlYmtpdHB5LnRvb2wubW9ja3Rv b2wgaW1wb3J0IE1vY2tPcHRpb25zLCBNb2NrVG9vbAorZnJvbSB3ZWJraXRweS5jb21tb24uY29u ZmlnLnBvcnRzX21vY2sgaW1wb3J0IE1vY2tQb3J0LCBNb2NrUG9ydEZhY3RvcnkKIAogZnJvbSB3 ZWJraXRweS50b29sIGltcG9ydCBzdGVwcwogCkBAIC05OCwxMyArOTksMTUgQEAgY2xhc3MgU3Rl cHNUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICBkZWYgdGVzdF9ydW50ZXN0c19hcmdzKHNl bGYpOgogICAgICAgICBtb2NrX29wdGlvbnMgPSBzZWxmLl9zdGVwX29wdGlvbnMoKQogICAgICAg ICBtb2NrX29wdGlvbnMubm9uX2ludGVyYWN0aXZlID0gRmFsc2UKLSAgICAgICAgc3RlcCA9IHN0 ZXBzLlJ1blRlc3RzKE1vY2tUb29sKGxvZ19leGVjdXRpdmU9VHJ1ZSksIG1vY2tfb3B0aW9ucykK KwogICAgICAgICB0b29sID0gTW9ja1Rvb2wobG9nX2V4ZWN1dGl2ZT1UcnVlKQogICAgICAgICAj IEZJWE1FOiBXZSBzaG91bGRuJ3QgdXNlIGEgcmVhbCBwb3J0LW9iamVjdCBoZXJlLCBidXQgdGhl cmUgaXMgdG9vIG11Y2ggdG8gbW9jayBhdCB0aGUgbW9tZW50LgorICAgICAgICB0b29sLnBvcnRf ZmFjdG9yeSA9IE1vY2tQb3J0RmFjdG9yeSgpCiAgICAgICAgIHRvb2wuX2RlcHJlY2F0ZWRfcG9y dCA9IERlcHJlY2F0ZWRQb3J0KCkKKwogICAgICAgICBzdGVwID0gc3RlcHMuUnVuVGVzdHModG9v bCwgbW9ja19vcHRpb25zKQogICAgICAgICBleHBlY3RlZF9sb2dzID0gIiIiUnVubmluZyBQeXRo b24gdW5pdCB0ZXN0cwotTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnVG9vbHMvU2NyaXB0 cy90ZXN0LXdlYmtpdHB5J10sIGN3ZD0vbW9jay1jaGVja291dAorTU9DSyBydW5fYW5kX3Rocm93 X2lmX2ZhaWw6IFsnVG9vbHMvU2NyaXB0cy90ZXN0LXdlYmtpdHB5JywgJy0tanNvbiddLCBjd2Q9 L21vY2stY2hlY2tvdXQKIFJ1bm5pbmcgUGVybCB1bml0IHRlc3RzCiBNT0NLIHJ1bl9hbmRfdGhy b3dfaWZfZmFpbDogWydUb29scy9TY3JpcHRzL3Rlc3Qtd2Via2l0cGVybCddLCBjd2Q9L21vY2st Y2hlY2tvdXQKIFJ1bm5pbmcgSmF2YVNjcmlwdENvcmUgdGVzdHMKLS0gCjEuOS4zIChBcHBsZSBH aXQtNTApCgo= 239739 2014-10-13 12:58:46 -0700 2014-10-13 16:46:52 -0700 Changes to use the _print_results_as_json method, as discussed in person. 0001-Add-json-flag-to-test-webkitpy-to-emit-JSON-formatte.patch text/plain 4945 jake.nielsen.webkit RnJvbSBhMTRkNzdhMTAzNjNjYTZjZDdkM2U1NDc3YzlhZTE0MThlOTY0NmQ4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBNb24sIDEzIE9jdCAyMDE0IDEyOjU3OjM5IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0g QWRkIC0tanNvbiBmbGFnIHRvIHRlc3Qtd2Via2l0cHkgdG8gZW1pdCBKU09OIGZvcm1hdHRlZCB0 ZXN0CiByZXN1bHRzIG9uIHN0ZG91dCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTM3MzUzCgpSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiogU2NyaXB0cy93ZWJr aXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5OgpBZGRzIHRoZSByZWFkIG1ldGhv ZCB0byBNb2NrRmlsZSB0byBhbGxvdyB0aGUgc3Rkb3V0IG9mIHRlc3Rfd2Via2l0cHkKdG8gYmUg cmVkaXJlY3RlZCB3aXRob3V0IGNhdXNpbmcgZXJyb25lb3VzIHRlc3QgZmFpbHVyZXMuCihNb2Nr RmlsZS5yZWFkKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5weToKQWRkcyB0aGUgX3By aW50X3Jlc3VsdHNfYXNfanNvbiBtZXRob2QgYW5kIHRoZSAtLWpzb24gZmxhZyB3aGljaApkZXRl cm1pbmVzIHdoZXRoZXIgX3ByaW50X3Jlc3VsdHNfYXNfanNvbiB3aWxsIGdldCBjYWxsZWQuCihU ZXN0ZXIuX3BhcnNlX2FyZ3MpOgooVGVzdGVyLl9wcmludF9yZXN1bHRzX2FzX2pzb24pOgooVGVz dGVyLl9wcmludF9yZXN1bHRzX2FzX2pzb24ucmVzdWx0X2RpY3RfZnJvbV90dXBsZSk6CihUZXN0 ZXIuX3J1bl90ZXN0cyk6Ci0tLQogVG9vbHMvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8IDIwICsrKysrKysrKysrKysrKysrKysrCiAuLi4vU2NyaXB0cy93 ZWJraXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5IHwgIDQgKysrKwogVG9vbHMv U2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHkgICAgICAgICAgICAgICAgICB8IDE5ICsrKysr KysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNDMgaW5zZXJ0aW9ucygrKQoKZGlmZiAt LWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCBlYjI0OWE1Li43 NjU0YWNjIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMjMgQEAKKzIwMTQtMTAtMTMgIEpha2UgTmllbHNlbiAgPGphY29iX25pZWxz ZW5AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCAtLWpzb24gZmxhZyB0byB0ZXN0LXdlYmtpdHB5 IHRvIGVtaXQgSlNPTiBmb3JtYXR0ZWQgdGVzdCByZXN1bHRzCisgICAgICAgIG9uIHN0ZG91dAor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM3MzUzCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHk6CisgICAgICAgIEFkZHMg dGhlIHJlYWQgbWV0aG9kIHRvIE1vY2tGaWxlIHRvIGFsbG93IHRoZSBzdGRvdXQgb2YgdGVzdF93 ZWJraXRweQorICAgICAgICB0byBiZSByZWRpcmVjdGVkIHdpdGhvdXQgY2F1c2luZyBlcnJvbmVv dXMgdGVzdCBmYWlsdXJlcy4KKyAgICAgICAgKE1vY2tGaWxlLnJlYWQpOgorICAgICAgICAqIFNj cmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5OgorICAgICAgICBBZGRzIHRoZSBfcHJpbnRfcmVz dWx0c19hc19qc29uIG1ldGhvZCBhbmQgdGhlIC0tanNvbiBmbGFnIHdoaWNoCisgICAgICAgIGRl dGVybWluZXMgd2hldGhlciBfcHJpbnRfcmVzdWx0c19hc19qc29uIHdpbGwgZ2V0IGNhbGxlZC4K KyAgICAgICAgKFRlc3Rlci5fcGFyc2VfYXJncyk6CisgICAgICAgIChUZXN0ZXIuX3ByaW50X3Jl c3VsdHNfYXNfanNvbik6CisgICAgICAgIChUZXN0ZXIuX3ByaW50X3Jlc3VsdHNfYXNfanNvbi5y ZXN1bHRfZGljdF9mcm9tX3R1cGxlKToKKyAgICAgICAgKFRlc3Rlci5fcnVuX3Rlc3RzKToKKwog MjAxNC0xMC0xMyAgQ2FybG9zIEFsYmVydG8gTG9wZXogUGVyZXogIDxjbG9wZXpAaWdhbGlhLmNv bT4KIAogICAgICAgICBbWHZmYkRyaXZlcl0gUmVndWxhciBleHByZXNzaW9uIHVzZWQgdG8gbWF0 Y2ggcnVubmluZyBYIHNlcnZlcnMgZmFpbHMgb24gRmVkb3JhIDIxLgpkaWZmIC0tZ2l0IGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5IGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5CmluZGV4 IDZlMDAxOTkuLjdiMDUxMjYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9y dC9zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkKQEAgLTY2LDYgKzY2LDEwIEBAIGNsYXNz IE1vY2tGaWxlKG9iamVjdCk6CiAgICAgICAgIHNlbGYuX3NlcnZlcl9wcm9jZXNzLmJyb2tlbl9w aXBlcy5hcHBlbmQoc2VsZikKICAgICAgICAgcmFpc2UgSU9FcnJvcgogCisgICAgZGVmIHJlYWQo c2VsZiwgc2l6ZT0wKToKKyAgICAgICAgcmV0dXJuICcnCisgICAgICAgICMgVGhpcyBtZWFucyBF T0YKKwogICAgIGRlZiBjbG9zZShzZWxmKToKICAgICAgICAgc2VsZi5jbG9zZWQgPSBUcnVlCiAK ZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5IGIvVG9vbHMv U2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHkKaW5kZXggY2IwZWYxNS4uYTJmNmY0NGMgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CisrKyBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CkBAIC0zMiw2ICszMiw4IEBAIGltcG9ydCBz eXMKIGltcG9ydCB0aW1lCiBpbXBvcnQgdHJhY2ViYWNrCiBpbXBvcnQgdW5pdHRlc3QKK2ltcG9y dCBvcGVyYXRvcgoraW1wb3J0IGpzb24KIAogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmZp bGVzeXN0ZW0gaW1wb3J0IEZpbGVTeXN0ZW0KIGZyb20gd2Via2l0cHkudGVzdC5maW5kZXIgaW1w b3J0IEZpbmRlcgpAQCAtMTAyLDYgKzEwNCw4IEBAIGNsYXNzIFRlc3RlcihvYmplY3QpOgogICAg ICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdkaXNwbGF5IHBlci10ZXN0IGV4ZWN1dGlvbiB0 aW1lIChpbXBsaWVzIC0tdmVyYm9zZSknKQogICAgICAgICBwYXJzZXIuYWRkX29wdGlvbignLXYn LCAnLS12ZXJib3NlJywgYWN0aW9uPSdjb3VudCcsIGRlZmF1bHQ9MCwKICAgICAgICAgICAgICAg ICAgICAgICAgICAgaGVscD0ndmVyYm9zZSBvdXRwdXQgKHNwZWNpZnkgb25jZSBmb3IgaW5kaXZp ZHVhbCB0ZXN0IHJlc3VsdHMsIHR3aWNlIGZvciBkZWJ1ZyBtZXNzYWdlcyknKQorICAgICAgICBw YXJzZXIuYWRkX29wdGlvbignLS1qc29uJywgYWN0aW9uPSdzdG9yZV90cnVlJywgZGVmYXVsdD1G YWxzZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0nZW1pdCBKU09OIGZvcm1hdHRl ZCB0ZXN0IHJlc3VsdHMgb24gc3Rkb3V0JykKIAogICAgICAgICBwYXJzZXIuZXBpbG9nID0gKCdb YXJncy4uLl0gaXMgYW4gb3B0aW9uYWwgbGlzdCBvZiBtb2R1bGVzLCB0ZXN0X2NsYXNzZXMsIG9y IGluZGl2aWR1YWwgdGVzdHMuICcKICAgICAgICAgICAgICAgICAgICAgICAgICAnSWYgbm8gYXJn cyBhcmUgZ2l2ZW4sIGFsbCB0aGUgdGVzdHMgd2lsbCBiZSBydW4uJykKQEAgLTEyMSw2ICsxMjUs MTggQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAKICAgICAgICAgcmV0dXJuIHNlbGYuX3J1bl90 ZXN0cyhuYW1lcykKIAorICAgIGRlZiBfcHJpbnRfcmVzdWx0c19hc19qc29uKHNlbGYsIHN0cmVh bSwgdGVzdF9uYW1lcywgZmFpbHVyZXMsIGVycm9ycyk6CisgICAgICAgIGRlZiByZXN1bHRfZGlj dF9mcm9tX3R1cGxlKHJlc3VsdF90dXBsZSk6CisgICAgICAgICAgICByZXR1cm4geyduYW1lJzog cmVzdWx0X3R1cGxlWzBdLCAncmVzdWx0JzogcmVzdWx0X3R1cGxlWzFdfQorCisgICAgICAgIHJl c3VsdHMgPSB7fQorICAgICAgICByZXN1bHRzWydmYWlsdXJlcyddID0gbWFwKHJlc3VsdF9kaWN0 X2Zyb21fdHVwbGUsIHNvcnRlZChmYWlsdXJlcywga2V5PW9wZXJhdG9yLml0ZW1nZXR0ZXIoMCkp KQorICAgICAgICByZXN1bHRzWydlcnJvcnMnXSA9IG1hcChyZXN1bHRfZGljdF9mcm9tX3R1cGxl LCBzb3J0ZWQoZXJyb3JzLCBrZXk9b3BlcmF0b3IuaXRlbWdldHRlcigwKSkpCisgICAgICAgIHJl c3VsdHNbJ3Rlc3RzJ10gPSBzb3J0ZWQodGVzdF9uYW1lcykKKworICAgICAgICBzdHJlYW0ud3Jp dGUoanNvbi5kdW1wcyhyZXN1bHRzKSkKKworCiAgICAgZGVmIF9ydW5fdGVzdHMoc2VsZiwgbmFt ZXMpOgogICAgICAgICAjIE1ha2Ugc3VyZSBQWVRIT05QQVRIIGlzIHNldCB1cCBwcm9wZXJseS4K ICAgICAgICAgc3lzLnBhdGggPSBzZWxmLmZpbmRlci5hZGRpdGlvbmFsX3BhdGhzKHN5cy5wYXRo KSArIHN5cy5wYXRoCkBAIC0xNTYsNiArMTcyLDkgQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAK ICAgICAgICAgc2VsZi5wcmludGVyLnByaW50X3Jlc3VsdCh0aW1lLnRpbWUoKSAtIHN0YXJ0KQog CisgICAgICAgIGlmIHNlbGYuX29wdGlvbnMuanNvbjoKKyAgICAgICAgICAgIHNlbGYuX3ByaW50 X3Jlc3VsdHNfYXNfanNvbihzeXMuc3Rkb3V0LCBwYXJhbGxlbF90ZXN0cyArIHNlcmlhbF90ZXN0 cywgdGVzdF9ydW5uZXIuZmFpbHVyZXMsIHRlc3RfcnVubmVyLmVycm9ycykKKwogICAgICAgICBp ZiBzZWxmLl9vcHRpb25zLmNvdmVyYWdlOgogICAgICAgICAgICAgY292LnN0b3AoKQogICAgICAg ICAgICAgY292LnNhdmUoKQotLSAKMS45LjMgKEFwcGxlIEdpdC01MCkKCg== 239759 2014-10-13 16:46:52 -0700 2014-10-13 16:50:38 -0700 Fixes as per comments. 0001-Make-test-webkitpy-generate-a-json-file-of-its-resul.patch text/plain 19011 jake.nielsen.webkit RnJvbSAyODFkMWU3OTM4NTJhMzYxODEwNzA2NjlmNmY1Y2U4ZjU4MDhjMjIyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBUaHUsIDIgT2N0IDIwMTQgMTg6Mzc6NTMgLTA3MDAKU3ViamVjdDogW1BBVENIXSBN YWtlIHRlc3Qtd2Via2l0cHkgZ2VuZXJhdGUgYSBqc29uIGZpbGUgb2YgaXRzIHJlc3VsdHMKIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzczNTMKClJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgoKKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi93ZWJraXRfZmluZGVy LnB5OgpBZGRzIGEgbWV0aG9kIHRvIG1ha2UgaXQgZWFzaWVyIHRvIGZpbmQgdGhlIHdlYmtpdCBy ZXN1bHRzIGRpcmVjdG9yeS4KKFdlYktpdEZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIpOgoqIFNj cmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5OgpBZGRzIHRoZSAtLXJlc3VsdHMtZGlyIG9wdGlv biwgYW5kIGFkZHMgbG9naWMgdG8gZHVtcCBhIGpzb24gZmlsZSBvZgp0aGUgcmVzdWx0cyBpZiAt LXJlc3VsdHMtZGlyIGhhcyBiZWVuIHNwZWNpZmllZC4KKFRlc3Rlci5fX2luaXRfXyk6CihUZXN0 ZXIuX3BhcnNlX2FyZ3MpOgooVGVzdGVyLl9ydW5fdGVzdHMpOgoqIFNjcmlwdHMvd2Via2l0cHkv dGVzdC9yZXN1bHRzLnB5OiBBZGRlZC4KUHJvdmlkZXMgYSBjbGFzcyB0byBlbmNhcHN1bGF0ZSB0 ZXN0IHJlc3VsdHMsIGFuZCB0byBhZGQgaXNvbGF0aW9uCmJldHdlZW4gdGhlIGpzb24gZmlsZSBh bmQgdGhlIHJlc3Qgb2Ygd2Via2l0cHkuCihUZXN0UmVzdWx0KToKKFRlc3RSZXN1bHQudGVzdF9y ZXN1bHRfZnJvbV9qc29uX2RpY3QpOgooVGVzdFJlc3VsdC50ZXN0X3Jlc3VsdF90b19qc29uX2Rp Y3QpOgooVGVzdFJlc3VsdC5fX2luaXRfXyk6CihUZXN0UmVzdWx0LnRlc3RfbmFtZSk6CihUZXN0 UmVzdWx0LmZhaWx1cmVzKToKKFRlc3RSZXN1bHQuZXJyb3JzKToKKFRlc3RSZXN1bHRzKToKKFRl c3RSZXN1bHRzLnRlc3RfcmVzdWx0c19mcm9tX2pzb25fZGljdCk6CihUZXN0UmVzdWx0cy50ZXN0 X3Jlc3VsdHNfdG9fanNvbl9kaWN0KToKKFRlc3RSZXN1bHRzLl9faW5pdF9fKToKKFRlc3RSZXN1 bHRzLmFkZF90ZXN0X3Jlc3VsdCk6CihUZXN0UmVzdWx0cy5saXN0X29mX3Rlc3RfcmVzdWx0cyk6 CihUZXN0UmVzdWx0cy5saXN0X29mX2ZhaWxlZF90ZXN0X3Jlc3VsdHMpOgooVGVzdFJlc3VsdHMu bGlzdF9vZl9lcnJvcmVkX3Rlc3RfcmVzdWx0cyk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1 bm5lci5weToKVGVhY2hlcyBydW5uZXIucHkgdG8gdXNlIFRlc3RSZXN1bHQgb2JqZWN0cyBpbnN0 ZWFkIG9mIGp1c3Qgc3R1ZmZpbmcKZXZlcnl0aGluZyBpbnRvIHR1cGxlcyBhbmQgbGlzdHMuCihS dW5uZXIuX19pbml0X18pOgooUnVubmVyLmhhbmRsZSk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0 L3J1bm5lcl91bml0dGVzdC5weToKVGVhY2hlcyB0ZXN0X3J1biBob3cgdG8gdXNlIFRlc3RSZXN1 bHRzIG9iamVjdHMuCihSdW5uZXJUZXN0LnRlc3RfcnVuKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rv b2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHk6ClVwZGF0ZXMgdGhlIHRlc3RfbGFuZF9j b3doYW5kIHRlc3QgdG8gcHJvcGVybHkgYW50aWNpcGF0ZSB3aGF0IFJ1blRlc3QKc2hvdWxkIGJl IHN0ZG91dGluZy4KKHRlc3RfbGFuZF9jb3doYW5kKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wv c3RlcHMvcnVudGVzdHMucHk6ClRlYWNoZXMgUnVuVGVzdHMgdG8gcGFzcyBhIC0tcmVzdWx0cy1k aXIgdG8gdGVzdC13ZWJraXRweS4KKFJ1blRlc3RzLnJ1bik6CiogU2NyaXB0cy93ZWJraXRweS90 b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5OgpVcGRhdGVzIHRoZSB0ZXN0X3J1bnRlc3RzX2Fy Z3MgdGVzdCB0byBwcm9wZXJseSBhbnRpY2lwYXRlIHdoYXQgUnVuVGVzdApzaG91bGQgYmUgc3Rk b3V0aW5nLgooU3RlcHNUZXN0LnRlc3RfcnVudGVzdHNfYXJncyk6Ci0tLQogVG9vbHMvQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCA1NCArKysrKysrKysrKysr KysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHkgICAgIHwg IDUgKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAgICAgICAg IHwgMTAgKystCiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5weSAgICAgICAg ICAgICB8IDc4ICsrKysrKysrKysrKysrKysrKysrKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dGVzdC9ydW5uZXIucHkgICAgICAgICAgICAgIHwgMTIgKystLQogVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90ZXN0L3J1bm5lcl91bml0dGVzdC5weSAgICAgfCAgNiArLQogLi4uL3dlYmtpdHB5L3Rv b2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRlc3QucHkgICAgfCAgNiArLQogVG9vbHMvU2NyaXB0 cy93ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5ICAgICAgfCAgOSArKysKIC4uLi9TY3Jp cHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkgIHwgIDYgKy0KIDkgZmls ZXMgY2hhbmdlZCwgMTcyIGluc2VydGlvbnMoKyksIDE0IGRlbGV0aW9ucygtKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5CgpkaWZmIC0t Z2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDRmNDNiZWMuLmQ5 NDRmZjggMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cK QEAgLTEsMyArMSw1NyBAQAorMjAxNC0xMC0wMiAgSmFrZSBOaWVsc2VuICA8amFjb2JfbmllbHNl bkBhcHBsZS5jb20+CisKKyAgICAgICAgTWFrZSB0ZXN0LXdlYmtpdHB5IGdlbmVyYXRlIGEganNv biBmaWxlIG9mIGl0cyByZXN1bHRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xMzczNTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHk6 CisgICAgICAgIEFkZHMgYSBtZXRob2QgdG8gbWFrZSBpdCBlYXNpZXIgdG8gZmluZCB0aGUgd2Vi a2l0IHJlc3VsdHMgZGlyZWN0b3J5LgorICAgICAgICAoV2ViS2l0RmluZGVyLndlYmtpdF9yZXN1 bHRzX2Rpcik6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHk6CisgICAg ICAgIEFkZHMgdGhlIC0tcmVzdWx0cy1kaXIgb3B0aW9uLCBhbmQgYWRkcyBsb2dpYyB0byBkdW1w IGEganNvbiBmaWxlIG9mCisgICAgICAgIHRoZSByZXN1bHRzIGlmIC0tcmVzdWx0cy1kaXIgaGFz IGJlZW4gc3BlY2lmaWVkLgorICAgICAgICAoVGVzdGVyLl9faW5pdF9fKToKKyAgICAgICAgKFRl c3Rlci5fcGFyc2VfYXJncyk6CisgICAgICAgIChUZXN0ZXIuX3J1bl90ZXN0cyk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS90ZXN0L3Jlc3VsdHMucHk6IEFkZGVkLgorICAgICAgICBQcm92 aWRlcyBhIGNsYXNzIHRvIGVuY2Fwc3VsYXRlIHRlc3QgcmVzdWx0cywgYW5kIHRvIGFkZCBpc29s YXRpb24KKyAgICAgICAgYmV0d2VlbiB0aGUganNvbiBmaWxlIGFuZCB0aGUgcmVzdCBvZiB3ZWJr aXRweS4KKyAgICAgICAgKFRlc3RSZXN1bHQpOgorICAgICAgICAoVGVzdFJlc3VsdC50ZXN0X3Jl c3VsdF9mcm9tX2pzb25fZGljdCk6CisgICAgICAgIChUZXN0UmVzdWx0LnRlc3RfcmVzdWx0X3Rv X2pzb25fZGljdCk6CisgICAgICAgIChUZXN0UmVzdWx0Ll9faW5pdF9fKToKKyAgICAgICAgKFRl c3RSZXN1bHQudGVzdF9uYW1lKToKKyAgICAgICAgKFRlc3RSZXN1bHQuZmFpbHVyZXMpOgorICAg ICAgICAoVGVzdFJlc3VsdC5lcnJvcnMpOgorICAgICAgICAoVGVzdFJlc3VsdHMpOgorICAgICAg ICAoVGVzdFJlc3VsdHMudGVzdF9yZXN1bHRzX2Zyb21fanNvbl9kaWN0KToKKyAgICAgICAgKFRl c3RSZXN1bHRzLnRlc3RfcmVzdWx0c190b19qc29uX2RpY3QpOgorICAgICAgICAoVGVzdFJlc3Vs dHMuX19pbml0X18pOgorICAgICAgICAoVGVzdFJlc3VsdHMuYWRkX3Rlc3RfcmVzdWx0KToKKyAg ICAgICAgKFRlc3RSZXN1bHRzLmxpc3Rfb2ZfdGVzdF9yZXN1bHRzKToKKyAgICAgICAgKFRlc3RS ZXN1bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cyk6CisgICAgICAgIChUZXN0UmVzdWx0 cy5saXN0X29mX2Vycm9yZWRfdGVzdF9yZXN1bHRzKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L3Rlc3QvcnVubmVyLnB5OgorICAgICAgICBUZWFjaGVzIHJ1bm5lci5weSB0byB1c2UgVGVz dFJlc3VsdCBvYmplY3RzIGluc3RlYWQgb2YganVzdCBzdHVmZmluZworICAgICAgICBldmVyeXRo aW5nIGludG8gdHVwbGVzIGFuZCBsaXN0cy4KKyAgICAgICAgKFJ1bm5lci5fX2luaXRfXyk6Cisg ICAgICAgIChSdW5uZXIuaGFuZGxlKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rlc3Qv cnVubmVyX3VuaXR0ZXN0LnB5OgorICAgICAgICBUZWFjaGVzIHRlc3RfcnVuIGhvdyB0byB1c2Ug VGVzdFJlc3VsdHMgb2JqZWN0cy4KKyAgICAgICAgKFJ1bm5lclRlc3QudGVzdF9ydW4pOgorICAg ICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91bml0dGVzdC5w eToKKyAgICAgICAgVXBkYXRlcyB0aGUgdGVzdF9sYW5kX2Nvd2hhbmQgdGVzdCB0byBwcm9wZXJs eSBhbnRpY2lwYXRlIHdoYXQgUnVuVGVzdAorICAgICAgICBzaG91bGQgYmUgc3Rkb3V0aW5nLgor ICAgICAgICAodGVzdF9sYW5kX2Nvd2hhbmQpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkv dG9vbC9zdGVwcy9ydW50ZXN0cy5weToKKyAgICAgICAgVGVhY2hlcyBSdW5UZXN0cyB0byBwYXNz IGEgLS1yZXN1bHRzLWRpciB0byB0ZXN0LXdlYmtpdHB5LgorICAgICAgICAoUnVuVGVzdHMucnVu KToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3Qu cHk6CisgICAgICAgIFVwZGF0ZXMgdGhlIHRlc3RfcnVudGVzdHNfYXJncyB0ZXN0IHRvIHByb3Bl cmx5IGFudGljaXBhdGUgd2hhdCBSdW5UZXN0CisgICAgICAgIHNob3VsZCBiZSBzdGRvdXRpbmcu CisgICAgICAgIChTdGVwc1Rlc3QudGVzdF9ydW50ZXN0c19hcmdzKToKKwogMjAxNC0xMC0wMiAg Q2FybG9zIEFsYmVydG8gTG9wZXogUGVyZXogIDxjbG9wZXpAaWdhbGlhLmNvbT4KIAogICAgICAg ICBbR1RLXSBbSkhCdWlsZF0gU3dpdGNoIHNvdXJjZXdhcmUub3JnIG1pcnJvciB0byBodHRwLgpk aWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vd2Via2l0X2ZpbmRlci5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3dlYmtpdF9maW5kZXIucHkKaW5kZXgg N2I5YzAxNC4uNTQyZWFhOCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vd2Via2l0X2ZpbmRlci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi93 ZWJraXRfZmluZGVyLnB5CkBAIC0zMiw2ICszMiwxMSBAQCBjbGFzcyBXZWJLaXRGaW5kZXIob2Jq ZWN0KToKICAgICAgICAgc2VsZi5fZmlsZXN5c3RlbSA9IGZpbGVzeXN0ZW0KICAgICAgICAgc2Vs Zi5fd2Via2l0X2Jhc2UgPSBOb25lCiAKKyAgICBkZWYgd2Via2l0X3Jlc3VsdHNfZGlyKHNlbGYp OgorICAgICAgICBwYXRoX3RvX2J1aWxkX2RpciA9IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxm LndlYmtpdF9iYXNlKCksICJXZWJLaXRCdWlsZCIpCisgICAgICAgIGNvbmZpZ3VyYXRpb25fZGly ID0gc2VsZi5fZmlsZXN5c3RlbS5yZWFkX3RleHRfZmlsZShzZWxmLl9maWxlc3lzdGVtLmpvaW4o cGF0aF90b19idWlsZF9kaXIsICJDb25maWd1cmF0aW9uIikpCisgICAgICAgIHJldHVybiBzZWxm Ll9maWxlc3lzdGVtLmpvaW4ocGF0aF90b19idWlsZF9kaXIsIGNvbmZpZ3VyYXRpb25fZGlyKQor CiAgICAgZGVmIHdlYmtpdF9iYXNlKHNlbGYpOgogICAgICAgICAiIiJSZXR1cm5zIHRoZSBhYnNv bHV0ZSBwYXRoIHRvIHRoZSB0b3Agb2YgdGhlIFdlYktpdCB0cmVlLgogCmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdGVzdC9tYWluLnB5CmluZGV4IGY1MThiNTEuLjYzN2NlOWMgMTAwNjQ0Ci0tLSBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdGVzdC9tYWluLnB5CkBAIC0zMiw3ICszMiw5IEBAIGltcG9ydCBzeXMKIGltcG9ydCB0aW1l CiBpbXBvcnQgdHJhY2ViYWNrCiBpbXBvcnQgdW5pdHRlc3QKK2ltcG9ydCBqc29uCiAKK2Zyb20g d2Via2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktpdEZpbmRlcgogZnJvbSB3 ZWJraXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZpbGVTeXN0ZW0KIGZyb20g d2Via2l0cHkudGVzdC5maW5kZXIgaW1wb3J0IEZpbmRlcgogZnJvbSB3ZWJraXRweS50ZXN0LnBy aW50ZXIgaW1wb3J0IFByaW50ZXIKQEAgLTc0LDcgKzc2LDggQEAgZGVmIG1haW4oKToKIAogY2xh c3MgVGVzdGVyKG9iamVjdCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIGZpbGVzeXN0ZW09Tm9u ZSk6Ci0gICAgICAgIHNlbGYuZmluZGVyID0gRmluZGVyKGZpbGVzeXN0ZW0gb3IgRmlsZVN5c3Rl bSgpKQorICAgICAgICBzZWxmLl9maWxlc3lzdGVtID0gZmlsZXN5c3RlbSBvciBGaWxlU3lzdGVt KCkKKyAgICAgICAgc2VsZi5maW5kZXIgPSBGaW5kZXIoc2VsZi5fZmlsZXN5c3RlbSkKICAgICAg ICAgc2VsZi5wcmludGVyID0gUHJpbnRlcihzeXMuc3RkZXJyKQogICAgICAgICBzZWxmLl9vcHRp b25zID0gTm9uZQogCkBAIC0xMDIsNiArMTA1LDggQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAg ICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2Rpc3BsYXkgcGVyLXRlc3QgZXhlY3V0aW9u IHRpbWUgKGltcGxpZXMgLS12ZXJib3NlKScpCiAgICAgICAgIHBhcnNlci5hZGRfb3B0aW9uKCct dicsICctLXZlcmJvc2UnLCBhY3Rpb249J2NvdW50JywgZGVmYXVsdD0wLAogICAgICAgICAgICAg ICAgICAgICAgICAgICBoZWxwPSd2ZXJib3NlIG91dHB1dCAoc3BlY2lmeSBvbmNlIGZvciBpbmRp dmlkdWFsIHRlc3QgcmVzdWx0cywgdHdpY2UgZm9yIGRlYnVnIG1lc3NhZ2VzKScpCisgICAgICAg IHBhcnNlci5hZGRfb3B0aW9uKCctcicsICctLXJlc3VsdHMtZGlyJywgYWN0aW9uPSdzdG9yZScs IGRlZmF1bHQ9IiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3NwZWNpZmllcyBh IGRpcmVjdG9yeSBpbiB3aGljaCB0byBnZW5lcmF0ZSBhIGpzb24gZmlsZSB0aGF0IGNvbnRhaW5z IHRoZSByZXN1bHRzIG9mIHRoZSB0ZXN0cycpCiAKICAgICAgICAgcGFyc2VyLmVwaWxvZyA9ICgn W2FyZ3MuLi5dIGlzIGFuIG9wdGlvbmFsIGxpc3Qgb2YgbW9kdWxlcywgdGVzdF9jbGFzc2VzLCBv ciBpbmRpdmlkdWFsIHRlc3RzLiAnCiAgICAgICAgICAgICAgICAgICAgICAgICAgJ0lmIG5vIGFy Z3MgYXJlIGdpdmVuLCBhbGwgdGhlIHRlc3RzIHdpbGwgYmUgcnVuLicpCkBAIC0xNjIsNiArMTY3 LDkgQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAKICAgICAgICAgc2VsZi5wcmludGVyLnByaW50 X3Jlc3VsdCh0aW1lLnRpbWUoKSAtIHN0YXJ0KQogCisgICAgICAgIGlmIHNlbGYuX29wdGlvbnMu cmVzdWx0c19kaXI6CisgICAgICAgICAgICBzZWxmLl9maWxlc3lzdGVtLndyaXRlX3RleHRfZmls ZShzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1bHRzX2RpciwgInJlc3Vs dHMuanNvbiIpLCBqc29uLmR1bXBzKHRlc3RfcnVubmVyLnRlc3RfcmVzdWx0cy50ZXN0X3Jlc3Vs dHNfdG9fanNvbl9kaWN0KCkpKQorCiAgICAgICAgIGlmIHNlbGYuX29wdGlvbnMuY292ZXJhZ2U6 CiAgICAgICAgICAgICBjb3Yuc3RvcCgpCiAgICAgICAgICAgICBjb3Yuc2F2ZSgpCmRpZmYgLS1n aXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcmVzdWx0cy5weSBiL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvdGVzdC9yZXN1bHRzLnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLmMyMmZiNDEKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L3Rlc3QvcmVzdWx0cy5weQpAQCAtMCwwICsxLDc4IEBACisjIENvcHlyaWdodCAoQykgMjAxNCBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyMgYXJlIG1ldDoKKyMgMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuICBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor IyAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorIyAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBB TkQKKyMgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyMgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorIyBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUgorIyBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCisjIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SCisjIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KSBIT1dFVkVSCisjIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksCisjIE9SIFRPUlQgKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF CisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisKK2ltcG9ydCBsb2dnaW5nCitfbG9nID0gbG9nZ2luZy5nZXRMb2dn ZXIoX19uYW1lX18pCisKKworY2xhc3MgVGVzdFJlc3VsdChvYmplY3QpOgorICAgIEBjbGFzc21l dGhvZAorICAgIGRlZiB0ZXN0X3Jlc3VsdF9mcm9tX2pzb25fZGljdChjbHMsIGpzb25fZGljdCk6 CisgICAgICAgIHJldHVybiBjbHMoanNvbl9kaWN0Wyd0ZXN0X25hbWUnXSwganNvbl9kaWN0Wydm YWlsdXJlcyddLCBqc29uX2RpY3RbJ2Vycm9ycyddKQorCisgICAgZGVmIHRlc3RfcmVzdWx0X3Rv X2pzb25fZGljdChzZWxmKToKKyAgICAgICAganNvbl9kaWN0ID0ge30KKyAgICAgICAganNvbl9k aWN0Wyd0ZXN0X25hbWUnXSA9IHNlbGYuX3Rlc3RfbmFtZQorICAgICAgICBqc29uX2RpY3RbJ2Zh aWx1cmVzJ10gPSBzZWxmLl9mYWlsdXJlcworICAgICAgICBqc29uX2RpY3RbJ2Vycm9ycyddID0g c2VsZi5fZXJyb3JzCisgICAgICAgIHJldHVybiBqc29uX2RpY3QKKworICAgIGRlZiBfX2luaXRf XyhzZWxmLCB0ZXN0X25hbWUsIGZhaWx1cmVzPU5vbmUsIGVycm9ycz1Ob25lKToKKyAgICAgICAg c2VsZi5fdGVzdF9uYW1lID0gdGVzdF9uYW1lCisgICAgICAgIHNlbGYuX2ZhaWx1cmVzID0gZmFp bHVyZXMKKyAgICAgICAgc2VsZi5fZXJyb3JzID0gZXJyb3JzCisKKyAgICBkZWYgdGVzdF9uYW1l KHNlbGYpOgorICAgICAgICByZXR1cm4gc2VsZi5fdGVzdF9uYW1lCisKKyAgICBkZWYgZmFpbHVy ZXMoc2VsZik6CisgICAgICAgIHJldHVybiBzZWxmLl9mYWlsdXJlcworCisgICAgZGVmIGVycm9y cyhzZWxmKToKKyAgICAgICAgcmV0dXJuIHNlbGYuX2Vycm9ycworCisKK2NsYXNzIFRlc3RSZXN1 bHRzKG9iamVjdCk6CisgICAgQGNsYXNzbWV0aG9kCisgICAgZGVmIHRlc3RfcmVzdWx0c19mcm9t X2pzb25fZGljdChjbHMsIGpzb25fZGljdCk6CisgICAgICAgIGxpc3Rfb2ZfdGVzdF9yZXN1bHRz ID0gW1Rlc3RSZXN1bHQudGVzdF9yZXN1bHRfZnJvbV9qc29uX2RpY3QoanNvbl9yZXN1bHQpIGZv ciBqc29uX3Jlc3VsdCBpbiBqc29uX2RpY3RbJ2xpc3Rfb2ZfdGVzdF9yZXN1bHRzJ11dCisgICAg ICAgIHJldHVybiBjbHMobGlzdF9vZl90ZXN0X3Jlc3VsdHMpCisKKyAgICBkZWYgdGVzdF9yZXN1 bHRzX3RvX2pzb25fZGljdChzZWxmKToKKyAgICAgICAganNvbl9kaWN0ID0ge30KKyAgICAgICAg anNvbl9kaWN0WydsaXN0X29mX3Rlc3RfcmVzdWx0cyddID0gW3Jlc3VsdC50ZXN0X3Jlc3VsdF90 b19qc29uX2RpY3QoKSBmb3IgcmVzdWx0IGluIHNlbGYuX2xpc3Rfb2ZfdGVzdF9yZXN1bHRzXQor ICAgICAgICByZXR1cm4ganNvbl9kaWN0CisKKyAgICBkZWYgX19pbml0X18oc2VsZiwgbGlzdF9v Zl90ZXN0X3Jlc3VsdHM9W10pOgorICAgICAgICBzZWxmLl9saXN0X29mX3Rlc3RfcmVzdWx0cyA9 IGxpc3Rfb2ZfdGVzdF9yZXN1bHRzCisKKyAgICBkZWYgYWRkX3Rlc3RfcmVzdWx0KHNlbGYsIHRl c3QpOgorICAgICAgICBzZWxmLl9saXN0X29mX3Rlc3RfcmVzdWx0cy5hcHBlbmQodGVzdCkKKwor ICAgIGRlZiBsaXN0X29mX3Rlc3RfcmVzdWx0cyhzZWxmKToKKyAgICAgICAgcmV0dXJuIHNlbGYu X2xpc3Rfb2ZfdGVzdF9yZXN1bHRzCisKKyAgICBkZWYgbGlzdF9vZl9mYWlsZWRfdGVzdF9yZXN1 bHRzKHNlbGYpOgorICAgICAgICByZXR1cm4gW3Jlc3VsdCBmb3IgcmVzdWx0IGluIHNlbGYuX2xp c3Rfb2ZfdGVzdF9yZXN1bHRzIGlmIHJlc3VsdC5mYWlsdXJlcygpXQorCisgICAgZGVmIGxpc3Rf b2ZfZXJyb3JlZF90ZXN0X3Jlc3VsdHMoc2VsZik6CisgICAgICAgIHJldHVybiBbcmVzdWx0IGZv ciByZXN1bHQgaW4gc2VsZi5fbGlzdF9vZl90ZXN0X3Jlc3VsdHMgaWYgcmVzdWx0LmVycm9ycygp XQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lci5weSBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXIucHkKaW5kZXggZDNmNTc2NC4uN2Q0OTQ0 YiAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3J1bm5lci5weQorKysg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyLnB5CkBAIC0yNyw2ICsyNyw3IEBA IGltcG9ydCB0aW1lCiBpbXBvcnQgdW5pdHRlc3QKIAogZnJvbSB3ZWJraXRweS5jb21tb24gaW1w b3J0IG1lc3NhZ2VfcG9vbAorZnJvbSB3ZWJraXRweS50ZXN0LnJlc3VsdHMgaW1wb3J0IFRlc3RS ZXN1bHQsIFRlc3RSZXN1bHRzCiAKIF90ZXN0X2Rlc2NyaXB0aW9uID0gcmUuY29tcGlsZSgiKFx3 KykgXCgoW1x3Ll0rKVwpIikKIApAQCAtNDAsOSArNDEsNyBAQCBjbGFzcyBSdW5uZXIob2JqZWN0 KToKICAgICBkZWYgX19pbml0X18oc2VsZiwgcHJpbnRlciwgbG9hZGVyKToKICAgICAgICAgc2Vs Zi5wcmludGVyID0gcHJpbnRlcgogICAgICAgICBzZWxmLmxvYWRlciA9IGxvYWRlcgotICAgICAg ICBzZWxmLnRlc3RzX3J1biA9IDAKLSAgICAgICAgc2VsZi5lcnJvcnMgPSBbXQotICAgICAgICBz ZWxmLmZhaWx1cmVzID0gW10KKyAgICAgICAgc2VsZi50ZXN0X3Jlc3VsdHMgPSBUZXN0UmVzdWx0 cygpCiAgICAgICAgIHNlbGYud29ya2VyX2ZhY3RvcnkgPSBsYW1iZGEgY2FsbGVyOiBfV29ya2Vy KGNhbGxlciwgc2VsZi5sb2FkZXIpCiAKICAgICBkZWYgcnVuKHNlbGYsIHRlc3RfbmFtZXMsIG51 bV93b3JrZXJzKToKQEAgLTU3LDExICs1Niw4IEBAIGNsYXNzIFJ1bm5lcihvYmplY3QpOgogICAg ICAgICAgICAgc2VsZi5wcmludGVyLnByaW50X3N0YXJ0ZWRfdGVzdChzb3VyY2UsIHRlc3RfbmFt ZSkKICAgICAgICAgICAgIHJldHVybgogCi0gICAgICAgIHNlbGYudGVzdHNfcnVuICs9IDEKLSAg ICAgICAgaWYgZmFpbHVyZXM6Ci0gICAgICAgICAgICBzZWxmLmZhaWx1cmVzLmFwcGVuZCgodGVz dF9uYW1lLCBmYWlsdXJlcykpCi0gICAgICAgIGlmIGVycm9yczoKLSAgICAgICAgICAgIHNlbGYu ZXJyb3JzLmFwcGVuZCgodGVzdF9uYW1lLCBlcnJvcnMpKQorICAgICAgICBzZWxmLnRlc3RfcmVz dWx0cy5hZGRfdGVzdF9yZXN1bHQoVGVzdFJlc3VsdCh0ZXN0X25hbWUsIGZhaWx1cmVzLCBlcnJv cnMpKQorCiAgICAgICAgIHNlbGYucHJpbnRlci5wcmludF9maW5pc2hlZF90ZXN0KHNvdXJjZSwg dGVzdF9uYW1lLCBkZWxheSwgZmFpbHVyZXMsIGVycm9ycykKIAogCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS90ZXN0L3J1bm5lcl91bml0dGVzdC5weQppbmRleCA5OTUwNzBiLi5hOWM2MWVj IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvcnVubmVyX3VuaXR0ZXN0 LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9ydW5uZXJfdW5pdHRlc3QucHkK QEAgLTkyLDYgKzkyLDYgQEAgY2xhc3MgUnVubmVyVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgKCd0ZXN0MyAoRm9vKScsICdFJywgJ3Rlc3QzXG5l cnJlZCcpKQogICAgICAgICBydW5uZXIgPSBSdW5uZXIoUHJpbnRlcihzdHJlYW0sIG9wdGlvbnMp LCBsb2FkZXIpCiAgICAgICAgIHJ1bm5lci5ydW4oWydGb28udGVzdDEnLCAnRm9vLnRlc3QyJywg J0Zvby50ZXN0MyddLCAxKQotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHJ1bm5lci50ZXN0c19y dW4sIDMpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci5mYWlsdXJlcyksIDEp Ci0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobGVuKHJ1bm5lci5lcnJvcnMpLCAxKQorICAgICAg ICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5uZXIudGVzdF9yZXN1bHRzLmxpc3Rfb2ZfdGVzdF9y ZXN1bHRzKCkpLCAzKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGxlbihydW5uZXIudGVzdF9y ZXN1bHRzLmxpc3Rfb2ZfZmFpbGVkX3Rlc3RfcmVzdWx0cygpKSwgMSkKKyAgICAgICAgc2VsZi5h c3NlcnRFcXVhbChsZW4ocnVubmVyLnRlc3RfcmVzdWx0cy5saXN0X29mX2Vycm9yZWRfdGVzdF9y ZXN1bHRzKCkpLCAxKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2Nv bW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29s L2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5CmluZGV4IDU5YjUyZWEuLjBhYzZkMDYgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91 bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93 bmxvYWRfdW5pdHRlc3QucHkKQEAgLTM0LDYgKzM0LDggQEAgZnJvbSB3ZWJraXRweS50b29sLmNv bW1hbmRzLmNvbW1hbmR0ZXN0IGltcG9ydCBDb21tYW5kc1Rlc3QKIGZyb20gd2Via2l0cHkudG9v bC5jb21tYW5kcy5kb3dubG9hZCBpbXBvcnQgKgogZnJvbSB3ZWJraXRweS50b29sLm1vY2t0b29s IGltcG9ydCBNb2NrT3B0aW9ucywgTW9ja1Rvb2wKIGZyb20gd2Via2l0cHkuY29tbW9uLmNoZWNr b3V0LmNoZWNrb3V0X21vY2sgaW1wb3J0IE1vY2tDaGVja291dAorZnJvbSB3ZWJraXRweS5jb21t b24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZpbGVTeXN0ZW0KK2Zyb20gd2Via2l0cHkuY29t bW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktpdEZpbmRlcgogCiAKIGNsYXNzIEFic3RyYWN0 Um9sbG91dFByZXBDb21tYW5kVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CkBAIC0xNTYsNiArMTU4 LDggQEAgVXBkYXRpbmcgYnVnIDUwMDAwCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwobW9ja190 b29sLmNoZWNrb3V0KCkubW9kaWZpZWRfY2hhbmdlbG9ncy5jYWxsX2NvdW50LCAxKQogCiAgICAg ZGVmIHRlc3RfbGFuZF9jb3doYW5kKHNlbGYpOgorICAgICAgICBmaWxlc3lzdGVtID0gRmlsZVN5 c3RlbSgpCisgICAgICAgIHdlYmtpdF9maW5kZXIgPSBXZWJLaXRGaW5kZXIoZmlsZXN5c3RlbSkK ICAgICAgICAgZXhwZWN0ZWRfbG9ncyA9ICIiIk1PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBb J21vY2stcHJlcGFyZS1DaGFuZ2VMb2cnLCAnLS1lbWFpbD1NT0NLIGVtYWlsJywgJy0tbWVyZ2Ut YmFzZT1Ob25lJywgJ01vY2tGaWxlMSddLCBjd2Q9L21vY2stY2hlY2tvdXQKIE1PQ0sgcnVuX2Fu ZF90aHJvd19pZl9mYWlsOiBbJ21vY2stY2hlY2std2Via2l0LXN0eWxlJywgJy0tZ2l0LWNvbW1p dCcsICdNT0NLIGdpdCBjb21taXQnLCAnLS1kaWZmLWZpbGVzJywgJ01vY2tGaWxlMScsICctLWZp bHRlcicsICctY2hhbmdlbG9nJ10sIGN3ZD0vbW9jay1jaGVja291dAogTU9DSyBydW5fY29tbWFu ZDogWydydWJ5JywgJy1JJywgJy9tb2NrLWNoZWNrb3V0L1dlYnNpdGVzL2J1Z3Mud2Via2l0Lm9y Zy9QcmV0dHlQYXRjaCcsICcvbW9jay1jaGVja291dC9XZWJzaXRlcy9idWdzLndlYmtpdC5vcmcv UHJldHR5UGF0Y2gvcHJldHRpZnkucmInXSwgY3dkPU5vbmUsIGlucHV0PVBhdGNoMQpAQCAtMTY0 LDcgKzE2OCw3IEBAIFdhcyB0aGF0IGRpZmYgY29ycmVjdD8KIEJ1aWxkaW5nIFdlYktpdAogTU9D SyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnbW9jay1idWlsZC13ZWJraXQnXSwgY3dkPS9tb2Nr LWNoZWNrb3V0LCBlbnY9eydMQ19BTEwnOiAnQycsICdURVJNJzogJ25vbmUnLCAnTU9DS19FTlZJ Uk9OX0NPUFknOiAnMSd9CiBSdW5uaW5nIFB5dGhvbiB1bml0IHRlc3RzCi1NT0NLIHJ1bl9hbmRf dGhyb3dfaWZfZmFpbDogWydtb2NrLXRlc3Qtd2Via2l0cHknXSwgY3dkPS9tb2NrLWNoZWNrb3V0 CitNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLXRlc3Qtd2Via2l0cHknLCAnLS1y ZXN1bHRzLWRpcicsIHUnIiIiICsgZmlsZXN5c3RlbS5qb2luKHdlYmtpdF9maW5kZXIud2Via2l0 X3Jlc3VsdHNfZGlyKCksICJweXRob24tdW5pdHRlc3QtcmVzdWx0cyIpICsgIiIiJ10sIGN3ZD0v bW9jay1jaGVja291dAogUnVubmluZyBQZXJsIHVuaXQgdGVzdHMKIE1PQ0sgcnVuX2FuZF90aHJv d19pZl9mYWlsOiBbJ21vY2stdGVzdC13ZWJraXRwZXJsJ10sIGN3ZD0vbW9jay1jaGVja291dAog UnVubmluZyBKYXZhU2NyaXB0Q29yZSB0ZXN0cwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS90b29sL3N0ZXBzL3J1bnRlc3RzLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90 b29sL3N0ZXBzL3J1bnRlc3RzLnB5CmluZGV4IGE0NTYyOGIuLmM0OWY0Y2MgMTAwNjQ0Ci0tLSBh L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9ydW50ZXN0cy5weQorKysgYi9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvcnVudGVzdHMucHkKQEAgLTMzLDYgKzMzLDgg QEAgaW1wb3J0IHN5cwogZnJvbSB3ZWJraXRweS50b29sLnN0ZXBzLmFic3RyYWN0c3RlcCBpbXBv cnQgQWJzdHJhY3RTdGVwCiBmcm9tIHdlYmtpdHB5LnRvb2wuc3RlcHMub3B0aW9ucyBpbXBvcnQg T3B0aW9ucwogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmV4ZWN1dGl2ZSBpbXBvcnQgU2Ny aXB0RXJyb3IKK2Zyb20gd2Via2l0cHkuY29tbW9uLndlYmtpdF9maW5kZXIgaW1wb3J0IFdlYktp dEZpbmRlcgorZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmZpbGVzeXN0ZW0gaW1wb3J0IEZp bGVTeXN0ZW0KIAogX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKF9fbmFtZV9fKQogCkBAIC01NSw4 ICs1NywxNSBAQCBjbGFzcyBSdW5UZXN0cyhBYnN0cmFjdFN0ZXApOgogCiAgICAgICAgIGlmIG5v dCBzZWxmLl9vcHRpb25zLm5vbl9pbnRlcmFjdGl2ZToKICAgICAgICAgICAgICMgRklYTUU6IFdl IHNob3VsZCB0ZWFjaCB0aGUgY29tbWl0LXF1ZXVlIGFuZCB0aGUgRVdTIGhvdyB0byBydW4gdGhl c2UgdGVzdHMuCisgICAgICAgICAgICBmaWxlc3lzdGVtID0gRmlsZVN5c3RlbSgpCisgICAgICAg ICAgICB3ZWJraXRfZmluZGVyID0gV2ViS2l0RmluZGVyKGZpbGVzeXN0ZW0pCisgICAgICAgICAg ICBweXRob25fdW5pdHRlc3RzX3Jlc3VsdHNfZGlyID0gZmlsZXN5c3RlbS5qb2luKHdlYmtpdF9m aW5kZXIud2Via2l0X3Jlc3VsdHNfZGlyKCksICJweXRob24tdW5pdHRlc3QtcmVzdWx0cyIpCisg ICAgICAgICAgICBmaWxlc3lzdGVtLm1heWJlX21ha2VfZGlyZWN0b3J5KHB5dGhvbl91bml0dGVz dHNfcmVzdWx0c19kaXIpCiAKICAgICAgICAgICAgIHB5dGhvbl91bml0dGVzdHNfY29tbWFuZCA9 IHNlbGYuX3Rvb2wuZGVwcmVjYXRlZF9wb3J0KCkucnVuX3B5dGhvbl91bml0dGVzdHNfY29tbWFu ZCgpCisgICAgICAgICAgICBweXRob25fdW5pdHRlc3RzX2NvbW1hbmQuYXBwZW5kKCItLXJlc3Vs dHMtZGlyIikKKyAgICAgICAgICAgIHB5dGhvbl91bml0dGVzdHNfY29tbWFuZC5hcHBlbmQocHl0 aG9uX3VuaXR0ZXN0c19yZXN1bHRzX2RpcikKKwogICAgICAgICAgICAgaWYgcHl0aG9uX3VuaXR0 ZXN0c19jb21tYW5kOgogICAgICAgICAgICAgICAgIF9sb2cuaW5mbygiUnVubmluZyBQeXRob24g dW5pdCB0ZXN0cyIpCiAgICAgICAgICAgICAgICAgc2VsZi5fdG9vbC5leGVjdXRpdmUucnVuX2Fu ZF90aHJvd19pZl9mYWlsKHB5dGhvbl91bml0dGVzdHNfY29tbWFuZCwgY3dkPXNlbGYuX3Rvb2wu c2NtKCkuY2hlY2tvdXRfcm9vdCkKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv dG9vbC9zdGVwcy9zdGVwc191bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9v bC9zdGVwcy9zdGVwc191bml0dGVzdC5weQppbmRleCBiMWUyYmYxLi4yYWYwMWU0IDEwMDY0NAot LS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvc3RlcHNfdW5pdHRlc3QucHkK KysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL3N0ZXBzX3VuaXR0ZXN0LnB5 CkBAIC0zMSw2ICszMSw4IEBAIGltcG9ydCB1bml0dGVzdAogZnJvbSB3ZWJraXRweS5jb21tb24u c3lzdGVtLm91dHB1dGNhcHR1cmUgaW1wb3J0IE91dHB1dENhcHR1cmUKIGZyb20gd2Via2l0cHku Y29tbW9uLmNvbmZpZy5wb3J0cyBpbXBvcnQgRGVwcmVjYXRlZFBvcnQKIGZyb20gd2Via2l0cHku dG9vbC5tb2NrdG9vbCBpbXBvcnQgTW9ja09wdGlvbnMsIE1vY2tUb29sCitmcm9tIHdlYmtpdHB5 LmNvbW1vbi5zeXN0ZW0uZmlsZXN5c3RlbSBpbXBvcnQgRmlsZVN5c3RlbQorZnJvbSB3ZWJraXRw eS5jb21tb24ud2Via2l0X2ZpbmRlciBpbXBvcnQgV2ViS2l0RmluZGVyCiAKIGZyb20gd2Via2l0 cHkudG9vbCBpbXBvcnQgc3RlcHMKIApAQCAtOTYsNiArOTgsOCBAQCBjbGFzcyBTdGVwc1Rlc3Qo dW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICBzZWxmLl9hc3NlcnRfc3RlcF9vdXRwdXRfd2l0 aF9idWcoc3RlcHMuRW5zdXJlQnVnSXNPcGVuQW5kQXNzaWduZWQsIDUwMDAyLCBleHBlY3RlZF9s b2dzKQogCiAgICAgZGVmIHRlc3RfcnVudGVzdHNfYXJncyhzZWxmKToKKyAgICAgICAgZmlsZXN5 c3RlbSA9IEZpbGVTeXN0ZW0oKQorICAgICAgICB3ZWJraXRfZmluZGVyID0gV2ViS2l0RmluZGVy KGZpbGVzeXN0ZW0pCiAgICAgICAgIG1vY2tfb3B0aW9ucyA9IHNlbGYuX3N0ZXBfb3B0aW9ucygp CiAgICAgICAgIG1vY2tfb3B0aW9ucy5ub25faW50ZXJhY3RpdmUgPSBGYWxzZQogICAgICAgICBz dGVwID0gc3RlcHMuUnVuVGVzdHMoTW9ja1Rvb2wobG9nX2V4ZWN1dGl2ZT1UcnVlKSwgbW9ja19v cHRpb25zKQpAQCAtMTA0LDcgKzEwOCw3IEBAIGNsYXNzIFN0ZXBzVGVzdCh1bml0dGVzdC5UZXN0 Q2FzZSk6CiAgICAgICAgIHRvb2wuX2RlcHJlY2F0ZWRfcG9ydCA9IERlcHJlY2F0ZWRQb3J0KCkK ICAgICAgICAgc3RlcCA9IHN0ZXBzLlJ1blRlc3RzKHRvb2wsIG1vY2tfb3B0aW9ucykKICAgICAg ICAgZXhwZWN0ZWRfbG9ncyA9ICIiIlJ1bm5pbmcgUHl0aG9uIHVuaXQgdGVzdHMKLU1PQ0sgcnVu X2FuZF90aHJvd19pZl9mYWlsOiBbJ1Rvb2xzL1NjcmlwdHMvdGVzdC13ZWJraXRweSddLCBjd2Q9 L21vY2stY2hlY2tvdXQKK01PQ0sgcnVuX2FuZF90aHJvd19pZl9mYWlsOiBbJ1Rvb2xzL1Njcmlw dHMvdGVzdC13ZWJraXRweScsICctLXJlc3VsdHMtZGlyJywgdSciIiIgKyBmaWxlc3lzdGVtLmpv aW4od2Via2l0X2ZpbmRlci53ZWJraXRfcmVzdWx0c19kaXIoKSwgInB5dGhvbi11bml0dGVzdC1y ZXN1bHRzIikgKyAiIiInXSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBSdW5uaW5nIFBlcmwgdW5pdCB0 ZXN0cwogTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6IFsnVG9vbHMvU2NyaXB0cy90ZXN0LXdl YmtpdHBlcmwnXSwgY3dkPS9tb2NrLWNoZWNrb3V0CiBSdW5uaW5nIEphdmFTY3JpcHRDb3JlIHRl c3RzCi0tIAoxLjkuMyAoQXBwbGUgR2l0LTUwKQoK 239760 2014-10-13 16:50:12 -0700 2014-10-15 10:46:25 -0700 The patch I intended to post last time... 0001-Add-json-flag-to-test-webkitpy-to-emit-JSON-formatte.patch text/plain 5796 jake.nielsen.webkit RnJvbSAzNDY2YWNlYTg2NzYwM2Q5MmZlNGVhYjI5ODc5YjA3ZjliNWM4MjRkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBNb24sIDEzIE9jdCAyMDE0IDE2OjQ1OjI2IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0g QWRkIC0tanNvbiBmbGFnIHRvIHRlc3Qtd2Via2l0cHkgdG8gZW1pdCBKU09OIGZvcm1hdHRlZCB0 ZXN0CiByZXN1bHRzIHRvIHN0ZG91dCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTM3MzUzCgpSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiogU2NyaXB0cy93ZWJr aXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5OgpBZGRzIHRoZSByZWFkIG1ldGhv ZCB0byBNb2NrRmlsZSB0byBhbGxvdyB0aGUgc3Rkb3V0IG9mIHRlc3Rfd2Via2l0cHkKdG8gYmUg cmVkaXJlY3RlZCB3aXRob3V0IGNhdXNpbmcgZXJyb25lb3VzIHRlc3QgZmFpbHVyZXMuCkluIHBh cnRpY3VsYXIsCndlYmtpdHB5LnBvcnQuc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QuVGVzdFNlcnZl clByb2Nlc3MudGVzdF9icm9rZW5fcGlwZQphbmQKd2Via2l0cHkucG9ydC5zZXJ2ZXJfcHJvY2Vz c191bml0dGVzdC5UZXN0U2VydmVyUHJvY2Vzcy50ZXN0X2NsZWFudXAKYmVjYXVzZSB3aGVuIHJl ZGlyZWN0aW5nIHRvIGEgZmlsZSwgdGhlCl93YWl0X2Zvcl9kYXRhX2FuZF91cGRhdGVfYnVmZmVy c191c2luZ19zZWxlY3QgbWV0aG9kIGluCnNlcnZlcl9wcm9jZXNzLnB5IHdpbGwgZmluZCB0aGF0 IHRoZXJlIGlzIGEgcmVhZCBmaWxlIGRlc2NyaXB0b3IgaW4KaXRzIGNhbGwgdG8gc2VsZWN0LnNl bGVjdCwgd2hpY2ggZXZlbnR1YWxseSBsZWFkcyB0byBpdCBjYWxsaW5nIHJlYWQoKQpvbiB0aGUg TW9ja0ZpbGUgb2JqZWN0LgooTW9ja0ZpbGUucmVhZCk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0 L21haW4ucHk6CkFkZHMgdGhlIF9wcmludF9yZXN1bHRzX2FzX2pzb24gbWV0aG9kIGFuZCB0aGUg LS1qc29uIGZsYWcgd2hpY2gKZGV0ZXJtaW5lcyB3aGV0aGVyIF9wcmludF9yZXN1bHRzX2FzX2pz b24gd2lsbCBnZXQgY2FsbGVkLgooVGVzdGVyLl9wYXJzZV9hcmdzKToKKFRlc3Rlci5fcHJpbnRf cmVzdWx0c19hc19qc29uKToKKFRlc3Rlci5fcHJpbnRfcmVzdWx0c19hc19qc29uLnJlc3VsdF9k aWN0X2Zyb21fdHVwbGUpOgooVGVzdGVyLl9ydW5fdGVzdHMpOgotLS0KIFRvb2xzL0NoYW5nZUxv ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjkgKysrKysrKysrKysrKysr KysrKysrKwogLi4uL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkgICAg ICAgfCAgNCArKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAg ICAgICAgIHwgMTkgKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNTIgaW5zZXJ0aW9u cygrKQoKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRl eCBlYjI0OWE1Li45ZDhhYjBhIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9v bHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTQtMTAtMTMgIEpha2UgTmllbHNlbiAg PGphY29iX25pZWxzZW5AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCAtLWpzb24gZmxhZyB0byB0 ZXN0LXdlYmtpdHB5IHRvIGVtaXQgSlNPTiBmb3JtYXR0ZWQgdGVzdCByZXN1bHRzCisgICAgICAg IHRvIHN0ZG91dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTM3MzUzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHk6Cisg ICAgICAgIEFkZHMgdGhlIHJlYWQgbWV0aG9kIHRvIE1vY2tGaWxlIHRvIGFsbG93IHRoZSBzdGRv dXQgb2YgdGVzdF93ZWJraXRweQorICAgICAgICB0byBiZSByZWRpcmVjdGVkIHdpdGhvdXQgY2F1 c2luZyBlcnJvbmVvdXMgdGVzdCBmYWlsdXJlcy4KKyAgICAgICAgSW4gcGFydGljdWxhciwKKyAg ICAgICAgd2Via2l0cHkucG9ydC5zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5UZXN0U2VydmVyUHJv Y2Vzcy50ZXN0X2Jyb2tlbl9waXBlCisgICAgICAgIGFuZAorICAgICAgICB3ZWJraXRweS5wb3J0 LnNlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LlRlc3RTZXJ2ZXJQcm9jZXNzLnRlc3RfY2xlYW51cAor ICAgICAgICBiZWNhdXNlIHdoZW4gcmVkaXJlY3RpbmcgdG8gYSBmaWxlLCB0aGUKKyAgICAgICAg X3dhaXRfZm9yX2RhdGFfYW5kX3VwZGF0ZV9idWZmZXJzX3VzaW5nX3NlbGVjdCBtZXRob2QgaW4g CisgICAgICAgIHNlcnZlcl9wcm9jZXNzLnB5IHdpbGwgZmluZCB0aGF0IHRoZXJlIGlzIGEgcmVh ZCBmaWxlIGRlc2NyaXB0b3IgaW4KKyAgICAgICAgaXRzIGNhbGwgdG8gc2VsZWN0LnNlbGVjdCwg d2hpY2ggZXZlbnR1YWxseSBsZWFkcyB0byBpdCBjYWxsaW5nIHJlYWQoKQorICAgICAgICBvbiB0 aGUgTW9ja0ZpbGUgb2JqZWN0LgorICAgICAgICAoTW9ja0ZpbGUucmVhZCk6CisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHk6CisgICAgICAgIEFkZHMgdGhlIF9wcmludF9y ZXN1bHRzX2FzX2pzb24gbWV0aG9kIGFuZCB0aGUgLS1qc29uIGZsYWcgd2hpY2gKKyAgICAgICAg ZGV0ZXJtaW5lcyB3aGV0aGVyIF9wcmludF9yZXN1bHRzX2FzX2pzb24gd2lsbCBnZXQgY2FsbGVk LgorICAgICAgICAoVGVzdGVyLl9wYXJzZV9hcmdzKToKKyAgICAgICAgKFRlc3Rlci5fcHJpbnRf cmVzdWx0c19hc19qc29uKToKKyAgICAgICAgKFRlc3Rlci5fcHJpbnRfcmVzdWx0c19hc19qc29u LnJlc3VsdF9kaWN0X2Zyb21fdHVwbGUpOgorICAgICAgICAoVGVzdGVyLl9ydW5fdGVzdHMpOgor CiAyMDE0LTEwLTEzICBDYXJsb3MgQWxiZXJ0byBMb3BleiBQZXJleiAgPGNsb3BlekBpZ2FsaWEu Y29tPgogCiAgICAgICAgIFtYdmZiRHJpdmVyXSBSZWd1bGFyIGV4cHJlc3Npb24gdXNlZCB0byBt YXRjaCBydW5uaW5nIFggc2VydmVycyBmYWlscyBvbiBGZWRvcmEgMjEuCmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkKaW5k ZXggNmUwMDE5OS4uM2Y0M2JmZCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9w b3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvcG9ydC9zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5weQpAQCAtNjYsNiArNjYsMTAgQEAgY2xh c3MgTW9ja0ZpbGUob2JqZWN0KToKICAgICAgICAgc2VsZi5fc2VydmVyX3Byb2Nlc3MuYnJva2Vu X3BpcGVzLmFwcGVuZChzZWxmKQogICAgICAgICByYWlzZSBJT0Vycm9yCiAKKyAgICBkZWYgcmVh ZChzZWxmLCBzaXplPTApOgorICAgICAgICAjIFRoaXMgbWVhbnMgZW5kIG9mIGZpbGUKKyAgICAg ICAgcmV0dXJuICcnCisKICAgICBkZWYgY2xvc2Uoc2VsZik6CiAgICAgICAgIHNlbGYuY2xvc2Vk ID0gVHJ1ZQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CmluZGV4IGNiMGVmMTUuLjE4 OGZhOWUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5Cisr KyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CkBAIC0yNCw4ICsyNCwxMSBA QAogIiIidW5pdCB0ZXN0aW5nIGNvZGUgZm9yIHdlYmtpdHB5LiIiIgogCiBpbXBvcnQgU3RyaW5n SU8KK2ltcG9ydCBpdGVydG9vbHMKK2ltcG9ydCBqc29uCiBpbXBvcnQgbG9nZ2luZwogaW1wb3J0 IG11bHRpcHJvY2Vzc2luZworaW1wb3J0IG9wZXJhdG9yCiBpbXBvcnQgb3B0cGFyc2UKIGltcG9y dCBvcwogaW1wb3J0IHN5cwpAQCAtNzIsNiArNzUsMTcgQEAgZGVmIG1haW4oKToKICAgICByZXR1 cm4gbm90IHRlc3Rlci5ydW4oKQogCiAKK2RlZiBfcHJpbnRfcmVzdWx0c19hc19qc29uKHN0cmVh bSwgdGVzdF9uYW1lcywgZmFpbHVyZXMsIGVycm9ycyk6CisgICAgZGVmIHJlc3VsdF9kaWN0X2Zy b21fdHVwbGUocmVzdWx0X3R1cGxlKToKKyAgICAgICAgcmV0dXJuIHsnbmFtZSc6IHJlc3VsdF90 dXBsZVswXSwgJ3Jlc3VsdCc6IHJlc3VsdF90dXBsZVsxXX0KKworICAgIHJlc3VsdHMgPSB7fQor ICAgIHJlc3VsdHNbJ2ZhaWx1cmVzJ10gPSBtYXAocmVzdWx0X2RpY3RfZnJvbV90dXBsZSwgc29y dGVkKGZhaWx1cmVzLCBrZXk9b3BlcmF0b3IuaXRlbWdldHRlcigwKSkpCisgICAgcmVzdWx0c1sn ZXJyb3JzJ10gPSBtYXAocmVzdWx0X2RpY3RfZnJvbV90dXBsZSwgc29ydGVkKGVycm9ycywga2V5 PW9wZXJhdG9yLml0ZW1nZXR0ZXIoMCkpKQorICAgIHJlc3VsdHNbJ3Rlc3RzJ10gPSBzb3J0ZWQo dGVzdF9uYW1lcykKKyAgICBqc29uLmR1bXAocmVzdWx0cywgc3RyZWFtLCBzZXBhcmF0b3JzPSgn LCcsICc6JykpCisKKwogY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAgICAgZGVmIF9faW5pdF9fKHNl bGYsIGZpbGVzeXN0ZW09Tm9uZSk6CiAgICAgICAgIHNlbGYuZmluZGVyID0gRmluZGVyKGZpbGVz eXN0ZW0gb3IgRmlsZVN5c3RlbSgpKQpAQCAtMTAyLDYgKzExNiw4IEBAIGNsYXNzIFRlc3Rlcihv YmplY3QpOgogICAgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdkaXNwbGF5IHBlci10ZXN0 IGV4ZWN1dGlvbiB0aW1lIChpbXBsaWVzIC0tdmVyYm9zZSknKQogICAgICAgICBwYXJzZXIuYWRk X29wdGlvbignLXYnLCAnLS12ZXJib3NlJywgYWN0aW9uPSdjb3VudCcsIGRlZmF1bHQ9MCwKICAg ICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0ndmVyYm9zZSBvdXRwdXQgKHNwZWNpZnkgb25j ZSBmb3IgaW5kaXZpZHVhbCB0ZXN0IHJlc3VsdHMsIHR3aWNlIGZvciBkZWJ1ZyBtZXNzYWdlcykn KQorICAgICAgICBwYXJzZXIuYWRkX29wdGlvbignLS1qc29uJywgYWN0aW9uPSdzdG9yZV90cnVl JywgZGVmYXVsdD1GYWxzZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0nd3JpdGUg SlNPTiBmb3JtYXR0ZWQgdGVzdCByZXN1bHRzIHRvIHN0ZG91dCcpCiAKICAgICAgICAgcGFyc2Vy LmVwaWxvZyA9ICgnW2FyZ3MuLi5dIGlzIGFuIG9wdGlvbmFsIGxpc3Qgb2YgbW9kdWxlcywgdGVz dF9jbGFzc2VzLCBvciBpbmRpdmlkdWFsIHRlc3RzLiAnCiAgICAgICAgICAgICAgICAgICAgICAg ICAgJ0lmIG5vIGFyZ3MgYXJlIGdpdmVuLCBhbGwgdGhlIHRlc3RzIHdpbGwgYmUgcnVuLicpCkBA IC0xNTYsNiArMTcyLDkgQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAKICAgICAgICAgc2VsZi5w cmludGVyLnByaW50X3Jlc3VsdCh0aW1lLnRpbWUoKSAtIHN0YXJ0KQogCisgICAgICAgIGlmIHNl bGYuX29wdGlvbnMuanNvbjoKKyAgICAgICAgICAgIF9wcmludF9yZXN1bHRzX2FzX2pzb24oc3lz LnN0ZG91dCwgaXRlcnRvb2xzLmNoYWluKHBhcmFsbGVsX3Rlc3RzLCBzZXJpYWxfdGVzdHMpLCB0 ZXN0X3J1bm5lci5mYWlsdXJlcywgdGVzdF9ydW5uZXIuZXJyb3JzKQorCiAgICAgICAgIGlmIHNl bGYuX29wdGlvbnMuY292ZXJhZ2U6CiAgICAgICAgICAgICBjb3Yuc3RvcCgpCiAgICAgICAgICAg ICBjb3Yuc2F2ZSgpCi0tIAoxLjkuMyAoQXBwbGUgR2l0LTUwKQoK 239877 2014-10-15 10:46:25 -0700 2014-10-15 10:51:37 -0700 Removes redundant test names from the list of tests 0001-Add-json-flag-to-test-webkitpy-to-emit-JSON-formatte.patch text/plain 5839 jake.nielsen.webkit RnJvbSAyZmE3OTc3MzJhZGQ4ZDlmMjMxNTRkYWZkMTVlYzU5NGIxZTlhMTcwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBXZWQsIDE1IE9jdCAyMDE0IDEwOjM5OjUzIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0g QWRkIC0tanNvbiBmbGFnIHRvIHRlc3Qtd2Via2l0cHkgdG8gZW1pdCBKU09OIGZvcm1hdHRlZCB0 ZXN0CiByZXN1bHRzIHRvIHN0ZG91dCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTM3MzUzCgpSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiogU2NyaXB0cy93ZWJr aXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5OgpBZGRzIHRoZSByZWFkIG1ldGhv ZCB0byBNb2NrRmlsZSB0byBhbGxvdyB0aGUgc3Rkb3V0IG9mIHRlc3Rfd2Via2l0cHkKdG8gYmUg cmVkaXJlY3RlZCB3aXRob3V0IGNhdXNpbmcgZXJyb25lb3VzIHRlc3QgZmFpbHVyZXMuCkluIHBh cnRpY3VsYXIsCndlYmtpdHB5LnBvcnQuc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QuVGVzdFNlcnZl clByb2Nlc3MudGVzdF9icm9rZW5fcGlwZQphbmQKd2Via2l0cHkucG9ydC5zZXJ2ZXJfcHJvY2Vz c191bml0dGVzdC5UZXN0U2VydmVyUHJvY2Vzcy50ZXN0X2NsZWFudXAKYmVjYXVzZSB3aGVuIHJl ZGlyZWN0aW5nIHRvIGEgZmlsZSwgdGhlCl93YWl0X2Zvcl9kYXRhX2FuZF91cGRhdGVfYnVmZmVy c191c2luZ19zZWxlY3QgbWV0aG9kIGluCnNlcnZlcl9wcm9jZXNzLnB5IHdpbGwgZmluZCB0aGF0 IHRoZXJlIGlzIGEgcmVhZCBmaWxlIGRlc2NyaXB0b3IgaW4KaXRzIGNhbGwgdG8gc2VsZWN0LnNl bGVjdCwgd2hpY2ggZXZlbnR1YWxseSBsZWFkcyB0byBpdCBjYWxsaW5nIHJlYWQoKQpvbiB0aGUg TW9ja0ZpbGUgb2JqZWN0LgooTW9ja0ZpbGUucmVhZCk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0 L21haW4ucHk6CkFkZHMgdGhlIF9wcmludF9yZXN1bHRzX2FzX2pzb24gbWV0aG9kIGFuZCB0aGUg LS1qc29uIGZsYWcgd2hpY2gKZGV0ZXJtaW5lcyB3aGV0aGVyIF9wcmludF9yZXN1bHRzX2FzX2pz b24gd2lsbCBnZXQgY2FsbGVkLgooVGVzdGVyLl9wYXJzZV9hcmdzKToKKFRlc3Rlci5fcHJpbnRf cmVzdWx0c19hc19qc29uKToKKFRlc3Rlci5fcHJpbnRfcmVzdWx0c19hc19qc29uLnJlc3VsdF9k aWN0X2Zyb21fdHVwbGUpOgooVGVzdGVyLl9ydW5fdGVzdHMpOgotLS0KIFRvb2xzL0NoYW5nZUxv ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjkgKysrKysrKysrKysrKysr KysrKysrKwogLi4uL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkgICAg ICAgfCAgNCArKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAg ICAgICAgIHwgMTggKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNTEgaW5zZXJ0aW9u cygrKQoKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRl eCBlYjI0OWE1Li45ZDhhYjBhIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9v bHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTQtMTAtMTMgIEpha2UgTmllbHNlbiAg PGphY29iX25pZWxzZW5AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCAtLWpzb24gZmxhZyB0byB0 ZXN0LXdlYmtpdHB5IHRvIGVtaXQgSlNPTiBmb3JtYXR0ZWQgdGVzdCByZXN1bHRzCisgICAgICAg IHRvIHN0ZG91dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTM3MzUzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHk6Cisg ICAgICAgIEFkZHMgdGhlIHJlYWQgbWV0aG9kIHRvIE1vY2tGaWxlIHRvIGFsbG93IHRoZSBzdGRv dXQgb2YgdGVzdF93ZWJraXRweQorICAgICAgICB0byBiZSByZWRpcmVjdGVkIHdpdGhvdXQgY2F1 c2luZyBlcnJvbmVvdXMgdGVzdCBmYWlsdXJlcy4KKyAgICAgICAgSW4gcGFydGljdWxhciwKKyAg ICAgICAgd2Via2l0cHkucG9ydC5zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5UZXN0U2VydmVyUHJv Y2Vzcy50ZXN0X2Jyb2tlbl9waXBlCisgICAgICAgIGFuZAorICAgICAgICB3ZWJraXRweS5wb3J0 LnNlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LlRlc3RTZXJ2ZXJQcm9jZXNzLnRlc3RfY2xlYW51cAor ICAgICAgICBiZWNhdXNlIHdoZW4gcmVkaXJlY3RpbmcgdG8gYSBmaWxlLCB0aGUKKyAgICAgICAg X3dhaXRfZm9yX2RhdGFfYW5kX3VwZGF0ZV9idWZmZXJzX3VzaW5nX3NlbGVjdCBtZXRob2QgaW4g CisgICAgICAgIHNlcnZlcl9wcm9jZXNzLnB5IHdpbGwgZmluZCB0aGF0IHRoZXJlIGlzIGEgcmVh ZCBmaWxlIGRlc2NyaXB0b3IgaW4KKyAgICAgICAgaXRzIGNhbGwgdG8gc2VsZWN0LnNlbGVjdCwg d2hpY2ggZXZlbnR1YWxseSBsZWFkcyB0byBpdCBjYWxsaW5nIHJlYWQoKQorICAgICAgICBvbiB0 aGUgTW9ja0ZpbGUgb2JqZWN0LgorICAgICAgICAoTW9ja0ZpbGUucmVhZCk6CisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHk6CisgICAgICAgIEFkZHMgdGhlIF9wcmludF9y ZXN1bHRzX2FzX2pzb24gbWV0aG9kIGFuZCB0aGUgLS1qc29uIGZsYWcgd2hpY2gKKyAgICAgICAg ZGV0ZXJtaW5lcyB3aGV0aGVyIF9wcmludF9yZXN1bHRzX2FzX2pzb24gd2lsbCBnZXQgY2FsbGVk LgorICAgICAgICAoVGVzdGVyLl9wYXJzZV9hcmdzKToKKyAgICAgICAgKFRlc3Rlci5fcHJpbnRf cmVzdWx0c19hc19qc29uKToKKyAgICAgICAgKFRlc3Rlci5fcHJpbnRfcmVzdWx0c19hc19qc29u LnJlc3VsdF9kaWN0X2Zyb21fdHVwbGUpOgorICAgICAgICAoVGVzdGVyLl9ydW5fdGVzdHMpOgor CiAyMDE0LTEwLTEzICBDYXJsb3MgQWxiZXJ0byBMb3BleiBQZXJleiAgPGNsb3BlekBpZ2FsaWEu Y29tPgogCiAgICAgICAgIFtYdmZiRHJpdmVyXSBSZWd1bGFyIGV4cHJlc3Npb24gdXNlZCB0byBt YXRjaCBydW5uaW5nIFggc2VydmVycyBmYWlscyBvbiBGZWRvcmEgMjEuCmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkKaW5k ZXggNmUwMDE5OS4uM2Y0M2JmZCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9w b3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvcG9ydC9zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5weQpAQCAtNjYsNiArNjYsMTAgQEAgY2xh c3MgTW9ja0ZpbGUob2JqZWN0KToKICAgICAgICAgc2VsZi5fc2VydmVyX3Byb2Nlc3MuYnJva2Vu X3BpcGVzLmFwcGVuZChzZWxmKQogICAgICAgICByYWlzZSBJT0Vycm9yCiAKKyAgICBkZWYgcmVh ZChzZWxmLCBzaXplPTApOgorICAgICAgICAjIFRoaXMgbWVhbnMgZW5kIG9mIGZpbGUKKyAgICAg ICAgcmV0dXJuICcnCisKICAgICBkZWYgY2xvc2Uoc2VsZik6CiAgICAgICAgIHNlbGYuY2xvc2Vk ID0gVHJ1ZQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CmluZGV4IGNiMGVmMTUuLmIy MDk2MDQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5Cisr KyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CkBAIC0yNCw4ICsyNCwxMSBA QAogIiIidW5pdCB0ZXN0aW5nIGNvZGUgZm9yIHdlYmtpdHB5LiIiIgogCiBpbXBvcnQgU3RyaW5n SU8KK2ltcG9ydCBpdGVydG9vbHMKK2ltcG9ydCBqc29uCiBpbXBvcnQgbG9nZ2luZwogaW1wb3J0 IG11bHRpcHJvY2Vzc2luZworaW1wb3J0IG9wZXJhdG9yCiBpbXBvcnQgb3B0cGFyc2UKIGltcG9y dCBvcwogaW1wb3J0IHN5cwpAQCAtNzEsNiArNzQsMTYgQEAgZGVmIG1haW4oKToKIAogICAgIHJl dHVybiBub3QgdGVzdGVyLnJ1bigpCiAKK2RlZiBfcHJpbnRfcmVzdWx0c19hc19qc29uKHN0cmVh bSwgYWxsX3Rlc3RfbmFtZXMsIGZhaWx1cmVzLCBlcnJvcnMpOgorICAgIGRlZiByZXN1bHRfZGlj dF9mcm9tX3R1cGxlKHJlc3VsdF90dXBsZSk6CisgICAgICAgIHJldHVybiB7J25hbWUnOiByZXN1 bHRfdHVwbGVbMF0sICdyZXN1bHQnOiByZXN1bHRfdHVwbGVbMV19CisKKyAgICByZXN1bHRzID0g e30KKyAgICByZXN1bHRzWydmYWlsdXJlcyddID0gbWFwKHJlc3VsdF9kaWN0X2Zyb21fdHVwbGUs IHNvcnRlZChmYWlsdXJlcywga2V5PW9wZXJhdG9yLml0ZW1nZXR0ZXIoMCkpKQorICAgIHJlc3Vs dHNbJ2Vycm9ycyddID0gbWFwKHJlc3VsdF9kaWN0X2Zyb21fdHVwbGUsIHNvcnRlZChlcnJvcnMs IGtleT1vcGVyYXRvci5pdGVtZ2V0dGVyKDApKSkKKyAgICByZXN1bHRzWyd0ZXN0cyddID0gc29y dGVkKHNldChhbGxfdGVzdF9uYW1lcykgLSBzZXQobWFwKG9wZXJhdG9yLml0ZW1nZXR0ZXIoMCks IGZhaWx1cmVzKSkgLSBzZXQobWFwKG9wZXJhdG9yLml0ZW1nZXR0ZXIoMCksIGVycm9ycykpKQor CisgICAganNvbi5kdW1wKHJlc3VsdHMsIHN0cmVhbSwgc2VwYXJhdG9ycz0oJywnLCAnOicpKQog CiBjbGFzcyBUZXN0ZXIob2JqZWN0KToKICAgICBkZWYgX19pbml0X18oc2VsZiwgZmlsZXN5c3Rl bT1Ob25lKToKQEAgLTEwMiw2ICsxMTUsOCBAQCBjbGFzcyBUZXN0ZXIob2JqZWN0KToKICAgICAg ICAgICAgICAgICAgICAgICAgICAgaGVscD0nZGlzcGxheSBwZXItdGVzdCBleGVjdXRpb24gdGlt ZSAoaW1wbGllcyAtLXZlcmJvc2UpJykKICAgICAgICAgcGFyc2VyLmFkZF9vcHRpb24oJy12Jywg Jy0tdmVyYm9zZScsIGFjdGlvbj0nY291bnQnLCBkZWZhdWx0PTAsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgIGhlbHA9J3ZlcmJvc2Ugb3V0cHV0IChzcGVjaWZ5IG9uY2UgZm9yIGluZGl2aWR1 YWwgdGVzdCByZXN1bHRzLCB0d2ljZSBmb3IgZGVidWcgbWVzc2FnZXMpJykKKyAgICAgICAgcGFy c2VyLmFkZF9vcHRpb24oJy0tanNvbicsIGFjdGlvbj0nc3RvcmVfdHJ1ZScsIGRlZmF1bHQ9RmFs c2UsCisgICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J3dyaXRlIEpTT04gZm9ybWF0dGVk IHRlc3QgcmVzdWx0cyB0byBzdGRvdXQnKQogCiAgICAgICAgIHBhcnNlci5lcGlsb2cgPSAoJ1th cmdzLi4uXSBpcyBhbiBvcHRpb25hbCBsaXN0IG9mIG1vZHVsZXMsIHRlc3RfY2xhc3Nlcywgb3Ig aW5kaXZpZHVhbCB0ZXN0cy4gJwogICAgICAgICAgICAgICAgICAgICAgICAgICdJZiBubyBhcmdz IGFyZSBnaXZlbiwgYWxsIHRoZSB0ZXN0cyB3aWxsIGJlIHJ1bi4nKQpAQCAtMTU2LDYgKzE3MSw5 IEBAIGNsYXNzIFRlc3RlcihvYmplY3QpOgogCiAgICAgICAgIHNlbGYucHJpbnRlci5wcmludF9y ZXN1bHQodGltZS50aW1lKCkgLSBzdGFydCkKIAorICAgICAgICBpZiBzZWxmLl9vcHRpb25zLmpz b246CisgICAgICAgICAgICBfcHJpbnRfcmVzdWx0c19hc19qc29uKHN5cy5zdGRvdXQsIGl0ZXJ0 b29scy5jaGFpbihwYXJhbGxlbF90ZXN0cywgc2VyaWFsX3Rlc3RzKSwgdGVzdF9ydW5uZXIuZmFp bHVyZXMsIHRlc3RfcnVubmVyLmVycm9ycykKKwogICAgICAgICBpZiBzZWxmLl9vcHRpb25zLmNv dmVyYWdlOgogICAgICAgICAgICAgY292LnN0b3AoKQogICAgICAgICAgICAgY292LnNhdmUoKQot LSAKMS45LjMgKEFwcGxlIEdpdC01MCkKCg== 239878 2014-10-15 10:51:37 -0700 2014-10-15 12:46:14 -0700 Fixes style issues 0001-Add-json-flag-to-test-webkitpy-to-emit-JSON-formatte.patch text/plain 5897 jake.nielsen.webkit RnJvbSBkMmI5Y2U5NzAxY2EzZmRiNzdiZWExN2ZjZDM0YjYxYzEyODE1OTM3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBXZWQsIDE1IE9jdCAyMDE0IDEwOjUwOjM2IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0g QWRkIC0tanNvbiBmbGFnIHRvIHRlc3Qtd2Via2l0cHkgdG8gZW1pdCBKU09OIGZvcm1hdHRlZCB0 ZXN0CiByZXN1bHRzIHRvIHN0ZG91dCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTM3MzUzCgpSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiogU2NyaXB0cy93ZWJr aXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5OgpBZGRzIHRoZSByZWFkIG1ldGhv ZCB0byBNb2NrRmlsZSB0byBhbGxvdyB0aGUgc3Rkb3V0IG9mIHRlc3Rfd2Via2l0cHkKdG8gYmUg cmVkaXJlY3RlZCB3aXRob3V0IGNhdXNpbmcgZXJyb25lb3VzIHRlc3QgZmFpbHVyZXMuCkluIHBh cnRpY3VsYXIsCndlYmtpdHB5LnBvcnQuc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QuVGVzdFNlcnZl clByb2Nlc3MudGVzdF9icm9rZW5fcGlwZQphbmQKd2Via2l0cHkucG9ydC5zZXJ2ZXJfcHJvY2Vz c191bml0dGVzdC5UZXN0U2VydmVyUHJvY2Vzcy50ZXN0X2NsZWFudXAKYmVjYXVzZSB3aGVuIHJl ZGlyZWN0aW5nIHRvIGEgZmlsZSwgdGhlCl93YWl0X2Zvcl9kYXRhX2FuZF91cGRhdGVfYnVmZmVy c191c2luZ19zZWxlY3QgbWV0aG9kIGluCnNlcnZlcl9wcm9jZXNzLnB5IHdpbGwgZmluZCB0aGF0 IHRoZXJlIGlzIGEgcmVhZCBmaWxlIGRlc2NyaXB0b3IgaW4KaXRzIGNhbGwgdG8gc2VsZWN0LnNl bGVjdCwgd2hpY2ggZXZlbnR1YWxseSBsZWFkcyB0byBpdCBjYWxsaW5nIHJlYWQoKQpvbiB0aGUg TW9ja0ZpbGUgb2JqZWN0LgooTW9ja0ZpbGUucmVhZCk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0 L21haW4ucHk6CkFkZHMgdGhlIF9wcmludF9yZXN1bHRzX2FzX2pzb24gbWV0aG9kIGFuZCB0aGUg LS1qc29uIGZsYWcgd2hpY2gKZGV0ZXJtaW5lcyB3aGV0aGVyIF9wcmludF9yZXN1bHRzX2FzX2pz b24gd2lsbCBnZXQgY2FsbGVkLgooVGVzdGVyLl9wYXJzZV9hcmdzKToKKFRlc3Rlci5fcHJpbnRf cmVzdWx0c19hc19qc29uKToKKFRlc3Rlci5fcHJpbnRfcmVzdWx0c19hc19qc29uLnJlc3VsdF9k aWN0X2Zyb21fdHVwbGUpOgooVGVzdGVyLl9ydW5fdGVzdHMpOgotLS0KIFRvb2xzL0NoYW5nZUxv ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjkgKysrKysrKysrKysrKysr KysrKysrKwogLi4uL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkgICAg ICAgfCAgNCArKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAg ICAgICAgIHwgMTkgKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNTIgaW5zZXJ0aW9u cygrKQoKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRl eCBlYjI0OWE1Li45ZDhhYjBhIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9v bHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTQtMTAtMTMgIEpha2UgTmllbHNlbiAg PGphY29iX25pZWxzZW5AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCAtLWpzb24gZmxhZyB0byB0 ZXN0LXdlYmtpdHB5IHRvIGVtaXQgSlNPTiBmb3JtYXR0ZWQgdGVzdCByZXN1bHRzCisgICAgICAg IHRvIHN0ZG91dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTM3MzUzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHk6Cisg ICAgICAgIEFkZHMgdGhlIHJlYWQgbWV0aG9kIHRvIE1vY2tGaWxlIHRvIGFsbG93IHRoZSBzdGRv dXQgb2YgdGVzdF93ZWJraXRweQorICAgICAgICB0byBiZSByZWRpcmVjdGVkIHdpdGhvdXQgY2F1 c2luZyBlcnJvbmVvdXMgdGVzdCBmYWlsdXJlcy4KKyAgICAgICAgSW4gcGFydGljdWxhciwKKyAg ICAgICAgd2Via2l0cHkucG9ydC5zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5UZXN0U2VydmVyUHJv Y2Vzcy50ZXN0X2Jyb2tlbl9waXBlCisgICAgICAgIGFuZAorICAgICAgICB3ZWJraXRweS5wb3J0 LnNlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LlRlc3RTZXJ2ZXJQcm9jZXNzLnRlc3RfY2xlYW51cAor ICAgICAgICBiZWNhdXNlIHdoZW4gcmVkaXJlY3RpbmcgdG8gYSBmaWxlLCB0aGUKKyAgICAgICAg X3dhaXRfZm9yX2RhdGFfYW5kX3VwZGF0ZV9idWZmZXJzX3VzaW5nX3NlbGVjdCBtZXRob2QgaW4g CisgICAgICAgIHNlcnZlcl9wcm9jZXNzLnB5IHdpbGwgZmluZCB0aGF0IHRoZXJlIGlzIGEgcmVh ZCBmaWxlIGRlc2NyaXB0b3IgaW4KKyAgICAgICAgaXRzIGNhbGwgdG8gc2VsZWN0LnNlbGVjdCwg d2hpY2ggZXZlbnR1YWxseSBsZWFkcyB0byBpdCBjYWxsaW5nIHJlYWQoKQorICAgICAgICBvbiB0 aGUgTW9ja0ZpbGUgb2JqZWN0LgorICAgICAgICAoTW9ja0ZpbGUucmVhZCk6CisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHk6CisgICAgICAgIEFkZHMgdGhlIF9wcmludF9y ZXN1bHRzX2FzX2pzb24gbWV0aG9kIGFuZCB0aGUgLS1qc29uIGZsYWcgd2hpY2gKKyAgICAgICAg ZGV0ZXJtaW5lcyB3aGV0aGVyIF9wcmludF9yZXN1bHRzX2FzX2pzb24gd2lsbCBnZXQgY2FsbGVk LgorICAgICAgICAoVGVzdGVyLl9wYXJzZV9hcmdzKToKKyAgICAgICAgKFRlc3Rlci5fcHJpbnRf cmVzdWx0c19hc19qc29uKToKKyAgICAgICAgKFRlc3Rlci5fcHJpbnRfcmVzdWx0c19hc19qc29u LnJlc3VsdF9kaWN0X2Zyb21fdHVwbGUpOgorICAgICAgICAoVGVzdGVyLl9ydW5fdGVzdHMpOgor CiAyMDE0LTEwLTEzICBDYXJsb3MgQWxiZXJ0byBMb3BleiBQZXJleiAgPGNsb3BlekBpZ2FsaWEu Y29tPgogCiAgICAgICAgIFtYdmZiRHJpdmVyXSBSZWd1bGFyIGV4cHJlc3Npb24gdXNlZCB0byBt YXRjaCBydW5uaW5nIFggc2VydmVycyBmYWlscyBvbiBGZWRvcmEgMjEuCmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkKaW5k ZXggNmUwMDE5OS4uM2Y0M2JmZCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9w b3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvcG9ydC9zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5weQpAQCAtNjYsNiArNjYsMTAgQEAgY2xh c3MgTW9ja0ZpbGUob2JqZWN0KToKICAgICAgICAgc2VsZi5fc2VydmVyX3Byb2Nlc3MuYnJva2Vu X3BpcGVzLmFwcGVuZChzZWxmKQogICAgICAgICByYWlzZSBJT0Vycm9yCiAKKyAgICBkZWYgcmVh ZChzZWxmLCBzaXplPTApOgorICAgICAgICAjIFRoaXMgbWVhbnMgZW5kIG9mIGZpbGUKKyAgICAg ICAgcmV0dXJuICcnCisKICAgICBkZWYgY2xvc2Uoc2VsZik6CiAgICAgICAgIHNlbGYuY2xvc2Vk ID0gVHJ1ZQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CmluZGV4IGNiMGVmMTUuLmY1 MWU2MjYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5Cisr KyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CkBAIC0yNCw4ICsyNCwxMSBA QAogIiIidW5pdCB0ZXN0aW5nIGNvZGUgZm9yIHdlYmtpdHB5LiIiIgogCiBpbXBvcnQgU3RyaW5n SU8KK2ltcG9ydCBpdGVydG9vbHMKK2ltcG9ydCBqc29uCiBpbXBvcnQgbG9nZ2luZwogaW1wb3J0 IG11bHRpcHJvY2Vzc2luZworaW1wb3J0IG9wZXJhdG9yCiBpbXBvcnQgb3B0cGFyc2UKIGltcG9y dCBvcwogaW1wb3J0IHN5cwpAQCAtNzIsNiArNzUsMTcgQEAgZGVmIG1haW4oKToKICAgICByZXR1 cm4gbm90IHRlc3Rlci5ydW4oKQogCiAKK2RlZiBfcHJpbnRfcmVzdWx0c19hc19qc29uKHN0cmVh bSwgYWxsX3Rlc3RfbmFtZXMsIGZhaWx1cmVzLCBlcnJvcnMpOgorICAgIGRlZiByZXN1bHRfZGlj dF9mcm9tX3R1cGxlKHJlc3VsdF90dXBsZSk6CisgICAgICAgIHJldHVybiB7J25hbWUnOiByZXN1 bHRfdHVwbGVbMF0sICdyZXN1bHQnOiByZXN1bHRfdHVwbGVbMV19CisKKyAgICByZXN1bHRzID0g e30KKyAgICByZXN1bHRzWydmYWlsdXJlcyddID0gbWFwKHJlc3VsdF9kaWN0X2Zyb21fdHVwbGUs IHNvcnRlZChmYWlsdXJlcywga2V5PW9wZXJhdG9yLml0ZW1nZXR0ZXIoMCkpKQorICAgIHJlc3Vs dHNbJ2Vycm9ycyddID0gbWFwKHJlc3VsdF9kaWN0X2Zyb21fdHVwbGUsIHNvcnRlZChlcnJvcnMs IGtleT1vcGVyYXRvci5pdGVtZ2V0dGVyKDApKSkKKyAgICByZXN1bHRzWyd0ZXN0cyddID0gc29y dGVkKHNldChhbGxfdGVzdF9uYW1lcykgLSBzZXQobWFwKG9wZXJhdG9yLml0ZW1nZXR0ZXIoMCks IGZhaWx1cmVzKSkgLSBzZXQobWFwKG9wZXJhdG9yLml0ZW1nZXR0ZXIoMCksIGVycm9ycykpKQor CisgICAganNvbi5kdW1wKHJlc3VsdHMsIHN0cmVhbSwgc2VwYXJhdG9ycz0oJywnLCAnOicpKQor CiBjbGFzcyBUZXN0ZXIob2JqZWN0KToKICAgICBkZWYgX19pbml0X18oc2VsZiwgZmlsZXN5c3Rl bT1Ob25lKToKICAgICAgICAgc2VsZi5maW5kZXIgPSBGaW5kZXIoZmlsZXN5c3RlbSBvciBGaWxl U3lzdGVtKCkpCkBAIC0xMDIsNiArMTE2LDggQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAgICAg ICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2Rpc3BsYXkgcGVyLXRlc3QgZXhlY3V0aW9uIHRp bWUgKGltcGxpZXMgLS12ZXJib3NlKScpCiAgICAgICAgIHBhcnNlci5hZGRfb3B0aW9uKCctdics ICctLXZlcmJvc2UnLCBhY3Rpb249J2NvdW50JywgZGVmYXVsdD0wLAogICAgICAgICAgICAgICAg ICAgICAgICAgICBoZWxwPSd2ZXJib3NlIG91dHB1dCAoc3BlY2lmeSBvbmNlIGZvciBpbmRpdmlk dWFsIHRlc3QgcmVzdWx0cywgdHdpY2UgZm9yIGRlYnVnIG1lc3NhZ2VzKScpCisgICAgICAgIHBh cnNlci5hZGRfb3B0aW9uKCctLWpzb24nLCBhY3Rpb249J3N0b3JlX3RydWUnLCBkZWZhdWx0PUZh bHNlLAorICAgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSd3cml0ZSBKU09OIGZvcm1hdHRl ZCB0ZXN0IHJlc3VsdHMgdG8gc3Rkb3V0JykKIAogICAgICAgICBwYXJzZXIuZXBpbG9nID0gKCdb YXJncy4uLl0gaXMgYW4gb3B0aW9uYWwgbGlzdCBvZiBtb2R1bGVzLCB0ZXN0X2NsYXNzZXMsIG9y IGluZGl2aWR1YWwgdGVzdHMuICcKICAgICAgICAgICAgICAgICAgICAgICAgICAnSWYgbm8gYXJn cyBhcmUgZ2l2ZW4sIGFsbCB0aGUgdGVzdHMgd2lsbCBiZSBydW4uJykKQEAgLTE1Niw2ICsxNzIs OSBAQCBjbGFzcyBUZXN0ZXIob2JqZWN0KToKIAogICAgICAgICBzZWxmLnByaW50ZXIucHJpbnRf cmVzdWx0KHRpbWUudGltZSgpIC0gc3RhcnQpCiAKKyAgICAgICAgaWYgc2VsZi5fb3B0aW9ucy5q c29uOgorICAgICAgICAgICAgX3ByaW50X3Jlc3VsdHNfYXNfanNvbihzeXMuc3Rkb3V0LCBpdGVy dG9vbHMuY2hhaW4ocGFyYWxsZWxfdGVzdHMsIHNlcmlhbF90ZXN0cyksIHRlc3RfcnVubmVyLmZh aWx1cmVzLCB0ZXN0X3J1bm5lci5lcnJvcnMpCisKICAgICAgICAgaWYgc2VsZi5fb3B0aW9ucy5j b3ZlcmFnZToKICAgICAgICAgICAgIGNvdi5zdG9wKCkKICAgICAgICAgICAgIGNvdi5zYXZlKCkK LS0gCjEuOS4zIChBcHBsZSBHaXQtNTApCgo= 239884 2014-10-15 12:46:14 -0700 2014-10-15 13:56:17 -0700 Dictionary key change 0001-Add-json-flag-to-test-webkitpy-to-emit-JSON-formatte.patch text/plain 5898 jake.nielsen.webkit RnJvbSBiNTRjNDYxYmVjZmE1MDliMTdlNWYzODhkNTFhMTY2NmUxYWRhYzFhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBXZWQsIDE1IE9jdCAyMDE0IDEyOjQ1OjExIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0g QWRkIC0tanNvbiBmbGFnIHRvIHRlc3Qtd2Via2l0cHkgdG8gZW1pdCBKU09OIGZvcm1hdHRlZCB0 ZXN0CiByZXN1bHRzIHRvIHN0ZG91dCBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTM3MzUzCgpSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiogU2NyaXB0cy93ZWJr aXRweS9wb3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5OgpBZGRzIHRoZSByZWFkIG1ldGhv ZCB0byBNb2NrRmlsZSB0byBhbGxvdyB0aGUgc3Rkb3V0IG9mIHRlc3Rfd2Via2l0cHkKdG8gYmUg cmVkaXJlY3RlZCB3aXRob3V0IGNhdXNpbmcgZXJyb25lb3VzIHRlc3QgZmFpbHVyZXMuCkluIHBh cnRpY3VsYXIsCndlYmtpdHB5LnBvcnQuc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QuVGVzdFNlcnZl clByb2Nlc3MudGVzdF9icm9rZW5fcGlwZQphbmQKd2Via2l0cHkucG9ydC5zZXJ2ZXJfcHJvY2Vz c191bml0dGVzdC5UZXN0U2VydmVyUHJvY2Vzcy50ZXN0X2NsZWFudXAKYmVjYXVzZSB3aGVuIHJl ZGlyZWN0aW5nIHRvIGEgZmlsZSwgdGhlCl93YWl0X2Zvcl9kYXRhX2FuZF91cGRhdGVfYnVmZmVy c191c2luZ19zZWxlY3QgbWV0aG9kIGluCnNlcnZlcl9wcm9jZXNzLnB5IHdpbGwgZmluZCB0aGF0 IHRoZXJlIGlzIGEgcmVhZCBmaWxlIGRlc2NyaXB0b3IgaW4KaXRzIGNhbGwgdG8gc2VsZWN0LnNl bGVjdCwgd2hpY2ggZXZlbnR1YWxseSBsZWFkcyB0byBpdCBjYWxsaW5nIHJlYWQoKQpvbiB0aGUg TW9ja0ZpbGUgb2JqZWN0LgooTW9ja0ZpbGUucmVhZCk6CiogU2NyaXB0cy93ZWJraXRweS90ZXN0 L21haW4ucHk6CkFkZHMgdGhlIF9wcmludF9yZXN1bHRzX2FzX2pzb24gbWV0aG9kIGFuZCB0aGUg LS1qc29uIGZsYWcgd2hpY2gKZGV0ZXJtaW5lcyB3aGV0aGVyIF9wcmludF9yZXN1bHRzX2FzX2pz b24gd2lsbCBnZXQgY2FsbGVkLgooVGVzdGVyLl9wYXJzZV9hcmdzKToKKFRlc3Rlci5fcHJpbnRf cmVzdWx0c19hc19qc29uKToKKFRlc3Rlci5fcHJpbnRfcmVzdWx0c19hc19qc29uLnJlc3VsdF9k aWN0X2Zyb21fdHVwbGUpOgooVGVzdGVyLl9ydW5fdGVzdHMpOgotLS0KIFRvb2xzL0NoYW5nZUxv ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjkgKysrKysrKysrKysrKysr KysrKysrKwogLi4uL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkgICAg ICAgfCAgNCArKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5ICAgICAgICAg ICAgICAgIHwgMTkgKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNTIgaW5zZXJ0aW9u cygrKQoKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRl eCBlYjI0OWE1Li45ZDhhYjBhIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9v bHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTQtMTAtMTMgIEpha2UgTmllbHNlbiAg PGphY29iX25pZWxzZW5AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCAtLWpzb24gZmxhZyB0byB0 ZXN0LXdlYmtpdHB5IHRvIGVtaXQgSlNPTiBmb3JtYXR0ZWQgdGVzdCByZXN1bHRzCisgICAgICAg IHRvIHN0ZG91dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTM3MzUzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHk6Cisg ICAgICAgIEFkZHMgdGhlIHJlYWQgbWV0aG9kIHRvIE1vY2tGaWxlIHRvIGFsbG93IHRoZSBzdGRv dXQgb2YgdGVzdF93ZWJraXRweQorICAgICAgICB0byBiZSByZWRpcmVjdGVkIHdpdGhvdXQgY2F1 c2luZyBlcnJvbmVvdXMgdGVzdCBmYWlsdXJlcy4KKyAgICAgICAgSW4gcGFydGljdWxhciwKKyAg ICAgICAgd2Via2l0cHkucG9ydC5zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5UZXN0U2VydmVyUHJv Y2Vzcy50ZXN0X2Jyb2tlbl9waXBlCisgICAgICAgIGFuZAorICAgICAgICB3ZWJraXRweS5wb3J0 LnNlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LlRlc3RTZXJ2ZXJQcm9jZXNzLnRlc3RfY2xlYW51cAor ICAgICAgICBiZWNhdXNlIHdoZW4gcmVkaXJlY3RpbmcgdG8gYSBmaWxlLCB0aGUKKyAgICAgICAg X3dhaXRfZm9yX2RhdGFfYW5kX3VwZGF0ZV9idWZmZXJzX3VzaW5nX3NlbGVjdCBtZXRob2QgaW4g CisgICAgICAgIHNlcnZlcl9wcm9jZXNzLnB5IHdpbGwgZmluZCB0aGF0IHRoZXJlIGlzIGEgcmVh ZCBmaWxlIGRlc2NyaXB0b3IgaW4KKyAgICAgICAgaXRzIGNhbGwgdG8gc2VsZWN0LnNlbGVjdCwg d2hpY2ggZXZlbnR1YWxseSBsZWFkcyB0byBpdCBjYWxsaW5nIHJlYWQoKQorICAgICAgICBvbiB0 aGUgTW9ja0ZpbGUgb2JqZWN0LgorICAgICAgICAoTW9ja0ZpbGUucmVhZCk6CisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS90ZXN0L21haW4ucHk6CisgICAgICAgIEFkZHMgdGhlIF9wcmludF9y ZXN1bHRzX2FzX2pzb24gbWV0aG9kIGFuZCB0aGUgLS1qc29uIGZsYWcgd2hpY2gKKyAgICAgICAg ZGV0ZXJtaW5lcyB3aGV0aGVyIF9wcmludF9yZXN1bHRzX2FzX2pzb24gd2lsbCBnZXQgY2FsbGVk LgorICAgICAgICAoVGVzdGVyLl9wYXJzZV9hcmdzKToKKyAgICAgICAgKFRlc3Rlci5fcHJpbnRf cmVzdWx0c19hc19qc29uKToKKyAgICAgICAgKFRlc3Rlci5fcHJpbnRfcmVzdWx0c19hc19qc29u LnJlc3VsdF9kaWN0X2Zyb21fdHVwbGUpOgorICAgICAgICAoVGVzdGVyLl9ydW5fdGVzdHMpOgor CiAyMDE0LTEwLTEzICBDYXJsb3MgQWxiZXJ0byBMb3BleiBQZXJleiAgPGNsb3BlekBpZ2FsaWEu Y29tPgogCiAgICAgICAgIFtYdmZiRHJpdmVyXSBSZWd1bGFyIGV4cHJlc3Npb24gdXNlZCB0byBt YXRjaCBydW5uaW5nIFggc2VydmVycyBmYWlscyBvbiBGZWRvcmEgMjEuCmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvc2VydmVyX3Byb2Nlc3NfdW5pdHRlc3QucHkKaW5k ZXggNmUwMDE5OS4uM2Y0M2JmZCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9w b3J0L3NlcnZlcl9wcm9jZXNzX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvcG9ydC9zZXJ2ZXJfcHJvY2Vzc191bml0dGVzdC5weQpAQCAtNjYsNiArNjYsMTAgQEAgY2xh c3MgTW9ja0ZpbGUob2JqZWN0KToKICAgICAgICAgc2VsZi5fc2VydmVyX3Byb2Nlc3MuYnJva2Vu X3BpcGVzLmFwcGVuZChzZWxmKQogICAgICAgICByYWlzZSBJT0Vycm9yCiAKKyAgICBkZWYgcmVh ZChzZWxmLCBzaXplPTApOgorICAgICAgICAjIFRoaXMgbWVhbnMgZW5kIG9mIGZpbGUKKyAgICAg ICAgcmV0dXJuICcnCisKICAgICBkZWYgY2xvc2Uoc2VsZik6CiAgICAgICAgIHNlbGYuY2xvc2Vk ID0gVHJ1ZQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3QvbWFpbi5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CmluZGV4IGNiMGVmMTUuLmVm NGU3MGUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5Cisr KyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9tYWluLnB5CkBAIC0yNCw4ICsyNCwxMSBA QAogIiIidW5pdCB0ZXN0aW5nIGNvZGUgZm9yIHdlYmtpdHB5LiIiIgogCiBpbXBvcnQgU3RyaW5n SU8KK2ltcG9ydCBpdGVydG9vbHMKK2ltcG9ydCBqc29uCiBpbXBvcnQgbG9nZ2luZwogaW1wb3J0 IG11bHRpcHJvY2Vzc2luZworaW1wb3J0IG9wZXJhdG9yCiBpbXBvcnQgb3B0cGFyc2UKIGltcG9y dCBvcwogaW1wb3J0IHN5cwpAQCAtNzIsNiArNzUsMTcgQEAgZGVmIG1haW4oKToKICAgICByZXR1 cm4gbm90IHRlc3Rlci5ydW4oKQogCiAKK2RlZiBfcHJpbnRfcmVzdWx0c19hc19qc29uKHN0cmVh bSwgYWxsX3Rlc3RfbmFtZXMsIGZhaWx1cmVzLCBlcnJvcnMpOgorICAgIGRlZiByZXN1bHRfZGlj dF9mcm9tX3R1cGxlKHJlc3VsdF90dXBsZSk6CisgICAgICAgIHJldHVybiB7J25hbWUnOiByZXN1 bHRfdHVwbGVbMF0sICdyZXN1bHQnOiByZXN1bHRfdHVwbGVbMV19CisKKyAgICByZXN1bHRzID0g e30KKyAgICByZXN1bHRzWydmYWlsdXJlcyddID0gbWFwKHJlc3VsdF9kaWN0X2Zyb21fdHVwbGUs IHNvcnRlZChmYWlsdXJlcywga2V5PW9wZXJhdG9yLml0ZW1nZXR0ZXIoMCkpKQorICAgIHJlc3Vs dHNbJ2Vycm9ycyddID0gbWFwKHJlc3VsdF9kaWN0X2Zyb21fdHVwbGUsIHNvcnRlZChlcnJvcnMs IGtleT1vcGVyYXRvci5pdGVtZ2V0dGVyKDApKSkKKyAgICByZXN1bHRzWydwYXNzZXMnXSA9IHNv cnRlZChzZXQoYWxsX3Rlc3RfbmFtZXMpIC0gc2V0KG1hcChvcGVyYXRvci5pdGVtZ2V0dGVyKDAp LCBmYWlsdXJlcykpIC0gc2V0KG1hcChvcGVyYXRvci5pdGVtZ2V0dGVyKDApLCBlcnJvcnMpKSkK KworICAgIGpzb24uZHVtcChyZXN1bHRzLCBzdHJlYW0sIHNlcGFyYXRvcnM9KCcsJywgJzonKSkK KwogY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIGZpbGVzeXN0 ZW09Tm9uZSk6CiAgICAgICAgIHNlbGYuZmluZGVyID0gRmluZGVyKGZpbGVzeXN0ZW0gb3IgRmls ZVN5c3RlbSgpKQpAQCAtMTAyLDYgKzExNiw4IEBAIGNsYXNzIFRlc3RlcihvYmplY3QpOgogICAg ICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdkaXNwbGF5IHBlci10ZXN0IGV4ZWN1dGlvbiB0 aW1lIChpbXBsaWVzIC0tdmVyYm9zZSknKQogICAgICAgICBwYXJzZXIuYWRkX29wdGlvbignLXYn LCAnLS12ZXJib3NlJywgYWN0aW9uPSdjb3VudCcsIGRlZmF1bHQ9MCwKICAgICAgICAgICAgICAg ICAgICAgICAgICAgaGVscD0ndmVyYm9zZSBvdXRwdXQgKHNwZWNpZnkgb25jZSBmb3IgaW5kaXZp ZHVhbCB0ZXN0IHJlc3VsdHMsIHR3aWNlIGZvciBkZWJ1ZyBtZXNzYWdlcyknKQorICAgICAgICBw YXJzZXIuYWRkX29wdGlvbignLS1qc29uJywgYWN0aW9uPSdzdG9yZV90cnVlJywgZGVmYXVsdD1G YWxzZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0nd3JpdGUgSlNPTiBmb3JtYXR0 ZWQgdGVzdCByZXN1bHRzIHRvIHN0ZG91dCcpCiAKICAgICAgICAgcGFyc2VyLmVwaWxvZyA9ICgn W2FyZ3MuLi5dIGlzIGFuIG9wdGlvbmFsIGxpc3Qgb2YgbW9kdWxlcywgdGVzdF9jbGFzc2VzLCBv ciBpbmRpdmlkdWFsIHRlc3RzLiAnCiAgICAgICAgICAgICAgICAgICAgICAgICAgJ0lmIG5vIGFy Z3MgYXJlIGdpdmVuLCBhbGwgdGhlIHRlc3RzIHdpbGwgYmUgcnVuLicpCkBAIC0xNTYsNiArMTcy LDkgQEAgY2xhc3MgVGVzdGVyKG9iamVjdCk6CiAKICAgICAgICAgc2VsZi5wcmludGVyLnByaW50 X3Jlc3VsdCh0aW1lLnRpbWUoKSAtIHN0YXJ0KQogCisgICAgICAgIGlmIHNlbGYuX29wdGlvbnMu anNvbjoKKyAgICAgICAgICAgIF9wcmludF9yZXN1bHRzX2FzX2pzb24oc3lzLnN0ZG91dCwgaXRl cnRvb2xzLmNoYWluKHBhcmFsbGVsX3Rlc3RzLCBzZXJpYWxfdGVzdHMpLCB0ZXN0X3J1bm5lci5m YWlsdXJlcywgdGVzdF9ydW5uZXIuZXJyb3JzKQorCiAgICAgICAgIGlmIHNlbGYuX29wdGlvbnMu Y292ZXJhZ2U6CiAgICAgICAgICAgICBjb3Yuc3RvcCgpCiAgICAgICAgICAgICBjb3Yuc2F2ZSgp Ci0tIAoxLjkuMyAoQXBwbGUgR2l0LTUwKQoK