65834 2011-08-07 15:57:42 -0700 NRWT should support cascading expectations 2012-06-13 16:00:39 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) Unspecified All RESOLVED FIXED P2 Normal --- 86926 87802 88942 88944 88945 88946 88947 88948 88680 1 kbalazs dpranke abarth abecsi dpranke epoger eric kkristof mjs ojan ossy rgabor tony vestbo oldest_to_newest 447777 0 kbalazs 2011-08-07 15:57:42 -0700 Discussion on the list started there: https://lists.webkit.org/pipermail/webkit-dev/2011-July/017520.html. I believe we have a consensus about cascading is needed. The question is how to do it. Actually I like Maciej's idea about introducing an include directive. 448030 1 eric 2011-08-08 09:13:10 -0700 Could you summarize the consensus? I don't really like an include directive because it can create non-tree fallback paths. 448055 2 kbalazs 2011-08-08 09:57:42 -0700 (In reply to comment #1) > Could you summarize the consensus? I don't really like an include directive because it can create non-tree fallback paths. I meant we have a consensus about is it needed not about how should we do it. Actually we can form a tree path with include and we can also have a non-tree path without it. I like the idea of the include directive because this way the fallback path would be explicitly defined in the list itself. 448250 3 dpranke 2011-08-08 13:53:07 -0700 We don't have tree fallback paths now, I doubt we'll easily be able to get rid of them, and changing the teset expectations shouldn't change the fallback paths, regardless (they're different concepts). [ Unless of course we fundamentally want to change some aspect of how test expectations work ]. That said, the only way to currently share expectations is to share the same expectations.txt file. Given that Chromium ports currently use the expectations file to track that the expectation is "expected to fail" and hence are using the expectations as "correctness" tests, and the other ports check in "failing" expectations and hence use the expectations as "regression" tests, we almost certainly don't want to share Chromium- and non-Chromium expectations.txt files. Besides, the Chromium file is is already way too big and churns too often. It's not clear to me that we need more than a "generic" set of expectations that applies to all ports in addition to the the "port-specific" expectations. I would be tempted to prototype that first and see if that got us what we wanted. But, it's not clear to me what we "want", either. My proposal would be that we (a) change Chromium to match the other port's behavior and view tests as regression tests, not correctness tests (i.e., check in revised platform-specific expectations) and then (b) see if we can get away with either a single file for all ports or a generic + port-specific file. 448472 4 kbalazs 2011-08-09 01:41:31 -0700 (In reply to comment #3) > We don't have tree fallback paths now, I doubt we'll easily be able to get rid of them, and changing the teset expectations shouldn't change the fallback paths, regardless (they're different concepts). As I know with ORWT the path of cascading the results was the same as the fallback paths. I think this is the only logical way of this. > [ Unless of course we fundamentally want to change some aspect of how test expectations work ]. > > That said, the only way to currently share expectations is to share the same expectations.txt file. > > Given that Chromium ports currently use the expectations file to track that the expectation is "expected to fail" and hence are using the expectations as "correctness" tests, and the other ports check in "failing" expectations and hence use the expectations as "regression" tests, we almost certainly don't want to share Chromium- and non-Chromium expectations.txt files. Besides, the Chromium file is is already way too big and churns too often. > I think the cascading has nothing to do with the way how we interpret the results. Cascading is useful for both regression and correctness tests. The point is that a port has subports (like qt and qt-linux) and the subport has some metric differences but a great amount of expectation can be shared across subports. > It's not clear to me that we need more than a "generic" set of expectations that applies to all ports in addition to the the "port-specific" expectations. I would be tempted to prototype that first and see if that got us what we wanted. I don't think we need a generic set of expectations. On the contrary, we need less generic expectations for subports. 448615 5 dpranke 2011-08-09 09:08:34 -0700 (In reply to comment #4) > The point is that a port has subports (like qt and qt-linux) and the subport > has some metric differences but a great amount of expectation can be shared > across subports. Agreed; however, the normal usage of the expectations file handles this fine (this is how Chromium uses it): use one expectations file for all of the QT ports. Results that are the same across all subports need no modifiers; results that vary can have them, e.g.: BUGWK12345 : foo/bar.html = TEXT BUGWK12346 LINUX : foo/bar.html = IMAGE indicates that all of the Qt ports fail the first but only Qt-Linux fails the second. The complication arises if you want to also share expectations with a different port (Gtk, Apple, Chromium, whatever), in which case you'd have to add some way to distinguish qt-linux from chromium-linux, or if you want to have expectations that are common across *all* ports, e.g., because every port will fail the test. 451000 6 kkristof 2011-08-15 02:04:47 -0700 The webkit2 ports share their expectations in the general wk2 platform. (e.g. the qt-wk2 should use these: qt, qt-wk2, wk2) I think the following things can solve this problem: - concatenate the wk2/test_expectations.txt and the <port>-wk2/test_expectations.txt without any include directive in a nice named method like cascade_wk2_test_expectations() - the test_expectations() return with the <port> expectations - the test_expectations_override() return with the concatenated list if the webkit test runner is used 451020 7 103899 kkristof 2011-08-15 03:43:48 -0700 Created attachment 103899 make able the wk2 ports to share their common expectations in the wk2 platform 451087 8 103899 abarth 2011-08-15 09:09:05 -0700 Comment on attachment 103899 make able the wk2 ports to share their common expectations in the wk2 platform View in context: https://bugs.webkit.org/attachment.cgi?id=103899&action=review > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:358 > + if self._filesystem.exists(path_to_wk2_test_expectations_file): > + expectations += self._filesystem.read_text_file(path_to_wk2_test_expectations_file) This might be more of a maintenance burden than you'd expect because test_expectations don't allow duplicate / shadowing expectations. That means you'll need to make sure that you don't have conflicts between the two files. (That's not to say we shouldn't go this route, just that it's not as pretty as it might seem.) 451109 9 103899 tony 2011-08-15 10:22:00 -0700 Comment on attachment 103899 make able the wk2 ports to share their common expectations in the wk2 platform View in context: https://bugs.webkit.org/attachment.cgi?id=103899&action=review >> Tools/Scripts/webkitpy/layout_tests/port/webkit.py:358 >> + expectations += self._filesystem.read_text_file(path_to_wk2_test_expectations_file) > > This might be more of a maintenance burden than you'd expect because test_expectations don't allow duplicate / shadowing expectations. That means you'll need to make sure that you don't have conflicts between the two files. (That's not to say we shouldn't go this route, just that it's not as pretty as it might seem.) I thought overrides are allowed to duplicate/shadow (hence, it's an override). That's what http://trac.webkit.org/browser/trunk/Tools/Scripts/webkitpy/layout_tests/models/test_expectations.py#L825 seems to suggest and I think that's how the chromium repository test_expectations.txt works. 451120 10 103899 abarth 2011-08-15 10:37:27 -0700 Comment on attachment 103899 make able the wk2 ports to share their common expectations in the wk2 platform View in context: https://bugs.webkit.org/attachment.cgi?id=103899&action=review >>> Tools/Scripts/webkitpy/layout_tests/port/webkit.py:358 >>> + if self._filesystem.exists(path_to_wk2_test_expectations_file): >>> + expectations += self._filesystem.read_text_file(path_to_wk2_test_expectations_file) >> >> This might be more of a maintenance burden than you'd expect because test_expectations don't allow duplicate / shadowing expectations. That means you'll need to make sure that you don't have conflicts between the two files. (That's not to say we shouldn't go this route, just that it's not as pretty as it might seem.) > > I thought overrides are allowed to duplicate/shadow (hence, it's an override). That's what http://trac.webkit.org/browser/trunk/Tools/Scripts/webkitpy/layout_tests/models/test_expectations.py#L825 seems to suggest and I think that's how the chromium repository test_expectations.txt works. Ah, looks like you're right! 451121 11 abarth 2011-08-15 10:37:45 -0700 We should probably add a test to that effect. 451126 12 kkristof 2011-08-15 10:40:17 -0700 (In reply to comment #11) > We should probably add a test to that effect. tomorrow I will test it, and if it will be necessary I will fix it 451153 13 dpranke 2011-08-15 11:07:31 -0700 The way I'm reading this patch, you will use the regular "qt" expectations by default, and if you're running the wk2 variant, you'll use the concatenation of the platform/wk2 and platform/qt-wk2 expectations as overrides. Is this the intended behavior? I'm not sure that this is a great idea. The overrides files are really intended to be mostly empty most of the time, and for short-term fixes (they were initially implemented in order to handle downstream failures in the chromium repo). The act of overriding can make it hard to understand which rules are actually taking effect, and can make it harder to figure out which expectations need to be modified where. In particular, in this case, you won't have any easy way to specify a test that fails one way most webkit 2 ports and a different way on the Qt port (e.g., a test that produces a TEXT diff on most wk2 ports but Qt times out). Of course, if the non-Chromium ports follow the approach that these files are empty most of the time anyway, maybe this'll be left of an issue. 452897 14 104311 kkristof 2011-08-18 00:59:52 -0700 Created attachment 104311 make able the wk2 ports to share their common expectations in the wk2 platform Sorry I didn't notice that about the overrides therefore in this patch I don't use it. It has one more advantage at now: when one test skipped for the orwt it now can mark as expectation for the nrwt too, because it clear the recurring expectation 454158 15 104311 dpranke 2011-08-19 15:58:37 -0700 Comment on attachment 104311 make able the wk2 ports to share their common expectations in the wk2 platform View in context: https://bugs.webkit.org/attachment.cgi?id=104311&action=review > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:370 > + return result I'm pretty sure that by coding things this way you're ignoring any modifiers that might be set on the lines, and so if you have a line in the wk2 file like: BUGX MAC : foo/bar.html = PASS and a line in the regular file like: BUGY WIN : foo/bar.html = TEXT you will throw away the second line, which would be wrong. I'm not sure that trying to manually implement a cascade through concatenation and a limited form of deduplication is a fruitful way of doing things. I think we probably need to implement "proper" support for cascading that is aware of the modifiers. 455265 16 kkristof 2011-08-23 02:17:59 -0700 > BUGX MAC : foo/bar.html = PASS > > and a line in the regular file like: > > BUGY WIN : foo/bar.html = TEXT In this example the next line is the correct? BUGY WIN : foo/bar.html = TEXT But I think it is a very bad idea to write an expected line like this in the file what is for the cross-platform failures. On the other hand the correct merge of the expected lines is a very nice idea. 455493 17 dpranke 2011-08-23 10:37:42 -0700 (In reply to comment #16) > > BUGX MAC : foo/bar.html = PASS > > > > and a line in the regular file like: > > > > BUGY WIN : foo/bar.html = TEXT > > In this example the next line is the correct? > BUGY WIN : foo/bar.html = TEXT > They are both correct. Imagine we're talking about the Qt port here. One expectation might be intended for the webkit2 version of qt-mac, and the other for qt-win (could be either for webkit1 or for both webkit1 and webkit2). > But I think it is a very bad idea to write an expected line like this in the file what is for the cross-platform failures. The basic idea of the test expectations file is to be able to manage all of the expectations for a single port in a single file; this is different than what we do using Skipped files, where you have files for each platform (and version, in some cases). If you wanted to have a file represent only cross-platform failures, and another file represent failures specific to a single platform (or version), we could do that, but that would be a change from what the code does now (I wouldn't really be in favor of this change, in case that wasn't obvious). 458745 18 kkristof 2011-08-30 00:10:03 -0700 There is any idea how we can merge correctly the different expectation lines? Anyway is that possible? e.g.: BUGWKX :foo/bar.html=PASS //some comment BUGWKY LINUX:foo/bar.html=FAIL //other comment = BUGWKX BUGWKY: foo/bar.html = PASS FAIL //some comment; other comment In that example the expectation line will be correct, but we don't see if there any regression. 461690 19 dpranke 2011-09-02 18:23:14 -0700 (In reply to comment #18) > There is any idea how we can merge correctly the different expectation lines? > Anyway is that possible? > > e.g.: > BUGWKX :foo/bar.html=PASS //some comment > BUGWKY LINUX:foo/bar.html=FAIL //other comment > = > BUGWKX BUGWKY: foo/bar.html = PASS FAIL //some comment; other comment > > In that example the expectation line will be correct, but we don't see if there any regression. Hi Kristóf, I'm not sure if I understood your question. Using your example above, if you have: BUGWKX :foo/bar.html=PASS //some comment BUGWKY LINUX:foo/bar.html=FAIL //other comment Today, you will actually get a parsing conflict, since the expectation is unclear on Linux. [ At one point the code did actually support this, and the second line would've overridden the first, but we got rid of this because it made the code more complex and arguably made the expectations harder to follow (because you couldn't just look at a single line to figure out what a test was expected to do). ] Of course, we can change the code. I think we need to start by defining what we want the syntax in the files to be, and the corresponding semantics. For example, you could just #include something and merge the results to produce a flaky result as you describe, but as you say, this would not be a very good solution. Another option would be to #include the files and just treat them as conflicts directly. As long as the files contained disjoint lists of tests, this woud be fine. This might be the way to start, as this would be pretty easy to support. Or, we could follow the model of the overrides files and just have later files trump earlier ones. But, if we wanted to support something fancier, it's not immediately obvious to me how to do it without resorting to something like what I described earlier (where a line with more modifiers takes precedence over a line w/ fewer). 541288 20 ossy 2012-01-24 06:28:22 -0800 Are we still want to support cascaded test_expectations.txt? It seems only chromium port uses test_expectations.txt actively. 541291 21 kbalazs 2012-01-24 06:38:28 -0800 (In reply to comment #20) > Are we still want to support cascaded test_expectations.txt? > It seems only chromium port uses test_expectations.txt actively. Because cascading is not supported. If it would be, we could use test_expectations.txt, and we could automatically notice no longer failing tests. 628174 22 dpranke 2012-05-18 15:46:42 -0700 I'm working on this now ... the basic plan will be as follows: cascading expectations will be an extension of the existing "overrides" mechanism. In other words, each port will have an ordered list of expectations files. If two files have an entry for the same test, the later entry will override the earlier one. If a later file has an entry for a directory that contains tests with entries in earlier files, those earlier entries will also be overridden (this will be different from how overrides currently work). This will allow later files to have full control over any and all suppressions. Initially, all files in the list will be required to have support the same list of platform/configuration modifiers. If need arises, we can work out a scheme by which different files can support different modifiers and/or have certain configurations "defaulted in". Skipped lists will be converted on-the-fly to expectations files and then appended. This means that tests listed in *any* Skipped file will override all entries in expectations files. Any tests disabled by compile-time or runtime flags will then be appended as expectations; this will also override any expectations entries. Finally, the command line flags --additional-expectations and --ignore-tests will be treated as if they were appended to the ordered list above, again giving the user full control over all of the expectations, allowing for local expectations on a machine, etc. --lint-test-files diagnostics will be improved to report which files each expectation shows up in, and when expectations are redundant. The basic implementation approach will be 1) rework the existing TestExpectations class interfaces a bit to make it easier to support the next sets of changes 2) add better diagnostics to --lint-test-files 3) update the existing code to remove the "overrides" concept and just pass the ordered lists around. "Skipped" lists 4) profit ... I mean, let each port decide if and how they want to use cascaded files and when they want to drop the Skipped files. 628191 23 ojan 2012-05-18 15:51:40 -0700 (In reply to comment #22) > I'm working on this now ... the basic plan will be as follows: This plan sounds great! > Initially, all files in the list will be required to have support the same list of platform/configuration modifiers. If need arises, we can work out a scheme by which different files can support different modifiers and/or have certain configurations "defaulted in". This is certainly good as a first milestone. I think we'll eventually want the platform modifiers to be inferred from the platform directory names (e.g. linux would be disallowed on Apple's test_expectations.txt file since there's no platform/mac-linux directory). 629325 24 104311 dpranke 2012-05-21 11:48:13 -0700 Comment on attachment 104311 make able the wk2 ports to share their common expectations in the wk2 platform clearing the flags from this old patch ... I assume it's no longer interesting/needed? 647626 25 dpranke 2012-06-12 20:02:41 -0700 all the patches necessary to make NRWT support cascading expectations (with all expectations files using the same sets of modifiers) have been posted. There is more work to be done to make 'webkit-patch rebaseline-expectations' support them, and there's probably more work in the flakiness dashboard and possibly garden-o-matic, but those are separate issues. 648551 26 dpranke 2012-06-13 16:00:39 -0700 Basic support for cascading is now supported. Each port may specify an ordered list of TestExpectations files; entries in later files will override entries in earlier files. The port is required to support any keyword listed in any of the files (which basically means that all the files should use the same list of keywords). There is no #include mechanism; I don't think it's really needed, and it probably just complicates things. Right now the non-Chromium ports only use a single TestExpectations file; it should be trivial to change it to do something like the the logic we use for Skipped files, and use platform/X/TestExpectations then platform/X-version/TestExpectations and platform/wk2/TestExpectations as necessary. We could also add a top-level TestExpectations file for tests that will be broken across all ports, if we wanted. We can of course add more features, but I'd like to keep things simple at the start and see how this goes. Feedback welcome! 103899 2011-08-15 03:43:48 -0700 2011-08-18 00:59:52 -0700 make able the wk2 ports to share their common expectations in the wk2 platform 0001-NRWT-should-support-cascading-expectations.patch text/plain 6588 kkristof RnJvbSA4OTI2NTE3NWQwM2JjMTkzMTgxY2MyNTBiZDAxZTkxNzFmNzAwMGRlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/S3Jpc3Q9QzM9QjNmPTIwS29zenR5PUMzPUIz Pz0gPEtvc3p0eW8uS3Jpc3RvZkBzdHVkLnUtc3plZ2VkLmh1PgpEYXRlOiBNb24sIDE1IEF1ZyAy MDExIDEyOjM4OjU5ICswMjAwClN1YmplY3Q6IFtQQVRDSF0gTlJXVCBzaG91bGQgc3VwcG9ydCBj YXNjYWRpbmcgZXhwZWN0YXRpb25zCiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NjU4MzQKCk1ha2UgYWJsZSB0aGUgd2syIHBvcnRzIHRvIHNoYXJlIHRoZWlyIGV4cGVj dGF0aW9ucwotLS0KIExheW91dFRlc3RzL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICAxNCArKysrKysrKysrKwogTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi90 ZXN0X2V4cGVjdGF0aW9ucy50eHQgfCAgICA0ICsrKwogTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQt d2syL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCAgfCAgICA0ICsrKwogTGF5b3V0VGVzdHMvcGxhdGZv cm0vd2luLXdrMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQgfCAgICA0ICsrKwogTGF5b3V0VGVzdHMv cGxhdGZvcm0vd2syL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCAgICAgfCAgICA0ICsrKwogVG9vbHMv Q2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEyICsrKysr KysrKysKIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5 IHwgICAyNCArKysrKysrKysrKysrKysrKysrLQogNyBmaWxlcyBjaGFuZ2VkLCA2NSBpbnNlcnRp b25zKCspLCAxIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91dFRlc3RzL3Bs YXRmb3JtL21hYy13azIvdGVzdF9leHBlY3RhdGlvbnMudHh0CiBjcmVhdGUgbW9kZSAxMDA2NDQg TGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQtd2syL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAogY3JlYXRl IG1vZGUgMTAwNjQ0IExheW91dFRlc3RzL3BsYXRmb3JtL3dpbi13azIvdGVzdF9leHBlY3RhdGlv bnMudHh0CiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2syL3Rlc3Rf ZXhwZWN0YXRpb25zLnR4dAoKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xh eW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA2NWZjYjFmLi4wOWM3ZWUwIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTcgQEAKKzIwMTEtMDgtMTUgIEtyaXN0w7NmIEtvc3p0ecOzICA8S29zenR5by5LcmlzdG9m QHN0dWQudS1zemVnZWQuaHU+CisKKyAgICAgICAgTlJXVCBzaG91bGQgc3VwcG9ydCBjYXNjYWRp bmcgZXhwZWN0YXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD02NTgzNAorCisgICAgICAgIENyZWF0ZSB0ZXN0X2V4cGVjdGF0aW5vcy50eHQgZm9y IHRoZSB3azIgcGxhdGZvcm1zCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMtd2syL3Rlc3RfZXhwZWN0YXRpb25zLnR4dDogQWRk ZWQuCisgICAgICAgICogcGxhdGZvcm0vcXQtd2syL3Rlc3RfZXhwZWN0YXRpb25zLnR4dDogQWRk ZWQuCisgICAgICAgICogcGxhdGZvcm0vd2luLXdrMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQ6IEFk ZGVkLgorICAgICAgICAqIHBsYXRmb3JtL3drMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQ6IEFkZGVk LgorCiAyMDExLTA4LTE0ICBSZW5hdGEgSG9kb3ZhbiAgPHJlbmlAd2Via2l0Lm9yZz4KIAogICAg ICAgIFtRVF1SRUdSRVNTSU9OIGFmdGVyIHI5MzAxMQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv cGxhdGZvcm0vbWFjLXdrMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQgYi9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS9tYWMtd2syL3Rlc3RfZXhwZWN0YXRpb25zLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi43ZTBjNmM3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vbWFjLXdrMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQKQEAgLTAsMCArMSw0IEBACisvLyBU aGVzZSBhcmUgdGhlIGxheW91dCB0ZXN0IGV4cGVjdGF0aW9ucyBmb3IgQXBwbGUncyBNYWMgcG9y dCBvZiBXZWJLaXQyLgorLy8KKy8vIFNlZSBodHRwOi8vdHJhYy53ZWJraXQub3JnL3dpa2kvVGVz dEV4cGVjdGF0aW9ucyBmb3IgbW9yZSBpbmZvcm1hdGlvbiBvbiB0aGlzIGZpbGUuCisKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0LXdrMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC13azIvdGVzdF9leHBlY3RhdGlvbnMudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjYxOWU2OGMKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC13azIvdGVzdF9leHBlY3RhdGlvbnMudHh0CkBAIC0w LDAgKzEsNCBAQAorLy8gVGhlc2UgYXJlIHRoZSBsYXlvdXQgdGVzdCBleHBlY3RhdGlvbnMgZm9y IHRoZSBRdCBwb3J0IG9mIFdlYktpdDIuCisvLworLy8gU2VlIGh0dHA6Ly90cmFjLndlYmtpdC5v cmcvd2lraS9UZXN0RXhwZWN0YXRpb25zIGZvciBtb3JlIGluZm9ybWF0aW9uIG9uIHRoaXMgZmls ZS4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2luLXdrMi90ZXN0X2V4cGVj dGF0aW9ucy50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4td2syL3Rlc3RfZXhwZWN0YXRp b25zLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40MDI4MDNjCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2luLXdrMi90ZXN0X2V4cGVjdGF0 aW9ucy50eHQKQEAgLTAsMCArMSw0IEBACisvLyBUaGVzZSBhcmUgdGhlIGxheW91dCB0ZXN0IGV4 cGVjdGF0aW9ucyBmb3IgQXBwbGUncyBXaW5kb3dzIHBvcnQgb2YgV2ViS2l0Mi4KKy8vCisvLyBT ZWUgaHR0cDovL3RyYWMud2Via2l0Lm9yZy93aWtpL1Rlc3RFeHBlY3RhdGlvbnMgZm9yIG1vcmUg aW5mb3JtYXRpb24gb24gdGhpcyBmaWxlLgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS93azIvdGVzdF9leHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2sy L3Rlc3RfZXhwZWN0YXRpb25zLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li4xMmZkMTAyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2syL3Rl c3RfZXhwZWN0YXRpb25zLnR4dApAQCAtMCwwICsxLDQgQEAKKy8vIFRoZXNlIGFyZSB0aGUgbGF5 b3V0IHRlc3QgZXhwZWN0YXRpb25zIGZvciB0aGUgY29tbW9uIFdlYktpdDIgcG9ydC4KKy8vIAor Ly8gU2VlIGh0dHA6Ly90cmFjLndlYmtpdC5vcmcvd2lraS9UZXN0RXhwZWN0YXRpb25zIGZvciBt b3JlIGluZm9ybWF0aW9uIG9uIHRoaXMgZmlsZS4KKwpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdl TG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDdjY2JjNTUuLjEzNWEyOTEgMTAwNjQ0Ci0tLSBh L1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAor MjAxMS0wOC0xNSAgS3Jpc3TDs2YgS29zenR5w7MgIDxLb3N6dHlvLktyaXN0b2ZAc3R1ZC51LXN6 ZWdlZC5odT4KKworICAgICAgICBOUldUIHNob3VsZCBzdXBwb3J0IGNhc2NhZGluZyBleHBlY3Rh dGlvbnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY1 ODM0CisKKyAgICAgICAgVGhlIHdlYmtpdDIgcG9ydHMgY2FuIHNoYXJlIHRoZWlyIGNvbW1vbiBl eHBlY2F0aW9ucyBpbiB0aGUgd2syIHBsYXRmb3JtIGFzCisgICAgICAgIGxpa2UgYXMgdGhlIHdr Mi9Ta2lwcGVkIGZpbGUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5Ogor CiAyMDExLTA4LTE0ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAg U3dpdGNoIHJlc3VsdHMgZGV0YWlsIHZpZXcgb3ZlciB0byBuZXctc3R5bGUgb2JqZWN0LW9yaWVu dGVkIFVJIHdpZGdldHMKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3BvcnQvd2Via2l0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC93ZWJraXQucHkKaW5kZXggZjE4OGRkOC4uZjAyMjg2MiAxMDA2NDQKLS0tIGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKKysrIGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKQEAgLTc3LDcg Kzc3LDcgQEAgY2xhc3MgV2ViS2l0UG9ydChQb3J0KToKIAogICAgIGRlZiBwYXRoX3RvX3Rlc3Rf ZXhwZWN0YXRpb25zX2ZpbGUoc2VsZik6CiAgICAgICAgICMgdGVzdF9leHBlY3RhdGlvbnMgYXJl IGFsd2F5cyBpbiBtYWMvIG5vdCBtYWMtbGVvcGFyZC8gYnkgY29udmVudGlvbiwgaGVuY2Ugd2Ug dXNlIHBvcnRfbmFtZSBpbnN0ZWFkIG9mIG5hbWUoKS4KLSAgICAgICAgZXhwZWN0YXRpb25zX2Rp cmVjdG9yeSA9IHNlbGYuX3drMl9wb3J0X25hbWUoKSBpZiBzZWxmLmdldF9vcHRpb24oJ3dlYmtp dF90ZXN0X3J1bm5lcicpIGVsc2Ugc2VsZi5wb3J0X25hbWUKKyAgICAgICAgZXhwZWN0YXRpb25z X2RpcmVjdG9yeSA9IHNlbGYucG9ydF9uYW1lCiAgICAgICAgIHJldHVybiBzZWxmLl9maWxlc3lz dGVtLmpvaW4oc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoZXhwZWN0YXRpb25zX2RpcmVjdG9y eSksICd0ZXN0X2V4cGVjdGF0aW9ucy50eHQnKQogCiAgICAgZGVmIF9kcml2ZXJfYnVpbGRfc2Ny aXB0X25hbWUoc2VsZik6CkBAIC0zMzYsNiArMzM2LDI4IEBAIGNsYXNzIFdlYktpdFBvcnQoUG9y dCk6CiAgICAgICAgICAgICBleHBlY3RhdGlvbnMgPSBzZWxmLl9maWxlc3lzdGVtLnJlYWRfdGV4 dF9maWxlKGV4cGVjdGF0aW9uc19wYXRoKSArIGV4cGVjdGF0aW9ucwogICAgICAgICByZXR1cm4g ZXhwZWN0YXRpb25zCiAKKyAgICBkZWYgdGVzdF9leHBlY3RhdGlvbnNfb3ZlcnJpZGVzKHNlbGYp OgorICAgICAgICAjIFRoaXMgd2lsbCBvdmVycmlkZSB0aGUgdGVzdCBleHBlY3RhdGlvbnMgd2l0 aCB0aGUgd2syIGV4cGVjdGF0aW9ucworICAgICAgICBleHBlY3RhdGlvbnMgPSBOb25lCisKKyAg ICAgICAgaWYgc2VsZi5nZXRfb3B0aW9uKCd3ZWJraXRfdGVzdF9ydW5uZXInKToKKyAgICAgICAg ICAgIGV4cGVjdGF0aW9ucyA9IHNlbGYuY2FzY2FkZV93azJfdGVzdF9leHBlY3RhdGlvbnMoKQor ICAgICAgICByZXR1cm4gZXhwZWN0YXRpb25zCisKKyAgICBkZWYgY2FzY2FkZV93azJfdGVzdF9l eHBlY3RhdGlvbnMoc2VsZik6CisgICAgICAgICMgVGhlIHdrMiBwb3J0cyBzaGFyZSB0aGVpciBl eHBlY3RhdGlvbnMgaW4gdGhlIGNvbW1vbiB3azIgcGxhdGZvcm0KKyAgICAgICAgZXhwZWN0YXRp b25zID0gTm9uZQorICAgICAgICBwb3J0X3drMl9kaXJlY3RvcnkgPSBzZWxmLl93azJfcG9ydF9u YW1lKCkKKyAgICAgICAgd2syX2RpcmVjdG9yeSA9ICd3azInCisgICAgICAgIHBhdGhfdG9fcG9y dF93azJfdGVzdF9leHBlY3RhdGlvbnNfZmlsZSA9IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxm Ll93ZWJraXRfYmFzZWxpbmVfcGF0aChwb3J0X3drMl9kaXJlY3RvcnkpLCAndGVzdF9leHBlY3Rh dGlvbnMudHh0JykKKyAgICAgICAgcGF0aF90b193azJfdGVzdF9leHBlY3RhdGlvbnNfZmlsZSA9 IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aCh3azJfZGly ZWN0b3J5KSwgJ3Rlc3RfZXhwZWN0YXRpb25zLnR4dCcpCisKKyAgICAgICAgaWYgc2VsZi5fZmls ZXN5c3RlbS5leGlzdHMocGF0aF90b19wb3J0X3drMl90ZXN0X2V4cGVjdGF0aW9uc19maWxlKToK KyAgICAgICAgICAgIGV4cGVjdGF0aW9ucyA9IHNlbGYuX2ZpbGVzeXN0ZW0ucmVhZF90ZXh0X2Zp bGUocGF0aF90b19wb3J0X3drMl90ZXN0X2V4cGVjdGF0aW9uc19maWxlKQorICAgICAgICBpZiBz ZWxmLl9maWxlc3lzdGVtLmV4aXN0cyhwYXRoX3RvX3drMl90ZXN0X2V4cGVjdGF0aW9uc19maWxl KToKKyAgICAgICAgICAgIGV4cGVjdGF0aW9ucyArPSBzZWxmLl9maWxlc3lzdGVtLnJlYWRfdGV4 dF9maWxlKHBhdGhfdG9fd2syX3Rlc3RfZXhwZWN0YXRpb25zX2ZpbGUpCisgICAgICAgIHJldHVy biBleHBlY3RhdGlvbnMKKwogICAgIGRlZiBfc2tpcHBlZF9saXN0X2FzX2V4cGVjdGF0aW9ucyhz ZWxmKToKICAgICAgICAgIyBFYWNoIFNraXBwZWQgZmlsZSBjb250YWlucyBhIGxpc3Qgb2YgZmls ZXMKICAgICAgICAgIyBvciBkaXJlY3RvcmllcyB0byBiZSBza2lwcGVkIGR1cmluZyB0aGUgdGVz dCBydW4uIFRoZSB0b3RhbCBsaXN0Ci0tIAoxLjcuMQoK 104311 2011-08-18 00:59:52 -0700 2012-05-21 11:48:13 -0700 make able the wk2 ports to share their common expectations in the wk2 platform 0001-NRWT-should-support-cascading-expectations.patch text/plain 7045 kkristof RnJvbSAyZDNhZGVhNWNmY2U1MDliNGU2NGUyMmM1ZTEyOGQ4ZWViNmM3ZmNhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiA9P1VURi04P3E/S3Jpc3Q9QzM9QjNmPTIwS29zenR5PUMzPUIz Pz0gPGtrcmlzdG9mQGluZi51LXN6ZWdlZC5odT4KRGF0ZTogVGh1LCAxOCBBdWcgMjAxMSAwOTo0 ODoxMyArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIE5SV1Qgc2hvdWxkIHN1cHBvcnQgY2FzY2FkaW5n IGV4cGVjdGF0aW9ucwogaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY1 ODM0CiBNYWtlIGFibGUgdGhlIHdrMiBwb3J0cyB0byBzaGFyZSB0aGVpciBleHBlY3RhdGlvbnMK Ci0tLQogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCAgIDE0ICsrKysrKysrCiBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMtd2syL3Rlc3RfZXhwZWN0 YXRpb25zLnR4dCB8ICAgIDQgKysKIExheW91dFRlc3RzL3BsYXRmb3JtL3F0LXdrMi90ZXN0X2V4 cGVjdGF0aW9ucy50eHQgIHwgICAgNCArKwogTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2luLXdrMi90 ZXN0X2V4cGVjdGF0aW9ucy50eHQgfCAgICA0ICsrCiBMYXlvdXRUZXN0cy9wbGF0Zm9ybS93azIv dGVzdF9leHBlY3RhdGlvbnMudHh0ICAgICB8ICAgIDQgKysKIFRvb2xzL0NoYW5nZUxvZyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMSArKysrKysKIFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5IHwgICAzNSArKysrKysrKysr KysrKysrKysrLQogNyBmaWxlcyBjaGFuZ2VkLCA3NSBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9u cygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91dFRlc3RzL3BsYXRmb3JtL21hYy13azIvdGVz dF9leHBlY3RhdGlvbnMudHh0CiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvcGxhdGZv cm0vcXQtd2syL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91 dFRlc3RzL3BsYXRmb3JtL3dpbi13azIvdGVzdF9leHBlY3RhdGlvbnMudHh0CiBjcmVhdGUgbW9k ZSAxMDA2NDQgTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2syL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAoK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA2N2EwOTRjLi4zOWYyNTUxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTEtMDgt MTggIEtyaXN0w7NmIEtvc3p0ecOzICA8a2tyaXN0b2ZAaW5mLnUtc3plZ2VkLmh1PgorCisgICAg ICAgIE5SV1Qgc2hvdWxkIHN1cHBvcnQgY2FzY2FkaW5nIGV4cGVjdGF0aW9ucworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjU4MzQKKworICAgICAgICBD cmVhdGUgdGVzdF9leHBlY3RhdGlub3MudHh0IGZvciB0aGUgd2syIHBsYXRmb3JtcworCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcGxhdGZvcm0vbWFj LXdrMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQ6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL3F0 LXdrMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQ6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL3dp bi13azIvdGVzdF9leHBlY3RhdGlvbnMudHh0OiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS93 azIvdGVzdF9leHBlY3RhdGlvbnMudHh0OiBBZGRlZC4KKwogMjAxMS0wOC0xNiAgVG9ueSBDaGFu ZyAgPHRvbnlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFtjaHJvbWl1bV0gZmFzdC9jc3MvY3Vz dG9tLWZvbnQteGhlaWdodC5odG1sIGlzIGFzc2VydGluZyBvbiBhbGwKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL3BsYXRmb3JtL21hYy13azIvdGVzdF9leHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2UwYzZjNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL3BsYXRmb3JtL21hYy13azIvdGVzdF9leHBlY3RhdGlvbnMudHh0CkBAIC0wLDAgKzEs NCBAQAorLy8gVGhlc2UgYXJlIHRoZSBsYXlvdXQgdGVzdCBleHBlY3RhdGlvbnMgZm9yIEFwcGxl J3MgTWFjIHBvcnQgb2YgV2ViS2l0Mi4KKy8vCisvLyBTZWUgaHR0cDovL3RyYWMud2Via2l0Lm9y Zy93aWtpL1Rlc3RFeHBlY3RhdGlvbnMgZm9yIG1vcmUgaW5mb3JtYXRpb24gb24gdGhpcyBmaWxl LgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC13azIvdGVzdF9leHBlY3Rh dGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQtd2syL3Rlc3RfZXhwZWN0YXRpb25z LnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kZGJiMDZiCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQtd2syL3Rlc3RfZXhwZWN0YXRpb25z LnR4dApAQCAtMCwwICsxLDQgQEAKKy8vIFRoZXNlIGFyZSB0aGUgbGF5b3V0IHRlc3QgZXhwZWN0 YXRpb25zIGZvciBUaGUgUXQgcG9ydCBvZiBXZWJLaXQyLgorLy8KKy8vIFNlZSBodHRwOi8vdHJh Yy53ZWJraXQub3JnL3dpa2kvVGVzdEV4cGVjdGF0aW9ucyBmb3IgbW9yZSBpbmZvcm1hdGlvbiBv biB0aGlzIGZpbGUuCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi13azIv dGVzdF9leHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2luLXdrMi90ZXN0 X2V4cGVjdGF0aW9ucy50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDAy ODAzYwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi13azIvdGVz dF9leHBlY3RhdGlvbnMudHh0CkBAIC0wLDAgKzEsNCBAQAorLy8gVGhlc2UgYXJlIHRoZSBsYXlv dXQgdGVzdCBleHBlY3RhdGlvbnMgZm9yIEFwcGxlJ3MgV2luZG93cyBwb3J0IG9mIFdlYktpdDIu CisvLworLy8gU2VlIGh0dHA6Ly90cmFjLndlYmtpdC5vcmcvd2lraS9UZXN0RXhwZWN0YXRpb25z IGZvciBtb3JlIGluZm9ybWF0aW9uIG9uIHRoaXMgZmlsZS4KKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vd2syL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL3drMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMC4uN2U2MThlYwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3BsYXRm b3JtL3drMi90ZXN0X2V4cGVjdGF0aW9ucy50eHQKQEAgLTAsMCArMSw0IEBACisvLyBUaGVzZSBh cmUgdGhlIGxheW91dCB0ZXN0IGV4cGVjdGF0aW9ucyBmb3IgdGhlIGNvbW1vbiBwb3J0IG9mIFdl YktpdDIuCisvLworLy8gU2VlIGh0dHA6Ly90cmFjLndlYmtpdC5vcmcvd2lraS9UZXN0RXhwZWN0 YXRpb25zIGZvciBtb3JlIGluZm9ybWF0aW9uIG9uIHRoaXMgZmlsZS4KKwpkaWZmIC0tZ2l0IGEv VG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDczNzlmZjQuLjhmNmExNDAg MTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNCBAQAorMjAxMS0wOC0xOCAgS3Jpc3TDs2YgS29zenR5w7MgIDxra3Jpc3RvZkBpbmYu dS1zemVnZWQuaHU+CisKKyAgICAgICAgTlJXVCBzaG91bGQgc3VwcG9ydCBjYXNjYWRpbmcgZXhw ZWN0YXRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD02NTgzNAorCisgICAgICAgIFRoZSB3ZWJraXQyIHBvcnRzIGNhbiBzaGFyZSB0aGVpciBjb21t b24gZXhwZWN0YXRpb25zIGluIHRoZSB3azIgcGxhdGZvcm0uCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L3dlYmtpdC5weToKKwogMjAxMS0wOC0xNiAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3 ZWJraXQub3JnPgogCiAgICAgICAgIE1vdmUgY2hyb21pdW0tbWFjIHRvIGNocm9taXVtLWNnLW1h YyB0byBwcmVwYXJlIGZvciBTa2lhIHN3aXRjaG92ZXIKZGlmZiAtLWdpdCBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5IGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKaW5kZXggZjE4OGRkOC4uYzA5YTI4 YyAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93 ZWJraXQucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93 ZWJraXQucHkKQEAgLTc3LDcgKzc3LDcgQEAgY2xhc3MgV2ViS2l0UG9ydChQb3J0KToKIAogICAg IGRlZiBwYXRoX3RvX3Rlc3RfZXhwZWN0YXRpb25zX2ZpbGUoc2VsZik6CiAgICAgICAgICMgdGVz dF9leHBlY3RhdGlvbnMgYXJlIGFsd2F5cyBpbiBtYWMvIG5vdCBtYWMtbGVvcGFyZC8gYnkgY29u dmVudGlvbiwgaGVuY2Ugd2UgdXNlIHBvcnRfbmFtZSBpbnN0ZWFkIG9mIG5hbWUoKS4KLSAgICAg ICAgZXhwZWN0YXRpb25zX2RpcmVjdG9yeSA9IHNlbGYuX3drMl9wb3J0X25hbWUoKSBpZiBzZWxm LmdldF9vcHRpb24oJ3dlYmtpdF90ZXN0X3J1bm5lcicpIGVsc2Ugc2VsZi5wb3J0X25hbWUKKyAg ICAgICAgZXhwZWN0YXRpb25zX2RpcmVjdG9yeSA9IHNlbGYucG9ydF9uYW1lCiAgICAgICAgIHJl dHVybiBzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoZXhw ZWN0YXRpb25zX2RpcmVjdG9yeSksICd0ZXN0X2V4cGVjdGF0aW9ucy50eHQnKQogCiAgICAgZGVm IF9kcml2ZXJfYnVpbGRfc2NyaXB0X25hbWUoc2VsZik6CkBAIC0zMzQsOCArMzM0LDQxIEBAIGNs YXNzIFdlYktpdFBvcnQoUG9ydCk6CiAgICAgICAgIGlmIHNlbGYuX2ZpbGVzeXN0ZW0uZXhpc3Rz KGV4cGVjdGF0aW9uc19wYXRoKToKICAgICAgICAgICAgIF9sb2cuZGVidWcoIlVzaW5nIHRlc3Rf ZXhwZWN0YXRpb25zLnR4dDogJXMiICUgZXhwZWN0YXRpb25zX3BhdGgpCiAgICAgICAgICAgICBl eHBlY3RhdGlvbnMgPSBzZWxmLl9maWxlc3lzdGVtLnJlYWRfdGV4dF9maWxlKGV4cGVjdGF0aW9u c19wYXRoKSArIGV4cGVjdGF0aW9ucworICAgICAgICAgICAgaWYgc2VsZi5nZXRfb3B0aW9uKCd3 ZWJraXRfdGVzdF9ydW5uZXInKToKKyAgICAgICAgICAgICAgICBleHBlY3RhdGlvbnMgPSBzZWxm LmNhc2NhZGVfd2syX3Rlc3RfZXhwZWN0YXRpb25zKCkgKyBleHBlY3RhdGlvbnMKKyAgICAgICAg cmV0dXJuIHNlbGYuY2xlYXJfZHVwbGljYXRlZF9leHBlY3RhdGlvbnMoZXhwZWN0YXRpb25zKQor CisgICAgZGVmIGNhc2NhZGVfd2syX3Rlc3RfZXhwZWN0YXRpb25zKHNlbGYpOgorICAgICAgICBl eHBlY3RhdGlvbnMgPSAnJworICAgICAgICBwb3J0X3drMl9kaXJlY3RvcnkgPSBzZWxmLl93azJf cG9ydF9uYW1lKCkKKyAgICAgICAgd2syX2RpcmVjdG9yeSA9ICd3azInCisgICAgICAgIHBhdGhf dG9fcG9ydF93azJfdGVzdF9leHBlY3RhdGlvbnMgPSBzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2Vs Zi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgocG9ydF93azJfZGlyZWN0b3J5KSwgJ3Rlc3RfZXhwZWN0 YXRpb25zLnR4dCcpCisgICAgICAgIHBhdGhfdG9fd2syX3Rlc3RfZXhwZWN0YXRpb25zID0gc2Vs Zi5fZmlsZXN5c3RlbS5qb2luKHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHdrMl9kaXJlY3Rv cnkpLCAndGVzdF9leHBlY3RhdGlvbnMudHh0JykKKworICAgICAgICBpZiBzZWxmLl9maWxlc3lz dGVtLmV4aXN0cyhwYXRoX3RvX3BvcnRfd2syX3Rlc3RfZXhwZWN0YXRpb25zKToKKyAgICAgICAg ICAgIGV4cGVjdGF0aW9ucyA9IHNlbGYuX2ZpbGVzeXN0ZW0ucmVhZF90ZXh0X2ZpbGUocGF0aF90 b19wb3J0X3drMl90ZXN0X2V4cGVjdGF0aW9ucykKKyAgICAgICAgaWYgc2VsZi5fZmlsZXN5c3Rl bS5leGlzdHMocGF0aF90b193azJfdGVzdF9leHBlY3RhdGlvbnNfZmlsZSk6CisgICAgICAgICAg ICBleHBlY3RhdGlvbnMgKz0gc2VsZi5fZmlsZXN5c3RlbS5yZWFkX3RleHRfZmlsZShwYXRoX3Rv X3drMl90ZXN0X2V4cGVjdGF0aW9ucykKKwogICAgICAgICByZXR1cm4gZXhwZWN0YXRpb25zCiAK KyAgICBkZWYgY2xlYXJfZHVwbGljYXRlZF9leHBlY3RhdGlvbnMoc2VsZiwgZXhwZWN0YXRpb25z KToKKyAgICAgICAgdGVzdHMgPSBzZXQoKQorICAgICAgICByZXN1bHQgPSAnJworICAgICAgICBm b3IgbGluZSBpbiBleHBlY3RhdGlvbnMuc3BsaXQoJ1xuJyk6CisgICAgICAgICAgICBpZiByZS5t YXRjaCgnLy8nLCBsaW5lKToKKyAgICAgICAgICAgICAgICByZXN1bHQgKz0gbGluZSArICdcbicK KyAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgcGFydCA9IGxpbmUuc3BsaXQoJzon KQorICAgICAgICAgICAgICAgIGlmIGxlbihwYXJ0KSA8IDI6CisgICAgICAgICAgICAgICAgICAg IHJlc3VsdCArPSBsaW5lICsgJ1xuJworICAgICAgICAgICAgICAgICAgICBjb250aW51ZQorICAg ICAgICAgICAgICAgIHBhcnQgPSBwYXJ0WzFdLnNwbGl0KCc9JykKKyAgICAgICAgICAgICAgICBp ZiBwYXJ0WzBdIG5vdCBpbiB0ZXN0czoKKyAgICAgICAgICAgICAgICAgICAgdGVzdHMuYWRkKHBh cnRbMF0pCisgICAgICAgICAgICAgICAgICAgIHJlc3VsdCArPSBsaW5lICsgJ1xuJworICAgICAg ICByZXR1cm4gcmVzdWx0CisKICAgICBkZWYgX3NraXBwZWRfbGlzdF9hc19leHBlY3RhdGlvbnMo c2VsZik6CiAgICAgICAgICMgRWFjaCBTa2lwcGVkIGZpbGUgY29udGFpbnMgYSBsaXN0IG9mIGZp bGVzCiAgICAgICAgICMgb3IgZGlyZWN0b3JpZXMgdG8gYmUgc2tpcHBlZCBkdXJpbmcgdGhlIHRl c3QgcnVuLiBUaGUgdG90YWwgbGlzdAotLSAKMS43LjEKCg==