143967 2015-04-20 14:34:46 -0700 Many test failures in scm_unittest.py 2015-07-15 16:15:16 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) PC Linux RESOLVED FIXED P2 Normal --- 145511 1 mcatanzaro dean_johnson agomez commit-queue dbates dean_johnson glenn mcatanzaro mmaxfield ossy oldest_to_newest 1086909 0 mcatanzaro 2015-04-20 14:34:46 -0700 Looks like scm_unittest.py has not been updated in a while. I see many failures: $ test-webkitpy --all Suppressing most webkitpy logging while running unit tests. [47/1550] webkitpy.common.checkout.scm.s..._files_local_plus_working_copy erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1409, in test_changed_files_local_plus_working_copy files = self.scm.changed_files('trunk..') File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/git.py", line 223, in changed_files return self.run_status_and_extract_filenames(status_command, self._status_regexp("ADM")) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm.py", line 88, in run_status_and_extract_filenames for line in self.run(status_command, cwd=self.checkout_root).splitlines(): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm.py", line 78, in run decode_output=decode_output) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 456, in run_command (error_handler or self.default_error_handler)(script_error) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 374, in default_error_handler raise error ScriptError: Failed to run "['git', 'diff', '-r', '--name-status', '--no-renames', '--no-ext-diff', '--full-index', 'trunk..', '.']" exit_code: 128 cwd: /tmp/tmpNGh_3sgit_test_checkout [49/1550] webkitpy.common.checkout.scm.s....test_changed_files_not_synced erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1452, in test_changed_files_not_synced run_command(['git', 'checkout', '-b', 'my-branch', 'trunk~3']) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 85, in run_command return Executive().run_command(*args, **kwargs) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 456, in run_command (error_handler or self.default_error_handler)(script_error) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 374, in default_error_handler raise error ScriptError: Failed to run "['git', 'checkout', '-b', 'my-branch', 'trunk~3']" exit_code: 128 [56/1550] webkitpy.common.checkout.scm.s...commit_with_message_not_synced erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1273, in test_commit_with_message_not_synced run_command(['git', 'checkout', '-b', 'my-branch', 'trunk~3']) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 85, in run_command return Executive().run_command(*args, **kwargs) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 456, in run_command (error_handler or self.default_error_handler)(script_error) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 374, in default_error_handler raise error ScriptError: Failed to run "['git', 'checkout', '-b', 'my-branch', 'trunk~3']" exit_code: 128 [58/1550] webkitpy.common.checkout.scm.s...ssage_not_synced_with_conflict erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1286, in test_commit_with_message_not_synced_with_conflict run_command(['git', 'checkout', '-b', 'my-branch', 'trunk~3']) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 85, in run_command return Executive().run_command(*args, **kwargs) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 456, in run_command (error_handler or self.default_error_handler)(script_error) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 374, in default_error_handler raise error ScriptError: Failed to run "['git', 'checkout', '-b', 'my-branch', 'trunk~3']" exit_code: 128 [68/1550] webkitpy.common.checkout.scm.s....test_create_patch_after_merge erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1323, in test_create_patch_after_merge run_command(['git', 'checkout', '-b', 'dummy-branch', 'trunk~3']) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 85, in run_command return Executive().run_command(*args, **kwargs) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 456, in run_command (error_handler or self.default_error_handler)(script_error) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 374, in default_error_handler raise error ScriptError: Failed to run "['git', 'checkout', '-b', 'dummy-branch', 'trunk~3']" exit_code: 128 [75/1550] webkitpy.common.checkout.scm.s...t.test_create_patch_not_synced erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1369, in test_create_patch_not_synced run_command(['git', 'checkout', '-b', 'my-branch', 'trunk~3']) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 85, in run_command return Executive().run_command(*args, **kwargs) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 456, in run_command (error_handler or self.default_error_handler)(script_error) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/system/executive.py", line 374, in default_error_handler raise error ScriptError: Failed to run "['git', 'checkout', '-b', 'my-branch', 'trunk~3']" exit_code: 128 [93/1550] webkitpy.common.checkout.scm....SVNTest.test_remote_branch_ref failed: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1298, in test_remote_branch_ref self.assertEqual(self.scm.remote_branch_ref(), 'refs/remotes/trunk') AssertionError: u'refs/remotes/origin/trunk' != 'refs/remotes/trunk' [104/1550] webkitpy.common.checkout.scm....TestWithMock.test_create_patch erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1569, in test_create_patch scm = self.make_scm(logging_executive=True) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1563, in make_scm scm = Git(cwd=".", executive=MockExecutive(), filesystem=MockFileSystem()) TypeError: __init__() takes exactly 3 arguments (2 given) [105/1550] webkitpy.common.checkout.scm....ver_with_username_and_password erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1579, in test_push_local_commits_to_server_with_username_and_password self.assertEqual(self.make_scm().push_local_commits_to_server(username='dbates@webkit.org', password='blah'), "MOCK output of child process") File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1563, in make_scm scm = Git(cwd=".", executive=MockExecutive(), filesystem=MockFileSystem()) TypeError: __init__() takes exactly 3 arguments (2 given) [106/1550] webkitpy.common.checkout.scm...._username_and_without_password erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1585, in test_push_local_commits_to_server_with_username_and_without_password self.assertRaises(AuthenticationError, self.make_scm().push_local_commits_to_server, {'username': 'dbates@webkit.org'}) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1563, in make_scm scm = Git(cwd=".", executive=MockExecutive(), filesystem=MockFileSystem()) TypeError: __init__() takes exactly 3 arguments (2 given) [107/1550] webkitpy.common.checkout.scm...._without_username_and_password erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1582, in test_push_local_commits_to_server_without_username_and_password self.assertRaises(AuthenticationError, self.make_scm().push_local_commits_to_server) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1563, in make_scm scm = Git(cwd=".", executive=MockExecutive(), filesystem=MockFileSystem()) TypeError: __init__() takes exactly 3 arguments (2 given) [108/1550] webkitpy.common.checkout.scm....out_username_and_with_password erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1588, in test_push_local_commits_to_server_without_username_and_with_password self.assertRaises(AuthenticationError, self.make_scm().push_local_commits_to_server, {'password': 'blah'}) File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1563, in make_scm scm = Git(cwd=".", executive=MockExecutive(), filesystem=MockFileSystem()) TypeError: __init__() takes exactly 3 arguments (2 given) [109/1550] webkitpy.common.checkout.scm....ock.test_timestamp_of_revision erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1591, in test_timestamp_of_revision scm = self.make_scm() File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1563, in make_scm scm = Git(cwd=".", executive=MockExecutive(), filesystem=MockFileSystem()) TypeError: __init__() takes exactly 3 arguments (2 given) [1017/1550] webkitpy.thirdparty.__init___...t.ThirdpartyTest.test_imports erred: Traceback (most recent call last): File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/thirdparty/__init___unittest.py", line 62, in test_imports import webkitpy.thirdparty.autoinstalled.coverage File "/home/mcatanzaro/WebKit/Tools/Scripts/webkitpy/thirdparty/autoinstalled/coverage/__init__.py", line 15, in <module> from coverage.control import coverage, process_startup ImportError: cannot import name coverage Ran 1550 tests in 13.943s FAILED (failures=1, errors=13) Half of them seem to be that GitTestWithMock.make_scm() passes too few arguments to the Git() constructor. The other half seem to reference a commit named trunk, which has no meaning in git. This is with git 2.3.5. 1106278 1 mcatanzaro 2015-07-01 18:29:46 -0700 Note, there was some work on this done in bug #145511. 1106417 2 256017 dean_johnson 2015-07-02 11:06:59 -0700 Created attachment 256017 This is the patch This patch fixes the broken tests. 1106423 3 256017 dbates 2015-07-02 11:22:15 -0700 Comment on attachment 256017 This is the patch View in context: https://bugs.webkit.org/attachment.cgi?id=256017&action=review I have not finished reviewing this change. The patch is taking a reasonable approach. There are some minor issues I've noticed and I have some questions. > Tools/Scripts/webkitpy/common/checkout/scm/git.py:220 > + # status_command.extend(self._patch_directories) We should remove commented out code. > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1274 > + run_command(['git', 'checkout', 'master~3']) > + run_command(['git', 'checkout', '-b', 'my-branch']) Is this correct? Can we write this using only one call to git checkout? > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1288 > + run_command(['git', 'checkout', 'master~3']) > + run_command(['git', 'checkout', '-b', 'my-branch']) Ditto. > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1300 > + self.assertEqual(self.scm.remote_branch_ref(), 'refs/remotes/origin/trunk') Is this correct? > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1325 > + # Check out the correct branch to base dummy-branch from. Please remove this comment since it explains what the code below does. We consider good comments to be comments that explain "why" the codes does a particular action as opposed to "what" the code does. > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1327 > + # Create dummy branch and add a commit Ditto. > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1330 > + run_command(['git', 'merge', 'master']) Is this correct? Can we write this using only one call to git checkout? > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1375 > + run_command(['git', 'checkout', 'master~3']) > + run_command(['git', 'checkout', '-b', 'my-branch']) Is this correct? Can we write this using only one call to git checkout? > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1459 > + run_command(['git', 'checkout', 'master~3']) > + run_command(['git', 'checkout', '-b', 'my-branch']) Is this correct? Can we write this using only one call to git checkout? > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1468 > + run_command(['git', 'checkout', 'master~3']) > + run_command(['git', 'checkout', '-b', 'my-branch']) Ditto. 1106447 4 256028 dean_johnson 2015-07-02 13:15:15 -0700 Created attachment 256028 Fixes scm unit tests and updated based on Daniel's comments. As per Daniel and I's in person discussion, the referenced `trunk` does not appear in any of the created git repositories used for tests, and such I believe that `master` is the correct branch to be comparing to in the majority of the tests. 1106448 5 dean_johnson 2015-07-02 13:16:02 -0700 (In reply to comment #3) > Comment on attachment 256017 [details] > This is the patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=256017&action=review > > I have not finished reviewing this change. The patch is taking a reasonable > approach. There are some minor issues I've noticed and I have some questions. > > > Tools/Scripts/webkitpy/common/checkout/scm/git.py:220 > > + # status_command.extend(self._patch_directories) > > We should remove commented out code. > Removed. > > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1274 > > + run_command(['git', 'checkout', 'master~3']) > > + run_command(['git', 'checkout', '-b', 'my-branch']) > > Is this correct? Can we write this using only one call to git checkout? > > > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1288 > > + run_command(['git', 'checkout', 'master~3']) > > + run_command(['git', 'checkout', '-b', 'my-branch']) > > Ditto. > Fixed. > > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1300 > > + self.assertEqual(self.scm.remote_branch_ref(), 'refs/remotes/origin/trunk') > > Is this correct? > In the setup function for this test suite we clone the trunk branch from the svn repo using git-svn and put it in the git checkout path which is just a temporary path made for tests. My assumption is that git-svn or git itself has changed slightly since the code was originally written to include the remote in the branch reference, which is why origin/ had to be added. > > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1325 > > + # Check out the correct branch to base dummy-branch from. > > Please remove this comment since it explains what the code below does. We > consider good comments to be comments that explain "why" the codes does a > particular action as opposed to "what" the code does. > > > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1327 > > + # Create dummy branch and add a commit > > Ditto. > Removed. > > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1330 > > + run_command(['git', 'merge', 'master']) > > Is this correct? Can we write this using only one call to git checkout? > > > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1375 > > + run_command(['git', 'checkout', 'master~3']) > > + run_command(['git', 'checkout', '-b', 'my-branch']) > > Is this correct? Can we write this using only one call to git checkout? > > > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1459 > > + run_command(['git', 'checkout', 'master~3']) > > + run_command(['git', 'checkout', '-b', 'my-branch']) > > Is this correct? Can we write this using only one call to git checkout? > > > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1468 > > + run_command(['git', 'checkout', 'master~3']) > > + run_command(['git', 'checkout', '-b', 'my-branch']) > > Ditto. Combined all pairs of `git checkout` commands into a single `git checkout` 1106471 6 mcatanzaro 2015-07-02 14:25:02 -0700 Thanks for fixing this. And now I've learned that you can use a single 'git checkout' to switch to a commit and create a new branch with it at the same time; that's new to me too. 1106473 7 mcatanzaro 2015-07-02 14:28:16 -0700 Probably also we should run this test by default, or it will just break again. 'test-webkitpy --all' takes 15 seconds on my machine, so I don't see any point in skipping "slow" tests like this when --all is not passed. 1106499 8 dean_johnson 2015-07-02 15:36:20 -0700 This patch is in conflict with https://bugs.webkit.org/show_bug.cgi?id=137166 and such until we figure out what #!37116 solved exactly I do not think this patch should be landed, even if it's +1'd for code. Removing from commit queue. 1107235 9 256243 dean_johnson 2015-07-06 14:56:06 -0700 Created attachment 256243 Added back patch_directories This adds back the previously affected patch_directories code and fixes the underlying issues that were causing git to complain. 1107283 10 mcatanzaro 2015-07-06 16:50:17 -0700 A couple very minor nits from me. Normally we wrap changelogs at 100 characters, so you don't have to scroll way to the right to read the changelog entry. Also, the comment about /private/var/tmp seems to be Mac-specific; I've never heard of /private before, and mkdtemp() normally returns a path under /tmp not /var/tmp on my machine. 1107288 11 dean_johnson 2015-07-06 17:14:03 -0700 (In reply to comment #10) > A couple very minor nits from me. Normally we wrap changelogs at 100 > characters, so you don't have to scroll way to the right to read the > changelog entry. Good to know, thanks for that info :) > Also, the comment about /private/var/tmp seems to be > Mac-specific; I've never heard of /private before, and mkdtemp() normally > returns a path under /tmp not /var/tmp on my machine. You're right, I should have noted that this fix is primarily for tests being run on Mac systems. After some review, I've still got a few more changes and assumptions to verify before it's ready for review again, so I'll update my new patch with your feedback then. Thanks! 1107320 12 256243 dbates 2015-07-06 18:12:35 -0700 Comment on attachment 256243 Added back patch_directories Clearing review and commit queue flags as further investigation is required per comment 11 . 1107726 13 256243 ossy 2015-07-08 05:03:05 -0700 Comment on attachment 256243 Added back patch_directories View in context: https://bugs.webkit.org/attachment.cgi?id=256243&action=review > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1302 > - self.assertEqual(self.scm.remote_branch_ref(), 'refs/remotes/trunk') > + self.assertEqual(self.scm.remote_branch_ref(), 'refs/remotes/origin/trunk') It would break the test on Linux: [104/1563] webkitpy.common.checkout.scm.scm_unittest.GitSVNTest.test_remote_branch_ref failed: Traceback (most recent call last): File "/home/webkit/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py", line 1302, in test_remote_branch_ref self.assertEqual(self.scm.remote_branch_ref(), 'refs/remotes/origin/trunk') AssertionError: u'refs/remotes/trunk' != 'refs/remotes/origin/trunk' 1107728 14 ossy 2015-07-08 05:06:32 -0700 (In reply to comment #7) > Probably also we should run this test by default, or it will just break > again. 'test-webkitpy --all' takes 15 seconds on my machine, so I don't see > any point in skipping "slow" tests like this when --all is not passed. It takes 5 seconds without all and 30 seconds with --all on a quad core machine. I agree, we can enable it (at least on the bots) once tests pass on Linux, Mac and Windows too. 1108242 15 256491 dean_johnson 2015-07-09 10:52:19 -0700 Created attachment 256491 Added fixes for issues from comments and changed one incorrect test case. The tests originally written in GitSvnTest.test_changed_files_local_plus_working_copy don't seem to be consistent with other test cases written by the author in the same commit, so they've been edited to be correct and now pass. 1108243 16 commit-queue 2015-07-09 10:54:52 -0700 Attachment 256491 did not pass style-queue: ERROR: Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1038: [GitSVNTest._setup_git_checkout] Instance of 'GitSVNTest' has no 'svn_repo_url' member [pylint/E1101] [5] Total errors found: 1 in 4 files If any of these errors are false positives, please file a bug against check-webkit-style. 1108288 17 dean_johnson 2015-07-09 12:26:59 -0700 (In reply to comment #16) > Attachment 256491 [details] did not pass style-queue: > > > ERROR: Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1038: > [GitSVNTest._setup_git_checkout] Instance of 'GitSVNTest' has no > 'svn_repo_url' member [pylint/E1101] [5] > Total errors found: 1 in 4 files > > > If any of these errors are false positives, please file a bug against > check-webkit-style. Bug filed: https://bugs.webkit.org/show_bug.cgi?id=146797 svn_repo_url is a member of SVNTestRepository, which we use in the GitSVNTest setup. 1108333 18 mcatanzaro 2015-07-09 13:51:22 -0700 Your changelog entry is messed up! 1108361 19 256491 dean_johnson 2015-07-09 14:12:10 -0700 Comment on attachment 256491 Added fixes for issues from comments and changed one incorrect test case. Oops. Fixed. 1108363 20 256491 dean_johnson 2015-07-09 14:12:34 -0700 Comment on attachment 256491 Added fixes for issues from comments and changed one incorrect test case. From 588babf59986d51aa0b0c4ea23f17c13725b6ff5 Mon Sep 17 00:00:00 2001 From: Dean Johnson <dean_johnson@apple.com> Date: Thu, 9 Jul 2015 14:09:17 -0700 Subject: [PATCH] Fixes scm unit tests. --- Tools/ChangeLog | 15 +++++++++++++++ Tools/Scripts/webkitpy/common/checkout/scm/detection.py | 10 +++++----- Tools/Scripts/webkitpy/common/checkout/scm/git.py | 2 +- .../Scripts/webkitpy/common/checkout/scm/scm_unittest.py | 16 +++++++++++++--- 4 files changed, 34 insertions(+), 9 deletions(-) diff --git a/Tools/ChangeLog b/Tools/ChangeLog index 8a33cac0..2368627 100644 --- a/Tools/ChangeLog +++ b/Tools/ChangeLog @@ -1,3 +1,18 @@ +2015-07-09 Dean Johnson <dean_johnson@apple.com> + + Fixed scm unit tests. + https://bugs.webkit.org/show_bug.cgi?id=143967 + + Reviewed by NOBODY (OOPS!). + + * Scripts/webkitpy/common/checkout/scm/detection.py: + (SCMDetector.detect_scm_system): Now use realpaths so all paths are consistent when being compared. + * Scripts/webkitpy/common/checkout/scm/git.py: + (Git.changed_files): Fixed `git` invocation syntactical errors. ('-r' replaced with '--raw' and added '--' to escape patch_directories as arguments) + * Scripts/webkitpy/common/checkout/scm/scm_unittest.py: Changed tests and setup in the GitSVNTest class to mroe closely emulate old git.. + (GitSVNTest._setup_git_checkout): Added --prefix option to `git clone` and renamed `master` branch to `trunk`. + (GitSVNTest.test_changed_files_local_plus_working_copy): Changed `trunk` to master and changed how git was referenced so the expected value match the return. Previously the test would fail due to an error of which commits needed to be compared and what was expected. + 2015-06-29 Jake Nielsen <jacob_nielsen@apple.com> Add timeout in run-webkit-tests for launching the simulator diff --git a/Tools/Scripts/webkitpy/common/checkout/scm/detection.py b/Tools/Scripts/webkitpy/common/checkout/scm/detection.py index 87a7a0d..8c59005 100644 --- a/Tools/Scripts/webkitpy/common/checkout/scm/detection.py +++ b/Tools/Scripts/webkitpy/common/checkout/scm/detection.py @@ -63,16 +63,16 @@ class SCMDetector(object): return scm_system def detect_scm_system(self, path, patch_directories=None): - absolute_path = self._filesystem.abspath(path) + real_path = self._filesystem.realpath(path) if patch_directories == []: patch_directories = None - if SVN.in_working_directory(absolute_path, executive=self._executive): - return SVN(cwd=absolute_path, patch_directories=patch_directories, filesystem=self._filesystem, executive=self._executive) + if SVN.in_working_directory(real_path, executive=self._executive): + return SVN(cwd=real_path, patch_directories=patch_directories, filesystem=self._filesystem, executive=self._executive) - if Git.in_working_directory(absolute_path, executive=self._executive): - return Git(cwd=absolute_path, patch_directories=patch_directories, filesystem=self._filesystem, executive=self._executive) + if Git.in_working_directory(real_path, executive=self._executive): + return Git(cwd=real_path, patch_directories=patch_directories, filesystem=self._filesystem, executive=self._executive) return None diff --git a/Tools/Scripts/webkitpy/common/checkout/scm/git.py b/Tools/Scripts/webkitpy/common/checkout/scm/git.py index aad6ead..2be683d 100644 --- a/Tools/Scripts/webkitpy/common/checkout/scm/git.py +++ b/Tools/Scripts/webkitpy/common/checkout/scm/git.py @@ -216,7 +216,7 @@ class Git(SCM, SVNRepository): def changed_files(self, git_commit=None): # FIXME: --diff-filter could be used to avoid the "extract_filenames" step. - status_command = [self.executable_name, 'diff', '-r', '--name-status', "--no-renames", "--no-ext-diff", "--full-index", self.merge_base(git_commit)] + status_command = [self.executable_name, 'diff', '--raw', '--name-status', "--no-renames", "--no-ext-diff", "--full-index", self.merge_base(git_commit), '--'] status_command.extend(self._patch_directories) # FIXME: I'm not sure we're returning the same set of files that SVN.changed_files is. # Added (A), Copied (C), Deleted (D), Modified (M), Renamed (R) diff --git a/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py b/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py index d772d79..484c35c 100644 --- a/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py +++ b/Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py @@ -1035,8 +1035,9 @@ class GitSVNTest(SCMTest): def _setup_git_checkout(self): self.git_checkout_path = tempfile.mkdtemp(suffix="git_test_checkout") # --quiet doesn't make git svn silent, so we use run_silent to redirect output - run_silent(['git', 'svn', 'clone', '-T', 'trunk', self.svn_repo_url, self.git_checkout_path]) + run_silent(['git', 'svn', 'clone', '-T', 'trunk', '--prefix', '', self.svn_repo_url, self.git_checkout_path]) os.chdir(self.git_checkout_path) + run_silent(['git', 'branch', '-m', 'trunk']) def _tear_down_git_checkout(self): # Change back to a valid directory so that later calls to os.getcwd() do not fail. @@ -1406,12 +1407,21 @@ class GitSVNTest(SCMTest): self.assertIn('test_file_commit2', files) # working copy should *not* be in the list. - files = self.scm.changed_files('trunk..') + files = self.scm.changed_files('trunk..') # git diff trunk..HEAD + self.assertNotIn('test_file_commit1', files) + self.assertNotIn('test_file_commit2', files) + + files = self.scm.changed_files('trunk^..') # git diff trunk^..HEAD self.assertIn('test_file_commit1', files) self.assertNotIn('test_file_commit2', files) # working copy *should* be in the list. - files = self.scm.changed_files('trunk....') + # .... is a hack for working copy changes to be included + files = self.scm.changed_files('trunk....') # git diff trunk + self.assertNotIn('test_file_commit1', files) + self.assertIn('test_file_commit2', files) + + files = self.scm.changed_files('trunk^....') # git diff trunk^ self.assertIn('test_file_commit1', files) self.assertIn('test_file_commit2', files) -- 2.3.7 (Apple Git-57) 1108365 21 256518 dean_johnson 2015-07-09 14:14:23 -0700 Created attachment 256518 Fixed changelog from previous patch. Sorry about the spam, I'm still learning the system. 1108367 22 commit-queue 2015-07-09 14:15:38 -0700 Attachment 256518 did not pass style-queue: ERROR: Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1038: [GitSVNTest._setup_git_checkout] Instance of 'GitSVNTest' has no 'svn_repo_url' member [pylint/E1101] [5] Total errors found: 1 in 4 files If any of these errors are false positives, please file a bug against check-webkit-style. 1108389 23 mcatanzaro 2015-07-09 14:51:27 -0700 I don't pretend to understand the changes, but I confirm that all tests pass with this patch. Without this patch I have one failure and six errors. 1108406 24 dean_johnson 2015-07-09 15:06:55 -0700 If you have any questions I'd be more than happy to answer them. :) 1108796 25 256518 dbates 2015-07-10 16:10:08 -0700 Comment on attachment 256518 Fixed changelog from previous patch. View in context: https://bugs.webkit.org/attachment.cgi?id=256518&action=review > Tools/ChangeLog:3 > + Fixed scm unit tests. This line should be the bug title, "Many test failures in scm_unittest.py" (*). An optional bug description should be written after the Reviewed By line. It is unwritten convention to omit a description if the bug title is sufficiently descriptive so as to explain the purpose of the patch. With regards to this patch, the bug title seems sufficiently descriptive. Unless you would like to elaborate further, I suggest we omit the description "Fixed scm unit tests." One example of a well-formed ChangeLog entry can be seen in changeset r186592, <http://trac.webkit.org/changeset/186592>. > Tools/ChangeLog:9 > + (SCMDetector.detect_scm_system): Now use realpaths so all paths are consistent when being compared. This line does not read well. Moreover, the phrase "consistent when being compared" is vague as it neither explains what we are making the path(s) consistent with nor what the path(s) are being compared against. We should explain why we need to use FileSystem.realpath() instead of FileSystem.abspath() to resolve symbolic links. In particular, we should explain why some of the tests (you may want to consider naming one such test) failed on Mac because we did not resolve symbolic links in the checkout path. > Tools/ChangeLog:11 > + (Git.changed_files): Fixed `git` invocation syntactical errors. ('-r' replaced with '--raw' and added '--' to escape patch_directories as arguments) The first sentence in this remark implies that syntax was incorrect for all versions of Git. Notice that the original syntax (before your proposed change) was valid at least up to Git version 1.4.4.5. Also, -r is not equivalent to --raw. According to (2) of section "Limiting the diff output" of the git diff documentation for Git version 1.4.4.5 (*), the command line argument -r was used to recursively perform a diff when given a sub directory. Looking at the same section in the documentation for git diff in Git versions > 1.4.4.5 it seems to imply that git diff performs a recursive diff by default; => we can remove the -r command line option. With regards to the -- delimiter, that was added to git diff in Git version > 1.4.4.5. (*) <https://git-scm.com/docs/git-diff/1.4.4.5> > Tools/ChangeLog:12 > + * Scripts/webkitpy/common/checkout/scm/scm_unittest.py: Changed tests and setup in the GitSVNTest class to mroe closely emulate old git.. mroe => more > Tools/ChangeLog:13 > + (GitSVNTest._setup_git_checkout): Added --prefix option to `git clone` and renamed `master` branch to `trunk`. For your consideration, I suggest we add a remark that explains the versions of Git that require explicitly specifying --prefix to be the empty string. According to <http://git-scm.com/docs/git-svn>, "Before Git v2.0, the default prefix was '' (no prefix)". > Tools/Scripts/webkitpy/common/checkout/scm/git.py:219 > + status_command = [self.executable_name, 'diff', '--raw', '--name-status', "--no-renames", "--no-ext-diff", "--full-index", self.merge_base(git_commit), '--'] As remarked above, -r is not equivalent to --raw. The command line argument -r was used to perform a recursive diff in Git version <= 1.4.4.5. We may be able to omit the -r argument. See my remark above for more details. Alternatively, we could switch to using git diff-tree, which accepts a -r argument and does not require using a path delimiter (--). > Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1040 > + run_silent(['git', 'svn', 'clone', '-T', 'trunk', '--prefix', '', self.svn_repo_url, self.git_checkout_path]) > os.chdir(self.git_checkout_path) > + run_silent(['git', 'branch', '-m', 'trunk']) This change is OK as-is. I wish we could track down when this behavior changed in Git. 1109271 26 256742 dean_johnson 2015-07-13 16:10:30 -0700 Created attachment 256742 Final changes and fixes Updated the ChangeLog to be much more informative about what and why decisions were made. 1109283 27 256742 dbates 2015-07-13 16:46:16 -0700 Comment on attachment 256742 Final changes and fixes Clearing cq flag as Dean has an updated patch. 1109371 28 256771 dean_johnson 2015-07-14 09:12:24 -0700 Created attachment 256771 Patch 1109400 29 256780 dean_johnson 2015-07-14 11:19:16 -0700 Created attachment 256780 Patch 1109401 30 commit-queue 2015-07-14 11:21:51 -0700 Attachment 256780 did not pass style-queue: ERROR: Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1038: [GitSVNTest._setup_git_checkout] Instance of 'GitSVNTest' has no 'svn_repo_url' member [pylint/E1101] [5] Total errors found: 1 in 3 files If any of these errors are false positives, please file a bug against check-webkit-style. 1109403 31 256781 dean_johnson 2015-07-14 11:34:18 -0700 Created attachment 256781 Patch 1109404 32 commit-queue 2015-07-14 11:37:06 -0700 Attachment 256781 did not pass style-queue: ERROR: Tools/Scripts/webkitpy/common/checkout/scm/scm_unittest.py:1038: [GitSVNTest._setup_git_checkout] Instance of 'GitSVNTest' has no 'svn_repo_url' member [pylint/E1101] [5] Total errors found: 1 in 4 files If any of these errors are false positives, please file a bug against check-webkit-style. 1109737 33 256781 dbates 2015-07-15 15:23:40 -0700 Comment on attachment 256781 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=256781&action=review > Tools/Scripts/webkitpy/common/checkout/scm/git.py:220 > + status_command = [self.executable_name, 'diff', '-r', '--name-status', "--no-renames", "--no-ext-diff", "--full-index", self.merge_base(git_commit), '--'] > status_command.extend(self._patch_directories) This is OK as-is. As far as I can tell it is acceptable to pass nothing after the '--'. The first mention of the '--' delimiter that I found was in <https://git-scm.com/docs/git-diff/1.5.0>. We may want to consider only emitting a "--" delimiter if self._patch_directories is a non-empty list. 1109761 34 256781 commit-queue 2015-07-15 16:15:10 -0700 Comment on attachment 256781 Patch Clearing flags on attachment: 256781 Committed r186870: <http://trac.webkit.org/changeset/186870> 1109762 35 commit-queue 2015-07-15 16:15:16 -0700 All reviewed patches have been landed. Closing bug. 256017 2015-07-02 11:06:59 -0700 2015-07-02 13:15:15 -0700 This is the patch file_143967.txt text/plain 8179 dean_johnson RnJvbSA0MWY3YjE1MzEzYzY5OTI5Mzc0YjIzMjFmNWUxMTQ0MGY2Y2ZhMTRiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQ0KRnJvbTogRGVhbiBKb2huc29uIDxkZWFuX2pvaG5zb25AYXBwbGUuY29t Pg0KRGF0ZTogVGh1LCAyIEp1bCAyMDE1IDExOjAzOjE1IC0wNzAwDQpTdWJqZWN0OiBbUEFUQ0hd IEZpeGVkIHNjbSB1bml0IHRlc3RzLg0KDQotLS0NCiBUb29scy9DaGFuZ2VMb2cgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8IDIwICsrKysrKysrKysrKw0KIFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9naXQucHkgIHwgIDQgKy0tDQogLi4uL3dl YmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5ICAgfCAzNiArKysrKysr KysrKysrKysrLS0tLS0tDQogMyBmaWxlcyBjaGFuZ2VkLCA0OCBpbnNlcnRpb25zKCspLCAxMiBk ZWxldGlvbnMoLSkNCg0KZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5n ZUxvZw0KaW5kZXggOGEzM2NhYzAuLmM0YWVkYjggMTAwNjQ0DQotLS0gYS9Ub29scy9DaGFuZ2VM b2cNCisrKyBiL1Rvb2xzL0NoYW5nZUxvZw0KQEAgLTEsMyArMSwyMyBAQA0KKzIwMTUtMDctMDIg IERlYW4gSm9obnNvbiAgPGRlYW5fam9obnNvbkBhcHBsZS5jb20+DQorDQorICAgICAgICBGaXhl ZCBicm9rZW4gdGVzdHMgaW4gc2NtX3VuaXR0ZXN0LnB5DQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQzOTY3DQorDQorICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4NCisNCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24v Y2hlY2tvdXQvc2NtL2dpdC5weToNCisgICAgICAgIChHaXQpOg0KKyAgICAgICAgKEdpdC5jaGFu Z2VkX2ZpbGVzKTogRml4ZWQgYGdpdGAgaW52b2NhdGlvbiBzeW50YWN0aWNhbCBlcnJvcnMuDQor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9zY21fdW5pdHRl c3QucHk6DQorICAgICAgICAoR2l0U1ZOVGVzdC50ZXN0X2NvbW1pdF93aXRoX21lc3NhZ2Vfbm90 X3N5bmNlZCk6IA0KKyAgICAgICAgKEdpdFNWTlRlc3QudGVzdF9jb21taXRfd2l0aF9tZXNzYWdl X25vdF9zeW5jZWRfd2l0aF9jb25mbGljdCk6DQorICAgICAgICAoR2l0U1ZOVGVzdC50ZXN0X3Jl bW90ZV9icmFuY2hfcmVmKToNCisgICAgICAgIChHaXRTVk5UZXN0LnRlc3RfY3JlYXRlX3BhdGNo X2FmdGVyX21lcmdlKToNCisgICAgICAgIChHaXRTVk5UZXN0LnRlc3RfY3JlYXRlX3BhdGNoX25v dF9zeW5jZWQpOg0KKyAgICAgICAgKEdpdFNWTlRlc3QudGVzdF9jaGFuZ2VkX2ZpbGVzX2xvY2Fs X3BsdXNfd29ya2luZ19jb3B5KTogTWVudGlvbmVkICdoYWNrJyBhbHJlYWR5IGJ1aWx0IGludG8g dGhlIGdpdCBTQ00gbW9kdWxlLg0KKyAgICAgICAgKEdpdFNWTlRlc3QudGVzdF9jaGFuZ2VkX2Zp bGVzX2dpdF9jb21taXQpOg0KKyAgICAgICAgKEdpdFNWTlRlc3QudGVzdF9jaGFuZ2VkX2ZpbGVz X25vdF9zeW5jZWQpOg0KKw0KIDIwMTUtMDYtMjkgIEpha2UgTmllbHNlbiAgPGphY29iX25pZWxz ZW5AYXBwbGUuY29tPg0KIA0KICAgICAgICAgQWRkIHRpbWVvdXQgaW4gcnVuLXdlYmtpdC10ZXN0 cyBmb3IgbGF1bmNoaW5nIHRoZSBzaW11bGF0b3INCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weQ0KaW5kZXggYWFkNmVhZC4uOWZiNGJlYSAx MDA2NDQNCi0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9n aXQucHkNCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9n aXQucHkNCkBAIC0yMTYsOCArMjE2LDggQEAgY2xhc3MgR2l0KFNDTSwgU1ZOUmVwb3NpdG9yeSk6 DQogDQogICAgIGRlZiBjaGFuZ2VkX2ZpbGVzKHNlbGYsIGdpdF9jb21taXQ9Tm9uZSk6DQogICAg ICAgICAjIEZJWE1FOiAtLWRpZmYtZmlsdGVyIGNvdWxkIGJlIHVzZWQgdG8gYXZvaWQgdGhlICJl eHRyYWN0X2ZpbGVuYW1lcyIgc3RlcC4NCi0gICAgICAgIHN0YXR1c19jb21tYW5kID0gW3NlbGYu ZXhlY3V0YWJsZV9uYW1lLCAnZGlmZicsICctcicsICctLW5hbWUtc3RhdHVzJywgIi0tbm8tcmVu YW1lcyIsICItLW5vLWV4dC1kaWZmIiwgIi0tZnVsbC1pbmRleCIsIHNlbGYubWVyZ2VfYmFzZShn aXRfY29tbWl0KV0NCi0gICAgICAgIHN0YXR1c19jb21tYW5kLmV4dGVuZChzZWxmLl9wYXRjaF9k aXJlY3RvcmllcykNCisgICAgICAgIHN0YXR1c19jb21tYW5kID0gW3NlbGYuZXhlY3V0YWJsZV9u YW1lLCAnZGlmZicsICctLXJhdycsICctLW5hbWUtc3RhdHVzJywgIi0tbm8tcmVuYW1lcyIsICIt LW5vLWV4dC1kaWZmIiwgIi0tZnVsbC1pbmRleCIsIHNlbGYubWVyZ2VfYmFzZShnaXRfY29tbWl0 KV0NCisgICAgICAgICMgc3RhdHVzX2NvbW1hbmQuZXh0ZW5kKHNlbGYuX3BhdGNoX2RpcmVjdG9y aWVzKQ0KICAgICAgICAgIyBGSVhNRTogSSdtIG5vdCBzdXJlIHdlJ3JlIHJldHVybmluZyB0aGUg c2FtZSBzZXQgb2YgZmlsZXMgdGhhdCBTVk4uY2hhbmdlZF9maWxlcyBpcy4NCiAgICAgICAgICMg QWRkZWQgKEEpLCBDb3BpZWQgKEMpLCBEZWxldGVkIChEKSwgTW9kaWZpZWQgKE0pLCBSZW5hbWVk IChSKQ0KICAgICAgICAgcmV0dXJuIHNlbGYucnVuX3N0YXR1c19hbmRfZXh0cmFjdF9maWxlbmFt ZXMoc3RhdHVzX2NvbW1hbmQsIHNlbGYuX3N0YXR1c19yZWdleHAoIkFETSIpKQ0KZGlmZiAtLWdp dCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9zY21fdW5pdHRl c3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3Vu aXR0ZXN0LnB5DQppbmRleCBkNzcyZDc5Li40YTZlZjY0IDEwMDY0NA0KLS0tIGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5weQ0KKysrIGIv VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5w eQ0KQEAgLTEyNzAsNyArMTI3MCw4IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAg ICAgICBzZWxmLmFzc2VydFJlZ2V4cE1hdGNoZXMoc3ZuX2xvZywgcid0ZXN0X2ZpbGVfY29tbWl0 MScpDQogDQogICAgIGRlZiB0ZXN0X2NvbW1pdF93aXRoX21lc3NhZ2Vfbm90X3N5bmNlZChzZWxm KToNCi0gICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywgJ215LWJy YW5jaCcsICd0cnVua34zJ10pDQorICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291 dCcsICdtYXN0ZXJ+MyddKQ0KKyAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAnY2hlY2tvdXQn LCAnLWInLCAnbXktYnJhbmNoJ10pDQogICAgICAgICBzZWxmLl90d29fbG9jYWxfY29tbWl0cygp DQogICAgICAgICBzZWxmLmFzc2VydFJhaXNlcyhBbWJpZ3VvdXNDb21taXRFcnJvciwgc2VsZi5z Y20uY29tbWl0X3dpdGhfbWVzc2FnZSwgImFub3RoZXIgdGVzdCBjb21taXQiKQ0KICAgICAgICAg Y29tbWl0X3RleHQgPSBzZWxmLnNjbS5jb21taXRfd2l0aF9tZXNzYWdlKCJhbm90aGVyIHRlc3Qg Y29tbWl0IiwgZm9yY2Vfc3F1YXNoPVRydWUpDQpAQCAtMTI4Myw3ICsxMjg0LDggQEAgY2xhc3Mg R2l0U1ZOVGVzdChTQ01UZXN0KToNCiAgICAgICAgIHNlbGYuYXNzZXJ0UmVnZXhwTWF0Y2hlcyhz dm5fbG9nLCByJ3Rlc3RfZmlsZV9jb21taXQxJykNCiANCiAgICAgZGVmIHRlc3RfY29tbWl0X3dp dGhfbWVzc2FnZV9ub3Rfc3luY2VkX3dpdGhfY29uZmxpY3Qoc2VsZik6DQotICAgICAgICBydW5f Y29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdteS1icmFuY2gnLCAndHJ1bmt+Mydd KQ0KKyAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAnY2hlY2tvdXQnLCAnbWFzdGVyfjMnXSkN CisgICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywgJ215LWJyYW5j aCddKQ0KICAgICAgICAgc2VsZi5fbG9jYWxfY29tbWl0KCd0ZXN0X2ZpbGUyJywgJ2FzZGYnLCAn YXNkZiBjb21taXQnKQ0KIA0KICAgICAgICAgIyBUaGVyZSdzIGEgY29uZmxpY3QgYmV0d2VlbiB0 cnVuayBhbmQgdGhlIHRlc3RfZmlsZTIgbW9kaWZpY2F0aW9uLg0KQEAgLTEyOTUsNyArMTI5Nyw3 IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFzc2VydEVxdWFs KHNlbGYuc2NtLl91cHN0cmVhbV9icmFuY2goKSwgJ215LWJyYW5jaCcpDQogDQogICAgIGRlZiB0 ZXN0X3JlbW90ZV9icmFuY2hfcmVmKHNlbGYpOg0KLSAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChz ZWxmLnNjbS5yZW1vdGVfYnJhbmNoX3JlZigpLCAncmVmcy9yZW1vdGVzL3RydW5rJykNCisgICAg ICAgIHNlbGYuYXNzZXJ0RXF1YWwoc2VsZi5zY20ucmVtb3RlX2JyYW5jaF9yZWYoKSwgJ3JlZnMv cmVtb3Rlcy9vcmlnaW4vdHJ1bmsnKQ0KIA0KICAgICBkZWYgdGVzdF9yZXZlcnNlX2RpZmYoc2Vs Zik6DQogICAgICAgICBzZWxmLl9zaGFyZWRfdGVzdF9yZXZlcnNlX2RpZmYoKQ0KQEAgLTEzMjAs OSArMTMyMiwxMiBAQCBjbGFzcyBHaXRTVk5UZXN0KFNDTVRlc3QpOg0KICAgICAgICAgc2VsZi5h c3NlcnRSZWdleHBNYXRjaGVzKHBhdGNoLCByJ1N1YnZlcnNpb24gUmV2aXNpb246IDUnKQ0KIA0K ICAgICBkZWYgdGVzdF9jcmVhdGVfcGF0Y2hfYWZ0ZXJfbWVyZ2Uoc2VsZik6DQotICAgICAgICBy dW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdkdW1teS1icmFuY2gnLCAndHJ1 bmt+MyddKQ0KKyAgICAgICAgIyBDaGVjayBvdXQgdGhlIGNvcnJlY3QgYnJhbmNoIHRvIGJhc2Ug ZHVtbXktYnJhbmNoIGZyb20uDQorICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291 dCcsICdtYXN0ZXJ+MyddKQ0KKyAgICAgICAgIyBDcmVhdGUgZHVtbXkgYnJhbmNoIGFuZCBhZGQg YSBjb21taXQNCisgICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywg J2R1bW15LWJyYW5jaCddKQ0KICAgICAgICAgc2VsZi5fb25lX2xvY2FsX2NvbW1pdCgpDQotICAg ICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdtZXJnZScsICd0cnVuayddKQ0KKyAgICAgICAgcnVu X2NvbW1hbmQoWydnaXQnLCAnbWVyZ2UnLCAnbWFzdGVyJ10pDQogDQogICAgICAgICBwYXRjaCA9 IHNlbGYuc2NtLmNyZWF0ZV9wYXRjaCgpDQogICAgICAgICBzZWxmLmFzc2VydFJlZ2V4cE1hdGNo ZXMocGF0Y2gsIHIndGVzdF9maWxlX2NvbW1pdDEnKQ0KQEAgLTEzNjYsNyArMTM3MSw4IEBAIGNs YXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFzc2VydFJlZ2V4cE1hdGNo ZXMocGF0Y2gsIHIndGVzdF9maWxlX2NvbW1pdDEnKQ0KIA0KICAgICBkZWYgdGVzdF9jcmVhdGVf cGF0Y2hfbm90X3N5bmNlZChzZWxmKToNCi0gICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ2No ZWNrb3V0JywgJy1iJywgJ215LWJyYW5jaCcsICd0cnVua34zJ10pDQorICAgICAgICBydW5fY29t bWFuZChbJ2dpdCcsICdjaGVja291dCcsICdtYXN0ZXJ+MyddKQ0KKyAgICAgICAgcnVuX2NvbW1h bmQoWydnaXQnLCAnY2hlY2tvdXQnLCAnLWInLCAnbXktYnJhbmNoJ10pDQogICAgICAgICBzZWxm Ll90d29fbG9jYWxfY29tbWl0cygpDQogICAgICAgICBwYXRjaCA9IHNlbGYuc2NtLmNyZWF0ZV9w YXRjaCgpDQogICAgICAgICBzZWxmLmFzc2VydE5vdFJlZ2V4cE1hdGNoZXMocGF0Y2gsIHIndGVz dF9maWxlMicpDQpAQCAtMTQwNiwxMiArMTQxMiwxNCBAQCBjbGFzcyBHaXRTVk5UZXN0KFNDTVRl c3QpOg0KICAgICAgICAgc2VsZi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykN CiANCiAgICAgICAgICMgd29ya2luZyBjb3B5IHNob3VsZCAqbm90KiBiZSBpbiB0aGUgbGlzdC4N Ci0gICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygndHJ1bmsuLicpDQorICAg ICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoJ21hc3RlcicpDQogICAgICAgICBz ZWxmLmFzc2VydEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0KICAgICAgICAgc2VsZi5h c3NlcnROb3RJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykNCiANCiAgICAgICAgICMgd29y a2luZyBjb3B5ICpzaG91bGQqIGJlIGluIHRoZSBsaXN0Lg0KLSAgICAgICAgZmlsZXMgPSBzZWxm LnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVuay4uLi4nKQ0KKyAgICAgICAgIyAuLi4uIGlzIGEgaGFj ayBhcm91bmQgXi4uPGNvbW1pdD4gYmVpbmcgYXBwZW5kZWQNCisgICAgICAgICMgdG8gZWFjaCBn aXQgZGlmZiBjb21tYW5kLg0KKyAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVz KCdtYXN0ZXJeLi4uLicpDQogICAgICAgICBzZWxmLmFzc2VydEluKCd0ZXN0X2ZpbGVfY29tbWl0 MScsIGZpbGVzKQ0KICAgICAgICAgc2VsZi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDInLCBm aWxlcykNCiANCkBAIC0xNDIxLDYgKzE0MjksMTIgQEAgY2xhc3MgR2l0U1ZOVGVzdChTQ01UZXN0 KToNCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQxJywgZmlsZXMpDQog ICAgICAgICBzZWxmLmFzc2VydE5vdEluKCd0ZXN0X2ZpbGVfY29tbWl0MicsIGZpbGVzKQ0KIA0K KyAgICAgICAgIyAuLi4uIGlzIGEgaGFjayBhcm91bmQgXi4uPGNvbW1pdD4gYmVpbmcgYXBwZW5k ZWQNCisgICAgICAgICMgdG8gZWFjaCBnaXQgZGlmZiBjb21tYW5kLg0KKyAgICAgICAgZmlsZXMg PSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKGdpdF9jb21taXQ9IkhFQUReXi4uLi4iKQ0KKyAgICAg ICAgc2VsZi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykNCisgICAgICAgIHNl bGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQxJywgZmlsZXMpDQorDQogICAgIGRlZiB0ZXN0 X2NoYW5nZWRfZmlsZXNfZ2l0X2NvbW1pdF9yYW5nZShzZWxmKToNCiAgICAgICAgIHNlbGYuX3Ro cmVlX2xvY2FsX2NvbW1pdHMoKQ0KICAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2Zp bGVzKGdpdF9jb21taXQ9IkhFQUR+Mi4uSEVBRCIpDQpAQCAtMTQ0MSw3ICsxNDU1LDggQEAgY2xh c3MgR2l0U1ZOVGVzdChTQ01UZXN0KToNCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmls ZV9jb21taXQxJywgZmlsZXMpDQogDQogICAgIGRlZiB0ZXN0X2NoYW5nZWRfZmlsZXNfbm90X3N5 bmNlZChzZWxmKToNCi0gICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1i JywgJ215LWJyYW5jaCcsICd0cnVua34zJ10pDQorICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcs ICdjaGVja291dCcsICdtYXN0ZXJ+MyddKQ0KKyAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAn Y2hlY2tvdXQnLCAnLWInLCAnbXktYnJhbmNoJ10pDQogICAgICAgICBzZWxmLl90d29fbG9jYWxf Y29tbWl0cygpDQogICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoKQ0KICAg ICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlMicsIGZpbGVzKQ0KQEAgLTE0NDksNyAr MTQ2NCw4IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFzc2Vy dEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0KIA0KICAgICBkZWYgdGVzdF9jaGFuZ2Vk X2ZpbGVzX25vdF9zeW5jZWQoc2VsZik6DQotICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdj aGVja291dCcsICctYicsICdteS1icmFuY2gnLCAndHJ1bmt+MyddKQ0KKyAgICAgICAgcnVuX2Nv bW1hbmQoWydnaXQnLCAnY2hlY2tvdXQnLCAnbWFzdGVyfjMnXSkNCisgICAgICAgIHJ1bl9jb21t YW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywgJ215LWJyYW5jaCddKQ0KICAgICAgICAgc2Vs Zi5fdHdvX2xvY2FsX2NvbW1pdHMoKQ0KICAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2Vk X2ZpbGVzKCkNCiAgICAgICAgIHNlbGYuYXNzZXJ0Tm90SW4oJ3Rlc3RfZmlsZTInLCBmaWxlcykN Ci0tIA0KMi4zLjcgKEFwcGxlIEdpdC01NykNCg== 256028 2015-07-02 13:15:15 -0700 2015-07-06 14:56:06 -0700 Fixes scm unit tests and updated based on Daniel's comments. file_143967.txt text/plain 8358 dean_johnson RnJvbSBjMjllNWVmODcyZTU3N2QzYWE2OTUzMDVlZmJhMDhhMDk2ZTYwZWYyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQ0KRnJvbTogRGVhbiBKb2huc29uIDxkZWFuX2pvaG5zb25AYXBwbGUuY29t Pg0KRGF0ZTogVGh1LCAyIEp1bCAyMDE1IDEzOjExOjU2IC0wNzAwDQpTdWJqZWN0OiBbUEFUQ0hd IEZpeGVkIHNjbSB1bml0IHRlc3RzLg0KDQotLS0NCiBUb29scy9DaGFuZ2VMb2cgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8IDE5ICsrKysrKysrKysrKysrKw0KIFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9naXQucHkgIHwgIDMgKy0tDQogLi4u L3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5ICAgfCAyOCArKysr KysrKysrKysrKy0tLS0tLS0tDQogMyBmaWxlcyBjaGFuZ2VkLCAzOCBpbnNlcnRpb25zKCspLCAx MiBkZWxldGlvbnMoLSkNCg0KZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0No YW5nZUxvZw0KaW5kZXggOGEzM2NhYzAuLjM2MWE1ZTIgMTAwNjQ0DQotLS0gYS9Ub29scy9DaGFu Z2VMb2cNCisrKyBiL1Rvb2xzL0NoYW5nZUxvZw0KQEAgLTEsMyArMSwyMiBAQA0KKzIwMTUtMDct MDIgIERlYW4gSm9obnNvbiAgPGRlYW5fam9obnNvbkBhcHBsZS5jb20+DQorDQorICAgICAgICBG aXhlZCBzY20gdW5pdCB0ZXN0cy4NCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNDM5NjcNCisNCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLg0KKw0KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20v Z2l0LnB5Og0KKyAgICAgICAgKEdpdC5jaGFuZ2VkX2ZpbGVzKTogQ2hhbmdlZCB0byBub3QgaW5j bHVkZSBwYXRjaF9kaXJlY3RvcmllcyB3aGVuIHJlZmVyZW5jaW5nIGNvbW1pdHMgYW5kIGZpeGVk IGBnaXRgIGludm9jYXRpb24gc3ludGFjdGljYWwgZXJyb3JzLiAoLXIgcmVwbGFjZWQgd2l0aCAt LXJhdykNCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3Nj bV91bml0dGVzdC5weTogRml4ZWQgdGVzdHMuDQorICAgICAgICAoR2l0U1ZOVGVzdC50ZXN0X2Nv bW1pdF93aXRoX21lc3NhZ2Vfbm90X3N5bmNlZCk6IENoYW5nZWQgYHRydW5rYCByZWZlcmVuY2Ug dG8gYG1hc3RlcmANCisgICAgICAgIChHaXRTVk5UZXN0LnRlc3RfY29tbWl0X3dpdGhfbWVzc2Fn ZV9ub3Rfc3luY2VkX3dpdGhfY29uZmxpY3QpOiBDaGFuZ2VkIGB0cnVua2AgcmVmZXJlbmNlIHRv IGBtYXN0ZXJgDQorICAgICAgICAoR2l0U1ZOVGVzdC50ZXN0X3JlbW90ZV9icmFuY2hfcmVmKTog QWRkZWQgL29yaWdpbiB0byB0aGUgbWlkZGxlIG9mIHRoZSBleHBlY3RlZCByZXR1cm4gc3RyaW5n Lg0KKyAgICAgICAgKEdpdFNWTlRlc3QudGVzdF9jcmVhdGVfcGF0Y2hfYWZ0ZXJfbWVyZ2UpOiBD aGFuZ2VkIGB0cnVua2AgcmVmZXJlbmNlIHRvIGBtYXN0ZXJgDQorICAgICAgICAoR2l0U1ZOVGVz dC50ZXN0X2NyZWF0ZV9wYXRjaF9ub3Rfc3luY2VkKTogQ2hhbmdlZCBgdHJ1bmtgIHJlZmVyZW5j ZSB0byBgbWFzdGVyYA0KKyAgICAgICAgKEdpdFNWTlRlc3QudGVzdF9jaGFuZ2VkX2ZpbGVzX2xv Y2FsX3BsdXNfd29ya2luZ19jb3B5KTogQ2hhbmdlZCBgdHJ1bmtgIHRvIG1hc3RlciBhbmQgY2hh bmdlZCBob3cgZ2l0IHdhcyByZWZlcmVuY2VkIHNvIHRoZSBleHBlY3RlZCB2YWx1ZSBtYXRjaCB0 aGUgcmV0dXJuLiBQcmV2aW91c2x5IHRoZSB0ZXN0IHdvdWxkIGZhaWwgZHVlIHRvIGFuIGVycm9y IG9mIHdoaWNoIGNvbW1pdHMgbmVlZGVkIHRvIGJlIGNvbXBhcmVkIGFuZCB3aGF0IHdhcyBleHBl Y3RlZC4NCisgICAgICAgIChHaXRTVk5UZXN0LnRlc3RfY2hhbmdlZF9maWxlc19naXRfY29tbWl0 KTogQWRkZWQgdGVzdCBjYXNlIHRoYXQgbWltaWNrZWQgZnVuY3Rpb24gZGVmaW5pdGlvbiBtb3Jl IHByZWNpc2VseSBhbmQgZml4ZWQgdGhlIGdpdCBjb21taXQgdGhlIHByZXZpb3VzIHRlc3Qgd2Fz IGF0dGVtcHRpbmcgdG8gcmVmZXJlbmNlLg0KKyAgICAgICAgKEdpdFNWTlRlc3QudGVzdF9jaGFu Z2VkX2ZpbGVzX25vdF9zeW5jZWQpOiBDaGFuZ2VkIGB0cnVua2AgcmVmZXJlbmNlIHRvIGBtYXN0 ZXJgDQorDQogMjAxNS0wNi0yOSAgSmFrZSBOaWVsc2VuICA8amFjb2JfbmllbHNlbkBhcHBsZS5j b20+DQogDQogICAgICAgICBBZGQgdGltZW91dCBpbiBydW4td2Via2l0LXRlc3RzIGZvciBsYXVu Y2hpbmcgdGhlIHNpbXVsYXRvcg0KZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv Y29tbW9uL2NoZWNrb3V0L3NjbS9naXQucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9jaGVja291dC9zY20vZ2l0LnB5DQppbmRleCBhYWQ2ZWFkLi42N2YwYmFkIDEwMDY0NA0KLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weQ0KKysr IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weQ0KQEAg LTIxNiw4ICsyMTYsNyBAQCBjbGFzcyBHaXQoU0NNLCBTVk5SZXBvc2l0b3J5KToNCiANCiAgICAg ZGVmIGNoYW5nZWRfZmlsZXMoc2VsZiwgZ2l0X2NvbW1pdD1Ob25lKToNCiAgICAgICAgICMgRklY TUU6IC0tZGlmZi1maWx0ZXIgY291bGQgYmUgdXNlZCB0byBhdm9pZCB0aGUgImV4dHJhY3RfZmls ZW5hbWVzIiBzdGVwLg0KLSAgICAgICAgc3RhdHVzX2NvbW1hbmQgPSBbc2VsZi5leGVjdXRhYmxl X25hbWUsICdkaWZmJywgJy1yJywgJy0tbmFtZS1zdGF0dXMnLCAiLS1uby1yZW5hbWVzIiwgIi0t bm8tZXh0LWRpZmYiLCAiLS1mdWxsLWluZGV4Iiwgc2VsZi5tZXJnZV9iYXNlKGdpdF9jb21taXQp XQ0KLSAgICAgICAgc3RhdHVzX2NvbW1hbmQuZXh0ZW5kKHNlbGYuX3BhdGNoX2RpcmVjdG9yaWVz KQ0KKyAgICAgICAgc3RhdHVzX2NvbW1hbmQgPSBbc2VsZi5leGVjdXRhYmxlX25hbWUsICdkaWZm JywgJy0tcmF3JywgJy0tbmFtZS1zdGF0dXMnLCAiLS1uby1yZW5hbWVzIiwgIi0tbm8tZXh0LWRp ZmYiLCAiLS1mdWxsLWluZGV4Iiwgc2VsZi5tZXJnZV9iYXNlKGdpdF9jb21taXQpXQ0KICAgICAg ICAgIyBGSVhNRTogSSdtIG5vdCBzdXJlIHdlJ3JlIHJldHVybmluZyB0aGUgc2FtZSBzZXQgb2Yg ZmlsZXMgdGhhdCBTVk4uY2hhbmdlZF9maWxlcyBpcy4NCiAgICAgICAgICMgQWRkZWQgKEEpLCBD b3BpZWQgKEMpLCBEZWxldGVkIChEKSwgTW9kaWZpZWQgKE0pLCBSZW5hbWVkIChSKQ0KICAgICAg ICAgcmV0dXJuIHNlbGYucnVuX3N0YXR1c19hbmRfZXh0cmFjdF9maWxlbmFtZXMoc3RhdHVzX2Nv bW1hbmQsIHNlbGYuX3N0YXR1c19yZWdleHAoIkFETSIpKQ0KZGlmZiAtLWdpdCBhL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9zY21fdW5pdHRlc3QucHkgYi9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5DQpp bmRleCBkNzcyZDc5Li5iZTVmOTY1IDEwMDY0NA0KLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5weQ0KKysrIGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5weQ0KQEAgLTEyNzAs NyArMTI3MCw3IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFz c2VydFJlZ2V4cE1hdGNoZXMoc3ZuX2xvZywgcid0ZXN0X2ZpbGVfY29tbWl0MScpDQogDQogICAg IGRlZiB0ZXN0X2NvbW1pdF93aXRoX21lc3NhZ2Vfbm90X3N5bmNlZChzZWxmKToNCi0gICAgICAg IHJ1bl9jb21tYW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywgJ215LWJyYW5jaCcsICd0cnVu a34zJ10pDQorICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdt eS1icmFuY2gnLCAnbWFzdGVyfjMnXSkNCiAgICAgICAgIHNlbGYuX3R3b19sb2NhbF9jb21taXRz KCkNCiAgICAgICAgIHNlbGYuYXNzZXJ0UmFpc2VzKEFtYmlndW91c0NvbW1pdEVycm9yLCBzZWxm LnNjbS5jb21taXRfd2l0aF9tZXNzYWdlLCAiYW5vdGhlciB0ZXN0IGNvbW1pdCIpDQogICAgICAg ICBjb21taXRfdGV4dCA9IHNlbGYuc2NtLmNvbW1pdF93aXRoX21lc3NhZ2UoImFub3RoZXIgdGVz dCBjb21taXQiLCBmb3JjZV9zcXVhc2g9VHJ1ZSkNCkBAIC0xMjgzLDcgKzEyODMsNyBAQCBjbGFz cyBHaXRTVk5UZXN0KFNDTVRlc3QpOg0KICAgICAgICAgc2VsZi5hc3NlcnRSZWdleHBNYXRjaGVz KHN2bl9sb2csIHIndGVzdF9maWxlX2NvbW1pdDEnKQ0KIA0KICAgICBkZWYgdGVzdF9jb21taXRf d2l0aF9tZXNzYWdlX25vdF9zeW5jZWRfd2l0aF9jb25mbGljdChzZWxmKToNCi0gICAgICAgIHJ1 bl9jb21tYW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywgJ215LWJyYW5jaCcsICd0cnVua34z J10pDQorICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdteS1i cmFuY2gnLCAnbWFzdGVyfjMnXSkNCiAgICAgICAgIHNlbGYuX2xvY2FsX2NvbW1pdCgndGVzdF9m aWxlMicsICdhc2RmJywgJ2FzZGYgY29tbWl0JykNCiANCiAgICAgICAgICMgVGhlcmUncyBhIGNv bmZsaWN0IGJldHdlZW4gdHJ1bmsgYW5kIHRoZSB0ZXN0X2ZpbGUyIG1vZGlmaWNhdGlvbi4NCkBA IC0xMjk1LDcgKzEyOTUsNyBAQCBjbGFzcyBHaXRTVk5UZXN0KFNDTVRlc3QpOg0KICAgICAgICAg c2VsZi5hc3NlcnRFcXVhbChzZWxmLnNjbS5fdXBzdHJlYW1fYnJhbmNoKCksICdteS1icmFuY2gn KQ0KIA0KICAgICBkZWYgdGVzdF9yZW1vdGVfYnJhbmNoX3JlZihzZWxmKToNCi0gICAgICAgIHNl bGYuYXNzZXJ0RXF1YWwoc2VsZi5zY20ucmVtb3RlX2JyYW5jaF9yZWYoKSwgJ3JlZnMvcmVtb3Rl cy90cnVuaycpDQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHNlbGYuc2NtLnJlbW90ZV9icmFu Y2hfcmVmKCksICdyZWZzL3JlbW90ZXMvb3JpZ2luL3RydW5rJykNCiANCiAgICAgZGVmIHRlc3Rf cmV2ZXJzZV9kaWZmKHNlbGYpOg0KICAgICAgICAgc2VsZi5fc2hhcmVkX3Rlc3RfcmV2ZXJzZV9k aWZmKCkNCkBAIC0xMzIwLDkgKzEzMjAsOSBAQCBjbGFzcyBHaXRTVk5UZXN0KFNDTVRlc3QpOg0K ICAgICAgICAgc2VsZi5hc3NlcnRSZWdleHBNYXRjaGVzKHBhdGNoLCByJ1N1YnZlcnNpb24gUmV2 aXNpb246IDUnKQ0KIA0KICAgICBkZWYgdGVzdF9jcmVhdGVfcGF0Y2hfYWZ0ZXJfbWVyZ2Uoc2Vs Zik6DQotICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdkdW1t eS1icmFuY2gnLCAndHJ1bmt+MyddKQ0KKyAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAnY2hl Y2tvdXQnLCAnLWInLCAnbXktYnJhbmNoJywgJ21hc3Rlcn4zJ10pDQogICAgICAgICBzZWxmLl9v bmVfbG9jYWxfY29tbWl0KCkNCi0gICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ21lcmdlJywg J3RydW5rJ10pDQorICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdtZXJnZScsICdtYXN0ZXIn XSkNCiANCiAgICAgICAgIHBhdGNoID0gc2VsZi5zY20uY3JlYXRlX3BhdGNoKCkNCiAgICAgICAg IHNlbGYuYXNzZXJ0UmVnZXhwTWF0Y2hlcyhwYXRjaCwgcid0ZXN0X2ZpbGVfY29tbWl0MScpDQpA QCAtMTM2Niw3ICsxMzY2LDcgQEAgY2xhc3MgR2l0U1ZOVGVzdChTQ01UZXN0KToNCiAgICAgICAg IHNlbGYuYXNzZXJ0UmVnZXhwTWF0Y2hlcyhwYXRjaCwgcid0ZXN0X2ZpbGVfY29tbWl0MScpDQog DQogICAgIGRlZiB0ZXN0X2NyZWF0ZV9wYXRjaF9ub3Rfc3luY2VkKHNlbGYpOg0KLSAgICAgICAg cnVuX2NvbW1hbmQoWydnaXQnLCAnY2hlY2tvdXQnLCAnLWInLCAnbXktYnJhbmNoJywgJ3RydW5r fjMnXSkNCisgICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywgJ215 LWJyYW5jaCcsICdtYXN0ZXJ+MyddKQ0KICAgICAgICAgc2VsZi5fdHdvX2xvY2FsX2NvbW1pdHMo KQ0KICAgICAgICAgcGF0Y2ggPSBzZWxmLnNjbS5jcmVhdGVfcGF0Y2goKQ0KICAgICAgICAgc2Vs Zi5hc3NlcnROb3RSZWdleHBNYXRjaGVzKHBhdGNoLCByJ3Rlc3RfZmlsZTInKQ0KQEAgLTE0MDYs MTIgKzE0MDYsMTQgQEAgY2xhc3MgR2l0U1ZOVGVzdChTQ01UZXN0KToNCiAgICAgICAgIHNlbGYu YXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpDQogDQogICAgICAgICAjIHdvcmtp bmcgY29weSBzaG91bGQgKm5vdCogYmUgaW4gdGhlIGxpc3QuDQotICAgICAgICBmaWxlcyA9IHNl bGYuc2NtLmNoYW5nZWRfZmlsZXMoJ3RydW5rLi4nKQ0KKyAgICAgICAgZmlsZXMgPSBzZWxmLnNj bS5jaGFuZ2VkX2ZpbGVzKCdtYXN0ZXInKQ0KICAgICAgICAgc2VsZi5hc3NlcnRJbigndGVzdF9m aWxlX2NvbW1pdDEnLCBmaWxlcykNCiAgICAgICAgIHNlbGYuYXNzZXJ0Tm90SW4oJ3Rlc3RfZmls ZV9jb21taXQyJywgZmlsZXMpDQogDQogICAgICAgICAjIHdvcmtpbmcgY29weSAqc2hvdWxkKiBi ZSBpbiB0aGUgbGlzdC4NCi0gICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygn dHJ1bmsuLi4uJykNCisgICAgICAgICMgLi4uLiBpcyBhIGhhY2sgYXJvdW5kIF4uLjxjb21taXQ+ IGJlaW5nIGFwcGVuZGVkDQorICAgICAgICAjIHRvIGVhY2ggZ2l0IGRpZmYgY29tbWFuZC4NCisg ICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygnbWFzdGVyXi4uLi4nKQ0KICAg ICAgICAgc2VsZi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDEnLCBmaWxlcykNCiAgICAgICAg IHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpDQogDQpAQCAtMTQyMSw2 ICsxNDIzLDEyIEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFz c2VydEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0KICAgICAgICAgc2VsZi5hc3NlcnRO b3RJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykNCiANCisgICAgICAgICMgLi4uLiBpcyBh IGhhY2sgYXJvdW5kIF4uLjxjb21taXQ+IGJlaW5nIGFwcGVuZGVkDQorICAgICAgICAjIHRvIGVh Y2ggZ2l0IGRpZmYgY29tbWFuZC4NCisgICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9m aWxlcyhnaXRfY29tbWl0PSJIRUFEXl4uLi4uIikNCisgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rl c3RfZmlsZV9jb21taXQyJywgZmlsZXMpDQorICAgICAgICBzZWxmLmFzc2VydEluKCd0ZXN0X2Zp bGVfY29tbWl0MScsIGZpbGVzKQ0KKw0KICAgICBkZWYgdGVzdF9jaGFuZ2VkX2ZpbGVzX2dpdF9j b21taXRfcmFuZ2Uoc2VsZik6DQogICAgICAgICBzZWxmLl90aHJlZV9sb2NhbF9jb21taXRzKCkN CiAgICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcyhnaXRfY29tbWl0PSJIRUFE fjIuLkhFQUQiKQ0KQEAgLTE0NDEsNyArMTQ0OSw3IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVz dCk6DQogICAgICAgICBzZWxmLmFzc2VydEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0K IA0KICAgICBkZWYgdGVzdF9jaGFuZ2VkX2ZpbGVzX25vdF9zeW5jZWQoc2VsZik6DQotICAgICAg ICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdteS1icmFuY2gnLCAndHJ1 bmt+MyddKQ0KKyAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAnY2hlY2tvdXQnLCAnLWInLCAn bXktYnJhbmNoJywgJ21hc3Rlcn4zJ10pDQogICAgICAgICBzZWxmLl90d29fbG9jYWxfY29tbWl0 cygpDQogICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoKQ0KICAgICAgICAg c2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlMicsIGZpbGVzKQ0KQEAgLTE0NDksNyArMTQ1Nyw3 IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFzc2VydEluKCd0 ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0KIA0KICAgICBkZWYgdGVzdF9jaGFuZ2VkX2ZpbGVz X25vdF9zeW5jZWQoc2VsZik6DQotICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291 dCcsICctYicsICdteS1icmFuY2gnLCAndHJ1bmt+MyddKQ0KKyAgICAgICAgcnVuX2NvbW1hbmQo WydnaXQnLCAnY2hlY2tvdXQnLCAnLWInLCAnbXktYnJhbmNoJywgJ21hc3Rlcn4zJ10pDQogICAg ICAgICBzZWxmLl90d29fbG9jYWxfY29tbWl0cygpDQogICAgICAgICBmaWxlcyA9IHNlbGYuc2Nt LmNoYW5nZWRfZmlsZXMoKQ0KICAgICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlMics IGZpbGVzKQ0KLS0gDQoyLjMuNyAoQXBwbGUgR2l0LTU3KQ0K 256243 2015-07-06 14:56:06 -0700 2015-07-09 10:52:19 -0700 Added back patch_directories file_143967.txt text/plain 9774 dean_johnson RnJvbSAzNWU3M2ZmZTQ5ODA0OTRmZTczOGVmZWFlYWM0NzVjNmYzODY5NDQxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQ0KRnJvbTogRGVhbiBKb2huc29uIDxkZWFuX2pvaG5zb25AYXBwbGUuY29t Pg0KRGF0ZTogTW9uLCA2IEp1bCAyMDE1IDE0OjUyOjAxIC0wNzAwDQpTdWJqZWN0OiBbUEFUQ0hd IEZpeGVkIHNjbSB1bml0IHRlc3RzLg0KDQotLS0NCiBUb29scy9DaGFuZ2VMb2cgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8IDIwICsrKysrKysrKysrKysNCiBUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5ICB8ICAyICstDQogLi4uL3dl YmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5ICAgfCAzNCArKysrKysr KysrKysrKystLS0tLS0tDQogMyBmaWxlcyBjaGFuZ2VkLCA0NCBpbnNlcnRpb25zKCspLCAxMiBk ZWxldGlvbnMoLSkNCg0KZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5n ZUxvZw0KaW5kZXggOGEzM2NhYzAuLjliZWQxZDMgMTAwNjQ0DQotLS0gYS9Ub29scy9DaGFuZ2VM b2cNCisrKyBiL1Rvb2xzL0NoYW5nZUxvZw0KQEAgLTEsMyArMSwyMyBAQA0KKzIwMTUtMDctMDYg IERlYW4gSm9obnNvbiAgPGRlYW5fam9obnNvbkBhcHBsZS5jb20+DQorDQorICAgICAgICBGaXhl ZCBzY20gdW5pdCB0ZXN0cy4NCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xNDM5NjcNCisNCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp Lg0KKw0KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0 LnB5Og0KKyAgICAgICAgKEdpdC5jaGFuZ2VkX2ZpbGVzKTogRml4ZWQgYGdpdGAgaW52b2NhdGlv biBzeW50YWN0aWNhbCBlcnJvcnMuICgnLXInIHJlcGxhY2VkIHdpdGggJy0tcmF3JyBhbmQgYWRk ZWQgJy0tJyB0byBlc2NhcGUgcGF0Y2hfZGlyZWN0b3JpZXMgYXMgYXJndW1lbnRzKQ0KKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5 OiBDaGFuZ2VkIHRlc3RzIGFuZCBzZXR1cCBpbiB0aGUgR2l0U1ZOVGVzdCBjbGFzcyB0byBnZXQg ZmFpbGluZyB0ZXN0cyBwYXNzaW5nLg0KKyAgICAgICAgKEdpdFNWTlRlc3QuX3NldHVwX2dpdF9j aGVja291dCk6IFByZXZpb3VzbHksIGdlbmVyYXRpbmcgdGVzdCBnaXQgY2hlY2tvdXRzIHJldHVy bmVkIGEgcmVmZXJlbmNlIGEgbmV3IGZpbGUgaW4gL3Zhci90bXAvLiBOb3csIGl0IHJldHVybnMg dGhlIHJlYWwgcGF0aCBvZiAvcHJpdmF0ZS92YXIvLiBCZWNhdXNlIC92YXIgaXMganVzdCBhIHN5 bWxpbmsgdG8gL3ByaXZhdGUvdmFyIGFuZCB3ZSB1c2UgdGhlIGFic29sdXRlIHBhdGggKC9wcml2 YXRlL3ZhcikgaW4gbWFueSBvZiBvdXIgdGVzdHMsIHdlIHdlcmUgZ2V0dGluZyBpbmNvbnNpc3Rl bnQgcmVsYXRpdmUgcGF0aHMgYmV0d2VlbiB0aGUgdHdvIGlkZW50aWNhbCBkaXJlY3RvcmllcyAo L3ByaXZhdGUvdmFyIGFuZCAvdmFyKSB0aGF0IGNhdXNlZCBnaXQtZGlmZiB0byBicmVhayBpbiB3 ZWJraXRweS5jb21tb24uY2hlY2tvdXQuc2NtLmdpdC5HaXQuY2hhbmdlZF9maWxlcy4gVGhlIGNo YW5nZSBub3cgdXNlcyB0aGUgcmVhbCBwYXRoIG9mIC92YXIgKC9wcml2YXRlL3ZhcikgYXMgdGhl IG5ldyBnaXRfY2hlY2tvdXRfcGF0aCB3aGljaCBhbGxvd3Mgb2YgY29ycmVjdCBjYWxjdWxhdGlv biBvZiByZWxhdGl2ZSBwYXRocyBhbmQgZml4ZXMgc29tZSB0ZXN0cy4NCisgICAgICAgIChHaXRT Vk5UZXN0LnRlc3RfY29tbWl0X3dpdGhfbWVzc2FnZV9ub3Rfc3luY2VkKTogQ2hhbmdlZCBgdHJ1 bmtgIHJlZmVyZW5jZSB0byBgbWFzdGVyYA0KKyAgICAgICAgKEdpdFNWTlRlc3QudGVzdF9jb21t aXRfd2l0aF9tZXNzYWdlX25vdF9zeW5jZWRfd2l0aF9jb25mbGljdCk6IENoYW5nZWQgYHRydW5r YCByZWZlcmVuY2UgdG8gYG1hc3RlcmANCisgICAgICAgIChHaXRTVk5UZXN0LnRlc3RfcmVtb3Rl X2JyYW5jaF9yZWYpOiBBZGRlZCAvb3JpZ2luIHRvIHRoZSBtaWRkbGUgb2YgdGhlIGV4cGVjdGVk IHJldHVybiBzdHJpbmcuDQorICAgICAgICAoR2l0U1ZOVGVzdC50ZXN0X2NyZWF0ZV9wYXRjaF9h ZnRlcl9tZXJnZSk6IENoYW5nZWQgYHRydW5rYCByZWZlcmVuY2UgdG8gYG1hc3RlcmANCisgICAg ICAgIChHaXRTVk5UZXN0LnRlc3RfY3JlYXRlX3BhdGNoX25vdF9zeW5jZWQpOiBDaGFuZ2VkIGB0 cnVua2AgcmVmZXJlbmNlIHRvIGBtYXN0ZXJgDQorICAgICAgICAoR2l0U1ZOVGVzdC50ZXN0X2No YW5nZWRfZmlsZXNfbG9jYWxfcGx1c193b3JraW5nX2NvcHkpOiBDaGFuZ2VkIGB0cnVua2AgdG8g bWFzdGVyIGFuZCBjaGFuZ2VkIGhvdyBnaXQgd2FzIHJlZmVyZW5jZWQgc28gdGhlIGV4cGVjdGVk IHZhbHVlIG1hdGNoIHRoZSByZXR1cm4uIFByZXZpb3VzbHkgdGhlIHRlc3Qgd291bGQgZmFpbCBk dWUgdG8gYW4gZXJyb3Igb2Ygd2hpY2ggY29tbWl0cyBuZWVkZWQgdG8gYmUgY29tcGFyZWQgYW5k IHdoYXQgd2FzIGV4cGVjdGVkLg0KKyAgICAgICAgKEdpdFNWTlRlc3QudGVzdF9jaGFuZ2VkX2Zp bGVzX2dpdF9jb21taXQpOiBBZGRlZCB0ZXN0IGNhc2UgdGhhdCBtaW1pY2tlZCBmdW5jdGlvbiBk ZWZpbml0aW9uIG1vcmUgcHJlY2lzZWx5IGFuZCBmaXhlZCB0aGUgZ2l0IGNvbW1pdCB0aGUgcHJl dmlvdXMgdGVzdCB3YXMgYXR0ZW1wdGluZyB0byByZWZlcmVuY2UuDQorICAgICAgICAoR2l0U1ZO VGVzdC50ZXN0X2NoYW5nZWRfZmlsZXNfbm90X3N5bmNlZCk6IENoYW5nZWQgYHRydW5rYCByZWZl cmVuY2UgdG8gYG1hc3RlcmANCisNCiAyMDE1LTA2LTI5ICBKYWtlIE5pZWxzZW4gIDxqYWNvYl9u aWVsc2VuQGFwcGxlLmNvbT4NCiANCiAgICAgICAgIEFkZCB0aW1lb3V0IGluIHJ1bi13ZWJraXQt dGVzdHMgZm9yIGxhdW5jaGluZyB0aGUgc2ltdWxhdG9yDQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weSBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9naXQucHkNCmluZGV4IGFhZDZlYWQuLjJiZTY4 M2QgMTAwNjQ0DQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9z Y20vZ2l0LnB5DQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9z Y20vZ2l0LnB5DQpAQCAtMjE2LDcgKzIxNiw3IEBAIGNsYXNzIEdpdChTQ00sIFNWTlJlcG9zaXRv cnkpOg0KIA0KICAgICBkZWYgY2hhbmdlZF9maWxlcyhzZWxmLCBnaXRfY29tbWl0PU5vbmUpOg0K ICAgICAgICAgIyBGSVhNRTogLS1kaWZmLWZpbHRlciBjb3VsZCBiZSB1c2VkIHRvIGF2b2lkIHRo ZSAiZXh0cmFjdF9maWxlbmFtZXMiIHN0ZXAuDQotICAgICAgICBzdGF0dXNfY29tbWFuZCA9IFtz ZWxmLmV4ZWN1dGFibGVfbmFtZSwgJ2RpZmYnLCAnLXInLCAnLS1uYW1lLXN0YXR1cycsICItLW5v LXJlbmFtZXMiLCAiLS1uby1leHQtZGlmZiIsICItLWZ1bGwtaW5kZXgiLCBzZWxmLm1lcmdlX2Jh c2UoZ2l0X2NvbW1pdCldDQorICAgICAgICBzdGF0dXNfY29tbWFuZCA9IFtzZWxmLmV4ZWN1dGFi bGVfbmFtZSwgJ2RpZmYnLCAnLS1yYXcnLCAnLS1uYW1lLXN0YXR1cycsICItLW5vLXJlbmFtZXMi LCAiLS1uby1leHQtZGlmZiIsICItLWZ1bGwtaW5kZXgiLCBzZWxmLm1lcmdlX2Jhc2UoZ2l0X2Nv bW1pdCksICctLSddDQogICAgICAgICBzdGF0dXNfY29tbWFuZC5leHRlbmQoc2VsZi5fcGF0Y2hf ZGlyZWN0b3JpZXMpDQogICAgICAgICAjIEZJWE1FOiBJJ20gbm90IHN1cmUgd2UncmUgcmV0dXJu aW5nIHRoZSBzYW1lIHNldCBvZiBmaWxlcyB0aGF0IFNWTi5jaGFuZ2VkX2ZpbGVzIGlzLg0KICAg ICAgICAgIyBBZGRlZCAoQSksIENvcGllZCAoQyksIERlbGV0ZWQgKEQpLCBNb2RpZmllZCAoTSks IFJlbmFtZWQgKFIpDQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24v Y2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29t bW9uL2NoZWNrb3V0L3NjbS9zY21fdW5pdHRlc3QucHkNCmluZGV4IGQ3NzJkNzkuLjk2ODQ1Mzkg MTAwNjQ0DQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20v c2NtX3VuaXR0ZXN0LnB5DQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVj a291dC9zY20vc2NtX3VuaXR0ZXN0LnB5DQpAQCAtMTAzMyw3ICsxMDMzLDExIEBAIGNsYXNzIEdp dFRlc3QoU0NNVGVzdCk6DQogY2xhc3MgR2l0U1ZOVGVzdChTQ01UZXN0KToNCiANCiAgICAgZGVm IF9zZXR1cF9naXRfY2hlY2tvdXQoc2VsZik6DQotICAgICAgICBzZWxmLmdpdF9jaGVja291dF9w YXRoID0gdGVtcGZpbGUubWtkdGVtcChzdWZmaXg9ImdpdF90ZXN0X2NoZWNrb3V0IikNCisgICAg ICAgICMgdGVtcGZpbGUgcmV0dXJucyBhIHBhdGggaW4gL3Zhci90bXAgaW5zdGVhZCBvZiAvcHJp dmF0ZS92YXIvdG1wLA0KKyAgICAgICAgIyB3aGljaCBpcyB3aHkgd2UgdXNlIG9zLnBhdGgucmVh bHBhdGgoKS4gSWYgdGhpcyBwYXRoIGlzIG5vdCBhYnNvbHV0ZWx5DQorICAgICAgICAjIGNvcnJl Y3QsIHJlbGF0aXZlIHBhdGggaXNzdWVzIHNob3cgdXAgd2hlbiBydW5uaW5nIHRlc3RzIG9uIHRo ZQ0KKyAgICAgICAgIyBuZXdseSBjcmVhdGVkIGdpdCByZXBvc2l0b3JpZXMuDQorICAgICAgICBz ZWxmLmdpdF9jaGVja291dF9wYXRoID0gb3MucGF0aC5yZWFscGF0aCh0ZW1wZmlsZS5ta2R0ZW1w KHN1ZmZpeD0iZ2l0X3Rlc3RfY2hlY2tvdXQiKSkNCiAgICAgICAgICMgLS1xdWlldCBkb2Vzbid0 IG1ha2UgZ2l0IHN2biBzaWxlbnQsIHNvIHdlIHVzZSBydW5fc2lsZW50IHRvIHJlZGlyZWN0IG91 dHB1dA0KICAgICAgICAgcnVuX3NpbGVudChbJ2dpdCcsICdzdm4nLCAnY2xvbmUnLCAnLVQnLCAn dHJ1bmsnLCBzZWxmLnN2bl9yZXBvX3VybCwgc2VsZi5naXRfY2hlY2tvdXRfcGF0aF0pDQogICAg ICAgICBvcy5jaGRpcihzZWxmLmdpdF9jaGVja291dF9wYXRoKQ0KQEAgLTEyNzAsNyArMTI3NCw3 IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFzc2VydFJlZ2V4 cE1hdGNoZXMoc3ZuX2xvZywgcid0ZXN0X2ZpbGVfY29tbWl0MScpDQogDQogICAgIGRlZiB0ZXN0 X2NvbW1pdF93aXRoX21lc3NhZ2Vfbm90X3N5bmNlZChzZWxmKToNCi0gICAgICAgIHJ1bl9jb21t YW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywgJ215LWJyYW5jaCcsICd0cnVua34zJ10pDQor ICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdteS1icmFuY2gn LCAnbWFzdGVyfjMnXSkNCiAgICAgICAgIHNlbGYuX3R3b19sb2NhbF9jb21taXRzKCkNCiAgICAg ICAgIHNlbGYuYXNzZXJ0UmFpc2VzKEFtYmlndW91c0NvbW1pdEVycm9yLCBzZWxmLnNjbS5jb21t aXRfd2l0aF9tZXNzYWdlLCAiYW5vdGhlciB0ZXN0IGNvbW1pdCIpDQogICAgICAgICBjb21taXRf dGV4dCA9IHNlbGYuc2NtLmNvbW1pdF93aXRoX21lc3NhZ2UoImFub3RoZXIgdGVzdCBjb21taXQi LCBmb3JjZV9zcXVhc2g9VHJ1ZSkNCkBAIC0xMjgzLDcgKzEyODcsNyBAQCBjbGFzcyBHaXRTVk5U ZXN0KFNDTVRlc3QpOg0KICAgICAgICAgc2VsZi5hc3NlcnRSZWdleHBNYXRjaGVzKHN2bl9sb2cs IHIndGVzdF9maWxlX2NvbW1pdDEnKQ0KIA0KICAgICBkZWYgdGVzdF9jb21taXRfd2l0aF9tZXNz YWdlX25vdF9zeW5jZWRfd2l0aF9jb25mbGljdChzZWxmKToNCi0gICAgICAgIHJ1bl9jb21tYW5k KFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywgJ215LWJyYW5jaCcsICd0cnVua34zJ10pDQorICAg ICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdteS1icmFuY2gnLCAn bWFzdGVyfjMnXSkNCiAgICAgICAgIHNlbGYuX2xvY2FsX2NvbW1pdCgndGVzdF9maWxlMicsICdh c2RmJywgJ2FzZGYgY29tbWl0JykNCiANCiAgICAgICAgICMgVGhlcmUncyBhIGNvbmZsaWN0IGJl dHdlZW4gdHJ1bmsgYW5kIHRoZSB0ZXN0X2ZpbGUyIG1vZGlmaWNhdGlvbi4NCkBAIC0xMjk1LDcg KzEyOTksNyBAQCBjbGFzcyBHaXRTVk5UZXN0KFNDTVRlc3QpOg0KICAgICAgICAgc2VsZi5hc3Nl cnRFcXVhbChzZWxmLnNjbS5fdXBzdHJlYW1fYnJhbmNoKCksICdteS1icmFuY2gnKQ0KIA0KICAg ICBkZWYgdGVzdF9yZW1vdGVfYnJhbmNoX3JlZihzZWxmKToNCi0gICAgICAgIHNlbGYuYXNzZXJ0 RXF1YWwoc2VsZi5zY20ucmVtb3RlX2JyYW5jaF9yZWYoKSwgJ3JlZnMvcmVtb3Rlcy90cnVuaycp DQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHNlbGYuc2NtLnJlbW90ZV9icmFuY2hfcmVmKCks ICdyZWZzL3JlbW90ZXMvb3JpZ2luL3RydW5rJykNCiANCiAgICAgZGVmIHRlc3RfcmV2ZXJzZV9k aWZmKHNlbGYpOg0KICAgICAgICAgc2VsZi5fc2hhcmVkX3Rlc3RfcmV2ZXJzZV9kaWZmKCkNCkBA IC0xMzIwLDkgKzEzMjQsOSBAQCBjbGFzcyBHaXRTVk5UZXN0KFNDTVRlc3QpOg0KICAgICAgICAg c2VsZi5hc3NlcnRSZWdleHBNYXRjaGVzKHBhdGNoLCByJ1N1YnZlcnNpb24gUmV2aXNpb246IDUn KQ0KIA0KICAgICBkZWYgdGVzdF9jcmVhdGVfcGF0Y2hfYWZ0ZXJfbWVyZ2Uoc2VsZik6DQotICAg ICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdkdW1teS1icmFuY2gn LCAndHJ1bmt+MyddKQ0KKyAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAnY2hlY2tvdXQnLCAn LWInLCAnbXktYnJhbmNoJywgJ21hc3Rlcn4zJ10pDQogICAgICAgICBzZWxmLl9vbmVfbG9jYWxf Y29tbWl0KCkNCi0gICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ21lcmdlJywgJ3RydW5rJ10p DQorICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdtZXJnZScsICdtYXN0ZXInXSkNCiANCiAg ICAgICAgIHBhdGNoID0gc2VsZi5zY20uY3JlYXRlX3BhdGNoKCkNCiAgICAgICAgIHNlbGYuYXNz ZXJ0UmVnZXhwTWF0Y2hlcyhwYXRjaCwgcid0ZXN0X2ZpbGVfY29tbWl0MScpDQpAQCAtMTM2Niw3 ICsxMzcwLDcgQEAgY2xhc3MgR2l0U1ZOVGVzdChTQ01UZXN0KToNCiAgICAgICAgIHNlbGYuYXNz ZXJ0UmVnZXhwTWF0Y2hlcyhwYXRjaCwgcid0ZXN0X2ZpbGVfY29tbWl0MScpDQogDQogICAgIGRl ZiB0ZXN0X2NyZWF0ZV9wYXRjaF9ub3Rfc3luY2VkKHNlbGYpOg0KLSAgICAgICAgcnVuX2NvbW1h bmQoWydnaXQnLCAnY2hlY2tvdXQnLCAnLWInLCAnbXktYnJhbmNoJywgJ3RydW5rfjMnXSkNCisg ICAgICAgIHJ1bl9jb21tYW5kKFsnZ2l0JywgJ2NoZWNrb3V0JywgJy1iJywgJ215LWJyYW5jaCcs ICdtYXN0ZXJ+MyddKQ0KICAgICAgICAgc2VsZi5fdHdvX2xvY2FsX2NvbW1pdHMoKQ0KICAgICAg ICAgcGF0Y2ggPSBzZWxmLnNjbS5jcmVhdGVfcGF0Y2goKQ0KICAgICAgICAgc2VsZi5hc3NlcnRO b3RSZWdleHBNYXRjaGVzKHBhdGNoLCByJ3Rlc3RfZmlsZTInKQ0KQEAgLTE0MDYsMTIgKzE0MTAs MTQgQEAgY2xhc3MgR2l0U1ZOVGVzdChTQ01UZXN0KToNCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4o J3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpDQogDQogICAgICAgICAjIHdvcmtpbmcgY29weSBz aG91bGQgKm5vdCogYmUgaW4gdGhlIGxpc3QuDQotICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNo YW5nZWRfZmlsZXMoJ3RydW5rLi4nKQ0KKyAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2Vk X2ZpbGVzKCdtYXN0ZXInKQ0KICAgICAgICAgc2VsZi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1p dDEnLCBmaWxlcykNCiAgICAgICAgIHNlbGYuYXNzZXJ0Tm90SW4oJ3Rlc3RfZmlsZV9jb21taXQy JywgZmlsZXMpDQogDQogICAgICAgICAjIHdvcmtpbmcgY29weSAqc2hvdWxkKiBiZSBpbiB0aGUg bGlzdC4NCi0gICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygndHJ1bmsuLi4u JykNCisgICAgICAgICMgLi4uLiBpcyBhIGhhY2sgYXJvdW5kIF4uLjxjb21taXQ+IGJlaW5nIGFw cGVuZGVkDQorICAgICAgICAjIHRvIGVhY2ggZ2l0IGRpZmYgY29tbWFuZC4NCisgICAgICAgIGZp bGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygnbWFzdGVyXi4uLi4nKQ0KICAgICAgICAgc2Vs Zi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDEnLCBmaWxlcykNCiAgICAgICAgIHNlbGYuYXNz ZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpDQogDQpAQCAtMTQyMSw2ICsxNDI3LDEy IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFzc2VydEluKCd0 ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0KICAgICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVz dF9maWxlX2NvbW1pdDInLCBmaWxlcykNCiANCisgICAgICAgICMgLi4uLiBpcyBhIGhhY2sgYXJv dW5kIF4uLjxjb21taXQ+IGJlaW5nIGFwcGVuZGVkDQorICAgICAgICAjIHRvIGVhY2ggZ2l0IGRp ZmYgY29tbWFuZC4NCisgICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcyhnaXRf Y29tbWl0PSJIRUFEXl4uLi4uIikNCisgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9j b21taXQyJywgZmlsZXMpDQorICAgICAgICBzZWxmLmFzc2VydEluKCd0ZXN0X2ZpbGVfY29tbWl0 MScsIGZpbGVzKQ0KKw0KICAgICBkZWYgdGVzdF9jaGFuZ2VkX2ZpbGVzX2dpdF9jb21taXRfcmFu Z2Uoc2VsZik6DQogICAgICAgICBzZWxmLl90aHJlZV9sb2NhbF9jb21taXRzKCkNCiAgICAgICAg IGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcyhnaXRfY29tbWl0PSJIRUFEfjIuLkhFQUQi KQ0KQEAgLTE0NDEsNyArMTQ1Myw3IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAg ICAgICBzZWxmLmFzc2VydEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0KIA0KICAgICBk ZWYgdGVzdF9jaGFuZ2VkX2ZpbGVzX25vdF9zeW5jZWQoc2VsZik6DQotICAgICAgICBydW5fY29t bWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYicsICdteS1icmFuY2gnLCAndHJ1bmt+MyddKQ0K KyAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAnY2hlY2tvdXQnLCAnLWInLCAnbXktYnJhbmNo JywgJ21hc3Rlcn4zJ10pDQogICAgICAgICBzZWxmLl90d29fbG9jYWxfY29tbWl0cygpDQogICAg ICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoKQ0KICAgICAgICAgc2VsZi5hc3Nl cnROb3RJbigndGVzdF9maWxlMicsIGZpbGVzKQ0KQEAgLTE0NDksNyArMTQ2MSw3IEBAIGNsYXNz IEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFzc2VydEluKCd0ZXN0X2ZpbGVf Y29tbWl0MScsIGZpbGVzKQ0KIA0KICAgICBkZWYgdGVzdF9jaGFuZ2VkX2ZpbGVzX25vdF9zeW5j ZWQoc2VsZik6DQotICAgICAgICBydW5fY29tbWFuZChbJ2dpdCcsICdjaGVja291dCcsICctYics ICdteS1icmFuY2gnLCAndHJ1bmt+MyddKQ0KKyAgICAgICAgcnVuX2NvbW1hbmQoWydnaXQnLCAn Y2hlY2tvdXQnLCAnLWInLCAnbXktYnJhbmNoJywgJ21hc3Rlcn4zJ10pDQogICAgICAgICBzZWxm Ll90d29fbG9jYWxfY29tbWl0cygpDQogICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRf ZmlsZXMoKQ0KICAgICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlMicsIGZpbGVzKQ0K LS0gDQoyLjMuNyAoQXBwbGUgR2l0LTU3KQ0K 256491 2015-07-09 10:52:19 -0700 2015-07-09 14:14:23 -0700 Added fixes for issues from comments and changed one incorrect test case. file_143967.txt text/plain 7122 dean_johnson RnJvbSAwNTVmOTk5MmNmNjAyMjAxMWUxZmVhM2Q3MTI1OGExMTVhNWVlYzU1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQ0KRnJvbTogRGVhbiBKb2huc29uIDxkZWFuX2pvaG5zb25AYXBwbGUuY29t Pg0KRGF0ZTogVGh1LCA5IEp1bCAyMDE1IDEwOjQ3OjI4IC0wNzAwDQpTdWJqZWN0OiBbUEFUQ0hd IEZpeGVkIHNjbSB1bml0IHRlc3RzLg0KDQotLS0NCiBUb29scy9DaGFuZ2VMb2cgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8IDI5ICsrKysrKysrKysrKysrKysrKysrKysNCiAu Li4vd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9kZXRlY3Rpb24ucHkgICAgICB8IDEwICsr KystLS0tDQogVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5w eSAgfCAgMiArLQ0KIC4uLi93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVz dC5weSAgIHwgMTYgKysrKysrKysrLS0tDQogNCBmaWxlcyBjaGFuZ2VkLCA0OCBpbnNlcnRpb25z KCspLCA5IGRlbGV0aW9ucygtKQ0KDQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9v bHMvQ2hhbmdlTG9nDQppbmRleCA4YTMzY2FjMC4uMWM5ZjU0MiAxMDA2NDQNCi0tLSBhL1Rvb2xz L0NoYW5nZUxvZw0KKysrIGIvVG9vbHMvQ2hhbmdlTG9nDQpAQCAtMSwzICsxLDMyIEBADQorMjAx NS0wNy0wOSAgRGVhbiBKb2huc29uICA8ZGVhbl9qb2huc29uQGFwcGxlLmNvbT4NCisNCisgICAg ICAgIE5lZWQgYSBzaG9ydCBkZXNjcmlwdGlvbiAoT09QUyEpLg0KKyAgICAgICAgTmVlZCB0aGUg YnVnIFVSTCAoT09QUyEpLg0KKw0KKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku DQorDQorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9kZXRl Y3Rpb24ucHk6DQorICAgICAgICAoU0NNRGV0ZWN0b3IuZGV0ZWN0X3NjbV9zeXN0ZW0pOg0KKyAg ICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5Og0KKyAg ICAgICAgKEdpdC5jaGFuZ2VkX2ZpbGVzKToNCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9j b21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5weToNCisgICAgICAgIChHaXRTVk5UZXN0 LnRlc3RfY2hhbmdlZF9maWxlc19sb2NhbF9wbHVzX3dvcmtpbmdfY29weSk6DQorDQorMjAxNS0w Ny0wNyAgRGVhbiBKb2huc29uICA8ZGVhbl9qb2huc29uQGFwcGxlLmNvbT4NCisNCisgICAgICAg IEZpeGVkIHNjbSB1bml0IHRlc3RzLg0KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE0Mzk2Nw0KKw0KKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuDQorDQorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3Nj bS9kZXRlY3Rpb24ucHk6DQorICAgICAgICAoU0NNRGV0ZWN0b3IuZGV0ZWN0X3NjbV9zeXN0ZW0p OiBOb3cgdXNlIHJlYWxwYXRocyBzbyBhbGwgcGF0aHMgYXJlIGNvbnNpc3RlbnQgd2hlbiBiZWlu ZyBjb21wYXJlZC4NCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQv c2NtL2dpdC5weToNCisgICAgICAgIChHaXQuY2hhbmdlZF9maWxlcyk6IEZpeGVkIGBnaXRgIGlu dm9jYXRpb24gc3ludGFjdGljYWwgZXJyb3JzLiAoJy1yJyByZXBsYWNlZCB3aXRoICctLXJhdycg YW5kIGFkZGVkICctLScgdG8gZXNjYXBlIHBhdGNoX2RpcmVjdG9yaWVzIGFzIGFyZ3VtZW50cykN CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0 dGVzdC5weTogQ2hhbmdlZCB0ZXN0cyBhbmQgc2V0dXAgaW4gdGhlIEdpdFNWTlRlc3QgY2xhc3Mg dG8gbXJvZSBjbG9zZWx5IGVtdWxhdGUgb2xkIGdpdC4uDQorICAgICAgICAoR2l0U1ZOVGVzdC5f c2V0dXBfZ2l0X2NoZWNrb3V0KTogQWRkZWQgLS1wcmVmaXggb3B0aW9uIHRvIGBnaXQgY2xvbmVg IGFuZCByZW5hbWVkIGBtYXN0ZXJgIGJyYW5jaCB0byBgdHJ1bmtgLg0KKyAgICAgICAgKEdpdFNW TlRlc3QudGVzdF9jaGFuZ2VkX2ZpbGVzX2xvY2FsX3BsdXNfd29ya2luZ19jb3B5KTogQ2hhbmdl ZCBgdHJ1bmtgIHRvIG1hc3RlciBhbmQgY2hhbmdlZCBob3cgZ2l0IHdhcyByZWZlcmVuY2VkIHNv IHRoZSBleHBlY3RlZCB2YWx1ZSBtYXRjaCB0aGUgcmV0dXJuLiBQcmV2aW91c2x5IHRoZSB0ZXN0 IHdvdWxkIGZhaWwgZHVlIHRvIGFuIGVycm9yIG9mIHdoaWNoIGNvbW1pdHMgbmVlZGVkIHRvIGJl IGNvbXBhcmVkIGFuZCB3aGF0IHdhcyBleHBlY3RlZC4NCisNCiAyMDE1LTA2LTI5ICBKYWtlIE5p ZWxzZW4gIDxqYWNvYl9uaWVsc2VuQGFwcGxlLmNvbT4NCiANCiAgICAgICAgIEFkZCB0aW1lb3V0 IGluIHJ1bi13ZWJraXQtdGVzdHMgZm9yIGxhdW5jaGluZyB0aGUgc2ltdWxhdG9yDQpkaWZmIC0t Z2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2RldGVjdGlv bi5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9kZXRlY3Rp b24ucHkNCmluZGV4IDg3YTdhMGQuLjhjNTkwMDUgMTAwNjQ0DQotLS0gYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5DQorKysgYi9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5DQpAQCAtNjMs MTYgKzYzLDE2IEBAIGNsYXNzIFNDTURldGVjdG9yKG9iamVjdCk6DQogICAgICAgICByZXR1cm4g c2NtX3N5c3RlbQ0KIA0KICAgICBkZWYgZGV0ZWN0X3NjbV9zeXN0ZW0oc2VsZiwgcGF0aCwgcGF0 Y2hfZGlyZWN0b3JpZXM9Tm9uZSk6DQotICAgICAgICBhYnNvbHV0ZV9wYXRoID0gc2VsZi5fZmls ZXN5c3RlbS5hYnNwYXRoKHBhdGgpDQorICAgICAgICByZWFsX3BhdGggPSBzZWxmLl9maWxlc3lz dGVtLnJlYWxwYXRoKHBhdGgpDQogDQogICAgICAgICBpZiBwYXRjaF9kaXJlY3RvcmllcyA9PSBb XToNCiAgICAgICAgICAgICBwYXRjaF9kaXJlY3RvcmllcyA9IE5vbmUNCiANCi0gICAgICAgIGlm IFNWTi5pbl93b3JraW5nX2RpcmVjdG9yeShhYnNvbHV0ZV9wYXRoLCBleGVjdXRpdmU9c2VsZi5f ZXhlY3V0aXZlKToNCi0gICAgICAgICAgICByZXR1cm4gU1ZOKGN3ZD1hYnNvbHV0ZV9wYXRoLCBw YXRjaF9kaXJlY3Rvcmllcz1wYXRjaF9kaXJlY3RvcmllcywgZmlsZXN5c3RlbT1zZWxmLl9maWxl c3lzdGVtLCBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKQ0KKyAgICAgICAgaWYgU1ZOLmluX3dv cmtpbmdfZGlyZWN0b3J5KHJlYWxfcGF0aCwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSk6DQor ICAgICAgICAgICAgcmV0dXJuIFNWTihjd2Q9cmVhbF9wYXRoLCBwYXRjaF9kaXJlY3Rvcmllcz1w YXRjaF9kaXJlY3RvcmllcywgZmlsZXN5c3RlbT1zZWxmLl9maWxlc3lzdGVtLCBleGVjdXRpdmU9 c2VsZi5fZXhlY3V0aXZlKQ0KIA0KLSAgICAgICAgaWYgR2l0LmluX3dvcmtpbmdfZGlyZWN0b3J5 KGFic29sdXRlX3BhdGgsIGV4ZWN1dGl2ZT1zZWxmLl9leGVjdXRpdmUpOg0KLSAgICAgICAgICAg IHJldHVybiBHaXQoY3dkPWFic29sdXRlX3BhdGgsIHBhdGNoX2RpcmVjdG9yaWVzPXBhdGNoX2Rp cmVjdG9yaWVzLCBmaWxlc3lzdGVtPXNlbGYuX2ZpbGVzeXN0ZW0sIGV4ZWN1dGl2ZT1zZWxmLl9l eGVjdXRpdmUpDQorICAgICAgICBpZiBHaXQuaW5fd29ya2luZ19kaXJlY3RvcnkocmVhbF9wYXRo LCBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKToNCisgICAgICAgICAgICByZXR1cm4gR2l0KGN3 ZD1yZWFsX3BhdGgsIHBhdGNoX2RpcmVjdG9yaWVzPXBhdGNoX2RpcmVjdG9yaWVzLCBmaWxlc3lz dGVtPXNlbGYuX2ZpbGVzeXN0ZW0sIGV4ZWN1dGl2ZT1zZWxmLl9leGVjdXRpdmUpDQogDQogICAg ICAgICByZXR1cm4gTm9uZQ0KIA0KZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv Y29tbW9uL2NoZWNrb3V0L3NjbS9naXQucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9jaGVja291dC9zY20vZ2l0LnB5DQppbmRleCBhYWQ2ZWFkLi4yYmU2ODNkIDEwMDY0NA0KLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weQ0KKysr IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weQ0KQEAg LTIxNiw3ICsyMTYsNyBAQCBjbGFzcyBHaXQoU0NNLCBTVk5SZXBvc2l0b3J5KToNCiANCiAgICAg ZGVmIGNoYW5nZWRfZmlsZXMoc2VsZiwgZ2l0X2NvbW1pdD1Ob25lKToNCiAgICAgICAgICMgRklY TUU6IC0tZGlmZi1maWx0ZXIgY291bGQgYmUgdXNlZCB0byBhdm9pZCB0aGUgImV4dHJhY3RfZmls ZW5hbWVzIiBzdGVwLg0KLSAgICAgICAgc3RhdHVzX2NvbW1hbmQgPSBbc2VsZi5leGVjdXRhYmxl X25hbWUsICdkaWZmJywgJy1yJywgJy0tbmFtZS1zdGF0dXMnLCAiLS1uby1yZW5hbWVzIiwgIi0t bm8tZXh0LWRpZmYiLCAiLS1mdWxsLWluZGV4Iiwgc2VsZi5tZXJnZV9iYXNlKGdpdF9jb21taXQp XQ0KKyAgICAgICAgc3RhdHVzX2NvbW1hbmQgPSBbc2VsZi5leGVjdXRhYmxlX25hbWUsICdkaWZm JywgJy0tcmF3JywgJy0tbmFtZS1zdGF0dXMnLCAiLS1uby1yZW5hbWVzIiwgIi0tbm8tZXh0LWRp ZmYiLCAiLS1mdWxsLWluZGV4Iiwgc2VsZi5tZXJnZV9iYXNlKGdpdF9jb21taXQpLCAnLS0nXQ0K ICAgICAgICAgc3RhdHVzX2NvbW1hbmQuZXh0ZW5kKHNlbGYuX3BhdGNoX2RpcmVjdG9yaWVzKQ0K ICAgICAgICAgIyBGSVhNRTogSSdtIG5vdCBzdXJlIHdlJ3JlIHJldHVybmluZyB0aGUgc2FtZSBz ZXQgb2YgZmlsZXMgdGhhdCBTVk4uY2hhbmdlZF9maWxlcyBpcy4NCiAgICAgICAgICMgQWRkZWQg KEEpLCBDb3BpZWQgKEMpLCBEZWxldGVkIChEKSwgTW9kaWZpZWQgKE0pLCBSZW5hbWVkIChSKQ0K ZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9z Y21fdW5pdHRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9z Y20vc2NtX3VuaXR0ZXN0LnB5DQppbmRleCBkNzcyZDc5Li40ODRjMzVjIDEwMDY0NA0KLS0tIGEv VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5w eQ0KKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91 bml0dGVzdC5weQ0KQEAgLTEwMzUsOCArMTAzNSw5IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVz dCk6DQogICAgIGRlZiBfc2V0dXBfZ2l0X2NoZWNrb3V0KHNlbGYpOg0KICAgICAgICAgc2VsZi5n aXRfY2hlY2tvdXRfcGF0aCA9IHRlbXBmaWxlLm1rZHRlbXAoc3VmZml4PSJnaXRfdGVzdF9jaGVj a291dCIpDQogICAgICAgICAjIC0tcXVpZXQgZG9lc24ndCBtYWtlIGdpdCBzdm4gc2lsZW50LCBz byB3ZSB1c2UgcnVuX3NpbGVudCB0byByZWRpcmVjdCBvdXRwdXQNCi0gICAgICAgIHJ1bl9zaWxl bnQoWydnaXQnLCAnc3ZuJywgJ2Nsb25lJywgJy1UJywgJ3RydW5rJywgc2VsZi5zdm5fcmVwb191 cmwsIHNlbGYuZ2l0X2NoZWNrb3V0X3BhdGhdKQ0KKyAgICAgICAgcnVuX3NpbGVudChbJ2dpdCcs ICdzdm4nLCAnY2xvbmUnLCAnLVQnLCAndHJ1bmsnLCAnLS1wcmVmaXgnLCAnJywgc2VsZi5zdm5f cmVwb191cmwsIHNlbGYuZ2l0X2NoZWNrb3V0X3BhdGhdKQ0KICAgICAgICAgb3MuY2hkaXIoc2Vs Zi5naXRfY2hlY2tvdXRfcGF0aCkNCisgICAgICAgIHJ1bl9zaWxlbnQoWydnaXQnLCAnYnJhbmNo JywgJy1tJywgJ3RydW5rJ10pDQogDQogICAgIGRlZiBfdGVhcl9kb3duX2dpdF9jaGVja291dChz ZWxmKToNCiAgICAgICAgICMgQ2hhbmdlIGJhY2sgdG8gYSB2YWxpZCBkaXJlY3Rvcnkgc28gdGhh dCBsYXRlciBjYWxscyB0byBvcy5nZXRjd2QoKSBkbyBub3QgZmFpbC4NCkBAIC0xNDA2LDEyICsx NDA3LDIxIEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6DQogICAgICAgICBzZWxmLmFzc2Vy dEluKCd0ZXN0X2ZpbGVfY29tbWl0MicsIGZpbGVzKQ0KIA0KICAgICAgICAgIyB3b3JraW5nIGNv cHkgc2hvdWxkICpub3QqIGJlIGluIHRoZSBsaXN0Lg0KLSAgICAgICAgZmlsZXMgPSBzZWxmLnNj bS5jaGFuZ2VkX2ZpbGVzKCd0cnVuay4uJykNCisgICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hh bmdlZF9maWxlcygndHJ1bmsuLicpICAjIGdpdCBkaWZmIHRydW5rLi5IRUFEDQorICAgICAgICBz ZWxmLmFzc2VydE5vdEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0KKyAgICAgICAgc2Vs Zi5hc3NlcnROb3RJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykNCisNCisgICAgICAgIGZp bGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygndHJ1bmteLi4nKSAgIyBnaXQgZGlmZiB0cnVu a14uLkhFQUQNCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQxJywgZmls ZXMpDQogICAgICAgICBzZWxmLmFzc2VydE5vdEluKCd0ZXN0X2ZpbGVfY29tbWl0MicsIGZpbGVz KQ0KIA0KICAgICAgICAgIyB3b3JraW5nIGNvcHkgKnNob3VsZCogYmUgaW4gdGhlIGxpc3QuDQot ICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoJ3RydW5rLi4uLicpDQorICAg ICAgICAjIC4uLi4gaXMgYSBoYWNrIGZvciB3b3JraW5nIGNvcHkgY2hhbmdlcyB0byBiZSBpbmNs dWRlZA0KKyAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVuay4uLi4n KSAgIyBnaXQgZGlmZiB0cnVuaw0KKyAgICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxl X2NvbW1pdDEnLCBmaWxlcykNCisgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21t aXQyJywgZmlsZXMpDQorDQorICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMo J3RydW5rXi4uLi4nKSAgIyBnaXQgZGlmZiB0cnVua14NCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4o J3Rlc3RfZmlsZV9jb21taXQxJywgZmlsZXMpDQogICAgICAgICBzZWxmLmFzc2VydEluKCd0ZXN0 X2ZpbGVfY29tbWl0MicsIGZpbGVzKQ0KIA0KLS0gDQoyLjMuNyAoQXBwbGUgR2l0LTU3KQ0K 256518 2015-07-09 14:14:23 -0700 2015-07-13 16:10:30 -0700 Fixed changelog from previous patch. file_143967.txt text/plain 6637 dean_johnson RnJvbSA1ODhiYWJmNTk5ODZkNTFhYTBiMGM0ZWEyM2YxN2MxMzcyNWI2ZmY1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQ0KRnJvbTogRGVhbiBKb2huc29uIDxkZWFuX2pvaG5zb25AYXBwbGUuY29t Pg0KRGF0ZTogVGh1LCA5IEp1bCAyMDE1IDE0OjA5OjE3IC0wNzAwDQpTdWJqZWN0OiBbUEFUQ0hd IEZpeGVzIHNjbSB1bml0IHRlc3RzLg0KDQotLS0NCiBUb29scy9DaGFuZ2VMb2cgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IDE1ICsrKysrKysrKysrKysrKw0KIFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9kZXRlY3Rpb24ucHkgIHwg MTAgKysrKystLS0tLQ0KIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3Nj bS9naXQucHkgICAgICAgIHwgIDIgKy0NCiAuLi4vU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hl Y2tvdXQvc2NtL3NjbV91bml0dGVzdC5weSB8IDE2ICsrKysrKysrKysrKystLS0NCiA0IGZpbGVz IGNoYW5nZWQsIDM0IGluc2VydGlvbnMoKyksIDkgZGVsZXRpb25zKC0pDQoNCmRpZmYgLS1naXQg YS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cNCmluZGV4IDhhMzNjYWMwLi4yMzY4 NjI3IDEwMDY0NA0KLS0tIGEvVG9vbHMvQ2hhbmdlTG9nDQorKysgYi9Ub29scy9DaGFuZ2VMb2cN CkBAIC0xLDMgKzEsMTggQEANCisyMDE1LTA3LTA5ICBEZWFuIEpvaG5zb24gIDxkZWFuX2pvaG5z b25AYXBwbGUuY29tPg0KKw0KKyAgICAgICAgRml4ZWQgc2NtIHVuaXQgdGVzdHMuDQorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQzOTY3DQorDQorICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4NCisNCisgICAgICAgICogU2NyaXB0cy93 ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2RldGVjdGlvbi5weToNCisgICAgICAgIChTQ01E ZXRlY3Rvci5kZXRlY3Rfc2NtX3N5c3RlbSk6IE5vdyB1c2UgcmVhbHBhdGhzIHNvIGFsbCBwYXRo cyBhcmUgY29uc2lzdGVudCB3aGVuIGJlaW5nIGNvbXBhcmVkLg0KKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5Og0KKyAgICAgICAgKEdpdC5jaGFu Z2VkX2ZpbGVzKTogRml4ZWQgYGdpdGAgaW52b2NhdGlvbiBzeW50YWN0aWNhbCBlcnJvcnMuICgn LXInIHJlcGxhY2VkIHdpdGggJy0tcmF3JyBhbmQgYWRkZWQgJy0tJyB0byBlc2NhcGUgcGF0Y2hf ZGlyZWN0b3JpZXMgYXMgYXJndW1lbnRzKQ0KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2Nv bW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5OiBDaGFuZ2VkIHRlc3RzIGFuZCBzZXR1 cCBpbiB0aGUgR2l0U1ZOVGVzdCBjbGFzcyB0byBtcm9lIGNsb3NlbHkgZW11bGF0ZSBvbGQgZ2l0 Li4NCisgICAgICAgIChHaXRTVk5UZXN0Ll9zZXR1cF9naXRfY2hlY2tvdXQpOiBBZGRlZCAtLXBy ZWZpeCBvcHRpb24gdG8gYGdpdCBjbG9uZWAgYW5kIHJlbmFtZWQgYG1hc3RlcmAgYnJhbmNoIHRv IGB0cnVua2AuDQorICAgICAgICAoR2l0U1ZOVGVzdC50ZXN0X2NoYW5nZWRfZmlsZXNfbG9jYWxf cGx1c193b3JraW5nX2NvcHkpOiBDaGFuZ2VkIGB0cnVua2AgdG8gbWFzdGVyIGFuZCBjaGFuZ2Vk IGhvdyBnaXQgd2FzIHJlZmVyZW5jZWQgc28gdGhlIGV4cGVjdGVkIHZhbHVlIG1hdGNoIHRoZSBy ZXR1cm4uIFByZXZpb3VzbHkgdGhlIHRlc3Qgd291bGQgZmFpbCBkdWUgdG8gYW4gZXJyb3Igb2Yg d2hpY2ggY29tbWl0cyBuZWVkZWQgdG8gYmUgY29tcGFyZWQgYW5kIHdoYXQgd2FzIGV4cGVjdGVk Lg0KKw0KIDIwMTUtMDYtMjkgIEpha2UgTmllbHNlbiAgPGphY29iX25pZWxzZW5AYXBwbGUuY29t Pg0KIA0KICAgICAgICAgQWRkIHRpbWVvdXQgaW4gcnVuLXdlYmtpdC10ZXN0cyBmb3IgbGF1bmNo aW5nIHRoZSBzaW11bGF0b3INCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2Nv bW1vbi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9j b21tb24vY2hlY2tvdXQvc2NtL2RldGVjdGlvbi5weQ0KaW5kZXggODdhN2EwZC4uOGM1OTAwNSAx MDA2NDQNCi0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9k ZXRlY3Rpb24ucHkNCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0 L3NjbS9kZXRlY3Rpb24ucHkNCkBAIC02MywxNiArNjMsMTYgQEAgY2xhc3MgU0NNRGV0ZWN0b3Io b2JqZWN0KToNCiAgICAgICAgIHJldHVybiBzY21fc3lzdGVtDQogDQogICAgIGRlZiBkZXRlY3Rf c2NtX3N5c3RlbShzZWxmLCBwYXRoLCBwYXRjaF9kaXJlY3Rvcmllcz1Ob25lKToNCi0gICAgICAg IGFic29sdXRlX3BhdGggPSBzZWxmLl9maWxlc3lzdGVtLmFic3BhdGgocGF0aCkNCisgICAgICAg IHJlYWxfcGF0aCA9IHNlbGYuX2ZpbGVzeXN0ZW0ucmVhbHBhdGgocGF0aCkNCiANCiAgICAgICAg IGlmIHBhdGNoX2RpcmVjdG9yaWVzID09IFtdOg0KICAgICAgICAgICAgIHBhdGNoX2RpcmVjdG9y aWVzID0gTm9uZQ0KIA0KLSAgICAgICAgaWYgU1ZOLmluX3dvcmtpbmdfZGlyZWN0b3J5KGFic29s dXRlX3BhdGgsIGV4ZWN1dGl2ZT1zZWxmLl9leGVjdXRpdmUpOg0KLSAgICAgICAgICAgIHJldHVy biBTVk4oY3dkPWFic29sdXRlX3BhdGgsIHBhdGNoX2RpcmVjdG9yaWVzPXBhdGNoX2RpcmVjdG9y aWVzLCBmaWxlc3lzdGVtPXNlbGYuX2ZpbGVzeXN0ZW0sIGV4ZWN1dGl2ZT1zZWxmLl9leGVjdXRp dmUpDQorICAgICAgICBpZiBTVk4uaW5fd29ya2luZ19kaXJlY3RvcnkocmVhbF9wYXRoLCBleGVj dXRpdmU9c2VsZi5fZXhlY3V0aXZlKToNCisgICAgICAgICAgICByZXR1cm4gU1ZOKGN3ZD1yZWFs X3BhdGgsIHBhdGNoX2RpcmVjdG9yaWVzPXBhdGNoX2RpcmVjdG9yaWVzLCBmaWxlc3lzdGVtPXNl bGYuX2ZpbGVzeXN0ZW0sIGV4ZWN1dGl2ZT1zZWxmLl9leGVjdXRpdmUpDQogDQotICAgICAgICBp ZiBHaXQuaW5fd29ya2luZ19kaXJlY3RvcnkoYWJzb2x1dGVfcGF0aCwgZXhlY3V0aXZlPXNlbGYu X2V4ZWN1dGl2ZSk6DQotICAgICAgICAgICAgcmV0dXJuIEdpdChjd2Q9YWJzb2x1dGVfcGF0aCwg cGF0Y2hfZGlyZWN0b3JpZXM9cGF0Y2hfZGlyZWN0b3JpZXMsIGZpbGVzeXN0ZW09c2VsZi5fZmls ZXN5c3RlbSwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSkNCisgICAgICAgIGlmIEdpdC5pbl93 b3JraW5nX2RpcmVjdG9yeShyZWFsX3BhdGgsIGV4ZWN1dGl2ZT1zZWxmLl9leGVjdXRpdmUpOg0K KyAgICAgICAgICAgIHJldHVybiBHaXQoY3dkPXJlYWxfcGF0aCwgcGF0Y2hfZGlyZWN0b3JpZXM9 cGF0Y2hfZGlyZWN0b3JpZXMsIGZpbGVzeXN0ZW09c2VsZi5fZmlsZXN5c3RlbSwgZXhlY3V0aXZl PXNlbGYuX2V4ZWN1dGl2ZSkNCiANCiAgICAgICAgIHJldHVybiBOb25lDQogDQpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weSBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9naXQucHkNCmluZGV4IGFh ZDZlYWQuLjJiZTY4M2QgMTAwNjQ0DQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9jaGVja291dC9zY20vZ2l0LnB5DQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9jaGVja291dC9zY20vZ2l0LnB5DQpAQCAtMjE2LDcgKzIxNiw3IEBAIGNsYXNzIEdpdChTQ00s IFNWTlJlcG9zaXRvcnkpOg0KIA0KICAgICBkZWYgY2hhbmdlZF9maWxlcyhzZWxmLCBnaXRfY29t bWl0PU5vbmUpOg0KICAgICAgICAgIyBGSVhNRTogLS1kaWZmLWZpbHRlciBjb3VsZCBiZSB1c2Vk IHRvIGF2b2lkIHRoZSAiZXh0cmFjdF9maWxlbmFtZXMiIHN0ZXAuDQotICAgICAgICBzdGF0dXNf Y29tbWFuZCA9IFtzZWxmLmV4ZWN1dGFibGVfbmFtZSwgJ2RpZmYnLCAnLXInLCAnLS1uYW1lLXN0 YXR1cycsICItLW5vLXJlbmFtZXMiLCAiLS1uby1leHQtZGlmZiIsICItLWZ1bGwtaW5kZXgiLCBz ZWxmLm1lcmdlX2Jhc2UoZ2l0X2NvbW1pdCldDQorICAgICAgICBzdGF0dXNfY29tbWFuZCA9IFtz ZWxmLmV4ZWN1dGFibGVfbmFtZSwgJ2RpZmYnLCAnLS1yYXcnLCAnLS1uYW1lLXN0YXR1cycsICIt LW5vLXJlbmFtZXMiLCAiLS1uby1leHQtZGlmZiIsICItLWZ1bGwtaW5kZXgiLCBzZWxmLm1lcmdl X2Jhc2UoZ2l0X2NvbW1pdCksICctLSddDQogICAgICAgICBzdGF0dXNfY29tbWFuZC5leHRlbmQo c2VsZi5fcGF0Y2hfZGlyZWN0b3JpZXMpDQogICAgICAgICAjIEZJWE1FOiBJJ20gbm90IHN1cmUg d2UncmUgcmV0dXJuaW5nIHRoZSBzYW1lIHNldCBvZiBmaWxlcyB0aGF0IFNWTi5jaGFuZ2VkX2Zp bGVzIGlzLg0KICAgICAgICAgIyBBZGRlZCAoQSksIENvcGllZCAoQyksIERlbGV0ZWQgKEQpLCBN b2RpZmllZCAoTSksIFJlbmFtZWQgKFIpDQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9zY21fdW5pdHRlc3QucHkNCmluZGV4IGQ3NzJk NzkuLjQ4NGMzNWMgMTAwNjQ0DQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9j aGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5DQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5DQpAQCAtMTAzNSw4ICsxMDM1LDkg QEAgY2xhc3MgR2l0U1ZOVGVzdChTQ01UZXN0KToNCiAgICAgZGVmIF9zZXR1cF9naXRfY2hlY2tv dXQoc2VsZik6DQogICAgICAgICBzZWxmLmdpdF9jaGVja291dF9wYXRoID0gdGVtcGZpbGUubWtk dGVtcChzdWZmaXg9ImdpdF90ZXN0X2NoZWNrb3V0IikNCiAgICAgICAgICMgLS1xdWlldCBkb2Vz bid0IG1ha2UgZ2l0IHN2biBzaWxlbnQsIHNvIHdlIHVzZSBydW5fc2lsZW50IHRvIHJlZGlyZWN0 IG91dHB1dA0KLSAgICAgICAgcnVuX3NpbGVudChbJ2dpdCcsICdzdm4nLCAnY2xvbmUnLCAnLVQn LCAndHJ1bmsnLCBzZWxmLnN2bl9yZXBvX3VybCwgc2VsZi5naXRfY2hlY2tvdXRfcGF0aF0pDQor ICAgICAgICBydW5fc2lsZW50KFsnZ2l0JywgJ3N2bicsICdjbG9uZScsICctVCcsICd0cnVuaycs ICctLXByZWZpeCcsICcnLCBzZWxmLnN2bl9yZXBvX3VybCwgc2VsZi5naXRfY2hlY2tvdXRfcGF0 aF0pDQogICAgICAgICBvcy5jaGRpcihzZWxmLmdpdF9jaGVja291dF9wYXRoKQ0KKyAgICAgICAg cnVuX3NpbGVudChbJ2dpdCcsICdicmFuY2gnLCAnLW0nLCAndHJ1bmsnXSkNCiANCiAgICAgZGVm IF90ZWFyX2Rvd25fZ2l0X2NoZWNrb3V0KHNlbGYpOg0KICAgICAgICAgIyBDaGFuZ2UgYmFjayB0 byBhIHZhbGlkIGRpcmVjdG9yeSBzbyB0aGF0IGxhdGVyIGNhbGxzIHRvIG9zLmdldGN3ZCgpIGRv IG5vdCBmYWlsLg0KQEAgLTE0MDYsMTIgKzE0MDcsMjEgQEAgY2xhc3MgR2l0U1ZOVGVzdChTQ01U ZXN0KToNCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMp DQogDQogICAgICAgICAjIHdvcmtpbmcgY29weSBzaG91bGQgKm5vdCogYmUgaW4gdGhlIGxpc3Qu DQotICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoJ3RydW5rLi4nKQ0KKyAg ICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVuay4uJykgICMgZ2l0IGRp ZmYgdHJ1bmsuLkhFQUQNCisgICAgICAgIHNlbGYuYXNzZXJ0Tm90SW4oJ3Rlc3RfZmlsZV9jb21t aXQxJywgZmlsZXMpDQorICAgICAgICBzZWxmLmFzc2VydE5vdEluKCd0ZXN0X2ZpbGVfY29tbWl0 MicsIGZpbGVzKQ0KKw0KKyAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0 cnVua14uLicpICAjIGdpdCBkaWZmIHRydW5rXi4uSEVBRA0KICAgICAgICAgc2VsZi5hc3NlcnRJ bigndGVzdF9maWxlX2NvbW1pdDEnLCBmaWxlcykNCiAgICAgICAgIHNlbGYuYXNzZXJ0Tm90SW4o J3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpDQogDQogICAgICAgICAjIHdvcmtpbmcgY29weSAq c2hvdWxkKiBiZSBpbiB0aGUgbGlzdC4NCi0gICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdl ZF9maWxlcygndHJ1bmsuLi4uJykNCisgICAgICAgICMgLi4uLiBpcyBhIGhhY2sgZm9yIHdvcmtp bmcgY29weSBjaGFuZ2VzIHRvIGJlIGluY2x1ZGVkDQorICAgICAgICBmaWxlcyA9IHNlbGYuc2Nt LmNoYW5nZWRfZmlsZXMoJ3RydW5rLi4uLicpICAjIGdpdCBkaWZmIHRydW5rDQorICAgICAgICBz ZWxmLmFzc2VydE5vdEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0KKyAgICAgICAgc2Vs Zi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykNCisNCisgICAgICAgIGZpbGVz ID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygndHJ1bmteLi4uLicpICAjIGdpdCBkaWZmIHRydW5r Xg0KICAgICAgICAgc2VsZi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDEnLCBmaWxlcykNCiAg ICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpDQogDQotLSAN CjIuMy43IChBcHBsZSBHaXQtNTcpDQoNCg== 256742 2015-07-13 16:10:30 -0700 2015-07-14 09:12:19 -0700 Final changes and fixes file_143967.txt text/plain 9928 dean_johnson RnJvbSA2YTY0YjJkMTA2NWQ0NmFhNmQxZmVmZDY3MTg1M2RkMGJjNDhhMzM1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQ0KRnJvbTogRGVhbiBKb2huc29uIDxkZWFuX2pvaG5zb25AYXBwbGUuY29t Pg0KRGF0ZTogTW9uLCAxMyBKdWwgMjAxNSAxNjowNDo0OSAtMDcwMA0KU3ViamVjdDogW1BBVENI XSBNYW55IHRlc3QgZmFpbHVyZXMgaW4gc2NtX3VuaXR0ZXN0LnB5DQogaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0Mzk2Nw0KDQpSZXZpZXdlZCBieSBEYW5pZWwgQmF0 ZXMuDQoNCiogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2RldGVjdGlvbi5w eToNCihTQ01EZXRlY3Rvci5kZXRlY3Rfc2NtX3N5c3RlbSk6IFBhdGhzIHdpdGggc3ltbGlua3Mg YXJlIG5vdyByZXNvbHZlZCB0bw0KYWJzb2x1dGUgY2Fub25pY2FsIGZpbGUgcGF0aHMuIFR3byBt dXR1YWxseSBleGNsdXNpdmUgaXNzdWVzIGNhdXNlIHRoaXMNCnRvIGJlIGEgcHJvYmxlbS4NCiAg ICAxKSBQeXRob24ncyBvcy5wYXRoLnJlbHBhdGgoKSBmdW5jdGlvbiBkb2VzIG5vdCByZXR1cm4g Y29ycmVjdCByZWxhdGl2ZQ0KICAgIHBhdGhzIGJldHdlZW4gdHdvIGZpbGVwYXRocyB0aGF0IHBv aW50IHRvIHRoZSBzYW1lIGZpbGUsIGlmIHN5bWxpbmtzIGFyZQ0KICAgIGludm9sdmVkLg0KICAg ICAgICBPbiBNYWMsIC90bXAgcG9pbnRzIHRvIC9wcml2YXRlL3RtcA0KICAgICAgICBleC4gb3Mu cGF0aC5yZWxwYXRoKCcvdG1wJywgJy9wcml2YXRlL3RtcCcpDQogICAgICAgICAgICByZXR1cm5z ICcuLi8uLi90bXAnDQogICAgV2hhdCB3ZSB3YW50IGlzIGFjdHVhbGx5IGp1c3QgJy4nDQogICAg MikgR2l0IGRvZXMgbm90IGFsbG93IHJlZmVyZW5jZWQgZmlsZXBhdGhzIHRvIHRyYWNlIG91dHNp ZGUgb2YNCiAgICB0aGUgZ2l0IHJlcG9zaXRvcnkuIFRoaXMgbWVhbnMgdGhhdCBpZiB5b3UgaGF2 ZSBhIHJlcG9zaXRvcnkgaW4NCiAgICAvdG1wIGFuZCB0aGUgcGF0aCB0byB0aGUgcmVwb3NpdG9y eSBpcyAuLi90bXAsIEdpdCB3aWxsIHByb2R1Y2UNCiAgICBlcnJvcnMgYWJvdXQgd29ya2luZyBv dXRzaWRlIG9mIHRoZSByZXBvc2l0b3J5Lg0KKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVj a291dC9zY20vZ2l0LnB5OiBPdmVyIHRpbWUgR2l0IGhhcyBjaGFuZ2VkDQppdHMgZGVmYXVsdCBi ZWhhdmlvdXIgYW5kIHN1Y2gsIG5lZWRlZCB0byBiZSB1cGRhdGVkLg0KKEdpdC5jaGFuZ2VkX2Zp bGVzKToNCiAgICAxKSBSZW1vdmVkIHRoZSAnLXInIChyZWN1cnNpdmVseSBhZGRlZCBmaWxlcykg b3B0aW9uIGFzIEdpdCBtYWRlIGl0IHRoZQ0KICAgIGRlZmF1bHQgZm9yIHZlcnNpb25zID4gMS40 LjQuNS4NCiAgICAyKSAnLS0nIHdhcyBhZGRlZCBpbnRvIHRoZSBjb21tYW5kIHNvIHRoYXQgcGF0 Y2hfZGlyZWN0b3JpZXMgd2VyZSB0YWtlbg0KICAgIGFzIHBvc2l0aW9uYWwgYXJndW1lbnRzLg0K KiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5OiBD aGFuZ2VkIHRlc3RzIGFuZCBzZXR1cA0KaW4gdGhlIEdpdFNWTlRlc3QgY2xhc3MgdG8gbW9yZSBj bG9zZWx5IGVtdWxhdGUgdGhlIHZlcnNpb24gb2YgZ2l0IHRoYXQgdGhlIHRlc3RzDQphc3N1bWVk IGEgc3lzdGVtIGhhZC4NCihHaXRTVk5UZXN0Ll9zZXR1cF9naXRfY2hlY2tvdXQpOg0KICAgIDEp IEFkZGVkICItLXByZWZpeCAnJyIgb3B0aW9uIHRvIGBnaXQgY2xvbmVgIHNpbmNlIGdpdCBjaGFu Z2VkIGl0cyBkZWZhdWx0DQogICAgYmVoYXZpb3IgaW4gdmVyc2lvbiAyLjAuDQogICAgMikgVGhl IGJyYW5jaCBtYXN0ZXIgd2FzIHJlbmFtZWQgdG8gdHJ1bmsgdG8gbW9yZSBjbG9zZWx5IGVtdWxh dGUgd2hhdA0KICAgIHRlc3RzIGV4cGVjdGVkIHdoZW4gdGhleSB3ZXJlIHdyaXR0ZW4uDQooR2l0 U1ZOVGVzdC50ZXN0X2NoYW5nZWRfZmlsZXNfbG9jYWxfcGx1c193b3JraW5nX2NvcHkpOiBUd28g b2YgdGhlIHRocmVlDQpvcmlnaW5hbCB0ZXN0cyBmYWlsZWQgYmVjYXVzZSB0aGUgdGVzdHMgZXhw ZWN0ZWQgdGhlIHRydW5rIGJyYW5jaA0KdG8gcHJvZHVjZSBpdHMgcGFyZW50J3MgY29tbWl0LCB3 aGVyZWFzIGdpdCBtZXJlbHkgcHJvdmlkZXMgdGhlIEhFQUQgY29tbWl0DQpmb3IgYSBnaXZlbiBi cmFuY2ggKHRydW5rIGluIHRoaXMgY2FzZSkuIEJhc2VkIG9uIG90aGVyIHRlc3RzIHdyaXR0ZW4N CmluIHRoZSBzYW1lIGNvbW1pdCwgaXQgYXBwZWFycyB0aGVzZSB0ZXN0cyB3ZXJlIGZhaWxpbmcg ZnJvbSB0aGUgcG9pbnQgdGhleQ0Kd2VyZSB3cml0dGVuLg0KLS0tDQogVG9vbHMvQ2hhbmdlTG9n ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCA0NCArKysrKysrKysrKysrKysr KysrKysrDQogLi4uL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5ICAg ICAgfCAxMCArKy0tLQ0KIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3Nj bS9naXQucHkgIHwgIDIgKy0NCiAuLi4vd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9zY21f dW5pdHRlc3QucHkgICB8IDE2ICsrKysrKy0tDQogNCBmaWxlcyBjaGFuZ2VkLCA2MyBpbnNlcnRp b25zKCspLCA5IGRlbGV0aW9ucygtKQ0KDQpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIv VG9vbHMvQ2hhbmdlTG9nDQppbmRleCBkMGM5NzVjLi42ZWRmM2VmIDEwMDY0NA0KLS0tIGEvVG9v bHMvQ2hhbmdlTG9nDQorKysgYi9Ub29scy9DaGFuZ2VMb2cNCkBAIC0xLDMgKzEsNDcgQEANCisy MDE1LTA3LTEzICBEZWFuIEpvaG5zb24gIDxkZWFuX2pvaG5zb25AYXBwbGUuY29tPg0KKw0KKyAg ICAgICAgTWFueSB0ZXN0IGZhaWx1cmVzIGluIHNjbV91bml0dGVzdC5weQ0KKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0Mzk2Nw0KKw0KKyAgICAgICAg UmV2aWV3ZWQgYnkgRGFuaWVsIEJhdGVzLiANCisNCisgICAgICAgICogU2NyaXB0cy93ZWJraXRw eS9jb21tb24vY2hlY2tvdXQvc2NtL2RldGVjdGlvbi5weToNCisgICAgICAgIChTQ01EZXRlY3Rv ci5kZXRlY3Rfc2NtX3N5c3RlbSk6IFBhdGhzIHdpdGggc3ltbGlua3MgYXJlIG5vdyByZXNvbHZl ZCB0bw0KKwkJYWJzb2x1dGUgY2Fub25pY2FsIGZpbGUgcGF0aHMuIFR3byBtdXR1YWxseSBleGNs dXNpdmUgaXNzdWVzIGNhdXNlIHRoaXMNCisJCXRvIGJlIGEgcHJvYmxlbS4NCisJCQkxKSBQeXRo b24ncyBvcy5wYXRoLnJlbHBhdGgoKSBmdW5jdGlvbiBkb2VzIG5vdCByZXR1cm4gY29ycmVjdCBy ZWxhdGl2ZQ0KKwkJCXBhdGhzIGJldHdlZW4gdHdvIGZpbGVwYXRocyB0aGF0IHBvaW50IHRvIHRo ZSBzYW1lIGZpbGUsIGlmIHN5bWxpbmtzIGFyZQ0KKwkJCWludm9sdmVkLg0KKwkJCQlPbiBNYWMs IC90bXAgcG9pbnRzIHRvIC9wcml2YXRlL3RtcA0KKwkJCQlleC4gb3MucGF0aC5yZWxwYXRoKCcv dG1wJywgJy9wcml2YXRlL3RtcCcpDQorCQkJCQlyZXR1cm5zICcuLi8uLi90bXAnDQorCQkJV2hh dCB3ZSB3YW50IGlzIGFjdHVhbGx5IGp1c3QgJy4nDQorCQkJMikgR2l0IGRvZXMgbm90IGFsbG93 IHJlZmVyZW5jZWQgZmlsZXBhdGhzIHRvIHRyYWNlIG91dHNpZGUgb2YNCisJCQl0aGUgZ2l0IHJl cG9zaXRvcnkuIFRoaXMgbWVhbnMgdGhhdCBpZiB5b3UgaGF2ZSBhIHJlcG9zaXRvcnkgaW4NCisJ CQkvdG1wIGFuZCB0aGUgcGF0aCB0byB0aGUgcmVwb3NpdG9yeSBpcyAuLi90bXAsIEdpdCB3aWxs IHByb2R1Y2UNCisJCQllcnJvcnMgYWJvdXQgd29ya2luZyBvdXRzaWRlIG9mIHRoZSByZXBvc2l0 b3J5Lg0KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0 LnB5OiBPdmVyIHRpbWUgR2l0IGhhcyBjaGFuZ2VkDQorCQlpdHMgZGVmYXVsdCBiZWhhdmlvdXIg YW5kIHN1Y2gsIG5lZWRlZCB0byBiZSB1cGRhdGVkLg0KKyAgICAgICAgKEdpdC5jaGFuZ2VkX2Zp bGVzKTogDQorICAgICAgICAgICAgMSkgUmVtb3ZlZCB0aGUgJy1yJyAocmVjdXJzaXZlbHkgYWRk ZWQgZmlsZXMpIG9wdGlvbiBhcyBHaXQgbWFkZSBpdCB0aGUNCisJCQlkZWZhdWx0IGZvciB2ZXJz aW9ucyA+IDEuNC40LjUuDQorICAgICAgICAgICAgMikgJy0tJyB3YXMgYWRkZWQgaW50byB0aGUg Y29tbWFuZCBzbyB0aGF0IHBhdGNoX2RpcmVjdG9yaWVzIHdlcmUgdGFrZW4NCisJCQlhcyBwb3Np dGlvbmFsIGFyZ3VtZW50cy4NCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hl Y2tvdXQvc2NtL3NjbV91bml0dGVzdC5weTogQ2hhbmdlZCB0ZXN0cyBhbmQgc2V0dXAgDQorCQlp biB0aGUgR2l0U1ZOVGVzdCBjbGFzcyB0byBtb3JlIGNsb3NlbHkgZW11bGF0ZSB0aGUgdmVyc2lv biBvZiBnaXQgdGhhdCB0aGUgdGVzdHMNCisJCWFzc3VtZWQgYSBzeXN0ZW0gaGFkLg0KKyAgICAg ICAgKEdpdFNWTlRlc3QuX3NldHVwX2dpdF9jaGVja291dCk6DQorICAgICAgICAgICAgMSkgQWRk ZWQgIi0tcHJlZml4ICcnIiBvcHRpb24gdG8gYGdpdCBjbG9uZWAgc2luY2UgZ2l0IGNoYW5nZWQg aXRzIGRlZmF1bHQNCisJCQliZWhhdmlvciBpbiB2ZXJzaW9uIDIuMC4NCisgICAgICAgICAgICAy KSBUaGUgYnJhbmNoIG1hc3RlciB3YXMgcmVuYW1lZCB0byB0cnVuayB0byBtb3JlIGNsb3NlbHkg ZW11bGF0ZSB3aGF0DQorCQkJdGVzdHMgZXhwZWN0ZWQgd2hlbiB0aGV5IHdlcmUgd3JpdHRlbi4g DQorICAgICAgICAoR2l0U1ZOVGVzdC50ZXN0X2NoYW5nZWRfZmlsZXNfbG9jYWxfcGx1c193b3Jr aW5nX2NvcHkpOiBUd28gb2YgdGhlIHRocmVlDQorCQlvcmlnaW5hbCB0ZXN0cyBmYWlsZWQgYmVj YXVzZSB0aGUgdGVzdHMgZXhwZWN0ZWQgdGhlIHRydW5rIGJyYW5jaA0KKwkJdG8gcHJvZHVjZSBp dHMgcGFyZW50J3MgY29tbWl0LCB3aGVyZWFzIGdpdCBtZXJlbHkgcHJvdmlkZXMgdGhlIEhFQUQg Y29tbWl0DQorCQlmb3IgYSBnaXZlbiBicmFuY2ggKHRydW5rIGluIHRoaXMgY2FzZSkuIEJhc2Vk IG9uIG90aGVyIHRlc3RzIHdyaXR0ZW4NCisJCWluIHRoZSBzYW1lIGNvbW1pdCwgaXQgYXBwZWFy cyB0aGVzZSB0ZXN0cyB3ZXJlIGZhaWxpbmcgZnJvbSB0aGUgcG9pbnQgdGhleQ0KKwkJd2VyZSB3 cml0dGVuLg0KKw0KIDIwMTUtMDctMTAgIEJyZW50IEZ1bGdoYW0gIDxiZnVsZ2hhbUBhcHBsZS5j b20+DQogDQogICAgICAgICBbTWFjXSBVbmFibGUgdG8gZGlzbWlzcyBjb250ZXh0IG1lbnUgZHVy aW5nIHRlc3QgcnVucw0KZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2NoZWNrb3V0L3NjbS9kZXRlY3Rpb24ucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5DQppbmRleCA4N2E3YTBkLi44YzU5MDA1IDEwMDY0 NA0KLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2RldGVj dGlvbi5weQ0KKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2Nt L2RldGVjdGlvbi5weQ0KQEAgLTYzLDE2ICs2MywxNiBAQCBjbGFzcyBTQ01EZXRlY3RvcihvYmpl Y3QpOg0KICAgICAgICAgcmV0dXJuIHNjbV9zeXN0ZW0NCiANCiAgICAgZGVmIGRldGVjdF9zY21f c3lzdGVtKHNlbGYsIHBhdGgsIHBhdGNoX2RpcmVjdG9yaWVzPU5vbmUpOg0KLSAgICAgICAgYWJz b2x1dGVfcGF0aCA9IHNlbGYuX2ZpbGVzeXN0ZW0uYWJzcGF0aChwYXRoKQ0KKyAgICAgICAgcmVh bF9wYXRoID0gc2VsZi5fZmlsZXN5c3RlbS5yZWFscGF0aChwYXRoKQ0KIA0KICAgICAgICAgaWYg cGF0Y2hfZGlyZWN0b3JpZXMgPT0gW106DQogICAgICAgICAgICAgcGF0Y2hfZGlyZWN0b3JpZXMg PSBOb25lDQogDQotICAgICAgICBpZiBTVk4uaW5fd29ya2luZ19kaXJlY3RvcnkoYWJzb2x1dGVf cGF0aCwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSk6DQotICAgICAgICAgICAgcmV0dXJuIFNW Tihjd2Q9YWJzb2x1dGVfcGF0aCwgcGF0Y2hfZGlyZWN0b3JpZXM9cGF0Y2hfZGlyZWN0b3JpZXMs IGZpbGVzeXN0ZW09c2VsZi5fZmlsZXN5c3RlbSwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSkN CisgICAgICAgIGlmIFNWTi5pbl93b3JraW5nX2RpcmVjdG9yeShyZWFsX3BhdGgsIGV4ZWN1dGl2 ZT1zZWxmLl9leGVjdXRpdmUpOg0KKyAgICAgICAgICAgIHJldHVybiBTVk4oY3dkPXJlYWxfcGF0 aCwgcGF0Y2hfZGlyZWN0b3JpZXM9cGF0Y2hfZGlyZWN0b3JpZXMsIGZpbGVzeXN0ZW09c2VsZi5f ZmlsZXN5c3RlbSwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSkNCiANCi0gICAgICAgIGlmIEdp dC5pbl93b3JraW5nX2RpcmVjdG9yeShhYnNvbHV0ZV9wYXRoLCBleGVjdXRpdmU9c2VsZi5fZXhl Y3V0aXZlKToNCi0gICAgICAgICAgICByZXR1cm4gR2l0KGN3ZD1hYnNvbHV0ZV9wYXRoLCBwYXRj aF9kaXJlY3Rvcmllcz1wYXRjaF9kaXJlY3RvcmllcywgZmlsZXN5c3RlbT1zZWxmLl9maWxlc3lz dGVtLCBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKQ0KKyAgICAgICAgaWYgR2l0LmluX3dvcmtp bmdfZGlyZWN0b3J5KHJlYWxfcGF0aCwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSk6DQorICAg ICAgICAgICAgcmV0dXJuIEdpdChjd2Q9cmVhbF9wYXRoLCBwYXRjaF9kaXJlY3Rvcmllcz1wYXRj aF9kaXJlY3RvcmllcywgZmlsZXN5c3RlbT1zZWxmLl9maWxlc3lzdGVtLCBleGVjdXRpdmU9c2Vs Zi5fZXhlY3V0aXZlKQ0KIA0KICAgICAgICAgcmV0dXJuIE5vbmUNCiANCmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5IGIvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weQ0KaW5kZXggYWFkNmVh ZC4uOWQ1M2U3MiAxMDA2NDQNCi0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2No ZWNrb3V0L3NjbS9naXQucHkNCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2No ZWNrb3V0L3NjbS9naXQucHkNCkBAIC0yMTYsNyArMjE2LDcgQEAgY2xhc3MgR2l0KFNDTSwgU1ZO UmVwb3NpdG9yeSk6DQogDQogICAgIGRlZiBjaGFuZ2VkX2ZpbGVzKHNlbGYsIGdpdF9jb21taXQ9 Tm9uZSk6DQogICAgICAgICAjIEZJWE1FOiAtLWRpZmYtZmlsdGVyIGNvdWxkIGJlIHVzZWQgdG8g YXZvaWQgdGhlICJleHRyYWN0X2ZpbGVuYW1lcyIgc3RlcC4NCi0gICAgICAgIHN0YXR1c19jb21t YW5kID0gW3NlbGYuZXhlY3V0YWJsZV9uYW1lLCAnZGlmZicsICctcicsICctLW5hbWUtc3RhdHVz JywgIi0tbm8tcmVuYW1lcyIsICItLW5vLWV4dC1kaWZmIiwgIi0tZnVsbC1pbmRleCIsIHNlbGYu bWVyZ2VfYmFzZShnaXRfY29tbWl0KV0NCisgICAgICAgIHN0YXR1c19jb21tYW5kID0gW3NlbGYu ZXhlY3V0YWJsZV9uYW1lLCAnZGlmZicsICctLW5hbWUtc3RhdHVzJywgIi0tbm8tcmVuYW1lcyIs ICItLW5vLWV4dC1kaWZmIiwgIi0tZnVsbC1pbmRleCIsIHNlbGYubWVyZ2VfYmFzZShnaXRfY29t bWl0KSwgJy0tJ10NCiAgICAgICAgIHN0YXR1c19jb21tYW5kLmV4dGVuZChzZWxmLl9wYXRjaF9k aXJlY3RvcmllcykNCiAgICAgICAgICMgRklYTUU6IEknbSBub3Qgc3VyZSB3ZSdyZSByZXR1cm5p bmcgdGhlIHNhbWUgc2V0IG9mIGZpbGVzIHRoYXQgU1ZOLmNoYW5nZWRfZmlsZXMgaXMuDQogICAg ICAgICAjIEFkZGVkIChBKSwgQ29waWVkIChDKSwgRGVsZXRlZCAoRCksIE1vZGlmaWVkIChNKSwg UmVuYW1lZCAoUikNCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9j aGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5weQ0KaW5kZXggZDc3MmQ3OS4uNDg0YzM1YyAx MDA2NDQNCi0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9z Y21fdW5pdHRlc3QucHkNCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNr b3V0L3NjbS9zY21fdW5pdHRlc3QucHkNCkBAIC0xMDM1LDggKzEwMzUsOSBAQCBjbGFzcyBHaXRT Vk5UZXN0KFNDTVRlc3QpOg0KICAgICBkZWYgX3NldHVwX2dpdF9jaGVja291dChzZWxmKToNCiAg ICAgICAgIHNlbGYuZ2l0X2NoZWNrb3V0X3BhdGggPSB0ZW1wZmlsZS5ta2R0ZW1wKHN1ZmZpeD0i Z2l0X3Rlc3RfY2hlY2tvdXQiKQ0KICAgICAgICAgIyAtLXF1aWV0IGRvZXNuJ3QgbWFrZSBnaXQg c3ZuIHNpbGVudCwgc28gd2UgdXNlIHJ1bl9zaWxlbnQgdG8gcmVkaXJlY3Qgb3V0cHV0DQotICAg ICAgICBydW5fc2lsZW50KFsnZ2l0JywgJ3N2bicsICdjbG9uZScsICctVCcsICd0cnVuaycsIHNl bGYuc3ZuX3JlcG9fdXJsLCBzZWxmLmdpdF9jaGVja291dF9wYXRoXSkNCisgICAgICAgIHJ1bl9z aWxlbnQoWydnaXQnLCAnc3ZuJywgJ2Nsb25lJywgJy1UJywgJ3RydW5rJywgJy0tcHJlZml4Jywg JycsIHNlbGYuc3ZuX3JlcG9fdXJsLCBzZWxmLmdpdF9jaGVja291dF9wYXRoXSkNCiAgICAgICAg IG9zLmNoZGlyKHNlbGYuZ2l0X2NoZWNrb3V0X3BhdGgpDQorICAgICAgICBydW5fc2lsZW50KFsn Z2l0JywgJ2JyYW5jaCcsICctbScsICd0cnVuayddKQ0KIA0KICAgICBkZWYgX3RlYXJfZG93bl9n aXRfY2hlY2tvdXQoc2VsZik6DQogICAgICAgICAjIENoYW5nZSBiYWNrIHRvIGEgdmFsaWQgZGly ZWN0b3J5IHNvIHRoYXQgbGF0ZXIgY2FsbHMgdG8gb3MuZ2V0Y3dkKCkgZG8gbm90IGZhaWwuDQpA QCAtMTQwNiwxMiArMTQwNywyMSBAQCBjbGFzcyBHaXRTVk5UZXN0KFNDTVRlc3QpOg0KICAgICAg ICAgc2VsZi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykNCiANCiAgICAgICAg ICMgd29ya2luZyBjb3B5IHNob3VsZCAqbm90KiBiZSBpbiB0aGUgbGlzdC4NCi0gICAgICAgIGZp bGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygndHJ1bmsuLicpDQorICAgICAgICBmaWxlcyA9 IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoJ3RydW5rLi4nKSAgIyBnaXQgZGlmZiB0cnVuay4uSEVB RA0KKyAgICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlX2NvbW1pdDEnLCBmaWxlcykN CisgICAgICAgIHNlbGYuYXNzZXJ0Tm90SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpDQor DQorICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoJ3RydW5rXi4uJykgICMg Z2l0IGRpZmYgdHJ1bmteLi5IRUFEDQogICAgICAgICBzZWxmLmFzc2VydEluKCd0ZXN0X2ZpbGVf Y29tbWl0MScsIGZpbGVzKQ0KICAgICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlX2Nv bW1pdDInLCBmaWxlcykNCiANCiAgICAgICAgICMgd29ya2luZyBjb3B5ICpzaG91bGQqIGJlIGlu IHRoZSBsaXN0Lg0KLSAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVu ay4uLi4nKQ0KKyAgICAgICAgIyAuLi4uIGlzIGEgaGFjayBmb3Igd29ya2luZyBjb3B5IGNoYW5n ZXMgdG8gYmUgaW5jbHVkZWQNCisgICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxl cygndHJ1bmsuLi4uJykgICMgZ2l0IGRpZmYgdHJ1bmsNCisgICAgICAgIHNlbGYuYXNzZXJ0Tm90 SW4oJ3Rlc3RfZmlsZV9jb21taXQxJywgZmlsZXMpDQorICAgICAgICBzZWxmLmFzc2VydEluKCd0 ZXN0X2ZpbGVfY29tbWl0MicsIGZpbGVzKQ0KKw0KKyAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5j aGFuZ2VkX2ZpbGVzKCd0cnVua14uLi4uJykgICMgZ2l0IGRpZmYgdHJ1bmteDQogICAgICAgICBz ZWxmLmFzc2VydEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQ0KICAgICAgICAgc2VsZi5h c3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykNCiANCi0tIA0KMi4zLjggKEFwcGxl IEdpdC01OCkNCg== 256771 2015-07-14 09:12:24 -0700 2015-07-14 11:19:11 -0700 Patch bug-143967-20150714091117.patch text/plain 7641 dean_johnson U3VidmVyc2lvbiBSZXZpc2lvbjogMTg2NzY4CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZDBjOTc1YzUzNmY3ZDA0NjQzMmVkNTk4NTBmMmQxZmY5 ZmMzYzU0My4uMzlkY2Y1ZDdlYjU4N2I3NzFlNWUxYjUzODUyNGExMzhiNjM3YzJjNiAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ3 IEBACisyMDE1LTA3LTEzICBEZWFuIEpvaG5zb24gIDxkZWFuX2pvaG5zb25AYXBwbGUuY29tPgor CisgICAgICAgIE1hbnkgdGVzdCBmYWlsdXJlcyBpbiBzY21fdW5pdHRlc3QucHkKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0Mzk2NworCisgICAgICAg IFJldmlld2VkIGJ5IERhbmllbCBCYXRlcy4gCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5OgorICAgICAgICAoU0NNRGV0ZWN0b3Iu ZGV0ZWN0X3NjbV9zeXN0ZW0pOiBQYXRocyB3aXRoIHN5bWxpbmtzIGFyZSBub3cgcmVzb2x2ZWQg dG8KKyAgICAgICAgYWJzb2x1dGUgY2Fub25pY2FsIGZpbGUgcGF0aHMuIFR3byBtdXR1YWxseSBl eGNsdXNpdmUgaXNzdWVzIGNhdXNlIHRoaXMKKyAgICAgICAgdG8gYmUgYSBwcm9ibGVtLgorICAg ICAgICAgICAgMSkgUHl0aG9uJ3Mgb3MucGF0aC5yZWxwYXRoKCkgZnVuY3Rpb24gZG9lcyBub3Qg cmV0dXJuIGNvcnJlY3QgcmVsYXRpdmUKKyAgICAgICAgICAgIHBhdGhzIGJldHdlZW4gdHdvIGZp bGVwYXRocyB0aGF0IHBvaW50IHRvIHRoZSBzYW1lIGZpbGUsIGlmIHN5bWxpbmtzIGFyZQorICAg ICAgICAgICAgaW52b2x2ZWQuCisgICAgICAgICAgICAgICAgT24gTWFjLCAvdG1wIHBvaW50cyB0 byAvcHJpdmF0ZS90bXAKKyAgICAgICAgICAgICAgICBleC4gb3MucGF0aC5yZWxwYXRoKCcvdG1w JywgJy9wcml2YXRlL3RtcCcpCisgICAgICAgICAgICAgICAgICAgIHJldHVybnMgJy4uLy4uL3Rt cCcKKyAgICAgICAgICAgIFdoYXQgd2Ugd2FudCBpcyBhY3R1YWxseSBqdXN0ICcuJworICAgICAg ICAgICAgMikgR2l0IGRvZXMgbm90IGFsbG93IGZpbGUgcGF0aHMgdG8gdHJhY2Ugb3V0c2lkZSBv ZgorICAgICAgICAgICAgdGhlIEdpdCByZXBvc2l0b3J5LiBUaGlzIG1lYW5zIHRoYXQgaWYgeW91 IGhhdmUgYSByZXBvc2l0b3J5IGluCisgICAgICAgICAgICAvdG1wIGFuZCB5b3UgcmVmZXIgdG8g dGhhdCByZXBvc2l0b3J5IHdoZW4gaW52b2tpbmcgYSBnaXQgY29tbWFuZCBhcworICAgICAgICAg ICAgLi4vdG1wLCBHaXQgd2lsbCBwcm9kdWNlIGVycm9ycyBhYm91dCB3b3JraW5nIG91dHNpZGUg b2YgdGhlIHJlcG9zaXRvcnkuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hl Y2tvdXQvc2NtL2dpdC5weTogT3ZlciB0aW1lIEdpdCBoYXMgY2hhbmdlZAorICAgICAgICBpdHMg ZGVmYXVsdCBiZWhhdmlvciBhbmQgc3VjaCwgbmVlZGVkIHRvIGJlIHVwZGF0ZWQuCisgICAgICAg IChHaXQuY2hhbmdlZF9maWxlcyk6IAorICAgICAgICAgICAgMSkgUmVtb3ZlZCB0aGUgJy1yJyAo cmVjdXJzaXZlbHkgYWRkZWQgZmlsZXMpIG9wdGlvbiBhcyBHaXQgbWFkZSBpdCB0aGUKKyAgICAg ICAgICAgIGRlZmF1bHQgZm9yIHZlcnNpb25zID4gMS40LjQuNS4KKyAgICAgICAgICAgIDIpICct LScgd2FzIGFkZGVkIGludG8gdGhlIGNvbW1hbmQgc28gdGhhdCBwYXRjaF9kaXJlY3RvcmllcyB3 ZXJlIHRha2VuCisgICAgICAgICAgICBhcyBwb3NpdGlvbmFsIGFyZ3VtZW50cy4KKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5OiBD aGFuZ2VkIHRlc3RzIGFuZCBzZXR1cCAKKyAgICAgICAgaW4gdGhlIEdpdFNWTlRlc3QgY2xhc3Mg dG8gbW9yZSBjbG9zZWx5IGVtdWxhdGUgdGhlIHZlcnNpb24gb2YgR2l0IHRoYXQgdGhlIHRlc3Rz CisgICAgICAgIGFzc3VtZWQgYSBzeXN0ZW0gaGFkLgorICAgICAgICAoR2l0U1ZOVGVzdC5fc2V0 dXBfZ2l0X2NoZWNrb3V0KToKKyAgICAgICAgICAgIDEpIEFkZGVkICItLXByZWZpeCAnJyIgb3B0 aW9uIHRvIGBnaXQgY2xvbmVgIHNpbmNlIEdpdCBjaGFuZ2VkIGl0cyBkZWZhdWx0CisgICAgICAg ICAgICBiZWhhdmlvciBpbiB2ZXJzaW9uIDIuMC4KKyAgICAgICAgICAgIDIpIFRoZSBicmFuY2gg bWFzdGVyIHdhcyByZW5hbWVkIHRvIHRydW5rIHRvIG1vcmUgY2xvc2VseSBlbXVsYXRlIHdoYXQK KyAgICAgICAgICAgIHRlc3RzIGV4cGVjdGVkIHdoZW4gdGhleSB3ZXJlIHdyaXR0ZW4uIAorICAg ICAgICAoR2l0U1ZOVGVzdC50ZXN0X2NoYW5nZWRfZmlsZXNfbG9jYWxfcGx1c193b3JraW5nX2Nv cHkpOiBUd28gb2YgdGhlIHRocmVlCisgICAgICAgIG9yaWdpbmFsIHRlc3RzIGZhaWxlZCBiZWNh dXNlIHRoZSB0ZXN0cyBleHBlY3RlZCB0aGUgdHJ1bmsgYnJhbmNoCisgICAgICAgIHRvIHByb2R1 Y2UgaXRzIHBhcmVudCdzIGNvbW1pdCwgd2hlcmVhcyBHaXQgbWVyZWx5IHByb3ZpZGVzIHRoZSBI RUFEIGNvbW1pdAorICAgICAgICBmb3IgYSBnaXZlbiBicmFuY2ggKHRydW5rIGluIHRoaXMgY2Fz ZSkuIEJhc2VkIG9uIG90aGVyIHRlc3RzIHdyaXR0ZW4KKyAgICAgICAgaW4gdGhlIHNhbWUgY29t bWl0LCBpdCBhcHBlYXJzIHRoZXNlIHRlc3RzIHdlcmUgZmFpbGluZyBmcm9tIHRoZSBwb2ludCB0 aGV5CisgICAgICAgIHdlcmUgd3JpdHRlbi4KKwogMjAxNS0wNy0xMCAgQnJlbnQgRnVsZ2hhbSAg PGJmdWxnaGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBbTWFjXSBVbmFibGUgdG8gZGlzbWlzcyBj b250ZXh0IG1lbnUgZHVyaW5nIHRlc3QgcnVucwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2RldGVjdGlvbi5weSBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9kZXRlY3Rpb24ucHkKaW5kZXggODdhN2EwZGM1 YjRkOGQ3YzJmMjZhMjI5MGUyZTI5YTIwMjM0N2M2ZS4uOGM1OTAwNTEyYjdjNzhhMTNkYTIyMzIz NjUzNjY4ODVjMmI1NjUwMiAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vY2hlY2tvdXQvc2NtL2RldGVjdGlvbi5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5CkBAIC02MywxNiArNjMsMTYgQEAgY2xh c3MgU0NNRGV0ZWN0b3Iob2JqZWN0KToKICAgICAgICAgcmV0dXJuIHNjbV9zeXN0ZW0KIAogICAg IGRlZiBkZXRlY3Rfc2NtX3N5c3RlbShzZWxmLCBwYXRoLCBwYXRjaF9kaXJlY3Rvcmllcz1Ob25l KToKLSAgICAgICAgYWJzb2x1dGVfcGF0aCA9IHNlbGYuX2ZpbGVzeXN0ZW0uYWJzcGF0aChwYXRo KQorICAgICAgICByZWFsX3BhdGggPSBzZWxmLl9maWxlc3lzdGVtLnJlYWxwYXRoKHBhdGgpCiAK ICAgICAgICAgaWYgcGF0Y2hfZGlyZWN0b3JpZXMgPT0gW106CiAgICAgICAgICAgICBwYXRjaF9k aXJlY3RvcmllcyA9IE5vbmUKIAotICAgICAgICBpZiBTVk4uaW5fd29ya2luZ19kaXJlY3Rvcnko YWJzb2x1dGVfcGF0aCwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSk6Ci0gICAgICAgICAgICBy ZXR1cm4gU1ZOKGN3ZD1hYnNvbHV0ZV9wYXRoLCBwYXRjaF9kaXJlY3Rvcmllcz1wYXRjaF9kaXJl Y3RvcmllcywgZmlsZXN5c3RlbT1zZWxmLl9maWxlc3lzdGVtLCBleGVjdXRpdmU9c2VsZi5fZXhl Y3V0aXZlKQorICAgICAgICBpZiBTVk4uaW5fd29ya2luZ19kaXJlY3RvcnkocmVhbF9wYXRoLCBl eGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKToKKyAgICAgICAgICAgIHJldHVybiBTVk4oY3dkPXJl YWxfcGF0aCwgcGF0Y2hfZGlyZWN0b3JpZXM9cGF0Y2hfZGlyZWN0b3JpZXMsIGZpbGVzeXN0ZW09 c2VsZi5fZmlsZXN5c3RlbSwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSkKIAotICAgICAgICBp ZiBHaXQuaW5fd29ya2luZ19kaXJlY3RvcnkoYWJzb2x1dGVfcGF0aCwgZXhlY3V0aXZlPXNlbGYu X2V4ZWN1dGl2ZSk6Ci0gICAgICAgICAgICByZXR1cm4gR2l0KGN3ZD1hYnNvbHV0ZV9wYXRoLCBw YXRjaF9kaXJlY3Rvcmllcz1wYXRjaF9kaXJlY3RvcmllcywgZmlsZXN5c3RlbT1zZWxmLl9maWxl c3lzdGVtLCBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKQorICAgICAgICBpZiBHaXQuaW5fd29y a2luZ19kaXJlY3RvcnkocmVhbF9wYXRoLCBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKToKKyAg ICAgICAgICAgIHJldHVybiBHaXQoY3dkPXJlYWxfcGF0aCwgcGF0Y2hfZGlyZWN0b3JpZXM9cGF0 Y2hfZGlyZWN0b3JpZXMsIGZpbGVzeXN0ZW09c2VsZi5fZmlsZXN5c3RlbSwgZXhlY3V0aXZlPXNl bGYuX2V4ZWN1dGl2ZSkKIAogICAgICAgICByZXR1cm4gTm9uZQogCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5IGIvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weQppbmRleCBhYWQ2ZWFkYjI5 NjMwYzU3OTJmYTAxNTBiYzg2ZmJiZTg3NzkxYmVmLi45ZDUzZTcyYzRhZjNmOTk3ZWVlZTFkNGYx NzAzYTNiNjA2ZGQ1NjI2IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9jaGVja291dC9zY20vZ2l0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2NoZWNrb3V0L3NjbS9naXQucHkKQEAgLTIxNiw3ICsyMTYsNyBAQCBjbGFzcyBHaXQoU0NNLCBT Vk5SZXBvc2l0b3J5KToKIAogICAgIGRlZiBjaGFuZ2VkX2ZpbGVzKHNlbGYsIGdpdF9jb21taXQ9 Tm9uZSk6CiAgICAgICAgICMgRklYTUU6IC0tZGlmZi1maWx0ZXIgY291bGQgYmUgdXNlZCB0byBh dm9pZCB0aGUgImV4dHJhY3RfZmlsZW5hbWVzIiBzdGVwLgotICAgICAgICBzdGF0dXNfY29tbWFu ZCA9IFtzZWxmLmV4ZWN1dGFibGVfbmFtZSwgJ2RpZmYnLCAnLXInLCAnLS1uYW1lLXN0YXR1cycs ICItLW5vLXJlbmFtZXMiLCAiLS1uby1leHQtZGlmZiIsICItLWZ1bGwtaW5kZXgiLCBzZWxmLm1l cmdlX2Jhc2UoZ2l0X2NvbW1pdCldCisgICAgICAgIHN0YXR1c19jb21tYW5kID0gW3NlbGYuZXhl Y3V0YWJsZV9uYW1lLCAnZGlmZicsICctLW5hbWUtc3RhdHVzJywgIi0tbm8tcmVuYW1lcyIsICIt LW5vLWV4dC1kaWZmIiwgIi0tZnVsbC1pbmRleCIsIHNlbGYubWVyZ2VfYmFzZShnaXRfY29tbWl0 KSwgJy0tJ10KICAgICAgICAgc3RhdHVzX2NvbW1hbmQuZXh0ZW5kKHNlbGYuX3BhdGNoX2RpcmVj dG9yaWVzKQogICAgICAgICAjIEZJWE1FOiBJJ20gbm90IHN1cmUgd2UncmUgcmV0dXJuaW5nIHRo ZSBzYW1lIHNldCBvZiBmaWxlcyB0aGF0IFNWTi5jaGFuZ2VkX2ZpbGVzIGlzLgogICAgICAgICAj IEFkZGVkIChBKSwgQ29waWVkIChDKSwgRGVsZXRlZCAoRCksIE1vZGlmaWVkIChNKSwgUmVuYW1l ZCAoUikKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0 L3NjbS9zY21fdW5pdHRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVj a291dC9zY20vc2NtX3VuaXR0ZXN0LnB5CmluZGV4IGQ3NzJkNzlmMDU4ODdmMGE3MWRmYzRkN2Nk N2E0MTgxMDhhZjk1YjcuLjQ4NGMzNWNlNmJiOTM5ZmEwNjRjODIxYWZjNmEwMjQwODIxZTk4ZTEg MTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9z Y21fdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tv dXQvc2NtL3NjbV91bml0dGVzdC5weQpAQCAtMTAzNSw4ICsxMDM1LDkgQEAgY2xhc3MgR2l0U1ZO VGVzdChTQ01UZXN0KToKICAgICBkZWYgX3NldHVwX2dpdF9jaGVja291dChzZWxmKToKICAgICAg ICAgc2VsZi5naXRfY2hlY2tvdXRfcGF0aCA9IHRlbXBmaWxlLm1rZHRlbXAoc3VmZml4PSJnaXRf dGVzdF9jaGVja291dCIpCiAgICAgICAgICMgLS1xdWlldCBkb2Vzbid0IG1ha2UgZ2l0IHN2biBz aWxlbnQsIHNvIHdlIHVzZSBydW5fc2lsZW50IHRvIHJlZGlyZWN0IG91dHB1dAotICAgICAgICBy dW5fc2lsZW50KFsnZ2l0JywgJ3N2bicsICdjbG9uZScsICctVCcsICd0cnVuaycsIHNlbGYuc3Zu X3JlcG9fdXJsLCBzZWxmLmdpdF9jaGVja291dF9wYXRoXSkKKyAgICAgICAgcnVuX3NpbGVudChb J2dpdCcsICdzdm4nLCAnY2xvbmUnLCAnLVQnLCAndHJ1bmsnLCAnLS1wcmVmaXgnLCAnJywgc2Vs Zi5zdm5fcmVwb191cmwsIHNlbGYuZ2l0X2NoZWNrb3V0X3BhdGhdKQogICAgICAgICBvcy5jaGRp cihzZWxmLmdpdF9jaGVja291dF9wYXRoKQorICAgICAgICBydW5fc2lsZW50KFsnZ2l0JywgJ2Jy YW5jaCcsICctbScsICd0cnVuayddKQogCiAgICAgZGVmIF90ZWFyX2Rvd25fZ2l0X2NoZWNrb3V0 KHNlbGYpOgogICAgICAgICAjIENoYW5nZSBiYWNrIHRvIGEgdmFsaWQgZGlyZWN0b3J5IHNvIHRo YXQgbGF0ZXIgY2FsbHMgdG8gb3MuZ2V0Y3dkKCkgZG8gbm90IGZhaWwuCkBAIC0xNDA2LDEyICsx NDA3LDIxIEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6CiAgICAgICAgIHNlbGYuYXNzZXJ0 SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpCiAKICAgICAgICAgIyB3b3JraW5nIGNvcHkg c2hvdWxkICpub3QqIGJlIGluIHRoZSBsaXN0LgotICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNo YW5nZWRfZmlsZXMoJ3RydW5rLi4nKQorICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRf ZmlsZXMoJ3RydW5rLi4nKSAgIyBnaXQgZGlmZiB0cnVuay4uSEVBRAorICAgICAgICBzZWxmLmFz c2VydE5vdEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQorICAgICAgICBzZWxmLmFzc2Vy dE5vdEluKCd0ZXN0X2ZpbGVfY29tbWl0MicsIGZpbGVzKQorCisgICAgICAgIGZpbGVzID0gc2Vs Zi5zY20uY2hhbmdlZF9maWxlcygndHJ1bmteLi4nKSAgIyBnaXQgZGlmZiB0cnVua14uLkhFQUQK ICAgICAgICAgc2VsZi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDEnLCBmaWxlcykKICAgICAg ICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykKIAogICAgICAg ICAjIHdvcmtpbmcgY29weSAqc2hvdWxkKiBiZSBpbiB0aGUgbGlzdC4KLSAgICAgICAgZmlsZXMg PSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVuay4uLi4nKQorICAgICAgICAjIC4uLi4gaXMg YSBoYWNrIGZvciB3b3JraW5nIGNvcHkgY2hhbmdlcyB0byBiZSBpbmNsdWRlZAorICAgICAgICBm aWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoJ3RydW5rLi4uLicpICAjIGdpdCBkaWZmIHRy dW5rCisgICAgICAgIHNlbGYuYXNzZXJ0Tm90SW4oJ3Rlc3RfZmlsZV9jb21taXQxJywgZmlsZXMp CisgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpCisKKyAg ICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVua14uLi4uJykgICMgZ2l0 IGRpZmYgdHJ1bmteCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQxJywg ZmlsZXMpCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMp CiAK 256780 2015-07-14 11:19:16 -0700 2015-07-14 11:34:14 -0700 Patch bug-143967-20150714111810.patch text/plain 5370 dean_johnson U3VidmVyc2lvbiBSZXZpc2lvbjogMTg2NzY4CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5IGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2RldGVjdGlvbi5weQppbmRleCA4N2E3YTBkYzVi NGQ4ZDdjMmYyNmEyMjkwZTJlMjlhMjAyMzQ3YzZlLi44YzU5MDA1MTJiN2M3OGExM2RhMjIzMjM2 NTM2Njg4NWMyYjU2NTAyIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv Y29tbW9uL2NoZWNrb3V0L3NjbS9kZXRlY3Rpb24ucHkKQEAgLTYzLDE2ICs2MywxNiBAQCBjbGFz cyBTQ01EZXRlY3RvcihvYmplY3QpOgogICAgICAgICByZXR1cm4gc2NtX3N5c3RlbQogCiAgICAg ZGVmIGRldGVjdF9zY21fc3lzdGVtKHNlbGYsIHBhdGgsIHBhdGNoX2RpcmVjdG9yaWVzPU5vbmUp OgotICAgICAgICBhYnNvbHV0ZV9wYXRoID0gc2VsZi5fZmlsZXN5c3RlbS5hYnNwYXRoKHBhdGgp CisgICAgICAgIHJlYWxfcGF0aCA9IHNlbGYuX2ZpbGVzeXN0ZW0ucmVhbHBhdGgocGF0aCkKIAog ICAgICAgICBpZiBwYXRjaF9kaXJlY3RvcmllcyA9PSBbXToKICAgICAgICAgICAgIHBhdGNoX2Rp cmVjdG9yaWVzID0gTm9uZQogCi0gICAgICAgIGlmIFNWTi5pbl93b3JraW5nX2RpcmVjdG9yeShh YnNvbHV0ZV9wYXRoLCBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKToKLSAgICAgICAgICAgIHJl dHVybiBTVk4oY3dkPWFic29sdXRlX3BhdGgsIHBhdGNoX2RpcmVjdG9yaWVzPXBhdGNoX2RpcmVj dG9yaWVzLCBmaWxlc3lzdGVtPXNlbGYuX2ZpbGVzeXN0ZW0sIGV4ZWN1dGl2ZT1zZWxmLl9leGVj dXRpdmUpCisgICAgICAgIGlmIFNWTi5pbl93b3JraW5nX2RpcmVjdG9yeShyZWFsX3BhdGgsIGV4 ZWN1dGl2ZT1zZWxmLl9leGVjdXRpdmUpOgorICAgICAgICAgICAgcmV0dXJuIFNWTihjd2Q9cmVh bF9wYXRoLCBwYXRjaF9kaXJlY3Rvcmllcz1wYXRjaF9kaXJlY3RvcmllcywgZmlsZXN5c3RlbT1z ZWxmLl9maWxlc3lzdGVtLCBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKQogCi0gICAgICAgIGlm IEdpdC5pbl93b3JraW5nX2RpcmVjdG9yeShhYnNvbHV0ZV9wYXRoLCBleGVjdXRpdmU9c2VsZi5f ZXhlY3V0aXZlKToKLSAgICAgICAgICAgIHJldHVybiBHaXQoY3dkPWFic29sdXRlX3BhdGgsIHBh dGNoX2RpcmVjdG9yaWVzPXBhdGNoX2RpcmVjdG9yaWVzLCBmaWxlc3lzdGVtPXNlbGYuX2ZpbGVz eXN0ZW0sIGV4ZWN1dGl2ZT1zZWxmLl9leGVjdXRpdmUpCisgICAgICAgIGlmIEdpdC5pbl93b3Jr aW5nX2RpcmVjdG9yeShyZWFsX3BhdGgsIGV4ZWN1dGl2ZT1zZWxmLl9leGVjdXRpdmUpOgorICAg ICAgICAgICAgcmV0dXJuIEdpdChjd2Q9cmVhbF9wYXRoLCBwYXRjaF9kaXJlY3Rvcmllcz1wYXRj aF9kaXJlY3RvcmllcywgZmlsZXN5c3RlbT1zZWxmLl9maWxlc3lzdGVtLCBleGVjdXRpdmU9c2Vs Zi5fZXhlY3V0aXZlKQogCiAgICAgICAgIHJldHVybiBOb25lCiAKZGlmZiAtLWdpdCBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9naXQucHkgYi9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5CmluZGV4IGFhZDZlYWRiMjk2 MzBjNTc5MmZhMDE1MGJjODZmYmJlODc3OTFiZWYuLjdhYmI5YWFjMDBiZTZmOTFiOTU5NWRlNzQ5 N2E3NjJkMTJlYjAwZjAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2NoZWNrb3V0L3NjbS9naXQucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24v Y2hlY2tvdXQvc2NtL2dpdC5weQpAQCAtMjE2LDcgKzIxNiw3IEBAIGNsYXNzIEdpdChTQ00sIFNW TlJlcG9zaXRvcnkpOgogCiAgICAgZGVmIGNoYW5nZWRfZmlsZXMoc2VsZiwgZ2l0X2NvbW1pdD1O b25lKToKICAgICAgICAgIyBGSVhNRTogLS1kaWZmLWZpbHRlciBjb3VsZCBiZSB1c2VkIHRvIGF2 b2lkIHRoZSAiZXh0cmFjdF9maWxlbmFtZXMiIHN0ZXAuCi0gICAgICAgIHN0YXR1c19jb21tYW5k ID0gW3NlbGYuZXhlY3V0YWJsZV9uYW1lLCAnZGlmZicsICctcicsICctLW5hbWUtc3RhdHVzJywg Ii0tbm8tcmVuYW1lcyIsICItLW5vLWV4dC1kaWZmIiwgIi0tZnVsbC1pbmRleCIsIHNlbGYubWVy Z2VfYmFzZShnaXRfY29tbWl0KV0KKyAgICAgICAgc3RhdHVzX2NvbW1hbmQgPSBbc2VsZi5leGVj dXRhYmxlX25hbWUsICdkaWZmJywgJy1yJywgJy0tbmFtZS1zdGF0dXMnLCAiLS1uby1yZW5hbWVz IiwgIi0tbm8tZXh0LWRpZmYiLCAiLS1mdWxsLWluZGV4Iiwgc2VsZi5tZXJnZV9iYXNlKGdpdF9j b21taXQpLCAnLS0nXQogICAgICAgICBzdGF0dXNfY29tbWFuZC5leHRlbmQoc2VsZi5fcGF0Y2hf ZGlyZWN0b3JpZXMpCiAgICAgICAgICMgRklYTUU6IEknbSBub3Qgc3VyZSB3ZSdyZSByZXR1cm5p bmcgdGhlIHNhbWUgc2V0IG9mIGZpbGVzIHRoYXQgU1ZOLmNoYW5nZWRfZmlsZXMgaXMuCiAgICAg ICAgICMgQWRkZWQgKEEpLCBDb3BpZWQgKEMpLCBEZWxldGVkIChEKSwgTW9kaWZpZWQgKE0pLCBS ZW5hbWVkIChSKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hl Y2tvdXQvc2NtL3NjbV91bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2NoZWNrb3V0L3NjbS9zY21fdW5pdHRlc3QucHkKaW5kZXggZDc3MmQ3OWYwNTg4N2YwYTcxZGZj NGQ3Y2Q3YTQxODEwOGFmOTViNy4uNGI2NTgyY2I0ZTdmMWM4Y2Q3MmI5MTdjZjA2YmI5NDVlYzg3 MWY3MiAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQv c2NtL3NjbV91bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9j aGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5CkBAIC0xODUsNyArMTg1LDcgQEAgY2xhc3MgU1ZO VGVzdFJlcG9zaXRvcnkob2JqZWN0KToKICAgICAgICAgaWYgbm90IGNhY2hlZF9zdm5fcmVwb19w YXRoOgogICAgICAgICAgICAgY2FjaGVkX3N2bl9yZXBvX3BhdGggPSBjbHMuX3NldHVwX21vY2tf cmVwbygpCiAKLSAgICAgICAgdGVzdF9vYmplY3QudGVtcF9kaXJlY3RvcnkgPSB0ZW1wZmlsZS5t a2R0ZW1wKHN1ZmZpeD0ic3ZuX3Rlc3QiKQorICAgICAgICB0ZXN0X29iamVjdC50ZW1wX2RpcmVj dG9yeSA9IG9zLnBhdGgucmVhbHBhdGgodGVtcGZpbGUubWtkdGVtcChzdWZmaXg9InN2bl90ZXN0 IikpCiAgICAgICAgIHRlc3Rfb2JqZWN0LnN2bl9yZXBvX3BhdGggPSBvcy5wYXRoLmpvaW4odGVz dF9vYmplY3QudGVtcF9kaXJlY3RvcnksICJyZXBvIikKICAgICAgICAgdGVzdF9vYmplY3Quc3Zu X3JlcG9fdXJsID0gImZpbGU6Ly8lcyIgJSB0ZXN0X29iamVjdC5zdm5fcmVwb19wYXRoCiAgICAg ICAgIHRlc3Rfb2JqZWN0LnN2bl9jaGVja291dF9wYXRoID0gb3MucGF0aC5qb2luKHRlc3Rfb2Jq ZWN0LnRlbXBfZGlyZWN0b3J5LCAiY2hlY2tvdXQiKQpAQCAtMTAzNSw4ICsxMDM1LDkgQEAgY2xh c3MgR2l0U1ZOVGVzdChTQ01UZXN0KToKICAgICBkZWYgX3NldHVwX2dpdF9jaGVja291dChzZWxm KToKICAgICAgICAgc2VsZi5naXRfY2hlY2tvdXRfcGF0aCA9IHRlbXBmaWxlLm1rZHRlbXAoc3Vm Zml4PSJnaXRfdGVzdF9jaGVja291dCIpCiAgICAgICAgICMgLS1xdWlldCBkb2Vzbid0IG1ha2Ug Z2l0IHN2biBzaWxlbnQsIHNvIHdlIHVzZSBydW5fc2lsZW50IHRvIHJlZGlyZWN0IG91dHB1dAot ICAgICAgICBydW5fc2lsZW50KFsnZ2l0JywgJ3N2bicsICdjbG9uZScsICctVCcsICd0cnVuaycs IHNlbGYuc3ZuX3JlcG9fdXJsLCBzZWxmLmdpdF9jaGVja291dF9wYXRoXSkKKyAgICAgICAgcnVu X3NpbGVudChbJ2dpdCcsICdzdm4nLCAnY2xvbmUnLCAnLVQnLCAndHJ1bmsnLCAnLS1wcmVmaXgn LCAnJywgc2VsZi5zdm5fcmVwb191cmwsIHNlbGYuZ2l0X2NoZWNrb3V0X3BhdGhdKQogICAgICAg ICBvcy5jaGRpcihzZWxmLmdpdF9jaGVja291dF9wYXRoKQorICAgICAgICBydW5fc2lsZW50KFsn Z2l0JywgJ2JyYW5jaCcsICctbScsICd0cnVuayddKQogCiAgICAgZGVmIF90ZWFyX2Rvd25fZ2l0 X2NoZWNrb3V0KHNlbGYpOgogICAgICAgICAjIENoYW5nZSBiYWNrIHRvIGEgdmFsaWQgZGlyZWN0 b3J5IHNvIHRoYXQgbGF0ZXIgY2FsbHMgdG8gb3MuZ2V0Y3dkKCkgZG8gbm90IGZhaWwuCkBAIC0x NDA2LDEyICsxNDA3LDIxIEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6CiAgICAgICAgIHNl bGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmlsZXMpCiAKICAgICAgICAgIyB3b3Jr aW5nIGNvcHkgc2hvdWxkICpub3QqIGJlIGluIHRoZSBsaXN0LgotICAgICAgICBmaWxlcyA9IHNl bGYuc2NtLmNoYW5nZWRfZmlsZXMoJ3RydW5rLi4nKQorICAgICAgICBmaWxlcyA9IHNlbGYuc2Nt LmNoYW5nZWRfZmlsZXMoJ3RydW5rLi4nKSAgIyBnaXQgZGlmZiB0cnVuay4uSEVBRAorICAgICAg ICBzZWxmLmFzc2VydE5vdEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQorICAgICAgICBz ZWxmLmFzc2VydE5vdEluKCd0ZXN0X2ZpbGVfY29tbWl0MicsIGZpbGVzKQorCisgICAgICAgIGZp bGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygndHJ1bmteLi4nKSAgIyBnaXQgZGlmZiB0cnVu a14uLkhFQUQKICAgICAgICAgc2VsZi5hc3NlcnRJbigndGVzdF9maWxlX2NvbW1pdDEnLCBmaWxl cykKICAgICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlX2NvbW1pdDInLCBmaWxlcykK IAogICAgICAgICAjIHdvcmtpbmcgY29weSAqc2hvdWxkKiBiZSBpbiB0aGUgbGlzdC4KLSAgICAg ICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVuay4uLi4nKQorICAgICAgICAj IC4uLi4gaXMgYSBoYWNrIGZvciB3b3JraW5nIGNvcHkgY2hhbmdlcyB0byBiZSBpbmNsdWRlZAor ICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoJ3RydW5rLi4uLicpICAjIGdp dCBkaWZmIHRydW5rCisgICAgICAgIHNlbGYuYXNzZXJ0Tm90SW4oJ3Rlc3RfZmlsZV9jb21taXQx JywgZmlsZXMpCisgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQyJywgZmls ZXMpCisKKyAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVua14uLi4u JykgICMgZ2l0IGRpZmYgdHJ1bmteCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9j b21taXQxJywgZmlsZXMpCiAgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3RfZmlsZV9jb21taXQy JywgZmlsZXMpCiAK 256781 2015-07-14 11:34:18 -0700 2015-07-15 16:15:10 -0700 Patch bug-143967-20150714113312.patch text/plain 8524 dean_johnson U3VidmVyc2lvbiBSZXZpc2lvbjogMTg2NzY4CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZDBjOTc1YzUzNmY3ZDA0NjQzMmVkNTk4NTBmMmQxZmY5 ZmMzYzU0My4uOGQ3NTc4YTliMDViYTMyODEzYWVhOWZlMDJlN2NlNTYwYmFhODVjMCAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUw IEBACisyMDE1LTA3LTE0ICBEZWFuIEpvaG5zb24gIDxkZWFuX2pvaG5zb25AYXBwbGUuY29tPgor CisgICAgICAgIE1hbnkgdGVzdCBmYWlsdXJlcyBpbiBzY21fdW5pdHRlc3QucHkKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0Mzk2NworCisgICAgICAg IFJldmlld2VkIGJ5IERhbmllbCBCYXRlcy4gCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5OgorICAgICAgICAoU0NNRGV0ZWN0b3Iu ZGV0ZWN0X3NjbV9zeXN0ZW0pOiBQYXRocyB3aXRoIHN5bWxpbmtzIGFyZSBub3cgcmVzb2x2ZWQg dG8KKyAgICAgICAgYWJzb2x1dGUgY2Fub25pY2FsIGZpbGUgcGF0aHMuIFR3byBtdXR1YWxseSBl eGNsdXNpdmUgaXNzdWVzIGNhdXNlIHRoaXMKKyAgICAgICAgdG8gYmUgYSBwcm9ibGVtLgorICAg ICAgICAgICAgMSkgUHl0aG9uJ3Mgb3MucGF0aC5yZWxwYXRoKCkgZnVuY3Rpb24gZG9lcyBub3Qg cmV0dXJuIGNvcnJlY3QgcmVsYXRpdmUKKyAgICAgICAgICAgIHBhdGhzIGJldHdlZW4gdHdvIGZp bGVwYXRocyB0aGF0IHBvaW50IHRvIHRoZSBzYW1lIGZpbGUsIGlmIHN5bWxpbmtzIGFyZQorICAg ICAgICAgICAgaW52b2x2ZWQuCisgICAgICAgICAgICAgICAgT24gTWFjLCAvdG1wIHBvaW50cyB0 byAvcHJpdmF0ZS90bXAKKyAgICAgICAgICAgICAgICBleC4gb3MucGF0aC5yZWxwYXRoKCcvdG1w JywgJy9wcml2YXRlL3RtcCcpCisgICAgICAgICAgICAgICAgICAgIHJldHVybnMgJy4uLy4uL3Rt cCcKKyAgICAgICAgICAgIFdoYXQgd2Ugd2FudCBpcyBhY3R1YWxseSBqdXN0ICcuJworICAgICAg ICAgICAgMikgR2l0IGRvZXMgbm90IGFsbG93IGZpbGUgcGF0aHMgdG8gdHJhY2Ugb3V0c2lkZSBv ZgorICAgICAgICAgICAgdGhlIEdpdCByZXBvc2l0b3J5LiBUaGlzIG1lYW5zIHRoYXQgaWYgeW91 IGhhdmUgYSByZXBvc2l0b3J5IGluCisgICAgICAgICAgICAvdG1wIGFuZCB5b3UgcmVmZXIgdG8g dGhhdCByZXBvc2l0b3J5IHdoZW4gaW52b2tpbmcgYSBnaXQgY29tbWFuZCBhcworICAgICAgICAg ICAgLi4vdG1wLCBHaXQgd2lsbCBwcm9kdWNlIGVycm9ycyBhYm91dCB3b3JraW5nIG91dHNpZGUg b2YgdGhlIHJlcG9zaXRvcnkuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hl Y2tvdXQvc2NtL2dpdC5weTogT3ZlciB0aW1lIEdpdCBoYXMgY2hhbmdlZAorICAgICAgICBpdHMg ZGVmYXVsdCBiZWhhdmlvciBhbmQgc3VjaCwgbmVlZGVkIHRvIGJlIHVwZGF0ZWQuCisgICAgICAg IChHaXQuY2hhbmdlZF9maWxlcyk6ICctLScgd2FzIGFkZGVkIGludG8gdGhlIGNvbW1hbmQgc28g dGhhdCBwYXRjaF9kaXJlY3RvcmllcworICAgICAgICB3ZXJlIHRha2VuIGFzIHBvc2l0aW9uYWwg YXJndW1lbnRzLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3Nj bS9zY21fdW5pdHRlc3QucHk6IENoYW5nZWQgdGVzdHMgYW5kIHNldHVwIAorICAgICAgICBpbiB0 aGUgR2l0U1ZOVGVzdCBjbGFzcyB0byBtb3JlIGNsb3NlbHkgZW11bGF0ZSB0aGUgdmVyc2lvbiBv ZiBHaXQgdGhhdCB0aGUgdGVzdHMKKyAgICAgICAgYXNzdW1lZCBhIHN5c3RlbSBoYWQuIEFsc28g Zml4ZWQgYSBzbWFsbCBzaWRlLWVmZmVjdCBmcm9tIHRoZSBhYnNvbHV0ZSBjYW5vbmljYWwKKyAg ICAgICAgcGF0aCBmaXggaW4gU0NNRGV0ZWN0b3IuZGV0ZWN0X3NjbV9zeXN0ZW0KKyAgICAgICAg KFNWTlRlc3RSZXBvc2l0b3J5LnNldHVwKTogQSByZWxhdGl2ZSBmaWxlcGF0aCB3YXMgcHJldmlv dXNseSBwYXNzZWQgYXMgdGhlCisgICAgICAgIGNoZWNrb3V0IHJvb3QgdG8gU0NNRGV0ZWN0b3Iu ZGV0ZWN0X3NjbV9zeXN0ZW0sIGJ1dCBpcyBub3cgY2xlYW5lZCB0bworICAgICAgICBhbiBhYnNv bHV0ZSBjYW5vbmljYWwgcGF0aCBiZWZvcmUgYmVpbmcgcGFzc2VkIGluLiBUaGUgZmFpbGluZyB0 ZXN0CisgICAgICAgIHdhcyBhICJzYW5pdHkgY2hlY2siIHRoYXQgdGhlIHN2bi5jaGVja291dF9y b290IGFuZCBzY20uY2hlY2tvdXRfcm9vdAorICAgICAgICB3ZXJlIHRoZSBzYW1lLgorICAgICAg ICAoR2l0U1ZOVGVzdC5fc2V0dXBfZ2l0X2NoZWNrb3V0KToKKyAgICAgICAgICAgIDEpIEFkZGVk ICItLXByZWZpeCAnJyIgb3B0aW9uIHRvIGBnaXQgY2xvbmVgIHNpbmNlIEdpdCBjaGFuZ2VkIGl0 cyBkZWZhdWx0CisgICAgICAgICAgICBiZWhhdmlvciBpbiB2ZXJzaW9uIDIuMC4KKyAgICAgICAg ICAgIDIpIFRoZSBicmFuY2ggbWFzdGVyIHdhcyByZW5hbWVkIHRvIHRydW5rIHRvIG1vcmUgY2xv c2VseSBlbXVsYXRlIHdoYXQKKyAgICAgICAgICAgIHRlc3RzIGV4cGVjdGVkIHdoZW4gdGhleSB3 ZXJlIHdyaXR0ZW4uIAorICAgICAgICAoR2l0U1ZOVGVzdC50ZXN0X2NoYW5nZWRfZmlsZXNfbG9j YWxfcGx1c193b3JraW5nX2NvcHkpOiBUd28gb2YgdGhlIHRocmVlCisgICAgICAgIG9yaWdpbmFs IHRlc3RzIGZhaWxlZCBiZWNhdXNlIHRoZSB0ZXN0cyBleHBlY3RlZCB0aGUgdHJ1bmsgYnJhbmNo CisgICAgICAgIHRvIHByb2R1Y2UgaXRzIHBhcmVudCdzIGNvbW1pdCwgd2hlcmVhcyBHaXQgbWVy ZWx5IHByb3ZpZGVzIHRoZSBIRUFEIGNvbW1pdAorICAgICAgICBmb3IgYSBnaXZlbiBicmFuY2gg KHRydW5rIGluIHRoaXMgY2FzZSkuIEJhc2VkIG9uIG90aGVyIHRlc3RzIHdyaXR0ZW4KKyAgICAg ICAgaW4gdGhlIHNhbWUgY29tbWl0LCBpdCBhcHBlYXJzIHRoZXNlIHRlc3RzIHdlcmUgZmFpbGlu ZyBmcm9tIHRoZSBwb2ludCB0aGV5CisgICAgICAgIHdlcmUgd3JpdHRlbi4KKwogMjAxNS0wNy0x MCAgQnJlbnQgRnVsZ2hhbSAgPGJmdWxnaGFtQGFwcGxlLmNvbT4KIAogICAgICAgICBbTWFjXSBV bmFibGUgdG8gZGlzbWlzcyBjb250ZXh0IG1lbnUgZHVyaW5nIHRlc3QgcnVucwpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2RldGVjdGlvbi5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9kZXRlY3Rpb24u cHkKaW5kZXggODdhN2EwZGM1YjRkOGQ3YzJmMjZhMjI5MGUyZTI5YTIwMjM0N2M2ZS4uOGM1OTAw NTEyYjdjNzhhMTNkYTIyMzIzNjUzNjY4ODVjMmI1NjUwMiAxMDA2NDQKLS0tIGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2RldGVjdGlvbi5weQorKysgYi9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZGV0ZWN0aW9uLnB5CkBAIC02 MywxNiArNjMsMTYgQEAgY2xhc3MgU0NNRGV0ZWN0b3Iob2JqZWN0KToKICAgICAgICAgcmV0dXJu IHNjbV9zeXN0ZW0KIAogICAgIGRlZiBkZXRlY3Rfc2NtX3N5c3RlbShzZWxmLCBwYXRoLCBwYXRj aF9kaXJlY3Rvcmllcz1Ob25lKToKLSAgICAgICAgYWJzb2x1dGVfcGF0aCA9IHNlbGYuX2ZpbGVz eXN0ZW0uYWJzcGF0aChwYXRoKQorICAgICAgICByZWFsX3BhdGggPSBzZWxmLl9maWxlc3lzdGVt LnJlYWxwYXRoKHBhdGgpCiAKICAgICAgICAgaWYgcGF0Y2hfZGlyZWN0b3JpZXMgPT0gW106CiAg ICAgICAgICAgICBwYXRjaF9kaXJlY3RvcmllcyA9IE5vbmUKIAotICAgICAgICBpZiBTVk4uaW5f d29ya2luZ19kaXJlY3RvcnkoYWJzb2x1dGVfcGF0aCwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2 ZSk6Ci0gICAgICAgICAgICByZXR1cm4gU1ZOKGN3ZD1hYnNvbHV0ZV9wYXRoLCBwYXRjaF9kaXJl Y3Rvcmllcz1wYXRjaF9kaXJlY3RvcmllcywgZmlsZXN5c3RlbT1zZWxmLl9maWxlc3lzdGVtLCBl eGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKQorICAgICAgICBpZiBTVk4uaW5fd29ya2luZ19kaXJl Y3RvcnkocmVhbF9wYXRoLCBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKToKKyAgICAgICAgICAg IHJldHVybiBTVk4oY3dkPXJlYWxfcGF0aCwgcGF0Y2hfZGlyZWN0b3JpZXM9cGF0Y2hfZGlyZWN0 b3JpZXMsIGZpbGVzeXN0ZW09c2VsZi5fZmlsZXN5c3RlbSwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1 dGl2ZSkKIAotICAgICAgICBpZiBHaXQuaW5fd29ya2luZ19kaXJlY3RvcnkoYWJzb2x1dGVfcGF0 aCwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSk6Ci0gICAgICAgICAgICByZXR1cm4gR2l0KGN3 ZD1hYnNvbHV0ZV9wYXRoLCBwYXRjaF9kaXJlY3Rvcmllcz1wYXRjaF9kaXJlY3RvcmllcywgZmls ZXN5c3RlbT1zZWxmLl9maWxlc3lzdGVtLCBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKQorICAg ICAgICBpZiBHaXQuaW5fd29ya2luZ19kaXJlY3RvcnkocmVhbF9wYXRoLCBleGVjdXRpdmU9c2Vs Zi5fZXhlY3V0aXZlKToKKyAgICAgICAgICAgIHJldHVybiBHaXQoY3dkPXJlYWxfcGF0aCwgcGF0 Y2hfZGlyZWN0b3JpZXM9cGF0Y2hfZGlyZWN0b3JpZXMsIGZpbGVzeXN0ZW09c2VsZi5fZmlsZXN5 c3RlbSwgZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSkKIAogICAgICAgICByZXR1cm4gTm9uZQog CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20v Z2l0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5w eQppbmRleCBhYWQ2ZWFkYjI5NjMwYzU3OTJmYTAxNTBiYzg2ZmJiZTg3NzkxYmVmLi43YWJiOWFh YzAwYmU2ZjkxYjk1OTVkZTc0OTdhNzYyZDEyZWIwMGYwIDEwMDY0NAotLS0gYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5CisrKyBiL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9naXQucHkKQEAgLTIxNiw3ICsyMTYsNyBA QCBjbGFzcyBHaXQoU0NNLCBTVk5SZXBvc2l0b3J5KToKIAogICAgIGRlZiBjaGFuZ2VkX2ZpbGVz KHNlbGYsIGdpdF9jb21taXQ9Tm9uZSk6CiAgICAgICAgICMgRklYTUU6IC0tZGlmZi1maWx0ZXIg Y291bGQgYmUgdXNlZCB0byBhdm9pZCB0aGUgImV4dHJhY3RfZmlsZW5hbWVzIiBzdGVwLgotICAg ICAgICBzdGF0dXNfY29tbWFuZCA9IFtzZWxmLmV4ZWN1dGFibGVfbmFtZSwgJ2RpZmYnLCAnLXIn LCAnLS1uYW1lLXN0YXR1cycsICItLW5vLXJlbmFtZXMiLCAiLS1uby1leHQtZGlmZiIsICItLWZ1 bGwtaW5kZXgiLCBzZWxmLm1lcmdlX2Jhc2UoZ2l0X2NvbW1pdCldCisgICAgICAgIHN0YXR1c19j b21tYW5kID0gW3NlbGYuZXhlY3V0YWJsZV9uYW1lLCAnZGlmZicsICctcicsICctLW5hbWUtc3Rh dHVzJywgIi0tbm8tcmVuYW1lcyIsICItLW5vLWV4dC1kaWZmIiwgIi0tZnVsbC1pbmRleCIsIHNl bGYubWVyZ2VfYmFzZShnaXRfY29tbWl0KSwgJy0tJ10KICAgICAgICAgc3RhdHVzX2NvbW1hbmQu ZXh0ZW5kKHNlbGYuX3BhdGNoX2RpcmVjdG9yaWVzKQogICAgICAgICAjIEZJWE1FOiBJJ20gbm90 IHN1cmUgd2UncmUgcmV0dXJuaW5nIHRoZSBzYW1lIHNldCBvZiBmaWxlcyB0aGF0IFNWTi5jaGFu Z2VkX2ZpbGVzIGlzLgogICAgICAgICAjIEFkZGVkIChBKSwgQ29waWVkIChDKSwgRGVsZXRlZCAo RCksIE1vZGlmaWVkIChNKSwgUmVuYW1lZCAoUikKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9zY21fdW5pdHRlc3QucHkgYi9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vc2NtX3VuaXR0ZXN0LnB5CmluZGV4IGQ3 NzJkNzlmMDU4ODdmMGE3MWRmYzRkN2NkN2E0MTgxMDhhZjk1YjcuLjRiNjU4MmNiNGU3ZjFjOGNk NzJiOTE3Y2YwNmJiOTQ1ZWM4NzFmNzIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvY29tbW9uL2NoZWNrb3V0L3NjbS9zY21fdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL3NjbV91bml0dGVzdC5weQpAQCAtMTg1LDcg KzE4NSw3IEBAIGNsYXNzIFNWTlRlc3RSZXBvc2l0b3J5KG9iamVjdCk6CiAgICAgICAgIGlmIG5v dCBjYWNoZWRfc3ZuX3JlcG9fcGF0aDoKICAgICAgICAgICAgIGNhY2hlZF9zdm5fcmVwb19wYXRo ID0gY2xzLl9zZXR1cF9tb2NrX3JlcG8oKQogCi0gICAgICAgIHRlc3Rfb2JqZWN0LnRlbXBfZGly ZWN0b3J5ID0gdGVtcGZpbGUubWtkdGVtcChzdWZmaXg9InN2bl90ZXN0IikKKyAgICAgICAgdGVz dF9vYmplY3QudGVtcF9kaXJlY3RvcnkgPSBvcy5wYXRoLnJlYWxwYXRoKHRlbXBmaWxlLm1rZHRl bXAoc3VmZml4PSJzdm5fdGVzdCIpKQogICAgICAgICB0ZXN0X29iamVjdC5zdm5fcmVwb19wYXRo ID0gb3MucGF0aC5qb2luKHRlc3Rfb2JqZWN0LnRlbXBfZGlyZWN0b3J5LCAicmVwbyIpCiAgICAg ICAgIHRlc3Rfb2JqZWN0LnN2bl9yZXBvX3VybCA9ICJmaWxlOi8vJXMiICUgdGVzdF9vYmplY3Qu c3ZuX3JlcG9fcGF0aAogICAgICAgICB0ZXN0X29iamVjdC5zdm5fY2hlY2tvdXRfcGF0aCA9IG9z LnBhdGguam9pbih0ZXN0X29iamVjdC50ZW1wX2RpcmVjdG9yeSwgImNoZWNrb3V0IikKQEAgLTEw MzUsOCArMTAzNSw5IEBAIGNsYXNzIEdpdFNWTlRlc3QoU0NNVGVzdCk6CiAgICAgZGVmIF9zZXR1 cF9naXRfY2hlY2tvdXQoc2VsZik6CiAgICAgICAgIHNlbGYuZ2l0X2NoZWNrb3V0X3BhdGggPSB0 ZW1wZmlsZS5ta2R0ZW1wKHN1ZmZpeD0iZ2l0X3Rlc3RfY2hlY2tvdXQiKQogICAgICAgICAjIC0t cXVpZXQgZG9lc24ndCBtYWtlIGdpdCBzdm4gc2lsZW50LCBzbyB3ZSB1c2UgcnVuX3NpbGVudCB0 byByZWRpcmVjdCBvdXRwdXQKLSAgICAgICAgcnVuX3NpbGVudChbJ2dpdCcsICdzdm4nLCAnY2xv bmUnLCAnLVQnLCAndHJ1bmsnLCBzZWxmLnN2bl9yZXBvX3VybCwgc2VsZi5naXRfY2hlY2tvdXRf cGF0aF0pCisgICAgICAgIHJ1bl9zaWxlbnQoWydnaXQnLCAnc3ZuJywgJ2Nsb25lJywgJy1UJywg J3RydW5rJywgJy0tcHJlZml4JywgJycsIHNlbGYuc3ZuX3JlcG9fdXJsLCBzZWxmLmdpdF9jaGVj a291dF9wYXRoXSkKICAgICAgICAgb3MuY2hkaXIoc2VsZi5naXRfY2hlY2tvdXRfcGF0aCkKKyAg ICAgICAgcnVuX3NpbGVudChbJ2dpdCcsICdicmFuY2gnLCAnLW0nLCAndHJ1bmsnXSkKIAogICAg IGRlZiBfdGVhcl9kb3duX2dpdF9jaGVja291dChzZWxmKToKICAgICAgICAgIyBDaGFuZ2UgYmFj ayB0byBhIHZhbGlkIGRpcmVjdG9yeSBzbyB0aGF0IGxhdGVyIGNhbGxzIHRvIG9zLmdldGN3ZCgp IGRvIG5vdCBmYWlsLgpAQCAtMTQwNiwxMiArMTQwNywyMSBAQCBjbGFzcyBHaXRTVk5UZXN0KFND TVRlc3QpOgogICAgICAgICBzZWxmLmFzc2VydEluKCd0ZXN0X2ZpbGVfY29tbWl0MicsIGZpbGVz KQogCiAgICAgICAgICMgd29ya2luZyBjb3B5IHNob3VsZCAqbm90KiBiZSBpbiB0aGUgbGlzdC4K LSAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVuay4uJykKKyAgICAg ICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVzKCd0cnVuay4uJykgICMgZ2l0IGRpZmYg dHJ1bmsuLkhFQUQKKyAgICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlX2NvbW1pdDEn LCBmaWxlcykKKyAgICAgICAgc2VsZi5hc3NlcnROb3RJbigndGVzdF9maWxlX2NvbW1pdDInLCBm aWxlcykKKworICAgICAgICBmaWxlcyA9IHNlbGYuc2NtLmNoYW5nZWRfZmlsZXMoJ3RydW5rXi4u JykgICMgZ2l0IGRpZmYgdHJ1bmteLi5IRUFECiAgICAgICAgIHNlbGYuYXNzZXJ0SW4oJ3Rlc3Rf ZmlsZV9jb21taXQxJywgZmlsZXMpCiAgICAgICAgIHNlbGYuYXNzZXJ0Tm90SW4oJ3Rlc3RfZmls ZV9jb21taXQyJywgZmlsZXMpCiAKICAgICAgICAgIyB3b3JraW5nIGNvcHkgKnNob3VsZCogYmUg aW4gdGhlIGxpc3QuCi0gICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdlZF9maWxlcygndHJ1 bmsuLi4uJykKKyAgICAgICAgIyAuLi4uIGlzIGEgaGFjayBmb3Igd29ya2luZyBjb3B5IGNoYW5n ZXMgdG8gYmUgaW5jbHVkZWQKKyAgICAgICAgZmlsZXMgPSBzZWxmLnNjbS5jaGFuZ2VkX2ZpbGVz KCd0cnVuay4uLi4nKSAgIyBnaXQgZGlmZiB0cnVuaworICAgICAgICBzZWxmLmFzc2VydE5vdElu KCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQorICAgICAgICBzZWxmLmFzc2VydEluKCd0ZXN0 X2ZpbGVfY29tbWl0MicsIGZpbGVzKQorCisgICAgICAgIGZpbGVzID0gc2VsZi5zY20uY2hhbmdl ZF9maWxlcygndHJ1bmteLi4uLicpICAjIGdpdCBkaWZmIHRydW5rXgogICAgICAgICBzZWxmLmFz c2VydEluKCd0ZXN0X2ZpbGVfY29tbWl0MScsIGZpbGVzKQogICAgICAgICBzZWxmLmFzc2VydElu KCd0ZXN0X2ZpbGVfY29tbWl0MicsIGZpbGVzKQogCg==