138184 2014-10-29 14:19:40 -0700 CommitQueue and EWS should reject any patches that result in consistent test failures that aren't present on the tree. 2014-10-30 11:33:16 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 jake.nielsen.webkit jake.nielsen.webkit ap buildbot commit-queue dbates glenn rniwa oldest_to_newest 1044829 0 jake.nielsen.webkit 2014-10-29 14:19:40 -0700 Example: https://bugs.webkit.org/show_bug.cgi?id=137132 1044835 1 240624 jake.nielsen.webkit 2014-10-29 14:24:52 -0700 Created attachment 240624 Alters PatchAnalysisTask's behavior, and changes the unit tests accordingly. 1044851 2 240624 ap 2014-10-29 14:49:12 -0700 Comment on attachment 240624 Alters PatchAnalysisTask's behavior, and changes the unit tests accordingly. View in context: https://bugs.webkit.org/attachment.cgi?id=240624&action=review > Tools/ChangeLog:3 > + CommitQueue should reject any patches result in consistent test Is it just the commit queue? > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:-231 > - # we happen to hit the --exit-after-N-failures limit. Do we have enough test coverage for when we hit the limit of failures? > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:228 > + tests_that_only_failed_first = list(set(first_results.failing_test_results()) - set(second_results.failing_test_results())) Why is it not always a set? It seems wasteful to convert every time. > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:243 > + new_failures_introduced_by_patch = list(set(tests_that_consistently_failed) - set(tests_that_failed_on_tree)) > + if new_failures_introduced_by_patch: > + self.failure_status_id = first_failure_status_id > + return self.report_failure(first_results_archive, new_failures_introduced_by_patch, first_script_error) I don't think that this heuristic is quite right. If there is enough flakiness in the tree, we could reject a perfectly good patch. We should probably refuse to give a result when there is much flakiness. However, I'm not sure what "enough" would be here. > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:247 > + # were introduced. This is a bit of a grey-zone, and for now I will leave this code path as it was, > + # AKA, defer. I'd finish this after "grey-zone", as the rest is not very helpful to the reader. 1044852 3 240624 dbates 2014-10-29 14:55:45 -0700 Comment on attachment 240624 Alters PatchAnalysisTask's behavior, and changes the unit tests accordingly. View in context: https://bugs.webkit.org/attachment.cgi?id=240624&action=review I didn't check this patch for correctness. I noticed some minor nits and had some questions. > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:234 > + tests_that_only_failed_first = list(set(first_results.failing_test_results()) - set(second_results.failing_test_results())) > + self._report_flaky_tests(tests_that_only_failed_first, first_results_archive) > + > + tests_that_only_failed_second = list(set(second_results.failing_test_results()) - set(first_results.failing_test_results())) > + self._report_flaky_tests(tests_that_only_failed_second, second_results_archive) > + > + tests_that_consistently_failed = list(set(second_results.failing_test_results()) & set(first_results.failing_test_results())) This is inefficient as we are computing set(first_results.failing_test_results()) and set(second_results.failing_test_results()) multiple times. We should compute these values once. Is it necessary to create mutable sets? Or can we use frozenset()? As far as I can tell from briefly searching through the Python code we prefer using set.intersection() over the overloaded binary-and operator (&) when computing the intersection of two sets/frozensets. I suggest we use set.intersection() for consistency. See <https://docs.python.org/2/library/stdtypes.html#frozenset> for more details on frozenset(). > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:240 > + new_failures_introduced_by_patch = list(set(tests_that_consistently_failed) - set(tests_that_failed_on_tree)) Notice that we made tests_that_consistently_failed a list data type above (line 234) by explicitly passing the right-hand side set computation to the list constructor. Instead of converting tests_that_consistently_failed from a set to a list to a set, I suggest we let tests_that_consistently_failed be a set. > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:245 > + # At this point we know that there is flakyness with the patch applied, but no consistent failures Nit: flakyness => flakiness 1044856 4 240630 jake.nielsen.webkit 2014-10-29 15:01:53 -0700 Created attachment 240630 Addresses comments 1044863 5 240630 dbates 2014-10-29 15:11:20 -0700 Comment on attachment 240630 Addresses comments View in context: https://bugs.webkit.org/attachment.cgi?id=240630&action=review > Tools/Scripts/webkitpy/tool/bot/commitqueuetask_unittest.py:178 > + self.assertEqual(set(commit_queue.get_reported_flaky_tests()), set(expected_reported_flaky_tests)) Can you elaborate on this change? 1044865 6 jake.nielsen.webkit 2014-10-29 15:19:46 -0700 I just stepped out for some food, but I'll address these comments when I get back. 1044895 7 jake.nielsen.webkit 2014-10-29 16:05:49 -0700 (In reply to comment #5) > Comment on attachment 240630 [details] > Addresses comments > > View in context: > https://bugs.webkit.org/attachment.cgi?id=240630&action=review > > > Tools/Scripts/webkitpy/tool/bot/commitqueuetask_unittest.py:178 > > + self.assertEqual(set(commit_queue.get_reported_flaky_tests()), set(expected_reported_flaky_tests)) > > Can you elaborate on this change? This just makes it less annoying to define which tests you expect to get reported. The order in which they appear doesn't matter, so checking set equality makes more sense. 1044896 8 240637 jake.nielsen.webkit 2014-10-29 16:09:12 -0700 Created attachment 240637 Changes sets to frozen sets, and computes frozenset(first_results.failing_test_results()) only once. 1044980 9 240637 commit-queue 2014-10-29 22:02:30 -0700 Comment on attachment 240637 Changes sets to frozen sets, and computes frozenset(first_results.failing_test_results()) only once. Clearing flags on attachment: 240637 Committed r175367: <http://trac.webkit.org/changeset/175367> 1044981 10 commit-queue 2014-10-29 22:02:35 -0700 All reviewed patches have been landed. Closing bug. 1045046 11 240637 dbates 2014-10-30 09:52:04 -0700 Comment on attachment 240637 Changes sets to frozen sets, and computes frozenset(first_results.failing_test_results()) only once. View in context: https://bugs.webkit.org/attachment.cgi?id=240637&action=review I know that this patch already landed. I noticed some minor issues and had some questions about the correctness of this patch. > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:-232 > - # See https://bugs.webkit.org/show_bug.cgi?id=51272 Out of curiosity, did you have a chance to look at the posted patches and discussion in bug #51272? If so, are the concerns raised about --exit-after-N-failures and test ordering non-issues? In particular, is <https://bugs.webkit.org/show_bug.cgi?id=51272#c3> a non-issue? > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:235 > + tests_that_only_failed_second = second_failing_results_set.difference(first_failing_results_set) > + self._report_flaky_tests(tests_that_only_failed_second, second_results_archive) The following assumes <https://bugs.webkit.org/show_bug.cgi?id=51272#c3> is still applicable (see my question above). Take --exit-after-N-failures to be 2 and assume there are a total of 4 tests {A, B, C, D} and test D is a test that constantly fails (and we haven't added it to the skip list or rolled out the patch that caused the failure yet). Suppose the first and second test runs have the following results {(A, Pass), (B, Fail), (C, Fail)} and {(A, Fail), (B, Pass), (C, Pass), (D, Fail)}. Then we will report test D as a flaky test (since tests_that_only_failed_second = {A, D}). Is this acceptable? > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:246 > + self._build_and_test_without_patch() > + self._clean_tree_results = self._delegate.test_results() > + tests_that_failed_on_tree = self._clean_tree_results.failing_test_results() > + > + new_failures_introduced_by_patch = tests_that_consistently_failed.difference(set(tests_that_failed_on_tree)) > + if new_failures_introduced_by_patch: > + self.failure_status_id = first_failure_status_id > + return self.report_failure(first_results_archive, new_failures_introduced_by_patch, first_script_error) Is is necessary to compute all of this when self._build_and_test_without_patch() returns true? On another note, this code looks similar to code we have below when self._results_failed_different_tests() returns false. I wish would could unify these code paths/share more code so as to avoid code duplication. > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:247 > + If we get here, it means that that the tests in tests_that_consistently_failed are also failing on trunk (i.e. the tree is red). So, we know the tests in tests_that_consistently_failed are not flaky. However, we don't know if the tests in tests_that_consistently_failed with the patch applied are failing for the same reason as when these tests failed without the patch. If the failure reason (diff) is the same for these tests with and without the patch then the patch didn't cause these failures; => do not report such test failures for the patch. Otherwise, the patch has caused the tests to fail differently than with a clean build (maybe the patch actually fixes the tests, but due to human error the expected results are still not quite right); => we need to report these tests as failing. > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:249 > + # At this point we know that there is flakyness with the patch applied, but no consistent failures > + # were introduced. This is a bit of a grey-zone. This comment is disingenuous. We may have reached this point in the execution flow because all these tests that failed in both runs with the patch also fail without the patch (i.e. tests_that_consistently_failed != [] and new_failures_introduced_by_patch := []) 1045047 12 240637 dbates 2014-10-30 09:53:57 -0700 Comment on attachment 240637 Changes sets to frozen sets, and computes frozenset(first_results.failing_test_results()) only once. View in context: https://bugs.webkit.org/attachment.cgi?id=240637&action=review > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:248 > + # At this point we know that there is flakyness with the patch applied, but no consistent failures As remarked in comment #3, did you intend to write flakiness as "flakyness"? 1045049 13 ap 2014-10-30 10:04:50 -0700 In comment 2, I asked Jake to check into test coverage for when we hit the limit, as we need regression tests to fix those cases. Thinking about it now, I have a different concern. We report flaky tests whenever first and second runs are different. But how does that make sense, what if flakiness was introduced by the patch itself? Also, I don't see queues report flaky tests recently, so I suspect that the functionality is broken anyway. > However, we don't know if the tests in tests_that_consistently_failed with the patch applied are failing for the same reason as when these tests failed without the patch. This is an interesting improvement idea. I don't think that EWS ever compared actual results, or did it? 1045061 14 jake.nielsen.webkit 2014-10-30 11:23:55 -0700 (In reply to comment #11) > Comment on attachment 240637 [details] > Changes sets to frozen sets, and computes > frozenset(first_results.failing_test_results()) only once. > > View in context: > https://bugs.webkit.org/attachment.cgi?id=240637&action=review > > I know that this patch already landed. I noticed some minor issues and had > some questions about the correctness of this patch. > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:-232 > > - # See https://bugs.webkit.org/show_bug.cgi?id=51272 > > Out of curiosity, did you have a chance to look at the posted patches and > discussion in bug #51272? If so, are the concerns raised about > --exit-after-N-failures and test ordering non-issues? In particular, is > <https://bugs.webkit.org/show_bug.cgi?id=51272#c3> a non-issue? I don't see which comment you mean regarding --exit-after-N-failures, but regarding test ordering, order shouldn't matter since we're taking a set difference. > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:235 > > + tests_that_only_failed_second = second_failing_results_set.difference(first_failing_results_set) > > + self._report_flaky_tests(tests_that_only_failed_second, second_results_archive) > > The following assumes <https://bugs.webkit.org/show_bug.cgi?id=51272#c3> is > still applicable (see my question above). Maybe I'm not understanding what you mean, I don't see what this has to do with test ordering? > > Take --exit-after-N-failures to be 2 and assume there are a total of 4 tests > {A, B, C, D} and test D is a test that constantly fails (and we haven't > added it to the skip list or rolled out the patch that caused the failure > yet). Suppose the first and second test runs have the following results {(A, > Pass), (B, Fail), (C, Fail)} and {(A, Fail), (B, Pass), (C, Pass), (D, > Fail)}. Then we will report test D as a flaky test (since > tests_that_only_failed_second = {A, D}). Is this acceptable? It won't reach this code path. It will enter the if first_results.did_exceed_test_failure_limit(): return self._continue_testing_patch_that_exceeded_failure_limit_on_first_or_second_try(first_results, first_results_archive, first_script_error) codepath. > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:246 > > + self._build_and_test_without_patch() > > + self._clean_tree_results = self._delegate.test_results() > > + tests_that_failed_on_tree = self._clean_tree_results.failing_test_results() > > + > > + new_failures_introduced_by_patch = tests_that_consistently_failed.difference(set(tests_that_failed_on_tree)) > > + if new_failures_introduced_by_patch: > > + self.failure_status_id = first_failure_status_id > > + return self.report_failure(first_results_archive, new_failures_introduced_by_patch, first_script_error) > > Is is necessary to compute all of this when > self._build_and_test_without_patch() returns true? It's not, but special casing it means more code duplication for microseconds of computing time gain. It's not worth it. > > On another note, this code looks similar to code we have below when > self._results_failed_different_tests() returns false. I wish would could > unify these code paths/share more code so as to avoid code duplication. You're right. I think we can. I'll do that. > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:247 > > + > > If we get here, it means that that the tests in > tests_that_consistently_failed are also failing on trunk (i.e. the tree is > red). So, we know the tests in tests_that_consistently_failed are not flaky. > However, we don't know if the tests in tests_that_consistently_failed with > the patch applied are failing for the same reason as when these tests failed > without the patch. If the failure reason (diff) is the same for these tests > with and without the patch then the patch didn't cause these failures; => do > not report such test failures for the patch. Otherwise, the patch has caused > the tests to fail differently than with a clean build (maybe the patch > actually fixes the tests, but due to human error the expected results are > still not quite right); => we need to report these tests as failing. The failure type is already taken into account by the TestResult.__eq__ method. It would be a mistake to try to compare the failure messages though. Since there are stack traces in the messages, if line numbers changed and we were just doing a comparison of those strings, we would peg the failures as different, even if they weren't, and we would be unable to land a good patch. Even beyond this though, the behavior at this point in the code is exactly the same as without this patch, so any further issues at this point should be new bugs and aren't really to do with the problem at hand. > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:249 > > + # At this point we know that there is flakyness with the patch applied, but no consistent failures > > + # were introduced. This is a bit of a grey-zone. > > This comment is disingenuous. We may have reached this point in the > execution flow because all these tests that failed in both runs with the > patch also fail without the patch (i.e. tests_that_consistently_failed != [] > and new_failures_introduced_by_patch := []) The comment says that no consistent failures were introduced. In this case, no consistent failures were introduced, they were there to begin with. 1045062 15 jake.nielsen.webkit 2014-10-30 11:28:52 -0700 (In reply to comment #14) > (In reply to comment #11) > > Comment on attachment 240637 [details] > > Changes sets to frozen sets, and computes > > frozenset(first_results.failing_test_results()) only once. > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=240637&action=review > > > > I know that this patch already landed. I noticed some minor issues and had > > some questions about the correctness of this patch. > > > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:-232 > > > - # See https://bugs.webkit.org/show_bug.cgi?id=51272 > > > > Out of curiosity, did you have a chance to look at the posted patches and > > discussion in bug #51272? If so, are the concerns raised about > > --exit-after-N-failures and test ordering non-issues? In particular, is > > <https://bugs.webkit.org/show_bug.cgi?id=51272#c3> a non-issue? > I don't see which comment you mean regarding --exit-after-N-failures, but > regarding test ordering, order shouldn't matter since we're taking a set > difference. > > > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:235 > > > + tests_that_only_failed_second = second_failing_results_set.difference(first_failing_results_set) > > > + self._report_flaky_tests(tests_that_only_failed_second, second_results_archive) > > > > The following assumes <https://bugs.webkit.org/show_bug.cgi?id=51272#c3> is > > still applicable (see my question above). > Maybe I'm not understanding what you mean, I don't see what this has to do > with test ordering? > > > > Take --exit-after-N-failures to be 2 and assume there are a total of 4 tests > > {A, B, C, D} and test D is a test that constantly fails (and we haven't > > added it to the skip list or rolled out the patch that caused the failure > > yet). Suppose the first and second test runs have the following results {(A, > > Pass), (B, Fail), (C, Fail)} and {(A, Fail), (B, Pass), (C, Pass), (D, > > Fail)}. Then we will report test D as a flaky test (since > > tests_that_only_failed_second = {A, D}). Is this acceptable? > It won't reach this code path. It will enter the > if first_results.did_exceed_test_failure_limit(): > return > self. > _continue_testing_patch_that_exceeded_failure_limit_on_first_or_second_try(fi > rst_results, first_results_archive, first_script_error) > codepath. > > > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:246 > > > + self._build_and_test_without_patch() > > > + self._clean_tree_results = self._delegate.test_results() > > > + tests_that_failed_on_tree = self._clean_tree_results.failing_test_results() > > > + > > > + new_failures_introduced_by_patch = tests_that_consistently_failed.difference(set(tests_that_failed_on_tree)) > > > + if new_failures_introduced_by_patch: > > > + self.failure_status_id = first_failure_status_id > > > + return self.report_failure(first_results_archive, new_failures_introduced_by_patch, first_script_error) > > > > Is is necessary to compute all of this when > > self._build_and_test_without_patch() returns true? > It's not, but special casing it means more code duplication for microseconds > of computing time gain. It's not worth it. > > > > On another note, this code looks similar to code we have below when > > self._results_failed_different_tests() returns false. I wish would could > > unify these code paths/share more code so as to avoid code duplication. > You're right. I think we can. I'll do that. > > > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:247 > > > + > > > > If we get here, it means that that the tests in > > tests_that_consistently_failed are also failing on trunk (i.e. the tree is > > red). So, we know the tests in tests_that_consistently_failed are not flaky. > > However, we don't know if the tests in tests_that_consistently_failed with > > the patch applied are failing for the same reason as when these tests failed > > without the patch. If the failure reason (diff) is the same for these tests > > with and without the patch then the patch didn't cause these failures; => do > > not report such test failures for the patch. Otherwise, the patch has caused > > the tests to fail differently than with a clean build (maybe the patch > > actually fixes the tests, but due to human error the expected results are > > still not quite right); => we need to report these tests as failing. > The failure type is already taken into account by the TestResult.__eq__ > method. It would be a mistake to try to compare the failure messages though. > Since there are stack traces in the messages, if line numbers changed and we > were just doing a comparison of those strings, we would peg the failures as > different, even if they weren't, and we would be unable to land a good patch. I lied, they don't contain stack traces. Brain fart. > Even beyond this though, the behavior at this point in the code is exactly > the same as without this patch, so any further issues at this point should > be new bugs and aren't really to do with the problem at hand. > > > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:249 > > > + # At this point we know that there is flakyness with the patch applied, but no consistent failures > > > + # were introduced. This is a bit of a grey-zone. > > > > This comment is disingenuous. We may have reached this point in the > > execution flow because all these tests that failed in both runs with the > > patch also fail without the patch (i.e. tests_that_consistently_failed != [] > > and new_failures_introduced_by_patch := []) > The comment says that no consistent failures were introduced. In this case, > no consistent failures were introduced, they were there to begin with. 1045063 16 jake.nielsen.webkit 2014-10-30 11:33:16 -0700 (In reply to comment #12) > Comment on attachment 240637 [details] > Changes sets to frozen sets, and computes > frozenset(first_results.failing_test_results()) only once. > > View in context: > https://bugs.webkit.org/attachment.cgi?id=240637&action=review > > > Tools/Scripts/webkitpy/tool/bot/patchanalysistask.py:248 > > + # At this point we know that there is flakyness with the patch applied, but no consistent failures > > As remarked in comment #3, did you intend to write flakiness as "flakyness"? Sorry I missed that. I'll make a note and change it in the next bug fix in this code. 240624 2014-10-29 14:24:52 -0700 2014-10-29 15:01:53 -0700 Alters PatchAnalysisTask's behavior, and changes the unit tests accordingly. 0001-CommitQueue-should-reject-any-patches-result-in-cons.patch text/plain 14437 jake.nielsen.webkit RnJvbSA1NjQ5MmZkMjkzZmNiMWQ3Yjg1MWU0MGFkY2EyNzhiZGNkYWE4YmFmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBXZWQsIDI5IE9jdCAyMDE0IDE0OjI0OjAyIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0g Q29tbWl0UXVldWUgc2hvdWxkIHJlamVjdCBhbnkgcGF0Y2hlcyByZXN1bHQgaW4gY29uc2lzdGVu dAogdGVzdCBmYWlsdXJlcyB0aGF0IGFyZW4ndCBwcmVzZW50IG9uIHRoZSB0cmVlLgogaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzODE4NAoKUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCgoqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL21vZGVscy90ZXN0 X3Jlc3VsdHMucHk6CkFkZHMgYSBzaW1wbGUgaGFzaGluZyBmdW5jdGlvbiB0byBhbGxvdyBmb3Ig c2V0IG9wZXJhdGlvbnMgdG8gaGFuZGxlClRlc3RSZXN1bHQgb2JqZWN0cyBwcm9wZXJseS4KKFRl c3RSZXN1bHQuX19oYXNoX18pOgoqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9ib3QvY29tbWl0cXVl dWV0YXNrX3VuaXR0ZXN0LnB5OgpBZGRzIG9uZSB1bml0IHRlc3QsIGFuZCBtb2RpZmllcyBvdGhl cnMgdG8gYWdyZWUgd2l0aCB0aGUgbm90aW9uIHRoYXQKcGF0Y2hlcyB0aGF0IGludHJvZHVjZSBu ZXcgdGVzdCBmYWlsdXJlcyAoYnV0IGFsc28gaGF2ZSBmbGFreW5lc3MpCnNob3VsZCBiZSByZWpl Y3RlZCByYXRoZXIgdGhhbiBzcGluLgooTW9ja0NvbW1pdFF1ZXVlLnJlcG9ydF9mbGFreV90ZXN0 cyk6CihDb21taXRRdWV1ZVRhc2tUZXN0Ll9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19y ZXN1bHQpOgoodGVzdF9kb3VibGVfZmxha3lfdGVzdF9mYWlsdXJlKToKKHRlc3RfdHdvX2ZsYWt5 X3Rlc3RzKToKKHRlc3RfdmVyeV9mbGFreV9wYXRjaCk6Cih0ZXN0X3ZlcnlfZmxha3lfcGF0Y2hf d2l0aF9zb21lX3RyZWVfcmVkbmVzcyk6Cih0ZXN0X2RpZmZlcmVudF90ZXN0X2ZhaWx1cmVzKToK KHRlc3RfZGlmZmVyZW50X3Rlc3RfZmFpbHVyZXNfd2l0aF9zb21lX3RyZWVfcmVkbmVzcyk6Cih0 ZXN0X2RpZmZlcmVudF90ZXN0X2ZhaWx1cmVzX3dpdGhfc29tZV90cmVlX3JlZG5lc3NfYW5kX3Nv bWVfZml4ZXMpOgoodGVzdF9taWxkbHlfZmxha3lfcGF0Y2gpOgoodGVzdF9taWxkbHlfZmxha3lf cGF0Y2hfd2l0aF9zb21lX3RyZWVfcmVkbmVzcyk6CiogU2NyaXB0cy93ZWJraXRweS90b29sL2Jv dC9wYXRjaGFuYWx5c2lzdGFzay5weToKTWFrZXMgUGF0Y2hBbmFseXNpc1Rhc2sgcmVqZWN0IHNh aWQgcGF0Y2hlcy4KKFBhdGNoQW5hbHlzaXNUYXNrLl90ZXN0X3BhdGNoKToKLS0tCiBUb29scy9D aGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IDMxICsrKysrKysr KysrKysrKysrKwogLi4uL3dlYmtpdHB5L2xheW91dF90ZXN0cy9tb2RlbHMvdGVzdF9yZXN1bHRz LnB5ICAgfCAgMyArKwogLi4uL3dlYmtpdHB5L3Rvb2wvYm90L2NvbW1pdHF1ZXVldGFza191bml0 dGVzdC5weSAgfCAzNyArKysrKysrKysrKysrLS0tLS0tLS0tCiAuLi4vU2NyaXB0cy93ZWJraXRw eS90b29sL2JvdC9wYXRjaGFuYWx5c2lzdGFzay5weSB8IDI1ICsrKysrKysrKysrKy0tLQogNCBm aWxlcyBjaGFuZ2VkLCA3NiBpbnNlcnRpb25zKCspLCAyMCBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggN2Y1ZGI0Mi4uMGFk YjQ1YSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpA QCAtMSwzICsxLDM0IEBACisyMDE0LTEwLTI5ICBKYWtlIE5pZWxzZW4gIDxqYWNvYl9uaWVsc2Vu QGFwcGxlLmNvbT4KKworICAgICAgICBDb21taXRRdWV1ZSBzaG91bGQgcmVqZWN0IGFueSBwYXRj aGVzIHJlc3VsdCBpbiBjb25zaXN0ZW50IHRlc3QKKyAgICAgICAgZmFpbHVyZXMgdGhhdCBhcmVu J3QgcHJlc2VudCBvbiB0aGUgdHJlZS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTEzODE4NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbW9kZWxzL3Rl c3RfcmVzdWx0cy5weToKKyAgICAgICAgQWRkcyBhIHNpbXBsZSBoYXNoaW5nIGZ1bmN0aW9uIHRv IGFsbG93IGZvciBzZXQgb3BlcmF0aW9ucyB0byBoYW5kbGUKKyAgICAgICAgVGVzdFJlc3VsdCBv YmplY3RzIHByb3Blcmx5LgorICAgICAgICAoVGVzdFJlc3VsdC5fX2hhc2hfXyk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS90b29sL2JvdC9jb21taXRxdWV1ZXRhc2tfdW5pdHRlc3QucHk6 CisgICAgICAgIEFkZHMgb25lIHVuaXQgdGVzdCwgYW5kIG1vZGlmaWVzIG90aGVycyB0byBhZ3Jl ZSB3aXRoIHRoZSBub3Rpb24gdGhhdAorICAgICAgICBwYXRjaGVzIHRoYXQgaW50cm9kdWNlIG5l dyB0ZXN0IGZhaWx1cmVzIChidXQgYWxzbyBoYXZlIGZsYWt5bmVzcykKKyAgICAgICAgc2hvdWxk IGJlIHJlamVjdGVkIHJhdGhlciB0aGFuIHNwaW4uCisgICAgICAgIChNb2NrQ29tbWl0UXVldWUu cmVwb3J0X2ZsYWt5X3Rlc3RzKToKKyAgICAgICAgKENvbW1pdFF1ZXVlVGFza1Rlc3QuX3J1bl9h bmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdCk6CisgICAgICAgICh0ZXN0X2RvdWJsZV9m bGFreV90ZXN0X2ZhaWx1cmUpOgorICAgICAgICAodGVzdF90d29fZmxha3lfdGVzdHMpOgorICAg ICAgICAodGVzdF92ZXJ5X2ZsYWt5X3BhdGNoKToKKyAgICAgICAgKHRlc3RfdmVyeV9mbGFreV9w YXRjaF93aXRoX3NvbWVfdHJlZV9yZWRuZXNzKToKKyAgICAgICAgKHRlc3RfZGlmZmVyZW50X3Rl c3RfZmFpbHVyZXMpOgorICAgICAgICAodGVzdF9kaWZmZXJlbnRfdGVzdF9mYWlsdXJlc193aXRo X3NvbWVfdHJlZV9yZWRuZXNzKToKKyAgICAgICAgKHRlc3RfZGlmZmVyZW50X3Rlc3RfZmFpbHVy ZXNfd2l0aF9zb21lX3RyZWVfcmVkbmVzc19hbmRfc29tZV9maXhlcyk6CisgICAgICAgICh0ZXN0 X21pbGRseV9mbGFreV9wYXRjaCk6CisgICAgICAgICh0ZXN0X21pbGRseV9mbGFreV9wYXRjaF93 aXRoX3NvbWVfdHJlZV9yZWRuZXNzKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wv Ym90L3BhdGNoYW5hbHlzaXN0YXNrLnB5OgorICAgICAgICBNYWtlcyBQYXRjaEFuYWx5c2lzVGFz ayByZWplY3Qgc2FpZCBwYXRjaGVzLgorICAgICAgICAoUGF0Y2hBbmFseXNpc1Rhc2suX3Rlc3Rf cGF0Y2gpOgorCiAyMDE0LTEwLTI5ICBDc2FiYSBPc3p0cm9nb27DoWMgIDxvc3N5QHdlYmtpdC5v cmc+CiAKICAgICAgICAgW0VGTF0gYnVpbGQtd2Via2l0IHNob3VsZCB0cnkgaGFyZGVyIHRvIGF2 b2lkIHJlLXJ1bm5pbmcgY21ha2UKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL21vZGVscy90ZXN0X3Jlc3VsdHMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9tb2RlbHMvdGVzdF9yZXN1bHRzLnB5CmluZGV4IGQ2ZmQxMGIuLjEz MGM5OTAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL21v ZGVscy90ZXN0X3Jlc3VsdHMucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvbW9kZWxzL3Rlc3RfcmVzdWx0cy5weQpAQCAtNjQsNiArNjQsOSBAQCBjbGFzcyBUZXN0 UmVzdWx0KG9iamVjdCk6CiAgICAgZGVmIF9fbmVfXyhzZWxmLCBvdGhlcik6CiAgICAgICAgIHJl dHVybiBub3QgKHNlbGYgPT0gb3RoZXIpCiAKKyAgICBkZWYgX19oYXNoX18oc2VsZik6CisgICAg ICAgIHJldHVybiBzZWxmLnRlc3RfbmFtZS5fX2hhc2hfXygpCisKICAgICBkZWYgaGFzX2ZhaWx1 cmVfbWF0Y2hpbmdfdHlwZXMoc2VsZiwgKmZhaWx1cmVfY2xhc3Nlcyk6CiAgICAgICAgIGZvciBm YWlsdXJlIGluIHNlbGYuZmFpbHVyZXM6CiAgICAgICAgICAgICBpZiB0eXBlKGZhaWx1cmUpIGlu IGZhaWx1cmVfY2xhc3NlczoKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9v bC9ib3QvY29tbWl0cXVldWV0YXNrX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS90b29sL2JvdC9jb21taXRxdWV1ZXRhc2tfdW5pdHRlc3QucHkKaW5kZXggNGRmYWMzZi4uNWI0 YWNhOCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2JvdC9jb21taXRx dWV1ZXRhc2tfdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2Jv dC9jb21taXRxdWV1ZXRhc2tfdW5pdHRlc3QucHkKQEAgLTczLDggKzczLDkgQEAgY2xhc3MgTW9j a0NvbW1pdFF1ZXVlKENvbW1pdFF1ZXVlVGFza0RlbGVnYXRlKToKICAgICAgICAgcmV0dXJuIExh eW91dFRlc3RSZXN1bHRzKHRlc3RfcmVzdWx0cz1bXSwgZGlkX2V4Y2VlZF90ZXN0X2ZhaWx1cmVf bGltaXQ9RmFsc2UpCiAKICAgICBkZWYgcmVwb3J0X2ZsYWt5X3Rlc3RzKHNlbGYsIHBhdGNoLCBm bGFreV9yZXN1bHRzLCByZXN1bHRzX2FyY2hpdmUpOgotICAgICAgICBzZWxmLl9mbGFreV90ZXN0 cyA9IFtyZXN1bHQudGVzdF9uYW1lIGZvciByZXN1bHQgaW4gZmxha3lfcmVzdWx0c10KLSAgICAg ICAgX2xvZy5pbmZvKCJyZXBvcnRfZmxha3lfdGVzdHM6IHBhdGNoPSclcycgZmxha3lfdGVzdHM9 JyVzJyBhcmNoaXZlPSclcyciICUgKHBhdGNoLmlkKCksIHNlbGYuX2ZsYWt5X3Rlc3RzLCByZXN1 bHRzX2FyY2hpdmUuZmlsZW5hbWUpKQorICAgICAgICBjdXJyZW50X2ZsYWt5X3Rlc3RzID0gW3Jl c3VsdC50ZXN0X25hbWUgZm9yIHJlc3VsdCBpbiBmbGFreV9yZXN1bHRzXQorICAgICAgICBzZWxm Ll9mbGFreV90ZXN0cyArPSBjdXJyZW50X2ZsYWt5X3Rlc3RzCisgICAgICAgIF9sb2cuaW5mbygi cmVwb3J0X2ZsYWt5X3Rlc3RzOiBwYXRjaD0nJXMnIGZsYWt5X3Rlc3RzPSclcycgYXJjaGl2ZT0n JXMnIiAlIChwYXRjaC5pZCgpLCBjdXJyZW50X2ZsYWt5X3Rlc3RzLCByZXN1bHRzX2FyY2hpdmUu ZmlsZW5hbWUpKQogCiAgICAgZGVmIGdldF9yZXBvcnRlZF9mbGFreV90ZXN0cyhzZWxmKToKICAg ICAgICAgcmV0dXJuIHNlbGYuX2ZsYWt5X3Rlc3RzCkBAIC0xNzQsNyArMTc1LDcgQEAgY2xhc3Mg Q29tbWl0UXVldWVUYXNrVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgICAgICBhbmFs eXNpc19yZXN1bHQgPSBQYXRjaEFuYWx5c2lzUmVzdWx0LkZBSUwKIAogICAgICAgICBzZWxmLmFz c2VydEVxdWFsKGFuYWx5c2lzX3Jlc3VsdCwgZXhwZWN0ZWRfYW5hbHlzaXNfcmVzdWx0KQotICAg ICAgICBzZWxmLmFzc2VydEVxdWFsKGNvbW1pdF9xdWV1ZS5nZXRfcmVwb3J0ZWRfZmxha3lfdGVz dHMoKSwgZXhwZWN0ZWRfcmVwb3J0ZWRfZmxha3lfdGVzdHMpCisgICAgICAgIHNlbGYuYXNzZXJ0 RXF1YWwoc2V0KGNvbW1pdF9xdWV1ZS5nZXRfcmVwb3J0ZWRfZmxha3lfdGVzdHMoKSksIHNldChl eHBlY3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0cykpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwo Y29tbWl0X3F1ZXVlLmRpZF9ydW5fY2xlYW5fdGVzdHMoKSwgZXhwZWN0X2NsZWFuX3Rlc3RzX3Rv X3J1bikKIAogICAgICAgICAjIFRoZSBmYWlsdXJlIHN0YXR1cyBvbmx5IG1lYW5zIGFueXRoaW5n IGlmIHdlIGFjdHVhbGx5IGZhaWxlZC4KQEAgLTM3OCw3ICszNzksNyBAQCBjb21tYW5kX2ZhaWxl ZDogZmFpbHVyZV9tZXNzYWdlPSdVbmFibGUgdG8gbGFuZCBwYXRjaCcgc2NyaXB0X2Vycm9yPSdN T0NLIGxhbmQgZgogICAgICAgICAjIFRoZSAoc3VidGxlKSBwb2ludCBvZiB0aGlzIHRlc3QgaXMg dGhhdCByZXBvcnRfZmxha3lfdGVzdHMgZG9lcyBub3QgZ2V0CiAgICAgICAgICMgY2FsbGVkIGZv ciB0aGlzIHJ1bi4KICAgICAgICAgIyBOb3RlIGFsc28gdGhhdCB0aGVyZSBpcyBubyBhdHRlbXB0 IHRvIHJ1biB0aGUgdGVzdHMgdy9vIHRoZSBwYXRjaC4KLSAgICAgICAgc2VsZi5fcnVuX2FuZF9l eHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jl c3VsdC5ERUZFUikKKyAgICAgICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNf cmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUiwgZXhwZWN0ZWRf cmVwb3J0ZWRfZmxha3lfdGVzdHM9WyJGYWlsMSIsICJGYWlsMiJdKQogCiAgICAgZGVmIHRlc3Rf dGVzdF9mYWlsdXJlKHNlbGYpOgogICAgICAgICBjb21taXRfcXVldWUgPSBNb2NrU2ltcGxlVGVz dFBsYW5Db21taXRRdWV1ZSgKQEAgLTQyMSw3ICs0MjIsNyBAQCBjb21tYW5kX2ZhaWxlZDogZmFp bHVyZV9tZXNzYWdlPSdVbmFibGUgdG8gbGFuZCBwYXRjaCcgc2NyaXB0X2Vycm9yPSdNT0NLIGxh bmQgZgogICAgICAgICAgICAgY2xlYW5fdGVzdF9mYWlsdXJlcz1bIkZhaWwxIiwgIkZhaWwyIl0p CiAKICAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQgcGFzcywgYnV0IGFzIG9mIHJpZ2h0IG5v dywgaXQgZGVmZXJzLgotICAgICAgICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNp c19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSKQorICAgICAg ICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVl LCBQYXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSLCBleHBlY3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0 cz1bIkZhaWwxIiwgIkZhaWwyIl0pCiAKICAgICBkZWYgdGVzdF9vbmVfZmxha3lfdGVzdChzZWxm KToKICAgICAgICAgY29tbWl0X3F1ZXVlID0gTW9ja1NpbXBsZVRlc3RQbGFuQ29tbWl0UXVldWUo CkBAIC00MzgsMTYgKzQzOSwxNiBAQCBjb21tYW5kX2ZhaWxlZDogZmFpbHVyZV9tZXNzYWdlPSdV bmFibGUgdG8gbGFuZCBwYXRjaCcgc2NyaXB0X2Vycm9yPSdNT0NLIGxhbmQgZgogICAgICAgICAg ICAgY2xlYW5fdGVzdF9mYWlsdXJlcz1bXSkKIAogICAgICAgICAjIEZJWE1FOiBUaGlzIHNob3Vs ZCBhY3R1YWxseSBmYWlsLCBidXQgcmlnaHQgbm93IGl0IGRlZmVycwotICAgICAgICBzZWxmLl9y dW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFu YWx5c2lzUmVzdWx0LkRFRkVSKQorICAgICAgICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9h bmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSLCBl eHBlY3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0cz1bIkZhaWwxIiwgIkZhaWwyIiwgIkZhaWwzIiwg IkZhaWw0IiwgIkZhaWw1IiwgIkZhaWw2IiwgIkZhaWw3IiwgIkZhaWw4IiwgIkZhaWw5IiwgIkZh aWwxMCJdKQogCiAgICAgZGVmIHRlc3RfdmVyeV9mbGFreV9wYXRjaF93aXRoX3NvbWVfdHJlZV9y ZWRuZXNzKHNlbGYpOgogICAgICAgICBjb21taXRfcXVldWUgPSBNb2NrU2ltcGxlVGVzdFBsYW5D b21taXRRdWV1ZSgKLSAgICAgICAgICAgIGZpcnN0X3Rlc3RfZmFpbHVyZXM9WyJQcmVFeGlzdGlu Z0ZhaWwxIiwgIlByZUV4aXN0aW5nRmFpbDIiLCAiRmFpbDYiLCAiRmFpbDciLCAiRmFpbDgiLCAi RmFpbDkiLCAiRmFpbDEwIl0sCi0gICAgICAgICAgICBzZWNvbmRfdGVzdF9mYWlsdXJlcz1bIlBy ZUV4aXN0aW5nRmFpbDEiLCAiUHJlRXhpc3RpbmdGYWlsMiIsICJGYWlsMSIsICJGYWlsMiIsICJG YWlsMyIsICJGYWlsNCIsICJGYWlsNSJdLAorICAgICAgICAgICAgZmlyc3RfdGVzdF9mYWlsdXJl cz1bIlByZUV4aXN0aW5nRmFpbDEiLCAiUHJlRXhpc3RpbmdGYWlsMiIsICJGYWlsMSIsICJGYWls MiIsICJGYWlsMyIsICJGYWlsNCIsICJGYWlsNSJdLAorICAgICAgICAgICAgc2Vjb25kX3Rlc3Rf ZmFpbHVyZXM9WyJQcmVFeGlzdGluZ0ZhaWwxIiwgIlByZUV4aXN0aW5nRmFpbDIiLCAiRmFpbDYi LCAiRmFpbDciLCAiRmFpbDgiLCAiRmFpbDkiLCAiRmFpbDEwIl0sCiAgICAgICAgICAgICBjbGVh bl90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhpc3RpbmdGYWlsMSIsICJQcmVFeGlzdGluZ0ZhaWwyIl0p CiAKICAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQgYWN0dWFsbHkgZmFpbCwgYnV0IHJpZ2h0 IG5vdyBpdCBkZWZlcnMKLSAgICAgICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlz aXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUikKKyAgICAg ICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1 ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUiwgZXhwZWN0X2NsZWFuX3Rlc3RzX3RvX3J1bj1U cnVlLCBleHBlY3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0cz1bIkZhaWwxIiwgIkZhaWwyIiwgIkZh aWwzIiwgIkZhaWw0IiwgIkZhaWw1IiwgIkZhaWw2IiwgIkZhaWw3IiwgIkZhaWw4IiwgIkZhaWw5 IiwgIkZhaWwxMCJdKQogCiAgICAgZGVmIHRlc3RfZGlmZmVyZW50X3Rlc3RfZmFpbHVyZXMoc2Vs Zik6CiAgICAgICAgIGNvbW1pdF9xdWV1ZSA9IE1vY2tTaW1wbGVUZXN0UGxhbkNvbW1pdFF1ZXVl KApAQCAtNDU1LDggKzQ1Niw3IEBAIGNvbW1hbmRfZmFpbGVkOiBmYWlsdXJlX21lc3NhZ2U9J1Vu YWJsZSB0byBsYW5kIHBhdGNoJyBzY3JpcHRfZXJyb3I9J01PQ0sgbGFuZCBmCiAgICAgICAgICAg ICBzZWNvbmRfdGVzdF9mYWlsdXJlcz1bIkZhaWwxIiwgIkZhaWwyIiwgIkZhaWwzIiwgIkZhaWw0 IiwgIkZhaWw1Il0sCiAgICAgICAgICAgICBjbGVhbl90ZXN0X2ZhaWx1cmVzPVtdKQogCi0gICAg ICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIGFjdHVhbGx5IGZhaWwsIGJ1dCByaWdodCBub3cgaXQg ZGVmZXJzCi0gICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3Vs dChjb21taXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuREVGRVIpCisgICAgICAgIHNlbGYu X3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNo QW5hbHlzaXNSZXN1bHQuRkFJTCwgZXhwZWN0X2NsZWFuX3Rlc3RzX3RvX3J1bj1UcnVlLCBleHBl Y3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0cz1bIkZhaWw2Il0sIGV4cGVjdGVkX2ZhaWx1cmVfc3Rh dHVzX2lkPTEpCiAKICAgICBkZWYgdGVzdF9kaWZmZXJlbnRfdGVzdF9mYWlsdXJlc193aXRoX3Nv bWVfdHJlZV9yZWRuZXNzKHNlbGYpOgogICAgICAgICBjb21taXRfcXVldWUgPSBNb2NrU2ltcGxl VGVzdFBsYW5Db21taXRRdWV1ZSgKQEAgLTQ2NCw4ICs0NjQsMTUgQEAgY29tbWFuZF9mYWlsZWQ6 IGZhaWx1cmVfbWVzc2FnZT0nVW5hYmxlIHRvIGxhbmQgcGF0Y2gnIHNjcmlwdF9lcnJvcj0nTU9D SyBsYW5kIGYKICAgICAgICAgICAgIHNlY29uZF90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhpc3RpbmdG YWlsMSIsICJQcmVFeGlzdGluZ0ZhaWwyIiwgIkZhaWwxIiwgIkZhaWwyIiwgIkZhaWwzIiwgIkZh aWw0IiwgIkZhaWw1Il0sCiAgICAgICAgICAgICBjbGVhbl90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhp c3RpbmdGYWlsMSIsICJQcmVFeGlzdGluZ0ZhaWwyIl0pCiAKLSAgICAgICAgIyBGSVhNRTogVGhp cyBzaG91bGQgYWN0dWFsbHkgZmFpbCwgYnV0IHJpZ2h0IG5vdyBpdCBkZWZlcnMKLSAgICAgICAg c2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwg UGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUikKKyAgICAgICAgc2VsZi5fcnVuX2FuZF9leHBlY3Rf cGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5G QUlMLCBleHBlY3RfY2xlYW5fdGVzdHNfdG9fcnVuPVRydWUsIGV4cGVjdGVkX3JlcG9ydGVkX2Zs YWt5X3Rlc3RzPVsiRmFpbDYiXSwgZXhwZWN0ZWRfZmFpbHVyZV9zdGF0dXNfaWQ9MSkKKworICAg IGRlZiB0ZXN0X2RpZmZlcmVudF90ZXN0X2ZhaWx1cmVzX3dpdGhfc29tZV90cmVlX3JlZG5lc3Nf YW5kX3NvbWVfZml4ZXMoc2VsZik6CisgICAgICAgIGNvbW1pdF9xdWV1ZSA9IE1vY2tTaW1wbGVU ZXN0UGxhbkNvbW1pdFF1ZXVlKAorICAgICAgICAgICAgZmlyc3RfdGVzdF9mYWlsdXJlcz1bIlBy ZUV4aXN0aW5nRmFpbDEiLCAiRmFpbDEiLCAiRmFpbDIiLCAiRmFpbDMiLCAiRmFpbDQiLCAiRmFp bDUiLCAiRmFpbDYiXSwKKyAgICAgICAgICAgIHNlY29uZF90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhp c3RpbmdGYWlsMSIsICJGYWlsMSIsICJGYWlsMiIsICJGYWlsMyIsICJGYWlsNCIsICJGYWlsNSJd LAorICAgICAgICAgICAgY2xlYW5fdGVzdF9mYWlsdXJlcz1bIlByZUV4aXN0aW5nRmFpbDEiLCAi UHJlRXhpc3RpbmdGYWlsMiJdKQorCisgICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNo X2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuRkFJTCwg ZXhwZWN0X2NsZWFuX3Rlc3RzX3RvX3J1bj1UcnVlLCBleHBlY3RlZF9yZXBvcnRlZF9mbGFreV90 ZXN0cz1bIkZhaWw2Il0sIGV4cGVjdGVkX2ZhaWx1cmVfc3RhdHVzX2lkPTEpCiAKICAgICBkZWYg dGVzdF9taWxkbHlfZmxha3lfcGF0Y2goc2VsZik6CiAgICAgICAgIGNvbW1pdF9xdWV1ZSA9IE1v Y2tTaW1wbGVUZXN0UGxhbkNvbW1pdFF1ZXVlKApAQCAtNDczLDcgKzQ4MCw3IEBAIGNvbW1hbmRf ZmFpbGVkOiBmYWlsdXJlX21lc3NhZ2U9J1VuYWJsZSB0byBsYW5kIHBhdGNoJyBzY3JpcHRfZXJy b3I9J01PQ0sgbGFuZCBmCiAgICAgICAgICAgICBzZWNvbmRfdGVzdF9mYWlsdXJlcz1bIkZhaWwy Il0sCiAgICAgICAgICAgICBjbGVhbl90ZXN0X2ZhaWx1cmVzPVtdKQogCi0gICAgICAgIHNlbGYu X3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNo QW5hbHlzaXNSZXN1bHQuREVGRVIpCisgICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNo X2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuREVGRVIs IGV4cGVjdF9jbGVhbl90ZXN0c190b19ydW49RmFsc2UsIGV4cGVjdGVkX3JlcG9ydGVkX2ZsYWt5 X3Rlc3RzPVsiRmFpbDEiLCAiRmFpbDIiXSkKIAogICAgIGRlZiB0ZXN0X21pbGRseV9mbGFreV9w YXRjaF93aXRoX3NvbWVfdHJlZV9yZWRuZXNzKHNlbGYpOgogICAgICAgICBjb21taXRfcXVldWUg PSBNb2NrU2ltcGxlVGVzdFBsYW5Db21taXRRdWV1ZSgKQEAgLTQ4MSw3ICs0ODgsNyBAQCBjb21t YW5kX2ZhaWxlZDogZmFpbHVyZV9tZXNzYWdlPSdVbmFibGUgdG8gbGFuZCBwYXRjaCcgc2NyaXB0 X2Vycm9yPSdNT0NLIGxhbmQgZgogICAgICAgICAgICAgc2Vjb25kX3Rlc3RfZmFpbHVyZXM9WyJQ cmVFeGlzdGluZ0ZhaWwxIiwgIlByZUV4aXN0aW5nRmFpbDIiLCAiRmFpbDIiXSwKICAgICAgICAg ICAgIGNsZWFuX3Rlc3RfZmFpbHVyZXM9WyJQcmVFeGlzdGluZ0ZhaWwxIiwgIlByZUV4aXN0aW5n RmFpbDIiXSkKIAotICAgICAgICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19y ZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSKQorICAgICAgICBz ZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQ YXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSLCBleHBlY3RfY2xlYW5fdGVzdHNfdG9fcnVuPVRydWUs IGV4cGVjdGVkX3JlcG9ydGVkX2ZsYWt5X3Rlc3RzPVsiRmFpbDEiLCAiRmFpbDIiXSkKIAogICAg IGRlZiB0ZXN0X3RyZWVfbW9yZV9yZWRfdGhhbl9wYXRjaChzZWxmKToKICAgICAgICAgY29tbWl0 X3F1ZXVlID0gTW9ja1NpbXBsZVRlc3RQbGFuQ29tbWl0UXVldWUoCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvYm90L3BhdGNoYW5hbHlzaXN0YXNrLnB5IGIvVG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL2JvdC9wYXRjaGFuYWx5c2lzdGFzay5weQppbmRleCA1NThk M2ZjLi40YmE4MThmIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvYm90 L3BhdGNoYW5hbHlzaXN0YXNrLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9i b3QvcGF0Y2hhbmFseXNpc3Rhc2sucHkKQEAgLTIyNSwxMSArMjI1LDI2IEBAIGNsYXNzIFBhdGNo QW5hbHlzaXNUYXNrKG9iamVjdCk6CiAgICAgICAgICAgICByZXR1cm4gc2VsZi5fY29udGludWVf dGVzdGluZ19wYXRjaF90aGF0X2V4Y2VlZGVkX2ZhaWx1cmVfbGltaXRfb25fZmlyc3Rfb3Jfc2Vj b25kX3RyeShzZWNvbmRfcmVzdWx0cywgc2Vjb25kX3Jlc3VsdHNfYXJjaGl2ZSwgc2Vjb25kX3Nj cmlwdF9lcnJvcikKIAogICAgICAgICBpZiBzZWxmLl9yZXN1bHRzX2ZhaWxlZF9kaWZmZXJlbnRf dGVzdHMoZmlyc3RfcmVzdWx0cywgc2Vjb25kX3Jlc3VsdHMpOgotICAgICAgICAgICAgIyBXZSBj b3VsZCByZXBvcnQgZmxha3kgdGVzdHMgaGVyZSwgYnV0IHdlIHdvdWxkIG5lZWQgdG8gYmUgY2Fy ZWZ1bAotICAgICAgICAgICAgIyB0byB1c2Ugc2ltaWxhciBjaGVja3MgdG8gRXhwZWN0ZWRGYWls dXJlcy5fY2FuX3RydXN0X3Jlc3VsdHMKLSAgICAgICAgICAgICMgdG8gbWFrZSBzdXJlIHdlIGRv bid0IHJlcG9ydCBjb25zdGFudCBmYWlsdXJlcyBhcyBmbGFrZXMgd2hlbgotICAgICAgICAgICAg IyB3ZSBoYXBwZW4gdG8gaGl0IHRoZSAtLWV4aXQtYWZ0ZXItTi1mYWlsdXJlcyBsaW1pdC4KLSAg ICAgICAgICAgICMgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01 MTI3MgorICAgICAgICAgICAgdGVzdHNfdGhhdF9vbmx5X2ZhaWxlZF9maXJzdCA9IGxpc3Qoc2V0 KGZpcnN0X3Jlc3VsdHMuZmFpbGluZ190ZXN0X3Jlc3VsdHMoKSkgLSBzZXQoc2Vjb25kX3Jlc3Vs dHMuZmFpbGluZ190ZXN0X3Jlc3VsdHMoKSkpCisgICAgICAgICAgICBzZWxmLl9yZXBvcnRfZmxh a3lfdGVzdHModGVzdHNfdGhhdF9vbmx5X2ZhaWxlZF9maXJzdCwgZmlyc3RfcmVzdWx0c19hcmNo aXZlKQorCisgICAgICAgICAgICB0ZXN0c190aGF0X29ubHlfZmFpbGVkX3NlY29uZCA9IGxpc3Qo c2V0KHNlY29uZF9yZXN1bHRzLmZhaWxpbmdfdGVzdF9yZXN1bHRzKCkpIC0gc2V0KGZpcnN0X3Jl c3VsdHMuZmFpbGluZ190ZXN0X3Jlc3VsdHMoKSkpCisgICAgICAgICAgICBzZWxmLl9yZXBvcnRf Zmxha3lfdGVzdHModGVzdHNfdGhhdF9vbmx5X2ZhaWxlZF9zZWNvbmQsIHNlY29uZF9yZXN1bHRz X2FyY2hpdmUpCisKKyAgICAgICAgICAgIHRlc3RzX3RoYXRfY29uc2lzdGVudGx5X2ZhaWxlZCA9 IGxpc3Qoc2V0KHNlY29uZF9yZXN1bHRzLmZhaWxpbmdfdGVzdF9yZXN1bHRzKCkpICYgc2V0KGZp cnN0X3Jlc3VsdHMuZmFpbGluZ190ZXN0X3Jlc3VsdHMoKSkpCisgICAgICAgICAgICBpZiB0ZXN0 c190aGF0X2NvbnNpc3RlbnRseV9mYWlsZWQ6CisgICAgICAgICAgICAgICAgc2VsZi5fYnVpbGRf YW5kX3Rlc3Rfd2l0aG91dF9wYXRjaCgpCisgICAgICAgICAgICAgICAgc2VsZi5fY2xlYW5fdHJl ZV9yZXN1bHRzID0gc2VsZi5fZGVsZWdhdGUudGVzdF9yZXN1bHRzKCkKKyAgICAgICAgICAgICAg ICB0ZXN0c190aGF0X2ZhaWxlZF9vbl90cmVlID0gc2VsZi5fY2xlYW5fdHJlZV9yZXN1bHRzLmZh aWxpbmdfdGVzdF9yZXN1bHRzKCkKKworICAgICAgICAgICAgICAgIG5ld19mYWlsdXJlc19pbnRy b2R1Y2VkX2J5X3BhdGNoID0gbGlzdChzZXQodGVzdHNfdGhhdF9jb25zaXN0ZW50bHlfZmFpbGVk KSAtIHNldCh0ZXN0c190aGF0X2ZhaWxlZF9vbl90cmVlKSkKKyAgICAgICAgICAgICAgICBpZiBu ZXdfZmFpbHVyZXNfaW50cm9kdWNlZF9ieV9wYXRjaDoKKyAgICAgICAgICAgICAgICAgICAgc2Vs Zi5mYWlsdXJlX3N0YXR1c19pZCA9IGZpcnN0X2ZhaWx1cmVfc3RhdHVzX2lkCisgICAgICAgICAg ICAgICAgICAgIHJldHVybiBzZWxmLnJlcG9ydF9mYWlsdXJlKGZpcnN0X3Jlc3VsdHNfYXJjaGl2 ZSwgbmV3X2ZhaWx1cmVzX2ludHJvZHVjZWRfYnlfcGF0Y2gsIGZpcnN0X3NjcmlwdF9lcnJvcikK KworICAgICAgICAgICAgIyBBdCB0aGlzIHBvaW50IHdlIGtub3cgdGhhdCB0aGVyZSBpcyBmbGFr eW5lc3Mgd2l0aCB0aGUgcGF0Y2ggYXBwbGllZCwgYnV0IG5vIGNvbnNpc3RlbnQgZmFpbHVyZXMK KyAgICAgICAgICAgICMgd2VyZSBpbnRyb2R1Y2VkLiBUaGlzIGlzIGEgYml0IG9mIGEgZ3JleS16 b25lLCBhbmQgZm9yIG5vdyBJIHdpbGwgbGVhdmUgdGhpcyBjb2RlIHBhdGggYXMgaXQgd2FzLAor ICAgICAgICAgICAgIyBBS0EsIGRlZmVyLgogICAgICAgICAgICAgcmV0dXJuIEZhbHNlCiAKICAg ICAgICAgaWYgc2VsZi5fYnVpbGRfYW5kX3Rlc3Rfd2l0aG91dF9wYXRjaCgpOgotLSAKMS45LjMg KEFwcGxlIEdpdC01MCkKCg== 240630 2014-10-29 15:01:53 -0700 2014-10-29 16:09:12 -0700 Addresses comments 0001-CommitQueue-and-EWS-should-reject-any-patches-that-r.patch text/plain 14355 jake.nielsen.webkit RnJvbSAyYWFlOTE5Yjg4MTViMGZlZGUyZWQ5NDYwYmY5OGJlZTBjZTcyODUyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBXZWQsIDI5IE9jdCAyMDE0IDE1OjAxOjI3IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0g Q29tbWl0UXVldWUgYW5kIEVXUyBzaG91bGQgcmVqZWN0IGFueSBwYXRjaGVzIHRoYXQgcmVzdWx0 IGluCiBjb25zaXN0ZW50IHRlc3QgZmFpbHVyZXMgdGhhdCBhcmVuJ3QgcHJlc2VudCBvbiB0aGUg dHJlZS4KIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzgxODQKClJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9tb2RlbHMvdGVzdF9yZXN1bHRzLnB5OgpBZGRzIGEgc2ltcGxlIGhhc2hpbmcgZnVuY3Rpb24g dG8gYWxsb3cgZm9yIHNldCBvcGVyYXRpb25zIHRvIGhhbmRsZQpUZXN0UmVzdWx0IG9iamVjdHMg cHJvcGVybHkuCihUZXN0UmVzdWx0Ll9faGFzaF9fKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wv Ym90L2NvbW1pdHF1ZXVldGFza191bml0dGVzdC5weToKQWRkcyBvbmUgdW5pdCB0ZXN0LCBhbmQg bW9kaWZpZXMgb3RoZXJzIHRvIGFncmVlIHdpdGggdGhlIG5vdGlvbiB0aGF0CnBhdGNoZXMgdGhh dCBpbnRyb2R1Y2UgbmV3IHRlc3QgZmFpbHVyZXMgKGJ1dCBhbHNvIGhhdmUgZmxha3luZXNzKQpz aG91bGQgYmUgcmVqZWN0ZWQgcmF0aGVyIHRoYW4gc3Bpbi4KKE1vY2tDb21taXRRdWV1ZS5yZXBv cnRfZmxha3lfdGVzdHMpOgooQ29tbWl0UXVldWVUYXNrVGVzdC5fcnVuX2FuZF9leHBlY3RfcGF0 Y2hfYW5hbHlzaXNfcmVzdWx0KToKKHRlc3RfZG91YmxlX2ZsYWt5X3Rlc3RfZmFpbHVyZSk6Cih0 ZXN0X3R3b19mbGFreV90ZXN0cyk6Cih0ZXN0X3ZlcnlfZmxha3lfcGF0Y2gpOgoodGVzdF92ZXJ5 X2ZsYWt5X3BhdGNoX3dpdGhfc29tZV90cmVlX3JlZG5lc3MpOgoodGVzdF9kaWZmZXJlbnRfdGVz dF9mYWlsdXJlcyk6Cih0ZXN0X2RpZmZlcmVudF90ZXN0X2ZhaWx1cmVzX3dpdGhfc29tZV90cmVl X3JlZG5lc3MpOgoodGVzdF9kaWZmZXJlbnRfdGVzdF9mYWlsdXJlc193aXRoX3NvbWVfdHJlZV9y ZWRuZXNzX2FuZF9zb21lX2ZpeGVzKToKKHRlc3RfbWlsZGx5X2ZsYWt5X3BhdGNoKToKKHRlc3Rf bWlsZGx5X2ZsYWt5X3BhdGNoX3dpdGhfc29tZV90cmVlX3JlZG5lc3MpOgoqIFNjcmlwdHMvd2Vi a2l0cHkvdG9vbC9ib3QvcGF0Y2hhbmFseXNpc3Rhc2sucHk6Ck1ha2VzIFBhdGNoQW5hbHlzaXNU YXNrIHJlamVjdCBzYWlkIHBhdGNoZXMuCihQYXRjaEFuYWx5c2lzVGFzay5fdGVzdF9wYXRjaCk6 Ci0tLQogVG9vbHMvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCAzMSArKysrKysrKysrKysrKysrKysKIC4uLi93ZWJraXRweS9sYXlvdXRfdGVzdHMvbW9kZWxz L3Rlc3RfcmVzdWx0cy5weSAgIHwgIDMgKysKIC4uLi93ZWJraXRweS90b29sL2JvdC9jb21taXRx dWV1ZXRhc2tfdW5pdHRlc3QucHkgIHwgMzcgKysrKysrKysrKysrKy0tLS0tLS0tLQogLi4uL1Nj cmlwdHMvd2Via2l0cHkvdG9vbC9ib3QvcGF0Y2hhbmFseXNpc3Rhc2sucHkgfCAyNCArKysrKysr KysrKy0tLQogNCBmaWxlcyBjaGFuZ2VkLCA3NSBpbnNlcnRpb25zKCspLCAyMCBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXgg N2Y1ZGI0Mi4uMjNkZDg3NyAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xz L0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDE0LTEwLTI5ICBKYWtlIE5pZWxzZW4gIDxq YWNvYl9uaWVsc2VuQGFwcGxlLmNvbT4KKworICAgICAgICBDb21taXRRdWV1ZSBhbmQgRVdTIHNo b3VsZCByZWplY3QgYW55IHBhdGNoZXMgdGhhdCByZXN1bHQgaW4gY29uc2lzdGVudCB0ZXN0Cisg ICAgICAgIGZhaWx1cmVzIHRoYXQgYXJlbid0IHByZXNlbnQgb24gdGhlIHRyZWUuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzgxODQKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL21vZGVscy90ZXN0X3Jlc3VsdHMucHk6CisgICAgICAgIEFkZHMgYSBz aW1wbGUgaGFzaGluZyBmdW5jdGlvbiB0byBhbGxvdyBmb3Igc2V0IG9wZXJhdGlvbnMgdG8gaGFu ZGxlCisgICAgICAgIFRlc3RSZXN1bHQgb2JqZWN0cyBwcm9wZXJseS4KKyAgICAgICAgKFRlc3RS ZXN1bHQuX19oYXNoX18pOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9ib3QvY29t bWl0cXVldWV0YXNrX3VuaXR0ZXN0LnB5OgorICAgICAgICBBZGRzIG9uZSB1bml0IHRlc3QsIGFu ZCBtb2RpZmllcyBvdGhlcnMgdG8gYWdyZWUgd2l0aCB0aGUgbm90aW9uIHRoYXQKKyAgICAgICAg cGF0Y2hlcyB0aGF0IGludHJvZHVjZSBuZXcgdGVzdCBmYWlsdXJlcyAoYnV0IGFsc28gaGF2ZSBm bGFreW5lc3MpCisgICAgICAgIHNob3VsZCBiZSByZWplY3RlZCByYXRoZXIgdGhhbiBzcGluLgor ICAgICAgICAoTW9ja0NvbW1pdFF1ZXVlLnJlcG9ydF9mbGFreV90ZXN0cyk6CisgICAgICAgIChD b21taXRRdWV1ZVRhc2tUZXN0Ll9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQp OgorICAgICAgICAodGVzdF9kb3VibGVfZmxha3lfdGVzdF9mYWlsdXJlKToKKyAgICAgICAgKHRl c3RfdHdvX2ZsYWt5X3Rlc3RzKToKKyAgICAgICAgKHRlc3RfdmVyeV9mbGFreV9wYXRjaCk6Cisg ICAgICAgICh0ZXN0X3ZlcnlfZmxha3lfcGF0Y2hfd2l0aF9zb21lX3RyZWVfcmVkbmVzcyk6Cisg ICAgICAgICh0ZXN0X2RpZmZlcmVudF90ZXN0X2ZhaWx1cmVzKToKKyAgICAgICAgKHRlc3RfZGlm ZmVyZW50X3Rlc3RfZmFpbHVyZXNfd2l0aF9zb21lX3RyZWVfcmVkbmVzcyk6CisgICAgICAgICh0 ZXN0X2RpZmZlcmVudF90ZXN0X2ZhaWx1cmVzX3dpdGhfc29tZV90cmVlX3JlZG5lc3NfYW5kX3Nv bWVfZml4ZXMpOgorICAgICAgICAodGVzdF9taWxkbHlfZmxha3lfcGF0Y2gpOgorICAgICAgICAo dGVzdF9taWxkbHlfZmxha3lfcGF0Y2hfd2l0aF9zb21lX3RyZWVfcmVkbmVzcyk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS90b29sL2JvdC9wYXRjaGFuYWx5c2lzdGFzay5weToKKyAgICAg ICAgTWFrZXMgUGF0Y2hBbmFseXNpc1Rhc2sgcmVqZWN0IHNhaWQgcGF0Y2hlcy4KKyAgICAgICAg KFBhdGNoQW5hbHlzaXNUYXNrLl90ZXN0X3BhdGNoKToKKwogMjAxNC0xMC0yOSAgQ3NhYmEgT3N6 dHJvZ29uw6FjICA8b3NzeUB3ZWJraXQub3JnPgogCiAgICAgICAgIFtFRkxdIGJ1aWxkLXdlYmtp dCBzaG91bGQgdHJ5IGhhcmRlciB0byBhdm9pZCByZS1ydW5uaW5nIGNtYWtlCmRpZmYgLS1naXQg YS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9tb2RlbHMvdGVzdF9yZXN1bHRz LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbW9kZWxzL3Rlc3RfcmVz dWx0cy5weQppbmRleCBkNmZkMTBiLi4xMzBjOTkwIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9tb2RlbHMvdGVzdF9yZXN1bHRzLnB5CisrKyBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL21vZGVscy90ZXN0X3Jlc3VsdHMucHkKQEAg LTY0LDYgKzY0LDkgQEAgY2xhc3MgVGVzdFJlc3VsdChvYmplY3QpOgogICAgIGRlZiBfX25lX18o c2VsZiwgb3RoZXIpOgogICAgICAgICByZXR1cm4gbm90IChzZWxmID09IG90aGVyKQogCisgICAg ZGVmIF9faGFzaF9fKHNlbGYpOgorICAgICAgICByZXR1cm4gc2VsZi50ZXN0X25hbWUuX19oYXNo X18oKQorCiAgICAgZGVmIGhhc19mYWlsdXJlX21hdGNoaW5nX3R5cGVzKHNlbGYsICpmYWlsdXJl X2NsYXNzZXMpOgogICAgICAgICBmb3IgZmFpbHVyZSBpbiBzZWxmLmZhaWx1cmVzOgogICAgICAg ICAgICAgaWYgdHlwZShmYWlsdXJlKSBpbiBmYWlsdXJlX2NsYXNzZXM6CmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvYm90L2NvbW1pdHF1ZXVldGFza191bml0dGVzdC5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9ib3QvY29tbWl0cXVldWV0YXNrX3VuaXR0 ZXN0LnB5CmluZGV4IDRkZmFjM2YuLjViNGFjYTggMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvdG9vbC9ib3QvY29tbWl0cXVldWV0YXNrX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdG9vbC9ib3QvY29tbWl0cXVldWV0YXNrX3VuaXR0ZXN0LnB5CkBA IC03Myw4ICs3Myw5IEBAIGNsYXNzIE1vY2tDb21taXRRdWV1ZShDb21taXRRdWV1ZVRhc2tEZWxl Z2F0ZSk6CiAgICAgICAgIHJldHVybiBMYXlvdXRUZXN0UmVzdWx0cyh0ZXN0X3Jlc3VsdHM9W10s IGRpZF9leGNlZWRfdGVzdF9mYWlsdXJlX2xpbWl0PUZhbHNlKQogCiAgICAgZGVmIHJlcG9ydF9m bGFreV90ZXN0cyhzZWxmLCBwYXRjaCwgZmxha3lfcmVzdWx0cywgcmVzdWx0c19hcmNoaXZlKToK LSAgICAgICAgc2VsZi5fZmxha3lfdGVzdHMgPSBbcmVzdWx0LnRlc3RfbmFtZSBmb3IgcmVzdWx0 IGluIGZsYWt5X3Jlc3VsdHNdCi0gICAgICAgIF9sb2cuaW5mbygicmVwb3J0X2ZsYWt5X3Rlc3Rz OiBwYXRjaD0nJXMnIGZsYWt5X3Rlc3RzPSclcycgYXJjaGl2ZT0nJXMnIiAlIChwYXRjaC5pZCgp LCBzZWxmLl9mbGFreV90ZXN0cywgcmVzdWx0c19hcmNoaXZlLmZpbGVuYW1lKSkKKyAgICAgICAg Y3VycmVudF9mbGFreV90ZXN0cyA9IFtyZXN1bHQudGVzdF9uYW1lIGZvciByZXN1bHQgaW4gZmxh a3lfcmVzdWx0c10KKyAgICAgICAgc2VsZi5fZmxha3lfdGVzdHMgKz0gY3VycmVudF9mbGFreV90 ZXN0cworICAgICAgICBfbG9nLmluZm8oInJlcG9ydF9mbGFreV90ZXN0czogcGF0Y2g9JyVzJyBm bGFreV90ZXN0cz0nJXMnIGFyY2hpdmU9JyVzJyIgJSAocGF0Y2guaWQoKSwgY3VycmVudF9mbGFr eV90ZXN0cywgcmVzdWx0c19hcmNoaXZlLmZpbGVuYW1lKSkKIAogICAgIGRlZiBnZXRfcmVwb3J0 ZWRfZmxha3lfdGVzdHMoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9mbGFreV90ZXN0cwpA QCAtMTc0LDcgKzE3NSw3IEBAIGNsYXNzIENvbW1pdFF1ZXVlVGFza1Rlc3QodW5pdHRlc3QuVGVz dENhc2UpOgogICAgICAgICAgICAgYW5hbHlzaXNfcmVzdWx0ID0gUGF0Y2hBbmFseXNpc1Jlc3Vs dC5GQUlMCiAKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChhbmFseXNpc19yZXN1bHQsIGV4cGVj dGVkX2FuYWx5c2lzX3Jlc3VsdCkKLSAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChjb21taXRfcXVl dWUuZ2V0X3JlcG9ydGVkX2ZsYWt5X3Rlc3RzKCksIGV4cGVjdGVkX3JlcG9ydGVkX2ZsYWt5X3Rl c3RzKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHNldChjb21taXRfcXVldWUuZ2V0X3JlcG9y dGVkX2ZsYWt5X3Rlc3RzKCkpLCBzZXQoZXhwZWN0ZWRfcmVwb3J0ZWRfZmxha3lfdGVzdHMpKQog ICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGNvbW1pdF9xdWV1ZS5kaWRfcnVuX2NsZWFuX3Rlc3Rz KCksIGV4cGVjdF9jbGVhbl90ZXN0c190b19ydW4pCiAKICAgICAgICAgIyBUaGUgZmFpbHVyZSBz dGF0dXMgb25seSBtZWFucyBhbnl0aGluZyBpZiB3ZSBhY3R1YWxseSBmYWlsZWQuCkBAIC0zNzgs NyArMzc5LDcgQEAgY29tbWFuZF9mYWlsZWQ6IGZhaWx1cmVfbWVzc2FnZT0nVW5hYmxlIHRvIGxh bmQgcGF0Y2gnIHNjcmlwdF9lcnJvcj0nTU9DSyBsYW5kIGYKICAgICAgICAgIyBUaGUgKHN1YnRs ZSkgcG9pbnQgb2YgdGhpcyB0ZXN0IGlzIHRoYXQgcmVwb3J0X2ZsYWt5X3Rlc3RzIGRvZXMgbm90 IGdldAogICAgICAgICAjIGNhbGxlZCBmb3IgdGhpcyBydW4uCiAgICAgICAgICMgTm90ZSBhbHNv IHRoYXQgdGhlcmUgaXMgbm8gYXR0ZW1wdCB0byBydW4gdGhlIHRlc3RzIHcvbyB0aGUgcGF0Y2gu Ci0gICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdChjb21t aXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuREVGRVIpCisgICAgICAgIHNlbGYuX3J1bl9h bmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNoQW5hbHlz aXNSZXN1bHQuREVGRVIsIGV4cGVjdGVkX3JlcG9ydGVkX2ZsYWt5X3Rlc3RzPVsiRmFpbDEiLCAi RmFpbDIiXSkKIAogICAgIGRlZiB0ZXN0X3Rlc3RfZmFpbHVyZShzZWxmKToKICAgICAgICAgY29t bWl0X3F1ZXVlID0gTW9ja1NpbXBsZVRlc3RQbGFuQ29tbWl0UXVldWUoCkBAIC00MjEsNyArNDIy LDcgQEAgY29tbWFuZF9mYWlsZWQ6IGZhaWx1cmVfbWVzc2FnZT0nVW5hYmxlIHRvIGxhbmQgcGF0 Y2gnIHNjcmlwdF9lcnJvcj0nTU9DSyBsYW5kIGYKICAgICAgICAgICAgIGNsZWFuX3Rlc3RfZmFp bHVyZXM9WyJGYWlsMSIsICJGYWlsMiJdKQogCiAgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxk IHBhc3MsIGJ1dCBhcyBvZiByaWdodCBub3csIGl0IGRlZmVycy4KLSAgICAgICAgc2VsZi5fcnVu X2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFs eXNpc1Jlc3VsdC5ERUZFUikKKyAgICAgICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5h bHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUiwgZXhw ZWN0ZWRfcmVwb3J0ZWRfZmxha3lfdGVzdHM9WyJGYWlsMSIsICJGYWlsMiJdKQogCiAgICAgZGVm IHRlc3Rfb25lX2ZsYWt5X3Rlc3Qoc2VsZik6CiAgICAgICAgIGNvbW1pdF9xdWV1ZSA9IE1vY2tT aW1wbGVUZXN0UGxhbkNvbW1pdFF1ZXVlKApAQCAtNDM4LDE2ICs0MzksMTYgQEAgY29tbWFuZF9m YWlsZWQ6IGZhaWx1cmVfbWVzc2FnZT0nVW5hYmxlIHRvIGxhbmQgcGF0Y2gnIHNjcmlwdF9lcnJv cj0nTU9DSyBsYW5kIGYKICAgICAgICAgICAgIGNsZWFuX3Rlc3RfZmFpbHVyZXM9W10pCiAKICAg ICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQgYWN0dWFsbHkgZmFpbCwgYnV0IHJpZ2h0IG5vdyBp dCBkZWZlcnMKLSAgICAgICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVz dWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUikKKyAgICAgICAgc2Vs Zi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0 Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUiwgZXhwZWN0ZWRfcmVwb3J0ZWRfZmxha3lfdGVzdHM9WyJG YWlsMSIsICJGYWlsMiIsICJGYWlsMyIsICJGYWlsNCIsICJGYWlsNSIsICJGYWlsNiIsICJGYWls NyIsICJGYWlsOCIsICJGYWlsOSIsICJGYWlsMTAiXSkKIAogICAgIGRlZiB0ZXN0X3ZlcnlfZmxh a3lfcGF0Y2hfd2l0aF9zb21lX3RyZWVfcmVkbmVzcyhzZWxmKToKICAgICAgICAgY29tbWl0X3F1 ZXVlID0gTW9ja1NpbXBsZVRlc3RQbGFuQ29tbWl0UXVldWUoCi0gICAgICAgICAgICBmaXJzdF90 ZXN0X2ZhaWx1cmVzPVsiUHJlRXhpc3RpbmdGYWlsMSIsICJQcmVFeGlzdGluZ0ZhaWwyIiwgIkZh aWw2IiwgIkZhaWw3IiwgIkZhaWw4IiwgIkZhaWw5IiwgIkZhaWwxMCJdLAotICAgICAgICAgICAg c2Vjb25kX3Rlc3RfZmFpbHVyZXM9WyJQcmVFeGlzdGluZ0ZhaWwxIiwgIlByZUV4aXN0aW5nRmFp bDIiLCAiRmFpbDEiLCAiRmFpbDIiLCAiRmFpbDMiLCAiRmFpbDQiLCAiRmFpbDUiXSwKKyAgICAg ICAgICAgIGZpcnN0X3Rlc3RfZmFpbHVyZXM9WyJQcmVFeGlzdGluZ0ZhaWwxIiwgIlByZUV4aXN0 aW5nRmFpbDIiLCAiRmFpbDEiLCAiRmFpbDIiLCAiRmFpbDMiLCAiRmFpbDQiLCAiRmFpbDUiXSwK KyAgICAgICAgICAgIHNlY29uZF90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhpc3RpbmdGYWlsMSIsICJQ cmVFeGlzdGluZ0ZhaWwyIiwgIkZhaWw2IiwgIkZhaWw3IiwgIkZhaWw4IiwgIkZhaWw5IiwgIkZh aWwxMCJdLAogICAgICAgICAgICAgY2xlYW5fdGVzdF9mYWlsdXJlcz1bIlByZUV4aXN0aW5nRmFp bDEiLCAiUHJlRXhpc3RpbmdGYWlsMiJdKQogCiAgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxk IGFjdHVhbGx5IGZhaWwsIGJ1dCByaWdodCBub3cgaXQgZGVmZXJzCi0gICAgICAgIHNlbGYuX3J1 bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNoQW5h bHlzaXNSZXN1bHQuREVGRVIpCisgICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNoX2Fu YWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuREVGRVIsIGV4 cGVjdF9jbGVhbl90ZXN0c190b19ydW49VHJ1ZSwgZXhwZWN0ZWRfcmVwb3J0ZWRfZmxha3lfdGVz dHM9WyJGYWlsMSIsICJGYWlsMiIsICJGYWlsMyIsICJGYWlsNCIsICJGYWlsNSIsICJGYWlsNiIs ICJGYWlsNyIsICJGYWlsOCIsICJGYWlsOSIsICJGYWlsMTAiXSkKIAogICAgIGRlZiB0ZXN0X2Rp ZmZlcmVudF90ZXN0X2ZhaWx1cmVzKHNlbGYpOgogICAgICAgICBjb21taXRfcXVldWUgPSBNb2Nr U2ltcGxlVGVzdFBsYW5Db21taXRRdWV1ZSgKQEAgLTQ1NSw4ICs0NTYsNyBAQCBjb21tYW5kX2Zh aWxlZDogZmFpbHVyZV9tZXNzYWdlPSdVbmFibGUgdG8gbGFuZCBwYXRjaCcgc2NyaXB0X2Vycm9y PSdNT0NLIGxhbmQgZgogICAgICAgICAgICAgc2Vjb25kX3Rlc3RfZmFpbHVyZXM9WyJGYWlsMSIs ICJGYWlsMiIsICJGYWlsMyIsICJGYWlsNCIsICJGYWlsNSJdLAogICAgICAgICAgICAgY2xlYW5f dGVzdF9mYWlsdXJlcz1bXSkKIAotICAgICAgICAjIEZJWE1FOiBUaGlzIHNob3VsZCBhY3R1YWxs eSBmYWlsLCBidXQgcmlnaHQgbm93IGl0IGRlZmVycwotICAgICAgICBzZWxmLl9ydW5fYW5kX2V4 cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVz dWx0LkRFRkVSKQorICAgICAgICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19y ZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVzdWx0LkZBSUwsIGV4cGVjdF9jbGVh bl90ZXN0c190b19ydW49VHJ1ZSwgZXhwZWN0ZWRfcmVwb3J0ZWRfZmxha3lfdGVzdHM9WyJGYWls NiJdLCBleHBlY3RlZF9mYWlsdXJlX3N0YXR1c19pZD0xKQogCiAgICAgZGVmIHRlc3RfZGlmZmVy ZW50X3Rlc3RfZmFpbHVyZXNfd2l0aF9zb21lX3RyZWVfcmVkbmVzcyhzZWxmKToKICAgICAgICAg Y29tbWl0X3F1ZXVlID0gTW9ja1NpbXBsZVRlc3RQbGFuQ29tbWl0UXVldWUoCkBAIC00NjQsOCAr NDY0LDE1IEBAIGNvbW1hbmRfZmFpbGVkOiBmYWlsdXJlX21lc3NhZ2U9J1VuYWJsZSB0byBsYW5k IHBhdGNoJyBzY3JpcHRfZXJyb3I9J01PQ0sgbGFuZCBmCiAgICAgICAgICAgICBzZWNvbmRfdGVz dF9mYWlsdXJlcz1bIlByZUV4aXN0aW5nRmFpbDEiLCAiUHJlRXhpc3RpbmdGYWlsMiIsICJGYWls MSIsICJGYWlsMiIsICJGYWlsMyIsICJGYWlsNCIsICJGYWlsNSJdLAogICAgICAgICAgICAgY2xl YW5fdGVzdF9mYWlsdXJlcz1bIlByZUV4aXN0aW5nRmFpbDEiLCAiUHJlRXhpc3RpbmdGYWlsMiJd KQogCi0gICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIGFjdHVhbGx5IGZhaWwsIGJ1dCByaWdo dCBub3cgaXQgZGVmZXJzCi0gICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5 c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuREVGRVIpCisgICAg ICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVl dWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuRkFJTCwgZXhwZWN0X2NsZWFuX3Rlc3RzX3RvX3J1bj1U cnVlLCBleHBlY3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0cz1bIkZhaWw2Il0sIGV4cGVjdGVkX2Zh aWx1cmVfc3RhdHVzX2lkPTEpCisKKyAgICBkZWYgdGVzdF9kaWZmZXJlbnRfdGVzdF9mYWlsdXJl c193aXRoX3NvbWVfdHJlZV9yZWRuZXNzX2FuZF9zb21lX2ZpeGVzKHNlbGYpOgorICAgICAgICBj b21taXRfcXVldWUgPSBNb2NrU2ltcGxlVGVzdFBsYW5Db21taXRRdWV1ZSgKKyAgICAgICAgICAg IGZpcnN0X3Rlc3RfZmFpbHVyZXM9WyJQcmVFeGlzdGluZ0ZhaWwxIiwgIkZhaWwxIiwgIkZhaWwy IiwgIkZhaWwzIiwgIkZhaWw0IiwgIkZhaWw1IiwgIkZhaWw2Il0sCisgICAgICAgICAgICBzZWNv bmRfdGVzdF9mYWlsdXJlcz1bIlByZUV4aXN0aW5nRmFpbDEiLCAiRmFpbDEiLCAiRmFpbDIiLCAi RmFpbDMiLCAiRmFpbDQiLCAiRmFpbDUiXSwKKyAgICAgICAgICAgIGNsZWFuX3Rlc3RfZmFpbHVy ZXM9WyJQcmVFeGlzdGluZ0ZhaWwxIiwgIlByZUV4aXN0aW5nRmFpbDIiXSkKKworICAgICAgICBz ZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQ YXRjaEFuYWx5c2lzUmVzdWx0LkZBSUwsIGV4cGVjdF9jbGVhbl90ZXN0c190b19ydW49VHJ1ZSwg ZXhwZWN0ZWRfcmVwb3J0ZWRfZmxha3lfdGVzdHM9WyJGYWlsNiJdLCBleHBlY3RlZF9mYWlsdXJl X3N0YXR1c19pZD0xKQogCiAgICAgZGVmIHRlc3RfbWlsZGx5X2ZsYWt5X3BhdGNoKHNlbGYpOgog ICAgICAgICBjb21taXRfcXVldWUgPSBNb2NrU2ltcGxlVGVzdFBsYW5Db21taXRRdWV1ZSgKQEAg LTQ3Myw3ICs0ODAsNyBAQCBjb21tYW5kX2ZhaWxlZDogZmFpbHVyZV9tZXNzYWdlPSdVbmFibGUg dG8gbGFuZCBwYXRjaCcgc2NyaXB0X2Vycm9yPSdNT0NLIGxhbmQgZgogICAgICAgICAgICAgc2Vj b25kX3Rlc3RfZmFpbHVyZXM9WyJGYWlsMiJdLAogICAgICAgICAgICAgY2xlYW5fdGVzdF9mYWls dXJlcz1bXSkKIAotICAgICAgICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19y ZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSKQorICAgICAgICBz ZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQ YXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSLCBleHBlY3RfY2xlYW5fdGVzdHNfdG9fcnVuPUZhbHNl LCBleHBlY3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0cz1bIkZhaWwxIiwgIkZhaWwyIl0pCiAKICAg ICBkZWYgdGVzdF9taWxkbHlfZmxha3lfcGF0Y2hfd2l0aF9zb21lX3RyZWVfcmVkbmVzcyhzZWxm KToKICAgICAgICAgY29tbWl0X3F1ZXVlID0gTW9ja1NpbXBsZVRlc3RQbGFuQ29tbWl0UXVldWUo CkBAIC00ODEsNyArNDg4LDcgQEAgY29tbWFuZF9mYWlsZWQ6IGZhaWx1cmVfbWVzc2FnZT0nVW5h YmxlIHRvIGxhbmQgcGF0Y2gnIHNjcmlwdF9lcnJvcj0nTU9DSyBsYW5kIGYKICAgICAgICAgICAg IHNlY29uZF90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhpc3RpbmdGYWlsMSIsICJQcmVFeGlzdGluZ0Zh aWwyIiwgIkZhaWwyIl0sCiAgICAgICAgICAgICBjbGVhbl90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhp c3RpbmdGYWlsMSIsICJQcmVFeGlzdGluZ0ZhaWwyIl0pCiAKLSAgICAgICAgc2VsZi5fcnVuX2Fu ZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNp c1Jlc3VsdC5ERUZFUikKKyAgICAgICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlz aXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUiwgZXhwZWN0 X2NsZWFuX3Rlc3RzX3RvX3J1bj1UcnVlLCBleHBlY3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0cz1b IkZhaWwxIiwgIkZhaWwyIl0pCiAKICAgICBkZWYgdGVzdF90cmVlX21vcmVfcmVkX3RoYW5fcGF0 Y2goc2VsZik6CiAgICAgICAgIGNvbW1pdF9xdWV1ZSA9IE1vY2tTaW1wbGVUZXN0UGxhbkNvbW1p dFF1ZXVlKApkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2JvdC9wYXRj aGFuYWx5c2lzdGFzay5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9ib3QvcGF0Y2hh bmFseXNpc3Rhc2sucHkKaW5kZXggNTU4ZDNmYy4uMGYxN2E0OSAxMDA2NDQKLS0tIGEvVG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL2JvdC9wYXRjaGFuYWx5c2lzdGFzay5weQorKysgYi9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvYm90L3BhdGNoYW5hbHlzaXN0YXNrLnB5CkBAIC0yMjUs MTEgKzIyNSwyNSBAQCBjbGFzcyBQYXRjaEFuYWx5c2lzVGFzayhvYmplY3QpOgogICAgICAgICAg ICAgcmV0dXJuIHNlbGYuX2NvbnRpbnVlX3Rlc3RpbmdfcGF0Y2hfdGhhdF9leGNlZWRlZF9mYWls dXJlX2xpbWl0X29uX2ZpcnN0X29yX3NlY29uZF90cnkoc2Vjb25kX3Jlc3VsdHMsIHNlY29uZF9y ZXN1bHRzX2FyY2hpdmUsIHNlY29uZF9zY3JpcHRfZXJyb3IpCiAKICAgICAgICAgaWYgc2VsZi5f cmVzdWx0c19mYWlsZWRfZGlmZmVyZW50X3Rlc3RzKGZpcnN0X3Jlc3VsdHMsIHNlY29uZF9yZXN1 bHRzKToKLSAgICAgICAgICAgICMgV2UgY291bGQgcmVwb3J0IGZsYWt5IHRlc3RzIGhlcmUsIGJ1 dCB3ZSB3b3VsZCBuZWVkIHRvIGJlIGNhcmVmdWwKLSAgICAgICAgICAgICMgdG8gdXNlIHNpbWls YXIgY2hlY2tzIHRvIEV4cGVjdGVkRmFpbHVyZXMuX2Nhbl90cnVzdF9yZXN1bHRzCi0gICAgICAg ICAgICAjIHRvIG1ha2Ugc3VyZSB3ZSBkb24ndCByZXBvcnQgY29uc3RhbnQgZmFpbHVyZXMgYXMg Zmxha2VzIHdoZW4KLSAgICAgICAgICAgICMgd2UgaGFwcGVuIHRvIGhpdCB0aGUgLS1leGl0LWFm dGVyLU4tZmFpbHVyZXMgbGltaXQuCi0gICAgICAgICAgICAjIFNlZSBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTEyNzIKKyAgICAgICAgICAgIHRlc3RzX3RoYXRfb25s eV9mYWlsZWRfZmlyc3QgPSBzZXQoZmlyc3RfcmVzdWx0cy5mYWlsaW5nX3Rlc3RfcmVzdWx0cygp KSAtIHNldChzZWNvbmRfcmVzdWx0cy5mYWlsaW5nX3Rlc3RfcmVzdWx0cygpKQorICAgICAgICAg ICAgc2VsZi5fcmVwb3J0X2ZsYWt5X3Rlc3RzKHRlc3RzX3RoYXRfb25seV9mYWlsZWRfZmlyc3Qs IGZpcnN0X3Jlc3VsdHNfYXJjaGl2ZSkKKworICAgICAgICAgICAgdGVzdHNfdGhhdF9vbmx5X2Zh aWxlZF9zZWNvbmQgPSBzZXQoc2Vjb25kX3Jlc3VsdHMuZmFpbGluZ190ZXN0X3Jlc3VsdHMoKSkg LSBzZXQoZmlyc3RfcmVzdWx0cy5mYWlsaW5nX3Rlc3RfcmVzdWx0cygpKQorICAgICAgICAgICAg c2VsZi5fcmVwb3J0X2ZsYWt5X3Rlc3RzKHRlc3RzX3RoYXRfb25seV9mYWlsZWRfc2Vjb25kLCBz ZWNvbmRfcmVzdWx0c19hcmNoaXZlKQorCisgICAgICAgICAgICB0ZXN0c190aGF0X2NvbnNpc3Rl bnRseV9mYWlsZWQgPSBzZXQoc2Vjb25kX3Jlc3VsdHMuZmFpbGluZ190ZXN0X3Jlc3VsdHMoKSkg JiBzZXQoZmlyc3RfcmVzdWx0cy5mYWlsaW5nX3Rlc3RfcmVzdWx0cygpKQorICAgICAgICAgICAg aWYgdGVzdHNfdGhhdF9jb25zaXN0ZW50bHlfZmFpbGVkOgorICAgICAgICAgICAgICAgIHNlbGYu X2J1aWxkX2FuZF90ZXN0X3dpdGhvdXRfcGF0Y2goKQorICAgICAgICAgICAgICAgIHNlbGYuX2Ns ZWFuX3RyZWVfcmVzdWx0cyA9IHNlbGYuX2RlbGVnYXRlLnRlc3RfcmVzdWx0cygpCisgICAgICAg ICAgICAgICAgdGVzdHNfdGhhdF9mYWlsZWRfb25fdHJlZSA9IHNlbGYuX2NsZWFuX3RyZWVfcmVz dWx0cy5mYWlsaW5nX3Rlc3RfcmVzdWx0cygpCisKKyAgICAgICAgICAgICAgICBuZXdfZmFpbHVy ZXNfaW50cm9kdWNlZF9ieV9wYXRjaCA9IHRlc3RzX3RoYXRfY29uc2lzdGVudGx5X2ZhaWxlZCAt IHNldCh0ZXN0c190aGF0X2ZhaWxlZF9vbl90cmVlKQorICAgICAgICAgICAgICAgIGlmIG5ld19m YWlsdXJlc19pbnRyb2R1Y2VkX2J5X3BhdGNoOgorICAgICAgICAgICAgICAgICAgICBzZWxmLmZh aWx1cmVfc3RhdHVzX2lkID0gZmlyc3RfZmFpbHVyZV9zdGF0dXNfaWQKKyAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIHNlbGYucmVwb3J0X2ZhaWx1cmUoZmlyc3RfcmVzdWx0c19hcmNoaXZlLCBu ZXdfZmFpbHVyZXNfaW50cm9kdWNlZF9ieV9wYXRjaCwgZmlyc3Rfc2NyaXB0X2Vycm9yKQorCisg ICAgICAgICAgICAjIEF0IHRoaXMgcG9pbnQgd2Uga25vdyB0aGF0IHRoZXJlIGlzIGZsYWt5bmVz cyB3aXRoIHRoZSBwYXRjaCBhcHBsaWVkLCBidXQgbm8gY29uc2lzdGVudCBmYWlsdXJlcworICAg ICAgICAgICAgIyB3ZXJlIGludHJvZHVjZWQuIFRoaXMgaXMgYSBiaXQgb2YgYSBncmV5LXpvbmUu CiAgICAgICAgICAgICByZXR1cm4gRmFsc2UKIAogICAgICAgICBpZiBzZWxmLl9idWlsZF9hbmRf dGVzdF93aXRob3V0X3BhdGNoKCk6Ci0tIAoxLjkuMyAoQXBwbGUgR2l0LTUwKQoK 240637 2014-10-29 16:09:12 -0700 2014-10-29 22:02:30 -0700 Changes sets to frozen sets, and computes frozenset(first_results.failing_test_results()) only once. 0001-CommitQueue-and-EWS-should-reject-any-patches-that-r.patch text/plain 14497 jake.nielsen.webkit RnJvbSA0YWIyNTRjYmIxMmQyNWFjMTAyYThjYjM0YTQwM2Q5OTM4MTJiODBhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBXZWQsIDI5IE9jdCAyMDE0IDE2OjA3OjQ3IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0g Q29tbWl0UXVldWUgYW5kIEVXUyBzaG91bGQgcmVqZWN0IGFueSBwYXRjaGVzIHRoYXQgcmVzdWx0 IGluCiBjb25zaXN0ZW50IHRlc3QgZmFpbHVyZXMgdGhhdCBhcmVuJ3QgcHJlc2VudCBvbiB0aGUg dHJlZS4KIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzgxODQKClJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9tb2RlbHMvdGVzdF9yZXN1bHRzLnB5OgpBZGRzIGEgc2ltcGxlIGhhc2hpbmcgZnVuY3Rpb24g dG8gYWxsb3cgZm9yIHNldCBvcGVyYXRpb25zIHRvIGhhbmRsZQpUZXN0UmVzdWx0IG9iamVjdHMg cHJvcGVybHkuCihUZXN0UmVzdWx0Ll9faGFzaF9fKToKKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wv Ym90L2NvbW1pdHF1ZXVldGFza191bml0dGVzdC5weToKQWRkcyBvbmUgdW5pdCB0ZXN0LCBhbmQg bW9kaWZpZXMgb3RoZXJzIHRvIGFncmVlIHdpdGggdGhlIG5vdGlvbiB0aGF0CnBhdGNoZXMgdGhh dCBpbnRyb2R1Y2UgbmV3IHRlc3QgZmFpbHVyZXMgKGJ1dCBhbHNvIGhhdmUgZmxha3luZXNzKQpz aG91bGQgYmUgcmVqZWN0ZWQgcmF0aGVyIHRoYW4gc3Bpbi4KKE1vY2tDb21taXRRdWV1ZS5yZXBv cnRfZmxha3lfdGVzdHMpOgooQ29tbWl0UXVldWVUYXNrVGVzdC5fcnVuX2FuZF9leHBlY3RfcGF0 Y2hfYW5hbHlzaXNfcmVzdWx0KToKKHRlc3RfZG91YmxlX2ZsYWt5X3Rlc3RfZmFpbHVyZSk6Cih0 ZXN0X3R3b19mbGFreV90ZXN0cyk6Cih0ZXN0X3ZlcnlfZmxha3lfcGF0Y2gpOgoodGVzdF92ZXJ5 X2ZsYWt5X3BhdGNoX3dpdGhfc29tZV90cmVlX3JlZG5lc3MpOgoodGVzdF9kaWZmZXJlbnRfdGVz dF9mYWlsdXJlcyk6Cih0ZXN0X2RpZmZlcmVudF90ZXN0X2ZhaWx1cmVzX3dpdGhfc29tZV90cmVl X3JlZG5lc3MpOgoodGVzdF9kaWZmZXJlbnRfdGVzdF9mYWlsdXJlc193aXRoX3NvbWVfdHJlZV9y ZWRuZXNzX2FuZF9zb21lX2ZpeGVzKToKKHRlc3RfbWlsZGx5X2ZsYWt5X3BhdGNoKToKKHRlc3Rf bWlsZGx5X2ZsYWt5X3BhdGNoX3dpdGhfc29tZV90cmVlX3JlZG5lc3MpOgoqIFNjcmlwdHMvd2Vi a2l0cHkvdG9vbC9ib3QvcGF0Y2hhbmFseXNpc3Rhc2sucHk6Ck1ha2VzIFBhdGNoQW5hbHlzaXNU YXNrIHJlamVjdCBzYWlkIHBhdGNoZXMuCihQYXRjaEFuYWx5c2lzVGFzay5fdGVzdF9wYXRjaCk6 Ci0tLQogVG9vbHMvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCAzMSArKysrKysrKysrKysrKysrKysKIC4uLi93ZWJraXRweS9sYXlvdXRfdGVzdHMvbW9kZWxz L3Rlc3RfcmVzdWx0cy5weSAgIHwgIDMgKysKIC4uLi93ZWJraXRweS90b29sL2JvdC9jb21taXRx dWV1ZXRhc2tfdW5pdHRlc3QucHkgIHwgMzcgKysrKysrKysrKysrKy0tLS0tLS0tLQogLi4uL1Nj cmlwdHMvd2Via2l0cHkvdG9vbC9ib3QvcGF0Y2hhbmFseXNpc3Rhc2sucHkgfCAyNyArKysrKysr KysrKysrLS0tCiA0IGZpbGVzIGNoYW5nZWQsIDc4IGluc2VydGlvbnMoKyksIDIwIGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRl eCA3ZjVkYjQyLi4yM2RkODc3IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9v bHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTQtMTAtMjkgIEpha2UgTmllbHNlbiAg PGphY29iX25pZWxzZW5AYXBwbGUuY29tPgorCisgICAgICAgIENvbW1pdFF1ZXVlIGFuZCBFV1Mg c2hvdWxkIHJlamVjdCBhbnkgcGF0Y2hlcyB0aGF0IHJlc3VsdCBpbiBjb25zaXN0ZW50IHRlc3QK KyAgICAgICAgZmFpbHVyZXMgdGhhdCBhcmVuJ3QgcHJlc2VudCBvbiB0aGUgdHJlZS4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzODE4NAorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogU2NyaXB0cy93ZWJr aXRweS9sYXlvdXRfdGVzdHMvbW9kZWxzL3Rlc3RfcmVzdWx0cy5weToKKyAgICAgICAgQWRkcyBh IHNpbXBsZSBoYXNoaW5nIGZ1bmN0aW9uIHRvIGFsbG93IGZvciBzZXQgb3BlcmF0aW9ucyB0byBo YW5kbGUKKyAgICAgICAgVGVzdFJlc3VsdCBvYmplY3RzIHByb3Blcmx5LgorICAgICAgICAoVGVz dFJlc3VsdC5fX2hhc2hfXyk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29sL2JvdC9j b21taXRxdWV1ZXRhc2tfdW5pdHRlc3QucHk6CisgICAgICAgIEFkZHMgb25lIHVuaXQgdGVzdCwg YW5kIG1vZGlmaWVzIG90aGVycyB0byBhZ3JlZSB3aXRoIHRoZSBub3Rpb24gdGhhdAorICAgICAg ICBwYXRjaGVzIHRoYXQgaW50cm9kdWNlIG5ldyB0ZXN0IGZhaWx1cmVzIChidXQgYWxzbyBoYXZl IGZsYWt5bmVzcykKKyAgICAgICAgc2hvdWxkIGJlIHJlamVjdGVkIHJhdGhlciB0aGFuIHNwaW4u CisgICAgICAgIChNb2NrQ29tbWl0UXVldWUucmVwb3J0X2ZsYWt5X3Rlc3RzKToKKyAgICAgICAg KENvbW1pdFF1ZXVlVGFza1Rlc3QuX3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3Vs dCk6CisgICAgICAgICh0ZXN0X2RvdWJsZV9mbGFreV90ZXN0X2ZhaWx1cmUpOgorICAgICAgICAo dGVzdF90d29fZmxha3lfdGVzdHMpOgorICAgICAgICAodGVzdF92ZXJ5X2ZsYWt5X3BhdGNoKToK KyAgICAgICAgKHRlc3RfdmVyeV9mbGFreV9wYXRjaF93aXRoX3NvbWVfdHJlZV9yZWRuZXNzKToK KyAgICAgICAgKHRlc3RfZGlmZmVyZW50X3Rlc3RfZmFpbHVyZXMpOgorICAgICAgICAodGVzdF9k aWZmZXJlbnRfdGVzdF9mYWlsdXJlc193aXRoX3NvbWVfdHJlZV9yZWRuZXNzKToKKyAgICAgICAg KHRlc3RfZGlmZmVyZW50X3Rlc3RfZmFpbHVyZXNfd2l0aF9zb21lX3RyZWVfcmVkbmVzc19hbmRf c29tZV9maXhlcyk6CisgICAgICAgICh0ZXN0X21pbGRseV9mbGFreV9wYXRjaCk6CisgICAgICAg ICh0ZXN0X21pbGRseV9mbGFreV9wYXRjaF93aXRoX3NvbWVfdHJlZV9yZWRuZXNzKToKKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvYm90L3BhdGNoYW5hbHlzaXN0YXNrLnB5OgorICAg ICAgICBNYWtlcyBQYXRjaEFuYWx5c2lzVGFzayByZWplY3Qgc2FpZCBwYXRjaGVzLgorICAgICAg ICAoUGF0Y2hBbmFseXNpc1Rhc2suX3Rlc3RfcGF0Y2gpOgorCiAyMDE0LTEwLTI5ICBDc2FiYSBP c3p0cm9nb27DoWMgIDxvc3N5QHdlYmtpdC5vcmc+CiAKICAgICAgICAgW0VGTF0gYnVpbGQtd2Vi a2l0IHNob3VsZCB0cnkgaGFyZGVyIHRvIGF2b2lkIHJlLXJ1bm5pbmcgY21ha2UKZGlmZiAtLWdp dCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL21vZGVscy90ZXN0X3Jlc3Vs dHMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9tb2RlbHMvdGVzdF9y ZXN1bHRzLnB5CmluZGV4IGQ2ZmQxMGIuLjEzMGM5OTAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL21vZGVscy90ZXN0X3Jlc3VsdHMucHkKKysrIGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbW9kZWxzL3Rlc3RfcmVzdWx0cy5weQpA QCAtNjQsNiArNjQsOSBAQCBjbGFzcyBUZXN0UmVzdWx0KG9iamVjdCk6CiAgICAgZGVmIF9fbmVf XyhzZWxmLCBvdGhlcik6CiAgICAgICAgIHJldHVybiBub3QgKHNlbGYgPT0gb3RoZXIpCiAKKyAg ICBkZWYgX19oYXNoX18oc2VsZik6CisgICAgICAgIHJldHVybiBzZWxmLnRlc3RfbmFtZS5fX2hh c2hfXygpCisKICAgICBkZWYgaGFzX2ZhaWx1cmVfbWF0Y2hpbmdfdHlwZXMoc2VsZiwgKmZhaWx1 cmVfY2xhc3Nlcyk6CiAgICAgICAgIGZvciBmYWlsdXJlIGluIHNlbGYuZmFpbHVyZXM6CiAgICAg ICAgICAgICBpZiB0eXBlKGZhaWx1cmUpIGluIGZhaWx1cmVfY2xhc3NlczoKZGlmZiAtLWdpdCBh L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9ib3QvY29tbWl0cXVldWV0YXNrX3VuaXR0ZXN0 LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2JvdC9jb21taXRxdWV1ZXRhc2tfdW5p dHRlc3QucHkKaW5kZXggNGRmYWMzZi4uZGMxMzljOCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS90b29sL2JvdC9jb21taXRxdWV1ZXRhc2tfdW5pdHRlc3QucHkKKysrIGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS90b29sL2JvdC9jb21taXRxdWV1ZXRhc2tfdW5pdHRlc3QucHkK QEAgLTczLDggKzczLDkgQEAgY2xhc3MgTW9ja0NvbW1pdFF1ZXVlKENvbW1pdFF1ZXVlVGFza0Rl bGVnYXRlKToKICAgICAgICAgcmV0dXJuIExheW91dFRlc3RSZXN1bHRzKHRlc3RfcmVzdWx0cz1b XSwgZGlkX2V4Y2VlZF90ZXN0X2ZhaWx1cmVfbGltaXQ9RmFsc2UpCiAKICAgICBkZWYgcmVwb3J0 X2ZsYWt5X3Rlc3RzKHNlbGYsIHBhdGNoLCBmbGFreV9yZXN1bHRzLCByZXN1bHRzX2FyY2hpdmUp OgotICAgICAgICBzZWxmLl9mbGFreV90ZXN0cyA9IFtyZXN1bHQudGVzdF9uYW1lIGZvciByZXN1 bHQgaW4gZmxha3lfcmVzdWx0c10KLSAgICAgICAgX2xvZy5pbmZvKCJyZXBvcnRfZmxha3lfdGVz dHM6IHBhdGNoPSclcycgZmxha3lfdGVzdHM9JyVzJyBhcmNoaXZlPSclcyciICUgKHBhdGNoLmlk KCksIHNlbGYuX2ZsYWt5X3Rlc3RzLCByZXN1bHRzX2FyY2hpdmUuZmlsZW5hbWUpKQorICAgICAg ICBjdXJyZW50X2ZsYWt5X3Rlc3RzID0gW3Jlc3VsdC50ZXN0X25hbWUgZm9yIHJlc3VsdCBpbiBm bGFreV9yZXN1bHRzXQorICAgICAgICBzZWxmLl9mbGFreV90ZXN0cyArPSBjdXJyZW50X2ZsYWt5 X3Rlc3RzCisgICAgICAgIF9sb2cuaW5mbygicmVwb3J0X2ZsYWt5X3Rlc3RzOiBwYXRjaD0nJXMn IGZsYWt5X3Rlc3RzPSclcycgYXJjaGl2ZT0nJXMnIiAlIChwYXRjaC5pZCgpLCBjdXJyZW50X2Zs YWt5X3Rlc3RzLCByZXN1bHRzX2FyY2hpdmUuZmlsZW5hbWUpKQogCiAgICAgZGVmIGdldF9yZXBv cnRlZF9mbGFreV90ZXN0cyhzZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYuX2ZsYWt5X3Rlc3Rz CkBAIC0xNzQsNyArMTc1LDcgQEAgY2xhc3MgQ29tbWl0UXVldWVUYXNrVGVzdCh1bml0dGVzdC5U ZXN0Q2FzZSk6CiAgICAgICAgICAgICBhbmFseXNpc19yZXN1bHQgPSBQYXRjaEFuYWx5c2lzUmVz dWx0LkZBSUwKIAogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGFuYWx5c2lzX3Jlc3VsdCwgZXhw ZWN0ZWRfYW5hbHlzaXNfcmVzdWx0KQotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGNvbW1pdF9x dWV1ZS5nZXRfcmVwb3J0ZWRfZmxha3lfdGVzdHMoKSwgZXhwZWN0ZWRfcmVwb3J0ZWRfZmxha3lf dGVzdHMpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoZnJvemVuc2V0KGNvbW1pdF9xdWV1ZS5n ZXRfcmVwb3J0ZWRfZmxha3lfdGVzdHMoKSksIGZyb3plbnNldChleHBlY3RlZF9yZXBvcnRlZF9m bGFreV90ZXN0cykpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoY29tbWl0X3F1ZXVlLmRpZF9y dW5fY2xlYW5fdGVzdHMoKSwgZXhwZWN0X2NsZWFuX3Rlc3RzX3RvX3J1bikKIAogICAgICAgICAj IFRoZSBmYWlsdXJlIHN0YXR1cyBvbmx5IG1lYW5zIGFueXRoaW5nIGlmIHdlIGFjdHVhbGx5IGZh aWxlZC4KQEAgLTM3OCw3ICszNzksNyBAQCBjb21tYW5kX2ZhaWxlZDogZmFpbHVyZV9tZXNzYWdl PSdVbmFibGUgdG8gbGFuZCBwYXRjaCcgc2NyaXB0X2Vycm9yPSdNT0NLIGxhbmQgZgogICAgICAg ICAjIFRoZSAoc3VidGxlKSBwb2ludCBvZiB0aGlzIHRlc3QgaXMgdGhhdCByZXBvcnRfZmxha3lf dGVzdHMgZG9lcyBub3QgZ2V0CiAgICAgICAgICMgY2FsbGVkIGZvciB0aGlzIHJ1bi4KICAgICAg ICAgIyBOb3RlIGFsc28gdGhhdCB0aGVyZSBpcyBubyBhdHRlbXB0IHRvIHJ1biB0aGUgdGVzdHMg dy9vIHRoZSBwYXRjaC4KLSAgICAgICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlz aXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUikKKyAgICAg ICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1 ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUiwgZXhwZWN0ZWRfcmVwb3J0ZWRfZmxha3lfdGVz dHM9WyJGYWlsMSIsICJGYWlsMiJdKQogCiAgICAgZGVmIHRlc3RfdGVzdF9mYWlsdXJlKHNlbGYp OgogICAgICAgICBjb21taXRfcXVldWUgPSBNb2NrU2ltcGxlVGVzdFBsYW5Db21taXRRdWV1ZSgK QEAgLTQyMSw3ICs0MjIsNyBAQCBjb21tYW5kX2ZhaWxlZDogZmFpbHVyZV9tZXNzYWdlPSdVbmFi bGUgdG8gbGFuZCBwYXRjaCcgc2NyaXB0X2Vycm9yPSdNT0NLIGxhbmQgZgogICAgICAgICAgICAg Y2xlYW5fdGVzdF9mYWlsdXJlcz1bIkZhaWwxIiwgIkZhaWwyIl0pCiAKICAgICAgICAgIyBGSVhN RTogVGhpcyBzaG91bGQgcGFzcywgYnV0IGFzIG9mIHJpZ2h0IG5vdywgaXQgZGVmZXJzLgotICAg ICAgICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1 ZXVlLCBQYXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSKQorICAgICAgICBzZWxmLl9ydW5fYW5kX2V4 cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVz dWx0LkRFRkVSLCBleHBlY3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0cz1bIkZhaWwxIiwgIkZhaWwy Il0pCiAKICAgICBkZWYgdGVzdF9vbmVfZmxha3lfdGVzdChzZWxmKToKICAgICAgICAgY29tbWl0 X3F1ZXVlID0gTW9ja1NpbXBsZVRlc3RQbGFuQ29tbWl0UXVldWUoCkBAIC00MzgsMTYgKzQzOSwx NiBAQCBjb21tYW5kX2ZhaWxlZDogZmFpbHVyZV9tZXNzYWdlPSdVbmFibGUgdG8gbGFuZCBwYXRj aCcgc2NyaXB0X2Vycm9yPSdNT0NLIGxhbmQgZgogICAgICAgICAgICAgY2xlYW5fdGVzdF9mYWls dXJlcz1bXSkKIAogICAgICAgICAjIEZJWE1FOiBUaGlzIHNob3VsZCBhY3R1YWxseSBmYWlsLCBi dXQgcmlnaHQgbm93IGl0IGRlZmVycwotICAgICAgICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRj aF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVS KQorICAgICAgICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29t bWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSLCBleHBlY3RlZF9yZXBvcnRlZF9m bGFreV90ZXN0cz1bIkZhaWwxIiwgIkZhaWwyIiwgIkZhaWwzIiwgIkZhaWw0IiwgIkZhaWw1Iiwg IkZhaWw2IiwgIkZhaWw3IiwgIkZhaWw4IiwgIkZhaWw5IiwgIkZhaWwxMCJdKQogCiAgICAgZGVm IHRlc3RfdmVyeV9mbGFreV9wYXRjaF93aXRoX3NvbWVfdHJlZV9yZWRuZXNzKHNlbGYpOgogICAg ICAgICBjb21taXRfcXVldWUgPSBNb2NrU2ltcGxlVGVzdFBsYW5Db21taXRRdWV1ZSgKLSAgICAg ICAgICAgIGZpcnN0X3Rlc3RfZmFpbHVyZXM9WyJQcmVFeGlzdGluZ0ZhaWwxIiwgIlByZUV4aXN0 aW5nRmFpbDIiLCAiRmFpbDYiLCAiRmFpbDciLCAiRmFpbDgiLCAiRmFpbDkiLCAiRmFpbDEwIl0s Ci0gICAgICAgICAgICBzZWNvbmRfdGVzdF9mYWlsdXJlcz1bIlByZUV4aXN0aW5nRmFpbDEiLCAi UHJlRXhpc3RpbmdGYWlsMiIsICJGYWlsMSIsICJGYWlsMiIsICJGYWlsMyIsICJGYWlsNCIsICJG YWlsNSJdLAorICAgICAgICAgICAgZmlyc3RfdGVzdF9mYWlsdXJlcz1bIlByZUV4aXN0aW5nRmFp bDEiLCAiUHJlRXhpc3RpbmdGYWlsMiIsICJGYWlsMSIsICJGYWlsMiIsICJGYWlsMyIsICJGYWls NCIsICJGYWlsNSJdLAorICAgICAgICAgICAgc2Vjb25kX3Rlc3RfZmFpbHVyZXM9WyJQcmVFeGlz dGluZ0ZhaWwxIiwgIlByZUV4aXN0aW5nRmFpbDIiLCAiRmFpbDYiLCAiRmFpbDciLCAiRmFpbDgi LCAiRmFpbDkiLCAiRmFpbDEwIl0sCiAgICAgICAgICAgICBjbGVhbl90ZXN0X2ZhaWx1cmVzPVsi UHJlRXhpc3RpbmdGYWlsMSIsICJQcmVFeGlzdGluZ0ZhaWwyIl0pCiAKICAgICAgICAgIyBGSVhN RTogVGhpcyBzaG91bGQgYWN0dWFsbHkgZmFpbCwgYnV0IHJpZ2h0IG5vdyBpdCBkZWZlcnMKLSAg ICAgICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9x dWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5ERUZFUikKKyAgICAgICAgc2VsZi5fcnVuX2FuZF9l eHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jl c3VsdC5ERUZFUiwgZXhwZWN0X2NsZWFuX3Rlc3RzX3RvX3J1bj1UcnVlLCBleHBlY3RlZF9yZXBv cnRlZF9mbGFreV90ZXN0cz1bIkZhaWwxIiwgIkZhaWwyIiwgIkZhaWwzIiwgIkZhaWw0IiwgIkZh aWw1IiwgIkZhaWw2IiwgIkZhaWw3IiwgIkZhaWw4IiwgIkZhaWw5IiwgIkZhaWwxMCJdKQogCiAg ICAgZGVmIHRlc3RfZGlmZmVyZW50X3Rlc3RfZmFpbHVyZXMoc2VsZik6CiAgICAgICAgIGNvbW1p dF9xdWV1ZSA9IE1vY2tTaW1wbGVUZXN0UGxhbkNvbW1pdFF1ZXVlKApAQCAtNDU1LDggKzQ1Niw3 IEBAIGNvbW1hbmRfZmFpbGVkOiBmYWlsdXJlX21lc3NhZ2U9J1VuYWJsZSB0byBsYW5kIHBhdGNo JyBzY3JpcHRfZXJyb3I9J01PQ0sgbGFuZCBmCiAgICAgICAgICAgICBzZWNvbmRfdGVzdF9mYWls dXJlcz1bIkZhaWwxIiwgIkZhaWwyIiwgIkZhaWwzIiwgIkZhaWw0IiwgIkZhaWw1Il0sCiAgICAg ICAgICAgICBjbGVhbl90ZXN0X2ZhaWx1cmVzPVtdKQogCi0gICAgICAgICMgRklYTUU6IFRoaXMg c2hvdWxkIGFjdHVhbGx5IGZhaWwsIGJ1dCByaWdodCBub3cgaXQgZGVmZXJzCi0gICAgICAgIHNl bGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBh dGNoQW5hbHlzaXNSZXN1bHQuREVGRVIpCisgICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3Bh dGNoX2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuRkFJ TCwgZXhwZWN0X2NsZWFuX3Rlc3RzX3RvX3J1bj1UcnVlLCBleHBlY3RlZF9yZXBvcnRlZF9mbGFr eV90ZXN0cz1bIkZhaWw2Il0sIGV4cGVjdGVkX2ZhaWx1cmVfc3RhdHVzX2lkPTEpCiAKICAgICBk ZWYgdGVzdF9kaWZmZXJlbnRfdGVzdF9mYWlsdXJlc193aXRoX3NvbWVfdHJlZV9yZWRuZXNzKHNl bGYpOgogICAgICAgICBjb21taXRfcXVldWUgPSBNb2NrU2ltcGxlVGVzdFBsYW5Db21taXRRdWV1 ZSgKQEAgLTQ2NCw4ICs0NjQsMTUgQEAgY29tbWFuZF9mYWlsZWQ6IGZhaWx1cmVfbWVzc2FnZT0n VW5hYmxlIHRvIGxhbmQgcGF0Y2gnIHNjcmlwdF9lcnJvcj0nTU9DSyBsYW5kIGYKICAgICAgICAg ICAgIHNlY29uZF90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhpc3RpbmdGYWlsMSIsICJQcmVFeGlzdGlu Z0ZhaWwyIiwgIkZhaWwxIiwgIkZhaWwyIiwgIkZhaWwzIiwgIkZhaWw0IiwgIkZhaWw1Il0sCiAg ICAgICAgICAgICBjbGVhbl90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhpc3RpbmdGYWlsMSIsICJQcmVF eGlzdGluZ0ZhaWwyIl0pCiAKLSAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQgYWN0dWFsbHkg ZmFpbCwgYnV0IHJpZ2h0IG5vdyBpdCBkZWZlcnMKLSAgICAgICAgc2VsZi5fcnVuX2FuZF9leHBl Y3RfcGF0Y2hfYW5hbHlzaXNfcmVzdWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3Vs dC5ERUZFUikKKyAgICAgICAgc2VsZi5fcnVuX2FuZF9leHBlY3RfcGF0Y2hfYW5hbHlzaXNfcmVz dWx0KGNvbW1pdF9xdWV1ZSwgUGF0Y2hBbmFseXNpc1Jlc3VsdC5GQUlMLCBleHBlY3RfY2xlYW5f dGVzdHNfdG9fcnVuPVRydWUsIGV4cGVjdGVkX3JlcG9ydGVkX2ZsYWt5X3Rlc3RzPVsiRmFpbDYi XSwgZXhwZWN0ZWRfZmFpbHVyZV9zdGF0dXNfaWQ9MSkKKworICAgIGRlZiB0ZXN0X2RpZmZlcmVu dF90ZXN0X2ZhaWx1cmVzX3dpdGhfc29tZV90cmVlX3JlZG5lc3NfYW5kX3NvbWVfZml4ZXMoc2Vs Zik6CisgICAgICAgIGNvbW1pdF9xdWV1ZSA9IE1vY2tTaW1wbGVUZXN0UGxhbkNvbW1pdFF1ZXVl KAorICAgICAgICAgICAgZmlyc3RfdGVzdF9mYWlsdXJlcz1bIlByZUV4aXN0aW5nRmFpbDEiLCAi RmFpbDEiLCAiRmFpbDIiLCAiRmFpbDMiLCAiRmFpbDQiLCAiRmFpbDUiLCAiRmFpbDYiXSwKKyAg ICAgICAgICAgIHNlY29uZF90ZXN0X2ZhaWx1cmVzPVsiUHJlRXhpc3RpbmdGYWlsMSIsICJGYWls MSIsICJGYWlsMiIsICJGYWlsMyIsICJGYWlsNCIsICJGYWlsNSJdLAorICAgICAgICAgICAgY2xl YW5fdGVzdF9mYWlsdXJlcz1bIlByZUV4aXN0aW5nRmFpbDEiLCAiUHJlRXhpc3RpbmdGYWlsMiJd KQorCisgICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdChj b21taXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuRkFJTCwgZXhwZWN0X2NsZWFuX3Rlc3Rz X3RvX3J1bj1UcnVlLCBleHBlY3RlZF9yZXBvcnRlZF9mbGFreV90ZXN0cz1bIkZhaWw2Il0sIGV4 cGVjdGVkX2ZhaWx1cmVfc3RhdHVzX2lkPTEpCiAKICAgICBkZWYgdGVzdF9taWxkbHlfZmxha3lf cGF0Y2goc2VsZik6CiAgICAgICAgIGNvbW1pdF9xdWV1ZSA9IE1vY2tTaW1wbGVUZXN0UGxhbkNv bW1pdFF1ZXVlKApAQCAtNDczLDcgKzQ4MCw3IEBAIGNvbW1hbmRfZmFpbGVkOiBmYWlsdXJlX21l c3NhZ2U9J1VuYWJsZSB0byBsYW5kIHBhdGNoJyBzY3JpcHRfZXJyb3I9J01PQ0sgbGFuZCBmCiAg ICAgICAgICAgICBzZWNvbmRfdGVzdF9mYWlsdXJlcz1bIkZhaWwyIl0sCiAgICAgICAgICAgICBj bGVhbl90ZXN0X2ZhaWx1cmVzPVtdKQogCi0gICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3Bh dGNoX2FuYWx5c2lzX3Jlc3VsdChjb21taXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuREVG RVIpCisgICAgICAgIHNlbGYuX3J1bl9hbmRfZXhwZWN0X3BhdGNoX2FuYWx5c2lzX3Jlc3VsdChj b21taXRfcXVldWUsIFBhdGNoQW5hbHlzaXNSZXN1bHQuREVGRVIsIGV4cGVjdF9jbGVhbl90ZXN0 c190b19ydW49RmFsc2UsIGV4cGVjdGVkX3JlcG9ydGVkX2ZsYWt5X3Rlc3RzPVsiRmFpbDEiLCAi RmFpbDIiXSkKIAogICAgIGRlZiB0ZXN0X21pbGRseV9mbGFreV9wYXRjaF93aXRoX3NvbWVfdHJl ZV9yZWRuZXNzKHNlbGYpOgogICAgICAgICBjb21taXRfcXVldWUgPSBNb2NrU2ltcGxlVGVzdFBs YW5Db21taXRRdWV1ZSgKQEAgLTQ4MSw3ICs0ODgsNyBAQCBjb21tYW5kX2ZhaWxlZDogZmFpbHVy ZV9tZXNzYWdlPSdVbmFibGUgdG8gbGFuZCBwYXRjaCcgc2NyaXB0X2Vycm9yPSdNT0NLIGxhbmQg ZgogICAgICAgICAgICAgc2Vjb25kX3Rlc3RfZmFpbHVyZXM9WyJQcmVFeGlzdGluZ0ZhaWwxIiwg IlByZUV4aXN0aW5nRmFpbDIiLCAiRmFpbDIiXSwKICAgICAgICAgICAgIGNsZWFuX3Rlc3RfZmFp bHVyZXM9WyJQcmVFeGlzdGluZ0ZhaWwxIiwgIlByZUV4aXN0aW5nRmFpbDIiXSkKIAotICAgICAg ICBzZWxmLl9ydW5fYW5kX2V4cGVjdF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVl LCBQYXRjaEFuYWx5c2lzUmVzdWx0LkRFRkVSKQorICAgICAgICBzZWxmLl9ydW5fYW5kX2V4cGVj dF9wYXRjaF9hbmFseXNpc19yZXN1bHQoY29tbWl0X3F1ZXVlLCBQYXRjaEFuYWx5c2lzUmVzdWx0 LkRFRkVSLCBleHBlY3RfY2xlYW5fdGVzdHNfdG9fcnVuPVRydWUsIGV4cGVjdGVkX3JlcG9ydGVk X2ZsYWt5X3Rlc3RzPVsiRmFpbDEiLCAiRmFpbDIiXSkKIAogICAgIGRlZiB0ZXN0X3RyZWVfbW9y ZV9yZWRfdGhhbl9wYXRjaChzZWxmKToKICAgICAgICAgY29tbWl0X3F1ZXVlID0gTW9ja1NpbXBs ZVRlc3RQbGFuQ29tbWl0UXVldWUoCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L3Rvb2wvYm90L3BhdGNoYW5hbHlzaXN0YXNrLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90 b29sL2JvdC9wYXRjaGFuYWx5c2lzdGFzay5weQppbmRleCA1NThkM2ZjLi5mNWVhZDRjIDEwMDY0 NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvYm90L3BhdGNoYW5hbHlzaXN0YXNr LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9ib3QvcGF0Y2hhbmFseXNpc3Rh c2sucHkKQEAgLTIyNSwxMSArMjI1LDI4IEBAIGNsYXNzIFBhdGNoQW5hbHlzaXNUYXNrKG9iamVj dCk6CiAgICAgICAgICAgICByZXR1cm4gc2VsZi5fY29udGludWVfdGVzdGluZ19wYXRjaF90aGF0 X2V4Y2VlZGVkX2ZhaWx1cmVfbGltaXRfb25fZmlyc3Rfb3Jfc2Vjb25kX3RyeShzZWNvbmRfcmVz dWx0cywgc2Vjb25kX3Jlc3VsdHNfYXJjaGl2ZSwgc2Vjb25kX3NjcmlwdF9lcnJvcikKIAogICAg ICAgICBpZiBzZWxmLl9yZXN1bHRzX2ZhaWxlZF9kaWZmZXJlbnRfdGVzdHMoZmlyc3RfcmVzdWx0 cywgc2Vjb25kX3Jlc3VsdHMpOgotICAgICAgICAgICAgIyBXZSBjb3VsZCByZXBvcnQgZmxha3kg dGVzdHMgaGVyZSwgYnV0IHdlIHdvdWxkIG5lZWQgdG8gYmUgY2FyZWZ1bAotICAgICAgICAgICAg IyB0byB1c2Ugc2ltaWxhciBjaGVja3MgdG8gRXhwZWN0ZWRGYWlsdXJlcy5fY2FuX3RydXN0X3Jl c3VsdHMKLSAgICAgICAgICAgICMgdG8gbWFrZSBzdXJlIHdlIGRvbid0IHJlcG9ydCBjb25zdGFu dCBmYWlsdXJlcyBhcyBmbGFrZXMgd2hlbgotICAgICAgICAgICAgIyB3ZSBoYXBwZW4gdG8gaGl0 IHRoZSAtLWV4aXQtYWZ0ZXItTi1mYWlsdXJlcyBsaW1pdC4KLSAgICAgICAgICAgICMgU2VlIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01MTI3MgorICAgICAgICAgICAg Zmlyc3RfZmFpbGluZ19yZXN1bHRzX3NldCA9IGZyb3plbnNldChmaXJzdF9yZXN1bHRzLmZhaWxp bmdfdGVzdF9yZXN1bHRzKCkpCisgICAgICAgICAgICBzZWNvbmRfZmFpbGluZ19yZXN1bHRzX3Nl dCA9IGZyb3plbnNldChzZWNvbmRfcmVzdWx0cy5mYWlsaW5nX3Rlc3RfcmVzdWx0cygpKQorCisg ICAgICAgICAgICB0ZXN0c190aGF0X29ubHlfZmFpbGVkX2ZpcnN0ID0gZmlyc3RfZmFpbGluZ19y ZXN1bHRzX3NldC5kaWZmZXJlbmNlKHNlY29uZF9mYWlsaW5nX3Jlc3VsdHNfc2V0KQorICAgICAg ICAgICAgc2VsZi5fcmVwb3J0X2ZsYWt5X3Rlc3RzKHRlc3RzX3RoYXRfb25seV9mYWlsZWRfZmly c3QsIGZpcnN0X3Jlc3VsdHNfYXJjaGl2ZSkKKworICAgICAgICAgICAgdGVzdHNfdGhhdF9vbmx5 X2ZhaWxlZF9zZWNvbmQgPSBzZWNvbmRfZmFpbGluZ19yZXN1bHRzX3NldC5kaWZmZXJlbmNlKGZp cnN0X2ZhaWxpbmdfcmVzdWx0c19zZXQpCisgICAgICAgICAgICBzZWxmLl9yZXBvcnRfZmxha3lf dGVzdHModGVzdHNfdGhhdF9vbmx5X2ZhaWxlZF9zZWNvbmQsIHNlY29uZF9yZXN1bHRzX2FyY2hp dmUpCisKKyAgICAgICAgICAgIHRlc3RzX3RoYXRfY29uc2lzdGVudGx5X2ZhaWxlZCA9IGZpcnN0 X2ZhaWxpbmdfcmVzdWx0c19zZXQuaW50ZXJzZWN0aW9uKHNlY29uZF9mYWlsaW5nX3Jlc3VsdHNf c2V0KQorICAgICAgICAgICAgaWYgdGVzdHNfdGhhdF9jb25zaXN0ZW50bHlfZmFpbGVkOgorICAg ICAgICAgICAgICAgIHNlbGYuX2J1aWxkX2FuZF90ZXN0X3dpdGhvdXRfcGF0Y2goKQorICAgICAg ICAgICAgICAgIHNlbGYuX2NsZWFuX3RyZWVfcmVzdWx0cyA9IHNlbGYuX2RlbGVnYXRlLnRlc3Rf cmVzdWx0cygpCisgICAgICAgICAgICAgICAgdGVzdHNfdGhhdF9mYWlsZWRfb25fdHJlZSA9IHNl bGYuX2NsZWFuX3RyZWVfcmVzdWx0cy5mYWlsaW5nX3Rlc3RfcmVzdWx0cygpCisKKyAgICAgICAg ICAgICAgICBuZXdfZmFpbHVyZXNfaW50cm9kdWNlZF9ieV9wYXRjaCA9IHRlc3RzX3RoYXRfY29u c2lzdGVudGx5X2ZhaWxlZC5kaWZmZXJlbmNlKHNldCh0ZXN0c190aGF0X2ZhaWxlZF9vbl90cmVl KSkKKyAgICAgICAgICAgICAgICBpZiBuZXdfZmFpbHVyZXNfaW50cm9kdWNlZF9ieV9wYXRjaDoK KyAgICAgICAgICAgICAgICAgICAgc2VsZi5mYWlsdXJlX3N0YXR1c19pZCA9IGZpcnN0X2ZhaWx1 cmVfc3RhdHVzX2lkCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLnJlcG9ydF9mYWls dXJlKGZpcnN0X3Jlc3VsdHNfYXJjaGl2ZSwgbmV3X2ZhaWx1cmVzX2ludHJvZHVjZWRfYnlfcGF0 Y2gsIGZpcnN0X3NjcmlwdF9lcnJvcikKKworICAgICAgICAgICAgIyBBdCB0aGlzIHBvaW50IHdl IGtub3cgdGhhdCB0aGVyZSBpcyBmbGFreW5lc3Mgd2l0aCB0aGUgcGF0Y2ggYXBwbGllZCwgYnV0 IG5vIGNvbnNpc3RlbnQgZmFpbHVyZXMKKyAgICAgICAgICAgICMgd2VyZSBpbnRyb2R1Y2VkLiBU aGlzIGlzIGEgYml0IG9mIGEgZ3JleS16b25lLgogICAgICAgICAgICAgcmV0dXJuIEZhbHNlCiAK ICAgICAgICAgaWYgc2VsZi5fYnVpbGRfYW5kX3Rlc3Rfd2l0aG91dF9wYXRjaCgpOgotLSAKMS45 LjMgKEFwcGxlIEdpdC01MCkKCg==