60605 2011-05-10 20:18:58 -0700 [NRWT] Reftests should run even when pixel tests are disabled. 2011-11-15 14:30:28 -0800 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 72038 36065 71779 1 hayato tony abarth ap aroben cshu dpranke eric mrobinson ojan ossy rniwa simon.fraser tony webkit.review.bot oldest_to_newest 401731 0 hayato 2011-05-10 20:18:58 -0700 In current implementation of reftests, reftests don't run if pixel tests are disabled. Which was introduced in http://trac.webkit.org/changeset/86126 as a temporary fix to avoid giving wrong test results. It is confusing for end-users that '--pixel-tests' command line option affects the behavior of reftests. We should run reftests regardless of whether 'pixel tests' are enabled or not. 482727 1 eric 2011-10-12 14:35:16 -0700 Do we still have ref tests? 482752 2 dpranke 2011-10-12 14:50:38 -0700 Yes. 482758 3 eric 2011-10-12 14:52:15 -0700 How many reftests do we have, and can we have more of them? :) 482761 4 dpranke 2011-10-12 14:54:25 -0700 I believe less than a handful, and I believe we were gating reftests on converting everyone over to NRWT (or at least getting critical mass). I would suggest that as soon as the WK2 bots are running NRWT, that's good enough (since I think that would just leave the win bot running ORWT). 482765 5 eric 2011-10-12 14:56:32 -0700 Sounds good. I'll polish up my -2 patch for NRWT once I fix bug 69899. 495143 6 ojan 2011-11-02 18:58:11 -0700 *** Bug 71158 has been marked as a duplicate of this bug. *** 497696 7 rniwa 2011-11-07 20:17:16 -0800 I'm concerned that running reftests as implemented now might be as slow as running pixel tests. If that were the case, then always enabling reftests defeats the point of not running pixel tests (fast cycle time). Do we have data to suggest otherwise? (i.e. running reftests is as fast as running render tree dump tests) Or are we going to compare render tree dumps when -p is not passed? 497704 8 dpranke 2011-11-07 20:38:06 -0800 (In reply to comment #7) > I'm concerned that running reftests as implemented now might be as slow as running pixel tests. If that were the case, then always enabling reftests defeats the point of not running pixel tests (fast cycle time). > > Do we have data to suggest otherwise? (i.e. running reftests is as fast as running render tree dump tests) Or are we going to compare render tree dumps when -p is not passed? I have always assumed that people don't run pixel tests because the pixel tests fail (the png's aren't correct), not that they were too slow. Hence, I support this change. It is possible that they were slower with ORWT, but given NRWT running with more than one thread, this would seem like not much of an issue. That said, I assume running reftests are significantly slower than either pixel tests or text-only tests, since we have to do double the work. 497711 9 rniwa 2011-11-07 21:01:46 -0800 (In reply to comment #8) > I have always assumed that people don't run pixel tests because the pixel tests fail (the png's aren't correct), not that they were too slow. Hence, I support this change. The last time I checked generating/comparing pixel tests were significantly slower than generating/comparing render tree dumps. > It is possible that they were slower with ORWT, but given NRWT running with more than one thread, this would seem like not much of an issue. Possible. It'll be nice to get numbers. 497742 10 dpranke 2011-11-07 22:17:57 -0800 (In reply to comment #9) > (In reply to comment #8) > > I have always assumed that people don't run pixel tests because the pixel tests fail (the png's aren't correct), not that they were too slow. Hence, I support this change. > > The last time I checked generating/comparing pixel tests were significantly slower than generating/comparing render tree dumps. Yes, I am sure that this is true. > > > It is possible that they were slower with ORWT, but given NRWT running with more than one thread, this would seem like not much of an issue. > > Possible. It'll be nice to get numbers. I think you're missing my point; I've never heard anyone say that they skip pixel tests w/ NRWT because they're too slow. Possibly this was true with ORWT, but given how much faster NRWT can be than ORWT, I don't think it matters all that much. If someone is worried about cycle time, there are lots of things we can do to improve the cycle time; we should not let that be an argument against getting people to write reftests instead of pixel tests, given the other benefits that they will bring. 497744 11 rniwa 2011-11-07 22:22:08 -0800 (In reply to comment #10) > (In reply to comment #9) > > Possible. It'll be nice to get numbers. > > I think you're missing my point; I've never heard anyone say that they skip pixel tests w/ NRWT because they're too slow. I do that because multi-processing isn't enabled on Mac port by default. > we should not let that be an argument against getting people to write reftests instead of pixel tests, given the other benefits that they will bring. I'm not but we certainly need to enable ref tests when -p is not passed because bots don't use -p. Also, I'm inclined to think that we might be better off generating and comparing render tree dump when -p is not passed. 497777 12 ojan 2011-11-07 23:30:19 -0800 Pixel tests were disabled because they were hard to maintain due to subtle platform differences and lots of pixel results changing for small changes. Neither of these problems is true for reftests. Reftests are likely slower than non-reftests, but I don't expect that this would block turning them on by default. Certainly, noone on webkit-dev seems opposed to it. 497793 13 hayato 2011-11-07 23:55:49 -0800 Let me loop in. Apart from the discussion, I guess no one is working on to run reftests even if '-p' is not passed, right? If so, let me start to implement it. If '-p' is given, we run *traditional* pixel tests and run also reftests. If '-p' is not given, we don't run *traditional* pixel tests, but reftests should be run. Reftests should be run in both cases. Maybe we should have additional cmd line option, e.g. '--run-reftests', but it should be 'on' by default, shouldn't we? (In reply to comment #12) > Pixel tests were disabled because they were hard to maintain due to subtle platform differences and lots of pixel results changing for small changes. Neither of these problems is true for reftests. > > Reftests are likely slower than non-reftests, but I don't expect that this would block turning them on by default. Certainly, noone on webkit-dev seems opposed to it. 497794 14 rniwa 2011-11-07 23:58:16 -0800 (In reply to comment #13) > If '-p' is given, we run *traditional* pixel tests and run also reftests. > If '-p' is not given, we don't run *traditional* pixel tests, but reftests should be run. > Reftests should be run in both cases. Right. > Maybe we should have additional cmd line option, e.g. '--run-reftests', but it should be 'on' by default, shouldn't we? Agreed. But I think it's worth hearing what other ports' contributors feel about doing png comparison vs. render tree dump comparison. 498104 15 ojan 2011-11-08 08:40:29 -0800 (In reply to comment #14) > (In reply to comment #13) > > If '-p' is given, we run *traditional* pixel tests and run also reftests. > > If '-p' is not given, we don't run *traditional* pixel tests, but reftests should be run. > > Reftests should be run in both cases. > > Right. Yup. > > Maybe we should have additional cmd line option, e.g. '--run-reftests', but it should be 'on' by default, shouldn't we? > > Agreed. > > But I think it's worth hearing what other ports' contributors feel about doing png comparison vs. render tree dump comparison. I think my email to webkit-dev about turning reftests on by default was sufficient. Everyone who chimed in supports doing it and noone objected. Is there a port your concerned about? 498105 16 mrobinson 2011-11-08 08:43:38 -0800 (In reply to comment #15) > I think my email to webkit-dev about turning reftests on by default was sufficient. Everyone who chimed in supports doing it and noone objected. Is there a port your concerned about? Speaking from the perspective of one of the ports that has pixel tests support, but does not have pixel tests enabled, I like the idea of reftests by default. 498633 17 rniwa 2011-11-08 21:21:19 -0800 Per IRC discusion, we've agreed to run "traditional" reftests even when -p is not passed. 499246 18 114341 tony 2011-11-09 12:23:58 -0800 Created attachment 114341 Patch 499254 19 114341 rniwa 2011-11-09 12:31:53 -0800 Comment on attachment 114341 Patch Don't you need to pass -p to DRT? 499344 20 114341 tony 2011-11-09 14:09:54 -0800 Comment on attachment 114341 Patch Ryosuke is right, this says pass but doesn't run the test. 499352 21 rniwa 2011-11-09 14:22:47 -0800 (In reply to comment #20) > (From update of attachment 114341 [details]) > Ryosuke is right, this says pass but doesn't run the test. We should probably return MISSING result in such cases. 499669 22 hayato 2011-11-09 22:59:34 -0800 The problem is that we have to pass an option, like '--pixel-tests=.../png_result_x.png', to DRT for reftests, but we should not pass such an option to other non-pixel tests because it impacts the performance. Because DRT requires to take such option at startup, we cannot share one DRT instance between reftests and other non-pixel tests. Is there any way to solve this issue without modifying each DRT port? I am thinking that we should separate DRT instance so that some DRT instances are only used for reftests. But I am not sure this is a good idea... 499691 23 hayato 2011-11-09 23:55:23 -0800 Maybe I am too worrying about the performance since chromium port always use '--pixel-tests' and no one doesn't complain about the performance with NRWT in chromium port. Does anyone have data about other ports? (In reply to comment #22) > The problem is that we have to pass an option, like '--pixel-tests=.../png_result_x.png', to DRT for reftests, but we should not pass such an option to other non-pixel tests because it impacts the performance. > Because DRT requires to take such option at startup, we cannot share one DRT instance between reftests and other non-pixel tests. > Is there any way to solve this issue without modifying each DRT port? > I am thinking that we should separate DRT instance so that some DRT instances are only used for reftests. But I am not sure this is a good idea... 500004 24 tony 2011-11-10 09:40:37 -0800 Sorry, here's my plan: 1) Refactor Driver so start() is call lazily rather than having to manually call it from Worker. 2) When a Worker is created, create 2 Drivers (one with pixel tests one without). 3) Pass both drivers to single_test_runner. 4) In single_test_runner, use the correct driver depending on which test is needed. This means that each worker may start 2 DRT instances, but only use one at a time. This would result in a few more DRT instances hanging around (and a bit more memory), but that seems OK. If running with pixel tests enabled, we would only have 1 DRT instance per worker. I'm going to split this work into 3 patches. 500013 25 rniwa 2011-11-10 09:52:25 -0800 (In reply to comment #24) > 1) Refactor Driver so start() is call lazily rather than having to manually call it from Worker. > 2) When a Worker is created, create 2 Drivers (one with pixel tests one without). > 3) Pass both drivers to single_test_runner. > 4) In single_test_runner, use the correct driver depending on which test is needed. > > This means that each worker may start 2 DRT instances, but only use one at a time. Does this mean that those 2 instances are created lazily? 500017 26 tony 2011-11-10 09:58:16 -0800 (In reply to comment #25) > (In reply to comment #24) > > 1) Refactor Driver so start() is call lazily rather than having to manually call it from Worker. > > 2) When a Worker is created, create 2 Drivers (one with pixel tests one without). > > 3) Pass both drivers to single_test_runner. > > 4) In single_test_runner, use the correct driver depending on which test is needed. > > > > This means that each worker may start 2 DRT instances, but only use one at a time. > > Does this mean that those 2 instances are created lazily? Correct. If a worker doesn't have any ref tests, it will only have 1 DRT instance. 500116 27 dpranke 2011-11-10 12:20:09 -0800 (In reply to comment #24) > Sorry, here's my plan: > > 1) Refactor Driver so start() is call lazily rather than having to manually call it from Worker. > 2) When a Worker is created, create 2 Drivers (one with pixel tests one without). > 3) Pass both drivers to single_test_runner. > 4) In single_test_runner, use the correct driver depending on which test is needed. > > This means that each worker may start 2 DRT instances, but only use one at a time. This would result in a few more DRT instances hanging around (and a bit more memory), but that seems OK. If running with pixel tests enabled, we would only have 1 DRT instance per worker. > > I'm going to split this work into 3 patches. Correct me if I'm wrong, but this isn't "a few" more instances, this is 2x the instances, right? i.e., if I'm running w/ 8 workers, I will have up to 16 DRTs (although at most 8 of them doing something at any one time)? Rather than doing this, you could perhaps restart DRT if it needs to switch between "wants pixel tests" and doesn't want pixel tests. This seems a bit conceptually simpler, although it might be slightly slower. 500140 28 eric 2011-11-10 12:33:38 -0800 We also could simply add a command to DRTs to allow them to dump certain tests as pixel tests. pixel testing isn't stateful. Since DRT already is (sorta) speaking http, think of it like requesting a differnet page on the same server. :) 500144 29 dpranke 2011-11-10 12:37:53 -0800 (In reply to comment #28) > We also could simply add a command to DRTs to allow them to dump certain tests as pixel tests. pixel testing isn't stateful. Since DRT already is (sorta) speaking http, think of it like requesting a differnet page on the same server. :) True. We already pass the image has we're expecting for each test, so either passing in a magic value or another parameter would do the trick. 500149 30 tony 2011-11-10 12:39:49 -0800 (In reply to comment #27) > Correct me if I'm wrong, but this isn't "a few" more instances, this is 2x the instances, right? i.e., if I'm running w/ 8 workers, I will have up to 16 DRTs (although at most 8 of them doing something at any one time)? Correct, but only if all workers hit a ref test. Currently, that means a few more DRTs, but in the future, it probably means 2x instances. > Rather than doing this, you could perhaps restart DRT if it needs to switch between "wants pixel tests" and doesn't want pixel tests. This seems a bit conceptually simpler, although it might be slightly slower. I considered doing this first, but the abstraction makes it hard to do this. Worker creates DRT instances, but single_test_runner makes decisions about whether we have a ref test or not. It seemed more complicated (both conceptually and in code) to move this around. Also, the slowness could be pretty extreme since ref tests are mixed with non-ref tests. The extra memory use here should be minimal and memory is not currently a limiting factor in running layout tests. (In reply to comment #28) > We also could simply add a command to DRTs to allow them to dump certain tests as pixel tests. pixel testing isn't stateful. Since DRT already is (sorta) speaking http, think of it like requesting a differnet page on the same server. :) I considered this as well, but updating 4+ DRTs seems like more effort than it was worth. 500161 31 dpranke 2011-11-10 12:48:33 -0800 (In reply to comment #30) > I considered doing this first, but the abstraction makes it hard to do this. Worker creates DRT instances, but single_test_runner makes decisions about whether we have a ref test or not. It seemed more complicated (both conceptually and in code) to move this around. > Sorry, I meant that you could make the change in bug 72038, so that worker and single_test_runner get out of the start() business, and then you could decide whether you needed to restart DRT inside run_test as necessary. I think w/ the change in 72038, we can then play with the logic we want to use purely inside run_test(), so I don't feel strongly about the approach now. We can change it later if it turns out to matter. 500182 32 eric 2011-11-10 13:06:16 -0800 > (In reply to comment #28) > > We also could simply add a command to DRTs to allow them to dump certain tests as pixel tests. pixel testing isn't stateful. Since DRT already is (sorta) speaking http, think of it like requesting a differnet page on the same server. :) > > I considered this as well, but updating 4+ DRTs seems like more effort than it was worth. This is a huge barrier to entry we have. We need to continue to share more code between DRT instances. There is no reason they shouldn't all share the same main loop, in which case changes like this would be absolutely trivial. 500208 33 rniwa 2011-11-10 13:28:12 -0800 (In reply to comment #27) > Correct me if I'm wrong, but this isn't "a few" more instances, this is 2x the instances, right? i.e., if I'm running w/ 8 workers, I will have up to 16 DRTs (although at most 8 of them doing something at any one time)? I don't think this would be an issue. My machine isn't certainly going out of memory even if I had 30+ chrome renderers open. If we can't have 16 DRT instances on 8 core machines, we're definitely doing something wrong. Also DRT loads about:blank as soon as the test is finished to clear states. > Rather than doing this, you could perhaps restart DRT if it needs to switch between "wants pixel tests" and doesn't want pixel tests. This seems a bit conceptually simpler, although it might be slightly slower. I'm unsupportive of this approach given it might slow down nrwt. (In reply to comment #28) > We also could simply add a command to DRTs to allow them to dump certain tests as pixel tests. pixel testing isn't stateful. Since DRT already is (sorta) speaking http, think of it like requesting a differnet page on the same server. :) Mac port's DRT changes the color profile if pixel tests are enabled. This probably doesn't matter for reftests unless the test is dependent on the color profile configuration provided under --pixel.(In reply to comment #30) (In reply to comment #30) > I considered this as well, but updating 4+ DRTs seems like more effort than it was worth. And WebKitTestRunner for WebKit2. (In reply to comment #32) > This is a huge barrier to entry we have. We need to continue to share more code between DRT instances. There is no reason they shouldn't all share the same main loop, in which case changes like this would be absolutely trivial. I believe WebKit2 does that in WebKitTestRunner. 500545 34 hayato 2011-11-10 23:12:50 -0800 Instead of passing two drivers into single_test_runner, how about driver itself maintains two DRT instances, and use correct one inside of driver.run_test()? Although we have to add additional flag to DriverInput class so that driver can easily know which DRT should be used inside of its run_test, this make the implementation simpler, doesn't it? (In reply to comment #24) > Sorry, here's my plan: > > 1) Refactor Driver so start() is call lazily rather than having to manually call it from Worker. > 2) When a Worker is created, create 2 Drivers (one with pixel tests one without). > 3) Pass both drivers to single_test_runner. > 4) In single_test_runner, use the correct driver depending on which test is needed. > > This means that each worker may start 2 DRT instances, but only use one at a time. This would result in a few more DRT instances hanging around (and a bit more memory), but that seems OK. If running with pixel tests enabled, we would only have 1 DRT instance per worker. > > I'm going to split this work into 3 patches. 500554 35 rniwa 2011-11-10 23:38:28 -0800 (In reply to comment #34) > Instead of passing two drivers into single_test_runner, how about driver itself maintains two DRT instances, and use correct one inside of driver.run_test()? Although we have to add additional flag to DriverInput class so that driver can easily know which DRT should be used inside of its run_test, this make the implementation simpler, doesn't it? That sounds like a good idea. It also makes the transition easier if we ever wanted to make DRT natively support switching between two modes. 501195 36 114793 tony 2011-11-11 16:03:08 -0800 Created attachment 114793 Patch 501197 37 tony 2011-11-11 16:05:35 -0800 (In reply to comment #34) > Instead of passing two drivers into single_test_runner, how about driver itself maintains two DRT instances, and use correct one inside of driver.run_test()? Although we have to add additional flag to DriverInput class so that driver can easily know which DRT should be used inside of its run_test, this make the implementation simpler, doesn't it? This is a good idea. I made a new driver called RefTestDriver that handles this logic. I made a new driver to avoid having to make duplicate changes in ChromiumDriver and WebKitDriver which don't share that much right now. If the patch is too big to review but the design is OK, let me know and I can break it out into some smaller patches. 501573 38 hayato 2011-11-13 18:28:43 -0800 Before reviewing that, I'd like to confirm about new-run-webkit-test's behavior: Suppose these two conditions are met: 1. command line option, '--pixel-tests', is given 2. A test, 'foo.html', doesn't contain 'foo-expected.png', contains only 'foo-expected.txt'. In this case, current NRWT always uses DRT which started with '--pixel-tests=.../png_resultx.png' even for such a text-only test. I guess this affects the performance. Is this an intended behavior? If this is not a desired behavior, it might be good opportunity to change this behavior because now we can choose correct DRT at runtime for each test. 501582 39 rniwa 2011-11-13 19:48:56 -0800 (In reply to comment #38) > Before reviewing that, I'd like to confirm about new-run-webkit-test's behavior: > > Suppose these two conditions are met: > 1. command line option, '--pixel-tests', is given > 2. A test, 'foo.html', doesn't contain 'foo-expected.png', contains only 'foo-expected.txt'. > In this case, current NRWT always uses DRT which started with '--pixel-tests=.../png_resultx.png' even for such a text-only test. > I guess this affects the performance. Is this an intended behavior? I think it is intended. If the test author check-in .txt to cross-platform dir. and t hen .png to platform-specific dir., we'd still like to get .png out of DRT, right? 501586 40 hayato 2011-11-13 20:04:47 -0800 I meant that 'foo.html' doesn't have any '-expected.png' anywhere, either in cross-platform or platform-specific dir. We can judge that for each tests before calling driver.run_test for that test. (In reply to comment #39) > (In reply to comment #38) > > Before reviewing that, I'd like to confirm about new-run-webkit-test's behavior: > > > > Suppose these two conditions are met: > > 1. command line option, '--pixel-tests', is given > > 2. A test, 'foo.html', doesn't contain 'foo-expected.png', contains only 'foo-expected.txt'. > > In this case, current NRWT always uses DRT which started with '--pixel-tests=.../png_resultx.png' even for such a text-only test. > > I guess this affects the performance. Is this an intended behavior? > > I think it is intended. If the test author check-in .txt to cross-platform dir. and t hen .png to platform-specific dir., we'd still like to get .png out of DRT, right? 501589 41 rniwa 2011-11-13 20:14:10 -0800 (In reply to comment #40) > I meant that 'foo.html' doesn't have any '-expected.png' anywhere, either in cross-platform or platform-specific dir. We can judge that for each tests before calling driver.run_test for that test. That sounds like a reasonable idea if neither --rest-results nor --new-baseline is specified. But accessing many different directories itself could be expensive so it might be worth measuring the time. 501591 42 hayato 2011-11-13 20:23:29 -0800 Yeah. Actually, it seems that such accessing many different directories is already done in single_test_runner.driver_input(), which calls port.expected_checksum(), which checks each directories to retrieve correct 'expected' checksum. So this shouldn't increase the runtime cost. (In reply to comment #41) > (In reply to comment #40) > > I meant that 'foo.html' doesn't have any '-expected.png' anywhere, either in cross-platform or platform-specific dir. We can judge that for each tests before calling driver.run_test for that test. > > That sounds like a reasonable idea if neither --rest-results nor --new-baseline is specified. But accessing many different directories itself could be expensive so it might be worth measuring the time. 501593 43 hayato 2011-11-13 20:32:45 -0800 The point is: If ((test.is_reftest) or (('options.pixel_tests is true') and ('we can find an expected checksum for that test'))), we should use pixel_driver. The condition will be more complex because we should consider also 'options.new_baseline' and 'options.result_resutls'... (In reply to comment #42) > Yeah. Actually, it seems that such accessing many different directories is already done in single_test_runner.driver_input(), which calls port.expected_checksum(), which checks each directories to retrieve correct 'expected' checksum. So this shouldn't increase the runtime cost. > > (In reply to comment #41) > > (In reply to comment #40) > > > I meant that 'foo.html' doesn't have any '-expected.png' anywhere, either in cross-platform or platform-specific dir. We can judge that for each tests before calling driver.run_test for that test. > > > > That sounds like a reasonable idea if neither --rest-results nor --new-baseline is specified. But accessing many different directories itself could be expensive so it might be worth measuring the time. 502006 44 tony 2011-11-14 09:38:14 -0800 (In reply to comment #38) > Before reviewing that, I'd like to confirm about new-run-webkit-test's behavior: > > Suppose these two conditions are met: > 1. command line option, '--pixel-tests', is given > 2. A test, 'foo.html', doesn't contain 'foo-expected.png', contains only 'foo-expected.txt'. > In this case, current NRWT always uses DRT which started with '--pixel-tests=.../png_resultx.png' even for such a text-only test. > I guess this affects the performance. Is this an intended behavior? I don't think this affects performance. If layoutTestController.dumpAsText() is called, we don't compute the pixel results or write the png file. It shouldn't matter which DRT we pass a dumpAsText() test to. 502211 45 dpranke 2011-11-14 12:47:35 -0800 (In reply to comment #39) > I think it is intended. If the test author check-in .txt to cross-platform dir. and t hen .png to platform-specific dir., we'd still like to get .png out of DRT, right? Correct. In the absence of being able to determine that this is a text-only test, we have to assume that this is a pixel test and pass the correct flags to DRT (and assume that the PNG is simply MISSING). 502230 46 114793 dpranke 2011-11-14 13:09:13 -0800 Comment on attachment 114793 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=114793&action=review > Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py:130 > + return self._run_reftest() Can you restructure this function so that we test for reftests first, and use the same dummy/skip logic for both the case where we're rebasing or we're skipping the reftests? I think that can eliminate at least one branch and make the logic a little clearer. > Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py:311 > + assert(driver_output1.image_hash or driver_output2.image_hash) Why is this an OR and not an AND? I guess I'm not sure why you're allowed to assert anything here if it isn't an AND? > Tools/Scripts/webkitpy/layout_tests/port/chromium.py:257 > + return RefTestDriver(self, worker_number, ChromiumDriver) I think it might make more sense to make the "driver_instance_constructor" argument a separate property of the Port object, and then pull create_driver() up into base.Port, since the rest of the code is the same. Then you can insulate the port subclasses from the existence of the RefTestDriver (or whatever we end up calling it). > Tools/Scripts/webkitpy/layout_tests/port/driver.py:75 > + self._pixel_tests = force_pixel_results or (self._port and self._port.get_option('pixel_tests')) Nit: I think port should always be non-NULL, so you probably don't need that check? > Tools/Scripts/webkitpy/layout_tests/port/driver.py:104 > +class RefTestDriver: Nit: subclass from object. I think this design makes sense, but I'm not wild about the class name; it makes me think that this driver is geared specifically to ref tests, as opposed to a delegating proxy that picks the right driver depending on the test. Maybe rename this to something like "DriverProxy" (not that that is a great name either) and add a comment as to why it's necessary? > Tools/Scripts/webkitpy/layout_tests/port/driver.py:108 > + self._pixel_driver = self._driver I might rename this _reftest_driver instead of _pixel_driver, since the code is written to only use this field if the test is a reftest. > Tools/Scripts/webkitpy/layout_tests/port/driver.py:127 > + cmd_line += ['; '] + self._pixel_driver.cmd_line() This doesn't seem right (or perhaps safe) ... cmd_line() is used for logging but I think it is also to actually spawn the DRTs (e.g., when it's passed to ServerProcess in the webkit ports, and when MockDRT uses it). We might have to return a list of cmd lines or something instead. > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:444 > + Driver.__init__(self, port, worker_number, force_pixel_results) It would be good to add a comment or a docstring explaining what force_pixel_results is for. 502400 47 115047 tony 2011-11-14 15:46:27 -0800 Created attachment 115047 Patch 502409 48 114793 tony 2011-11-14 15:51:59 -0800 Comment on attachment 114793 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=114793&action=review I made all the suggested changes except those mentioned below. >> Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py:311 >> + assert(driver_output1.image_hash or driver_output2.image_hash) > > Why is this an OR and not an AND? I guess I'm not sure why you're allowed to assert anything here if it isn't an AND? Another way to write it would be "driver_output1.image_hash is not None and driver_output2.image_hash is not None". This was why it used to say PASS previously, we were getting no image hashes but None == None, so the test was passing. I could also return a test failure in this case, but I'm not sure that would be any clearer. >> Tools/Scripts/webkitpy/layout_tests/port/chromium.py:257 >> + return RefTestDriver(self, worker_number, ChromiumDriver) > > I think it might make more sense to make the "driver_instance_constructor" argument a separate property of the Port object, and then pull create_driver() up into base.Port, since the rest of the code is the same. Then you can insulate the port subclasses from the existence of the RefTestDriver (or whatever we end up calling it). I called it driver_class. >> Tools/Scripts/webkitpy/layout_tests/port/driver.py:75 >> + self._pixel_tests = force_pixel_results or (self._port and self._port.get_option('pixel_tests')) > > Nit: I think port should always be non-NULL, so you probably don't need that check? There were tests in base_unittests.py that passed in None for the port. I fixed the tests instead. >> Tools/Scripts/webkitpy/layout_tests/port/driver.py:127 >> + cmd_line += ['; '] + self._pixel_driver.cmd_line() > > This doesn't seem right (or perhaps safe) ... cmd_line() is used for logging but I think it is also to actually spawn the DRTs (e.g., when it's passed to ServerProcess in the webkit ports, and when MockDRT uses it). We might have to return a list of cmd lines or something instead. cmd_line() is only used to spawn DRTs within a driver (e.g., WebKitDriver uses it for that). It's safe to change it here because DriverProxy never calls cmd_line() directly. AFAICT, the API is only for logging. >> Tools/Scripts/webkitpy/layout_tests/port/webkit.py:444 >> + Driver.__init__(self, port, worker_number, force_pixel_results) > > It would be good to add a comment or a docstring explaining what force_pixel_results is for. Do you think we could name this param so no comment is needed? Maybe force_drt_to_dump_pixel_results or something? 502441 49 115047 dpranke 2011-11-14 16:21:23 -0800 Comment on attachment 115047 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=115047&action=review (In reply to comment #48) > >> Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py:311 > >> + assert(driver_output1.image_hash or driver_output2.image_hash) > > > > Why is this an OR and not an AND? I guess I'm not sure why you're allowed to assert anything here if it isn't an AND? > > Another way to write it would be "driver_output1.image_hash is not None and driver_output2.image_hash is not None". This was why it used to say PASS previously, we were getting no image hashes but None == None, so the test was passing. > Got it. > >> Tools/Scripts/webkitpy/layout_tests/port/driver.py:75 > >> + self._pixel_tests = force_pixel_results or (self._port and self._port.get_option('pixel_tests')) > > > > Nit: I think port should always be non-NULL, so you probably don't need that check? > > There were tests in base_unittests.py that passed in None for the port. I fixed the tests instead. > Great. > >> Tools/Scripts/webkitpy/layout_tests/port/driver.py:127 > >> + cmd_line += ['; '] + self._pixel_driver.cmd_line() > > > > This doesn't seem right (or perhaps safe) ... cmd_line() is used for logging but I think it is also to actually spawn the DRTs (e.g., when it's passed to ServerProcess in the webkit ports, and when MockDRT uses it). We might have to return a list of cmd lines or something instead. > > cmd_line() is only used to spawn DRTs within a driver (e.g., WebKitDriver uses it for that). It's safe to change it here because DriverProxy never calls cmd_line() directly. AFAICT, the API is only for logging. > Hmm. I'm not quite sure I follow you, but I'll take your word for it. > Tools/Scripts/webkitpy/layout_tests/port/driver.py:75 > + self._pixel_tests = force_pixel_results or self._port.get_option('pixel_tests') Thinking about this further ... can we rearrange this slightly so that the Driver doesn't need to know about self._port.get_option('pixel_tests')? I.e., since Drivers are now only constructed by Port.create_driver(), just modify that code to know whether this driver needs pixel_tests (and then we can just call this parameter pixel_tests). > Tools/Scripts/webkitpy/layout_tests/port/driver.py:114 > + self._reftest_driver = driver_instance_constructor(port, worker_number, force_pixel_results=True) See comments above ... I think we can restructure this so that force_pixel_tests can be renamed pixel_tests and we can explicitly tell the constructor whether we want pixel tests or not. 502595 50 hayato 2011-11-14 19:36:52 -0800 Thank you for the explanation. My understanding is that as long as a text-only test calls dumpAsText(), we don't have to worry about the performance even if we use DRT which starts with 'pixel-tests' option because it doesn't dump pixels at all. We can assume that all existing tests follow this rule. (In reply to comment #45) > (In reply to comment #39) > > I think it is intended. If the test author check-in .txt to cross-platform dir. and t hen .png to platform-specific dir., we'd still like to get .png out of DRT, right? > > Correct. In the absence of being able to determine that this is a text-only test, we have to assume that this is a pixel test and pass the correct flags to DRT (and assume that the PNG is simply MISSING). 502625 51 dpranke 2011-11-14 21:44:44 -0800 (In reply to comment #50) > Thank you for the explanation. > My understanding is that as long as a text-only test calls dumpAsText(), we don't have to worry about the performance even if we use DRT which starts with 'pixel-tests' option because it doesn't dump pixels at all. We can assume that all existing tests follow this rule. > Right. There is no performance hit caused by merely passing the flag along, and this is how all the existing tests work. 502632 52 rniwa 2011-11-14 22:03:23 -0800 As I talked about this with Tony, there's a subtle implication on color profile setting on Mac port. Mac port's DRT sets up the color profile at start and then tear it down when the program exists. Setting new color profile is extremely annoying and takes a long time (1-2s). 503052 53 simon.fraser 2011-11-15 10:53:12 -0800 We may no longer have to change the entire display profile; we should just be able to set a profile on the DRT window, now that Leopard is no longer an issue. 503056 54 rniwa 2011-11-15 10:57:51 -0800 (In reply to comment #53) > We may no longer have to change the entire display profile; we should just be able to set a profile on the DRT window, now that Leopard is no longer an issue. That's good to know! FYI, Chromium Mac port has a special script to set/unset color profile so resolving this issue on Mac port will let us move forward. 503081 55 115206 tony 2011-11-15 11:16:48 -0800 Created attachment 115206 Patch 503086 56 115047 tony 2011-11-15 11:17:47 -0800 Comment on attachment 115047 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=115047&action=review >>> Tools/Scripts/webkitpy/layout_tests/port/driver.py:75 >>> + self._pixel_tests = force_pixel_results or self._port.get_option('pixel_tests') >> >> Great. > > Thinking about this further ... can we rearrange this slightly so that the Driver doesn't need to know about self._port.get_option('pixel_tests')? I.e., since Drivers are now only constructed by Port.create_driver(), just modify that code to know whether this driver needs pixel_tests (and then we can just call this parameter pixel_tests). OK. 503134 57 115206 dpranke 2011-11-15 12:12:26 -0800 Comment on attachment 115206 Patch Almost there. This feels pretty clean to me, now. View in context: https://bugs.webkit.org/attachment.cgi?id=115206&action=review > Tools/Scripts/webkitpy/layout_tests/port/chromium.py:402 > + def __init__(self, port, worker_number, pixel_tests=False): Nit: I think you should remove the default value for pixel_tests. > Tools/Scripts/webkitpy/layout_tests/port/dryrun.py:103 > + return DryrunDriver(self, worker_number, pixel_tests=False) I think you can just delete this method and implement _driver_class(). I'm pretty sure this change would cause pixel tests to be ignored, which would be wrong. > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:443 > + def __init__(self, port, worker_number, pixel_tests=False): Nit: again, remove the default value. > Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:155 > + TestDriver.__init__(self, port, worker_number, pixel_tests=False) Nit: pass in pixel_tests instead, maybe? 503155 58 115219 tony 2011-11-15 12:34:28 -0800 Created attachment 115219 Patch 503158 59 115206 tony 2011-11-15 12:37:11 -0800 Comment on attachment 115206 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=115206&action=review >> Tools/Scripts/webkitpy/layout_tests/port/chromium.py:402 >> + def __init__(self, port, worker_number, pixel_tests=False): > > Nit: I think you should remove the default value for pixel_tests. I kept it here and in WebKitDriver because there are multiple callers that need to be updated that I hope are only tests. I would rather do that in a separate patch since this patch is already large and likely to break something even without making that change. >> Tools/Scripts/webkitpy/layout_tests/port/dryrun.py:103 >> + return DryrunDriver(self, worker_number, pixel_tests=False) > > I think you can just delete this method and implement _driver_class(). I'm pretty sure this change would cause pixel tests to be ignored, which would be wrong. OK. >> Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:155 >> + TestDriver.__init__(self, port, worker_number, pixel_tests=False) > > Nit: pass in pixel_tests instead, maybe? OK. 503231 60 dpranke 2011-11-15 13:54:23 -0800 (In reply to comment #59) > (From update of attachment 115206 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=115206&action=review > > >> Tools/Scripts/webkitpy/layout_tests/port/chromium.py:402 > >> + def __init__(self, port, worker_number, pixel_tests=False): > > > > Nit: I think you should remove the default value for pixel_tests. > > I kept it here and in WebKitDriver because there are multiple callers that need to be updated that I hope are only tests. I would rather do that in a separate patch since this patch is already large and likely to break something even without making that change. > Sure. Thanks for making all the changes. 503289 61 tony 2011-11-15 14:30:28 -0800 Committed r100326: <http://trac.webkit.org/changeset/100326> 114341 2011-11-09 12:23:58 -0800 2011-11-11 16:03:02 -0800 Patch bug-60605-20111109122411.patch text/plain 4328 tony U3VidmVyc2lvbiBSZXZpc2lvbjogOTk3NDAKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBi L1Rvb2xzL0NoYW5nZUxvZwppbmRleCA1YzQxOTM2ODI5MmRiYmViYmFhYWU3NDZiMzgyNzk4MDg5 NDQ2NGFkLi43MzhjYjM3ZTQ5MzY0N2E0YzZkODYzYjFkNDA5ZmM4ZDEzNjZkNmI0IDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYg QEAKKzIwMTEtMTEtMDkgIFRvbnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KKworICAgICAg ICBbTlJXVF0gUmVmdGVzdHMgc2hvdWxkIHJ1biBldmVuIHdoZW4gcGl4ZWwgdGVzdHMgYXJlIGRp c2FibGVkLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjA2MDUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBB bHNvIGFkZHMgYSAtLW5vLXJlZi10ZXN0cyBmbGFnIHRvIG1hbnVhbGx5IGRpc2FibGUgcmVmIHRl c3RzLgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxl cnMvc2luZ2xlX3Rlc3RfcnVubmVyLnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0c19pbnRlZ3JhdGlvbnRlc3QucHk6CisKIDIw MTEtMTEtMDkgIENocmlzIEZsZWl6YWNoICA8Y2ZsZWl6YWNoQGFwcGxlLmNvbT4KIAogICAgICAg ICBBWDogY3Jhc2ggd2hlbiBhY2Nlc3Npbmcgc2VsZWN0ZWRUYWIgaW4gYSB0YWIgbGlzdApkaWZm IC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMv c2luZ2xlX3Rlc3RfcnVubmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvY29udHJvbGxlcnMvc2luZ2xlX3Rlc3RfcnVubmVyLnB5CmluZGV4IGM0OWZhM2QyODFiYTRk MTViMTkwM2VkNWVkNDlmZTE0MmVlYWJhOWEuLjJhMWY0ODI1ZGNlODhiZTUyMjE2YWMxNzRhMTdj MjBmMTk0YmRlNzMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL2NvbnRyb2xsZXJzL3NpbmdsZV90ZXN0X3J1bm5lci5weQorKysgYi9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVzdF9ydW5uZXIucHkK QEAgLTEyMywxMSArMTIzLDExIEBAIGNsYXNzIFNpbmdsZVRlc3RSdW5uZXI6CiAgICAgICAgICAg ICBlbHNlOgogICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLl9ydW5fcmViYXNlbGluZSgpCiAg ICAgICAgIGlmIHNlbGYuX2lzX3JlZnRlc3Q6Ci0gICAgICAgICAgICBpZiBzZWxmLl9wb3J0Lmdl dF9vcHRpb24oJ3BpeGVsX3Rlc3RzJyk6Ci0gICAgICAgICAgICAgICAgcmV0dXJuIHNlbGYuX3J1 bl9yZWZ0ZXN0KCkKLSAgICAgICAgICAgIHJlc3VsdCA9IFRlc3RSZXN1bHQoc2VsZi5fdGVzdF9u YW1lKQotICAgICAgICAgICAgcmVzdWx0LnR5cGUgPSB0ZXN0X2V4cGVjdGF0aW9ucy5TS0lQCi0g ICAgICAgICAgICByZXR1cm4gcmVzdWx0CisgICAgICAgICAgICBpZiBzZWxmLl9wb3J0LmdldF9v cHRpb24oJ25vX3JlZl90ZXN0cycpOgorICAgICAgICAgICAgICAgIHJlc3VsdCA9IFRlc3RSZXN1 bHQoc2VsZi5fdGVzdF9uYW1lKQorICAgICAgICAgICAgICAgIHJlc3VsdC50eXBlID0gdGVzdF9l eHBlY3RhdGlvbnMuU0tJUAorICAgICAgICAgICAgICAgIHJldHVybiByZXN1bHQKKyAgICAgICAg ICAgIHJldHVybiBzZWxmLl9ydW5fcmVmdGVzdCgpCiAgICAgICAgIHJldHVybiBzZWxmLl9ydW5f Y29tcGFyZV90ZXN0KCkKIAogICAgIGRlZiBfcnVuX2NvbXBhcmVfdGVzdChzZWxmKToKZGlmZiAt LWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVz dHMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rl c3RzLnB5CmluZGV4IDZkNjI3YjY0OGI3YTJkMmZhMWRmY2EzOWE0ZGMyOWY3ZWVhZTA4ZDAuLmVk NzhiMTJmYjIzNGNjYjhjODQxMzhkN2MyMmVmYzdiODEwNGQ0MjUgMTAwNzU1Ci0tLSBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKKysrIGIv VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQpA QCAtMjc0LDYgKzI3NCw4IEBAIGRlZiBwYXJzZV9hcmdzKGFyZ3M9Tm9uZSk6CiAgICAgICAgICAg ICBkZXN0PSJwaXhlbF90ZXN0cyIsIGhlbHA9IkRpc2FibGUgcGl4ZWwtdG8tcGl4ZWwgUE5HIGNv bXBhcmlzb25zIiksCiAgICAgICAgIG9wdHBhcnNlLm1ha2Vfb3B0aW9uKCItLW5vLXNhbXBsZS1v bi10aW1lb3V0IiwgYWN0aW9uPSJzdG9yZV9mYWxzZSIsCiAgICAgICAgICAgICBkZXN0PSJzYW1w bGVfb25fdGltZW91dCIsIGhlbHA9IkRvbid0IHJ1biBzYW1wbGUgb24gdGltZW91dCAoTWFjIE9T IFggb25seSkiKSwKKyAgICAgICAgb3B0cGFyc2UubWFrZV9vcHRpb24oIi0tbm8tcmVmLXRlc3Rz IiwgYWN0aW9uPSJzdG9yZV90cnVlIiwKKyAgICAgICAgICAgIGRlc3Q9Im5vX3JlZl90ZXN0cyIs IGhlbHA9IlNraXAgYWxsIHJlZiB0ZXN0cyIpLAogICAgICAgICBvcHRwYXJzZS5tYWtlX29wdGlv bigiLS10b2xlcmFuY2UiLAogICAgICAgICAgICAgaGVscD0iSWdub3JlIGltYWdlIGRpZmZlcmVu Y2VzIGxlc3MgdGhhbiB0aGlzIHBlcmNlbnRhZ2UgKHNvbWUgIgogICAgICAgICAgICAgICAgICJw b3J0cyBtYXkgaWdub3JlIHRoaXMgb3B0aW9uKSIsIHR5cGU9ImZsb2F0IiksCmRpZmYgLS1naXQg YS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX2lu dGVncmF0aW9udGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1 bl93ZWJraXRfdGVzdHNfaW50ZWdyYXRpb250ZXN0LnB5CmluZGV4IDFiNzA0YmMwNzRlYmFiOTUx YjQ4ZTI5N2MwMzM5MTk2OTJiZTI0N2QuLjk1NDVmOGUyNjIzNjQ0MTQ4NzE3MTYwMWQyMWM0MGI5 ZjIyNTIwM2EgMTAwNzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3J1bl93ZWJraXRfdGVzdHNfaW50ZWdyYXRpb250ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNfaW50ZWdyYXRpb250ZXN0LnB5 CkBAIC02ODEsOCArNjgxLDE0IEBAIGNsYXNzIE1haW5UZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToK ICAgICAgICAgdGVzdHNfcnVuID0gZ2V0X3Rlc3RzX3J1bihbJ3Bhc3Nlcy9yZWZ0ZXN0Lmh0bWwn XSwgdGVzdHNfaW5jbHVkZWQ9VHJ1ZSwgZmxhdHRlbl9iYXRjaGVzPVRydWUpCiAgICAgICAgIHNl bGYuYXNzZXJ0RXF1YWxzKFsncGFzc2VzL3JlZnRlc3QuaHRtbCddLCB0ZXN0c19ydW4pCiAKLSAg ICBkZWYgdGVzdF9yZWZ0ZXN0X3NraXBfcmVmdGVzdHNfaWZfcGl4ZWxfdGVzdHNfYXJlX2Rpc2Fi bGVkKHNlbGYpOgorICAgIGRlZiB0ZXN0X3JlZnRlc3RfcnVuX3JlZnRlc3RzX2lmX3BpeGVsX3Rl c3RzX2FyZV9kaXNhYmxlZChzZWxmKToKICAgICAgICAgdGVzdHNfcnVuID0gZ2V0X3Rlc3RzX3J1 bihbJy0tbm8tcGl4ZWwtdGVzdHMnLCAncGFzc2VzL3JlZnRlc3QuaHRtbCddLCB0ZXN0c19pbmNs dWRlZD1UcnVlLCBmbGF0dGVuX2JhdGNoZXM9VHJ1ZSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVh bHMoWydwYXNzZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX3J1bikKKworICAgIGRlZiB0ZXN0X3Jl ZnRlc3Rfc2tpcF9yZWZ0ZXN0c19pZl9ub19yZWZfdGVzdHMoc2VsZik6CisgICAgICAgIHRlc3Rz X3J1biA9IGdldF90ZXN0c19ydW4oWyctLW5vLXJlZi10ZXN0cycsICdwYXNzZXMvcmVmdGVzdC5o dG1sJ10sIHRlc3RzX2luY2x1ZGVkPVRydWUsIGZsYXR0ZW5fYmF0Y2hlcz1UcnVlKQorICAgICAg ICBzZWxmLmFzc2VydEVxdWFscyhbXSwgdGVzdHNfcnVuKQorICAgICAgICB0ZXN0c19ydW4gPSBn ZXRfdGVzdHNfcnVuKFsnLS1uby1yZWYtdGVzdHMnLCAnLS1uby1waXhlbC10ZXN0cycsICdwYXNz ZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX2luY2x1ZGVkPVRydWUsIGZsYXR0ZW5fYmF0Y2hlcz1U cnVlKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhbXSwgdGVzdHNfcnVuKQogCiAgICAgZGVm IHRlc3RfcmVmdGVzdF9leHBlY3RlZF9odG1sX3Nob3VsZF9iZV9pZ25vcmVkKHNlbGYpOgo= 114793 2011-11-11 16:03:08 -0800 2011-11-15 11:16:38 -0800 Patch bug-60605-20111111160322.patch text/plain 19280 tony U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMDExCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggOThlZmFkMjJkM2EwMjRkMGVjM2Q1NjUxZDgwN2IwNzI3 NDM0OTUyNC4uOTMwYzU2ZGNhZTUwM2M1MmU1YzY1Y2U2ZmQwMjQ4ZTQ1ZWFjOTUxNSAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0 IEBACisyMDExLTExLTExICBUb255IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgW05SV1RdIFJlZnRlc3RzIHNob3VsZCBydW4gZXZlbiB3aGVuIHBpeGVsIHRlc3RzIGFyZSBk aXNhYmxlZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTYwNjA1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVzdF9y dW5uZXIucHk6IE9ubHkgc2tpcCByZWYgdGVzdHMgaWYgLS1uby1yZWYtdGVzdHMgaXMgcGFzc2Vk LgorICAgICAgICAgICAgQWxzbyBhZGQgYW4gYXNzZXJ0IHRvIG1ha2Ugc3VyZSB3ZSBnZXQgaW1h Z2UgaGFzaGVzIGJhY2sgd2hlbiBydW5uaW5nIHJlZiB0ZXN0cy4KKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy93b3JrZXIucHk6IFVzZSBEcml2ZXIu aGFzX2NyYXNoZWQoKSBpbnN0ZWFkIG9mIHBvbGwoKS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2VfdW5pdHRlc3QucHk6CisgICAgICAgICogU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weTogVXNlIFJlZlRlc3REcml2 ZXIuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcml2ZXIu cHk6IEFkZCBSZWZUZXN0RHJpdmVyIHdoaWNoIGRvZXMgdGhlIHdvcmsKKyAgICAgICAgICAgIG9m IHN0YXJ0aW5nIGEgcGl4ZWwgZHJpdmVyIGlmIG5lZWRlZC4gIEl0IGhhbmRsZXMgdGhlIGxvZ2lj IG9mIHNlbmRpbmcgdGhlIHRlc3QKKyAgICAgICAgICAgIHRvIHRoZSBjb3JyZWN0IGRyaXZlci4g IEFsc28gcmVuYW1lZCBEcml2ZXIucG9sbCgpIHRvIERyaXZlci5oYXNfY3Jhc2hlZCgpLgorICAg ICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZHJ5cnVuLnB5OgorICAg ICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdC5weTogU3dpdGNo IHRvIHVzaW5nIFJlZlRlc3REcml2ZXIgc28gd2UgZ2V0IHRlc3QgY292ZXJhZ2UuCisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHk6IFVzZSBSZWZU ZXN0RHJpdmVyLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93 ZWJraXRfdGVzdHMucHk6IEFkZCAtLW5vLXJlZi10ZXN0cy4KKyAgICAgICAgKiBTY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX2ludGVncmF0aW9udGVzdC5weTog VGVzdCAtLW5vLXJlZi10ZXN0cy4KKwogMjAxMS0xMS0xMSAgUnlvc3VrZSBOaXdhICA8cm5pd2FA d2Via2l0Lm9yZz4KIAogICAgICAgICBNYWtlIENoYW5nZUxvZ0VudHJ5J3MgcmV2aWV3ZXIgcGFy c2luZyBhbGdvcml0aG0gc3VwcG9ydCBsYXN0IDQgV2ViQ29yZSBjaGFuZ2UgbG9ncwpkaWZmIC0t Z2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvc2lu Z2xlX3Rlc3RfcnVubmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv Y29udHJvbGxlcnMvc2luZ2xlX3Rlc3RfcnVubmVyLnB5CmluZGV4IGM0OWZhM2QyODFiYTRkMTVi MTkwM2VkNWVkNDlmZTE0MmVlYWJhOWEuLjBmMDczM2I5ZWE1YzhjN2UxNzI2MTkzNDAyNjNiMmJj NTcyZTcwOGQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L2NvbnRyb2xsZXJzL3NpbmdsZV90ZXN0X3J1bm5lci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVzdF9ydW5uZXIucHkKQEAg LTExMyw3ICsxMTMsNyBAQCBjbGFzcyBTaW5nbGVUZXN0UnVubmVyOgogICAgICAgICBpbWFnZV9o YXNoID0gTm9uZQogICAgICAgICBpZiBzZWxmLl9zaG91bGRfZmV0Y2hfZXhwZWN0ZWRfY2hlY2tz dW0oKToKICAgICAgICAgICAgIGltYWdlX2hhc2ggPSBzZWxmLl9wb3J0LmV4cGVjdGVkX2NoZWNr c3VtKHNlbGYuX3Rlc3RfbmFtZSkKLSAgICAgICAgcmV0dXJuIERyaXZlcklucHV0KHNlbGYuX3Rl c3RfbmFtZSwgc2VsZi5fdGltZW91dCwgaW1hZ2VfaGFzaCkKKyAgICAgICAgcmV0dXJuIERyaXZl cklucHV0KHNlbGYuX3Rlc3RfbmFtZSwgc2VsZi5fdGltZW91dCwgaW1hZ2VfaGFzaCwgc2VsZi5f aXNfcmVmdGVzdCkKIAogICAgIGRlZiBydW4oc2VsZik6CiAgICAgICAgIGlmIHNlbGYuX29wdGlv bnMubmV3X2Jhc2VsaW5lIG9yIHNlbGYuX29wdGlvbnMucmVzZXRfcmVzdWx0czoKQEAgLTEyMywx MSArMTIzLDExIEBAIGNsYXNzIFNpbmdsZVRlc3RSdW5uZXI6CiAgICAgICAgICAgICBlbHNlOgog ICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLl9ydW5fcmViYXNlbGluZSgpCiAgICAgICAgIGlm IHNlbGYuX2lzX3JlZnRlc3Q6Ci0gICAgICAgICAgICBpZiBzZWxmLl9wb3J0LmdldF9vcHRpb24o J3BpeGVsX3Rlc3RzJyk6Ci0gICAgICAgICAgICAgICAgcmV0dXJuIHNlbGYuX3J1bl9yZWZ0ZXN0 KCkKLSAgICAgICAgICAgIHJlc3VsdCA9IFRlc3RSZXN1bHQoc2VsZi5fdGVzdF9uYW1lKQotICAg ICAgICAgICAgcmVzdWx0LnR5cGUgPSB0ZXN0X2V4cGVjdGF0aW9ucy5TS0lQCi0gICAgICAgICAg ICByZXR1cm4gcmVzdWx0CisgICAgICAgICAgICBpZiBzZWxmLl9wb3J0LmdldF9vcHRpb24oJ25v X3JlZl90ZXN0cycpOgorICAgICAgICAgICAgICAgIHJlc3VsdCA9IFRlc3RSZXN1bHQoc2VsZi5f dGVzdF9uYW1lKQorICAgICAgICAgICAgICAgIHJlc3VsdC50eXBlID0gdGVzdF9leHBlY3RhdGlv bnMuU0tJUAorICAgICAgICAgICAgICAgIHJldHVybiByZXN1bHQKKyAgICAgICAgICAgIHJldHVy biBzZWxmLl9ydW5fcmVmdGVzdCgpCiAgICAgICAgIHJldHVybiBzZWxmLl9ydW5fY29tcGFyZV90 ZXN0KCkKIAogICAgIGRlZiBfcnVuX2NvbXBhcmVfdGVzdChzZWxmKToKQEAgLTI5MCw3ICsyOTAs NyBAQCBjbGFzcyBTaW5nbGVUZXN0UnVubmVyOgogICAgIGRlZiBfcnVuX3JlZnRlc3Qoc2VsZik6 CiAgICAgICAgIGRyaXZlcl9vdXRwdXQxID0gc2VsZi5fZHJpdmVyLnJ1bl90ZXN0KHNlbGYuX2Ry aXZlcl9pbnB1dCgpKQogICAgICAgICByZWZlcmVuY2VfdGVzdF9uYW1lID0gc2VsZi5fcG9ydC5y ZWxhdGl2ZV90ZXN0X2ZpbGVuYW1lKHNlbGYuX3JlZmVyZW5jZV9maWxlbmFtZSkKLSAgICAgICAg ZHJpdmVyX291dHB1dDIgPSBzZWxmLl9kcml2ZXIucnVuX3Rlc3QoRHJpdmVySW5wdXQocmVmZXJl bmNlX3Rlc3RfbmFtZSwgc2VsZi5fdGltZW91dCwgZHJpdmVyX291dHB1dDEuaW1hZ2VfaGFzaCkp CisgICAgICAgIGRyaXZlcl9vdXRwdXQyID0gc2VsZi5fZHJpdmVyLnJ1bl90ZXN0KERyaXZlcklu cHV0KHJlZmVyZW5jZV90ZXN0X25hbWUsIHNlbGYuX3RpbWVvdXQsIGRyaXZlcl9vdXRwdXQxLmlt YWdlX2hhc2gsIHNlbGYuX2lzX3JlZnRlc3QpKQogICAgICAgICB0ZXN0X3Jlc3VsdCA9IHNlbGYu X2NvbXBhcmVfb3V0cHV0X3dpdGhfcmVmZXJlbmNlKGRyaXZlcl9vdXRwdXQxLCBkcml2ZXJfb3V0 cHV0MikKIAogICAgICAgICB0ZXN0X3Jlc3VsdF93cml0ZXIud3JpdGVfdGVzdF9yZXN1bHQoc2Vs Zi5fcG9ydCwgc2VsZi5fdGVzdF9uYW1lLCBkcml2ZXJfb3V0cHV0MSwgZHJpdmVyX291dHB1dDIs IHRlc3RfcmVzdWx0LmZhaWx1cmVzKQpAQCAtMzA4LDYgKzMwOCw4IEBAIGNsYXNzIFNpbmdsZVRl c3RSdW5uZXI6CiAgICAgICAgIGlmIGZhaWx1cmVzOgogICAgICAgICAgICAgcmV0dXJuIFRlc3RS ZXN1bHQoc2VsZi5fdGVzdF9uYW1lLCBmYWlsdXJlcywgdG90YWxfdGVzdF90aW1lLCBoYXNfc3Rk ZXJyKQogCisgICAgICAgIGFzc2VydChkcml2ZXJfb3V0cHV0MS5pbWFnZV9oYXNoIG9yIGRyaXZl cl9vdXRwdXQyLmltYWdlX2hhc2gpCisKICAgICAgICAgaWYgc2VsZi5faXNfbWlzbWF0Y2hfcmVm dGVzdDoKICAgICAgICAgICAgIGlmIGRyaXZlcl9vdXRwdXQxLmltYWdlX2hhc2ggPT0gZHJpdmVy X291dHB1dDIuaW1hZ2VfaGFzaDoKICAgICAgICAgICAgICAgICBmYWlsdXJlcy5hcHBlbmQodGVz dF9mYWlsdXJlcy5GYWlsdXJlUmVmdGVzdE1pc21hdGNoRGlkTm90T2NjdXIoc2VsZi5fcmVmZXJl bmNlX2ZpbGVuYW1lKSkKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL2NvbnRyb2xsZXJzL3dvcmtlci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL2NvbnRyb2xsZXJzL3dvcmtlci5weQppbmRleCBhYjhhYTc1NmQ0OTU5MWVmZWNl NDJlNzZmNDExYjM2YzAxNmUwMmMwLi41ZGQzM2EyNmQ3ZDE3ZWQzYzA1N2M0ZTk1MjhjNjIwNzc1 MDQ4YThiIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9j b250cm9sbGVycy93b3JrZXIucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvY29udHJvbGxlcnMvd29ya2VyLnB5CkBAIC0yNDMsNyArMjQzLDkgQEAgY2xhc3MgV29y a2VyKG1hbmFnZXJfd29ya2VyX2Jyb2tlci5BYnN0cmFjdFdvcmtlcik6CiAKICAgICAgICAgUmV0 dXJuczogYSBUZXN0UmVzdWx0IG9iamVjdC4KICAgICAgICAgIiIiCi0gICAgICAgIGlmIG5vdCBz ZWxmLl9kcml2ZXIgb3Igc2VsZi5fZHJpdmVyLnBvbGwoKSBpcyBub3QgTm9uZToKKyAgICAgICAg aWYgc2VsZi5fZHJpdmVyIGFuZCBzZWxmLl9kcml2ZXIuaGFzX2NyYXNoZWQoKToKKyAgICAgICAg ICAgIHNlbGYua2lsbF9kcml2ZXIoKQorICAgICAgICBpZiBub3Qgc2VsZi5fZHJpdmVyOgogICAg ICAgICAgICAgc2VsZi5fZHJpdmVyID0gc2VsZi5fcG9ydC5jcmVhdGVfZHJpdmVyKHNlbGYuX3dv cmtlcl9udW1iZXIpCiAgICAgICAgIHJldHVybiBzZWxmLnJ1bl9zaW5nbGVfdGVzdChzZWxmLl9k cml2ZXIsIHRlc3RfaW5wdXQpCiAKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3BvcnQvYmFzZV91bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZV91bml0dGVzdC5weQppbmRleCA2YjY3Zjk3MjhmYmYw OTU3ZTk2OGI4MTViMGFiMTlmYzljZTUzYzc3Li5iYzEzNTg0NzFjNGM0MDFhMWEwZTk4ZjJkODUx NmFhNGRlM2FjM2M4IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2Jhc2VfdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcG9ydC9iYXNlX3VuaXR0ZXN0LnB5CkBAIC0zMDQsOCArMzA0LDggQEAgY2xh c3MgVmlydHVhbFRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgIGRlZiB0ZXN0X3ZpcnR1YWxf ZHJpdmVyX21ldGhvZHMoc2VsZik6CiAgICAgICAgIGRyaXZlciA9IERyaXZlcihOb25lLCBOb25l KQogICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwoZHJpdmVyLnJ1bl90ZXN0LCBOb25lKQotICAg ICAgICBzZWxmLmFzc2VydFZpcnR1YWwoZHJpdmVyLnBvbGwpCiAgICAgICAgIHNlbGYuYXNzZXJ0 VmlydHVhbChkcml2ZXIuc3RvcCkKKyAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKGRyaXZlci5j bWRfbGluZSkKIAogCiAjIEZJWE1FOiBUaGlzIHNob3VsZCBiZSBtb3ZlZCB0byBkcml2ZXJfdW5p dHRlc3QucHkgb3IganVzdCBkZWxldGVkLgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkKaW5kZXggMWU5NzMwZDUzN2E0OTc3Yjg3 YjZiM2VjNjY2OTc3MmIzYjRhMDQ0YS4uNWUzYWJmYmIzYjNjNjc2MmQxMTA1M2NiODk4MDAyYTQx Yjk3OGExYSAxMDA3NTUKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9jaHJvbWl1bS5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L2Nocm9taXVtLnB5CkBAIC00Niw3ICs0Niw3IEBAIGZyb20gd2Via2l0cHkubGF5b3V0 X3Rlc3RzLmNvbnRyb2xsZXJzLm1hbmFnZXIgaW1wb3J0IE1hbmFnZXIKIGZyb20gd2Via2l0cHku bGF5b3V0X3Rlc3RzLm1vZGVscyBpbXBvcnQgdGVzdF9leHBlY3RhdGlvbnMKIGZyb20gd2Via2l0 cHkubGF5b3V0X3Rlc3RzLm1vZGVscy50ZXN0X2NvbmZpZ3VyYXRpb24gaW1wb3J0IFRlc3RDb25m aWd1cmF0aW9uCiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0LmJhc2UgaW1wb3J0IFBv cnQKLWZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQuZHJpdmVyIGltcG9ydCBEcml2ZXIs IERyaXZlck91dHB1dAorZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydC5kcml2ZXIgaW1w b3J0IERyaXZlciwgRHJpdmVyT3V0cHV0LCBSZWZUZXN0RHJpdmVyCiBmcm9tIHdlYmtpdHB5Lmxh eW91dF90ZXN0cy5wb3J0IGltcG9ydCBidWlsZGVycwogZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVz dHMuc2VydmVycyBpbXBvcnQgaHR0cF9zZXJ2ZXIKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3Rz LnNlcnZlcnMgaW1wb3J0IHdlYnNvY2tldF9zZXJ2ZXIKQEAgLTI1NCw3ICsyNTQsNyBAQCBjbGFz cyBDaHJvbWl1bVBvcnQoUG9ydCk6CiAKICAgICBkZWYgY3JlYXRlX2RyaXZlcihzZWxmLCB3b3Jr ZXJfbnVtYmVyKToKICAgICAgICAgIiIiU3RhcnRzIGEgbmV3IERyaXZlciBhbmQgcmV0dXJucyBh IGhhbmRsZSB0byBpdC4iIiIKLSAgICAgICAgcmV0dXJuIENocm9taXVtRHJpdmVyKHNlbGYsIHdv cmtlcl9udW1iZXIpCisgICAgICAgIHJldHVybiBSZWZUZXN0RHJpdmVyKHNlbGYsIHdvcmtlcl9u dW1iZXIsIENocm9taXVtRHJpdmVyKQogCiAgICAgZGVmIHN0YXJ0X2hlbHBlcihzZWxmKToKICAg ICAgICAgaGVscGVyX3BhdGggPSBzZWxmLl9wYXRoX3RvX2hlbHBlcigpCkBAIC00MDAsMTYgKzQw MCwxNiBAQCBjbGFzcyBDaHJvbWl1bVBvcnQoUG9ydCk6CiAKICMgRklYTUU6IFRoaXMgc2hvdWxk IGluaGVyaXQgZnJvbSBXZWJLaXREcml2ZXIgbm93IHRoYXQgQ2hyb21pdW0gaGFzIGEgRHVtcFJl bmRlclRyZWUgcHJvY2VzcyBsaWtlIHRoZSByZXN0IG9mIFdlYktpdC4KIGNsYXNzIENocm9taXVt RHJpdmVyKERyaXZlcik6Ci0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1i ZXIpOgotICAgICAgICBEcml2ZXIuX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlcikK KyAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlciwgZm9yY2VfcGl4ZWxf cmVzdWx0cz1GYWxzZSk6CisgICAgICAgIERyaXZlci5fX2luaXRfXyhzZWxmLCBwb3J0LCB3b3Jr ZXJfbnVtYmVyLCBmb3JjZV9waXhlbF9yZXN1bHRzKQogICAgICAgICBzZWxmLl9wcm9jID0gTm9u ZQogICAgICAgICBzZWxmLl9pbWFnZV9wYXRoID0gTm9uZQotICAgICAgICBpZiBzZWxmLl9wb3J0 LmdldF9vcHRpb24oJ3BpeGVsX3Rlc3RzJyk6CisgICAgICAgIGlmIHNlbGYuX3BpeGVsX3Rlc3Rz OgogICAgICAgICAgICAgc2VsZi5faW1hZ2VfcGF0aCA9IHNlbGYuX3BvcnQuX2ZpbGVzeXN0ZW0u am9pbihzZWxmLl9wb3J0LnJlc3VsdHNfZGlyZWN0b3J5KCksICdwbmdfcmVzdWx0JXMucG5nJyAl IHNlbGYuX3dvcmtlcl9udW1iZXIpCiAKICAgICBkZWYgX3dyYXBwZXJfb3B0aW9ucyhzZWxmKToK ICAgICAgICAgY21kID0gW10KLSAgICAgICAgaWYgc2VsZi5fcG9ydC5nZXRfb3B0aW9uKCdwaXhl bF90ZXN0cycpOgorICAgICAgICBpZiBzZWxmLl9waXhlbF90ZXN0czoKICAgICAgICAgICAgICMg U2VlIG5vdGUgYWJvdmUgaW4gZGlmZl9pbWFnZSgpIGZvciB3aHkgd2UgbmVlZCBfY29udmVydF9w YXRoKCkuCiAgICAgICAgICAgICBjbWQuYXBwZW5kKCItLXBpeGVsLXRlc3RzPSIgKyBzZWxmLl9w b3J0Ll9jb252ZXJ0X3BhdGgoc2VsZi5faW1hZ2VfcGF0aCkpCiAgICAgICAgICMgRklYTUU6IFRo aXMgaXMgbm90IE5vbmUgc2hvdWxkbid0IGJlIG5lY2Vzc2FyeSwgdW5sZXNzIC0tanMtZmxhZ3M9 IicnIiBjaGFuZ2VzIGJlaGF2aW9yIHNvbWVob3c/CkBAIC00NTUsOCArNDU1LDEwIEBAIGNsYXNz IENocm9taXVtRHJpdmVyKERyaXZlcik6CiAgICAgICAgIGNsb3NlX2ZkcyA9IHN5cy5wbGF0Zm9y bSBub3QgaW4gKCd3aW4zMicsICdjeWd3aW4nKQogICAgICAgICBzZWxmLl9wcm9jID0gc3VicHJv Y2Vzcy5Qb3BlbihzZWxmLmNtZF9saW5lKCksIHN0ZGluPXN1YnByb2Nlc3MuUElQRSwgc3Rkb3V0 PXN1YnByb2Nlc3MuUElQRSwgc3RkZXJyPXN1YnByb2Nlc3MuU1RET1VULCBjbG9zZV9mZHM9Y2xv c2VfZmRzKQogCi0gICAgZGVmIHBvbGwoc2VsZik6Ci0gICAgICAgIHJldHVybiBzZWxmLl9wcm9j LnBvbGwoKQorICAgIGRlZiBoYXNfY3Jhc2hlZChzZWxmKToKKyAgICAgICAgaWYgc2VsZi5fcHJv YyBpcyBOb25lOgorICAgICAgICAgICAgcmV0dXJuIEZhbHNlCisgICAgICAgIHJldHVybiBzZWxm Ll9wcm9jLnBvbGwoKSBpcyBub3QgTm9uZQogCiAgICAgZGVmIF93cml0ZV9jb21tYW5kX2FuZF9y ZWFkX2xpbmUoc2VsZiwgaW5wdXQ9Tm9uZSk6CiAgICAgICAgICIiIlJldHVybnMgYSB0dXBsZTog KGxpbmUsIGRpZF9jcmFzaCkiIiIKQEAgLTUzMSw3ICs1MzMsNyBAQCBjbGFzcyBDaHJvbWl1bURy aXZlcihEcml2ZXIpOgogCiAgICAgICAgIHdoaWxlIG5vdCBjcmFzaCBhbmQgbGluZS5yc3RyaXAo KSAhPSAiI0VPRiI6CiAgICAgICAgICAgICAjIE1ha2Ugc3VyZSB3ZSBoYXZlbid0IGNyYXNoZWQu Ci0gICAgICAgICAgICBpZiBsaW5lID09ICcnIGFuZCBzZWxmLnBvbGwoKSBpcyBub3QgTm9uZToK KyAgICAgICAgICAgIGlmIGxpbmUgPT0gJycgYW5kIHNlbGYuX3Byb2MucG9sbCgpIGlzIG5vdCBO b25lOgogICAgICAgICAgICAgICAgICMgVGhpcyBpcyBoZXggY29kZSAweGMwMDAwMDFkLCB3aGlj aCBpcyB1c2VkIGZvciBhYnJ1cHQKICAgICAgICAgICAgICAgICAjIHRlcm1pbmF0aW9uLiBUaGlz IGhhcHBlbnMgaWYgd2UgaGl0IGN0cmwrYyBmcm9tIHRoZSBwcm9tcHQKICAgICAgICAgICAgICAg ICAjIGFuZCB3ZSBoYXBwZW4gdG8gYmUgd2FpdGluZyBvbiBEUlQuCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2RyaXZlci5weSBiL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZHJpdmVyLnB5CmluZGV4IGI3NDJkYWJm MTI2YTE3NTE0NzE4NWE1NjZlNjU1OTUyZGJhN2Q3YzIuLmM1ZWYyN2U2ZTY3ZjEyNGE3NTA0YWYw MDVhNTI0MTU5NDVlNjU2MjQgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3BvcnQvZHJpdmVyLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3BvcnQvZHJpdmVyLnB5CkBAIC0zMCwxMCArMzAsMTEgQEAgaW1wb3J0IHNobGV4 CiAKIAogY2xhc3MgRHJpdmVySW5wdXQob2JqZWN0KToKLSAgICBkZWYgX19pbml0X18oc2VsZiwg dGVzdF9uYW1lLCB0aW1lb3V0LCBpbWFnZV9oYXNoKToKKyAgICBkZWYgX19pbml0X18oc2VsZiwg dGVzdF9uYW1lLCB0aW1lb3V0LCBpbWFnZV9oYXNoLCBpc19yZWZ0ZXN0KToKICAgICAgICAgc2Vs Zi50ZXN0X25hbWUgPSB0ZXN0X25hbWUKICAgICAgICAgc2VsZi50aW1lb3V0ID0gdGltZW91dCAg IyBpbiBtcwogICAgICAgICBzZWxmLmltYWdlX2hhc2ggPSBpbWFnZV9oYXNoCisgICAgICAgIHNl bGYuaXNfcmVmdGVzdCA9IGlzX3JlZnRlc3QKIAogCiBjbGFzcyBEcml2ZXJPdXRwdXQob2JqZWN0 KToKQEAgLTYwLDcgKzYxLDcgQEAgY2xhc3MgRHJpdmVyT3V0cHV0KG9iamVjdCk6CiBjbGFzcyBE cml2ZXI6CiAgICAgIiIiQWJzdHJhY3QgaW50ZXJmYWNlIGZvciB0aGUgRHVtcFJlbmRlclRyZWUg aW50ZXJmYWNlLiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1i ZXIpOgorICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyLCBmb3JjZV9w aXhlbF9yZXN1bHRzPUZhbHNlKToKICAgICAgICAgIiIiSW5pdGlhbGl6ZSBhIERyaXZlciB0byBz dWJzZXF1ZW50bHkgcnVuIHRlc3RzLgogCiAgICAgICAgIFR5cGljYWxseSB0aGlzIHJvdXRpbmUg d2lsbCBzcGF3biBEdW1wUmVuZGVyVHJlZSBpbiBhIGNvbmZpZwpAQCAtNzEsNiArNzIsNyBAQCBj bGFzcyBEcml2ZXI6CiAgICAgICAgICIiIgogICAgICAgICBzZWxmLl9wb3J0ID0gcG9ydAogICAg ICAgICBzZWxmLl93b3JrZXJfbnVtYmVyID0gd29ya2VyX251bWJlcgorICAgICAgICBzZWxmLl9w aXhlbF90ZXN0cyA9IGZvcmNlX3BpeGVsX3Jlc3VsdHMgb3IgKHNlbGYuX3BvcnQgYW5kIHNlbGYu X3BvcnQuZ2V0X29wdGlvbigncGl4ZWxfdGVzdHMnKSkKIAogICAgIGRlZiBydW5fdGVzdChzZWxm LCBkcml2ZXJfaW5wdXQpOgogICAgICAgICAiIiJSdW4gYSBzaW5nbGUgdGVzdCBhbmQgcmV0dXJu IHRoZSByZXN1bHRzLgpAQCAtODksOSArOTEsMzggQEAgY2xhc3MgRHJpdmVyOgogICAgICAgICAj IHVzZWQgYnkgZS5nLiB0b29scy92YWxncmluZC92YWxncmluZF90ZXN0cy5weS4KICAgICAgICAg cmV0dXJuIHNobGV4LnNwbGl0KHdyYXBwZXJfb3B0aW9uKSBpZiB3cmFwcGVyX29wdGlvbiBlbHNl IFtdCiAKLSAgICBkZWYgcG9sbChzZWxmKToKLSAgICAgICAgIiIiUmV0dXJucyBOb25lIGlmIHRo ZSBEcml2ZXIgaXMgc3RpbGwgcnVubmluZy4gUmV0dXJucyB0aGUgcmV0dXJuY29kZSBpZiBpdCBo YXMgZXhpdGVkLiIiIgotICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdEcml2ZXIu cG9sbCcpCisgICAgZGVmIGhhc19jcmFzaGVkKHNlbGYpOgorICAgICAgICByZXR1cm4gRmFsc2UK IAogICAgIGRlZiBzdG9wKHNlbGYpOgogICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9y KCdEcml2ZXIuc3RvcCcpCisKKyAgICBkZWYgY21kX2xpbmUoc2VsZik6CisgICAgICAgIHJhaXNl IE5vdEltcGxlbWVudGVkRXJyb3IoJ0RyaXZlci5jbWRfbGluZScpCisKKworY2xhc3MgUmVmVGVz dERyaXZlcjoKKyAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlciwgZHJp dmVyX2luc3RhbmNlX2NvbnN0cnVjdG9yKToKKyAgICAgICAgc2VsZi5fZHJpdmVyID0gZHJpdmVy X2luc3RhbmNlX2NvbnN0cnVjdG9yKHBvcnQsIHdvcmtlcl9udW1iZXIpCisgICAgICAgIGlmIHBv cnQuZ2V0X29wdGlvbigncGl4ZWxfdGVzdHMnKToKKyAgICAgICAgICAgIHNlbGYuX3BpeGVsX2Ry aXZlciA9IHNlbGYuX2RyaXZlcgorICAgICAgICBlbHNlOgorICAgICAgICAgICAgc2VsZi5fcGl4 ZWxfZHJpdmVyID0gZHJpdmVyX2luc3RhbmNlX2NvbnN0cnVjdG9yKHBvcnQsIHdvcmtlcl9udW1i ZXIsIGZvcmNlX3BpeGVsX3Jlc3VsdHM9VHJ1ZSkKKworICAgIGRlZiBydW5fdGVzdChzZWxmLCBk cml2ZXJfaW5wdXQpOgorICAgICAgICBpZiBkcml2ZXJfaW5wdXQuaXNfcmVmdGVzdDoKKyAgICAg ICAgICAgIHJldHVybiBzZWxmLl9waXhlbF9kcml2ZXIucnVuX3Rlc3QoZHJpdmVyX2lucHV0KQor ICAgICAgICByZXR1cm4gc2VsZi5fZHJpdmVyLnJ1bl90ZXN0KGRyaXZlcl9pbnB1dCkKKworICAg IGRlZiBoYXNfY3Jhc2hlZChzZWxmKToKKyAgICAgICAgcmV0dXJuIHNlbGYuX2RyaXZlci5oYXNf Y3Jhc2hlZCgpIG9yIHNlbGYuX3BpeGVsX2RyaXZlci5oYXNfY3Jhc2hlZCgpCisKKyAgICBkZWYg c3RvcChzZWxmKToKKyAgICAgICAgc2VsZi5fZHJpdmVyLnN0b3AoKQorICAgICAgICBzZWxmLl9w aXhlbF9kcml2ZXIuc3RvcCgpCisKKyAgICBkZWYgY21kX2xpbmUoc2VsZik6CisgICAgICAgIGNt ZF9saW5lID0gc2VsZi5fZHJpdmVyLmNtZF9saW5lKCkKKyAgICAgICAgaWYgc2VsZi5fZHJpdmVy ICE9IHNlbGYuX3BpeGVsX2RyaXZlcjoKKyAgICAgICAgICAgIGNtZF9saW5lICs9IFsnOyAnXSAr IHNlbGYuX3BpeGVsX2RyaXZlci5jbWRfbGluZSgpCisgICAgICAgIHJldHVybiBjbWRfbGluZQpk aWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnly dW4ucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2RyeXJ1bi5w eQppbmRleCBjYTNiYWRlM2Q4ZThmZGVjOTg0OGFiOGM1YWFmODE5OWM1NTJhNzAxLi44OTc1NWU2 ZmI1NWNmOTM0YzY4OGQ3OWFjOTA3MmU0ZjdkNDVmNDFiIDEwMDY0NAotLS0gYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2RyeXJ1bi5weQorKysgYi9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2RyeXJ1bi5weQpAQCAtMTA5LDkgKzEwOSw2 IEBAIGNsYXNzIERyeXJ1bkRyaXZlcihEcml2ZXIpOgogICAgIGRlZiBjbWRfbGluZShzZWxmKToK ICAgICAgICAgcmV0dXJuIFsnTm9uZSddCiAKLSAgICBkZWYgcG9sbChzZWxmKToKLSAgICAgICAg cmV0dXJuIE5vbmUKLQogICAgIGRlZiBydW5fdGVzdChzZWxmLCBkcml2ZXJfaW5wdXQpOgogICAg ICAgICBzdGFydF90aW1lID0gdGltZS50aW1lKCkKICAgICAgICAgZnMgPSBzZWxmLl9wb3J0Ll9m aWxlc3lzdGVtCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L3Rlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L3Rlc3QucHkKaW5kZXggN2U1ZDk1NmVlNGQ0MTBiMDQ4YjczNGMzMzQ4NmZhOGQ4YTE5MDc4ZC4u ZjZhYzFmOTI2ZjhhMTQwZDY5NDJjNGZkN2QyMTJhZjVhYzhlM2Q0OCAxMDA2NDQKLS0tIGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5CisrKyBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdC5weQpAQCAtMzQsNiArMzQs NyBAQCBpbXBvcnQgYmFzZTY0CiBpbXBvcnQgdGltZQogCiBmcm9tIHdlYmtpdHB5LmxheW91dF90 ZXN0cy5wb3J0IGltcG9ydCBQb3J0LCBEcml2ZXIsIERyaXZlck91dHB1dAorZnJvbSB3ZWJraXRw eS5sYXlvdXRfdGVzdHMucG9ydC5kcml2ZXIgaW1wb3J0IFJlZlRlc3REcml2ZXIKIGZyb20gd2Vi a2l0cHkubGF5b3V0X3Rlc3RzLm1vZGVscy50ZXN0X2NvbmZpZ3VyYXRpb24gaW1wb3J0IFRlc3RD b25maWd1cmF0aW9uCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5ob3N0X21vY2sgaW1wb3J0IE1vY2tI b3N0CiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0uZmlsZXN5c3RlbV9tb2NrIGltcG9ydCBN b2NrRmlsZVN5c3RlbQpAQCAtMzYwLDcgKzM2MSw3IEBAIGNsYXNzIFRlc3RQb3J0KFBvcnQpOgog ICAgICAgICBwYXNzCiAKICAgICBkZWYgY3JlYXRlX2RyaXZlcihzZWxmLCB3b3JrZXJfbnVtYmVy KToKLSAgICAgICAgcmV0dXJuIFRlc3REcml2ZXIoc2VsZiwgd29ya2VyX251bWJlcikKKyAgICAg ICAgcmV0dXJuIFJlZlRlc3REcml2ZXIoc2VsZiwgd29ya2VyX251bWJlciwgVGVzdERyaXZlcikK IAogICAgIGRlZiBzdGFydF9odHRwX3NlcnZlcihzZWxmKToKICAgICAgICAgcGFzcwpAQCAtNDg4 LDkgKzQ4OSw2IEBAIGNsYXNzIFRlc3REcml2ZXIoRHJpdmVyKToKICAgICBkZWYgY21kX2xpbmUo c2VsZik6CiAgICAgICAgIHJldHVybiBbc2VsZi5fcG9ydC5fcGF0aF90b19kcml2ZXIoKV0gKyBz ZWxmLl9wb3J0LmdldF9vcHRpb24oJ2FkZGl0aW9uYWxfZHJ0X2ZsYWcnLCBbXSkKIAotICAgIGRl ZiBwb2xsKHNlbGYpOgotICAgICAgICByZXR1cm4gVHJ1ZQotCiAgICAgZGVmIHJ1bl90ZXN0KHNl bGYsIHRlc3RfaW5wdXQpOgogICAgICAgICBzdGFydF90aW1lID0gdGltZS50aW1lKCkKICAgICAg ICAgdGVzdF9uYW1lID0gdGVzdF9pbnB1dC50ZXN0X25hbWUKZGlmZiAtLWdpdCBhL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKaW5kZXggOTU2MTFiNGEyZjFl M2Y3MWRjY2NlYjExYTViMmYzNWViYjgyZDIxOC4uZDYzOTJkMWU4YmU5Y2Y1NjRiNzM2YTMwMjg3 ZTc4MTc4ZTA1ZDk4ZSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC93ZWJraXQucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC93ZWJraXQucHkKQEAgLTQ0MCw4ICs0NDAsOCBAQCBjbGFzcyBXZWJLaXRQb3J0 KFBvcnQpOgogY2xhc3MgV2ViS2l0RHJpdmVyKERyaXZlcik6CiAgICAgIiIiV2ViS2l0IGltcGxl bWVudGF0aW9uIG9mIHRoZSBEdW1wUmVuZGVyVHJlZS9XZWJLaXRUZXN0UnVubmVyIGludGVyZmFj ZS4iIiIKIAotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyKToKLSAg ICAgICAgRHJpdmVyLl9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIpCisgICAgZGVm IF9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIsIGZvcmNlX3BpeGVsX3Jlc3VsdHM9 RmFsc2UpOgorICAgICAgICBEcml2ZXIuX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJl ciwgZm9yY2VfcGl4ZWxfcmVzdWx0cykKICAgICAgICAgc2VsZi5fZHJpdmVyX3RlbXBkaXIgPSBw b3J0Ll9maWxlc3lzdGVtLm1rZHRlbXAocHJlZml4PSclcy0nICUgc2VsZi5fcG9ydC5kcml2ZXJf bmFtZSgpKQogICAgICAgICAjIFdlYktpdFRlc3RSdW5uZXIgY2FuIHJlcG9ydCBiYWNrIHN1YnBy b2Nlc3MgY3Jhc2hlcyBieSBwcmludGluZwogICAgICAgICAjICIjQ1JBU0hFRCAtIFBST0NFU1NO QU1FIi4gIFNpbmNlIHRob3NlIGNhbiBoYXBwZW4gYXQgYW55IHRpbWUKQEAgLTQ1Nyw3ICs0NTcs NiBAQCBjbGFzcyBXZWJLaXREcml2ZXIoRHJpdmVyKToKICAgICAgICAgc2VsZi5lcnJfc2Vlbl9l b2YgPSBGYWxzZQogICAgICAgICBzZWxmLl9zZXJ2ZXJfcHJvY2VzcyA9IE5vbmUKIAotCiAgICAg IyBGSVhNRTogVGhpcyBtYXkgYmUgdW5zYWZlLCBhcyBweXRob24gZG9lcyBub3QgZ3VhcmVudGVl IGFueSBvcmRlcmluZyBvZiBfX2RlbF9fIGNhbGxzCiAgICAgIyBJIGJlbGlldmUgaXQncyBwb3Nz aWJsZSB0aGF0IHNlbGYuX3BvcnQgb3Igc2VsZi5fcG9ydC5fZmlsZXN5c3RlbSBtYXkgYWxyZWFk eSBiZSBkZXN0cm95ZWQuCiAgICAgZGVmIF9fZGVsX18oc2VsZik6CkBAIC00NjYsNyArNDY1LDcg QEAgY2xhc3MgV2ViS2l0RHJpdmVyKERyaXZlcik6CiAgICAgZGVmIGNtZF9saW5lKHNlbGYpOgog ICAgICAgICBjbWQgPSBzZWxmLl9jb21tYW5kX3dyYXBwZXIoc2VsZi5fcG9ydC5nZXRfb3B0aW9u KCd3cmFwcGVyJykpCiAgICAgICAgIGNtZC5hcHBlbmQoc2VsZi5fcG9ydC5fcGF0aF90b19kcml2 ZXIoKSkKLSAgICAgICAgaWYgc2VsZi5fcG9ydC5nZXRfb3B0aW9uKCdwaXhlbF90ZXN0cycpOgor ICAgICAgICBpZiBzZWxmLl9waXhlbF90ZXN0czoKICAgICAgICAgICAgIGNtZC5hcHBlbmQoJy0t cGl4ZWwtdGVzdHMnKQogICAgICAgICBpZiBzZWxmLl9wb3J0LmdldF9vcHRpb24oJ2djX2JldHdl ZW5fdGVzdHMnKToKICAgICAgICAgICAgIGNtZC5hcHBlbmQoJy0tZ2MtYmV0d2Vlbi10ZXN0cycp CkBAIC00OTAsOCArNDg5LDEwIEBAIGNsYXNzIFdlYktpdERyaXZlcihEcml2ZXIpOgogICAgICAg ICBzZWxmLl9jcmFzaGVkX3N1YnByb2Nlc3NfbmFtZSA9IE5vbmUKICAgICAgICAgc2VsZi5fc2Vy dmVyX3Byb2Nlc3MgPSBzZXJ2ZXJfcHJvY2Vzcy5TZXJ2ZXJQcm9jZXNzKHNlbGYuX3BvcnQsIHNl cnZlcl9uYW1lLCBzZWxmLmNtZF9saW5lKCksIGVudmlyb25tZW50KQogCi0gICAgZGVmIHBvbGwo c2VsZik6Ci0gICAgICAgIHJldHVybiBzZWxmLl9zZXJ2ZXJfcHJvY2Vzcy5wb2xsKCkKKyAgICBk ZWYgaGFzX2NyYXNoZWQoc2VsZik6CisgICAgICAgIGlmIHNlbGYuX3NlcnZlcl9wcm9jZXNzIGlz IE5vbmU6CisgICAgICAgICAgICByZXR1cm4gRmFsc2UKKyAgICAgICAgcmV0dXJuIHNlbGYuX3Nl cnZlcl9wcm9jZXNzLnBvbGwoKSBpcyBub3QgTm9uZQogCiAgICAgZGVmIF9jaGVja19mb3JfZHJp dmVyX2NyYXNoKHNlbGYsIGVycm9yX2xpbmUpOgogICAgICAgICBpZiBlcnJvcl9saW5lID09ICIj Q1JBU0hFRFxuIjoKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3J1bl93ZWJraXRfdGVzdHMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CmluZGV4IDZkNjI3YjY0OGI3YTJkMmZhMWRmY2EzOWE0 ZGMyOWY3ZWVhZTA4ZDAuLmVkNzhiMTJmYjIzNGNjYjhjODQxMzhkN2MyMmVmYzdiODEwNGQ0MjUg MTAwNzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJr aXRfdGVzdHMucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVu X3dlYmtpdF90ZXN0cy5weQpAQCAtMjc0LDYgKzI3NCw4IEBAIGRlZiBwYXJzZV9hcmdzKGFyZ3M9 Tm9uZSk6CiAgICAgICAgICAgICBkZXN0PSJwaXhlbF90ZXN0cyIsIGhlbHA9IkRpc2FibGUgcGl4 ZWwtdG8tcGl4ZWwgUE5HIGNvbXBhcmlzb25zIiksCiAgICAgICAgIG9wdHBhcnNlLm1ha2Vfb3B0 aW9uKCItLW5vLXNhbXBsZS1vbi10aW1lb3V0IiwgYWN0aW9uPSJzdG9yZV9mYWxzZSIsCiAgICAg ICAgICAgICBkZXN0PSJzYW1wbGVfb25fdGltZW91dCIsIGhlbHA9IkRvbid0IHJ1biBzYW1wbGUg b24gdGltZW91dCAoTWFjIE9TIFggb25seSkiKSwKKyAgICAgICAgb3B0cGFyc2UubWFrZV9vcHRp b24oIi0tbm8tcmVmLXRlc3RzIiwgYWN0aW9uPSJzdG9yZV90cnVlIiwKKyAgICAgICAgICAgIGRl c3Q9Im5vX3JlZl90ZXN0cyIsIGhlbHA9IlNraXAgYWxsIHJlZiB0ZXN0cyIpLAogICAgICAgICBv cHRwYXJzZS5tYWtlX29wdGlvbigiLS10b2xlcmFuY2UiLAogICAgICAgICAgICAgaGVscD0iSWdu b3JlIGltYWdlIGRpZmZlcmVuY2VzIGxlc3MgdGhhbiB0aGlzIHBlcmNlbnRhZ2UgKHNvbWUgIgog ICAgICAgICAgICAgICAgICJwb3J0cyBtYXkgaWdub3JlIHRoaXMgb3B0aW9uKSIsIHR5cGU9ImZs b2F0IiksCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9y dW5fd2Via2l0X3Rlc3RzX2ludGVncmF0aW9udGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNfaW50ZWdyYXRpb250ZXN0LnB5CmluZGV4 IGE2NDQ2YzUyZDk4Mjc0Mjk3MDY2Mjc3ZjEwYTA3ZTJiOTgwNjkyOWIuLjZlY2ZkNDliNmU4OWJm Mjg5Y2I4M2VkNzAxOTY4ZjUzYWYzZTMwZGUgMTAwNzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNfaW50ZWdyYXRpb250ZXN0LnB5Cisr KyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNf aW50ZWdyYXRpb250ZXN0LnB5CkBAIC0xNTUsMTAgKzE1NSw2IEBAIGRlZiBnZXRfdGVzdHNfcnVu KGV4dHJhX2FyZ3M9Tm9uZSwgdGVzdHNfaW5jbHVkZWQ9RmFsc2UsIGZsYXR0ZW5fYmF0Y2hlcz1G YWxzZSwKICAgICAgICAgICAgIFRlc3REcml2ZXIuX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2Vy X251bWJlcikKICAgICAgICAgICAgIHNlbGYuX2N1cnJlbnRfdGVzdF9iYXRjaCA9IE5vbmUKIAot ICAgICAgICBkZWYgcG9sbChzZWxmKToKLSAgICAgICAgICAgICMgU28gdGhhdCB3ZSBkb24ndCBj cmVhdGUgYSBuZXcgZHJpdmVyIGZvciBldmVyeSB0ZXN0Ci0gICAgICAgICAgICByZXR1cm4gTm9u ZQotCiAgICAgICAgIGRlZiBzdG9wKHNlbGYpOgogICAgICAgICAgICAgc2VsZi5fY3VycmVudF90 ZXN0X2JhdGNoID0gTm9uZQogCkBAIC02ODAsOCArNjc2LDE0IEBAIGNsYXNzIE1haW5UZXN0KHVu aXR0ZXN0LlRlc3RDYXNlKToKICAgICAgICAgdGVzdHNfcnVuID0gZ2V0X3Rlc3RzX3J1bihbJ3Bh c3Nlcy9yZWZ0ZXN0Lmh0bWwnXSwgdGVzdHNfaW5jbHVkZWQ9VHJ1ZSwgZmxhdHRlbl9iYXRjaGVz PVRydWUpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWxzKFsncGFzc2VzL3JlZnRlc3QuaHRtbCdd LCB0ZXN0c19ydW4pCiAKLSAgICBkZWYgdGVzdF9yZWZ0ZXN0X3NraXBfcmVmdGVzdHNfaWZfcGl4 ZWxfdGVzdHNfYXJlX2Rpc2FibGVkKHNlbGYpOgorICAgIGRlZiB0ZXN0X3JlZnRlc3RfcnVuX3Jl ZnRlc3RzX2lmX3BpeGVsX3Rlc3RzX2FyZV9kaXNhYmxlZChzZWxmKToKICAgICAgICAgdGVzdHNf cnVuID0gZ2V0X3Rlc3RzX3J1bihbJy0tbm8tcGl4ZWwtdGVzdHMnLCAncGFzc2VzL3JlZnRlc3Qu aHRtbCddLCB0ZXN0c19pbmNsdWRlZD1UcnVlLCBmbGF0dGVuX2JhdGNoZXM9VHJ1ZSkKKyAgICAg ICAgc2VsZi5hc3NlcnRFcXVhbHMoWydwYXNzZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX3J1bikK KworICAgIGRlZiB0ZXN0X3JlZnRlc3Rfc2tpcF9yZWZ0ZXN0c19pZl9ub19yZWZfdGVzdHMoc2Vs Zik6CisgICAgICAgIHRlc3RzX3J1biA9IGdldF90ZXN0c19ydW4oWyctLW5vLXJlZi10ZXN0cycs ICdwYXNzZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX2luY2x1ZGVkPVRydWUsIGZsYXR0ZW5fYmF0 Y2hlcz1UcnVlKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhbXSwgdGVzdHNfcnVuKQorICAg ICAgICB0ZXN0c19ydW4gPSBnZXRfdGVzdHNfcnVuKFsnLS1uby1yZWYtdGVzdHMnLCAnLS1uby1w aXhlbC10ZXN0cycsICdwYXNzZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX2luY2x1ZGVkPVRydWUs IGZsYXR0ZW5fYmF0Y2hlcz1UcnVlKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhbXSwgdGVz dHNfcnVuKQogCiAgICAgZGVmIHRlc3RfcmVmdGVzdF9leHBlY3RlZF9odG1sX3Nob3VsZF9iZV9p Z25vcmVkKHNlbGYpOgo= 115047 2011-11-14 15:46:27 -0800 2011-11-15 11:17:47 -0800 Patch bug-60605-20111114154643.patch text/plain 22272 tony U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMTk4CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggM2IyOTNlZTAwZDg3MzJjOWY3MWZkYmI1ZmQ0OWJkYjky ODRiMDk2ZS4uZDc4YTBkZWQ2NDRjOWZjYzIwNTY0N2RhM2VlNjIyYjk4YzIyOTRhNiAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDI2 IEBACiAyMDExLTExLTE0ICBUb255IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+CiAKKyAgICAg ICAgW05SV1RdIFJlZnRlc3RzIHNob3VsZCBydW4gZXZlbiB3aGVuIHBpeGVsIHRlc3RzIGFyZSBk aXNhYmxlZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTYwNjA1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVzdF9y dW5uZXIucHk6IE9ubHkgc2tpcCByZWYgdGVzdHMgaWYgLS1uby1yZWYtdGVzdHMgaXMgcGFzc2Vk LgorICAgICAgICAgICAgQWxzbyBhZGQgYW4gYXNzZXJ0IHRvIG1ha2Ugc3VyZSB3ZSBnZXQgaW1h Z2UgaGFzaGVzIGJhY2sgd2hlbiBydW5uaW5nIHJlZiB0ZXN0cy4KKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy93b3JrZXIucHk6IFVzZSBEcml2ZXIu aGFzX2NyYXNoZWQoKSBpbnN0ZWFkIG9mIHBvbGwoKS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2VfdW5pdHRlc3QucHk6CisgICAgICAgICogU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weTogVXNlIERyaXZlclByb3h5 LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZHJpdmVyLnB5 OiBBZGQgRHJpdmVyUHJveHkgd2hpY2ggZG9lcyB0aGUgd29yaworICAgICAgICAgICAgb2Ygc3Rh cnRpbmcgYSBwaXhlbCBkcml2ZXIgaWYgbmVlZGVkLiAgSXQgaGFuZGxlcyB0aGUgbG9naWMgb2Yg c2VuZGluZyB0aGUgdGVzdAorICAgICAgICAgICAgdG8gdGhlIGNvcnJlY3QgZHJpdmVyLiAgQWxz byByZW5hbWVkIERyaXZlci5wb2xsKCkgdG8gRHJpdmVyLmhhc19jcmFzaGVkKCkuCisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5OiBTd2l0Y2ggdG8g dXNpbmcgKiBEcml2ZXJQcm94eSBzbyB3ZSBnZXQgdGVzdCBjb3ZlcmFnZS4KKyAgICAgICAgKiBT Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weToKKyAgICAgICAgKiBT Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5OiBBZGQgLS1u by1yZWYtdGVzdHMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVu X3dlYmtpdF90ZXN0c19pbnRlZ3JhdGlvbnRlc3QucHk6IFRlc3QgLS1uby1yZWYtdGVzdHMuCisK KzIwMTEtMTEtMTQgIFRvbnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KKwogICAgICAgICBS ZW1vdmUgdGhlIENTUzNfRkxFWEJPWCBjb21waWxlIHRpbWUgZmxhZyBhbmQgZW5hYmxlIG9uIGFs bCBwb3J0cwogICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NzIxOTYKIApkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv Y29udHJvbGxlcnMvc2luZ2xlX3Rlc3RfcnVubmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvc2luZ2xlX3Rlc3RfcnVubmVyLnB5CmluZGV4IGM0 OWZhM2QyODFiYTRkMTViMTkwM2VkNWVkNDlmZTE0MmVlYWJhOWEuLjcxNDMxMWI4NzhkYzU1ODRk NjhiYmY3NWFiYzBjNTM5YTRhYzU0MjEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL2NvbnRyb2xsZXJzL3NpbmdsZV90ZXN0X3J1bm5lci5weQorKysgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVz dF9ydW5uZXIucHkKQEAgLTExMywyMSArMTEzLDE3IEBAIGNsYXNzIFNpbmdsZVRlc3RSdW5uZXI6 CiAgICAgICAgIGltYWdlX2hhc2ggPSBOb25lCiAgICAgICAgIGlmIHNlbGYuX3Nob3VsZF9mZXRj aF9leHBlY3RlZF9jaGVja3N1bSgpOgogICAgICAgICAgICAgaW1hZ2VfaGFzaCA9IHNlbGYuX3Bv cnQuZXhwZWN0ZWRfY2hlY2tzdW0oc2VsZi5fdGVzdF9uYW1lKQotICAgICAgICByZXR1cm4gRHJp dmVySW5wdXQoc2VsZi5fdGVzdF9uYW1lLCBzZWxmLl90aW1lb3V0LCBpbWFnZV9oYXNoKQorICAg ICAgICByZXR1cm4gRHJpdmVySW5wdXQoc2VsZi5fdGVzdF9uYW1lLCBzZWxmLl90aW1lb3V0LCBp bWFnZV9oYXNoLCBzZWxmLl9pc19yZWZ0ZXN0KQogCiAgICAgZGVmIHJ1bihzZWxmKToKLSAgICAg ICAgaWYgc2VsZi5fb3B0aW9ucy5uZXdfYmFzZWxpbmUgb3Igc2VsZi5fb3B0aW9ucy5yZXNldF9y ZXN1bHRzOgotICAgICAgICAgICAgaWYgc2VsZi5faXNfcmVmdGVzdDoKLSAgICAgICAgICAgICAg ICAjIFJldHVybnMgYSBkdW1teSBUZXN0UmVzdWx0LiBXZSBkb24ndCBoYXZlIHRvIHJlYmFzZSBm b3IgcmVmdGVzdHMuCi0gICAgICAgICAgICAgICAgcmV0dXJuIFRlc3RSZXN1bHQoc2VsZi5fdGVz dF9uYW1lKQotICAgICAgICAgICAgZWxzZToKLSAgICAgICAgICAgICAgICByZXR1cm4gc2VsZi5f cnVuX3JlYmFzZWxpbmUoKQogICAgICAgICBpZiBzZWxmLl9pc19yZWZ0ZXN0OgotICAgICAgICAg ICAgaWYgc2VsZi5fcG9ydC5nZXRfb3B0aW9uKCdwaXhlbF90ZXN0cycpOgotICAgICAgICAgICAg ICAgIHJldHVybiBzZWxmLl9ydW5fcmVmdGVzdCgpCi0gICAgICAgICAgICByZXN1bHQgPSBUZXN0 UmVzdWx0KHNlbGYuX3Rlc3RfbmFtZSkKLSAgICAgICAgICAgIHJlc3VsdC50eXBlID0gdGVzdF9l eHBlY3RhdGlvbnMuU0tJUAotICAgICAgICAgICAgcmV0dXJuIHJlc3VsdAorICAgICAgICAgICAg aWYgc2VsZi5fcG9ydC5nZXRfb3B0aW9uKCdub19yZWZfdGVzdHMnKSBvciBzZWxmLl9vcHRpb25z Lm5ld19iYXNlbGluZSBvciBzZWxmLl9vcHRpb25zLnJlc2V0X3Jlc3VsdHM6CisgICAgICAgICAg ICAgICAgcmVzdWx0ID0gVGVzdFJlc3VsdChzZWxmLl90ZXN0X25hbWUpCisgICAgICAgICAgICAg ICAgcmVzdWx0LnR5cGUgPSB0ZXN0X2V4cGVjdGF0aW9ucy5TS0lQCisgICAgICAgICAgICAgICAg cmV0dXJuIHJlc3VsdAorICAgICAgICAgICAgcmV0dXJuIHNlbGYuX3J1bl9yZWZ0ZXN0KCkKKyAg ICAgICAgaWYgc2VsZi5fb3B0aW9ucy5uZXdfYmFzZWxpbmUgb3Igc2VsZi5fb3B0aW9ucy5yZXNl dF9yZXN1bHRzOgorICAgICAgICAgICAgcmV0dXJuIHNlbGYuX3J1bl9yZWJhc2VsaW5lKCkKICAg ICAgICAgcmV0dXJuIHNlbGYuX3J1bl9jb21wYXJlX3Rlc3QoKQogCiAgICAgZGVmIF9ydW5fY29t cGFyZV90ZXN0KHNlbGYpOgpAQCAtMjkwLDcgKzI4Niw3IEBAIGNsYXNzIFNpbmdsZVRlc3RSdW5u ZXI6CiAgICAgZGVmIF9ydW5fcmVmdGVzdChzZWxmKToKICAgICAgICAgZHJpdmVyX291dHB1dDEg PSBzZWxmLl9kcml2ZXIucnVuX3Rlc3Qoc2VsZi5fZHJpdmVyX2lucHV0KCkpCiAgICAgICAgIHJl ZmVyZW5jZV90ZXN0X25hbWUgPSBzZWxmLl9wb3J0LnJlbGF0aXZlX3Rlc3RfZmlsZW5hbWUoc2Vs Zi5fcmVmZXJlbmNlX2ZpbGVuYW1lKQotICAgICAgICBkcml2ZXJfb3V0cHV0MiA9IHNlbGYuX2Ry aXZlci5ydW5fdGVzdChEcml2ZXJJbnB1dChyZWZlcmVuY2VfdGVzdF9uYW1lLCBzZWxmLl90aW1l b3V0LCBkcml2ZXJfb3V0cHV0MS5pbWFnZV9oYXNoKSkKKyAgICAgICAgZHJpdmVyX291dHB1dDIg PSBzZWxmLl9kcml2ZXIucnVuX3Rlc3QoRHJpdmVySW5wdXQocmVmZXJlbmNlX3Rlc3RfbmFtZSwg c2VsZi5fdGltZW91dCwgZHJpdmVyX291dHB1dDEuaW1hZ2VfaGFzaCwgc2VsZi5faXNfcmVmdGVz dCkpCiAgICAgICAgIHRlc3RfcmVzdWx0ID0gc2VsZi5fY29tcGFyZV9vdXRwdXRfd2l0aF9yZWZl cmVuY2UoZHJpdmVyX291dHB1dDEsIGRyaXZlcl9vdXRwdXQyKQogCiAgICAgICAgIHRlc3RfcmVz dWx0X3dyaXRlci53cml0ZV90ZXN0X3Jlc3VsdChzZWxmLl9wb3J0LCBzZWxmLl90ZXN0X25hbWUs IGRyaXZlcl9vdXRwdXQxLCBkcml2ZXJfb3V0cHV0MiwgdGVzdF9yZXN1bHQuZmFpbHVyZXMpCkBA IC0zMDgsNiArMzA0LDggQEAgY2xhc3MgU2luZ2xlVGVzdFJ1bm5lcjoKICAgICAgICAgaWYgZmFp bHVyZXM6CiAgICAgICAgICAgICByZXR1cm4gVGVzdFJlc3VsdChzZWxmLl90ZXN0X25hbWUsIGZh aWx1cmVzLCB0b3RhbF90ZXN0X3RpbWUsIGhhc19zdGRlcnIpCiAKKyAgICAgICAgYXNzZXJ0KGRy aXZlcl9vdXRwdXQxLmltYWdlX2hhc2ggb3IgZHJpdmVyX291dHB1dDIuaW1hZ2VfaGFzaCkKKwog ICAgICAgICBpZiBzZWxmLl9pc19taXNtYXRjaF9yZWZ0ZXN0OgogICAgICAgICAgICAgaWYgZHJp dmVyX291dHB1dDEuaW1hZ2VfaGFzaCA9PSBkcml2ZXJfb3V0cHV0Mi5pbWFnZV9oYXNoOgogICAg ICAgICAgICAgICAgIGZhaWx1cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVSZWZ0ZXN0 TWlzbWF0Y2hEaWROb3RPY2N1cihzZWxmLl9yZWZlcmVuY2VfZmlsZW5hbWUpKQpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvd29ya2Vy LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvd29y a2VyLnB5CmluZGV4IGFiOGFhNzU2ZDQ5NTkxZWZlY2U0MmU3NmY0MTFiMzZjMDE2ZTAyYzAuLjVk ZDMzYTI2ZDdkMTdlZDNjMDU3YzRlOTUyOGM2MjA3NzUwNDhhOGIgMTAwNjQ0Ci0tLSBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2NvbnRyb2xsZXJzL3dvcmtlci5weQorKysg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy93b3JrZXIu cHkKQEAgLTI0Myw3ICsyNDMsOSBAQCBjbGFzcyBXb3JrZXIobWFuYWdlcl93b3JrZXJfYnJva2Vy LkFic3RyYWN0V29ya2VyKToKIAogICAgICAgICBSZXR1cm5zOiBhIFRlc3RSZXN1bHQgb2JqZWN0 LgogICAgICAgICAiIiIKLSAgICAgICAgaWYgbm90IHNlbGYuX2RyaXZlciBvciBzZWxmLl9kcml2 ZXIucG9sbCgpIGlzIG5vdCBOb25lOgorICAgICAgICBpZiBzZWxmLl9kcml2ZXIgYW5kIHNlbGYu X2RyaXZlci5oYXNfY3Jhc2hlZCgpOgorICAgICAgICAgICAgc2VsZi5raWxsX2RyaXZlcigpCisg ICAgICAgIGlmIG5vdCBzZWxmLl9kcml2ZXI6CiAgICAgICAgICAgICBzZWxmLl9kcml2ZXIgPSBz ZWxmLl9wb3J0LmNyZWF0ZV9kcml2ZXIoc2VsZi5fd29ya2VyX251bWJlcikKICAgICAgICAgcmV0 dXJuIHNlbGYucnVuX3NpbmdsZV90ZXN0KHNlbGYuX2RyaXZlciwgdGVzdF9pbnB1dCkKIApkaWZm IC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5 IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5CmluZGV4 IGY1Y2EzN2Q5NjUzZDhkY2I0Yzk4ZTUyMjQ5YzAxNWU1MzQ3NjU1NDIuLmI3OTA5NDJhMjgyMzIz OTUyYmY3MDEwNWRkMGY1MmJlYzBmYTk0MzUgMTAwNzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZS5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKQEAgLTUzLDYgKzUzLDcgQEAgZnJvbSB3ZWJr aXRweS5jb21tb24uc3lzdGVtLmV4ZWN1dGl2ZSBpbXBvcnQgU2NyaXB0RXJyb3IKIGZyb20gd2Vi a2l0cHkubGF5b3V0X3Rlc3RzIGltcG9ydCByZWFkX2NoZWNrc3VtX2Zyb21fcG5nCiBmcm9tIHdl YmtpdHB5LmxheW91dF90ZXN0cy5tb2RlbHMudGVzdF9jb25maWd1cmF0aW9uIGltcG9ydCBUZXN0 Q29uZmlndXJhdGlvbgogZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydCBpbXBvcnQgY29u ZmlnIGFzIHBvcnRfY29uZmlnCitmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0IGltcG9y dCBkcml2ZXIKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQgaW1wb3J0IGh0dHBfbG9j awogZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydCBpbXBvcnQgdGVzdF9maWxlcwogZnJv bSB3ZWJraXRweS5sYXlvdXRfdGVzdHMuc2VydmVycyBpbXBvcnQgYXBhY2hlX2h0dHBfc2VydmVy CkBAIC02NjksNyArNjcwLDcgQEAgY2xhc3MgUG9ydChvYmplY3QpOgogCiAgICAgZGVmIGNyZWF0 ZV9kcml2ZXIoc2VsZiwgd29ya2VyX251bWJlcik6CiAgICAgICAgICIiIlJldHVybiBhIG5ld2x5 IGNyZWF0ZWQgRHJpdmVyIHN1YmNsYXNzIGZvciBzdGFydGluZy9zdG9wcGluZyB0aGUgdGVzdCBk cml2ZXIuIiIiCi0gICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IoJ1BvcnQuY3JlYXRl X2RyaXZlcicpCisgICAgICAgIHJldHVybiBkcml2ZXIuRHJpdmVyUHJveHkoc2VsZiwgd29ya2Vy X251bWJlciwgc2VsZi5fZHJpdmVyX2NsYXNzKCkpCiAKICAgICBkZWYgc3RhcnRfaGVscGVyKHNl bGYpOgogICAgICAgICAiIiJJZiBhIHBvcnQgbmVlZHMgdG8gcmVjb25maWd1cmUgZ3JhcGhpY3Mg c2V0dGluZ3Mgb3IgZG8gb3RoZXIKQEAgLTk2MywzICs5NjQsNyBAQCBjbGFzcyBQb3J0KG9iamVj dCk6CiAgICAgICAgICIiIkdlbmVyYXRlcyBhIGxpc3Qgb2YgVGVzdENvbmZpZ3VyYXRpb24gaW5z dGFuY2VzLCByZXByZXNlbnRpbmcgY29uZmlndXJhdGlvbnMKICAgICAgICAgZm9yIGEgcGxhdGZv cm0gYWNyb3NzIGFsbCBPU2VzLCBhcmNoaXRlY3R1cmVzLCBidWlsZCBhbmQgZ3JhcGhpY3MgdHlw ZXMuIiIiCiAgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IoJ1BvcnQuX2dlbmVyYXRl X3Rlc3RfY29uZmlndXJhdGlvbnMnKQorCisgICAgZGVmIF9kcml2ZXJfY2xhc3Moc2VsZik6Cisg ICAgICAgICIiIlJldHVybnMgdGhlIHBvcnQncyBkcml2ZXIgaW1wbGVtZW50YXRpb24uIiIiCisg ICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IoJ1BvcnQuX2RyaXZlcl9jbGFzcycpCmRp ZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2Vf dW5pdHRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jh c2VfdW5pdHRlc3QucHkKaW5kZXggOGY1NTJhMzM5YWJiMDA4M2I3YzE0NDA2Y2I2YjAwOWEzNGE0 ODNlMS4uZjMxZmQ4MGYzYWYxOTIwYmIzYWUwNDU1NTI5MjAxYTM3ZmMyZTJlMSAxMDA2NDQKLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlX3VuaXR0ZXN0 LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZV91 bml0dGVzdC5weQpAQCAtMzA5LDE3ICszMDksMTcgQEAgY2xhc3MgVmlydHVhbFRlc3QodW5pdHRl c3QuVGVzdENhc2UpOgogICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwocG9ydC5fcGF0aF90b193 ZGlmZikKIAogICAgIGRlZiB0ZXN0X3ZpcnR1YWxfZHJpdmVyX21ldGhvZHMoc2VsZik6Ci0gICAg ICAgIGRyaXZlciA9IERyaXZlcihOb25lLCBOb25lKQorICAgICAgICBkcml2ZXIgPSBEcml2ZXIo UG9ydChNb2NrSG9zdCgpKSwgTm9uZSkKICAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKGRyaXZl ci5ydW5fdGVzdCwgTm9uZSkKLSAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKGRyaXZlci5wb2xs KQogICAgICAgICBzZWxmLmFzc2VydFZpcnR1YWwoZHJpdmVyLnN0b3ApCisgICAgICAgIHNlbGYu YXNzZXJ0VmlydHVhbChkcml2ZXIuY21kX2xpbmUpCiAKIAogIyBGSVhNRTogVGhpcyBzaG91bGQg YmUgbW92ZWQgdG8gZHJpdmVyX3VuaXR0ZXN0LnB5IG9yIGp1c3QgZGVsZXRlZC4KIGNsYXNzIERy aXZlclRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogCiAgICAgZGVmIF9hc3NlcnRfd3JhcHBlcihz ZWxmLCB3cmFwcGVyX3N0cmluZywgZXhwZWN0ZWRfd3JhcHBlcik6Ci0gICAgICAgIHdyYXBwZXIg PSBEcml2ZXIoTm9uZSwgTm9uZSkuX2NvbW1hbmRfd3JhcHBlcih3cmFwcGVyX3N0cmluZykKKyAg ICAgICAgd3JhcHBlciA9IERyaXZlcihQb3J0KE1vY2tIb3N0KCkpLCBOb25lKS5fY29tbWFuZF93 cmFwcGVyKHdyYXBwZXJfc3RyaW5nKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHdyYXBwZXIs IGV4cGVjdGVkX3dyYXBwZXIpCiAKICAgICBkZWYgdGVzdF9jb21tYW5kX3dyYXBwZXIoc2VsZik6 CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2No cm9taXVtLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJv bWl1bS5weQppbmRleCAxZTk3MzBkNTM3YTQ5NzdiODdiNmIzZWM2NjY5NzcyYjNiNGEwNDRhLi45 OWFlYmYxMTEwOGQwMTllYjExODdjYmI0NmE2OTQwOTFlMGRjOTdjIDEwMDc1NQotLS0gYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5CisrKyBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkKQEAgLTI1 Miw5ICsyNTIsOCBAQCBjbGFzcyBDaHJvbWl1bVBvcnQoUG9ydCk6CiAgICAgICAgIGlmIHNlbGYu X2ZpbGVzeXN0ZW0uZXhpc3RzKGNhY2hlZGlyKToKICAgICAgICAgICAgIHNlbGYuX2ZpbGVzeXN0 ZW0ucm10cmVlKGNhY2hlZGlyKQogCi0gICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwgd29ya2Vy X251bWJlcik6Ci0gICAgICAgICIiIlN0YXJ0cyBhIG5ldyBEcml2ZXIgYW5kIHJldHVybnMgYSBo YW5kbGUgdG8gaXQuIiIiCi0gICAgICAgIHJldHVybiBDaHJvbWl1bURyaXZlcihzZWxmLCB3b3Jr ZXJfbnVtYmVyKQorICAgIGRlZiBfZHJpdmVyX2NsYXNzKHNlbGYpOgorICAgICAgICByZXR1cm4g Q2hyb21pdW1Ecml2ZXIKIAogICAgIGRlZiBzdGFydF9oZWxwZXIoc2VsZik6CiAgICAgICAgIGhl bHBlcl9wYXRoID0gc2VsZi5fcGF0aF90b19oZWxwZXIoKQpAQCAtNDAwLDE2ICszOTksMTYgQEAg Y2xhc3MgQ2hyb21pdW1Qb3J0KFBvcnQpOgogCiAjIEZJWE1FOiBUaGlzIHNob3VsZCBpbmhlcml0 IGZyb20gV2ViS2l0RHJpdmVyIG5vdyB0aGF0IENocm9taXVtIGhhcyBhIER1bXBSZW5kZXJUcmVl IHByb2Nlc3MgbGlrZSB0aGUgcmVzdCBvZiBXZWJLaXQuCiBjbGFzcyBDaHJvbWl1bURyaXZlcihE cml2ZXIpOgotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyKToKLSAg ICAgICAgRHJpdmVyLl9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIpCisgICAgZGVm IF9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIsIGZvcmNlX3BpeGVsX3Jlc3VsdHM9 RmFsc2UpOgorICAgICAgICBEcml2ZXIuX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJl ciwgZm9yY2VfcGl4ZWxfcmVzdWx0cykKICAgICAgICAgc2VsZi5fcHJvYyA9IE5vbmUKICAgICAg ICAgc2VsZi5faW1hZ2VfcGF0aCA9IE5vbmUKLSAgICAgICAgaWYgc2VsZi5fcG9ydC5nZXRfb3B0 aW9uKCdwaXhlbF90ZXN0cycpOgorICAgICAgICBpZiBzZWxmLl9waXhlbF90ZXN0czoKICAgICAg ICAgICAgIHNlbGYuX2ltYWdlX3BhdGggPSBzZWxmLl9wb3J0Ll9maWxlc3lzdGVtLmpvaW4oc2Vs Zi5fcG9ydC5yZXN1bHRzX2RpcmVjdG9yeSgpLCAncG5nX3Jlc3VsdCVzLnBuZycgJSBzZWxmLl93 b3JrZXJfbnVtYmVyKQogCiAgICAgZGVmIF93cmFwcGVyX29wdGlvbnMoc2VsZik6CiAgICAgICAg IGNtZCA9IFtdCi0gICAgICAgIGlmIHNlbGYuX3BvcnQuZ2V0X29wdGlvbigncGl4ZWxfdGVzdHMn KToKKyAgICAgICAgaWYgc2VsZi5fcGl4ZWxfdGVzdHM6CiAgICAgICAgICAgICAjIFNlZSBub3Rl IGFib3ZlIGluIGRpZmZfaW1hZ2UoKSBmb3Igd2h5IHdlIG5lZWQgX2NvbnZlcnRfcGF0aCgpLgog ICAgICAgICAgICAgY21kLmFwcGVuZCgiLS1waXhlbC10ZXN0cz0iICsgc2VsZi5fcG9ydC5fY29u dmVydF9wYXRoKHNlbGYuX2ltYWdlX3BhdGgpKQogICAgICAgICAjIEZJWE1FOiBUaGlzIGlzIG5v dCBOb25lIHNob3VsZG4ndCBiZSBuZWNlc3NhcnksIHVubGVzcyAtLWpzLWZsYWdzPSInJyIgY2hh bmdlcyBiZWhhdmlvciBzb21laG93PwpAQCAtNDU1LDggKzQ1NCwxMCBAQCBjbGFzcyBDaHJvbWl1 bURyaXZlcihEcml2ZXIpOgogICAgICAgICBjbG9zZV9mZHMgPSBzeXMucGxhdGZvcm0gbm90IGlu ICgnd2luMzInLCAnY3lnd2luJykKICAgICAgICAgc2VsZi5fcHJvYyA9IHN1YnByb2Nlc3MuUG9w ZW4oc2VsZi5jbWRfbGluZSgpLCBzdGRpbj1zdWJwcm9jZXNzLlBJUEUsIHN0ZG91dD1zdWJwcm9j ZXNzLlBJUEUsIHN0ZGVycj1zdWJwcm9jZXNzLlNURE9VVCwgY2xvc2VfZmRzPWNsb3NlX2ZkcykK IAotICAgIGRlZiBwb2xsKHNlbGYpOgotICAgICAgICByZXR1cm4gc2VsZi5fcHJvYy5wb2xsKCkK KyAgICBkZWYgaGFzX2NyYXNoZWQoc2VsZik6CisgICAgICAgIGlmIHNlbGYuX3Byb2MgaXMgTm9u ZToKKyAgICAgICAgICAgIHJldHVybiBGYWxzZQorICAgICAgICByZXR1cm4gc2VsZi5fcHJvYy5w b2xsKCkgaXMgbm90IE5vbmUKIAogICAgIGRlZiBfd3JpdGVfY29tbWFuZF9hbmRfcmVhZF9saW5l KHNlbGYsIGlucHV0PU5vbmUpOgogICAgICAgICAiIiJSZXR1cm5zIGEgdHVwbGU6IChsaW5lLCBk aWRfY3Jhc2gpIiIiCkBAIC01MzEsNyArNTMyLDcgQEAgY2xhc3MgQ2hyb21pdW1Ecml2ZXIoRHJp dmVyKToKIAogICAgICAgICB3aGlsZSBub3QgY3Jhc2ggYW5kIGxpbmUucnN0cmlwKCkgIT0gIiNF T0YiOgogICAgICAgICAgICAgIyBNYWtlIHN1cmUgd2UgaGF2ZW4ndCBjcmFzaGVkLgotICAgICAg ICAgICAgaWYgbGluZSA9PSAnJyBhbmQgc2VsZi5wb2xsKCkgaXMgbm90IE5vbmU6CisgICAgICAg ICAgICBpZiBsaW5lID09ICcnIGFuZCBzZWxmLl9wcm9jLnBvbGwoKSBpcyBub3QgTm9uZToKICAg ICAgICAgICAgICAgICAjIFRoaXMgaXMgaGV4IGNvZGUgMHhjMDAwMDAxZCwgd2hpY2ggaXMgdXNl ZCBmb3IgYWJydXB0CiAgICAgICAgICAgICAgICAgIyB0ZXJtaW5hdGlvbi4gVGhpcyBoYXBwZW5z IGlmIHdlIGhpdCBjdHJsK2MgZnJvbSB0aGUgcHJvbXB0CiAgICAgICAgICAgICAgICAgIyBhbmQg d2UgaGFwcGVuIHRvIGJlIHdhaXRpbmcgb24gRFJULgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcml2ZXIucHkgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2RyaXZlci5weQppbmRleCBiNzQyZGFiZjEyNmExNzUx NDcxODVhNTY2ZTY1NTk1MmRiYTdkN2MyLi42YzRmMmI5ZTJhMDg0OWFmOTE5MDc0NWZiYzRiNDJm MmNhZTk5MDg0IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L2RyaXZlci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L2RyaXZlci5weQpAQCAtMzAsMTAgKzMwLDExIEBAIGltcG9ydCBzaGxleAogCiAKIGNs YXNzIERyaXZlcklucHV0KG9iamVjdCk6Ci0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHRlc3RfbmFt ZSwgdGltZW91dCwgaW1hZ2VfaGFzaCk6CisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHRlc3RfbmFt ZSwgdGltZW91dCwgaW1hZ2VfaGFzaCwgaXNfcmVmdGVzdCk6CiAgICAgICAgIHNlbGYudGVzdF9u YW1lID0gdGVzdF9uYW1lCiAgICAgICAgIHNlbGYudGltZW91dCA9IHRpbWVvdXQgICMgaW4gbXMK ICAgICAgICAgc2VsZi5pbWFnZV9oYXNoID0gaW1hZ2VfaGFzaAorICAgICAgICBzZWxmLmlzX3Jl ZnRlc3QgPSBpc19yZWZ0ZXN0CiAKIAogY2xhc3MgRHJpdmVyT3V0cHV0KG9iamVjdCk6CkBAIC01 NywxMCArNTgsMTAgQEAgY2xhc3MgRHJpdmVyT3V0cHV0KG9iamVjdCk6CiAgICAgICAgIHJldHVy biBib29sKHNlbGYuZXJyb3IpCiAKIAotY2xhc3MgRHJpdmVyOgorY2xhc3MgRHJpdmVyKG9iamVj dCk6CiAgICAgIiIiQWJzdHJhY3QgaW50ZXJmYWNlIGZvciB0aGUgRHVtcFJlbmRlclRyZWUgaW50 ZXJmYWNlLiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIp OgorICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyLCBmb3JjZV9waXhl bF9yZXN1bHRzPUZhbHNlKToKICAgICAgICAgIiIiSW5pdGlhbGl6ZSBhIERyaXZlciB0byBzdWJz ZXF1ZW50bHkgcnVuIHRlc3RzLgogCiAgICAgICAgIFR5cGljYWxseSB0aGlzIHJvdXRpbmUgd2ls bCBzcGF3biBEdW1wUmVuZGVyVHJlZSBpbiBhIGNvbmZpZwpAQCAtNzEsNiArNzIsNyBAQCBjbGFz cyBEcml2ZXI6CiAgICAgICAgICIiIgogICAgICAgICBzZWxmLl9wb3J0ID0gcG9ydAogICAgICAg ICBzZWxmLl93b3JrZXJfbnVtYmVyID0gd29ya2VyX251bWJlcgorICAgICAgICBzZWxmLl9waXhl bF90ZXN0cyA9IGZvcmNlX3BpeGVsX3Jlc3VsdHMgb3Igc2VsZi5fcG9ydC5nZXRfb3B0aW9uKCdw aXhlbF90ZXN0cycpCiAKICAgICBkZWYgcnVuX3Rlc3Qoc2VsZiwgZHJpdmVyX2lucHV0KToKICAg ICAgICAgIiIiUnVuIGEgc2luZ2xlIHRlc3QgYW5kIHJldHVybiB0aGUgcmVzdWx0cy4KQEAgLTg5 LDkgKzkxLDQyIEBAIGNsYXNzIERyaXZlcjoKICAgICAgICAgIyB1c2VkIGJ5IGUuZy4gdG9vbHMv dmFsZ3JpbmQvdmFsZ3JpbmRfdGVzdHMucHkuCiAgICAgICAgIHJldHVybiBzaGxleC5zcGxpdCh3 cmFwcGVyX29wdGlvbikgaWYgd3JhcHBlcl9vcHRpb24gZWxzZSBbXQogCi0gICAgZGVmIHBvbGwo c2VsZik6Ci0gICAgICAgICIiIlJldHVybnMgTm9uZSBpZiB0aGUgRHJpdmVyIGlzIHN0aWxsIHJ1 bm5pbmcuIFJldHVybnMgdGhlIHJldHVybmNvZGUgaWYgaXQgaGFzIGV4aXRlZC4iIiIKLSAgICAg ICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcignRHJpdmVyLnBvbGwnKQorICAgIGRlZiBoYXNf Y3Jhc2hlZChzZWxmKToKKyAgICAgICAgcmV0dXJuIEZhbHNlCiAKICAgICBkZWYgc3RvcChzZWxm KToKICAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcignRHJpdmVyLnN0b3AnKQorCisg ICAgZGVmIGNtZF9saW5lKHNlbGYpOgorICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9y KCdEcml2ZXIuY21kX2xpbmUnKQorCisKK2NsYXNzIERyaXZlclByb3h5KG9iamVjdCk6CisgICAg IiIiQSB3cmFwcGVyIGZvciBtYW5hZ2luZyB0d28gRHJpdmVyIGluc3RhbmNlcywgb25lIHdpdGgg cGl4ZWwgdGVzdHMgYW5kCisgICAgb25lIHdpdGhvdXQuIFRoaXMgYWxsb3dzIHVzIHRvIGhhbmRs ZSBwbGFpbiB0ZXh0IHRlc3RzIGFuZCByZWYgdGVzdHMgd2l0aCBhCisgICAgc2luZ2xlIGRyaXZl ci4iIiIKKworICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyLCBkcml2 ZXJfaW5zdGFuY2VfY29uc3RydWN0b3IpOgorICAgICAgICBzZWxmLl9kcml2ZXIgPSBkcml2ZXJf aW5zdGFuY2VfY29uc3RydWN0b3IocG9ydCwgd29ya2VyX251bWJlcikKKyAgICAgICAgaWYgcG9y dC5nZXRfb3B0aW9uKCdwaXhlbF90ZXN0cycpOgorICAgICAgICAgICAgc2VsZi5fcmVmdGVzdF9k cml2ZXIgPSBzZWxmLl9kcml2ZXIKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIHNlbGYuX3Jl ZnRlc3RfZHJpdmVyID0gZHJpdmVyX2luc3RhbmNlX2NvbnN0cnVjdG9yKHBvcnQsIHdvcmtlcl9u dW1iZXIsIGZvcmNlX3BpeGVsX3Jlc3VsdHM9VHJ1ZSkKKworICAgIGRlZiBydW5fdGVzdChzZWxm LCBkcml2ZXJfaW5wdXQpOgorICAgICAgICBpZiBkcml2ZXJfaW5wdXQuaXNfcmVmdGVzdDoKKyAg ICAgICAgICAgIHJldHVybiBzZWxmLl9yZWZ0ZXN0X2RyaXZlci5ydW5fdGVzdChkcml2ZXJfaW5w dXQpCisgICAgICAgIHJldHVybiBzZWxmLl9kcml2ZXIucnVuX3Rlc3QoZHJpdmVyX2lucHV0KQor CisgICAgZGVmIGhhc19jcmFzaGVkKHNlbGYpOgorICAgICAgICByZXR1cm4gc2VsZi5fZHJpdmVy Lmhhc19jcmFzaGVkKCkgb3Igc2VsZi5fcmVmdGVzdF9kcml2ZXIuaGFzX2NyYXNoZWQoKQorCisg ICAgZGVmIHN0b3Aoc2VsZik6CisgICAgICAgIHNlbGYuX2RyaXZlci5zdG9wKCkKKyAgICAgICAg c2VsZi5fcmVmdGVzdF9kcml2ZXIuc3RvcCgpCisKKyAgICBkZWYgY21kX2xpbmUoc2VsZik6Cisg ICAgICAgIGNtZF9saW5lID0gc2VsZi5fZHJpdmVyLmNtZF9saW5lKCkKKyAgICAgICAgaWYgc2Vs Zi5fZHJpdmVyICE9IHNlbGYuX3JlZnRlc3RfZHJpdmVyOgorICAgICAgICAgICAgY21kX2xpbmUg Kz0gWyc7ICddICsgc2VsZi5fcmVmdGVzdF9kcml2ZXIuY21kX2xpbmUoKQorICAgICAgICByZXR1 cm4gY21kX2xpbmUKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvZHJ5cnVuLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9kcnlydW4ucHkKaW5kZXggY2EzYmFkZTNkOGU4ZmRlYzk4NDhhYjhjNWFhZjgxOTljNTUy YTcwMS4uODk3NTVlNmZiNTVjZjkzNGM2ODhkNzlhYzkwNzJlNGY3ZDQ1ZjQxYiAxMDA2NDQKLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHkKKysr IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHkKQEAg LTEwOSw5ICsxMDksNiBAQCBjbGFzcyBEcnlydW5Ecml2ZXIoRHJpdmVyKToKICAgICBkZWYgY21k X2xpbmUoc2VsZik6CiAgICAgICAgIHJldHVybiBbJ05vbmUnXQogCi0gICAgZGVmIHBvbGwoc2Vs Zik6Ci0gICAgICAgIHJldHVybiBOb25lCi0KICAgICBkZWYgcnVuX3Rlc3Qoc2VsZiwgZHJpdmVy X2lucHV0KToKICAgICAgICAgc3RhcnRfdGltZSA9IHRpbWUudGltZSgpCiAgICAgICAgIGZzID0g c2VsZi5fcG9ydC5fZmlsZXN5c3RlbQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2d0ay5weQppbmRleCAzZWVkODI5MTQ2Y2U0Yjk0OTY3ZjQ5MDBkYTQ3NTMw MzA5NTRiYjY0Li5mZTFlYjA1OGU3MzBhZmMwMTI4N2NkOGNjYWQ5NmEzNDE0OTFkOTAzIDEwMDY0 NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2d0ay5weQor KysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2d0ay5weQpAQCAt NzIsOCArNzIsOCBAQCBjbGFzcyBHdGtQb3J0KFdlYktpdFBvcnQpOgogICAgIGRlZiBfcG9ydF9m bGFnX2Zvcl9zY3JpcHRzKHNlbGYpOgogICAgICAgICByZXR1cm4gIi0tZ3RrIgogCi0gICAgZGVm IGNyZWF0ZV9kcml2ZXIoc2VsZiwgd29ya2VyX251bWJlcik6Ci0gICAgICAgIHJldHVybiBHdGtE cml2ZXIoc2VsZiwgd29ya2VyX251bWJlcikKKyAgICBkZWYgX2RyaXZlcl9jbGFzcyhzZWxmKToK KyAgICAgICAgcmV0dXJuIEd0a0RyaXZlcgogCiAgICAgZGVmIHNldHVwX2Vudmlyb25fZm9yX3Nl cnZlcihzZWxmLCBzZXJ2ZXJfbmFtZT1Ob25lKToKICAgICAgICAgZW52aXJvbm1lbnQgPSBXZWJL aXRQb3J0LnNldHVwX2Vudmlyb25fZm9yX3NlcnZlcihzZWxmLCBzZXJ2ZXJfbmFtZSkKZGlmZiAt LWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdC5weSBi L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdC5weQppbmRleCA3 ZTVkOTU2ZWU0ZDQxMGIwNDhiNzM0YzMzNDg2ZmE4ZDhhMTkwNzhkLi40OWY2NDU1MmM1YjEwZjQ5 MGM5N2Y4NWZjOWU3ZmJjYWFhZDIyNzJlIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5CkBAIC0zNTksOCArMzU5LDggQEAgY2xhc3MgVGVz dFBvcnQoUG9ydCk6CiAgICAgZGVmIHNldHVwX3Rlc3RfcnVuKHNlbGYpOgogICAgICAgICBwYXNz CiAKLSAgICBkZWYgY3JlYXRlX2RyaXZlcihzZWxmLCB3b3JrZXJfbnVtYmVyKToKLSAgICAgICAg cmV0dXJuIFRlc3REcml2ZXIoc2VsZiwgd29ya2VyX251bWJlcikKKyAgICBkZWYgX2RyaXZlcl9j bGFzcyhzZWxmKToKKyAgICAgICAgcmV0dXJuIFRlc3REcml2ZXIKIAogICAgIGRlZiBzdGFydF9o dHRwX3NlcnZlcihzZWxmKToKICAgICAgICAgcGFzcwpAQCAtNDg4LDkgKzQ4OCw2IEBAIGNsYXNz IFRlc3REcml2ZXIoRHJpdmVyKToKICAgICBkZWYgY21kX2xpbmUoc2VsZik6CiAgICAgICAgIHJl dHVybiBbc2VsZi5fcG9ydC5fcGF0aF90b19kcml2ZXIoKV0gKyBzZWxmLl9wb3J0LmdldF9vcHRp b24oJ2FkZGl0aW9uYWxfZHJ0X2ZsYWcnLCBbXSkKIAotICAgIGRlZiBwb2xsKHNlbGYpOgotICAg ICAgICByZXR1cm4gVHJ1ZQotCiAgICAgZGVmIHJ1bl90ZXN0KHNlbGYsIHRlc3RfaW5wdXQpOgog ICAgICAgICBzdGFydF90aW1lID0gdGltZS50aW1lKCkKICAgICAgICAgdGVzdF9uYW1lID0gdGVz dF9pbnB1dC50ZXN0X25hbWUKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC93ZWJraXQucHkKaW5kZXggOTU2MTFiNGEyZjFlM2Y3MWRjY2NlYjExYTViMmYz NWViYjgyZDIxOC4uZjNlMzA0NTE3OGVmNzMwMGVkZWNhYzkyNjY3YTQ0OTg4MDQ1ZDBlNCAxMDA2 NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQu cHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQu cHkKQEAgLTIyNSw4ICsyMjUsOCBAQCBjbGFzcyBXZWJLaXRQb3J0KFBvcnQpOgogICAgICAgICAj IHRvIGhhdmUgbXVsdGlwbGUgY29waWVzIG9mIHdlYmtpdCBjaGVja2VkIG91dCBhbmQgYnVpbHQu CiAgICAgICAgIHJldHVybiBzZWxmLl9idWlsZF9wYXRoKCdsYXlvdXQtdGVzdC1yZXN1bHRzJykK IAotICAgIGRlZiBjcmVhdGVfZHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpOgotICAgICAgICBy ZXR1cm4gV2ViS2l0RHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpCisgICAgZGVmIF9kcml2ZXJf Y2xhc3Moc2VsZik6CisgICAgICAgIHJldHVybiBXZWJLaXREcml2ZXIKIAogICAgIGRlZiBfdGVz dHNfZm9yX290aGVyX3BsYXRmb3JtcyhzZWxmKToKICAgICAgICAgIyBCeSBkZWZhdWx0IHdlIHdp bGwgc2tpcCBhbnkgZGlyZWN0b3J5IHVuZGVyIExheW91dFRlc3RzL3BsYXRmb3JtCkBAIC00NDAs OCArNDQwLDggQEAgY2xhc3MgV2ViS2l0UG9ydChQb3J0KToKIGNsYXNzIFdlYktpdERyaXZlcihE cml2ZXIpOgogICAgICIiIldlYktpdCBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgRHVtcFJlbmRlclRy ZWUvV2ViS2l0VGVzdFJ1bm5lciBpbnRlcmZhY2UuIiIiCiAKLSAgICBkZWYgX19pbml0X18oc2Vs ZiwgcG9ydCwgd29ya2VyX251bWJlcik6Ci0gICAgICAgIERyaXZlci5fX2luaXRfXyhzZWxmLCBw b3J0LCB3b3JrZXJfbnVtYmVyKQorICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJf bnVtYmVyLCBmb3JjZV9waXhlbF9yZXN1bHRzPUZhbHNlKToKKyAgICAgICAgRHJpdmVyLl9faW5p dF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIsIGZvcmNlX3BpeGVsX3Jlc3VsdHMpCiAgICAg ICAgIHNlbGYuX2RyaXZlcl90ZW1wZGlyID0gcG9ydC5fZmlsZXN5c3RlbS5ta2R0ZW1wKHByZWZp eD0nJXMtJyAlIHNlbGYuX3BvcnQuZHJpdmVyX25hbWUoKSkKICAgICAgICAgIyBXZWJLaXRUZXN0 UnVubmVyIGNhbiByZXBvcnQgYmFjayBzdWJwcm9jZXNzIGNyYXNoZXMgYnkgcHJpbnRpbmcKICAg ICAgICAgIyAiI0NSQVNIRUQgLSBQUk9DRVNTTkFNRSIuICBTaW5jZSB0aG9zZSBjYW4gaGFwcGVu IGF0IGFueSB0aW1lCkBAIC00NTcsNyArNDU3LDYgQEAgY2xhc3MgV2ViS2l0RHJpdmVyKERyaXZl cik6CiAgICAgICAgIHNlbGYuZXJyX3NlZW5fZW9mID0gRmFsc2UKICAgICAgICAgc2VsZi5fc2Vy dmVyX3Byb2Nlc3MgPSBOb25lCiAKLQogICAgICMgRklYTUU6IFRoaXMgbWF5IGJlIHVuc2FmZSwg YXMgcHl0aG9uIGRvZXMgbm90IGd1YXJlbnRlZSBhbnkgb3JkZXJpbmcgb2YgX19kZWxfXyBjYWxs cwogICAgICMgSSBiZWxpZXZlIGl0J3MgcG9zc2libGUgdGhhdCBzZWxmLl9wb3J0IG9yIHNlbGYu X3BvcnQuX2ZpbGVzeXN0ZW0gbWF5IGFscmVhZHkgYmUgZGVzdHJveWVkLgogICAgIGRlZiBfX2Rl bF9fKHNlbGYpOgpAQCAtNDY2LDcgKzQ2NSw3IEBAIGNsYXNzIFdlYktpdERyaXZlcihEcml2ZXIp OgogICAgIGRlZiBjbWRfbGluZShzZWxmKToKICAgICAgICAgY21kID0gc2VsZi5fY29tbWFuZF93 cmFwcGVyKHNlbGYuX3BvcnQuZ2V0X29wdGlvbignd3JhcHBlcicpKQogICAgICAgICBjbWQuYXBw ZW5kKHNlbGYuX3BvcnQuX3BhdGhfdG9fZHJpdmVyKCkpCi0gICAgICAgIGlmIHNlbGYuX3BvcnQu Z2V0X29wdGlvbigncGl4ZWxfdGVzdHMnKToKKyAgICAgICAgaWYgc2VsZi5fcGl4ZWxfdGVzdHM6 CiAgICAgICAgICAgICBjbWQuYXBwZW5kKCctLXBpeGVsLXRlc3RzJykKICAgICAgICAgaWYgc2Vs Zi5fcG9ydC5nZXRfb3B0aW9uKCdnY19iZXR3ZWVuX3Rlc3RzJyk6CiAgICAgICAgICAgICBjbWQu YXBwZW5kKCctLWdjLWJldHdlZW4tdGVzdHMnKQpAQCAtNDkwLDggKzQ4OSwxMCBAQCBjbGFzcyBX ZWJLaXREcml2ZXIoRHJpdmVyKToKICAgICAgICAgc2VsZi5fY3Jhc2hlZF9zdWJwcm9jZXNzX25h bWUgPSBOb25lCiAgICAgICAgIHNlbGYuX3NlcnZlcl9wcm9jZXNzID0gc2VydmVyX3Byb2Nlc3Mu U2VydmVyUHJvY2VzcyhzZWxmLl9wb3J0LCBzZXJ2ZXJfbmFtZSwgc2VsZi5jbWRfbGluZSgpLCBl bnZpcm9ubWVudCkKIAotICAgIGRlZiBwb2xsKHNlbGYpOgotICAgICAgICByZXR1cm4gc2VsZi5f c2VydmVyX3Byb2Nlc3MucG9sbCgpCisgICAgZGVmIGhhc19jcmFzaGVkKHNlbGYpOgorICAgICAg ICBpZiBzZWxmLl9zZXJ2ZXJfcHJvY2VzcyBpcyBOb25lOgorICAgICAgICAgICAgcmV0dXJuIEZh bHNlCisgICAgICAgIHJldHVybiBzZWxmLl9zZXJ2ZXJfcHJvY2Vzcy5wb2xsKCkgaXMgbm90IE5v bmUKIAogICAgIGRlZiBfY2hlY2tfZm9yX2RyaXZlcl9jcmFzaChzZWxmLCBlcnJvcl9saW5lKToK ICAgICAgICAgaWYgZXJyb3JfbGluZSA9PSAiI0NSQVNIRURcbiI6CmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5IGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQppbmRl eCA2ZDYyN2I2NDhiN2EyZDJmYTFkZmNhMzlhNGRjMjlmN2VlYWUwOGQwLi5lZDc4YjEyZmIyMzRj Y2I4Yzg0MTM4ZDdjMjJlZmM3YjgxMDRkNDI1IDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CisrKyBiL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKQEAgLTI3NCw2ICsy NzQsOCBAQCBkZWYgcGFyc2VfYXJncyhhcmdzPU5vbmUpOgogICAgICAgICAgICAgZGVzdD0icGl4 ZWxfdGVzdHMiLCBoZWxwPSJEaXNhYmxlIHBpeGVsLXRvLXBpeGVsIFBORyBjb21wYXJpc29ucyIp LAogICAgICAgICBvcHRwYXJzZS5tYWtlX29wdGlvbigiLS1uby1zYW1wbGUtb24tdGltZW91dCIs IGFjdGlvbj0ic3RvcmVfZmFsc2UiLAogICAgICAgICAgICAgZGVzdD0ic2FtcGxlX29uX3RpbWVv dXQiLCBoZWxwPSJEb24ndCBydW4gc2FtcGxlIG9uIHRpbWVvdXQgKE1hYyBPUyBYIG9ubHkpIiks CisgICAgICAgIG9wdHBhcnNlLm1ha2Vfb3B0aW9uKCItLW5vLXJlZi10ZXN0cyIsIGFjdGlvbj0i c3RvcmVfdHJ1ZSIsCisgICAgICAgICAgICBkZXN0PSJub19yZWZfdGVzdHMiLCBoZWxwPSJTa2lw IGFsbCByZWYgdGVzdHMiKSwKICAgICAgICAgb3B0cGFyc2UubWFrZV9vcHRpb24oIi0tdG9sZXJh bmNlIiwKICAgICAgICAgICAgIGhlbHA9Iklnbm9yZSBpbWFnZSBkaWZmZXJlbmNlcyBsZXNzIHRo YW4gdGhpcyBwZXJjZW50YWdlIChzb21lICIKICAgICAgICAgICAgICAgICAicG9ydHMgbWF5IGln bm9yZSB0aGlzIG9wdGlvbikiLCB0eXBlPSJmbG9hdCIpLApkaWZmIC0tZ2l0IGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0c19pbnRlZ3JhdGlvbnRl c3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rl c3RzX2ludGVncmF0aW9udGVzdC5weQppbmRleCBhNjQ0NmM1MmQ5ODI3NDI5NzA2NjI3N2YxMGEw N2UyYjk4MDY5MjliLi42ZWNmZDQ5YjZlODliZjI4OWNiODNlZDcwMTk2OGY1M2FmM2UzMGRlIDEw MDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0 X3Rlc3RzX2ludGVncmF0aW9udGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX2ludGVncmF0aW9udGVzdC5weQpAQCAtMTU1LDEw ICsxNTUsNiBAQCBkZWYgZ2V0X3Rlc3RzX3J1bihleHRyYV9hcmdzPU5vbmUsIHRlc3RzX2luY2x1 ZGVkPUZhbHNlLCBmbGF0dGVuX2JhdGNoZXM9RmFsc2UsCiAgICAgICAgICAgICBUZXN0RHJpdmVy Ll9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIpCiAgICAgICAgICAgICBzZWxmLl9j dXJyZW50X3Rlc3RfYmF0Y2ggPSBOb25lCiAKLSAgICAgICAgZGVmIHBvbGwoc2VsZik6Ci0gICAg ICAgICAgICAjIFNvIHRoYXQgd2UgZG9uJ3QgY3JlYXRlIGEgbmV3IGRyaXZlciBmb3IgZXZlcnkg dGVzdAotICAgICAgICAgICAgcmV0dXJuIE5vbmUKLQogICAgICAgICBkZWYgc3RvcChzZWxmKToK ICAgICAgICAgICAgIHNlbGYuX2N1cnJlbnRfdGVzdF9iYXRjaCA9IE5vbmUKIApAQCAtNjgwLDgg KzY3NiwxNCBAQCBjbGFzcyBNYWluVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgIHRl c3RzX3J1biA9IGdldF90ZXN0c19ydW4oWydwYXNzZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX2lu Y2x1ZGVkPVRydWUsIGZsYXR0ZW5fYmF0Y2hlcz1UcnVlKQogICAgICAgICBzZWxmLmFzc2VydEVx dWFscyhbJ3Bhc3Nlcy9yZWZ0ZXN0Lmh0bWwnXSwgdGVzdHNfcnVuKQogCi0gICAgZGVmIHRlc3Rf cmVmdGVzdF9za2lwX3JlZnRlc3RzX2lmX3BpeGVsX3Rlc3RzX2FyZV9kaXNhYmxlZChzZWxmKToK KyAgICBkZWYgdGVzdF9yZWZ0ZXN0X3J1bl9yZWZ0ZXN0c19pZl9waXhlbF90ZXN0c19hcmVfZGlz YWJsZWQoc2VsZik6CiAgICAgICAgIHRlc3RzX3J1biA9IGdldF90ZXN0c19ydW4oWyctLW5vLXBp eGVsLXRlc3RzJywgJ3Bhc3Nlcy9yZWZ0ZXN0Lmh0bWwnXSwgdGVzdHNfaW5jbHVkZWQ9VHJ1ZSwg ZmxhdHRlbl9iYXRjaGVzPVRydWUpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWxzKFsncGFzc2Vz L3JlZnRlc3QuaHRtbCddLCB0ZXN0c19ydW4pCisKKyAgICBkZWYgdGVzdF9yZWZ0ZXN0X3NraXBf cmVmdGVzdHNfaWZfbm9fcmVmX3Rlc3RzKHNlbGYpOgorICAgICAgICB0ZXN0c19ydW4gPSBnZXRf dGVzdHNfcnVuKFsnLS1uby1yZWYtdGVzdHMnLCAncGFzc2VzL3JlZnRlc3QuaHRtbCddLCB0ZXN0 c19pbmNsdWRlZD1UcnVlLCBmbGF0dGVuX2JhdGNoZXM9VHJ1ZSkKKyAgICAgICAgc2VsZi5hc3Nl cnRFcXVhbHMoW10sIHRlc3RzX3J1bikKKyAgICAgICAgdGVzdHNfcnVuID0gZ2V0X3Rlc3RzX3J1 bihbJy0tbm8tcmVmLXRlc3RzJywgJy0tbm8tcGl4ZWwtdGVzdHMnLCAncGFzc2VzL3JlZnRlc3Qu aHRtbCddLCB0ZXN0c19pbmNsdWRlZD1UcnVlLCBmbGF0dGVuX2JhdGNoZXM9VHJ1ZSkKICAgICAg ICAgc2VsZi5hc3NlcnRFcXVhbHMoW10sIHRlc3RzX3J1bikKIAogICAgIGRlZiB0ZXN0X3JlZnRl c3RfZXhwZWN0ZWRfaHRtbF9zaG91bGRfYmVfaWdub3JlZChzZWxmKToK 115206 2011-11-15 11:16:48 -0800 2011-11-15 12:37:11 -0800 Patch bug-60605-20111115111705.patch text/plain 22618 tony U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMjkyCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYmM0OWY1OTk3ODYxZGRjYjUzODdhZjE0ZTdjN2ZmODE2 ZTgwZTY2Yy4uZWU5NDY1MjE4NTRiN2MxNjgxYWIyZjBjZWE3MWMxNzAwNDQyOTg3YiAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0 IEBACisyMDExLTExLTE0ICBUb255IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgW05SV1RdIFJlZnRlc3RzIHNob3VsZCBydW4gZXZlbiB3aGVuIHBpeGVsIHRlc3RzIGFyZSBk aXNhYmxlZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTYwNjA1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVzdF9y dW5uZXIucHk6IE9ubHkgc2tpcCByZWYgdGVzdHMgaWYgLS1uby1yZWYtdGVzdHMgaXMgcGFzc2Vk LgorICAgICAgICAgICAgQWxzbyBhZGQgYW4gYXNzZXJ0IHRvIG1ha2Ugc3VyZSB3ZSBnZXQgaW1h Z2UgaGFzaGVzIGJhY2sgd2hlbiBydW5uaW5nIHJlZiB0ZXN0cy4KKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy93b3JrZXIucHk6IFVzZSBEcml2ZXIu aGFzX2NyYXNoZWQoKSBpbnN0ZWFkIG9mIHBvbGwoKS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2VfdW5pdHRlc3QucHk6CisgICAgICAgICogU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weTogVXNlIERyaXZlclByb3h5 LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZHJpdmVyLnB5 OiBBZGQgRHJpdmVyUHJveHkgd2hpY2ggZG9lcyB0aGUgd29yaworICAgICAgICAgICAgb2Ygc3Rh cnRpbmcgYSBwaXhlbCBkcml2ZXIgaWYgbmVlZGVkLiAgSXQgaGFuZGxlcyB0aGUgbG9naWMgb2Yg c2VuZGluZyB0aGUgdGVzdAorICAgICAgICAgICAgdG8gdGhlIGNvcnJlY3QgZHJpdmVyLiAgQWxz byByZW5hbWVkIERyaXZlci5wb2xsKCkgdG8gRHJpdmVyLmhhc19jcmFzaGVkKCkuCisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5OiBTd2l0Y2ggdG8g dXNpbmcgRHJpdmVyUHJveHkgc28gd2UgZ2V0IHRlc3QgY292ZXJhZ2UuCisgICAgICAgICogU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHk6CisgICAgICAgICogU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weTogQWRkIC0tbm8t cmVmLXRlc3RzLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93 ZWJraXRfdGVzdHNfaW50ZWdyYXRpb250ZXN0LnB5OiBUZXN0IC0tbm8tcmVmLXRlc3RzLgorCiAy MDExLTExLTE1ICBEYXZpZCBLaWx6ZXIgIDxkZGtpbHplckBhcHBsZS5jb20+CiAKICAgICAgICAg RG9uJ3QgdXNlIEZpbGU6OlNsdXJwIGZvciBydW4tbGVha3MgdW5pdCB0ZXN0cwpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvc2luZ2xl X3Rlc3RfcnVubmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29u dHJvbGxlcnMvc2luZ2xlX3Rlc3RfcnVubmVyLnB5CmluZGV4IGM0OWZhM2QyODFiYTRkMTViMTkw M2VkNWVkNDlmZTE0MmVlYWJhOWEuLjcxNDMxMWI4NzhkYzU1ODRkNjhiYmY3NWFiYzBjNTM5YTRh YzU0MjEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2Nv bnRyb2xsZXJzL3NpbmdsZV90ZXN0X3J1bm5lci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVzdF9ydW5uZXIucHkKQEAgLTEx MywyMSArMTEzLDE3IEBAIGNsYXNzIFNpbmdsZVRlc3RSdW5uZXI6CiAgICAgICAgIGltYWdlX2hh c2ggPSBOb25lCiAgICAgICAgIGlmIHNlbGYuX3Nob3VsZF9mZXRjaF9leHBlY3RlZF9jaGVja3N1 bSgpOgogICAgICAgICAgICAgaW1hZ2VfaGFzaCA9IHNlbGYuX3BvcnQuZXhwZWN0ZWRfY2hlY2tz dW0oc2VsZi5fdGVzdF9uYW1lKQotICAgICAgICByZXR1cm4gRHJpdmVySW5wdXQoc2VsZi5fdGVz dF9uYW1lLCBzZWxmLl90aW1lb3V0LCBpbWFnZV9oYXNoKQorICAgICAgICByZXR1cm4gRHJpdmVy SW5wdXQoc2VsZi5fdGVzdF9uYW1lLCBzZWxmLl90aW1lb3V0LCBpbWFnZV9oYXNoLCBzZWxmLl9p c19yZWZ0ZXN0KQogCiAgICAgZGVmIHJ1bihzZWxmKToKLSAgICAgICAgaWYgc2VsZi5fb3B0aW9u cy5uZXdfYmFzZWxpbmUgb3Igc2VsZi5fb3B0aW9ucy5yZXNldF9yZXN1bHRzOgotICAgICAgICAg ICAgaWYgc2VsZi5faXNfcmVmdGVzdDoKLSAgICAgICAgICAgICAgICAjIFJldHVybnMgYSBkdW1t eSBUZXN0UmVzdWx0LiBXZSBkb24ndCBoYXZlIHRvIHJlYmFzZSBmb3IgcmVmdGVzdHMuCi0gICAg ICAgICAgICAgICAgcmV0dXJuIFRlc3RSZXN1bHQoc2VsZi5fdGVzdF9uYW1lKQotICAgICAgICAg ICAgZWxzZToKLSAgICAgICAgICAgICAgICByZXR1cm4gc2VsZi5fcnVuX3JlYmFzZWxpbmUoKQog ICAgICAgICBpZiBzZWxmLl9pc19yZWZ0ZXN0OgotICAgICAgICAgICAgaWYgc2VsZi5fcG9ydC5n ZXRfb3B0aW9uKCdwaXhlbF90ZXN0cycpOgotICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLl9y dW5fcmVmdGVzdCgpCi0gICAgICAgICAgICByZXN1bHQgPSBUZXN0UmVzdWx0KHNlbGYuX3Rlc3Rf bmFtZSkKLSAgICAgICAgICAgIHJlc3VsdC50eXBlID0gdGVzdF9leHBlY3RhdGlvbnMuU0tJUAot ICAgICAgICAgICAgcmV0dXJuIHJlc3VsdAorICAgICAgICAgICAgaWYgc2VsZi5fcG9ydC5nZXRf b3B0aW9uKCdub19yZWZfdGVzdHMnKSBvciBzZWxmLl9vcHRpb25zLm5ld19iYXNlbGluZSBvciBz ZWxmLl9vcHRpb25zLnJlc2V0X3Jlc3VsdHM6CisgICAgICAgICAgICAgICAgcmVzdWx0ID0gVGVz dFJlc3VsdChzZWxmLl90ZXN0X25hbWUpCisgICAgICAgICAgICAgICAgcmVzdWx0LnR5cGUgPSB0 ZXN0X2V4cGVjdGF0aW9ucy5TS0lQCisgICAgICAgICAgICAgICAgcmV0dXJuIHJlc3VsdAorICAg ICAgICAgICAgcmV0dXJuIHNlbGYuX3J1bl9yZWZ0ZXN0KCkKKyAgICAgICAgaWYgc2VsZi5fb3B0 aW9ucy5uZXdfYmFzZWxpbmUgb3Igc2VsZi5fb3B0aW9ucy5yZXNldF9yZXN1bHRzOgorICAgICAg ICAgICAgcmV0dXJuIHNlbGYuX3J1bl9yZWJhc2VsaW5lKCkKICAgICAgICAgcmV0dXJuIHNlbGYu X3J1bl9jb21wYXJlX3Rlc3QoKQogCiAgICAgZGVmIF9ydW5fY29tcGFyZV90ZXN0KHNlbGYpOgpA QCAtMjkwLDcgKzI4Niw3IEBAIGNsYXNzIFNpbmdsZVRlc3RSdW5uZXI6CiAgICAgZGVmIF9ydW5f cmVmdGVzdChzZWxmKToKICAgICAgICAgZHJpdmVyX291dHB1dDEgPSBzZWxmLl9kcml2ZXIucnVu X3Rlc3Qoc2VsZi5fZHJpdmVyX2lucHV0KCkpCiAgICAgICAgIHJlZmVyZW5jZV90ZXN0X25hbWUg PSBzZWxmLl9wb3J0LnJlbGF0aXZlX3Rlc3RfZmlsZW5hbWUoc2VsZi5fcmVmZXJlbmNlX2ZpbGVu YW1lKQotICAgICAgICBkcml2ZXJfb3V0cHV0MiA9IHNlbGYuX2RyaXZlci5ydW5fdGVzdChEcml2 ZXJJbnB1dChyZWZlcmVuY2VfdGVzdF9uYW1lLCBzZWxmLl90aW1lb3V0LCBkcml2ZXJfb3V0cHV0 MS5pbWFnZV9oYXNoKSkKKyAgICAgICAgZHJpdmVyX291dHB1dDIgPSBzZWxmLl9kcml2ZXIucnVu X3Rlc3QoRHJpdmVySW5wdXQocmVmZXJlbmNlX3Rlc3RfbmFtZSwgc2VsZi5fdGltZW91dCwgZHJp dmVyX291dHB1dDEuaW1hZ2VfaGFzaCwgc2VsZi5faXNfcmVmdGVzdCkpCiAgICAgICAgIHRlc3Rf cmVzdWx0ID0gc2VsZi5fY29tcGFyZV9vdXRwdXRfd2l0aF9yZWZlcmVuY2UoZHJpdmVyX291dHB1 dDEsIGRyaXZlcl9vdXRwdXQyKQogCiAgICAgICAgIHRlc3RfcmVzdWx0X3dyaXRlci53cml0ZV90 ZXN0X3Jlc3VsdChzZWxmLl9wb3J0LCBzZWxmLl90ZXN0X25hbWUsIGRyaXZlcl9vdXRwdXQxLCBk cml2ZXJfb3V0cHV0MiwgdGVzdF9yZXN1bHQuZmFpbHVyZXMpCkBAIC0zMDgsNiArMzA0LDggQEAg Y2xhc3MgU2luZ2xlVGVzdFJ1bm5lcjoKICAgICAgICAgaWYgZmFpbHVyZXM6CiAgICAgICAgICAg ICByZXR1cm4gVGVzdFJlc3VsdChzZWxmLl90ZXN0X25hbWUsIGZhaWx1cmVzLCB0b3RhbF90ZXN0 X3RpbWUsIGhhc19zdGRlcnIpCiAKKyAgICAgICAgYXNzZXJ0KGRyaXZlcl9vdXRwdXQxLmltYWdl X2hhc2ggb3IgZHJpdmVyX291dHB1dDIuaW1hZ2VfaGFzaCkKKwogICAgICAgICBpZiBzZWxmLl9p c19taXNtYXRjaF9yZWZ0ZXN0OgogICAgICAgICAgICAgaWYgZHJpdmVyX291dHB1dDEuaW1hZ2Vf aGFzaCA9PSBkcml2ZXJfb3V0cHV0Mi5pbWFnZV9oYXNoOgogICAgICAgICAgICAgICAgIGZhaWx1 cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVSZWZ0ZXN0TWlzbWF0Y2hEaWROb3RPY2N1 cihzZWxmLl9yZWZlcmVuY2VfZmlsZW5hbWUpKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvd29ya2VyLnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvd29ya2VyLnB5CmluZGV4IGFiOGFh NzU2ZDQ5NTkxZWZlY2U0MmU3NmY0MTFiMzZjMDE2ZTAyYzAuLjVkZDMzYTI2ZDdkMTdlZDNjMDU3 YzRlOTUyOGM2MjA3NzUwNDhhOGIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL2NvbnRyb2xsZXJzL3dvcmtlci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy93b3JrZXIucHkKQEAgLTI0Myw3ICsyNDMs OSBAQCBjbGFzcyBXb3JrZXIobWFuYWdlcl93b3JrZXJfYnJva2VyLkFic3RyYWN0V29ya2VyKToK IAogICAgICAgICBSZXR1cm5zOiBhIFRlc3RSZXN1bHQgb2JqZWN0LgogICAgICAgICAiIiIKLSAg ICAgICAgaWYgbm90IHNlbGYuX2RyaXZlciBvciBzZWxmLl9kcml2ZXIucG9sbCgpIGlzIG5vdCBO b25lOgorICAgICAgICBpZiBzZWxmLl9kcml2ZXIgYW5kIHNlbGYuX2RyaXZlci5oYXNfY3Jhc2hl ZCgpOgorICAgICAgICAgICAgc2VsZi5raWxsX2RyaXZlcigpCisgICAgICAgIGlmIG5vdCBzZWxm Ll9kcml2ZXI6CiAgICAgICAgICAgICBzZWxmLl9kcml2ZXIgPSBzZWxmLl9wb3J0LmNyZWF0ZV9k cml2ZXIoc2VsZi5fd29ya2VyX251bWJlcikKICAgICAgICAgcmV0dXJuIHNlbGYucnVuX3Npbmds ZV90ZXN0KHNlbGYuX2RyaXZlciwgdGVzdF9pbnB1dCkKIApkaWZmIC0tZ2l0IGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5IGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5CmluZGV4IGU3NDRjZDBhMWMyYTMyOGY1 Y2ZkMjA2MTljNTgyMzA4YjhiNmM2MTIuLmQzNGM0MTEyY2JhZGI0Y2MxMzE3NzIwYWVmMGI0NTJm NjlmNjA0MzYgMTAwNzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvYmFzZS5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2Jhc2UucHkKQEAgLTUzLDYgKzUzLDcgQEAgZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVt LmV4ZWN1dGl2ZSBpbXBvcnQgU2NyaXB0RXJyb3IKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3Rz IGltcG9ydCByZWFkX2NoZWNrc3VtX2Zyb21fcG5nCiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0 cy5tb2RlbHMudGVzdF9jb25maWd1cmF0aW9uIGltcG9ydCBUZXN0Q29uZmlndXJhdGlvbgogZnJv bSB3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydCBpbXBvcnQgY29uZmlnIGFzIHBvcnRfY29uZmln Citmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0IGltcG9ydCBkcml2ZXIKIGZyb20gd2Vi a2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQgaW1wb3J0IGh0dHBfbG9jawogZnJvbSB3ZWJraXRweS5s YXlvdXRfdGVzdHMucG9ydCBpbXBvcnQgdGVzdF9maWxlcwogZnJvbSB3ZWJraXRweS5sYXlvdXRf dGVzdHMuc2VydmVycyBpbXBvcnQgYXBhY2hlX2h0dHBfc2VydmVyCkBAIC02NjMsNyArNjY0LDcg QEAgY2xhc3MgUG9ydChvYmplY3QpOgogCiAgICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwgd29y a2VyX251bWJlcik6CiAgICAgICAgICIiIlJldHVybiBhIG5ld2x5IGNyZWF0ZWQgRHJpdmVyIHN1 YmNsYXNzIGZvciBzdGFydGluZy9zdG9wcGluZyB0aGUgdGVzdCBkcml2ZXIuIiIiCi0gICAgICAg IHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IoJ1BvcnQuY3JlYXRlX2RyaXZlcicpCisgICAgICAg IHJldHVybiBkcml2ZXIuRHJpdmVyUHJveHkoc2VsZiwgd29ya2VyX251bWJlciwgc2VsZi5fZHJp dmVyX2NsYXNzKCksIHBpeGVsX3Rlc3RzPXNlbGYuZ2V0X29wdGlvbigncGl4ZWxfdGVzdHMnKSkK IAogICAgIGRlZiBzdGFydF9oZWxwZXIoc2VsZik6CiAgICAgICAgICIiIklmIGEgcG9ydCBuZWVk cyB0byByZWNvbmZpZ3VyZSBncmFwaGljcyBzZXR0aW5ncyBvciBkbyBvdGhlcgpAQCAtOTU3LDMg Kzk1OCw3IEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgIiIiR2VuZXJhdGVzIGEgbGlz dCBvZiBUZXN0Q29uZmlndXJhdGlvbiBpbnN0YW5jZXMsIHJlcHJlc2VudGluZyBjb25maWd1cmF0 aW9ucwogICAgICAgICBmb3IgYSBwbGF0Zm9ybSBhY3Jvc3MgYWxsIE9TZXMsIGFyY2hpdGVjdHVy ZXMsIGJ1aWxkIGFuZCBncmFwaGljcyB0eXBlcy4iIiIKICAgICAgICAgcmFpc2UgTm90SW1wbGVt ZW50ZWRFcnJvcignUG9ydC5fZ2VuZXJhdGVfdGVzdF9jb25maWd1cmF0aW9ucycpCisKKyAgICBk ZWYgX2RyaXZlcl9jbGFzcyhzZWxmKToKKyAgICAgICAgIiIiUmV0dXJucyB0aGUgcG9ydCdzIGRy aXZlciBpbXBsZW1lbnRhdGlvbi4iIiIKKyAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJv cignUG9ydC5fZHJpdmVyX2NsYXNzJykKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZV91bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZV91bml0dGVzdC5weQppbmRleCA2YjY3Zjk3Mjhm YmYwOTU3ZTk2OGI4MTViMGFiMTlmYzljZTUzYzc3Li5kNzA1YWZjNGI2YmUyMWFmYWRmZjUyNWE0 OTZlNTA1Mjk5ZTU5NjJiIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2Jhc2VfdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlX3VuaXR0ZXN0LnB5CkBAIC0zMDIsMTcgKzMwMiwxNyBA QCBjbGFzcyBWaXJ0dWFsVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgIHNlbGYuYXNz ZXJ0VmlydHVhbChwb3J0Ll9wYXRoX3RvX3dkaWZmKQogCiAgICAgZGVmIHRlc3RfdmlydHVhbF9k cml2ZXJfbWV0aG9kcyhzZWxmKToKLSAgICAgICAgZHJpdmVyID0gRHJpdmVyKE5vbmUsIE5vbmUp CisgICAgICAgIGRyaXZlciA9IERyaXZlcihQb3J0KE1vY2tIb3N0KCkpLCBOb25lLCBwaXhlbF90 ZXN0cz1GYWxzZSkKICAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKGRyaXZlci5ydW5fdGVzdCwg Tm9uZSkKLSAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKGRyaXZlci5wb2xsKQogICAgICAgICBz ZWxmLmFzc2VydFZpcnR1YWwoZHJpdmVyLnN0b3ApCisgICAgICAgIHNlbGYuYXNzZXJ0VmlydHVh bChkcml2ZXIuY21kX2xpbmUpCiAKIAogIyBGSVhNRTogVGhpcyBzaG91bGQgYmUgbW92ZWQgdG8g ZHJpdmVyX3VuaXR0ZXN0LnB5IG9yIGp1c3QgZGVsZXRlZC4KIGNsYXNzIERyaXZlclRlc3QodW5p dHRlc3QuVGVzdENhc2UpOgogCiAgICAgZGVmIF9hc3NlcnRfd3JhcHBlcihzZWxmLCB3cmFwcGVy X3N0cmluZywgZXhwZWN0ZWRfd3JhcHBlcik6Ci0gICAgICAgIHdyYXBwZXIgPSBEcml2ZXIoTm9u ZSwgTm9uZSkuX2NvbW1hbmRfd3JhcHBlcih3cmFwcGVyX3N0cmluZykKKyAgICAgICAgd3JhcHBl ciA9IERyaXZlcihQb3J0KE1vY2tIb3N0KCkpLCBOb25lLCBwaXhlbF90ZXN0cz1GYWxzZSkuX2Nv bW1hbmRfd3JhcHBlcih3cmFwcGVyX3N0cmluZykKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCh3 cmFwcGVyLCBleHBlY3RlZF93cmFwcGVyKQogCiAgICAgZGVmIHRlc3RfY29tbWFuZF93cmFwcGVy KHNlbGYpOgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9jaHJvbWl1bS5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvY2hyb21pdW0ucHkKaW5kZXggMWU5NzMwZDUzN2E0OTc3Yjg3YjZiM2VjNjY2OTc3MmIzYjRh MDQ0YS4uZTEyYWIzZDVkYjcyNDY2ZWI4NGFiZjFmZTUzMmU3NDE5YTg5N2ZiMiAxMDA3NTUKLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weQor KysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5 CkBAIC0yNTIsOSArMjUyLDggQEAgY2xhc3MgQ2hyb21pdW1Qb3J0KFBvcnQpOgogICAgICAgICBp ZiBzZWxmLl9maWxlc3lzdGVtLmV4aXN0cyhjYWNoZWRpcik6CiAgICAgICAgICAgICBzZWxmLl9m aWxlc3lzdGVtLnJtdHJlZShjYWNoZWRpcikKIAotICAgIGRlZiBjcmVhdGVfZHJpdmVyKHNlbGYs IHdvcmtlcl9udW1iZXIpOgotICAgICAgICAiIiJTdGFydHMgYSBuZXcgRHJpdmVyIGFuZCByZXR1 cm5zIGEgaGFuZGxlIHRvIGl0LiIiIgotICAgICAgICByZXR1cm4gQ2hyb21pdW1Ecml2ZXIoc2Vs Ziwgd29ya2VyX251bWJlcikKKyAgICBkZWYgX2RyaXZlcl9jbGFzcyhzZWxmKToKKyAgICAgICAg cmV0dXJuIENocm9taXVtRHJpdmVyCiAKICAgICBkZWYgc3RhcnRfaGVscGVyKHNlbGYpOgogICAg ICAgICBoZWxwZXJfcGF0aCA9IHNlbGYuX3BhdGhfdG9faGVscGVyKCkKQEAgLTQwMCwxNiArMzk5 LDE2IEBAIGNsYXNzIENocm9taXVtUG9ydChQb3J0KToKIAogIyBGSVhNRTogVGhpcyBzaG91bGQg aW5oZXJpdCBmcm9tIFdlYktpdERyaXZlciBub3cgdGhhdCBDaHJvbWl1bSBoYXMgYSBEdW1wUmVu ZGVyVHJlZSBwcm9jZXNzIGxpa2UgdGhlIHJlc3Qgb2YgV2ViS2l0LgogY2xhc3MgQ2hyb21pdW1E cml2ZXIoRHJpdmVyKToKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJl cik6Ci0gICAgICAgIERyaXZlci5fX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyKQor ICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyLCBwaXhlbF90ZXN0cz1G YWxzZSk6CisgICAgICAgIERyaXZlci5fX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVy LCBwaXhlbF90ZXN0cykKICAgICAgICAgc2VsZi5fcHJvYyA9IE5vbmUKICAgICAgICAgc2VsZi5f aW1hZ2VfcGF0aCA9IE5vbmUKLSAgICAgICAgaWYgc2VsZi5fcG9ydC5nZXRfb3B0aW9uKCdwaXhl bF90ZXN0cycpOgorICAgICAgICBpZiBzZWxmLl9waXhlbF90ZXN0czoKICAgICAgICAgICAgIHNl bGYuX2ltYWdlX3BhdGggPSBzZWxmLl9wb3J0Ll9maWxlc3lzdGVtLmpvaW4oc2VsZi5fcG9ydC5y ZXN1bHRzX2RpcmVjdG9yeSgpLCAncG5nX3Jlc3VsdCVzLnBuZycgJSBzZWxmLl93b3JrZXJfbnVt YmVyKQogCiAgICAgZGVmIF93cmFwcGVyX29wdGlvbnMoc2VsZik6CiAgICAgICAgIGNtZCA9IFtd Ci0gICAgICAgIGlmIHNlbGYuX3BvcnQuZ2V0X29wdGlvbigncGl4ZWxfdGVzdHMnKToKKyAgICAg ICAgaWYgc2VsZi5fcGl4ZWxfdGVzdHM6CiAgICAgICAgICAgICAjIFNlZSBub3RlIGFib3ZlIGlu IGRpZmZfaW1hZ2UoKSBmb3Igd2h5IHdlIG5lZWQgX2NvbnZlcnRfcGF0aCgpLgogICAgICAgICAg ICAgY21kLmFwcGVuZCgiLS1waXhlbC10ZXN0cz0iICsgc2VsZi5fcG9ydC5fY29udmVydF9wYXRo KHNlbGYuX2ltYWdlX3BhdGgpKQogICAgICAgICAjIEZJWE1FOiBUaGlzIGlzIG5vdCBOb25lIHNo b3VsZG4ndCBiZSBuZWNlc3NhcnksIHVubGVzcyAtLWpzLWZsYWdzPSInJyIgY2hhbmdlcyBiZWhh dmlvciBzb21laG93PwpAQCAtNDU1LDggKzQ1NCwxMCBAQCBjbGFzcyBDaHJvbWl1bURyaXZlcihE cml2ZXIpOgogICAgICAgICBjbG9zZV9mZHMgPSBzeXMucGxhdGZvcm0gbm90IGluICgnd2luMzIn LCAnY3lnd2luJykKICAgICAgICAgc2VsZi5fcHJvYyA9IHN1YnByb2Nlc3MuUG9wZW4oc2VsZi5j bWRfbGluZSgpLCBzdGRpbj1zdWJwcm9jZXNzLlBJUEUsIHN0ZG91dD1zdWJwcm9jZXNzLlBJUEUs IHN0ZGVycj1zdWJwcm9jZXNzLlNURE9VVCwgY2xvc2VfZmRzPWNsb3NlX2ZkcykKIAotICAgIGRl ZiBwb2xsKHNlbGYpOgotICAgICAgICByZXR1cm4gc2VsZi5fcHJvYy5wb2xsKCkKKyAgICBkZWYg aGFzX2NyYXNoZWQoc2VsZik6CisgICAgICAgIGlmIHNlbGYuX3Byb2MgaXMgTm9uZToKKyAgICAg ICAgICAgIHJldHVybiBGYWxzZQorICAgICAgICByZXR1cm4gc2VsZi5fcHJvYy5wb2xsKCkgaXMg bm90IE5vbmUKIAogICAgIGRlZiBfd3JpdGVfY29tbWFuZF9hbmRfcmVhZF9saW5lKHNlbGYsIGlu cHV0PU5vbmUpOgogICAgICAgICAiIiJSZXR1cm5zIGEgdHVwbGU6IChsaW5lLCBkaWRfY3Jhc2gp IiIiCkBAIC01MzEsNyArNTMyLDcgQEAgY2xhc3MgQ2hyb21pdW1Ecml2ZXIoRHJpdmVyKToKIAog ICAgICAgICB3aGlsZSBub3QgY3Jhc2ggYW5kIGxpbmUucnN0cmlwKCkgIT0gIiNFT0YiOgogICAg ICAgICAgICAgIyBNYWtlIHN1cmUgd2UgaGF2ZW4ndCBjcmFzaGVkLgotICAgICAgICAgICAgaWYg bGluZSA9PSAnJyBhbmQgc2VsZi5wb2xsKCkgaXMgbm90IE5vbmU6CisgICAgICAgICAgICBpZiBs aW5lID09ICcnIGFuZCBzZWxmLl9wcm9jLnBvbGwoKSBpcyBub3QgTm9uZToKICAgICAgICAgICAg ICAgICAjIFRoaXMgaXMgaGV4IGNvZGUgMHhjMDAwMDAxZCwgd2hpY2ggaXMgdXNlZCBmb3IgYWJy dXB0CiAgICAgICAgICAgICAgICAgIyB0ZXJtaW5hdGlvbi4gVGhpcyBoYXBwZW5zIGlmIHdlIGhp dCBjdHJsK2MgZnJvbSB0aGUgcHJvbXB0CiAgICAgICAgICAgICAgICAgIyBhbmQgd2UgaGFwcGVu IHRvIGJlIHdhaXRpbmcgb24gRFJULgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC9kcml2ZXIucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L2RyaXZlci5weQppbmRleCBiNzQyZGFiZjEyNmExNzUxNDcxODVhNTY2 ZTY1NTk1MmRiYTdkN2MyLi5mOGM0MTQ4OTlmMTZiNWRiZDcxYTMxMzM4YWU2OWIyZjgxZDRjYWU0 IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Ry aXZlci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Ry aXZlci5weQpAQCAtMzAsMTAgKzMwLDExIEBAIGltcG9ydCBzaGxleAogCiAKIGNsYXNzIERyaXZl cklucHV0KG9iamVjdCk6Ci0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHRlc3RfbmFtZSwgdGltZW91 dCwgaW1hZ2VfaGFzaCk6CisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHRlc3RfbmFtZSwgdGltZW91 dCwgaW1hZ2VfaGFzaCwgaXNfcmVmdGVzdCk6CiAgICAgICAgIHNlbGYudGVzdF9uYW1lID0gdGVz dF9uYW1lCiAgICAgICAgIHNlbGYudGltZW91dCA9IHRpbWVvdXQgICMgaW4gbXMKICAgICAgICAg c2VsZi5pbWFnZV9oYXNoID0gaW1hZ2VfaGFzaAorICAgICAgICBzZWxmLmlzX3JlZnRlc3QgPSBp c19yZWZ0ZXN0CiAKIAogY2xhc3MgRHJpdmVyT3V0cHV0KG9iamVjdCk6CkBAIC01NywxMCArNTgs MTAgQEAgY2xhc3MgRHJpdmVyT3V0cHV0KG9iamVjdCk6CiAgICAgICAgIHJldHVybiBib29sKHNl bGYuZXJyb3IpCiAKIAotY2xhc3MgRHJpdmVyOgorY2xhc3MgRHJpdmVyKG9iamVjdCk6CiAgICAg IiIiQWJzdHJhY3QgaW50ZXJmYWNlIGZvciB0aGUgRHVtcFJlbmRlclRyZWUgaW50ZXJmYWNlLiIi IgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIpOgorICAgIGRl ZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyLCBwaXhlbF90ZXN0cyk6CiAgICAg ICAgICIiIkluaXRpYWxpemUgYSBEcml2ZXIgdG8gc3Vic2VxdWVudGx5IHJ1biB0ZXN0cy4KIAog ICAgICAgICBUeXBpY2FsbHkgdGhpcyByb3V0aW5lIHdpbGwgc3Bhd24gRHVtcFJlbmRlclRyZWUg aW4gYSBjb25maWcKQEAgLTcxLDYgKzcyLDcgQEAgY2xhc3MgRHJpdmVyOgogICAgICAgICAiIiIK ICAgICAgICAgc2VsZi5fcG9ydCA9IHBvcnQKICAgICAgICAgc2VsZi5fd29ya2VyX251bWJlciA9 IHdvcmtlcl9udW1iZXIKKyAgICAgICAgc2VsZi5fcGl4ZWxfdGVzdHMgPSBwaXhlbF90ZXN0cwog CiAgICAgZGVmIHJ1bl90ZXN0KHNlbGYsIGRyaXZlcl9pbnB1dCk6CiAgICAgICAgICIiIlJ1biBh IHNpbmdsZSB0ZXN0IGFuZCByZXR1cm4gdGhlIHJlc3VsdHMuCkBAIC04OSw5ICs5MSw0MiBAQCBj bGFzcyBEcml2ZXI6CiAgICAgICAgICMgdXNlZCBieSBlLmcuIHRvb2xzL3ZhbGdyaW5kL3ZhbGdy aW5kX3Rlc3RzLnB5LgogICAgICAgICByZXR1cm4gc2hsZXguc3BsaXQod3JhcHBlcl9vcHRpb24p IGlmIHdyYXBwZXJfb3B0aW9uIGVsc2UgW10KIAotICAgIGRlZiBwb2xsKHNlbGYpOgotICAgICAg ICAiIiJSZXR1cm5zIE5vbmUgaWYgdGhlIERyaXZlciBpcyBzdGlsbCBydW5uaW5nLiBSZXR1cm5z IHRoZSByZXR1cm5jb2RlIGlmIGl0IGhhcyBleGl0ZWQuIiIiCi0gICAgICAgIHJhaXNlIE5vdElt cGxlbWVudGVkRXJyb3IoJ0RyaXZlci5wb2xsJykKKyAgICBkZWYgaGFzX2NyYXNoZWQoc2VsZik6 CisgICAgICAgIHJldHVybiBGYWxzZQogCiAgICAgZGVmIHN0b3Aoc2VsZik6CiAgICAgICAgIHJh aXNlIE5vdEltcGxlbWVudGVkRXJyb3IoJ0RyaXZlci5zdG9wJykKKworICAgIGRlZiBjbWRfbGlu ZShzZWxmKToKKyAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcignRHJpdmVyLmNtZF9s aW5lJykKKworCitjbGFzcyBEcml2ZXJQcm94eShvYmplY3QpOgorICAgICIiIkEgd3JhcHBlciBm b3IgbWFuYWdpbmcgdHdvIERyaXZlciBpbnN0YW5jZXMsIG9uZSB3aXRoIHBpeGVsIHRlc3RzIGFu ZAorICAgIG9uZSB3aXRob3V0LiBUaGlzIGFsbG93cyB1cyB0byBoYW5kbGUgcGxhaW4gdGV4dCB0 ZXN0cyBhbmQgcmVmIHRlc3RzIHdpdGggYQorICAgIHNpbmdsZSBkcml2ZXIuIiIiCisKKyAgICBk ZWYgX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlciwgZHJpdmVyX2luc3RhbmNlX2Nv bnN0cnVjdG9yLCBwaXhlbF90ZXN0cyk6CisgICAgICAgIHNlbGYuX2RyaXZlciA9IGRyaXZlcl9p bnN0YW5jZV9jb25zdHJ1Y3Rvcihwb3J0LCB3b3JrZXJfbnVtYmVyLCBwaXhlbF90ZXN0cykKKyAg ICAgICAgaWYgcGl4ZWxfdGVzdHM6CisgICAgICAgICAgICBzZWxmLl9yZWZ0ZXN0X2RyaXZlciA9 IHNlbGYuX2RyaXZlcgorICAgICAgICBlbHNlOgorICAgICAgICAgICAgc2VsZi5fcmVmdGVzdF9k cml2ZXIgPSBkcml2ZXJfaW5zdGFuY2VfY29uc3RydWN0b3IocG9ydCwgd29ya2VyX251bWJlciwg cGl4ZWxfdGVzdHM9VHJ1ZSkKKworICAgIGRlZiBydW5fdGVzdChzZWxmLCBkcml2ZXJfaW5wdXQp OgorICAgICAgICBpZiBkcml2ZXJfaW5wdXQuaXNfcmVmdGVzdDoKKyAgICAgICAgICAgIHJldHVy biBzZWxmLl9yZWZ0ZXN0X2RyaXZlci5ydW5fdGVzdChkcml2ZXJfaW5wdXQpCisgICAgICAgIHJl dHVybiBzZWxmLl9kcml2ZXIucnVuX3Rlc3QoZHJpdmVyX2lucHV0KQorCisgICAgZGVmIGhhc19j cmFzaGVkKHNlbGYpOgorICAgICAgICByZXR1cm4gc2VsZi5fZHJpdmVyLmhhc19jcmFzaGVkKCkg b3Igc2VsZi5fcmVmdGVzdF9kcml2ZXIuaGFzX2NyYXNoZWQoKQorCisgICAgZGVmIHN0b3Aoc2Vs Zik6CisgICAgICAgIHNlbGYuX2RyaXZlci5zdG9wKCkKKyAgICAgICAgc2VsZi5fcmVmdGVzdF9k cml2ZXIuc3RvcCgpCisKKyAgICBkZWYgY21kX2xpbmUoc2VsZik6CisgICAgICAgIGNtZF9saW5l ID0gc2VsZi5fZHJpdmVyLmNtZF9saW5lKCkKKyAgICAgICAgaWYgc2VsZi5fZHJpdmVyICE9IHNl bGYuX3JlZnRlc3RfZHJpdmVyOgorICAgICAgICAgICAgY21kX2xpbmUgKz0gWyc7ICddICsgc2Vs Zi5fcmVmdGVzdF9kcml2ZXIuY21kX2xpbmUoKQorICAgICAgICByZXR1cm4gY21kX2xpbmUKZGlm ZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZHJ5cnVu LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHkK aW5kZXggY2EzYmFkZTNkOGU4ZmRlYzk4NDhhYjhjNWFhZjgxOTljNTUyYTcwMS4uYzJiYjk1YTIw MjMyZGQwNGFjMWFlZjdhMTYzMDkzZDczYThjZjFhMSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHkKKysrIGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHkKQEAgLTEwMCw3ICsxMDAsNyBA QCBjbGFzcyBEcnlSdW5Qb3J0KG9iamVjdCk6CiAgICAgICAgIHBhc3MKIAogICAgIGRlZiBjcmVh dGVfZHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpOgotICAgICAgICByZXR1cm4gRHJ5cnVuRHJp dmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpCisgICAgICAgIHJldHVybiBEcnlydW5Ecml2ZXIoc2Vs Ziwgd29ya2VyX251bWJlciwgcGl4ZWxfdGVzdHM9RmFsc2UpCiAKIAogY2xhc3MgRHJ5cnVuRHJp dmVyKERyaXZlcik6CkBAIC0xMDksOSArMTA5LDYgQEAgY2xhc3MgRHJ5cnVuRHJpdmVyKERyaXZl cik6CiAgICAgZGVmIGNtZF9saW5lKHNlbGYpOgogICAgICAgICByZXR1cm4gWydOb25lJ10KIAot ICAgIGRlZiBwb2xsKHNlbGYpOgotICAgICAgICByZXR1cm4gTm9uZQotCiAgICAgZGVmIHJ1bl90 ZXN0KHNlbGYsIGRyaXZlcl9pbnB1dCk6CiAgICAgICAgIHN0YXJ0X3RpbWUgPSB0aW1lLnRpbWUo KQogICAgICAgICBmcyA9IHNlbGYuX3BvcnQuX2ZpbGVzeXN0ZW0KZGlmZiAtLWdpdCBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ3RrLnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkKaW5kZXggM2VlZDgyOTE0NmNlNGI5 NDk2N2Y0OTAwZGE0NzUzMDMwOTU0YmI2NC4uZmUxZWIwNThlNzMwYWZjMDEyODdjZDhjY2FkOTZh MzQxNDkxZDkwMyAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9ndGsucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9ndGsucHkKQEAgLTcyLDggKzcyLDggQEAgY2xhc3MgR3RrUG9ydChXZWJLaXRQb3J0KToK ICAgICBkZWYgX3BvcnRfZmxhZ19mb3Jfc2NyaXB0cyhzZWxmKToKICAgICAgICAgcmV0dXJuICIt LWd0ayIKIAotICAgIGRlZiBjcmVhdGVfZHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpOgotICAg ICAgICByZXR1cm4gR3RrRHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpCisgICAgZGVmIF9kcml2 ZXJfY2xhc3Moc2VsZik6CisgICAgICAgIHJldHVybiBHdGtEcml2ZXIKIAogICAgIGRlZiBzZXR1 cF9lbnZpcm9uX2Zvcl9zZXJ2ZXIoc2VsZiwgc2VydmVyX25hbWU9Tm9uZSk6CiAgICAgICAgIGVu dmlyb25tZW50ID0gV2ViS2l0UG9ydC5zZXR1cF9lbnZpcm9uX2Zvcl9zZXJ2ZXIoc2VsZiwgc2Vy dmVyX25hbWUpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L3Rlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L3Rlc3QucHkKaW5kZXggN2U1ZDk1NmVlNGQ0MTBiMDQ4YjczNGMzMzQ4NmZhOGQ4YTE5MDc4ZC4u NDlmNjQ1NTJjNWIxMGY0OTBjOTdmODVmYzllN2ZiY2FhYWQyMjcyZSAxMDA2NDQKLS0tIGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5CisrKyBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdC5weQpAQCAtMzU5LDggKzM1 OSw4IEBAIGNsYXNzIFRlc3RQb3J0KFBvcnQpOgogICAgIGRlZiBzZXR1cF90ZXN0X3J1bihzZWxm KToKICAgICAgICAgcGFzcwogCi0gICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwgd29ya2VyX251 bWJlcik6Ci0gICAgICAgIHJldHVybiBUZXN0RHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpCisg ICAgZGVmIF9kcml2ZXJfY2xhc3Moc2VsZik6CisgICAgICAgIHJldHVybiBUZXN0RHJpdmVyCiAK ICAgICBkZWYgc3RhcnRfaHR0cF9zZXJ2ZXIoc2VsZik6CiAgICAgICAgIHBhc3MKQEAgLTQ4OCw5 ICs0ODgsNiBAQCBjbGFzcyBUZXN0RHJpdmVyKERyaXZlcik6CiAgICAgZGVmIGNtZF9saW5lKHNl bGYpOgogICAgICAgICByZXR1cm4gW3NlbGYuX3BvcnQuX3BhdGhfdG9fZHJpdmVyKCldICsgc2Vs Zi5fcG9ydC5nZXRfb3B0aW9uKCdhZGRpdGlvbmFsX2RydF9mbGFnJywgW10pCiAKLSAgICBkZWYg cG9sbChzZWxmKToKLSAgICAgICAgcmV0dXJuIFRydWUKLQogICAgIGRlZiBydW5fdGVzdChzZWxm LCB0ZXN0X2lucHV0KToKICAgICAgICAgc3RhcnRfdGltZSA9IHRpbWUudGltZSgpCiAgICAgICAg IHRlc3RfbmFtZSA9IHRlc3RfaW5wdXQudGVzdF9uYW1lCmRpZmYgLS1naXQgYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weSBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CmluZGV4IDk1NjExYjRhMmYxZTNm NzFkY2NjZWIxMWE1YjJmMzVlYmI4MmQyMTguLjgxZDNkOTQ3ZDgzOGU4MTNkMTU5NTY3NGJiZWJl ODI0MTIzMjliMmUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvd2Via2l0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvd2Via2l0LnB5CkBAIC0yMjUsOCArMjI1LDggQEAgY2xhc3MgV2ViS2l0UG9ydChQ b3J0KToKICAgICAgICAgIyB0byBoYXZlIG11bHRpcGxlIGNvcGllcyBvZiB3ZWJraXQgY2hlY2tl ZCBvdXQgYW5kIGJ1aWx0LgogICAgICAgICByZXR1cm4gc2VsZi5fYnVpbGRfcGF0aCgnbGF5b3V0 LXRlc3QtcmVzdWx0cycpCiAKLSAgICBkZWYgY3JlYXRlX2RyaXZlcihzZWxmLCB3b3JrZXJfbnVt YmVyKToKLSAgICAgICAgcmV0dXJuIFdlYktpdERyaXZlcihzZWxmLCB3b3JrZXJfbnVtYmVyKQor ICAgIGRlZiBfZHJpdmVyX2NsYXNzKHNlbGYpOgorICAgICAgICByZXR1cm4gV2ViS2l0RHJpdmVy CiAKICAgICBkZWYgX3Rlc3RzX2Zvcl9vdGhlcl9wbGF0Zm9ybXMoc2VsZik6CiAgICAgICAgICMg QnkgZGVmYXVsdCB3ZSB3aWxsIHNraXAgYW55IGRpcmVjdG9yeSB1bmRlciBMYXlvdXRUZXN0cy9w bGF0Zm9ybQpAQCAtNDQwLDggKzQ0MCw4IEBAIGNsYXNzIFdlYktpdFBvcnQoUG9ydCk6CiBjbGFz cyBXZWJLaXREcml2ZXIoRHJpdmVyKToKICAgICAiIiJXZWJLaXQgaW1wbGVtZW50YXRpb24gb2Yg dGhlIER1bXBSZW5kZXJUcmVlL1dlYktpdFRlc3RSdW5uZXIgaW50ZXJmYWNlLiIiIgogCi0gICAg ZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIpOgotICAgICAgICBEcml2ZXIu X19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlcikKKyAgICBkZWYgX19pbml0X18oc2Vs ZiwgcG9ydCwgd29ya2VyX251bWJlciwgcGl4ZWxfdGVzdHM9RmFsc2UpOgorICAgICAgICBEcml2 ZXIuX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlciwgcGl4ZWxfdGVzdHMpCiAgICAg ICAgIHNlbGYuX2RyaXZlcl90ZW1wZGlyID0gcG9ydC5fZmlsZXN5c3RlbS5ta2R0ZW1wKHByZWZp eD0nJXMtJyAlIHNlbGYuX3BvcnQuZHJpdmVyX25hbWUoKSkKICAgICAgICAgIyBXZWJLaXRUZXN0 UnVubmVyIGNhbiByZXBvcnQgYmFjayBzdWJwcm9jZXNzIGNyYXNoZXMgYnkgcHJpbnRpbmcKICAg ICAgICAgIyAiI0NSQVNIRUQgLSBQUk9DRVNTTkFNRSIuICBTaW5jZSB0aG9zZSBjYW4gaGFwcGVu IGF0IGFueSB0aW1lCkBAIC00NTcsNyArNDU3LDYgQEAgY2xhc3MgV2ViS2l0RHJpdmVyKERyaXZl cik6CiAgICAgICAgIHNlbGYuZXJyX3NlZW5fZW9mID0gRmFsc2UKICAgICAgICAgc2VsZi5fc2Vy dmVyX3Byb2Nlc3MgPSBOb25lCiAKLQogICAgICMgRklYTUU6IFRoaXMgbWF5IGJlIHVuc2FmZSwg YXMgcHl0aG9uIGRvZXMgbm90IGd1YXJlbnRlZSBhbnkgb3JkZXJpbmcgb2YgX19kZWxfXyBjYWxs cwogICAgICMgSSBiZWxpZXZlIGl0J3MgcG9zc2libGUgdGhhdCBzZWxmLl9wb3J0IG9yIHNlbGYu X3BvcnQuX2ZpbGVzeXN0ZW0gbWF5IGFscmVhZHkgYmUgZGVzdHJveWVkLgogICAgIGRlZiBfX2Rl bF9fKHNlbGYpOgpAQCAtNDY2LDcgKzQ2NSw3IEBAIGNsYXNzIFdlYktpdERyaXZlcihEcml2ZXIp OgogICAgIGRlZiBjbWRfbGluZShzZWxmKToKICAgICAgICAgY21kID0gc2VsZi5fY29tbWFuZF93 cmFwcGVyKHNlbGYuX3BvcnQuZ2V0X29wdGlvbignd3JhcHBlcicpKQogICAgICAgICBjbWQuYXBw ZW5kKHNlbGYuX3BvcnQuX3BhdGhfdG9fZHJpdmVyKCkpCi0gICAgICAgIGlmIHNlbGYuX3BvcnQu Z2V0X29wdGlvbigncGl4ZWxfdGVzdHMnKToKKyAgICAgICAgaWYgc2VsZi5fcGl4ZWxfdGVzdHM6 CiAgICAgICAgICAgICBjbWQuYXBwZW5kKCctLXBpeGVsLXRlc3RzJykKICAgICAgICAgaWYgc2Vs Zi5fcG9ydC5nZXRfb3B0aW9uKCdnY19iZXR3ZWVuX3Rlc3RzJyk6CiAgICAgICAgICAgICBjbWQu YXBwZW5kKCctLWdjLWJldHdlZW4tdGVzdHMnKQpAQCAtNDkwLDggKzQ4OSwxMCBAQCBjbGFzcyBX ZWJLaXREcml2ZXIoRHJpdmVyKToKICAgICAgICAgc2VsZi5fY3Jhc2hlZF9zdWJwcm9jZXNzX25h bWUgPSBOb25lCiAgICAgICAgIHNlbGYuX3NlcnZlcl9wcm9jZXNzID0gc2VydmVyX3Byb2Nlc3Mu U2VydmVyUHJvY2VzcyhzZWxmLl9wb3J0LCBzZXJ2ZXJfbmFtZSwgc2VsZi5jbWRfbGluZSgpLCBl bnZpcm9ubWVudCkKIAotICAgIGRlZiBwb2xsKHNlbGYpOgotICAgICAgICByZXR1cm4gc2VsZi5f c2VydmVyX3Byb2Nlc3MucG9sbCgpCisgICAgZGVmIGhhc19jcmFzaGVkKHNlbGYpOgorICAgICAg ICBpZiBzZWxmLl9zZXJ2ZXJfcHJvY2VzcyBpcyBOb25lOgorICAgICAgICAgICAgcmV0dXJuIEZh bHNlCisgICAgICAgIHJldHVybiBzZWxmLl9zZXJ2ZXJfcHJvY2Vzcy5wb2xsKCkgaXMgbm90IE5v bmUKIAogICAgIGRlZiBfY2hlY2tfZm9yX2RyaXZlcl9jcmFzaChzZWxmLCBlcnJvcl9saW5lKToK ICAgICAgICAgaWYgZXJyb3JfbGluZSA9PSAiI0NSQVNIRURcbiI6CmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5IGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQppbmRl eCA2ZDYyN2I2NDhiN2EyZDJmYTFkZmNhMzlhNGRjMjlmN2VlYWUwOGQwLi5lZDc4YjEyZmIyMzRj Y2I4Yzg0MTM4ZDdjMjJlZmM3YjgxMDRkNDI1IDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CisrKyBiL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKQEAgLTI3NCw2ICsy NzQsOCBAQCBkZWYgcGFyc2VfYXJncyhhcmdzPU5vbmUpOgogICAgICAgICAgICAgZGVzdD0icGl4 ZWxfdGVzdHMiLCBoZWxwPSJEaXNhYmxlIHBpeGVsLXRvLXBpeGVsIFBORyBjb21wYXJpc29ucyIp LAogICAgICAgICBvcHRwYXJzZS5tYWtlX29wdGlvbigiLS1uby1zYW1wbGUtb24tdGltZW91dCIs IGFjdGlvbj0ic3RvcmVfZmFsc2UiLAogICAgICAgICAgICAgZGVzdD0ic2FtcGxlX29uX3RpbWVv dXQiLCBoZWxwPSJEb24ndCBydW4gc2FtcGxlIG9uIHRpbWVvdXQgKE1hYyBPUyBYIG9ubHkpIiks CisgICAgICAgIG9wdHBhcnNlLm1ha2Vfb3B0aW9uKCItLW5vLXJlZi10ZXN0cyIsIGFjdGlvbj0i c3RvcmVfdHJ1ZSIsCisgICAgICAgICAgICBkZXN0PSJub19yZWZfdGVzdHMiLCBoZWxwPSJTa2lw IGFsbCByZWYgdGVzdHMiKSwKICAgICAgICAgb3B0cGFyc2UubWFrZV9vcHRpb24oIi0tdG9sZXJh bmNlIiwKICAgICAgICAgICAgIGhlbHA9Iklnbm9yZSBpbWFnZSBkaWZmZXJlbmNlcyBsZXNzIHRo YW4gdGhpcyBwZXJjZW50YWdlIChzb21lICIKICAgICAgICAgICAgICAgICAicG9ydHMgbWF5IGln bm9yZSB0aGlzIG9wdGlvbikiLCB0eXBlPSJmbG9hdCIpLApkaWZmIC0tZ2l0IGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0c19pbnRlZ3JhdGlvbnRl c3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rl c3RzX2ludGVncmF0aW9udGVzdC5weQppbmRleCBhNjQ0NmM1MmQ5ODI3NDI5NzA2NjI3N2YxMGEw N2UyYjk4MDY5MjliLi42MTcwY2FhZjE0YWFhZTc4OTI4NTBmMTRkYTM3NDA3NWI1NGZjOGFhIDEw MDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0 X3Rlc3RzX2ludGVncmF0aW9udGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX2ludGVncmF0aW9udGVzdC5weQpAQCAtMTUyLDEz ICsxNTIsOSBAQCBkZWYgZ2V0X3Rlc3RzX3J1bihleHRyYV9hcmdzPU5vbmUsIHRlc3RzX2luY2x1 ZGVkPUZhbHNlLCBmbGF0dGVuX2JhdGNoZXM9RmFsc2UsCiAKICAgICBjbGFzcyBSZWNvcmRpbmdU ZXN0RHJpdmVyKFRlc3REcml2ZXIpOgogICAgICAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCwg d29ya2VyX251bWJlcik6Ci0gICAgICAgICAgICBUZXN0RHJpdmVyLl9faW5pdF9fKHNlbGYsIHBv cnQsIHdvcmtlcl9udW1iZXIpCisgICAgICAgICAgICBUZXN0RHJpdmVyLl9faW5pdF9fKHNlbGYs IHBvcnQsIHdvcmtlcl9udW1iZXIsIHBpeGVsX3Rlc3RzPUZhbHNlKQogICAgICAgICAgICAgc2Vs Zi5fY3VycmVudF90ZXN0X2JhdGNoID0gTm9uZQogCi0gICAgICAgIGRlZiBwb2xsKHNlbGYpOgot ICAgICAgICAgICAgIyBTbyB0aGF0IHdlIGRvbid0IGNyZWF0ZSBhIG5ldyBkcml2ZXIgZm9yIGV2 ZXJ5IHRlc3QKLSAgICAgICAgICAgIHJldHVybiBOb25lCi0KICAgICAgICAgZGVmIHN0b3Aoc2Vs Zik6CiAgICAgICAgICAgICBzZWxmLl9jdXJyZW50X3Rlc3RfYmF0Y2ggPSBOb25lCiAKQEAgLTY4 MCw4ICs2NzYsMTQgQEAgY2xhc3MgTWFpblRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAg ICB0ZXN0c19ydW4gPSBnZXRfdGVzdHNfcnVuKFsncGFzc2VzL3JlZnRlc3QuaHRtbCddLCB0ZXN0 c19pbmNsdWRlZD1UcnVlLCBmbGF0dGVuX2JhdGNoZXM9VHJ1ZSkKICAgICAgICAgc2VsZi5hc3Nl cnRFcXVhbHMoWydwYXNzZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX3J1bikKIAotICAgIGRlZiB0 ZXN0X3JlZnRlc3Rfc2tpcF9yZWZ0ZXN0c19pZl9waXhlbF90ZXN0c19hcmVfZGlzYWJsZWQoc2Vs Zik6CisgICAgZGVmIHRlc3RfcmVmdGVzdF9ydW5fcmVmdGVzdHNfaWZfcGl4ZWxfdGVzdHNfYXJl X2Rpc2FibGVkKHNlbGYpOgogICAgICAgICB0ZXN0c19ydW4gPSBnZXRfdGVzdHNfcnVuKFsnLS1u by1waXhlbC10ZXN0cycsICdwYXNzZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX2luY2x1ZGVkPVRy dWUsIGZsYXR0ZW5fYmF0Y2hlcz1UcnVlKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhbJ3Bh c3Nlcy9yZWZ0ZXN0Lmh0bWwnXSwgdGVzdHNfcnVuKQorCisgICAgZGVmIHRlc3RfcmVmdGVzdF9z a2lwX3JlZnRlc3RzX2lmX25vX3JlZl90ZXN0cyhzZWxmKToKKyAgICAgICAgdGVzdHNfcnVuID0g Z2V0X3Rlc3RzX3J1bihbJy0tbm8tcmVmLXRlc3RzJywgJ3Bhc3Nlcy9yZWZ0ZXN0Lmh0bWwnXSwg dGVzdHNfaW5jbHVkZWQ9VHJ1ZSwgZmxhdHRlbl9iYXRjaGVzPVRydWUpCisgICAgICAgIHNlbGYu YXNzZXJ0RXF1YWxzKFtdLCB0ZXN0c19ydW4pCisgICAgICAgIHRlc3RzX3J1biA9IGdldF90ZXN0 c19ydW4oWyctLW5vLXJlZi10ZXN0cycsICctLW5vLXBpeGVsLXRlc3RzJywgJ3Bhc3Nlcy9yZWZ0 ZXN0Lmh0bWwnXSwgdGVzdHNfaW5jbHVkZWQ9VHJ1ZSwgZmxhdHRlbl9iYXRjaGVzPVRydWUpCiAg ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWxzKFtdLCB0ZXN0c19ydW4pCiAKICAgICBkZWYgdGVzdF9y ZWZ0ZXN0X2V4cGVjdGVkX2h0bWxfc2hvdWxkX2JlX2lnbm9yZWQoc2VsZik6Cg== 115219 2011-11-15 12:34:28 -0800 2011-11-15 13:54:00 -0800 Patch bug-60605-20111115123445.patch text/plain 22666 tony U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwMzAwCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYmM0OWY1OTk3ODYxZGRjYjUzODdhZjE0ZTdjN2ZmODE2 ZTgwZTY2Yy4uZWU5NDY1MjE4NTRiN2MxNjgxYWIyZjBjZWE3MWMxNzAwNDQyOTg3YiAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0 IEBACisyMDExLTExLTE0ICBUb255IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+CisKKyAgICAg ICAgW05SV1RdIFJlZnRlc3RzIHNob3VsZCBydW4gZXZlbiB3aGVuIHBpeGVsIHRlc3RzIGFyZSBk aXNhYmxlZC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTYwNjA1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVzdF9y dW5uZXIucHk6IE9ubHkgc2tpcCByZWYgdGVzdHMgaWYgLS1uby1yZWYtdGVzdHMgaXMgcGFzc2Vk LgorICAgICAgICAgICAgQWxzbyBhZGQgYW4gYXNzZXJ0IHRvIG1ha2Ugc3VyZSB3ZSBnZXQgaW1h Z2UgaGFzaGVzIGJhY2sgd2hlbiBydW5uaW5nIHJlZiB0ZXN0cy4KKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy93b3JrZXIucHk6IFVzZSBEcml2ZXIu aGFzX2NyYXNoZWQoKSBpbnN0ZWFkIG9mIHBvbGwoKS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2VfdW5pdHRlc3QucHk6CisgICAgICAgICogU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weTogVXNlIERyaXZlclByb3h5 LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZHJpdmVyLnB5 OiBBZGQgRHJpdmVyUHJveHkgd2hpY2ggZG9lcyB0aGUgd29yaworICAgICAgICAgICAgb2Ygc3Rh cnRpbmcgYSBwaXhlbCBkcml2ZXIgaWYgbmVlZGVkLiAgSXQgaGFuZGxlcyB0aGUgbG9naWMgb2Yg c2VuZGluZyB0aGUgdGVzdAorICAgICAgICAgICAgdG8gdGhlIGNvcnJlY3QgZHJpdmVyLiAgQWxz byByZW5hbWVkIERyaXZlci5wb2xsKCkgdG8gRHJpdmVyLmhhc19jcmFzaGVkKCkuCisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4ucHk6CisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5OiBTd2l0Y2ggdG8g dXNpbmcgRHJpdmVyUHJveHkgc28gd2UgZ2V0IHRlc3QgY292ZXJhZ2UuCisgICAgICAgICogU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHk6CisgICAgICAgICogU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weTogQWRkIC0tbm8t cmVmLXRlc3RzLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93 ZWJraXRfdGVzdHNfaW50ZWdyYXRpb250ZXN0LnB5OiBUZXN0IC0tbm8tcmVmLXRlc3RzLgorCiAy MDExLTExLTE1ICBEYXZpZCBLaWx6ZXIgIDxkZGtpbHplckBhcHBsZS5jb20+CiAKICAgICAgICAg RG9uJ3QgdXNlIEZpbGU6OlNsdXJwIGZvciBydW4tbGVha3MgdW5pdCB0ZXN0cwpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvc2luZ2xl X3Rlc3RfcnVubmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29u dHJvbGxlcnMvc2luZ2xlX3Rlc3RfcnVubmVyLnB5CmluZGV4IGM0OWZhM2QyODFiYTRkMTViMTkw M2VkNWVkNDlmZTE0MmVlYWJhOWEuLjcxNDMxMWI4NzhkYzU1ODRkNjhiYmY3NWFiYzBjNTM5YTRh YzU0MjEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2Nv bnRyb2xsZXJzL3NpbmdsZV90ZXN0X3J1bm5lci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVzdF9ydW5uZXIucHkKQEAgLTEx MywyMSArMTEzLDE3IEBAIGNsYXNzIFNpbmdsZVRlc3RSdW5uZXI6CiAgICAgICAgIGltYWdlX2hh c2ggPSBOb25lCiAgICAgICAgIGlmIHNlbGYuX3Nob3VsZF9mZXRjaF9leHBlY3RlZF9jaGVja3N1 bSgpOgogICAgICAgICAgICAgaW1hZ2VfaGFzaCA9IHNlbGYuX3BvcnQuZXhwZWN0ZWRfY2hlY2tz dW0oc2VsZi5fdGVzdF9uYW1lKQotICAgICAgICByZXR1cm4gRHJpdmVySW5wdXQoc2VsZi5fdGVz dF9uYW1lLCBzZWxmLl90aW1lb3V0LCBpbWFnZV9oYXNoKQorICAgICAgICByZXR1cm4gRHJpdmVy SW5wdXQoc2VsZi5fdGVzdF9uYW1lLCBzZWxmLl90aW1lb3V0LCBpbWFnZV9oYXNoLCBzZWxmLl9p c19yZWZ0ZXN0KQogCiAgICAgZGVmIHJ1bihzZWxmKToKLSAgICAgICAgaWYgc2VsZi5fb3B0aW9u cy5uZXdfYmFzZWxpbmUgb3Igc2VsZi5fb3B0aW9ucy5yZXNldF9yZXN1bHRzOgotICAgICAgICAg ICAgaWYgc2VsZi5faXNfcmVmdGVzdDoKLSAgICAgICAgICAgICAgICAjIFJldHVybnMgYSBkdW1t eSBUZXN0UmVzdWx0LiBXZSBkb24ndCBoYXZlIHRvIHJlYmFzZSBmb3IgcmVmdGVzdHMuCi0gICAg ICAgICAgICAgICAgcmV0dXJuIFRlc3RSZXN1bHQoc2VsZi5fdGVzdF9uYW1lKQotICAgICAgICAg ICAgZWxzZToKLSAgICAgICAgICAgICAgICByZXR1cm4gc2VsZi5fcnVuX3JlYmFzZWxpbmUoKQog ICAgICAgICBpZiBzZWxmLl9pc19yZWZ0ZXN0OgotICAgICAgICAgICAgaWYgc2VsZi5fcG9ydC5n ZXRfb3B0aW9uKCdwaXhlbF90ZXN0cycpOgotICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLl9y dW5fcmVmdGVzdCgpCi0gICAgICAgICAgICByZXN1bHQgPSBUZXN0UmVzdWx0KHNlbGYuX3Rlc3Rf bmFtZSkKLSAgICAgICAgICAgIHJlc3VsdC50eXBlID0gdGVzdF9leHBlY3RhdGlvbnMuU0tJUAot ICAgICAgICAgICAgcmV0dXJuIHJlc3VsdAorICAgICAgICAgICAgaWYgc2VsZi5fcG9ydC5nZXRf b3B0aW9uKCdub19yZWZfdGVzdHMnKSBvciBzZWxmLl9vcHRpb25zLm5ld19iYXNlbGluZSBvciBz ZWxmLl9vcHRpb25zLnJlc2V0X3Jlc3VsdHM6CisgICAgICAgICAgICAgICAgcmVzdWx0ID0gVGVz dFJlc3VsdChzZWxmLl90ZXN0X25hbWUpCisgICAgICAgICAgICAgICAgcmVzdWx0LnR5cGUgPSB0 ZXN0X2V4cGVjdGF0aW9ucy5TS0lQCisgICAgICAgICAgICAgICAgcmV0dXJuIHJlc3VsdAorICAg ICAgICAgICAgcmV0dXJuIHNlbGYuX3J1bl9yZWZ0ZXN0KCkKKyAgICAgICAgaWYgc2VsZi5fb3B0 aW9ucy5uZXdfYmFzZWxpbmUgb3Igc2VsZi5fb3B0aW9ucy5yZXNldF9yZXN1bHRzOgorICAgICAg ICAgICAgcmV0dXJuIHNlbGYuX3J1bl9yZWJhc2VsaW5lKCkKICAgICAgICAgcmV0dXJuIHNlbGYu X3J1bl9jb21wYXJlX3Rlc3QoKQogCiAgICAgZGVmIF9ydW5fY29tcGFyZV90ZXN0KHNlbGYpOgpA QCAtMjkwLDcgKzI4Niw3IEBAIGNsYXNzIFNpbmdsZVRlc3RSdW5uZXI6CiAgICAgZGVmIF9ydW5f cmVmdGVzdChzZWxmKToKICAgICAgICAgZHJpdmVyX291dHB1dDEgPSBzZWxmLl9kcml2ZXIucnVu X3Rlc3Qoc2VsZi5fZHJpdmVyX2lucHV0KCkpCiAgICAgICAgIHJlZmVyZW5jZV90ZXN0X25hbWUg PSBzZWxmLl9wb3J0LnJlbGF0aXZlX3Rlc3RfZmlsZW5hbWUoc2VsZi5fcmVmZXJlbmNlX2ZpbGVu YW1lKQotICAgICAgICBkcml2ZXJfb3V0cHV0MiA9IHNlbGYuX2RyaXZlci5ydW5fdGVzdChEcml2 ZXJJbnB1dChyZWZlcmVuY2VfdGVzdF9uYW1lLCBzZWxmLl90aW1lb3V0LCBkcml2ZXJfb3V0cHV0 MS5pbWFnZV9oYXNoKSkKKyAgICAgICAgZHJpdmVyX291dHB1dDIgPSBzZWxmLl9kcml2ZXIucnVu X3Rlc3QoRHJpdmVySW5wdXQocmVmZXJlbmNlX3Rlc3RfbmFtZSwgc2VsZi5fdGltZW91dCwgZHJp dmVyX291dHB1dDEuaW1hZ2VfaGFzaCwgc2VsZi5faXNfcmVmdGVzdCkpCiAgICAgICAgIHRlc3Rf cmVzdWx0ID0gc2VsZi5fY29tcGFyZV9vdXRwdXRfd2l0aF9yZWZlcmVuY2UoZHJpdmVyX291dHB1 dDEsIGRyaXZlcl9vdXRwdXQyKQogCiAgICAgICAgIHRlc3RfcmVzdWx0X3dyaXRlci53cml0ZV90 ZXN0X3Jlc3VsdChzZWxmLl9wb3J0LCBzZWxmLl90ZXN0X25hbWUsIGRyaXZlcl9vdXRwdXQxLCBk cml2ZXJfb3V0cHV0MiwgdGVzdF9yZXN1bHQuZmFpbHVyZXMpCkBAIC0zMDgsNiArMzA0LDggQEAg Y2xhc3MgU2luZ2xlVGVzdFJ1bm5lcjoKICAgICAgICAgaWYgZmFpbHVyZXM6CiAgICAgICAgICAg ICByZXR1cm4gVGVzdFJlc3VsdChzZWxmLl90ZXN0X25hbWUsIGZhaWx1cmVzLCB0b3RhbF90ZXN0 X3RpbWUsIGhhc19zdGRlcnIpCiAKKyAgICAgICAgYXNzZXJ0KGRyaXZlcl9vdXRwdXQxLmltYWdl X2hhc2ggb3IgZHJpdmVyX291dHB1dDIuaW1hZ2VfaGFzaCkKKwogICAgICAgICBpZiBzZWxmLl9p c19taXNtYXRjaF9yZWZ0ZXN0OgogICAgICAgICAgICAgaWYgZHJpdmVyX291dHB1dDEuaW1hZ2Vf aGFzaCA9PSBkcml2ZXJfb3V0cHV0Mi5pbWFnZV9oYXNoOgogICAgICAgICAgICAgICAgIGZhaWx1 cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVSZWZ0ZXN0TWlzbWF0Y2hEaWROb3RPY2N1 cihzZWxmLl9yZWZlcmVuY2VfZmlsZW5hbWUpKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvd29ya2VyLnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvd29ya2VyLnB5CmluZGV4IGFiOGFh NzU2ZDQ5NTkxZWZlY2U0MmU3NmY0MTFiMzZjMDE2ZTAyYzAuLjVkZDMzYTI2ZDdkMTdlZDNjMDU3 YzRlOTUyOGM2MjA3NzUwNDhhOGIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL2NvbnRyb2xsZXJzL3dvcmtlci5weQorKysgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy93b3JrZXIucHkKQEAgLTI0Myw3ICsyNDMs OSBAQCBjbGFzcyBXb3JrZXIobWFuYWdlcl93b3JrZXJfYnJva2VyLkFic3RyYWN0V29ya2VyKToK IAogICAgICAgICBSZXR1cm5zOiBhIFRlc3RSZXN1bHQgb2JqZWN0LgogICAgICAgICAiIiIKLSAg ICAgICAgaWYgbm90IHNlbGYuX2RyaXZlciBvciBzZWxmLl9kcml2ZXIucG9sbCgpIGlzIG5vdCBO b25lOgorICAgICAgICBpZiBzZWxmLl9kcml2ZXIgYW5kIHNlbGYuX2RyaXZlci5oYXNfY3Jhc2hl ZCgpOgorICAgICAgICAgICAgc2VsZi5raWxsX2RyaXZlcigpCisgICAgICAgIGlmIG5vdCBzZWxm Ll9kcml2ZXI6CiAgICAgICAgICAgICBzZWxmLl9kcml2ZXIgPSBzZWxmLl9wb3J0LmNyZWF0ZV9k cml2ZXIoc2VsZi5fd29ya2VyX251bWJlcikKICAgICAgICAgcmV0dXJuIHNlbGYucnVuX3Npbmds ZV90ZXN0KHNlbGYuX2RyaXZlciwgdGVzdF9pbnB1dCkKIApkaWZmIC0tZ2l0IGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5IGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5CmluZGV4IGU3NDRjZDBhMWMyYTMyOGY1 Y2ZkMjA2MTljNTgyMzA4YjhiNmM2MTIuLmQzNGM0MTEyY2JhZGI0Y2MxMzE3NzIwYWVmMGI0NTJm NjlmNjA0MzYgMTAwNzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvYmFzZS5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2Jhc2UucHkKQEAgLTUzLDYgKzUzLDcgQEAgZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVt LmV4ZWN1dGl2ZSBpbXBvcnQgU2NyaXB0RXJyb3IKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3Rz IGltcG9ydCByZWFkX2NoZWNrc3VtX2Zyb21fcG5nCiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0 cy5tb2RlbHMudGVzdF9jb25maWd1cmF0aW9uIGltcG9ydCBUZXN0Q29uZmlndXJhdGlvbgogZnJv bSB3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydCBpbXBvcnQgY29uZmlnIGFzIHBvcnRfY29uZmln Citmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0IGltcG9ydCBkcml2ZXIKIGZyb20gd2Vi a2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQgaW1wb3J0IGh0dHBfbG9jawogZnJvbSB3ZWJraXRweS5s YXlvdXRfdGVzdHMucG9ydCBpbXBvcnQgdGVzdF9maWxlcwogZnJvbSB3ZWJraXRweS5sYXlvdXRf dGVzdHMuc2VydmVycyBpbXBvcnQgYXBhY2hlX2h0dHBfc2VydmVyCkBAIC02NjMsNyArNjY0LDcg QEAgY2xhc3MgUG9ydChvYmplY3QpOgogCiAgICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwgd29y a2VyX251bWJlcik6CiAgICAgICAgICIiIlJldHVybiBhIG5ld2x5IGNyZWF0ZWQgRHJpdmVyIHN1 YmNsYXNzIGZvciBzdGFydGluZy9zdG9wcGluZyB0aGUgdGVzdCBkcml2ZXIuIiIiCi0gICAgICAg IHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IoJ1BvcnQuY3JlYXRlX2RyaXZlcicpCisgICAgICAg IHJldHVybiBkcml2ZXIuRHJpdmVyUHJveHkoc2VsZiwgd29ya2VyX251bWJlciwgc2VsZi5fZHJp dmVyX2NsYXNzKCksIHBpeGVsX3Rlc3RzPXNlbGYuZ2V0X29wdGlvbigncGl4ZWxfdGVzdHMnKSkK IAogICAgIGRlZiBzdGFydF9oZWxwZXIoc2VsZik6CiAgICAgICAgICIiIklmIGEgcG9ydCBuZWVk cyB0byByZWNvbmZpZ3VyZSBncmFwaGljcyBzZXR0aW5ncyBvciBkbyBvdGhlcgpAQCAtOTU3LDMg Kzk1OCw3IEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgIiIiR2VuZXJhdGVzIGEgbGlz dCBvZiBUZXN0Q29uZmlndXJhdGlvbiBpbnN0YW5jZXMsIHJlcHJlc2VudGluZyBjb25maWd1cmF0 aW9ucwogICAgICAgICBmb3IgYSBwbGF0Zm9ybSBhY3Jvc3MgYWxsIE9TZXMsIGFyY2hpdGVjdHVy ZXMsIGJ1aWxkIGFuZCBncmFwaGljcyB0eXBlcy4iIiIKICAgICAgICAgcmFpc2UgTm90SW1wbGVt ZW50ZWRFcnJvcignUG9ydC5fZ2VuZXJhdGVfdGVzdF9jb25maWd1cmF0aW9ucycpCisKKyAgICBk ZWYgX2RyaXZlcl9jbGFzcyhzZWxmKToKKyAgICAgICAgIiIiUmV0dXJucyB0aGUgcG9ydCdzIGRy aXZlciBpbXBsZW1lbnRhdGlvbi4iIiIKKyAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJv cignUG9ydC5fZHJpdmVyX2NsYXNzJykKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZV91bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZV91bml0dGVzdC5weQppbmRleCA2YjY3Zjk3Mjhm YmYwOTU3ZTk2OGI4MTViMGFiMTlmYzljZTUzYzc3Li5kNzA1YWZjNGI2YmUyMWFmYWRmZjUyNWE0 OTZlNTA1Mjk5ZTU5NjJiIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2Jhc2VfdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlX3VuaXR0ZXN0LnB5CkBAIC0zMDIsMTcgKzMwMiwxNyBA QCBjbGFzcyBWaXJ0dWFsVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAgICAgICAgIHNlbGYuYXNz ZXJ0VmlydHVhbChwb3J0Ll9wYXRoX3RvX3dkaWZmKQogCiAgICAgZGVmIHRlc3RfdmlydHVhbF9k cml2ZXJfbWV0aG9kcyhzZWxmKToKLSAgICAgICAgZHJpdmVyID0gRHJpdmVyKE5vbmUsIE5vbmUp CisgICAgICAgIGRyaXZlciA9IERyaXZlcihQb3J0KE1vY2tIb3N0KCkpLCBOb25lLCBwaXhlbF90 ZXN0cz1GYWxzZSkKICAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKGRyaXZlci5ydW5fdGVzdCwg Tm9uZSkKLSAgICAgICAgc2VsZi5hc3NlcnRWaXJ0dWFsKGRyaXZlci5wb2xsKQogICAgICAgICBz ZWxmLmFzc2VydFZpcnR1YWwoZHJpdmVyLnN0b3ApCisgICAgICAgIHNlbGYuYXNzZXJ0VmlydHVh bChkcml2ZXIuY21kX2xpbmUpCiAKIAogIyBGSVhNRTogVGhpcyBzaG91bGQgYmUgbW92ZWQgdG8g ZHJpdmVyX3VuaXR0ZXN0LnB5IG9yIGp1c3QgZGVsZXRlZC4KIGNsYXNzIERyaXZlclRlc3QodW5p dHRlc3QuVGVzdENhc2UpOgogCiAgICAgZGVmIF9hc3NlcnRfd3JhcHBlcihzZWxmLCB3cmFwcGVy X3N0cmluZywgZXhwZWN0ZWRfd3JhcHBlcik6Ci0gICAgICAgIHdyYXBwZXIgPSBEcml2ZXIoTm9u ZSwgTm9uZSkuX2NvbW1hbmRfd3JhcHBlcih3cmFwcGVyX3N0cmluZykKKyAgICAgICAgd3JhcHBl ciA9IERyaXZlcihQb3J0KE1vY2tIb3N0KCkpLCBOb25lLCBwaXhlbF90ZXN0cz1GYWxzZSkuX2Nv bW1hbmRfd3JhcHBlcih3cmFwcGVyX3N0cmluZykKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCh3 cmFwcGVyLCBleHBlY3RlZF93cmFwcGVyKQogCiAgICAgZGVmIHRlc3RfY29tbWFuZF93cmFwcGVy KHNlbGYpOgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9jaHJvbWl1bS5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvY2hyb21pdW0ucHkKaW5kZXggMWU5NzMwZDUzN2E0OTc3Yjg3YjZiM2VjNjY2OTc3MmIzYjRh MDQ0YS4uNjQ4NmU4ZTNjMzlkMjViNzAwMmE5MDRkZDcxODg4NzkxZmUyM2Q0NyAxMDA3NTUKLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bS5weQor KysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5 CkBAIC0yNTIsOSArMjUyLDggQEAgY2xhc3MgQ2hyb21pdW1Qb3J0KFBvcnQpOgogICAgICAgICBp ZiBzZWxmLl9maWxlc3lzdGVtLmV4aXN0cyhjYWNoZWRpcik6CiAgICAgICAgICAgICBzZWxmLl9m aWxlc3lzdGVtLnJtdHJlZShjYWNoZWRpcikKIAotICAgIGRlZiBjcmVhdGVfZHJpdmVyKHNlbGYs IHdvcmtlcl9udW1iZXIpOgotICAgICAgICAiIiJTdGFydHMgYSBuZXcgRHJpdmVyIGFuZCByZXR1 cm5zIGEgaGFuZGxlIHRvIGl0LiIiIgotICAgICAgICByZXR1cm4gQ2hyb21pdW1Ecml2ZXIoc2Vs Ziwgd29ya2VyX251bWJlcikKKyAgICBkZWYgX2RyaXZlcl9jbGFzcyhzZWxmKToKKyAgICAgICAg cmV0dXJuIENocm9taXVtRHJpdmVyCiAKICAgICBkZWYgc3RhcnRfaGVscGVyKHNlbGYpOgogICAg ICAgICBoZWxwZXJfcGF0aCA9IHNlbGYuX3BhdGhfdG9faGVscGVyKCkKQEAgLTQwMCwxNiArMzk5 LDE2IEBAIGNsYXNzIENocm9taXVtUG9ydChQb3J0KToKIAogIyBGSVhNRTogVGhpcyBzaG91bGQg aW5oZXJpdCBmcm9tIFdlYktpdERyaXZlciBub3cgdGhhdCBDaHJvbWl1bSBoYXMgYSBEdW1wUmVu ZGVyVHJlZSBwcm9jZXNzIGxpa2UgdGhlIHJlc3Qgb2YgV2ViS2l0LgogY2xhc3MgQ2hyb21pdW1E cml2ZXIoRHJpdmVyKToKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJl cik6Ci0gICAgICAgIERyaXZlci5fX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyKQor ICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyLCBwaXhlbF90ZXN0cz1U cnVlKToKKyAgICAgICAgRHJpdmVyLl9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIs IHBpeGVsX3Rlc3RzKQogICAgICAgICBzZWxmLl9wcm9jID0gTm9uZQogICAgICAgICBzZWxmLl9p bWFnZV9wYXRoID0gTm9uZQotICAgICAgICBpZiBzZWxmLl9wb3J0LmdldF9vcHRpb24oJ3BpeGVs X3Rlc3RzJyk6CisgICAgICAgIGlmIHNlbGYuX3BpeGVsX3Rlc3RzOgogICAgICAgICAgICAgc2Vs Zi5faW1hZ2VfcGF0aCA9IHNlbGYuX3BvcnQuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl9wb3J0LnJl c3VsdHNfZGlyZWN0b3J5KCksICdwbmdfcmVzdWx0JXMucG5nJyAlIHNlbGYuX3dvcmtlcl9udW1i ZXIpCiAKICAgICBkZWYgX3dyYXBwZXJfb3B0aW9ucyhzZWxmKToKICAgICAgICAgY21kID0gW10K LSAgICAgICAgaWYgc2VsZi5fcG9ydC5nZXRfb3B0aW9uKCdwaXhlbF90ZXN0cycpOgorICAgICAg ICBpZiBzZWxmLl9waXhlbF90ZXN0czoKICAgICAgICAgICAgICMgU2VlIG5vdGUgYWJvdmUgaW4g ZGlmZl9pbWFnZSgpIGZvciB3aHkgd2UgbmVlZCBfY29udmVydF9wYXRoKCkuCiAgICAgICAgICAg ICBjbWQuYXBwZW5kKCItLXBpeGVsLXRlc3RzPSIgKyBzZWxmLl9wb3J0Ll9jb252ZXJ0X3BhdGgo c2VsZi5faW1hZ2VfcGF0aCkpCiAgICAgICAgICMgRklYTUU6IFRoaXMgaXMgbm90IE5vbmUgc2hv dWxkbid0IGJlIG5lY2Vzc2FyeSwgdW5sZXNzIC0tanMtZmxhZ3M9IicnIiBjaGFuZ2VzIGJlaGF2 aW9yIHNvbWVob3c/CkBAIC00NTUsOCArNDU0LDEwIEBAIGNsYXNzIENocm9taXVtRHJpdmVyKERy aXZlcik6CiAgICAgICAgIGNsb3NlX2ZkcyA9IHN5cy5wbGF0Zm9ybSBub3QgaW4gKCd3aW4zMics ICdjeWd3aW4nKQogICAgICAgICBzZWxmLl9wcm9jID0gc3VicHJvY2Vzcy5Qb3BlbihzZWxmLmNt ZF9saW5lKCksIHN0ZGluPXN1YnByb2Nlc3MuUElQRSwgc3Rkb3V0PXN1YnByb2Nlc3MuUElQRSwg c3RkZXJyPXN1YnByb2Nlc3MuU1RET1VULCBjbG9zZV9mZHM9Y2xvc2VfZmRzKQogCi0gICAgZGVm IHBvbGwoc2VsZik6Ci0gICAgICAgIHJldHVybiBzZWxmLl9wcm9jLnBvbGwoKQorICAgIGRlZiBo YXNfY3Jhc2hlZChzZWxmKToKKyAgICAgICAgaWYgc2VsZi5fcHJvYyBpcyBOb25lOgorICAgICAg ICAgICAgcmV0dXJuIEZhbHNlCisgICAgICAgIHJldHVybiBzZWxmLl9wcm9jLnBvbGwoKSBpcyBu b3QgTm9uZQogCiAgICAgZGVmIF93cml0ZV9jb21tYW5kX2FuZF9yZWFkX2xpbmUoc2VsZiwgaW5w dXQ9Tm9uZSk6CiAgICAgICAgICIiIlJldHVybnMgYSB0dXBsZTogKGxpbmUsIGRpZF9jcmFzaCki IiIKQEAgLTUzMSw3ICs1MzIsNyBAQCBjbGFzcyBDaHJvbWl1bURyaXZlcihEcml2ZXIpOgogCiAg ICAgICAgIHdoaWxlIG5vdCBjcmFzaCBhbmQgbGluZS5yc3RyaXAoKSAhPSAiI0VPRiI6CiAgICAg ICAgICAgICAjIE1ha2Ugc3VyZSB3ZSBoYXZlbid0IGNyYXNoZWQuCi0gICAgICAgICAgICBpZiBs aW5lID09ICcnIGFuZCBzZWxmLnBvbGwoKSBpcyBub3QgTm9uZToKKyAgICAgICAgICAgIGlmIGxp bmUgPT0gJycgYW5kIHNlbGYuX3Byb2MucG9sbCgpIGlzIG5vdCBOb25lOgogICAgICAgICAgICAg ICAgICMgVGhpcyBpcyBoZXggY29kZSAweGMwMDAwMDFkLCB3aGljaCBpcyB1c2VkIGZvciBhYnJ1 cHQKICAgICAgICAgICAgICAgICAjIHRlcm1pbmF0aW9uLiBUaGlzIGhhcHBlbnMgaWYgd2UgaGl0 IGN0cmwrYyBmcm9tIHRoZSBwcm9tcHQKICAgICAgICAgICAgICAgICAjIGFuZCB3ZSBoYXBwZW4g dG8gYmUgd2FpdGluZyBvbiBEUlQuCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2RyaXZlci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3BvcnQvZHJpdmVyLnB5CmluZGV4IGI3NDJkYWJmMTI2YTE3NTE0NzE4NWE1NjZl NjU1OTUyZGJhN2Q3YzIuLmY4YzQxNDg5OWYxNmI1ZGJkNzFhMzEzMzhhZTY5YjJmODFkNGNhZTQg MTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZHJp dmVyLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZHJp dmVyLnB5CkBAIC0zMCwxMCArMzAsMTEgQEAgaW1wb3J0IHNobGV4CiAKIAogY2xhc3MgRHJpdmVy SW5wdXQob2JqZWN0KToKLSAgICBkZWYgX19pbml0X18oc2VsZiwgdGVzdF9uYW1lLCB0aW1lb3V0 LCBpbWFnZV9oYXNoKToKKyAgICBkZWYgX19pbml0X18oc2VsZiwgdGVzdF9uYW1lLCB0aW1lb3V0 LCBpbWFnZV9oYXNoLCBpc19yZWZ0ZXN0KToKICAgICAgICAgc2VsZi50ZXN0X25hbWUgPSB0ZXN0 X25hbWUKICAgICAgICAgc2VsZi50aW1lb3V0ID0gdGltZW91dCAgIyBpbiBtcwogICAgICAgICBz ZWxmLmltYWdlX2hhc2ggPSBpbWFnZV9oYXNoCisgICAgICAgIHNlbGYuaXNfcmVmdGVzdCA9IGlz X3JlZnRlc3QKIAogCiBjbGFzcyBEcml2ZXJPdXRwdXQob2JqZWN0KToKQEAgLTU3LDEwICs1OCwx MCBAQCBjbGFzcyBEcml2ZXJPdXRwdXQob2JqZWN0KToKICAgICAgICAgcmV0dXJuIGJvb2woc2Vs Zi5lcnJvcikKIAogCi1jbGFzcyBEcml2ZXI6CitjbGFzcyBEcml2ZXIob2JqZWN0KToKICAgICAi IiJBYnN0cmFjdCBpbnRlcmZhY2UgZm9yIHRoZSBEdW1wUmVuZGVyVHJlZSBpbnRlcmZhY2UuIiIi CiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlcik6CisgICAgZGVm IF9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIsIHBpeGVsX3Rlc3RzKToKICAgICAg ICAgIiIiSW5pdGlhbGl6ZSBhIERyaXZlciB0byBzdWJzZXF1ZW50bHkgcnVuIHRlc3RzLgogCiAg ICAgICAgIFR5cGljYWxseSB0aGlzIHJvdXRpbmUgd2lsbCBzcGF3biBEdW1wUmVuZGVyVHJlZSBp biBhIGNvbmZpZwpAQCAtNzEsNiArNzIsNyBAQCBjbGFzcyBEcml2ZXI6CiAgICAgICAgICIiIgog ICAgICAgICBzZWxmLl9wb3J0ID0gcG9ydAogICAgICAgICBzZWxmLl93b3JrZXJfbnVtYmVyID0g d29ya2VyX251bWJlcgorICAgICAgICBzZWxmLl9waXhlbF90ZXN0cyA9IHBpeGVsX3Rlc3RzCiAK ICAgICBkZWYgcnVuX3Rlc3Qoc2VsZiwgZHJpdmVyX2lucHV0KToKICAgICAgICAgIiIiUnVuIGEg c2luZ2xlIHRlc3QgYW5kIHJldHVybiB0aGUgcmVzdWx0cy4KQEAgLTg5LDkgKzkxLDQyIEBAIGNs YXNzIERyaXZlcjoKICAgICAgICAgIyB1c2VkIGJ5IGUuZy4gdG9vbHMvdmFsZ3JpbmQvdmFsZ3Jp bmRfdGVzdHMucHkuCiAgICAgICAgIHJldHVybiBzaGxleC5zcGxpdCh3cmFwcGVyX29wdGlvbikg aWYgd3JhcHBlcl9vcHRpb24gZWxzZSBbXQogCi0gICAgZGVmIHBvbGwoc2VsZik6Ci0gICAgICAg ICIiIlJldHVybnMgTm9uZSBpZiB0aGUgRHJpdmVyIGlzIHN0aWxsIHJ1bm5pbmcuIFJldHVybnMg dGhlIHJldHVybmNvZGUgaWYgaXQgaGFzIGV4aXRlZC4iIiIKLSAgICAgICAgcmFpc2UgTm90SW1w bGVtZW50ZWRFcnJvcignRHJpdmVyLnBvbGwnKQorICAgIGRlZiBoYXNfY3Jhc2hlZChzZWxmKToK KyAgICAgICAgcmV0dXJuIEZhbHNlCiAKICAgICBkZWYgc3RvcChzZWxmKToKICAgICAgICAgcmFp c2UgTm90SW1wbGVtZW50ZWRFcnJvcignRHJpdmVyLnN0b3AnKQorCisgICAgZGVmIGNtZF9saW5l KHNlbGYpOgorICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdEcml2ZXIuY21kX2xp bmUnKQorCisKK2NsYXNzIERyaXZlclByb3h5KG9iamVjdCk6CisgICAgIiIiQSB3cmFwcGVyIGZv ciBtYW5hZ2luZyB0d28gRHJpdmVyIGluc3RhbmNlcywgb25lIHdpdGggcGl4ZWwgdGVzdHMgYW5k CisgICAgb25lIHdpdGhvdXQuIFRoaXMgYWxsb3dzIHVzIHRvIGhhbmRsZSBwbGFpbiB0ZXh0IHRl c3RzIGFuZCByZWYgdGVzdHMgd2l0aCBhCisgICAgc2luZ2xlIGRyaXZlci4iIiIKKworICAgIGRl ZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyLCBkcml2ZXJfaW5zdGFuY2VfY29u c3RydWN0b3IsIHBpeGVsX3Rlc3RzKToKKyAgICAgICAgc2VsZi5fZHJpdmVyID0gZHJpdmVyX2lu c3RhbmNlX2NvbnN0cnVjdG9yKHBvcnQsIHdvcmtlcl9udW1iZXIsIHBpeGVsX3Rlc3RzKQorICAg ICAgICBpZiBwaXhlbF90ZXN0czoKKyAgICAgICAgICAgIHNlbGYuX3JlZnRlc3RfZHJpdmVyID0g c2VsZi5fZHJpdmVyCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBzZWxmLl9yZWZ0ZXN0X2Ry aXZlciA9IGRyaXZlcl9pbnN0YW5jZV9jb25zdHJ1Y3Rvcihwb3J0LCB3b3JrZXJfbnVtYmVyLCBw aXhlbF90ZXN0cz1UcnVlKQorCisgICAgZGVmIHJ1bl90ZXN0KHNlbGYsIGRyaXZlcl9pbnB1dCk6 CisgICAgICAgIGlmIGRyaXZlcl9pbnB1dC5pc19yZWZ0ZXN0OgorICAgICAgICAgICAgcmV0dXJu IHNlbGYuX3JlZnRlc3RfZHJpdmVyLnJ1bl90ZXN0KGRyaXZlcl9pbnB1dCkKKyAgICAgICAgcmV0 dXJuIHNlbGYuX2RyaXZlci5ydW5fdGVzdChkcml2ZXJfaW5wdXQpCisKKyAgICBkZWYgaGFzX2Ny YXNoZWQoc2VsZik6CisgICAgICAgIHJldHVybiBzZWxmLl9kcml2ZXIuaGFzX2NyYXNoZWQoKSBv ciBzZWxmLl9yZWZ0ZXN0X2RyaXZlci5oYXNfY3Jhc2hlZCgpCisKKyAgICBkZWYgc3RvcChzZWxm KToKKyAgICAgICAgc2VsZi5fZHJpdmVyLnN0b3AoKQorICAgICAgICBzZWxmLl9yZWZ0ZXN0X2Ry aXZlci5zdG9wKCkKKworICAgIGRlZiBjbWRfbGluZShzZWxmKToKKyAgICAgICAgY21kX2xpbmUg PSBzZWxmLl9kcml2ZXIuY21kX2xpbmUoKQorICAgICAgICBpZiBzZWxmLl9kcml2ZXIgIT0gc2Vs Zi5fcmVmdGVzdF9kcml2ZXI6CisgICAgICAgICAgICBjbWRfbGluZSArPSBbJzsgJ10gKyBzZWxm Ll9yZWZ0ZXN0X2RyaXZlci5jbWRfbGluZSgpCisgICAgICAgIHJldHVybiBjbWRfbGluZQpkaWZm IC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9kcnlydW4u cHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2RyeXJ1bi5weQpp bmRleCBjYTNiYWRlM2Q4ZThmZGVjOTg0OGFiOGM1YWFmODE5OWM1NTJhNzAxLi4yNmI4ZDM1YmZm Yzk1NWMwNjEwZDMzZDcxMTI2NzUxYTQ4OWQzMzRmIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2RyeXJ1bi5weQorKysgYi9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2RyeXJ1bi5weQpAQCAtOTksOCArOTksOCBAQCBj bGFzcyBEcnlSdW5Qb3J0KG9iamVjdCk6CiAgICAgZGVmIHN0b3Bfd2Vic29ja2V0X3NlcnZlcihz ZWxmKToKICAgICAgICAgcGFzcwogCi0gICAgZGVmIGNyZWF0ZV9kcml2ZXIoc2VsZiwgd29ya2Vy X251bWJlcik6Ci0gICAgICAgIHJldHVybiBEcnlydW5Ecml2ZXIoc2VsZiwgd29ya2VyX251bWJl cikKKyAgICBkZWYgZHJpdmVyX2NsYXNzKHNlbGYpOgorICAgICAgICByZXR1cm4gRHJ5cnVuRHJp dmVyCiAKIAogY2xhc3MgRHJ5cnVuRHJpdmVyKERyaXZlcik6CkBAIC0xMDksOSArMTA5LDYgQEAg Y2xhc3MgRHJ5cnVuRHJpdmVyKERyaXZlcik6CiAgICAgZGVmIGNtZF9saW5lKHNlbGYpOgogICAg ICAgICByZXR1cm4gWydOb25lJ10KIAotICAgIGRlZiBwb2xsKHNlbGYpOgotICAgICAgICByZXR1 cm4gTm9uZQotCiAgICAgZGVmIHJ1bl90ZXN0KHNlbGYsIGRyaXZlcl9pbnB1dCk6CiAgICAgICAg IHN0YXJ0X3RpbWUgPSB0aW1lLnRpbWUoKQogICAgICAgICBmcyA9IHNlbGYuX3BvcnQuX2ZpbGVz eXN0ZW0KZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvZ3RrLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsu cHkKaW5kZXggM2VlZDgyOTE0NmNlNGI5NDk2N2Y0OTAwZGE0NzUzMDMwOTU0YmI2NC4uZmUxZWIw NThlNzMwYWZjMDEyODdjZDhjY2FkOTZhMzQxNDkxZDkwMyAxMDA2NDQKLS0tIGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkKKysrIGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkKQEAgLTcyLDggKzcyLDggQEAgY2xh c3MgR3RrUG9ydChXZWJLaXRQb3J0KToKICAgICBkZWYgX3BvcnRfZmxhZ19mb3Jfc2NyaXB0cyhz ZWxmKToKICAgICAgICAgcmV0dXJuICItLWd0ayIKIAotICAgIGRlZiBjcmVhdGVfZHJpdmVyKHNl bGYsIHdvcmtlcl9udW1iZXIpOgotICAgICAgICByZXR1cm4gR3RrRHJpdmVyKHNlbGYsIHdvcmtl cl9udW1iZXIpCisgICAgZGVmIF9kcml2ZXJfY2xhc3Moc2VsZik6CisgICAgICAgIHJldHVybiBH dGtEcml2ZXIKIAogICAgIGRlZiBzZXR1cF9lbnZpcm9uX2Zvcl9zZXJ2ZXIoc2VsZiwgc2VydmVy X25hbWU9Tm9uZSk6CiAgICAgICAgIGVudmlyb25tZW50ID0gV2ViS2l0UG9ydC5zZXR1cF9lbnZp cm9uX2Zvcl9zZXJ2ZXIoc2VsZiwgc2VydmVyX25hbWUpCmRpZmYgLS1naXQgYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3QucHkKaW5kZXggN2U1ZDk1NmVlNGQ0MTBiMDQ4 YjczNGMzMzQ4NmZhOGQ4YTE5MDc4ZC4uNDlmNjQ1NTJjNWIxMGY0OTBjOTdmODVmYzllN2ZiY2Fh YWQyMjcyZSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC90ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvdGVzdC5weQpAQCAtMzU5LDggKzM1OSw4IEBAIGNsYXNzIFRlc3RQb3J0KFBvcnQpOgogICAg IGRlZiBzZXR1cF90ZXN0X3J1bihzZWxmKToKICAgICAgICAgcGFzcwogCi0gICAgZGVmIGNyZWF0 ZV9kcml2ZXIoc2VsZiwgd29ya2VyX251bWJlcik6Ci0gICAgICAgIHJldHVybiBUZXN0RHJpdmVy KHNlbGYsIHdvcmtlcl9udW1iZXIpCisgICAgZGVmIF9kcml2ZXJfY2xhc3Moc2VsZik6CisgICAg ICAgIHJldHVybiBUZXN0RHJpdmVyCiAKICAgICBkZWYgc3RhcnRfaHR0cF9zZXJ2ZXIoc2VsZik6 CiAgICAgICAgIHBhc3MKQEAgLTQ4OCw5ICs0ODgsNiBAQCBjbGFzcyBUZXN0RHJpdmVyKERyaXZl cik6CiAgICAgZGVmIGNtZF9saW5lKHNlbGYpOgogICAgICAgICByZXR1cm4gW3NlbGYuX3BvcnQu X3BhdGhfdG9fZHJpdmVyKCldICsgc2VsZi5fcG9ydC5nZXRfb3B0aW9uKCdhZGRpdGlvbmFsX2Ry dF9mbGFnJywgW10pCiAKLSAgICBkZWYgcG9sbChzZWxmKToKLSAgICAgICAgcmV0dXJuIFRydWUK LQogICAgIGRlZiBydW5fdGVzdChzZWxmLCB0ZXN0X2lucHV0KToKICAgICAgICAgc3RhcnRfdGlt ZSA9IHRpbWUudGltZSgpCiAgICAgICAgIHRlc3RfbmFtZSA9IHRlc3RfaW5wdXQudGVzdF9uYW1l CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dl YmtpdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0 LnB5CmluZGV4IDk1NjExYjRhMmYxZTNmNzFkY2NjZWIxMWE1YjJmMzVlYmI4MmQyMTguLjgxZDNk OTQ3ZDgzOGU4MTNkMTU5NTY3NGJiZWJlODI0MTIzMjliMmUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CisrKyBiL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CkBAIC0yMjUsOCArMjI1 LDggQEAgY2xhc3MgV2ViS2l0UG9ydChQb3J0KToKICAgICAgICAgIyB0byBoYXZlIG11bHRpcGxl IGNvcGllcyBvZiB3ZWJraXQgY2hlY2tlZCBvdXQgYW5kIGJ1aWx0LgogICAgICAgICByZXR1cm4g c2VsZi5fYnVpbGRfcGF0aCgnbGF5b3V0LXRlc3QtcmVzdWx0cycpCiAKLSAgICBkZWYgY3JlYXRl X2RyaXZlcihzZWxmLCB3b3JrZXJfbnVtYmVyKToKLSAgICAgICAgcmV0dXJuIFdlYktpdERyaXZl cihzZWxmLCB3b3JrZXJfbnVtYmVyKQorICAgIGRlZiBfZHJpdmVyX2NsYXNzKHNlbGYpOgorICAg ICAgICByZXR1cm4gV2ViS2l0RHJpdmVyCiAKICAgICBkZWYgX3Rlc3RzX2Zvcl9vdGhlcl9wbGF0 Zm9ybXMoc2VsZik6CiAgICAgICAgICMgQnkgZGVmYXVsdCB3ZSB3aWxsIHNraXAgYW55IGRpcmVj dG9yeSB1bmRlciBMYXlvdXRUZXN0cy9wbGF0Zm9ybQpAQCAtNDQwLDggKzQ0MCw4IEBAIGNsYXNz IFdlYktpdFBvcnQoUG9ydCk6CiBjbGFzcyBXZWJLaXREcml2ZXIoRHJpdmVyKToKICAgICAiIiJX ZWJLaXQgaW1wbGVtZW50YXRpb24gb2YgdGhlIER1bXBSZW5kZXJUcmVlL1dlYktpdFRlc3RSdW5u ZXIgaW50ZXJmYWNlLiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9u dW1iZXIpOgotICAgICAgICBEcml2ZXIuX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJl cikKKyAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlciwgcGl4ZWxfdGVz dHM9RmFsc2UpOgorICAgICAgICBEcml2ZXIuX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251 bWJlciwgcGl4ZWxfdGVzdHMpCiAgICAgICAgIHNlbGYuX2RyaXZlcl90ZW1wZGlyID0gcG9ydC5f ZmlsZXN5c3RlbS5ta2R0ZW1wKHByZWZpeD0nJXMtJyAlIHNlbGYuX3BvcnQuZHJpdmVyX25hbWUo KSkKICAgICAgICAgIyBXZWJLaXRUZXN0UnVubmVyIGNhbiByZXBvcnQgYmFjayBzdWJwcm9jZXNz IGNyYXNoZXMgYnkgcHJpbnRpbmcKICAgICAgICAgIyAiI0NSQVNIRUQgLSBQUk9DRVNTTkFNRSIu ICBTaW5jZSB0aG9zZSBjYW4gaGFwcGVuIGF0IGFueSB0aW1lCkBAIC00NTcsNyArNDU3LDYgQEAg Y2xhc3MgV2ViS2l0RHJpdmVyKERyaXZlcik6CiAgICAgICAgIHNlbGYuZXJyX3NlZW5fZW9mID0g RmFsc2UKICAgICAgICAgc2VsZi5fc2VydmVyX3Byb2Nlc3MgPSBOb25lCiAKLQogICAgICMgRklY TUU6IFRoaXMgbWF5IGJlIHVuc2FmZSwgYXMgcHl0aG9uIGRvZXMgbm90IGd1YXJlbnRlZSBhbnkg b3JkZXJpbmcgb2YgX19kZWxfXyBjYWxscwogICAgICMgSSBiZWxpZXZlIGl0J3MgcG9zc2libGUg dGhhdCBzZWxmLl9wb3J0IG9yIHNlbGYuX3BvcnQuX2ZpbGVzeXN0ZW0gbWF5IGFscmVhZHkgYmUg ZGVzdHJveWVkLgogICAgIGRlZiBfX2RlbF9fKHNlbGYpOgpAQCAtNDY2LDcgKzQ2NSw3IEBAIGNs YXNzIFdlYktpdERyaXZlcihEcml2ZXIpOgogICAgIGRlZiBjbWRfbGluZShzZWxmKToKICAgICAg ICAgY21kID0gc2VsZi5fY29tbWFuZF93cmFwcGVyKHNlbGYuX3BvcnQuZ2V0X29wdGlvbignd3Jh cHBlcicpKQogICAgICAgICBjbWQuYXBwZW5kKHNlbGYuX3BvcnQuX3BhdGhfdG9fZHJpdmVyKCkp Ci0gICAgICAgIGlmIHNlbGYuX3BvcnQuZ2V0X29wdGlvbigncGl4ZWxfdGVzdHMnKToKKyAgICAg ICAgaWYgc2VsZi5fcGl4ZWxfdGVzdHM6CiAgICAgICAgICAgICBjbWQuYXBwZW5kKCctLXBpeGVs LXRlc3RzJykKICAgICAgICAgaWYgc2VsZi5fcG9ydC5nZXRfb3B0aW9uKCdnY19iZXR3ZWVuX3Rl c3RzJyk6CiAgICAgICAgICAgICBjbWQuYXBwZW5kKCctLWdjLWJldHdlZW4tdGVzdHMnKQpAQCAt NDkwLDggKzQ4OSwxMCBAQCBjbGFzcyBXZWJLaXREcml2ZXIoRHJpdmVyKToKICAgICAgICAgc2Vs Zi5fY3Jhc2hlZF9zdWJwcm9jZXNzX25hbWUgPSBOb25lCiAgICAgICAgIHNlbGYuX3NlcnZlcl9w cm9jZXNzID0gc2VydmVyX3Byb2Nlc3MuU2VydmVyUHJvY2VzcyhzZWxmLl9wb3J0LCBzZXJ2ZXJf bmFtZSwgc2VsZi5jbWRfbGluZSgpLCBlbnZpcm9ubWVudCkKIAotICAgIGRlZiBwb2xsKHNlbGYp OgotICAgICAgICByZXR1cm4gc2VsZi5fc2VydmVyX3Byb2Nlc3MucG9sbCgpCisgICAgZGVmIGhh c19jcmFzaGVkKHNlbGYpOgorICAgICAgICBpZiBzZWxmLl9zZXJ2ZXJfcHJvY2VzcyBpcyBOb25l OgorICAgICAgICAgICAgcmV0dXJuIEZhbHNlCisgICAgICAgIHJldHVybiBzZWxmLl9zZXJ2ZXJf cHJvY2Vzcy5wb2xsKCkgaXMgbm90IE5vbmUKIAogICAgIGRlZiBfY2hlY2tfZm9yX2RyaXZlcl9j cmFzaChzZWxmLCBlcnJvcl9saW5lKToKICAgICAgICAgaWYgZXJyb3JfbGluZSA9PSAiI0NSQVNI RURcbiI6CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9y dW5fd2Via2l0X3Rlc3RzLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cnVuX3dlYmtpdF90ZXN0cy5weQppbmRleCA2ZDYyN2I2NDhiN2EyZDJmYTFkZmNhMzlhNGRjMjlm N2VlYWUwOGQwLi5lZDc4YjEyZmIyMzRjY2I4Yzg0MTM4ZDdjMjJlZmM3YjgxMDRkNDI1IDEwMDc1 NQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rl c3RzLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJr aXRfdGVzdHMucHkKQEAgLTI3NCw2ICsyNzQsOCBAQCBkZWYgcGFyc2VfYXJncyhhcmdzPU5vbmUp OgogICAgICAgICAgICAgZGVzdD0icGl4ZWxfdGVzdHMiLCBoZWxwPSJEaXNhYmxlIHBpeGVsLXRv LXBpeGVsIFBORyBjb21wYXJpc29ucyIpLAogICAgICAgICBvcHRwYXJzZS5tYWtlX29wdGlvbigi LS1uby1zYW1wbGUtb24tdGltZW91dCIsIGFjdGlvbj0ic3RvcmVfZmFsc2UiLAogICAgICAgICAg ICAgZGVzdD0ic2FtcGxlX29uX3RpbWVvdXQiLCBoZWxwPSJEb24ndCBydW4gc2FtcGxlIG9uIHRp bWVvdXQgKE1hYyBPUyBYIG9ubHkpIiksCisgICAgICAgIG9wdHBhcnNlLm1ha2Vfb3B0aW9uKCIt LW5vLXJlZi10ZXN0cyIsIGFjdGlvbj0ic3RvcmVfdHJ1ZSIsCisgICAgICAgICAgICBkZXN0PSJu b19yZWZfdGVzdHMiLCBoZWxwPSJTa2lwIGFsbCByZWYgdGVzdHMiKSwKICAgICAgICAgb3B0cGFy c2UubWFrZV9vcHRpb24oIi0tdG9sZXJhbmNlIiwKICAgICAgICAgICAgIGhlbHA9Iklnbm9yZSBp bWFnZSBkaWZmZXJlbmNlcyBsZXNzIHRoYW4gdGhpcyBwZXJjZW50YWdlIChzb21lICIKICAgICAg ICAgICAgICAgICAicG9ydHMgbWF5IGlnbm9yZSB0aGlzIG9wdGlvbikiLCB0eXBlPSJmbG9hdCIp LApkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dl YmtpdF90ZXN0c19pbnRlZ3JhdGlvbnRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX2ludGVncmF0aW9udGVzdC5weQppbmRleCBhNjQ0 NmM1MmQ5ODI3NDI5NzA2NjI3N2YxMGEwN2UyYjk4MDY5MjliLi5kOTY5YTBlNTg3NTcyMDhhYWJh OTQwOGUyNTBjYjY3MzI1ZjliODQ5IDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX2ludGVncmF0aW9udGVzdC5weQorKysgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX2ludGVn cmF0aW9udGVzdC5weQpAQCAtMTUyLDEzICsxNTIsOSBAQCBkZWYgZ2V0X3Rlc3RzX3J1bihleHRy YV9hcmdzPU5vbmUsIHRlc3RzX2luY2x1ZGVkPUZhbHNlLCBmbGF0dGVuX2JhdGNoZXM9RmFsc2Us CiAKICAgICBjbGFzcyBSZWNvcmRpbmdUZXN0RHJpdmVyKFRlc3REcml2ZXIpOgogICAgICAgICBk ZWYgX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlcik6Ci0gICAgICAgICAgICBUZXN0 RHJpdmVyLl9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIpCisgICAgICAgICAgICBU ZXN0RHJpdmVyLl9faW5pdF9fKHNlbGYsIHBvcnQsIHdvcmtlcl9udW1iZXIsIHBpeGVsX3Rlc3Rz PXBvcnQuZ2V0X29wdGlvbigncGl4ZWxfdGVzdCcpKQogICAgICAgICAgICAgc2VsZi5fY3VycmVu dF90ZXN0X2JhdGNoID0gTm9uZQogCi0gICAgICAgIGRlZiBwb2xsKHNlbGYpOgotICAgICAgICAg ICAgIyBTbyB0aGF0IHdlIGRvbid0IGNyZWF0ZSBhIG5ldyBkcml2ZXIgZm9yIGV2ZXJ5IHRlc3QK LSAgICAgICAgICAgIHJldHVybiBOb25lCi0KICAgICAgICAgZGVmIHN0b3Aoc2VsZik6CiAgICAg ICAgICAgICBzZWxmLl9jdXJyZW50X3Rlc3RfYmF0Y2ggPSBOb25lCiAKQEAgLTY4MCw4ICs2NzYs MTQgQEAgY2xhc3MgTWFpblRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICB0ZXN0c19y dW4gPSBnZXRfdGVzdHNfcnVuKFsncGFzc2VzL3JlZnRlc3QuaHRtbCddLCB0ZXN0c19pbmNsdWRl ZD1UcnVlLCBmbGF0dGVuX2JhdGNoZXM9VHJ1ZSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbHMo WydwYXNzZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX3J1bikKIAotICAgIGRlZiB0ZXN0X3JlZnRl c3Rfc2tpcF9yZWZ0ZXN0c19pZl9waXhlbF90ZXN0c19hcmVfZGlzYWJsZWQoc2VsZik6CisgICAg ZGVmIHRlc3RfcmVmdGVzdF9ydW5fcmVmdGVzdHNfaWZfcGl4ZWxfdGVzdHNfYXJlX2Rpc2FibGVk KHNlbGYpOgogICAgICAgICB0ZXN0c19ydW4gPSBnZXRfdGVzdHNfcnVuKFsnLS1uby1waXhlbC10 ZXN0cycsICdwYXNzZXMvcmVmdGVzdC5odG1sJ10sIHRlc3RzX2luY2x1ZGVkPVRydWUsIGZsYXR0 ZW5fYmF0Y2hlcz1UcnVlKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFscyhbJ3Bhc3Nlcy9yZWZ0 ZXN0Lmh0bWwnXSwgdGVzdHNfcnVuKQorCisgICAgZGVmIHRlc3RfcmVmdGVzdF9za2lwX3JlZnRl c3RzX2lmX25vX3JlZl90ZXN0cyhzZWxmKToKKyAgICAgICAgdGVzdHNfcnVuID0gZ2V0X3Rlc3Rz X3J1bihbJy0tbm8tcmVmLXRlc3RzJywgJ3Bhc3Nlcy9yZWZ0ZXN0Lmh0bWwnXSwgdGVzdHNfaW5j bHVkZWQ9VHJ1ZSwgZmxhdHRlbl9iYXRjaGVzPVRydWUpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1 YWxzKFtdLCB0ZXN0c19ydW4pCisgICAgICAgIHRlc3RzX3J1biA9IGdldF90ZXN0c19ydW4oWyct LW5vLXJlZi10ZXN0cycsICctLW5vLXBpeGVsLXRlc3RzJywgJ3Bhc3Nlcy9yZWZ0ZXN0Lmh0bWwn XSwgdGVzdHNfaW5jbHVkZWQ9VHJ1ZSwgZmxhdHRlbl9iYXRjaGVzPVRydWUpCiAgICAgICAgIHNl bGYuYXNzZXJ0RXF1YWxzKFtdLCB0ZXN0c19ydW4pCiAKICAgICBkZWYgdGVzdF9yZWZ0ZXN0X2V4 cGVjdGVkX2h0bWxfc2hvdWxkX2JlX2lnbm9yZWQoc2VsZik6Cg==