42336 2010-07-14 21:48:32 -0700 Add script to synchronize WebKit and Khronos WebGL tests 2010-09-16 14:44:43 -0700 1 1 1 Unclassified WebKit WebGL 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 42185 1 kbr enne abarth cmarrin commit-queue dglazkov dpranke enne eric fishd japhet oliver tony zmo oldest_to_newest 251669 0 kbr 2010-07-14 21:48:32 -0700 The synchronization of WebGL tests in the Khronos repository which originated in the WebKit repository is a mechanical process, and should be automated with a script. 251671 1 61608 kbr 2010-07-14 21:56:13 -0700 Created attachment 61608 Patch From the ChangeLog: Wrote script to automate the process of copying WebGL tests which originated in the WebKit repository from a local checkout of the Khronos repository. Verified manually with a dry run of the script that the desired results will be achieved. The script will be run, and its results and rebaseline results checked in, in a following bug. Note that this script is being added to fast/canvas/webgl/ rather than WebKitTools/Scripts to keep it co-located with the files it affects, and the directory in which it must be run. 251687 2 61608 fishd 2010-07-14 23:08:36 -0700 Comment on attachment 61608 Patch Scripts are ordinarily placed under the WebKitTools/Scripts directory. Is there precedent for scripts like this (that help to update tests) living under LayoutTests? 251959 3 kbr 2010-07-15 10:05:37 -0700 (In reply to comment #2) > (From update of attachment 61608 [details]) > Scripts are ordinarily placed under the WebKitTools/Scripts directory. Is there > precedent for scripts like this (that help to update tests) living under LayoutTests? I don't think there is a precedent, but as I mentioned in the ChangeLog, it will be confusing to put this script in WebKitTools/Scripts for two reasons. The first is that it is intended to affect files in the LayoutTests/fast/canvas/webgl/ directory, and the second is that as written it needs to be run from that directory. I think that the script is likely to be lost or forgotten if it isn't placed alongside the tests. 251988 4 61608 abarth 2010-07-15 10:54:36 -0700 Comment on attachment 61608 Patch Scripts need to go in WebKitTools/Scripts. Also, we prefer Perl or Python to bash. 251998 5 abarth 2010-07-15 11:14:53 -0700 I chatted with Kenneth. Ideally, this business logic would be integrated with webkitpy so we can gain the network effects of the rest of the infrastructure. For example, 1) it could use the scm module to add new tests working copy, 2) it could generate patches and upload them to bugs.webkit.org, 3) we could write a bot that synced the tests automatically and filed bugs whenever they were out of sync. I'm not saying that we should do all those things right now, but rather that those things become easy if this script isn't an island. We also taked about testing. In general, I'd rather we didn't accept new scripts that don't have testing, or (at a minimum) are designed in a way that can be tested. Without tests, folks won't be able to improve the script because they'll be afraid of breaking it. 252002 6 kbr 2010-07-15 11:18:20 -0700 I'm removing this bug as a blocker for 42185. I need to get the Khronos and WebKit WebGL tests synchronized today so my colleague can land his outstanding patches before going on vacation. I'll work more on this script in the future. 273969 7 66506 enne 2010-09-03 09:09:01 -0700 Created attachment 66506 Patch 274165 8 66506 kbr 2010-09-03 14:06:02 -0700 Comment on attachment 66506 Patch Thank you very much for picking this up. It looks like you have some git history encapsulated in this patch which causes WebKitTools/Scripts/webkitpy/layout_tests/update-webgl-conformance-tests.py to be deleted and then added. Could you please clean up this history and regenerate the patch? r- because of the need for cleanup. Couple of comments below. > diff --git a/WebKitTools/ChangeLog b/WebKitTools/ChangeLog > index b4797d02797797bf9acbe68c89b52347283e65f6..00e2dfd7bd42638a32b595f70094fc2ef0788690 100644 > --- a/WebKitTools/ChangeLog > +++ b/WebKitTools/ChangeLog > @@ -1,3 +1,14 @@ > +2010-09-02 Adrienne Walker <enne@google.com> > + > + Reviewed by NOBODY (OOPS!). > + > + Add script to synchronize WebKit and Khronos WebGL tests > + https://bugs.webkit.org/show_bug.cgi?id=42336 > + > + * Scripts/update-webgl-conformance-tests: Added. > + * Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py: Added. > + * Scripts/webkitpy/layout_tests/update_webgl_conformance_tests_unittest.py: Added. > + > 2010-09-01 Gabor Rapcsanyi <rgabor@inf.u-szeged.hu> > > Reviewed by Antonio Gomes. > diff --git a/WebKitTools/Scripts/update-webgl-conformance-tests b/WebKitTools/Scripts/update-webgl-conformance-tests > new file mode 100755 > index 0000000000000000000000000000000000000000..847dec79288e16b5f84c0875ad0f2f44d78f1bcd > --- /dev/null > +++ b/WebKitTools/Scripts/update-webgl-conformance-tests > @@ -0,0 +1,41 @@ > +#!/usr/bin/env python > +# Copyright (C) 2010 Google Inc. All rights reserved. > +# > +# Redistribution and use in source and binary forms, with or without > +# modification, are permitted provided that the following conditions are > +# met: > +# > +# * Redistributions of source code must retain the above copyright > +# notice, this list of conditions and the following disclaimer. > +# * Redistributions in binary form must reproduce the above > +# copyright notice, this list of conditions and the following disclaimer > +# in the documentation and/or other materials provided with the > +# distribution. > +# * Neither the name of Google Inc. nor the names of its > +# contributors may be used to endorse or promote products derived from > +# this software without specific prior written permission. > +# > +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR > +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT > +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, > +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT > +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, > +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY > +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE > +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + > +"""Wrapper around webkitpy/layout_tests/update-webgl-conformance-tests.py""" > +import os > +import sys > + > +scripts_directory = os.path.dirname(os.path.abspath(sys.argv[0])) > +webkitpy_directory = os.path.join(scripts_directory, "webkitpy") > +sys.path.append(os.path.join(webkitpy_directory, "layout_tests")) > + > +import update_webgl_conformance_tests > + > +if __name__ == '__main__': > + update_webgl_conformance_tests.main() > diff --git a/WebKitTools/Scripts/webkitpy/layout_tests/update-webgl-conformance-tests.py b/WebKitTools/Scripts/webkitpy/layout_tests/update-webgl-conformance-tests.py > deleted file mode 100755 > index e03dbc91a8d03954bb354392fde47dbbf9d2ea8e..0000000000000000000000000000000000000000 > --- a/WebKitTools/Scripts/webkitpy/layout_tests/update-webgl-conformance-tests.py > +++ /dev/null > @@ -1,112 +0,0 @@ > -#!/usr/bin/env python > - > -# Copyright (C) 2010 Google Inc. All rights reserved. > -# > -# Redistribution and use in source and binary forms, with or without > -# modification, are permitted provided that the following conditions > -# are met: > -# 1. Redistributions of source code must retain the above copyright > -# notice, this list of conditions and the following disclaimer. > -# 2. Redistributions in binary form must reproduce the above copyright > -# notice, this list of conditions and the following disclaimer in the > -# documentation and/or other materials provided with the distribution. > -# > -# THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY > -# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE > -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR > -# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR > -# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, > -# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, > -# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR > -# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY > -# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE > -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > - > -import glob > -import os > -import re > -import sys > -from webkitpy.common.system.deprecated_logging import error, log > -from webkitpy.common.checkout import scm > - > -def usage(): > - print os.path.basename(sys.argv[0]) + " (input file or directory) (optional output directory)" > - > -def removeFirstLineComment(text): > - return re.compile(r'^<!--.*?-->\s*', re.DOTALL).sub('', text) > - > -def translateIncludes(text): > - # Mapping of single filename to relative path under WebKit root. > - # Assumption: these filenames are globally unique. > - includeMapping = { > - "js-test-style.css" : "../../js/resources", > - "js-test-pre.js" : "../../js/resources", > - "js-test-post.js" : "../../js/resources", > - "desktop-gl-constants.js" : "resources", > - }; > - > - for filename, path in includeMapping.items(): > - text = re.sub(r'(?:[^"\'= ]*/)?' + re.escape(filename), os.path.join(path, filename), text) > - > - return text > - > -def translateKhronosTest(text): > - """ > - This method translates the contents of a Khronos test to a WebKit test. > - """ > - > - translateFuncs = [ > - removeFirstLineComment, > - translateIncludes, > - ] > - > - for f in translateFuncs: > - text = f(text) > - > - return text > - > -def updateFile(inputFileName, outputDir): > - # check inputFileName exists > - # check outputDir exists > - outputFileName = os.path.join(outputDir, os.path.basename(inputFileName)) > - > - with open(inputFileName, 'r') as inputFile: > - with open(outputFileName, 'w') as outputFile: > - outputFile.write(translateKhronosTest(inputFile.read())) > - > -def updateDirectory(inputDir, outputDir): > - for fileName in glob.glob(os.path.join(inputDir, '*.html')): > - updateFile(os.path.join(inputDir, fileName), outputDir) > - > -def defaultOutputDir(): > - current_scm = scm.detect_scm_system(os.path.dirname(sys.argv[0])) > - if (not current_scm): > - error("No SCM detected. Please specify an explict output dir."); > - root_dir = current_scm.checkout_root > - if (not root_dir): > - error("Couldn't find SCM root. Please specify an explicit output dir."); > - return os.path.join(root_dir, "LayoutTests/fast/canvas/webgl") > - > -def main(argv): > - if "--help" in argv or len(argv) == 0: > - usage(); > - sys.exit(0) > - inputName = argv[0] > - if len(argv) == 1: > - outputDir = defaultOutputDir() > - else: > - outputDir = argv[1] > - > - if (os.path.isfile(inputName)): > - updateFile(inputName, outputDir) > - elif (os.path.isdir(inputName)): > - updateDirectory(inputName, outputDir) > - else: > - error("'" + inputName + "' is not a directory or a file."); > - sys.exit(2) > - > - sys.exit(0) > - > -if __name__ == "__main__": > - main(sys.argv[1:]) > diff --git a/WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py b/WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py > new file mode 100755 > index 0000000000000000000000000000000000000000..ecf2b67f0e1158243df9aa9114227773ef453681 > --- /dev/null > +++ b/WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py > @@ -0,0 +1,158 @@ > +#!/usr/bin/env python > + > +# Copyright (C) 2010 Google Inc. All rights reserved. > +# > +# Redistribution and use in source and binary forms, with or without > +# modification, are permitted provided that the following conditions > +# are met: > +# 1. Redistributions of source code must retain the above copyright > +# notice, this list of conditions and the following disclaimer. > +# 2. Redistributions in binary form must reproduce the above copyright > +# notice, this list of conditions and the following disclaimer in the > +# documentation and/or other materials provided with the distribution. > +# > +# THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY > +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE > +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR > +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR > +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, > +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, > +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR > +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY > +# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE > +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + > +import glob > +import logging > +import optparse > +import os > +import re > +import sys > +import webkitpy.common.checkout.scm as scm > + > +_log = logging.getLogger("webkitpy.layout_tests." > + "update-webgl-conformance-tests") > + > + > +def remove_first_line_comment(text): > + return re.compile(r'^<!--.*?-->\s*', re.DOTALL).sub('', text) How does this guarantee that it only matches on the first line of the input, or not at all? Not all of the conformance tests have the copyright header we're trying to remove with this regexp, and we don't want to delete comments in the middle of the tests. > + > + > +def translate_includes(text): > + # Mapping of single filename to relative path under WebKit root. > + # Assumption: these filenames are globally unique. > + include_mapping = { > + "js-test-style.css": "../../js/resources", > + "js-test-pre.js": "../../js/resources", > + "js-test-post.js": "../../js/resources", > + "desktop-gl-constants.js": "resources", > + } > + > + for filename, path in include_mapping.items(): > + search = r'(?:[^"\'= ]*/)?' + re.escape(filename) Why are '=' and ' ' included in the complement of the character set here? Would it be simpler to just hardcode the full source and destination paths in the include_mapping? > + replace = os.path.join(path, filename) > + text = re.sub(search, replace, text) > + > + return text > + > + > +def translate_khronos_test(text): > + """ > + This method translates the contents of a Khronos test to a WebKit test. > + """ > + > + translateFuncs = [ > + remove_first_line_comment, > + translate_includes, > + ] > + > + for f in translateFuncs: > + text = f(text) > + > + return text > + > + > +def update_file(in_filename, out_dir): > + # check in_filename exists > + # check out_dir exists > + out_filename = os.path.join(out_dir, os.path.basename(in_filename)) > + > + _log.debug("Processing " + in_filename) > + with open(in_filename, 'r') as in_file: > + with open(out_filename, 'w') as out_file: > + out_file.write(translate_khronos_test(in_file.read())) > + > + > +def update_directory(in_dir, out_dir): > + for filename in glob.glob(os.path.join(in_dir, '*.html')): > + update_file(os.path.join(in_dir, filename), out_dir) > + > + > +def default_out_dir(): > + current_scm = scm.detect_scm_system(os.path.dirname(sys.argv[0])) > + if (not current_scm): > + return os.getcwd() > + root_dir = current_scm.checkout_root > + if (not root_dir): > + return os.getcwd() > + out_dir = os.path.join(root_dir, "LayoutTests/fast/canvas/webgl") > + if (os.path.isdir(out_dir)): > + return out_dir > + else: > + return os.getcwd() > + > + > +def configure_logging(options): > + """Configures the logging system.""" > + log_fmt = '%(levelname)s: %(message)s' > + log_datefmt = '%y%m%d %H:%M:%S' > + log_level = logging.INFO > + if options.verbose: > + log_fmt = ('%(asctime)s %(filename)s:%(lineno)-4d %(levelname)s ' > + '%(message)s') > + log_level = logging.DEBUG > + logging.basicConfig(level=log_level, format=log_fmt, > + datefmt=log_datefmt) > + > + > +def get_option_parser(): > + usage = "usage: %prog [options] (input file or directory)" > + option_parser = optparse.OptionParser(usage=usage) > + option_parser.add_option('-v', '--verbose', > + action='store_true', > + default=False, > + help='include debug-level logging') > + option_parser.add_option('-o', '--output', > + action='store', > + type='string', > + default=default_out_dir(), > + metavar='DIR', > + help='specify an output directory to place files ' > + 'in [default: %default]') > + return option_parser > + > + > +def main(): > + option_parser = get_option_parser() > + (options, args) = option_parser.parse_args() > + configure_logging(options) > + > + if (len(args) == 0): > + _log.error("Must specify an input directory or filename.") > + option_parser.print_help() > + sys.exit(1) > + > + in_name = args[0] > + if (os.path.isfile(in_name)): > + update_file(in_name, options.output) > + elif (os.path.isdir(in_name)): > + update_directory(in_name, options.output) > + else: > + _log.error("'" + in_name + "' is not a directory or a file.") > + sys.exit(2) > + > + sys.exit(0) > + > +if __name__ == "__main__": > + main() > diff --git a/WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests_unittest.py b/WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests_unittest.py > new file mode 100644 > index 0000000000000000000000000000000000000000..786c60325794d2dad34890338bc87f6010fe0fe5 > --- /dev/null > +++ b/WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests_unittest.py > @@ -0,0 +1,104 @@ > +#!/usr/bin/python > +# Copyright (C) 2010 Google Inc. All rights reserved. > +# > +# Redistribution and use in source and binary forms, with or without > +# modification, are permitted provided that the following conditions are > +# met: > +# > +# * Redistributions of source code must retain the above copyright > +# notice, this list of conditions and the following disclaimer. > +# * Redistributions in binary form must reproduce the above > +# copyright notice, this list of conditions and the following disclaimer > +# in the documentation and/or other materials provided with the > +# distribution. > +# * Neither the name of Google Inc. nor the names of its > +# contributors may be used to endorse or promote products derived from > +# this software without specific prior written permission. > +# > +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR > +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT > +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, > +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT > +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, > +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY > +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE > +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + > +"""Unit tests for update_webgl_conformance_tests.""" > + > +import unittest > +from webkitpy.layout_tests import update_webgl_conformance_tests as webgl > + > + > +def construct_script(name): > + return "<script src=\"" + name + "\"></script>\n" > + > + > +def construct_style(name): > + return "<link rel=\"stylesheet\" href=\"" + name + "\">" > + > + > +class TestTranslation(unittest.TestCase): > + def assert_unchanged(self, text): > + self.assertEqual(text, webgl.translate_khronos_test(text)) > + > + def assert_translate(self, input, output): > + self.assertEqual(output, webgl.translate_khronos_test(input)) > + > + def test_simple_unchanged(self): > + self.assert_unchanged("") > + self.assert_unchanged("<html></html>") > + > + def test_header_strip(self): > + single_line_header = "<!-- single line header. -->" > + multi_line_header = """<!-- this is a multi-line > + header. it should all be removed too. > + -->""" > + text = "<html></html>" > + self.assert_translate(single_line_header, "") > + self.assert_translate(single_line_header + text, text) > + self.assert_translate(multi_line_header + text, text) > + > + def test_include_rewriting(self): > + # Mappings to None are unchanged > + styles = { > + "../resources/js-test-style.css": "../../js/resources/js-test-style.css", > + "fail.css": None, > + "resources/stylesheet.css": None, > + "../resources/style.css": None, > + } > + scripts = { > + "../resources/js-test-pre.js": "../../js/resources/js-test-pre.js", > + "../resources/js-test-post.js": "../../js/resources/js-test-post.js", > + "../resources/desktop-gl-constants.js": "resources/desktop-gl-constants.js", > + > + "resources/shadow-offset.js": None, > + "../resources/js-test-post-async.js": None, > + } > + > + input_text = "" > + output_text = "" > + for input, output in styles.items(): > + input_text += construct_style(input) > + if (output): > + output_text += construct_style(output) > + else: > + output_text += construct_style(input) > + for input, output in scripts.items(): > + input_text += construct_script(input) > + if (output): > + output_text += construct_script(output) > + else: > + output_text += construct_script(input) > + > + head = '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">\n<html>\n<head>\n' > + foot = '</head>\n<body>\n</body>\n</html>' > + input_text = head + input_text + foot > + output_text = head + output_text + foot > + self.assert_translate(input_text, output_text) > + > +if __name__ == '__main__': > + unittest.main() 274188 9 enne 2010-09-03 14:43:49 -0700 (In reply to comment #8) > (From update of attachment 66506 [details]) > Thank you very much for picking this up. It looks like you have some git history encapsulated in this patch which causes WebKitTools/Scripts/webkitpy/layout_tests/update-webgl-conformance-tests.py to be deleted and then added. Could you please clean up this history and regenerate the patch? r- because of the need for cleanup. Couple of comments below. Odd. That an unexpected result from creating and renaming a file. I can fix it though. > > +def remove_first_line_comment(text): > > + return re.compile(r'^<!--.*?-->\s*', re.DOTALL).sub('', text) > > How does this guarantee that it only matches on the first line of the input, or not at all? Not all of the conformance tests have the copyright header we're trying to remove with this regexp, and we don't want to delete comments in the middle of the tests. I'll add a test to demonstrate this explicitly, but the '^' means the start of the string rather than the start of a line when you're using the DOTALL option. > > +def translate_includes(text): > > + # Mapping of single filename to relative path under WebKit root. > > + # Assumption: these filenames are globally unique. > > + include_mapping = { > > + "js-test-style.css": "../../js/resources", > > + "js-test-pre.js": "../../js/resources", > > + "js-test-post.js": "../../js/resources", > > + "desktop-gl-constants.js": "resources", > > + } > > + > > + for filename, path in include_mapping.items(): > > + search = r'(?:[^"\'= ]*/)?' + re.escape(filename) > > Why are '=' and ' ' included in the complement of the character set here? '=' and ' ' were just to catch nonsense like "<script src = foo.js>" which is bad form but still accepted. > Would it be simpler to just hardcode the full source and destination paths in the include_mapping? I figured this was equally simple but additionally more robust to files moving around in the Khronos repository in the future. 274196 10 enne 2010-09-03 14:51:42 -0700 (In reply to comment #9) > (In reply to comment #8) > > (From update of attachment 66506 [details] [details]) > > > +def remove_first_line_comment(text): > > > + return re.compile(r'^<!--.*?-->\s*', re.DOTALL).sub('', text) > > > > How does this guarantee that it only matches on the first line of the input, or not at all? Not all of the conformance tests have the copyright header we're trying to remove with this regexp, and we don't want to delete comments in the middle of the tests. > > I'll add a test to demonstrate this explicitly, but the '^' means the start of the string rather than the start of a line when you're using the DOTALL option. This still works as expected, but ignore my incorrect statement about re.DOTALL. Except when using re.M, '^' means the start of the string. In this case, it's the beginning of the file because the string contains the entire file. 274199 11 66550 enne 2010-09-03 14:56:00 -0700 Created attachment 66550 Patch 274222 12 66550 kbr 2010-09-03 15:35:33 -0700 Comment on attachment 66550 Patch This looks great. Your unit tests are awesome. Thanks again for picking this up. 274239 13 66550 commit-queue 2010-09-03 16:05:05 -0700 Comment on attachment 66550 Patch Rejecting patch 66550 from commit-queue. enne@google.com does not have committer permissions according to http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/webkitpy/common/config/committers.py. - If you do not have committer rights please read http://webkit.org/coding/contributing.html for instructions on how to use bugzilla flags. - If you have committer rights please correct the error in WebKitTools/Scripts/webkitpy/common/config/committers.py by adding yourself to the file (no review needed). The commit-queue restarts itself every 2 hours. After restart the commit-queue will correctly respect your committer rights. 274305 14 66550 commit-queue 2010-09-03 18:04:30 -0700 Comment on attachment 66550 Patch Rejecting patch 66550 from commit-queue. Failed to run "['WebKitTools/Scripts/test-webkitpy']" exit_code: 1 Last 500 characters of output: romName module = __import__('.'.join(parts_copy)) File "/Users/eseidel/Projects/CommitQueue/WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests_unittest.py", line 33, in <module> from webkitpy.layout_tests import update_webgl_conformance_tests as webgl File "/Users/eseidel/Projects/CommitQueue/WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py", line 82 with open(in_filename, 'r') as in_file: ^ SyntaxError: invalid syntax Full output: http://queues.webkit.org/results/3944104 275102 15 66732 enne 2010-09-07 09:55:38 -0700 Created attachment 66732 Patch 275103 16 enne 2010-09-07 09:57:17 -0700 (In reply to comment #15) > Created an attachment (id=66732) [details] > Patch This is identical to the previous patch except that I imported the with statement from the __future__. I suspect that's the cause of the above problem. 275112 17 66732 eric 2010-09-07 10:08:10 -0700 Comment on attachment 66732 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=66732&action=prettypatch Seems like your addition to layout_tests should be a class, not just a bunch of free functions. I'm also not sure why this belongs in layout_tests (then again layout_tests is already a mess). In general this looks fine. Just needs some cleanup. > WebKitTools/Scripts/update-webgl-conformance-tests:36 > +sys.path.append(os.path.join(webkitpy_directory, "layout_tests")) No no no. This is evil and wrong. The new-run-webkit-tests hack like this is also wrong. NRWT was attempting to make it possible to run run_chromium_webkit_tests.py directly from chromium w/o depending on python 2.5. That hack should be removed these days, and not repeated here. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:143 > + if (len(args) == 0): no parens. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests_unittest.py:92 > + if (output): > + output_text += construct_style(output) > + else: > + output_text += construct_style(input) This seems like an overly verbose way of writing this ternary. 275114 18 eric 2010-09-07 10:10:54 -0700 My comments ended out of order a bit (due to my confusion with the new review tool). End result: your patch looks OK, but I'd like to see an updated one with a few of the above mentioned cleanups. The overarching goal with our python in WebKit is to design for re-use. Not to just be a pile of scripts (like our perl is/was). So classes, and testing, and good factoring of logic into the various common re-use places are important. Thanks for the patch! 275356 19 66732 eric 2010-09-07 15:52:01 -0700 Comment on attachment 66732 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=66732&action=prettypatch About making it a class, it just helps separate the logic. You make it SyncKronosTests(object) and then instantiate it in your __main__ and call SyncKronosTests(object).main(args), etc. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:96 > + if (not current_scm): no parens. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:99 > + if (not root_dir): again > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:102 > + if (os.path.isdir(out_dir)): again > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:121 > +def get_option_parser(): I'm pretty sure that pep8 is anti-"get" prefixes. WebKit C++ code certainly is. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:149 > + if (os.path.isfile(in_name)): no parens. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:151 > + elif (os.path.isdir(in_name)): I think we have a python lint tool somewhere to catch this stuff. I'm surprised check-webkit-style didn't catch it, it has a pep8 checker iirc. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:154 > + _log.error("'" + in_name + "' is not a directory or a file.") I would have used %s. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:157 > + sys.exit(0) You could just "return 0" from main if you set up your caller to exit with main's return. I think that's slighly more common, but I coudl be wrong. 275380 20 66785 enne 2010-09-07 16:25:20 -0700 Created attachment 66785 Patch 279859 21 66785 kbr 2010-09-15 17:54:45 -0700 Comment on attachment 66785 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=66785&action=prettypatch I think this basically looks fine and since there haven't been any updates on the bug from the original reviewer for a week I'm marking it r+ since we need this script to incorporate more layout tests from the Khronos site. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:151 > + elif (os.path.isdir(in_name)): According to the previous review this shouldn't have parentheses. 279866 22 66785 eric 2010-09-15 18:02:40 -0700 Comment on attachment 66785 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=66785&action=prettypatch > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests.py:105 > + else: > + return os.getcwd() WebKit C++ code avoids else after return. Python probably should too. > WebKitTools/Scripts/webkitpy/layout_tests/update_webgl_conformance_tests_unittest.py:100 > + self.assert_translate(input_text, output_text) > + > +if __name__ == '__main__': I think pep8 requires 2 lines here. Looks fine. Sorry I forgot about you. 279908 23 67761 enne 2010-09-15 19:32:56 -0700 Created attachment 67761 Patch 280132 24 enne 2010-09-16 09:13:32 -0700 (In reply to comment #23) > Created an attachment (id=67761) [details] > Patch I've fixed the style issues listed above. 280178 25 67761 kbr 2010-09-16 10:16:33 -0700 Comment on attachment 67761 Patch Verified that the style issues mentioned above are fixed. r=me 280288 26 67761 commit-queue 2010-09-16 12:46:51 -0700 Comment on attachment 67761 Patch Rejecting patch 67761 from commit-queue. Failed to run "['WebKitTools/Scripts/update-webkit']" exit_code: 2 Last 500 characters of output: MLInputElement.h M WebCore/rendering/RenderFileUploadControl.cpp M WebCore/css/CSSStyleSelector.cpp r67653 = a6cb255b7102ae73f9141e4c7b36ead6f20c8af5 (refs/remotes/trunk) First, rewinding head to replay your work on top of it... error: Untracked working tree file 'LayoutTests/platform/mac/fast/images/gif-large-checkerboard-expected.txt' would be overwritten by merge. could not detach HEAD rebase refs/remotes/trunk: command returned error: 1 Died at WebKitTools/Scripts/update-webkit line 129. Full output: http://queues.webkit.org/results/4030036 280290 27 eric 2010-09-16 12:51:31 -0700 (In reply to comment #26) > (From update of attachment 67761 [details]) > Rejecting patch 67761 from commit-queue. > > Failed to run "['WebKitTools/Scripts/update-webkit']" exit_code: 2 > Last 500 characters of output: > MLInputElement.h > M WebCore/rendering/RenderFileUploadControl.cpp > M WebCore/css/CSSStyleSelector.cpp > r67653 = a6cb255b7102ae73f9141e4c7b36ead6f20c8af5 (refs/remotes/trunk) > First, rewinding head to replay your work on top of it... > error: Untracked working tree file 'LayoutTests/platform/mac/fast/images/gif-large-checkerboard-expected.txt' would be overwritten by merge. > could not detach HEAD > rebase refs/remotes/trunk: command returned error: 1 > > Died at WebKitTools/Scripts/update-webkit line 129. > > Full output: http://queues.webkit.org/results/4030036 That looks like a bug in the commit-queue. It should have run git clean -f before this. I suspect this came from our recent re-organization of code inside the queue. @abarth. 280369 28 67761 commit-queue 2010-09-16 14:44:36 -0700 Comment on attachment 67761 Patch Clearing flags on attachment: 67761 Committed r67669: <http://trac.webkit.org/changeset/67669> 280370 29 commit-queue 2010-09-16 14:44:43 -0700 All reviewed patches have been landed. Closing bug. 61608 2010-07-14 21:56:13 -0700 2010-09-03 09:08:57 -0700 Patch script.patch text/plain 3933 kbr SW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9D aGFuZ2VMb2cJKHJldmlzaW9uIDYzNDA0KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTAtMDctMTQgIEtlbm5ldGggUnVzc2VsbCAg PGtickBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZCBzY3JpcHQgdG8gc3luY2hyb25pemUgV2ViS2l0IGFuZCBLaHJvbm9zIFdl YkdMIHRlc3RzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD00MjMzNgorCisgICAgICAgIFdyb3RlIHNjcmlwdCB0byBhdXRvbWF0ZSB0aGUgcHJvY2VzcyBv ZiBjb3B5aW5nIFdlYkdMIHRlc3RzIHdoaWNoCisgICAgICAgIG9yaWdpbmF0ZWQgaW4gdGhlIFdl YktpdCByZXBvc2l0b3J5IGZyb20gYSBsb2NhbCBjaGVja291dCBvZiB0aGUKKyAgICAgICAgS2hy b25vcyByZXBvc2l0b3J5LiBWZXJpZmllZCBtYW51YWxseSB3aXRoIGEgZHJ5IHJ1biBvZiB0aGUg c2NyaXB0CisgICAgICAgIHRoYXQgdGhlIGRlc2lyZWQgcmVzdWx0cyB3aWxsIGJlIGFjaGlldmVk LiBUaGUgc2NyaXB0IHdpbGwgYmUgcnVuLAorICAgICAgICBhbmQgaXRzIHJlc3VsdHMgYW5kIHJl YmFzZWxpbmUgcmVzdWx0cyBjaGVja2VkIGluLCBpbiBhIGZvbGxvd2luZworICAgICAgICBidWcu IE5vdGUgdGhhdCB0aGlzIHNjcmlwdCBpcyBiZWluZyBhZGRlZCB0byBmYXN0L2NhbnZhcy93ZWJn bC8KKyAgICAgICAgcmF0aGVyIHRoYW4gV2ViS2l0VG9vbHMvU2NyaXB0cyB0byBrZWVwIGl0IGNv LWxvY2F0ZWQgd2l0aCB0aGUKKyAgICAgICAgZmlsZXMgaXQgYWZmZWN0cywgYW5kIHRoZSBkaXJl Y3RvcnkgaW4gd2hpY2ggaXQgbXVzdCBiZSBydW4uCisKKyAgICAgICAgKiBmYXN0L2NhbnZhcy93 ZWJnbC9jb3B5LWZyb20ta2hyb25vczogQWRkZWQuCisKIDIwMTAtMDctMTQgIEVyaWMgU2VpZGVs ICA8ZXJpY0B3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCklu ZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbC9jb3B5LWZyb20ta2hyb25vcwo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbC9jb3B5LWZyb20ta2hyb25v cwkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmdsL2NvcHktZnJv bS1raHJvbm9zCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDgzIEBACisjIS9iaW4vYmFzaAorCisj IFNjcmlwdCB0byBoZWxwIHN5bmNocm9uaXplIHRoZSBLaHJvbm9zIFdlYkdMIGNvbmZvcm1hbmNl IHRlc3RzIHdpdGgKKyMgdGhlIFdlYktpdCBsYXlvdXQgdGVzdHMuIENvcGllcyBhIGtub3duIHNl dCBvZiB0ZXN0cyBmcm9tIHRoZQorIyBLaHJvbm9zIHJlcG9zaXRvcnksIHBlcmZvcm1pbmcgY2Vy dGFpbiB0ZXh0dWFsIHN1YnN0aXR1dGlvbnMga25vd24KKyMgdG8gYmUgbmVjZXNzYXJ5IGR1ZSB0 byBkaWZmZXJlbmNlcyBpbiB0aGUgZGlyZWN0b3J5IGxheW91dCBiZXR3ZWVuCisjIHRoZSByZXBv c2l0b3JpZXMuCisKK3VzYWdlICgpIHsKKyAgbmFtZT1gYmFzZW5hbWUgJDBgCisgIGVjaG8gVXNh Z2U6CisgIGVjaG8gIiAiICRuYW1lIFtwYXRoIHRvIHRlc3QgaW4gS2hyb25vcyByZXBvc2l0b3J5 XQorICBlY2hvICIgICAiIENvcGllcyBhIHNpbmdsZSB0ZXN0IGZyb20gdGhlIEtocm9ub3MgcmVw b3NpdG9yeSBpbnRvIHRoZQorICBlY2hvICIgICAiIGN1cnJlbnQgd29ya2luZyBkaXJlY3Rvcnks IHByb2Nlc3NpbmcgaXQgdG8gYWRqdXN0IHBhdGggbmFtZXMuCisgIGVjaG8gIiAiICRuYW1lIFtw YXRoIHRvIEtocm9ub3MgcmVwb3NpdG9yeV0KKyAgZWNobyAiICAgIiBGb3IgZWFjaCB0ZXN0IFwo Lmh0bWxcKSBpbiB0aGUgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSwgY29waWVzCisgIGVjaG8g IiAgICIgdGhlIHRlc3Qgb2YgdGhlIHNhbWUgbmFtZSBmcm9tIHRoZSBLaHJvbm9zIHJlcG9zaXRv cnksIHByb2Nlc3NpbmcKKyAgZWNobyAiICAgIiBpdCB0byBhZGp1c3QgcGF0aCBuYW1lcy4KKyAg ZWNobyAiICIgVGhpcyBjb21tYW5kIHNob3VsZCBiZSBydW4gZnJvbSB3aXRoaW4gdGhlIExheW91 dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmdsCisgIGVjaG8gIiAiIGRpcmVjdG9yeS4KK30KKworY2hv cF9pbml0aWFsX2NvbW1lbnQgKCkgeworICBhd2sgJworLzwhLS0vICYmIEZOUiA9PSAxLCAvLiot LT4vIHsgbmV4dCB9Cit7IHByaW50IH0KKycKK30KKworZml4X2pzX3Rlc3Rfc3R5bGUgKCkgewor ICAgIHNlZCAtZSAicy8uLlwvcmVzb3VyY2VzXC9qcy10ZXN0LXN0eWxlLmNzcy8uLlwvLi5cL2pz XC9yZXNvdXJjZXNcL2pzLXRlc3Qtc3R5bGUuY3NzL2ciCit9CisKK2ZpeF9qc190ZXN0X3ByZSAo KSB7CisgICAgc2VkIC1lICJzLy4uXC9yZXNvdXJjZXNcL2pzLXRlc3QtcHJlLmpzLy4uXC8uLlwv anNcL3Jlc291cmNlc1wvanMtdGVzdC1wcmUuanMvZyIKK30KKworZml4X2pzX3Rlc3RfcG9zdCAo KSB7CisgICAgc2VkIC1lICJzLy4uXC9yZXNvdXJjZXNcL2pzLXRlc3QtcG9zdC5qcy8uLlwvLi5c L2pzXC9yZXNvdXJjZXNcL2pzLXRlc3QtcG9zdC5qcy9nIgorfQorCitmaXhfZGVza3RvcF9nbF9j b25zdGFudHMgKCkgeworICAgIHNlZCAtZSAicy8uLlwvcmVzb3VyY2VzXC9kZXNrdG9wLWdsLWNv bnN0YW50cy5qcy9yZXNvdXJjZXNcL2Rlc2t0b3AtZ2wtY29uc3RhbnRzLmpzL2ciCit9CisKK3By b2Nlc3NfZmlsZSAoKSB7CisgIGJhc2VfbmFtZT1gYmFzZW5hbWUgJDFgCisgIGNhdCAkMSB8IGNo b3BfaW5pdGlhbF9jb21tZW50IHwgZml4X2pzX3Rlc3Rfc3R5bGUgfCBmaXhfanNfdGVzdF9wcmUg fCBmaXhfanNfdGVzdF9wb3N0IHwgZml4X2Rlc2t0b3BfZ2xfY29uc3RhbnRzID4gJGJhc2VfbmFt ZQorICBlY2hvICIgIFByb2Nlc3NlZCAiICRiYXNlX25hbWUKK30KKworZmluZF9maWxlX2luX2Rp ciAoKSB7CisgIHZhbD1gZmluZCAkMSAtbmFtZSAkMiAtcHJpbnRgCisgIGlmIFsgIiR2YWwiID09 ICIiIF0gOyB0aGVuCisgICAgcmV0dXJuIDEKKyAgZmkKKyAgZXZhbCAiJDM9JHZhbCIKKyAgcmV0 dXJuIDAKK30KKworaWYgWyAkIyA9PSAwIF0gOyB0aGVuCisgIHVzYWdlCisgIGV4aXQgMQorZmkK KworaWYgWyAtZiAkMSBdIDsgdGhlbgorICBwcm9jZXNzX2ZpbGUgJDEKK2VsaWYgWyAtZCAkMSBd IDsgdGhlbgorICBGSUxFUz1gbHMgKi5odG1sYAorICBSRVRVUk49CisgIGVjaG8gQ29weWluZyB0 ZXN0cyBmcm9tIEtocm9ub3MgcmVwb3NpdG9yeSAkMQorICBmb3IgaWkgaW4gJEZJTEVTIDsgZG8K KyAgICBmaW5kX2ZpbGVfaW5fZGlyICQxICRpaSBSRVRVUk4KKyAgICBpZiBbICQ/ID09IDAgXSA7 IHRoZW4KKyAgICAgIHByb2Nlc3NfZmlsZSAkUkVUVVJOCisgICAgZWxzZQorICAgICAgZWNobyAk aWkgbm90IGZvdW5kIGluIEtocm9ub3MgcmVwb3NpdG9yeQorICAgIGZpCisgIGRvbmUKK2Vsc2UK KyAgZWNobyAkMSBpcyBuZWl0aGVyIGEgZmlsZSBub3IgZGlyZWN0b3J5CisgIHVzYWdlCitmaQoK UHJvcGVydHkgY2hhbmdlcyBvbjogTGF5b3V0VGVzdHMvZmFzdC9jYW52YXMvd2ViZ2wvY29weS1m cm9tLWtocm9ub3MKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpBZGRlZDogc3ZuOmV4ZWN1dGFibGUKICAgKyAqCkFkZGVk OiBwcm9oaWJpdC10YWJzCiAgICsgeApBZGRlZDogc3ZuOmVvbC1zdHlsZQogICArIG5hdGl2ZQoK 66506 2010-09-03 09:09:01 -0700 2010-09-03 14:55:56 -0700 Patch bug-42336-20100903090901.patch text/plain 18304 enne ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBiNDc5N2QwMjc5Nzc5N2JmOWFjYmU2OGM4OWI1MjM0NzI4M2U2NWY2Li4wMGUyZGZk N2JkNDI2MzhhMzJiNTk1ZjcwMDk0ZmMyZWYwNzg4NjkwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTAtMDktMDIgIEFkcmllbm5lIFdhbGtlciAgPGVubmVAZ29vZ2xlLmNvbT4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgc2NyaXB0IHRvIHN5 bmNocm9uaXplIFdlYktpdCBhbmQgS2hyb25vcyBXZWJHTCB0ZXN0cworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDIzMzYKKworICAgICAgICAqIFNjcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzOiBBZGRlZC4KKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHMu cHk6IEFkZGVkLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0 ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0c191bml0dGVzdC5weTogQWRkZWQuCisKIDIwMTAtMDkt MDEgIEdhYm9yIFJhcGNzYW55aSAgPHJnYWJvckBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgQW50b25pbyBHb21lcy4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy91 cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODQ3ZGVjNzkyODhlMTZi NWY4NGMwODc1YWQwZjJmNDRkNzhmMWJjZAotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzCkBAIC0wLDAgKzEsNDEgQEAK KyMhL3Vzci9iaW4vZW52IHB5dGhvbgorIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMg bWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor IyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMgICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworIyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorIyB0aGlzIHNvZnR3 YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorIworIyBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJ QlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorIyBBIFBBUlRJQ1VMQVIgUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorIyBPV05F UiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyMgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisjIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKyIiIldyYXBwZXIgYXJv dW5kIHdlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMu cHkiIiIKK2ltcG9ydCBvcworaW1wb3J0IHN5cworCitzY3JpcHRzX2RpcmVjdG9yeSA9IG9zLnBh dGguZGlybmFtZShvcy5wYXRoLmFic3BhdGgoc3lzLmFyZ3ZbMF0pKQord2Via2l0cHlfZGlyZWN0 b3J5ID0gb3MucGF0aC5qb2luKHNjcmlwdHNfZGlyZWN0b3J5LCAid2Via2l0cHkiKQorc3lzLnBh dGguYXBwZW5kKG9zLnBhdGguam9pbih3ZWJraXRweV9kaXJlY3RvcnksICJsYXlvdXRfdGVzdHMi KSkKKworaW1wb3J0IHVwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cworCitpZiBfX25hbWVf XyA9PSAnX19tYWluX18nOgorICAgIHVwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5tYWlu KCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3VwZGF0ZS13ZWJnbC1jb25mb3JtYW5jZS10ZXN0cy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0ZS13ZWJnbC1jb25mb3JtYW5jZS10ZXN0cy5weQpk ZWxldGVkIGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggZTAzZGJjOTFhOGQwMzk1NGJiMzU0MzkyZmRl NDdkYmJmOWQyZWE4ZS4uMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAot LS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGUtd2Vi Z2wtY29uZm9ybWFuY2UtdGVzdHMucHkKKysrIC9kZXYvbnVsbApAQCAtMSwxMTIgKzAsMCBAQAot IyEvdXNyL2Jpbi9lbnYgcHl0aG9uCi0KLSMgQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0jCi0jIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotIyBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSMgYXJl IG1ldDoKLSMgMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKLSMgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotIyAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAotIyAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCi0jICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uCi0jCi0jIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBBTlkKLSMgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKLSMgSU1Q TElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSCi0jIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBDT01QVVRFUiwgSU5DLiBPUgotIyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKLSMgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAotIyBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFU QSwgT1IKLSMgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWQotIyBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLSMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCi0jIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu Ci0KLWltcG9ydCBnbG9iCi1pbXBvcnQgb3MKLWltcG9ydCByZQotaW1wb3J0IHN5cwotZnJvbSB3 ZWJraXRweS5jb21tb24uc3lzdGVtLmRlcHJlY2F0ZWRfbG9nZ2luZyBpbXBvcnQgZXJyb3IsIGxv ZwotZnJvbSB3ZWJraXRweS5jb21tb24uY2hlY2tvdXQgaW1wb3J0IHNjbQotCi1kZWYgdXNhZ2Uo KToKLSAgICBwcmludCBvcy5wYXRoLmJhc2VuYW1lKHN5cy5hcmd2WzBdKSArICIgKGlucHV0IGZp bGUgb3IgZGlyZWN0b3J5KSAob3B0aW9uYWwgb3V0cHV0IGRpcmVjdG9yeSkiCi0KLWRlZiByZW1v dmVGaXJzdExpbmVDb21tZW50KHRleHQpOgotICAgIHJldHVybiByZS5jb21waWxlKHInXjwhLS0u Kj8tLT5ccyonLCByZS5ET1RBTEwpLnN1YignJywgdGV4dCkKLQotZGVmIHRyYW5zbGF0ZUluY2x1 ZGVzKHRleHQpOgotICAgICMgTWFwcGluZyBvZiBzaW5nbGUgZmlsZW5hbWUgdG8gcmVsYXRpdmUg cGF0aCB1bmRlciBXZWJLaXQgcm9vdC4KLSAgICAjIEFzc3VtcHRpb246IHRoZXNlIGZpbGVuYW1l cyBhcmUgZ2xvYmFsbHkgdW5pcXVlLgotICAgIGluY2x1ZGVNYXBwaW5nID0gewotICAgICAgICAi anMtdGVzdC1zdHlsZS5jc3MiIDogIi4uLy4uL2pzL3Jlc291cmNlcyIsCi0gICAgICAgICJqcy10 ZXN0LXByZS5qcyIgOiAiLi4vLi4vanMvcmVzb3VyY2VzIiwKLSAgICAgICAgImpzLXRlc3QtcG9z dC5qcyIgOiAiLi4vLi4vanMvcmVzb3VyY2VzIiwKLSAgICAgICAgImRlc2t0b3AtZ2wtY29uc3Rh bnRzLmpzIiA6ICJyZXNvdXJjZXMiLAotICAgIH07Ci0KLSAgICBmb3IgZmlsZW5hbWUsIHBhdGgg aW4gaW5jbHVkZU1hcHBpbmcuaXRlbXMoKToKLSAgICAgICAgdGV4dCA9IHJlLnN1YihyJyg/Olte IlwnPSBdKi8pPycgKyByZS5lc2NhcGUoZmlsZW5hbWUpLCBvcy5wYXRoLmpvaW4ocGF0aCwgZmls ZW5hbWUpLCB0ZXh0KQotCi0gICAgcmV0dXJuIHRleHQKLQotZGVmIHRyYW5zbGF0ZUtocm9ub3NU ZXN0KHRleHQpOgotICAgICIiIgotICAgIFRoaXMgbWV0aG9kIHRyYW5zbGF0ZXMgdGhlIGNvbnRl bnRzIG9mIGEgS2hyb25vcyB0ZXN0IHRvIGEgV2ViS2l0IHRlc3QuCi0gICAgIiIiIAotCi0gICAg dHJhbnNsYXRlRnVuY3MgPSBbCi0gICAgICAgIHJlbW92ZUZpcnN0TGluZUNvbW1lbnQsCi0gICAg ICAgIHRyYW5zbGF0ZUluY2x1ZGVzLAotICAgIF0KLQotICAgIGZvciBmIGluIHRyYW5zbGF0ZUZ1 bmNzOgotICAgICAgICB0ZXh0ID0gZih0ZXh0KQotCi0gICAgcmV0dXJuIHRleHQKLQotZGVmIHVw ZGF0ZUZpbGUoaW5wdXRGaWxlTmFtZSwgb3V0cHV0RGlyKToKLSAgICAjIGNoZWNrIGlucHV0Rmls ZU5hbWUgZXhpc3RzCi0gICAgIyBjaGVjayBvdXRwdXREaXIgZXhpc3RzCi0gICAgb3V0cHV0Rmls ZU5hbWUgPSBvcy5wYXRoLmpvaW4ob3V0cHV0RGlyLCBvcy5wYXRoLmJhc2VuYW1lKGlucHV0Rmls ZU5hbWUpKQotCi0gICAgd2l0aCBvcGVuKGlucHV0RmlsZU5hbWUsICdyJykgYXMgaW5wdXRGaWxl OgotICAgICAgICB3aXRoIG9wZW4ob3V0cHV0RmlsZU5hbWUsICd3JykgYXMgb3V0cHV0RmlsZToK LSAgICAgICAgICAgIG91dHB1dEZpbGUud3JpdGUodHJhbnNsYXRlS2hyb25vc1Rlc3QoaW5wdXRG aWxlLnJlYWQoKSkpICAKLQotZGVmIHVwZGF0ZURpcmVjdG9yeShpbnB1dERpciwgb3V0cHV0RGly KToKLSAgICBmb3IgZmlsZU5hbWUgaW4gZ2xvYi5nbG9iKG9zLnBhdGguam9pbihpbnB1dERpciwg JyouaHRtbCcpKToKLSAgICAgICAgdXBkYXRlRmlsZShvcy5wYXRoLmpvaW4oaW5wdXREaXIsIGZp bGVOYW1lKSwgb3V0cHV0RGlyKQotCi1kZWYgZGVmYXVsdE91dHB1dERpcigpOgotICAgIGN1cnJl bnRfc2NtID0gc2NtLmRldGVjdF9zY21fc3lzdGVtKG9zLnBhdGguZGlybmFtZShzeXMuYXJndlsw XSkpCi0gICAgaWYgKG5vdCBjdXJyZW50X3NjbSk6Ci0gICAgICAgIGVycm9yKCJObyBTQ00gZGV0 ZWN0ZWQuICBQbGVhc2Ugc3BlY2lmeSBhbiBleHBsaWN0IG91dHB1dCBkaXIuIik7Ci0gICAgcm9v dF9kaXIgPSBjdXJyZW50X3NjbS5jaGVja291dF9yb290Ci0gICAgaWYgKG5vdCByb290X2Rpcik6 Ci0gICAgICAgIGVycm9yKCJDb3VsZG4ndCBmaW5kIFNDTSByb290LiAgUGxlYXNlIHNwZWNpZnkg YW4gZXhwbGljaXQgb3V0cHV0IGRpci4iKTsKLSAgICByZXR1cm4gb3MucGF0aC5qb2luKHJvb3Rf ZGlyLCAiTGF5b3V0VGVzdHMvZmFzdC9jYW52YXMvd2ViZ2wiKQotCi1kZWYgbWFpbihhcmd2KToK LSAgICBpZiAiLS1oZWxwIiBpbiBhcmd2IG9yIGxlbihhcmd2KSA9PSAwOgotICAgICAgICB1c2Fn ZSgpOwotICAgICAgICBzeXMuZXhpdCgwKQotICAgIGlucHV0TmFtZSA9IGFyZ3ZbMF0KLSAgICBp ZiBsZW4oYXJndikgPT0gMToKLSAgICAgICAgb3V0cHV0RGlyID0gZGVmYXVsdE91dHB1dERpcigp Ci0gICAgZWxzZToKLSAgICAgICAgb3V0cHV0RGlyID0gYXJndlsxXQotCi0gICAgaWYgKG9zLnBh dGguaXNmaWxlKGlucHV0TmFtZSkpOgotICAgICAgICB1cGRhdGVGaWxlKGlucHV0TmFtZSwgb3V0 cHV0RGlyKQotICAgIGVsaWYgKG9zLnBhdGguaXNkaXIoaW5wdXROYW1lKSk6Ci0gICAgICAgIHVw ZGF0ZURpcmVjdG9yeShpbnB1dE5hbWUsIG91dHB1dERpcikKLSAgICBlbHNlOgotICAgICAgICBl cnJvcigiJyIgKyBpbnB1dE5hbWUgKyAiJyBpcyBub3QgYSBkaXJlY3Rvcnkgb3IgYSBmaWxlLiIp OwotICAgICAgICBzeXMuZXhpdCgyKQotCi0gICAgc3lzLmV4aXQoMCkKLQotaWYgX19uYW1lX18g PT0gIl9fbWFpbl9fIjoKLSAgICBtYWluKHN5cy5hcmd2WzE6XSkKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3Jt YW5jZV90ZXN0cy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5weQpuZXcgZmlsZSBtb2RlIDEwMDc1NQpp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lY2YyYjY3ZjBl MTE1ODI0M2RmOWFhOTExNDIyNzc3M2VmNDUzNjgxCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdXBkYXRlX3dlYmdsX2NvbmZvcm1h bmNlX3Rlc3RzLnB5CkBAIC0wLDAgKzEsMTU4IEBACisjIS91c3IvYmluL2VudiBweXRob24KKwor IyBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMK KyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworIyBhcmUgbWV0OgorIyAxLiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisjIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisjICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyMgICAgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMK KyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFT IElTJycgQU5EIEFOWQorIyBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorIyBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyMgUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisjIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LCBTUEVDSUFMLAorIyBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisjIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorIyBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisjIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VAorIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworaW1wb3J0IGdsb2IKK2ltcG9ydCBs b2dnaW5nCitpbXBvcnQgb3B0cGFyc2UKK2ltcG9ydCBvcworaW1wb3J0IHJlCitpbXBvcnQgc3lz CitpbXBvcnQgd2Via2l0cHkuY29tbW9uLmNoZWNrb3V0LnNjbSBhcyBzY20KKworX2xvZyA9IGxv Z2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMuIgorICAgICAgICAgICAgICAg ICAgICAgICAgICJ1cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMiKQorCisKK2RlZiByZW1v dmVfZmlyc3RfbGluZV9jb21tZW50KHRleHQpOgorICAgIHJldHVybiByZS5jb21waWxlKHInXjwh LS0uKj8tLT5ccyonLCByZS5ET1RBTEwpLnN1YignJywgdGV4dCkKKworCitkZWYgdHJhbnNsYXRl X2luY2x1ZGVzKHRleHQpOgorICAgICMgTWFwcGluZyBvZiBzaW5nbGUgZmlsZW5hbWUgdG8gcmVs YXRpdmUgcGF0aCB1bmRlciBXZWJLaXQgcm9vdC4KKyAgICAjIEFzc3VtcHRpb246IHRoZXNlIGZp bGVuYW1lcyBhcmUgZ2xvYmFsbHkgdW5pcXVlLgorICAgIGluY2x1ZGVfbWFwcGluZyA9IHsKKyAg ICAgICAgImpzLXRlc3Qtc3R5bGUuY3NzIjogIi4uLy4uL2pzL3Jlc291cmNlcyIsCisgICAgICAg ICJqcy10ZXN0LXByZS5qcyI6ICIuLi8uLi9qcy9yZXNvdXJjZXMiLAorICAgICAgICAianMtdGVz dC1wb3N0LmpzIjogIi4uLy4uL2pzL3Jlc291cmNlcyIsCisgICAgICAgICJkZXNrdG9wLWdsLWNv bnN0YW50cy5qcyI6ICJyZXNvdXJjZXMiLAorICAgIH0KKworICAgIGZvciBmaWxlbmFtZSwgcGF0 aCBpbiBpbmNsdWRlX21hcHBpbmcuaXRlbXMoKToKKyAgICAgICAgc2VhcmNoID0gcicoPzpbXiJc Jz0gXSovKT8nICsgcmUuZXNjYXBlKGZpbGVuYW1lKQorICAgICAgICByZXBsYWNlID0gb3MucGF0 aC5qb2luKHBhdGgsIGZpbGVuYW1lKQorICAgICAgICB0ZXh0ID0gcmUuc3ViKHNlYXJjaCwgcmVw bGFjZSwgdGV4dCkKKworICAgIHJldHVybiB0ZXh0CisKKworZGVmIHRyYW5zbGF0ZV9raHJvbm9z X3Rlc3QodGV4dCk6CisgICAgIiIiCisgICAgVGhpcyBtZXRob2QgdHJhbnNsYXRlcyB0aGUgY29u dGVudHMgb2YgYSBLaHJvbm9zIHRlc3QgdG8gYSBXZWJLaXQgdGVzdC4KKyAgICAiIiIKKworICAg IHRyYW5zbGF0ZUZ1bmNzID0gWworICAgICAgICByZW1vdmVfZmlyc3RfbGluZV9jb21tZW50LAor ICAgICAgICB0cmFuc2xhdGVfaW5jbHVkZXMsCisgICAgXQorCisgICAgZm9yIGYgaW4gdHJhbnNs YXRlRnVuY3M6CisgICAgICAgIHRleHQgPSBmKHRleHQpCisKKyAgICByZXR1cm4gdGV4dAorCisK K2RlZiB1cGRhdGVfZmlsZShpbl9maWxlbmFtZSwgb3V0X2Rpcik6CisgICAgIyBjaGVjayBpbl9m aWxlbmFtZSBleGlzdHMKKyAgICAjIGNoZWNrIG91dF9kaXIgZXhpc3RzCisgICAgb3V0X2ZpbGVu YW1lID0gb3MucGF0aC5qb2luKG91dF9kaXIsIG9zLnBhdGguYmFzZW5hbWUoaW5fZmlsZW5hbWUp KQorCisgICAgX2xvZy5kZWJ1ZygiUHJvY2Vzc2luZyAiICsgaW5fZmlsZW5hbWUpCisgICAgd2l0 aCBvcGVuKGluX2ZpbGVuYW1lLCAncicpIGFzIGluX2ZpbGU6CisgICAgICAgIHdpdGggb3Blbihv dXRfZmlsZW5hbWUsICd3JykgYXMgb3V0X2ZpbGU6CisgICAgICAgICAgICBvdXRfZmlsZS53cml0 ZSh0cmFuc2xhdGVfa2hyb25vc190ZXN0KGluX2ZpbGUucmVhZCgpKSkKKworCitkZWYgdXBkYXRl X2RpcmVjdG9yeShpbl9kaXIsIG91dF9kaXIpOgorICAgIGZvciBmaWxlbmFtZSBpbiBnbG9iLmds b2Iob3MucGF0aC5qb2luKGluX2RpciwgJyouaHRtbCcpKToKKyAgICAgICAgdXBkYXRlX2ZpbGUo b3MucGF0aC5qb2luKGluX2RpciwgZmlsZW5hbWUpLCBvdXRfZGlyKQorCisKK2RlZiBkZWZhdWx0 X291dF9kaXIoKToKKyAgICBjdXJyZW50X3NjbSA9IHNjbS5kZXRlY3Rfc2NtX3N5c3RlbShvcy5w YXRoLmRpcm5hbWUoc3lzLmFyZ3ZbMF0pKQorICAgIGlmIChub3QgY3VycmVudF9zY20pOgorICAg ICAgICByZXR1cm4gb3MuZ2V0Y3dkKCkKKyAgICByb290X2RpciA9IGN1cnJlbnRfc2NtLmNoZWNr b3V0X3Jvb3QKKyAgICBpZiAobm90IHJvb3RfZGlyKToKKyAgICAgICAgcmV0dXJuIG9zLmdldGN3 ZCgpCisgICAgb3V0X2RpciA9IG9zLnBhdGguam9pbihyb290X2RpciwgIkxheW91dFRlc3RzL2Zh c3QvY2FudmFzL3dlYmdsIikKKyAgICBpZiAob3MucGF0aC5pc2RpcihvdXRfZGlyKSk6CisgICAg ICAgIHJldHVybiBvdXRfZGlyCisgICAgZWxzZToKKyAgICAgICAgcmV0dXJuIG9zLmdldGN3ZCgp CisKKworZGVmIGNvbmZpZ3VyZV9sb2dnaW5nKG9wdGlvbnMpOgorICAgICIiIkNvbmZpZ3VyZXMg dGhlIGxvZ2dpbmcgc3lzdGVtLiIiIgorICAgIGxvZ19mbXQgPSAnJShsZXZlbG5hbWUpczogJSht ZXNzYWdlKXMnCisgICAgbG9nX2RhdGVmbXQgPSAnJXklbSVkICVIOiVNOiVTJworICAgIGxvZ19s ZXZlbCA9IGxvZ2dpbmcuSU5GTworICAgIGlmIG9wdGlvbnMudmVyYm9zZToKKyAgICAgICAgbG9n X2ZtdCA9ICgnJShhc2N0aW1lKXMgJShmaWxlbmFtZSlzOiUobGluZW5vKS00ZCAlKGxldmVsbmFt ZSlzICcKKyAgICAgICAgICAgICAgICAgICAnJShtZXNzYWdlKXMnKQorICAgICAgICBsb2dfbGV2 ZWwgPSBsb2dnaW5nLkRFQlVHCisgICAgbG9nZ2luZy5iYXNpY0NvbmZpZyhsZXZlbD1sb2dfbGV2 ZWwsIGZvcm1hdD1sb2dfZm10LAorICAgICAgICAgICAgICAgICAgICAgICAgZGF0ZWZtdD1sb2df ZGF0ZWZtdCkKKworCitkZWYgZ2V0X29wdGlvbl9wYXJzZXIoKToKKyAgICB1c2FnZSA9ICJ1c2Fn ZTogJXByb2cgW29wdGlvbnNdIChpbnB1dCBmaWxlIG9yIGRpcmVjdG9yeSkiCisgICAgb3B0aW9u X3BhcnNlciA9IG9wdHBhcnNlLk9wdGlvblBhcnNlcih1c2FnZT11c2FnZSkKKyAgICBvcHRpb25f cGFyc2VyLmFkZF9vcHRpb24oJy12JywgJy0tdmVyYm9zZScsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGFjdGlvbj0nc3RvcmVfdHJ1ZScsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGRlZmF1bHQ9RmFsc2UsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGhlbHA9J2lu Y2x1ZGUgZGVidWctbGV2ZWwgbG9nZ2luZycpCisgICAgb3B0aW9uX3BhcnNlci5hZGRfb3B0aW9u KCctbycsICctLW91dHB1dCcsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFjdGlvbj0n c3RvcmUnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0eXBlPSdzdHJpbmcnLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBkZWZhdWx0PWRlZmF1bHRfb3V0X2RpcigpLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBtZXRhdmFyPSdESVInLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBoZWxwPSdzcGVjaWZ5IGFuIG91dHB1dCBkaXJlY3RvcnkgdG8gcGxhY2Ug ZmlsZXMgJworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdpbiBbZGVmYXVsdDog JWRlZmF1bHRdJykKKyAgICByZXR1cm4gb3B0aW9uX3BhcnNlcgorCisKK2RlZiBtYWluKCk6Cisg ICAgb3B0aW9uX3BhcnNlciA9IGdldF9vcHRpb25fcGFyc2VyKCkKKyAgICAob3B0aW9ucywgYXJn cykgPSBvcHRpb25fcGFyc2VyLnBhcnNlX2FyZ3MoKQorICAgIGNvbmZpZ3VyZV9sb2dnaW5nKG9w dGlvbnMpCisKKyAgICBpZiAobGVuKGFyZ3MpID09IDApOgorICAgICAgICBfbG9nLmVycm9yKCJN dXN0IHNwZWNpZnkgYW4gaW5wdXQgZGlyZWN0b3J5IG9yIGZpbGVuYW1lLiIpCisgICAgICAgIG9w dGlvbl9wYXJzZXIucHJpbnRfaGVscCgpCisgICAgICAgIHN5cy5leGl0KDEpCisKKyAgICBpbl9u YW1lID0gYXJnc1swXQorICAgIGlmIChvcy5wYXRoLmlzZmlsZShpbl9uYW1lKSk6CisgICAgICAg IHVwZGF0ZV9maWxlKGluX25hbWUsIG9wdGlvbnMub3V0cHV0KQorICAgIGVsaWYgKG9zLnBhdGgu aXNkaXIoaW5fbmFtZSkpOgorICAgICAgICB1cGRhdGVfZGlyZWN0b3J5KGluX25hbWUsIG9wdGlv bnMub3V0cHV0KQorICAgIGVsc2U6CisgICAgICAgIF9sb2cuZXJyb3IoIiciICsgaW5fbmFtZSAr ICInIGlzIG5vdCBhIGRpcmVjdG9yeSBvciBhIGZpbGUuIikKKyAgICAgICAgc3lzLmV4aXQoMikK KworICAgIHN5cy5leGl0KDApCisKK2lmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CisgICAgbWFp bigpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHNfdW5pdHRlc3QucHkgYi9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2Vf dGVzdHNfdW5pdHRlc3QucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNzg2YzYwMzI1Nzk0ZDJkYWQzNDg5MDMzOGJj ODdmNjAxMGZlMGZlNQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0c191bml0dGVz dC5weQpAQCAtMCwwICsxLDEwNCBAQAorIyEvdXNyL2Jpbi9weXRob24KKyMgQ29weXJpZ2h0IChD KSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor IyBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMgYXJlCisjIG1ldDoKKyMKKyMgICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorIyAgICAg KiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl CisjIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIKKyMgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorIyBkaXN0cmlidXRpb24uCisjICAgICAqIE5laXRo ZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyMgY29udHJp YnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVk IGZyb20KKyMgdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVy bWlzc2lvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hU IEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworIyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMg QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRI RSBDT1BZUklHSFQKKyMgT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisj IERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWQorIyBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorCisiIiJVbml0IHRlc3RzIGZvciB1cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHMuIiIi CisKK2ltcG9ydCB1bml0dGVzdAorZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMgaW1wb3J0IHVw ZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cyBhcyB3ZWJnbAorCisKK2RlZiBjb25zdHJ1Y3Rf c2NyaXB0KG5hbWUpOgorICAgIHJldHVybiAiPHNjcmlwdCBzcmM9XCIiICsgbmFtZSArICJcIj48 L3NjcmlwdD5cbiIKKworCitkZWYgY29uc3RydWN0X3N0eWxlKG5hbWUpOgorICAgIHJldHVybiAi PGxpbmsgcmVsPVwic3R5bGVzaGVldFwiIGhyZWY9XCIiICsgbmFtZSArICJcIj4iCisKKworY2xh c3MgVGVzdFRyYW5zbGF0aW9uKHVuaXR0ZXN0LlRlc3RDYXNlKToKKyAgICBkZWYgYXNzZXJ0X3Vu Y2hhbmdlZChzZWxmLCB0ZXh0KToKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCh0ZXh0LCB3ZWJn bC50cmFuc2xhdGVfa2hyb25vc190ZXN0KHRleHQpKQorCisgICAgZGVmIGFzc2VydF90cmFuc2xh dGUoc2VsZiwgaW5wdXQsIG91dHB1dCk6CisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwob3V0cHV0 LCB3ZWJnbC50cmFuc2xhdGVfa2hyb25vc190ZXN0KGlucHV0KSkKKworICAgIGRlZiB0ZXN0X3Np bXBsZV91bmNoYW5nZWQoc2VsZik6CisgICAgICAgIHNlbGYuYXNzZXJ0X3VuY2hhbmdlZCgiIikK KyAgICAgICAgc2VsZi5hc3NlcnRfdW5jaGFuZ2VkKCI8aHRtbD48L2h0bWw+IikKKworICAgIGRl ZiB0ZXN0X2hlYWRlcl9zdHJpcChzZWxmKToKKyAgICAgICAgc2luZ2xlX2xpbmVfaGVhZGVyID0g IjwhLS0gc2luZ2xlIGxpbmUgaGVhZGVyLiAtLT4iCisgICAgICAgIG11bHRpX2xpbmVfaGVhZGVy ID0gIiIiPCEtLSB0aGlzIGlzIGEgbXVsdGktbGluZQorICAgICAgICAgICAgICAgIGhlYWRlci4g IGl0IHNob3VsZCBhbGwgYmUgcmVtb3ZlZCB0b28uCisgICAgICAgICAgICAgICAgLS0+IiIiCisg ICAgICAgIHRleHQgPSAiPGh0bWw+PC9odG1sPiIKKyAgICAgICAgc2VsZi5hc3NlcnRfdHJhbnNs YXRlKHNpbmdsZV9saW5lX2hlYWRlciwgIiIpCisgICAgICAgIHNlbGYuYXNzZXJ0X3RyYW5zbGF0 ZShzaW5nbGVfbGluZV9oZWFkZXIgKyB0ZXh0LCB0ZXh0KQorICAgICAgICBzZWxmLmFzc2VydF90 cmFuc2xhdGUobXVsdGlfbGluZV9oZWFkZXIgKyB0ZXh0LCB0ZXh0KQorCisgICAgZGVmIHRlc3Rf aW5jbHVkZV9yZXdyaXRpbmcoc2VsZik6CisgICAgICAgICMgTWFwcGluZ3MgdG8gTm9uZSBhcmUg dW5jaGFuZ2VkCisgICAgICAgIHN0eWxlcyA9IHsKKyAgICAgICAgICAgICIuLi9yZXNvdXJjZXMv anMtdGVzdC1zdHlsZS5jc3MiOiAiLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3Nz IiwKKyAgICAgICAgICAgICJmYWlsLmNzcyI6IE5vbmUsCisgICAgICAgICAgICAicmVzb3VyY2Vz L3N0eWxlc2hlZXQuY3NzIjogTm9uZSwKKyAgICAgICAgICAgICIuLi9yZXNvdXJjZXMvc3R5bGUu Y3NzIjogTm9uZSwKKyAgICAgICAgfQorICAgICAgICBzY3JpcHRzID0geworICAgICAgICAgICAg Ii4uL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI6ICIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1wcmUuanMiLAorICAgICAgICAgICAgIi4uL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiOiAi Li4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyIsCisgICAgICAgICAgICAiLi4vcmVz b3VyY2VzL2Rlc2t0b3AtZ2wtY29uc3RhbnRzLmpzIjogInJlc291cmNlcy9kZXNrdG9wLWdsLWNv bnN0YW50cy5qcyIsCisKKyAgICAgICAgICAgICJyZXNvdXJjZXMvc2hhZG93LW9mZnNldC5qcyI6 IE5vbmUsCisgICAgICAgICAgICAiLi4vcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC1hc3luYy5qcyI6 IE5vbmUsCisgICAgICAgIH0KKworICAgICAgICBpbnB1dF90ZXh0ID0gIiIKKyAgICAgICAgb3V0 cHV0X3RleHQgPSAiIgorICAgICAgICBmb3IgaW5wdXQsIG91dHB1dCBpbiBzdHlsZXMuaXRlbXMo KToKKyAgICAgICAgICAgIGlucHV0X3RleHQgKz0gY29uc3RydWN0X3N0eWxlKGlucHV0KQorICAg ICAgICAgICAgaWYgKG91dHB1dCk6CisgICAgICAgICAgICAgICAgb3V0cHV0X3RleHQgKz0gY29u c3RydWN0X3N0eWxlKG91dHB1dCkKKyAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAg b3V0cHV0X3RleHQgKz0gY29uc3RydWN0X3N0eWxlKGlucHV0KQorICAgICAgICBmb3IgaW5wdXQs IG91dHB1dCBpbiBzY3JpcHRzLml0ZW1zKCk6CisgICAgICAgICAgICBpbnB1dF90ZXh0ICs9IGNv bnN0cnVjdF9zY3JpcHQoaW5wdXQpCisgICAgICAgICAgICBpZiAob3V0cHV0KToKKyAgICAgICAg ICAgICAgICBvdXRwdXRfdGV4dCArPSBjb25zdHJ1Y3Rfc2NyaXB0KG91dHB1dCkKKyAgICAgICAg ICAgIGVsc2U6CisgICAgICAgICAgICAgICAgb3V0cHV0X3RleHQgKz0gY29uc3RydWN0X3Njcmlw dChpbnB1dCkKKworICAgICAgICBoZWFkID0gJzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVU Ri8vRFREIEhUTUwvL0VOIj5cbjxodG1sPlxuPGhlYWQ+XG4nCisgICAgICAgIGZvb3QgPSAnPC9o ZWFkPlxuPGJvZHk+XG48L2JvZHk+XG48L2h0bWw+JworICAgICAgICBpbnB1dF90ZXh0ID0gaGVh ZCArIGlucHV0X3RleHQgKyBmb290CisgICAgICAgIG91dHB1dF90ZXh0ID0gaGVhZCArIG91dHB1 dF90ZXh0ICsgZm9vdAorICAgICAgICBzZWxmLmFzc2VydF90cmFuc2xhdGUoaW5wdXRfdGV4dCwg b3V0cHV0X3RleHQpCisKK2lmIF9fbmFtZV9fID09ICdfX21haW5fXyc6CisgICAgdW5pdHRlc3Qu bWFpbigpCg== 66550 2010-09-03 14:56:00 -0700 2010-09-07 09:55:28 -0700 Patch bug-42336-20100903145559.patch text/plain 13906 enne ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBiNDc5N2QwMjc5Nzc5N2JmOWFjYmU2OGM4OWI1MjM0NzI4M2U2NWY2Li4wMGUyZGZk N2JkNDI2MzhhMzJiNTk1ZjcwMDk0ZmMyZWYwNzg4NjkwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTAtMDktMDIgIEFkcmllbm5lIFdhbGtlciAgPGVubmVAZ29vZ2xlLmNvbT4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgc2NyaXB0IHRvIHN5 bmNocm9uaXplIFdlYktpdCBhbmQgS2hyb25vcyBXZWJHTCB0ZXN0cworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDIzMzYKKworICAgICAgICAqIFNjcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzOiBBZGRlZC4KKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHMu cHk6IEFkZGVkLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0 ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0c191bml0dGVzdC5weTogQWRkZWQuCisKIDIwMTAtMDkt MDEgIEdhYm9yIFJhcGNzYW55aSAgPHJnYWJvckBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgQW50b25pbyBHb21lcy4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy91 cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODQ3ZGVjNzkyODhlMTZi NWY4NGMwODc1YWQwZjJmNDRkNzhmMWJjZAotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzCkBAIC0wLDAgKzEsNDEgQEAK KyMhL3Vzci9iaW4vZW52IHB5dGhvbgorIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMg bWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor IyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMgICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworIyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorIyB0aGlzIHNvZnR3 YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorIworIyBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJ QlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorIyBBIFBBUlRJQ1VMQVIgUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorIyBPV05F UiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyMgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisjIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKyIiIldyYXBwZXIgYXJv dW5kIHdlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMu cHkiIiIKK2ltcG9ydCBvcworaW1wb3J0IHN5cworCitzY3JpcHRzX2RpcmVjdG9yeSA9IG9zLnBh dGguZGlybmFtZShvcy5wYXRoLmFic3BhdGgoc3lzLmFyZ3ZbMF0pKQord2Via2l0cHlfZGlyZWN0 b3J5ID0gb3MucGF0aC5qb2luKHNjcmlwdHNfZGlyZWN0b3J5LCAid2Via2l0cHkiKQorc3lzLnBh dGguYXBwZW5kKG9zLnBhdGguam9pbih3ZWJraXRweV9kaXJlY3RvcnksICJsYXlvdXRfdGVzdHMi KSkKKworaW1wb3J0IHVwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cworCitpZiBfX25hbWVf XyA9PSAnX19tYWluX18nOgorICAgIHVwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5tYWlu KCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5weQpu ZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lY2YyYjY3ZjBlMTE1ODI0M2RmOWFhOTExNDIyNzc3M2VmNDUzNjgxCi0tLSAv ZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv dXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3RzLnB5CkBAIC0wLDAgKzEsMTU4IEBACisjIS91 c3IvYmluL2VudiBweXRob24KKworIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworIyBhcmUgbWV0 OgorIyAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorIyAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK KyMgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorIyBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorIyBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyMgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENP TVBVVEVSLCBJTkMuIE9SCisjIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorIyBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisjIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBP UgorIyBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZCisjIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKwor aW1wb3J0IGdsb2IKK2ltcG9ydCBsb2dnaW5nCitpbXBvcnQgb3B0cGFyc2UKK2ltcG9ydCBvcwor aW1wb3J0IHJlCitpbXBvcnQgc3lzCitpbXBvcnQgd2Via2l0cHkuY29tbW9uLmNoZWNrb3V0LnNj bSBhcyBzY20KKworX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVz dHMuIgorICAgICAgICAgICAgICAgICAgICAgICAgICJ1cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2Ut dGVzdHMiKQorCisKK2RlZiByZW1vdmVfZmlyc3RfbGluZV9jb21tZW50KHRleHQpOgorICAgIHJl dHVybiByZS5jb21waWxlKHInXjwhLS0uKj8tLT5ccyonLCByZS5ET1RBTEwpLnN1YignJywgdGV4 dCkKKworCitkZWYgdHJhbnNsYXRlX2luY2x1ZGVzKHRleHQpOgorICAgICMgTWFwcGluZyBvZiBz aW5nbGUgZmlsZW5hbWUgdG8gcmVsYXRpdmUgcGF0aCB1bmRlciBXZWJLaXQgcm9vdC4KKyAgICAj IEFzc3VtcHRpb246IHRoZXNlIGZpbGVuYW1lcyBhcmUgZ2xvYmFsbHkgdW5pcXVlLgorICAgIGlu Y2x1ZGVfbWFwcGluZyA9IHsKKyAgICAgICAgImpzLXRlc3Qtc3R5bGUuY3NzIjogIi4uLy4uL2pz L3Jlc291cmNlcyIsCisgICAgICAgICJqcy10ZXN0LXByZS5qcyI6ICIuLi8uLi9qcy9yZXNvdXJj ZXMiLAorICAgICAgICAianMtdGVzdC1wb3N0LmpzIjogIi4uLy4uL2pzL3Jlc291cmNlcyIsCisg ICAgICAgICJkZXNrdG9wLWdsLWNvbnN0YW50cy5qcyI6ICJyZXNvdXJjZXMiLAorICAgIH0KKwor ICAgIGZvciBmaWxlbmFtZSwgcGF0aCBpbiBpbmNsdWRlX21hcHBpbmcuaXRlbXMoKToKKyAgICAg ICAgc2VhcmNoID0gcicoPzpbXiJcJz0gXSovKT8nICsgcmUuZXNjYXBlKGZpbGVuYW1lKQorICAg ICAgICByZXBsYWNlID0gb3MucGF0aC5qb2luKHBhdGgsIGZpbGVuYW1lKQorICAgICAgICB0ZXh0 ID0gcmUuc3ViKHNlYXJjaCwgcmVwbGFjZSwgdGV4dCkKKworICAgIHJldHVybiB0ZXh0CisKKwor ZGVmIHRyYW5zbGF0ZV9raHJvbm9zX3Rlc3QodGV4dCk6CisgICAgIiIiCisgICAgVGhpcyBtZXRo b2QgdHJhbnNsYXRlcyB0aGUgY29udGVudHMgb2YgYSBLaHJvbm9zIHRlc3QgdG8gYSBXZWJLaXQg dGVzdC4KKyAgICAiIiIKKworICAgIHRyYW5zbGF0ZUZ1bmNzID0gWworICAgICAgICByZW1vdmVf Zmlyc3RfbGluZV9jb21tZW50LAorICAgICAgICB0cmFuc2xhdGVfaW5jbHVkZXMsCisgICAgXQor CisgICAgZm9yIGYgaW4gdHJhbnNsYXRlRnVuY3M6CisgICAgICAgIHRleHQgPSBmKHRleHQpCisK KyAgICByZXR1cm4gdGV4dAorCisKK2RlZiB1cGRhdGVfZmlsZShpbl9maWxlbmFtZSwgb3V0X2Rp cik6CisgICAgIyBjaGVjayBpbl9maWxlbmFtZSBleGlzdHMKKyAgICAjIGNoZWNrIG91dF9kaXIg ZXhpc3RzCisgICAgb3V0X2ZpbGVuYW1lID0gb3MucGF0aC5qb2luKG91dF9kaXIsIG9zLnBhdGgu YmFzZW5hbWUoaW5fZmlsZW5hbWUpKQorCisgICAgX2xvZy5kZWJ1ZygiUHJvY2Vzc2luZyAiICsg aW5fZmlsZW5hbWUpCisgICAgd2l0aCBvcGVuKGluX2ZpbGVuYW1lLCAncicpIGFzIGluX2ZpbGU6 CisgICAgICAgIHdpdGggb3BlbihvdXRfZmlsZW5hbWUsICd3JykgYXMgb3V0X2ZpbGU6CisgICAg ICAgICAgICBvdXRfZmlsZS53cml0ZSh0cmFuc2xhdGVfa2hyb25vc190ZXN0KGluX2ZpbGUucmVh ZCgpKSkKKworCitkZWYgdXBkYXRlX2RpcmVjdG9yeShpbl9kaXIsIG91dF9kaXIpOgorICAgIGZv ciBmaWxlbmFtZSBpbiBnbG9iLmdsb2Iob3MucGF0aC5qb2luKGluX2RpciwgJyouaHRtbCcpKToK KyAgICAgICAgdXBkYXRlX2ZpbGUob3MucGF0aC5qb2luKGluX2RpciwgZmlsZW5hbWUpLCBvdXRf ZGlyKQorCisKK2RlZiBkZWZhdWx0X291dF9kaXIoKToKKyAgICBjdXJyZW50X3NjbSA9IHNjbS5k ZXRlY3Rfc2NtX3N5c3RlbShvcy5wYXRoLmRpcm5hbWUoc3lzLmFyZ3ZbMF0pKQorICAgIGlmIChu b3QgY3VycmVudF9zY20pOgorICAgICAgICByZXR1cm4gb3MuZ2V0Y3dkKCkKKyAgICByb290X2Rp ciA9IGN1cnJlbnRfc2NtLmNoZWNrb3V0X3Jvb3QKKyAgICBpZiAobm90IHJvb3RfZGlyKToKKyAg ICAgICAgcmV0dXJuIG9zLmdldGN3ZCgpCisgICAgb3V0X2RpciA9IG9zLnBhdGguam9pbihyb290 X2RpciwgIkxheW91dFRlc3RzL2Zhc3QvY2FudmFzL3dlYmdsIikKKyAgICBpZiAob3MucGF0aC5p c2RpcihvdXRfZGlyKSk6CisgICAgICAgIHJldHVybiBvdXRfZGlyCisgICAgZWxzZToKKyAgICAg ICAgcmV0dXJuIG9zLmdldGN3ZCgpCisKKworZGVmIGNvbmZpZ3VyZV9sb2dnaW5nKG9wdGlvbnMp OgorICAgICIiIkNvbmZpZ3VyZXMgdGhlIGxvZ2dpbmcgc3lzdGVtLiIiIgorICAgIGxvZ19mbXQg PSAnJShsZXZlbG5hbWUpczogJShtZXNzYWdlKXMnCisgICAgbG9nX2RhdGVmbXQgPSAnJXklbSVk ICVIOiVNOiVTJworICAgIGxvZ19sZXZlbCA9IGxvZ2dpbmcuSU5GTworICAgIGlmIG9wdGlvbnMu dmVyYm9zZToKKyAgICAgICAgbG9nX2ZtdCA9ICgnJShhc2N0aW1lKXMgJShmaWxlbmFtZSlzOiUo bGluZW5vKS00ZCAlKGxldmVsbmFtZSlzICcKKyAgICAgICAgICAgICAgICAgICAnJShtZXNzYWdl KXMnKQorICAgICAgICBsb2dfbGV2ZWwgPSBsb2dnaW5nLkRFQlVHCisgICAgbG9nZ2luZy5iYXNp Y0NvbmZpZyhsZXZlbD1sb2dfbGV2ZWwsIGZvcm1hdD1sb2dfZm10LAorICAgICAgICAgICAgICAg ICAgICAgICAgZGF0ZWZtdD1sb2dfZGF0ZWZtdCkKKworCitkZWYgZ2V0X29wdGlvbl9wYXJzZXIo KToKKyAgICB1c2FnZSA9ICJ1c2FnZTogJXByb2cgW29wdGlvbnNdIChpbnB1dCBmaWxlIG9yIGRp cmVjdG9yeSkiCisgICAgb3B0aW9uX3BhcnNlciA9IG9wdHBhcnNlLk9wdGlvblBhcnNlcih1c2Fn ZT11c2FnZSkKKyAgICBvcHRpb25fcGFyc2VyLmFkZF9vcHRpb24oJy12JywgJy0tdmVyYm9zZScs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFjdGlvbj0nc3RvcmVfdHJ1ZScsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGRlZmF1bHQ9RmFsc2UsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGhlbHA9J2luY2x1ZGUgZGVidWctbGV2ZWwgbG9nZ2luZycpCisgICAgb3B0 aW9uX3BhcnNlci5hZGRfb3B0aW9uKCctbycsICctLW91dHB1dCcsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGFjdGlvbj0nc3RvcmUnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB0eXBlPSdzdHJpbmcnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkZWZhdWx0PWRl ZmF1bHRfb3V0X2RpcigpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZXRhdmFyPSdE SVInLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdzcGVjaWZ5IGFuIG91dHB1 dCBkaXJlY3RvcnkgdG8gcGxhY2UgZmlsZXMgJworICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICdpbiBbZGVmYXVsdDogJWRlZmF1bHRdJykKKyAgICByZXR1cm4gb3B0aW9uX3BhcnNl cgorCisKK2RlZiBtYWluKCk6CisgICAgb3B0aW9uX3BhcnNlciA9IGdldF9vcHRpb25fcGFyc2Vy KCkKKyAgICAob3B0aW9ucywgYXJncykgPSBvcHRpb25fcGFyc2VyLnBhcnNlX2FyZ3MoKQorICAg IGNvbmZpZ3VyZV9sb2dnaW5nKG9wdGlvbnMpCisKKyAgICBpZiAobGVuKGFyZ3MpID09IDApOgor ICAgICAgICBfbG9nLmVycm9yKCJNdXN0IHNwZWNpZnkgYW4gaW5wdXQgZGlyZWN0b3J5IG9yIGZp bGVuYW1lLiIpCisgICAgICAgIG9wdGlvbl9wYXJzZXIucHJpbnRfaGVscCgpCisgICAgICAgIHN5 cy5leGl0KDEpCisKKyAgICBpbl9uYW1lID0gYXJnc1swXQorICAgIGlmIChvcy5wYXRoLmlzZmls ZShpbl9uYW1lKSk6CisgICAgICAgIHVwZGF0ZV9maWxlKGluX25hbWUsIG9wdGlvbnMub3V0cHV0 KQorICAgIGVsaWYgKG9zLnBhdGguaXNkaXIoaW5fbmFtZSkpOgorICAgICAgICB1cGRhdGVfZGly ZWN0b3J5KGluX25hbWUsIG9wdGlvbnMub3V0cHV0KQorICAgIGVsc2U6CisgICAgICAgIF9sb2cu ZXJyb3IoIiciICsgaW5fbmFtZSArICInIGlzIG5vdCBhIGRpcmVjdG9yeSBvciBhIGZpbGUuIikK KyAgICAgICAgc3lzLmV4aXQoMikKKworICAgIHN5cy5leGl0KDApCisKK2lmIF9fbmFtZV9fID09 ICJfX21haW5fXyI6CisgICAgbWFpbigpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHNfdW5p dHRlc3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRh dGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHNfdW5pdHRlc3QucHkKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmNmNzhk NmQ5Yzg0ODYwZGI2YTYwMDJhZWYyYzYzZDE5MjMzNmVhYwotLS0gL2Rldi9udWxsCisrKyBiL1dl YktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25m b3JtYW5jZV90ZXN0c191bml0dGVzdC5weQpAQCAtMCwwICsxLDEwNyBAQAorIyEvdXNyL2Jpbi9w eXRob24KKyMgQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisjIG1ldDoKKyMKKyMgICAgICog UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyMgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlCisjIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyMgaW4gdGhlIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorIyBkaXN0cmli dXRpb24uCisjICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyMgdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNp ZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworIyAiQVMgSVMi IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VAorIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyMgT1dORVIgT1IgQ09OVFJJQlVUT1JT IEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QKKyMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsCisjIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorIyBUSEVPUlkgT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCisiIiJVbml0IHRlc3RzIGZvciB1cGRhdGVfd2ViZ2xf Y29uZm9ybWFuY2VfdGVzdHMuIiIiCisKK2ltcG9ydCB1bml0dGVzdAorZnJvbSB3ZWJraXRweS5s YXlvdXRfdGVzdHMgaW1wb3J0IHVwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cyBhcyB3ZWJn bAorCisKK2RlZiBjb25zdHJ1Y3Rfc2NyaXB0KG5hbWUpOgorICAgIHJldHVybiAiPHNjcmlwdCBz cmM9XCIiICsgbmFtZSArICJcIj48L3NjcmlwdD5cbiIKKworCitkZWYgY29uc3RydWN0X3N0eWxl KG5hbWUpOgorICAgIHJldHVybiAiPGxpbmsgcmVsPVwic3R5bGVzaGVldFwiIGhyZWY9XCIiICsg bmFtZSArICJcIj4iCisKKworY2xhc3MgVGVzdFRyYW5zbGF0aW9uKHVuaXR0ZXN0LlRlc3RDYXNl KToKKyAgICBkZWYgYXNzZXJ0X3VuY2hhbmdlZChzZWxmLCB0ZXh0KToKKyAgICAgICAgc2VsZi5h c3NlcnRFcXVhbCh0ZXh0LCB3ZWJnbC50cmFuc2xhdGVfa2hyb25vc190ZXN0KHRleHQpKQorCisg ICAgZGVmIGFzc2VydF90cmFuc2xhdGUoc2VsZiwgaW5wdXQsIG91dHB1dCk6CisgICAgICAgIHNl bGYuYXNzZXJ0RXF1YWwob3V0cHV0LCB3ZWJnbC50cmFuc2xhdGVfa2hyb25vc190ZXN0KGlucHV0 KSkKKworICAgIGRlZiB0ZXN0X3NpbXBsZV91bmNoYW5nZWQoc2VsZik6CisgICAgICAgIHNlbGYu YXNzZXJ0X3VuY2hhbmdlZCgiIikKKyAgICAgICAgc2VsZi5hc3NlcnRfdW5jaGFuZ2VkKCI8aHRt bD48L2h0bWw+IikKKworICAgIGRlZiB0ZXN0X2hlYWRlcl9zdHJpcChzZWxmKToKKyAgICAgICAg c2luZ2xlX2xpbmVfaGVhZGVyID0gIjwhLS0gc2luZ2xlIGxpbmUgaGVhZGVyLiAtLT4iCisgICAg ICAgIG11bHRpX2xpbmVfaGVhZGVyID0gIiIiPCEtLSB0aGlzIGlzIGEgbXVsdGktbGluZQorICAg ICAgICAgICAgICAgIGhlYWRlci4gIGl0IHNob3VsZCBhbGwgYmUgcmVtb3ZlZCB0b28uCisgICAg ICAgICAgICAgICAgLS0+IiIiCisgICAgICAgIHRleHQgPSAiPGh0bWw+PC9odG1sPiIKKyAgICAg ICAgc2VsZi5hc3NlcnRfdHJhbnNsYXRlKHNpbmdsZV9saW5lX2hlYWRlciwgIiIpCisgICAgICAg IHNlbGYuYXNzZXJ0X3RyYW5zbGF0ZShzaW5nbGVfbGluZV9oZWFkZXIgKyB0ZXh0LCB0ZXh0KQor ICAgICAgICBzZWxmLmFzc2VydF90cmFuc2xhdGUobXVsdGlfbGluZV9oZWFkZXIgKyB0ZXh0LCB0 ZXh0KQorCisgICAgZGVmIGRvbnRfc3RyaXBfb3RoZXJfaGVhZGVycyhzZWxmKToKKyAgICAgICAg c2VsZi5hc3NlcnRfdW5jaGFuZ2VkKCI8aHRtbD5cbjwhLS0gZG9uJ3QgcmVtb3ZlIGNvbW1lbnRz IG9uIG90aGVyIGxpbmVzLiAtLT5cbjwvaHRtbD4iKQorCisgICAgZGVmIHRlc3RfaW5jbHVkZV9y ZXdyaXRpbmcoc2VsZik6CisgICAgICAgICMgTWFwcGluZ3MgdG8gTm9uZSBhcmUgdW5jaGFuZ2Vk CisgICAgICAgIHN0eWxlcyA9IHsKKyAgICAgICAgICAgICIuLi9yZXNvdXJjZXMvanMtdGVzdC1z dHlsZS5jc3MiOiAiLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIiwKKyAgICAg ICAgICAgICJmYWlsLmNzcyI6IE5vbmUsCisgICAgICAgICAgICAicmVzb3VyY2VzL3N0eWxlc2hl ZXQuY3NzIjogTm9uZSwKKyAgICAgICAgICAgICIuLi9yZXNvdXJjZXMvc3R5bGUuY3NzIjogTm9u ZSwKKyAgICAgICAgfQorICAgICAgICBzY3JpcHRzID0geworICAgICAgICAgICAgIi4uL3Jlc291 cmNlcy9qcy10ZXN0LXByZS5qcyI6ICIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMi LAorICAgICAgICAgICAgIi4uL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiOiAiLi4vLi4vanMv cmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyIsCisgICAgICAgICAgICAiLi4vcmVzb3VyY2VzL2Rl c2t0b3AtZ2wtY29uc3RhbnRzLmpzIjogInJlc291cmNlcy9kZXNrdG9wLWdsLWNvbnN0YW50cy5q cyIsCisKKyAgICAgICAgICAgICJyZXNvdXJjZXMvc2hhZG93LW9mZnNldC5qcyI6IE5vbmUsCisg ICAgICAgICAgICAiLi4vcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC1hc3luYy5qcyI6IE5vbmUsCisg ICAgICAgIH0KKworICAgICAgICBpbnB1dF90ZXh0ID0gIiIKKyAgICAgICAgb3V0cHV0X3RleHQg PSAiIgorICAgICAgICBmb3IgaW5wdXQsIG91dHB1dCBpbiBzdHlsZXMuaXRlbXMoKToKKyAgICAg ICAgICAgIGlucHV0X3RleHQgKz0gY29uc3RydWN0X3N0eWxlKGlucHV0KQorICAgICAgICAgICAg aWYgKG91dHB1dCk6CisgICAgICAgICAgICAgICAgb3V0cHV0X3RleHQgKz0gY29uc3RydWN0X3N0 eWxlKG91dHB1dCkKKyAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgb3V0cHV0X3Rl eHQgKz0gY29uc3RydWN0X3N0eWxlKGlucHV0KQorICAgICAgICBmb3IgaW5wdXQsIG91dHB1dCBp biBzY3JpcHRzLml0ZW1zKCk6CisgICAgICAgICAgICBpbnB1dF90ZXh0ICs9IGNvbnN0cnVjdF9z Y3JpcHQoaW5wdXQpCisgICAgICAgICAgICBpZiAob3V0cHV0KToKKyAgICAgICAgICAgICAgICBv dXRwdXRfdGV4dCArPSBjb25zdHJ1Y3Rfc2NyaXB0KG91dHB1dCkKKyAgICAgICAgICAgIGVsc2U6 CisgICAgICAgICAgICAgICAgb3V0cHV0X3RleHQgKz0gY29uc3RydWN0X3NjcmlwdChpbnB1dCkK KworICAgICAgICBoZWFkID0gJzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhU TUwvL0VOIj5cbjxodG1sPlxuPGhlYWQ+XG4nCisgICAgICAgIGZvb3QgPSAnPC9oZWFkPlxuPGJv ZHk+XG48L2JvZHk+XG48L2h0bWw+JworICAgICAgICBpbnB1dF90ZXh0ID0gaGVhZCArIGlucHV0 X3RleHQgKyBmb290CisgICAgICAgIG91dHB1dF90ZXh0ID0gaGVhZCArIG91dHB1dF90ZXh0ICsg Zm9vdAorICAgICAgICBzZWxmLmFzc2VydF90cmFuc2xhdGUoaW5wdXRfdGV4dCwgb3V0cHV0X3Rl eHQpCisKK2lmIF9fbmFtZV9fID09ICdfX21haW5fXyc6CisgICAgdW5pdHRlc3QubWFpbigpCg== 66732 2010-09-07 09:55:38 -0700 2010-09-07 16:25:05 -0700 Patch bug-42336-20100907095533.patch text/plain 13947 enne ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBiNDc5N2QwMjc5Nzc5N2JmOWFjYmU2OGM4OWI1MjM0NzI4M2U2NWY2Li4wMGUyZGZk N2JkNDI2MzhhMzJiNTk1ZjcwMDk0ZmMyZWYwNzg4NjkwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTAtMDktMDIgIEFkcmllbm5lIFdhbGtlciAgPGVubmVAZ29vZ2xlLmNvbT4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgc2NyaXB0IHRvIHN5 bmNocm9uaXplIFdlYktpdCBhbmQgS2hyb25vcyBXZWJHTCB0ZXN0cworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDIzMzYKKworICAgICAgICAqIFNjcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzOiBBZGRlZC4KKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHMu cHk6IEFkZGVkLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0 ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0c191bml0dGVzdC5weTogQWRkZWQuCisKIDIwMTAtMDkt MDEgIEdhYm9yIFJhcGNzYW55aSAgPHJnYWJvckBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgQW50b25pbyBHb21lcy4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy91 cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODQ3ZGVjNzkyODhlMTZi NWY4NGMwODc1YWQwZjJmNDRkNzhmMWJjZAotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzCkBAIC0wLDAgKzEsNDEgQEAK KyMhL3Vzci9iaW4vZW52IHB5dGhvbgorIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMg bWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor IyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMgICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworIyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorIyB0aGlzIHNvZnR3 YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorIworIyBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJ QlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorIyBBIFBBUlRJQ1VMQVIgUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorIyBPV05F UiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyMgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisjIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKyIiIldyYXBwZXIgYXJv dW5kIHdlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMu cHkiIiIKK2ltcG9ydCBvcworaW1wb3J0IHN5cworCitzY3JpcHRzX2RpcmVjdG9yeSA9IG9zLnBh dGguZGlybmFtZShvcy5wYXRoLmFic3BhdGgoc3lzLmFyZ3ZbMF0pKQord2Via2l0cHlfZGlyZWN0 b3J5ID0gb3MucGF0aC5qb2luKHNjcmlwdHNfZGlyZWN0b3J5LCAid2Via2l0cHkiKQorc3lzLnBh dGguYXBwZW5kKG9zLnBhdGguam9pbih3ZWJraXRweV9kaXJlY3RvcnksICJsYXlvdXRfdGVzdHMi KSkKKworaW1wb3J0IHVwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cworCitpZiBfX25hbWVf XyA9PSAnX19tYWluX18nOgorICAgIHVwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5tYWlu KCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5weQpu ZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi40OTRmMWU0YTEyZTMxNjg1YzZhM2YwZTJiYzY4NDQ3YTMzODNhNGMyCi0tLSAv ZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv dXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3RzLnB5CkBAIC0wLDAgKzEsMTYwIEBACisjIS91 c3IvYmluL2VudiBweXRob24KKworIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworIyBhcmUgbWV0 OgorIyAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorIyAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK KyMgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorIyBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorIyBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyMgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIENP TVBVVEVSLCBJTkMuIE9SCisjIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorIyBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisjIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBP UgorIyBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZCisjIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKwor ZnJvbSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRlbWVudAorCitpbXBvcnQgZ2xvYgoraW1w b3J0IGxvZ2dpbmcKK2ltcG9ydCBvcHRwYXJzZQoraW1wb3J0IG9zCitpbXBvcnQgcmUKK2ltcG9y dCBzeXMKK2ltcG9ydCB3ZWJraXRweS5jb21tb24uY2hlY2tvdXQuc2NtIGFzIHNjbQorCitfbG9n ID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy4iCisgICAgICAgICAg ICAgICAgICAgICAgICAgInVwZGF0ZS13ZWJnbC1jb25mb3JtYW5jZS10ZXN0cyIpCisKKworZGVm IHJlbW92ZV9maXJzdF9saW5lX2NvbW1lbnQodGV4dCk6CisgICAgcmV0dXJuIHJlLmNvbXBpbGUo cidePCEtLS4qPy0tPlxzKicsIHJlLkRPVEFMTCkuc3ViKCcnLCB0ZXh0KQorCisKK2RlZiB0cmFu c2xhdGVfaW5jbHVkZXModGV4dCk6CisgICAgIyBNYXBwaW5nIG9mIHNpbmdsZSBmaWxlbmFtZSB0 byByZWxhdGl2ZSBwYXRoIHVuZGVyIFdlYktpdCByb290LgorICAgICMgQXNzdW1wdGlvbjogdGhl c2UgZmlsZW5hbWVzIGFyZSBnbG9iYWxseSB1bmlxdWUuCisgICAgaW5jbHVkZV9tYXBwaW5nID0g eworICAgICAgICAianMtdGVzdC1zdHlsZS5jc3MiOiAiLi4vLi4vanMvcmVzb3VyY2VzIiwKKyAg ICAgICAgImpzLXRlc3QtcHJlLmpzIjogIi4uLy4uL2pzL3Jlc291cmNlcyIsCisgICAgICAgICJq cy10ZXN0LXBvc3QuanMiOiAiLi4vLi4vanMvcmVzb3VyY2VzIiwKKyAgICAgICAgImRlc2t0b3At Z2wtY29uc3RhbnRzLmpzIjogInJlc291cmNlcyIsCisgICAgfQorCisgICAgZm9yIGZpbGVuYW1l LCBwYXRoIGluIGluY2x1ZGVfbWFwcGluZy5pdGVtcygpOgorICAgICAgICBzZWFyY2ggPSByJyg/ OlteIlwnPSBdKi8pPycgKyByZS5lc2NhcGUoZmlsZW5hbWUpCisgICAgICAgIHJlcGxhY2UgPSBv cy5wYXRoLmpvaW4ocGF0aCwgZmlsZW5hbWUpCisgICAgICAgIHRleHQgPSByZS5zdWIoc2VhcmNo LCByZXBsYWNlLCB0ZXh0KQorCisgICAgcmV0dXJuIHRleHQKKworCitkZWYgdHJhbnNsYXRlX2to cm9ub3NfdGVzdCh0ZXh0KToKKyAgICAiIiIKKyAgICBUaGlzIG1ldGhvZCB0cmFuc2xhdGVzIHRo ZSBjb250ZW50cyBvZiBhIEtocm9ub3MgdGVzdCB0byBhIFdlYktpdCB0ZXN0LgorICAgICIiIgor CisgICAgdHJhbnNsYXRlRnVuY3MgPSBbCisgICAgICAgIHJlbW92ZV9maXJzdF9saW5lX2NvbW1l bnQsCisgICAgICAgIHRyYW5zbGF0ZV9pbmNsdWRlcywKKyAgICBdCisKKyAgICBmb3IgZiBpbiB0 cmFuc2xhdGVGdW5jczoKKyAgICAgICAgdGV4dCA9IGYodGV4dCkKKworICAgIHJldHVybiB0ZXh0 CisKKworZGVmIHVwZGF0ZV9maWxlKGluX2ZpbGVuYW1lLCBvdXRfZGlyKToKKyAgICAjIGNoZWNr IGluX2ZpbGVuYW1lIGV4aXN0cworICAgICMgY2hlY2sgb3V0X2RpciBleGlzdHMKKyAgICBvdXRf ZmlsZW5hbWUgPSBvcy5wYXRoLmpvaW4ob3V0X2Rpciwgb3MucGF0aC5iYXNlbmFtZShpbl9maWxl bmFtZSkpCisKKyAgICBfbG9nLmRlYnVnKCJQcm9jZXNzaW5nICIgKyBpbl9maWxlbmFtZSkKKyAg ICB3aXRoIG9wZW4oaW5fZmlsZW5hbWUsICdyJykgYXMgaW5fZmlsZToKKyAgICAgICAgd2l0aCBv cGVuKG91dF9maWxlbmFtZSwgJ3cnKSBhcyBvdXRfZmlsZToKKyAgICAgICAgICAgIG91dF9maWxl LndyaXRlKHRyYW5zbGF0ZV9raHJvbm9zX3Rlc3QoaW5fZmlsZS5yZWFkKCkpKQorCisKK2RlZiB1 cGRhdGVfZGlyZWN0b3J5KGluX2Rpciwgb3V0X2Rpcik6CisgICAgZm9yIGZpbGVuYW1lIGluIGds b2IuZ2xvYihvcy5wYXRoLmpvaW4oaW5fZGlyLCAnKi5odG1sJykpOgorICAgICAgICB1cGRhdGVf ZmlsZShvcy5wYXRoLmpvaW4oaW5fZGlyLCBmaWxlbmFtZSksIG91dF9kaXIpCisKKworZGVmIGRl ZmF1bHRfb3V0X2RpcigpOgorICAgIGN1cnJlbnRfc2NtID0gc2NtLmRldGVjdF9zY21fc3lzdGVt KG9zLnBhdGguZGlybmFtZShzeXMuYXJndlswXSkpCisgICAgaWYgKG5vdCBjdXJyZW50X3NjbSk6 CisgICAgICAgIHJldHVybiBvcy5nZXRjd2QoKQorICAgIHJvb3RfZGlyID0gY3VycmVudF9zY20u Y2hlY2tvdXRfcm9vdAorICAgIGlmIChub3Qgcm9vdF9kaXIpOgorICAgICAgICByZXR1cm4gb3Mu Z2V0Y3dkKCkKKyAgICBvdXRfZGlyID0gb3MucGF0aC5qb2luKHJvb3RfZGlyLCAiTGF5b3V0VGVz dHMvZmFzdC9jYW52YXMvd2ViZ2wiKQorICAgIGlmIChvcy5wYXRoLmlzZGlyKG91dF9kaXIpKToK KyAgICAgICAgcmV0dXJuIG91dF9kaXIKKyAgICBlbHNlOgorICAgICAgICByZXR1cm4gb3MuZ2V0 Y3dkKCkKKworCitkZWYgY29uZmlndXJlX2xvZ2dpbmcob3B0aW9ucyk6CisgICAgIiIiQ29uZmln dXJlcyB0aGUgbG9nZ2luZyBzeXN0ZW0uIiIiCisgICAgbG9nX2ZtdCA9ICclKGxldmVsbmFtZSlz OiAlKG1lc3NhZ2UpcycKKyAgICBsb2dfZGF0ZWZtdCA9ICcleSVtJWQgJUg6JU06JVMnCisgICAg bG9nX2xldmVsID0gbG9nZ2luZy5JTkZPCisgICAgaWYgb3B0aW9ucy52ZXJib3NlOgorICAgICAg ICBsb2dfZm10ID0gKCclKGFzY3RpbWUpcyAlKGZpbGVuYW1lKXM6JShsaW5lbm8pLTRkICUobGV2 ZWxuYW1lKXMgJworICAgICAgICAgICAgICAgICAgICclKG1lc3NhZ2UpcycpCisgICAgICAgIGxv Z19sZXZlbCA9IGxvZ2dpbmcuREVCVUcKKyAgICBsb2dnaW5nLmJhc2ljQ29uZmlnKGxldmVsPWxv Z19sZXZlbCwgZm9ybWF0PWxvZ19mbXQsCisgICAgICAgICAgICAgICAgICAgICAgICBkYXRlZm10 PWxvZ19kYXRlZm10KQorCisKK2RlZiBnZXRfb3B0aW9uX3BhcnNlcigpOgorICAgIHVzYWdlID0g InVzYWdlOiAlcHJvZyBbb3B0aW9uc10gKGlucHV0IGZpbGUgb3IgZGlyZWN0b3J5KSIKKyAgICBv cHRpb25fcGFyc2VyID0gb3B0cGFyc2UuT3B0aW9uUGFyc2VyKHVzYWdlPXVzYWdlKQorICAgIG9w dGlvbl9wYXJzZXIuYWRkX29wdGlvbignLXYnLCAnLS12ZXJib3NlJywKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgYWN0aW9uPSdzdG9yZV90cnVlJywKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZGVmYXVsdD1GYWxzZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaGVs cD0naW5jbHVkZSBkZWJ1Zy1sZXZlbCBsb2dnaW5nJykKKyAgICBvcHRpb25fcGFyc2VyLmFkZF9v cHRpb24oJy1vJywgJy0tb3V0cHV0JywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWN0 aW9uPSdzdG9yZScsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHR5cGU9J3N0cmluZycs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRlZmF1bHQ9ZGVmYXVsdF9vdXRfZGlyKCks CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1ldGF2YXI9J0RJUicsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGhlbHA9J3NwZWNpZnkgYW4gb3V0cHV0IGRpcmVjdG9yeSB0byBw bGFjZSBmaWxlcyAnCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ2luIFtkZWZh dWx0OiAlZGVmYXVsdF0nKQorICAgIHJldHVybiBvcHRpb25fcGFyc2VyCisKKworZGVmIG1haW4o KToKKyAgICBvcHRpb25fcGFyc2VyID0gZ2V0X29wdGlvbl9wYXJzZXIoKQorICAgIChvcHRpb25z LCBhcmdzKSA9IG9wdGlvbl9wYXJzZXIucGFyc2VfYXJncygpCisgICAgY29uZmlndXJlX2xvZ2dp bmcob3B0aW9ucykKKworICAgIGlmIChsZW4oYXJncykgPT0gMCk6CisgICAgICAgIF9sb2cuZXJy b3IoIk11c3Qgc3BlY2lmeSBhbiBpbnB1dCBkaXJlY3Rvcnkgb3IgZmlsZW5hbWUuIikKKyAgICAg ICAgb3B0aW9uX3BhcnNlci5wcmludF9oZWxwKCkKKyAgICAgICAgc3lzLmV4aXQoMSkKKworICAg IGluX25hbWUgPSBhcmdzWzBdCisgICAgaWYgKG9zLnBhdGguaXNmaWxlKGluX25hbWUpKToKKyAg ICAgICAgdXBkYXRlX2ZpbGUoaW5fbmFtZSwgb3B0aW9ucy5vdXRwdXQpCisgICAgZWxpZiAob3Mu cGF0aC5pc2Rpcihpbl9uYW1lKSk6CisgICAgICAgIHVwZGF0ZV9kaXJlY3RvcnkoaW5fbmFtZSwg b3B0aW9ucy5vdXRwdXQpCisgICAgZWxzZToKKyAgICAgICAgX2xvZy5lcnJvcigiJyIgKyBpbl9u YW1lICsgIicgaXMgbm90IGEgZGlyZWN0b3J5IG9yIGEgZmlsZS4iKQorICAgICAgICBzeXMuZXhp dCgyKQorCisgICAgc3lzLmV4aXQoMCkKKworaWYgX19uYW1lX18gPT0gIl9fbWFpbl9fIjoKKyAg ICBtYWluKCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0c191bml0dGVzdC5weSBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3Jt YW5jZV90ZXN0c191bml0dGVzdC5weQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iY2Y3OGQ2ZDljODQ4NjBkYjZhNjAw MmFlZjJjNjNkMTkyMzM2ZWFjCi0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3RzX3Vu aXR0ZXN0LnB5CkBAIC0wLDAgKzEsMTA3IEBACisjIS91c3IvYmluL3B5dGhvbgorIyBDb3B5cmln aHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucyBhcmUKKyMgbWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisj ICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUKKyMgY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorIyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMgICAgICog TmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworIyBj b250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRl cml2ZWQgZnJvbQorIyB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRl biBwZXJtaXNzaW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZ UklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8s IFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UgorIyBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgVEhFIENPUFlSSUdIVAorIyBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwKKyMgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZCisjIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCisKKyIiIlVuaXQgdGVzdHMgZm9yIHVwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0 cy4iIiIKKworaW1wb3J0IHVuaXR0ZXN0Citmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cyBpbXBv cnQgdXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3RzIGFzIHdlYmdsCisKKworZGVmIGNvbnN0 cnVjdF9zY3JpcHQobmFtZSk6CisgICAgcmV0dXJuICI8c2NyaXB0IHNyYz1cIiIgKyBuYW1lICsg IlwiPjwvc2NyaXB0PlxuIgorCisKK2RlZiBjb25zdHJ1Y3Rfc3R5bGUobmFtZSk6CisgICAgcmV0 dXJuICI8bGluayByZWw9XCJzdHlsZXNoZWV0XCIgaHJlZj1cIiIgKyBuYW1lICsgIlwiPiIKKwor CitjbGFzcyBUZXN0VHJhbnNsYXRpb24odW5pdHRlc3QuVGVzdENhc2UpOgorICAgIGRlZiBhc3Nl cnRfdW5jaGFuZ2VkKHNlbGYsIHRleHQpOgorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHRleHQs IHdlYmdsLnRyYW5zbGF0ZV9raHJvbm9zX3Rlc3QodGV4dCkpCisKKyAgICBkZWYgYXNzZXJ0X3Ry YW5zbGF0ZShzZWxmLCBpbnB1dCwgb3V0cHV0KToKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChv dXRwdXQsIHdlYmdsLnRyYW5zbGF0ZV9raHJvbm9zX3Rlc3QoaW5wdXQpKQorCisgICAgZGVmIHRl c3Rfc2ltcGxlX3VuY2hhbmdlZChzZWxmKToKKyAgICAgICAgc2VsZi5hc3NlcnRfdW5jaGFuZ2Vk KCIiKQorICAgICAgICBzZWxmLmFzc2VydF91bmNoYW5nZWQoIjxodG1sPjwvaHRtbD4iKQorCisg ICAgZGVmIHRlc3RfaGVhZGVyX3N0cmlwKHNlbGYpOgorICAgICAgICBzaW5nbGVfbGluZV9oZWFk ZXIgPSAiPCEtLSBzaW5nbGUgbGluZSBoZWFkZXIuIC0tPiIKKyAgICAgICAgbXVsdGlfbGluZV9o ZWFkZXIgPSAiIiI8IS0tIHRoaXMgaXMgYSBtdWx0aS1saW5lCisgICAgICAgICAgICAgICAgaGVh ZGVyLiAgaXQgc2hvdWxkIGFsbCBiZSByZW1vdmVkIHRvby4KKyAgICAgICAgICAgICAgICAtLT4i IiIKKyAgICAgICAgdGV4dCA9ICI8aHRtbD48L2h0bWw+IgorICAgICAgICBzZWxmLmFzc2VydF90 cmFuc2xhdGUoc2luZ2xlX2xpbmVfaGVhZGVyLCAiIikKKyAgICAgICAgc2VsZi5hc3NlcnRfdHJh bnNsYXRlKHNpbmdsZV9saW5lX2hlYWRlciArIHRleHQsIHRleHQpCisgICAgICAgIHNlbGYuYXNz ZXJ0X3RyYW5zbGF0ZShtdWx0aV9saW5lX2hlYWRlciArIHRleHQsIHRleHQpCisKKyAgICBkZWYg ZG9udF9zdHJpcF9vdGhlcl9oZWFkZXJzKHNlbGYpOgorICAgICAgICBzZWxmLmFzc2VydF91bmNo YW5nZWQoIjxodG1sPlxuPCEtLSBkb24ndCByZW1vdmUgY29tbWVudHMgb24gb3RoZXIgbGluZXMu IC0tPlxuPC9odG1sPiIpCisKKyAgICBkZWYgdGVzdF9pbmNsdWRlX3Jld3JpdGluZyhzZWxmKToK KyAgICAgICAgIyBNYXBwaW5ncyB0byBOb25lIGFyZSB1bmNoYW5nZWQKKyAgICAgICAgc3R5bGVz ID0geworICAgICAgICAgICAgIi4uL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI6ICIuLi8u Li9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiLAorICAgICAgICAgICAgImZhaWwuY3Nz IjogTm9uZSwKKyAgICAgICAgICAgICJyZXNvdXJjZXMvc3R5bGVzaGVldC5jc3MiOiBOb25lLAor ICAgICAgICAgICAgIi4uL3Jlc291cmNlcy9zdHlsZS5jc3MiOiBOb25lLAorICAgICAgICB9Cisg ICAgICAgIHNjcmlwdHMgPSB7CisgICAgICAgICAgICAiLi4vcmVzb3VyY2VzL2pzLXRlc3QtcHJl LmpzIjogIi4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyIsCisgICAgICAgICAgICAi Li4vcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI6ICIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1wb3N0LmpzIiwKKyAgICAgICAgICAgICIuLi9yZXNvdXJjZXMvZGVza3RvcC1nbC1jb25zdGFu dHMuanMiOiAicmVzb3VyY2VzL2Rlc2t0b3AtZ2wtY29uc3RhbnRzLmpzIiwKKworICAgICAgICAg ICAgInJlc291cmNlcy9zaGFkb3ctb2Zmc2V0LmpzIjogTm9uZSwKKyAgICAgICAgICAgICIuLi9y ZXNvdXJjZXMvanMtdGVzdC1wb3N0LWFzeW5jLmpzIjogTm9uZSwKKyAgICAgICAgfQorCisgICAg ICAgIGlucHV0X3RleHQgPSAiIgorICAgICAgICBvdXRwdXRfdGV4dCA9ICIiCisgICAgICAgIGZv ciBpbnB1dCwgb3V0cHV0IGluIHN0eWxlcy5pdGVtcygpOgorICAgICAgICAgICAgaW5wdXRfdGV4 dCArPSBjb25zdHJ1Y3Rfc3R5bGUoaW5wdXQpCisgICAgICAgICAgICBpZiAob3V0cHV0KToKKyAg ICAgICAgICAgICAgICBvdXRwdXRfdGV4dCArPSBjb25zdHJ1Y3Rfc3R5bGUob3V0cHV0KQorICAg ICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAgICBvdXRwdXRfdGV4dCArPSBjb25zdHJ1Y3Rf c3R5bGUoaW5wdXQpCisgICAgICAgIGZvciBpbnB1dCwgb3V0cHV0IGluIHNjcmlwdHMuaXRlbXMo KToKKyAgICAgICAgICAgIGlucHV0X3RleHQgKz0gY29uc3RydWN0X3NjcmlwdChpbnB1dCkKKyAg ICAgICAgICAgIGlmIChvdXRwdXQpOgorICAgICAgICAgICAgICAgIG91dHB1dF90ZXh0ICs9IGNv bnN0cnVjdF9zY3JpcHQob3V0cHV0KQorICAgICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAg ICBvdXRwdXRfdGV4dCArPSBjb25zdHJ1Y3Rfc2NyaXB0KGlucHV0KQorCisgICAgICAgIGhlYWQg PSAnPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPlxuPGh0bWw+ XG48aGVhZD5cbicKKyAgICAgICAgZm9vdCA9ICc8L2hlYWQ+XG48Ym9keT5cbjwvYm9keT5cbjwv aHRtbD4nCisgICAgICAgIGlucHV0X3RleHQgPSBoZWFkICsgaW5wdXRfdGV4dCArIGZvb3QKKyAg ICAgICAgb3V0cHV0X3RleHQgPSBoZWFkICsgb3V0cHV0X3RleHQgKyBmb290CisgICAgICAgIHNl bGYuYXNzZXJ0X3RyYW5zbGF0ZShpbnB1dF90ZXh0LCBvdXRwdXRfdGV4dCkKKworaWYgX19uYW1l X18gPT0gJ19fbWFpbl9fJzoKKyAgICB1bml0dGVzdC5tYWluKCkK 66785 2010-09-07 16:25:20 -0700 2010-09-15 19:32:27 -0700 Patch bug-42336-20100907162513.patch text/plain 13551 enne ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBiNDc5N2QwMjc5Nzc5N2JmOWFjYmU2OGM4OWI1MjM0NzI4M2U2NWY2Li4wMGUyZGZk N2JkNDI2MzhhMzJiNTk1ZjcwMDk0ZmMyZWYwNzg4NjkwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTAtMDktMDIgIEFkcmllbm5lIFdhbGtlciAgPGVubmVAZ29vZ2xlLmNvbT4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgc2NyaXB0IHRvIHN5 bmNocm9uaXplIFdlYktpdCBhbmQgS2hyb25vcyBXZWJHTCB0ZXN0cworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDIzMzYKKworICAgICAgICAqIFNjcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzOiBBZGRlZC4KKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHMu cHk6IEFkZGVkLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0 ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0c191bml0dGVzdC5weTogQWRkZWQuCisKIDIwMTAtMDkt MDEgIEdhYm9yIFJhcGNzYW55aSAgPHJnYWJvckBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgQW50b25pbyBHb21lcy4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy91 cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZGZlMjBhMTllM2NiZmU5 ZTA4OGMyNTcwNDM5NjEyMzBlMWNiNmY1ZAotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzCkBAIC0wLDAgKzEsMzYgQEAK KyMhL3Vzci9iaW4vZW52IHB5dGhvbgorIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMg bWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor IyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMgICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworIyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorIyB0aGlzIHNvZnR3 YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorIworIyBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJ QlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorIyBBIFBBUlRJQ1VMQVIgUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorIyBPV05F UiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyMgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisjIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKyIiIldyYXBwZXIgYXJv dW5kIHdlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMu cHkiIiIKKworaW1wb3J0IHdlYmtpdHB5LmxheW91dF90ZXN0cy51cGRhdGVfd2ViZ2xfY29uZm9y bWFuY2VfdGVzdHMKK2ltcG9ydCBzeXMKKworaWYgX19uYW1lX18gPT0gJ19fbWFpbl9fJzoKKyAg ICBzeXMuZXhpdCh3ZWJraXRweS5sYXlvdXRfdGVzdHMudXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNl X3Rlc3RzLm1haW4oKSkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5weSBiL1dlYktpdFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5j ZV90ZXN0cy5weQpuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jMWFiNzM3Y2ExNDc0NmM5MjZmNGEyZGQ4MTRiODNkZjk4 NDFiZjU5Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvdXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3RzLnB5CkBAIC0wLDAgKzEs MTYwIEBACisjIS91c3IvYmluL2VudiBweXRob24KKworIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29v Z2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworIyBhcmUgbWV0OgorIyAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyMgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorIyBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRI RQorIyBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIKKyMgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNI QUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisjIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorIyBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisjIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUgorIyBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisjIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKworZnJvbSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRlbWVudAorCitpbXBv cnQgZ2xvYgoraW1wb3J0IGxvZ2dpbmcKK2ltcG9ydCBvcHRwYXJzZQoraW1wb3J0IG9zCitpbXBv cnQgcmUKK2ltcG9ydCBzeXMKK2ltcG9ydCB3ZWJraXRweS5jb21tb24uY2hlY2tvdXQuc2NtIGFz IHNjbQorCitfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy4i CisgICAgICAgICAgICAgICAgICAgICAgICAgInVwZGF0ZS13ZWJnbC1jb25mb3JtYW5jZS10ZXN0 cyIpCisKKworZGVmIHJlbW92ZV9maXJzdF9saW5lX2NvbW1lbnQodGV4dCk6CisgICAgcmV0dXJu IHJlLmNvbXBpbGUocidePCEtLS4qPy0tPlxzKicsIHJlLkRPVEFMTCkuc3ViKCcnLCB0ZXh0KQor CisKK2RlZiB0cmFuc2xhdGVfaW5jbHVkZXModGV4dCk6CisgICAgIyBNYXBwaW5nIG9mIHNpbmds ZSBmaWxlbmFtZSB0byByZWxhdGl2ZSBwYXRoIHVuZGVyIFdlYktpdCByb290LgorICAgICMgQXNz dW1wdGlvbjogdGhlc2UgZmlsZW5hbWVzIGFyZSBnbG9iYWxseSB1bmlxdWUuCisgICAgaW5jbHVk ZV9tYXBwaW5nID0geworICAgICAgICAianMtdGVzdC1zdHlsZS5jc3MiOiAiLi4vLi4vanMvcmVz b3VyY2VzIiwKKyAgICAgICAgImpzLXRlc3QtcHJlLmpzIjogIi4uLy4uL2pzL3Jlc291cmNlcyIs CisgICAgICAgICJqcy10ZXN0LXBvc3QuanMiOiAiLi4vLi4vanMvcmVzb3VyY2VzIiwKKyAgICAg ICAgImRlc2t0b3AtZ2wtY29uc3RhbnRzLmpzIjogInJlc291cmNlcyIsCisgICAgfQorCisgICAg Zm9yIGZpbGVuYW1lLCBwYXRoIGluIGluY2x1ZGVfbWFwcGluZy5pdGVtcygpOgorICAgICAgICBz ZWFyY2ggPSByJyg/OlteIlwnPSBdKi8pPycgKyByZS5lc2NhcGUoZmlsZW5hbWUpCisgICAgICAg IHJlcGxhY2UgPSBvcy5wYXRoLmpvaW4ocGF0aCwgZmlsZW5hbWUpCisgICAgICAgIHRleHQgPSBy ZS5zdWIoc2VhcmNoLCByZXBsYWNlLCB0ZXh0KQorCisgICAgcmV0dXJuIHRleHQKKworCitkZWYg dHJhbnNsYXRlX2tocm9ub3NfdGVzdCh0ZXh0KToKKyAgICAiIiIKKyAgICBUaGlzIG1ldGhvZCB0 cmFuc2xhdGVzIHRoZSBjb250ZW50cyBvZiBhIEtocm9ub3MgdGVzdCB0byBhIFdlYktpdCB0ZXN0 LgorICAgICIiIgorCisgICAgdHJhbnNsYXRlRnVuY3MgPSBbCisgICAgICAgIHJlbW92ZV9maXJz dF9saW5lX2NvbW1lbnQsCisgICAgICAgIHRyYW5zbGF0ZV9pbmNsdWRlcywKKyAgICBdCisKKyAg ICBmb3IgZiBpbiB0cmFuc2xhdGVGdW5jczoKKyAgICAgICAgdGV4dCA9IGYodGV4dCkKKworICAg IHJldHVybiB0ZXh0CisKKworZGVmIHVwZGF0ZV9maWxlKGluX2ZpbGVuYW1lLCBvdXRfZGlyKToK KyAgICAjIGNoZWNrIGluX2ZpbGVuYW1lIGV4aXN0cworICAgICMgY2hlY2sgb3V0X2RpciBleGlz dHMKKyAgICBvdXRfZmlsZW5hbWUgPSBvcy5wYXRoLmpvaW4ob3V0X2Rpciwgb3MucGF0aC5iYXNl bmFtZShpbl9maWxlbmFtZSkpCisKKyAgICBfbG9nLmRlYnVnKCJQcm9jZXNzaW5nICIgKyBpbl9m aWxlbmFtZSkKKyAgICB3aXRoIG9wZW4oaW5fZmlsZW5hbWUsICdyJykgYXMgaW5fZmlsZToKKyAg ICAgICAgd2l0aCBvcGVuKG91dF9maWxlbmFtZSwgJ3cnKSBhcyBvdXRfZmlsZToKKyAgICAgICAg ICAgIG91dF9maWxlLndyaXRlKHRyYW5zbGF0ZV9raHJvbm9zX3Rlc3QoaW5fZmlsZS5yZWFkKCkp KQorCisKK2RlZiB1cGRhdGVfZGlyZWN0b3J5KGluX2Rpciwgb3V0X2Rpcik6CisgICAgZm9yIGZp bGVuYW1lIGluIGdsb2IuZ2xvYihvcy5wYXRoLmpvaW4oaW5fZGlyLCAnKi5odG1sJykpOgorICAg ICAgICB1cGRhdGVfZmlsZShvcy5wYXRoLmpvaW4oaW5fZGlyLCBmaWxlbmFtZSksIG91dF9kaXIp CisKKworZGVmIGRlZmF1bHRfb3V0X2RpcigpOgorICAgIGN1cnJlbnRfc2NtID0gc2NtLmRldGVj dF9zY21fc3lzdGVtKG9zLnBhdGguZGlybmFtZShzeXMuYXJndlswXSkpCisgICAgaWYgbm90IGN1 cnJlbnRfc2NtOgorICAgICAgICByZXR1cm4gb3MuZ2V0Y3dkKCkKKyAgICByb290X2RpciA9IGN1 cnJlbnRfc2NtLmNoZWNrb3V0X3Jvb3QKKyAgICBpZiBub3Qgcm9vdF9kaXI6CisgICAgICAgIHJl dHVybiBvcy5nZXRjd2QoKQorICAgIG91dF9kaXIgPSBvcy5wYXRoLmpvaW4ocm9vdF9kaXIsICJM YXlvdXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbCIpCisgICAgaWYgb3MucGF0aC5pc2RpcihvdXRf ZGlyKToKKyAgICAgICAgcmV0dXJuIG91dF9kaXIKKyAgICBlbHNlOgorICAgICAgICByZXR1cm4g b3MuZ2V0Y3dkKCkKKworCitkZWYgY29uZmlndXJlX2xvZ2dpbmcob3B0aW9ucyk6CisgICAgIiIi Q29uZmlndXJlcyB0aGUgbG9nZ2luZyBzeXN0ZW0uIiIiCisgICAgbG9nX2ZtdCA9ICclKGxldmVs bmFtZSlzOiAlKG1lc3NhZ2UpcycKKyAgICBsb2dfZGF0ZWZtdCA9ICcleSVtJWQgJUg6JU06JVMn CisgICAgbG9nX2xldmVsID0gbG9nZ2luZy5JTkZPCisgICAgaWYgb3B0aW9ucy52ZXJib3NlOgor ICAgICAgICBsb2dfZm10ID0gKCclKGFzY3RpbWUpcyAlKGZpbGVuYW1lKXM6JShsaW5lbm8pLTRk ICUobGV2ZWxuYW1lKXMgJworICAgICAgICAgICAgICAgICAgICclKG1lc3NhZ2UpcycpCisgICAg ICAgIGxvZ19sZXZlbCA9IGxvZ2dpbmcuREVCVUcKKyAgICBsb2dnaW5nLmJhc2ljQ29uZmlnKGxl dmVsPWxvZ19sZXZlbCwgZm9ybWF0PWxvZ19mbXQsCisgICAgICAgICAgICAgICAgICAgICAgICBk YXRlZm10PWxvZ19kYXRlZm10KQorCisKK2RlZiBvcHRpb25fcGFyc2VyKCk6CisgICAgdXNhZ2Ug PSAidXNhZ2U6ICVwcm9nIFtvcHRpb25zXSAoaW5wdXQgZmlsZSBvciBkaXJlY3RvcnkpIgorICAg IHBhcnNlciA9IG9wdHBhcnNlLk9wdGlvblBhcnNlcih1c2FnZT11c2FnZSkKKyAgICBwYXJzZXIu YWRkX29wdGlvbignLXYnLCAnLS12ZXJib3NlJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgYWN0aW9uPSdzdG9yZV90cnVlJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGVm YXVsdD1GYWxzZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0naW5jbHVkZSBk ZWJ1Zy1sZXZlbCBsb2dnaW5nJykKKyAgICBwYXJzZXIuYWRkX29wdGlvbignLW8nLCAnLS1vdXRw dXQnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhY3Rpb249J3N0b3JlJywKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgdHlwZT0nc3RyaW5nJywKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgZGVmYXVsdD1kZWZhdWx0X291dF9kaXIoKSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgbWV0YXZhcj0nRElSJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg aGVscD0nc3BlY2lmeSBhbiBvdXRwdXQgZGlyZWN0b3J5IHRvIHBsYWNlIGZpbGVzICcKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnaW4gW2RlZmF1bHQ6ICVkZWZhdWx0XScpCisg ICAgcmV0dXJuIHBhcnNlcgorCisKK2RlZiBtYWluKCk6CisgICAgcGFyc2VyID0gb3B0aW9uX3Bh cnNlcigpCisgICAgKG9wdGlvbnMsIGFyZ3MpID0gcGFyc2VyLnBhcnNlX2FyZ3MoKQorICAgIGNv bmZpZ3VyZV9sb2dnaW5nKG9wdGlvbnMpCisKKyAgICBpZiBsZW4oYXJncykgPT0gMDoKKyAgICAg ICAgX2xvZy5lcnJvcigiTXVzdCBzcGVjaWZ5IGFuIGlucHV0IGRpcmVjdG9yeSBvciBmaWxlbmFt ZS4iKQorICAgICAgICBwYXJzZXIucHJpbnRfaGVscCgpCisgICAgICAgIHJldHVybiAxCisKKyAg ICBpbl9uYW1lID0gYXJnc1swXQorICAgIGlmIG9zLnBhdGguaXNmaWxlKGluX25hbWUpOgorICAg ICAgICB1cGRhdGVfZmlsZShpbl9uYW1lLCBvcHRpb25zLm91dHB1dCkKKyAgICBlbGlmIChvcy5w YXRoLmlzZGlyKGluX25hbWUpKToKKyAgICAgICAgdXBkYXRlX2RpcmVjdG9yeShpbl9uYW1lLCBv cHRpb25zLm91dHB1dCkKKyAgICBlbHNlOgorICAgICAgICBfbG9nLmVycm9yKCInJXMnIGlzIG5v dCBhIGRpcmVjdG9yeSBvciBhIGZpbGUuIiwgaW5fbmFtZSkKKyAgICAgICAgcmV0dXJuIDIKKwor ICAgIHJldHVybiAwCisKK2lmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CisgICAgc3lzLmV4aXQo bWFpbigpKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvdXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3RzX3VuaXR0ZXN0LnB5IGIvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdXBkYXRlX3dlYmdsX2NvbmZvcm1h bmNlX3Rlc3RzX3VuaXR0ZXN0LnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmIxMDllODEwNTUwNmQ5OGMxM2Y4ODI3 ZWUwNzAxZTY3YjhiMDQ1YjkKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHNfdW5p dHRlc3QucHkKQEAgLTAsMCArMSwxMDEgQEAKKyMhL3Vzci9iaW4vcHl0aG9uCisjIENvcHlyaWdo dCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorIworIyBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zIGFyZQorIyBtZXQ6CisjCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMg ICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZQorIyBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyCisjIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyMgZGlzdHJpYnV0aW9uLgorIyAgICAgKiBO ZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisjIGNv bnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVy aXZlZCBmcm9tCisjIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVu IHBlcm1pc3Npb24uCisjCisjIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlS SUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyMgIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywg VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S CisjIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFM TCBUSEUgQ09QWVJJR0hUCisjIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorIyBTUEVDSUFMLCBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LAorIyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkKKyMgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKworIiIiVW5pdCB0ZXN0cyBmb3IgdXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3Rz LiIiIgorCitpbXBvcnQgdW5pdHRlc3QKK2Zyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzIGltcG9y dCB1cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHMgYXMgd2ViZ2wKKworCitkZWYgY29uc3Ry dWN0X3NjcmlwdChuYW1lKToKKyAgICByZXR1cm4gIjxzY3JpcHQgc3JjPVwiIiArIG5hbWUgKyAi XCI+PC9zY3JpcHQ+XG4iCisKKworZGVmIGNvbnN0cnVjdF9zdHlsZShuYW1lKToKKyAgICByZXR1 cm4gIjxsaW5rIHJlbD1cInN0eWxlc2hlZXRcIiBocmVmPVwiIiArIG5hbWUgKyAiXCI+IgorCisK K2NsYXNzIFRlc3RUcmFuc2xhdGlvbih1bml0dGVzdC5UZXN0Q2FzZSk6CisgICAgZGVmIGFzc2Vy dF91bmNoYW5nZWQoc2VsZiwgdGV4dCk6CisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwodGV4dCwg d2ViZ2wudHJhbnNsYXRlX2tocm9ub3NfdGVzdCh0ZXh0KSkKKworICAgIGRlZiBhc3NlcnRfdHJh bnNsYXRlKHNlbGYsIGlucHV0LCBvdXRwdXQpOgorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKG91 dHB1dCwgd2ViZ2wudHJhbnNsYXRlX2tocm9ub3NfdGVzdChpbnB1dCkpCisKKyAgICBkZWYgdGVz dF9zaW1wbGVfdW5jaGFuZ2VkKHNlbGYpOgorICAgICAgICBzZWxmLmFzc2VydF91bmNoYW5nZWQo IiIpCisgICAgICAgIHNlbGYuYXNzZXJ0X3VuY2hhbmdlZCgiPGh0bWw+PC9odG1sPiIpCisKKyAg ICBkZWYgdGVzdF9oZWFkZXJfc3RyaXAoc2VsZik6CisgICAgICAgIHNpbmdsZV9saW5lX2hlYWRl ciA9ICI8IS0tIHNpbmdsZSBsaW5lIGhlYWRlci4gLS0+IgorICAgICAgICBtdWx0aV9saW5lX2hl YWRlciA9ICIiIjwhLS0gdGhpcyBpcyBhIG11bHRpLWxpbmUKKyAgICAgICAgICAgICAgICBoZWFk ZXIuICBpdCBzaG91bGQgYWxsIGJlIHJlbW92ZWQgdG9vLgorICAgICAgICAgICAgICAgIC0tPiIi IgorICAgICAgICB0ZXh0ID0gIjxodG1sPjwvaHRtbD4iCisgICAgICAgIHNlbGYuYXNzZXJ0X3Ry YW5zbGF0ZShzaW5nbGVfbGluZV9oZWFkZXIsICIiKQorICAgICAgICBzZWxmLmFzc2VydF90cmFu c2xhdGUoc2luZ2xlX2xpbmVfaGVhZGVyICsgdGV4dCwgdGV4dCkKKyAgICAgICAgc2VsZi5hc3Nl cnRfdHJhbnNsYXRlKG11bHRpX2xpbmVfaGVhZGVyICsgdGV4dCwgdGV4dCkKKworICAgIGRlZiBk b250X3N0cmlwX290aGVyX2hlYWRlcnMoc2VsZik6CisgICAgICAgIHNlbGYuYXNzZXJ0X3VuY2hh bmdlZCgiPGh0bWw+XG48IS0tIGRvbid0IHJlbW92ZSBjb21tZW50cyBvbiBvdGhlciBsaW5lcy4g LS0+XG48L2h0bWw+IikKKworICAgIGRlZiB0ZXN0X2luY2x1ZGVfcmV3cml0aW5nKHNlbGYpOgor ICAgICAgICAjIE1hcHBpbmdzIHRvIE5vbmUgYXJlIHVuY2hhbmdlZAorICAgICAgICBzdHlsZXMg PSB7CisgICAgICAgICAgICAiLi4vcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIjogIi4uLy4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyIsCisgICAgICAgICAgICAiZmFpbC5jc3Mi OiBOb25lLAorICAgICAgICAgICAgInJlc291cmNlcy9zdHlsZXNoZWV0LmNzcyI6IE5vbmUsCisg ICAgICAgICAgICAiLi4vcmVzb3VyY2VzL3N0eWxlLmNzcyI6IE5vbmUsCisgICAgICAgIH0KKyAg ICAgICAgc2NyaXB0cyA9IHsKKyAgICAgICAgICAgICIuLi9yZXNvdXJjZXMvanMtdGVzdC1wcmUu anMiOiAiLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIiwKKyAgICAgICAgICAgICIu Li9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIjogIi4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0 LXBvc3QuanMiLAorICAgICAgICAgICAgIi4uL3Jlc291cmNlcy9kZXNrdG9wLWdsLWNvbnN0YW50 cy5qcyI6ICJyZXNvdXJjZXMvZGVza3RvcC1nbC1jb25zdGFudHMuanMiLAorCisgICAgICAgICAg ICAicmVzb3VyY2VzL3NoYWRvdy1vZmZzZXQuanMiOiBOb25lLAorICAgICAgICAgICAgIi4uL3Jl c291cmNlcy9qcy10ZXN0LXBvc3QtYXN5bmMuanMiOiBOb25lLAorICAgICAgICB9CisKKyAgICAg ICAgaW5wdXRfdGV4dCA9ICIiCisgICAgICAgIG91dHB1dF90ZXh0ID0gIiIKKyAgICAgICAgZm9y IGlucHV0LCBvdXRwdXQgaW4gc3R5bGVzLml0ZW1zKCk6CisgICAgICAgICAgICBpbnB1dF90ZXh0 ICs9IGNvbnN0cnVjdF9zdHlsZShpbnB1dCkKKyAgICAgICAgICAgIG91dHB1dF90ZXh0ICs9IGNv bnN0cnVjdF9zdHlsZShvdXRwdXQgaWYgb3V0cHV0IGVsc2UgaW5wdXQpCisgICAgICAgIGZvciBp bnB1dCwgb3V0cHV0IGluIHNjcmlwdHMuaXRlbXMoKToKKyAgICAgICAgICAgIGlucHV0X3RleHQg Kz0gY29uc3RydWN0X3NjcmlwdChpbnB1dCkKKyAgICAgICAgICAgIG91dHB1dF90ZXh0ICs9IGNv bnN0cnVjdF9zY3JpcHQob3V0cHV0IGlmIG91dHB1dCBlbHNlIGlucHV0KQorCisgICAgICAgIGhl YWQgPSAnPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPlxuPGh0 bWw+XG48aGVhZD5cbicKKyAgICAgICAgZm9vdCA9ICc8L2hlYWQ+XG48Ym9keT5cbjwvYm9keT5c bjwvaHRtbD4nCisgICAgICAgIGlucHV0X3RleHQgPSBoZWFkICsgaW5wdXRfdGV4dCArIGZvb3QK KyAgICAgICAgb3V0cHV0X3RleHQgPSBoZWFkICsgb3V0cHV0X3RleHQgKyBmb290CisgICAgICAg IHNlbGYuYXNzZXJ0X3RyYW5zbGF0ZShpbnB1dF90ZXh0LCBvdXRwdXRfdGV4dCkKKworaWYgX19u YW1lX18gPT0gJ19fbWFpbl9fJzoKKyAgICB1bml0dGVzdC5tYWluKCkK 67761 2010-09-15 19:32:56 -0700 2010-09-16 14:44:36 -0700 Patch bug-42336-20100915193254.patch text/plain 13538 enne ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBiNDc5N2QwMjc5Nzc5N2JmOWFjYmU2OGM4OWI1MjM0NzI4M2U2NWY2Li4wMGUyZGZk N2JkNDI2MzhhMzJiNTk1ZjcwMDk0ZmMyZWYwNzg4NjkwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAK KzIwMTAtMDktMDIgIEFkcmllbm5lIFdhbGtlciAgPGVubmVAZ29vZ2xlLmNvbT4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgc2NyaXB0IHRvIHN5 bmNocm9uaXplIFdlYktpdCBhbmQgS2hyb25vcyBXZWJHTCB0ZXN0cworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDIzMzYKKworICAgICAgICAqIFNjcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzOiBBZGRlZC4KKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHMu cHk6IEFkZGVkLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0 ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0c191bml0dGVzdC5weTogQWRkZWQuCisKIDIwMTAtMDkt MDEgIEdhYm9yIFJhcGNzYW55aSAgPHJnYWJvckBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgQW50b25pbyBHb21lcy4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy91 cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZGZlMjBhMTllM2NiZmU5 ZTA4OGMyNTcwNDM5NjEyMzBlMWNiNmY1ZAotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvdXBkYXRlLXdlYmdsLWNvbmZvcm1hbmNlLXRlc3RzCkBAIC0wLDAgKzEsMzYgQEAK KyMhL3Vzci9iaW4vZW52IHB5dGhvbgorIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMg bWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor IyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMgICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworIyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorIyB0aGlzIHNvZnR3 YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorIworIyBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJ QlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorIyBBIFBBUlRJQ1VMQVIgUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorIyBPV05F UiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyMgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisjIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKyIiIldyYXBwZXIgYXJv dW5kIHdlYmtpdHB5L2xheW91dF90ZXN0cy91cGRhdGUtd2ViZ2wtY29uZm9ybWFuY2UtdGVzdHMu cHkiIiIKKworaW1wb3J0IHdlYmtpdHB5LmxheW91dF90ZXN0cy51cGRhdGVfd2ViZ2xfY29uZm9y bWFuY2VfdGVzdHMKK2ltcG9ydCBzeXMKKworaWYgX19uYW1lX18gPT0gJ19fbWFpbl9fJzoKKyAg ICBzeXMuZXhpdCh3ZWJraXRweS5sYXlvdXRfdGVzdHMudXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNl X3Rlc3RzLm1haW4oKSkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5jZV90ZXN0cy5weSBiL1dlYktpdFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3VwZGF0ZV93ZWJnbF9jb25mb3JtYW5j ZV90ZXN0cy5weQpuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mNGM4MDk4YzY2MjkzZWQxYzc1OWM0Yjk1ZDQ5MjE0ZjVi ZjY5Zjc5Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvdXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3RzLnB5CkBAIC0wLDAgKzEs MTYwIEBACisjIS91c3IvYmluL2VudiBweXRob24KKworIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29v Z2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworIyBhcmUgbWV0OgorIyAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyMgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHBy b3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorIyBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRI RQorIyBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIKKyMgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNI QUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisjIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorIyBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisjIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUgorIyBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisjIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKworZnJvbSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRlbWVudAorCitpbXBv cnQgZ2xvYgoraW1wb3J0IGxvZ2dpbmcKK2ltcG9ydCBvcHRwYXJzZQoraW1wb3J0IG9zCitpbXBv cnQgcmUKK2ltcG9ydCBzeXMKK2ltcG9ydCB3ZWJraXRweS5jb21tb24uY2hlY2tvdXQuc2NtIGFz IHNjbQorCitfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy4i CisgICAgICAgICAgICAgICAgICAgICAgICAgInVwZGF0ZS13ZWJnbC1jb25mb3JtYW5jZS10ZXN0 cyIpCisKKworZGVmIHJlbW92ZV9maXJzdF9saW5lX2NvbW1lbnQodGV4dCk6CisgICAgcmV0dXJu IHJlLmNvbXBpbGUocidePCEtLS4qPy0tPlxzKicsIHJlLkRPVEFMTCkuc3ViKCcnLCB0ZXh0KQor CisKK2RlZiB0cmFuc2xhdGVfaW5jbHVkZXModGV4dCk6CisgICAgIyBNYXBwaW5nIG9mIHNpbmds ZSBmaWxlbmFtZSB0byByZWxhdGl2ZSBwYXRoIHVuZGVyIFdlYktpdCByb290LgorICAgICMgQXNz dW1wdGlvbjogdGhlc2UgZmlsZW5hbWVzIGFyZSBnbG9iYWxseSB1bmlxdWUuCisgICAgaW5jbHVk ZV9tYXBwaW5nID0geworICAgICAgICAianMtdGVzdC1zdHlsZS5jc3MiOiAiLi4vLi4vanMvcmVz b3VyY2VzIiwKKyAgICAgICAgImpzLXRlc3QtcHJlLmpzIjogIi4uLy4uL2pzL3Jlc291cmNlcyIs CisgICAgICAgICJqcy10ZXN0LXBvc3QuanMiOiAiLi4vLi4vanMvcmVzb3VyY2VzIiwKKyAgICAg ICAgImRlc2t0b3AtZ2wtY29uc3RhbnRzLmpzIjogInJlc291cmNlcyIsCisgICAgfQorCisgICAg Zm9yIGZpbGVuYW1lLCBwYXRoIGluIGluY2x1ZGVfbWFwcGluZy5pdGVtcygpOgorICAgICAgICBz ZWFyY2ggPSByJyg/OlteIlwnPSBdKi8pPycgKyByZS5lc2NhcGUoZmlsZW5hbWUpCisgICAgICAg IHJlcGxhY2UgPSBvcy5wYXRoLmpvaW4ocGF0aCwgZmlsZW5hbWUpCisgICAgICAgIHRleHQgPSBy ZS5zdWIoc2VhcmNoLCByZXBsYWNlLCB0ZXh0KQorCisgICAgcmV0dXJuIHRleHQKKworCitkZWYg dHJhbnNsYXRlX2tocm9ub3NfdGVzdCh0ZXh0KToKKyAgICAiIiIKKyAgICBUaGlzIG1ldGhvZCB0 cmFuc2xhdGVzIHRoZSBjb250ZW50cyBvZiBhIEtocm9ub3MgdGVzdCB0byBhIFdlYktpdCB0ZXN0 LgorICAgICIiIgorCisgICAgdHJhbnNsYXRlRnVuY3MgPSBbCisgICAgICAgIHJlbW92ZV9maXJz dF9saW5lX2NvbW1lbnQsCisgICAgICAgIHRyYW5zbGF0ZV9pbmNsdWRlcywKKyAgICBdCisKKyAg ICBmb3IgZiBpbiB0cmFuc2xhdGVGdW5jczoKKyAgICAgICAgdGV4dCA9IGYodGV4dCkKKworICAg IHJldHVybiB0ZXh0CisKKworZGVmIHVwZGF0ZV9maWxlKGluX2ZpbGVuYW1lLCBvdXRfZGlyKToK KyAgICAjIGNoZWNrIGluX2ZpbGVuYW1lIGV4aXN0cworICAgICMgY2hlY2sgb3V0X2RpciBleGlz dHMKKyAgICBvdXRfZmlsZW5hbWUgPSBvcy5wYXRoLmpvaW4ob3V0X2Rpciwgb3MucGF0aC5iYXNl bmFtZShpbl9maWxlbmFtZSkpCisKKyAgICBfbG9nLmRlYnVnKCJQcm9jZXNzaW5nICIgKyBpbl9m aWxlbmFtZSkKKyAgICB3aXRoIG9wZW4oaW5fZmlsZW5hbWUsICdyJykgYXMgaW5fZmlsZToKKyAg ICAgICAgd2l0aCBvcGVuKG91dF9maWxlbmFtZSwgJ3cnKSBhcyBvdXRfZmlsZToKKyAgICAgICAg ICAgIG91dF9maWxlLndyaXRlKHRyYW5zbGF0ZV9raHJvbm9zX3Rlc3QoaW5fZmlsZS5yZWFkKCkp KQorCisKK2RlZiB1cGRhdGVfZGlyZWN0b3J5KGluX2Rpciwgb3V0X2Rpcik6CisgICAgZm9yIGZp bGVuYW1lIGluIGdsb2IuZ2xvYihvcy5wYXRoLmpvaW4oaW5fZGlyLCAnKi5odG1sJykpOgorICAg ICAgICB1cGRhdGVfZmlsZShvcy5wYXRoLmpvaW4oaW5fZGlyLCBmaWxlbmFtZSksIG91dF9kaXIp CisKKworZGVmIGRlZmF1bHRfb3V0X2RpcigpOgorICAgIGN1cnJlbnRfc2NtID0gc2NtLmRldGVj dF9zY21fc3lzdGVtKG9zLnBhdGguZGlybmFtZShzeXMuYXJndlswXSkpCisgICAgaWYgbm90IGN1 cnJlbnRfc2NtOgorICAgICAgICByZXR1cm4gb3MuZ2V0Y3dkKCkKKyAgICByb290X2RpciA9IGN1 cnJlbnRfc2NtLmNoZWNrb3V0X3Jvb3QKKyAgICBpZiBub3Qgcm9vdF9kaXI6CisgICAgICAgIHJl dHVybiBvcy5nZXRjd2QoKQorICAgIG91dF9kaXIgPSBvcy5wYXRoLmpvaW4ocm9vdF9kaXIsICJM YXlvdXRUZXN0cy9mYXN0L2NhbnZhcy93ZWJnbCIpCisgICAgaWYgb3MucGF0aC5pc2RpcihvdXRf ZGlyKToKKyAgICAgICAgcmV0dXJuIG91dF9kaXIKKyAgICByZXR1cm4gb3MuZ2V0Y3dkKCkKKwor CitkZWYgY29uZmlndXJlX2xvZ2dpbmcob3B0aW9ucyk6CisgICAgIiIiQ29uZmlndXJlcyB0aGUg bG9nZ2luZyBzeXN0ZW0uIiIiCisgICAgbG9nX2ZtdCA9ICclKGxldmVsbmFtZSlzOiAlKG1lc3Nh Z2UpcycKKyAgICBsb2dfZGF0ZWZtdCA9ICcleSVtJWQgJUg6JU06JVMnCisgICAgbG9nX2xldmVs ID0gbG9nZ2luZy5JTkZPCisgICAgaWYgb3B0aW9ucy52ZXJib3NlOgorICAgICAgICBsb2dfZm10 ID0gKCclKGFzY3RpbWUpcyAlKGZpbGVuYW1lKXM6JShsaW5lbm8pLTRkICUobGV2ZWxuYW1lKXMg JworICAgICAgICAgICAgICAgICAgICclKG1lc3NhZ2UpcycpCisgICAgICAgIGxvZ19sZXZlbCA9 IGxvZ2dpbmcuREVCVUcKKyAgICBsb2dnaW5nLmJhc2ljQ29uZmlnKGxldmVsPWxvZ19sZXZlbCwg Zm9ybWF0PWxvZ19mbXQsCisgICAgICAgICAgICAgICAgICAgICAgICBkYXRlZm10PWxvZ19kYXRl Zm10KQorCisKK2RlZiBvcHRpb25fcGFyc2VyKCk6CisgICAgdXNhZ2UgPSAidXNhZ2U6ICVwcm9n IFtvcHRpb25zXSAoaW5wdXQgZmlsZSBvciBkaXJlY3RvcnkpIgorICAgIHBhcnNlciA9IG9wdHBh cnNlLk9wdGlvblBhcnNlcih1c2FnZT11c2FnZSkKKyAgICBwYXJzZXIuYWRkX29wdGlvbignLXYn LCAnLS12ZXJib3NlJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWN0aW9uPSdzdG9y ZV90cnVlJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGVmYXVsdD1GYWxzZSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0naW5jbHVkZSBkZWJ1Zy1sZXZlbCBsb2dn aW5nJykKKyAgICBwYXJzZXIuYWRkX29wdGlvbignLW8nLCAnLS1vdXRwdXQnLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBhY3Rpb249J3N0b3JlJywKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgdHlwZT0nc3RyaW5nJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGVm YXVsdD1kZWZhdWx0X291dF9kaXIoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWV0 YXZhcj0nRElSJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaGVscD0nc3BlY2lmeSBh biBvdXRwdXQgZGlyZWN0b3J5IHRvIHBsYWNlIGZpbGVzICcKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAnaW4gW2RlZmF1bHQ6ICVkZWZhdWx0XScpCisgICAgcmV0dXJuIHBhcnNl cgorCisKK2RlZiBtYWluKCk6CisgICAgcGFyc2VyID0gb3B0aW9uX3BhcnNlcigpCisgICAgKG9w dGlvbnMsIGFyZ3MpID0gcGFyc2VyLnBhcnNlX2FyZ3MoKQorICAgIGNvbmZpZ3VyZV9sb2dnaW5n KG9wdGlvbnMpCisKKyAgICBpZiBsZW4oYXJncykgPT0gMDoKKyAgICAgICAgX2xvZy5lcnJvcigi TXVzdCBzcGVjaWZ5IGFuIGlucHV0IGRpcmVjdG9yeSBvciBmaWxlbmFtZS4iKQorICAgICAgICBw YXJzZXIucHJpbnRfaGVscCgpCisgICAgICAgIHJldHVybiAxCisKKyAgICBpbl9uYW1lID0gYXJn c1swXQorICAgIGlmIG9zLnBhdGguaXNmaWxlKGluX25hbWUpOgorICAgICAgICB1cGRhdGVfZmls ZShpbl9uYW1lLCBvcHRpb25zLm91dHB1dCkKKyAgICBlbGlmIG9zLnBhdGguaXNkaXIoaW5fbmFt ZSk6CisgICAgICAgIHVwZGF0ZV9kaXJlY3RvcnkoaW5fbmFtZSwgb3B0aW9ucy5vdXRwdXQpCisg ICAgZWxzZToKKyAgICAgICAgX2xvZy5lcnJvcigiJyVzJyBpcyBub3QgYSBkaXJlY3Rvcnkgb3Ig YSBmaWxlLiIsIGluX25hbWUpCisgICAgICAgIHJldHVybiAyCisKKyAgICByZXR1cm4gMAorCisK K2lmIF9fbmFtZV9fID09ICJfX21haW5fXyI6CisgICAgc3lzLmV4aXQobWFpbigpKQpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdXBkYXRlX3dl YmdsX2NvbmZvcm1hbmNlX3Rlc3RzX3VuaXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvdXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3RzX3VuaXR0 ZXN0LnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjczOTNiNzA3ZGNkZWU3MDc1ZjlmNDMwNzhhZjQ0ODA0ODJhN2Ix MGIKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy91cGRhdGVfd2ViZ2xfY29uZm9ybWFuY2VfdGVzdHNfdW5pdHRlc3QucHkKQEAgLTAs MCArMSwxMDIgQEAKKyMhL3Vzci9iaW4vcHl0aG9uCisjIENvcHlyaWdodCAoQykgMjAxMCBHb29n bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorIworIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyMgbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z IGFyZQorIyBtZXQ6CisjCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgICAgICogUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorIyBjb3B5cmln aHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyCisjIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUKKyMgZGlzdHJpYnV0aW9uLgorIyAgICAgKiBOZWl0aGVyIHRoZSBuYW1l IG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisjIGNvbnRyaWJ1dG9ycyBtYXkg YmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisjIHRo aXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisj CisjIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFO RCBDT05UUklCVVRPUlMKKyMgIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisjIEEgUEFSVElDVUxB UiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hU CisjIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLAorIyBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorIyBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkKKyMgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJ QUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworIiIiVW5p dCB0ZXN0cyBmb3IgdXBkYXRlX3dlYmdsX2NvbmZvcm1hbmNlX3Rlc3RzLiIiIgorCitpbXBvcnQg dW5pdHRlc3QKK2Zyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzIGltcG9ydCB1cGRhdGVfd2ViZ2xf Y29uZm9ybWFuY2VfdGVzdHMgYXMgd2ViZ2wKKworCitkZWYgY29uc3RydWN0X3NjcmlwdChuYW1l KToKKyAgICByZXR1cm4gIjxzY3JpcHQgc3JjPVwiIiArIG5hbWUgKyAiXCI+PC9zY3JpcHQ+XG4i CisKKworZGVmIGNvbnN0cnVjdF9zdHlsZShuYW1lKToKKyAgICByZXR1cm4gIjxsaW5rIHJlbD1c InN0eWxlc2hlZXRcIiBocmVmPVwiIiArIG5hbWUgKyAiXCI+IgorCisKK2NsYXNzIFRlc3RUcmFu c2xhdGlvbih1bml0dGVzdC5UZXN0Q2FzZSk6CisgICAgZGVmIGFzc2VydF91bmNoYW5nZWQoc2Vs ZiwgdGV4dCk6CisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwodGV4dCwgd2ViZ2wudHJhbnNsYXRl X2tocm9ub3NfdGVzdCh0ZXh0KSkKKworICAgIGRlZiBhc3NlcnRfdHJhbnNsYXRlKHNlbGYsIGlu cHV0LCBvdXRwdXQpOgorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKG91dHB1dCwgd2ViZ2wudHJh bnNsYXRlX2tocm9ub3NfdGVzdChpbnB1dCkpCisKKyAgICBkZWYgdGVzdF9zaW1wbGVfdW5jaGFu Z2VkKHNlbGYpOgorICAgICAgICBzZWxmLmFzc2VydF91bmNoYW5nZWQoIiIpCisgICAgICAgIHNl bGYuYXNzZXJ0X3VuY2hhbmdlZCgiPGh0bWw+PC9odG1sPiIpCisKKyAgICBkZWYgdGVzdF9oZWFk ZXJfc3RyaXAoc2VsZik6CisgICAgICAgIHNpbmdsZV9saW5lX2hlYWRlciA9ICI8IS0tIHNpbmds ZSBsaW5lIGhlYWRlci4gLS0+IgorICAgICAgICBtdWx0aV9saW5lX2hlYWRlciA9ICIiIjwhLS0g dGhpcyBpcyBhIG11bHRpLWxpbmUKKyAgICAgICAgICAgICAgICBoZWFkZXIuICBpdCBzaG91bGQg YWxsIGJlIHJlbW92ZWQgdG9vLgorICAgICAgICAgICAgICAgIC0tPiIiIgorICAgICAgICB0ZXh0 ID0gIjxodG1sPjwvaHRtbD4iCisgICAgICAgIHNlbGYuYXNzZXJ0X3RyYW5zbGF0ZShzaW5nbGVf bGluZV9oZWFkZXIsICIiKQorICAgICAgICBzZWxmLmFzc2VydF90cmFuc2xhdGUoc2luZ2xlX2xp bmVfaGVhZGVyICsgdGV4dCwgdGV4dCkKKyAgICAgICAgc2VsZi5hc3NlcnRfdHJhbnNsYXRlKG11 bHRpX2xpbmVfaGVhZGVyICsgdGV4dCwgdGV4dCkKKworICAgIGRlZiBkb250X3N0cmlwX290aGVy X2hlYWRlcnMoc2VsZik6CisgICAgICAgIHNlbGYuYXNzZXJ0X3VuY2hhbmdlZCgiPGh0bWw+XG48 IS0tIGRvbid0IHJlbW92ZSBjb21tZW50cyBvbiBvdGhlciBsaW5lcy4gLS0+XG48L2h0bWw+IikK KworICAgIGRlZiB0ZXN0X2luY2x1ZGVfcmV3cml0aW5nKHNlbGYpOgorICAgICAgICAjIE1hcHBp bmdzIHRvIE5vbmUgYXJlIHVuY2hhbmdlZAorICAgICAgICBzdHlsZXMgPSB7CisgICAgICAgICAg ICAiLi4vcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIjogIi4uLy4uL2pzL3Jlc291cmNlcy9q cy10ZXN0LXN0eWxlLmNzcyIsCisgICAgICAgICAgICAiZmFpbC5jc3MiOiBOb25lLAorICAgICAg ICAgICAgInJlc291cmNlcy9zdHlsZXNoZWV0LmNzcyI6IE5vbmUsCisgICAgICAgICAgICAiLi4v cmVzb3VyY2VzL3N0eWxlLmNzcyI6IE5vbmUsCisgICAgICAgIH0KKyAgICAgICAgc2NyaXB0cyA9 IHsKKyAgICAgICAgICAgICIuLi9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiOiAiLi4vLi4vanMv cmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIiwKKyAgICAgICAgICAgICIuLi9yZXNvdXJjZXMvanMt dGVzdC1wb3N0LmpzIjogIi4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiLAorICAg ICAgICAgICAgIi4uL3Jlc291cmNlcy9kZXNrdG9wLWdsLWNvbnN0YW50cy5qcyI6ICJyZXNvdXJj ZXMvZGVza3RvcC1nbC1jb25zdGFudHMuanMiLAorCisgICAgICAgICAgICAicmVzb3VyY2VzL3No YWRvdy1vZmZzZXQuanMiOiBOb25lLAorICAgICAgICAgICAgIi4uL3Jlc291cmNlcy9qcy10ZXN0 LXBvc3QtYXN5bmMuanMiOiBOb25lLAorICAgICAgICB9CisKKyAgICAgICAgaW5wdXRfdGV4dCA9 ICIiCisgICAgICAgIG91dHB1dF90ZXh0ID0gIiIKKyAgICAgICAgZm9yIGlucHV0LCBvdXRwdXQg aW4gc3R5bGVzLml0ZW1zKCk6CisgICAgICAgICAgICBpbnB1dF90ZXh0ICs9IGNvbnN0cnVjdF9z dHlsZShpbnB1dCkKKyAgICAgICAgICAgIG91dHB1dF90ZXh0ICs9IGNvbnN0cnVjdF9zdHlsZShv dXRwdXQgaWYgb3V0cHV0IGVsc2UgaW5wdXQpCisgICAgICAgIGZvciBpbnB1dCwgb3V0cHV0IGlu IHNjcmlwdHMuaXRlbXMoKToKKyAgICAgICAgICAgIGlucHV0X3RleHQgKz0gY29uc3RydWN0X3Nj cmlwdChpbnB1dCkKKyAgICAgICAgICAgIG91dHB1dF90ZXh0ICs9IGNvbnN0cnVjdF9zY3JpcHQo b3V0cHV0IGlmIG91dHB1dCBlbHNlIGlucHV0KQorCisgICAgICAgIGhlYWQgPSAnPCFET0NUWVBF IEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPlxuPGh0bWw+XG48aGVhZD5cbicK KyAgICAgICAgZm9vdCA9ICc8L2hlYWQ+XG48Ym9keT5cbjwvYm9keT5cbjwvaHRtbD4nCisgICAg ICAgIGlucHV0X3RleHQgPSBoZWFkICsgaW5wdXRfdGV4dCArIGZvb3QKKyAgICAgICAgb3V0cHV0 X3RleHQgPSBoZWFkICsgb3V0cHV0X3RleHQgKyBmb290CisgICAgICAgIHNlbGYuYXNzZXJ0X3Ry YW5zbGF0ZShpbnB1dF90ZXh0LCBvdXRwdXRfdGV4dCkKKworCitpZiBfX25hbWVfXyA9PSAnX19t YWluX18nOgorICAgIHVuaXR0ZXN0Lm1haW4oKQo=