135272 2014-07-24 17:06:39 -0700 Allow for multiple DumpRenderTree and WebKitTestRunner instances in the iOS Simulator 2014-07-28 13:04:02 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) iPhone / iPad All RESOLVED FIXED P2 Normal --- 1 dfarler dfarler dbates ddkilzer simon.fraser oldest_to_newest 1024683 0 dfarler 2014-07-24 17:06:39 -0700 To support multiple DRT/WKTR running in the simulator, the relay pipes should not be hard-coded but based on their bundle identifiers, which are uniqued when installing multiple copies into the simulator. In addition, they will need a renewing background task in order to keep running while the other copies are spawned. 1024694 1 235477 dfarler 2014-07-24 17:15:58 -0700 Created attachment 235477 Patch 1024702 2 235477 simon.fraser 2014-07-24 17:31:07 -0700 Comment on attachment 235477 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=235477&action=review > Tools/DumpRenderTree/mac/DumpRenderTree.mm:1126 > + const char *stdoutPath = [[NSString stringWithFormat:@"/tmp/%@_OUT", identifier] UTF8String]; > + const char *stderrPath = [[NSString stringWithFormat:@"/tmp/%@_ERROR", identifier] UTF8String]; > + Do we not need to unique these paths per DRT instance if several are running at once? > Tools/DumpRenderTree/mac/DumpRenderTree.mm:1249 > + NSTimeInterval timeRemaining; > + while (true) { > + timeRemaining = [application backgroundTimeRemaining]; > + if (timeRemaining <= 10.0 || bgTask == UIBackgroundTaskInvalid) { > + [application endBackgroundTask:bgTask]; > + bgTask = [application beginBackgroundTaskWithExpirationHandler:expirationHandler]; > + } > + sleep(5); Why is all this necessary? > Tools/DumpRenderTree/mac/DumpRenderTreeMac.h:80 > + UIBackgroundTaskIdentifier bgTask; bgTask -> backgroundTaskIdentifier. > Tools/WebKitTestRunner/ios/mainIOS.mm:35 > + UIBackgroundTaskIdentifier bgTask; backgroundTaskIdentifier > Tools/WebKitTestRunner/ios/mainIOS.mm:68 > + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ > + > + NSTimeInterval timeRemaining; > + while (true) { > + timeRemaining = [application backgroundTimeRemaining]; > + if (timeRemaining <= 10.0 || bgTask == UIBackgroundTaskInvalid) { > + [application endBackgroundTask:bgTask]; > + bgTask = [application beginBackgroundTaskWithExpirationHandler:expirationHandler]; > + } > + sleep(5); > + } Again, an explanatory comment would be useful. > Tools/WebKitTestRunner/ios/mainIOS.mm:79 > + UIApplicationMain(argc, (char**)argv, NSStringFromClass([WebKitTestRunnerApp class]), NSStringFromClass([WebKitTestRunnerApp class])); Seems odd not to just say @"WebKitTestRunnerApp" here. 1024722 3 dfarler 2014-07-24 18:24:09 -0700 (In reply to comment #2) > (From update of attachment 235477 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=235477&action=review > > > Tools/DumpRenderTree/mac/DumpRenderTree.mm:1126 > > + const char *stdoutPath = [[NSString stringWithFormat:@"/tmp/%@_OUT", identifier] UTF8String]; > > + const char *stderrPath = [[NSString stringWithFormat:@"/tmp/%@_ERROR", identifier] UTF8String]; > > + > > Do we not need to unique these paths per DRT instance if several are running at once? > > > Tools/DumpRenderTree/mac/DumpRenderTree.mm:1249 > > + NSTimeInterval timeRemaining; > > + while (true) { > > + timeRemaining = [application backgroundTimeRemaining]; > > + if (timeRemaining <= 10.0 || bgTask == UIBackgroundTaskInvalid) { > > + [application endBackgroundTask:bgTask]; > > + bgTask = [application beginBackgroundTaskWithExpirationHandler:expirationHandler]; > > + } > > + sleep(5); > > Why is all this necessary? The app will get suspended or killed some time after going into the background without some background task to keep the app alive. This is just a dummy task that does nothing but renew itself when the background time remaining dips below some safe number. 10 seconds was safe enough in my testing. > > > Tools/DumpRenderTree/mac/DumpRenderTreeMac.h:80 > > + UIBackgroundTaskIdentifier bgTask; > > bgTask -> backgroundTaskIdentifier. No problem, will fix. > > > Tools/WebKitTestRunner/ios/mainIOS.mm:35 > > + UIBackgroundTaskIdentifier bgTask; > > backgroundTaskIdentifier > > > Tools/WebKitTestRunner/ios/mainIOS.mm:68 > > + dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ > > + > > + NSTimeInterval timeRemaining; > > + while (true) { > > + timeRemaining = [application backgroundTimeRemaining]; > > + if (timeRemaining <= 10.0 || bgTask == UIBackgroundTaskInvalid) { > > + [application endBackgroundTask:bgTask]; > > + bgTask = [application beginBackgroundTaskWithExpirationHandler:expirationHandler]; > > + } > > + sleep(5); > > + } > > Again, an explanatory comment would be useful. I’ll add comments in both apps for these blocks explaining why it’s necessary. > > > Tools/WebKitTestRunner/ios/mainIOS.mm:79 > > + UIApplicationMain(argc, (char**)argv, NSStringFromClass([WebKitTestRunnerApp class]), NSStringFromClass([WebKitTestRunnerApp class])); > > Seems odd not to just say @"WebKitTestRunnerApp" here. Yeah, it’s just a plain string in DRT. I was just following convention here, but I suppose I can change it. The only advantage to using this is to catch class renaming at compile time. Come to think of it, the class names between these two projects are a little weird but I doubt we’ll change them any time soon. Thanks for the review. 1024725 4 dfarler 2014-07-24 18:25:39 -0700 > > Do we not need to unique these paths per DRT instance if several are running at once? Forgot to mention - the unique app bundle with a renamed app identifier is handled by the relay and ultimately the existing worker shard mechanism in webkitpy. 1025199 5 dfarler 2014-07-28 13:04:02 -0700 Committed r171687: <http://trac.webkit.org/changeset/171687> 235477 2014-07-24 17:15:58 -0700 2014-07-24 17:31:07 -0700 Patch bug-135272-20140724171543.patch text/plain 9897 dfarler U3VidmVyc2lvbiBSZXZpc2lvbjogMTcxNTU4CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYTcyNTA3YWViZmIyMjU2MGEyNDdiYWQ5OWI5OWQyNGM4 Zjk4NTA3NS4uYmI1ZTA1ZDEzZDg0NjE3MmNjMTE3ODNhNGMyNGVjNDc2OTFmMzgxNCAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIy IEBACisyMDE0LTA3LTI0ICBEYXZpZCBGYXJsZXIgIDxkZmFybGVyQGFwcGxlLmNvbT4KKworICAg ICAgICBBbGxvdyBmb3IgbXVsdGlwbGUgRHVtcFJlbmRlclRyZWUgYW5kIFdlYktpdFRlc3RSdW5u ZXIgaW5zdGFuY2VzIGluIHRoZSBpT1MgU2ltdWxhdG9yCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzUyNzIKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVy VHJlZS5tbToKKyAgICAgICAgKGR1bXBSZW5kZXJUcmVlKTogUmVtb3ZlIGhhcmQtY29kaW5nIG9m IEZJRk8gcGF0aHMuCisgICAgICAgICgtW0R1bXBSZW5kZXJUcmVlIGFwcGxpY2F0aW9uRGlkRW50 ZXJCYWNrZ3JvdW5kOl0pOiBDcmVhdGUgYmFja2dyb3VuZCB0YXNrLgorICAgICAgICAoRHVtcFJl bmRlclRyZWVNYWluKTogU2V0IER1bXBSZW5kZXJUcmVlIGFzIFVJQXBwbGljYXRpb24gZGVsZWdh dGUuCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlTWFjLmg6IGJn VGFzayBpdmFyLgorICAgICAgICAqIFNjcmlwdHMvb2xkLXJ1bi13ZWJraXQtdGVzdHM6IFVwZGF0 ZSBGSUZPIHBhdGhzIGZvciBPUldULgorICAgICAgICAqIFdlYktpdFRlc3RSdW5uZXIvVGVzdENv bnRyb2xsZXIuY3BwOiBSZW1vdmUgaGFyZC1jb2Rpbmcgb2YgRklGTyBwYXRocy4KKyAgICAgICAg KiBXZWJLaXRUZXN0UnVubmVyL2lvcy9UZXN0Q29udHJvbGxlcklPUy5tbTogTW92ZSBkdXAyIGNh bGxzIHRvIHBsYXRmb3JtSW5pdGlhbGl6ZQorICAgICAgICAqIFdlYktpdFRlc3RSdW5uZXIvaW9z L21haW5JT1MubW06IGJnVGFzayBpdmFyLgorICAgICAgICAoLVtXZWJLaXRUZXN0UnVubmVyQXBw IGFwcGxpY2F0aW9uRGlkRW50ZXJCYWNrZ3JvdW5kOl0pOiBDcmVhdGUgYmFja2dyb3VuZCB0YXNr LgorICAgICAgICAobWFpbik6IFNldCBXZWJLaXRUZXN0UnVubmVyQXBwIGFzIFVJQXBwbGljYXRp b24gZGVsZWdhdGUuCisKIDIwMTQtMDctMjQgIE1pY2hhZWwgQ2F0YW56YXJvICA8bWNhdGFuemFy b0BpZ2FsaWEuY29tPgogCiAgICAgICAgIEdUSyBqaGJ1aWxkIG1vZHVsZXMgbmVlZHMgdG8gYnVp bGQgeHNlcnZlciB3aXRoIC0tZGlzYWJsZS1sb2NhbC10cmFuc3BvcnQKZGlmZiAtLWdpdCBhL1Rv b2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbSBiL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQppbmRleCA3YmZkODIyOWQ2ZDRhMGYzOWM0MmJi MjUwM2FmZGFiYmQ1MzQyM2VmLi5mNTVhMDU3ZjMxMDdiNTY5NjM1YzFiNjlhM2ZjZDZmOTNkOGFm ZGNmIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUu bW0KKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCkBAIC0x MTE5LDExICsxMTE5LDE2IEBAIHN0YXRpYyB2b2lkIHByZXBhcmVDb25zaXN0ZW50VGVzdGluZ0Vu dmlyb25tZW50KCkKIHZvaWQgZHVtcFJlbmRlclRyZWUoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKmFy Z3ZbXSkKIHsKICNpZiBQTEFURk9STShJT1MpCi0gICAgaW50IGluZmQgPSBvcGVuKCIvdG1wL0R1 bXBSZW5kZXJUcmVlX0lOIiwgT19SRFdSKTsKKyAgICBOU1N0cmluZyAqaWRlbnRpZmllciA9IFtb TlNCdW5kbGUgbWFpbkJ1bmRsZV0gYnVuZGxlSWRlbnRpZmllcl07CisgICAgY29uc3QgY2hhciAq c3RkaW5QYXRoID0gW1tOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiL3RtcC8lQF9JTiIsIGlk ZW50aWZpZXJdIFVURjhTdHJpbmddOworICAgIGNvbnN0IGNoYXIgKnN0ZG91dFBhdGggPSBbW05T U3RyaW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIvdG1wLyVAX09VVCIsIGlkZW50aWZpZXJdIFVURjhT dHJpbmddOworICAgIGNvbnN0IGNoYXIgKnN0ZGVyclBhdGggPSBbW05TU3RyaW5nIHN0cmluZ1dp dGhGb3JtYXQ6QCIvdG1wLyVAX0VSUk9SIiwgaWRlbnRpZmllcl0gVVRGOFN0cmluZ107CisKKyAg ICBpbnQgaW5mZCA9IG9wZW4oc3RkaW5QYXRoLCBPX1JEV1IpOwogICAgIGR1cDIoaW5mZCwgU1RE SU5fRklMRU5PKTsKLSAgICBpbnQgb3V0ZmQgPSBvcGVuKCIvdG1wL0R1bXBSZW5kZXJUcmVlX09V VCIsIE9fUkRXUik7CisgICAgaW50IG91dGZkID0gb3BlbihzdGRvdXRQYXRoLCBPX1JEV1IpOwog ICAgIGR1cDIob3V0ZmQsIFNURE9VVF9GSUxFTk8pOwotICAgIGludCBlcnJmZCA9IG9wZW4oIi90 bXAvRHVtcFJlbmRlclRyZWVfRVJST1IiLCBPX1JEV1IgfCBPX05PTkJMT0NLKTsKKyAgICBpbnQg ZXJyZmQgPSBvcGVuKHN0ZGVyclBhdGgsIE9fUkRXUiB8IE9fTk9OQkxPQ0spOwogICAgIGR1cDIo ZXJyZmQsIFNUREVSUl9GSUxFTk8pOwogI2VuZGlmCiAKQEAgLTEyMjUsNiArMTIzMCwyNyBAQCBz dGF0aWMgY29uc3QgY2hhciAqKl9hcmd2OwogICAgIH0pOwogfQogCistICh2b2lkKWFwcGxpY2F0 aW9uRGlkRW50ZXJCYWNrZ3JvdW5kOihVSUFwcGxpY2F0aW9uICopYXBwbGljYXRpb24KK3sKKyAg ICB2b2lkICheZXhwaXJhdGlvbkhhbmRsZXIpKCkgPSBeIHsKKyAgICAgICAgW2FwcGxpY2F0aW9u IGVuZEJhY2tncm91bmRUYXNrOmJnVGFza107CisgICAgICAgIGJnVGFzayA9IFVJQmFja2dyb3Vu ZFRhc2tJbnZhbGlkOworICAgIH07CisKKyAgICBkaXNwYXRjaF9hc3luYyhkaXNwYXRjaF9nZXRf Z2xvYmFsX3F1ZXVlKERJU1BBVENIX1FVRVVFX1BSSU9SSVRZX0RFRkFVTFQsIDApLCBeeworCisg ICAgICAgIE5TVGltZUludGVydmFsIHRpbWVSZW1haW5pbmc7CisgICAgICAgIHdoaWxlICh0cnVl KSB7CisgICAgICAgICAgICB0aW1lUmVtYWluaW5nID0gW2FwcGxpY2F0aW9uIGJhY2tncm91bmRU aW1lUmVtYWluaW5nXTsKKyAgICAgICAgICAgIGlmICh0aW1lUmVtYWluaW5nIDw9IDEwLjAgfHwg YmdUYXNrID09IFVJQmFja2dyb3VuZFRhc2tJbnZhbGlkKSB7CisgICAgICAgICAgICAgICAgW2Fw cGxpY2F0aW9uIGVuZEJhY2tncm91bmRUYXNrOmJnVGFza107CisgICAgICAgICAgICAgICAgYmdU YXNrID0gW2FwcGxpY2F0aW9uIGJlZ2luQmFja2dyb3VuZFRhc2tXaXRoRXhwaXJhdGlvbkhhbmRs ZXI6ZXhwaXJhdGlvbkhhbmRsZXJdOworICAgICAgICAgICAgfQorICAgICAgICAgICAgc2xlZXAo NSk7CisgICAgICAgIH0KKyAgICB9KTsKK30KKwogLy8gVGhlIHRlc3QgY2FuIGVuZCBpbiByZXNw b25zZSB0byBhIGRlbGVnYXRlIGNhbGxiYWNrIHdoaWxlIHRoZXJlIGFyZSBzdGlsbCBtZXRob2Rz IHF1ZXVlZCBvbiB0aGUgV2ViIFRocmVhZC4KIC8vIElmIHdlIGRvIG5vdCBlbnN1cmUgdGhlIFdl YiBUaHJlYWQgaGFzIGJlZW4gcnVuLCB0aGUgY2FsbGJhY2sgY2FuIGJlIGRvbmUgb24gYSBXZWJW aWV3IHRoYXQgbm8gbG9uZ2VyIGV4aXN0cy4KIC8vIFRvIGF2b2lkIHRoaXMsIF93YWl0Rm9yV2Vi VGhyZWFkIGRpc3BhdGNoZXMgYSBjYWxsIHRvIHRoZSBXZWJUaHJlYWQgZXZlbnQgbG9vcCwgYWN0 aXZlbHkgcHJvY2Vzc2luZyB0aGUgZGVsZWdhdGUKQEAgLTEyNjIsNyArMTI4OCw3IEBAIGludCBE dW1wUmVuZGVyVHJlZU1haW4oaW50IGFyZ2MsIGNvbnN0IGNoYXIgKmFyZ3ZbXSkKICNlbHNlCiAg ICAgX2FyZ2MgPSBhcmdjOwogICAgIF9hcmd2ID0gYXJndjsKLSAgICBVSUFwcGxpY2F0aW9uTWFp bihhcmdjLCAoY2hhcioqKWFyZ3YsIEAiRHVtcFJlbmRlclRyZWUiLCBuaWwpOworICAgIFVJQXBw bGljYXRpb25NYWluKGFyZ2MsIChjaGFyKiopYXJndiwgQCJEdW1wUmVuZGVyVHJlZSIsIEAiRHVt cFJlbmRlclRyZWUiKTsKICNlbmRpZgogICAgIFtXZWJDb3JlU3RhdGlzdGljcyBnYXJiYWdlQ29s bGVjdEphdmFTY3JpcHRPYmplY3RzXTsKICAgICBbV2ViQ29yZVN0YXRpc3RpY3MgZW1wdHlDYWNo ZV07IC8vIE90aGVyd2lzZSBTVkdJbWFnZXMgdHJpZ2dlciBmYWxzZSBwb3NpdGl2ZXMgZm9yIEZy YW1lL05vZGUgY291bnRzCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVt cFJlbmRlclRyZWVNYWMuaCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJl ZU1hYy5oCmluZGV4IDE4ZmMxZjMwYzJiYWRlYWZiZDFiZWE0ZjBkOWMyOTVlODlmNmE2YzMuLjMz ODIyOTMxM2YwZDVkNjA5ODE0MGI2YTg0ODhkNjE0NTQ0MDU4OGMgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZU1hYy5oCisrKyBiL1Rvb2xzL0R1bXBS ZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZU1hYy5oCkBAIC03Nyw2ICs3Nyw3IEBAIHVuc2ln bmVkIHdvcmxkSURGb3JXb3JsZChXZWJTY3JpcHRXb3JsZCAqKTsKICNpZiBQTEFURk9STShJT1Mp ICYmIGRlZmluZWQoX19PQkpDX18pCiBAaW50ZXJmYWNlIER1bXBSZW5kZXJUcmVlIDogVUlBcHBs aWNhdGlvbiB7CiAgICAgQk9PTCBfaGFzRmx1c2hlZFdlYlRocmVhZFJ1blF1ZXVlOworICAgIFVJ QmFja2dyb3VuZFRhc2tJZGVudGlmaWVyIGJnVGFzazsKIH0KIAogLSAodm9pZClfd2FpdEZvcldl YlRocmVhZDsKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvb2xkLXJ1bi13ZWJraXQtdGVzdHMg Yi9Ub29scy9TY3JpcHRzL29sZC1ydW4td2Via2l0LXRlc3RzCmluZGV4IDhiZTFiMTBmZDhhNjdm NzJjMjk3YTA2MzE3NWQ1NjA4ZTM5OWIzZTMuLjZhMzQzMjAzYzE0MjczN2E4YTJmZWFiOTIxZGZm ZWFlMGFhMmZiYmUgMTAwNzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvb2xkLXJ1bi13ZWJraXQtdGVz dHMKKysrIGIvVG9vbHMvU2NyaXB0cy9vbGQtcnVuLXdlYmtpdC10ZXN0cwpAQCAtMTUwNiwxMSAr MTUwNiw4IEBAIHN1YiBvcGVuRGlmZlRvb2woKQogCiBzdWIgdW5saW5rRklGT3MoKQogewotICAg IGlmICgkdXNlV2ViS2l0VGVzdFJ1bm5lcikgewotICAgICAgICB1bmxpbmsgPC90bXAvV2ViS2l0 VGVzdFJ1bm5lcl8qPjsKLSAgICB9IGVsc2UgewotICAgICAgICB1bmxpbmsgPC90bXAvRHVtcFJl bmRlclRyZWVfKj47Ci0gICAgfQorICAgIG15ICRpZGVudGlmaWVyID0gaU9TRHVtcFRvb2xBcHBJ ZGVudGlmaWVyKCk7CisgICAgdW5saW5rIGdsb2IgIi90bXAvJHtpZGVudGlmaWVyfV8qIjsKIH0K IAogc3ViIGJ1aWxkRHVtcFRvb2woJCkKQEAgLTE2NDMsMTAgKzE2NDAsOSBAQCBzdWIgb3BlbkR1 bXBUb29sKCkKIAogICAgICAgICBteSAkYXBwSWRlbnRpZmllciA9IGlPU0R1bXBUb29sQXBwSWRl bnRpZmllcigpOwogCi0gICAgICAgIG15ICRmaWZvTmFtZSA9ICR1c2VXZWJLaXRUZXN0UnVubmVy ID8gIldlYktpdFRlc3RSdW5uZXIiIDogIkR1bXBSZW5kZXJUcmVlIjsKLSAgICAgICAgbXkgJGZp Zm9PdXQgPSAiL3RtcC8ke2ZpZm9OYW1lfV9PVVQiOwotICAgICAgICBteSAkZmlmb0luID0gIi90 bXAvJHtmaWZvTmFtZX1fSU4iOwotICAgICAgICBteSAkZmlmb0Vycm9yID0gIi90bXAvJHtmaWZv TmFtZX1fRVJST1IiOworICAgICAgICBteSAkZmlmb091dCA9ICIvdG1wLyR7YXBwSWRlbnRpZmll cn1fT1VUIjsKKyAgICAgICAgbXkgJGZpZm9JbiA9ICIvdG1wLyR7YXBwSWRlbnRpZmllcn1fSU4i OworICAgICAgICBteSAkZmlmb0Vycm9yID0gIi90bXAvJHthcHBJZGVudGlmaWVyfV9FUlJPUiI7 CiAKICAgICAgICAgZm9yZWFjaCBteSAkZmlmbyAoJGZpZm9PdXQsICRmaWZvSW4sICRmaWZvRXJy b3IpIHsKICAgICAgICAgICAgIGlmICghIC1lICRmaWZvKSB7CmRpZmYgLS1naXQgYS9Ub29scy9X ZWJLaXRUZXN0UnVubmVyL1Rlc3RDb250cm9sbGVyLmNwcCBiL1Rvb2xzL1dlYktpdFRlc3RSdW5u ZXIvVGVzdENvbnRyb2xsZXIuY3BwCmluZGV4IGEzMmI0ZjZkM2RmNTU1MmUzYjRhNGM2NGZhNTE3 OTdkOTRlNGIyMjIuLmY2NzkxZjk4NjBjNmVkMDcwZjQ0Mjk3YmNmMjk5NzFiZjkzNWQ2ZGUgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvVGVzdENvbnRyb2xsZXIuY3BwCisrKyBi L1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvVGVzdENvbnRyb2xsZXIuY3BwCkBAIC0xMjQsMTYgKzEy NCw2IEBAIFRlc3RDb250cm9sbGVyOjpUZXN0Q29udHJvbGxlcihpbnQgYXJnYywgY29uc3QgY2hh ciogYXJndltdKQogICAgICwgbV9zaG91bGRVc2VSZW1vdGVMYXllclRyZWUoZmFsc2UpCiAgICAg LCBtX3Nob3VsZExvZ0hpc3RvcnlDbGllbnRDYWxsYmFja3MoZmFsc2UpCiB7Ci0KLSNpZiBQTEFU Rk9STShJT1MpCi0gICAgaW50IGluZmQgPSBvcGVuKCIvdG1wL1dlYktpdFRlc3RSdW5uZXJfSU4i LCBPX1JEV1IpOwotICAgIGR1cDIoaW5mZCwgU1RESU5fRklMRU5PKTsKLSAgICBpbnQgb3V0ZmQg PSBvcGVuKCIvdG1wL1dlYktpdFRlc3RSdW5uZXJfT1VUIiwgT19SRFdSKTsKLSAgICBkdXAyKG91 dGZkLCBTVERPVVRfRklMRU5PKTsKLSAgICBpbnQgZXJyZmQgPSBvcGVuKCIvdG1wL1dlYktpdFRl c3RSdW5uZXJfRVJST1IiLCBPX1JEV1IgfCBPX05PTkJMT0NLKTsKLSAgICBkdXAyKGVycmZkLCBT VERFUlJfRklMRU5PKTsKLSNlbmRpZgotCiAgICAgaW5pdGlhbGl6ZShhcmdjLCBhcmd2KTsKICAg ICBjb250cm9sbGVyID0gdGhpczsKICAgICBydW4oKTsKZGlmZiAtLWdpdCBhL1Rvb2xzL1dlYktp dFRlc3RSdW5uZXIvaW9zL1Rlc3RDb250cm9sbGVySU9TLm1tIGIvVG9vbHMvV2ViS2l0VGVzdFJ1 bm5lci9pb3MvVGVzdENvbnRyb2xsZXJJT1MubW0KaW5kZXggNDI2M2E0YmNlMTdjMDRmMzgxZDQ2 YmE5Mzg3MGNiODk0MmVlY2Y0YS4uZDhjNWFhYTI5YmIzMDUyMDVhZTBiYmM0YmMxNzZiOWMyYThm YzE3NSAxMDA2NDQKLS0tIGEvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9pb3MvVGVzdENvbnRyb2xs ZXJJT1MubW0KKysrIGIvVG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9pb3MvVGVzdENvbnRyb2xsZXJJ T1MubW0KQEAgLTI3LDYgKzI3LDcgQEAKICNpbXBvcnQgIlRlc3RDb250cm9sbGVyLmgiCiAKICNp bXBvcnQgIkNyYXNoUmVwb3J0ZXJJbmZvLmgiCisjaW1wb3J0IDxGb3VuZGF0aW9uL0ZvdW5kYXRp b24uaD4KICNpbXBvcnQgIlBsYXRmb3JtV2ViVmlldy5oIgogI2ltcG9ydCAiVGVzdEludm9jYXRp b24uaCIKICNpbXBvcnQgPFdlYktpdC9XS1N0cmluZ0NGLmg+CkBAIC00MCw2ICs0MSwxNyBAQCB2 b2lkIFRlc3RDb250cm9sbGVyOjpub3RpZnlEb25lKCkKIAogdm9pZCBUZXN0Q29udHJvbGxlcjo6 cGxhdGZvcm1Jbml0aWFsaXplKCkKIHsKKyAgICBOU1N0cmluZyAqaWRlbnRpZmllciA9IFtbTlNC dW5kbGUgbWFpbkJ1bmRsZV0gYnVuZGxlSWRlbnRpZmllcl07CisgICAgY29uc3QgY2hhciAqc3Rk aW5QYXRoID0gW1tOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiL3RtcC8lQF9JTiIsIGlkZW50 aWZpZXJdIFVURjhTdHJpbmddOworICAgIGNvbnN0IGNoYXIgKnN0ZG91dFBhdGggPSBbW05TU3Ry aW5nIHN0cmluZ1dpdGhGb3JtYXQ6QCIvdG1wLyVAX09VVCIsIGlkZW50aWZpZXJdIFVURjhTdHJp bmddOworICAgIGNvbnN0IGNoYXIgKnN0ZGVyclBhdGggPSBbW05TU3RyaW5nIHN0cmluZ1dpdGhG b3JtYXQ6QCIvdG1wLyVAX0VSUk9SIiwgaWRlbnRpZmllcl0gVVRGOFN0cmluZ107CisKKyAgICBp bnQgaW5mZCA9IG9wZW4oc3RkaW5QYXRoLCBPX1JEV1IpOworICAgIGR1cDIoaW5mZCwgU1RESU5f RklMRU5PKTsKKyAgICBpbnQgb3V0ZmQgPSBvcGVuKHN0ZG91dFBhdGgsIE9fUkRXUik7CisgICAg ZHVwMihvdXRmZCwgU1RET1VUX0ZJTEVOTyk7CisgICAgaW50IGVycmZkID0gb3BlbihzdGRlcnJQ YXRoLCBPX1JEV1IgfCBPX05PTkJMT0NLKTsKKyAgICBkdXAyKGVycmZkLCBTVERFUlJfRklMRU5P KTsKIH0KIAogdm9pZCBUZXN0Q29udHJvbGxlcjo6cGxhdGZvcm1EZXN0cm95KCkKZGlmZiAtLWdp dCBhL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvaW9zL21haW5JT1MubW0gYi9Ub29scy9XZWJLaXRU ZXN0UnVubmVyL2lvcy9tYWluSU9TLm1tCmluZGV4IDljNWVkZDZjMTUwMDMyYTRlZjJmOGJiMTUy MDY1Y2YwYTAyZWMxZjAuLjNmNmYyZDFkNzRkMDJmYjBiNDQzNzFhNzY0ZjFlMDM1ZmZjOWEzYWUg MTAwNjQ0Ci0tLSBhL1Rvb2xzL1dlYktpdFRlc3RSdW5uZXIvaW9zL21haW5JT1MubW0KKysrIGIv VG9vbHMvV2ViS2l0VGVzdFJ1bm5lci9pb3MvbWFpbklPUy5tbQpAQCAtMzEsNyArMzEsOSBAQAog c3RhdGljIGludCBfYXJnYzsKIHN0YXRpYyBjb25zdCBjaGFyICoqX2FyZ3Y7CiAKLUBpbnRlcmZh Y2UgV2ViS2l0VGVzdFJ1bm5lckFwcCA6IFVJQXBwbGljYXRpb24KK0BpbnRlcmZhY2UgV2ViS2l0 VGVzdFJ1bm5lckFwcCA6IFVJQXBwbGljYXRpb24geworICAgIFVJQmFja2dyb3VuZFRhc2tJZGVu dGlmaWVyIGJnVGFzazsKK30KIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdlYktpdFRlc3RSdW5u ZXJBcHAKQEAgLTQ2LDYgKzQ4LDI3IEBAIHN0YXRpYyBjb25zdCBjaGFyICoqX2FyZ3Y7CiAgICAg W3NlbGYgcGVyZm9ybVNlbGVjdG9yT25NYWluVGhyZWFkOkBzZWxlY3RvcihfcnVuVGVzdENvbnRy b2xsZXIpIHdpdGhPYmplY3Q6bmlsIHdhaXRVbnRpbERvbmU6Tk9dOwogfQogCistICh2b2lkKWFw cGxpY2F0aW9uRGlkRW50ZXJCYWNrZ3JvdW5kOihVSUFwcGxpY2F0aW9uICopYXBwbGljYXRpb24K K3sKKyAgICB2b2lkICheZXhwaXJhdGlvbkhhbmRsZXIpKCkgPSBeIHsKKyAgICAgICAgW2FwcGxp Y2F0aW9uIGVuZEJhY2tncm91bmRUYXNrOmJnVGFza107CisgICAgICAgIGJnVGFzayA9IFVJQmFj a2dyb3VuZFRhc2tJbnZhbGlkOworICAgIH07CisKKyAgICBkaXNwYXRjaF9hc3luYyhkaXNwYXRj aF9nZXRfZ2xvYmFsX3F1ZXVlKERJU1BBVENIX1FVRVVFX1BSSU9SSVRZX0RFRkFVTFQsIDApLCBe eworCisgICAgICAgIE5TVGltZUludGVydmFsIHRpbWVSZW1haW5pbmc7CisgICAgICAgIHdoaWxl ICh0cnVlKSB7CisgICAgICAgICAgICB0aW1lUmVtYWluaW5nID0gW2FwcGxpY2F0aW9uIGJhY2tn cm91bmRUaW1lUmVtYWluaW5nXTsKKyAgICAgICAgICAgIGlmICh0aW1lUmVtYWluaW5nIDw9IDEw LjAgfHwgYmdUYXNrID09IFVJQmFja2dyb3VuZFRhc2tJbnZhbGlkKSB7CisgICAgICAgICAgICAg ICAgW2FwcGxpY2F0aW9uIGVuZEJhY2tncm91bmRUYXNrOmJnVGFza107CisgICAgICAgICAgICAg ICAgYmdUYXNrID0gW2FwcGxpY2F0aW9uIGJlZ2luQmFja2dyb3VuZFRhc2tXaXRoRXhwaXJhdGlv bkhhbmRsZXI6ZXhwaXJhdGlvbkhhbmRsZXJdOworICAgICAgICAgICAgfQorICAgICAgICAgICAg c2xlZXAoNSk7CisgICAgICAgIH0KKyAgICB9KTsKK30KKwogQGVuZAogCiBpbnQgbWFpbihpbnQg YXJnYywgY29uc3QgY2hhciogYXJndltdKQpAQCAtNTMsNiArNzYsNiBAQCBpbnQgbWFpbihpbnQg YXJnYywgY29uc3QgY2hhciogYXJndltdKQogICAgIF9hcmdjID0gYXJnYzsKICAgICBfYXJndiA9 IGFyZ3Y7CiAKLSAgICBVSUFwcGxpY2F0aW9uTWFpbihhcmdjLCAoY2hhcioqKWFyZ3YsIE5TU3Ry aW5nRnJvbUNsYXNzKFtXZWJLaXRUZXN0UnVubmVyQXBwIGNsYXNzXSksIG5pbCk7CisgICAgVUlB cHBsaWNhdGlvbk1haW4oYXJnYywgKGNoYXIqKilhcmd2LCBOU1N0cmluZ0Zyb21DbGFzcyhbV2Vi S2l0VGVzdFJ1bm5lckFwcCBjbGFzc10pLCBOU1N0cmluZ0Zyb21DbGFzcyhbV2ViS2l0VGVzdFJ1 bm5lckFwcCBjbGFzc10pKTsKICAgICByZXR1cm4gMDsKIH0K