27836 2009-07-30 07:50:25 -0700 Stale database version persists through browser refresh (changeVersion doesn't work) 2009-10-02 03:36:27 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Mac OS X 10.5 RESOLVED FIXED InRadar P2 Normal --- 1 mbolohan benm agrieve ap beidson benm ddkilzer dglazkov dumi ian jorlow michaeln oldest_to_newest 135842 0 33778 mbolohan 2009-07-30 07:50:25 -0700 Created attachment 33778 Script that demonstrates incorrect caching of database version r46507 The version property of the database object is stale after invoking changeVersion() and remains stale after a refresh. Killing webkit results in a correct value for db.version after calling window.openDatabase(). I have attached a test script that demonstrates this behavior. The script performs the following steps: 1) open a new database without a version restriction 2) check if the database version matches a predefined string constant (report success if the versions match) 3) if the versions don't match, change the database version to the predefined version constant 4) reload the page Expected behavior: - version doesn't match - change version (alert changeVersion success and reload) - version matches (alert success with version) Observed behavior: - version doesn't match - change version (alert changeVersion success and reload) - version doesn't match - change version (alert Error: current version of the database and `oldVersion` argument do not match) Note: Killing webkit and loading the script results in a successful version match. 137495 1 ap 2009-08-05 18:03:25 -0700 <rdar://problem/5737246> 137496 2 ap 2009-08-05 18:03:51 -0700 <rdar://problem/5556376> even. 142662 3 ap 2009-08-25 11:56:46 -0700 *** Bug 28418 has been marked as a duplicate of this bug. *** 145159 4 benm 2009-09-07 08:14:54 -0700 I think I know what is happening here and will send a patch shortly. 145169 5 39150 benm 2009-09-07 09:05:28 -0700 Created attachment 39150 Proposed patch with layout test. This patch fixes this bug and 24818 which although similar is actually not a duplicate. The problem described in this bug is caused by the database only being removed from the guid->version map in the Database dtor. The dtor is only called when the Database thread is destroyed which may come after the page has been unloaded and the next page loaded. Thus in the test script attached to this bug, the map still contains the old database version number when the page is reloaded because the dtor has at that point not been run. This is fixed by moving the code from the dtor into the Database::close() method. The bug described in 24818 comes from the fact that in the Database::setExcpectedVersion (called from the ChangeVersionWrapper postflight code) we do not update the guid->version map. This is fixed by adding code to update the map at that point. I've also implemented the changeVersion function in the V8 bindings and written a layout test that is a combination of the test attached to this bug and that attached to 24818. 145194 6 39154 ap 2009-09-07 10:18:40 -0700 Created attachment 39154 another test FWIW, here is a test that I had sitting in my tree disabled for quite a while. 145205 7 benm 2009-09-07 10:39:33 -0700 (In reply to comment #6) > Created an attachment (id=39154) [details] > another test > > FWIW, here is a test that I had sitting in my tree disabled for quite a while. Thanks Alexey, confirming that that test seems to work fine with the fix applied (displays the foobar error and no asserts on reload). Would you like me to add it to the patch? Cheers, Ben 145217 8 ap 2009-09-07 11:00:53 -0700 Not sure, I haven't compared it with your test carefully enough. If you think there's something additional that it tests, then adding it would be great. 145367 9 benm 2009-09-08 08:50:25 -0700 (In reply to comment #8) > Not sure, I haven't compared it with your test carefully enough. If you think > there's something additional that it tests, then adding it would be great. I think your test is valuable in addition to mine as it verifies that the DB handle stays alive (my test opens new handles). After I get some review feedback I will add your test into the patch. Cheers, Ben 145471 10 benm 2009-09-08 11:49:16 -0700 cc'ing dglazkov as part of this patch is an edit to V8 bindings. 146274 11 benm 2009-09-10 11:57:09 -0700 ping... 146292 12 39150 abarth 2009-09-10 12:27:45 -0700 Comment on attachment 39150 Proposed patch with layout test. The V8 parts of this patch look fine to me. I'm not that confident in the non-V8 parts, but I'm presuming AP has looked them over. 146306 13 ap 2009-09-10 13:06:50 -0700 > I'm presuming AP has looked them over. I did not. I'm not very familiar with this code. 146308 14 39150 abarth 2009-09-10 13:11:25 -0700 Comment on attachment 39150 Proposed patch with layout test. Hum... Ok. Then I'm putting this back to r?. The V8 parts are fine. We need to find someone familiar with database to look at the rest of the patch. 146505 15 benm 2009-09-11 02:37:03 -0700 (In reply to comment #14) > (From update of attachment 39150 [details]) > Hum... Ok. Then I'm putting this back to r?. The V8 parts are fine. We need > to find someone familiar with database to look at the rest of the patch. Thanks for looking over the V8 portion Adam. There have been a few patches to the WebCore storage code since I sent this patch so I need to regenerate it. dglazkov seems to have reviewed those refactorings, so perhaps he could review this one too? I will also cc Brady when I send the new patch because AFAIK he wrote the code originally. Cheers, Ben 146535 16 benm 2009-09-11 06:32:49 -0700 Seems that the recent DB refactorings didn't touch the same areas as this patch as it still applied after a sync. I've added ap's test into the patch now and will upload a new version. 146537 17 39426 benm 2009-09-11 06:44:32 -0700 Created attachment 39426 Patch incorporating Alexey's test New patch generated more recently and including Alexey's test. 146540 18 benm 2009-09-11 06:51:00 -0700 Brady, would you mind taking a look at this patch? Many thanks, Ben 147376 19 benm 2009-09-15 13:44:29 -0700 Ping... anyone able to take a look at this? Thanks, Ben 149558 20 39426 eric 2009-09-23 17:15:57 -0700 Comment on attachment 39426 Patch incorporating Alexey's test Why not just put: 178 { 179 MutexLocker locker(guidMutex()); 180 181 HashSet<Database*>* hashSet = guidToDatabaseMap().get(m_guid); 182 ASSERT(hashSet); 183 ASSERT(hashSet->contains(this)); 184 hashSet->remove(this); 185 if (hashSet->isEmpty()) { 186 guidToDatabaseMap().remove(m_guid); 187 delete hashSet; 188 guidToVersionMap().remove(m_guid); 189 } 190 } 191 into a static inline function? Also, I think Alexey is really your man here. 149988 21 benm 2009-09-25 06:08:53 -0700 (In reply to comment #20) Hi Eric, Thanks for looking at my patch! > (From update of attachment 39426 [details]) > Why not just put: > 178 { > 179 MutexLocker locker(guidMutex()); > 180 > 181 HashSet<Database*>* hashSet = guidToDatabaseMap().get(m_guid); > 182 ASSERT(hashSet); > 183 ASSERT(hashSet->contains(this)); > 184 hashSet->remove(this); > 185 if (hashSet->isEmpty()) { > 186 guidToDatabaseMap().remove(m_guid); > 187 delete hashSet; > 188 guidToVersionMap().remove(m_guid); > 189 } > 190 } > 191 > into a static inline function? As this code is only called once and my intention was to just move it from the destructor to the close() method, it's not clear to me what moving it into a static inline would buy us. Could you elaborate? > Also, I think Alexey is really your man here. Alexey already looked at it and said he wasn't familiar enough with the code to review it (comment 13 above). So could you please help me with getting this reviewed? Adam has OK'd the V8 portion (comment 12). Cheers, Ben 150308 22 39426 ddkilzer 2009-09-26 10:45:36 -0700 Comment on attachment 39426 Patch incorporating Alexey's test > Index: WebCore/storage/Database.cpp > =================================================================== > --- WebCore/storage/Database.cpp (revision 48292) > +++ WebCore/storage/Database.cpp (working copy) > @@ -328,6 +314,20 @@ void Database::close() > m_sqliteDatabase.close(); > m_document->databaseThread()->recordDatabaseClosed(this); > m_opened = false; > + > + { > + MutexLocker locker(guidMutex()); > + > + HashSet<Database*>* hashSet = guidToDatabaseMap().get(m_guid); > + ASSERT(hashSet); > + ASSERT(hashSet->contains(this)); > + hashSet->remove(this); > + if (hashSet->isEmpty()) { > + guidToDatabaseMap().remove(m_guid); > + delete hashSet; > + guidToVersionMap().remove(m_guid); > + } > + } > } > } > I think moving this code from the Database destructor to the close() method is fine. (Running all database tests with a debug build of WebKit after this change would be a really good idea. Have you done that?) > @@ -631,6 +631,9 @@ Vector<String> Database::tableNames() > void Database::setExpectedVersion(const String& version) > { > m_expectedVersion = version.copy(); > + // Update the in memory database version map. > + MutexLocker locker(guidMutex()); > + guidToVersionMap().set(m_guid, version); > } There is similar GUID-setting code in Database::performOpenAndVerify() that does two things this code does not: 1. It maps an empty string to a null string before updating the guidToVersionMap(). 2. It makes a defensive copy of the version string (if it is not an empty string). I think it would make sense to extract this code into its own static inline method (perhaps after the guidToVersionMap() method itself) and update the two call sites to use it. r- to fix Database::setExpectedVersion(). 150609 23 dumi 2009-09-28 12:47:09 -0700 the DB changes look good to me. thanks for catching this problem and fixing it! minor: please add a short comment to Database::setVersionInDatabase() explaining that INSERT will replace the old version because that's how the table is defined. > Index: LayoutTests/storage/change-version-expected.txt > =================================================================== > --- LayoutTests/storage/change-version-expected.txt (revision 0) > +++ LayoutTests/storage/change-version-expected.txt (revision 0) > @@ -0,0 +1,4 @@ > +This test verifies that the database.changeVersion function works as expected. minor: Database::changeVersion(). > Property changes on: LayoutTests/storage/change-version-expected.txt > ___________________________________________________________________ > Added: svn:eol-style > + native i don't think these are necessary. > Index: LayoutTests/storage/change-version-handle-reuse.html > +function finishTest() > +{ > + log("TEST COMPLETE."); replace tab with spaces. > +function runTest() > +{ > + if (window.layoutTestController) { > + layoutTestController.waitUntilDone(); tab --> spaces. > Index: LayoutTests/storage/change-version.html > +function changeVersionCallback(tx) > +{ > + tx.executeSql('drop table if exists info;', [], emptyFunction, emptyFunction); > + tx.executeSql('create table if not exists info (version INTEGER);',[], emptyFunction, emptyFunction); > + tx.executeSql('insert into info values(?);', [EXPECTED_VERSION_AFTER_RELOAD], emptyFunction, emptyFunction); > +} minor: i believe webkit code and tests always capitalize keywords such as DROP, CREATE TABLE, INSERT, etc. and uses double-quotes (") for strings. > +function runTest() > +{ > + if (window.location.search == "?2") { > + db = window.openDatabase('changeversion-test', '', 'Test for the database.changeVersion() function', 1024); > + log('Finished tests with version ' + db.version); minor: maybe change the log message to something like: log("Finished tests with version " + db.version + "; expected version: " + EXPECTED_VERSION_AFTER_RELOAD); > + finishTest(); > + } else { > + testPart1(); > + } 1-line else: remove {}. minor: maybe put the if-block into a testPart2() function? > +function testPart1() { > + if (window.layoutTestController) { > + layoutTestController.clearAllDatabases(); > + layoutTestController.dumpAsText(); > + layoutTestController.waitUntilDone(); > + } > + > + db = window.openDatabase('changeversion-test', '', 'Test for the database.changeVersion() function', 1024); > + > + if (db.version != EXPECTED_VERSION_AFTER_RELOAD) { > + // First run Hixie's test to ensure basic changeVersion functionality works (see bug 28418). > + db.changeVersion('', EXPECTED_VERSION_AFTER_HIXIE_TEST, emptyFunction, function (e) { > + log('FAIL in changeVersion:' + e); > + finishTest(); > + }, function () { > + try { > + var db2 = openDatabase('change-version-test', EXPECTED_VERSION_AFTER_HIXIE_TEST, '', 0); > + } catch (e) { > + log('FAIL in openDatabase: ' + e); > + finishTest(); > + } > + // Following versions should match. > + log('Database version: ' + db.version); > + log('Second database version: ' + db2.version); instead of expecting the user to know that the two versions are supposed to match, maybe replace these lines with something like this? if (db.version == db2.version) log("db.version(" + db.version + ") matches db2.version(" + db2.version + ") as expected."); else log("db.version(" + db.version + ") does not db2.version(" + db2.version + "): failing."); 150611 24 benm 2009-09-28 12:54:57 -0700 Thank you for the feedback David and Dumi. I'll incorporate your comments into a new patch and upload. Cheers! 151555 25 benm 2009-10-01 08:35:03 -0700 (In reply to comment #22) > (Running all database tests with a debug build of WebKit after this > change would be a really good idea. Have you done that?) Yes, I've run the storage layout tests on Mac and Windows and they all pass. > > There is similar GUID-setting code in Database::performOpenAndVerify() that > does two things this code does not: > > 1. It maps an empty string to a null string before updating the > guidToVersionMap(). > 2. It makes a defensive copy of the version string (if it is not an empty > string). > > I think it would make sense to extract this code into its own static inline > method (perhaps after the guidToVersionMap() method itself) and update the two > call sites to use it. > Fixed. (In reply to comment #23) > minor: please add a short comment to Database::setVersionInDatabase() > explaining that INSERT will replace the old version because that's how the > table is defined. Done. > > Index: LayoutTests/storage/change-version-expected.txt > > =================================================================== > > --- LayoutTests/storage/change-version-expected.txt (revision 0) > > +++ LayoutTests/storage/change-version-expected.txt (revision 0) > > @@ -0,0 +1,4 @@ > > +This test verifies that the database.changeVersion function works as expected. > >minor: Database::changeVersion(). IMHO as it's the JS function we're testing, I think database.changeVersion is fine. > > > Property changes on: LayoutTests/storage/change-version-expected.txt > > ___________________________________________________________________ > > Added: svn:eol-style > > + native > > i don't think these are necessary. Hmm, I was advised on a past review that they should be set. Keeping for now. > > > Index: LayoutTests/storage/change-version-handle-reuse.html > > +function finishTest() > > +{ > > + log("TEST COMPLETE."); > > replace tab with spaces. Done. > > > +function runTest() > > +{ > > + if (window.layoutTestController) { > > + layoutTestController.waitUntilDone(); > > tab --> spaces. Done. > > > Index: LayoutTests/storage/change-version.html > > +function changeVersionCallback(tx) > > +{ > > + tx.executeSql('drop table if exists info;', [], emptyFunction, emptyFunction); > > + tx.executeSql('create table if not exists info (version INTEGER);',[], emptyFunction, emptyFunction); > > + tx.executeSql('insert into info values(?);', [EXPECTED_VERSION_AFTER_RELOAD], emptyFunction, emptyFunction); > > +} > > minor: i believe webkit code and tests always capitalize keywords such as DROP, > CREATE TABLE, INSERT, etc. and uses double-quotes (") for strings. Done. > > > +function runTest() > > +{ > > + if (window.location.search == "?2") { > > + db = window.openDatabase('changeversion-test', '', 'Test for the database.changeVersion() function', 1024); > > + log('Finished tests with version ' + db.version); > > minor: maybe change the log message to something like: > > log("Finished tests with version " + db.version + "; expected version: " + > EXPECTED_VERSION_AFTER_RELOAD); Done. > > > + finishTest(); > > + } else { > > + testPart1(); > > + } > > 1-line else: remove {}. Fixed. > > minor: maybe put the if-block into a testPart2() function? > > > +function testPart1() { > > + if (window.layoutTestController) { > > + layoutTestController.clearAllDatabases(); > > + layoutTestController.dumpAsText(); > > + layoutTestController.waitUntilDone(); > > + } > > + > > + db = window.openDatabase('changeversion-test', '', 'Test for the database.changeVersion() function', 1024); > > + > > + if (db.version != EXPECTED_VERSION_AFTER_RELOAD) { > > + // First run Hixie's test to ensure basic changeVersion functionality works (see bug 28418). > > + db.changeVersion('', EXPECTED_VERSION_AFTER_HIXIE_TEST, emptyFunction, function (e) { > > + log('FAIL in changeVersion:' + e); > > + finishTest(); > > + }, function () { > > + try { > > + var db2 = openDatabase('change-version-test', EXPECTED_VERSION_AFTER_HIXIE_TEST, '', 0); > > + } catch (e) { > > + log('FAIL in openDatabase: ' + e); > > + finishTest(); > > + } > > + // Following versions should match. > > + log('Database version: ' + db.version); > > + log('Second database version: ' + db2.version); > > instead of expecting the user to know that the two versions are supposed to > match, maybe replace these lines with something like this? > > if (db.version == db2.version) > log("db.version(" + db.version + ") matches db2.version(" + db2.version + > ") as expected."); > else > log("db.version(" + db.version + ") does not db2.version(" + db2.version + > "): failing."); Done. New patch is on it's way! 151557 26 40445 benm 2009-10-01 08:36:19 -0700 Created attachment 40445 Revised patch. 151640 27 40445 dumi 2009-10-01 11:40:55 -0700 Comment on attachment 40445 Revised patch. LGTM, with 2 minor comments below. I'm not a reviewer though, so I can't r+ the patch. > Index: WebCore/storage/Database.cpp > =================================================================== > --- WebCore/storage/Database.cpp (revision 48292) > +++ WebCore/storage/Database.cpp (working copy) > @@ -89,6 +89,18 @@ static GuidVersionMap& guidToVersionMap( > return map; > } > > +static inline void updateGuidVersionMap(int guid, String newVersion) > +{ > + // Note: It is not safe to put an empty string into the guidToVersionMap() map. > + // That's because the map is cross-thread, but empty strings are per-thread. > + // The copy() function makes a version of the string you can use on the current > + // thread, but we need a string we can keep in a cross-thread data structure. > + // FIXME: This is a quite-awkward restriction to have to program with. > + > + // NOTE: Caller must lock guidMutex(). optional: might be a good idea to make this a function-level comment (ie. put it right before 'static inline void ...'). > Index: LayoutTests/storage/change-version.html > =================================================================== > + // The two database versions should match. > + if (db.version == db2.version) > + log("PASS: db.version(" + db.version + ") matches db2.version(" + db2.version +") as expected."); > + else > + log("FAIL: db.version(" + db.version + ") does not db2.version(" + db2.version +")"); typo (that i had in my comment too :)): does not MATCH db2.version 151642 28 benm 2009-10-01 11:48:23 -0700 (In reply to comment #27) Thanks Dumi -- if David is happy with the patch and can r+ I will address your comments when I commit. Cheers, Ben > (From update of attachment 40445 [details]) > LGTM, with 2 minor comments below. I'm not a reviewer though, so I can't r+ the > patch. > > > Index: WebCore/storage/Database.cpp > > =================================================================== > > --- WebCore/storage/Database.cpp (revision 48292) > > +++ WebCore/storage/Database.cpp (working copy) > > @@ -89,6 +89,18 @@ static GuidVersionMap& guidToVersionMap( > > return map; > > } > > > > +static inline void updateGuidVersionMap(int guid, String newVersion) > > +{ > > + // Note: It is not safe to put an empty string into the guidToVersionMap() map. > > + // That's because the map is cross-thread, but empty strings are per-thread. > > + // The copy() function makes a version of the string you can use on the current > > + // thread, but we need a string we can keep in a cross-thread data structure. > > + // FIXME: This is a quite-awkward restriction to have to program with. > > + > > + // NOTE: Caller must lock guidMutex(). > > optional: might be a good idea to make this a function-level comment (ie. put > it right before 'static inline void ...'). > > > Index: LayoutTests/storage/change-version.html > > =================================================================== > > + // The two database versions should match. > > + if (db.version == db2.version) > > + log("PASS: db.version(" + db.version + ") matches db2.version(" + db2.version +") as expected."); > > + else > > + log("FAIL: db.version(" + db.version + ") does not db2.version(" + db2.version +")"); > > typo (that i had in my comment too :)): does not MATCH db2.version 151691 29 ddkilzer 2009-10-01 14:08:42 -0700 (In reply to comment #27) > (From update of attachment 40445 [details]) > > Index: WebCore/storage/Database.cpp > > =================================================================== > > --- WebCore/storage/Database.cpp (revision 48292) > > +++ WebCore/storage/Database.cpp (working copy) > > @@ -89,6 +89,18 @@ static GuidVersionMap& guidToVersionMap( > > return map; > > } > > > > +static inline void updateGuidVersionMap(int guid, String newVersion) > > +{ > > + // Note: It is not safe to put an empty string into the guidToVersionMap() map. > > + // That's because the map is cross-thread, but empty strings are per-thread. > > + // The copy() function makes a version of the string you can use on the current > > + // thread, but we need a string we can keep in a cross-thread data structure. > > + // FIXME: This is a quite-awkward restriction to have to program with. > > + > > + // NOTE: Caller must lock guidMutex(). > > optional: might be a good idea to make this a function-level comment (ie. put > it right before 'static inline void ...'). I prefer the comment inside the method as it is above. Putting it outside the method makes it harder to visually parse the file when looking for the method name (IMO). Reviewing the new patch now. 151696 30 40445 ddkilzer 2009-10-01 14:20:41 -0700 Comment on attachment 40445 Revised patch. > Index: WebCore/ChangeLog > [...] > + * bindings/v8/custom/V8DatabaseCustom.cpp: > + (WebCore::CALLBACK_FUNC_DECL): implement the V8 binding for database.changeVersion > + (WebCore::createTransaction): Fix a bug that was checking the wrong argument index to save the success callback Would be nice if these comments both started with capital letters and ended with periods (like the ones below). > + * storage/Database.cpp: > + (WebCore::updateGuidVersionMap): Safely update the Guid/version hash map. > + (WebCore::Database::~Database): Remove code that removes the database from the guid->database and guid->version maps. > + (WebCore::Database::setVersionInDatabase): Add a comment to explain some behaviour. > + (WebCore::Database::close): Move the code that updates the maps from the destructor to here. > + (WebCore::Database::performOpenAndVerify): Call updateGuidVersionMap instead of setting the hash map directly. > + (WebCore::Database::setExpectedVersion): Update the in memory guid->version map when we want to update the database version. > Index: WebCore/storage/Database.cpp > [...] > +static inline void updateGuidVersionMap(int guid, String newVersion) > +{ > + // Note: It is not safe to put an empty string into the guidToVersionMap() map. > + // That's because the map is cross-thread, but empty strings are per-thread. > + // The copy() function makes a version of the string you can use on the current > + // thread, but we need a string we can keep in a cross-thread data structure. > + // FIXME: This is a quite-awkward restriction to have to program with. > + > + // NOTE: Caller must lock guidMutex(). Oops, I see what Dumi meant. This one-line comment could go above the 'static inline' method declaration. It would be nice to add this comment above the code (in case someone skips over the large block above): // Map null string to empty string (see comment above). > + guidToVersionMap().set(guid, newVersion.isEmpty() ? String() : newVersion.copy()); > +} > bool Database::setVersionInDatabase(const String& version) > { > + // The INSERT will replace an existing entry for the database with the new version number, due to the UNIQUE ON CONFLICT REPLACE > + // clause in the CREATE statement (see Database::performOpenAndVerify) This comment needs a period. Would be nice to add "()" after "performOpenAndVerify" so you know you're looking for a method. > @@ -447,12 +461,6 @@ bool Database::performOpenAndVerify(Exce > { > MutexLocker locker(guidMutex()); > > - // Note: It is not safe to put an empty string into the guidToVersionMap() map. > - // That's because the map is cross-thread, but empty strings are per-thread. > - // The copy() function makes a version of the string you can use on the current > - // thread, but we need a string we can keep in a cross-thread data structure. > - // FIXME: This is a quite-awkward restriction to have to program with. > - > GuidVersionMap::iterator entry = guidToVersionMap().find(m_guid); > if (entry != guidToVersionMap().end()) { > // Map null string to empty string (see comment above). This comment needs to change since you moved the big comment: // Map null string to empty string (see updateGuidVersionMap()). r=me with the above changes. 151812 31 benm 2009-10-02 03:36:27 -0700 Landed as r49018. 33778 2009-07-30 07:50:25 -0700 2009-07-30 07:50:25 -0700 Script that demonstrates incorrect caching of database version sql.html text/html 910 mbolohan PGh0bWw+CjxzY3JpcHQ+CgovLyBXZWJraXQgcjQ2NTA3Cgp2YXIgZGI7CnZhciB2ZXJzaW9uID0g JzInOwoKZnVuY3Rpb24gZW1wdHlGdW5jdGlvbigpIHt9CgpmdW5jdGlvbiBjaGFuZ2VWZXJzaW9u KHR4KSB7CiAgdHguZXhlY3V0ZVNxbCgnZHJvcCB0YWJsZSBpZiBleGlzdHMgaW5mbzsnLCBbXSwg ZW1wdHlGdW5jdGlvbiwgZW1wdHlGdW5jdGlvbik7CiAgdHguZXhlY3V0ZVNxbCgnY3JlYXRlIHRh YmxlIGlmIG5vdCBleGlzdHMgaW5mbyAodmVyc2lvbiBJTlRFR0VSKTsnLFtdLCBlbXB0eUZ1bmN0 aW9uLCBlbXB0eUZ1bmN0aW9uKTsKICB0eC5leGVjdXRlU3FsKCdpbnNlcnQgaW50byBpbmZvIHZh bHVlcyg/KTsnLCBbdmVyc2lvbl0sIGVtcHR5RnVuY3Rpb24sIGVtcHR5RnVuY3Rpb24pOwp9Cgpm dW5jdGlvbiBjaGFuZ2VWZXJzaW9uX3N1Y2Nlc3MoKSB7CiAgd2luZG93LmFsZXJ0KCdTdWNjZXNz ZnVsbHkgY2hhbmdlZCB2ZXJzaW9uIGZyb20gJyArIGRiLnZlcnNpb24gKyAnIHRvICcgKyB2ZXJz aW9uICsgJy4gUmVsb2FkaW5nLicpOwogIHdpbmRvdy5sb2NhdGlvbi5yZWxvYWQoKTsKfQoKZnVu Y3Rpb24gY2hhbmdlVmVyc2lvbl9lcnJvcihlcnJvcikgewogIHdpbmRvdy5hbGVydCgnRXJyb3I6 ICcgKyBlcnJvci5tZXNzYWdlKTsKfQoKZGIgPSB3aW5kb3cub3BlbkRhdGFiYXNlKCdkYicsICcn LCAnZGInLCAxMDAwMCk7CgppZiAoZGIudmVyc2lvbiAhPSB2ZXJzaW9uKSB7CiAgZGIuY2hhbmdl VmVyc2lvbihkYi52ZXJzaW9uLCB2ZXJzaW9uLCBjaGFuZ2VWZXJzaW9uLCBjaGFuZ2VWZXJzaW9u X2Vycm9yLCBjaGFuZ2VWZXJzaW9uX3N1Y2Nlc3MpOwp9IGVsc2UgewogIHdpbmRvdy5hbGVydCgn U3VjY2VzcyB3aXRoIHZlcnNpb24gJyArIHZlcnNpb24pOwp9Cgo8L3NjcmlwdD4KPC9odG1sPg== 39150 2009-09-07 09:05:28 -0700 2009-09-11 06:44:32 -0700 Proposed patch with layout test. 27836.txt text/plain 9837 benm SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0ODExNykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTkgQEAKKzIwMDktMDktMDcgIEJlbiBNdXJkb2NoICA8YmVubUBnb29nbGUuY29t PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN0YWxl IGRhdGFiYXNlIHZlcnNpb24gcGVyc2lzdHMgdGhyb3VnaCBicm93c2VyIHJlZnJlc2ggKGNoYW5n ZVZlcnNpb24gZG9lc24ndCB3b3JrKQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9Mjc4MzYKKworICAgICAgICBUZXN0OiBzdG9yYWdlL2NoYW5nZS12ZXJz aW9uLmh0bWwKKworICAgICAgICAqIGJpbmRpbmdzL3Y4L2N1c3RvbS9WOERhdGFiYXNlQ3VzdG9t LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNBTExCQUNLX0ZVTkNfREVDTCk6IEltcGxlbWVudCB0 aGUgVjggYmluZGluZyBmb3IgZGF0YWJhc2UuY2hhbmdlVmVyc2lvbgorICAgICAgICAqIHN0b3Jh Z2UvRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6On5EYXRhYmFzZSk6 IFJlbW92ZSBjb2RlIHRoYXQgcmVtb3ZlcyB0aGUgZGF0YWJhc2UgZnJvbSB0aGUgZ3VpZC0+ZGF0 YWJhc2UgYW5kIGd1aWQtPnZlcnNpb24gbWFwcy4KKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNl OjpjbG9zZSk6IE1vdmUgdGhlIGNvZGUgdGhhdCB1cGRhdGVzIHRoZSBtYXBzIGZyb20gdGhlIGRl c3RydWN0b3IgdG8gaGVyZS4KKyAgICAgICAgKFdlYkNvcmU6OkRhdGFiYXNlOjpzZXRFeHBlY3Rl ZFZlcnNpb24pOiBVcGRhdGUgdGhlIGluIG1lbW9yeSBndWlkLT52ZXJzaW9uIG1hcCB3aGVuIHdl IHdhbnQgdG8gdXBkYXRlIHRoZSBkYXRhYmFzZSB2ZXJzaW9uLgorCiAyMDA5LTA5LTA3ICBNYWRz IEFnZXIgIDxhZ2VyQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJh cnRoLgpJbmRleDogV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhEYXRhYmFzZUN1c3RvbS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhEYXRhYmFzZUN1 c3RvbS5jcHAJKHJldmlzaW9uIDQ4MDE2KQorKysgV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20v VjhEYXRhYmFzZUN1c3RvbS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ1LDYgKzQ1LDQ1IEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKIENBTExCQUNLX0ZVTkNfREVDTChEYXRhYmFzZUNoYW5nZVZlcnNp b24pCiB7CiAgICAgSU5DX1NUQVRTKCJET00uRGF0YWJhc2UuY2hhbmdlVmVyc2lvbigpIik7CisK KyAgICBpZiAoYXJncy5MZW5ndGgoKSA8IDIpCisgICAgICAgIHJldHVybiB0aHJvd0Vycm9yKCJU aGUgb2xkIGFuZCBuZXcgdmVyc2lvbiBzdHJpbmdzIGFyZSByZXF1aXJlZC4iLCBWOFByb3h5OjpT eW50YXhFcnJvcik7CisKKyAgICBpZiAoIShhcmdzWzBdLT5Jc1N0cmluZygpICYmIGFyZ3NbMV0t PklzU3RyaW5nKCkpKQorICAgICAgICByZXR1cm4gdGhyb3dFcnJvcigiVGhlIG9sZCBhbmQgbmV3 IHZlcnNpb25zIG11c3QgYmUgc3RyaW5ncy4iKTsKKworICAgIERhdGFiYXNlKiBkYXRhYmFzZSA9 IFY4RE9NV3JhcHBlcjo6Y29udmVydFRvTmF0aXZlT2JqZWN0PERhdGFiYXNlPihWOENsYXNzSW5k ZXg6OkRBVEFCQVNFLCBhcmdzLkhvbGRlcigpKTsKKworICAgIEZyYW1lKiBmcmFtZSA9IFY4UHJv eHk6OnJldHJpZXZlRnJhbWVGb3JDdXJyZW50Q29udGV4dCgpOworICAgIGlmICghZnJhbWUpCisg ICAgICAgIHJldHVybiB2ODo6VW5kZWZpbmVkKCk7CisKKyAgICBSZWZQdHI8VjhDdXN0b21TUUxU cmFuc2FjdGlvbkNhbGxiYWNrPiBjYWxsYmFjazsKKyAgICBpZiAoYXJncy5MZW5ndGgoKSA+IDIp IHsKKyAgICAgICAgaWYgKCFhcmdzWzJdLT5Jc09iamVjdCgpKQorICAgICAgICAgICAgcmV0dXJu IHRocm93RXJyb3IoImNoYW5nZVZlcnNpb24gdHJhbnNhY3Rpb24gY2FsbGJhY2sgbXVzdCBiZSBv ZiB2YWxpZCB0eXBlLiIpOworCisgICAgICAgIGNhbGxiYWNrID0gVjhDdXN0b21TUUxUcmFuc2Fj dGlvbkNhbGxiYWNrOjpjcmVhdGUoYXJnc1syXSwgZnJhbWUpOworICAgIH0KKworICAgIFJlZlB0 cjxWOEN1c3RvbVNRTFRyYW5zYWN0aW9uRXJyb3JDYWxsYmFjaz4gZXJyb3JDYWxsYmFjazsKKyAg ICBpZiAoYXJncy5MZW5ndGgoKSA+IDMpIHsKKyAgICAgICAgaWYgKCFhcmdzWzNdLT5Jc09iamVj dCgpKQorICAgICAgICAgICAgcmV0dXJuIHRocm93RXJyb3IoImNoYW5nZVZlcnNpb24gZXJyb3Ig Y2FsbGJhY2sgbXVzdCBiZSBvZiB2YWxpZCB0eXBlLiIpOworCisgICAgICAgIGVycm9yQ2FsbGJh Y2sgPSBWOEN1c3RvbVNRTFRyYW5zYWN0aW9uRXJyb3JDYWxsYmFjazo6Y3JlYXRlKGFyZ3NbM10s IGZyYW1lKTsKKyAgICB9CisKKyAgICBSZWZQdHI8VjhDdXN0b21Wb2lkQ2FsbGJhY2s+IHN1Y2Nl c3NDYWxsYmFjazsKKyAgICBpZiAoYXJncy5MZW5ndGgoKSA+IDQpIHsKKyAgICAgICAgaWYgKCFh cmdzWzRdLT5Jc09iamVjdCgpKQorICAgICAgICAgICAgcmV0dXJuIHRocm93RXJyb3IoImNoYW5n ZVZlcnNpb24gc3VjY2VzcyBjYWxsYmFjayBtdXN0IGJlIG9mIHZhbGlkIHR5cGUuIik7CisKKyAg ICAgICAgc3VjY2Vzc0NhbGxiYWNrID0gVjhDdXN0b21Wb2lkQ2FsbGJhY2s6OmNyZWF0ZShhcmdz WzRdLCBmcmFtZSk7CisgICAgfQorCisgICAgZGF0YWJhc2UtPmNoYW5nZVZlcnNpb24odG9XZWJD b3JlU3RyaW5nKGFyZ3NbMF0pLCB0b1dlYkNvcmVTdHJpbmcoYXJnc1sxXSksIGNhbGxiYWNrLnJl bGVhc2UoKSwgZXJyb3JDYWxsYmFjay5yZWxlYXNlKCksIHN1Y2Nlc3NDYWxsYmFjay5yZWxlYXNl KCkpOworCiAgICAgcmV0dXJuIHY4OjpVbmRlZmluZWQoKTsKIH0KIApAQCAtNzYsNyArMTE1LDcg QEAgQ0FMTEJBQ0tfRlVOQ19ERUNMKERhdGFiYXNlVHJhbnNhY3Rpb24pCiAKICAgICBSZWZQdHI8 VjhDdXN0b21Wb2lkQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjazsKICAgICBpZiAoYXJncy5MZW5n dGgoKSA+IDIpIHsKLSAgICAgICAgaWYgKCFhcmdzWzFdLT5Jc09iamVjdCgpKQorICAgICAgICBp ZiAoIWFyZ3NbMl0tPklzT2JqZWN0KCkpCiAgICAgICAgICAgICByZXR1cm4gdGhyb3dFcnJvcigi VHJhbnNhY3Rpb24gc3VjY2VzcyBjYWxsYmFjayBtdXN0IGJlIG9mIHZhbGlkIHR5cGUuIik7CiAK ICAgICAgICAgc3VjY2Vzc0NhbGxiYWNrID0gVjhDdXN0b21Wb2lkQ2FsbGJhY2s6OmNyZWF0ZShh cmdzWzJdLCBmcmFtZSk7CkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5jcHAJKHJldmlzaW9uIDQ4MDE2KQor KysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTc1LDIw ICsxNzUsNiBAQCBEYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1lbnQqIGRvY3VtZW50LCBjCiAKIERh dGFiYXNlOjp+RGF0YWJhc2UoKQogewotICAgIHsKLSAgICAgICAgTXV0ZXhMb2NrZXIgbG9ja2Vy KGd1aWRNdXRleCgpKTsKLQotICAgICAgICBIYXNoU2V0PERhdGFiYXNlKj4qIGhhc2hTZXQgPSBn dWlkVG9EYXRhYmFzZU1hcCgpLmdldChtX2d1aWQpOwotICAgICAgICBBU1NFUlQoaGFzaFNldCk7 Ci0gICAgICAgIEFTU0VSVChoYXNoU2V0LT5jb250YWlucyh0aGlzKSk7Ci0gICAgICAgIGhhc2hT ZXQtPnJlbW92ZSh0aGlzKTsKLSAgICAgICAgaWYgKGhhc2hTZXQtPmlzRW1wdHkoKSkgewotICAg ICAgICAgICAgZ3VpZFRvRGF0YWJhc2VNYXAoKS5yZW1vdmUobV9ndWlkKTsKLSAgICAgICAgICAg IGRlbGV0ZSBoYXNoU2V0OwotICAgICAgICAgICAgZ3VpZFRvVmVyc2lvbk1hcCgpLnJlbW92ZSht X2d1aWQpOwotICAgICAgICB9Ci0gICAgfQotCiAgICAgaWYgKG1fZG9jdW1lbnQtPmRhdGFiYXNl VGhyZWFkKCkpCiAgICAgICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnVuc2NoZWR1 bGVEYXRhYmFzZVRhc2tzKHRoaXMpOwogCkBAIC0zMjgsNiArMzE0LDIwIEBAIHZvaWQgRGF0YWJh c2U6OmNsb3NlKCkKICAgICAgICAgbV9zcWxpdGVEYXRhYmFzZS5jbG9zZSgpOwogICAgICAgICBt X2RvY3VtZW50LT5kYXRhYmFzZVRocmVhZCgpLT5yZWNvcmREYXRhYmFzZUNsb3NlZCh0aGlzKTsK ICAgICAgICAgbV9vcGVuZWQgPSBmYWxzZTsKKworICAgICAgICB7CisgICAgICAgICAgICBNdXRl eExvY2tlciBsb2NrZXIoZ3VpZE11dGV4KCkpOworCisgICAgICAgICAgICBIYXNoU2V0PERhdGFi YXNlKj4qIGhhc2hTZXQgPSBndWlkVG9EYXRhYmFzZU1hcCgpLmdldChtX2d1aWQpOworICAgICAg ICAgICAgQVNTRVJUKGhhc2hTZXQpOworICAgICAgICAgICAgQVNTRVJUKGhhc2hTZXQtPmNvbnRh aW5zKHRoaXMpKTsKKyAgICAgICAgICAgIGhhc2hTZXQtPnJlbW92ZSh0aGlzKTsKKyAgICAgICAg ICAgIGlmIChoYXNoU2V0LT5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAgICAgICBndWlkVG9EYXRh YmFzZU1hcCgpLnJlbW92ZShtX2d1aWQpOworICAgICAgICAgICAgICAgIGRlbGV0ZSBoYXNoU2V0 OworICAgICAgICAgICAgICAgIGd1aWRUb1ZlcnNpb25NYXAoKS5yZW1vdmUobV9ndWlkKTsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgfQogICAgIH0KIH0KIApAQCAtNjMxLDYgKzYzMSw5IEBAIFZl Y3RvcjxTdHJpbmc+IERhdGFiYXNlOjp0YWJsZU5hbWVzKCkKIHZvaWQgRGF0YWJhc2U6OnNldEV4 cGVjdGVkVmVyc2lvbihjb25zdCBTdHJpbmcmIHZlcnNpb24pCiB7CiAgICAgbV9leHBlY3RlZFZl cnNpb24gPSB2ZXJzaW9uLmNvcHkoKTsKKyAgICAvLyBVcGRhdGUgdGhlIGluIG1lbW9yeSBkYXRh YmFzZSB2ZXJzaW9uIG1hcC4KKyAgICBNdXRleExvY2tlciBsb2NrZXIoZ3VpZE11dGV4KCkpOwor ICAgIGd1aWRUb1ZlcnNpb25NYXAoKS5zZXQobV9ndWlkLCB2ZXJzaW9uKTsKIH0KIAogUGFzc1Jl ZlB0cjxTZWN1cml0eU9yaWdpbj4gRGF0YWJhc2U6OnNlY3VyaXR5T3JpZ2luQ29weSgpIGNvbnN0 CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCShyZXZpc2lvbiA0ODExNykKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29y a2luZyBjb3B5KQpAQCAtMSwzICsxLDEzIEBACisyMDA5LTA5LTA3ICBCZW4gTXVyZG9jaCAgPGJl bm1AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjc4MzYKKyAg ICAgICAgVGVzdCB0byBlbnN1cmUgdGhhdCB0aGUgZGF0YWJhc2UuY2hhbmdlVmVyc2lvbiBmdW5j dGlvbiB3b3JrcyBhcyBleHBlY3RlZC4KKworICAgICAgICAqIHN0b3JhZ2UvY2hhbmdlLXZlcnNp b24tZXhwZWN0ZWQudHh0OiBBZGRlZCB3aXRoIHByb3BlcnR5IHN2bjplb2wtc3R5bGUuCisgICAg ICAgICogc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi5odG1sOiBBZGRlZCB3aXRoIHByb3BlcnR5IHN2 bjplb2wtc3R5bGUuCisKIDIwMDktMDktMDcgQW5kcmFzIEJlY3NpIDxiZWNzaS5hbmRyYXNAc3R1 ZC51LXN6ZWdlZC5odT4KIAogICAgICAgICBSZXZpZXdlZCBieSBUb3IgQXJuZSBWZXN0YsO4Cklu ZGV4OiBMYXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLWV4cGVjdGVkLnR4dAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLWV4cGVjdGVkLnR4 dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3N0b3JhZ2UvY2hhbmdlLXZlcnNpb24tZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQgQEAKK1RoaXMgdGVzdCB2ZXJpZmll cyB0aGF0IHRoZSBkYXRhYmFzZS5jaGFuZ2VWZXJzaW9uIGZ1bmN0aW9uIHdvcmtzIGFzIGV4cGVj dGVkLgorRmluaXNoZWQgdGVzdHMgd2l0aCB2ZXJzaW9uIDMKK1RFU1QgQ09NUExFVEUKKwoKUHJv cGVydHkgY2hhbmdlcyBvbjogTGF5b3V0VGVzdHMvc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi1leHBl Y3RlZC50eHQKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpBZGRlZDogc3ZuOmVvbC1zdHlsZQogICArIG5hdGl2ZQoKSW5k ZXg6IExheW91dFRlc3RzL3N0b3JhZ2UvY2hhbmdlLXZlcnNpb24uaHRtbAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLmh0bWwJKHJldmlzaW9uIDApCisr KyBMYXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLmh0bWwJKHJldmlzaW9uIDApCkBA IC0wLDAgKzEsODkgQEAKKzxodG1sPiAKKzxoZWFkPgorPHRpdGxlPlRlc3QgZGF0YWJhc2UuY2hh bmdlVmVyc2lvbjwvdGl0bGU+Cis8c2NyaXB0PiAKK3ZhciBkYjsKK3ZhciBFWFBFQ1RFRF9WRVJT SU9OX0FGVEVSX0hJWElFX1RFU1QgPSAnMic7Cit2YXIgRVhQRUNURURfVkVSU0lPTl9BRlRFUl9S RUxPQUQgPSAnMyc7CisgCitmdW5jdGlvbiBlbXB0eUZ1bmN0aW9uKCkgeyB9CisgCitmdW5jdGlv biBjaGFuZ2VWZXJzaW9uQ2FsbGJhY2sodHgpCit7CisgICAgdHguZXhlY3V0ZVNxbCgnZHJvcCB0 YWJsZSBpZiBleGlzdHMgaW5mbzsnLCBbXSwgZW1wdHlGdW5jdGlvbiwgZW1wdHlGdW5jdGlvbik7 CisgICAgdHguZXhlY3V0ZVNxbCgnY3JlYXRlIHRhYmxlIGlmIG5vdCBleGlzdHMgaW5mbyAodmVy c2lvbiBJTlRFR0VSKTsnLFtdLCBlbXB0eUZ1bmN0aW9uLCBlbXB0eUZ1bmN0aW9uKTsKKyAgICB0 eC5leGVjdXRlU3FsKCdpbnNlcnQgaW50byBpbmZvIHZhbHVlcyg/KTsnLCBbRVhQRUNURURfVkVS U0lPTl9BRlRFUl9SRUxPQURdLCBlbXB0eUZ1bmN0aW9uLCBlbXB0eUZ1bmN0aW9uKTsKK30KKyAK K2Z1bmN0aW9uIGNoYW5nZVZlcnNpb25TdWNjZXNzKCkKK3sKKyAgICBsb2coJ1N1Y2Nlc3NmdWxs eSBjaGFuZ2VkIHZlcnNpb24gdG8gJyArIGRiLnZlcnNpb24gKyAnLiBSZWxvYWRpbmcuJyk7Cisg ICAgd2luZG93LmxvY2F0aW9uLmhyZWYgPSB3aW5kb3cubG9jYXRpb24gKyAnPzInOworfQorIAor ZnVuY3Rpb24gY2hhbmdlVmVyc2lvbkVycm9yKGVycm9yKQoreworICAgIGxvZygnRXJyb3I6ICcg KyBlcnJvci5tZXNzYWdlKTsKKyAgICBmaW5pc2hUZXN0KCk7Cit9CisKK2Z1bmN0aW9uIGZpbmlz aFRlc3QoKQoreworICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAg IGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICBsb2coIlRFU1QgQ09NUExF VEUiKTsKK30KKworZnVuY3Rpb24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoImNvbnNvbGUiKS5pbm5lclRleHQgKz0gbWVzc2FnZSArICJcbiI7Cit9CisKK2Z1 bmN0aW9uIHJ1blRlc3QoKQoreworICAgIGlmICh3aW5kb3cubG9jYXRpb24uc2VhcmNoID09ICI/ MiIpIHsKKyAgICAgICAgZGIgPSB3aW5kb3cub3BlbkRhdGFiYXNlKCdjaGFuZ2V2ZXJzaW9uLXRl c3QnLCAnJywgJ1Rlc3QgZm9yIHRoZSBkYXRhYmFzZS5jaGFuZ2VWZXJzaW9uKCkgZnVuY3Rpb24n LCAxMDI0KTsKKyAgICAgICAgbG9nKCdGaW5pc2hlZCB0ZXN0cyB3aXRoIHZlcnNpb24gJyArIGRi LnZlcnNpb24pOworICAgICAgICBmaW5pc2hUZXN0KCk7CisgICAgfSBlbHNlIHsKKyAgICAgICAg dGVzdFBhcnQxKCk7CisgICAgfQorfQorCitmdW5jdGlvbiB0ZXN0UGFydDEoKSB7CisgICAgaWYg KHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJv bGxlci5jbGVhckFsbERhdGFiYXNlcygpOworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5k dW1wQXNUZXh0KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUo KTsKKyAgICB9CisgICAgCisgICAgZGIgPSB3aW5kb3cub3BlbkRhdGFiYXNlKCdjaGFuZ2V2ZXJz aW9uLXRlc3QnLCAnJywgJ1Rlc3QgZm9yIHRoZSBkYXRhYmFzZS5jaGFuZ2VWZXJzaW9uKCkgZnVu Y3Rpb24nLCAxMDI0KTsKKworICAgIGlmIChkYi52ZXJzaW9uICE9IEVYUEVDVEVEX1ZFUlNJT05f QUZURVJfUkVMT0FEKSB7CisgICAgICAgIC8vIEZpcnN0IHJ1biBIaXhpZSdzIHRlc3QgdG8gZW5z dXJlIGJhc2ljIGNoYW5nZVZlcnNpb24gZnVuY3Rpb25hbGl0eSB3b3JrcyAoc2VlIGJ1ZyAyODQx OCkuCisgICAgICAgIGRiLmNoYW5nZVZlcnNpb24oJycsIEVYUEVDVEVEX1ZFUlNJT05fQUZURVJf SElYSUVfVEVTVCwgZW1wdHlGdW5jdGlvbiwgZnVuY3Rpb24gKGUpIHsKKyAgICAgICAgICAgIGxv ZygnRkFJTCBpbiBjaGFuZ2VWZXJzaW9uOicgKyBlKTsKKyAgICAgICAgICAgIGZpbmlzaFRlc3Qo KTsKKyAgICAgICAgfSwgZnVuY3Rpb24gKCkgeworICAgICAgICAgICAgdHJ5IHsKKyAgICAgICAg ICAgICAgICB2YXIgZGIyID0gb3BlbkRhdGFiYXNlKCdjaGFuZ2UtdmVyc2lvbi10ZXN0JywgRVhQ RUNURURfVkVSU0lPTl9BRlRFUl9ISVhJRV9URVNULCAnJywgMCk7CisgICAgICAgICAgICB9IGNh dGNoIChlKSB7CisgICAgICAgICAgICAgICAgbG9nKCdGQUlMIGluIG9wZW5EYXRhYmFzZTogJyAr IGUpOworICAgICAgICAgICAgICAgIGZpbmlzaFRlc3QoKTsKKyAgICAgICAgICAgIH0KKyAgICAg ICAgICAgIC8vIEZvbGxvd2luZyB2ZXJzaW9ucyBzaG91bGQgbWF0Y2guCisgICAgICAgICAgICBs b2coJ0RhdGFiYXNlIHZlcnNpb246ICcgKyBkYi52ZXJzaW9uKTsKKyAgICAgICAgICAgIGxvZygn U2Vjb25kIGRhdGFiYXNlIHZlcnNpb246ICcgKyBkYjIudmVyc2lvbik7CisKKyAgICAgICAgICAg IC8vIE5vdyB0cnkgYSB0ZXN0IHRvIGVuc3VyZSB0aGUgdmVyc2lvbiBwZXJzaXN0cyBhZnRlciBy ZWxvYWRpbmcgKHNlZSBidWcgMjc4MzYpCisgICAgICAgICAgICBkYi5jaGFuZ2VWZXJzaW9uKEVY UEVDVEVEX1ZFUlNJT05fQUZURVJfSElYSUVfVEVTVCwgRVhQRUNURURfVkVSU0lPTl9BRlRFUl9S RUxPQUQsIGNoYW5nZVZlcnNpb25DYWxsYmFjaywgY2hhbmdlVmVyc2lvbkVycm9yLCBjaGFuZ2VW ZXJzaW9uU3VjY2Vzcyk7CisgICAgICAgIH0pOworICAgIH0KK30KKzwvc2NyaXB0PgorPC9oZWFk PgorPGJvZHkgb25sb2FkPSJydW5UZXN0KCk7Ij4KK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRo ZSBkYXRhYmFzZS5jaGFuZ2VWZXJzaW9uIGZ1bmN0aW9uIHdvcmtzIGFzIGV4cGVjdGVkLgorPHBy ZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8L2JvZHk+Cis8L2h0bWw+CgpQcm9wZXJ0eSBjaGFuZ2Vz IG9uOiBMYXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLmh0bWwKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpB ZGRlZDogc3ZuOmVvbC1zdHlsZQogICArIG5hdGl2ZQoK 39154 2009-09-07 10:18:40 -0700 2009-09-07 10:18:40 -0700 another test change-version.html text/html 1692 ap PGh0bWw+CjxoZWFkPgo8c2NyaXB0PgpmdW5jdGlvbiBsb2cobWVzc2FnZSkgewogICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdCIpLmlubmVyVGV4dCArPSBtZXNzYWdlICsgIlxuIjsK fQoKZnVuY3Rpb24gcnVuVGVzdCgpIHsKICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpIAogICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKCiAgICBkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0IikuaW5uZXJUZXh0ID0gIiI7CgogICAgdHJ5IHsK ICAgICAgICBkYiA9IG9wZW5EYXRhYmFzZSgnQ2hhbmdlVmVyc2lvbicsICcnLCAnVGVzdCB0aGF0 IGNoYW5naW5nIGEgZGF0YWJhc2UgdmVyc2lvbiBkb2VzblwndCBraWxsIG91ciBoYW5kbGUgdG8g aXQnLCAxKTsKICAgICAgICB2YXIgdmVyc2lvbiA9IGRiLnZlcnNpb247CiAgICAgICAgdmFyIG5l d1ZlcnNpb24gPSB2ZXJzaW9uID8gKHBhcnNlSW50KHZlcnNpb24pICsgMSkudG9TdHJpbmcoKSA6 ICIxIjsgCiAgICAgICAgZGIuY2hhbmdlVmVyc2lvbih2ZXJzaW9uLCBuZXdWZXJzaW9uLCBmdW5j dGlvbih0eCkgewogICAgICAgICAgICBsb2coImNoYW5nZVZlcnNpb246IHRyYW5zYWN0aW9uIGNh bGxiYWNrIik7CiAgICAgICAgfSwgZnVuY3Rpb24oZXJyb3IpIHsKICAgICAgICAgICAgbG9nKCJj aGFuZ2VWZXJzaW9uOiBlcnJvciBjYWxsYmFjazogIiArIGVycm9yLm1lc3NhZ2UpOwogICAgICAg IH0sIGZ1bmN0aW9uKCkgewogICAgICAgICAgICBsb2coImNoYW5nZVZlcnNpb246IHN1Y2Nlc3Mg Y2FsbGJhY2siKTsKICAgICAgICB9KTsKICAgICAgICAKICAgICAgICBzZXRUaW1lb3V0KHJ1blRl c3QyLCAxMDAwKTsKICAgICAgICAKICAgIH0gY2F0Y2ggKGUpIHsKICAgICAgICBsb2coImNoYW5n ZVZlcnNpb24gZXhjZXB0aW9uOiAiICsgZSk7CiAgICB9Cn0KCmZ1bmN0aW9uIHJ1blRlc3QyKCkg ewogICAgdHJ5IHsKICAgICAgICBkYi50cmFuc2FjdGlvbihmdW5jdGlvbih0eCkgewogICAgICAg ICAgICB0eC5leGVjdXRlU3FsKCJTRUxFQ1QgKiBmcm9tIEZvb0JhciIsIFtdLCBmdW5jdGlvbih0 eCkgewogICAgICAgICAgICAgICAgbG9nKCJ0cmFuc2FjdGlvbjogc3RhdGVtZW50IGNhbGxiYWNr Iik7CiAgICAgICAgICAgIH0sIGZ1bmN0aW9uKHR4LCBlcnJvcikgewogICAgICAgICAgICAgICAg bG9nKCJ0cmFuc2FjdGlvbjogc3RhdGVtZW50IGVycm9yIGNhbGxiYWNrOiAiICsgZXJyb3IubWVz c2FnZSk7CiAgICAgICAgICAgIH0pOwogICAgICAgIH0pOwogICAgfSBjYXRjaCAoZSkgewogICAg ICAgIGxvZygidHJhbnNhY3Rpb24gZXhjZXB0aW9uOiAiICsgZSk7CiAgICB9Cn0KPC9zY3JpcHQ+ CjwvaGVhZD4KPGJvZHkgb25sb2FkPSJydW5UZXN0KCkiPgo8ZGl2PlRoaXMgdGVzdHMgdGhhdCBh IGRhdGFiYXNlIGNhbiBiZSBhY2Nlc3NlZCBhZnRlciBjaGFuZ2luZyBpdHMgdmVyc2lvbi4gWW91 IHNob3VsZCBzZWUgYW4gZXJyb3IgYWJvdXQgRm9vQmFyIHRhYmxlIGJlbG93LCBub3QgYWJvdXQg bWlzbWF0Y2hpbmcgdmVyc2lvbnMuIEFsc28sIHJlbG9hZGluZyB0aGUgcGFnZSBzaG91bGQgbm90 IGNhdXNlIGFuIGFzc2VydGlvbiBmYWlsdXJlLgo8cHJlIGlkPSJyZXN1bHQiPgpGQUlMVVJFOiB0 ZXN0IGRpZG4ndCBydW4uCjwvcHJlPgo8L2JvZHk+CjwvaHRtbD4K 39426 2009-09-11 06:44:32 -0700 2009-10-01 08:36:19 -0700 Patch incorporating Alexey's test 27836-1.txt text/plain 13480 benm SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0ODI5OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjEgQEAKKzIwMDktMDktMTEgIEJlbiBNdXJkb2NoICA8YmVubUBnb29nbGUuY29t PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN0YWxl IGRhdGFiYXNlIHZlcnNpb24gcGVyc2lzdHMgdGhyb3VnaCBicm93c2VyIHJlZnJlc2ggKGNoYW5n ZVZlcnNpb24gZG9lc24ndCB3b3JrKQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9Mjc4MzYKKworICAgICAgICBUZXN0czogc3RvcmFnZS9jaGFuZ2UtdmVy c2lvbi1oYW5kbGUtcmV1c2UuaHRtbAorICAgICAgICAgICAgICAgc3RvcmFnZS9jaGFuZ2UtdmVy c2lvbi5odG1sCisKKyAgICAgICAgKiBiaW5kaW5ncy92OC9jdXN0b20vVjhEYXRhYmFzZUN1c3Rv bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQUxMQkFDS19GVU5DX0RFQ0wpOiBJbXBsZW1lbnQg dGhlIFY4IGJpbmRpbmcgZm9yIGRhdGFiYXNlLmNoYW5nZVZlcnNpb24KKyAgICAgICAgKFdlYkNv cmU6OmNyZWF0ZVRyYW5zYWN0aW9uKTogRml4IGEgYnVnIHRoYXQgd2FzIGNoZWNraW5nIHRoZSB3 cm9uZyBhcmd1bWVudCBpbmRleCB0byBzYXZlIHRoZSBzdWNjZXNzIGNhbGxiYWNrCisgICAgICAg ICogc3RvcmFnZS9EYXRhYmFzZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6fkRh dGFiYXNlKTogUmVtb3ZlIGNvZGUgdGhhdCByZW1vdmVzIHRoZSBkYXRhYmFzZSBmcm9tIHRoZSBn dWlkLT5kYXRhYmFzZSBhbmQgZ3VpZC0+dmVyc2lvbiBtYXBzLgorICAgICAgICAoV2ViQ29yZTo6 RGF0YWJhc2U6OmNsb3NlKTogTW92ZSB0aGUgY29kZSB0aGF0IHVwZGF0ZXMgdGhlIG1hcHMgZnJv bSB0aGUgZGVzdHJ1Y3RvciB0byBoZXJlLgorICAgICAgICAoV2ViQ29yZTo6RGF0YWJhc2U6OnNl dEV4cGVjdGVkVmVyc2lvbik6IFVwZGF0ZSB0aGUgaW4gbWVtb3J5IGd1aWQtPnZlcnNpb24gbWFw IHdoZW4gd2Ugd2FudCB0byB1cGRhdGUgdGhlIGRhdGFiYXNlIHZlcnNpb24uCisKIDIwMDktMDkt MTEgIEFyaXlhIEhpZGF5YXQgIDxhcml5YS5oaWRheWF0QG5va2lhLmNvbT4KIAogICAgICAgICBS ZXZpZXdlZCBieSBTaW1vbiBIYXVzbWFubi4KSW5kZXg6IFdlYkNvcmUvYmluZGluZ3MvdjgvY3Vz dG9tL1Y4RGF0YWJhc2VDdXN0b20uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvYmluZGluZ3Mv djgvY3VzdG9tL1Y4RGF0YWJhc2VDdXN0b20uY3BwCShyZXZpc2lvbiA0ODI5MikKKysrIFdlYkNv cmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4RGF0YWJhc2VDdXN0b20uY3BwCSh3b3JraW5nIGNvcHkp CkBAIC00NSw2ICs0NSw0NSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBDQUxMQkFDS19GVU5DX0RF Q0woRGF0YWJhc2VDaGFuZ2VWZXJzaW9uKQogewogICAgIElOQ19TVEFUUygiRE9NLkRhdGFiYXNl LmNoYW5nZVZlcnNpb24oKSIpOworCisgICAgaWYgKGFyZ3MuTGVuZ3RoKCkgPCAyKQorICAgICAg ICByZXR1cm4gdGhyb3dFcnJvcigiVGhlIG9sZCBhbmQgbmV3IHZlcnNpb24gc3RyaW5ncyBhcmUg cmVxdWlyZWQuIiwgVjhQcm94eTo6U3ludGF4RXJyb3IpOworCisgICAgaWYgKCEoYXJnc1swXS0+ SXNTdHJpbmcoKSAmJiBhcmdzWzFdLT5Jc1N0cmluZygpKSkKKyAgICAgICAgcmV0dXJuIHRocm93 RXJyb3IoIlRoZSBvbGQgYW5kIG5ldyB2ZXJzaW9ucyBtdXN0IGJlIHN0cmluZ3MuIik7CisKKyAg ICBEYXRhYmFzZSogZGF0YWJhc2UgPSBWOERPTVdyYXBwZXI6OmNvbnZlcnRUb05hdGl2ZU9iamVj dDxEYXRhYmFzZT4oVjhDbGFzc0luZGV4OjpEQVRBQkFTRSwgYXJncy5Ib2xkZXIoKSk7CisKKyAg ICBGcmFtZSogZnJhbWUgPSBWOFByb3h5OjpyZXRyaWV2ZUZyYW1lRm9yQ3VycmVudENvbnRleHQo KTsKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICByZXR1cm4gdjg6OlVuZGVmaW5lZCgpOworCisg ICAgUmVmUHRyPFY4Q3VzdG9tU1FMVHJhbnNhY3Rpb25DYWxsYmFjaz4gY2FsbGJhY2s7CisgICAg aWYgKGFyZ3MuTGVuZ3RoKCkgPiAyKSB7CisgICAgICAgIGlmICghYXJnc1syXS0+SXNPYmplY3Qo KSkKKyAgICAgICAgICAgIHJldHVybiB0aHJvd0Vycm9yKCJjaGFuZ2VWZXJzaW9uIHRyYW5zYWN0 aW9uIGNhbGxiYWNrIG11c3QgYmUgb2YgdmFsaWQgdHlwZS4iKTsKKworICAgICAgICBjYWxsYmFj ayA9IFY4Q3VzdG9tU1FMVHJhbnNhY3Rpb25DYWxsYmFjazo6Y3JlYXRlKGFyZ3NbMl0sIGZyYW1l KTsKKyAgICB9CisKKyAgICBSZWZQdHI8VjhDdXN0b21TUUxUcmFuc2FjdGlvbkVycm9yQ2FsbGJh Y2s+IGVycm9yQ2FsbGJhY2s7CisgICAgaWYgKGFyZ3MuTGVuZ3RoKCkgPiAzKSB7CisgICAgICAg IGlmICghYXJnc1szXS0+SXNPYmplY3QoKSkKKyAgICAgICAgICAgIHJldHVybiB0aHJvd0Vycm9y KCJjaGFuZ2VWZXJzaW9uIGVycm9yIGNhbGxiYWNrIG11c3QgYmUgb2YgdmFsaWQgdHlwZS4iKTsK KworICAgICAgICBlcnJvckNhbGxiYWNrID0gVjhDdXN0b21TUUxUcmFuc2FjdGlvbkVycm9yQ2Fs bGJhY2s6OmNyZWF0ZShhcmdzWzNdLCBmcmFtZSk7CisgICAgfQorCisgICAgUmVmUHRyPFY4Q3Vz dG9tVm9pZENhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2s7CisgICAgaWYgKGFyZ3MuTGVuZ3RoKCkg PiA0KSB7CisgICAgICAgIGlmICghYXJnc1s0XS0+SXNPYmplY3QoKSkKKyAgICAgICAgICAgIHJl dHVybiB0aHJvd0Vycm9yKCJjaGFuZ2VWZXJzaW9uIHN1Y2Nlc3MgY2FsbGJhY2sgbXVzdCBiZSBv ZiB2YWxpZCB0eXBlLiIpOworCisgICAgICAgIHN1Y2Nlc3NDYWxsYmFjayA9IFY4Q3VzdG9tVm9p ZENhbGxiYWNrOjpjcmVhdGUoYXJnc1s0XSwgZnJhbWUpOworICAgIH0KKworICAgIGRhdGFiYXNl LT5jaGFuZ2VWZXJzaW9uKHRvV2ViQ29yZVN0cmluZyhhcmdzWzBdKSwgdG9XZWJDb3JlU3RyaW5n KGFyZ3NbMV0pLCBjYWxsYmFjay5yZWxlYXNlKCksIGVycm9yQ2FsbGJhY2sucmVsZWFzZSgpLCBz dWNjZXNzQ2FsbGJhY2sucmVsZWFzZSgpKTsKKwogICAgIHJldHVybiB2ODo6VW5kZWZpbmVkKCk7 CiB9CiAKQEAgLTc0LDcgKzExMyw3IEBAIHN0YXRpYyB2ODo6SGFuZGxlPHY4OjpWYWx1ZT4gY3Jl YXRlVHJhbnMKIAogICAgIFJlZlB0cjxWOEN1c3RvbVZvaWRDYWxsYmFjaz4gc3VjY2Vzc0NhbGxi YWNrOwogICAgIGlmIChhcmdzLkxlbmd0aCgpID4gMikgewotICAgICAgICBpZiAoIWFyZ3NbMV0t PklzT2JqZWN0KCkpCisgICAgICAgIGlmICghYXJnc1syXS0+SXNPYmplY3QoKSkKICAgICAgICAg ICAgIHJldHVybiB0aHJvd0Vycm9yKCJUcmFuc2FjdGlvbiBzdWNjZXNzIGNhbGxiYWNrIG11c3Qg YmUgb2YgdmFsaWQgdHlwZS4iKTsKIAogICAgICAgICBzdWNjZXNzQ2FsbGJhY2sgPSBWOEN1c3Rv bVZvaWRDYWxsYmFjazo6Y3JlYXRlKGFyZ3NbMl0sIGZyYW1lKTsKSW5kZXg6IFdlYkNvcmUvc3Rv cmFnZS9EYXRhYmFzZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNl LmNwcAkocmV2aXNpb24gNDgyOTIpCisrKyBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0xNzUsMjAgKzE3NSw2IEBAIERhdGFiYXNlOjpEYXRhYmFzZShEb2N1 bWVudCogZG9jdW1lbnQsIGMKIAogRGF0YWJhc2U6On5EYXRhYmFzZSgpCiB7Ci0gICAgewotICAg ICAgICBNdXRleExvY2tlciBsb2NrZXIoZ3VpZE11dGV4KCkpOwotCi0gICAgICAgIEhhc2hTZXQ8 RGF0YWJhc2UqPiogaGFzaFNldCA9IGd1aWRUb0RhdGFiYXNlTWFwKCkuZ2V0KG1fZ3VpZCk7Ci0g ICAgICAgIEFTU0VSVChoYXNoU2V0KTsKLSAgICAgICAgQVNTRVJUKGhhc2hTZXQtPmNvbnRhaW5z KHRoaXMpKTsKLSAgICAgICAgaGFzaFNldC0+cmVtb3ZlKHRoaXMpOwotICAgICAgICBpZiAoaGFz aFNldC0+aXNFbXB0eSgpKSB7Ci0gICAgICAgICAgICBndWlkVG9EYXRhYmFzZU1hcCgpLnJlbW92 ZShtX2d1aWQpOwotICAgICAgICAgICAgZGVsZXRlIGhhc2hTZXQ7Ci0gICAgICAgICAgICBndWlk VG9WZXJzaW9uTWFwKCkucmVtb3ZlKG1fZ3VpZCk7Ci0gICAgICAgIH0KLSAgICB9Ci0KICAgICBp ZiAobV9kb2N1bWVudC0+ZGF0YWJhc2VUaHJlYWQoKSkKICAgICAgICAgbV9kb2N1bWVudC0+ZGF0 YWJhc2VUaHJlYWQoKS0+dW5zY2hlZHVsZURhdGFiYXNlVGFza3ModGhpcyk7CiAKQEAgLTMyOCw2 ICszMTQsMjAgQEAgdm9pZCBEYXRhYmFzZTo6Y2xvc2UoKQogICAgICAgICBtX3NxbGl0ZURhdGFi YXNlLmNsb3NlKCk7CiAgICAgICAgIG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCktPnJlY29y ZERhdGFiYXNlQ2xvc2VkKHRoaXMpOwogICAgICAgICBtX29wZW5lZCA9IGZhbHNlOworCisgICAg ICAgIHsKKyAgICAgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihndWlkTXV0ZXgoKSk7CisKKyAg ICAgICAgICAgIEhhc2hTZXQ8RGF0YWJhc2UqPiogaGFzaFNldCA9IGd1aWRUb0RhdGFiYXNlTWFw KCkuZ2V0KG1fZ3VpZCk7CisgICAgICAgICAgICBBU1NFUlQoaGFzaFNldCk7CisgICAgICAgICAg ICBBU1NFUlQoaGFzaFNldC0+Y29udGFpbnModGhpcykpOworICAgICAgICAgICAgaGFzaFNldC0+ cmVtb3ZlKHRoaXMpOworICAgICAgICAgICAgaWYgKGhhc2hTZXQtPmlzRW1wdHkoKSkgeworICAg ICAgICAgICAgICAgIGd1aWRUb0RhdGFiYXNlTWFwKCkucmVtb3ZlKG1fZ3VpZCk7CisgICAgICAg ICAgICAgICAgZGVsZXRlIGhhc2hTZXQ7CisgICAgICAgICAgICAgICAgZ3VpZFRvVmVyc2lvbk1h cCgpLnJlbW92ZShtX2d1aWQpOworICAgICAgICAgICAgfQorICAgICAgICB9CiAgICAgfQogfQog CkBAIC02MzEsNiArNjMxLDkgQEAgVmVjdG9yPFN0cmluZz4gRGF0YWJhc2U6OnRhYmxlTmFtZXMo KQogdm9pZCBEYXRhYmFzZTo6c2V0RXhwZWN0ZWRWZXJzaW9uKGNvbnN0IFN0cmluZyYgdmVyc2lv bikKIHsKICAgICBtX2V4cGVjdGVkVmVyc2lvbiA9IHZlcnNpb24uY29weSgpOworICAgIC8vIFVw ZGF0ZSB0aGUgaW4gbWVtb3J5IGRhdGFiYXNlIHZlcnNpb24gbWFwLgorICAgIE11dGV4TG9ja2Vy IGxvY2tlcihndWlkTXV0ZXgoKSk7CisgICAgZ3VpZFRvVmVyc2lvbk1hcCgpLnNldChtX2d1aWQs IHZlcnNpb24pOwogfQogCiBQYXNzUmVmUHRyPFNlY3VyaXR5T3JpZ2luPiBEYXRhYmFzZTo6c2Vj dXJpdHlPcmlnaW5Db3B5KCkgY29uc3QKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDQ4Mjk5KQorKysgTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDkt MDktMTEgIEJlbiBNdXJkb2NoICA8YmVubUBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN0YWxlIGRhdGFiYXNlIHZlcnNpb24gcGVy c2lzdHMgdGhyb3VnaCBicm93c2VyIHJlZnJlc2ggKGNoYW5nZVZlcnNpb24gZG9lc24ndCB3b3Jr KQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjc4MzYK KworICAgICAgICAqIHN0b3JhZ2UvY2hhbmdlLXZlcnNpb24tZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBzdG9yYWdlL2NoYW5nZS12ZXJzaW9uLWhhbmRsZS1yZXVzZS1leHBlY3RlZC50 eHQ6IEFkZGVkLgorICAgICAgICAqIHN0b3JhZ2UvY2hhbmdlLXZlcnNpb24taGFuZGxlLXJldXNl Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIHN0b3JhZ2UvY2hhbmdlLXZlcnNpb24uaHRtbDogQWRk ZWQuCisKIDIwMDktMDktMTAgIEFkYW0gQmFydGggIDxhYmFydGhAd2Via2l0Lm9yZz4KIAogICAg ICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpJbmRleDogTGF5b3V0VGVzdHMvc3RvcmFnZS9j aGFuZ2UtdmVyc2lvbi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc3Rv cmFnZS9jaGFuZ2UtdmVyc2lvbi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRU ZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSw0IEBACitUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgZGF0YWJhc2UuY2hhbmdl VmVyc2lvbiBmdW5jdGlvbiB3b3JrcyBhcyBleHBlY3RlZC4KK0ZpbmlzaGVkIHRlc3RzIHdpdGgg dmVyc2lvbiAzCitURVNUIENPTVBMRVRFCisKClByb3BlcnR5IGNoYW5nZXMgb246IExheW91dFRl c3RzL3N0b3JhZ2UvY2hhbmdlLXZlcnNpb24tZXhwZWN0ZWQudHh0Cl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6 IHN2bjplb2wtc3R5bGUKICAgKyBuYXRpdmUKCkluZGV4OiBMYXlvdXRUZXN0cy9zdG9yYWdlL2No YW5nZS12ZXJzaW9uLWhhbmRsZS1yZXVzZS1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi1oYW5kbGUtcmV1c2UtZXhwZWN0ZWQudHh0 CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi1oYW5k bGUtcmV1c2UtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDYgQEAKK1RoaXMg dGVzdHMgdGhhdCBhIGRhdGFiYXNlIGNhbiBiZSBhY2Nlc3NlZCBhZnRlciBjaGFuZ2luZyBpdHMg dmVyc2lvbi4gWW91IHNob3VsZCBzZWUgYW4gZXJyb3IgYWJvdXQgRm9vQmFyIHRhYmxlIGJlbG93 LCBub3QgYWJvdXQgbWlzbWF0Y2hpbmcgdmVyc2lvbnMuIEFsc28sIHJlbG9hZGluZyB0aGUgcGFn ZSBzaG91bGQgbm90IGNhdXNlIGFuIGFzc2VydGlvbiBmYWlsdXJlLgorY2hhbmdlVmVyc2lvbjog dHJhbnNhY3Rpb24gY2FsbGJhY2sKK2NoYW5nZVZlcnNpb246IHN1Y2Nlc3MgY2FsbGJhY2sKK3Ry YW5zYWN0aW9uOiBzdGF0ZW1lbnQgZXJyb3IgY2FsbGJhY2s6IG5vIHN1Y2ggdGFibGU6IEZvb0Jh cgorVEVTVCBDT01QTEVURS4KKwoKUHJvcGVydHkgY2hhbmdlcyBvbjogTGF5b3V0VGVzdHMvc3Rv cmFnZS9jaGFuZ2UtdmVyc2lvbi1oYW5kbGUtcmV1c2UtZXhwZWN0ZWQudHh0Cl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K QWRkZWQ6IHN2bjplb2wtc3R5bGUKICAgKyBuYXRpdmUKCkluZGV4OiBMYXlvdXRUZXN0cy9zdG9y YWdlL2NoYW5nZS12ZXJzaW9uLWhhbmRsZS1yZXVzZS5odG1sCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91 dFRlc3RzL3N0b3JhZ2UvY2hhbmdlLXZlcnNpb24taGFuZGxlLXJldXNlLmh0bWwJKHJldmlzaW9u IDApCisrKyBMYXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLWhhbmRsZS1yZXVzZS5o dG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDcxIEBACis8aHRtbD4gCis8aGVhZD4gCis8c2Ny aXB0PiAKK2Z1bmN0aW9uIGxvZyhtZXNzYWdlKQoreworICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJyZXN1bHQiKS5pbm5lclRleHQgKz0gbWVzc2FnZSArICJcbiI7Cit9CisKK2Z1bmN0aW9u IGZpbmlzaFRlc3QoKQoreworCWxvZygiVEVTVCBDT01QTEVURS4iKTsKKworICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5v dGlmeURvbmUoKTsKK30KKworZnVuY3Rpb24gcnVuVGVzdCgpCit7CisgICAgaWYgKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikgeworCSAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50 aWxEb25lKCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAg ICB9CisgCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdCIpLmlubmVyVGV4dCA9 ICIiOworIAorICAgIHRyeSB7CisgICAgICAgIGRiID0gb3BlbkRhdGFiYXNlKCdDaGFuZ2VWZXJz aW9uJywgJycsICdUZXN0IHRoYXQgY2hhbmdpbmcgYSBkYXRhYmFzZSB2ZXJzaW9uIGRvZXNuXCd0 IGtpbGwgb3VyIGhhbmRsZSB0byBpdCcsIDEpOworICAgICAgICB2YXIgdmVyc2lvbiA9IGRiLnZl cnNpb247CisgICAgICAgIHZhciBuZXdWZXJzaW9uID0gdmVyc2lvbiA/IChwYXJzZUludCh2ZXJz aW9uKSArIDEpLnRvU3RyaW5nKCkgOiAiMSI7IAorICAgICAgICBkYi5jaGFuZ2VWZXJzaW9uKHZl cnNpb24sIG5ld1ZlcnNpb24sIGZ1bmN0aW9uKHR4KSB7CisgICAgICAgICAgICBsb2coImNoYW5n ZVZlcnNpb246IHRyYW5zYWN0aW9uIGNhbGxiYWNrIik7CisgICAgICAgIH0sIGZ1bmN0aW9uKGVy cm9yKSB7CisgICAgICAgICAgICBsb2coImNoYW5nZVZlcnNpb246IGVycm9yIGNhbGxiYWNrOiAi ICsgZXJyb3IubWVzc2FnZSk7CisgICAgICAgIH0sIGZ1bmN0aW9uKCkgeworICAgICAgICAgICAg bG9nKCJjaGFuZ2VWZXJzaW9uOiBzdWNjZXNzIGNhbGxiYWNrIik7CisgICAgICAgIH0pOworICAg ICAgICAKKyAgICAgICAgc2V0VGltZW91dChydW5UZXN0MiwgMTAwMCk7CisgICAgICAgIAorICAg IH0gY2F0Y2ggKGUpIHsKKyAgICAgICAgbG9nKCJjaGFuZ2VWZXJzaW9uIGV4Y2VwdGlvbjogIiAr IGUpOworICAgICAgICBmaW5pc2hUZXN0KCk7CisgICAgfQorfQorIAorZnVuY3Rpb24gcnVuVGVz dDIoKQoreworICAgIHRyeSB7CisgICAgICAgIGRiLnRyYW5zYWN0aW9uKGZ1bmN0aW9uKHR4KSB7 CisgICAgICAgICAgICB0eC5leGVjdXRlU3FsKCJTRUxFQ1QgKiBmcm9tIEZvb0JhciIsIFtdLCBm dW5jdGlvbih0eCkgeworICAgICAgICAgICAgICAgIGxvZygidHJhbnNhY3Rpb246IHN0YXRlbWVu dCBjYWxsYmFjayIpOworICAgICAgICAgICAgICAgIGZpbmlzaFRlc3QoKTsKKyAgICAgICAgICAg IH0sIGZ1bmN0aW9uKHR4LCBlcnJvcikgeworICAgICAgICAgICAgICAgIGxvZygidHJhbnNhY3Rp b246IHN0YXRlbWVudCBlcnJvciBjYWxsYmFjazogIiArIGVycm9yLm1lc3NhZ2UpOworICAgICAg ICAgICAgICAgIGZpbmlzaFRlc3QoKTsKKyAgICAgICAgICAgIH0pOworICAgICAgICB9KTsKKyAg ICB9IGNhdGNoIChlKSB7CisgICAgICAgIGxvZygidHJhbnNhY3Rpb24gZXhjZXB0aW9uOiAiICsg ZSk7CisgICAgICAgIGZpbmlzaFRlc3QoKTsKKyAgICB9Cit9Cis8L3NjcmlwdD4gCis8L2hlYWQ+ IAorPGJvZHkgb25sb2FkPSJydW5UZXN0KCkiPiAKKzxkaXY+VGhpcyB0ZXN0cyB0aGF0IGEgZGF0 YWJhc2UgY2FuIGJlIGFjY2Vzc2VkIGFmdGVyIGNoYW5naW5nIGl0cyB2ZXJzaW9uLiBZb3Ugc2hv dWxkIHNlZSBhbiBlcnJvciBhYm91dCBGb29CYXIgdGFibGUgYmVsb3csIG5vdCBhYm91dCBtaXNt YXRjaGluZyB2ZXJzaW9ucy4gQWxzbywgcmVsb2FkaW5nIHRoZSBwYWdlIHNob3VsZCBub3QgY2F1 c2UgYW4gYXNzZXJ0aW9uIGZhaWx1cmUuCis8cHJlIGlkPSJyZXN1bHQiPiAKK0ZBSUxVUkU6IHRl c3QgZGlkbid0IHJ1bi4KKzwvcHJlPiAKKzwvYm9keT4gCis8L2h0bWw+CgpQcm9wZXJ0eSBjaGFu Z2VzIG9uOiBMYXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLWhhbmRsZS1yZXVzZS5o dG1sCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KQWRkZWQ6IHN2bjplb2wtc3R5bGUKICAgKyBuYXRpdmUKCkluZGV4OiBM YXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLmh0bWwKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5 b3V0VGVzdHMvc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDg5IEBACis8aHRtbD4gCis8aGVhZD4KKzx0aXRsZT5UZXN0IGRhdGFiYXNlLmNoYW5nZVZl cnNpb248L3RpdGxlPgorPHNjcmlwdD4gCit2YXIgZGI7Cit2YXIgRVhQRUNURURfVkVSU0lPTl9B RlRFUl9ISVhJRV9URVNUID0gJzInOwordmFyIEVYUEVDVEVEX1ZFUlNJT05fQUZURVJfUkVMT0FE ID0gJzMnOworIAorZnVuY3Rpb24gZW1wdHlGdW5jdGlvbigpIHsgfQorIAorZnVuY3Rpb24gY2hh bmdlVmVyc2lvbkNhbGxiYWNrKHR4KQoreworICAgIHR4LmV4ZWN1dGVTcWwoJ2Ryb3AgdGFibGUg aWYgZXhpc3RzIGluZm87JywgW10sIGVtcHR5RnVuY3Rpb24sIGVtcHR5RnVuY3Rpb24pOworICAg IHR4LmV4ZWN1dGVTcWwoJ2NyZWF0ZSB0YWJsZSBpZiBub3QgZXhpc3RzIGluZm8gKHZlcnNpb24g SU5URUdFUik7JyxbXSwgZW1wdHlGdW5jdGlvbiwgZW1wdHlGdW5jdGlvbik7CisgICAgdHguZXhl Y3V0ZVNxbCgnaW5zZXJ0IGludG8gaW5mbyB2YWx1ZXMoPyk7JywgW0VYUEVDVEVEX1ZFUlNJT05f QUZURVJfUkVMT0FEXSwgZW1wdHlGdW5jdGlvbiwgZW1wdHlGdW5jdGlvbik7Cit9CisgCitmdW5j dGlvbiBjaGFuZ2VWZXJzaW9uU3VjY2VzcygpCit7CisgICAgbG9nKCdTdWNjZXNzZnVsbHkgY2hh bmdlZCB2ZXJzaW9uIHRvICcgKyBkYi52ZXJzaW9uICsgJy4gUmVsb2FkaW5nLicpOworICAgIHdp bmRvdy5sb2NhdGlvbi5ocmVmID0gd2luZG93LmxvY2F0aW9uICsgJz8yJzsKK30KKyAKK2Z1bmN0 aW9uIGNoYW5nZVZlcnNpb25FcnJvcihlcnJvcikKK3sKKyAgICBsb2coJ0Vycm9yOiAnICsgZXJy b3IubWVzc2FnZSk7CisgICAgZmluaXNoVGVzdCgpOworfQorCitmdW5jdGlvbiBmaW5pc2hUZXN0 KCkKK3sKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgbG9nKCJURVNUIENPTVBMRVRFIik7 Cit9CisKK2Z1bmN0aW9uIGxvZyhtZXNzYWdlKQoreworICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJjb25zb2xlIikuaW5uZXJUZXh0ICs9IG1lc3NhZ2UgKyAiXG4iOworfQorCitmdW5jdGlv biBydW5UZXN0KCkKK3sKKyAgICBpZiAod2luZG93LmxvY2F0aW9uLnNlYXJjaCA9PSAiPzIiKSB7 CisgICAgICAgIGRiID0gd2luZG93Lm9wZW5EYXRhYmFzZSgnY2hhbmdldmVyc2lvbi10ZXN0Jywg JycsICdUZXN0IGZvciB0aGUgZGF0YWJhc2UuY2hhbmdlVmVyc2lvbigpIGZ1bmN0aW9uJywgMTAy NCk7CisgICAgICAgIGxvZygnRmluaXNoZWQgdGVzdHMgd2l0aCB2ZXJzaW9uICcgKyBkYi52ZXJz aW9uKTsKKyAgICAgICAgZmluaXNoVGVzdCgpOworICAgIH0gZWxzZSB7CisgICAgICAgIHRlc3RQ YXJ0MSgpOworICAgIH0KK30KKworZnVuY3Rpb24gdGVzdFBhcnQxKCkgeworICAgIGlmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu Y2xlYXJBbGxEYXRhYmFzZXMoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7Cisg ICAgfQorICAgIAorICAgIGRiID0gd2luZG93Lm9wZW5EYXRhYmFzZSgnY2hhbmdldmVyc2lvbi10 ZXN0JywgJycsICdUZXN0IGZvciB0aGUgZGF0YWJhc2UuY2hhbmdlVmVyc2lvbigpIGZ1bmN0aW9u JywgMTAyNCk7CisKKyAgICBpZiAoZGIudmVyc2lvbiAhPSBFWFBFQ1RFRF9WRVJTSU9OX0FGVEVS X1JFTE9BRCkgeworICAgICAgICAvLyBGaXJzdCBydW4gSGl4aWUncyB0ZXN0IHRvIGVuc3VyZSBi YXNpYyBjaGFuZ2VWZXJzaW9uIGZ1bmN0aW9uYWxpdHkgd29ya3MgKHNlZSBidWcgMjg0MTgpLgor ICAgICAgICBkYi5jaGFuZ2VWZXJzaW9uKCcnLCBFWFBFQ1RFRF9WRVJTSU9OX0FGVEVSX0hJWElF X1RFU1QsIGVtcHR5RnVuY3Rpb24sIGZ1bmN0aW9uIChlKSB7CisgICAgICAgICAgICBsb2coJ0ZB SUwgaW4gY2hhbmdlVmVyc2lvbjonICsgZSk7CisgICAgICAgICAgICBmaW5pc2hUZXN0KCk7Cisg ICAgICAgIH0sIGZ1bmN0aW9uICgpIHsKKyAgICAgICAgICAgIHRyeSB7CisgICAgICAgICAgICAg ICAgdmFyIGRiMiA9IG9wZW5EYXRhYmFzZSgnY2hhbmdlLXZlcnNpb24tdGVzdCcsIEVYUEVDVEVE X1ZFUlNJT05fQUZURVJfSElYSUVfVEVTVCwgJycsIDApOworICAgICAgICAgICAgfSBjYXRjaCAo ZSkgeworICAgICAgICAgICAgICAgIGxvZygnRkFJTCBpbiBvcGVuRGF0YWJhc2U6ICcgKyBlKTsK KyAgICAgICAgICAgICAgICBmaW5pc2hUZXN0KCk7CisgICAgICAgICAgICB9CisgICAgICAgICAg ICAvLyBGb2xsb3dpbmcgdmVyc2lvbnMgc2hvdWxkIG1hdGNoLgorICAgICAgICAgICAgbG9nKCdE YXRhYmFzZSB2ZXJzaW9uOiAnICsgZGIudmVyc2lvbik7CisgICAgICAgICAgICBsb2coJ1NlY29u ZCBkYXRhYmFzZSB2ZXJzaW9uOiAnICsgZGIyLnZlcnNpb24pOworCisgICAgICAgICAgICAvLyBO b3cgdHJ5IGEgdGVzdCB0byBlbnN1cmUgdGhlIHZlcnNpb24gcGVyc2lzdHMgYWZ0ZXIgcmVsb2Fk aW5nIChzZWUgYnVnIDI3ODM2KQorICAgICAgICAgICAgZGIuY2hhbmdlVmVyc2lvbihFWFBFQ1RF RF9WRVJTSU9OX0FGVEVSX0hJWElFX1RFU1QsIEVYUEVDVEVEX1ZFUlNJT05fQUZURVJfUkVMT0FE LCBjaGFuZ2VWZXJzaW9uQ2FsbGJhY2ssIGNoYW5nZVZlcnNpb25FcnJvciwgY2hhbmdlVmVyc2lv blN1Y2Nlc3MpOworICAgICAgICB9KTsKKyAgICB9Cit9Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxi b2R5IG9ubG9hZD0icnVuVGVzdCgpOyI+CitUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgZGF0 YWJhc2UuY2hhbmdlVmVyc2lvbiBmdW5jdGlvbiB3b3JrcyBhcyBleHBlY3RlZC4KKzxwcmUgaWQ9 ImNvbnNvbGUiPjwvcHJlPgorPC9ib2R5PgorPC9odG1sPgoKUHJvcGVydHkgY2hhbmdlcyBvbjog TGF5b3V0VGVzdHMvc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi5odG1sCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6 IHN2bjplb2wtc3R5bGUKICAgKyBuYXRpdmUKCg== 40445 2009-10-01 08:36:19 -0700 2009-10-01 14:20:41 -0700 Revised patch. 27836-2.txt text/plain 16550 benm SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0ODg3MikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjQgQEAKKzIwMDktMDktMjkgIEJlbiBNdXJkb2NoICA8YmVubUBnb29nbGUuY29t PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN0YWxl IGRhdGFiYXNlIHZlcnNpb24gcGVyc2lzdHMgdGhyb3VnaCBicm93c2VyIHJlZnJlc2ggKGNoYW5n ZVZlcnNpb24gZG9lc24ndCB3b3JrKQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9Mjc4MzYKKworICAgICAgICBUZXN0czogc3RvcmFnZS9jaGFuZ2UtdmVy c2lvbi1oYW5kbGUtcmV1c2UuaHRtbAorICAgICAgICAgICAgICAgc3RvcmFnZS9jaGFuZ2UtdmVy c2lvbi5odG1sCisKKyAgICAgICAgKiBiaW5kaW5ncy92OC9jdXN0b20vVjhEYXRhYmFzZUN1c3Rv bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQUxMQkFDS19GVU5DX0RFQ0wpOiBpbXBsZW1lbnQg dGhlIFY4IGJpbmRpbmcgZm9yIGRhdGFiYXNlLmNoYW5nZVZlcnNpb24KKyAgICAgICAgKFdlYkNv cmU6OmNyZWF0ZVRyYW5zYWN0aW9uKTogRml4IGEgYnVnIHRoYXQgd2FzIGNoZWNraW5nIHRoZSB3 cm9uZyBhcmd1bWVudCBpbmRleCB0byBzYXZlIHRoZSBzdWNjZXNzIGNhbGxiYWNrCisgICAgICAg ICogc3RvcmFnZS9EYXRhYmFzZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjp1cGRhdGVHdWlkVmVy c2lvbk1hcCk6IFNhZmVseSB1cGRhdGUgdGhlIEd1aWQvdmVyc2lvbiBoYXNoIG1hcC4KKyAgICAg ICAgKFdlYkNvcmU6OkRhdGFiYXNlOjp+RGF0YWJhc2UpOiBSZW1vdmUgY29kZSB0aGF0IHJlbW92 ZXMgdGhlIGRhdGFiYXNlIGZyb20gdGhlIGd1aWQtPmRhdGFiYXNlIGFuZCBndWlkLT52ZXJzaW9u IG1hcHMuCisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFzZTo6c2V0VmVyc2lvbkluRGF0YWJhc2Up OiBBZGQgYSBjb21tZW50IHRvIGV4cGxhaW4gc29tZSBiZWhhdmlvdXIuCisgICAgICAgIChXZWJD b3JlOjpEYXRhYmFzZTo6Y2xvc2UpOiBNb3ZlIHRoZSBjb2RlIHRoYXQgdXBkYXRlcyB0aGUgbWFw cyBmcm9tIHRoZSBkZXN0cnVjdG9yIHRvIGhlcmUuCisgICAgICAgIChXZWJDb3JlOjpEYXRhYmFz ZTo6cGVyZm9ybU9wZW5BbmRWZXJpZnkpOiBDYWxsIHVwZGF0ZUd1aWRWZXJzaW9uTWFwIGluc3Rl YWQgb2Ygc2V0dGluZyB0aGUgaGFzaCBtYXAgZGlyZWN0bHkuCisgICAgICAgIChXZWJDb3JlOjpE YXRhYmFzZTo6c2V0RXhwZWN0ZWRWZXJzaW9uKTogVXBkYXRlIHRoZSBpbiBtZW1vcnkgZ3VpZC0+ dmVyc2lvbiBtYXAgd2hlbiB3ZSB3YW50IHRvIHVwZGF0ZSB0aGUgZGF0YWJhc2UgdmVyc2lvbi4K KwogMjAwOS0wOS0yOSAgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4gIDxrZW5uZXRoQHdlYmtp dC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24gSGF1c21hbm4gYW5kIFRvciBBcm5l IFZlc3Riw7guCkluZGV4OiBXZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOERhdGFiYXNlQ3Vz dG9tLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOERhdGFi YXNlQ3VzdG9tLmNwcAkocmV2aXNpb24gNDgyOTIpCisrKyBXZWJDb3JlL2JpbmRpbmdzL3Y4L2N1 c3RvbS9WOERhdGFiYXNlQ3VzdG9tLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDUsNiArNDUsNDUg QEAgbmFtZXNwYWNlIFdlYkNvcmUgewogQ0FMTEJBQ0tfRlVOQ19ERUNMKERhdGFiYXNlQ2hhbmdl VmVyc2lvbikKIHsKICAgICBJTkNfU1RBVFMoIkRPTS5EYXRhYmFzZS5jaGFuZ2VWZXJzaW9uKCki KTsKKworICAgIGlmIChhcmdzLkxlbmd0aCgpIDwgMikKKyAgICAgICAgcmV0dXJuIHRocm93RXJy b3IoIlRoZSBvbGQgYW5kIG5ldyB2ZXJzaW9uIHN0cmluZ3MgYXJlIHJlcXVpcmVkLiIsIFY4UHJv eHk6OlN5bnRheEVycm9yKTsKKworICAgIGlmICghKGFyZ3NbMF0tPklzU3RyaW5nKCkgJiYgYXJn c1sxXS0+SXNTdHJpbmcoKSkpCisgICAgICAgIHJldHVybiB0aHJvd0Vycm9yKCJUaGUgb2xkIGFu ZCBuZXcgdmVyc2lvbnMgbXVzdCBiZSBzdHJpbmdzLiIpOworCisgICAgRGF0YWJhc2UqIGRhdGFi YXNlID0gVjhET01XcmFwcGVyOjpjb252ZXJ0VG9OYXRpdmVPYmplY3Q8RGF0YWJhc2U+KFY4Q2xh c3NJbmRleDo6REFUQUJBU0UsIGFyZ3MuSG9sZGVyKCkpOworCisgICAgRnJhbWUqIGZyYW1lID0g VjhQcm94eTo6cmV0cmlldmVGcmFtZUZvckN1cnJlbnRDb250ZXh0KCk7CisgICAgaWYgKCFmcmFt ZSkKKyAgICAgICAgcmV0dXJuIHY4OjpVbmRlZmluZWQoKTsKKworICAgIFJlZlB0cjxWOEN1c3Rv bVNRTFRyYW5zYWN0aW9uQ2FsbGJhY2s+IGNhbGxiYWNrOworICAgIGlmIChhcmdzLkxlbmd0aCgp ID4gMikgeworICAgICAgICBpZiAoIWFyZ3NbMl0tPklzT2JqZWN0KCkpCisgICAgICAgICAgICBy ZXR1cm4gdGhyb3dFcnJvcigiY2hhbmdlVmVyc2lvbiB0cmFuc2FjdGlvbiBjYWxsYmFjayBtdXN0 IGJlIG9mIHZhbGlkIHR5cGUuIik7CisKKyAgICAgICAgY2FsbGJhY2sgPSBWOEN1c3RvbVNRTFRy YW5zYWN0aW9uQ2FsbGJhY2s6OmNyZWF0ZShhcmdzWzJdLCBmcmFtZSk7CisgICAgfQorCisgICAg UmVmUHRyPFY4Q3VzdG9tU1FMVHJhbnNhY3Rpb25FcnJvckNhbGxiYWNrPiBlcnJvckNhbGxiYWNr OworICAgIGlmIChhcmdzLkxlbmd0aCgpID4gMykgeworICAgICAgICBpZiAoIWFyZ3NbM10tPklz T2JqZWN0KCkpCisgICAgICAgICAgICByZXR1cm4gdGhyb3dFcnJvcigiY2hhbmdlVmVyc2lvbiBl cnJvciBjYWxsYmFjayBtdXN0IGJlIG9mIHZhbGlkIHR5cGUuIik7CisKKyAgICAgICAgZXJyb3JD YWxsYmFjayA9IFY4Q3VzdG9tU1FMVHJhbnNhY3Rpb25FcnJvckNhbGxiYWNrOjpjcmVhdGUoYXJn c1szXSwgZnJhbWUpOworICAgIH0KKworICAgIFJlZlB0cjxWOEN1c3RvbVZvaWRDYWxsYmFjaz4g c3VjY2Vzc0NhbGxiYWNrOworICAgIGlmIChhcmdzLkxlbmd0aCgpID4gNCkgeworICAgICAgICBp ZiAoIWFyZ3NbNF0tPklzT2JqZWN0KCkpCisgICAgICAgICAgICByZXR1cm4gdGhyb3dFcnJvcigi Y2hhbmdlVmVyc2lvbiBzdWNjZXNzIGNhbGxiYWNrIG11c3QgYmUgb2YgdmFsaWQgdHlwZS4iKTsK KworICAgICAgICBzdWNjZXNzQ2FsbGJhY2sgPSBWOEN1c3RvbVZvaWRDYWxsYmFjazo6Y3JlYXRl KGFyZ3NbNF0sIGZyYW1lKTsKKyAgICB9CisKKyAgICBkYXRhYmFzZS0+Y2hhbmdlVmVyc2lvbih0 b1dlYkNvcmVTdHJpbmcoYXJnc1swXSksIHRvV2ViQ29yZVN0cmluZyhhcmdzWzFdKSwgY2FsbGJh Y2sucmVsZWFzZSgpLCBlcnJvckNhbGxiYWNrLnJlbGVhc2UoKSwgc3VjY2Vzc0NhbGxiYWNrLnJl bGVhc2UoKSk7CisKICAgICByZXR1cm4gdjg6OlVuZGVmaW5lZCgpOwogfQogCkBAIC03NCw3ICsx MTMsNyBAQCBzdGF0aWMgdjg6OkhhbmRsZTx2ODo6VmFsdWU+IGNyZWF0ZVRyYW5zCiAKICAgICBS ZWZQdHI8VjhDdXN0b21Wb2lkQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjazsKICAgICBpZiAoYXJn cy5MZW5ndGgoKSA+IDIpIHsKLSAgICAgICAgaWYgKCFhcmdzWzFdLT5Jc09iamVjdCgpKQorICAg ICAgICBpZiAoIWFyZ3NbMl0tPklzT2JqZWN0KCkpCiAgICAgICAgICAgICByZXR1cm4gdGhyb3dF cnJvcigiVHJhbnNhY3Rpb24gc3VjY2VzcyBjYWxsYmFjayBtdXN0IGJlIG9mIHZhbGlkIHR5cGUu Iik7CiAKICAgICAgICAgc3VjY2Vzc0NhbGxiYWNrID0gVjhDdXN0b21Wb2lkQ2FsbGJhY2s6OmNy ZWF0ZShhcmdzWzJdLCBmcmFtZSk7CkluZGV4OiBXZWJDb3JlL3N0b3JhZ2UvRGF0YWJhc2UuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvc3RvcmFnZS9EYXRhYmFzZS5jcHAJKHJldmlzaW9uIDQ4 MjkyKQorKysgV2ViQ29yZS9zdG9yYWdlL0RhdGFiYXNlLmNwcAkod29ya2luZyBjb3B5KQpAQCAt ODksNiArODksMTggQEAgc3RhdGljIEd1aWRWZXJzaW9uTWFwJiBndWlkVG9WZXJzaW9uTWFwKAog ICAgIHJldHVybiBtYXA7CiB9CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCB1cGRhdGVHdWlkVmVyc2lv bk1hcChpbnQgZ3VpZCwgU3RyaW5nIG5ld1ZlcnNpb24pCit7CisgICAgLy8gTm90ZTogSXQgaXMg bm90IHNhZmUgdG8gcHV0IGFuIGVtcHR5IHN0cmluZyBpbnRvIHRoZSBndWlkVG9WZXJzaW9uTWFw KCkgbWFwLgorICAgIC8vIFRoYXQncyBiZWNhdXNlIHRoZSBtYXAgaXMgY3Jvc3MtdGhyZWFkLCBi dXQgZW1wdHkgc3RyaW5ncyBhcmUgcGVyLXRocmVhZC4KKyAgICAvLyBUaGUgY29weSgpIGZ1bmN0 aW9uIG1ha2VzIGEgdmVyc2lvbiBvZiB0aGUgc3RyaW5nIHlvdSBjYW4gdXNlIG9uIHRoZSBjdXJy ZW50CisgICAgLy8gdGhyZWFkLCBidXQgd2UgbmVlZCBhIHN0cmluZyB3ZSBjYW4ga2VlcCBpbiBh IGNyb3NzLXRocmVhZCBkYXRhIHN0cnVjdHVyZS4KKyAgICAvLyBGSVhNRTogVGhpcyBpcyBhIHF1 aXRlLWF3a3dhcmQgcmVzdHJpY3Rpb24gdG8gaGF2ZSB0byBwcm9ncmFtIHdpdGguCisKKyAgICAv LyBOT1RFOiBDYWxsZXIgbXVzdCBsb2NrIGd1aWRNdXRleCgpLgorICAgIGd1aWRUb1ZlcnNpb25N YXAoKS5zZXQoZ3VpZCwgbmV3VmVyc2lvbi5pc0VtcHR5KCkgPyBTdHJpbmcoKSA6IG5ld1ZlcnNp b24uY29weSgpKTsKK30KKwogdHlwZWRlZiBIYXNoTWFwPGludCwgSGFzaFNldDxEYXRhYmFzZSo+ Kj4gR3VpZERhdGFiYXNlTWFwOwogc3RhdGljIEd1aWREYXRhYmFzZU1hcCYgZ3VpZFRvRGF0YWJh c2VNYXAoKQogewpAQCAtMTc1LDIwICsxODcsNiBAQCBEYXRhYmFzZTo6RGF0YWJhc2UoRG9jdW1l bnQqIGRvY3VtZW50LCBjCiAKIERhdGFiYXNlOjp+RGF0YWJhc2UoKQogewotICAgIHsKLSAgICAg ICAgTXV0ZXhMb2NrZXIgbG9ja2VyKGd1aWRNdXRleCgpKTsKLQotICAgICAgICBIYXNoU2V0PERh dGFiYXNlKj4qIGhhc2hTZXQgPSBndWlkVG9EYXRhYmFzZU1hcCgpLmdldChtX2d1aWQpOwotICAg ICAgICBBU1NFUlQoaGFzaFNldCk7Ci0gICAgICAgIEFTU0VSVChoYXNoU2V0LT5jb250YWlucyh0 aGlzKSk7Ci0gICAgICAgIGhhc2hTZXQtPnJlbW92ZSh0aGlzKTsKLSAgICAgICAgaWYgKGhhc2hT ZXQtPmlzRW1wdHkoKSkgewotICAgICAgICAgICAgZ3VpZFRvRGF0YWJhc2VNYXAoKS5yZW1vdmUo bV9ndWlkKTsKLSAgICAgICAgICAgIGRlbGV0ZSBoYXNoU2V0OwotICAgICAgICAgICAgZ3VpZFRv VmVyc2lvbk1hcCgpLnJlbW92ZShtX2d1aWQpOwotICAgICAgICB9Ci0gICAgfQotCiAgICAgaWYg KG1fZG9jdW1lbnQtPmRhdGFiYXNlVGhyZWFkKCkpCiAgICAgICAgIG1fZG9jdW1lbnQtPmRhdGFi YXNlVGhyZWFkKCktPnVuc2NoZWR1bGVEYXRhYmFzZVRhc2tzKHRoaXMpOwogCkBAIC0yNzUsNiAr MjczLDggQEAgc3RhdGljIGJvb2wgc2V0VGV4dFZhbHVlSW5EYXRhYmFzZShTUUxpdAogCiBib29s IERhdGFiYXNlOjpzZXRWZXJzaW9uSW5EYXRhYmFzZShjb25zdCBTdHJpbmcmIHZlcnNpb24pCiB7 CisgICAgLy8gVGhlIElOU0VSVCB3aWxsIHJlcGxhY2UgYW4gZXhpc3RpbmcgZW50cnkgZm9yIHRo ZSBkYXRhYmFzZSB3aXRoIHRoZSBuZXcgdmVyc2lvbiBudW1iZXIsIGR1ZSB0byB0aGUgVU5JUVVF IE9OIENPTkZMSUNUIFJFUExBQ0UKKyAgICAvLyBjbGF1c2UgaW4gdGhlIENSRUFURSBzdGF0ZW1l bnQgKHNlZSBEYXRhYmFzZTo6cGVyZm9ybU9wZW5BbmRWZXJpZnkpCiAgICAgREVGSU5FX1NUQVRJ Q19MT0NBTChTdHJpbmcsIHNldFZlcnNpb25RdWVyeSwgKCJJTlNFUlQgSU5UTyAiICsgZGF0YWJh c2VJbmZvVGFibGVOYW1lKCkgKyAiIChrZXksIHZhbHVlKSBWQUxVRVMgKCciICsgZGF0YWJhc2VW ZXJzaW9uS2V5KCkgKyAiJywgPyk7IikpOwogCiAgICAgbV9kYXRhYmFzZUF1dGhvcml6ZXItPmRp c2FibGUoKTsKQEAgLTMyOCw2ICszMjgsMjAgQEAgdm9pZCBEYXRhYmFzZTo6Y2xvc2UoKQogICAg ICAgICBtX3NxbGl0ZURhdGFiYXNlLmNsb3NlKCk7CiAgICAgICAgIG1fZG9jdW1lbnQtPmRhdGFi YXNlVGhyZWFkKCktPnJlY29yZERhdGFiYXNlQ2xvc2VkKHRoaXMpOwogICAgICAgICBtX29wZW5l ZCA9IGZhbHNlOworCisgICAgICAgIHsKKyAgICAgICAgICAgIE11dGV4TG9ja2VyIGxvY2tlcihn dWlkTXV0ZXgoKSk7CisKKyAgICAgICAgICAgIEhhc2hTZXQ8RGF0YWJhc2UqPiogaGFzaFNldCA9 IGd1aWRUb0RhdGFiYXNlTWFwKCkuZ2V0KG1fZ3VpZCk7CisgICAgICAgICAgICBBU1NFUlQoaGFz aFNldCk7CisgICAgICAgICAgICBBU1NFUlQoaGFzaFNldC0+Y29udGFpbnModGhpcykpOworICAg ICAgICAgICAgaGFzaFNldC0+cmVtb3ZlKHRoaXMpOworICAgICAgICAgICAgaWYgKGhhc2hTZXQt PmlzRW1wdHkoKSkgeworICAgICAgICAgICAgICAgIGd1aWRUb0RhdGFiYXNlTWFwKCkucmVtb3Zl KG1fZ3VpZCk7CisgICAgICAgICAgICAgICAgZGVsZXRlIGhhc2hTZXQ7CisgICAgICAgICAgICAg ICAgZ3VpZFRvVmVyc2lvbk1hcCgpLnJlbW92ZShtX2d1aWQpOworICAgICAgICAgICAgfQorICAg ICAgICB9CiAgICAgfQogfQogCkBAIC00NDcsMTIgKzQ2MSw2IEBAIGJvb2wgRGF0YWJhc2U6OnBl cmZvcm1PcGVuQW5kVmVyaWZ5KEV4Y2UKICAgICB7CiAgICAgICAgIE11dGV4TG9ja2VyIGxvY2tl cihndWlkTXV0ZXgoKSk7CiAKLSAgICAgICAgLy8gTm90ZTogSXQgaXMgbm90IHNhZmUgdG8gcHV0 IGFuIGVtcHR5IHN0cmluZyBpbnRvIHRoZSBndWlkVG9WZXJzaW9uTWFwKCkgbWFwLgotICAgICAg ICAvLyBUaGF0J3MgYmVjYXVzZSB0aGUgbWFwIGlzIGNyb3NzLXRocmVhZCwgYnV0IGVtcHR5IHN0 cmluZ3MgYXJlIHBlci10aHJlYWQuCi0gICAgICAgIC8vIFRoZSBjb3B5KCkgZnVuY3Rpb24gbWFr ZXMgYSB2ZXJzaW9uIG9mIHRoZSBzdHJpbmcgeW91IGNhbiB1c2Ugb24gdGhlIGN1cnJlbnQKLSAg ICAgICAgLy8gdGhyZWFkLCBidXQgd2UgbmVlZCBhIHN0cmluZyB3ZSBjYW4ga2VlcCBpbiBhIGNy b3NzLXRocmVhZCBkYXRhIHN0cnVjdHVyZS4KLSAgICAgICAgLy8gRklYTUU6IFRoaXMgaXMgYSBx dWl0ZS1hd2t3YXJkIHJlc3RyaWN0aW9uIHRvIGhhdmUgdG8gcHJvZ3JhbSB3aXRoLgotCiAgICAg ICAgIEd1aWRWZXJzaW9uTWFwOjppdGVyYXRvciBlbnRyeSA9IGd1aWRUb1ZlcnNpb25NYXAoKS5m aW5kKG1fZ3VpZCk7CiAgICAgICAgIGlmIChlbnRyeSAhPSBndWlkVG9WZXJzaW9uTWFwKCkuZW5k KCkpIHsKICAgICAgICAgICAgIC8vIE1hcCBudWxsIHN0cmluZyB0byBlbXB0eSBzdHJpbmcgKHNl ZSBjb21tZW50IGFib3ZlKS4KQEAgLTQ4Niw4ICs0OTQsNyBAQCBib29sIERhdGFiYXNlOjpwZXJm b3JtT3BlbkFuZFZlcmlmeShFeGNlCiAgICAgICAgICAgICAgICAgY3VycmVudFZlcnNpb24gPSBt X2V4cGVjdGVkVmVyc2lvbjsKICAgICAgICAgICAgIH0KIAotICAgICAgICAgICAgLy8gTWFwIGVt cHR5IHN0cmluZyB0byBudWxsIHN0cmluZyAoc2VlIGNvbW1lbnQgYWJvdmUpLgotICAgICAgICAg ICAgZ3VpZFRvVmVyc2lvbk1hcCgpLnNldChtX2d1aWQsIGN1cnJlbnRWZXJzaW9uLmlzRW1wdHko KSA/IFN0cmluZygpIDogY3VycmVudFZlcnNpb24uY29weSgpKTsKKyAgICAgICAgICAgIHVwZGF0 ZUd1aWRWZXJzaW9uTWFwKG1fZ3VpZCwgY3VycmVudFZlcnNpb24pOwogICAgICAgICB9CiAgICAg fQogCkBAIC02MzEsNiArNjM4LDkgQEAgVmVjdG9yPFN0cmluZz4gRGF0YWJhc2U6OnRhYmxlTmFt ZXMoKQogdm9pZCBEYXRhYmFzZTo6c2V0RXhwZWN0ZWRWZXJzaW9uKGNvbnN0IFN0cmluZyYgdmVy c2lvbikKIHsKICAgICBtX2V4cGVjdGVkVmVyc2lvbiA9IHZlcnNpb24uY29weSgpOworICAgIC8v IFVwZGF0ZSB0aGUgaW4gbWVtb3J5IGRhdGFiYXNlIHZlcnNpb24gbWFwLgorICAgIE11dGV4TG9j a2VyIGxvY2tlcihndWlkTXV0ZXgoKSk7CisgICAgdXBkYXRlR3VpZFZlcnNpb25NYXAobV9ndWlk LCB2ZXJzaW9uKTsKIH0KIAogUGFzc1JlZlB0cjxTZWN1cml0eU9yaWdpbj4gRGF0YWJhc2U6OnNl Y3VyaXR5T3JpZ2luQ29weSgpIGNvbnN0CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA0ODg3MikKKysrIExh eW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE1IEBACisyMDA5 LTA5LTI5ICBCZW4gTXVyZG9jaCAgPGJlbm1AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdGFsZSBkYXRhYmFzZSB2ZXJzaW9uIHBl cnNpc3RzIHRocm91Z2ggYnJvd3NlciByZWZyZXNoIChjaGFuZ2VWZXJzaW9uIGRvZXNuJ3Qgd29y aykKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI3ODM2 CisKKyAgICAgICAgKiBzdG9yYWdlL2NoYW5nZS12ZXJzaW9uLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi1oYW5kbGUtcmV1c2UtZXhwZWN0ZWQu dHh0OiBBZGRlZC4KKyAgICAgICAgKiBzdG9yYWdlL2NoYW5nZS12ZXJzaW9uLWhhbmRsZS1yZXVz ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBzdG9yYWdlL2NoYW5nZS12ZXJzaW9uLmh0bWw6IEFk ZGVkLgorCiAyMDA5LTA5LTI5ICBBbmRyYXMgQmVjc2kgIDxiZWNzaS5hbmRyYXNAc3R1ZC51LXN6 ZWdlZC5odT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTaW1vbiBIYXVzbWFubi4KSW5kZXg6IExh eW91dFRlc3RzL3N0b3JhZ2UvY2hhbmdlLXZlcnNpb24tZXhwZWN0ZWQudHh0Cj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL3N0b3JhZ2UvY2hhbmdlLXZlcnNpb24tZXhwZWN0ZWQudHh0CShyZXZp c2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi1leHBlY3RlZC50 eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNCBAQAorVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQg dGhlIEpTIGRhdGFiYXNlLmNoYW5nZVZlcnNpb24oKSBmdW5jdGlvbiB3b3JrcyBhcyBleHBlY3Rl ZC4KK0ZpbmlzaGVkIHRlc3RzIHdpdGggdmVyc2lvbiAzOyBleHBlY3RlZCB2ZXJzaW9uOiAzCitU RVNUIENPTVBMRVRFCisKClByb3BlcnR5IGNoYW5nZXMgb246IExheW91dFRlc3RzL3N0b3JhZ2Uv Y2hhbmdlLXZlcnNpb24tZXhwZWN0ZWQudHh0Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2bjplb2wtc3R5 bGUKICAgKyBuYXRpdmUKCkluZGV4OiBMYXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9u LWhhbmRsZS1yZXVzZS1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc3Rv cmFnZS9jaGFuZ2UtdmVyc2lvbi1oYW5kbGUtcmV1c2UtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAw KQorKysgTGF5b3V0VGVzdHMvc3RvcmFnZS9jaGFuZ2UtdmVyc2lvbi1oYW5kbGUtcmV1c2UtZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDYgQEAKK1RoaXMgdGVzdHMgdGhhdCBh IGRhdGFiYXNlIGNhbiBiZSBhY2Nlc3NlZCBhZnRlciBjaGFuZ2luZyBpdHMgdmVyc2lvbi4gWW91 IHNob3VsZCBzZWUgYW4gZXJyb3IgYWJvdXQgRm9vQmFyIHRhYmxlIGJlbG93LCBub3QgYWJvdXQg bWlzbWF0Y2hpbmcgdmVyc2lvbnMuIEFsc28sIHJlbG9hZGluZyB0aGUgcGFnZSBzaG91bGQgbm90 IGNhdXNlIGFuIGFzc2VydGlvbiBmYWlsdXJlLgorY2hhbmdlVmVyc2lvbjogdHJhbnNhY3Rpb24g Y2FsbGJhY2sKK2NoYW5nZVZlcnNpb246IHN1Y2Nlc3MgY2FsbGJhY2sKK3RyYW5zYWN0aW9uOiBz dGF0ZW1lbnQgZXJyb3IgY2FsbGJhY2s6IG5vIHN1Y2ggdGFibGU6IEZvb0JhcgorVEVTVCBDT01Q TEVURS4KKwoKUHJvcGVydHkgY2hhbmdlcyBvbjogTGF5b3V0VGVzdHMvc3RvcmFnZS9jaGFuZ2Ut dmVyc2lvbi1oYW5kbGUtcmV1c2UtZXhwZWN0ZWQudHh0Cl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2bjpl b2wtc3R5bGUKICAgKyBuYXRpdmUKCkluZGV4OiBMYXlvdXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12 ZXJzaW9uLWhhbmRsZS1yZXVzZS5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3N0b3Jh Z2UvY2hhbmdlLXZlcnNpb24taGFuZGxlLXJldXNlLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlv dXRUZXN0cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLWhhbmRsZS1yZXVzZS5odG1sCShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDcxIEBACis8aHRtbD4gCis8aGVhZD4KKzxzY3JpcHQ+IAorZnVuY3Rp b24gbG9nKG1lc3NhZ2UpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdCIp LmlubmVyVGV4dCArPSBtZXNzYWdlICsgIlxuIjsKK30KKworZnVuY3Rpb24gZmluaXNoVGVzdCgp Cit7CisgICAgbG9nKCJURVNUIENPTVBMRVRFLiIpOworCisgICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgp OworfQorCitmdW5jdGlvbiBydW5UZXN0KCkKK3sKKyAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUo KTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgIH0KKyAK KyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0IikuaW5uZXJUZXh0ID0gIiI7Cisg CisgICAgdHJ5IHsKKyAgICAgICAgZGIgPSBvcGVuRGF0YWJhc2UoIkNoYW5nZVZlcnNpb24iLCAi IiwgIlRlc3QgdGhhdCBjaGFuZ2luZyBhIGRhdGFiYXNlIHZlcnNpb24gZG9lc25cJ3Qga2lsbCBv dXIgaGFuZGxlIHRvIGl0IiwgMSk7CisgICAgICAgIHZhciB2ZXJzaW9uID0gZGIudmVyc2lvbjsK KyAgICAgICAgdmFyIG5ld1ZlcnNpb24gPSB2ZXJzaW9uID8gKHBhcnNlSW50KHZlcnNpb24pICsg MSkudG9TdHJpbmcoKSA6ICIxIjsgCisgICAgICAgIGRiLmNoYW5nZVZlcnNpb24odmVyc2lvbiwg bmV3VmVyc2lvbiwgZnVuY3Rpb24odHgpIHsKKyAgICAgICAgICAgIGxvZygiY2hhbmdlVmVyc2lv bjogdHJhbnNhY3Rpb24gY2FsbGJhY2siKTsKKyAgICAgICAgfSwgZnVuY3Rpb24oZXJyb3IpIHsK KyAgICAgICAgICAgIGxvZygiY2hhbmdlVmVyc2lvbjogZXJyb3IgY2FsbGJhY2s6ICIgKyBlcnJv ci5tZXNzYWdlKTsKKyAgICAgICAgfSwgZnVuY3Rpb24oKSB7CisgICAgICAgICAgICBsb2coImNo YW5nZVZlcnNpb246IHN1Y2Nlc3MgY2FsbGJhY2siKTsKKyAgICAgICAgfSk7CisgICAgICAgIAor ICAgICAgICBzZXRUaW1lb3V0KHJ1blRlc3QyLCAxMDAwKTsKKyAgICAgICAgCisgICAgfSBjYXRj aCAoZSkgeworICAgICAgICBsb2coImNoYW5nZVZlcnNpb24gZXhjZXB0aW9uOiAiICsgZSk7Cisg ICAgICAgIGZpbmlzaFRlc3QoKTsKKyAgICB9Cit9CisgCitmdW5jdGlvbiBydW5UZXN0MigpCit7 CisgICAgdHJ5IHsKKyAgICAgICAgZGIudHJhbnNhY3Rpb24oZnVuY3Rpb24odHgpIHsKKyAgICAg ICAgICAgIHR4LmV4ZWN1dGVTcWwoIlNFTEVDVCAqIGZyb20gRm9vQmFyIiwgW10sIGZ1bmN0aW9u KHR4KSB7CisgICAgICAgICAgICAgICAgbG9nKCJ0cmFuc2FjdGlvbjogc3RhdGVtZW50IGNhbGxi YWNrIik7CisgICAgICAgICAgICAgICAgZmluaXNoVGVzdCgpOworICAgICAgICAgICAgfSwgZnVu Y3Rpb24odHgsIGVycm9yKSB7CisgICAgICAgICAgICAgICAgbG9nKCJ0cmFuc2FjdGlvbjogc3Rh dGVtZW50IGVycm9yIGNhbGxiYWNrOiAiICsgZXJyb3IubWVzc2FnZSk7CisgICAgICAgICAgICAg ICAgZmluaXNoVGVzdCgpOworICAgICAgICAgICAgfSk7CisgICAgICAgIH0pOworICAgIH0gY2F0 Y2ggKGUpIHsKKyAgICAgICAgbG9nKCJ0cmFuc2FjdGlvbiBleGNlcHRpb246ICIgKyBlKTsKKyAg ICAgICAgZmluaXNoVGVzdCgpOworICAgIH0KK30KKzwvc2NyaXB0PiAKKzwvaGVhZD4gCis8Ym9k eSBvbmxvYWQ9InJ1blRlc3QoKSI+IAorPGRpdj5UaGlzIHRlc3RzIHRoYXQgYSBkYXRhYmFzZSBj YW4gYmUgYWNjZXNzZWQgYWZ0ZXIgY2hhbmdpbmcgaXRzIHZlcnNpb24uIFlvdSBzaG91bGQgc2Vl IGFuIGVycm9yIGFib3V0IEZvb0JhciB0YWJsZSBiZWxvdywgbm90IGFib3V0IG1pc21hdGNoaW5n IHZlcnNpb25zLiBBbHNvLCByZWxvYWRpbmcgdGhlIHBhZ2Ugc2hvdWxkIG5vdCBjYXVzZSBhbiBh c3NlcnRpb24gZmFpbHVyZS4KKzxwcmUgaWQ9InJlc3VsdCI+IAorRkFJTFVSRTogdGVzdCBkaWRu J3QgcnVuLgorPC9wcmU+IAorPC9ib2R5PiAKKzwvaHRtbD4KClByb3BlcnR5IGNoYW5nZXMgb246 IExheW91dFRlc3RzL3N0b3JhZ2UvY2hhbmdlLXZlcnNpb24taGFuZGxlLXJldXNlLmh0bWwKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpBZGRlZDogc3ZuOmVvbC1zdHlsZQogICArIG5hdGl2ZQoKSW5kZXg6IExheW91dFRl c3RzL3N0b3JhZ2UvY2hhbmdlLXZlcnNpb24uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0 cy9zdG9yYWdlL2NoYW5nZS12ZXJzaW9uLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsOTAg QEAKKzxodG1sPiAKKzxoZWFkPgorPHRpdGxlPlRlc3QgZGF0YWJhc2UuY2hhbmdlVmVyc2lvbjwv dGl0bGU+Cis8c2NyaXB0PiAKK3ZhciBkYjsKK3ZhciBFWFBFQ1RFRF9WRVJTSU9OX0FGVEVSX0hJ WElFX1RFU1QgPSAnMic7Cit2YXIgRVhQRUNURURfVkVSU0lPTl9BRlRFUl9SRUxPQUQgPSAnMyc7 CisgCitmdW5jdGlvbiBlbXB0eUZ1bmN0aW9uKCkgeyB9CisgCitmdW5jdGlvbiBjaGFuZ2VWZXJz aW9uQ2FsbGJhY2sodHgpCit7CisgICAgdHguZXhlY3V0ZVNxbCgiRFJPUCB0YWJsZSBpZiBleGlz dHMgaW5mbzsiLCBbXSwgZW1wdHlGdW5jdGlvbiwgZW1wdHlGdW5jdGlvbik7CisgICAgdHguZXhl Y3V0ZVNxbCgiQ1JFQVRFIHRhYmxlIGlmIG5vdCBleGlzdHMgaW5mbyAodmVyc2lvbiBJTlRFR0VS KTsiLCBbXSwgZW1wdHlGdW5jdGlvbiwgZW1wdHlGdW5jdGlvbik7CisgICAgdHguZXhlY3V0ZVNx bCgiSU5TRVJUIGludG8gaW5mbyB2YWx1ZXMoPyk7IiwgW0VYUEVDVEVEX1ZFUlNJT05fQUZURVJf UkVMT0FEXSwgZW1wdHlGdW5jdGlvbiwgZW1wdHlGdW5jdGlvbik7Cit9CisgCitmdW5jdGlvbiBj aGFuZ2VWZXJzaW9uU3VjY2VzcygpCit7CisgICAgbG9nKCJTdWNjZXNzZnVsbHkgY2hhbmdlZCB2 ZXJzaW9uIHRvICcgKyBkYi52ZXJzaW9uICsgJy4gUmVsb2FkaW5nLiIpOworICAgIHdpbmRvdy5s b2NhdGlvbi5ocmVmID0gd2luZG93LmxvY2F0aW9uICsgJz8yJzsKK30KKyAKK2Z1bmN0aW9uIGNo YW5nZVZlcnNpb25FcnJvcihlcnJvcikKK3sKKyAgICBsb2coIkVycm9yOiAiICsgZXJyb3IubWVz c2FnZSk7CisgICAgZmluaXNoVGVzdCgpOworfQorCitmdW5jdGlvbiBmaW5pc2hUZXN0KCkKK3sK KyAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgbG9nKCJURVNUIENPTVBMRVRFIik7Cit9CisK K2Z1bmN0aW9uIGxvZyhtZXNzYWdlKQoreworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJj b25zb2xlIikuaW5uZXJUZXh0ICs9IG1lc3NhZ2UgKyAiXG4iOworfQorCitmdW5jdGlvbiBydW5U ZXN0KCkKK3sKKyAgICBpZiAod2luZG93LmxvY2F0aW9uLnNlYXJjaCA9PSAiPzIiKSB7CisgICAg ICAgIGRiID0gd2luZG93Lm9wZW5EYXRhYmFzZSgiY2hhbmdldmVyc2lvbi10ZXN0IiwgIiIsICJU ZXN0IGZvciB0aGUgZGF0YWJhc2UuY2hhbmdlVmVyc2lvbigpIGZ1bmN0aW9uIiwgMTAyNCk7Cisg ICAgICAgIGxvZygiRmluaXNoZWQgdGVzdHMgd2l0aCB2ZXJzaW9uICIgKyBkYi52ZXJzaW9uICsg IjsgZXhwZWN0ZWQgdmVyc2lvbjogIiArIEVYUEVDVEVEX1ZFUlNJT05fQUZURVJfUkVMT0FEKTsK KyAgICAgICAgZmluaXNoVGVzdCgpOworICAgIH0gZWxzZQorICAgICAgICB0ZXN0UGFydDEoKTsK K30KKworZnVuY3Rpb24gdGVzdFBhcnQxKCkgeworICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIpIHsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuY2xlYXJBbGxEYXRhYmFz ZXMoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAg ICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CisgICAgfQorICAgIAorICAg IGRiID0gd2luZG93Lm9wZW5EYXRhYmFzZSgiY2hhbmdldmVyc2lvbi10ZXN0IiwgIiIsICJUZXN0 IGZvciB0aGUgZGF0YWJhc2UuY2hhbmdlVmVyc2lvbigpIGZ1bmN0aW9uIiwgMTAyNCk7CisKKyAg ICBpZiAoZGIudmVyc2lvbiAhPSBFWFBFQ1RFRF9WRVJTSU9OX0FGVEVSX1JFTE9BRCkgeworICAg ICAgICAvLyBGaXJzdCBydW4gSGl4aWUncyB0ZXN0IHRvIGVuc3VyZSBiYXNpYyBjaGFuZ2VWZXJz aW9uIGZ1bmN0aW9uYWxpdHkgd29ya3MgKHNlZSBidWcgMjg0MTgpLgorICAgICAgICBkYi5jaGFu Z2VWZXJzaW9uKCIiLCBFWFBFQ1RFRF9WRVJTSU9OX0FGVEVSX0hJWElFX1RFU1QsIGVtcHR5RnVu Y3Rpb24sIGZ1bmN0aW9uIChlKSB7CisgICAgICAgICAgICBsb2coJ0ZBSUwgaW4gY2hhbmdlVmVy c2lvbjonICsgZSk7CisgICAgICAgICAgICBmaW5pc2hUZXN0KCk7CisgICAgICAgIH0sIGZ1bmN0 aW9uICgpIHsKKyAgICAgICAgICAgIHRyeSB7CisgICAgICAgICAgICAgICAgdmFyIGRiMiA9IG9w ZW5EYXRhYmFzZSgiY2hhbmdlLXZlcnNpb24tdGVzdCIsIEVYUEVDVEVEX1ZFUlNJT05fQUZURVJf SElYSUVfVEVTVCwgIiIsIDApOworICAgICAgICAgICAgfSBjYXRjaCAoZSkgeworICAgICAgICAg ICAgICAgIGxvZygnRkFJTCBpbiBvcGVuRGF0YWJhc2U6ICcgKyBlKTsKKyAgICAgICAgICAgICAg ICBmaW5pc2hUZXN0KCk7CisgICAgICAgICAgICB9CisgICAgICAgICAgICAvLyBUaGUgdHdvIGRh dGFiYXNlIHZlcnNpb25zIHNob3VsZCBtYXRjaC4KKyAgICAgICAgICAgIGlmIChkYi52ZXJzaW9u ID09IGRiMi52ZXJzaW9uKQorICAgICAgICAgICAgICAgIGxvZygiUEFTUzogZGIudmVyc2lvbigi ICsgZGIudmVyc2lvbiArICIpIG1hdGNoZXMgZGIyLnZlcnNpb24oIiArIGRiMi52ZXJzaW9uICsi KSBhcyBleHBlY3RlZC4iKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBsb2co IkZBSUw6IGRiLnZlcnNpb24oIiArIGRiLnZlcnNpb24gKyAiKSBkb2VzIG5vdCBkYjIudmVyc2lv bigiICsgZGIyLnZlcnNpb24gKyIpIik7CisKKyAgICAgICAgICAgIC8vIE5vdyB0cnkgYSB0ZXN0 IHRvIGVuc3VyZSB0aGUgdmVyc2lvbiBwZXJzaXN0cyBhZnRlciByZWxvYWRpbmcgKHNlZSBidWcg Mjc4MzYpCisgICAgICAgICAgICBkYi5jaGFuZ2VWZXJzaW9uKEVYUEVDVEVEX1ZFUlNJT05fQUZU RVJfSElYSUVfVEVTVCwgRVhQRUNURURfVkVSU0lPTl9BRlRFUl9SRUxPQUQsIGNoYW5nZVZlcnNp b25DYWxsYmFjaywgY2hhbmdlVmVyc2lvbkVycm9yLCBjaGFuZ2VWZXJzaW9uU3VjY2Vzcyk7Cisg ICAgICAgIH0pOworICAgIH0KK30KKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHkgb25sb2FkPSJy dW5UZXN0KCk7Ij4KK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBKUyBkYXRhYmFzZS5jaGFu Z2VWZXJzaW9uKCkgZnVuY3Rpb24gd29ya3MgYXMgZXhwZWN0ZWQuCis8cHJlIGlkPSJjb25zb2xl Ij48L3ByZT4KKzwvYm9keT4KKzwvaHRtbD4KClByb3BlcnR5IGNoYW5nZXMgb246IExheW91dFRl c3RzL3N0b3JhZ2UvY2hhbmdlLXZlcnNpb24uaHRtbApfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkFkZGVkOiBzdm46ZW9s LXN0eWxlCiAgICsgbmF0aXZlCgo=