71237 2011-10-31 14:12:24 -0700 BaselineOptimizer tests should use mocks instead of real Executive/FileSystem objects 2022-02-27 23:47:19 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 eric eric abarth dbates dpranke ojan oldest_to_newest 493490 0 eric 2011-10-31 14:12:24 -0700 BaselineOptimizer tests should use mocks instead of real Executive/FileSystem objects 493492 1 113086 eric 2011-10-31 14:16:32 -0700 Created attachment 113086 Patch 493500 2 113086 dpranke 2011-10-31 14:31:13 -0700 Comment on attachment 113086 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=113086&action=review > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer.py:-34 > -def _baseline_search_hypergraph(fs): I think it is better to be explicit about the objects that you depend on, rather than looking for a global context-like object, like host. > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer.py:47 > + port = port_factory.get(port_name) Why aren't you passing the filesystem to the port any more? > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer.py:67 > + def __init__(self, host): Same comment as above, I think it is better to be explicit about the objects that you depend on, rather than looking for a global context-like object, like host. > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer_unittest.py:39 > + BaselineOptimizer.__init__(self, MockHost()) Same comment. 493504 3 eric 2011-10-31 14:42:29 -0700 (In reply to comment #2) > (From update of attachment 113086 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=113086&action=review > Same comment as above, I think it is better to be explicit about the objects that you depend on, rather than looking for a global context-like object, like host. Unfortunately, that gets us into the trouble we have now. Since Port is explicit about what it depends on, and you are expected to pass it an Executive, User, and FileSystem, parts of code which fail to do so, aren't mockable. Part of this is the confusion of Port with some sort of Host object. Passing Host here, makes it easy to mock these calls. If they need to talk out to the OS, they do so via Host. Whether that's via Executive, Filesystem or User objects. 493505 4 eric 2011-10-31 14:44:15 -0700 (In reply to comment #2) > (From update of attachment 113086 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=113086&action=review > > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer.py:47 > > + port = port_factory.get(port_name) > > Why aren't you passing the filesystem to the port any more? It's no longer needed. It just happens that port_factory is the same name as the module used to be imported as. But now it's a PortFactory instance, which contains all the information needed to wire up a Port with the proper Executive, User, etc. Previously we only had a FileSystem, so we passed that, since that was better than nothing. Now we have a Host, and better yet, we have a PortFactory from that host, so we just get the port we want, knowing that it will be properly wired up with the right Executive, etc. 493509 5 113087 eric 2011-10-31 14:53:48 -0700 Created attachment 113087 Make our PortFactory mocking slightly more explicit 493510 6 dpranke 2011-10-31 14:55:40 -0700 (In reply to comment #3) > (In reply to comment #2) > > (From update of attachment 113086 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=113086&action=review > > Same comment as above, I think it is better to be explicit about the objects that you depend on, rather than looking for a global context-like object, like host. > > Unfortunately, that gets us into the trouble we have now. Since Port is explicit about what it depends on, and you are expected to pass it an Executive, User, and FileSystem, parts of code which fail to do so, aren't mockable. Part of this is the confusion of Port with some sort of Host object. Passing Host here, makes it easy to mock these calls. If they need to talk out to the OS, they do so via Host. Whether that's via Executive, Filesystem or User objects. I understand what you're aiming towards; the problem is that the MockHost includes a whole bunch of other objects as well (a SCM object, a Bugzilla object, etc.), and by switching to that, you lose visibility into the fact that you *only* need an executive, a user, and a filesystem. Perhaps part of the problem is that it's not clear to me what a "host" is supposed to be. Is it supposed to truly be just things like those three objects (i.e., pointers to stuff in common/system), or a bigger catch-all class? If the former, I'm okay with that (and agree that it will be good to split this out from Port). But I'm not okay with the latter. (In reply to comment #4) > (In reply to comment #2) > > (From update of attachment 113086 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=113086&action=review > > > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer.py:47 > > > + port = port_factory.get(port_name) > > > > Why aren't you passing the filesystem to the port any more? > > It's no longer needed. Ah, sorry, I missed the insertion on line 45. I follow it now. 493511 7 113087 dpranke 2011-10-31 14:58:08 -0700 Comment on attachment 113087 Make our PortFactory mocking slightly more explicit View in context: https://bugs.webkit.org/attachment.cgi?id=113087&action=review > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer_unittest.py:41 > + host.port_factory = PortFactory(host) # We want a real PortFactory, but it should use mocks. Okay, I'm lost again. Why does the host have a port_factory? That seems like a layering inversion. 493658 8 eric 2011-10-31 17:26:17 -0700 (In reply to comment #7) > (From update of attachment 113087 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=113087&action=review > > > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer_unittest.py:41 > > + host.port_factory = PortFactory(host) # We want a real PortFactory, but it should use mocks. > > Okay, I'm lost again. Why does the host have a port_factory? That seems like a layering inversion. Host has historically just been where all the Mock-able singletons have gone. PortFactory is one of them. We could certainly split Host and have an additional layer for higher-level mockable singletons. 493677 9 dpranke 2011-10-31 17:48:53 -0700 (In reply to comment #8) > (In reply to comment #7) > > (From update of attachment 113087 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=113087&action=review > > > > > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer_unittest.py:41 > > > + host.port_factory = PortFactory(host) # We want a real PortFactory, but it should use mocks. > > > > Okay, I'm lost again. Why does the host have a port_factory? That seems like a layering inversion. > > Host has historically just been where all the Mock-able singletons have gone. PortFactory is one of them. We could certainly split Host and have an additional layer for higher-level mockable singletons. Okay, I am definitely opposed to having one catch-all object that contains singletons from multiple layers. I would probably be okay with a version of this change that had a "host" object that contained singletons only for things in common/system, since that is a clear layer and set of functionality, although I still don't think I prefer that to requiring the specific objects that are needed. It would be good if we separated out the concept of "hosts" from "mockable objects", though. I think that is making things unnecessarily confusing (to me, at least). 493704 10 eric 2011-10-31 18:35:19 -0700 So if I'm looking for this same functionality, of having BaselineOptimizer not actually touch the filesystem (or launch processes) while running the unittests, how would you compose the change? 493705 11 eric 2011-10-31 18:38:49 -0700 (In reply to comment #9) > Okay, I am definitely opposed to having one catch-all object that contains singletons from multiple layers. I would probably be okay with a version of this change that had a "host" object that contained singletons only for things in common/system, since that is a clear layer and set of functionality, although I still don't think I prefer that to requiring the specific objects that are needed. I think the layers are at best il-defined. Port for example, is supposed to be rather low on the dependency chain, yet it's the "god object" for NRWT. Port holds NRWT's Executive and Filesystem. We'd like to fix that, but for now, when instantiating port objects we have to be very careful to pass them the current FileSystem/Executive/User or the unittests touch the real filesystem. This change is about making BaselineOptimizer pass the Host along to the Port, effectively, through the PortFactory (since that's the preferred way to make ports). The real layering violation of which you speak is that Port is the Host for NRWT. Until we fix that we basically need to pass a Host through any object which intends to create Port objects. 493708 12 dpranke 2011-10-31 18:48:04 -0700 (In reply to comment #10) > So if I'm looking for this same functionality, of having BaselineOptimizer not actually touch the filesystem (or launch processes) while running the unittests, how would you compose the change? Assuming I am following the code properly, I would pass a MockExecutive object and a MockFilesystem object to the TestBaselineOptimizer constructor, since the port will use a real user but we probably don't care about that. If I was being pedantic/thorough, I would pass a MockUser as well. I would not use the PortFactory object, since it takes host objects but those are not defined outside of the MockHost object. Alternatively, would create a default host object in common/system/host, and then allow myself to use MockHost. I don't think the (MockHost) host object should have a member called port_factory. That seems like it is just inviting trouble and isn't needed in this case, but maybe I'm missing something? 493711 13 dpranke 2011-10-31 18:58:13 -0700 (In reply to comment #11) > (In reply to comment #9) > > Okay, I am definitely opposed to having one catch-all object that contains singletons from multiple layers. I would probably be okay with a version of this change that had a "host" object that contained singletons only for things in common/system, since that is a clear layer and set of functionality, although I still don't think I prefer that to requiring the specific objects that are needed. > > I think the layers are at best il-defined. Port for example, is supposed to be rather low on the dependency chain, yet it's the "god object" for NRWT. Port holds NRWT's Executive and Filesystem. We'd like to fix that, but for now, when instantiating port objects we have to be very careful to pass them the current FileSystem/Executive/User or the unittests touch the real filesystem. I think we agree that the layers are ill-defined and where we eventually want to be; we might just be disagreeing over the path to get there. I would be happy to see filesystem, executive, and user objects be mandatory in the port constructors, and for them to be explicitly passed to most if not all other constructors under webkitpy.layout_tests; I would also -- as I attempted to describe above -- be happy to see a common.system-level "host" replace those three params (I put "host" in quotes here because I don't want to confuse this with the MockHost object that currently holds a bunch of other mocks as well). I don't think such a system-level host wants or needs a handle to a port_factory object, but maybe I am wrong? I'm not positive, but I think I've removed most of the places where we need to retrieve a filesystem from the port elsewhere in NRWT. It shouldn't be too hard to remove the few others that remain. There may be a few places that need to retrieve port.executive, but those shouldn't be too hard to fix, either. If you don't get to this before then, I would be happy to try and put together a patch to that effect tomorrow. 494796 14 abarth 2011-11-02 12:13:27 -0700 > Perhaps part of the problem is that it's not clear to me what a "host" is supposed to be. In webkitpy, our design philosophy has been to avoid instantiating object from the global static scope when those objects interact with the outside environment (e.g., create processes, touch the file system, or interact with the network). The "host" object is just an object to carry these dependencies around explicitly. Rather then instantiating these objects from the global static scope, we retrieve them from the host. The goal of those design is to make it easier to be able to write tests that do not have dependencies on the outside world. This approach has worked very well for us, at least for code that was developed as part of webkitpy. Code that we've imported from elsewhere often hasn't been designed with this philosophy in mind. In the case of NRWT, we've retrofitted some of this idea onto the code using the Port abstraction, but currently the Port abstraction is too broad. There's a lot of code in NRWT that gets things from Port that have nothing to do with ports of WebKit. Over time, we'd like to integrate NRWT better with the rest of webkitpy, which means infusing the Host object throughout NRWT. I haven't looked at this patch specifically, but from reading the comments, that appears to be what Eric is doing here. There's certainly a tradeoff in this design between using Python's import mechanism to create clean abstraction layers and removing dependencies on statics. Ideally the language would let give us an import-like mechanism for controlling the names available in the host namespace in the same way that it lets us control the names available in the global scope. Unfortunately, Python doesn't provide this facility, so we pay some cost for this design. Over time, we might want to break Host down into sub objects for each layer, which might make it easier to catch layering violation in code review. > I would be happy to try and put together a patch to that effect tomorrow. I didn't see this patch in my bugmail. (Although, admittedly, I did have hundreds of bugmails to wade through.) 494797 15 113087 abarth 2011-11-02 12:17:43 -0700 Comment on attachment 113087 Make our PortFactory mocking slightly more explicit View in context: https://bugs.webkit.org/attachment.cgi?id=113087&action=review > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer_unittest.py:35 > +from webkitpy.tool.mocktool import MockHost We should move MockHost to common now that we've moved Host to common. As written, Dirk is correct that importing tool packages in common is a layering violation. > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer_unittest.py:59 > + host.port_factory = PortFactory(host) # We want a real PortFactory, but it should use mocks. Perhaps that's what the default port_factory on MockHost should be? > Tools/Scripts/webkitpy/common/checkout/baselineoptimizer_unittest.py:139 > + # FIXME: What functionality does this rely on? When can we remove this if? I should have made a more detailed comment. This can probably be uncommented if we've succeeded in injecting all the dependencies. > Tools/Scripts/webkitpy/tool/commands/rebaseline.py:119 > - self._baseline_optimizer = BaselineOptimizer(tool.scm(), tool.filesystem) > + self._baseline_optimizer = BaselineOptimizer(tool) We should do a global search-and-replace for tool -> host. It's way past time for that. > Tools/Scripts/webkitpy/tool/mocktool.py:842 > -class MockTool(object): > +class MockHost(object): This should move to common. 494818 16 dpranke 2011-11-02 12:43:47 -0700 ((In reply to comment #14) > > Perhaps part of the problem is that it's not clear to me what a "host" is supposed to be. > > In webkitpy, our design philosophy has been to avoid instantiating object from the global static scope when those objects interact with the outside environment (e.g., create processes, touch the file system, or interact with the network). > I certainly agree with this design philosophy. > The "host" object is just an object to carry these dependencies around explicitly. Rather then instantiating these objects from the global static scope, we retrieve them from the host. The goal of those design is to make it easier to be able to write tests that do not have dependencies on the outside world. > I definitely agree with the second sentence of this. I am less enthusiastic about the first sentence, because a using a single global context, while convenient, can obscure what the true dependencies are. What I was attempting to get at with my comment was that I didn't know what the type signature of the host was supposed to be (i.e., what the interface is). What things should be hung off the host, and what shouldn't? > There's certainly a tradeoff in this design between using Python's import mechanism to create clean abstraction layers and removing dependencies on statics. Ideally the language would let give us an import-like mechanism for controlling the names available in the host namespace in the same way that it lets us control the names available in the global scope. Unfortunately, Python doesn't provide this facility, so we pay some cost for this design. Over time, we might want to break Host down into sub objects for each layer, which might make it easier to catch layering violation in code review. > Given that the Port class already has the mechanisms needed to catch layering violations (by taking the filesystem, user, executive objects directly), I don't want to lose that. That is what I am objecting to. If we had some concept of a "SystemHost" (for lack of a better word) that was being passed to the port, that would be better. The generic Host could then contain a system_host as a field, rather than containing a filesystem, executive, etc. Alternatively (and less satisfactorily), the Host could derive from SystemHost. > > I would be happy to try and put together a patch to that effect tomorrow. > > I didn't see this patch in my bugmail. (Although, admittedly, I did have hundreds of bugmails to wade through.) Yeah, sorry, I was occupied with my primary task these days and didn't have time for it. I will try to get to it today, but I don't believe that such a patch is holding up anything on this bug. 494831 17 abarth 2011-11-02 13:01:50 -0700 > What I was attempting to get at with my comment was that I didn't know what the type signature of the host was supposed to be (i.e., what the interface is). What things should be hung off the host, and what shouldn't? Generally, any object that reads or writes the environment (e.g., disk, network) should be obtained from the Host, either directly (as a property of the host) or from an object that was obtained from the host. For example, we could move SCM from Host to Checkout, which we get from the host. > Given that the Port class already has the mechanisms needed to catch layering violations (by taking the filesystem, user, executive objects directly), I don't want to lose that. That is what I am objecting to. As part of this process, we'd like to reduce the scope of things the Port needs to worry about. Today the Port object is concerned with a great many things that are unrelated to ports of WebKit. These concerns should be separated. That net result of that process is that much of the code that today holds a Port object will in the future hold a Host object. If it needs the Port, it can get it from the Host. > If we had some concept of a "SystemHost" (for lack of a better word) that was being passed to the port, that would be better. The generic Host could then contain a system_host as a field, rather than containing a filesystem, executive, etc. Alternatively (and less satisfactorily), the Host could derive from SystemHost. Yeah, in the future, we'll probably want to break the Host object down by layers. However, I don't think we should block this patch on that refactoring. > Yeah, sorry, I was occupied with my primary task these days and didn't have time for it. I will try to get to it today, but I don't believe that such a patch is holding up anything on this bug. Code should not be obtaining the Executive from the Port. The executive facilities of the environment are not related to ports of WebKit. Rather, that code should get the executive from the Host, which will require plumbing the Host object deeper into NRWT. Changing code to get the Executive from the Port might be worth doing, but we can also wait until Host is more prevalent throughout NRWT. 494915 18 dpranke 2011-11-02 14:34:09 -0700 (In reply to comment #17) > > What I was attempting to get at with my comment was that I didn't know what the type signature of the host was supposed to be (i.e., what the interface is). What things should be hung off the host, and what shouldn't? > > Generally, any object that reads or writes the environment (e.g., disk, network) should be obtained from the Host, either directly (as a property of the host) or from an object that was obtained from the host. For example, we could move SCM from Host to Checkout, which we get from the host. > To clarify, by "network" do you mean something like comon.system.url_fetcher or common.net.bugzilla.? I would normally call the latter a service, and the "net" is something of a misnomer (but terminology is not all that important as long as we understand each other). As I said before, Port implementations can depend on stuff in webkitpy.common.system but it's not clear to me that anything else should be allowed, and I am loathe to propagate coding patterns that will allow other dependencies to creep in unnoticed. > As part of this process, we'd like to reduce the scope of things the Port needs to worry about. Today the Port object is concerned with a great many things that are unrelated to ports of WebKit. These concerns should be separated. That net result of that process is that much of the code that today holds a Port object will in the future hold a Host object. If it needs the Port, it can get it from the Host. I have filed bug 71403 to track what we think should be split out from the Port object. While I believe that we all agree on the general claim, I would be very surprised if we agreed on the details. Please take a look and comment there :) > Code should not be obtaining the Executive from the Port. The executive facilities of the environment are not related to ports of WebKit. Agreed. At least under webkitpy.layout_tests, today no code does this. A perhaps slightly better example is the filesystem, which is referenced in a couple places and is the thing I was talking about fixing in the separate patch. > Rather, that code should get the executive from the Host, which will require plumbing the Host object deeper into NRWT. I think this is the part that we disagree about somewhat. I would say that code that needs an executive should be passed an executive, not passed a host from which it can get an executive. Accordingly, NRWT doesn't need to know about Hosts at all. That said, I obviously don't want to get into a situation where you have to pass 20 arguments to every constructor, so some form of aggregation is appropriate. I just don't believe in the "one Host to rule them all" aggregate. 494940 19 abarth 2011-11-02 14:56:04 -0700 > To clarify, by "network" do you mean something like comon.system.url_fetcher or common.net.bugzilla.? I would normally call the latter a service, and the "net" is something of a misnomer (but terminology is not all that important as long as we understand each other). Ideally, bugzilla would be built on top of a mockable abstraction of the network. Unfortunately, it's not, so using that class directly causes side effects. > I would say that code that needs an executive should be passed an executive, not passed a host from which it can get an executive. Yes. We disagree about that point. The design we've been using in webkitpy is to supply a Host in most cases. In some cases where it's clear only an executive will be needed, we pass just the Executive, but that's not the common case. 494967 20 eric 2011-11-02 15:25:38 -0700 I'm going to land this and start work on more cleanup. I'm glad we had this discussion! 494969 21 eric 2011-11-02 15:26:09 -0700 Committed r99106: <http://trac.webkit.org/changeset/99106> 113086 2011-10-31 14:16:32 -0700 2011-10-31 14:53:44 -0700 Patch bug-71237-20111031141631.patch text/plain 9009 eric U3VidmVyc2lvbiBSZXZpc2lvbjogOTg4NzcKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBi L1Rvb2xzL0NoYW5nZUxvZwppbmRleCBiY2E0YTIzZDUyODZhYjFkMWIxNDE4ZTllZGM4NWI4MGVl MTZiNWI0Li5kNTFlYzEyNTg4ZTU5NmMwYjcyNzYwNTJlMWI1YWRmNGYyY2ExYjE0IDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMjIg QEAKIDIwMTEtMTAtMzEgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCisgICAgICAg IEJhc2VsaW5lT3B0aW1pemVyIHRlc3RzIHNob3VsZCB1c2UgbW9ja3MgaW5zdGVhZCBvZiByZWFs IEV4ZWN1dGl2ZS9GaWxlU3lzdGVtIG9iamVjdHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTcxMjM3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQ2FsbGluZyB0aGUgc3RhdGljIHZlcnNpb24gb2YgZmFjdG9y eS5nZXQoKSB3aXRoIHByb3BlciBtb2NraW5nCisgICAgICAgIHJlcXVpcmVzIHBhc3NzaW5nIGFu IGV4cGxpY3QgZmlsZXN5c3RlbSwgZXhlY3V0aXZlLCBldGMuCisgICAgICAgIFNvIGluc3RlYWQs IHdlIHVzZSBhIFBvcnRGYWN0b3J5IGluc3RhbmNlIGFuZCBwYXNzIGl0IGEgSG9zdCBwb2ludGVy LgorICAgICAgICBJIGhhZCB0byBhZGQgYSBNb2NrSG9zdCBzaW5jZSB3ZSdkIG5vdCBuZWVkZWQg YSBub24taG9zdCB0b29sIGJlZm9yZSBub3cuCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGltaXplci5weToKKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGltaXplcl91bml0dGVzdC5weToK KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcmViYXNlbGluZS5weToK KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvbW9ja3Rvb2wucHk6CisKKzIwMTEtMTAt MzEgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCiAgICAgICAgIHdlYmtpdHB5IHRl c3RzIGRlcGVuZCB0b28gbXVjaCBvbiB0aGUgdXNlcidzIGVudmlyb25tZW50CiAgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MTIzNAogCmRpZmYgLS1naXQg YS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGltaXpl ci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Jhc2VsaW5lb3B0 aW1pemVyLnB5CmluZGV4IDEzZTViZDVjNmIxYjkzYzdiYzJjMDZmZDAxNjQwNDI0ZDFlY2IwOWQu LjAxZDYwZGQ1MTUzY2MzNWRlOGUyMDQ3MTc2ZmQ4MDdjZTIwYjc4NWUgMTAwNjQ0Ci0tLSBhL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Jhc2VsaW5lb3B0aW1pemVyLnB5 CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Jhc2VsaW5lb3B0 aW1pemVyLnB5CkBAIC0yNiwxMiArMjYsMTIgQEAKICMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCiAjIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCiAKLWZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQgaW1wb3J0IGZhY3RvcnkgYXMg cG9ydF9mYWN0b3J5Citmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0LmZhY3RvcnkgaW1w b3J0IFBvcnRGYWN0b3J5CiAKIAogIyBZZXMsIGl0J3MgYSBoeXBlcmdyYXBoLgogIyBGSVhNRTog U2hvdWxkIHRoaXMgZnVuY3Rpb24gbGl2ZSB3aXRoIHRoZSBwb3J0cyBzb21ld2hlcmU/Ci1kZWYg X2Jhc2VsaW5lX3NlYXJjaF9oeXBlcmdyYXBoKGZzKToKK2RlZiBfYmFzZWxpbmVfc2VhcmNoX2h5 cGVyZ3JhcGgoaG9zdCk6CiAgICAgaHlwZXJncmFwaCA9IHt9CiAKICAgICAjIFRoZXNlIGVkZ2Vz IGluIHRoZSBoeXBlcmdyYXBoIGFyZW4ndCB2aXNpYmxlIG9uIGJ1aWxkLndlYmtpdC5vcmcsCkBA IC00MiwxNCArNDIsMTMgQEAgZGVmIF9iYXNlbGluZV9zZWFyY2hfaHlwZXJncmFwaChmcyk6CiAg ICAgIyBGSVhNRTogU2hvdWxkIHdlIGdldCB0aGlzIGNvbnN0YW50IGZyb20gc29tZXdoZXJlPwog ICAgIGZhbGxiYWNrX3BhdGggPSBbJ0xheW91dFRlc3RzJ10KIAorICAgIHBvcnRfZmFjdG9yeSA9 IFBvcnRGYWN0b3J5KGhvc3QpCiAgICAgZm9yIHBvcnRfbmFtZSBpbiBwb3J0X2ZhY3RvcnkuYWxs X3BvcnRfbmFtZXMoKToKLSAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQgcGFzcyBVc2VyIGFu ZCBFeGVjdXRpdmUgYXMgd2VsbCB0byBhbGxvdyBmb3IgZWFzeSBtb2NraW5nLgotICAgICAgICAj IEFsdGVybmF0aXZlbHksIHdlIHNob3VsZCBnZXQgYSBwcmUtbW9ja2VkIFBvcnRGYWN0b3J5IGZy b20gdG9vbC4KLSAgICAgICAgcG9ydCA9IHBvcnRfZmFjdG9yeS5nZXQocG9ydF9uYW1lLCBmaWxl c3lzdGVtPWZzKQorICAgICAgICBwb3J0ID0gcG9ydF9mYWN0b3J5LmdldChwb3J0X25hbWUpCiAg ICAgICAgIHdlYmtpdF9iYXNlID0gcG9ydC53ZWJraXRfYmFzZSgpCiAgICAgICAgIHNlYXJjaF9w YXRoID0gcG9ydC5iYXNlbGluZV9zZWFyY2hfcGF0aCgpCiAgICAgICAgIGlmIHNlYXJjaF9wYXRo OgotICAgICAgICAgICAgaHlwZXJncmFwaFtwb3J0X25hbWVdID0gW2ZzLnJlbHBhdGgocGF0aCwg d2Via2l0X2Jhc2UpIGZvciBwYXRoIGluIHNlYXJjaF9wYXRoXSArIGZhbGxiYWNrX3BhdGgKKyAg ICAgICAgICAgIGh5cGVyZ3JhcGhbcG9ydF9uYW1lXSA9IFtob3N0LmZpbGVzeXN0ZW0ucmVscGF0 aChwYXRoLCB3ZWJraXRfYmFzZSkgZm9yIHBhdGggaW4gc2VhcmNoX3BhdGhdICsgZmFsbGJhY2tf cGF0aAogICAgIHJldHVybiBoeXBlcmdyYXBoCiAKIApAQCAtNjUsMTAgKzY0LDExIEBAIGRlZiBf aW52ZXJ0X2RpY3Rpb25hcnkoZGljdGlvbmFyeSk6CiAKIAogY2xhc3MgQmFzZWxpbmVPcHRpbWl6 ZXIob2JqZWN0KToKLSAgICBkZWYgX19pbml0X18oc2VsZiwgc2NtLCBmaWxlc3lzdGVtKToKLSAg ICAgICAgc2VsZi5fc2NtID0gc2NtCi0gICAgICAgIHNlbGYuX2ZpbGVzeXN0ZW0gPSBmaWxlc3lz dGVtCi0gICAgICAgIHNlbGYuX2h5cGVyZ3JhcGggPSBfYmFzZWxpbmVfc2VhcmNoX2h5cGVyZ3Jh cGgoc2VsZi5fZmlsZXN5c3RlbSkKKyAgICBkZWYgX19pbml0X18oc2VsZiwgaG9zdCk6CisgICAg ICAgIHNlbGYuX2hvc3QgPSBob3N0CisgICAgICAgIHNlbGYuX2ZpbGVzeXN0ZW0gPSBzZWxmLl9o b3N0LmZpbGVzeXN0ZW0KKyAgICAgICAgc2VsZi5fc2NtID0gc2VsZi5faG9zdC5zY20oKQorICAg ICAgICBzZWxmLl9oeXBlcmdyYXBoID0gX2Jhc2VsaW5lX3NlYXJjaF9oeXBlcmdyYXBoKHNlbGYu X2hvc3QpCiAgICAgICAgIHNlbGYuX2RpcmVjdG9yaWVzID0gcmVkdWNlKHNldC51bmlvbiwgbWFw KHNldCwgc2VsZi5faHlwZXJncmFwaC52YWx1ZXMoKSkpCiAKICAgICBkZWYgX3JlYWRfcmVzdWx0 c19ieV9kaXJlY3Rvcnkoc2VsZiwgYmFzZWxpbmVfbmFtZSk6CmRpZmYgLS1naXQgYS9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGltaXplcl91bml0dGVz dC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Jhc2VsaW5lb3B0 aW1pemVyX3VuaXR0ZXN0LnB5CmluZGV4IGJjZmU1MzJjODM2ZDM3NzkyOTg1NGRkNWY0ZjAwZGI0 ZmYzNWJkNjkuLjQ4YWZiZDRlNGUxZDE0NzhmMmRmZDcyZDU4ZThkY2NkMDllNmM1MWQgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Jhc2VsaW5lb3B0 aW1pemVyX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2No ZWNrb3V0L2Jhc2VsaW5lb3B0aW1pemVyX3VuaXR0ZXN0LnB5CkBAIC0zMSwxMiArMzEsMTIgQEAg aW1wb3J0IHVuaXR0ZXN0CiAKIGZyb20gd2Via2l0cHkuY29tbW9uLmNoZWNrb3V0LmJhc2VsaW5l b3B0aW1pemVyIGltcG9ydCBCYXNlbGluZU9wdGltaXplcgogZnJvbSB3ZWJraXRweS5jb21tb24u c3lzdGVtLmZpbGVzeXN0ZW1fbW9jayBpbXBvcnQgTW9ja0ZpbGVTeXN0ZW0KLWZyb20gd2Via2l0 cHkudG9vbC5tb2NrdG9vbCBpbXBvcnQgTW9ja1NDTQorZnJvbSB3ZWJraXRweS50b29sLm1vY2t0 b29sIGltcG9ydCBNb2NrSG9zdAogCiAKIGNsYXNzIFRlc3RCYXNlbGluZU9wdGltaXplcihCYXNl bGluZU9wdGltaXplcik6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIG1vY2tfcmVzdWx0c19ieV9k aXJlY3RvcnkpOgotICAgICAgICBCYXNlbGluZU9wdGltaXplci5fX2luaXRfXyhzZWxmLCBNb2Nr U0NNKCksIE1vY2tGaWxlU3lzdGVtKCkpCisgICAgICAgIEJhc2VsaW5lT3B0aW1pemVyLl9faW5p dF9fKHNlbGYsIE1vY2tIb3N0KCkpCiAgICAgICAgIHNlbGYuX21vY2tfcmVzdWx0c19ieV9kaXJl Y3RvcnkgPSBtb2NrX3Jlc3VsdHNfYnlfZGlyZWN0b3J5CiAKICAgICAjIFdlIG92ZXJyaWRlIHRo aXMgbWV0aG9kIGZvciB0ZXN0aW5nIHNvIHdlIGRvbid0IGhhdmUgdG8gY29uc3RydWN0IGFuCkBA IC01MiwxMSArNTIsMTEgQEAgY2xhc3MgQmFzZWxpbmVPcHRpbWl6ZXJUZXN0KHVuaXR0ZXN0LlRl c3RDYXNlKToKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChuZXdfcmVzdWx0c19ieV9kaXJlY3Rv cnksIGV4cGVjdGVkX25ld19yZXN1bHRzX2J5X2RpcmVjdG9yeSkKIAogICAgIGRlZiB0ZXN0X21v dmVfYmFzZWxpbmVzKHNlbGYpOgotICAgICAgICBmcyA9IE1vY2tGaWxlU3lzdGVtKCkKLSAgICAg ICAgZnMud3JpdGVfYmluYXJ5X2ZpbGUoJy9tb2NrLWNoZWNrb3V0L0xheW91dFRlc3RzL3BsYXRm b3JtL2Nocm9taXVtLXdpbi9hbm90aGVyL3Rlc3QtZXhwZWN0ZWQudHh0JywgJ3Jlc3VsdCBBJykK LSAgICAgICAgZnMud3JpdGVfYmluYXJ5X2ZpbGUoJy9tb2NrLWNoZWNrb3V0L0xheW91dFRlc3Rz L3BsYXRmb3JtL2Nocm9taXVtLWNnLW1hYy9hbm90aGVyL3Rlc3QtZXhwZWN0ZWQudHh0JywgJ3Jl c3VsdCBBJykKLSAgICAgICAgZnMud3JpdGVfYmluYXJ5X2ZpbGUoJy9tb2NrLWNoZWNrb3V0L0xh eW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2Fub3RoZXIvdGVzdC1leHBlY3RlZC50eHQnLCAn cmVzdWx0IEInKQotICAgICAgICBiYXNlbGluZV9vcHRpbWl6ZXIgPSBCYXNlbGluZU9wdGltaXpl cihNb2NrU0NNKCksIGZzKQorICAgICAgICBob3N0ID0gTW9ja0hvc3QoKQorICAgICAgICBob3N0 LmZpbGVzeXN0ZW0ud3JpdGVfYmluYXJ5X2ZpbGUoJy9tb2NrLWNoZWNrb3V0L0xheW91dFRlc3Rz L3BsYXRmb3JtL2Nocm9taXVtLXdpbi9hbm90aGVyL3Rlc3QtZXhwZWN0ZWQudHh0JywgJ3Jlc3Vs dCBBJykKKyAgICAgICAgaG9zdC5maWxlc3lzdGVtLndyaXRlX2JpbmFyeV9maWxlKCcvbW9jay1j aGVja291dC9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1jZy1tYWMvYW5vdGhlci90ZXN0 LWV4cGVjdGVkLnR4dCcsICdyZXN1bHQgQScpCisgICAgICAgIGhvc3QuZmlsZXN5c3RlbS53cml0 ZV9iaW5hcnlfZmlsZSgnL21vY2stY2hlY2tvdXQvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21p dW0vYW5vdGhlci90ZXN0LWV4cGVjdGVkLnR4dCcsICdyZXN1bHQgQicpCisgICAgICAgIGJhc2Vs aW5lX29wdGltaXplciA9IEJhc2VsaW5lT3B0aW1pemVyKGhvc3QpCiAgICAgICAgIGJhc2VsaW5l X29wdGltaXplci5fbW92ZV9iYXNlbGluZXMoJ2Fub3RoZXIvdGVzdC1leHBlY3RlZC50eHQnLCB7 CiAgICAgICAgICAgICAnTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0td2luJzogJ2FhYScs CiAgICAgICAgICAgICAnTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tY2ctbWFjJzogJ2Fh YScsCkBAIC02NCw3ICs2NCw3IEBAIGNsYXNzIEJhc2VsaW5lT3B0aW1pemVyVGVzdCh1bml0dGVz dC5UZXN0Q2FzZSk6CiAgICAgICAgIH0sIHsKICAgICAgICAgICAgICdMYXlvdXRUZXN0cy9wbGF0 Zm9ybS9jaHJvbWl1bSc6ICdhYWEnLAogICAgICAgICB9KQotICAgICAgICBzZWxmLmFzc2VydEVx dWFsKGZzLnJlYWRfYmluYXJ5X2ZpbGUoJy9tb2NrLWNoZWNrb3V0L0xheW91dFRlc3RzL3BsYXRm b3JtL2Nocm9taXVtL2Fub3RoZXIvdGVzdC1leHBlY3RlZC50eHQnKSwgJ3Jlc3VsdCBBJykKKyAg ICAgICAgc2VsZi5hc3NlcnRFcXVhbChob3N0LmZpbGVzeXN0ZW0ucmVhZF9iaW5hcnlfZmlsZSgn L21vY2stY2hlY2tvdXQvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vYW5vdGhlci90ZXN0 LWV4cGVjdGVkLnR4dCcpLCAncmVzdWx0IEEnKQogCiAgICAgZGVmIHRlc3RfY2hyb21pdW1fbGlu dXhfcmVkdW5kYW50X3dpdGhfd2luKHNlbGYpOgogICAgICAgICBzZWxmLl9hc3NlcnRPcHRpbWl6 YXRpb24oewpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRz L3JlYmFzZWxpbmUucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcmVi YXNlbGluZS5weQppbmRleCBiN2E5ZTYzMDJkODg1OGU3NTBjNGJmZmQ2MGJmMjdiMzU4YWI2MDcw Li5hM2JlYzcxODljN2JmYzUyMzc5MGU4YzNiNzMyYTVlNWRlZTcwN2E0IDEwMDY0NAotLS0gYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcmViYXNlbGluZS5weQorKysgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcmViYXNlbGluZS5weQpAQCAtMTE2 LDcgKzExNiw3IEBAIGNsYXNzIE9wdGltaXplQmFzZWxpbmVzKEFic3RyYWN0RGVjbGFyYXRpdmVD b21tYW5kKToKICAgICAgICAgcmV0dXJuIHNlbGYuX3Rvb2wuZmlsZXN5c3RlbS5yZWxwYXRoKGZp bGVfbmFtZSwgc2VsZi5fcG9ydC5sYXlvdXRfdGVzdHNfZGlyKCkpCiAKICAgICBkZWYgZXhlY3V0 ZShzZWxmLCBvcHRpb25zLCBhcmdzLCB0b29sKToKLSAgICAgICAgc2VsZi5fYmFzZWxpbmVfb3B0 aW1pemVyID0gQmFzZWxpbmVPcHRpbWl6ZXIodG9vbC5zY20oKSwgdG9vbC5maWxlc3lzdGVtKQor ICAgICAgICBzZWxmLl9iYXNlbGluZV9vcHRpbWl6ZXIgPSBCYXNlbGluZU9wdGltaXplcih0b29s KQogICAgICAgICBzZWxmLl9wb3J0ID0gZmFjdG9yeS5nZXQoImNocm9taXVtLXdpbi13aW43Iikg ICMgRklYTUU6IFRoaXMgc2hvdWxkIGJlIHNlbGVjdGFibGUuCiAKICAgICAgICAgZm9yIHRlc3Rf bmFtZSBpbiBtYXAoc2VsZi5fdG9fdGVzdF9uYW1lLCB0ZXN0X2ZpbGVzLmZpbmQoc2VsZi5fcG9y dCwgYXJncykpOgpAQCAtMTQ2LDcgKzE0Niw3IEBAIGNsYXNzIEFuYWx5emVCYXNlbGluZXMoQWJz dHJhY3REZWNsYXJhdGl2ZUNvbW1hbmQpOgogICAgICAgICByZXR1cm4gc2VsZi5fdG9vbC5maWxl c3lzdGVtLnJlbHBhdGgoZmlsZV9uYW1lLCBzZWxmLl9wb3J0LmxheW91dF90ZXN0c19kaXIoKSkK IAogICAgIGRlZiBleGVjdXRlKHNlbGYsIG9wdGlvbnMsIGFyZ3MsIHRvb2wpOgotICAgICAgICBz ZWxmLl9iYXNlbGluZV9vcHRpbWl6ZXIgPSBCYXNlbGluZU9wdGltaXplcih0b29sLnNjbSgpLCB0 b29sLmZpbGVzeXN0ZW0pCisgICAgICAgIHNlbGYuX2Jhc2VsaW5lX29wdGltaXplciA9IEJhc2Vs aW5lT3B0aW1pemVyKHRvb2wpCiAgICAgICAgIHNlbGYuX3BvcnQgPSBmYWN0b3J5LmdldCgiY2hy b21pdW0td2luLXdpbjciKSAgIyBGSVhNRTogVGhpcyBzaG91bGQgYmUgc2VsZWN0YWJsZS4KIAog ICAgICAgICBmb3IgdGVzdF9uYW1lIGluIG1hcChzZWxmLl90b190ZXN0X25hbWUsIHRlc3RfZmls ZXMuZmluZChzZWxmLl9wb3J0LCBhcmdzKSk6CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L3Rvb2wvbW9ja3Rvb2wucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvbW9j a3Rvb2wucHkKaW5kZXggOTM5NTA4NDI3YTNkMGJhODk3MGQ3MGI4OWQ4YmYzZTJiZmRkNjRhNC4u ZjcxM2FmNTQxZGNkMzU5YTVmYzEzMzdhNGZhNGU3NDVjYTkzMDM3ZiAxMDA2NDQKLS0tIGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS90b29sL21vY2t0b29sLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvdG9vbC9tb2NrdG9vbC5weQpAQCAtODM5LDcgKzgzOSw3IEBAIGNsYXNzIE1vY2tX ZWIob2JqZWN0KToKICAgICAgICAgcmV0dXJuICJNT0NLIFdlYiByZXN1bHQsIGNvbnZlcnQgNDA0 IHRvIE5vbmU9JXMiICUgY29udmVydF80MDRfdG9fTm9uZQogCiAKLWNsYXNzIE1vY2tUb29sKG9i amVjdCk6CitjbGFzcyBNb2NrSG9zdChvYmplY3QpOgogICAgIGRlZiBfX2luaXRfXyhzZWxmLCBs b2dfZXhlY3V0aXZlPUZhbHNlLCBleGVjdXRpdmVfdGhyb3dzX3doZW5fcnVuPU5vbmUpOgogICAg ICAgICBzZWxmLndha2V1cF9ldmVudCA9IHRocmVhZGluZy5FdmVudCgpCiAgICAgICAgIHNlbGYu YnVncyA9IE1vY2tCdWd6aWxsYSgpCkBAIC04NjgsNiArODY4LDkgQEAgY2xhc3MgTW9ja1Rvb2wo b2JqZWN0KToKICAgICBkZWYgY2hlY2tvdXQoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9j aGVja291dAogCisgICAgZGVmIHBvcnQoc2VsZik6CisgICAgICAgIHJldHVybiBzZWxmLl9wb3J0 CisKICAgICBkZWYgY2hyb21pdW1fYnVpbGRib3Qoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxm Ll9jaHJvbWl1bV9idWlsZGJvdAogCkBAIC04ODEsMTIgKzg4NCwxMSBAQCBjbGFzcyBNb2NrVG9v bChvYmplY3QpOgogICAgIGRlZiBpcmMoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9pcmMK IAorCitjbGFzcyBNb2NrVG9vbChNb2NrSG9zdCk6CiAgICAgZGVmIHBhdGgoc2VsZik6CiAgICAg ICAgIHJldHVybiAiZWNobyIKIAotICAgIGRlZiBwb3J0KHNlbGYpOgotICAgICAgICByZXR1cm4g c2VsZi5fcG9ydAotCiAKIGNsYXNzIE1vY2tCcm93c2VyKG9iamVjdCk6CiAgICAgcGFyYW1zID0g e30K 113087 2011-10-31 14:53:48 -0700 2022-02-27 23:47:19 -0800 Make our PortFactory mocking slightly more explicit bug-71237-20111031145347.patch text/plain 9652 eric U3VidmVyc2lvbiBSZXZpc2lvbjogOTg4NzcKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBi L1Rvb2xzL0NoYW5nZUxvZwppbmRleCBiY2E0YTIzZDUyODZhYjFkMWIxNDE4ZTllZGM4NWI4MGVl MTZiNWI0Li5kNTFlYzEyNTg4ZTU5NmMwYjcyNzYwNTJlMWI1YWRmNGYyY2ExYjE0IDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMjIg QEAKIDIwMTEtMTAtMzEgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCisgICAgICAg IEJhc2VsaW5lT3B0aW1pemVyIHRlc3RzIHNob3VsZCB1c2UgbW9ja3MgaW5zdGVhZCBvZiByZWFs IEV4ZWN1dGl2ZS9GaWxlU3lzdGVtIG9iamVjdHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTcxMjM3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQ2FsbGluZyB0aGUgc3RhdGljIHZlcnNpb24gb2YgZmFjdG9y eS5nZXQoKSB3aXRoIHByb3BlciBtb2NraW5nCisgICAgICAgIHJlcXVpcmVzIHBhc3NzaW5nIGFu IGV4cGxpY3QgZmlsZXN5c3RlbSwgZXhlY3V0aXZlLCBldGMuCisgICAgICAgIFNvIGluc3RlYWQs IHdlIHVzZSBhIFBvcnRGYWN0b3J5IGluc3RhbmNlIGFuZCBwYXNzIGl0IGEgSG9zdCBwb2ludGVy LgorICAgICAgICBJIGhhZCB0byBhZGQgYSBNb2NrSG9zdCBzaW5jZSB3ZSdkIG5vdCBuZWVkZWQg YSBub24taG9zdCB0b29sIGJlZm9yZSBub3cuCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGltaXplci5weToKKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGltaXplcl91bml0dGVzdC5weToK KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcmViYXNlbGluZS5weToK KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvbW9ja3Rvb2wucHk6CisKKzIwMTEtMTAt MzEgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCiAgICAgICAgIHdlYmtpdHB5IHRl c3RzIGRlcGVuZCB0b28gbXVjaCBvbiB0aGUgdXNlcidzIGVudmlyb25tZW50CiAgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MTIzNAogCmRpZmYgLS1naXQg YS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGltaXpl ci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Jhc2VsaW5lb3B0 aW1pemVyLnB5CmluZGV4IDEzZTViZDVjNmIxYjkzYzdiYzJjMDZmZDAxNjQwNDI0ZDFlY2IwOWQu LjRlNGRjNmM0OTFhMWM5OGQ1YjY5NDg2Y2QxM2Y5YmViMzNkYmVhM2EgMTAwNjQ0Ci0tLSBhL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Jhc2VsaW5lb3B0aW1pemVyLnB5 CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NoZWNrb3V0L2Jhc2VsaW5lb3B0 aW1pemVyLnB5CkBAIC0yNiwxMiArMjYsMTEgQEAKICMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCiAjIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCiAKLWZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQgaW1wb3J0IGZhY3RvcnkgYXMg cG9ydF9mYWN0b3J5Ci0KIAogIyBZZXMsIGl0J3MgYSBoeXBlcmdyYXBoLgogIyBGSVhNRTogU2hv dWxkIHRoaXMgZnVuY3Rpb24gbGl2ZSB3aXRoIHRoZSBwb3J0cyBzb21ld2hlcmU/Ci1kZWYgX2Jh c2VsaW5lX3NlYXJjaF9oeXBlcmdyYXBoKGZzKToKKyMgUGVyaGFwcyB0aGlzIHNob3VsZCBtb3Zl IG9udG8gUG9ydEZhY3Rvcnk/CitkZWYgX2Jhc2VsaW5lX3NlYXJjaF9oeXBlcmdyYXBoKGhvc3Qp OgogICAgIGh5cGVyZ3JhcGggPSB7fQogCiAgICAgIyBUaGVzZSBlZGdlcyBpbiB0aGUgaHlwZXJn cmFwaCBhcmVuJ3QgdmlzaWJsZSBvbiBidWlsZC53ZWJraXQub3JnLApAQCAtNDIsMTQgKzQxLDEz IEBAIGRlZiBfYmFzZWxpbmVfc2VhcmNoX2h5cGVyZ3JhcGgoZnMpOgogICAgICMgRklYTUU6IFNo b3VsZCB3ZSBnZXQgdGhpcyBjb25zdGFudCBmcm9tIHNvbWV3aGVyZT8KICAgICBmYWxsYmFja19w YXRoID0gWydMYXlvdXRUZXN0cyddCiAKKyAgICBwb3J0X2ZhY3RvcnkgPSBob3N0LnBvcnRfZmFj dG9yeQogICAgIGZvciBwb3J0X25hbWUgaW4gcG9ydF9mYWN0b3J5LmFsbF9wb3J0X25hbWVzKCk6 Ci0gICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIHBhc3MgVXNlciBhbmQgRXhlY3V0aXZlIGFz IHdlbGwgdG8gYWxsb3cgZm9yIGVhc3kgbW9ja2luZy4KLSAgICAgICAgIyBBbHRlcm5hdGl2ZWx5 LCB3ZSBzaG91bGQgZ2V0IGEgcHJlLW1vY2tlZCBQb3J0RmFjdG9yeSBmcm9tIHRvb2wuCi0gICAg ICAgIHBvcnQgPSBwb3J0X2ZhY3RvcnkuZ2V0KHBvcnRfbmFtZSwgZmlsZXN5c3RlbT1mcykKKyAg ICAgICAgcG9ydCA9IHBvcnRfZmFjdG9yeS5nZXQocG9ydF9uYW1lKQogICAgICAgICB3ZWJraXRf YmFzZSA9IHBvcnQud2Via2l0X2Jhc2UoKQogICAgICAgICBzZWFyY2hfcGF0aCA9IHBvcnQuYmFz ZWxpbmVfc2VhcmNoX3BhdGgoKQogICAgICAgICBpZiBzZWFyY2hfcGF0aDoKLSAgICAgICAgICAg IGh5cGVyZ3JhcGhbcG9ydF9uYW1lXSA9IFtmcy5yZWxwYXRoKHBhdGgsIHdlYmtpdF9iYXNlKSBm b3IgcGF0aCBpbiBzZWFyY2hfcGF0aF0gKyBmYWxsYmFja19wYXRoCisgICAgICAgICAgICBoeXBl cmdyYXBoW3BvcnRfbmFtZV0gPSBbaG9zdC5maWxlc3lzdGVtLnJlbHBhdGgocGF0aCwgd2Via2l0 X2Jhc2UpIGZvciBwYXRoIGluIHNlYXJjaF9wYXRoXSArIGZhbGxiYWNrX3BhdGgKICAgICByZXR1 cm4gaHlwZXJncmFwaAogCiAKQEAgLTY1LDEwICs2MywxMSBAQCBkZWYgX2ludmVydF9kaWN0aW9u YXJ5KGRpY3Rpb25hcnkpOgogCiAKIGNsYXNzIEJhc2VsaW5lT3B0aW1pemVyKG9iamVjdCk6Ci0g ICAgZGVmIF9faW5pdF9fKHNlbGYsIHNjbSwgZmlsZXN5c3RlbSk6Ci0gICAgICAgIHNlbGYuX3Nj bSA9IHNjbQotICAgICAgICBzZWxmLl9maWxlc3lzdGVtID0gZmlsZXN5c3RlbQotICAgICAgICBz ZWxmLl9oeXBlcmdyYXBoID0gX2Jhc2VsaW5lX3NlYXJjaF9oeXBlcmdyYXBoKHNlbGYuX2ZpbGVz eXN0ZW0pCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIGhvc3QpOgorICAgICAgICBzZWxmLl9ob3N0 ID0gaG9zdAorICAgICAgICBzZWxmLl9maWxlc3lzdGVtID0gc2VsZi5faG9zdC5maWxlc3lzdGVt CisgICAgICAgIHNlbGYuX3NjbSA9IHNlbGYuX2hvc3Quc2NtKCkKKyAgICAgICAgc2VsZi5faHlw ZXJncmFwaCA9IF9iYXNlbGluZV9zZWFyY2hfaHlwZXJncmFwaChob3N0KQogICAgICAgICBzZWxm Ll9kaXJlY3RvcmllcyA9IHJlZHVjZShzZXQudW5pb24sIG1hcChzZXQsIHNlbGYuX2h5cGVyZ3Jh cGgudmFsdWVzKCkpKQogCiAgICAgZGVmIF9yZWFkX3Jlc3VsdHNfYnlfZGlyZWN0b3J5KHNlbGYs IGJhc2VsaW5lX25hbWUpOgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21t b24vY2hlY2tvdXQvYmFzZWxpbmVvcHRpbWl6ZXJfdW5pdHRlc3QucHkgYi9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGltaXplcl91bml0dGVzdC5weQpp bmRleCBiY2ZlNTMyYzgzNmQzNzc5Mjk4NTRkZDVmNGYwMGRiNGZmMzViZDY5Li40MzI1MTBmNDIw ZjA1MjI0N2QyMGYxMDIxMmVmMzVlYTMzMmRjNTJmIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGltaXplcl91bml0dGVzdC5weQor KysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9iYXNlbGluZW9wdGlt aXplcl91bml0dGVzdC5weQpAQCAtMzEsMTIgKzMxLDE1IEBAIGltcG9ydCB1bml0dGVzdAogCiBm cm9tIHdlYmtpdHB5LmNvbW1vbi5jaGVja291dC5iYXNlbGluZW9wdGltaXplciBpbXBvcnQgQmFz ZWxpbmVPcHRpbWl6ZXIKIGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5maWxlc3lzdGVtX21v Y2sgaW1wb3J0IE1vY2tGaWxlU3lzdGVtCi1mcm9tIHdlYmtpdHB5LnRvb2wubW9ja3Rvb2wgaW1w b3J0IE1vY2tTQ00KK2Zyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQuZmFjdG9yeSBpbXBv cnQgUG9ydEZhY3RvcnkKK2Zyb20gd2Via2l0cHkudG9vbC5tb2NrdG9vbCBpbXBvcnQgTW9ja0hv c3QKIAogCiBjbGFzcyBUZXN0QmFzZWxpbmVPcHRpbWl6ZXIoQmFzZWxpbmVPcHRpbWl6ZXIpOgog ICAgIGRlZiBfX2luaXRfXyhzZWxmLCBtb2NrX3Jlc3VsdHNfYnlfZGlyZWN0b3J5KToKLSAgICAg ICAgQmFzZWxpbmVPcHRpbWl6ZXIuX19pbml0X18oc2VsZiwgTW9ja1NDTSgpLCBNb2NrRmlsZVN5 c3RlbSgpKQorICAgICAgICBob3N0ID0gTW9ja0hvc3QoKQorICAgICAgICBob3N0LnBvcnRfZmFj dG9yeSA9IFBvcnRGYWN0b3J5KGhvc3QpICAjIFdlIHdhbnQgYSByZWFsIFBvcnRGYWN0b3J5LCBi dXQgaXQgc2hvdWxkIHVzZSBtb2Nrcy4KKyAgICAgICAgQmFzZWxpbmVPcHRpbWl6ZXIuX19pbml0 X18oc2VsZiwgaG9zdCkKICAgICAgICAgc2VsZi5fbW9ja19yZXN1bHRzX2J5X2RpcmVjdG9yeSA9 IG1vY2tfcmVzdWx0c19ieV9kaXJlY3RvcnkKIAogICAgICMgV2Ugb3ZlcnJpZGUgdGhpcyBtZXRo b2QgZm9yIHRlc3Rpbmcgc28gd2UgZG9uJ3QgaGF2ZSB0byBjb25zdHJ1Y3QgYW4KQEAgLTUyLDEx ICs1NSwxMiBAQCBjbGFzcyBCYXNlbGluZU9wdGltaXplclRlc3QodW5pdHRlc3QuVGVzdENhc2Up OgogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKG5ld19yZXN1bHRzX2J5X2RpcmVjdG9yeSwgZXhw ZWN0ZWRfbmV3X3Jlc3VsdHNfYnlfZGlyZWN0b3J5KQogCiAgICAgZGVmIHRlc3RfbW92ZV9iYXNl bGluZXMoc2VsZik6Ci0gICAgICAgIGZzID0gTW9ja0ZpbGVTeXN0ZW0oKQotICAgICAgICBmcy53 cml0ZV9iaW5hcnlfZmlsZSgnL21vY2stY2hlY2tvdXQvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hy b21pdW0td2luL2Fub3RoZXIvdGVzdC1leHBlY3RlZC50eHQnLCAncmVzdWx0IEEnKQotICAgICAg ICBmcy53cml0ZV9iaW5hcnlfZmlsZSgnL21vY2stY2hlY2tvdXQvTGF5b3V0VGVzdHMvcGxhdGZv cm0vY2hyb21pdW0tY2ctbWFjL2Fub3RoZXIvdGVzdC1leHBlY3RlZC50eHQnLCAncmVzdWx0IEEn KQotICAgICAgICBmcy53cml0ZV9iaW5hcnlfZmlsZSgnL21vY2stY2hlY2tvdXQvTGF5b3V0VGVz dHMvcGxhdGZvcm0vY2hyb21pdW0vYW5vdGhlci90ZXN0LWV4cGVjdGVkLnR4dCcsICdyZXN1bHQg QicpCi0gICAgICAgIGJhc2VsaW5lX29wdGltaXplciA9IEJhc2VsaW5lT3B0aW1pemVyKE1vY2tT Q00oKSwgZnMpCisgICAgICAgIGhvc3QgPSBNb2NrSG9zdCgpCisgICAgICAgIGhvc3QucG9ydF9m YWN0b3J5ID0gUG9ydEZhY3RvcnkoaG9zdCkgICMgV2Ugd2FudCBhIHJlYWwgUG9ydEZhY3Rvcnks IGJ1dCBpdCBzaG91bGQgdXNlIG1vY2tzLgorICAgICAgICBob3N0LmZpbGVzeXN0ZW0ud3JpdGVf YmluYXJ5X2ZpbGUoJy9tb2NrLWNoZWNrb3V0L0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVt LXdpbi9hbm90aGVyL3Rlc3QtZXhwZWN0ZWQudHh0JywgJ3Jlc3VsdCBBJykKKyAgICAgICAgaG9z dC5maWxlc3lzdGVtLndyaXRlX2JpbmFyeV9maWxlKCcvbW9jay1jaGVja291dC9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9jaHJvbWl1bS1jZy1tYWMvYW5vdGhlci90ZXN0LWV4cGVjdGVkLnR4dCcsICdy ZXN1bHQgQScpCisgICAgICAgIGhvc3QuZmlsZXN5c3RlbS53cml0ZV9iaW5hcnlfZmlsZSgnL21v Y2stY2hlY2tvdXQvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vYW5vdGhlci90ZXN0LWV4 cGVjdGVkLnR4dCcsICdyZXN1bHQgQicpCisgICAgICAgIGJhc2VsaW5lX29wdGltaXplciA9IEJh c2VsaW5lT3B0aW1pemVyKGhvc3QpCiAgICAgICAgIGJhc2VsaW5lX29wdGltaXplci5fbW92ZV9i YXNlbGluZXMoJ2Fub3RoZXIvdGVzdC1leHBlY3RlZC50eHQnLCB7CiAgICAgICAgICAgICAnTGF5 b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0td2luJzogJ2FhYScsCiAgICAgICAgICAgICAnTGF5 b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tY2ctbWFjJzogJ2FhYScsCkBAIC02NCw3ICs2OCw3 IEBAIGNsYXNzIEJhc2VsaW5lT3B0aW1pemVyVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAg ICAgIH0sIHsKICAgICAgICAgICAgICdMYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bSc6ICdh YWEnLAogICAgICAgICB9KQotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGZzLnJlYWRfYmluYXJ5 X2ZpbGUoJy9tb2NrLWNoZWNrb3V0L0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2Fub3Ro ZXIvdGVzdC1leHBlY3RlZC50eHQnKSwgJ3Jlc3VsdCBBJykKKyAgICAgICAgc2VsZi5hc3NlcnRF cXVhbChob3N0LmZpbGVzeXN0ZW0ucmVhZF9iaW5hcnlfZmlsZSgnL21vY2stY2hlY2tvdXQvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vYW5vdGhlci90ZXN0LWV4cGVjdGVkLnR4dCcpLCAn cmVzdWx0IEEnKQogCiAgICAgZGVmIHRlc3RfY2hyb21pdW1fbGludXhfcmVkdW5kYW50X3dpdGhf d2luKHNlbGYpOgogICAgICAgICBzZWxmLl9hc3NlcnRPcHRpbWl6YXRpb24oewpAQCAtMTMyLDYg KzEzNiw3IEBAIGNsYXNzIEJhc2VsaW5lT3B0aW1pemVyVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6 CiAKICAgICBkZWYgdGVzdF9jb21wbGV4X3NoYWRvd2luZyhzZWxmKToKICAgICAgICAgIyBUaGlz IHRlc3QgcmVsaWVzIG9uIE9TIHNwZWNpZmljIGZ1bmN0aW9uYWxpdHksIHNvIGl0IGRvZXNuJ3Qg d29yayBvbiBXaW5kb3dzLgorICAgICAgICAjIEZJWE1FOiBXaGF0IGZ1bmN0aW9uYWxpdHkgZG9l cyB0aGlzIHJlbHkgb24/ICBXaGVuIGNhbiB3ZSByZW1vdmUgdGhpcyBpZj8KICAgICAgICAgaWYg c3lzLnBsYXRmb3JtID09ICd3aW4zMic6CiAgICAgICAgICAgICByZXR1cm4KICAgICAgICAgc2Vs Zi5fYXNzZXJ0T3B0aW1pemF0aW9uKHsKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5lLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90 b29sL2NvbW1hbmRzL3JlYmFzZWxpbmUucHkKaW5kZXggYjdhOWU2MzAyZDg4NThlNzUwYzRiZmZk NjBiZjI3YjM1OGFiNjA3MC4uYTNiZWM3MTg5YzdiZmM1MjM3OTBlOGMzYjczMmE1ZTVkZWU3MDdh NCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3JlYmFz ZWxpbmUucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3JlYmFz ZWxpbmUucHkKQEAgLTExNiw3ICsxMTYsNyBAQCBjbGFzcyBPcHRpbWl6ZUJhc2VsaW5lcyhBYnN0 cmFjdERlY2xhcmF0aXZlQ29tbWFuZCk6CiAgICAgICAgIHJldHVybiBzZWxmLl90b29sLmZpbGVz eXN0ZW0ucmVscGF0aChmaWxlX25hbWUsIHNlbGYuX3BvcnQubGF5b3V0X3Rlc3RzX2RpcigpKQog CiAgICAgZGVmIGV4ZWN1dGUoc2VsZiwgb3B0aW9ucywgYXJncywgdG9vbCk6Ci0gICAgICAgIHNl bGYuX2Jhc2VsaW5lX29wdGltaXplciA9IEJhc2VsaW5lT3B0aW1pemVyKHRvb2wuc2NtKCksIHRv b2wuZmlsZXN5c3RlbSkKKyAgICAgICAgc2VsZi5fYmFzZWxpbmVfb3B0aW1pemVyID0gQmFzZWxp bmVPcHRpbWl6ZXIodG9vbCkKICAgICAgICAgc2VsZi5fcG9ydCA9IGZhY3RvcnkuZ2V0KCJjaHJv bWl1bS13aW4td2luNyIpICAjIEZJWE1FOiBUaGlzIHNob3VsZCBiZSBzZWxlY3RhYmxlLgogCiAg ICAgICAgIGZvciB0ZXN0X25hbWUgaW4gbWFwKHNlbGYuX3RvX3Rlc3RfbmFtZSwgdGVzdF9maWxl cy5maW5kKHNlbGYuX3BvcnQsIGFyZ3MpKToKQEAgLTE0Niw3ICsxNDYsNyBAQCBjbGFzcyBBbmFs eXplQmFzZWxpbmVzKEFic3RyYWN0RGVjbGFyYXRpdmVDb21tYW5kKToKICAgICAgICAgcmV0dXJu IHNlbGYuX3Rvb2wuZmlsZXN5c3RlbS5yZWxwYXRoKGZpbGVfbmFtZSwgc2VsZi5fcG9ydC5sYXlv dXRfdGVzdHNfZGlyKCkpCiAKICAgICBkZWYgZXhlY3V0ZShzZWxmLCBvcHRpb25zLCBhcmdzLCB0 b29sKToKLSAgICAgICAgc2VsZi5fYmFzZWxpbmVfb3B0aW1pemVyID0gQmFzZWxpbmVPcHRpbWl6 ZXIodG9vbC5zY20oKSwgdG9vbC5maWxlc3lzdGVtKQorICAgICAgICBzZWxmLl9iYXNlbGluZV9v cHRpbWl6ZXIgPSBCYXNlbGluZU9wdGltaXplcih0b29sKQogICAgICAgICBzZWxmLl9wb3J0ID0g ZmFjdG9yeS5nZXQoImNocm9taXVtLXdpbi13aW43IikgICMgRklYTUU6IFRoaXMgc2hvdWxkIGJl IHNlbGVjdGFibGUuCiAKICAgICAgICAgZm9yIHRlc3RfbmFtZSBpbiBtYXAoc2VsZi5fdG9fdGVz dF9uYW1lLCB0ZXN0X2ZpbGVzLmZpbmQoc2VsZi5fcG9ydCwgYXJncykpOgpkaWZmIC0tZ2l0IGEv VG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL21vY2t0b29sLnB5IGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS90b29sL21vY2t0b29sLnB5CmluZGV4IDkzOTUwODQyN2EzZDBiYTg5NzBkNzBiODlk OGJmM2UyYmZkZDY0YTQuLmY3MTNhZjU0MWRjZDM1OWE1ZmMxMzM3YTRmYTRlNzQ1Y2E5MzAzN2Yg MTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9tb2NrdG9vbC5weQorKysg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvbW9ja3Rvb2wucHkKQEAgLTgzOSw3ICs4Mzks NyBAQCBjbGFzcyBNb2NrV2ViKG9iamVjdCk6CiAgICAgICAgIHJldHVybiAiTU9DSyBXZWIgcmVz dWx0LCBjb252ZXJ0IDQwNCB0byBOb25lPSVzIiAlIGNvbnZlcnRfNDA0X3RvX05vbmUKIAogCi1j bGFzcyBNb2NrVG9vbChvYmplY3QpOgorY2xhc3MgTW9ja0hvc3Qob2JqZWN0KToKICAgICBkZWYg X19pbml0X18oc2VsZiwgbG9nX2V4ZWN1dGl2ZT1GYWxzZSwgZXhlY3V0aXZlX3Rocm93c193aGVu X3J1bj1Ob25lKToKICAgICAgICAgc2VsZi53YWtldXBfZXZlbnQgPSB0aHJlYWRpbmcuRXZlbnQo KQogICAgICAgICBzZWxmLmJ1Z3MgPSBNb2NrQnVnemlsbGEoKQpAQCAtODY4LDYgKzg2OCw5IEBA IGNsYXNzIE1vY2tUb29sKG9iamVjdCk6CiAgICAgZGVmIGNoZWNrb3V0KHNlbGYpOgogICAgICAg ICByZXR1cm4gc2VsZi5fY2hlY2tvdXQKIAorICAgIGRlZiBwb3J0KHNlbGYpOgorICAgICAgICBy ZXR1cm4gc2VsZi5fcG9ydAorCiAgICAgZGVmIGNocm9taXVtX2J1aWxkYm90KHNlbGYpOgogICAg ICAgICByZXR1cm4gc2VsZi5fY2hyb21pdW1fYnVpbGRib3QKIApAQCAtODgxLDEyICs4ODQsMTEg QEAgY2xhc3MgTW9ja1Rvb2wob2JqZWN0KToKICAgICBkZWYgaXJjKHNlbGYpOgogICAgICAgICBy ZXR1cm4gc2VsZi5faXJjCiAKKworY2xhc3MgTW9ja1Rvb2woTW9ja0hvc3QpOgogICAgIGRlZiBw YXRoKHNlbGYpOgogICAgICAgICByZXR1cm4gImVjaG8iCiAKLSAgICBkZWYgcG9ydChzZWxmKToK LSAgICAgICAgcmV0dXJuIHNlbGYuX3BvcnQKLQogCiBjbGFzcyBNb2NrQnJvd3NlcihvYmplY3Qp OgogICAgIHBhcmFtcyA9IHt9Cg==