46128 2010-09-20 15:02:12 -0700 webkitpy - display web pages using a common routine 2010-09-21 19:25:05 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Other OS X 10.5 RESOLVED FIXED P2 Normal --- 1 dpranke dpranke abarth atwilson cjerdonek eric tony victorw oldest_to_newest 281837 0 dpranke 2010-09-20 15:02:12 -0700 webkitpy - display web pages using a common routine 281838 1 68141 dpranke 2010-09-20 15:03:12 -0700 Created attachment 68141 Patch 281841 2 dpranke 2010-09-20 15:05:37 -0700 Note that this fixes an issue with the rebaselining tool as it is currently checked in, which is crashing when trying to display the results file. 281889 3 68141 abarth 2010-09-20 16:24:20 -0700 Comment on attachment 68141 Patch LGTM. It's generally better to use an instance version rather than a static version of User to make it easier to write unit tests (by injecting a mock user object as a dependency), but this is a step in the right direction. 281909 4 dpranke 2010-09-20 16:51:39 -0700 (In reply to comment #3) > (From update of attachment 68141 [details]) > LGTM. It's generally better to use an instance version rather than a static version of User to make it easier to write unit tests (by injecting a mock user object as a dependency), but this is a step in the right direction. That is using an instance of User, and not a static object. I assume you mean instead that show_results_html_file() should take a user passed in as an argument; that would mean that I'd have to create a User object in the calling routine for no other purpose than to pass it to this routine, which shouldn't have to know that it uses a User at all, which feels like a layering violation. Frankly, I'm not sure why we have have the User.open_url() call, since it's basically just a wrapper around webbrowser.open(). I only used User() because there was a comment in one of the FIXMEs that mentioned it as desirable. 281915 5 eric 2010-09-20 17:00:06 -0700 (In reply to comment #4) > That is using an instance of User, and not a static object. I assume you mean instead that show_results_html_file() should take a user passed in as an argument; that would mean that I'd have to create a User object in the calling routine for no other purpose than to pass it to this routine, which shouldn't have to know that it uses a User at all, which feels like a layering violation. In these cases, where a User object isn't accessible, we can use patterns like Executive() does. The whole point of a User object is to abstract away interactions with the user so they can be easily mocked out for testing. > Frankly, I'm not sure why we have have the User.open_url() call, since it's basically just a wrapper around webbrowser.open(). I only used User() because there was a comment in one of the FIXMEs that mentioned it as desirable. For exactly the reason mentioned above. Ease-of-mocking. It's also generally a good idea to factor the code into different objects. Just like how Executive does all the dealing with processes instead of having individual os.kill calls sprinkled throughout the codebase. User handles platform-specific differences, and abstracts the whole idea of dealing with a User. If you ever don't have a User object, but feel like you should, make a static method on User which just creates a User() and calls the instance method. 281948 6 dpranke 2010-09-20 17:34:30 -0700 (In reply to comment #5) > (In reply to comment #4) > > That is using an instance of User, and not a static object. I assume you mean instead that show_results_html_file() should take a user passed in as an argument; that would mean that I'd have to create a User object in the calling routine for no other purpose than to pass it to this routine, which shouldn't have to know that it uses a User at all, which feels like a layering violation. > > In these cases, where a User object isn't accessible, we can use patterns like Executive() does. The whole point of a User object is to abstract away interactions with the user so they can be easily mocked out for testing. I'm not 100% sure that I follow what you're saying here. Looking at the current version of executive.py, the only pattern I see that might be applicable is how executive.run_command creates an instance and then calls executive.Executive.run_command on it. Is that what you're referring to? If so, how is executive.run_command() (or an equivalent User.static_open_url()) easier to mock than webbrowser.open() ? > It's also generally a good idea to factor the code into different objects. Just like how Executive does all the dealing with processes instead of having individual os.kill calls sprinkled throughout the codebase. User handles platform-specific differences, and abstracts the whole idea of dealing with a User. There's two reasons to factor the code - to ensure that wherever we try to do X, we do it the same way, and, where necessary, to deviate from built in implementations because the built in doesn't do what we want. os.kill() qualifies for both the first and second cases (because simply calling os.kill() doesn't work right on windows). User.open_url() -- as we're using it currently -- only falls into the first category. In this case we are simply duplicating the work the platform already does for us, which is less compelling to me. But there is still value in trying to get common behavior. > If you ever don't have a User object, but feel like you should, make a static method on User which just creates a User() and calls the instance method. I'm not sure I understand how that makes things better. Are you suggesting that by introducing a User.static_open_url() that wrapped User().open_url() it's easier to grep for the usages? Or is there some other benefit (apart from the first thing discussed above)? 281960 7 eric 2010-09-20 17:43:09 -0700 (In reply to comment #6) > (In reply to comment #5) > > (In reply to comment #4) > > > That is using an instance of User, and not a static object. I assume you mean instead that show_results_html_file() should take a user passed in as an argument; that would mean that I'd have to create a User object in the calling routine for no other purpose than to pass it to this routine, which shouldn't have to know that it uses a User at all, which feels like a layering violation. > > > > In these cases, where a User object isn't accessible, we can use patterns like Executive() does. The whole point of a User object is to abstract away interactions with the user so they can be easily mocked out for testing. > > I'm not 100% sure that I follow what you're saying here. Looking at the current version of executive.py, the only pattern I see that might be applicable is how executive.run_command creates an instance and then calls executive.Executive.run_command on it. Is that what you're referring to? Yes. > If so, how is executive.run_command() (or an equivalent User.static_open_url()) easier to mock than webbrowser.open() ? You can replace the User object with a MockUser (see mocktool.py) and then all parts of the code are known never to block on the user. Or even more useful is replacing the Tool object with a MockTool, and then the test never touches anything it shouldn't. Otherwise you'd need a whole set of functions where you go and replace pieces of python before any testing. I think this all makes sense form the webkit-patch world where there is a central non-static tool object which is passed around, and all interesting functionality is exposed off the tool or its sub objects. Never do Command or Step objects talk directly to the OS as then they'd be hard to mock. > > It's also generally a good idea to factor the code into different objects. Just like how Executive does all the dealing with processes instead of having individual os.kill calls sprinkled throughout the codebase. User handles platform-specific differences, and abstracts the whole idea of dealing with a User. > > There's two reasons to factor the code - to ensure that wherever we try to do X, we do it the same way, and, where necessary, to deviate from built in implementations because the built in doesn't do what we want. os.kill() qualifies for both the first and second cases (because simply calling os.kill() doesn't work right on windows). User.open_url() -- as we're using it currently -- only falls into the first category. In this case we are simply duplicating the work the platform already does for us, which is less compelling to me. But there is still value in trying to get common behavior. > > > If you ever don't have a User object, but feel like you should, make a static method on User which just creates a User() and calls the instance method. > > I'm not sure I understand how that makes things better. Are you suggesting that by introducing a User.static_open_url() that wrapped User().open_url() it's easier to grep for the usages? Or is there some other benefit (apart from the first thing discussed above)? Eventually new-run-webkit-tests should also have a Tool object (see bug 45838) and probably be a Command subclass using Steps to get its work done so as to most easily participate in webkitpy unit testing. In that world, it makes a lot of sense to have a User object and be able to mock out all user-related functions at once instead of wondering if you've overridden the right set of webbrowser or urllib2 module functions in your unit tests. 281963 8 eric 2010-09-20 17:44:56 -0700 Using instances like "User" for easy mocking also makes the code more future resilient. As when some lower-level part of webkitpy changes out from under you, you know your higher-level test is never going to start hitting servers or starting processes or whatever, because the mocks are in place. Those lower levels are going to be using the same MockUser/MockTool you passed into your higher level test. 281967 9 dpranke 2010-09-20 17:49:02 -0700 In case my previous comments weren't clear as to what I was saying ... If we added a function to user.py like: def open_url(url): user = User() user.open_url(url) then I would be fine with calling that instead of calling User().open_url() like I am now. I agree that the latter can't be Mocked very easily, and that there is value in all of the code calling a single routine to open URLs. I'm not convinced that the routine above really makes things much clearer than just asking everyone to call webbrowser.open(), but I don't feel that strongly about it. On the other hand, any changes to the existing run_webkit_tests code to create a User in one routine and pass it to others makes less sense to me. I will post an updated patch and add the static routine and we can make sure we're all on the same page. 281972 10 dpranke 2010-09-20 17:52:25 -0700 (In reply to comment #7) > > I'm not 100% sure that I follow what you're saying here. Looking at the current version of executive.py, the only pattern I see that might be applicable is how executive.run_command creates an instance and then calls executive.Executive.run_command on it. Is that what you're referring to? > > Yes. > > > If so, how is executive.run_command() (or an equivalent User.static_open_url()) easier to mock than webbrowser.open() ? > > You can replace the User object with a MockUser (see mocktool.py) and then all parts of the code are known never to block on the user. Or even more useful is replacing the Tool object with a MockTool, and then the test never touches anything it shouldn't. Otherwise you'd need a whole set of functions where you go and replace pieces of python before any testing. > > I think this all makes sense form the webkit-patch world where there is a central non-static tool object which is passed around, and all interesting functionality is exposed off the tool or its sub objects. Never do Command or Step objects talk directly to the OS as then they'd be hard to mock. > Yeah, if you can assume that you have some common global objects then life is easier, I agree. NRWT doesn't have the Tool and User objects, so this gets more contorted. 281975 11 eric 2010-09-20 17:56:46 -0700 I don't care re: User().foo() or User.foo(). The only real advantage to User.foo() is that you can later remove it and catch all the callers in ones unit testing. That's the plan with removing Executive.run_command() since everything should have an Executive() instance eventually. The idea of piping User through various routines in new-run-webkit-tests isn't super-appealing. Which is part of the idea behind the Step design. Running layout tests really shouldn't be very complicated. Its amazing to me what a tangled mess of code old-run-webkit-tests is (and NRWT is to some degree). We started moving Commands towards independent execution units called Steps which pass their state between them through a state object. Eventually I suspect NRWT may move to a similar model. It's difficult to see a global overview of what NRWT actually does, where-as it's super easy to see what "land" is doing: http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/webkitpy/tool/commands/download.py#L76 Part of that is made possible by having a global "talk to the rest of the world" object, which we call self.tool. It's possible for us to test at the function level, step level, command level, or even the whole mutli-command-tool level. For any of those we just pass our mock object down in and never have to worry about what may or may not be properly mocked in the subcomponents, because they all go through the global instances. 281977 12 eric 2010-09-20 17:57:48 -0700 (In reply to comment #10) > > I think this all makes sense form the webkit-patch world where there is a central non-static tool object which is passed around, and all interesting functionality is exposed off the tool or its sub objects. Never do Command or Step objects talk directly to the OS as then they'd be hard to mock. > > > > Yeah, if you can assume that you have some common global objects then life is easier, I agree. NRWT doesn't have the Tool and User objects, so this gets more contorted. Sounds like we're on a similar page. Much of that is our fault for never having split the Tool logic out. Command was designed to be able to be run in a single-command-tool-like-design. We just never finished ripping Tool out from WebKitPatch so that other objects could use the Command and Step infrastructure safely. 281987 13 68168 dpranke 2010-09-20 18:20:53 -0700 Created attachment 68168 Patch 281990 14 68168 abarth 2010-09-20 18:25:49 -0700 Comment on attachment 68168 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68168&action=review > WebKitTools/Scripts/webkitpy/common/system/user.py:53 > +def open_url(url): We should give this some sort of pejorative name to discourage folks from using this function. They shouldn't be using a global static. Instead, they should be using a user instance hung off a context object. > WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests_unittest.py:100 > + def setUp(self): > + def open_url(url): > + self._url_opened = url > + self._user_open_url = user.open_url > + user.open_url = open_url > + self._url_opened = None Mutating global statics in unit tests is error-prone. It's much better to pass in the dependencies explicitly so you can inject them explicitly too. 281992 15 eric 2010-09-20 18:27:18 -0700 We also often use OutputCapture for this sort of test. MockUser() writes to stdout whenever something tries to open a URL. Which is what OutputCapture can verify by calling assert_outputs with your expected stdout, which would include the MOCK: open_url http:://myurl.com/ message. 282000 16 dpranke 2010-09-20 18:32:02 -0700 (In reply to comment #14) > (From update of attachment 68168 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=68168&action=review > > > WebKitTools/Scripts/webkitpy/common/system/user.py:53 > > +def open_url(url): > > We should give this some sort of pejorative name to discourage folks from using this function. They shouldn't be using a global static. Instead, they should be using a user instance hung off a context object. Did you have any perjorative names in mind? > > WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests_unittest.py:100 > > + def setUp(self): > > + def open_url(url): > > + self._url_opened = url > > + self._user_open_url = user.open_url > > + user.open_url = open_url > > + self._url_opened = None > > Mutating global statics in unit tests is error-prone. It's much better to pass in the dependencies explicitly so you can inject them explicitly too. I generally agree that it's better to pass in dependencies than to mutate globals. In my experience, though, this pattern has been pretty much 100% reliable; do have some reason to think the above might fail? As discussed earlier, it may make sense eventually to have run_webkit_tests create or get passed a User object early on, but there isn't one now and so I think this'll have to do until such time. Are you suggesting some other change instead? 282008 17 68168 abarth 2010-09-20 18:37:14 -0700 Comment on attachment 68168 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68168&action=review >>> WebKitTools/Scripts/webkitpy/common/system/user.py:53 >>> +def open_url(url): >> >> We should give this some sort of pejorative name to discourage folks from using this function. They shouldn't be using a global static. Instead, they should be using a user instance hung off a context object. > > Did you have any perjorative names in mind? deprecated_open_url ? >>> WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests_unittest.py:100 >>> + self._url_opened = None >> >> Mutating global statics in unit tests is error-prone. It's much better to pass in the dependencies explicitly so you can inject them explicitly too. > > I generally agree that it's better to pass in dependencies than to mutate globals. In my experience, though, this pattern has been pretty much 100% reliable; do have some reason to think the above might fail? > > As discussed earlier, it may make sense eventually to have run_webkit_tests create or get passed a User object early on, but there isn't one now and so I think this'll have to do until such time. > > Are you suggesting some other change instead? I'd just skip these changes to the unittests. 282012 18 dpranke 2010-09-20 18:43:05 -0700 (In reply to comment #11) > > The idea of piping User through various routines in new-run-webkit-tests isn't super-appealing. > We need to pipe in some global context object, though, right? Which is part of the idea behind the Step design. Running layout tests really shouldn't be very complicated. Its amazing to me what a tangled mess of code old-run-webkit-tests is (and NRWT is to some degree). We started moving Commands towards independent execution units called Steps which pass their state between them through a state object. Eventually I suspect NRWT may move to a similar model. It's difficult to see a global overview of what NRWT actually does, where-as it's super easy to see what "land" is doing: > > http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/webkitpy/tool/commands/download.py#L76 > > Part of that is made possible by having a global "talk to the rest of the world" object, which we call self.tool. It's possible for us to test at the function level, step level, command level, or even the whole mutli-command-tool level. For any of those we just pass our mock object down in and never have to worry about what may or may not be properly mocked in the subcomponents, because they all go through the global instances. NRWT is gradually getting cleaner, but I suspect that at least part of the reason that you find "land" easy to follow is that you're much more familiar with the Tool/Step/Command infrastructure than you are with NRWT. I haven't yet spent enough time with that code to really understand it, and I find it difficult to follow what's going on at any more complicated level than "what steps are run" - e.g., how is state propagated from step to step? How are options parsed? Etc. It may be that once I do get my head wrapped around it, it will be clearer overall. Dunno yet :) At any rate, your design of having your global mock object is pretty similar to my design for the Port object, for what sounds like much the same goals. I think perhaps this is why you've been confused as to why I had so many things hanging off Port in the past - you wanted them to be on some other global object I didn't know existed. 282013 19 dpranke 2010-09-20 18:44:36 -0700 (In reply to comment #17) > (From update of attachment 68168 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=68168&action=review > > >>> WebKitTools/Scripts/webkitpy/common/system/user.py:53 > >>> +def open_url(url): > >> > >> We should give this some sort of pejorative name to discourage folks from using this function. They shouldn't be using a global static. Instead, they should be using a user instance hung off a context object. > > > > Did you have any perjorative names in mind? > > deprecated_open_url ? > Okay. > >>> WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests_unittest.py:100 > >>> + self._url_opened = None > >> > >> Mutating global statics in unit tests is error-prone. It's much better to pass in the dependencies explicitly so you can inject them explicitly too. > > > > I generally agree that it's better to pass in dependencies than to mutate globals. In my experience, though, this pattern has been pretty much 100% reliable; do have some reason to think the above might fail? > > > > As discussed earlier, it may make sense eventually to have run_webkit_tests create or get passed a User object early on, but there isn't one now and so I think this'll have to do until such time. > > > > Are you suggesting some other change instead? > > I'd just skip these changes to the unittests. No can do. It turns out that if I don't mock out user.open_url, then the person running the tests gets a whole bunch of pages opened in his/her browser. Also, I can't easily test that the open call is in fact getting called, which is kind of important (yes, the tests weren't doing that earlier, but that's not a good thing). 282014 20 68168 abarth 2010-09-20 18:48:22 -0700 Comment on attachment 68168 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68168&action=review >>>>> WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests_unittest.py:100 >>>>> + self._url_opened = None >>>> >>>> Mutating global statics in unit tests is error-prone. It's much better to pass in the dependencies explicitly so you can inject them explicitly too. >>> >>> I generally agree that it's better to pass in dependencies than to mutate globals. In my experience, though, this pattern has been pretty much 100% reliable; do have some reason to think the above might fail? >>> >>> As discussed earlier, it may make sense eventually to have run_webkit_tests create or get passed a User object early on, but there isn't one now and so I think this'll have to do until such time. >>> >>> Are you suggesting some other change instead? >> >> I'd just skip these changes to the unittests. > > No can do. It turns out that if I don't mock out user.open_url, then the person running the tests gets a whole bunch of pages opened in his/her browser. Also, I can't easily test that the open call is in fact getting called, which is kind of important (yes, the tests weren't doing that earlier, but that's not a good thing). It sounds like you're fixing the architectural problems in the wrong order then. You first need to make it so you can inject dependencies and the create the dependencies to inject. 282019 21 dpranke 2010-09-20 18:59:15 -0700 > It sounds like you're fixing the architectural problems in the wrong order then. You first need to make it so you can inject dependencies and the create the dependencies to inject. Like I said above, I've not found any difficulties to occur in practice if you do mutate global statics for testing purposes, so I don't know that I would really call it an "architectural problem". This is a pattern that's used a fair amount in the unit tests for NRWT. I personally find it preferable to introducing new objects and interfaces *solely* to be able to mock things out. I've already suggested that it may make sense to evaluate refactoring NRWT on top of the other webkitpy objects, but I would prefer not to have to do this before I can make this simple change, which fixes bugs, increases code reuse, and gets better test coverage. I will note that both rebaseline-chromium-webkit-tests and new-run-webkit-tests on the webkit ports are currently broken without this fix, so this isn't an idle thing ... Given that, do you still want me to hold off on this change? I can always fix the bug differently without actually trying to move in the right direction. 282027 22 abarth 2010-09-20 19:09:12 -0700 I feel I've given you my perspective. One thing you can do without re-writing the world is hang the User instance off the port and then have fake port sub in the MockUser object. 282035 23 dpranke 2010-09-20 19:29:48 -0700 (In reply to comment #22) > I feel I've given you my perspective. One thing you can do without re-writing the world is hang the User instance off the port and then have fake port sub in the MockUser object. Sorry, my last comment came off as more confrontational than I intended :( To clarify: you do not want to R+ a patch that modifies the global statics, so you would prefer it if I abandoned that approach? If that's true, then I think there's no point in adding the User.open_url() method, since that can't be mocked, and I essentially have to do something to propagate a user object in to this routine, right, in order to keep from actually opening windows? You're suggesting that a way to do this is to have ports create actual User() objects, and the fake port create a MockUser() object, and then I would modify the unit tests to grep captured stdout to see if MockUser.open_url() was called? 282037 24 abarth 2010-09-20 19:34:53 -0700 That sounds like it would work. Alternatively, you could find another reviewer who thinks the other approach is better. 282070 25 68184 dpranke 2010-09-20 21:06:44 -0700 Created attachment 68184 Patch 282071 26 dpranke 2010-09-20 21:08:02 -0700 Okay, trying again, this time with a MockUser and no mutated statics. I didn't use the MockUser object you have in ../common (a) because I don't really understand it yet and this was easier and (b) I wanted to actually verify the URL cleanly without having to grep output, so this seemed like a reasonable tradeoff. 282074 27 dpranke 2010-09-20 21:08:46 -0700 There's probably some additional cleanup we can do to assume that certain keyword arguments are getting passed and things are getting set up, but I'll leave that for some other patch. 282480 28 68275 dpranke 2010-09-21 12:34:16 -0700 Created attachment 68275 Patch 282633 29 68275 abarth 2010-09-21 16:35:56 -0700 Comment on attachment 68275 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=68275&action=review This looks good. I'm sorry that I don't have time to review it in complete detail, but this looks like a good compromise for now. > WebKitTools/Scripts/webkitpy/layout_tests/port/base.py:90 > + self._name = kwargs.get('port_name', None) > + self._options = kwargs.get('options', None) > + self._executive = kwargs.get('executive', Executive()) > + self._user = kwargs.get('user', User()) You can just name these in the argument list and let **kwargs grab the rest. 282639 30 dpranke 2010-09-21 16:44:13 -0700 (In reply to comment #29) > (From update of attachment 68275 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=68275&action=review > > This looks good. I'm sorry that I don't have time to review it in complete detail, but this looks like a good compromise for now. > Thanks! Hopefully soon I'll switch this ove to the Tool/Step infrastructure and we'll use real User and Executive objects. > > WebKitTools/Scripts/webkitpy/layout_tests/port/base.py:90 > > + self._name = kwargs.get('port_name', None) > > + self._options = kwargs.get('options', None) > > + self._executive = kwargs.get('executive', Executive()) > > + self._user = kwargs.get('user', User()) > > You can just name these in the argument list and let **kwargs grab the rest. True, but I intentionally deleted those two parameters and moved to an all-keyword approach because the args are all optional and this simplifies the interface to the constructor. This way we don't have to change the signature in every constructor whenever we want to propagate a new parameter from the caller to the base classes. 282735 31 dpranke 2010-09-21 19:25:05 -0700 Committed r68008: <http://trac.webkit.org/changeset/68008> 68141 2010-09-20 15:03:12 -0700 2010-09-20 18:20:50 -0700 Patch bug-46128-20100920150311.patch text/plain 6163 dpranke ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA3ZGRkNTA1NGQzM2Q4NjVmYzc4ZDRkMWQwMDk4ZmFmYjU5MTQ0NGIxLi44NThmMDQ0 NzkyMThhMTYzYzlhN2MwOTU5ZWU0YTJmYjlkYmFmZGM3IDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjcgQEAK KzIwMTAtMDktMjAgIERpcmsgUHJhbmtlICA8ZHByYW5rZUBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTW9kaWZ5IG5ldy1ydW4t d2Via2l0LXRlc3RzIGFuZCByZWJhc2VsaW5lLWNocm9taXVtLXdlYmtpdC10ZXN0cyB0byB1c2Ug dGhlCisgICAgICAgIGNvbW1vbiByb3V0aW5lIGluIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0udXNl ci5zaG93X3VybCgpIHRvIGRpc3BsYXkgSFRNTCBmaWxlcy4KKyAgICAgICAgVGhlcmUgd2FzIGEg cm91dGluZSBpbiB0aGUgUG9ydCBpbnRlcmZhY2UgdG8gZG8gdGhlIHNhbWUgdGhpbmcsIGJ1dCBJ IHNlZSBubyBuZWVkCisgICAgICAgIGZvciBhIHBvcnQtc3BlY2lmaWMgaG9vayBmb3IgdGhpcywg c2luY2UgaXQgaXMgc29tZXRoaW5nIHRoYXQgd2lsbCBhbHdheXMgYmUKKyAgICAgICAgZXhlY3V0 ZWQgYnkgdGhlIGhvc3QgZW52aXJvbm1lbnQgYW5kIGRpc3BsYXlpbmcgd2ViIHBhZ2VzIGhhcyBu b3RoaW5nIHRvIGRvIHdpdGgKKyAgICAgICAgcnVubmluZyBsYXlvdXQgdGVzdHMuCisKKyAgICAg ICAgTm90ZSB0aGF0IG5ldy1ydW4td2Via2l0LXRlc3RzIHVzZWQgdG8gdXNlIHRlc3Rfc2hlbGwg dG8gZGlzcGxheSB0aGUgcGFnZTsgdGhpcworICAgICAgICBpcyBwb3RlbnRpYWxseSB1c2VmdWwg c28gdGhhdCB5b3UgY2FuIGFjdHVhbGx5IGNsaWNrIGZyb20gYSByZXN1bHQgdG8gdGhlIGJyb2tl bgorICAgICAgICBwYWdlOyBob3dldmVyLCBzaW5jZSBEdW1wUmVuZGVyVHJlZSBkb2Vzbid0IHN1 cHBvcnQgdGhpcyBmdW5jdGlvbmFsaXR5LCBpdCB3aWxsCisgICAgICAgIGJlIGdvaW5nIGF3YXkg ZXZlbnR1YWxseS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NDYxMjgKKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvY2hyb21pdW0ucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC90ZXN0LnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvd2Via2l0LnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Jl YmFzZWxpbmVfY2hyb21pdW1fd2Via2l0X3Rlc3RzLnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHk6CisKIDIwMTAtMDktMTYgIEFu dG9uaW8gR29tZXMgIDx0b25pa2l0b29Ad2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBi eSBBbmRyZWFzIEtsaW5nLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkKaW5kZXggODk2ZWFiMTVlNWIxMjYw NTVmOGEwN2U2MDQwMGI1NDIyMDI3YWZjMi4uMjY0ZDc0NDI0YjYwZjM5ODRjOTYwYmM4OWJlYjJh NDg1YjExYjA4YSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5CkBAIC0xODMsMTUgKzE4Myw2IEBAIGNs YXNzIENocm9taXVtUG9ydChiYXNlLlBvcnQpOgogICAgICAgICBpZiBvcy5wYXRoLmV4aXN0cyhj YWNoZWRpcik6CiAgICAgICAgICAgICBzaHV0aWwucm10cmVlKGNhY2hlZGlyKQogCi0gICAgZGVm IHNob3dfcmVzdWx0c19odG1sX2ZpbGUoc2VsZiwgcmVzdWx0c19maWxlbmFtZSk6Ci0gICAgICAg IHVyaSA9IHNlbGYuZ2V0X2Fic29sdXRlX3BhdGgocmVzdWx0c19maWxlbmFtZSkKLSAgICAgICAg aWYgc2VsZi5fb3B0aW9ucy51c2VfZHJ0OgotICAgICAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91 bGQgdXNlIFVzZXIub3Blbl91cmwKLSAgICAgICAgICAgIHdlYmJyb3dzZXIub3Blbih1cmksIG5l dz0xKQotICAgICAgICBlbHNlOgotICAgICAgICAgICAgIyBOb3RlOiBOb3QgdGhyZWFkIHNhZmU6 IGh0dHA6Ly9idWdzLnB5dGhvbi5vcmcvaXNzdWUyMzIwCi0gICAgICAgICAgICBzdWJwcm9jZXNz LlBvcGVuKFtzZWxmLl9wYXRoX3RvX2RyaXZlcigpLCB1cmldKQotCiAgICAgZGVmIGNyZWF0ZV9k cml2ZXIoc2VsZiwgaW1hZ2VfcGF0aCwgb3B0aW9ucyk6CiAgICAgICAgICIiIlN0YXJ0cyBhIG5l dyBEcml2ZXIgYW5kIHJldHVybnMgYSBoYW5kbGUgdG8gaXQuIiIiCiAgICAgICAgIGlmIHNlbGYu X29wdGlvbnMudXNlX2RydCBhbmQgc3lzLnBsYXRmb3JtID09ICdkYXJ3aW4nOgpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5 IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5 CmluZGV4IGEzYTE2YzM0YTVhMjI2Njc0NmFmNWUwODBkZGM2NDUyMDE5Y2NmNDcuLjY4ZGY5NjRl MTkxNTNkYjRiMzA1ZGNkZWM1YjQxZDFmMWVjZDU0N2YgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdC5weQorKysgYi9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3QucHkKQEAgLTkzLDkg KzkzLDYgQEAgY2xhc3MgVGVzdFBvcnQoYmFzZS5Qb3J0KToKICAgICBkZWYgc2V0dXBfdGVzdF9y dW4oc2VsZik6CiAgICAgICAgIHBhc3MKIAotICAgIGRlZiBzaG93X3Jlc3VsdHNfaHRtbF9maWxl KHNlbGYsIGZpbGVuYW1lKToKLSAgICAgICAgcGFzcwotCiAgICAgZGVmIGNyZWF0ZV9kcml2ZXIo c2VsZiwgaW1hZ2VfcGF0aCwgb3B0aW9ucyk6CiAgICAgICAgIHJldHVybiBUZXN0RHJpdmVyKGlt YWdlX3BhdGgsIG9wdGlvbnMsIHNlbGYpCiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5IGIvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKaW5kZXggYjA4NWNlYjdl NjhmYzZiZGZjMjViZWEyYWFmYWU4YWI4YmM5MmRiOC4uMzNiODhmMzI0YzUxNGYxMjIzYmE0MzA1 MzNiMGFjMTk3Y2NjNzU1YSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKQEAgLTE5MywxMSArMTkzLDYgQEAg Y2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQpOgogICAgICAgICAjIFRoaXMgcG9ydCBkb2Vzbid0 IHJlcXVpcmUgYW55IHNwZWNpZmljIGNvbmZpZ3VyYXRpb24uCiAgICAgICAgIHBhc3MKIAotICAg IGRlZiBzaG93X3Jlc3VsdHNfaHRtbF9maWxlKHNlbGYsIHJlc3VsdHNfZmlsZW5hbWUpOgotICAg ICAgICB1cmkgPSBzZWxmLmZpbGVuYW1lX3RvX3VyaShyZXN1bHRzX2ZpbGVuYW1lKQotICAgICAg ICAjIEZJWE1FOiBXZSBzaG91bGQgb3BlbiByZXN1bHRzIGluIHRoZSB2ZXJzaW9uIG9mIFdlYktp dCB3ZSBidWlsdC4KLSAgICAgICAgd2ViYnJvd3Nlci5vcGVuKHVyaSwgbmV3PTEpCi0KICAgICBk ZWYgY3JlYXRlX2RyaXZlcihzZWxmLCBpbWFnZV9wYXRoLCBvcHRpb25zKToKICAgICAgICAgcmV0 dXJuIFdlYktpdERyaXZlcihzZWxmLCBpbWFnZV9wYXRoLCBvcHRpb25zLCBleGVjdXRpdmU9c2Vs Zi5fZXhlY3V0aXZlKQogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9yZWJhc2VsaW5lX2Nocm9taXVtX3dlYmtpdF90ZXN0cy5weSBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3JlYmFzZWxpbmVfY2hyb21pdW1f d2Via2l0X3Rlc3RzLnB5CmluZGV4IDNhOWY5MjNhMDU2Mjk3NTJhNDliODNhMjViOTgxMTMxNjUw NTdiODcuLmRhNGUyNDkyZDc4NjQzM2MwMjZjZWZmZjYxMTIzMGQ0YWRkOTgxOWMgMTAwNjQ0Ci0t LSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3JlYmFzZWxpbmVf Y2hyb21pdW1fd2Via2l0X3Rlc3RzLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3JlYmFzZWxpbmVfY2hyb21pdW1fd2Via2l0X3Rlc3RzLnB5CkBAIC01 NSw5ICs1NSw5IEBAIGltcG9ydCBzeXMKIGltcG9ydCB0ZW1wZmlsZQogaW1wb3J0IHRpbWUKIGlt cG9ydCB1cmxsaWIKLWltcG9ydCB3ZWJicm93c2VyCiBpbXBvcnQgemlwZmlsZQogCitmcm9tIHdl YmtpdHB5LmNvbW1vbi5zeXN0ZW0udXNlciBpbXBvcnQgVXNlcgogZnJvbSB3ZWJraXRweS5jb21t b24uc3lzdGVtLmV4ZWN1dGl2ZSBpbXBvcnQgcnVuX2NvbW1hbmQsIFNjcmlwdEVycm9yCiBpbXBv cnQgd2Via2l0cHkuY29tbW9uLmNoZWNrb3V0LnNjbSBhcyBzY20KIApAQCAtNzM3LDEwICs3Mzcs NyBAQCBjbGFzcyBIdG1sR2VuZXJhdG9yKG9iamVjdCk6CiAgICAgICAgICIiIkxhdW5jaCB0aGUg cmViYXNlbGluaW5nIGh0bWwgaW4gYnJ3b3Nlci4iIiIKIAogICAgICAgICBfbG9nLmluZm8oJ0xh dW5jaGluZyBodG1sOiAiJXMiJywgc2VsZi5faHRtbF9maWxlKQotCi0gICAgICAgIGh0bWxfdXJp ID0gc2VsZi5fdGFyZ2V0X3BvcnQuZmlsZW5hbWVfdG9fdXJpKHNlbGYuX2h0bWxfZmlsZSkKLSAg ICAgICAgd2ViYnJvd3Nlci5vcGVuKGh0bWxfdXJpLCAxKQotCisgICAgICAgIFVzZXIoKS5vcGVu X3VybChzZWxmLl9odG1sX2ZpbGUpCiAgICAgICAgIF9sb2cuaW5mbygnSHRtbCBsYXVuY2hlZC4n KQogCiAgICAgZGVmIF9nZW5lcmF0ZV9iYXNlbGluZV9saW5rcyhzZWxmLCB0ZXN0X2Jhc2VuYW1l LCBzdWZmaXgsIHBsYXRmb3JtKToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkgYi9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CmluZGV4IDJlMmRh NmQ1ODczNzcxODBjNWJmYmQxNzQ4ZGI4NTk0ZWZhYWEyMjUuLmYyM2JkMjI0MTJkYWNhOTgwYjAx NjUwYmRhZDhmNmI0ZmEwZTEwOWUgMTAwNzU1Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKKysrIGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQpAQCAtNzQs NiArNzQsNyBAQCBmcm9tIHRlc3RfdHlwZXMgaW1wb3J0IGltYWdlX2RpZmYKIGZyb20gdGVzdF90 eXBlcyBpbXBvcnQgdGV4dF9kaWZmCiBmcm9tIHRlc3RfdHlwZXMgaW1wb3J0IHRlc3RfdHlwZV9i YXNlCiAKK2Zyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS51c2VyIGltcG9ydCBVc2VyCiBmcm9t IHdlYmtpdHB5LnRoaXJkcGFydHkgaW1wb3J0IHNpbXBsZWpzb24KIAogaW1wb3J0IHBvcnQKQEAg LTEzNDIsNyArMTM0Myw3IEBAIGNsYXNzIFRlc3RSdW5uZXI6CiAgICAgICAgICIiIlNob3dzIHRo ZSByZXN1bHRzLmh0bWwgcGFnZS4iIiIKICAgICAgICAgcmVzdWx0c19maWxlbmFtZSA9IG9zLnBh dGguam9pbihzZWxmLl9vcHRpb25zLnJlc3VsdHNfZGlyZWN0b3J5LAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICJyZXN1bHRzLmh0bWwiKQotICAgICAgICBzZWxmLl9w b3J0LnNob3dfcmVzdWx0c19odG1sX2ZpbGUocmVzdWx0c19maWxlbmFtZSkKKyAgICAgICAgVXNl cigpLm9wZW5fdXJsKHJlc3VsdHNfZmlsZW5hbWUpCiAKIAogZGVmIHJlYWRfdGVzdF9maWxlcyhm aWxlcyk6Cg== 68168 2010-09-20 18:20:53 -0700 2010-09-20 21:06:40 -0700 Patch bug-46128-20100920182052.patch text/plain 11025 dpranke ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAyNzAxYzdkZmM2MDMyZTNhN2YyMGU2ODZhODIzZDM5NTFkMmMxMWI2Li5hY2MzZDUy OGIxYjE0MzExZWY0YTkxYjlhOGEwMGE0YmQ0Y2MxMWFiIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMgQEAK KzIwMTAtMDktMjAgIERpcmsgUHJhbmtlICA8ZHByYW5rZUBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KKworICAgICAgICBNb2RpZnkgbmV3LXJ1bi13ZWJr aXQtdGVzdHMgYW5kIHJlYmFzZWxpbmUtY2hyb21pdW0td2Via2l0LXRlc3RzCisgICAgICAgIHRv IHVzZSB0aGUgY29tbW9uIHJvdXRpbmUgaW4gd2Via2l0cHkuY29tbW9uLnN5c3RlbS51c2VyLm9w ZW5fdXJsKCkKKyAgICAgICAgdG8gZGlzcGxheSBIVE1MIGZpbGVzLgorCisgICAgICAgIFRoZXJl IHdhcyBhIHJvdXRpbmUgaW4gdGhlIFBvcnQgaW50ZXJmYWNlIHRvIGRvIHRoZSBzYW1lIHRoaW5n LAorICAgICAgICBidXQgSSBzZWUgbm8gbmVlZCBmb3IgYSBwb3J0LXNwZWNpZmljIGhvb2sgZm9y IHRoaXMsIHNpbmNlIGl0IGlzCisgICAgICAgIHNvbWV0aGluZyB0aGF0IHdpbGwgYWx3YXlzIGJl IGV4ZWN1dGVkIGJ5IHRoZSBob3N0IGVudmlyb25tZW50CisgICAgICAgIGFuZCBkaXNwbGF5aW5n IHdlYiBwYWdlcyBoYXMgbm90aGluZyB0byBkbyB3aXRoIHJ1bm5pbmcgbGF5b3V0IHRlc3RzLgor CisgICAgICAgIE5vdGUgdGhhdCBuZXctcnVuLXdlYmtpdC10ZXN0cyB1c2VkIHRvIHVzZSB0ZXN0 X3NoZWxsIHRvIGRpc3BsYXkKKyAgICAgICAgdGhlIHBhZ2U7IHRoaXMgaXMgcG90ZW50aWFsbHkg dXNlZnVsIHNvIHRoYXQgeW91IGNhbiBhY3R1YWxseSBjbGljaworICAgICAgICBmcm9tIGEgcmVz dWx0IHRvIHRoZSBicm9rZW4gcGFnZTsgaG93ZXZlciwgc2luY2UgRHVtcFJlbmRlclRyZWUKKyAg ICAgICAgZG9lc24ndCBzdXBwb3J0IHRoaXMgZnVuY3Rpb25hbGl0eSwgaXQgd2lsbCBiZSBnb2lu ZyBhd2F5IGV2ZW50dWFsbHkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTQ2MTI4CisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9z eXN0ZW0vdXNlci5weToKKyAgICAgICAgICAqIEFkZCBvcGVuX3VybCBmdW5jdGlvbiB0byB3cmFw IFVzZXIoKS5vcGVuX3VybCBmb3IgY2FsbGVycyB3aG8KKyAgICAgICAgICAgIGRvbid0IGhhdmUg YSBVc2VyIG9iamVjdC4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2Nocm9taXVtLnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvdGVzdC5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L3dlYmtpdC5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9y ZWJhc2VsaW5lX2Nocm9taXVtX3dlYmtpdF90ZXN0cy5weToKKyAgICAgICAgKiBTY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5OgorICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QucHk6CisK IDIwMTAtMDktMjAgIEFuZHJldyBXaWxzb24gIDxhdHdpbHNvbkBjaHJvbWl1bS5vcmc+CiAKICAg ICAgICAgUmV2ZXJ0IGNoYW5nZSB3aGljaCB3YXMgYWNjaWRlbnRhbGx5IGNvbW1pdHRlZCBhbG9u ZyB3aXRoIHNvbWUgZXhwZWN0YXRpb24gY2hhbmdlcy4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS91c2VyLnB5IGIvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL3VzZXIucHkKaW5kZXggOTQ0NGMwMGM1OGY1M2Qz YzI2MmIxZWFlNWUwYzQ0M2I5NzhiM2YxNy4uMDI3OGJiODgzMjBlMWU0MDQ3ZDMwNmE3Y2FlNjU1 Yzk1ZTkyYmJlMSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vc3lzdGVtL3VzZXIucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vc3lzdGVtL3VzZXIucHkKQEAgLTUwLDYgKzUwLDE1IEBAIGV4Y2VwdCBJbXBvcnRFcnJvcjoK ICAgICAgICAgX2xvZy53YXJuKCIgIHN1ZG8gcG9ydCBpbnN0YWxsIHB5MjUtcmVhZGxpbmUiKQog CiAKK2RlZiBvcGVuX3VybCh1cmwpOgorICAgICIiIk9wZW5zIGEgVVJMIHVzaW5nIHRoZSB1c2Vy J3Mgd2ViIGJyb3dzZXIuCisKKyAgICBJZiB0aGUgY2FsbGVyIGhhcyBhY2Nlc3MgdG8gYSBVc2Vy IG9iamVjdCwgVXNlci5vcGVuX3VybCgpIHNob3VsZCBiZSBjYWxsZWQKKyAgICBpbnN0ZWFkLgor CisgICAgIiIiCisgICAgVXNlcigpLm9wZW5fdXJsKHVybCkKKwogY2xhc3MgVXNlcihvYmplY3Qp OgogICAgICMgRklYTUU6IFRoZXNlIGFyZSBAY2xhc3NtZXRob2RzIGJlY2F1c2UgYnVnemlsbGEu cHkgZG9lc24ndCBoYXZlIGEgVG9vbCBvYmplY3QgKHRodXMgbm8gVXNlciBpbnN0YW5jZSkuCiAg ICAgQGNsYXNzbWV0aG9kCkBAIC0xMTEsNiArMTIwLDcgQEAgY2xhc3MgVXNlcihvYmplY3QpOgog ICAgICAgICBleGNlcHQgd2ViYnJvd3Nlci5FcnJvciwgZToKICAgICAgICAgICAgIHJldHVybiBG YWxzZQogCisgICAgIyBUaGlzIG1ldGhvZCBleGlzdHMgZm9yIGNhbGxlcnMgdGhhdCBkb24ndCBh bHJlYWR5IGhhdmUgYSBVc2VyIG9iamVjdC4KICAgICBkZWYgb3Blbl91cmwoc2VsZiwgdXJsKToK ICAgICAgICAgaWYgbm90IHNlbGYuY2FuX29wZW5fdXJsKCk6CiAgICAgICAgICAgICBfbG9nLndh cm4oIkZhaWxlZCB0byBvcGVuICVzIiAlIHVybCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkgYi9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5CmluZGV4IDg5 NmVhYjE1ZTViMTI2MDU1ZjhhMDdlNjA0MDBiNTQyMjAyN2FmYzIuLjI2NGQ3NDQyNGI2MGYzOTg0 Yzk2MGJjODliZWIyYTQ4NWIxMWIwOGEgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkKKysrIGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weQpAQCAtMTgzLDE1 ICsxODMsNiBAQCBjbGFzcyBDaHJvbWl1bVBvcnQoYmFzZS5Qb3J0KToKICAgICAgICAgaWYgb3Mu cGF0aC5leGlzdHMoY2FjaGVkaXIpOgogICAgICAgICAgICAgc2h1dGlsLnJtdHJlZShjYWNoZWRp cikKIAotICAgIGRlZiBzaG93X3Jlc3VsdHNfaHRtbF9maWxlKHNlbGYsIHJlc3VsdHNfZmlsZW5h bWUpOgotICAgICAgICB1cmkgPSBzZWxmLmdldF9hYnNvbHV0ZV9wYXRoKHJlc3VsdHNfZmlsZW5h bWUpCi0gICAgICAgIGlmIHNlbGYuX29wdGlvbnMudXNlX2RydDoKLSAgICAgICAgICAgICMgRklY TUU6IFRoaXMgc2hvdWxkIHVzZSBVc2VyLm9wZW5fdXJsCi0gICAgICAgICAgICB3ZWJicm93c2Vy Lm9wZW4odXJpLCBuZXc9MSkKLSAgICAgICAgZWxzZToKLSAgICAgICAgICAgICMgTm90ZTogTm90 IHRocmVhZCBzYWZlOiBodHRwOi8vYnVncy5weXRob24ub3JnL2lzc3VlMjMyMAotICAgICAgICAg ICAgc3VicHJvY2Vzcy5Qb3Blbihbc2VsZi5fcGF0aF90b19kcml2ZXIoKSwgdXJpXSkKLQogICAg IGRlZiBjcmVhdGVfZHJpdmVyKHNlbGYsIGltYWdlX3BhdGgsIG9wdGlvbnMpOgogICAgICAgICAi IiJTdGFydHMgYSBuZXcgRHJpdmVyIGFuZCByZXR1cm5zIGEgaGFuZGxlIHRvIGl0LiIiIgogICAg ICAgICBpZiBzZWxmLl9vcHRpb25zLnVzZV9kcnQgYW5kIHN5cy5wbGF0Zm9ybSA9PSAnZGFyd2lu JzoKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvdGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvdGVzdC5weQppbmRleCBhM2ExNmMzNGE1YTIyNjY3NDZhZjVlMDgwZGRjNjQ1MjAxOWNj ZjQ3Li42OGRmOTY0ZTE5MTUzZGI0YjMwNWRjZGVjNWI0MWQxZjFlY2Q1NDdmIDEwMDY0NAotLS0g YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3QucHkK KysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0 LnB5CkBAIC05Myw5ICs5Myw2IEBAIGNsYXNzIFRlc3RQb3J0KGJhc2UuUG9ydCk6CiAgICAgZGVm IHNldHVwX3Rlc3RfcnVuKHNlbGYpOgogICAgICAgICBwYXNzCiAKLSAgICBkZWYgc2hvd19yZXN1 bHRzX2h0bWxfZmlsZShzZWxmLCBmaWxlbmFtZSk6Ci0gICAgICAgIHBhc3MKLQogICAgIGRlZiBj cmVhdGVfZHJpdmVyKHNlbGYsIGltYWdlX3BhdGgsIG9wdGlvbnMpOgogICAgICAgICByZXR1cm4g VGVzdERyaXZlcihpbWFnZV9wYXRoLCBvcHRpb25zLCBzZWxmKQogCmRpZmYgLS1naXQgYS9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weSBiL1dl YktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5Cmlu ZGV4IGIwODVjZWI3ZTY4ZmM2YmRmYzI1YmVhMmFhZmFlOGFiOGJjOTJkYjguLjMzYjg4ZjMyNGM1 MTRmMTIyM2JhNDMwNTMzYjBhYzE5N2NjYzc1NWEgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CisrKyBiL1dlYktpdFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CkBAIC0xOTMs MTEgKzE5Myw2IEBAIGNsYXNzIFdlYktpdFBvcnQoYmFzZS5Qb3J0KToKICAgICAgICAgIyBUaGlz IHBvcnQgZG9lc24ndCByZXF1aXJlIGFueSBzcGVjaWZpYyBjb25maWd1cmF0aW9uLgogICAgICAg ICBwYXNzCiAKLSAgICBkZWYgc2hvd19yZXN1bHRzX2h0bWxfZmlsZShzZWxmLCByZXN1bHRzX2Zp bGVuYW1lKToKLSAgICAgICAgdXJpID0gc2VsZi5maWxlbmFtZV90b191cmkocmVzdWx0c19maWxl bmFtZSkKLSAgICAgICAgIyBGSVhNRTogV2Ugc2hvdWxkIG9wZW4gcmVzdWx0cyBpbiB0aGUgdmVy c2lvbiBvZiBXZWJLaXQgd2UgYnVpbHQuCi0gICAgICAgIHdlYmJyb3dzZXIub3Blbih1cmksIG5l dz0xKQotCiAgICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwgaW1hZ2VfcGF0aCwgb3B0aW9ucyk6 CiAgICAgICAgIHJldHVybiBXZWJLaXREcml2ZXIoc2VsZiwgaW1hZ2VfcGF0aCwgb3B0aW9ucywg ZXhlY3V0aXZlPXNlbGYuX2V4ZWN1dGl2ZSkKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNlbGluZV9jaHJvbWl1bV93ZWJraXRfdGVz dHMucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9yZWJhc2Vs aW5lX2Nocm9taXVtX3dlYmtpdF90ZXN0cy5weQppbmRleCAzYTlmOTIzYTA1NjI5NzUyYTQ5Yjgz YTI1Yjk4MTEzMTY1MDU3Yjg3Li40OTkxM2E5YjlmYmU0YTljZjY4NzJkZjNmYzM3Y2EzNzE2MDQ0 OWJkIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9yZWJhc2VsaW5lX2Nocm9taXVtX3dlYmtpdF90ZXN0cy5weQorKysgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9yZWJhc2VsaW5lX2Nocm9taXVtX3dlYmtpdF90 ZXN0cy5weQpAQCAtNTUsOSArNTUsOSBAQCBpbXBvcnQgc3lzCiBpbXBvcnQgdGVtcGZpbGUKIGlt cG9ydCB0aW1lCiBpbXBvcnQgdXJsbGliCi1pbXBvcnQgd2ViYnJvd3NlcgogaW1wb3J0IHppcGZp bGUKIAorZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtIGltcG9ydCB1c2VyCiBmcm9tIHdlYmtp dHB5LmNvbW1vbi5zeXN0ZW0uZXhlY3V0aXZlIGltcG9ydCBydW5fY29tbWFuZCwgU2NyaXB0RXJy b3IKIGltcG9ydCB3ZWJraXRweS5jb21tb24uY2hlY2tvdXQuc2NtIGFzIHNjbQogCkBAIC03Mzcs MTAgKzczNyw3IEBAIGNsYXNzIEh0bWxHZW5lcmF0b3Iob2JqZWN0KToKICAgICAgICAgIiIiTGF1 bmNoIHRoZSByZWJhc2VsaW5pbmcgaHRtbCBpbiBicndvc2VyLiIiIgogCiAgICAgICAgIF9sb2cu aW5mbygnTGF1bmNoaW5nIGh0bWw6ICIlcyInLCBzZWxmLl9odG1sX2ZpbGUpCi0KLSAgICAgICAg aHRtbF91cmkgPSBzZWxmLl90YXJnZXRfcG9ydC5maWxlbmFtZV90b191cmkoc2VsZi5faHRtbF9m aWxlKQotICAgICAgICB3ZWJicm93c2VyLm9wZW4oaHRtbF91cmksIDEpCi0KKyAgICAgICAgdXNl ci5vcGVuX3VybChzZWxmLl9odG1sX2ZpbGUpCiAgICAgICAgIF9sb2cuaW5mbygnSHRtbCBsYXVu Y2hlZC4nKQogCiAgICAgZGVmIF9nZW5lcmF0ZV9iYXNlbGluZV9saW5rcyhzZWxmLCB0ZXN0X2Jh c2VuYW1lLCBzdWZmaXgsIHBsYXRmb3JtKToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkgYi9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CmluZGV4 IDJlMmRhNmQ1ODczNzcxODBjNWJmYmQxNzQ4ZGI4NTk0ZWZhYWEyMjUuLjQ0MDRhYzRjNmJmZWEz NDA5OTY2YzI1MmUyOTkyYjE2OGUyNjJiODQgMTAwNzU1Ci0tLSBhL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKKysrIGIvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQpA QCAtNzQsNiArNzQsNyBAQCBmcm9tIHRlc3RfdHlwZXMgaW1wb3J0IGltYWdlX2RpZmYKIGZyb20g dGVzdF90eXBlcyBpbXBvcnQgdGV4dF9kaWZmCiBmcm9tIHRlc3RfdHlwZXMgaW1wb3J0IHRlc3Rf dHlwZV9iYXNlCiAKK2Zyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbSBpbXBvcnQgdXNlcgogZnJv bSB3ZWJraXRweS50aGlyZHBhcnR5IGltcG9ydCBzaW1wbGVqc29uCiAKIGltcG9ydCBwb3J0CkBA IC0xMzQyLDcgKzEzNDMsNyBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICAiIiJTaG93cyB0 aGUgcmVzdWx0cy5odG1sIHBhZ2UuIiIiCiAgICAgICAgIHJlc3VsdHNfZmlsZW5hbWUgPSBvcy5w YXRoLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1bHRzX2RpcmVjdG9yeSwKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAicmVzdWx0cy5odG1sIikKLSAgICAgICAgc2VsZi5f cG9ydC5zaG93X3Jlc3VsdHNfaHRtbF9maWxlKHJlc3VsdHNfZmlsZW5hbWUpCisgICAgICAgIHVz ZXIub3Blbl91cmwocmVzdWx0c19maWxlbmFtZSkKIAogCiBkZWYgcmVhZF90ZXN0X2ZpbGVzKGZp bGVzKToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3J1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0LnB5CmluZGV4IGFh OTY5NjI3MmQ5YTg3OGU2YTliOTZhNDQyYTlkNWEzYmZhOTk5NDQuLmUwMDE4ZmJkZGU5OTE4OWEw ZTRhNTc0Y2UzZmE1MjA5ZmM0MzhlNGYgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QucHkKKysrIGIv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0 c191bml0dGVzdC5weQpAQCAtNDIsNiArNDIsNyBAQCBpbXBvcnQgdW5pdHRlc3QKIAogZnJvbSB3 ZWJraXRweS5jb21tb24gaW1wb3J0IGFycmF5X3N0cmVhbQogZnJvbSB3ZWJraXRweS5jb21tb24u c3lzdGVtIGltcG9ydCBvdXRwdXRjYXB0dXJlCitmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0g aW1wb3J0IHVzZXIKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzIGltcG9ydCBwb3J0CiBmcm9t IHdlYmtpdHB5LmxheW91dF90ZXN0cyBpbXBvcnQgcnVuX3dlYmtpdF90ZXN0cwogZnJvbSB3ZWJr aXRweS5sYXlvdXRfdGVzdHMubGF5b3V0X3BhY2thZ2UgaW1wb3J0IGR1bXBfcmVuZGVyX3RyZWVf dGhyZWFkCkBAIC05MCw3ICs5MSwxOSBAQCBkZWYgbG9nZ2luZ19ydW4oYXJncz1bXSwgdGVzdHNf aW5jbHVkZWQ9RmFsc2UpOgogICAgIHJldHVybiAocmVzLCBidWlsZGJvdF9vdXRwdXQsIHJlZ3Vs YXJfb3V0cHV0KQogCiAKLWNsYXNzIE1haW5UZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKK2NsYXNz IEJhc2VUZXN0Q2FzZSh1bml0dGVzdC5UZXN0Q2FzZSk6CisgICAgZGVmIHNldFVwKHNlbGYpOgor ICAgICAgICBkZWYgb3Blbl91cmwodXJsKToKKyAgICAgICAgICAgIHNlbGYuX3VybF9vcGVuZWQg PSB1cmwKKyAgICAgICAgc2VsZi5fdXNlcl9vcGVuX3VybCA9IHVzZXIub3Blbl91cmwKKyAgICAg ICAgdXNlci5vcGVuX3VybCA9IG9wZW5fdXJsCisgICAgICAgIHNlbGYuX3VybF9vcGVuZWQgPSBO b25lCisKKyAgICBkZWYgdGVhckRvd24oc2VsZik6CisgICAgICAgIHVzZXIub3Blbl91cmwgPSBz ZWxmLl91c2VyX29wZW5fdXJsCisKKworY2xhc3MgTWFpblRlc3QoQmFzZVRlc3RDYXNlKToKICAg ICBkZWYgdGVzdF9iYXNpYyhzZWxmKToKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHBhc3Npbmdf cnVuKCkpCiAKQEAgLTIwMywxMCArMjE2LDEyIEBAIGNsYXNzIE1haW5UZXN0KHVuaXR0ZXN0LlRl c3RDYXNlKToKIAogICAgIGRlZiB0ZXN0X3VuZXhwZWN0ZWRfZmFpbHVyZXMoc2VsZik6CiAgICAg ICAgICMgUnVuIHRlc3RzIGluY2x1ZGluZyB0aGUgdW5leHBlY3RlZCBmYWlsdXJlcy4KKyAgICAg ICAgc2VsZi5fdXJsX29wZW5lZCA9IE5vbmUKICAgICAgICAgcmVzLCBvdXQsIGVyciA9IGxvZ2dp bmdfcnVuKHRlc3RzX2luY2x1ZGVkPVRydWUpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocmVz LCAxKQogICAgICAgICBzZWxmLmFzc2VydEZhbHNlKG91dC5lbXB0eSgpKQogICAgICAgICBzZWxm LmFzc2VydEZhbHNlKGVyci5lbXB0eSgpKQorICAgICAgICBzZWxmLmFzc2VydFRydWUoc2VsZi5f dXJsX29wZW5lZCkKIAogCiBkZWYgX21vY2tlZF9vcGVuKG9yaWdpbmFsX29wZW4sIGZpbGVfbGlz dCk6CkBAIC0yMjAsNyArMjM1LDcgQEAgZGVmIF9tb2NrZWRfb3BlbihvcmlnaW5hbF9vcGVuLCBm aWxlX2xpc3QpOgogICAgIHJldHVybiBfd3JhcHBlcgogCiAKLWNsYXNzIFJlYmFzZWxpbmVUZXN0 KHVuaXR0ZXN0LlRlc3RDYXNlKToKK2NsYXNzIFJlYmFzZWxpbmVUZXN0KEJhc2VUZXN0Q2FzZSk6 CiAgICAgZGVmIGFzc2VydEJhc2VsaW5lcyhzZWxmLCBmaWxlX2xpc3QsIGZpbGUpOgogICAgICAg ICAiYXNzZXJ0IHRoYXQgdGhlIGZpbGVfbGlzdCBjb250YWlucyB0aGUgYmFzZWxpbmVzLiIiIgog ICAgICAgICBmb3IgZXh0IGluIFsiLnR4dCIsICIucG5nIiwgIi5jaGVja3N1bSJdOgpAQCAtMjY5 LDcgKzI4NCw4IEBAIGNsYXNzIFJlYmFzZWxpbmVUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAg ICAgICAgZmluYWxseToKICAgICAgICAgICAgIGNvZGVjcy5vcGVuID0gb3JpZ2luYWxfb3Blbgog Ci1jbGFzcyBUZXN0UnVubmVyVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CisKK2NsYXNzIFRlc3RS dW5uZXJUZXN0KEJhc2VUZXN0Q2FzZSk6CiAgICAgZGVmIHRlc3RfcmVzdWx0c19odG1sKHNlbGYp OgogICAgICAgICBtb2NrX3BvcnQgPSBNb2NrKCkKICAgICAgICAgbW9ja19wb3J0LnJlbGF0aXZl X3Rlc3RfZmlsZW5hbWUgPSBsYW1iZGEgbmFtZTogbmFtZQpAQCAtMjkwLDcgKzMwNiw3IEBAIGNs YXNzIFRlc3RSdW5uZXJUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAgc2VsZi5hc3Nl cnRFcXVhbChodG1sLCBleHBlY3RlZF9odG1sKQogCiAKLWNsYXNzIERyeXJ1blRlc3QodW5pdHRl c3QuVGVzdENhc2UpOgorY2xhc3MgRHJ5cnVuVGVzdChCYXNlVGVzdENhc2UpOgogICAgICMgRklY TUU6IGl0J3MgaGFyZCB0byBrbm93IHdoaWNoIHBsYXRmb3JtcyBhcmUgc2FmZSB0byB0ZXN0OyB0 aGUKICAgICAjIGNocm9taXVtIHBsYXRmb3JtcyByZXF1aXJlIGEgY2hyb21pdW0gY2hlY2tvdXQs IGFuZCB0aGUgbWFjIHBsYXRmb3JtCiAgICAgIyByZXF1aXJlcyBmY250bCwgc28gaXQgY2FuJ3Qg YmUgdGVzdGVkIG9uIHdpbjMyLCBldGMuIFRoZXJlIGlzCkBAIC0zNTcsNyArMzczLDcgQEAgY2xh c3MgVGVzdEhhbmRsZXIobG9nZ2luZy5IYW5kbGVyKToKICAgICAgICAgc2VsZi5fc3RyZWFtLndy aXRlKHNlbGYuZm9ybWF0KHJlY29yZCkpCiAKIAotY2xhc3MgV2FpdEZvclRocmVhZHNUb0Zpbmlz aFRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgorY2xhc3MgV2FpdEZvclRocmVhZHNUb0ZpbmlzaFRl c3QoQmFzZVRlc3RDYXNlKToKICAgICBjbGFzcyBNb2NrVGVzdFJ1bm5lcihydW5fd2Via2l0X3Rl c3RzLlRlc3RSdW5uZXIpOgogICAgICAgICBkZWYgX19pbml0X18oc2VsZik6CiAgICAgICAgICAg ICBwYXNzCkBAIC0zOTgsNyArNDE0LDcgQEAgY2xhc3MgV2FpdEZvclRocmVhZHNUb0ZpbmlzaFRl c3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICBzZWxmLmFzc2VydFJhaXNlcyhWYWx1ZUVy cm9yLCBzZWxmLnJ1bl9vbmVfdGhyZWFkLCAnRXhjZXB0aW9uJykKIAogCi1jbGFzcyBTdGFuZGFs b25lRnVuY3Rpb25zVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CitjbGFzcyBTdGFuZGFsb25lRnVu Y3Rpb25zVGVzdChCYXNlVGVzdENhc2UpOgogICAgIGRlZiB0ZXN0X2xvZ193ZWRnZWRfdGhyZWFk KHNlbGYpOgogICAgICAgICBvYyA9IG91dHB1dGNhcHR1cmUuT3V0cHV0Q2FwdHVyZSgpCiAgICAg ICAgIG9jLmNhcHR1cmVfb3V0cHV0KCkK 68184 2010-09-20 21:06:44 -0700 2010-09-21 12:34:12 -0700 Patch bug-46128-20100920210643.patch text/plain 36419 dpranke ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA5MmZjMDRiNGE2NWIzNmE1NmIxYWY1OTc3MmE4MjkwMDkzNzEwYmY1Li40ZDM3Yjg3 NDM3MmU0NTdiNTA5ZTYwNmEzYTE1Zjc4ZTY3Mzk0YTE4IDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDkgQEAK KzIwMTAtMDktMjAgIERpcmsgUHJhbmtlICA8ZHByYW5rZUBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KKworICAgICAgICBNb2RpZnkgdGhlIFBvcnQgaW50 ZXJmYWNlIHRvIHRha2Ugb25seSBhIHNlcmllcyBvZiBrZXl3b3JkIGFyZ3VtZW50cworICAgICAg ICBpbiB0aGUgY29uc3RydWN0b3IsIGFuZCBtb2RpZnkgUG9ydC9mYWN0b3J5LmdldCgpIHRvIGFj Y29tb2RhdGUgdGhhdCwKKyAgICAgICAgYW5kIHRvIGFjY2VwdCB1c2VyPVhYWCBhcyBhbiBhcmd1 bWVudCBzbyB3ZSBjYW4gcGFzcworICAgICAgICB3ZWJraXRweS5jb21tb24uc3lzdGVtLnVzZXIu VXNlciBvYmplY3RzIGluLgorCisgICAgICAgIFRoZW4sIG1vZGlmeSBuZXctcnVuLXdlYmtpdC10 ZXN0cyBhbmQgcmViYXNlbGluZS1jaHJvbWl1bS13ZWJraXQtdGVzdHMKKyAgICAgICAgdG8gdXNl IHRoZSBjb21tb24gcm91dGluZSBpbiB3ZWJraXRweS5jb21tb24uc3lzdGVtLnVzZXIub3Blbl91 cmwoKQorICAgICAgICB0byBkaXNwbGF5IEhUTUwgZmlsZXMuCisKKyAgICAgICAgVGhlcmUgd2Fz IGEgcm91dGluZSBpbiB0aGUgUG9ydCBpbnRlcmZhY2UgdG8gZG8gdGhlIHNhbWUgdGhpbmcsCisg ICAgICAgIGJ1dCBJIHNlZSBubyBuZWVkIGZvciBhIHBvcnQtc3BlY2lmaWMgaG9vayBmb3IgdGhp cywgc2luY2UgaXQgaXMKKyAgICAgICAgc29tZXRoaW5nIHRoYXQgd2lsbCBhbHdheXMgYmUgZXhl Y3V0ZWQgYnkgdGhlIGhvc3QgZW52aXJvbm1lbnQKKyAgICAgICAgYW5kIGRpc3BsYXlpbmcgd2Vi IHBhZ2VzIGhhcyBub3RoaW5nIHRvIGRvIHdpdGggcnVubmluZyBsYXlvdXQgdGVzdHMuCisKKyAg ICAgICAgTm90ZSB0aGF0IG5ldy1ydW4td2Via2l0LXRlc3RzIHVzZWQgdG8gdXNlIHRlc3Rfc2hl bGwgdG8gZGlzcGxheQorICAgICAgICB0aGUgcGFnZTsgdGhpcyBpcyBwb3RlbnRpYWxseSB1c2Vm dWwgc28gdGhhdCB5b3UgY2FuIGFjdHVhbGx5IGNsaWNrCisgICAgICAgIGZyb20gYSByZXN1bHQg dG8gdGhlIGJyb2tlbiBwYWdlOyBob3dldmVyLCBzaW5jZSBEdW1wUmVuZGVyVHJlZQorICAgICAg ICBkb2Vzbid0IHN1cHBvcnQgdGhpcyBmdW5jdGlvbmFsaXR5LCBpdCB3aWxsIGJlIGdvaW5nIGF3 YXkgZXZlbnR1YWxseS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NDYxMjgKKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvYmFzZS5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2Jhc2VfdW5pdHRlc3QucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC9jaHJvbWl1bS5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fbWFjLnB5OgorICAgICAgICAqIFNjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fdW5pdHRlc3QucHk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV93aW4ucHk6Cisg ICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHk6Cisg ICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9mYWN0b3J5LnB5Ogor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ29vZ2xlX2Nocm9t ZS5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2dvb2ds ZV9jaHJvbWVfdW5pdHRlc3QucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC9ndGsucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9tYWMucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9xdC5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L3Rlc3QucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93 ZWJraXQucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93 aW4ucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNlbGlu ZV9jaHJvbWl1bV93ZWJraXRfdGVzdHMucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0LnB5OgorCiAyMDEwLTA5 LTIwICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgRXJpYyBTZWlkZWwuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKaW5kZXggNzBiZWFjMzI0OTNiYjY4NWVkMDZjNmI2 YWJlOWZmN2VhZDgxN2ZhMi4uN2MwZTQxMmU4OTY4ZjExOTY2MjM2MWI3MmYwYzVkZjRjNjk1NmRl MSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9iYXNlLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvYmFzZS5weQpAQCAtNDcsNiArNDcsNyBAQCBpbXBvcnQgd2Vic29ja2V0X3NlcnZl cgogCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0gaW1wb3J0IGxvZ3V0aWxzCiBmcm9tIHdl YmtpdHB5LmNvbW1vbi5zeXN0ZW0uZXhlY3V0aXZlIGltcG9ydCBFeGVjdXRpdmUsIFNjcmlwdEVy cm9yCitmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0udXNlciBpbXBvcnQgVXNlcgogCiAKIF9s b2cgPSBsb2d1dGlscy5nZXRfbG9nZ2VyKF9fZmlsZV9fKQpAQCAtODEsMTQgKzgyLDE1IEBAIGNs YXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgfQogICAgICAgICByZXR1cm4gZmxhZ3NfYnlfY29u ZmlndXJhdGlvbltjb25maWd1cmF0aW9uXQogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRf bmFtZT1Ob25lLCBvcHRpb25zPU5vbmUsIGV4ZWN1dGl2ZT1FeGVjdXRpdmUoKSk6Ci0gICAgICAg IHNlbGYuX25hbWUgPSBwb3J0X25hbWUKLSAgICAgICAgc2VsZi5fb3B0aW9ucyA9IG9wdGlvbnMK KyAgICBkZWYgX19pbml0X18oc2VsZiwgKiprd2FyZ3MpOgorICAgICAgICBzZWxmLl9uYW1lID0g a3dhcmdzLmdldCgncG9ydF9uYW1lJywgTm9uZSkKKyAgICAgICAgc2VsZi5fb3B0aW9ucyA9IGt3 YXJncy5nZXQoJ29wdGlvbnMnLCBOb25lKQorICAgICAgICBzZWxmLl9leGVjdXRpdmUgPSBrd2Fy Z3MuZ2V0KCdleGVjdXRpdmUnLCBFeGVjdXRpdmUoKSkKKyAgICAgICAgc2VsZi5fdXNlciA9IGt3 YXJncy5nZXQoJ3VzZXInLCBVc2VyKCkpCiAgICAgICAgIHNlbGYuX2hlbHBlciA9IE5vbmUKICAg ICAgICAgc2VsZi5faHR0cF9zZXJ2ZXIgPSBOb25lCiAgICAgICAgIHNlbGYuX3dlYmtpdF9iYXNl X2RpciA9IE5vbmUKICAgICAgICAgc2VsZi5fd2Vic29ja2V0X3NlcnZlciA9IE5vbmUKLSAgICAg ICAgc2VsZi5fZXhlY3V0aXZlID0gZXhlY3V0aXZlCiAKICAgICBkZWYgZGVmYXVsdF9jaGlsZF9w cm9jZXNzZXMoc2VsZik6CiAgICAgICAgICIiIlJldHVybiB0aGUgbnVtYmVyIG9mIER1bXBSZW5k ZXJUcmVlIGluc3RhbmNlcyB0byB1c2UgZm9yIHRoaXMKQEAgLTM3Miw3ICszNzQsNyBAQCBjbGFz cyBQb3J0KG9iamVjdCk6CiAgICAgZGVmIHNob3dfaHRtbF9yZXN1bHRzX2ZpbGUoc2VsZiwgcmVz dWx0c19maWxlbmFtZSk6CiAgICAgICAgICIiIlRoaXMgcm91dGluZSBzaG91bGQgZGlzcGxheSB0 aGUgSFRNTCBmaWxlIHBvaW50ZWQgYXQgYnkKICAgICAgICAgcmVzdWx0c19maWxlbmFtZSBpbiBh IHVzZXJzJyBicm93c2VyLiIiIgotICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdQ b3J0LnNob3dfaHRtbF9yZXN1bHRzX2ZpbGUnKQorICAgICAgICByZXR1cm4gc2VsZi5fdXNlci5v cGVuX3VybChyZXN1bHRzX2ZpbGVuYW1lKQogCiAgICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwg aW1hZ2VfcGF0aCwgb3B0aW9ucyk6CiAgICAgICAgICIiIlJldHVybiBhIG5ld2x5IGNyZWF0ZWQg YmFzZS5Ecml2ZXIgc3ViY2xhc3MgZm9yIHN0YXJ0aW5nL3N0b3BwaW5nCmRpZmYgLS1naXQgYS9X ZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2VfdW5pdHRl c3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jh c2VfdW5pdHRlc3QucHkKaW5kZXggNzgwY2QyMmY5NDUxNTI1NmNmN2JmNmJjNTRkM2YwZDdkOTA1 ZDQ3ZC4uNWEzMTJhMjYwYWEyNWJkZGYxN2E4MmFiMjdkN2Q1OWRiNzcyZDVkNiAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlX3Vu aXR0ZXN0LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvYmFzZV91bml0dGVzdC5weQpAQCAtMjMxLDcgKzIzMSw2IEBAIGNsYXNzIFZpcnR1YWxU ZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKHBvcnQu cGF0aF90b190ZXN0X2V4cGVjdGF0aW9uc19maWxlKQogICAgICAgICBzZWxmLmFzc2VydFZpcnR1 YWwocG9ydC50ZXN0X3BsYXRmb3JtX25hbWUpCiAgICAgICAgIHNlbGYuYXNzZXJ0VmlydHVhbChw b3J0LnJlc3VsdHNfZGlyZWN0b3J5KQotICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwocG9ydC5z aG93X2h0bWxfcmVzdWx0c19maWxlLCBOb25lKQogICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwo cG9ydC50ZXN0X2V4cGVjdGF0aW9ucykKICAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKHBvcnQu dGVzdF9iYXNlX3BsYXRmb3JtX25hbWVzKQogICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwocG9y dC50ZXN0X3BsYXRmb3JtX25hbWUpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weQppbmRleCAzZmM0NjEzNDcx NGFkNGQyZWZjMWM4OGM2YjBiM2Y5MjgzNDJkMzgwLi43OTM3NmI5MmMzNzVkNjk4Yzc1M2I1YTJh ODhkYWMyMTc4OWJlOTNkIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkKQEAgLTgyLDggKzgyLDEzIEBA IGRlZiBjaGVja19maWxlX2V4aXN0cyhwYXRoX3RvX2ZpbGUsIGZpbGVfZGVzY3JpcHRpb24sIG92 ZXJyaWRlX3N0ZXA9Tm9uZSwKIGNsYXNzIENocm9taXVtUG9ydChiYXNlLlBvcnQpOgogICAgICIi IkFic3RyYWN0IGJhc2UgY2xhc3MgZm9yIENocm9taXVtIGltcGxlbWVudGF0aW9ucyBvZiB0aGUg UG9ydCBjbGFzcy4iIiIKIAotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwg b3B0aW9ucz1Ob25lLCAqKmt3YXJncyk6Ci0gICAgICAgIGJhc2UuUG9ydC5fX2luaXRfXyhzZWxm LCBwb3J0X25hbWUsIG9wdGlvbnMsICoqa3dhcmdzKQorICAgIGRlZiBfX2luaXRfXyhzZWxmLCAq Kmt3YXJncyk6CisgICAgICAgIGlmICdvcHRpb25zJyBpbiBrd2FyZ3M6CisgICAgICAgICAgICBv cHRpb25zID0ga3dhcmdzWydvcHRpb25zJ10KKyAgICAgICAgICAgIGlmIChvcHRpb25zIGFuZCAo bm90IGhhc2F0dHIob3B0aW9ucywgJ2NvbmZpZ3VyYXRpb24nKSBvcgorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBvcHRpb25zLmNvbmZpZ3VyYXRpb24gaXMgTm9uZSkpOgorICAgICAgICAg ICAgICAgIG9wdGlvbnMuY29uZmlndXJhdGlvbiA9ICdSZWxlYXNlJworICAgICAgICBiYXNlLlBv cnQuX19pbml0X18oc2VsZiwgKiprd2FyZ3MpCiAgICAgICAgIHNlbGYuX2Nocm9taXVtX2Jhc2Vf ZGlyID0gTm9uZQogCiAgICAgZGVmIGJhc2VsaW5lX3BhdGgoc2VsZik6CkBAIC0xODMsMTUgKzE4 OCw2IEBAIGNsYXNzIENocm9taXVtUG9ydChiYXNlLlBvcnQpOgogICAgICAgICBpZiBvcy5wYXRo LmV4aXN0cyhjYWNoZWRpcik6CiAgICAgICAgICAgICBzaHV0aWwucm10cmVlKGNhY2hlZGlyKQog Ci0gICAgZGVmIHNob3dfcmVzdWx0c19odG1sX2ZpbGUoc2VsZiwgcmVzdWx0c19maWxlbmFtZSk6 Ci0gICAgICAgIHVyaSA9IHNlbGYuZ2V0X2Fic29sdXRlX3BhdGgocmVzdWx0c19maWxlbmFtZSkK LSAgICAgICAgaWYgc2VsZi5fb3B0aW9ucy51c2VfZHJ0OgotICAgICAgICAgICAgIyBGSVhNRTog VGhpcyBzaG91bGQgdXNlIFVzZXIub3Blbl91cmwKLSAgICAgICAgICAgIHdlYmJyb3dzZXIub3Bl bih1cmksIG5ldz0xKQotICAgICAgICBlbHNlOgotICAgICAgICAgICAgIyBOb3RlOiBOb3QgdGhy ZWFkIHNhZmU6IGh0dHA6Ly9idWdzLnB5dGhvbi5vcmcvaXNzdWUyMzIwCi0gICAgICAgICAgICBz dWJwcm9jZXNzLlBvcGVuKFtzZWxmLl9wYXRoX3RvX2RyaXZlcigpLCB1cmldKQotCiAgICAgZGVm IGNyZWF0ZV9kcml2ZXIoc2VsZiwgaW1hZ2VfcGF0aCwgb3B0aW9ucyk6CiAgICAgICAgICIiIlN0 YXJ0cyBhIG5ldyBEcml2ZXIgYW5kIHJldHVybnMgYSBoYW5kbGUgdG8gaXQuIiIiCiAgICAgICAg IGlmIG9wdGlvbnMudXNlX2RydCBhbmQgc3lzLnBsYXRmb3JtID09ICdkYXJ3aW4nOgpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJv bWl1bV9saW51eC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvY2hyb21pdW1fbGludXgucHkKaW5kZXggNGRmNDNlMDEzMjAyZjE4NzNkMjczYWY3ZDJk MzE0OGViODRiNmJjZS4uMTc2OTkxYjdmNmE2OGRmNzc5ZjcxZDUxMTA0NDEzMjg2OWUxZTE4OSAx MDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC9jaHJvbWl1bV9saW51eC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5CkBAIC00MSwxMiArNDEsOSBAQCBfbG9n ID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0LmNocm9taXVt X2xpbnV4IikKIGNsYXNzIENocm9taXVtTGludXhQb3J0KGNocm9taXVtLkNocm9taXVtUG9ydCk6 CiAgICAgIiIiQ2hyb21pdW0gTGludXggaW1wbGVtZW50YXRpb24gb2YgdGhlIFBvcnQgY2xhc3Mu IiIiCiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9Tm9u ZSk6Ci0gICAgICAgIGlmIHBvcnRfbmFtZSBpcyBOb25lOgotICAgICAgICAgICAgcG9ydF9uYW1l ID0gJ2Nocm9taXVtLWxpbnV4JwotICAgICAgICBpZiBvcHRpb25zIGFuZCBub3QgaGFzYXR0cihv cHRpb25zLCAnY29uZmlndXJhdGlvbicpOgotICAgICAgICAgICAgb3B0aW9ucy5jb25maWd1cmF0 aW9uID0gJ1JlbGVhc2UnCi0gICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhz ZWxmLCBwb3J0X25hbWUsIG9wdGlvbnMpCisgICAgZGVmIF9faW5pdF9fKHNlbGYsICoqa3dhcmdz KToKKyAgICAgICAga3dhcmdzLnNldGRlZmF1bHQoJ3BvcnRfbmFtZScsICdjaHJvbWl1bS1saW51 eCcpCisgICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhzZWxmLCAqKmt3YXJn cykKIAogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToKICAgICAgICAgcG9ydF9u YW1lcyA9IFsiY2hyb21pdW0tbGludXgiLCAiY2hyb21pdW0td2luIiwgImNocm9taXVtIiwgIndp biIsICJtYWMiXQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weQppbmRleCBhYmQ4NGFlNWVlNDRl ZjkzZjgwZjQ0ZjcwM2YwZWI2NGUxMDAzZDNlLi42NDAxNmFiMDQyY2FlOGE4ZTI3YmRjYWFiNDYx Y2Y1Y2FlM2EyZjgxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weQpAQCAtNDQsMTIgKzQ0 LDkgQEAgX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9y dC5jaHJvbWl1bV9tYWMiKQogY2xhc3MgQ2hyb21pdW1NYWNQb3J0KGNocm9taXVtLkNocm9taXVt UG9ydCk6CiAgICAgIiIiQ2hyb21pdW0gTWFjIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNs YXNzLiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvcHRpb25z PU5vbmUpOgotICAgICAgICBpZiBwb3J0X25hbWUgaXMgTm9uZToKLSAgICAgICAgICAgIHBvcnRf bmFtZSA9ICdjaHJvbWl1bS1tYWMnCi0gICAgICAgIGlmIG9wdGlvbnMgYW5kIG5vdCBoYXNhdHRy KG9wdGlvbnMsICdjb25maWd1cmF0aW9uJyk6Ci0gICAgICAgICAgICBvcHRpb25zLmNvbmZpZ3Vy YXRpb24gPSAnUmVsZWFzZScKLSAgICAgICAgY2hyb21pdW0uQ2hyb21pdW1Qb3J0Ll9faW5pdF9f KHNlbGYsIHBvcnRfbmFtZSwgb3B0aW9ucykKKyAgICBkZWYgX19pbml0X18oc2VsZiwgKiprd2Fy Z3MpOgorICAgICAgICBrd2FyZ3Muc2V0ZGVmYXVsdCgncG9ydF9uYW1lJywgJ2Nocm9taXVtLW1h YycpCisgICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhzZWxmLCAqKmt3YXJn cykKIAogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToKICAgICAgICAgcG9ydF9u YW1lcyA9IFsiY2hyb21pdW0tbWFjIiwgImNocm9taXVtIiwgIm1hYyIgKyBzZWxmLnZlcnNpb24o KSwgIm1hYyJdCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2Nocm9taXVtX3VuaXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV91bml0dGVzdC5weQppbmRleCA3YTAw NWIxNzA0ZTU5NjMzYTcxYjhiNTY3NTA5YmEyNDRkZDA5OTZiLi5mYTFjZThmNDk1MDY0OWY0NDQy YWFmNGYwOGM3ZTIwMDU1ZjhhYTljIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3VuaXR0ZXN0LnB5CisrKyBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fdW5pdHRl c3QucHkKQEAgLTg4LDEwICs4OCwxMiBAQCBjbGFzcyBDaHJvbWl1bURyaXZlclRlc3QodW5pdHRl c3QuVGVzdENhc2UpOgogICAgICAgICAgICAgZGVmIF9faW5pdF9fKHNlbGYpOgogICAgICAgICAg ICAgICAgIHNlbGYudXNlX2RydCA9IFRydWUKIAotICAgICAgICBwb3J0ID0gY2hyb21pdW1fbGlu dXguQ2hyb21pdW1MaW51eFBvcnQoJ3Rlc3QtcG9ydCcsIG9wdGlvbnM9TW9ja09wdGlvbnMoKSkK KyAgICAgICAgcG9ydCA9IGNocm9taXVtX2xpbnV4LkNocm9taXVtTGludXhQb3J0KHBvcnRfbmFt ZT0ndGVzdC1wb3J0JywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIG9wdGlvbnM9TW9ja09wdGlvbnMoKSkKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHBv cnQuX3BhdGhfdG9faW1hZ2VfZGlmZigpLmVuZHN3aXRoKAogICAgICAgICAgICAgJy9vdXQvUmVs ZWFzZS9JbWFnZURpZmYnKSkKLSAgICAgICAgcG9ydCA9IGNocm9taXVtX21hYy5DaHJvbWl1bU1h Y1BvcnQoJ3Rlc3QtcG9ydCcsIG9wdGlvbnM9TW9ja09wdGlvbnMoKSkKKyAgICAgICAgcG9ydCA9 IGNocm9taXVtX21hYy5DaHJvbWl1bU1hY1BvcnQocG9ydF9uYW1lPSd0ZXN0LXBvcnQnLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBvcHRpb25zPU1vY2tPcHRp b25zKCkpCiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShwb3J0Ll9wYXRoX3RvX2ltYWdlX2RpZmYo KS5lbmRzd2l0aCgKICAgICAgICAgICAgICcveGNvZGVidWlsZC9SZWxlYXNlL0ltYWdlRGlmZicp KQogICAgICAgICAjIEZJWE1FOiBGaWd1cmUgb3V0IGhvdyB0aGlzIGlzIGdvaW5nIHRvIHdvcmsg b24gV2luZG93cy4KQEAgLTEwMiw3ICsxMDQsOCBAQCBjbGFzcyBDaHJvbWl1bURyaXZlclRlc3Qo dW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICAgICAgZGVmIF9faW5pdF9fKHNlbGYpOgogICAg ICAgICAgICAgICAgIHNlbGYudXNlX2RydCA9IFRydWUKIAotICAgICAgICBwb3J0ID0gY2hyb21p dW1fbGludXguQ2hyb21pdW1MaW51eFBvcnQoJ3Rlc3QtcG9ydCcsIG9wdGlvbnM9TW9ja09wdGlv bnMoKSkKKyAgICAgICAgcG9ydCA9IGNocm9taXVtX2xpbnV4LkNocm9taXVtTGludXhQb3J0KHBv cnRfbmFtZT0ndGVzdC1wb3J0JywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIG9wdGlvbnM9TW9ja09wdGlvbnMoKSkKIAogICAgICAgICBmYWtlX3Rlc3Qg PSBvcy5wYXRoLmpvaW4ocG9ydC5sYXlvdXRfdGVzdHNfZGlyKCksICJmYXN0L2pzL25vdC1nb29k LmpzIikKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC9jaHJvbWl1bV93aW4ucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQppbmRleCBlOWE4MWU3OGYzZjVlNDMx ZGRhZDUwYmQ5OWFkOWU0NmRmNzE1ZTRmLi4zMzNjZmE0YTg0NGEwMTA0NGQxOTk2ZGM3YWE5Y2Nh M2IyNGFlMGNmIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQpAQCAtNDEsMTIgKzQxLDkg QEAgX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydC5j aHJvbWl1bV93aW4iKQogY2xhc3MgQ2hyb21pdW1XaW5Qb3J0KGNocm9taXVtLkNocm9taXVtUG9y dCk6CiAgICAgIiIiQ2hyb21pdW0gV2luIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNz LiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvcHRpb25zPU5v bmUpOgotICAgICAgICBpZiBwb3J0X25hbWUgaXMgTm9uZToKLSAgICAgICAgICAgIHBvcnRfbmFt ZSA9ICJjaHJvbWl1bS13aW4iICsgc2VsZi52ZXJzaW9uKCkKLSAgICAgICAgaWYgb3B0aW9ucyBh bmQgbm90IGhhc2F0dHIob3B0aW9ucywgImNvbmZpZ3VyYXRpb24iKToKLSAgICAgICAgICAgIG9w dGlvbnMuY29uZmlndXJhdGlvbiA9ICJSZWxlYXNlIgotICAgICAgICBjaHJvbWl1bS5DaHJvbWl1 bVBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lLCBvcHRpb25zKQorICAgIGRlZiBfX2luaXRf XyhzZWxmLCAqKmt3YXJncyk6CisgICAgICAgIGt3YXJncy5zZXRkZWZhdWx0KCdwb3J0X25hbWUn LCAnY2hyb21pdW0td2luJykKKyAgICAgICAgY2hyb21pdW0uQ2hyb21pdW1Qb3J0Ll9faW5pdF9f KHNlbGYsICoqa3dhcmdzKQogCiAgICAgZGVmIHNldHVwX2Vudmlyb25fZm9yX3NlcnZlcihzZWxm KToKICAgICAgICAgZW52ID0gY2hyb21pdW0uQ2hyb21pdW1Qb3J0LnNldHVwX2Vudmlyb25fZm9y X3NlcnZlcihzZWxmKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2RyeXJ1bi5weQppbmRleCA0OTQwZTRjMjJjOTRlZTg0OTdjZmNk MmUzZDc3NDI3ODUwOTM4MWZiLi4yNDdmZTI5Y2E5YTkxMDY2YzVhNjlkNWY3YTU0ZjhhZDc0OTA1 OWMwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L2RyeXJ1bi5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2RyeXJ1bi5weQpAQCAtODAsMTQgKzgwLDE0IEBAIGRlZiBfd3JpdGVfZmls ZShwYXRoLCBjb250ZW50cywgbW9kZT0ndycpOgogY2xhc3MgRHJ5UnVuUG9ydChvYmplY3QpOgog ICAgICIiIkRyeVJ1biBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgUG9ydCBpbnRlcmZhY2UuIiIiCiAK LSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9Tm9uZSk6Cisg ICAgZGVmIF9faW5pdF9fKHNlbGYsICoqa3dhcmdzKToKICAgICAgICAgcGZ4ID0gJ2RyeXJ1bi0n Ci0gICAgICAgIGlmIHBvcnRfbmFtZS5zdGFydHN3aXRoKHBmeCk6Ci0gICAgICAgICAgICBwb3J0 X25hbWUgPSBwb3J0X25hbWVbbGVuKHBmeCk6XQotICAgICAgICBlbHNlOgotICAgICAgICAgICAg cG9ydF9uYW1lID0gTm9uZQotICAgICAgICBzZWxmLl9vcHRpb25zID0gb3B0aW9ucwotICAgICAg ICBzZWxmLl9fZGVsZWdhdGUgPSBmYWN0b3J5LmdldChwb3J0X25hbWUsIG9wdGlvbnMpCisgICAg ICAgIGlmICdwb3J0X25hbWUnIGluIGt3YXJnczoKKyAgICAgICAgICAgIGlmIGt3YXJnc1sncG9y dF9uYW1lJ10uc3RhcnRzd2l0aChwZngpOgorICAgICAgICAgICAgICAgIGt3YXJnc1sncG9ydF9u YW1lJ10gPSBrd2FyZ3NbJ3BvcnRfbmFtZSddW2xlbihwZngpOl0KKyAgICAgICAgICAgIGVsc2U6 CisgICAgICAgICAgICAgICAga3dhcmdzWydwb3J0X25hbWUnXSA9IE5vbmUKKyAgICAgICAgc2Vs Zi5fX2RlbGVnYXRlID0gZmFjdG9yeS5nZXQoKiprd2FyZ3MpCiAKICAgICBkZWYgX19nZXRhdHRy X18oc2VsZiwgbmFtZSk6CiAgICAgICAgIHJldHVybiBnZXRhdHRyKHNlbGYuX19kZWxlZ2F0ZSwg bmFtZSkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvZmFjdG9yeS5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3BvcnQvZmFjdG9yeS5weQppbmRleCA1NzA0ZjY1N2ZjMzAyMWM4MWY5MGExN2Y2MDUy Yjg1MmQ2NWNiMzg0Li5lNjQwNWEzMWU4MTQ3OTBhMTEwNzI4OTg2YzA5OTZiMjM1M2E4ZmZjIDEw MDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L2ZhY3RvcnkucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9mYWN0b3J5LnB5CkBAIC0zNywxMSArMzcsMjEgQEAgQUxMX1BPUlRfTkFNRVMgPSBb J3Rlc3QnLCAnZHJ5cnVuJywgJ21hYycsICd3aW4nLCAnZ3RrJywgJ3F0JywgJ2Nocm9taXVtLW1h YycsCiAgICAgICAgICAgICAgICAgICAnZ29vZ2xlLWNocm9tZS1tYWMnLCAnZ29vZ2xlLWNocm9t ZS1saW51eDMyJywgJ2dvb2dsZS1jaHJvbWUtbGludXg2NCddCiAKIAotZGVmIGdldChwb3J0X25h bWU9Tm9uZSwgb3B0aW9ucz1Ob25lKToKK2RlZiBnZXQocG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9 Tm9uZSwgKiprd2FyZ3MpOgogICAgICIiIlJldHVybnMgYW4gb2JqZWN0IGltcGxlbWVudGluZyB0 aGUgUG9ydCBpbnRlcmZhY2UuIElmCiAgICAgcG9ydF9uYW1lIGlzIE5vbmUsIHRoaXMgcm91dGlu ZSBhdHRlbXB0cyB0byBndWVzcyBhdCB0aGUgbW9zdAogICAgIGFwcHJvcHJpYXRlIHBvcnQgb24g dGhpcyBwbGF0Zm9ybS4iIiIKLSAgICBwb3J0X3RvX3VzZSA9IHBvcnRfbmFtZQorICAgICMgV3Jh cHBlZCBmb3IgYmFja3dhcmRzLWNvbXBhdGliaWxpdHkKKyAgICBpZiBwb3J0X25hbWU6CisgICAg ICAgIGt3YXJnc1sncG9ydF9uYW1lJ10gPSBwb3J0X25hbWUKKyAgICBpZiBvcHRpb25zOgorICAg ICAgICBrd2FyZ3NbJ29wdGlvbnMnXSA9IG9wdGlvbnMKKyAgICByZXR1cm4gX2dldF9rd2FyZ3Mo Kiprd2FyZ3MpCisKKworZGVmIF9nZXRfa3dhcmdzKCoqa3dhcmdzKToKKyAgICBwb3J0X3RvX3Vz ZSA9IGt3YXJncy5nZXQoJ3BvcnRfbmFtZScsIE5vbmUpCisgICAgb3B0aW9ucyA9IGt3YXJncy5n ZXQoJ29wdGlvbnMnLCBOb25lKQogICAgIGlmIHBvcnRfdG9fdXNlIGlzIE5vbmU6CiAgICAgICAg IGlmIHN5cy5wbGF0Zm9ybSA9PSAnd2luMzInIG9yIHN5cy5wbGF0Zm9ybSA9PSAnY3lnd2luJzoK ICAgICAgICAgICAgIGlmIG9wdGlvbnMgYW5kIGhhc2F0dHIob3B0aW9ucywgJ2Nocm9taXVtJykg YW5kIG9wdGlvbnMuY2hyb21pdW06CkBAIC02MiwzOCArNzIsMzcgQEAgZGVmIGdldChwb3J0X25h bWU9Tm9uZSwgb3B0aW9ucz1Ob25lKToKIAogICAgIGlmIHBvcnRfdG9fdXNlID09ICd0ZXN0JzoK ICAgICAgICAgaW1wb3J0IHRlc3QKLSAgICAgICAgcmV0dXJuIHRlc3QuVGVzdFBvcnQocG9ydF9u YW1lLCBvcHRpb25zKQorICAgICAgICByZXR1cm4gdGVzdC5UZXN0UG9ydCgqKmt3YXJncykKICAg ICBlbGlmIHBvcnRfdG9fdXNlLnN0YXJ0c3dpdGgoJ2RyeXJ1bicpOgogICAgICAgICBpbXBvcnQg ZHJ5cnVuCi0gICAgICAgIHJldHVybiBkcnlydW4uRHJ5UnVuUG9ydChwb3J0X25hbWUsIG9wdGlv bnMpCisgICAgICAgIHJldHVybiBkcnlydW4uRHJ5UnVuUG9ydCgqKmt3YXJncykKICAgICBlbGlm IHBvcnRfdG9fdXNlLnN0YXJ0c3dpdGgoJ21hYycpOgogICAgICAgICBpbXBvcnQgbWFjCi0gICAg ICAgIHJldHVybiBtYWMuTWFjUG9ydChwb3J0X25hbWUsIG9wdGlvbnMpCisgICAgICAgIHJldHVy biBtYWMuTWFjUG9ydCgqKmt3YXJncykKICAgICBlbGlmIHBvcnRfdG9fdXNlLnN0YXJ0c3dpdGgo J3dpbicpOgogICAgICAgICBpbXBvcnQgd2luCi0gICAgICAgIHJldHVybiB3aW4uV2luUG9ydChw b3J0X25hbWUsIG9wdGlvbnMpCisgICAgICAgIHJldHVybiB3aW4uV2luUG9ydCgqKmt3YXJncykK ICAgICBlbGlmIHBvcnRfdG9fdXNlLnN0YXJ0c3dpdGgoJ2d0aycpOgogICAgICAgICBpbXBvcnQg Z3RrCi0gICAgICAgIHJldHVybiBndGsuR3RrUG9ydChwb3J0X25hbWUsIG9wdGlvbnMpCisgICAg ICAgIHJldHVybiBndGsuR3RrUG9ydCgqKmt3YXJncykKICAgICBlbGlmIHBvcnRfdG9fdXNlLnN0 YXJ0c3dpdGgoJ3F0Jyk6CiAgICAgICAgIGltcG9ydCBxdAotICAgICAgICByZXR1cm4gcXQuUXRQ b3J0KHBvcnRfbmFtZSwgb3B0aW9ucykKKyAgICAgICAgcmV0dXJuIHF0LlF0UG9ydCgqKmt3YXJn cykKICAgICBlbGlmIHBvcnRfdG9fdXNlLnN0YXJ0c3dpdGgoJ2Nocm9taXVtLW1hYycpOgogICAg ICAgICBpbXBvcnQgY2hyb21pdW1fbWFjCi0gICAgICAgIHJldHVybiBjaHJvbWl1bV9tYWMuQ2hy b21pdW1NYWNQb3J0KHBvcnRfbmFtZSwgb3B0aW9ucykKKyAgICAgICAgcmV0dXJuIGNocm9taXVt X21hYy5DaHJvbWl1bU1hY1BvcnQoKiprd2FyZ3MpCiAgICAgZWxpZiBwb3J0X3RvX3VzZS5zdGFy dHN3aXRoKCdjaHJvbWl1bS1saW51eCcpOgogICAgICAgICBpbXBvcnQgY2hyb21pdW1fbGludXgK LSAgICAgICAgcmV0dXJuIGNocm9taXVtX2xpbnV4LkNocm9taXVtTGludXhQb3J0KHBvcnRfbmFt ZSwgb3B0aW9ucykKKyAgICAgICAgcmV0dXJuIGNocm9taXVtX2xpbnV4LkNocm9taXVtTGludXhQ b3J0KCoqa3dhcmdzKQogICAgIGVsaWYgcG9ydF90b191c2Uuc3RhcnRzd2l0aCgnY2hyb21pdW0t d2luJyk6CiAgICAgICAgIGltcG9ydCBjaHJvbWl1bV93aW4KLSAgICAgICAgcmV0dXJuIGNocm9t aXVtX3dpbi5DaHJvbWl1bVdpblBvcnQocG9ydF9uYW1lLCBvcHRpb25zKQorICAgICAgICByZXR1 cm4gY2hyb21pdW1fd2luLkNocm9taXVtV2luUG9ydCgqKmt3YXJncykKICAgICBlbGlmIHBvcnRf dG9fdXNlLnN0YXJ0c3dpdGgoJ2dvb2dsZS1jaHJvbWUnKToKICAgICAgICAgaW1wb3J0IGdvb2ds ZV9jaHJvbWUKLSAgICAgICAgcmV0dXJuIGdvb2dsZV9jaHJvbWUuR2V0R29vZ2xlQ2hyb21lUG9y dChwb3J0X25hbWUsIG9wdGlvbnMpCisgICAgICAgIHJldHVybiBnb29nbGVfY2hyb21lLkdldEdv b2dsZUNocm9tZVBvcnQoKiprd2FyZ3MpCiAKICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9y KCd1bnN1cHBvcnRlZCBwb3J0OiAlcycgJSBwb3J0X3RvX3VzZSkKIAotCiBkZWYgZ2V0X2FsbChv cHRpb25zPU5vbmUpOgogICAgICIiIlJldHVybnMgYWxsIHRoZSBvYmplY3RzIGltcGxlbWVudGlu ZyB0aGUgUG9ydCBpbnRlcmZhY2UuIiIiCiAgICAgcmV0dXJuIGRpY3QoWyhwb3J0X25hbWUsIGdl dChwb3J0X25hbWUsIG9wdGlvbnM9b3B0aW9ucykpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2dvb2dsZV9jaHJvbWUucHkgYi9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2dvb2dsZV9jaHJvbWUu cHkKaW5kZXggNDZhYjNlZDU3YTY0OTJmOWZmOTc4MDMxMzAwNzlkYmJlY2ZmNzUxYy4uYmZmYzg2 MGUyMmE4NzllNmExNzQ0OTliMjM5OWM2Y2ZiZDQ5YmEyYSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9nb29nbGVfY2hyb21lLnB5Cisr KyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ29vZ2xl X2Nocm9tZS5weQpAQCAtMjUsMTAgKzI1LDEyIEBACiAjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAKIAotZGVmIEdl dEdvb2dsZUNocm9tZVBvcnQocG9ydF9uYW1lLCBvcHRpb25zKToKK2RlZiBHZXRHb29nbGVDaHJv bWVQb3J0KCoqa3dhcmdzKToKICAgICAiIiJTb21lIHRlc3RzIGhhdmUgc2xpZ2h0bHkgZGlmZmVy ZW50IHJlc3VsdHMgd2hlbiBjb21waWxlZCBhcyBHb29nbGUKICAgICBDaHJvbWUgdnMgQ2hyb21p dW0uICBJbiB0aG9zZSBjYXNlcywgd2UgcHJlcGVuZCBhbiBhZGRpdGlvbmFsIGRpcmVjdG9yeSB0 bwogICAgIHRvIHRoZSBiYXNlbGluZSBwYXRocy4iIiIKKyAgICBwb3J0X25hbWUgPSBrd2FyZ3Nb J3BvcnRfbmFtZSddCisgICAgZGVsIGt3YXJnc1sncG9ydF9uYW1lJ10KICAgICBpZiBwb3J0X25h bWUgPT0gJ2dvb2dsZS1jaHJvbWUtbGludXgzMic6CiAgICAgICAgIGltcG9ydCBjaHJvbWl1bV9s aW51eAogCkBAIC0zOSw3ICs0MSw3IEBAIGRlZiBHZXRHb29nbGVDaHJvbWVQb3J0KHBvcnRfbmFt ZSwgb3B0aW9ucyk6CiAgICAgICAgICAgICAgICAgcGF0aHMuaW5zZXJ0KDAsIHNlbGYuX3dlYmtp dF9iYXNlbGluZV9wYXRoKAogICAgICAgICAgICAgICAgICAgICAnZ29vZ2xlLWNocm9tZS1saW51 eDMyJykpCiAgICAgICAgICAgICAgICAgcmV0dXJuIHBhdGhzCi0gICAgICAgIHJldHVybiBHb29n bGVDaHJvbWVMaW51eDMyUG9ydChOb25lLCBvcHRpb25zKQorICAgICAgICByZXR1cm4gR29vZ2xl Q2hyb21lTGludXgzMlBvcnQoKiprd2FyZ3MpCiAgICAgZWxpZiBwb3J0X25hbWUgPT0gJ2dvb2ds ZS1jaHJvbWUtbGludXg2NCc6CiAgICAgICAgIGltcG9ydCBjaHJvbWl1bV9saW51eAogCkBAIC01 MCw3ICs1Miw3IEBAIGRlZiBHZXRHb29nbGVDaHJvbWVQb3J0KHBvcnRfbmFtZSwgb3B0aW9ucyk6 CiAgICAgICAgICAgICAgICAgcGF0aHMuaW5zZXJ0KDAsIHNlbGYuX3dlYmtpdF9iYXNlbGluZV9w YXRoKAogICAgICAgICAgICAgICAgICAgICAnZ29vZ2xlLWNocm9tZS1saW51eDY0JykpCiAgICAg ICAgICAgICAgICAgcmV0dXJuIHBhdGhzCi0gICAgICAgIHJldHVybiBHb29nbGVDaHJvbWVMaW51 eDY0UG9ydChOb25lLCBvcHRpb25zKQorICAgICAgICByZXR1cm4gR29vZ2xlQ2hyb21lTGludXg2 NFBvcnQoKiprd2FyZ3MpCiAgICAgZWxpZiBwb3J0X25hbWUuc3RhcnRzd2l0aCgnZ29vZ2xlLWNo cm9tZS1tYWMnKToKICAgICAgICAgaW1wb3J0IGNocm9taXVtX21hYwogCkBAIC02MSw3ICs2Myw3 IEBAIGRlZiBHZXRHb29nbGVDaHJvbWVQb3J0KHBvcnRfbmFtZSwgb3B0aW9ucyk6CiAgICAgICAg ICAgICAgICAgcGF0aHMuaW5zZXJ0KDAsIHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKAogICAg ICAgICAgICAgICAgICAgICAnZ29vZ2xlLWNocm9tZS1tYWMnKSkKICAgICAgICAgICAgICAgICBy ZXR1cm4gcGF0aHMKLSAgICAgICAgcmV0dXJuIEdvb2dsZUNocm9tZU1hY1BvcnQoTm9uZSwgb3B0 aW9ucykKKyAgICAgICAgcmV0dXJuIEdvb2dsZUNocm9tZU1hY1BvcnQoKiprd2FyZ3MpCiAgICAg ZWxpZiBwb3J0X25hbWUuc3RhcnRzd2l0aCgnZ29vZ2xlLWNocm9tZS13aW4nKToKICAgICAgICAg aW1wb3J0IGNocm9taXVtX3dpbgogCkBAIC03Miw1ICs3NCw1IEBAIGRlZiBHZXRHb29nbGVDaHJv bWVQb3J0KHBvcnRfbmFtZSwgb3B0aW9ucyk6CiAgICAgICAgICAgICAgICAgcGF0aHMuaW5zZXJ0 KDAsIHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKAogICAgICAgICAgICAgICAgICAgICAnZ29v Z2xlLWNocm9tZS13aW4nKSkKICAgICAgICAgICAgICAgICByZXR1cm4gcGF0aHMKLSAgICAgICAg cmV0dXJuIEdvb2dsZUNocm9tZVdpblBvcnQoTm9uZSwgb3B0aW9ucykKKyAgICAgICAgcmV0dXJu IEdvb2dsZUNocm9tZVdpblBvcnQoKiprd2FyZ3MpCiAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRF cnJvcigndW5zdXBwb3J0ZWQgcG9ydDogJXMnICUgcG9ydF9uYW1lKQpkaWZmIC0tZ2l0IGEvV2Vi S2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9nb29nbGVfY2hyb21l X3VuaXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9nb29nbGVfY2hyb21lX3VuaXR0ZXN0LnB5CmluZGV4IGEyZDcwNTY3YTAyZDUwYzI1YzZh ZGQ4MjI1ZDFjOGM4NDYzM2MxMWEuLjg1ZTkzMzg3MjJhZjY4N2RlN2ExZWMzM2I2YjIyNGRjNmY5 ZWJlNTQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvZ29vZ2xlX2Nocm9tZV91bml0dGVzdC5weQorKysgYi9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2dvb2dsZV9jaHJvbWVfdW5pdHRlc3QucHkK QEAgLTQxLDYgKzQxLDcgQEAgY2xhc3MgR2V0R29vZ2xlQ2hyb21lUG9ydFRlc3QodW5pdHRlc3Qu VGVzdENhc2UpOgogICAgICAgICBzZWxmLl92ZXJpZnlfYmFzZWxpbmVfcGF0aCgnZ29vZ2xlLWNo cm9tZS13aW4nLCAnZ29vZ2xlLWNocm9tZS13aW4tdmlzdGEnKQogCiAgICAgZGVmIF92ZXJpZnlf YmFzZWxpbmVfcGF0aChzZWxmLCBleHBlY3RlZF9wYXRoLCBwb3J0X25hbWUpOgotICAgICAgICBw b3J0ID0gZ29vZ2xlX2Nocm9tZS5HZXRHb29nbGVDaHJvbWVQb3J0KHBvcnRfbmFtZSwgTm9uZSkK KyAgICAgICAgcG9ydCA9IGdvb2dsZV9jaHJvbWUuR2V0R29vZ2xlQ2hyb21lUG9ydChwb3J0X25h bWU9cG9ydF9uYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIG9wdGlvbnM9Tm9uZSkKICAgICAgICAgcGF0aCA9IHBvcnQuYmFzZWxpbmVfc2VhcmNo X3BhdGgoKVswXQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX3BhdGgsIG9zLnBh dGguc3BsaXQocGF0aClbMV0pCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2d0ay5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ3RrLnB5CmluZGV4IDU5ZGMxZDk1ZDU2YWU3NDg1YTZlN2Ey NDg4MWExNWU3NmRkYTc4YzEuLmM2MDkwOWViOTRlZDYxMDc1MzJlZDNlZjkwY2Q2M2YwYmFkNzEz NTQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvZ3RrLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvZ3RrLnB5CkBAIC0zOSwxMCArMzksOSBAQCBfbG9nID0gbG9nZ2luZy5nZXRMb2dn ZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0Lmd0ayIpCiBjbGFzcyBHdGtQb3J0KFdlYktp dFBvcnQpOgogICAgICIiIldlYktpdCBHdGsgaW1wbGVtZW50YXRpb24gb2YgdGhlIFBvcnQgY2xh c3MuIiIiCiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9 Tm9uZSk6Ci0gICAgICAgIGlmIHBvcnRfbmFtZSBpcyBOb25lOgotICAgICAgICAgICAgcG9ydF9u YW1lID0gJ2d0aycKLSAgICAgICAgV2ViS2l0UG9ydC5fX2luaXRfXyhzZWxmLCBwb3J0X25hbWUs IG9wdGlvbnMpCisgICAgZGVmIF9faW5pdF9fKHNlbGYsICoqa3dhcmdzKToKKyAgICAgICAga3dh cmdzLnNldGRlZmF1bHQoJ3BvcnRfbmFtZScsICdndGsnKQorICAgICAgICBXZWJLaXRQb3J0Ll9f aW5pdF9fKHNlbGYsICoqa3dhcmdzKQogCiAgICAgZGVmIF90ZXN0c19mb3Jfb3RoZXJfcGxhdGZv cm1zKHNlbGYpOgogICAgICAgICAjIEZJWE1FOiBUaGlzIGxpc3QgY291bGQgYmUgZHluYW1pYyBi YXNlZCBvbiBwbGF0Zm9ybSBuYW1lIGFuZApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHkgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hYy5weQppbmRleCA0MTNiNWYyYzM1ZDg5YmIx ZjdjN2Y1NzljMDJmNzI1NzRlZTYwOThmLi42OTZlMzM5OGVhNGIyOGFjNzYyMjU5MDdkYzM2MmZm YzNmYjg2ZjllIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L21hYy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L21hYy5weQpAQCAtNDMsMTAgKzQzLDkgQEAgX2xvZyA9IGxvZ2dpbmcu Z2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydC5tYWMiKQogY2xhc3MgTWFjUG9y dChXZWJLaXRQb3J0KToKICAgICAiIiJXZWJLaXQgTWFjIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQ b3J0IGNsYXNzLiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBv cHRpb25zPU5vbmUpOgotICAgICAgICBpZiBwb3J0X25hbWUgaXMgTm9uZToKLSAgICAgICAgICAg IHBvcnRfbmFtZSA9ICdtYWMnICsgc2VsZi52ZXJzaW9uKCkKLSAgICAgICAgV2ViS2l0UG9ydC5f X2luaXRfXyhzZWxmLCBwb3J0X25hbWUsIG9wdGlvbnMpCisgICAgZGVmIF9faW5pdF9fKHNlbGYs ICoqa3dhcmdzKToKKyAgICAgICAga3dhcmdzLnNldGRlZmF1bHQoJ3BvcnRfbmFtZScsICdtYWMn ICsgc2VsZi52ZXJzaW9uKCkpCisgICAgICAgIFdlYktpdFBvcnQuX19pbml0X18oc2VsZiwgKipr d2FyZ3MpCiAKICAgICBkZWYgZGVmYXVsdF9jaGlsZF9wcm9jZXNzZXMoc2VsZik6CiAgICAgICAg ICMgRklYTUU6IG5ldy1ydW4td2Via2l0LXRlc3RzIGlzIHVuc3RhYmxlIG9uIE1hYyBydW5uaW5n IG1vcmUgdGhhbgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvcG9ydC9xdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3BvcnQvcXQucHkKaW5kZXggMTU4YzYzMzc4MGYxYzQxYzM3YmJmZWExYmFlYzZlNmZk YzlhZGVjOC4uNGM4ZmEwYTAwYjY3ZGVmNjVkMDhkYWNlNjQwNGI5YTMzYWY2NmQwYiAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9xdC5w eQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3F0 LnB5CkBAIC00MiwxMCArNDIsOSBAQCBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5 LmxheW91dF90ZXN0cy5wb3J0LnF0IikKIGNsYXNzIFF0UG9ydChXZWJLaXRQb3J0KToKICAgICAi IiJRdFdlYktpdCBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgUG9ydCBjbGFzcy4iIiIKIAotICAgIGRl ZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgb3B0aW9ucz1Ob25lKToKLSAgICAgICAg aWYgcG9ydF9uYW1lIGlzIE5vbmU6Ci0gICAgICAgICAgICBwb3J0X25hbWUgPSAncXQnCi0gICAg ICAgIFdlYktpdFBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lLCBvcHRpb25zKQorICAgIGRl ZiBfX2luaXRfXyhzZWxmLCAqKmt3YXJncyk6CisgICAgICAgIGt3YXJncy5zZXRkZWZhdWx0KCdw b3J0X25hbWUnLCAncXQnKQorICAgICAgICBXZWJLaXRQb3J0Ll9faW5pdF9fKHNlbGYsICoqa3dh cmdzKQogCiAgICAgZGVmIF90ZXN0c19mb3Jfb3RoZXJfcGxhdGZvcm1zKHNlbGYpOgogICAgICAg ICAjIEZJWE1FOiBUaGlzIGxpc3QgY291bGQgYmUgZHluYW1pYyBiYXNlZCBvbiBwbGF0Zm9ybSBu YW1lIGFuZApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC90ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC90ZXN0LnB5CmluZGV4IDJjY2RkYjA3Mjk1MjMyOWZkM2ZlOWNhOTIyMjFlMTAw MDIzMDVmYzQuLjliMmUwMjJiZWE2YmI3NjRkZDI0OTU0YWJlMjEwYTg5MThmODgyZTEgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVz dC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L3Rlc3QucHkKQEAgLTQwLDkgKzQwLDYgQEAgaW1wb3J0IGJhc2UKIGNsYXNzIFRlc3RQb3J0KGJh c2UuUG9ydCk6CiAgICAgIiIiVGVzdCBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgUG9ydCBpbnRlcmZh Y2UuIiIiCiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9 Tm9uZSk6Ci0gICAgICAgIGJhc2UuUG9ydC5fX2luaXRfXyhzZWxmLCBwb3J0X25hbWUsIG9wdGlv bnMpCi0KICAgICBkZWYgYmFzZWxpbmVfcGF0aChzZWxmKToKICAgICAgICAgcmV0dXJuIG9zLnBh dGguam9pbihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwgJ3BsYXRmb3JtJywKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBzZWxmLm5hbWUoKSArIHNlbGYudmVyc2lvbigpKQpAQCAtOTMsOSAr OTAsNiBAQCBjbGFzcyBUZXN0UG9ydChiYXNlLlBvcnQpOgogICAgIGRlZiBzZXR1cF90ZXN0X3J1 bihzZWxmKToKICAgICAgICAgcGFzcwogCi0gICAgZGVmIHNob3dfcmVzdWx0c19odG1sX2ZpbGUo c2VsZiwgZmlsZW5hbWUpOgotICAgICAgICBwYXNzCi0KICAgICBkZWYgY3JlYXRlX2RyaXZlcihz ZWxmLCBpbWFnZV9wYXRoLCBvcHRpb25zKToKICAgICAgICAgcmV0dXJuIFRlc3REcml2ZXIoc2Vs ZiwgaW1hZ2VfcGF0aCwgb3B0aW9ucywgZXhlY3V0aXZlPU5vbmUpCiAKZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5IGIv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkK aW5kZXggODhjOWJkZjk4MmQ1MmQzM2IyMTA5YTgwZmUyY2M3ZTg4YjE1MTE5Yi4uMmQ4ZTU1NmQ0 ZWQ0ZTFjNTdiNzQ2NWNiZTI1YmQ2NGM1MzhjMmIxNyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKKysrIGIvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKQEAgLTU4 LDE2ICs1OCwxNiBAQCBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90 ZXN0cy5wb3J0LndlYmtpdCIpCiBjbGFzcyBXZWJLaXRQb3J0KGJhc2UuUG9ydCk6CiAgICAgIiIi V2ViS2l0IGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNzLiIiIgogCi0gICAgZGVmIF9f aW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvcHRpb25zPU5vbmUsICoqa3dhcmdzKToKLSAg ICAgICAgYmFzZS5Qb3J0Ll9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZSwgb3B0aW9ucywgKiprd2Fy Z3MpCisgICAgZGVmIF9faW5pdF9fKHNlbGYsICoqa3dhcmdzKToKKyAgICAgICAgYmFzZS5Qb3J0 Ll9faW5pdF9fKHNlbGYsICoqa3dhcmdzKQogICAgICAgICBzZWxmLl9jYWNoZWRfYnVpbGRfcm9v dCA9IE5vbmUKICAgICAgICAgc2VsZi5fY2FjaGVkX2FwYWNoZV9wYXRoID0gTm9uZQogCiAgICAg ICAgICMgRklYTUU6IGRpc2FibGUgcGl4ZWwgdGVzdHMgdW50aWwgdGhleSBhcmUgcnVuIGJ5IGRl ZmF1bHQgb24gdGhlCiAgICAgICAgICMgYnVpbGQgbWFjaGluZXMuCi0gICAgICAgIGlmIG9wdGlv bnMgYW5kIChub3QgaGFzYXR0cihvcHRpb25zLCAicGl4ZWxfdGVzdHMiKSBvcgotICAgICAgICAg ICBvcHRpb25zLnBpeGVsX3Rlc3RzIGlzIE5vbmUpOgotICAgICAgICAgICAgb3B0aW9ucy5waXhl bF90ZXN0cyA9IEZhbHNlCisgICAgICAgIGlmIHNlbGYuX29wdGlvbnMgYW5kIChub3QgaGFzYXR0 cihzZWxmLl9vcHRpb25zLCAicGl4ZWxfdGVzdHMiKSBvcgorICAgICAgICAgICBzZWxmLl9vcHRp b25zLnBpeGVsX3Rlc3RzIGlzIE5vbmUpOgorICAgICAgICAgICAgc2VsZi5fb3B0aW9ucy5waXhl bF90ZXN0cyA9IEZhbHNlCiAKICAgICBkZWYgYmFzZWxpbmVfcGF0aChzZWxmKToKICAgICAgICAg cmV0dXJuIHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX25hbWUpCkBAIC0xOTMsMTEg KzE5Myw2IEBAIGNsYXNzIFdlYktpdFBvcnQoYmFzZS5Qb3J0KToKICAgICAgICAgIyBUaGlzIHBv cnQgZG9lc24ndCByZXF1aXJlIGFueSBzcGVjaWZpYyBjb25maWd1cmF0aW9uLgogICAgICAgICBw YXNzCiAKLSAgICBkZWYgc2hvd19yZXN1bHRzX2h0bWxfZmlsZShzZWxmLCByZXN1bHRzX2ZpbGVu YW1lKToKLSAgICAgICAgdXJpID0gc2VsZi5maWxlbmFtZV90b191cmkocmVzdWx0c19maWxlbmFt ZSkKLSAgICAgICAgIyBGSVhNRTogV2Ugc2hvdWxkIG9wZW4gcmVzdWx0cyBpbiB0aGUgdmVyc2lv biBvZiBXZWJLaXQgd2UgYnVpbHQuCi0gICAgICAgIHdlYmJyb3dzZXIub3Blbih1cmksIG5ldz0x KQotCiAgICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwgaW1hZ2VfcGF0aCwgb3B0aW9ucyk6CiAg ICAgICAgIHJldHVybiBXZWJLaXREcml2ZXIoc2VsZiwgaW1hZ2VfcGF0aCwgb3B0aW9ucywKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBleGVjdXRpdmU9c2VsZi5fZXhlY3V0aXZlKQpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93 aW4ucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dp bi5weQppbmRleCBlMDVhNjlkODFhYjc2NzA1ZWUzYWYzODNlYTUyNWJkNTE5MjQyOWI3Li45ZTMw MTU1MTAwMDc3NjA4ZGM3MWYyNDU1YTBmNGZlMjYyMTM1ZDY1IDEwMDY0NAotLS0gYS9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dpbi5weQorKysgYi9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dpbi5weQpAQCAtMzks MTAgKzM5LDkgQEAgX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVz dHMucG9ydC53aW4iKQogY2xhc3MgV2luUG9ydChXZWJLaXRQb3J0KToKICAgICAiIiJXZWJLaXQg V2luIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNzLiIiIgogCi0gICAgZGVmIF9faW5p dF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvcHRpb25zPU5vbmUpOgotICAgICAgICBpZiBwb3J0 X25hbWUgaXMgTm9uZToKLSAgICAgICAgICAgIHBvcnRfbmFtZSA9ICd3aW4nCi0gICAgICAgIFdl YktpdFBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lLCBvcHRpb25zKQorICAgIGRlZiBfX2lu aXRfXyhzZWxmLCAqKmt3YXJncyk6CisgICAgICAgIGt3YXJncy5zZXRkZWZhdWx0KCdwb3J0X25h bWUnLCAnd2luJykKKyAgICAgICAgV2ViS2l0UG9ydC5fX2luaXRfXyhzZWxmLCAqKmt3YXJncykK IAogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToKICAgICAgICAgIyBCYXNlZCBv biBjb2RlIGZyb20gb2xkLXJ1bi13ZWJraXQtdGVzdHMgZXhwZWN0ZWREaXJlY3RvcnlGb3JUZXN0 KCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3JlYmFzZWxpbmVfY2hyb21pdW1fd2Via2l0X3Rlc3RzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNlbGluZV9jaHJvbWl1bV93ZWJraXRfdGVzdHMu cHkKaW5kZXggM2E5ZjkyM2EwNTYyOTc1MmE0OWI4M2EyNWI5ODExMzE2NTA1N2I4Ny4uNDk5MTNh OWI5ZmJlNGE5Y2Y2ODcyZGYzZmMzN2NhMzcxNjA0NDliZCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNlbGluZV9jaHJvbWl1bV93ZWJr aXRfdGVzdHMucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcmViYXNlbGluZV9jaHJvbWl1bV93ZWJraXRfdGVzdHMucHkKQEAgLTU1LDkgKzU1LDkgQEAg aW1wb3J0IHN5cwogaW1wb3J0IHRlbXBmaWxlCiBpbXBvcnQgdGltZQogaW1wb3J0IHVybGxpYgot aW1wb3J0IHdlYmJyb3dzZXIKIGltcG9ydCB6aXBmaWxlCiAKK2Zyb20gd2Via2l0cHkuY29tbW9u LnN5c3RlbSBpbXBvcnQgdXNlcgogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmV4ZWN1dGl2 ZSBpbXBvcnQgcnVuX2NvbW1hbmQsIFNjcmlwdEVycm9yCiBpbXBvcnQgd2Via2l0cHkuY29tbW9u LmNoZWNrb3V0LnNjbSBhcyBzY20KIApAQCAtNzM3LDEwICs3MzcsNyBAQCBjbGFzcyBIdG1sR2Vu ZXJhdG9yKG9iamVjdCk6CiAgICAgICAgICIiIkxhdW5jaCB0aGUgcmViYXNlbGluaW5nIGh0bWwg aW4gYnJ3b3Nlci4iIiIKIAogICAgICAgICBfbG9nLmluZm8oJ0xhdW5jaGluZyBodG1sOiAiJXMi Jywgc2VsZi5faHRtbF9maWxlKQotCi0gICAgICAgIGh0bWxfdXJpID0gc2VsZi5fdGFyZ2V0X3Bv cnQuZmlsZW5hbWVfdG9fdXJpKHNlbGYuX2h0bWxfZmlsZSkKLSAgICAgICAgd2ViYnJvd3Nlci5v cGVuKGh0bWxfdXJpLCAxKQotCisgICAgICAgIHVzZXIub3Blbl91cmwoc2VsZi5faHRtbF9maWxl KQogICAgICAgICBfbG9nLmluZm8oJ0h0bWwgbGF1bmNoZWQuJykKIAogICAgIGRlZiBfZ2VuZXJh dGVfYmFzZWxpbmVfbGlua3Moc2VsZiwgdGVzdF9iYXNlbmFtZSwgc3VmZml4LCBwbGF0Zm9ybSk6 CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9y dW5fd2Via2l0X3Rlc3RzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQppbmRleCAxNGQ0ZjBlOTlmYTYxOWQ4YWY0NmI1OTFi NTdhMGY5NDM0MWJhNGNlLi44YjBhYjdhYTA0Y2JkZmNiZTgyZmI1YzAxZTYzZmFhNDMzMTVhZDQ2 IDEwMDc1NQotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9y dW5fd2Via2l0X3Rlc3RzLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKQEAgLTc0LDYgKzc0LDcgQEAgZnJvbSB0ZXN0 X3R5cGVzIGltcG9ydCBpbWFnZV9kaWZmCiBmcm9tIHRlc3RfdHlwZXMgaW1wb3J0IHRleHRfZGlm ZgogZnJvbSB0ZXN0X3R5cGVzIGltcG9ydCB0ZXN0X3R5cGVfYmFzZQogCitmcm9tIHdlYmtpdHB5 LmNvbW1vbi5zeXN0ZW0gaW1wb3J0IHVzZXIKIGZyb20gd2Via2l0cHkudGhpcmRwYXJ0eSBpbXBv cnQgc2ltcGxlanNvbgogCiBpbXBvcnQgcG9ydApAQCAtMTMzMiw3ICsxMzMzLDcgQEAgY2xhc3Mg VGVzdFJ1bm5lcjoKICAgICAgICAgIiIiU2hvd3MgdGhlIHJlc3VsdHMuaHRtbCBwYWdlLiIiIgog ICAgICAgICByZXN1bHRzX2ZpbGVuYW1lID0gb3MucGF0aC5qb2luKHNlbGYuX29wdGlvbnMucmVz dWx0c19kaXJlY3RvcnksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg InJlc3VsdHMuaHRtbCIpCi0gICAgICAgIHNlbGYuX3BvcnQuc2hvd19yZXN1bHRzX2h0bWxfZmls ZShyZXN1bHRzX2ZpbGVuYW1lKQorICAgICAgICBzZWxmLl9wb3J0LnNob3dfaHRtbF9yZXN1bHRz X2ZpbGUocmVzdWx0c19maWxlbmFtZSkKIAogCiBkZWYgcmVhZF90ZXN0X2ZpbGVzKGZpbGVzKToK ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1 bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0LnB5CmluZGV4IGFhOTY5NjI3 MmQ5YTg3OGU2YTliOTZhNDQyYTlkNWEzYmZhOTk5NDQuLjQyNDJiMDk4ZDA1MjM2OGQxMzhlZWQx MmUyYjZjNGVjNGIxYTFlY2YgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QucHkKKysrIGIvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0c191bml0 dGVzdC5weQpAQCAtNDIsNiArNDIsNyBAQCBpbXBvcnQgdW5pdHRlc3QKIAogZnJvbSB3ZWJraXRw eS5jb21tb24gaW1wb3J0IGFycmF5X3N0cmVhbQogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVt IGltcG9ydCBvdXRwdXRjYXB0dXJlCitmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0gaW1wb3J0 IHVzZXIKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzIGltcG9ydCBwb3J0CiBmcm9tIHdlYmtp dHB5LmxheW91dF90ZXN0cyBpbXBvcnQgcnVuX3dlYmtpdF90ZXN0cwogZnJvbSB3ZWJraXRweS5s YXlvdXRfdGVzdHMubGF5b3V0X3BhY2thZ2UgaW1wb3J0IGR1bXBfcmVuZGVyX3RyZWVfdGhyZWFk CkBAIC00OSw2ICs1MCwxNCBAQCBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5sYXlvdXRfcGFj a2FnZSBpbXBvcnQgZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQKIGZyb20gd2Via2l0cHkudGhpcmRw YXJ0eS5tb2NrIGltcG9ydCBNb2NrCiAKIAorY2xhc3MgTW9ja1VzZXIoKToKKyAgICBkZWYgX19p bml0X18oc2VsZik6CisgICAgICAgIHNlbGYudXJsID0gTm9uZQorCisgICAgZGVmIG9wZW5fdXJs KHNlbGYsIHVybCk6CisgICAgICAgIHNlbGYudXJsID0gdXJsCisKKwogZGVmIHBhc3NpbmdfcnVu KGFyZ3M9W10sIHBvcnRfb2JqPU5vbmUsIHJlY29yZF9yZXN1bHRzPUZhbHNlLAogICAgICAgICAg ICAgICAgIHRlc3RzX2luY2x1ZGVkPUZhbHNlKToKICAgICBuZXdfYXJncyA9IFsnLS1wcmludCcs ICdub3RoaW5nJ10KQEAgLTY1LDcgKzc0LDggQEAgZGVmIHBhc3NpbmdfcnVuKGFyZ3M9W10sIHBv cnRfb2JqPU5vbmUsIHJlY29yZF9yZXN1bHRzPUZhbHNlLAogICAgICAgICAgICAgICAgICAgICAg ICAgICdmYWlsdXJlcy9leHBlY3RlZC8qJ10pCiAgICAgb3B0aW9ucywgcGFyc2VkX2FyZ3MgPSBy dW5fd2Via2l0X3Rlc3RzLnBhcnNlX2FyZ3MobmV3X2FyZ3MpCiAgICAgaWYgcG9ydF9vYmogaXMg Tm9uZToKLSAgICAgICAgcG9ydF9vYmogPSBwb3J0LmdldChvcHRpb25zLnBsYXRmb3JtLCBvcHRp b25zKQorICAgICAgICBwb3J0X29iaiA9IHBvcnQuZ2V0KHBvcnRfbmFtZT1vcHRpb25zLnBsYXRm b3JtLCBvcHRpb25zPW9wdGlvbnMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgdXNlcj1N b2NrVXNlcigpKQogICAgIHJlcyA9IHJ1bl93ZWJraXRfdGVzdHMucnVuKHBvcnRfb2JqLCBvcHRp b25zLCBwYXJzZWRfYXJncykKICAgICByZXR1cm4gcmVzID09IDAKIApAQCAtODEsMTMgKzkxLDE0 IEBAIGRlZiBsb2dnaW5nX3J1bihhcmdzPVtdLCB0ZXN0c19pbmNsdWRlZD1GYWxzZSk6CiAgICAg ICAgICAgICAgICAgICAgICAgICAgJ3dlYnNvY2tldC90ZXN0cycsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgJ2ZhaWx1cmVzL2V4cGVjdGVkLyonXSkKICAgICBvcHRpb25zLCBwYXJzZWRfYXJn cyA9IHJ1bl93ZWJraXRfdGVzdHMucGFyc2VfYXJncyhuZXdfYXJncykKLSAgICBwb3J0X29iaiA9 IHBvcnQuZ2V0KG9wdGlvbnMucGxhdGZvcm0sIG9wdGlvbnMpCisgICAgdXNlciA9IE1vY2tVc2Vy KCkKKyAgICBwb3J0X29iaiA9IHBvcnQuZ2V0KHBvcnRfbmFtZT1vcHRpb25zLnBsYXRmb3JtLCBv cHRpb25zPW9wdGlvbnMsIHVzZXI9dXNlcikKICAgICBidWlsZGJvdF9vdXRwdXQgPSBhcnJheV9z dHJlYW0uQXJyYXlTdHJlYW0oKQogICAgIHJlZ3VsYXJfb3V0cHV0ID0gYXJyYXlfc3RyZWFtLkFy cmF5U3RyZWFtKCkKICAgICByZXMgPSBydW5fd2Via2l0X3Rlc3RzLnJ1bihwb3J0X29iaiwgb3B0 aW9ucywgcGFyc2VkX2FyZ3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnVpbGRi b3Rfb3V0cHV0PWJ1aWxkYm90X291dHB1dCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICByZWd1bGFyX291dHB1dD1yZWd1bGFyX291dHB1dCkKLSAgICByZXR1cm4gKHJlcywgYnVpbGRi b3Rfb3V0cHV0LCByZWd1bGFyX291dHB1dCkKKyAgICByZXR1cm4gKHJlcywgYnVpbGRib3Rfb3V0 cHV0LCByZWd1bGFyX291dHB1dCwgdXNlcikKIAogCiBjbGFzcyBNYWluVGVzdCh1bml0dGVzdC5U ZXN0Q2FzZSk6CkBAIC05OSwxMyArMTEwLDEzIEBAIGNsYXNzIE1haW5UZXN0KHVuaXR0ZXN0LlRl c3RDYXNlKToKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHBhc3NpbmdfcnVuKFsnLS1iYXRjaC1z aXplJywgJzInXSkpCiAKICAgICBkZWYgdGVzdF9jaGlsZF9wcm9jZXNzXzEoc2VsZik6Ci0gICAg ICAgIChyZXMsIGJ1aWxkYm90X291dHB1dCwgcmVndWxhcl9vdXRwdXQpID0gbG9nZ2luZ19ydW4o CisgICAgICAgIChyZXMsIGJ1aWxkYm90X291dHB1dCwgcmVndWxhcl9vdXRwdXQsIHVzZXIpID0g bG9nZ2luZ19ydW4oCiAgICAgICAgICAgICAgWyctLXByaW50JywgJ2NvbmZpZycsICctLWNoaWxk LXByb2Nlc3NlcycsICcxJ10pCiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZSgnUnVubmluZyBvbmUg RHVtcFJlbmRlclRyZWVcbicKICAgICAgICAgICAgICAgICAgICAgICAgIGluIHJlZ3VsYXJfb3V0 cHV0LmdldCgpKQogCiAgICAgZGVmIHRlc3RfY2hpbGRfcHJvY2Vzc2VzXzIoc2VsZik6Ci0gICAg ICAgIChyZXMsIGJ1aWxkYm90X291dHB1dCwgcmVndWxhcl9vdXRwdXQpID0gbG9nZ2luZ19ydW4o CisgICAgICAgIChyZXMsIGJ1aWxkYm90X291dHB1dCwgcmVndWxhcl9vdXRwdXQsIHVzZXIpID0g bG9nZ2luZ19ydW4oCiAgICAgICAgICAgICAgWyctLXByaW50JywgJ2NvbmZpZycsICctLWNoaWxk LXByb2Nlc3NlcycsICcyJ10pCiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZSgnUnVubmluZyAyIER1 bXBSZW5kZXJUcmVlcyBpbiBwYXJhbGxlbFxuJwogICAgICAgICAgICAgICAgICAgICAgICAgaW4g cmVndWxhcl9vdXRwdXQuZ2V0KCkpCkBAIC0xMTksMTUgKzEzMCwxNSBAQCBjbGFzcyBNYWluVGVz dCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShwYXNzaW5nX3J1 bihbJy0tZnVsbC1yZXN1bHRzLWh0bWwnXSkpCiAKICAgICBkZWYgdGVzdF9oZWxwX3ByaW50aW5n KHNlbGYpOgotICAgICAgICByZXMsIG91dCwgZXJyID0gbG9nZ2luZ19ydW4oWyctLWhlbHAtcHJp bnRpbmcnXSkKKyAgICAgICAgcmVzLCBvdXQsIGVyciwgdXNlciA9IGxvZ2dpbmdfcnVuKFsnLS1o ZWxwLXByaW50aW5nJ10pCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocmVzLCAwKQogICAgICAg ICBzZWxmLmFzc2VydFRydWUob3V0LmVtcHR5KCkpCiAgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2Uo ZXJyLmVtcHR5KCkpCiAKICAgICBkZWYgdGVzdF9odW5nX3RocmVhZChzZWxmKToKLSAgICAgICAg cmVzLCBvdXQsIGVyciA9IGxvZ2dpbmdfcnVuKFsnLS1ydW4tc2luZ2x5JywgJy0tdGltZS1vdXQt bXM9NTAnLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdmYWlsdXJlcy9l eHBlY3RlZC9oYW5nLmh0bWwnXSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHRlc3RzX2luY2x1ZGVkPVRydWUpCisgICAgICAgIHJlcywgb3V0LCBlcnIsIHVzZXIgPSBsb2dn aW5nX3J1bihbJy0tcnVuLXNpbmdseScsICctLXRpbWUtb3V0LW1zPTUwJywKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdmYWlsdXJlcy9leHBlY3RlZC9oYW5nLmh0 bWwnXSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRlc3RzX2lu Y2x1ZGVkPVRydWUpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocmVzLCAwKQogICAgICAgICBz ZWxmLmFzc2VydEZhbHNlKG91dC5lbXB0eSgpKQogICAgICAgICBzZWxmLmFzc2VydEZhbHNlKGVy ci5lbXB0eSgpKQpAQCAtMTQwLDI2ICsxNTEsMjcgQEAgY2xhc3MgTWFpblRlc3QodW5pdHRlc3Qu VGVzdENhc2UpOgogCiAgICAgZGVmIHRlc3RfbGFzdF9yZXN1bHRzKHNlbGYpOgogICAgICAgICBw YXNzaW5nX3J1bihbJy0tY2xvYmJlci1vbGQtcmVzdWx0cyddLCByZWNvcmRfcmVzdWx0cz1UcnVl KQotICAgICAgICAocmVzLCBidWlsZGJvdF9vdXRwdXQsIHJlZ3VsYXJfb3V0cHV0KSA9IGxvZ2dp bmdfcnVuKAorICAgICAgICAocmVzLCBidWlsZGJvdF9vdXRwdXQsIHJlZ3VsYXJfb3V0cHV0LCB1 c2VyKSA9IGxvZ2dpbmdfcnVuKAogICAgICAgICAgICAgWyctLXByaW50LWxhc3QtZmFpbHVyZXMn XSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChyZWd1bGFyX291dHB1dC5nZXQoKSwgWydcblxu J10pCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoYnVpbGRib3Rfb3V0cHV0LmdldCgpLCBbXSkK IAogICAgIGRlZiB0ZXN0X2xpbnRfdGVzdF9maWxlcyhzZWxmKToKICAgICAgICAgIyBGSVhNRTog IGFkZCBlcnJvcnM/Ci0gICAgICAgIHJlcywgb3V0LCBlcnIgPSBsb2dnaW5nX3J1bihbJy0tbGlu dC10ZXN0LWZpbGVzJ10sIHRlc3RzX2luY2x1ZGVkPVRydWUpCisgICAgICAgIHJlcywgb3V0LCBl cnIsIHVzZXIgPSBsb2dnaW5nX3J1bihbJy0tbGludC10ZXN0LWZpbGVzJ10sCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0ZXN0c19pbmNsdWRlZD1UcnVlKQogICAg ICAgICBzZWxmLmFzc2VydEVxdWFsKHJlcywgMCkKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKG91 dC5lbXB0eSgpKQogICAgICAgICBzZWxmLmFzc2VydFRydWUoYW55KFsnbGludCBzdWNjZWVkZWQn IGluIG1zZyBmb3IgbXNnIGluIGVyci5nZXQoKV0pKQogCiAgICAgZGVmIHRlc3Rfbm9fdGVzdHNf Zm91bmQoc2VsZik6Ci0gICAgICAgIHJlcywgb3V0LCBlcnIgPSBsb2dnaW5nX3J1bihbJ3Jlc291 cmNlcyddLCB0ZXN0c19pbmNsdWRlZD1UcnVlKQorICAgICAgICByZXMsIG91dCwgZXJyLCB1c2Vy ID0gbG9nZ2luZ19ydW4oWydyZXNvdXJjZXMnXSwgdGVzdHNfaW5jbHVkZWQ9VHJ1ZSkKICAgICAg ICAgc2VsZi5hc3NlcnRFcXVhbChyZXMsIC0xKQogICAgICAgICBzZWxmLmFzc2VydFRydWUob3V0 LmVtcHR5KCkpCiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZSgnTm8gdGVzdHMgdG8gcnVuLlxuJyBp biBlcnIuZ2V0KCkpCiAKICAgICBkZWYgdGVzdF9ub190ZXN0c19mb3VuZF8yKHNlbGYpOgotICAg ICAgICByZXMsIG91dCwgZXJyID0gbG9nZ2luZ19ydW4oWydmb28nXSwgdGVzdHNfaW5jbHVkZWQ9 VHJ1ZSkKKyAgICAgICAgcmVzLCBvdXQsIGVyciwgdXNlciA9IGxvZ2dpbmdfcnVuKFsnZm9vJ10s IHRlc3RzX2luY2x1ZGVkPVRydWUpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocmVzLCAtMSkK ICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKG91dC5lbXB0eSgpKQogICAgICAgICBzZWxmLmFzc2Vy dFRydWUoJ05vIHRlc3RzIHRvIHJ1bi5cbicgaW4gZXJyLmdldCgpKQpAQCAtMTk2LDE3ICsyMDgs MTkgQEAgY2xhc3MgTWFpblRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICBzZWxmLmFz c2VydFRydWUocGFzc2luZ19ydW4oWyctLXRlc3QtbGlzdD0lcycgJSBmaWxlbmFtZV0sCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0ZXN0c19pbmNsdWRlZD1UcnVlKSkKICAg ICAgICAgb3MucmVtb3ZlKGZpbGVuYW1lKQotICAgICAgICByZXMsIG91dCwgZXJyID0gbG9nZ2lu Z19ydW4oWyctLXRlc3QtbGlzdD0lcycgJSBmaWxlbmFtZV0sCi0gICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB0ZXN0c19pbmNsdWRlZD1UcnVlKQorICAgICAgICByZXMsIG91dCwg ZXJyLCB1c2VyID0gbG9nZ2luZ19ydW4oWyctLXRlc3QtbGlzdD0lcycgJSBmaWxlbmFtZV0sCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0ZXN0c19pbmNsdWRlZD1U cnVlKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHJlcywgLTEpCiAgICAgICAgIHNlbGYuYXNz ZXJ0RmFsc2UoZXJyLmVtcHR5KCkpCiAKICAgICBkZWYgdGVzdF91bmV4cGVjdGVkX2ZhaWx1cmVz KHNlbGYpOgogICAgICAgICAjIFJ1biB0ZXN0cyBpbmNsdWRpbmcgdGhlIHVuZXhwZWN0ZWQgZmFp bHVyZXMuCi0gICAgICAgIHJlcywgb3V0LCBlcnIgPSBsb2dnaW5nX3J1bih0ZXN0c19pbmNsdWRl ZD1UcnVlKQorICAgICAgICBzZWxmLl91cmxfb3BlbmVkID0gTm9uZQorICAgICAgICByZXMsIG91 dCwgZXJyLCB1c2VyID0gbG9nZ2luZ19ydW4odGVzdHNfaW5jbHVkZWQ9VHJ1ZSkKICAgICAgICAg c2VsZi5hc3NlcnRFcXVhbChyZXMsIDEpCiAgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2Uob3V0LmVt cHR5KCkpCiAgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2UoZXJyLmVtcHR5KCkpCisgICAgICAgIHNl bGYuYXNzZXJ0RXF1YWwodXNlci51cmwsICcvdG1wL2xheW91dC10ZXN0LXJlc3VsdHMvcmVzdWx0 cy5odG1sJykKIAogCiBkZWYgX21vY2tlZF9vcGVuKG9yaWdpbmFsX29wZW4sIGZpbGVfbGlzdCk6 CkBAIC0yNjksNiArMjgzLDcgQEAgY2xhc3MgUmViYXNlbGluZVRlc3QodW5pdHRlc3QuVGVzdENh c2UpOgogICAgICAgICBmaW5hbGx5OgogICAgICAgICAgICAgY29kZWNzLm9wZW4gPSBvcmlnaW5h bF9vcGVuCiAKKwogY2xhc3MgVGVzdFJ1bm5lclRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAg IGRlZiB0ZXN0X3Jlc3VsdHNfaHRtbChzZWxmKToKICAgICAgICAgbW9ja19wb3J0ID0gTW9jaygp CkBAIC0zMDYsOCArMzIxLDggQEAgY2xhc3MgRHJ5cnVuVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6 CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ2Zhc3QvaHRtbCddKSkKIAog ICAgIGRlZiB0ZXN0X3Rlc3Qoc2VsZik6Ci0gICAgICAgIHJlcywgb3V0LCBlcnIgPSBsb2dnaW5n X3J1bihbJy0tcGxhdGZvcm0nLCAnZHJ5cnVuLXRlc3QnLAotICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICctLXBpeGVsLXRlc3RzJ10pCisgICAgICAgIHJlcywgb3V0LCBlcnIs IHVzZXIgPSBsb2dnaW5nX3J1bihbJy0tcGxhdGZvcm0nLCAnZHJ5cnVuLXRlc3QnLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICctLXBpeGVsLXRlc3RzJ10pCiAg ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocmVzLCAyKQogICAgICAgICBzZWxmLmFzc2VydEZhbHNl KG91dC5lbXB0eSgpKQogICAgICAgICBzZWxmLmFzc2VydEZhbHNlKGVyci5lbXB0eSgpKQo= 68275 2010-09-21 12:34:16 -0700 2010-09-21 16:35:56 -0700 Patch bug-46128-20100921123414.patch text/plain 36127 dpranke ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA2M2M3NjdmNjVhNDNjYzc0MGVkYjM2YzRlMmMyNjNiODg2NzkxYzcxLi44OWQwYzFi M2FiM2FjYjg4ZDgyYzJkYTM4ZjgxZTY5NThiMWUwMzUxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDkgQEAK KzIwMTAtMDktMjAgIERpcmsgUHJhbmtlICA8ZHByYW5rZUBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KKworICAgICAgICBNb2RpZnkgdGhlIFBvcnQgaW50 ZXJmYWNlIHRvIHRha2Ugb25seSBhIHNlcmllcyBvZiBrZXl3b3JkIGFyZ3VtZW50cworICAgICAg ICBpbiB0aGUgY29uc3RydWN0b3IsIGFuZCBtb2RpZnkgUG9ydC9mYWN0b3J5LmdldCgpIHRvIGFj Y29tb2RhdGUgdGhhdCwKKyAgICAgICAgYW5kIHRvIGFjY2VwdCB1c2VyPVhYWCBhcyBhbiBhcmd1 bWVudCBzbyB3ZSBjYW4gcGFzcworICAgICAgICB3ZWJraXRweS5jb21tb24uc3lzdGVtLnVzZXIu VXNlciBvYmplY3RzIGluLgorCisgICAgICAgIFRoZW4sIG1vZGlmeSBuZXctcnVuLXdlYmtpdC10 ZXN0cyBhbmQgcmViYXNlbGluZS1jaHJvbWl1bS13ZWJraXQtdGVzdHMKKyAgICAgICAgdG8gdXNl IHRoZSBjb21tb24gcm91dGluZSBpbiB3ZWJraXRweS5jb21tb24uc3lzdGVtLnVzZXIub3Blbl91 cmwoKQorICAgICAgICB0byBkaXNwbGF5IEhUTUwgZmlsZXMuCisKKyAgICAgICAgVGhlcmUgd2Fz IGEgcm91dGluZSBpbiB0aGUgUG9ydCBpbnRlcmZhY2UgdG8gZG8gdGhlIHNhbWUgdGhpbmcsCisg ICAgICAgIGJ1dCBJIHNlZSBubyBuZWVkIGZvciBhIHBvcnQtc3BlY2lmaWMgaG9vayBmb3IgdGhp cywgc2luY2UgaXQgaXMKKyAgICAgICAgc29tZXRoaW5nIHRoYXQgd2lsbCBhbHdheXMgYmUgZXhl Y3V0ZWQgYnkgdGhlIGhvc3QgZW52aXJvbm1lbnQKKyAgICAgICAgYW5kIGRpc3BsYXlpbmcgd2Vi IHBhZ2VzIGhhcyBub3RoaW5nIHRvIGRvIHdpdGggcnVubmluZyBsYXlvdXQgdGVzdHMuCisKKyAg ICAgICAgTm90ZSB0aGF0IG5ldy1ydW4td2Via2l0LXRlc3RzIHVzZWQgdG8gdXNlIHRlc3Rfc2hl bGwgdG8gZGlzcGxheQorICAgICAgICB0aGUgcGFnZTsgdGhpcyBpcyBwb3RlbnRpYWxseSB1c2Vm dWwgc28gdGhhdCB5b3UgY2FuIGFjdHVhbGx5IGNsaWNrCisgICAgICAgIGZyb20gYSByZXN1bHQg dG8gdGhlIGJyb2tlbiBwYWdlOyBob3dldmVyLCBzaW5jZSBEdW1wUmVuZGVyVHJlZQorICAgICAg ICBkb2Vzbid0IHN1cHBvcnQgdGhpcyBmdW5jdGlvbmFsaXR5LCBpdCB3aWxsIGJlIGdvaW5nIGF3 YXkgZXZlbnR1YWxseS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9NDYxMjgKKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvYmFzZS5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2Jhc2VfdW5pdHRlc3QucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC9jaHJvbWl1bS5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fbWFjLnB5OgorICAgICAgICAqIFNjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fdW5pdHRlc3QucHk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV93aW4ucHk6Cisg ICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHk6Cisg ICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9mYWN0b3J5LnB5Ogor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ29vZ2xlX2Nocm9t ZS5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2dvb2ds ZV9jaHJvbWVfdW5pdHRlc3QucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC9ndGsucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9tYWMucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9xdC5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L3Rlc3QucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93 ZWJraXQucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93 aW4ucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNlbGlu ZV9jaHJvbWl1bV93ZWJraXRfdGVzdHMucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0LnB5OgorCiAyMDEwLTA5 LTE3ICBEaXJrIFByYW5rZSAgPGRwcmFua2VAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmll d2VkIGJ5IE9qYW4gVmFmYWkuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKaW5kZXggOGExMjYzYzFjNGM1ZjFiZTcwZjRk NjEwMWExNjY0YzhhN2QzODFkYy4uMzJhNGUxNzI5NjUwMTYwZWE0ZDc3YmU2OTZhNGIxMzlmMTVm MjY3YyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9iYXNlLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3BvcnQvYmFzZS5weQpAQCAtNDgsNiArNDgsNyBAQCBpbXBvcnQgd2Vic29ja2V0X3Nl cnZlcgogCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0gaW1wb3J0IGxvZ3V0aWxzCiBmcm9t IHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0uZXhlY3V0aXZlIGltcG9ydCBFeGVjdXRpdmUsIFNjcmlw dEVycm9yCitmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0udXNlciBpbXBvcnQgVXNlcgogCiAK IF9sb2cgPSBsb2d1dGlscy5nZXRfbG9nZ2VyKF9fZmlsZV9fKQpAQCAtODIsMTQgKzgzLDE1IEBA IGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgfQogICAgICAgICByZXR1cm4gZmxhZ3NfYnlf Y29uZmlndXJhdGlvbltjb25maWd1cmF0aW9uXQogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBv cnRfbmFtZT1Ob25lLCBvcHRpb25zPU5vbmUsIGV4ZWN1dGl2ZT1FeGVjdXRpdmUoKSk6Ci0gICAg ICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUKLSAgICAgICAgc2VsZi5fb3B0aW9ucyA9IG9wdGlv bnMKKyAgICBkZWYgX19pbml0X18oc2VsZiwgKiprd2FyZ3MpOgorICAgICAgICBzZWxmLl9uYW1l ID0ga3dhcmdzLmdldCgncG9ydF9uYW1lJywgTm9uZSkKKyAgICAgICAgc2VsZi5fb3B0aW9ucyA9 IGt3YXJncy5nZXQoJ29wdGlvbnMnLCBOb25lKQorICAgICAgICBzZWxmLl9leGVjdXRpdmUgPSBr d2FyZ3MuZ2V0KCdleGVjdXRpdmUnLCBFeGVjdXRpdmUoKSkKKyAgICAgICAgc2VsZi5fdXNlciA9 IGt3YXJncy5nZXQoJ3VzZXInLCBVc2VyKCkpCiAgICAgICAgIHNlbGYuX2hlbHBlciA9IE5vbmUK ICAgICAgICAgc2VsZi5faHR0cF9zZXJ2ZXIgPSBOb25lCiAgICAgICAgIHNlbGYuX3dlYmtpdF9i YXNlX2RpciA9IE5vbmUKICAgICAgICAgc2VsZi5fd2Vic29ja2V0X3NlcnZlciA9IE5vbmUKLSAg ICAgICAgc2VsZi5fZXhlY3V0aXZlID0gZXhlY3V0aXZlCiAKICAgICBkZWYgZGVmYXVsdF9jaGls ZF9wcm9jZXNzZXMoc2VsZik6CiAgICAgICAgICIiIlJldHVybiB0aGUgbnVtYmVyIG9mIER1bXBS ZW5kZXJUcmVlIGluc3RhbmNlcyB0byB1c2UgZm9yIHRoaXMKQEAgLTQ2MiwxMCArNDY0LDEwIEBA IGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgIiIiCiAgICAgICAgIHJldHVybiBvcy5lbnZp cm9uLmNvcHkoKQogCi0gICAgZGVmIHNob3dfaHRtbF9yZXN1bHRzX2ZpbGUoc2VsZiwgcmVzdWx0 c19maWxlbmFtZSk6CisgICAgZGVmIHNob3dfcmVzdWx0c19odG1sX2ZpbGUoc2VsZiwgcmVzdWx0 c19maWxlbmFtZSk6CiAgICAgICAgICIiIlRoaXMgcm91dGluZSBzaG91bGQgZGlzcGxheSB0aGUg SFRNTCBmaWxlIHBvaW50ZWQgYXQgYnkKICAgICAgICAgcmVzdWx0c19maWxlbmFtZSBpbiBhIHVz ZXJzJyBicm93c2VyLiIiIgotICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdQb3J0 LnNob3dfaHRtbF9yZXN1bHRzX2ZpbGUnKQorICAgICAgICByZXR1cm4gc2VsZi5fdXNlci5vcGVu X3VybChyZXN1bHRzX2ZpbGVuYW1lKQogCiAgICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwgaW1h Z2VfcGF0aCwgb3B0aW9ucyk6CiAgICAgICAgICIiIlJldHVybiBhIG5ld2x5IGNyZWF0ZWQgYmFz ZS5Ecml2ZXIgc3ViY2xhc3MgZm9yIHN0YXJ0aW5nL3N0b3BwaW5nCmRpZmYgLS1naXQgYS9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2VfdW5pdHRlc3Qu cHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2Vf dW5pdHRlc3QucHkKaW5kZXggNDc0NDkyOGYyOTE0NDhlYWJhMjA2YTUxZDJhZmNiZWNjZTZlOWE5 Ny4uMWE2ZTQxMDAzOGQ5YjFjNTY4MDNiODQ5YmQ4NjMxMWFjZTA3MmU2MiAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlX3VuaXR0 ZXN0LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvYmFzZV91bml0dGVzdC5weQpAQCAtMjM2LDcgKzIzNiw2IEBAIGNsYXNzIFZpcnR1YWxUZXN0 KHVuaXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKHBvcnQucGF0 aF90b190ZXN0X2V4cGVjdGF0aW9uc19maWxlKQogICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwo cG9ydC50ZXN0X3BsYXRmb3JtX25hbWUpCiAgICAgICAgIHNlbGYuYXNzZXJ0VmlydHVhbChwb3J0 LnJlc3VsdHNfZGlyZWN0b3J5KQotICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwocG9ydC5zaG93 X2h0bWxfcmVzdWx0c19maWxlLCBOb25lKQogICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwocG9y dC50ZXN0X2V4cGVjdGF0aW9ucykKICAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKHBvcnQudGVz dF9iYXNlX3BsYXRmb3JtX25hbWVzKQogICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwocG9ydC50 ZXN0X3BsYXRmb3JtX25hbWUpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weQppbmRleCBlZDNkNDg2NDRmNDRj OTU3ZmZkYmI4MTdhZmJhNTI5ZGIyNjBjMTUyLi43ZDliZDU2Nzk1MjY4MzMxNDhhZDg5NTgzY2Nj ZGQyZDQzMTI2YjUzIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkKQEAgLTgxLDggKzgxLDEzIEBAIGRl ZiBjaGVja19maWxlX2V4aXN0cyhwYXRoX3RvX2ZpbGUsIGZpbGVfZGVzY3JpcHRpb24sIG92ZXJy aWRlX3N0ZXA9Tm9uZSwKIGNsYXNzIENocm9taXVtUG9ydChiYXNlLlBvcnQpOgogICAgICIiIkFi c3RyYWN0IGJhc2UgY2xhc3MgZm9yIENocm9taXVtIGltcGxlbWVudGF0aW9ucyBvZiB0aGUgUG9y dCBjbGFzcy4iIiIKIAotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgb3B0 aW9ucz1Ob25lLCAqKmt3YXJncyk6Ci0gICAgICAgIGJhc2UuUG9ydC5fX2luaXRfXyhzZWxmLCBw b3J0X25hbWUsIG9wdGlvbnMsICoqa3dhcmdzKQorICAgIGRlZiBfX2luaXRfXyhzZWxmLCAqKmt3 YXJncyk6CisgICAgICAgIGlmICdvcHRpb25zJyBpbiBrd2FyZ3M6CisgICAgICAgICAgICBvcHRp b25zID0ga3dhcmdzWydvcHRpb25zJ10KKyAgICAgICAgICAgIGlmIChvcHRpb25zIGFuZCAobm90 IGhhc2F0dHIob3B0aW9ucywgJ2NvbmZpZ3VyYXRpb24nKSBvcgorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBvcHRpb25zLmNvbmZpZ3VyYXRpb24gaXMgTm9uZSkpOgorICAgICAgICAgICAg ICAgIG9wdGlvbnMuY29uZmlndXJhdGlvbiA9ICdSZWxlYXNlJworICAgICAgICBiYXNlLlBvcnQu X19pbml0X18oc2VsZiwgKiprd2FyZ3MpCiAgICAgICAgIHNlbGYuX2Nocm9taXVtX2Jhc2VfZGly ID0gTm9uZQogCiAgICAgZGVmIGJhc2VsaW5lX3BhdGgoc2VsZik6CkBAIC0xODksMTUgKzE5NCw2 IEBAIGNsYXNzIENocm9taXVtUG9ydChiYXNlLlBvcnQpOgogICAgICAgICBpZiBvcy5wYXRoLmV4 aXN0cyhjYWNoZWRpcik6CiAgICAgICAgICAgICBzaHV0aWwucm10cmVlKGNhY2hlZGlyKQogCi0g ICAgZGVmIHNob3dfcmVzdWx0c19odG1sX2ZpbGUoc2VsZiwgcmVzdWx0c19maWxlbmFtZSk6Ci0g ICAgICAgIHVyaSA9IHNlbGYuZ2V0X2Fic29sdXRlX3BhdGgocmVzdWx0c19maWxlbmFtZSkKLSAg ICAgICAgaWYgc2VsZi5fb3B0aW9ucy51c2VfZHJ0OgotICAgICAgICAgICAgIyBGSVhNRTogVGhp cyBzaG91bGQgdXNlIFVzZXIub3Blbl91cmwKLSAgICAgICAgICAgIHdlYmJyb3dzZXIub3Blbih1 cmksIG5ldz0xKQotICAgICAgICBlbHNlOgotICAgICAgICAgICAgIyBOb3RlOiBOb3QgdGhyZWFk IHNhZmU6IGh0dHA6Ly9idWdzLnB5dGhvbi5vcmcvaXNzdWUyMzIwCi0gICAgICAgICAgICBzdWJw cm9jZXNzLlBvcGVuKFtzZWxmLl9wYXRoX3RvX2RyaXZlcigpLCB1cmldKQotCiAgICAgZGVmIGNy ZWF0ZV9kcml2ZXIoc2VsZiwgaW1hZ2VfcGF0aCwgb3B0aW9ucyk6CiAgICAgICAgICIiIlN0YXJ0 cyBhIG5ldyBEcml2ZXIgYW5kIHJldHVybnMgYSBoYW5kbGUgdG8gaXQuIiIiCiAgICAgICAgIGlm IG9wdGlvbnMudXNlX2RydCBhbmQgc3lzLnBsYXRmb3JtID09ICdkYXJ3aW4nOgpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1 bV9saW51eC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvY2hyb21pdW1fbGludXgucHkKaW5kZXggNGRmNDNlMDEzMjAyZjE4NzNkMjczYWY3ZDJkMzE0 OGViODRiNmJjZS4uMTc2OTkxYjdmNmE2OGRmNzc5ZjcxZDUxMTA0NDEzMjg2OWUxZTE4OSAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9j aHJvbWl1bV9saW51eC5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5CkBAIC00MSwxMiArNDEsOSBAQCBfbG9nID0g bG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0LmNocm9taXVtX2xp bnV4IikKIGNsYXNzIENocm9taXVtTGludXhQb3J0KGNocm9taXVtLkNocm9taXVtUG9ydCk6CiAg ICAgIiIiQ2hyb21pdW0gTGludXggaW1wbGVtZW50YXRpb24gb2YgdGhlIFBvcnQgY2xhc3MuIiIi CiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9Tm9uZSk6 Ci0gICAgICAgIGlmIHBvcnRfbmFtZSBpcyBOb25lOgotICAgICAgICAgICAgcG9ydF9uYW1lID0g J2Nocm9taXVtLWxpbnV4JwotICAgICAgICBpZiBvcHRpb25zIGFuZCBub3QgaGFzYXR0cihvcHRp b25zLCAnY29uZmlndXJhdGlvbicpOgotICAgICAgICAgICAgb3B0aW9ucy5jb25maWd1cmF0aW9u ID0gJ1JlbGVhc2UnCi0gICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhzZWxm LCBwb3J0X25hbWUsIG9wdGlvbnMpCisgICAgZGVmIF9faW5pdF9fKHNlbGYsICoqa3dhcmdzKToK KyAgICAgICAga3dhcmdzLnNldGRlZmF1bHQoJ3BvcnRfbmFtZScsICdjaHJvbWl1bS1saW51eCcp CisgICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhzZWxmLCAqKmt3YXJncykK IAogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToKICAgICAgICAgcG9ydF9uYW1l cyA9IFsiY2hyb21pdW0tbGludXgiLCAiY2hyb21pdW0td2luIiwgImNocm9taXVtIiwgIndpbiIs ICJtYWMiXQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weQppbmRleCBhYmQ4NGFlNWVlNDRlZjkz ZjgwZjQ0ZjcwM2YwZWI2NGUxMDAzZDNlLi42NDAxNmFiMDQyY2FlOGE4ZTI3YmRjYWFiNDYxY2Y1 Y2FlM2EyZjgxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weQpAQCAtNDQsMTIgKzQ0LDkg QEAgX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydC5j aHJvbWl1bV9tYWMiKQogY2xhc3MgQ2hyb21pdW1NYWNQb3J0KGNocm9taXVtLkNocm9taXVtUG9y dCk6CiAgICAgIiIiQ2hyb21pdW0gTWFjIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNz LiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvcHRpb25zPU5v bmUpOgotICAgICAgICBpZiBwb3J0X25hbWUgaXMgTm9uZToKLSAgICAgICAgICAgIHBvcnRfbmFt ZSA9ICdjaHJvbWl1bS1tYWMnCi0gICAgICAgIGlmIG9wdGlvbnMgYW5kIG5vdCBoYXNhdHRyKG9w dGlvbnMsICdjb25maWd1cmF0aW9uJyk6Ci0gICAgICAgICAgICBvcHRpb25zLmNvbmZpZ3VyYXRp b24gPSAnUmVsZWFzZScKLSAgICAgICAgY2hyb21pdW0uQ2hyb21pdW1Qb3J0Ll9faW5pdF9fKHNl bGYsIHBvcnRfbmFtZSwgb3B0aW9ucykKKyAgICBkZWYgX19pbml0X18oc2VsZiwgKiprd2FyZ3Mp OgorICAgICAgICBrd2FyZ3Muc2V0ZGVmYXVsdCgncG9ydF9uYW1lJywgJ2Nocm9taXVtLW1hYycp CisgICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhzZWxmLCAqKmt3YXJncykK IAogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToKICAgICAgICAgcG9ydF9uYW1l cyA9IFsiY2hyb21pdW0tbWFjIiwgImNocm9taXVtIiwgIm1hYyIgKyBzZWxmLnZlcnNpb24oKSwg Im1hYyJdCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2Nocm9taXVtX3VuaXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJr aXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV91bml0dGVzdC5weQppbmRleCA1MThjZGI5 MmRkYzAxM2IxNDM0NjM4ZjI4ZGVmNjAzYmM3N2VlMjE3Li4xY2ZiZGUxNzc0YWFlM2U4ODMzN2Q1 MzJjOThmMDllMWM0YzU4YzYwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3VuaXR0ZXN0LnB5CisrKyBiL1dlYktpdFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fdW5pdHRlc3Qu cHkKQEAgLTg4LDEwICs4OCwxMiBAQCBjbGFzcyBDaHJvbWl1bURyaXZlclRlc3QodW5pdHRlc3Qu VGVzdENhc2UpOgogICAgICAgICAgICAgZGVmIF9faW5pdF9fKHNlbGYpOgogICAgICAgICAgICAg ICAgIHNlbGYudXNlX2RydCA9IFRydWUKIAotICAgICAgICBwb3J0ID0gY2hyb21pdW1fbGludXgu Q2hyb21pdW1MaW51eFBvcnQoJ3Rlc3QtcG9ydCcsIG9wdGlvbnM9TW9ja09wdGlvbnMoKSkKKyAg ICAgICAgcG9ydCA9IGNocm9taXVtX2xpbnV4LkNocm9taXVtTGludXhQb3J0KHBvcnRfbmFtZT0n dGVzdC1wb3J0JywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIG9wdGlvbnM9TW9ja09wdGlvbnMoKSkKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHBvcnQu X3BhdGhfdG9faW1hZ2VfZGlmZigpLmVuZHN3aXRoKAogICAgICAgICAgICAgJy9vdXQvUmVsZWFz ZS9JbWFnZURpZmYnKSkKLSAgICAgICAgcG9ydCA9IGNocm9taXVtX21hYy5DaHJvbWl1bU1hY1Bv cnQoJ3Rlc3QtcG9ydCcsIG9wdGlvbnM9TW9ja09wdGlvbnMoKSkKKyAgICAgICAgcG9ydCA9IGNo cm9taXVtX21hYy5DaHJvbWl1bU1hY1BvcnQocG9ydF9uYW1lPSd0ZXN0LXBvcnQnLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBvcHRpb25zPU1vY2tPcHRpb25z KCkpCiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShwb3J0Ll9wYXRoX3RvX2ltYWdlX2RpZmYoKS5l bmRzd2l0aCgKICAgICAgICAgICAgICcveGNvZGVidWlsZC9SZWxlYXNlL0ltYWdlRGlmZicpKQog ICAgICAgICAjIEZJWE1FOiBGaWd1cmUgb3V0IGhvdyB0aGlzIGlzIGdvaW5nIHRvIHdvcmsgb24g V2luZG93cy4KQEAgLTEwMiw3ICsxMDQsOCBAQCBjbGFzcyBDaHJvbWl1bURyaXZlclRlc3QodW5p dHRlc3QuVGVzdENhc2UpOgogICAgICAgICAgICAgZGVmIF9faW5pdF9fKHNlbGYpOgogICAgICAg ICAgICAgICAgIHNlbGYudXNlX2RydCA9IFRydWUKIAotICAgICAgICBwb3J0ID0gY2hyb21pdW1f bGludXguQ2hyb21pdW1MaW51eFBvcnQoJ3Rlc3QtcG9ydCcsIG9wdGlvbnM9TW9ja09wdGlvbnMo KSkKKyAgICAgICAgcG9ydCA9IGNocm9taXVtX2xpbnV4LkNocm9taXVtTGludXhQb3J0KHBvcnRf bmFtZT0ndGVzdC1wb3J0JywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIG9wdGlvbnM9TW9ja09wdGlvbnMoKSkKIAogICAgICAgICBmYWtlX3Rlc3QgPSBv cy5wYXRoLmpvaW4ocG9ydC5sYXlvdXRfdGVzdHNfZGlyKCksICJmYXN0L2pzL25vdC1nb29kLmpz IikKIApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9jaHJvbWl1bV93aW4ucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQppbmRleCBlOWE4MWU3OGYzZjVlNDMxZGRh ZDUwYmQ5OWFkOWU0NmRmNzE1ZTRmLi4zMzNjZmE0YTg0NGEwMTA0NGQxOTk2ZGM3YWE5Y2NhM2Iy NGFlMGNmIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQpAQCAtNDEsMTIgKzQxLDkgQEAg X2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydC5jaHJv bWl1bV93aW4iKQogY2xhc3MgQ2hyb21pdW1XaW5Qb3J0KGNocm9taXVtLkNocm9taXVtUG9ydCk6 CiAgICAgIiIiQ2hyb21pdW0gV2luIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNzLiIi IgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvcHRpb25zPU5vbmUp OgotICAgICAgICBpZiBwb3J0X25hbWUgaXMgTm9uZToKLSAgICAgICAgICAgIHBvcnRfbmFtZSA9 ICJjaHJvbWl1bS13aW4iICsgc2VsZi52ZXJzaW9uKCkKLSAgICAgICAgaWYgb3B0aW9ucyBhbmQg bm90IGhhc2F0dHIob3B0aW9ucywgImNvbmZpZ3VyYXRpb24iKToKLSAgICAgICAgICAgIG9wdGlv bnMuY29uZmlndXJhdGlvbiA9ICJSZWxlYXNlIgotICAgICAgICBjaHJvbWl1bS5DaHJvbWl1bVBv cnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lLCBvcHRpb25zKQorICAgIGRlZiBfX2luaXRfXyhz ZWxmLCAqKmt3YXJncyk6CisgICAgICAgIGt3YXJncy5zZXRkZWZhdWx0KCdwb3J0X25hbWUnLCAn Y2hyb21pdW0td2luJykKKyAgICAgICAgY2hyb21pdW0uQ2hyb21pdW1Qb3J0Ll9faW5pdF9fKHNl bGYsICoqa3dhcmdzKQogCiAgICAgZGVmIHNldHVwX2Vudmlyb25fZm9yX3NlcnZlcihzZWxmKToK ICAgICAgICAgZW52ID0gY2hyb21pdW0uQ2hyb21pdW1Qb3J0LnNldHVwX2Vudmlyb25fZm9yX3Nl cnZlcihzZWxmKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvcG9ydC9kcnlydW4ucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L2RyeXJ1bi5weQppbmRleCAzNWUwZTJkMmUxNWViMDJmNTZkNjNlZWIw MjhmODI0MDljM2RhNTIxLi42NDhjY2FkYWFlNmY0NWY3ZDA2YjJiNWViNmNiMWVkZDJmZjU4YjEw IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2RyeXJ1bi5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2RyeXJ1bi5weQpAQCAtNTYsMTQgKzU2LDE0IEBAIGltcG9ydCBmYWN0b3J5CiBj bGFzcyBEcnlSdW5Qb3J0KG9iamVjdCk6CiAgICAgIiIiRHJ5UnVuIGltcGxlbWVudGF0aW9uIG9m IHRoZSBQb3J0IGludGVyZmFjZS4iIiIKIAotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0X25h bWU9Tm9uZSwgb3B0aW9ucz1Ob25lKToKKyAgICBkZWYgX19pbml0X18oc2VsZiwgKiprd2FyZ3Mp OgogICAgICAgICBwZnggPSAnZHJ5cnVuLScKLSAgICAgICAgaWYgcG9ydF9uYW1lLnN0YXJ0c3dp dGgocGZ4KToKLSAgICAgICAgICAgIHBvcnRfbmFtZSA9IHBvcnRfbmFtZVtsZW4ocGZ4KTpdCi0g ICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBwb3J0X25hbWUgPSBOb25lCi0gICAgICAgIHNlbGYu X29wdGlvbnMgPSBvcHRpb25zCi0gICAgICAgIHNlbGYuX19kZWxlZ2F0ZSA9IGZhY3RvcnkuZ2V0 KHBvcnRfbmFtZSwgb3B0aW9ucykKKyAgICAgICAgaWYgJ3BvcnRfbmFtZScgaW4ga3dhcmdzOgor ICAgICAgICAgICAgaWYga3dhcmdzWydwb3J0X25hbWUnXS5zdGFydHN3aXRoKHBmeCk6CisgICAg ICAgICAgICAgICAga3dhcmdzWydwb3J0X25hbWUnXSA9IGt3YXJnc1sncG9ydF9uYW1lJ11bbGVu KHBmeCk6XQorICAgICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAgICBrd2FyZ3NbJ3BvcnRf bmFtZSddID0gTm9uZQorICAgICAgICBzZWxmLl9fZGVsZWdhdGUgPSBmYWN0b3J5LmdldCgqKmt3 YXJncykKIAogICAgIGRlZiBfX2dldGF0dHJfXyhzZWxmLCBuYW1lKToKICAgICAgICAgcmV0dXJu IGdldGF0dHIoc2VsZi5fX2RlbGVnYXRlLCBuYW1lKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9mYWN0b3J5LnB5IGIvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9mYWN0b3J5LnB5CmluZGV4IDU3 MDRmNjU3ZmMzMDIxYzgxZjkwYTE3ZjYwNTJiODUyZDY1Y2IzODQuLmFmZTE3ZGZmNTAzOTQwZDhj ZThjZmUwMTcyOTQ5MTJlZGUzYWVkZjMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZmFjdG9yeS5weQorKysgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2ZhY3RvcnkucHkKQEAgLTM3LDExICsz NywyMSBAQCBBTExfUE9SVF9OQU1FUyA9IFsndGVzdCcsICdkcnlydW4nLCAnbWFjJywgJ3dpbics ICdndGsnLCAncXQnLCAnY2hyb21pdW0tbWFjJywKICAgICAgICAgICAgICAgICAgICdnb29nbGUt Y2hyb21lLW1hYycsICdnb29nbGUtY2hyb21lLWxpbnV4MzInLCAnZ29vZ2xlLWNocm9tZS1saW51 eDY0J10KIAogCi1kZWYgZ2V0KHBvcnRfbmFtZT1Ob25lLCBvcHRpb25zPU5vbmUpOgorZGVmIGdl dChwb3J0X25hbWU9Tm9uZSwgb3B0aW9ucz1Ob25lLCAqKmt3YXJncyk6CiAgICAgIiIiUmV0dXJu cyBhbiBvYmplY3QgaW1wbGVtZW50aW5nIHRoZSBQb3J0IGludGVyZmFjZS4gSWYKICAgICBwb3J0 X25hbWUgaXMgTm9uZSwgdGhpcyByb3V0aW5lIGF0dGVtcHRzIHRvIGd1ZXNzIGF0IHRoZSBtb3N0 CiAgICAgYXBwcm9wcmlhdGUgcG9ydCBvbiB0aGlzIHBsYXRmb3JtLiIiIgotICAgIHBvcnRfdG9f dXNlID0gcG9ydF9uYW1lCisgICAgIyBXcmFwcGVkIGZvciBiYWNrd2FyZHMtY29tcGF0aWJpbGl0 eQorICAgIGlmIHBvcnRfbmFtZToKKyAgICAgICAga3dhcmdzWydwb3J0X25hbWUnXSA9IHBvcnRf bmFtZQorICAgIGlmIG9wdGlvbnM6CisgICAgICAgIGt3YXJnc1snb3B0aW9ucyddID0gb3B0aW9u cworICAgIHJldHVybiBfZ2V0X2t3YXJncygqKmt3YXJncykKKworCitkZWYgX2dldF9rd2FyZ3Mo Kiprd2FyZ3MpOgorICAgIHBvcnRfdG9fdXNlID0ga3dhcmdzLmdldCgncG9ydF9uYW1lJywgTm9u ZSkKKyAgICBvcHRpb25zID0ga3dhcmdzLmdldCgnb3B0aW9ucycsIE5vbmUpCiAgICAgaWYgcG9y dF90b191c2UgaXMgTm9uZToKICAgICAgICAgaWYgc3lzLnBsYXRmb3JtID09ICd3aW4zMicgb3Ig c3lzLnBsYXRmb3JtID09ICdjeWd3aW4nOgogICAgICAgICAgICAgaWYgb3B0aW9ucyBhbmQgaGFz YXR0cihvcHRpb25zLCAnY2hyb21pdW0nKSBhbmQgb3B0aW9ucy5jaHJvbWl1bToKQEAgLTYyLDM3 ICs3MiwzNyBAQCBkZWYgZ2V0KHBvcnRfbmFtZT1Ob25lLCBvcHRpb25zPU5vbmUpOgogCiAgICAg aWYgcG9ydF90b191c2UgPT0gJ3Rlc3QnOgogICAgICAgICBpbXBvcnQgdGVzdAotICAgICAgICBy ZXR1cm4gdGVzdC5UZXN0UG9ydChwb3J0X25hbWUsIG9wdGlvbnMpCisgICAgICAgIGNscyA9IHRl c3QuVGVzdFBvcnQKICAgICBlbGlmIHBvcnRfdG9fdXNlLnN0YXJ0c3dpdGgoJ2RyeXJ1bicpOgog ICAgICAgICBpbXBvcnQgZHJ5cnVuCi0gICAgICAgIHJldHVybiBkcnlydW4uRHJ5UnVuUG9ydChw b3J0X25hbWUsIG9wdGlvbnMpCisgICAgICAgIGNscyA9IGRyeXJ1bi5EcnlSdW5Qb3J0CiAgICAg ZWxpZiBwb3J0X3RvX3VzZS5zdGFydHN3aXRoKCdtYWMnKToKICAgICAgICAgaW1wb3J0IG1hYwot ICAgICAgICByZXR1cm4gbWFjLk1hY1BvcnQocG9ydF9uYW1lLCBvcHRpb25zKQorICAgICAgICBj bHMgPSBtYWMuTWFjUG9ydAogICAgIGVsaWYgcG9ydF90b191c2Uuc3RhcnRzd2l0aCgnd2luJyk6 CiAgICAgICAgIGltcG9ydCB3aW4KLSAgICAgICAgcmV0dXJuIHdpbi5XaW5Qb3J0KHBvcnRfbmFt ZSwgb3B0aW9ucykKKyAgICAgICAgY2xzID0gd2luLldpblBvcnQKICAgICBlbGlmIHBvcnRfdG9f dXNlLnN0YXJ0c3dpdGgoJ2d0aycpOgogICAgICAgICBpbXBvcnQgZ3RrCi0gICAgICAgIHJldHVy biBndGsuR3RrUG9ydChwb3J0X25hbWUsIG9wdGlvbnMpCisgICAgICAgIGNscyA9IGd0ay5HdGtQ b3J0CiAgICAgZWxpZiBwb3J0X3RvX3VzZS5zdGFydHN3aXRoKCdxdCcpOgogICAgICAgICBpbXBv cnQgcXQKLSAgICAgICAgcmV0dXJuIHF0LlF0UG9ydChwb3J0X25hbWUsIG9wdGlvbnMpCisgICAg ICAgIGNscyA9IHF0LlF0UG9ydAogICAgIGVsaWYgcG9ydF90b191c2Uuc3RhcnRzd2l0aCgnY2hy b21pdW0tbWFjJyk6CiAgICAgICAgIGltcG9ydCBjaHJvbWl1bV9tYWMKLSAgICAgICAgcmV0dXJu IGNocm9taXVtX21hYy5DaHJvbWl1bU1hY1BvcnQocG9ydF9uYW1lLCBvcHRpb25zKQorICAgICAg ICBjbHMgPSBjaHJvbWl1bV9tYWMuQ2hyb21pdW1NYWNQb3J0CiAgICAgZWxpZiBwb3J0X3RvX3Vz ZS5zdGFydHN3aXRoKCdjaHJvbWl1bS1saW51eCcpOgogICAgICAgICBpbXBvcnQgY2hyb21pdW1f bGludXgKLSAgICAgICAgcmV0dXJuIGNocm9taXVtX2xpbnV4LkNocm9taXVtTGludXhQb3J0KHBv cnRfbmFtZSwgb3B0aW9ucykKKyAgICAgICAgY2xzID0gY2hyb21pdW1fbGludXguQ2hyb21pdW1M aW51eFBvcnQKICAgICBlbGlmIHBvcnRfdG9fdXNlLnN0YXJ0c3dpdGgoJ2Nocm9taXVtLXdpbicp OgogICAgICAgICBpbXBvcnQgY2hyb21pdW1fd2luCi0gICAgICAgIHJldHVybiBjaHJvbWl1bV93 aW4uQ2hyb21pdW1XaW5Qb3J0KHBvcnRfbmFtZSwgb3B0aW9ucykKKyAgICAgICAgY2xzID0gY2hy b21pdW1fd2luLkNocm9taXVtV2luUG9ydAogICAgIGVsaWYgcG9ydF90b191c2Uuc3RhcnRzd2l0 aCgnZ29vZ2xlLWNocm9tZScpOgogICAgICAgICBpbXBvcnQgZ29vZ2xlX2Nocm9tZQotICAgICAg ICByZXR1cm4gZ29vZ2xlX2Nocm9tZS5HZXRHb29nbGVDaHJvbWVQb3J0KHBvcnRfbmFtZSwgb3B0 aW9ucykKLQotICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IoJ3Vuc3VwcG9ydGVkIHBvcnQ6 ICVzJyAlIHBvcnRfdG9fdXNlKQotCisgICAgICAgIGNscyA9IGdvb2dsZV9jaHJvbWUuR2V0R29v Z2xlQ2hyb21lUG9ydAorICAgIGVsc2U6CisgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJy b3IoJ3Vuc3VwcG9ydGVkIHBvcnQ6ICVzJyAlIHBvcnRfdG9fdXNlKQorICAgIHJldHVybiBjbHMo Kiprd2FyZ3MpCiAKIGRlZiBnZXRfYWxsKG9wdGlvbnM9Tm9uZSk6CiAgICAgIiIiUmV0dXJucyBh bGwgdGhlIG9iamVjdHMgaW1wbGVtZW50aW5nIHRoZSBQb3J0IGludGVyZmFjZS4iIiIKZGlmZiAt LWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ29v Z2xlX2Nocm9tZS5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvZ29vZ2xlX2Nocm9tZS5weQppbmRleCA0NmFiM2VkNTdhNjQ5MmY5ZmY5NzgwMzEzMDA3 OWRiYmVjZmY3NTFjLi5iZmZjODYwZTIyYTg3OWU2YTE3NDQ5OWIyMzk5YzZjZmJkNDliYTJhIDEw MDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L2dvb2dsZV9jaHJvbWUucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvcG9ydC9nb29nbGVfY2hyb21lLnB5CkBAIC0yNSwxMCArMjUsMTIgQEAKICMgT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KIAogCi1kZWYgR2V0R29vZ2xlQ2hyb21lUG9ydChwb3J0X25hbWUsIG9wdGlvbnMp OgorZGVmIEdldEdvb2dsZUNocm9tZVBvcnQoKiprd2FyZ3MpOgogICAgICIiIlNvbWUgdGVzdHMg aGF2ZSBzbGlnaHRseSBkaWZmZXJlbnQgcmVzdWx0cyB3aGVuIGNvbXBpbGVkIGFzIEdvb2dsZQog ICAgIENocm9tZSB2cyBDaHJvbWl1bS4gIEluIHRob3NlIGNhc2VzLCB3ZSBwcmVwZW5kIGFuIGFk ZGl0aW9uYWwgZGlyZWN0b3J5IHRvCiAgICAgdG8gdGhlIGJhc2VsaW5lIHBhdGhzLiIiIgorICAg IHBvcnRfbmFtZSA9IGt3YXJnc1sncG9ydF9uYW1lJ10KKyAgICBkZWwga3dhcmdzWydwb3J0X25h bWUnXQogICAgIGlmIHBvcnRfbmFtZSA9PSAnZ29vZ2xlLWNocm9tZS1saW51eDMyJzoKICAgICAg ICAgaW1wb3J0IGNocm9taXVtX2xpbnV4CiAKQEAgLTM5LDcgKzQxLDcgQEAgZGVmIEdldEdvb2ds ZUNocm9tZVBvcnQocG9ydF9uYW1lLCBvcHRpb25zKToKICAgICAgICAgICAgICAgICBwYXRocy5p bnNlcnQoMCwgc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoCiAgICAgICAgICAgICAgICAgICAg ICdnb29nbGUtY2hyb21lLWxpbnV4MzInKSkKICAgICAgICAgICAgICAgICByZXR1cm4gcGF0aHMK LSAgICAgICAgcmV0dXJuIEdvb2dsZUNocm9tZUxpbnV4MzJQb3J0KE5vbmUsIG9wdGlvbnMpCisg ICAgICAgIHJldHVybiBHb29nbGVDaHJvbWVMaW51eDMyUG9ydCgqKmt3YXJncykKICAgICBlbGlm IHBvcnRfbmFtZSA9PSAnZ29vZ2xlLWNocm9tZS1saW51eDY0JzoKICAgICAgICAgaW1wb3J0IGNo cm9taXVtX2xpbnV4CiAKQEAgLTUwLDcgKzUyLDcgQEAgZGVmIEdldEdvb2dsZUNocm9tZVBvcnQo cG9ydF9uYW1lLCBvcHRpb25zKToKICAgICAgICAgICAgICAgICBwYXRocy5pbnNlcnQoMCwgc2Vs Zi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoCiAgICAgICAgICAgICAgICAgICAgICdnb29nbGUtY2hy b21lLWxpbnV4NjQnKSkKICAgICAgICAgICAgICAgICByZXR1cm4gcGF0aHMKLSAgICAgICAgcmV0 dXJuIEdvb2dsZUNocm9tZUxpbnV4NjRQb3J0KE5vbmUsIG9wdGlvbnMpCisgICAgICAgIHJldHVy biBHb29nbGVDaHJvbWVMaW51eDY0UG9ydCgqKmt3YXJncykKICAgICBlbGlmIHBvcnRfbmFtZS5z dGFydHN3aXRoKCdnb29nbGUtY2hyb21lLW1hYycpOgogICAgICAgICBpbXBvcnQgY2hyb21pdW1f bWFjCiAKQEAgLTYxLDcgKzYzLDcgQEAgZGVmIEdldEdvb2dsZUNocm9tZVBvcnQocG9ydF9uYW1l LCBvcHRpb25zKToKICAgICAgICAgICAgICAgICBwYXRocy5pbnNlcnQoMCwgc2VsZi5fd2Via2l0 X2Jhc2VsaW5lX3BhdGgoCiAgICAgICAgICAgICAgICAgICAgICdnb29nbGUtY2hyb21lLW1hYycp KQogICAgICAgICAgICAgICAgIHJldHVybiBwYXRocwotICAgICAgICByZXR1cm4gR29vZ2xlQ2hy b21lTWFjUG9ydChOb25lLCBvcHRpb25zKQorICAgICAgICByZXR1cm4gR29vZ2xlQ2hyb21lTWFj UG9ydCgqKmt3YXJncykKICAgICBlbGlmIHBvcnRfbmFtZS5zdGFydHN3aXRoKCdnb29nbGUtY2hy b21lLXdpbicpOgogICAgICAgICBpbXBvcnQgY2hyb21pdW1fd2luCiAKQEAgLTcyLDUgKzc0LDUg QEAgZGVmIEdldEdvb2dsZUNocm9tZVBvcnQocG9ydF9uYW1lLCBvcHRpb25zKToKICAgICAgICAg ICAgICAgICBwYXRocy5pbnNlcnQoMCwgc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoCiAgICAg ICAgICAgICAgICAgICAgICdnb29nbGUtY2hyb21lLXdpbicpKQogICAgICAgICAgICAgICAgIHJl dHVybiBwYXRocwotICAgICAgICByZXR1cm4gR29vZ2xlQ2hyb21lV2luUG9ydChOb25lLCBvcHRp b25zKQorICAgICAgICByZXR1cm4gR29vZ2xlQ2hyb21lV2luUG9ydCgqKmt3YXJncykKICAgICBy YWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCd1bnN1cHBvcnRlZCBwb3J0OiAlcycgJSBwb3J0X25h bWUpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L2dvb2dsZV9jaHJvbWVfdW5pdHRlc3QucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2dvb2dsZV9jaHJvbWVfdW5pdHRlc3QucHkKaW5kZXgg YTJkNzA1NjdhMDJkNTBjMjVjNmFkZDgyMjVkMWM4Yzg0NjMzYzExYS4uODVlOTMzODcyMmFmNjg3 ZGU3YTFlYzMzYjZiMjI0ZGM2ZjllYmU1NCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9nb29nbGVfY2hyb21lX3VuaXR0ZXN0LnB5Cisr KyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ29vZ2xl X2Nocm9tZV91bml0dGVzdC5weQpAQCAtNDEsNiArNDEsNyBAQCBjbGFzcyBHZXRHb29nbGVDaHJv bWVQb3J0VGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgIHNlbGYuX3ZlcmlmeV9iYXNl bGluZV9wYXRoKCdnb29nbGUtY2hyb21lLXdpbicsICdnb29nbGUtY2hyb21lLXdpbi12aXN0YScp CiAKICAgICBkZWYgX3ZlcmlmeV9iYXNlbGluZV9wYXRoKHNlbGYsIGV4cGVjdGVkX3BhdGgsIHBv cnRfbmFtZSk6Ci0gICAgICAgIHBvcnQgPSBnb29nbGVfY2hyb21lLkdldEdvb2dsZUNocm9tZVBv cnQocG9ydF9uYW1lLCBOb25lKQorICAgICAgICBwb3J0ID0gZ29vZ2xlX2Nocm9tZS5HZXRHb29n bGVDaHJvbWVQb3J0KHBvcnRfbmFtZT1wb3J0X25hbWUsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgb3B0aW9ucz1Ob25lKQogICAgICAgICBwYXRoID0g cG9ydC5iYXNlbGluZV9zZWFyY2hfcGF0aCgpWzBdCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwo ZXhwZWN0ZWRfcGF0aCwgb3MucGF0aC5zcGxpdChwYXRoKVsxXSkKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ3RrLnB5IGIvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkKaW5kZXggNTlk YzFkOTVkNTZhZTc0ODVhNmU3YTI0ODgxYTE1ZTc2ZGRhNzhjMS4uYzYwOTA5ZWI5NGVkNjEwNzUz MmVkM2VmOTBjZDYzZjBiYWQ3MTM1NCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkKQEAgLTM5LDEwICszOSw5IEBAIF9s b2cgPSBsb2dnaW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQuZ3RrIikK IGNsYXNzIEd0a1BvcnQoV2ViS2l0UG9ydCk6CiAgICAgIiIiV2ViS2l0IEd0ayBpbXBsZW1lbnRh dGlvbiBvZiB0aGUgUG9ydCBjbGFzcy4iIiIKIAotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0 X25hbWU9Tm9uZSwgb3B0aW9ucz1Ob25lKToKLSAgICAgICAgaWYgcG9ydF9uYW1lIGlzIE5vbmU6 Ci0gICAgICAgICAgICBwb3J0X25hbWUgPSAnZ3RrJwotICAgICAgICBXZWJLaXRQb3J0Ll9faW5p dF9fKHNlbGYsIHBvcnRfbmFtZSwgb3B0aW9ucykKKyAgICBkZWYgX19pbml0X18oc2VsZiwgKipr d2FyZ3MpOgorICAgICAgICBrd2FyZ3Muc2V0ZGVmYXVsdCgncG9ydF9uYW1lJywgJ2d0aycpCisg ICAgICAgIFdlYktpdFBvcnQuX19pbml0X18oc2VsZiwgKiprd2FyZ3MpCiAKICAgICBkZWYgX3Rl c3RzX2Zvcl9vdGhlcl9wbGF0Zm9ybXMoc2VsZik6CiAgICAgICAgICMgRklYTUU6IFRoaXMgbGlz dCBjb3VsZCBiZSBkeW5hbWljIGJhc2VkIG9uIHBsYXRmb3JtIG5hbWUgYW5kCmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hYy5weSBi L1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5Cmlu ZGV4IDQxM2I1ZjJjMzVkODliYjFmN2M3ZjU3OWMwMmY3MjU3NGVlNjA5OGYuLjY5NmUzMzk4ZWE0 YjI4YWM3NjIyNTkwN2RjMzYyZmZjM2ZiODZmOWUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5CisrKyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5CkBAIC00MywxMCArNDMs OSBAQCBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0 Lm1hYyIpCiBjbGFzcyBNYWNQb3J0KFdlYktpdFBvcnQpOgogICAgICIiIldlYktpdCBNYWMgaW1w bGVtZW50YXRpb24gb2YgdGhlIFBvcnQgY2xhc3MuIiIiCiAKLSAgICBkZWYgX19pbml0X18oc2Vs ZiwgcG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9Tm9uZSk6Ci0gICAgICAgIGlmIHBvcnRfbmFtZSBp cyBOb25lOgotICAgICAgICAgICAgcG9ydF9uYW1lID0gJ21hYycgKyBzZWxmLnZlcnNpb24oKQot ICAgICAgICBXZWJLaXRQb3J0Ll9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZSwgb3B0aW9ucykKKyAg ICBkZWYgX19pbml0X18oc2VsZiwgKiprd2FyZ3MpOgorICAgICAgICBrd2FyZ3Muc2V0ZGVmYXVs dCgncG9ydF9uYW1lJywgJ21hYycgKyBzZWxmLnZlcnNpb24oKSkKKyAgICAgICAgV2ViS2l0UG9y dC5fX2luaXRfXyhzZWxmLCAqKmt3YXJncykKIAogICAgIGRlZiBkZWZhdWx0X2NoaWxkX3Byb2Nl c3NlcyhzZWxmKToKICAgICAgICAgIyBGSVhNRTogbmV3LXJ1bi13ZWJraXQtdGVzdHMgaXMgdW5z dGFibGUgb24gTWFjIHJ1bm5pbmcgbW9yZSB0aGFuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3F0LnB5IGIvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9xdC5weQppbmRleCAxNThjNjMzNzgwZjFj NDFjMzdiYmZlYTFiYWVjNmU2ZmRjOWFkZWM4Li40YzhmYTBhMDBiNjdkZWY2NWQwOGRhY2U2NDA0 YjlhMzNhZjY2ZDBiIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L3F0LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3BvcnQvcXQucHkKQEAgLTQyLDEwICs0Miw5IEBAIF9sb2cgPSBsb2dnaW5n LmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQucXQiKQogY2xhc3MgUXRQb3J0 KFdlYktpdFBvcnQpOgogICAgICIiIlF0V2ViS2l0IGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0 IGNsYXNzLiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvcHRp b25zPU5vbmUpOgotICAgICAgICBpZiBwb3J0X25hbWUgaXMgTm9uZToKLSAgICAgICAgICAgIHBv cnRfbmFtZSA9ICdxdCcKLSAgICAgICAgV2ViS2l0UG9ydC5fX2luaXRfXyhzZWxmLCBwb3J0X25h bWUsIG9wdGlvbnMpCisgICAgZGVmIF9faW5pdF9fKHNlbGYsICoqa3dhcmdzKToKKyAgICAgICAg a3dhcmdzLnNldGRlZmF1bHQoJ3BvcnRfbmFtZScsICdxdCcpCisgICAgICAgIFdlYktpdFBvcnQu X19pbml0X18oc2VsZiwgKiprd2FyZ3MpCiAKICAgICBkZWYgX3Rlc3RzX2Zvcl9vdGhlcl9wbGF0 Zm9ybXMoc2VsZik6CiAgICAgICAgICMgRklYTUU6IFRoaXMgbGlzdCBjb3VsZCBiZSBkeW5hbWlj IGJhc2VkIG9uIHBsYXRmb3JtIG5hbWUgYW5kCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3QucHkgYi9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3QucHkKaW5kZXggMGRmYWEzZDBhYzYx OWIyNzhhM2E0Yjc5YzhhM2I4OGEyNDg2NGU2Ni4uM2I4MTE2Nzk5YWYzY2Q0ZWVhNmViMWRmZGI4 ZGE5MDRjZDVmOTgwMCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdC5weQpAQCAtODUsOCArODUsOCBAQCBjbGFzcyBUZXN0 TGlzdDoKIGNsYXNzIFRlc3RQb3J0KGJhc2UuUG9ydCk6CiAgICAgIiIiVGVzdCBpbXBsZW1lbnRh dGlvbiBvZiB0aGUgUG9ydCBpbnRlcmZhY2UuIiIiCiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwg cG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9Tm9uZSk6Ci0gICAgICAgIGJhc2UuUG9ydC5fX2luaXRf XyhzZWxmLCBwb3J0X25hbWUsIG9wdGlvbnMpCisgICAgZGVmIF9faW5pdF9fKHNlbGYsICoqa3dh cmdzKToKKyAgICAgICAgYmFzZS5Qb3J0Ll9faW5pdF9fKHNlbGYsICoqa3dhcmdzKQogICAgICAg ICB0ZXN0cyA9IFRlc3RMaXN0KHNlbGYpCiAgICAgICAgIHRlc3RzLmFkZCgncGFzc2VzL2ltYWdl Lmh0bWwnKQogICAgICAgICB0ZXN0cy5hZGQoJ3Bhc3Nlcy90ZXh0Lmh0bWwnKQpAQCAtMjI3LDkg KzIyNyw2IEBAIGNsYXNzIFRlc3RQb3J0KGJhc2UuUG9ydCk6CiAgICAgZGVmIHNldHVwX3Rlc3Rf cnVuKHNlbGYpOgogICAgICAgICBwYXNzCiAKLSAgICBkZWYgc2hvd19yZXN1bHRzX2h0bWxfZmls ZShzZWxmLCBmaWxlbmFtZSk6Ci0gICAgICAgIHBhc3MKLQogICAgIGRlZiBjcmVhdGVfZHJpdmVy KHNlbGYsIGltYWdlX3BhdGgsIG9wdGlvbnMpOgogICAgICAgICByZXR1cm4gVGVzdERyaXZlcihz ZWxmLCBpbWFnZV9wYXRoLCBvcHRpb25zLCBleGVjdXRpdmU9Tm9uZSkKIApkaWZmIC0tZ2l0IGEv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkg Yi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5w eQppbmRleCBlYjhlZTVmNWU5OGM3NWYwYTZhNDA2M2UxNTk1YzhhODkwYTc3ZGZjLi4wMWM2Mzlm Mzc1MTZkNzlhZjUwNWE2ZWJhZmRlY2IxYmNhYzg5YmQ1IDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weQorKysgYi9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weQpAQCAt NTgsMTYgKzU4LDE2IEBAIF9sb2cgPSBsb2dnaW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0 X3Rlc3RzLnBvcnQud2Via2l0IikKIGNsYXNzIFdlYktpdFBvcnQoYmFzZS5Qb3J0KToKICAgICAi IiJXZWJLaXQgaW1wbGVtZW50YXRpb24gb2YgdGhlIFBvcnQgY2xhc3MuIiIiCiAKLSAgICBkZWYg X19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9Tm9uZSwgKiprd2FyZ3MpOgot ICAgICAgICBiYXNlLlBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lLCBvcHRpb25zLCAqKmt3 YXJncykKKyAgICBkZWYgX19pbml0X18oc2VsZiwgKiprd2FyZ3MpOgorICAgICAgICBiYXNlLlBv cnQuX19pbml0X18oc2VsZiwgKiprd2FyZ3MpCiAgICAgICAgIHNlbGYuX2NhY2hlZF9idWlsZF9y b290ID0gTm9uZQogICAgICAgICBzZWxmLl9jYWNoZWRfYXBhY2hlX3BhdGggPSBOb25lCiAKICAg ICAgICAgIyBGSVhNRTogZGlzYWJsZSBwaXhlbCB0ZXN0cyB1bnRpbCB0aGV5IGFyZSBydW4gYnkg ZGVmYXVsdCBvbiB0aGUKICAgICAgICAgIyBidWlsZCBtYWNoaW5lcy4KLSAgICAgICAgaWYgb3B0 aW9ucyBhbmQgKG5vdCBoYXNhdHRyKG9wdGlvbnMsICJwaXhlbF90ZXN0cyIpIG9yCi0gICAgICAg ICAgIG9wdGlvbnMucGl4ZWxfdGVzdHMgaXMgTm9uZSk6Ci0gICAgICAgICAgICBvcHRpb25zLnBp eGVsX3Rlc3RzID0gRmFsc2UKKyAgICAgICAgaWYgc2VsZi5fb3B0aW9ucyBhbmQgKG5vdCBoYXNh dHRyKHNlbGYuX29wdGlvbnMsICJwaXhlbF90ZXN0cyIpIG9yCisgICAgICAgICAgIHNlbGYuX29w dGlvbnMucGl4ZWxfdGVzdHMgaXMgTm9uZSk6CisgICAgICAgICAgICBzZWxmLl9vcHRpb25zLnBp eGVsX3Rlc3RzID0gRmFsc2UKIAogICAgIGRlZiBiYXNlbGluZV9wYXRoKHNlbGYpOgogICAgICAg ICByZXR1cm4gc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoc2VsZi5fbmFtZSkKQEAgLTE4Niwx MCArMTg2LDYgQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQpOgogICAgICAgICAjIFRoaXMg cG9ydCBkb2Vzbid0IHJlcXVpcmUgYW55IHNwZWNpZmljIGNvbmZpZ3VyYXRpb24uCiAgICAgICAg IHBhc3MKIAotICAgIGRlZiBzaG93X3Jlc3VsdHNfaHRtbF9maWxlKHNlbGYsIHJlc3VsdHNfZmls ZW5hbWUpOgotICAgICAgICAjIEZJWE1FOiBXZSBzaG91bGQgb3BlbiByZXN1bHRzIGluIHRoZSB2 ZXJzaW9uIG9mIFdlYktpdCB3ZSBidWlsdC4KLSAgICAgICAgd2ViYnJvd3Nlci5vcGVuKHJlc3Vs dHNfZmlsZW5hbWUsIG5ldz0xKQotCiAgICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwgaW1hZ2Vf cGF0aCwgb3B0aW9ucyk6CiAgICAgICAgIHJldHVybiBXZWJLaXREcml2ZXIoc2VsZiwgaW1hZ2Vf cGF0aCwgb3B0aW9ucywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleGVjdXRpdmU9c2Vs Zi5fZXhlY3V0aXZlKQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcG9ydC93aW4ucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L3dpbi5weQppbmRleCBlMDVhNjlkODFhYjc2NzA1ZWUzYWYzODNlYTUy NWJkNTE5MjQyOWI3Li45ZTMwMTU1MTAwMDc3NjA4ZGM3MWYyNDU1YTBmNGZlMjYyMTM1ZDY1IDEw MDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L3dpbi5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L3dpbi5weQpAQCAtMzksMTAgKzM5LDkgQEAgX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3 ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydC53aW4iKQogY2xhc3MgV2luUG9ydChXZWJLaXRQb3J0 KToKICAgICAiIiJXZWJLaXQgV2luIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNzLiIi IgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvcHRpb25zPU5vbmUp OgotICAgICAgICBpZiBwb3J0X25hbWUgaXMgTm9uZToKLSAgICAgICAgICAgIHBvcnRfbmFtZSA9 ICd3aW4nCi0gICAgICAgIFdlYktpdFBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lLCBvcHRp b25zKQorICAgIGRlZiBfX2luaXRfXyhzZWxmLCAqKmt3YXJncyk6CisgICAgICAgIGt3YXJncy5z ZXRkZWZhdWx0KCdwb3J0X25hbWUnLCAnd2luJykKKyAgICAgICAgV2ViS2l0UG9ydC5fX2luaXRf XyhzZWxmLCAqKmt3YXJncykKIAogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToK ICAgICAgICAgIyBCYXNlZCBvbiBjb2RlIGZyb20gb2xkLXJ1bi13ZWJraXQtdGVzdHMgZXhwZWN0 ZWREaXJlY3RvcnlGb3JUZXN0KCkKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3JlYmFzZWxpbmVfY2hyb21pdW1fd2Via2l0X3Rlc3RzLnB5IGIv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNlbGluZV9jaHJv bWl1bV93ZWJraXRfdGVzdHMucHkKaW5kZXggYWMzZGZkZWJkZDZiYzE0ZmEwMzUyODJlMzkyYjFk ZmM3Y2QyYWM1Yy4uY2RmM2JjYTkwZDk4NzFjOTRmNTAyZjBiMzkzOWZlMGQzOGE2OTU5MCAxMDA2 NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNl bGluZV9jaHJvbWl1bV93ZWJraXRfdGVzdHMucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcmViYXNlbGluZV9jaHJvbWl1bV93ZWJraXRfdGVzdHMucHkK QEAgLTU1LDkgKzU1LDkgQEAgaW1wb3J0IHN5cwogaW1wb3J0IHRlbXBmaWxlCiBpbXBvcnQgdGlt ZQogaW1wb3J0IHVybGxpYgotaW1wb3J0IHdlYmJyb3dzZXIKIGltcG9ydCB6aXBmaWxlCiAKK2Zy b20gd2Via2l0cHkuY29tbW9uLnN5c3RlbSBpbXBvcnQgdXNlcgogZnJvbSB3ZWJraXRweS5jb21t b24uc3lzdGVtLmV4ZWN1dGl2ZSBpbXBvcnQgcnVuX2NvbW1hbmQsIFNjcmlwdEVycm9yCiBpbXBv cnQgd2Via2l0cHkuY29tbW9uLmNoZWNrb3V0LnNjbSBhcyBzY20KIApAQCAtNzMwLDEwICs3MzAs NyBAQCBjbGFzcyBIdG1sR2VuZXJhdG9yKG9iamVjdCk6CiAgICAgICAgICIiIkxhdW5jaCB0aGUg cmViYXNlbGluaW5nIGh0bWwgaW4gYnJ3b3Nlci4iIiIKIAogICAgICAgICBfbG9nLmluZm8oJ0xh dW5jaGluZyBodG1sOiAiJXMiJywgc2VsZi5faHRtbF9maWxlKQotCi0gICAgICAgIGh0bWxfdXJp ID0gc2VsZi5fdGFyZ2V0X3BvcnQuZmlsZW5hbWVfdG9fdXJpKHNlbGYuX2h0bWxfZmlsZSkKLSAg ICAgICAgd2ViYnJvd3Nlci5vcGVuKGh0bWxfdXJpLCAxKQotCisgICAgICAgIHVzZXIub3Blbl91 cmwoc2VsZi5faHRtbF9maWxlKQogICAgICAgICBfbG9nLmluZm8oJ0h0bWwgbGF1bmNoZWQuJykK IAogICAgIGRlZiBfZ2VuZXJhdGVfYmFzZWxpbmVfbGlua3Moc2VsZiwgdGVzdF9iYXNlbmFtZSwg c3VmZml4LCBwbGF0Zm9ybSk6CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQppbmRleCBmZDYzZGE5 YzQ0OTdhNjc3MThhMzVlYmFlOThhNDUxOGM4ZjE3M2ZkLi41MTkzZGJkY2YzZTNjYzM3YjYzMGJi ZGJkMGY0NzcwNDRhOWVlYWIyIDEwMDc1NQotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CisrKyBiL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKQEAgLTczLDYg KzczLDcgQEAgZnJvbSB0ZXN0X3R5cGVzIGltcG9ydCBpbWFnZV9kaWZmCiBmcm9tIHRlc3RfdHlw ZXMgaW1wb3J0IHRleHRfZGlmZgogZnJvbSB0ZXN0X3R5cGVzIGltcG9ydCB0ZXN0X3R5cGVfYmFz ZQogCitmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0gaW1wb3J0IHVzZXIKIGZyb20gd2Via2l0 cHkudGhpcmRwYXJ0eSBpbXBvcnQgc2ltcGxlanNvbgogCiBpbXBvcnQgcG9ydApkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90 ZXN0c191bml0dGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3J1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QucHkKaW5kZXggZTM5MTRlODViNjNkNDQ3OTJl ZjU1Yzc1ZGU5M2QyZjM2YWE4YzdhNS4uOWQ0ODYwNGRlODQ0Y2Q3ZDQ5MjI4Nzg3MDdlNTdlMzI2 NTYzMGE2YSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcnVuX3dlYmtpdF90ZXN0c191bml0dGVzdC5weQorKysgYi9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0LnB5CkBA IC00Miw2ICs0Miw3IEBAIGltcG9ydCB1bml0dGVzdAogCiBmcm9tIHdlYmtpdHB5LmNvbW1vbiBp bXBvcnQgYXJyYXlfc3RyZWFtCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0gaW1wb3J0IG91 dHB1dGNhcHR1cmUKK2Zyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbSBpbXBvcnQgdXNlcgogZnJv bSB3ZWJraXRweS5sYXlvdXRfdGVzdHMgaW1wb3J0IHBvcnQKIGZyb20gd2Via2l0cHkubGF5b3V0 X3Rlc3RzIGltcG9ydCBydW5fd2Via2l0X3Rlc3RzCiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0 cy5sYXlvdXRfcGFja2FnZSBpbXBvcnQgZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQKQEAgLTQ5LDYg KzUwLDE0IEBAIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLmxheW91dF9wYWNrYWdlIGltcG9y dCBkdW1wX3JlbmRlcl90cmVlX3RocmVhZAogZnJvbSB3ZWJraXRweS50aGlyZHBhcnR5Lm1vY2sg aW1wb3J0IE1vY2sKIAogCitjbGFzcyBNb2NrVXNlcigpOgorICAgIGRlZiBfX2luaXRfXyhzZWxm KToKKyAgICAgICAgc2VsZi51cmwgPSBOb25lCisKKyAgICBkZWYgb3Blbl91cmwoc2VsZiwgdXJs KToKKyAgICAgICAgc2VsZi51cmwgPSB1cmwKKworCiBkZWYgcGFzc2luZ19ydW4oYXJncz1bXSwg cG9ydF9vYmo9Tm9uZSwgcmVjb3JkX3Jlc3VsdHM9RmFsc2UsCiAgICAgICAgICAgICAgICAgdGVz dHNfaW5jbHVkZWQ9RmFsc2UpOgogICAgIG5ld19hcmdzID0gWyctLXByaW50JywgJ25vdGhpbmcn XQpAQCAtNjUsNyArNzQsOCBAQCBkZWYgcGFzc2luZ19ydW4oYXJncz1bXSwgcG9ydF9vYmo9Tm9u ZSwgcmVjb3JkX3Jlc3VsdHM9RmFsc2UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgJ2ZhaWx1 cmVzL2V4cGVjdGVkLyonXSkKICAgICBvcHRpb25zLCBwYXJzZWRfYXJncyA9IHJ1bl93ZWJraXRf dGVzdHMucGFyc2VfYXJncyhuZXdfYXJncykKICAgICBpZiBwb3J0X29iaiBpcyBOb25lOgotICAg ICAgICBwb3J0X29iaiA9IHBvcnQuZ2V0KG9wdGlvbnMucGxhdGZvcm0sIG9wdGlvbnMpCisgICAg ICAgIHBvcnRfb2JqID0gcG9ydC5nZXQocG9ydF9uYW1lPW9wdGlvbnMucGxhdGZvcm0sIG9wdGlv bnM9b3B0aW9ucywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB1c2VyPU1vY2tVc2VyKCkp CiAgICAgcmVzID0gcnVuX3dlYmtpdF90ZXN0cy5ydW4ocG9ydF9vYmosIG9wdGlvbnMsIHBhcnNl ZF9hcmdzKQogICAgIHJldHVybiByZXMgPT0gMAogCkBAIC04MSwxMyArOTEsMTQgQEAgZGVmIGxv Z2dpbmdfcnVuKGFyZ3M9W10sIHRlc3RzX2luY2x1ZGVkPUZhbHNlKToKICAgICAgICAgICAgICAg ICAgICAgICAgICAnd2Vic29ja2V0L3Rlc3RzJywKICAgICAgICAgICAgICAgICAgICAgICAgICAn ZmFpbHVyZXMvZXhwZWN0ZWQvKiddKQogICAgIG9wdGlvbnMsIHBhcnNlZF9hcmdzID0gcnVuX3dl YmtpdF90ZXN0cy5wYXJzZV9hcmdzKG5ld19hcmdzKQotICAgIHBvcnRfb2JqID0gcG9ydC5nZXQo b3B0aW9ucy5wbGF0Zm9ybSwgb3B0aW9ucykKKyAgICB1c2VyID0gTW9ja1VzZXIoKQorICAgIHBv cnRfb2JqID0gcG9ydC5nZXQocG9ydF9uYW1lPW9wdGlvbnMucGxhdGZvcm0sIG9wdGlvbnM9b3B0 aW9ucywgdXNlcj11c2VyKQogICAgIGJ1aWxkYm90X291dHB1dCA9IGFycmF5X3N0cmVhbS5BcnJh eVN0cmVhbSgpCiAgICAgcmVndWxhcl9vdXRwdXQgPSBhcnJheV9zdHJlYW0uQXJyYXlTdHJlYW0o KQogICAgIHJlcyA9IHJ1bl93ZWJraXRfdGVzdHMucnVuKHBvcnRfb2JqLCBvcHRpb25zLCBwYXJz ZWRfYXJncywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBidWlsZGJvdF9vdXRwdXQ9 YnVpbGRib3Rfb3V0cHV0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlZ3VsYXJf b3V0cHV0PXJlZ3VsYXJfb3V0cHV0KQotICAgIHJldHVybiAocmVzLCBidWlsZGJvdF9vdXRwdXQs IHJlZ3VsYXJfb3V0cHV0KQorICAgIHJldHVybiAocmVzLCBidWlsZGJvdF9vdXRwdXQsIHJlZ3Vs YXJfb3V0cHV0LCB1c2VyKQogCiAKIGNsYXNzIE1haW5UZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToK QEAgLTk5LDEzICsxMTAsMTMgQEAgY2xhc3MgTWFpblRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgog ICAgICAgICBzZWxmLmFzc2VydFRydWUocGFzc2luZ19ydW4oWyctLWJhdGNoLXNpemUnLCAnMidd KSkKIAogICAgIGRlZiB0ZXN0X2NoaWxkX3Byb2Nlc3NfMShzZWxmKToKLSAgICAgICAgKHJlcywg YnVpbGRib3Rfb3V0cHV0LCByZWd1bGFyX291dHB1dCkgPSBsb2dnaW5nX3J1bigKKyAgICAgICAg KHJlcywgYnVpbGRib3Rfb3V0cHV0LCByZWd1bGFyX291dHB1dCwgdXNlcikgPSBsb2dnaW5nX3J1 bigKICAgICAgICAgICAgICBbJy0tcHJpbnQnLCAnY29uZmlnJywgJy0tY2hpbGQtcHJvY2Vzc2Vz JywgJzEnXSkKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKCdSdW5uaW5nIG9uZSBEdW1wUmVuZGVy VHJlZVxuJwogICAgICAgICAgICAgICAgICAgICAgICAgaW4gcmVndWxhcl9vdXRwdXQuZ2V0KCkp CiAKICAgICBkZWYgdGVzdF9jaGlsZF9wcm9jZXNzZXNfMihzZWxmKToKLSAgICAgICAgKHJlcywg YnVpbGRib3Rfb3V0cHV0LCByZWd1bGFyX291dHB1dCkgPSBsb2dnaW5nX3J1bigKKyAgICAgICAg KHJlcywgYnVpbGRib3Rfb3V0cHV0LCByZWd1bGFyX291dHB1dCwgdXNlcikgPSBsb2dnaW5nX3J1 bigKICAgICAgICAgICAgICBbJy0tcHJpbnQnLCAnY29uZmlnJywgJy0tY2hpbGQtcHJvY2Vzc2Vz JywgJzInXSkKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKCdSdW5uaW5nIDIgRHVtcFJlbmRlclRy ZWVzIGluIHBhcmFsbGVsXG4nCiAgICAgICAgICAgICAgICAgICAgICAgICBpbiByZWd1bGFyX291 dHB1dC5nZXQoKSkKQEAgLTExOSwxNSArMTMwLDE1IEBAIGNsYXNzIE1haW5UZXN0KHVuaXR0ZXN0 LlRlc3RDYXNlKToKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHBhc3NpbmdfcnVuKFsnLS1mdWxs LXJlc3VsdHMtaHRtbCddKSkKIAogICAgIGRlZiB0ZXN0X2hlbHBfcHJpbnRpbmcoc2VsZik6Ci0g ICAgICAgIHJlcywgb3V0LCBlcnIgPSBsb2dnaW5nX3J1bihbJy0taGVscC1wcmludGluZyddKQor ICAgICAgICByZXMsIG91dCwgZXJyLCB1c2VyID0gbG9nZ2luZ19ydW4oWyctLWhlbHAtcHJpbnRp bmcnXSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChyZXMsIDApCiAgICAgICAgIHNlbGYuYXNz ZXJ0VHJ1ZShvdXQuZW1wdHkoKSkKICAgICAgICAgc2VsZi5hc3NlcnRGYWxzZShlcnIuZW1wdHko KSkKIAogICAgIGRlZiB0ZXN0X2h1bmdfdGhyZWFkKHNlbGYpOgotICAgICAgICByZXMsIG91dCwg ZXJyID0gbG9nZ2luZ19ydW4oWyctLXJ1bi1zaW5nbHknLCAnLS10aW1lLW91dC1tcz01MCcsCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ2ZhaWx1cmVzL2V4cGVjdGVkL2hh bmcuaHRtbCddLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGVzdHNfaW5j bHVkZWQ9VHJ1ZSkKKyAgICAgICAgcmVzLCBvdXQsIGVyciwgdXNlciA9IGxvZ2dpbmdfcnVuKFsn LS1ydW4tc2luZ2x5JywgJy0tdGltZS1vdXQtbXM9NTAnLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgJ2ZhaWx1cmVzL2V4cGVjdGVkL2hhbmcuaHRtbCddLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGVzdHNfaW5jbHVkZWQ9VHJ1 ZSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChyZXMsIDApCiAgICAgICAgIHNlbGYuYXNzZXJ0 RmFsc2Uob3V0LmVtcHR5KCkpCiAgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2UoZXJyLmVtcHR5KCkp CkBAIC0xNDAsMjYgKzE1MSwyNyBAQCBjbGFzcyBNYWluVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6 CiAKICAgICBkZWYgdGVzdF9sYXN0X3Jlc3VsdHMoc2VsZik6CiAgICAgICAgIHBhc3NpbmdfcnVu KFsnLS1jbG9iYmVyLW9sZC1yZXN1bHRzJ10sIHJlY29yZF9yZXN1bHRzPVRydWUpCi0gICAgICAg IChyZXMsIGJ1aWxkYm90X291dHB1dCwgcmVndWxhcl9vdXRwdXQpID0gbG9nZ2luZ19ydW4oCisg ICAgICAgIChyZXMsIGJ1aWxkYm90X291dHB1dCwgcmVndWxhcl9vdXRwdXQsIHVzZXIpID0gbG9n Z2luZ19ydW4oCiAgICAgICAgICAgICBbJy0tcHJpbnQtbGFzdC1mYWlsdXJlcyddKQogICAgICAg ICBzZWxmLmFzc2VydEVxdWFsKHJlZ3VsYXJfb3V0cHV0LmdldCgpLCBbJ1xuXG4nXSkKICAgICAg ICAgc2VsZi5hc3NlcnRFcXVhbChidWlsZGJvdF9vdXRwdXQuZ2V0KCksIFtdKQogCiAgICAgZGVm IHRlc3RfbGludF90ZXN0X2ZpbGVzKHNlbGYpOgogICAgICAgICAjIEZJWE1FOiAgYWRkIGVycm9y cz8KLSAgICAgICAgcmVzLCBvdXQsIGVyciA9IGxvZ2dpbmdfcnVuKFsnLS1saW50LXRlc3QtZmls ZXMnXSwgdGVzdHNfaW5jbHVkZWQ9VHJ1ZSkKKyAgICAgICAgcmVzLCBvdXQsIGVyciwgdXNlciA9 IGxvZ2dpbmdfcnVuKFsnLS1saW50LXRlc3QtZmlsZXMnXSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHRlc3RzX2luY2x1ZGVkPVRydWUpCiAgICAgICAgIHNlbGYu YXNzZXJ0RXF1YWwocmVzLCAwKQogICAgICAgICBzZWxmLmFzc2VydFRydWUob3V0LmVtcHR5KCkp CiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShhbnkoWydsaW50IHN1Y2NlZWRlZCcgaW4gbXNnIGZv ciBtc2cgaW4gZXJyLmdldCgpXSkpCiAKICAgICBkZWYgdGVzdF9ub190ZXN0c19mb3VuZChzZWxm KToKLSAgICAgICAgcmVzLCBvdXQsIGVyciA9IGxvZ2dpbmdfcnVuKFsncmVzb3VyY2VzJ10sIHRl c3RzX2luY2x1ZGVkPVRydWUpCisgICAgICAgIHJlcywgb3V0LCBlcnIsIHVzZXIgPSBsb2dnaW5n X3J1bihbJ3Jlc291cmNlcyddLCB0ZXN0c19pbmNsdWRlZD1UcnVlKQogICAgICAgICBzZWxmLmFz c2VydEVxdWFsKHJlcywgLTEpCiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShvdXQuZW1wdHkoKSkK ICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKCdObyB0ZXN0cyB0byBydW4uXG4nIGluIGVyci5nZXQo KSkKIAogICAgIGRlZiB0ZXN0X25vX3Rlc3RzX2ZvdW5kXzIoc2VsZik6Ci0gICAgICAgIHJlcywg b3V0LCBlcnIgPSBsb2dnaW5nX3J1bihbJ2ZvbyddLCB0ZXN0c19pbmNsdWRlZD1UcnVlKQorICAg ICAgICByZXMsIG91dCwgZXJyLCB1c2VyID0gbG9nZ2luZ19ydW4oWydmb28nXSwgdGVzdHNfaW5j bHVkZWQ9VHJ1ZSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChyZXMsIC0xKQogICAgICAgICBz ZWxmLmFzc2VydFRydWUob3V0LmVtcHR5KCkpCiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZSgnTm8g dGVzdHMgdG8gcnVuLlxuJyBpbiBlcnIuZ2V0KCkpCkBAIC0xOTYsMTcgKzIwOCwxOSBAQCBjbGFz cyBNYWluVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShw YXNzaW5nX3J1bihbJy0tdGVzdC1saXN0PSVzJyAlIGZpbGVuYW1lXSwKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHRlc3RzX2luY2x1ZGVkPVRydWUpKQogICAgICAgICBvcy5y ZW1vdmUoZmlsZW5hbWUpCi0gICAgICAgIHJlcywgb3V0LCBlcnIgPSBsb2dnaW5nX3J1bihbJy0t dGVzdC1saXN0PSVzJyAlIGZpbGVuYW1lXSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHRlc3RzX2luY2x1ZGVkPVRydWUpCisgICAgICAgIHJlcywgb3V0LCBlcnIsIHVzZXIg PSBsb2dnaW5nX3J1bihbJy0tdGVzdC1saXN0PSVzJyAlIGZpbGVuYW1lXSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRlc3RzX2luY2x1ZGVkPVRydWUpCiAgICAg ICAgIHNlbGYuYXNzZXJ0RXF1YWwocmVzLCAtMSkKICAgICAgICAgc2VsZi5hc3NlcnRGYWxzZShl cnIuZW1wdHkoKSkKIAogICAgIGRlZiB0ZXN0X3VuZXhwZWN0ZWRfZmFpbHVyZXMoc2VsZik6CiAg ICAgICAgICMgUnVuIHRlc3RzIGluY2x1ZGluZyB0aGUgdW5leHBlY3RlZCBmYWlsdXJlcy4KLSAg ICAgICAgcmVzLCBvdXQsIGVyciA9IGxvZ2dpbmdfcnVuKHRlc3RzX2luY2x1ZGVkPVRydWUpCisg ICAgICAgIHNlbGYuX3VybF9vcGVuZWQgPSBOb25lCisgICAgICAgIHJlcywgb3V0LCBlcnIsIHVz ZXIgPSBsb2dnaW5nX3J1bih0ZXN0c19pbmNsdWRlZD1UcnVlKQogICAgICAgICBzZWxmLmFzc2Vy dEVxdWFsKHJlcywgMSkKICAgICAgICAgc2VsZi5hc3NlcnRGYWxzZShvdXQuZW1wdHkoKSkKICAg ICAgICAgc2VsZi5hc3NlcnRGYWxzZShlcnIuZW1wdHkoKSkKKyAgICAgICAgc2VsZi5hc3NlcnRF cXVhbCh1c2VyLnVybCwgJy90bXAvbGF5b3V0LXRlc3QtcmVzdWx0cy9yZXN1bHRzLmh0bWwnKQog CiAKIGRlZiBfbW9ja2VkX29wZW4ob3JpZ2luYWxfb3BlbiwgZmlsZV9saXN0KToKQEAgLTI2OSw2 ICsyODMsNyBAQCBjbGFzcyBSZWJhc2VsaW5lVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAg ICAgIGZpbmFsbHk6CiAgICAgICAgICAgICBjb2RlY3Mub3BlbiA9IG9yaWdpbmFsX29wZW4KIAor CiBjbGFzcyBUZXN0UnVubmVyVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgZGVmIHRlc3Rf cmVzdWx0c19odG1sKHNlbGYpOgogICAgICAgICBtb2NrX3BvcnQgPSBNb2NrKCkKQEAgLTMwNiwx MSArMzIxLDggQEAgY2xhc3MgRHJ5cnVuVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ2Zhc3QvaHRtbCddKSkKIAogICAgIGRlZiB0 ZXN0X3Rlc3Qoc2VsZik6Ci0gICAgICAgIHJlcywgb3V0LCBlcnIgPSBsb2dnaW5nX3J1bihbJy0t cGxhdGZvcm0nLCAnZHJ5cnVuLXRlc3QnLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICctLXBpeGVsLXRlc3RzJ10pCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocmVzLCAw KQotICAgICAgICBzZWxmLmFzc2VydEZhbHNlKG91dC5lbXB0eSgpKQotICAgICAgICBzZWxmLmFz c2VydEZhbHNlKGVyci5lbXB0eSgpKQorICAgICAgICBzZWxmLmFzc2VydFRydWUocGFzc2luZ19y dW4oWyctLXBsYXRmb3JtJywgJ2RyeXJ1bi10ZXN0JywKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAnLS1waXhlbC10ZXN0cyddKSkKIAogCiBjbGFzcyBUZXN0VGhy ZWFkKGR1bXBfcmVuZGVyX3RyZWVfdGhyZWFkLldhdGNoYWJsZVRocmVhZCk6Cg==