48614 2010-10-28 20:46:53 -0700 webkitpy.layout_tests.run_webkit_tests_unittest.MainTest gets wedged on Windows XP/Cygwin 1.5/Python 2.5.2 2011-11-05 16:27:12 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) PC Windows XP RESOLVED DUPLICATE 71593 http://build.webkit.org/builders/Windows%20Release%20(Tests)/builds/5747/steps/webkitpy-test/logs/stdio InRadar P2 Normal --- 55811 1 aroben webkit-unassigned abarth dpranke eric ojan tony oldest_to_newest 301561 0 aroben 2010-10-28 20:46:53 -0700 To reproduce: 1. test-webkitpy webkitpy.layout_tests.run_webkit_tests_unittest.MainTest.test_basic On Windows XP with Cygwin 1.5 and Python 2.5.2, this wedges Python. It may also happen in other configurations. It is known not to happen with Windows 7/Cygwin 1.7/Python 2.6.5. 302738 1 aroben 2010-11-01 09:18:18 -0700 In the meantime we should skip this test when this configuration is detected. 302828 2 dpranke 2010-11-01 11:58:02 -0700 That's not a single test, it's a whole class of tests. AFAIK, there isn't a way to disable a whole class is there? Note that I do agree with you though; we should be skipping these tests if they're hanging. 302858 3 aroben 2010-11-01 13:00:30 -0700 (In reply to comment #2) > That's not a single test, it's a whole class of tests. AFAIK, there isn't a way to disable a whole class is there? There is in Python 3.1+ via a decorator. We can emulate it in older versions. 302910 4 72555 aroben 2010-11-01 14:06:55 -0700 Created attachment 72555 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x 302912 5 72555 aroben 2010-11-01 14:07:30 -0700 Comment on attachment 72555 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x View in context: https://bugs.webkit.org/attachment.cgi?id=72555&action=review > WebKitTools/Scripts/webkitpy/test/skip.py:39 > +def skip_if(klass, condition, message=None): > + if not condition: > + return klass > + for name in dir(klass): > + attr = getattr(klass, name) > + if not callable(attr): > + continue > + if not name.startswith('test_'): > + continue > + setattr(klass, name, _skipped_method(attr)) > + klass._printed_skipped_message = False > + return klass I'm not sure of the best way to test skip_if. Any suggestions? 302936 6 72555 dpranke 2010-11-01 14:26:24 -0700 Comment on attachment 72555 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x View in context: https://bugs.webkit.org/attachment.cgi?id=72555&action=review change looks reasonable to me. I assume this is backported from code in 3.2 or other parts of unittest? Sadly, I'm not a reviewer so you'll still need someone else to r+ this. >> WebKitTools/Scripts/webkitpy/test/skip.py:39 >> + return klass > > I'm not sure of the best way to test skip_if. Any suggestions? I would create a dummy class, e.g.: TestSkipFixture(object): def test_foo(self): pass and then call skip_if(TestSkipFixture, True), then call test_foo() and use outputcapture to ensure the messages get logged. And vice-versa for skip_if(TestSkipFixture, False). 302991 7 aroben 2010-11-01 15:29:56 -0700 (In reply to comment #6) > (From update of attachment 72555 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=72555&action=review > > change looks reasonable to me. I assume this is backported from code in 3.2 or other parts of unittest? Yes, backported from 3.1+. > >> WebKitTools/Scripts/webkitpy/test/skip.py:39 > >> + return klass > > > > I'm not sure of the best way to test skip_if. Any suggestions? > > I would create a dummy class, e.g.: > > TestSkipFixture(object): > def test_foo(self): > pass > > and then call skip_if(TestSkipFixture, True), then call test_foo() and use outputcapture to ensure the messages get logged. And vice-versa for skip_if(TestSkipFixture, False). Thanks for the suggestion. Unfortunately outputcapture doesn't seem to be capturing the output from skip_if's logger. Any ideas why that might be happening? Maybe the logger buffers its input? 302998 8 dpranke 2010-11-01 15:40:47 -0700 (In reply to comment #7) > > Thanks for the suggestion. Unfortunately outputcapture doesn't seem to be capturing the output from skip_if's logger. Any ideas why that might be happening? Maybe the logger buffers its input? The loggers don't buffer any input, so that's not going to be it. It could be a couple of things. You didn't say in what environment it wasn't working, or how you know that outputcapture isn't capturing it. So, I'll guess that the regular stderr logger isn't configured to print messages at log.info. You might need to do something like: import logging class Test(unittest.TestCase) def setUp(): self.logger = logging.getLogger() self.old_level = self.logger.level self.logger.setLevel(logging.INFO) def tearDown(): self.logger.setLevel(self._old_level) def test_skip_if(self): ... If that doesn't work, lmk or ping me on IRC and upload whatever patch you have so I can take a look and see if I can reproduce it. 303357 9 72665 aroben 2010-11-02 08:04:36 -0700 Created attachment 72665 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x 303369 10 aroben 2010-11-02 08:29:06 -0700 <rdar://problem/8620361> 303373 11 72671 aroben 2010-11-02 08:31:45 -0700 Created attachment 72671 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x 303533 12 72671 dpranke 2010-11-02 12:01:17 -0700 Comment on attachment 72671 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x Change basically looks good to me. Can you add a comment to skip_if noting that this class is backported from 3.1+ ? Also, I've discussed this w/ eseidel, but we should add the scaffolding to outputcapture to do install and remove logging handlers so that you don't have to do the stuff you did in setUp() and tearDown(). 303535 13 72671 abarth 2010-11-02 12:02:37 -0700 Comment on attachment 72671 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x Cool. 303536 14 aroben 2010-11-02 12:03:32 -0700 (In reply to comment #12) > (From update of attachment 72671 [details]) > Change basically looks good to me. Can you add a comment to skip_if noting that this class is backported from 3.1+ ? Done. > Also, I've discussed this w/ eseidel, but we should add the scaffolding to outputcapture to do install and remove logging handlers so that you don't have to do the stuff you did in setUp() and tearDown(). That would be great! 303539 15 aroben 2010-11-02 12:09:23 -0700 Committed r71146: <http://trac.webkit.org/changeset/71146> 303541 16 aroben 2010-11-02 12:10:07 -0700 Leaving this bug open to cover unwedging the tests on this platform. 303552 17 72671 eric 2010-11-02 12:30:00 -0700 Comment on attachment 72671 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x View in context: https://bugs.webkit.org/attachment.cgi?id=72671&action=review abarth let you off easy. :) > WebKitTools/ChangeLog:18 > + unittest.skip_if decorator added in Python 3.1. false. it's skipIf and added in 2.7: http://docs.python.org/library/unittest.html#unittest.skipIf > WebKitTools/Scripts/webkitpy/test/skip.py:28 > +def skip_if(klass, condition, message=None, logger=None): We should note that this exists in 2.7: http://docs.python.org/library/unittest.html#unittest.skipIf Why does your decorator look so different from the one I wrote for memoized? Is this a "new" style? I guess this is a class decorator not a function decorator? > WebKitTools/Scripts/webkitpy/test/skip_unittest.py:41 > + > + self.old_level = self.logger.level > + self.logger.setLevel(logging.INFO) > + > + self.old_propagate = self.logger.propagate > + self.logger.propagate = False > + > + self.log_stream = StringIO.StringIO() > + self.handler = logging.StreamHandler(self.log_stream) So this is using "INFO" because currently INFO isnt' logged? Maybe this integrates with dpranke's attempt to make OutputCapture understand python logging.py? OutputCapture is our current way of grabbing output during a unit test and should be taught how to grab logging.py output too, by teaching it about the wekbit-patch logging handler (currently > INFO) and how to disable/remove it while an OutputCapture is in place. > WebKitTools/Scripts/webkitpy/test/skip_unittest.py:59 > + def create_fixture_class(self): > + class TestSkipFixture(object): > + def __init__(self, callback): > + self.callback = callback > + > + def test_foo(self): > + self.callback() > + > + return TestSkipFixture I'm confused why not just declare this at the top of the file? Creating it dynamically in this method doesn't make much sense to me? > WebKitTools/Scripts/webkitpy/test/skip_unittest.py:65 > + klass = skip_if(self.create_fixture_class(), False, 'Should not see this message.', logger=self.logger) Would have been nice to see an example of it using the decorator syntax. > WebKitTools/Scripts/webkitpy/test/skip_unittest.py:75 > + two spaces. 303562 18 72671 aroben 2010-11-02 12:40:18 -0700 Comment on attachment 72671 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x View in context: https://bugs.webkit.org/attachment.cgi?id=72671&action=review Thanks for taking a look! >> WebKitTools/ChangeLog:18 >> + unittest.skip_if decorator added in Python 3.1. > > false. it's skipIf and added in 2.7: http://docs.python.org/library/unittest.html#unittest.skipIf OK, I got confused by the "New in version 3.1" from <http://docs.python.org/dev/library/unittest.html#skipping-tests-and-expected-failures>. That doesn't explain the typo, though. >> WebKitTools/Scripts/webkitpy/test/skip.py:28 >> +def skip_if(klass, condition, message=None, logger=None): > > We should note that this exists in 2.7: http://docs.python.org/library/unittest.html#unittest.skipIf > > Why does your decorator look so different from the one I wrote for memoized? Is this a "new" style? > > I guess this is a class decorator not a function decorator? I added a docstring in the patch I checked in based on Dirk's suggestion. I assume the decorator looks different because it is a class decorator. >> WebKitTools/Scripts/webkitpy/test/skip_unittest.py:41 >> + self.handler = logging.StreamHandler(self.log_stream) > > So this is using "INFO" because currently INFO isnt' logged? Maybe this integrates with dpranke's attempt to make OutputCapture understand python logging.py? OutputCapture is our current way of grabbing output during a unit test and should be taught how to grab logging.py output too, by teaching it about the wekbit-patch logging handler (currently > INFO) and how to disable/remove it while an OutputCapture is in place. Yes, Dirk said basically the same thing in comment 12. >> WebKitTools/Scripts/webkitpy/test/skip_unittest.py:59 >> + return TestSkipFixture > > I'm confused why not just declare this at the top of the file? Creating it dynamically in this method doesn't make much sense to me? The decorator modifies the class itself. Since we want to test skip_if twice (once with True and once with False) we need to have two different classes so that the tests don't interfere with each other. Maybe I should have added a comment. >> WebKitTools/Scripts/webkitpy/test/skip_unittest.py:65 >> + klass = skip_if(self.create_fixture_class(), False, 'Should not see this message.', logger=self.logger) > > Would have been nice to see an example of it using the decorator syntax. My understanding is that class decorator syntax wasn't added until Python 2.6. >> WebKitTools/Scripts/webkitpy/test/skip_unittest.py:75 >> + > > two spaces. Hm, check-webkit-style didn't complain here. 303593 19 eric 2010-11-02 13:01:21 -0700 (In reply to comment #18) > (From update of attachment 72671 [details]) > I assume the decorator looks different because it is a class decorator. What does the class decorator syntax look like? I wonder if we want a class decorator or just function decorators like unittest seems to have? > >> WebKitTools/Scripts/webkitpy/test/skip_unittest.py:59 > >> + return TestSkipFixture > > > > I'm confused why not just declare this at the top of the file? Creating it dynamically in this method doesn't make much sense to me? > > The decorator modifies the class itself. Since we want to test skip_if twice (once with True and once with False) we need to have two different classes so that the tests don't interfere with each other. Maybe I should have added a comment. Yeah, I'm just not sure what a "class decorator" looks like, and I'm not sure we want one over method decorators. We could basically write our own wkunittest.py module, and then use things like this via: @wkunittest.skipIf(condition) I think it would be *super awesome* to be able to use more of the new skip* stuff from unittest, so I'm glad you've started us down that path. I just think we should try to be as much like the stuff coming in python 2.7 instead of inventing our own syntax. > >> WebKitTools/Scripts/webkitpy/test/skip_unittest.py:65 > >> + klass = skip_if(self.create_fixture_class(), False, 'Should not see this message.', logger=self.logger) > > > > Would have been nice to see an example of it using the decorator syntax. > > My understanding is that class decorator syntax wasn't added until Python 2.6. http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/webkitpy/common/memoized.py seems to work with 2.5. :) 303594 20 eric 2010-11-02 13:02:03 -0700 Obviously if when we skip this test we should add a FIXME, since we still dont' seem to understand why it wedges. 303599 21 dpranke 2010-11-02 13:10:57 -0700 (In reply to comment #19) > > Yeah, I'm just not sure what a "class decorator" looks like, and I'm not sure we want one over method decorators. > I think the class decorator mechanism is useful to avoid a lot of cutting and pasting, since we know none of the tests in that class are going to work. It seems like skipping modules and classes would be generally useful in our testing infrastructure. I've actually been debating looking at switching to unittest2, since it has all the 2.7+ goodness but has been backported to work with the earlier versions. -- Dirk 303602 22 aroben 2010-11-02 13:12:36 -0700 (In reply to comment #19) > (In reply to comment #18) > > (From update of attachment 72671 [details] [details]) > > I assume the decorator looks different because it is a class decorator. > > What does the class decorator syntax look like? I wonder if we want a class decorator or just function decorators like unittest seems to have? Class decorator syntax looks just like method decorator syntax, except you put it above a class declaration instead of a method declaration: @mydecorator class MyClass: You can see an example in <http://docs.python.org/library/unittest.html#skipping-tests-and-expected-failures> where it says "Classes can be skipped just like methods:" > > >> WebKitTools/Scripts/webkitpy/test/skip_unittest.py:59 > > >> + return TestSkipFixture > > > > > > I'm confused why not just declare this at the top of the file? Creating it dynamically in this method doesn't make much sense to me? > > > > The decorator modifies the class itself. Since we want to test skip_if twice (once with True and once with False) we need to have two different classes so that the tests don't interfere with each other. Maybe I should have added a comment. > > Yeah, I'm just not sure what a "class decorator" looks like, and I'm not sure we want one over method decorators. Hopefully the above information will help you. > We could basically write our own wkunittest.py module, and then use things like this via: > @wkunittest.skipIf(condition) Sure, that sounds fine. > I think it would be *super awesome* to be able to use more of the new skip* stuff from unittest, so I'm glad you've started us down that path. I just think we should try to be as much like the stuff coming in python 2.7 instead of inventing our own syntax. OK. > > >> WebKitTools/Scripts/webkitpy/test/skip_unittest.py:65 > > >> + klass = skip_if(self.create_fixture_class(), False, 'Should not see this message.', logger=self.logger) > > > > > > Would have been nice to see an example of it using the decorator syntax. > > > > My understanding is that class decorator syntax wasn't added until Python 2.6. > > http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/webkitpy/common/memoized.py > seems to work with 2.5. :) memoized is a method decorator, not a class decorator. 303684 23 72671 eric 2010-11-02 14:46:01 -0700 Comment on attachment 72671 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x View in context: https://bugs.webkit.org/attachment.cgi?id=72671&action=review > WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests_unittest.py:292 > +MainTest = skip_if(MainTest, sys.platform == 'cygwin' and compare_version(sys, '2.6')[0] < 0, 'new-run-webkit-tests tests hang on Cygwin Python 2.5.2') OK. Since python 2.5 doesn't have class decorator syntax (pardon my confusion) this seems fine. 413070 24 dpranke 2011-05-31 18:48:24 -0700 disclaiming ownership on this one; I'm probably not going to look at it any time soon. I'm not sure if it's even relevant any more. Adam, can we assume that everything is on Cygwin 7 (or can be made to be) instead? 496725 25 eric 2011-11-05 16:27:12 -0700 We no longer support Python 2.5 in WebKit, so this can be closed, right? *** This bug has been marked as a duplicate of bug 71593 *** 72555 2010-11-01 14:06:55 -0700 2010-11-02 08:04:29 -0700 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x bug-48614-20101101170705.patch text/plain 4744 aroben ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBkMTFkNTg1MTI4NGUyZjQ4ZTk0YWFjYjg3OTdhMmFkMjBjN2Q0MmEyLi5hODZiNDA1 ZGE1OGMwYmQyNDI3YjU5YjRlMjg5YWRkMzEwMDE4N2ZhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAK KzIwMTAtMTEtMDEgIEFkYW0gUm9iZW4gIDxhcm9iZW5AYXBwbGUuY29tPgorCisgICAgICAgIFNr aXAgd2Via2l0cHkubGF5b3V0X3Rlc3RzLnJ1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QuTWFpblRl c3Qgb24gQ3lnd2luCisgICAgICAgIFB5dGhvbiAyLjUueAorCisgICAgICAgIEl0IGlzIGtub3du IHRvIGhhbmcgb24gdGhhdCB2ZXJzaW9uIG9mIFB5dGhvbi4gU2VlCisgICAgICAgIDxodHRwOi8v d2Via2l0Lm9yZy9iLzQ4NjE0Pi4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRf dGVzdHNfdW5pdHRlc3QucHk6IFVzZQorICAgICAgICBza2lwX2lmIHRvIHNraXAgTWFpblRlc3Qg b24gQ3lnd2luIFB5dGhvbiAyLjUueC4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVz dC9za2lwLnB5OiBBZGRlZC4KKyAgICAgICAgKHNraXBfaWYpOiBJZiB0aGUgcGFzc2VkLWluIGNv bmRpdGlvbiBpcyBmYWxzZSwgZmluZCBhbGwgdGhlIHRlc3RfKgorICAgICAgICBtZXRob2RzIG9m IHRoZSBnaXZlbiBjbGFzcyBhbmQgcmVwbGFjZSB0aGVtIHdpdGggYSBmdW5jdGlvbiB0aGF0IGp1 c3QKKyAgICAgICAgbG9ncyB0aGF0IHdlJ3JlIHNraXBwaW5nIHRoZXNlIHRlc3RzLgorICAgICAg ICAoX3NraXBwZWRfbWV0aG9kKTogUmV0dXJucyBhIGZ1bmN0aW9uIHRoYXQganVzdCBsb2dzIHRo YXQgdGhlIHRlc3RzIGFyZQorICAgICAgICBiZWluZyBza2lwcGVkLiBUaGlzIGlzIHVzZWQgaW4g cGxhY2Ugb2YgdGhlIGFjdHVhbCB0ZXN0XyogZnVuY3Rpb25zLgorCiAyMDEwLTExLTAxICBTw7hy ZW4gR2plc3NlICA8c2dqZXNzZUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg QW5kcmVhcyBLbGluZy4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QucHkgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0LnB5 CmluZGV4IDBmMDlmZmEwNDM0MjNkNzM1Y2MwYTNkM2M2NjcxNWQ1MzdhYWE2MTQuLjc0YjczMWMz MTNkMmM4ZWIxYzI2YTkyZTk4OTZjODViNmI1ZTMxYWQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3Qu cHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dl YmtpdF90ZXN0c191bml0dGVzdC5weQpAQCAtNDksNiArNDksOCBAQCBmcm9tIHdlYmtpdHB5Lmxh eW91dF90ZXN0cyBpbXBvcnQgcG9ydAogZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMgaW1wb3J0 IHJ1bl93ZWJraXRfdGVzdHMKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLmxheW91dF9wYWNr YWdlIGltcG9ydCBkdW1wX3JlbmRlcl90cmVlX3RocmVhZAogZnJvbSB3ZWJraXRweS5sYXlvdXRf dGVzdHMucG9ydC50ZXN0IGltcG9ydCBUZXN0UG9ydAorZnJvbSB3ZWJraXRweS5weXRob24yNC52 ZXJzaW9uaW5nIGltcG9ydCBjb21wYXJlX3ZlcnNpb24KK2Zyb20gd2Via2l0cHkudGVzdC5za2lw IGltcG9ydCBza2lwX2lmCiAKIGZyb20gd2Via2l0cHkudGhpcmRwYXJ0eS5tb2NrIGltcG9ydCBN b2NrCiAKQEAgLTI4Nyw2ICsyODksOCBAQCBjbGFzcyBNYWluVGVzdCh1bml0dGVzdC5UZXN0Q2Fz ZSk6CiAgICAgICAgIHRlc3RfcG9ydCA9IGdldF9wb3J0X2Zvcl9ydW4oYmFzZV9hcmdzKQogICAg ICAgICBzZWxmLmFzc2VydEVxdWFsKE5vbmUsIHRlc3RfcG9ydC50b2xlcmFuY2VfdXNlZF9mb3Jf ZGlmZl9pbWFnZSkKIAorTWFpblRlc3QgPSBza2lwX2lmKE1haW5UZXN0LCBzeXMucGxhdGZvcm0g PT0gJ2N5Z3dpbicgYW5kIGNvbXBhcmVfdmVyc2lvbihzeXMsICcyLjYnKVswXSA8IDAsICduZXct cnVuLXdlYmtpdC10ZXN0IHRlc3RzIGhhbmcgb24gQ3lnd2luIFB5dGhvbiAyLjUuMicpCisKIAog ZGVmIF9tb2NrZWRfb3BlbihvcmlnaW5hbF9vcGVuLCBmaWxlX2xpc3QpOgogICAgIGRlZiBfd3Jh cHBlcihuYW1lLCBtb2RlLCBlbmNvZGluZyk6CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L3Rlc3Qvc2tpcC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dGVzdC9za2lwLnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjYwZTQzMDJlODc4NWIyYzhkNzgyMzE5ZDZlZTk2Yjg0 YTcwZmVmOTgKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L3Rlc3Qvc2tpcC5weQpAQCAtMCwwICsxLDQ4IEBACisjIENvcHlyaWdodCAoQykgMjAxMCBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyMgYXJlIG1ldDoKKyMgMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuICBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorIyAg ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorIyAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQK KyMgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFIElNUExJRUQKKyMgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorIyBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxF IEZPUgorIyBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMCisjIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SCisjIFNFUlZJQ0VTOyBM T1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSCisjIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksCisjIE9SIFRPUlQgKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisj IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisKK2ltcG9ydCBsb2dnaW5nCisKK19sb2cgPSBsb2dnaW5nLmdldExvZ2dl cihfX25hbWVfXykKKworCitkZWYgc2tpcF9pZihrbGFzcywgY29uZGl0aW9uLCBtZXNzYWdlPU5v bmUpOgorICAgIGlmIG5vdCBjb25kaXRpb246CisgICAgICAgIHJldHVybiBrbGFzcworICAgIGZv ciBuYW1lIGluIGRpcihrbGFzcyk6CisgICAgICAgIGF0dHIgPSBnZXRhdHRyKGtsYXNzLCBuYW1l KQorICAgICAgICBpZiBub3QgY2FsbGFibGUoYXR0cik6CisgICAgICAgICAgICBjb250aW51ZQor ICAgICAgICBpZiBub3QgbmFtZS5zdGFydHN3aXRoKCd0ZXN0XycpOgorICAgICAgICAgICAgY29u dGludWUKKyAgICAgICAgc2V0YXR0cihrbGFzcywgbmFtZSwgX3NraXBwZWRfbWV0aG9kKGF0dHIp KQorICAgIGtsYXNzLl9wcmludGVkX3NraXBwZWRfbWVzc2FnZSA9IEZhbHNlCisgICAgcmV0dXJu IGtsYXNzCisKKworZGVmIF9za2lwcGVkX21ldGhvZChtZXRob2QpOgorICAgIGRlZiBfc2tpcCgq YXJncyk6CisgICAgICAgIGlmIG1ldGhvZC5pbV9jbGFzcy5fcHJpbnRlZF9za2lwcGVkX21lc3Nh Z2U6CisgICAgICAgICAgICByZXR1cm4KKyAgICAgICAgbWV0aG9kLmltX2NsYXNzLl9wcmludGVk X3NraXBwZWRfbWVzc2FnZSA9IFRydWUKKyAgICAgICAgX2xvZy5pbmZvKCdTa2lwcGluZyAlcy4l cycgJSAobWV0aG9kLl9fbW9kdWxlX18sIG1ldGhvZC5pbV9jbGFzcy5fX25hbWVfXykpCisgICAg cmV0dXJuIF9za2lwCg== 72665 2010-11-02 08:04:36 -0700 2010-11-02 08:31:37 -0700 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x bug-48614-20101102110438.patch text/plain 8324 aroben ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAwNDEzY2RhNDc1MzViODVlMThiY2ZjNDc2Mjk4OGVkOTc3ZTA2MTc1Li4yMzRjMjkw Y2VlYWIxMzQxZTljYTk2ZmI1NDQ4YTlmMjlkMDI5MTFlIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAK KzIwMTAtMTEtMDEgIEFkYW0gUm9iZW4gIDxhcm9iZW5AYXBwbGUuY29tPgorCisgICAgICAgIFNr aXAgd2Via2l0cHkubGF5b3V0X3Rlc3RzLnJ1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QuTWFpblRl c3Qgb24gQ3lnd2luCisgICAgICAgIFB5dGhvbiAyLjUueAorCisgICAgICAgIEl0IGlzIGtub3du IHRvIGhhbmcgb24gdGhhdCB2ZXJzaW9uIG9mIFB5dGhvbi4gU2VlCisgICAgICAgIDxodHRwOi8v d2Via2l0Lm9yZy9iLzQ4NjE0Pi4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRf dGVzdHNfdW5pdHRlc3QucHk6IFVzZQorICAgICAgICBza2lwX2lmIHRvIHNraXAgTWFpblRlc3Qg b24gQ3lnd2luIFB5dGhvbiAyLjUueC4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVz dC9za2lwLnB5OiBBZGRlZC4KKyAgICAgICAgKHNraXBfaWYpOiBJZiB0aGUgcGFzc2VkLWluIGNv bmRpdGlvbiBpcyBmYWxzZSwgZmluZCBhbGwgdGhlIHRlc3RfKgorICAgICAgICBtZXRob2RzIG9m IHRoZSBnaXZlbiBjbGFzcyBhbmQgcmVwbGFjZSB0aGVtIHdpdGggYSBmdW5jdGlvbiB0aGF0IGp1 c3QKKyAgICAgICAgbG9ncyB0aGF0IHdlJ3JlIHNraXBwaW5nIHRoZXNlIHRlc3RzLgorICAgICAg ICAoX3NraXBwZWRfbWV0aG9kKTogUmV0dXJucyBhIGZ1bmN0aW9uIHRoYXQganVzdCBsb2dzIHRo YXQgdGhlIHRlc3RzIGFyZQorICAgICAgICBiZWluZyBza2lwcGVkLiBUaGlzIGlzIHVzZWQgaW4g cGxhY2Ugb2YgdGhlIGFjdHVhbCB0ZXN0XyogZnVuY3Rpb25zLgorCiAyMDEwLTExLTAxICBKZW5u IEJyYWl0aHdhaXRlICA8amVubmJAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5 IEFkYW0gUm9iZW4uCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0c191bml0dGVzdC5weQpp bmRleCAwZjA5ZmZhMDQzNDIzZDczNWNjMGEzZDNjNjY3MTVkNTM3YWFhNjE0Li4yNjcyNTA4NGE5 NmZkNTM3NDI3M2QyZGQ3ZGU1N2IwMDBmMmNhOTRlIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0LnB5 CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJr aXRfdGVzdHNfdW5pdHRlc3QucHkKQEAgLTQ5LDYgKzQ5LDggQEAgZnJvbSB3ZWJraXRweS5sYXlv dXRfdGVzdHMgaW1wb3J0IHBvcnQKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzIGltcG9ydCBy dW5fd2Via2l0X3Rlc3RzCiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5sYXlvdXRfcGFja2Fn ZSBpbXBvcnQgZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rl c3RzLnBvcnQudGVzdCBpbXBvcnQgVGVzdFBvcnQKK2Zyb20gd2Via2l0cHkucHl0aG9uMjQudmVy c2lvbmluZyBpbXBvcnQgY29tcGFyZV92ZXJzaW9uCitmcm9tIHdlYmtpdHB5LnRlc3Quc2tpcCBp bXBvcnQgc2tpcF9pZgogCiBmcm9tIHdlYmtpdHB5LnRoaXJkcGFydHkubW9jayBpbXBvcnQgTW9j awogCkBAIC0yODcsNiArMjg5LDggQEAgY2xhc3MgTWFpblRlc3QodW5pdHRlc3QuVGVzdENhc2Up OgogICAgICAgICB0ZXN0X3BvcnQgPSBnZXRfcG9ydF9mb3JfcnVuKGJhc2VfYXJncykKICAgICAg ICAgc2VsZi5hc3NlcnRFcXVhbChOb25lLCB0ZXN0X3BvcnQudG9sZXJhbmNlX3VzZWRfZm9yX2Rp ZmZfaW1hZ2UpCiAKK01haW5UZXN0ID0gc2tpcF9pZihNYWluVGVzdCwgc3lzLnBsYXRmb3JtID09 ICdjeWd3aW4nIGFuZCBjb21wYXJlX3ZlcnNpb24oc3lzLCAnMi42JylbMF0gPCAwLCAnbmV3LXJ1 bi13ZWJraXQtdGVzdHMgdGVzdHMgaGFuZyBvbiBDeWd3aW4gUHl0aG9uIDIuNS4yJykKKwogCiBk ZWYgX21vY2tlZF9vcGVuKG9yaWdpbmFsX29wZW4sIGZpbGVfbGlzdCk6CiAgICAgZGVmIF93cmFw cGVyKG5hbWUsIG1vZGUsIGVuY29kaW5nKToKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvdGVzdC9za2lwLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90 ZXN0L3NraXAucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZWZmMGQ0ODZiMTAyYzU3OWY1ZGU5OGNmYWFlODdkMDc0 Mzc5MDdhMQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dGVzdC9za2lwLnB5CkBAIC0wLDAgKzEsNTAgQEAKKyMgQ29weXJpZ2h0IChDKSAyMDEwIEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor IyBhcmUgbWV0OgorIyAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgMi4gIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisjICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORAor IyBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRAorIyBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisjIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SCisjIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExB UlksIE9SIENPTlNFUVVFTlRJQUwKKyMgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IKKyMgU0VSVklDRVM7IExP U1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhP V0VWRVIKKyMgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwKKyMgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMg T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKworaW1wb3J0IGxvZ2dpbmcKKworX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2Vy KF9fbmFtZV9fKQorCisKK2RlZiBza2lwX2lmKGtsYXNzLCBjb25kaXRpb24sIG1lc3NhZ2U9Tm9u ZSwgbG9nZ2VyPU5vbmUpOgorICAgIGlmIG5vdCBsb2dnZXI6CisgICAgICAgIGxvZ2dlciA9IF9s b2cKKyAgICBpZiBub3QgY29uZGl0aW9uOgorICAgICAgICByZXR1cm4ga2xhc3MKKyAgICBmb3Ig bmFtZSBpbiBkaXIoa2xhc3MpOgorICAgICAgICBhdHRyID0gZ2V0YXR0cihrbGFzcywgbmFtZSkK KyAgICAgICAgaWYgbm90IGNhbGxhYmxlKGF0dHIpOgorICAgICAgICAgICAgY29udGludWUKKyAg ICAgICAgaWYgbm90IG5hbWUuc3RhcnRzd2l0aCgndGVzdF8nKToKKyAgICAgICAgICAgIGNvbnRp bnVlCisgICAgICAgIHNldGF0dHIoa2xhc3MsIG5hbWUsIF9za2lwcGVkX21ldGhvZChhdHRyLCBt ZXNzYWdlLCBsb2dnZXIpKQorICAgIGtsYXNzLl9wcmludGVkX3NraXBwZWRfbWVzc2FnZSA9IEZh bHNlCisgICAgcmV0dXJuIGtsYXNzCisKKworZGVmIF9za2lwcGVkX21ldGhvZChtZXRob2QsIG1l c3NhZ2UsIGxvZ2dlcik6CisgICAgZGVmIF9za2lwKCphcmdzKToKKyAgICAgICAgaWYgbWV0aG9k LmltX2NsYXNzLl9wcmludGVkX3NraXBwZWRfbWVzc2FnZToKKyAgICAgICAgICAgIHJldHVybgor ICAgICAgICBtZXRob2QuaW1fY2xhc3MuX3ByaW50ZWRfc2tpcHBlZF9tZXNzYWdlID0gVHJ1ZQor ICAgICAgICBsb2dnZXIuaW5mbygnU2tpcHBpbmcgJXMuJXM6ICVzJyAlIChtZXRob2QuX19tb2R1 bGVfXywgbWV0aG9kLmltX2NsYXNzLl9fbmFtZV9fLCBtZXNzYWdlKSkKKyAgICByZXR1cm4gX3Nr aXAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9za2lwX3Vu aXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS90ZXN0L3NraXBfdW5pdHRl c3QucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uZjYxYTFiYjQ3OGE3NjJkZjFiZjE4ODA3YjEzYTFkMWU5OTg4ZDll ZgotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9z a2lwX3VuaXR0ZXN0LnB5CkBAIC0wLDAgKzEsNzcgQEAKKyMgQ29weXJpZ2h0IChDKSAyMDEwIEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworIyBhcmUgbWV0OgorIyAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgMi4gIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisj ICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCisjICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorIworIyBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFO RAorIyBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorIyBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisjIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SCisjIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVN UExBUlksIE9SIENPTlNFUVVFTlRJQUwKKyMgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IKKyMgU0VSVklDRVM7 IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIKKyMgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwKKyMgT1IgVE9SVCAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UK KyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKworaW1wb3J0IFN0cmluZ0lPCitpbXBvcnQgbG9nZ2luZworaW1wb3J0 IHVuaXR0ZXN0CisKK2Zyb20gd2Via2l0cHkudGVzdC5za2lwIGltcG9ydCBza2lwX2lmCisKKwor Y2xhc3MgU2tpcFRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgorICAgIGRlZiBzZXRVcChzZWxmKToK KyAgICAgICAgc2VsZi5sb2dnZXIgPSBsb2dnaW5nLmdldExvZ2dlcihfX25hbWVfXykKKworICAg ICAgICBzZWxmLm9sZF9sZXZlbCA9IHNlbGYubG9nZ2VyLmxldmVsCisgICAgICAgIHNlbGYubG9n Z2VyLnNldExldmVsKGxvZ2dpbmcuSU5GTykKKworICAgICAgICBzZWxmLm9sZF9wcm9wYWdhdGUg PSBzZWxmLmxvZ2dlci5wcm9wYWdhdGUKKyAgICAgICAgc2VsZi5sb2dnZXIucHJvcGFnYXRlID0g RmFsc2UKKworICAgICAgICBzZWxmLmxvZ19zdHJlYW0gPSBTdHJpbmdJTy5TdHJpbmdJTygpCisg ICAgICAgIHNlbGYuaGFuZGxlciA9IGxvZ2dpbmcuU3RyZWFtSGFuZGxlcihzZWxmLmxvZ19zdHJl YW0pCisgICAgICAgIHNlbGYubG9nZ2VyLmFkZEhhbmRsZXIoc2VsZi5oYW5kbGVyKQorCisgICAg ICAgIHNlbGYuZm9vX3dhc19jYWxsZWQgPSBGYWxzZQorCisgICAgZGVmIHRlYXJEb3duKHNlbGYp OgorICAgICAgICBzZWxmLmxvZ2dlci5yZW1vdmVIYW5kbGVyKHNlbGYuaGFuZGxlcikKKyAgICAg ICAgc2VsZi5wcm9wYWdhdGUgPSBzZWxmLm9sZF9wcm9wYWdhdGUKKyAgICAgICAgc2VsZi5sb2dn ZXIuc2V0TGV2ZWwoc2VsZi5vbGRfbGV2ZWwpCisKKyAgICBkZWYgY3JlYXRlX2ZpeHR1cmVfY2xh c3Moc2VsZik6CisgICAgICAgIGNsYXNzIFRlc3RTa2lwRml4dHVyZShvYmplY3QpOgorICAgICAg ICAgICAgZGVmIF9faW5pdF9fKHNlbGYsIGNhbGxiYWNrKToKKyAgICAgICAgICAgICAgICBzZWxm LmNhbGxiYWNrID0gY2FsbGJhY2sKKworICAgICAgICAgICAgZGVmIHRlc3RfZm9vKHNlbGYpOgor ICAgICAgICAgICAgICAgIHNlbGYuY2FsbGJhY2soKQorCisgICAgICAgIHJldHVybiBUZXN0U2tp cEZpeHR1cmUKKworICAgIGRlZiBmb29fY2FsbGJhY2soc2VsZik6CisgICAgICAgIHNlbGYuZm9v X3dhc19jYWxsZWQgPSBUcnVlCisKKyAgICBkZWYgdGVzdF9za2lwX2lmX2ZhbHNlKHNlbGYpOgor ICAgICAgICBrbGFzcyA9IHNraXBfaWYoc2VsZi5jcmVhdGVfZml4dHVyZV9jbGFzcygpLCBGYWxz ZSwgJ1Nob3VsZCBub3Qgc2VlIHRoaXMgbWVzc2FnZS4nLCBsb2dnZXI9c2VsZi5sb2dnZXIpCisg ICAgICAgIGtsYXNzKHNlbGYuZm9vX2NhbGxiYWNrKS50ZXN0X2ZvbygpCisgICAgICAgIHNlbGYu YXNzZXJ0RXF1YWwoc2VsZi5sb2dfc3RyZWFtLmdldHZhbHVlKCksICcnKQorICAgICAgICBzZWxm LmFzc2VydFRydWUoc2VsZi5mb29fd2FzX2NhbGxlZCkKKworICAgIGRlZiB0ZXN0X3NraXBfaWZf dHJ1ZShzZWxmKToKKyAgICAgICAga2xhc3MgPSBza2lwX2lmKHNlbGYuY3JlYXRlX2ZpeHR1cmVf Y2xhc3MoKSwgVHJ1ZSwgJ1Nob3VsZCBzZWUgdGhpcyBtZXNzYWdlLicsIGxvZ2dlcj1zZWxmLmxv Z2dlcikKKyAgICAgICAga2xhc3Moc2VsZi5mb29fY2FsbGJhY2spLnRlc3RfZm9vKCkKKyAgICAg ICAgc2VsZi5hc3NlcnRFcXVhbChzZWxmLmxvZ19zdHJlYW0uZ2V0dmFsdWUoKSwgJ1NraXBwaW5n IHdlYmtpdHB5LnRlc3Quc2tpcF91bml0dGVzdC5UZXN0U2tpcEZpeHR1cmU6IFNob3VsZCBzZWUg dGhpcyBtZXNzYWdlLlxuJykKKyAgICAgICAgc2VsZi5hc3NlcnRGYWxzZShzZWxmLmZvb193YXNf Y2FsbGVkKQorCitpZiBfX25hbWVfXyA9PSAnX19tYWluX18nOgorICAgIHVuaXR0ZXN0Lm1haW4o KQo= 72671 2010-11-02 08:31:45 -0700 2010-11-02 14:46:01 -0700 Skip webkitpy.layout_tests.run_webkit_tests_unittest.MainTest on Cygwin Python 2.5.x bug-48614-20101102113148.patch text/plain 9180 aroben ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCAwNDEzY2RhNDc1MzViODVlMThiY2ZjNDc2Mjk4OGVkOTc3ZTA2MTc1Li44OGMzMTZk ZDk4MTVjYTFkZTJmNjcyMTc3NTg2YWI1OWY5Nzk5MDc1IDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzggQEAK KzIwMTAtMTEtMDIgIEFkYW0gUm9iZW4gIDxhcm9iZW5AYXBwbGUuY29tPgorCisgICAgICAgIFNr aXAgd2Via2l0cHkubGF5b3V0X3Rlc3RzLnJ1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QuTWFpblRl c3Qgb24gQ3lnd2luCisgICAgICAgIFB5dGhvbiAyLjUueAorCisgICAgICAgIEl0IGlzIGtub3du IHRvIGhhbmcgb24gdGhhdCB2ZXJzaW9uIG9mIFB5dGhvbi4gU2VlCisgICAgICAgIDxodHRwOi8v d2Via2l0Lm9yZy9iLzQ4NjE0Pi4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRf dGVzdHNfdW5pdHRlc3QucHk6IFVzZQorICAgICAgICBza2lwX2lmIHRvIHNraXAgTWFpblRlc3Qg b24gQ3lnd2luIFB5dGhvbiAyLjUueC4KKworICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdGVz dC9za2lwLnB5OiBBZGRlZC4KKyAgICAgICAgKHNraXBfaWYpOiBJZiB0aGUgcGFzc2VkLWluIGNv bmRpdGlvbiBpcyBmYWxzZSwgZmluZCBhbGwgdGhlIHRlc3RfKgorICAgICAgICBtZXRob2RzIG9m IHRoZSBnaXZlbiBjbGFzcyBhbmQgcmVwbGFjZSB0aGVtIHdpdGggYSBmdW5jdGlvbiB0aGF0IGp1 c3QKKyAgICAgICAgbG9ncyB0aGF0IHdlJ3JlIHNraXBwaW5nIHRoZXNlIHRlc3RzLiBUaGlzIGlz IGxvb3NlbHkgYmFzZWQgb24gdGhlCisgICAgICAgIHVuaXR0ZXN0LnNraXBfaWYgZGVjb3JhdG9y IGFkZGVkIGluIFB5dGhvbiAzLjEuCisgICAgICAgIChfc2tpcHBlZF9tZXRob2QpOiBSZXR1cm5z IGEgZnVuY3Rpb24gdGhhdCBqdXN0IGxvZ3MgdGhhdCB0aGUgdGVzdHMgYXJlCisgICAgICAgIGJl aW5nIHNraXBwZWQuIFRoaXMgaXMgdXNlZCBpbiBwbGFjZSBvZiB0aGUgYWN0dWFsIHRlc3RfKiBm dW5jdGlvbnMuCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rlc3Qvc2tpcF91bml0dGVz dC5weTogQWRkZWQuCisgICAgICAgIChTa2lwVGVzdC5zZXRVcCk6IENyZWF0ZSBhIGxvZ2dlciBm b3Igb3Vyc2VsdmVzIGFuZCBnaXZlIGl0IGEgaGFuZGxlcgorICAgICAgICB0aGF0IGxvZ3MgdG8g YSBwcml2YXRlIHN0cmVhbS4KKyAgICAgICAgKFNraXBUZXN0LnRlYXJEb3duKTogUmVzZXQgdGhl IGxvZ2dlci4KKyAgICAgICAgKFNraXBUZXN0LmNyZWF0ZV9maXh0dXJlX2NsYXNzKTogUmV0dXJu cyBhIGNsYXNzIHRoYXQgd2UgdXNlIHRvIHRlc3QKKyAgICAgICAgc2tpcF9pZi4gSXQgaGFzIGEg c2luZ2xlIHRlc3RfKiBtZXRob2QsIHRlc3RfZm9vLCB0aGF0IGp1c3QgY2FsbHMKKyAgICAgICAg dGhyb3VnaCB0byBhIGNhbGxiYWNrLgorICAgICAgICAoU2tpcFRlc3QuZm9vX2NhbGxiYWNrKTog UmVjb3JkIHRoYXQgdGVzdF9mb28gd2FzIGNhbGxlZC4KKyAgICAgICAgKFNraXBUZXN0LnRlc3Rf c2tpcF9pZl9mYWxzZSk6IFBhc3Mgc2tpcF9pZiBhIEZhbHNlIGNvbmRpdGlvbiBhbmQgdGVzdAor ICAgICAgICB0aGF0IHRlc3RfZm9vIGRvZXMgZ2V0IGNhbGxlZC4KKyAgICAgICAgKFNraXBUZXN0 LnRlc3Rfc2tpcF9pZl90cnVlKTogUGFzcyBza2lwX2lmIGEgVHJ1ZSBjb25kaXRpb24gYW5kIHRl c3QKKyAgICAgICAgdGhhdCB0ZXN0X2ZvbyBkb2VzIG5vdCBnZXQgY2FsbGVkIGFuZCB0aGUgYXBw cm9wcmlhdGUgbWVzc2FnZSBnZXRzCisgICAgICAgIGxvZ2dlZC4KKwogMjAxMC0xMS0wMSAgSmVu biBCcmFpdGh3YWl0ZSAgPGplbm5iQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBi eSBBZGFtIFJvYmVuLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0c191bml0dGVzdC5weSBiL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHNfdW5pdHRlc3QucHkK aW5kZXggMGYwOWZmYTA0MzQyM2Q3MzVjYzBhM2QzYzY2NzE1ZDUzN2FhYTYxNC4uMjY3MjUwODRh OTZmZDUzNzQyNzNkMmRkN2RlNTdiMDAwZjJjYTk0ZSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0c191bml0dGVzdC5w eQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Vi a2l0X3Rlc3RzX3VuaXR0ZXN0LnB5CkBAIC00OSw2ICs0OSw4IEBAIGZyb20gd2Via2l0cHkubGF5 b3V0X3Rlc3RzIGltcG9ydCBwb3J0CiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cyBpbXBvcnQg cnVuX3dlYmtpdF90ZXN0cwogZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMubGF5b3V0X3BhY2th Z2UgaW1wb3J0IGR1bXBfcmVuZGVyX3RyZWVfdGhyZWFkCiBmcm9tIHdlYmtpdHB5LmxheW91dF90 ZXN0cy5wb3J0LnRlc3QgaW1wb3J0IFRlc3RQb3J0Citmcm9tIHdlYmtpdHB5LnB5dGhvbjI0LnZl cnNpb25pbmcgaW1wb3J0IGNvbXBhcmVfdmVyc2lvbgorZnJvbSB3ZWJraXRweS50ZXN0LnNraXAg aW1wb3J0IHNraXBfaWYKIAogZnJvbSB3ZWJraXRweS50aGlyZHBhcnR5Lm1vY2sgaW1wb3J0IE1v Y2sKIApAQCAtMjg3LDYgKzI4OSw4IEBAIGNsYXNzIE1haW5UZXN0KHVuaXR0ZXN0LlRlc3RDYXNl KToKICAgICAgICAgdGVzdF9wb3J0ID0gZ2V0X3BvcnRfZm9yX3J1bihiYXNlX2FyZ3MpCiAgICAg ICAgIHNlbGYuYXNzZXJ0RXF1YWwoTm9uZSwgdGVzdF9wb3J0LnRvbGVyYW5jZV91c2VkX2Zvcl9k aWZmX2ltYWdlKQogCitNYWluVGVzdCA9IHNraXBfaWYoTWFpblRlc3QsIHN5cy5wbGF0Zm9ybSA9 PSAnY3lnd2luJyBhbmQgY29tcGFyZV92ZXJzaW9uKHN5cywgJzIuNicpWzBdIDwgMCwgJ25ldy1y dW4td2Via2l0LXRlc3RzIHRlc3RzIGhhbmcgb24gQ3lnd2luIFB5dGhvbiAyLjUuMicpCisKIAog ZGVmIF9tb2NrZWRfb3BlbihvcmlnaW5hbF9vcGVuLCBmaWxlX2xpc3QpOgogICAgIGRlZiBfd3Jh cHBlcihuYW1lLCBtb2RlLCBlbmNvZGluZyk6CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3Jp cHRzL3dlYmtpdHB5L3Rlc3Qvc2tpcC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv dGVzdC9za2lwLnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmVmZjBkNDg2YjEwMmM1NzlmNWRlOThjZmFhZTg3ZDA3 NDM3OTA3YTEKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L3Rlc3Qvc2tpcC5weQpAQCAtMCwwICsxLDUwIEBACisjIENvcHlyaWdodCAoQykgMjAxMCBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyMgYXJlIG1ldDoKKyMgMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuICBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorIyAg ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorIyAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQK KyMgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFIElNUExJRUQKKyMgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorIyBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxF IEZPUgorIyBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMCisjIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SCisjIFNFUlZJQ0VTOyBM T1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSCisjIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksCisjIE9SIFRPUlQgKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisj IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisKK2ltcG9ydCBsb2dnaW5nCisKK19sb2cgPSBsb2dnaW5nLmdldExvZ2dl cihfX25hbWVfXykKKworCitkZWYgc2tpcF9pZihrbGFzcywgY29uZGl0aW9uLCBtZXNzYWdlPU5v bmUsIGxvZ2dlcj1Ob25lKToKKyAgICBpZiBub3QgbG9nZ2VyOgorICAgICAgICBsb2dnZXIgPSBf bG9nCisgICAgaWYgbm90IGNvbmRpdGlvbjoKKyAgICAgICAgcmV0dXJuIGtsYXNzCisgICAgZm9y IG5hbWUgaW4gZGlyKGtsYXNzKToKKyAgICAgICAgYXR0ciA9IGdldGF0dHIoa2xhc3MsIG5hbWUp CisgICAgICAgIGlmIG5vdCBjYWxsYWJsZShhdHRyKToKKyAgICAgICAgICAgIGNvbnRpbnVlCisg ICAgICAgIGlmIG5vdCBuYW1lLnN0YXJ0c3dpdGgoJ3Rlc3RfJyk6CisgICAgICAgICAgICBjb250 aW51ZQorICAgICAgICBzZXRhdHRyKGtsYXNzLCBuYW1lLCBfc2tpcHBlZF9tZXRob2QoYXR0ciwg bWVzc2FnZSwgbG9nZ2VyKSkKKyAgICBrbGFzcy5fcHJpbnRlZF9za2lwcGVkX21lc3NhZ2UgPSBG YWxzZQorICAgIHJldHVybiBrbGFzcworCisKK2RlZiBfc2tpcHBlZF9tZXRob2QobWV0aG9kLCBt ZXNzYWdlLCBsb2dnZXIpOgorICAgIGRlZiBfc2tpcCgqYXJncyk6CisgICAgICAgIGlmIG1ldGhv ZC5pbV9jbGFzcy5fcHJpbnRlZF9za2lwcGVkX21lc3NhZ2U6CisgICAgICAgICAgICByZXR1cm4K KyAgICAgICAgbWV0aG9kLmltX2NsYXNzLl9wcmludGVkX3NraXBwZWRfbWVzc2FnZSA9IFRydWUK KyAgICAgICAgbG9nZ2VyLmluZm8oJ1NraXBwaW5nICVzLiVzOiAlcycgJSAobWV0aG9kLl9fbW9k dWxlX18sIG1ldGhvZC5pbV9jbGFzcy5fX25hbWVfXywgbWVzc2FnZSkpCisgICAgcmV0dXJuIF9z a2lwCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3Qvc2tpcF91 bml0dGVzdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvdGVzdC9za2lwX3VuaXR0 ZXN0LnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmY2MWExYmI0NzhhNzYyZGYxYmYxODgwN2IxM2ExZDFlOTk4OGQ5 ZWYKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Rlc3Qv c2tpcF91bml0dGVzdC5weQpAQCAtMCwwICsxLDc3IEBACisjIENvcHlyaWdodCAoQykgMjAxMCBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyMgYXJlIG1ldDoKKyMgMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuICBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor IyAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorIyAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBB TkQKKyMgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyMgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorIyBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUgorIyBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCisjIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SCisjIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KSBIT1dFVkVSCisjIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksCisjIE9SIFRPUlQgKElOQ0xVRElORyBO RUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNF CisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisKK2ltcG9ydCBTdHJpbmdJTworaW1wb3J0IGxvZ2dpbmcKK2ltcG9y dCB1bml0dGVzdAorCitmcm9tIHdlYmtpdHB5LnRlc3Quc2tpcCBpbXBvcnQgc2tpcF9pZgorCisK K2NsYXNzIFNraXBUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKKyAgICBkZWYgc2V0VXAoc2VsZik6 CisgICAgICAgIHNlbGYubG9nZ2VyID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCisKKyAg ICAgICAgc2VsZi5vbGRfbGV2ZWwgPSBzZWxmLmxvZ2dlci5sZXZlbAorICAgICAgICBzZWxmLmxv Z2dlci5zZXRMZXZlbChsb2dnaW5nLklORk8pCisKKyAgICAgICAgc2VsZi5vbGRfcHJvcGFnYXRl ID0gc2VsZi5sb2dnZXIucHJvcGFnYXRlCisgICAgICAgIHNlbGYubG9nZ2VyLnByb3BhZ2F0ZSA9 IEZhbHNlCisKKyAgICAgICAgc2VsZi5sb2dfc3RyZWFtID0gU3RyaW5nSU8uU3RyaW5nSU8oKQor ICAgICAgICBzZWxmLmhhbmRsZXIgPSBsb2dnaW5nLlN0cmVhbUhhbmRsZXIoc2VsZi5sb2dfc3Ry ZWFtKQorICAgICAgICBzZWxmLmxvZ2dlci5hZGRIYW5kbGVyKHNlbGYuaGFuZGxlcikKKworICAg ICAgICBzZWxmLmZvb193YXNfY2FsbGVkID0gRmFsc2UKKworICAgIGRlZiB0ZWFyRG93bihzZWxm KToKKyAgICAgICAgc2VsZi5sb2dnZXIucmVtb3ZlSGFuZGxlcihzZWxmLmhhbmRsZXIpCisgICAg ICAgIHNlbGYucHJvcGFnYXRlID0gc2VsZi5vbGRfcHJvcGFnYXRlCisgICAgICAgIHNlbGYubG9n Z2VyLnNldExldmVsKHNlbGYub2xkX2xldmVsKQorCisgICAgZGVmIGNyZWF0ZV9maXh0dXJlX2Ns YXNzKHNlbGYpOgorICAgICAgICBjbGFzcyBUZXN0U2tpcEZpeHR1cmUob2JqZWN0KToKKyAgICAg ICAgICAgIGRlZiBfX2luaXRfXyhzZWxmLCBjYWxsYmFjayk6CisgICAgICAgICAgICAgICAgc2Vs Zi5jYWxsYmFjayA9IGNhbGxiYWNrCisKKyAgICAgICAgICAgIGRlZiB0ZXN0X2ZvbyhzZWxmKToK KyAgICAgICAgICAgICAgICBzZWxmLmNhbGxiYWNrKCkKKworICAgICAgICByZXR1cm4gVGVzdFNr aXBGaXh0dXJlCisKKyAgICBkZWYgZm9vX2NhbGxiYWNrKHNlbGYpOgorICAgICAgICBzZWxmLmZv b193YXNfY2FsbGVkID0gVHJ1ZQorCisgICAgZGVmIHRlc3Rfc2tpcF9pZl9mYWxzZShzZWxmKToK KyAgICAgICAga2xhc3MgPSBza2lwX2lmKHNlbGYuY3JlYXRlX2ZpeHR1cmVfY2xhc3MoKSwgRmFs c2UsICdTaG91bGQgbm90IHNlZSB0aGlzIG1lc3NhZ2UuJywgbG9nZ2VyPXNlbGYubG9nZ2VyKQor ICAgICAgICBrbGFzcyhzZWxmLmZvb19jYWxsYmFjaykudGVzdF9mb28oKQorICAgICAgICBzZWxm LmFzc2VydEVxdWFsKHNlbGYubG9nX3N0cmVhbS5nZXR2YWx1ZSgpLCAnJykKKyAgICAgICAgc2Vs Zi5hc3NlcnRUcnVlKHNlbGYuZm9vX3dhc19jYWxsZWQpCisKKyAgICBkZWYgdGVzdF9za2lwX2lm X3RydWUoc2VsZik6CisgICAgICAgIGtsYXNzID0gc2tpcF9pZihzZWxmLmNyZWF0ZV9maXh0dXJl X2NsYXNzKCksIFRydWUsICdTaG91bGQgc2VlIHRoaXMgbWVzc2FnZS4nLCBsb2dnZXI9c2VsZi5s b2dnZXIpCisgICAgICAgIGtsYXNzKHNlbGYuZm9vX2NhbGxiYWNrKS50ZXN0X2ZvbygpCisgICAg ICAgIHNlbGYuYXNzZXJ0RXF1YWwoc2VsZi5sb2dfc3RyZWFtLmdldHZhbHVlKCksICdTa2lwcGlu ZyB3ZWJraXRweS50ZXN0LnNraXBfdW5pdHRlc3QuVGVzdFNraXBGaXh0dXJlOiBTaG91bGQgc2Vl IHRoaXMgbWVzc2FnZS5cbicpCisgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2Uoc2VsZi5mb29fd2Fz X2NhbGxlZCkKKworaWYgX19uYW1lX18gPT0gJ19fbWFpbl9fJzoKKyAgICB1bml0dGVzdC5tYWlu KCkK