139671 2014-12-15 21:44:37 -0800 Sort out timeout implementations in DRT and WKTR 2014-12-18 05:32:55 -0800 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=139734 P2 Normal --- 139774 139734 139772 1 ap ap bfulgham cgarcia clopez commit-queue dbates glenn gyuyoung.kim ossy simon.fraser oldest_to_newest 1055865 0 ap 2014-12-15 21:44:37 -0800 There are multiple timeout watchdogs for regression tests: 1. One in run-webkit-test. When this fires, the tool gets sampled, and restarted. No partial output is saved. This supports [ Slow ] modifiers. 2. Async tests have their timeouts detected by DumpRenderTree and WebKitTestRunner, as long as main thread returns to event loop. When this timeout occurs, the test is incorrectly reported as failing, not timing out. There is partial output and an error line for the timeout. [ Slow ] modifiers are not respected - this timeout is always 30 seconds. 3. In WebKitTestRunner, UI process detects a timeout and fails. There is no partial output saved, no sample, and the test is reported as failing. 4. There are timeouts for individual messages that UI process sends to WebProcess in WebKitTestRunner. #3 is no better than #1, and can be eliminated. #2 should support [ Slow ] modifiers, and should be reported as an actual timeout that it is. WebKitTestRunner has a lot longer async test timeout than DumpRenderTree. I don't think that this is necessary or desirable. iOS has a lot longer DumpRenderTree timeout. I don't think that this is necessary or desirable. Gtk has a very strange timeout computation in WebKitTestRunner, see bug 138831 comment 10. I'm going to fix all these issues here, except for the Gtk one, which I cannot test. 1055867 1 ap 2014-12-15 21:51:31 -0800 Also not fixing: Windows DumpRenderTree. This should be straightforward, but needs building and testing on a Windows machine. 1055871 2 243350 ap 2014-12-15 22:33:29 -0800 Created attachment 243350 proposed fix 1055873 3 commit-queue 2014-12-15 22:35:47 -0800 Attachment 243350 did not pass style-queue: ERROR: Tools/Scripts/webkitpy/port/driver.py:367: multiple statements on one line (semicolon) [pep8/E702] [5] Total errors found: 1 in 17 files If any of these errors are false positives, please file a bug against check-webkit-style. 1055877 4 243350 simon.fraser 2014-12-15 23:12:15 -0800 Comment on attachment 243350 proposed fix View in context: https://bugs.webkit.org/attachment.cgi?id=243350&action=review > Tools/DumpRenderTree/TestRunner.h:437 > + int m_timeout; Would be nice to use a comment saying what units this is in, or use a double, or std::chrono something. > Tools/WebKitTestRunner/InjectedBundle/mac/TestRunnerMac.mm:55 > + CFTimeInterval interval = m_timeout ? m_timeout / 1000.0 : defaultWaitToDumpWatchdogTimerInterval; Can't we just initialize m_timeout with defaultWaitToDumpWatchdogTimerInterval ? 1055957 5 243350 cgarcia 2014-12-16 02:05:39 -0800 Comment on attachment 243350 proposed fix View in context: https://bugs.webkit.org/attachment.cgi?id=243350&action=review > Tools/WebKitTestRunner/InjectedBundle/gtk/TestRunnerGtk.cpp:53 > + // FIXME: Use m_timeout, and only fall back to default when it's zero. > m_waitToDumpWatchdogTimer.scheduleAfterDelay("[WTR] waitToDumpWatchdogTimerCallback", [this] { waitToDumpWatchdogTimerFired(); }, > - std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(waitToDumpWatchdogTimerInterval))); > + std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(defaultWaitToDumpWatchdogTimerInterval))); So, what units is m_timeout in? The conversion to microseconds is correct here for the default timeout that is in seconds as a double value. I guess m_timeout is in milliseconds, since you are doing m_timeout/1000 in other cases. In this case that we know the value will not be truncated when converting to milliseconds (test timeouts are not that short), we could use milliseconds. std::chrono::milliseconds interval = m_timeout ? std::chrono::milliseconds(m_timeout) : std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::duration<double>(defaultWaitToDumpWatchdogTimerInterval)); m_waitToDumpWatchdogTimer.scheduleAfterDelay("[WTR] waitToDumpWatchdogTimerCallback", [this] { waitToDumpWatchdogTimerFired(); }, interval); Everything would be easier if m_timeout was a std::chrono::milliseconds and initialized to the default as Simon proposes. 1055996 6 ap 2014-12-16 10:12:44 -0800 > Would be nice to use a comment saying what units this is in, or use a double, or std::chrono something. True. There are several more m_timeout variables in DumpRenderTree and WebKitTestRunner though, so it's better to update the types in a separate patch. > Can't we just initialize m_timeout with defaultWaitToDumpWatchdogTimerInterval ? Good idea. 1055999 7 ap 2014-12-16 10:31:54 -0800 Committed <https://trac.webkit.org/r177363>. 1056059 8 ossy 2014-12-16 12:42:13 -0800 (In reply to comment #7) > Committed <https://trac.webkit.org/r177363>. It broke the test infrastructure on EFL and GTK: - https://build.webkit.org/builders/GTK%20Linux%2064-bit%20Release%20%28Tests%29/builds/4907 - https://build.webkit.org/builders/EFL%20Linux%2064-bit%20Release%20WK2/builds/18385 1056131 9 ap 2014-12-16 13:58:48 -0800 Sorry about that. It's not clear to me from the logs what broke. I'd love to help, but someone else will need to analyze what the problems are. Essentially, I made all the fixes blindly, and they worked on Mac from the first time, there wasn't much Mac specific here. One thing that I noticed earlier about Gtk tests was that they tend to time out unexpectedly quickly. See e.g. <http://webkit-test-results.appspot.com/dashboards/flakiness_dashboard.html#tests=fast%2Fworkers%2Fworker-close-more.html> - why do tests time out in 6 seconds? Perhaps that's somehow related. 1056235 10 clopez 2014-12-16 18:57:52 -0800 (In reply to comment #9) > Sorry about that. > > It's not clear to me from the logs what broke. I'd love to help, but someone > else will need to analyze what the problems are. Essentially, I made all the > fixes blindly, and they worked on Mac from the first time, there wasn't much > Mac specific here. > > One thing that I noticed earlier about Gtk tests was that they tend to time > out unexpectedly quickly. See e.g. > <http://webkit-test-results.appspot.com/dashboards/flakiness_dashboard. > html#tests=fast%2Fworkers%2Fworker-close-more.html> - why do tests time out > in 6 seconds? Perhaps that's somehow related. I have detected two main issues: 1) On the GTK port, we define the timeout to 6000ms (release), 12000ms (debug) or 10000ms (if checking memory leaks with valgrind) http://trac.webkit.org/browser/trunk/Tools/Scripts/webkitpy/port/gtk.py?rev=177363#L83 Your patch is substracting 5000ms from this timeout <http://trac.webkit.org/changeset/177363/trunk/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py> Leaving it to 1000ms (1 sec). That don't seems enough for many tests to complete. Why are you removing those 5 seconds from the default timeout? 2) r177363 breakes all ports that don't enable supports_per_test_timeout() on Tools/Scripts/webkitpy/port/$port.py This is because m_timeout is initialized to 0 <http://trac.webkit.org/browser/trunk/Tools/WebKitTestRunner/TestInvocation.cpp?rev=177363#L96>, and never updated with the port default value because the python scripts don't pass the --timeout argument when the previous is not enabled. Maybe we should just enable supports_per_test_timeout() for all ports at Tools/Scripts/webkitpy/port/base.py ? So, I have tested, and the patch below will fix the breakage introduced by r177363 on the GTK port: diff --git a/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py b/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py index 8f72506..1c3fa21 100644 --- a/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py +++ b/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py @@ -62,11 +62,6 @@ class SingleTestRunner(object): self._stop_when_done = stop_when_done self._timeout = test_input.timeout - if self._timeout > 5000: - # Timeouts are detected by both script and tool; tool detected timeouts are - # better, because they contain partial output. Give the tool some time to - # report the timeout instead of being killed. - self._timeout = int(self._timeout) - 5000 if self._reference_files: # Detect and report a test which has a wrong combination of expectation files. diff --git a/Tools/Scripts/webkitpy/port/gtk.py b/Tools/Scripts/webkitpy/port/gtk.py index 338e2d1..ad451be 100644 --- a/Tools/Scripts/webkitpy/port/gtk.py +++ b/Tools/Scripts/webkitpy/port/gtk.py @@ -80,6 +80,9 @@ class GtkPort(Port): return XorgDriver return XvfbDriver + def supports_per_test_timeout(self): + return True + def default_timeout_ms(self): # Starting an application under Valgrind takes a lot longer than normal # so increase the timeout (empirically 10x is enough to avoid timeouts). Any comments about it? 1056238 11 clopez 2014-12-16 19:01:35 -0800 (In reply to comment #10) > 1) > On the GTK port, we define the timeout to 6000ms (release), 12000ms (debug) > or 10000ms (if checking memory leaks with valgrind) > http://trac.webkit.org/browser/trunk/Tools/Scripts/webkitpy/port/gtk. > py?rev=177363#L83 I read it wrongly. When using valgrind we are doing a 10x (so 60000ms for release and 120000ms for debug) 1056247 12 ap 2014-12-16 19:48:59 -0800 Thank you for looking into this! > Why are you removing those 5 seconds from the default timeout? This is needed to let tool-detected timeout be reported before run-webkit-tests kills the tool. When both have the same timeout, there is a race to detect it. It is OK to change these numbers to some reasonable values that suit other ports. > Maybe we should just enable supports_per_test_timeout() for all ports at Tools/Scripts/webkitpy/port/base.py ? I'm not sure if DumpRenderTree on Windows supports it yet, but otherwise, this seems like the right thing to do. We could also remove a bunch of code then. But this is not the best solution to this problem, because we should also keep WebKitTestRunner working when launched manually, without the option. > This is because m_timeout is initialized to 0 Oops, I tried to have it use the default 30 second timeout in this case, but didn't do that right. Should be an easy fix - I can do that tomorrow if no one beats me to it. 1056309 13 clopez 2014-12-17 05:00:17 -0800 (In reply to comment #12) > Thank you for looking into this! > > > Why are you removing those 5 seconds from the default timeout? > > This is needed to let tool-detected timeout be reported before > run-webkit-tests kills the tool. When both have the same timeout, there is a > race to detect it. > > It is OK to change these numbers to some reasonable values that suit other > ports. > And instead of doing that (subtracting 5 seconds from the parameter --timeout passed to the tool (WKTR))... what about just making run-webkit-test wait 1 second more? diff --git a/Tools/Scripts/webkitpy/port/driver.py b/Tools/Scripts/webkitpy/port/driver.py index 715bd7e..9f5e3cd 100644 --- a/Tools/Scripts/webkitpy/port/driver.py +++ b/Tools/Scripts/webkitpy/port/driver.py @@ -180,6 +180,9 @@ class Driver(object): command = self._command_from_driver_input(driver_input) deadline = test_begin_time + int(driver_input.timeout) / 1000.0 + # Add an extra second to let tool-detected timeout be reported before run-webkit-tests kills the tool. + # When both have the same timeout, there is a race to detect it. + deadline = deadline + 1.0 self._server_process.write(command) text, audio = self._read_first_block(deadline) # First block is either text or audio At least to me, this seems less error prone and guaranteed to work on all ports (no matter which assumptions they make on the number of seconds for a test to timeout) 1056348 14 ap 2014-12-17 09:44:21 -0800 > And instead of doing that (subtracting 5 seconds from the parameter --timeout passed to the tool (WKTR))... what about just making run-webkit-test wait 1 second more? In this case, run-webkit-tests would use a timeout that is different from what is specified in port configuration, or in --time-out-ms argument. That seems like it would introduce too much confusion. Also, it's not driver's job to make policy decisions, it should use whatever timeout is passed to it without further tweaking. 1056353 15 ap 2014-12-17 09:54:54 -0800 Fixing the known issues in bug 139734. 1056360 16 clopez 2014-12-17 10:06:29 -0800 (In reply to comment #14) > > And instead of doing that (subtracting 5 seconds from the parameter --timeout passed to the tool (WKTR))... what about just making run-webkit-test wait 1 second more? > > In this case, run-webkit-tests would use a timeout that is different from > what is specified in port configuration, or in --time-out-ms argument. That > seems like it would introduce too much confusion. You can see it also the other way around: With the changes introduced by r177363, the test timeouts faster (-5secs) than what is specified in port configuration, or in --time-out-ms argument. I think that this actually introduces much more confusion than what I'm proposing. > Also, it's not driver's > job to make policy decisions, it should use whatever timeout is passed to it > without further tweaking. I don't see any policy decision here. Only a work-around to avoid a race condition. The subtracting of 5 seconds from r177363 isn't also policy, just another workaround. I think that adding 1 second in run-webkit-tests is better. At least to me it looks cleaner. If I say --timeou-out-ms 8, and I have to wait 9 seconds for the test to finish (or timeout), I probably won't notice. But, on the other hand, if I get a timeout after 3 seconds (8-5) probably I will notice something weird. Don't you agree on that? 1056370 17 ap 2014-12-17 10:30:14 -0800 > With the changes introduced by r177363, the test timeouts faster (-5secs) than what is specified in port configuration This was already the case for many years. WebKitTestRunner has multiple shorter timeouts for specific operations, so a test could time out faster than specified in port configuration. Mac in particular always had port timeout specified at 35 seconds, but both DumpRenderTree and WebKitTestRunner ignored that, and timed out after 30 seconds. Maybe there was some confusion due to that, but not anything show-stopping. Additionally, a lot of tests have their own shorter timeouts implemented in JavaScript, which also don't obey port configuration. I am not very strongly opposed to adding instead of subtracting, but I don't see it as obviously superior. > I don't see any policy decision here. Only a work-around to avoid a race condition. A workaround is something that can be made to a bug. But there is no bug here - when both the script and the tool have the same timeout, race is the expected behavior. We need to have script timeout and tool timeout different, and this cannot be hidden under the carpet in driver.py, whose sole purpose is to translate Python variables into command line arguments, and then stdout/stderr into Python objects. I posted a patch to bug 139734, let's move this discussion there. 243350 2014-12-15 22:33:29 -0800 2014-12-15 23:12:15 -0800 proposed fix RespectTimeout.txt text/plain 23942 ap SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDE3NzMzMikKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDgwIEBACisyMDE0LTEyLTE1ICBBbGV4ZXkgUHJvc2t1cnlha292ICA8YXBAYXBwbGUuY29t PgorCisgICAgICAgIFNvcnQgb3V0IHRpbWVvdXQgaW1wbGVtZW50YXRpb25zIGluIERSVCBhbmQg V0tUUgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM5 NjcxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVz dCB0aW1lb3V0IGltcGxlbWVudGF0aW9uIGhhZCBtYW55IGRlZmljaWVuY2llcywgcGxlYXNlIHNl ZSB0aGUgYnVnIGZvciBkZXRhaWxzLgorICAgICAgICBNb3N0IG5vdGFibHksIHdlIHNob3VsZG4n dCBoYXZlIHRoZSB0b29sIGNvbmZ1c2VkIGFib3V0IHRpbWVvdXRzIHZzLiBmYWlsdXJlcywgYW5k CisgICAgICAgIFsgU2xvdyBdIG1vZGlmaWVycyBzaG91bGQgd29yayBhIGxvdCBiZXR0ZXIuCisK KyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9UZXN0UnVubmVyLmNwcDogKFRlc3RSdW5uZXI6OlRl c3RSdW5uZXIpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL1Rlc3RSdW5uZXIuaDogKFRlc3RS dW5uZXI6OnNldEN1c3RvbVRpbWVvdXQpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9E dW1wUmVuZGVyVHJlZS5tbTogKHJ1blRlc3QpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21h Yy9UZXN0UnVubmVyTWFjLm1tOiAoVGVzdFJ1bm5lcjo6c2V0V2FpdFRvRHVtcCk6CisgICAgICAg IER1bXBSZW5kZXJUcmVlIGFscmVhZHkgcmVhZCB0aGUgLS10aW1lb3V0IG9wdGlvbiBmcm9tIGNv bW1hbmQgbGluZSwgYW5kIHdlYmtpdHB5CisgICAgICAgIHdhcyBhbHJlYWR5IGNvbmZpZ3VyZWQg dG8gcGFzcyBpdCBvbiBNYWMgYW5kIGlPUy4gTGV0J3MgYWN0dWFsbHkgdXNlIGl0LgorICAgICAg ICBUZXN0Q29tbWFuZCBhbHJlYWR5IGhhZCB0aGUgc2FtZSAzMCBzZWNvbmQgZGVmYXVsdCwgc28g dGhpcyBkb2Vzbid0IGNoYW5nZSBiZWhhdmlvcgorICAgICAgICB3aGVuIERSVCBpcyByYW4gbWFu dWFsbHkgd2l0aG91dCB0aGUgb3B0aW9uLgorICAgICAgICBXaW5kb3dzIER1bXBSZW5kZXJUcmVl IHdpbGwgbmVlZCB0byBiZSBmaXhlZCBzZXBhcmF0ZWx5ICh0aGF0J3MgZWFzeSkuCisKKyAgICAg ICAgKiBEdW1wUmVuZGVyVHJlZS9UZXN0UnVubmVyLmNwcDogKFRlc3RSdW5uZXI6OndhaXRUb0R1 bXBXYXRjaGRvZ1RpbWVyRmlyZWQoKSk6CisgICAgICAgIERvbid0IHByaW50IHRoZSB0aW1lb3V0 IG1lc3NhZ2UgdG8gc3Rkb3V0IHRvIG1hdGNoIFdlYktpdFRlc3RSdW5uZXIuIEl0IHdvdWxkIGJl CisgICAgICAgIHNsaWdodGx5IGJldHRlciB0byB1c2Ugc3RkZXJyIGluIGJvdGgsIGFzIHRoaXMg aXMgYW4gb3V0IG9mIGJhbmQgbWVzc2FnZSwgYnV0CisgICAgICAgIHRoYXQncyBhIGxhcmdlciBy ZWZhY3RvcmluZywgYW5kIHRoZSBkaWZmZXJlbmNlIGlzIG1pbmltYWwgaW4gcHJhY3RpY2UuCisK KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5n bGVfdGVzdF9ydW5uZXIucHk6CisgICAgICAgIChTaW5nbGVUZXN0UnVubmVyLl9faW5pdF9fKTog RW5zdXJlIHRoYXQgc2NyaXB0IGFuZCB0b29sIHRpbWVvdXRzIGFyZSBzdWJzdGFudGlhbGx5Cisg ICAgICAgIGRpZmZlcmVudC4gV2Ugd2FudCB0aGUgdG9vbCB0byByZWxpYWJseSBkZXRlY3QgdGlt ZW91dHMgdGhhdCBjYW4gYmUgZGV0ZWN0ZWQsIGFuZAorICAgICAgICBub3QgcmFjZSB3aXRoIHRo ZSBzY3JpcHQgZm9yIHRoYXQuCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvYmFz ZS5weTogKFBvcnQuZGVmYXVsdF90aW1lb3V0X21zKTogRG9uJ3QgbWFrZSBXZWJLaXQyCisgICAg ICAgIHRpbWVvdXQgbG9uZ2VyIHRoYW4gV2ViS2l0MSBvbmUsIEkgZG91YnQgdGhhdCB0aGlzIGlz IG5lY2Vzc2FyeS4gTm93IHRoYXQgdGhlIHZhbHVlCisgICAgICAgIGlzIGhvbm9yZWQgaW5tb3Jl IGNhc2VzLCB0aGF0IGNvdWxkIG1ha2UgdGVzdHMgcnVuIHNsb3dlci4KKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L3BvcnQvZHJpdmVyLnB5OgorICAgICAgICAoRHJpdmVyLl9faW5pdF9fKToK KyAgICAgICAgKERyaXZlci5ydW5fdGVzdCk6CisgICAgICAgIChEcml2ZXIuY21kX2xpbmUpOgor ICAgICAgICAoRHJpdmVyLl9jaGVja19mb3JfZHJpdmVyX3RpbWVvdXQpOgorICAgICAgICBEZXRl Y3QgdGVzdHMgdGhhdCBoYXZlIHRoZSB0aW1lb3V0IG91dHB1dCwgYW5kIG1ha2UgdGhlc2UgaGF2 ZSB0aGUgcHJvcGVyIFRpbWVvdXQgcmVzdWx0LgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXRw eS9wb3J0L2lvcy5weTogKElPU1NpbXVsYXRvclBvcnQuZGVmYXVsdF90aW1lb3V0X21zKTogUmVt b3ZlIGFuCisgICAgICAgIGluY29ycmVjdCByZWNlbnQgY2hhbmdlIC0gODAgKiAxMDAwIGlzIDgw IHNlY29uZHMsIG5vdCA4MCBtaWxsaXNlY29uZHMuCisKKyAgICAgICAgKiBXZWJLaXRUZXN0UnVu bmVyL0luamVjdGVkQnVuZGxlL1Rlc3RSdW5uZXIuY3BwOgorICAgICAgICAoV1RSOjpUZXN0UnVu bmVyOjpzZXRDdXN0b21UaW1lb3V0KTogRGVsZXRlZC4KKyAgICAgICAgKiBXZWJLaXRUZXN0UnVu bmVyL0luamVjdGVkQnVuZGxlL1Rlc3RSdW5uZXIuaDoKKyAgICAgICAgKFdUUjo6VGVzdFJ1bm5l cjo6c2V0Q3VzdG9tVGltZW91dCk6CisgICAgICAgICogV2ViS2l0VGVzdFJ1bm5lci9JbmplY3Rl ZEJ1bmRsZS9lZmwvVGVzdFJ1bm5lckVmbC5jcHA6CisgICAgICAgIChXVFI6OlRlc3RSdW5uZXI6 OmluaXRpYWxpemVXYWl0VG9EdW1wV2F0Y2hkb2dUaW1lcklmTmVlZGVkKToKKyAgICAgICAgKiBX ZWJLaXRUZXN0UnVubmVyL0luamVjdGVkQnVuZGxlL21hYy9UZXN0UnVubmVyTWFjLm1tOgorICAg ICAgICAoV1RSOjpUZXN0UnVubmVyOjppbml0aWFsaXplV2FpdFRvRHVtcFdhdGNoZG9nVGltZXJJ Zk5lZWRlZCk6CisgICAgICAgICogV2ViS2l0VGVzdFJ1bm5lci9JbmplY3RlZEJ1bmRsZS93aW4v VGVzdFJ1bm5lcldpbi5jcHA6CisgICAgICAgIChXVFI6OlRlc3RSdW5uZXI6OmluaXRpYWxpemVX YWl0VG9EdW1wV2F0Y2hkb2dUaW1lcklmTmVlZGVkKToKKyAgICAgICAgVXBkYXRlZCB0byB1c2Ug YSB0aW1lb3V0IHBhc3NlZCBmcm9tIFVJIHByb2Nlc3MsIHdoaWNoIHVzZWQgdG8gYmUgaWdub3Jl ZC4KKworICAgICAgICAqIFdlYktpdFRlc3RSdW5uZXIvSW5qZWN0ZWRCdW5kbGUvZ3RrL1Rlc3RS dW5uZXJHdGsuY3BwOgorICAgICAgICAoV1RSOjpUZXN0UnVubmVyOjppbml0aWFsaXplV2FpdFRv RHVtcFdhdGNoZG9nVGltZXJJZk5lZWRlZCk6CisgICAgICAgIEFkZGVkIGEgRklYTUUuCisKKyAg ICAgICAgKiBXZWJLaXRUZXN0UnVubmVyL1Rlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKFdU Ujo6VGVzdENvbnRyb2xsZXI6OlRlc3RDb250cm9sbGVyKToKKyAgICAgICAgKFdUUjo6VGVzdENv bnRyb2xsZXI6OnJ1blVudGlsKToKKyAgICAgICAgKFdUUjo6VGVzdENvbnRyb2xsZXI6OmdldEN1 c3RvbVRpbWVvdXQpOiBEZWxldGVkLgorICAgICAgICAqIFdlYktpdFRlc3RSdW5uZXIvVGVzdENv bnRyb2xsZXIuaDoKKyAgICAgICAgRGVsZXRlIHVudXNlZCBtX3RpbWVvdXQuIEZpcnN0LCBpdCB3 YXMgYWx3YXlzIDAsIGFuZCBzZWNvbmQsIHdlIGRvbid0IG5lZWQgaXQgYXQgYWxsLgorICAgICAg ICBDaGFuZ2VkIGRlZmF1bHQgbWVzc2FnZSB0aW1lb3V0cyB0byBtYXRjaCBuZXcgcnVuLXdlYmtp dC10ZXN0cyB0aW1lb3V0LiBUaGVzZSBkb24ndAorICAgICAgICBhZmZlY3QgcG9ydHMgd2hlcmUg dGltZW91dCBpcyBwYXNzZWQgcGVyIHRlc3QgKHNob3VsZG4ndCB0aGV5IGFsbCBiZSBsaWtlIHRo YXQ/KS4KKworICAgICAgICAqIFdlYktpdFRlc3RSdW5uZXIvVGVzdEludm9jYXRpb24uY3BwOgor ICAgICAgICAoV1RSOjpUZXN0SW52b2NhdGlvbjo6aW52b2tlKToKKyAgICAgICAgKFdUUjo6VGVz dEludm9jYXRpb246OnNldEN1c3RvbVRpbWVvdXQpOiBEZWxldGVkLgorICAgICAgICAqIFdlYktp dFRlc3RSdW5uZXIvVGVzdEludm9jYXRpb24uaDoKKyAgICAgICAgKFdUUjo6VGVzdEludm9jYXRp b246OnNldEN1c3RvbVRpbWVvdXQpOgorICAgICAgICAoV1RSOjpUZXN0SW52b2NhdGlvbjo6Y3Vz dG9tVGltZW91dCk6CisgICAgICAgIERpdHRvLgorCiAyMDE0LTEyLTE1ICBEw6FuaWVsIELDoXR5 YWkgIDxkYmF0eWFpLnUtc3plZ2VkQHBhcnRuZXIuc2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0VG TF0gRlRMIEpJVCBub3Qgd29ya2luZyBvbiBBUk02NApJbmRleDogVG9vbHMvRHVtcFJlbmRlclRy ZWUvVGVzdFJ1bm5lci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvRHVtcFJlbmRlclRyZWUvVGVz dFJ1bm5lci5jcHAJKHJldmlzaW9uIDE3NzI3OSkKKysrIFRvb2xzL0R1bXBSZW5kZXJUcmVlL1Rl c3RSdW5uZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMTUsNiArMTE1LDcgQEAgVGVzdFJ1bm5l cjo6VGVzdFJ1bm5lcihjb25zdCBzdGQ6OnN0cmluZwogICAgICwgbV90ZXN0VVJMKHRlc3RVUkwp CiAgICAgLCBtX2V4cGVjdGVkUGl4ZWxIYXNoKGV4cGVjdGVkUGl4ZWxIYXNoKQogICAgICwgbV90 aXRsZVRleHREaXJlY3Rpb24oImx0ciIpCisgICAgLCBtX3RpbWVvdXQoMCkKIHsKIH0KIApAQCAt MjI1Nyw3ICsyMjU4LDYgQEAgdm9pZCBUZXN0UnVubmVyOjppZ25vcmVMZWdhY3lXZWJOb3RpZmlj YQogdm9pZCBUZXN0UnVubmVyOjp3YWl0VG9EdW1wV2F0Y2hkb2dUaW1lckZpcmVkKCkKIHsKICAg ICBjb25zdCBjaGFyKiBtZXNzYWdlID0gIkZBSUw6IFRpbWVkIG91dCB3YWl0aW5nIGZvciBub3Rp ZnlEb25lIHRvIGJlIGNhbGxlZFxuIjsKLSAgICBmcHJpbnRmKHN0ZGVyciwgIiVzIiwgbWVzc2Fn ZSk7CiAgICAgZnByaW50ZihzdGRvdXQsICIlcyIsIG1lc3NhZ2UpOwogICAgIG5vdGlmeURvbmUo KTsKIH0KSW5kZXg6IFRvb2xzL0R1bXBSZW5kZXJUcmVlL1Rlc3RSdW5uZXIuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBUb29scy9EdW1wUmVuZGVyVHJlZS9UZXN0UnVubmVyLmgJKHJldmlzaW9uIDE3NzI3OSkK KysrIFRvb2xzL0R1bXBSZW5kZXJUcmVlL1Rlc3RSdW5uZXIuaAkod29ya2luZyBjb3B5KQpAQCAt MzU2LDYgKzM1Niw4IEBAIHB1YmxpYzoKIAogICAgIGJvb2wgaGFzUGVuZGluZ1dlYk5vdGlmaWNh dGlvbkNsaWNrKCkgY29uc3QgeyByZXR1cm4gbV9oYXNQZW5kaW5nV2ViTm90aWZpY2F0aW9uQ2xp Y2s7IH0KIAorICAgIHZvaWQgc2V0Q3VzdG9tVGltZW91dChpbnQgZHVyYXRpb24pIHsgbV90aW1l b3V0ID0gZHVyYXRpb247IH0KKwogcHJpdmF0ZToKICAgICBUZXN0UnVubmVyKGNvbnN0IHN0ZDo6 c3RyaW5nJiB0ZXN0VVJMLCBjb25zdCBzdGQ6OnN0cmluZyYgZXhwZWN0ZWRQaXhlbEhhc2gpOwog CkBAIC00MzEsNiArNDMzLDggQEAgcHJpdmF0ZToKICAgICBzdGF0aWMgSlNDbGFzc1JlZiBnZXRK U0NsYXNzKCk7CiAgICAgc3RhdGljIEpTU3RhdGljVmFsdWUqIHN0YXRpY1ZhbHVlcygpOwogICAg IHN0YXRpYyBKU1N0YXRpY0Z1bmN0aW9uKiBzdGF0aWNGdW5jdGlvbnMoKTsKKworICAgIGludCBt X3RpbWVvdXQ7CiB9OwogCiAjZW5kaWYgLy8gVGVzdFJ1bm5lcl9oCkluZGV4OiBUb29scy9EdW1w UmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvRHVt cFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCShyZXZpc2lvbiAxNzcyNzkpCisrKyBU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0JKHdvcmtpbmcgY29weSkK QEAgLTE4NjMsNiArMTg2Myw3IEBAIHN0YXRpYyB2b2lkIHJ1blRlc3QoY29uc3Qgc3RyaW5nJiBp bnB1dEwKICNlbmRpZgogCiAgICAgZ1Rlc3RSdW5uZXIgPSBUZXN0UnVubmVyOjpjcmVhdGUodGVz dFVSTCwgY29tbWFuZC5leHBlY3RlZFBpeGVsSGFzaCk7CisgICAgZ1Rlc3RSdW5uZXItPnNldEN1 c3RvbVRpbWVvdXQoY29tbWFuZC50aW1lb3V0KTsKICAgICB0b3BMb2FkaW5nRnJhbWUgPSBuaWw7 CiAjaWYgIVBMQVRGT1JNKElPUykKICAgICBBU1NFUlQoIWRyYWdnaW5nSW5mbyk7IC8vIHRoZSBw cmV2aW91cyB0ZXN0IHNob3VsZCBoYXZlIGNhbGxlZCBldmVudFNlbmRlci5tb3VzZVVwIHRvIGRy b3AhCkluZGV4OiBUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvVGVzdFJ1bm5lck1hYy5tbQo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvVGVzdFJ1bm5lck1hYy5tbQkocmV2 aXNpb24gMTc3Mjc5KQorKysgVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL1Rlc3RSdW5uZXJNYWMu bW0JKHdvcmtpbmcgY29weSkKQEAgLTY0Niw4ICs2NDYsNiBAQCB2b2lkIFRlc3RSdW5uZXI6OnNl dFdpbmRvd0lzS2V5KGJvb2wgd2luCiAgICAgW1ttYWluRnJhbWUgd2ViVmlld10gX3VwZGF0ZUFj dGl2ZVN0YXRlXTsKIH0KIAotc3RhdGljIGNvbnN0IENGVGltZUludGVydmFsIHdhaXRUb0R1bXBX YXRjaGRvZ0ludGVydmFsID0gMzAuMDsKLQogc3RhdGljIHZvaWQgd2FpdFVudGlsRG9uZVdhdGNo ZG9nRmlyZWQoQ0ZSdW5Mb29wVGltZXJSZWYgdGltZXIsIHZvaWQqIGluZm8pCiB7CiAgICAgZ1Rl c3RSdW5uZXItPndhaXRUb0R1bXBXYXRjaGRvZ1RpbWVyRmlyZWQoKTsKQEAgLTY1Niw4ICs2NTQs OCBAQCBzdGF0aWMgdm9pZCB3YWl0VW50aWxEb25lV2F0Y2hkb2dGaXJlZChDCiB2b2lkIFRlc3RS dW5uZXI6OnNldFdhaXRUb0R1bXAoYm9vbCB3YWl0VW50aWxEb25lKQogewogICAgIG1fd2FpdFRv RHVtcCA9IHdhaXRVbnRpbERvbmU7Ci0gICAgaWYgKG1fd2FpdFRvRHVtcCAmJiBzaG91bGRTZXRX YWl0VG9EdW1wV2F0Y2hkb2coKSkKLSAgICAgICAgc2V0V2FpdFRvRHVtcFdhdGNoZG9nKENGUnVu TG9vcFRpbWVyQ3JlYXRlKGtDRkFsbG9jYXRvckRlZmF1bHQsIENGQWJzb2x1dGVUaW1lR2V0Q3Vy cmVudCgpICsgd2FpdFRvRHVtcFdhdGNoZG9nSW50ZXJ2YWwsIDAsIDAsIDAsIHdhaXRVbnRpbERv bmVXYXRjaGRvZ0ZpcmVkLCBOVUxMKSk7CisgICAgaWYgKG1fd2FpdFRvRHVtcCAmJiBtX3RpbWVv dXQgJiYgc2hvdWxkU2V0V2FpdFRvRHVtcFdhdGNoZG9nKCkpCisgICAgICAgIHNldFdhaXRUb0R1 bXBXYXRjaGRvZyhDRlJ1bkxvb3BUaW1lckNyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBDRkFi c29sdXRlVGltZUdldEN1cnJlbnQoKSArIG1fdGltZW91dCAvIDEwMDAuMCwgMCwgMCwgMCwgd2Fp dFVudGlsRG9uZVdhdGNoZG9nRmlyZWQsIE5VTEwpKTsKIH0KIAogaW50IFRlc3RSdW5uZXI6Ondp bmRvd0NvdW50KCkKSW5kZXg6IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2Nv bnRyb2xsZXJzL3NpbmdsZV90ZXN0X3J1bm5lci5weQo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9zaW5nbGVfdGVzdF9ydW5uZXIu cHkJKHJldmlzaW9uIDE3NzI3OSkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL2NvbnRyb2xsZXJzL3NpbmdsZV90ZXN0X3J1bm5lci5weQkod29ya2luZyBjb3B5KQpAQCAt NTUsMTMgKzU1LDE5IEBAIGNsYXNzIFNpbmdsZVRlc3RSdW5uZXIob2JqZWN0KToKICAgICAgICAg c2VsZi5fb3B0aW9ucyA9IG9wdGlvbnMKICAgICAgICAgc2VsZi5fcmVzdWx0c19kaXJlY3Rvcnkg PSByZXN1bHRzX2RpcmVjdG9yeQogICAgICAgICBzZWxmLl9kcml2ZXIgPSBkcml2ZXIKLSAgICAg ICAgc2VsZi5fdGltZW91dCA9IHRlc3RfaW5wdXQudGltZW91dAogICAgICAgICBzZWxmLl93b3Jr ZXJfbmFtZSA9IHdvcmtlcl9uYW1lCiAgICAgICAgIHNlbGYuX3Rlc3RfbmFtZSA9IHRlc3RfaW5w dXQudGVzdF9uYW1lCiAgICAgICAgIHNlbGYuX3Nob3VsZF9ydW5fcGl4ZWxfdGVzdCA9IHRlc3Rf aW5wdXQuc2hvdWxkX3J1bl9waXhlbF90ZXN0CiAgICAgICAgIHNlbGYuX3JlZmVyZW5jZV9maWxl cyA9IHRlc3RfaW5wdXQucmVmZXJlbmNlX2ZpbGVzCiAgICAgICAgIHNlbGYuX3N0b3Bfd2hlbl9k b25lID0gc3RvcF93aGVuX2RvbmUKIAorICAgICAgICBzZWxmLl90aW1lb3V0ID0gdGVzdF9pbnB1 dC50aW1lb3V0CisgICAgICAgIGlmIHNlbGYuX3RpbWVvdXQgPiA1MDAwOgorICAgICAgICAgICAg IyBUaW1lb3V0cyBhcmUgZGV0ZWN0ZWQgYnkgYm90aCBzY3JpcHQgYW5kIHRvb2w7IHRvb2wgZGV0 ZWN0ZWQgdGltZW91dHMgYXJlCisgICAgICAgICAgICAjIGJldHRlciwgYmVjYXVzZSB0aGV5IGNv bnRhaW4gcGFydGlhbCBvdXRwdXQuIEdpdmUgdGhlIHRvb2wgc29tZSB0aW1lIHRvCisgICAgICAg ICAgICAjIHJlcG9ydCB0aGUgdGltZW91dCBpbnN0ZWFkIG9mIGJlaW5nIGtpbGxlZC4KKyAgICAg ICAgICAgIHNlbGYuX3RpbWVvdXQgPSBpbnQoc2VsZi5fdGltZW91dCkgLSA1MDAwCisKICAgICAg ICAgaWYgc2VsZi5fcmVmZXJlbmNlX2ZpbGVzOgogICAgICAgICAgICAgIyBEZXRlY3QgYW5kIHJl cG9ydCBhIHRlc3Qgd2hpY2ggaGFzIGEgd3JvbmcgY29tYmluYXRpb24gb2YgZXhwZWN0YXRpb24g ZmlsZXMuCiAgICAgICAgICAgICAjIEZvciBleGFtcGxlLCBpZiAnZm9vLmh0bWwnIGhhcyB0d28g ZXhwZWN0YXRpb24gZmlsZXMsICdmb28tZXhwZWN0ZWQuaHRtbCcgYW5kCkluZGV4OiBUb29scy9T Y3JpcHRzL3dlYmtpdHB5L3BvcnQvYmFzZS5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRz L3dlYmtpdHB5L3BvcnQvYmFzZS5weQkocmV2aXNpb24gMTc3Mjc5KQorKysgVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9wb3J0L2Jhc2UucHkJKHdvcmtpbmcgY29weSkKQEAgLTEzOCwxMCArMTM4LDYg QEAgY2xhc3MgUG9ydChvYmplY3QpOgogICAgICAgICByZXR1cm4gRmFsc2UKIAogICAgIGRlZiBk ZWZhdWx0X3RpbWVvdXRfbXMoc2VsZik6Ci0gICAgICAgIGlmIHNlbGYuZ2V0X29wdGlvbignd2Vi a2l0X3Rlc3RfcnVubmVyJyk6Ci0gICAgICAgICAgICAjIEFkZCBzb21lIG1vcmUgdGltZSB0byBX ZWJLaXRUZXN0UnVubmVyIGJlY2F1c2UgaXQgbmVlZHMgdG8gc3luY3JvbmlzZSB0aGUgc3RhdGUK LSAgICAgICAgICAgICMgd2l0aCB0aGUgd2ViIHByb2Nlc3MgYW5kIHdlIHdhbnQgdG8gZGV0ZWN0 IGlmIHRoZXJlIGlzIGEgcHJvYmxlbSB3aXRoIHRoYXQgaW4gdGhlIGRyaXZlci4KLSAgICAgICAg ICAgIHJldHVybiA4MCAqIDEwMDAKICAgICAgICAgcmV0dXJuIDM1ICogMTAwMAogCiAgICAgZGVm IGRyaXZlcl9zdG9wX3RpbWVvdXQoc2VsZik6CkluZGV4OiBUb29scy9TY3JpcHRzL3dlYmtpdHB5 L3BvcnQvZHJpdmVyLnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9y dC9kcml2ZXIucHkJKHJldmlzaW9uIDE3NzI3OSkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv cG9ydC9kcml2ZXIucHkJKHdvcmtpbmcgY29weSkKQEAgLTEzNyw2ICsxMzcsOCBAQCBjbGFzcyBE cml2ZXIob2JqZWN0KToKICAgICAgICAgc2VsZi5fY3Jhc2hlZF9wcm9jZXNzX25hbWUgPSBOb25l CiAgICAgICAgIHNlbGYuX2NyYXNoZWRfcGlkID0gTm9uZQogCisgICAgICAgIHNlbGYuX2RyaXZl cl90aW1lZF9vdXQgPSBGYWxzZQorCiAgICAgICAgICMgV2ViS2l0VGVzdFJ1bm5lciBjYW4gcmVw b3J0IGJhY2sgc3VicHJvY2Vzc2VzIHRoYXQgYmVjYW1lIHVucmVzcG9uc2l2ZQogICAgICAgICAj IFRoaXMgY291bGQgbWVhbiB0aGV5IGNyYXNoZWQuCiAgICAgICAgIHNlbGYuX3N1YnByb2Nlc3Nf d2FzX3VucmVzcG9uc2l2ZSA9IEZhbHNlCkBAIC0xNzIsNiArMTc0LDcgQEAgY2xhc3MgRHJpdmVy KG9iamVjdCk6CiAgICAgICAgIHN0YXJ0X3RpbWUgPSB0aW1lLnRpbWUoKQogICAgICAgICBzZWxm LnN0YXJ0KGRyaXZlcl9pbnB1dC5zaG91bGRfcnVuX3BpeGVsX3Rlc3QsIGRyaXZlcl9pbnB1dC5h cmdzKQogICAgICAgICB0ZXN0X2JlZ2luX3RpbWUgPSB0aW1lLnRpbWUoKQorICAgICAgICBzZWxm Ll9kcml2ZXJfdGltZWRfb3V0ID0gRmFsc2UKICAgICAgICAgc2VsZi5lcnJvcl9mcm9tX3Rlc3Qg PSBzdHIoKQogICAgICAgICBzZWxmLmVycl9zZWVuX2VvZiA9IEZhbHNlCiAKQEAgLTE4NCw2ICsx ODcsNyBAQCBjbGFzcyBEcml2ZXIob2JqZWN0KToKIAogICAgICAgICBjcmFzaGVkID0gc2VsZi5o YXNfY3Jhc2hlZCgpCiAgICAgICAgIHRpbWVkX291dCA9IHNlbGYuX3NlcnZlcl9wcm9jZXNzLnRp bWVkX291dAorICAgICAgICBkcml2ZXJfdGltZWRfb3V0ID0gc2VsZi5fZHJpdmVyX3RpbWVkX291 dAogICAgICAgICBwaWQgPSBzZWxmLl9zZXJ2ZXJfcHJvY2Vzcy5waWQoKQogCiAgICAgICAgIGlm IHN0b3Bfd2hlbl9kb25lIG9yIGNyYXNoZWQgb3IgdGltZWRfb3V0OgpAQCAtMjEzLDcgKzIxNyw3 IEBAIGNsYXNzIERyaXZlcihvYmplY3QpOgogCiAgICAgICAgIHJldHVybiBEcml2ZXJPdXRwdXQo dGV4dCwgaW1hZ2UsIGFjdHVhbF9pbWFnZV9oYXNoLCBhdWRpbywKICAgICAgICAgICAgIGNyYXNo PWNyYXNoZWQsIHRlc3RfdGltZT10aW1lLnRpbWUoKSAtIHRlc3RfYmVnaW5fdGltZSwgbWVhc3Vy ZW1lbnRzPXNlbGYuX21lYXN1cmVtZW50cywKLSAgICAgICAgICAgIHRpbWVvdXQ9dGltZWRfb3V0 LCBlcnJvcj1zZWxmLmVycm9yX2Zyb21fdGVzdCwKKyAgICAgICAgICAgIHRpbWVvdXQ9dGltZWRf b3V0IG9yIGRyaXZlcl90aW1lZF9vdXQsIGVycm9yPXNlbGYuZXJyb3JfZnJvbV90ZXN0LAogICAg ICAgICAgICAgY3Jhc2hlZF9wcm9jZXNzX25hbWU9c2VsZi5fY3Jhc2hlZF9wcm9jZXNzX25hbWUs CiAgICAgICAgICAgICBjcmFzaGVkX3BpZD1zZWxmLl9jcmFzaGVkX3BpZCwgY3Jhc2hfbG9nPWNy YXNoX2xvZywgcGlkPXBpZCkKIApAQCAtMzQ5LDcgKzM1Myw2IEBAIGNsYXNzIERyaXZlcihvYmpl Y3QpOgogICAgICAgICAgICAgY21kLmFwcGVuZCgnLS10aHJlYWRlZCcpCiAgICAgICAgIGlmIHNl bGYuX25vX3RpbWVvdXQ6CiAgICAgICAgICAgICBjbWQuYXBwZW5kKCctLW5vLXRpbWVvdXQnKQot ICAgICAgICAjIEZJWE1FOiBXZSBuZWVkIHRvIHBhc3MgLS10aW1lb3V0PVNFQ09ORFMgdG8gV2Vi S2l0VGVzdFJ1bm5lciBmb3IgV2ViS2l0Mi4KIAogICAgICAgICBjbWQuZXh0ZW5kKHNlbGYuX3Bv cnQuZ2V0X29wdGlvbignYWRkaXRpb25hbF9kcnRfZmxhZycsIFtdKSkKICAgICAgICAgY21kLmV4 dGVuZChzZWxmLl9wb3J0LmFkZGl0aW9uYWxfZHJ0X2ZsYWcoKSkKQEAgLTM1OSw2ICszNjIsMTAg QEAgY2xhc3MgRHJpdmVyKG9iamVjdCk6CiAgICAgICAgIGNtZC5hcHBlbmQoJy0nKQogICAgICAg ICByZXR1cm4gY21kCiAKKyAgICBkZWYgX2NoZWNrX2Zvcl9kcml2ZXJfdGltZW91dChzZWxmLCBv dXRfbGluZSk6CisgICAgICAgIGlmIG91dF9saW5lID09ICJGQUlMOiBUaW1lZCBvdXQgd2FpdGlu ZyBmb3Igbm90aWZ5RG9uZSB0byBiZSBjYWxsZWQiOgorICAgICAgICAgICAgc2VsZi5fZHJpdmVy X3RpbWVkX291dCA9IFRydWU7CisKICAgICBkZWYgX2NoZWNrX2Zvcl9kcml2ZXJfY3Jhc2goc2Vs ZiwgZXJyb3JfbGluZSk6CiAgICAgICAgIGlmIGVycm9yX2xpbmUgPT0gIiNDUkFTSEVEXG4iOgog ICAgICAgICAgICAgIyBUaGlzIGlzIHVzZWQgb24gV2luZG93cyBhbmQgaU9TIHRvIHJlcG9ydCB0 aGF0IHRoZSBwcm9jZXNzIGhhcyBjcmFzaGVkCkluZGV4OiBUb29scy9TY3JpcHRzL3dlYmtpdHB5 L3BvcnQvaW9zLnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9p b3MucHkJKHJldmlzaW9uIDE3NzI3OSkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9p b3MucHkJKHdvcmtpbmcgY29weSkKQEAgLTgyLDExICs4Miw2IEBAIGNsYXNzIElPU1NpbXVsYXRv clBvcnQoUG9ydCk6CiAgICAgZGVmIGRlZmF1bHRfdGltZW91dF9tcyhzZWxmKToKICAgICAgICAg aWYgc2VsZi5nZXRfb3B0aW9uKCdndWFyZF9tYWxsb2MnKToKICAgICAgICAgICAgIHJldHVybiAz NTAgKiAxMDAwCi0gICAgICAgIGlmIG5vdCBzZWxmLmdldF9vcHRpb24oJ3dlYmtpdF90ZXN0X3J1 bm5lcicpOgotICAgICAgICAgICAgIyBEdW1wUmVuZGVyVHJlZS5hcHAgd2FpdHMgZm9yIHRoZSBX ZWJUaHJlYWQgdG8gcnVuIGJlZm9yZSBkdW1waW5nIGl0cyBvdXRwdXQuICBJbiBwcmFjdGljZQot ICAgICAgICAgICAgIyBpdCBzZWVtcyBzdWZmaWNpZW50IHRvIHdhaXQgdXAgdG8gODBtcyB0byBl bnN1cmUgdGhhdCB0aGUgV2ViVGhyZWFkIHJhbiBhbmQgaGVuY2Ugb3V0cHV0Ci0gICAgICAgICAg ICAjIGZvciB0aGUgdGVzdCBpcyBkdW1wZWQuCi0gICAgICAgICAgICByZXR1cm4gODAgKiAxMDAw CiAgICAgICAgIHJldHVybiBzdXBlcihJT1NTaW11bGF0b3JQb3J0LCBzZWxmKS5kZWZhdWx0X3Rp bWVvdXRfbXMoKQogCiAgICAgZGVmIHN1cHBvcnRzX3Blcl90ZXN0X3RpbWVvdXQoc2VsZik6Cklu ZGV4OiBUb29scy9XZWJLaXRUZXN0UnVubmVyL1Rlc3RDb250cm9sbGVyLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBUb29scy9XZWJLaXRUZXN0UnVubmVyL1Rlc3RDb250cm9sbGVyLmNwcAkocmV2aXNpb24g MTc3Mjc5KQorKysgVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9UZXN0Q29udHJvbGxlci5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTcwLDExICs3MCwxMiBAQCBjb25zdCB1bnNpZ25lZCBUZXN0Q29udHJv bGxlcjo6dmlld0hlaWdoCiBjb25zdCB1bnNpZ25lZCBUZXN0Q29udHJvbGxlcjo6dzNjU1ZHVmll d1dpZHRoID0gNDgwOwogY29uc3QgdW5zaWduZWQgVGVzdENvbnRyb2xsZXI6OnczY1NWR1ZpZXdI ZWlnaHQgPSAzNjA7CiAKLS8vIGRlZmF1bHRMb25nVGltZW91dCArIGRlZmF1bHRTaG9ydFRpbWVv dXQgc2hvdWxkIGJlIGxlc3MgdGhhbiA4MCwKKy8vIGRlZmF1bHRMb25nVGltZW91dCArIGRlZmF1 bHRTaG9ydFRpbWVvdXQgc2hvdWxkIGJlIGxlc3MgdGhhbiAzNSwKIC8vIHRoZSBkZWZhdWx0IHRp bWVvdXQgdmFsdWUgb2YgdGhlIHRlc3QgaGFybmVzcyBzbyB3ZSBjYW4gZGV0ZWN0IGFuCiAvLyB1 bnJlc3BvbnNpdmUgd2ViIHByb2Nlc3MuCi1zdGF0aWMgY29uc3QgZG91YmxlIGRlZmF1bHRMb25n VGltZW91dCA9IDYwOwotc3RhdGljIGNvbnN0IGRvdWJsZSBkZWZhdWx0U2hvcnRUaW1lb3V0ID0g MTU7CisvLyBUaGVzZSB2YWx1ZXMgYXJlIG9ubHkgdXNlZCBieSBwb3J0cyB0aGF0IGRvbid0IGhh dmUgLS10aW1lb3V0IG9wdGlvbiBwYXNzZWQgdG8gV2ViS2l0VGVzdFJ1bm5lci4KK3N0YXRpYyBj b25zdCBkb3VibGUgZGVmYXVsdExvbmdUaW1lb3V0ID0gMjU7CitzdGF0aWMgY29uc3QgZG91Ymxl IGRlZmF1bHRTaG9ydFRpbWVvdXQgPSA1Owogc3RhdGljIGNvbnN0IGRvdWJsZSBkZWZhdWx0Tm9U aW1lb3V0ID0gLTE7CiAKIHN0YXRpYyBXS1VSTFJlZiBibGFua1VSTCgpCkBAIC0xMTAsNyArMTEx LDYgQEAgVGVzdENvbnRyb2xsZXI6OlRlc3RDb250cm9sbGVyKGludCBhcmdjLAogICAgICwgbV9u b1RpbWVvdXQoZGVmYXVsdE5vVGltZW91dCkKICAgICAsIG1fdXNlV2FpdFRvRHVtcFdhdGNoZG9n VGltZXIodHJ1ZSkKICAgICAsIG1fZm9yY2VOb1RpbWVvdXQoZmFsc2UpCi0gICAgLCBtX3RpbWVv dXQoMCkKICAgICAsIG1fZGlkUHJpbnRXZWJQcm9jZXNzQ3Jhc2hlZE1lc3NhZ2UoZmFsc2UpCiAg ICAgLCBtX3Nob3VsZEV4aXRXaGVuV2ViUHJvY2Vzc0NyYXNoZXModHJ1ZSkKICAgICAsIG1fYmVm b3JlVW5sb2FkUmV0dXJuVmFsdWUodHJ1ZSkKQEAgLTE5NCwxMSArMTk0LDYgQEAgc3RhdGljIHZv aWQgZGVjaWRlUG9saWN5Rm9yVXNlck1lZGlhUGVybQogICAgIFRlc3RDb250cm9sbGVyOjpzaGFy ZWQoKS5oYW5kbGVVc2VyTWVkaWFQZXJtaXNzaW9uUmVxdWVzdChwZXJtaXNzaW9uUmVxdWVzdCk7 CiB9CiAKLWludCBUZXN0Q29udHJvbGxlcjo6Z2V0Q3VzdG9tVGltZW91dCgpCi17Ci0gICAgcmV0 dXJuIG1fdGltZW91dDsKLX0KLQogV0tQYWdlUmVmIFRlc3RDb250cm9sbGVyOjpjcmVhdGVPdGhl clBhZ2UoV0tQYWdlUmVmIG9sZFBhZ2UsIFdLVVJMUmVxdWVzdFJlZiwgV0tEaWN0aW9uYXJ5UmVm LCBXS0V2ZW50TW9kaWZpZXJzLCBXS0V2ZW50TW91c2VCdXR0b24sIGNvbnN0IHZvaWQqIGNsaWVu dEluZm8pCiB7CiAgICAgUGxhdGZvcm1XZWJWaWV3KiBwYXJlbnRWaWV3ID0gc3RhdGljX2Nhc3Q8 UGxhdGZvcm1XZWJWaWV3Kj4oY29uc3RfY2FzdDx2b2lkKj4oY2xpZW50SW5mbykpOwpAQCAtOTc5 LDkgKzk3NCw2IEBAIHZvaWQgVGVzdENvbnRyb2xsZXI6OnJ1blVudGlsKGJvb2wmIGRvbmUKICAg ICAgICAgY2FzZSBMb25nVGltZW91dDoKICAgICAgICAgICAgIHRpbWVvdXQgPSBtX2xvbmdUaW1l b3V0OwogICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgIGNhc2UgQ3VzdG9tVGltZW91dDoKLSAg ICAgICAgICAgIHRpbWVvdXQgPSBtX3RpbWVvdXQ7Ci0gICAgICAgICAgICBicmVhazsKICAgICAg ICAgY2FzZSBOb1RpbWVvdXQ6CiAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICB0aW1lb3V0 ID0gbV9ub1RpbWVvdXQ7CkluZGV4OiBUb29scy9XZWJLaXRUZXN0UnVubmVyL1Rlc3RDb250cm9s bGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9UZXN0Q29udHJvbGxl ci5oCShyZXZpc2lvbiAxNzcyNzkpCisrKyBUb29scy9XZWJLaXRUZXN0UnVubmVyL1Rlc3RDb250 cm9sbGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTY4LDE0ICs2OCwxMiBAQCBwdWJsaWM6CiAgICAg Ym9vbCBzaG91bGRVc2VSZW1vdGVMYXllclRyZWUoKSBjb25zdCB7IHJldHVybiBtX3Nob3VsZFVz ZVJlbW90ZUxheWVyVHJlZTsgfQogICAgIAogICAgIC8vIFJ1bnMgdGhlIHJ1biBsb29wIHVudGls IGBkb25lYCBpcyB0cnVlIG9yIHRoZSB0aW1lb3V0IGVsYXBzZXMuCi0gICAgZW51bSBUaW1lb3V0 RHVyYXRpb24geyBTaG9ydFRpbWVvdXQsIExvbmdUaW1lb3V0LCBOb1RpbWVvdXQsIEN1c3RvbVRp bWVvdXQgfTsKKyAgICBlbnVtIFRpbWVvdXREdXJhdGlvbiB7IFNob3J0VGltZW91dCwgTG9uZ1Rp bWVvdXQsIE5vVGltZW91dCB9OwogICAgIGJvb2wgdXNlV2FpdFRvRHVtcFdhdGNoZG9nVGltZXIo KSB7IHJldHVybiBtX3VzZVdhaXRUb0R1bXBXYXRjaGRvZ1RpbWVyOyB9CiAgICAgdm9pZCBydW5V bnRpbChib29sJiBkb25lLCBUaW1lb3V0RHVyYXRpb24pOwogICAgIHZvaWQgbm90aWZ5RG9uZSgp OwogICAgIAogICAgIHZvaWQgY29uZmlndXJlVmlld0ZvclRlc3QoY29uc3QgVGVzdEludm9jYXRp b24mKTsKLQotICAgIGludCBnZXRDdXN0b21UaW1lb3V0KCk7CiAgICAgCiAgICAgYm9vbCBiZWZv cmVVbmxvYWRSZXR1cm5WYWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fYmVmb3JlVW5sb2FkUmV0dXJu VmFsdWU7IH0KICAgICB2b2lkIHNldEJlZm9yZVVubG9hZFJldHVyblZhbHVlKGJvb2wgdmFsdWUp IHsgbV9iZWZvcmVVbmxvYWRSZXR1cm5WYWx1ZSA9IHZhbHVlOyB9CkBAIC0yMzEsOCArMjI5LDYg QEAgcHJpdmF0ZToKICAgICBib29sIG1fdXNlV2FpdFRvRHVtcFdhdGNoZG9nVGltZXI7CiAgICAg Ym9vbCBtX2ZvcmNlTm9UaW1lb3V0OwogCi0gICAgaW50IG1fdGltZW91dDsKLQogICAgIGJvb2wg bV9kaWRQcmludFdlYlByb2Nlc3NDcmFzaGVkTWVzc2FnZTsKICAgICBib29sIG1fc2hvdWxkRXhp dFdoZW5XZWJQcm9jZXNzQ3Jhc2hlczsKICAgICAKSW5kZXg6IFRvb2xzL1dlYktpdFRlc3RSdW5u ZXIvVGVzdEludm9jYXRpb24uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1dlYktpdFRlc3RSdW5u ZXIvVGVzdEludm9jYXRpb24uY3BwCShyZXZpc2lvbiAxNzcyNzkpCisrKyBUb29scy9XZWJLaXRU ZXN0UnVubmVyL1Rlc3RJbnZvY2F0aW9uLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE3LDExICsx MTcsNiBAQCB2b2lkIFRlc3RJbnZvY2F0aW9uOjpzZXRJc1BpeGVsVGVzdChjb25zCiAgICAgbV9l eHBlY3RlZFBpeGVsSGFzaCA9IGV4cGVjdGVkUGl4ZWxIYXNoOwogfQogCi12b2lkIFRlc3RJbnZv Y2F0aW9uOjpzZXRDdXN0b21UaW1lb3V0KGludCB0aW1lb3V0KQotewotICAgIG1fdGltZW91dCA9 IHRpbWVvdXQ7Ci19Ci0KIHN0YXRpYyBib29sIHNob3VsZExvZ0ZyYW1lTG9hZERlbGVnYXRlcyhj b25zdCBjaGFyKiBwYXRoT3JVUkwpCiB7CiAgICAgcmV0dXJuIHN0cnN0cihwYXRoT3JVUkwsICJs b2FkaW5nLyIpOwpAQCAtMTY1LDggKzE2MCw2IEBAIHZvaWQgVGVzdEludm9jYXRpb246Omludm9r ZSgpCiAKICAgICBXS0NvbnRleHRQb3N0TWVzc2FnZVRvSW5qZWN0ZWRCdW5kbGUoVGVzdENvbnRy b2xsZXI6OnNoYXJlZCgpLmNvbnRleHQoKSwgbWVzc2FnZU5hbWUuZ2V0KCksIGJlZ2luVGVzdE1l c3NhZ2VCb2R5LmdldCgpKTsKIAotICAgIFRlc3RDb250cm9sbGVyOjpUaW1lb3V0RHVyYXRpb24g dGltZW91dFRvVXNlID0gVGVzdENvbnRyb2xsZXI6OkxvbmdUaW1lb3V0OwotCiAgICAgVGVzdENv bnRyb2xsZXI6OnNoYXJlZCgpLnJ1blVudGlsKG1fZ290SW5pdGlhbFJlc3BvbnNlLCBUZXN0Q29u dHJvbGxlcjo6U2hvcnRUaW1lb3V0KTsKICAgICBpZiAoIW1fZ290SW5pdGlhbFJlc3BvbnNlKSB7 CiAgICAgICAgIG1fZXJyb3JNZXNzYWdlID0gIlRpbWVkIG91dCB3YWl0aW5nIGZvciBpbml0aWFs IHJlc3BvbnNlIGZyb20gd2ViIHByb2Nlc3NcbiI7CkBAIC0xNzgsMTIgKzE3MSw3IEBAIHZvaWQg VGVzdEludm9jYXRpb246Omludm9rZSgpCiAKICAgICBXS1BhZ2VMb2FkVVJMKFRlc3RDb250cm9s bGVyOjpzaGFyZWQoKS5tYWluV2ViVmlldygpLT5wYWdlKCksIG1fdXJsLmdldCgpKTsKIAotICAg IGlmIChUZXN0Q29udHJvbGxlcjo6c2hhcmVkKCkudXNlV2FpdFRvRHVtcFdhdGNoZG9nVGltZXIo KSkgewotICAgICAgICBpZiAobV90aW1lb3V0ID4gMCkKLSAgICAgICAgICAgIHRpbWVvdXRUb1Vz ZSA9IFRlc3RDb250cm9sbGVyOjpDdXN0b21UaW1lb3V0OwotICAgIH0gZWxzZQotICAgICAgICB0 aW1lb3V0VG9Vc2UgPSBUZXN0Q29udHJvbGxlcjo6Tm9UaW1lb3V0OwotICAgIFRlc3RDb250cm9s bGVyOjpzaGFyZWQoKS5ydW5VbnRpbChtX2dvdEZpbmFsTWVzc2FnZSwgdGltZW91dFRvVXNlKTsK KyAgICBUZXN0Q29udHJvbGxlcjo6c2hhcmVkKCkucnVuVW50aWwobV9nb3RGaW5hbE1lc3NhZ2Us IFRlc3RDb250cm9sbGVyOjpOb1RpbWVvdXQpOwogCiAgICAgaWYgKCFtX2dvdEZpbmFsTWVzc2Fn ZSkgewogICAgICAgICBtX2Vycm9yTWVzc2FnZSA9ICJUaW1lZCBvdXQgd2FpdGluZyBmb3IgZmlu YWwgbWVzc2FnZSBmcm9tIHdlYiBwcm9jZXNzXG4iOwpJbmRleDogVG9vbHMvV2ViS2l0VGVzdFJ1 bm5lci9UZXN0SW52b2NhdGlvbi5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1dlYktpdFRlc3RSdW5u ZXIvVGVzdEludm9jYXRpb24uaAkocmV2aXNpb24gMTc3Mjc5KQorKysgVG9vbHMvV2ViS2l0VGVz dFJ1bm5lci9UZXN0SW52b2NhdGlvbi5oCSh3b3JraW5nIGNvcHkpCkBAIC00NCw3ICs0NCw4IEBA IHB1YmxpYzoKIAogICAgIHZvaWQgc2V0SXNQaXhlbFRlc3QoY29uc3Qgc3RkOjpzdHJpbmcmIGV4 cGVjdGVkUGl4ZWxIYXNoKTsKIAotICAgIHZvaWQgc2V0Q3VzdG9tVGltZW91dChpbnQgZHVyYXRp b24pOworICAgIHZvaWQgc2V0Q3VzdG9tVGltZW91dChpbnQgZHVyYXRpb24pIHsgbV90aW1lb3V0 ID0gZHVyYXRpb247IH0KKyAgICBpbnQgY3VzdG9tVGltZW91dCgpIGNvbnN0IHsgcmV0dXJuIG1f dGltZW91dDsgfQogCiAgICAgdm9pZCBpbnZva2UoKTsKICAgICB2b2lkIGRpZFJlY2VpdmVNZXNz YWdlRnJvbUluamVjdGVkQnVuZGxlKFdLU3RyaW5nUmVmIG1lc3NhZ2VOYW1lLCBXS1R5cGVSZWYg bWVzc2FnZUJvZHkpOwpJbmRleDogVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9JbmplY3RlZEJ1bmRs ZS9UZXN0UnVubmVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9XZWJLaXRUZXN0UnVubmVyL0lu amVjdGVkQnVuZGxlL1Rlc3RSdW5uZXIuY3BwCShyZXZpc2lvbiAxNzcyNzkpCisrKyBUb29scy9X ZWJLaXRUZXN0UnVubmVyL0luamVjdGVkQnVuZGxlL1Rlc3RSdW5uZXIuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC01NSw3ICs1NSw3IEBACiAKIG5hbWVzcGFjZSBXVFIgewogCi1jb25zdCBkb3VibGUg VGVzdFJ1bm5lcjo6d2FpdFRvRHVtcFdhdGNoZG9nVGltZXJJbnRlcnZhbCA9IDMwOworY29uc3Qg ZG91YmxlIFRlc3RSdW5uZXI6OmRlZmF1bHRXYWl0VG9EdW1wV2F0Y2hkb2dUaW1lckludGVydmFs ID0gMzA7CiAKIFBhc3NSZWZQdHI8VGVzdFJ1bm5lcj4gVGVzdFJ1bm5lcjo6Y3JlYXRlKCkKIHsK QEAgLTE2NCwxMSArMTY0LDYgQEAgdm9pZCBUZXN0UnVubmVyOjpub3RpZnlEb25lKCkKICAgICBt X3dhaXRUb0R1bXAgPSBmYWxzZTsKIH0KIAotdm9pZCBUZXN0UnVubmVyOjpzZXRDdXN0b21UaW1l b3V0KGludCB0aW1lb3V0KQotewotICAgIG1fdGltZW91dCA9IHRpbWVvdXQ7Ci19Ci0KIHZvaWQg VGVzdFJ1bm5lcjo6YWRkVXNlclNjcmlwdChKU1N0cmluZ1JlZiBzb3VyY2UsIGJvb2wgcnVuQXRT dGFydCwgYm9vbCBhbGxGcmFtZXMpCiB7CiAgICAgV0tSZXRhaW5QdHI8V0tTdHJpbmdSZWY+IHNv dXJjZVdLID0gdG9XSyhzb3VyY2UpOwpJbmRleDogVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9Jbmpl Y3RlZEJ1bmRsZS9UZXN0UnVubmVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvV2ViS2l0VGVzdFJ1 bm5lci9JbmplY3RlZEJ1bmRsZS9UZXN0UnVubmVyLmgJKHJldmlzaW9uIDE3NzI3OSkKKysrIFRv b2xzL1dlYktpdFRlc3RSdW5uZXIvSW5qZWN0ZWRCdW5kbGUvVGVzdFJ1bm5lci5oCSh3b3JraW5n IGNvcHkpCkBAIC0yNjMsNyArMjYzLDcgQEAgcHVibGljOgogCiAgICAgYm9vbCBjYWxsU2hvdWxk Q2xvc2VPbldlYlZpZXcoKTsKIAotICAgIHZvaWQgc2V0Q3VzdG9tVGltZW91dChpbnQgZHVyYXRp b24pOworICAgIHZvaWQgc2V0Q3VzdG9tVGltZW91dChpbnQgZHVyYXRpb24pIHsgbV90aW1lb3V0 ID0gZHVyYXRpb247IH0KIAogICAgIC8vIFdvcmsgcXVldWUuCiAgICAgdm9pZCBxdWV1ZUJhY2tO YXZpZ2F0aW9uKHVuc2lnbmVkIGhvd0ZhckJhY2t3YXJkKTsKQEAgLTI4MCw3ICsyODAsNyBAQCBw dWJsaWM6CiAgICAgSlNWYWx1ZVJlZiBuZXZlcklubGluZUZ1bmN0aW9uKEpTVmFsdWVSZWYgdGhl RnVuY3Rpb24pOwogCiBwcml2YXRlOgotICAgIHN0YXRpYyBjb25zdCBkb3VibGUgd2FpdFRvRHVt cFdhdGNoZG9nVGltZXJJbnRlcnZhbDsKKyAgICBzdGF0aWMgY29uc3QgZG91YmxlIGRlZmF1bHRX YWl0VG9EdW1wV2F0Y2hkb2dUaW1lckludGVydmFsOwogCiAgICAgVGVzdFJ1bm5lcigpOwogCklu ZGV4OiBUb29scy9XZWJLaXRUZXN0UnVubmVyL0luamVjdGVkQnVuZGxlL2VmbC9UZXN0UnVubmVy RWZsLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9XZWJLaXRUZXN0UnVubmVyL0luamVjdGVkQnVu ZGxlL2VmbC9UZXN0UnVubmVyRWZsLmNwcAkocmV2aXNpb24gMTc3Mjc5KQorKysgVG9vbHMvV2Vi S2l0VGVzdFJ1bm5lci9JbmplY3RlZEJ1bmRsZS9lZmwvVGVzdFJ1bm5lckVmbC5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTUzLDggKzUzLDggQEAgdm9pZCBUZXN0UnVubmVyOjppbml0aWFsaXplV2Fp dFRvRHVtcFdhdAogICAgIGlmIChtX3dhaXRUb0R1bXBXYXRjaGRvZ1RpbWVyKQogICAgICAgICBy ZXR1cm47CiAKLSAgICBtX3dhaXRUb0R1bXBXYXRjaGRvZ1RpbWVyID0gZWNvcmVfdGltZXJfbG9v cF9hZGQod2FpdFRvRHVtcFdhdGNoZG9nVGltZXJJbnRlcnZhbCwKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgd2FpdFRvRHVtcFdhdGNoZG9nVGlt ZXJDYWxsYmFjaywgMCk7CisgICAgZG91YmxlIGludGVydmFsID0gbV90aW1lb3V0ID8gbV90aW1l b3V0IC8gMTAwMC4wIDogZGVmYXVsdFdhaXRUb0R1bXBXYXRjaGRvZ1RpbWVySW50ZXJ2YWw7Cisg ICAgbV93YWl0VG9EdW1wV2F0Y2hkb2dUaW1lciA9IGVjb3JlX3RpbWVyX2xvb3BfYWRkKGludGVy dmFsLCB3YWl0VG9EdW1wV2F0Y2hkb2dUaW1lckNhbGxiYWNrLCAwKTsKIH0KIAogSlNSZXRhaW5Q dHI8SlNTdHJpbmdSZWY+IFRlc3RSdW5uZXI6OnBhdGhUb0xvY2FsUmVzb3VyY2UoSlNTdHJpbmdS ZWYgdXJsKQpJbmRleDogVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9JbmplY3RlZEJ1bmRsZS9ndGsv VGVzdFJ1bm5lckd0ay5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9J bmplY3RlZEJ1bmRsZS9ndGsvVGVzdFJ1bm5lckd0ay5jcHAJKHJldmlzaW9uIDE3NzI3OSkKKysr IFRvb2xzL1dlYktpdFRlc3RSdW5uZXIvSW5qZWN0ZWRCdW5kbGUvZ3RrL1Rlc3RSdW5uZXJHdGsu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC00OCw4ICs0OCw5IEBAIHZvaWQgVGVzdFJ1bm5lcjo6aW5p dGlhbGl6ZVdhaXRUb0R1bXBXYXQKICAgICBpZiAobV93YWl0VG9EdW1wV2F0Y2hkb2dUaW1lci5p c1NjaGVkdWxlZCgpKQogICAgICAgICByZXR1cm47CiAKKyAgICAvLyBGSVhNRTogVXNlIG1fdGlt ZW91dCwgYW5kIG9ubHkgZmFsbCBiYWNrIHRvIGRlZmF1bHQgd2hlbiBpdCdzIHplcm8uCiAgICAg bV93YWl0VG9EdW1wV2F0Y2hkb2dUaW1lci5zY2hlZHVsZUFmdGVyRGVsYXkoIltXVFJdIHdhaXRU b0R1bXBXYXRjaGRvZ1RpbWVyQ2FsbGJhY2siLCBbdGhpc10geyB3YWl0VG9EdW1wV2F0Y2hkb2dU aW1lckZpcmVkKCk7IH0sCi0gICAgICAgIHN0ZDo6Y2hyb25vOjpkdXJhdGlvbl9jYXN0PHN0ZDo6 Y2hyb25vOjptaWNyb3NlY29uZHM+KHN0ZDo6Y2hyb25vOjpkdXJhdGlvbjxkb3VibGU+KHdhaXRU b0R1bXBXYXRjaGRvZ1RpbWVySW50ZXJ2YWwpKSk7CisgICAgICAgIHN0ZDo6Y2hyb25vOjpkdXJh dGlvbl9jYXN0PHN0ZDo6Y2hyb25vOjptaWNyb3NlY29uZHM+KHN0ZDo6Y2hyb25vOjpkdXJhdGlv bjxkb3VibGU+KGRlZmF1bHRXYWl0VG9EdW1wV2F0Y2hkb2dUaW1lckludGVydmFsKSkpOwogfQog CiBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gVGVzdFJ1bm5lcjo6cGF0aFRvTG9jYWxSZXNvdXJj ZShKU1N0cmluZ1JlZiB1cmwpCkluZGV4OiBUb29scy9XZWJLaXRUZXN0UnVubmVyL0luamVjdGVk QnVuZGxlL21hYy9UZXN0UnVubmVyTWFjLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1dlYktpdFRl c3RSdW5uZXIvSW5qZWN0ZWRCdW5kbGUvbWFjL1Rlc3RSdW5uZXJNYWMubW0JKHJldmlzaW9uIDE3 NzI3OSkKKysrIFRvb2xzL1dlYktpdFRlc3RSdW5uZXIvSW5qZWN0ZWRCdW5kbGUvbWFjL1Rlc3RS dW5uZXJNYWMubW0JKHdvcmtpbmcgY29weSkKQEAgLTUyLDcgKzUyLDggQEAgdm9pZCBUZXN0UnVu bmVyOjppbml0aWFsaXplV2FpdFRvRHVtcFdhdAogICAgIGlmIChtX3dhaXRUb0R1bXBXYXRjaGRv Z1RpbWVyKQogICAgICAgICByZXR1cm47CiAKLSAgICBtX3dhaXRUb0R1bXBXYXRjaGRvZ1RpbWVy ID0gYWRvcHRDRihDRlJ1bkxvb3BUaW1lckNyZWF0ZShrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBDRkFi c29sdXRlVGltZUdldEN1cnJlbnQoKSArIHdhaXRUb0R1bXBXYXRjaGRvZ1RpbWVySW50ZXJ2YWws IDAsIDAsIDAsIFdUUjo6d2FpdFVudGlsRG9uZVdhdGNoZG9nVGltZXJGaXJlZCwgTlVMTCkpOwor ICAgIENGVGltZUludGVydmFsIGludGVydmFsID0gbV90aW1lb3V0ID8gbV90aW1lb3V0IC8gMTAw MC4wIDogZGVmYXVsdFdhaXRUb0R1bXBXYXRjaGRvZ1RpbWVySW50ZXJ2YWw7CisgICAgbV93YWl0 VG9EdW1wV2F0Y2hkb2dUaW1lciA9IGFkb3B0Q0YoQ0ZSdW5Mb29wVGltZXJDcmVhdGUoa0NGQWxs b2NhdG9yRGVmYXVsdCwgQ0ZBYnNvbHV0ZVRpbWVHZXRDdXJyZW50KCkgKyBpbnRlcnZhbCwgMCwg MCwgMCwgV1RSOjp3YWl0VW50aWxEb25lV2F0Y2hkb2dUaW1lckZpcmVkLCBOVUxMKSk7CiAgICAg Q0ZSdW5Mb29wQWRkVGltZXIoQ0ZSdW5Mb29wR2V0Q3VycmVudCgpLCBtX3dhaXRUb0R1bXBXYXRj aGRvZ1RpbWVyLmdldCgpLCBrQ0ZSdW5Mb29wQ29tbW9uTW9kZXMpOwogfQogCkluZGV4OiBUb29s cy9XZWJLaXRUZXN0UnVubmVyL0luamVjdGVkQnVuZGxlL3dpbi9UZXN0UnVubmVyV2luLmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBUb29scy9XZWJLaXRUZXN0UnVubmVyL0luamVjdGVkQnVuZGxlL3dpbi9U ZXN0UnVubmVyV2luLmNwcAkocmV2aXNpb24gMTc3Mjc5KQorKysgVG9vbHMvV2ViS2l0VGVzdFJ1 bm5lci9JbmplY3RlZEJ1bmRsZS93aW4vVGVzdFJ1bm5lcldpbi5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTU2LDcgKzU2LDggQEAgdm9pZCBUZXN0UnVubmVyOjppbml0aWFsaXplV2FpdFRvRHVtcFdh dAogICAgIGlmIChtX3dhaXRUb0R1bXBXYXRjaGRvZ1RpbWVyKQogICAgICAgICByZXR1cm47CiAK LSAgICBtX3dhaXRUb0R1bXBXYXRjaGRvZ1RpbWVyID0gOjpTZXRUaW1lcigwLCB3YWl0VG9EdW1w V2F0Y2hkb2dUaW1lcklkZW50aWZpZXIsIHdhaXRUb0R1bXBXYXRjaGRvZ1RpbWVySW50ZXJ2YWwg KiAxMDAwLCBXVFI6OndhaXRUb0R1bXBXYXRjaGRvZ1RpbWVyRmlyZWQpOworICAgIFVJTlQgaW50 ZXJ2YWwgPSBtX3RpbWVvdXQgPyBtX3RpbWVvdXQgOiBkZWZhdWx0V2FpdFRvRHVtcFdhdGNoZG9n VGltZXJJbnRlcnZhbCAqIDEwMDA7CisgICAgbV93YWl0VG9EdW1wV2F0Y2hkb2dUaW1lciA9IDo6 U2V0VGltZXIoMCwgd2FpdFRvRHVtcFdhdGNoZG9nVGltZXJJZGVudGlmaWVyLCBpbnRlcnZhbCwg V1RSOjp3YWl0VG9EdW1wV2F0Y2hkb2dUaW1lckZpcmVkKTsKIH0KIAogSlNSZXRhaW5QdHI8SlNT dHJpbmdSZWY+IFRlc3RSdW5uZXI6OnBhdGhUb0xvY2FsUmVzb3VyY2UoSlNTdHJpbmdSZWYgdXJs KQo=