30491 2009-10-18 06:03:47 -0700 Pressing Enter in <isindex> doesn't submit it if there is no form 2009-11-07 19:38:20 -0800 1 1 1 Unclassified WebKit Forms 528+ (Nightly build) All All RESOLVED FIXED http://webblaze.org/dbates/xsstest-isindex.php P2 Normal --- 1 grawity dbates andersca ap aroben bdakin darin dbates vicki oldest_to_newest 155468 0 grawity 2009-10-18 06:03:47 -0700 (I'm not sure if this is the correct place, but...) I'm using Epiphany 2.28.0 (AppleWebKit/531.2+ libwebkit 1.1.15.2), and I have noticed that it is impossible to submit forms created with the <isindex> HTML tag. The input box appears, but does not react to pressing the Enter key. (No submit button either.) The same happens with Midori 0.2.0 (same WebKit version). 155517 1 ap 2009-10-18 12:52:54 -0700 Do you have a test case you could link to, or attach? 155603 2 dbates 2009-10-19 00:20:44 -0700 Confirmed this issue effects the Windows and Mac builds. Example: http://webblaze.org/dbates/xsstest-isindex.php Enter a search keyword. Try to the submit the keyword. Neither pressing the return key nor the enter key on the keyboard submit the keyword (as you would expect if this was a typical form). Expected result: Without loss of generality, suppose the search keyboard is "dog". Then on pressing return or enter on the keyboard, the page should redirect to: http://webblaze.org/dbates/xsstest-isindex.php?dog 155606 3 dbates 2009-10-19 00:43:36 -0700 On looking through the layout tests, the closest test I came across is http/tests/misc/isindex-formdata.html. But this only tests the case when <isindex> is within an HTML form element. All of the other <isindex> layout tests I saw are similar. Section 7.5 "Queries and Indexes" of the HTML 2.0 spec. (http://www.rfc-editor.org/rfc/rfc1866.txt) implies that the <isindex> element can appear standalone (or at the very least along with an HTML Base element). That is, it does not have to appear within an HTML Form element. Firefox seems to follow this interpretation. 155820 4 41437 dbates 2009-10-19 12:17:00 -0700 Created attachment 41437 Layout tests Included in this patch are two layout tests, both without enclosing the <isindex> tag within a <form> element: 1) isindex-with-no-form.html: A page with a standalone <isindex> tag. Any submitted result will be submitted to the same page. This matches the default behavior of Firefox. 2) isindex-with-no-form-base-href.html: A page with a <isindex> tag and <base> tag. The submitted result should be sent to the page resources/isindex-with-no-form-base-href-submit.html for processing (as indicated by the href property of the HTML Base element). The tests work by using DRT's eventSender to send the simulate pressing the return key on the keyboard. Until we fix this bug, both tests time out under DRT. 157523 5 41804 dbates 2009-10-24 18:36:11 -0700 Created attachment 41804 Patch with test cases (work in progress) 157535 6 41807 dbates 2009-10-24 20:14:29 -0700 Created attachment 41807 Patch with test cases 157550 7 41807 dbates 2009-10-24 21:16:06 -0700 Comment on attachment 41807 Patch with test cases Need to think about this some more. This patch does not conform to <http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87069980> 157559 8 41814 dbates 2009-10-24 22:40:25 -0700 Created attachment 41814 Patch with test cases Moved code into HTMLInputElement::defaultEventHandler so that we don't create a form that is visible to the client. Hence, we conform to http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/level-one-html#ID-87069980. I am open to suggestions on the placement of this code. Also, let me know if you have a better name for the variable myForm. This patch passes all layout tests, on my Mac, as of r49810. 157560 9 dbates 2009-10-24 22:47:54 -0700 Found out that my original patch was basically a revert of: https://bugs.webkit.org/show_bug.cgi?id=4828 (<rdar://problem/4288307>) The latest patch <https://bug-30491-attachments.webkit.org/attachment.cgi?id=41814> passes all DRT layout tests, including dom/html/level2/html/HTMLIsIndexElement02.html (which lead to the patch for bug #4828). I am CC'ing Darin, Viki, and Anders on this bug, since they may have some additional insight (from bug #4828). Some additional notes: According to the HTML 2.0 spec (http://www.w3.org/MarkUp/html-spec/html-spec_7.html#SEC7.5), <isindex> should not need to be within a <form> to be able to submit it. Moreover, <isindex> precedes the introduction of HTML forms, see HTML 1.2 <http://www.w3.org/MarkUp/draft-ietf-iiir-html-01.txt>. Additionally, the 2.0 spec. implies that the href property of the <base> element should be dictate where the value of the <isindex> element is sent (analogous to the action property of a <form>)(*). Another issue is that <isindex> should be able to work when inside <head> as stated in the HTML 1.2 and later specs. But we should probably file another bug for this issue. Both IE 8 and Firefox seem to correctly handle the <isindex> element. (*) Only Firefox respects this. Doesn't seem to work in IE 8. 157564 10 dbates 2009-10-24 23:35:11 -0700 CC'ing Beth Dakin, since she reviewed <http://trac.webkit.org/changeset/10779>. 157646 11 41814 darin 2009-10-25 17:45:46 -0700 Comment on attachment 41814 Patch with test cases > + RefPtr<HTMLFormElement> myForm = form(); I don’t think the "my" prefix is helpful to explain this local variable's purpose. By definition, this->form() is "my form", so the prefix simply creates confusion. I suggest formForSubmission as the name here. > + bool isIsIndexElementAndThereIsNoForm = (inputType() == ISINDEX) && !form(); It seems a waste to call form() again when we have a local variable with that same value in it. Also, those parentheses are not needed, and we normally omit them although I suppose they could confuse newcomers to C programming. > + if (isIsIndexElementAndThereIsNoForm) { > + // Since this <isindex> is not contained within a <form>, we create one. > + myForm = new HTMLFormElement(formTag, document()); > + myForm->registerFormElement(this); > + myForm->setMethod("GET"); > + if (!document()->baseURL().isEmpty()) { > + // We treat the href property of the <base> element as the form action, as per section 7.5 > + // "Queries and Indexes" of the HTML 2.0 spec. <http://www.w3.org/MarkUp/html-spec/html-spec_7.html#SEC7.5>. > + myForm->setAction(document()->baseURL().string()); > + } > + } Putting so much code in line into this function just for this element is inelegant. I suggest creating a separate function to create the temporary form. It could be a non-member function or if you prefer it could be a private member function named createTemporaryForm which returns a PassRefPtr<HTMLFormElement>. Then the code here would be just: RefPtr<HTMLFormElement> formForSubmission = form(); // If there is no form and the element is an <isindex>, then create a temporary form just to be used for submission. if (!formForSubmission && inputType() == ISINDEX) formForSubmission = createTemporaryForm(this). // Form may never have been present, or may have been destroyed by code responding to the change event. if (formForSubmission) formForSubmission->submitClick(evt); I think that's easier to read. > + if (isIsIndexElementAndThereIsNoForm) > + myForm.clear(); This is not needed. A RefPtr will automatically release its value when it goes out of scope and there's no need to ensure it's dereferenced before calling setDefaultHandled. Since the <isindex> is one of the form's elements, isn't there a chance this might call dispatchSimulatedClick on the <isindex>? What prevents this from happening? If it does happen, will it do the right thing? Why won't this just end up creating another temporary form in an infinite loop? Do we guarantee this form won't be seen by any JavaScript code? Is there any way an event handler might somehow see this event and get its target and so get at the underlying form? > +If you are running this test by hand, submit the phrase: "This is a test" (without quotes). Doesn't that text automatically get put into the field by the JavaScript even when running the test by hand? I think that instruction is unneeded, but OK. Why does this need to be an HTTP test? We can do form submissions with local URLs. Can these same tests just be put in fast/forms instead of http/tests/misc and run without requiring the http server? Is it in the http section because of the base element? This patch seems pretty good and probably ready to go, but I had enough questions and suggestions that I'm going to say review- for now. 158031 12 dbates 2009-10-26 17:26:17 -0700 (In reply to comment #11) > (From update of attachment 41814 [details]) > > + RefPtr<HTMLFormElement> myForm = form(); > > I don’t think the "my" prefix is helpful to explain this local variable's > purpose. By definition, this->form() is "my form", so the prefix simply creates > confusion. I suggest formForSubmission as the name here. Will do. > > > + bool isIsIndexElementAndThereIsNoForm = (inputType() == ISINDEX) && !form(); > > It seems a waste to call form() again when we have a local variable with that > same value in it. Also, those parentheses are not needed, and we normally omit > them although I suppose they could confuse newcomers to C programming. > > > + if (isIsIndexElementAndThereIsNoForm) { > > + // Since this <isindex> is not contained within a <form>, we create one. > > + myForm = new HTMLFormElement(formTag, document()); > > + myForm->registerFormElement(this); > > + myForm->setMethod("GET"); > > + if (!document()->baseURL().isEmpty()) { > > + // We treat the href property of the <base> element as the form action, as per section 7.5 > > + // "Queries and Indexes" of the HTML 2.0 spec. <http://www.w3.org/MarkUp/html-spec/html-spec_7.html#SEC7.5>. > > + myForm->setAction(document()->baseURL().string()); > > + } > > + } > > Putting so much code in line into this function just for this element is > inelegant. I suggest creating a separate function to create the temporary form. > It could be a non-member function or if you prefer it could be a private member > function named createTemporaryForm which returns a PassRefPtr<HTMLFormElement>. > Then the code here would be just: > > RefPtr<HTMLFormElement> formForSubmission = form(); > > // If there is no form and the element is an <isindex>, then create a > temporary form just to be used for submission. > if (!formForSubmission && inputType() == ISINDEX) > formForSubmission = createTemporaryForm(this). > > // Form may never have been present, or may have been destroyed by code > responding to the change event. > if (formForSubmission) > formForSubmission->submitClick(evt); > > I think that's easier to read. I agree. I'll refactor it. > > > + if (isIsIndexElementAndThereIsNoForm) > > + myForm.clear(); > > This is not needed. A RefPtr will automatically release its value when it goes > out of scope and there's no need to ensure it's dereferenced before calling > setDefaultHandled. > Will remove it. > Since the <isindex> is one of the form's elements, isn't there a chance this > might call dispatchSimulatedClick on the <isindex>? What prevents this from > happening? If it does happen, will it do the right thing? Why won't this just > end up creating another temporary form in an infinite loop? No, there is no chance this will call dispatchSimulatedClick on the <isindex>. Looking at HTMLFormElement::submitClick, which is the only place where dispatchSimulatedClick is called from in the file HTMLFormElement.cpp, only image/submit buttons are dispatched simulated clicks by the first conjunction of the inner-if condition (*), element->isSuccessfulSubmitButton(). And, by line 903 of HTMLInputElement.cpp <http://trac.webkit.org/browser/trunk/WebCore/html/HTMLInputElement.cpp#L903>, HTMLInputElement::isSuccessfulSubmitButton() only returns true if it is enabled and the type property is either "image" or "submit". But, an <isindex> element has type "isindex", so (*) never evaluates to true. So, HTMLFormElement::submitClick never calls dispatchSimulatedClick on an <isindex> element. > Do we guarantee this form won't be seen by any JavaScript code? Is there any > way an event handler might somehow see this event and get its target and so get > at the underlying form? I assume you are referring to the case that dispatchSimulatedClick fired on an <isindex> element, in which case a JavaScript installed event handler may be able to catch the simulated click event. By the above argument, it is impossible for method dispatchSimulatedClick() to be called. So, no simulated click event is generated. Or am I misunderstanding your question? > > +If you are running this test by hand, submit the phrase: "This is a test" (without quotes). > > Doesn't that text automatically get put into the field by the JavaScript even > when running the test by hand? I think that instruction is unneeded, but OK. Changed to read: "If you are running this test by hand, press the enter/return key on your keyboard to submit." > Why does this need to be an HTTP test? We can do form submissions with local > URLs. Can these same tests just be put in fast/forms instead of http/tests/misc > and run without requiring the http server? Is it in the http section because of > the base element? Yes, it is in the http section because of the HTML Base element. If you want we can probably separate the test cases so as to put isindex-with-no-form-base-href.html in fast/form and leave isindex-with-no-form-base-href.html in http/tests/misc. Note, another isindex test case, isindex-formdata.html, (which I based my tests on) is in the http/tests/misc directory. 158033 13 darin 2009-10-26 17:28:56 -0700 (In reply to comment #12) > Yes, it is in the http section because of the HTML Base element. If you want we > can probably separate the test cases so as to put > isindex-with-no-form-base-href.html in fast/form and leave > isindex-with-no-form-base-href.html in http/tests/misc. I do think that would be better. > Note, another isindex test case, isindex-formdata.html, (which I based my tests > on) is in the http/tests/misc directory. I don't know why. The original author, Adam Roben, might remember. I think it would be better if someone moved it to fast/forms. 158035 14 41918 dbates 2009-10-26 17:33:23 -0700 Created attachment 41918 Patch with test cases Updated patch based on Darin's suggestions. I decided to define a no-argument method called HTMLInputElement::createTemporaryFormForIsIndex as opposed to something more generalized (like createTemporaryForm as Darin suggested) because only the <isindex> element needs to create a temporary form and this form must always register the form element we are in (i.e. this) plus possibly use the base href URL as the form action (which is very <isindex>-specific functionality). 158045 15 41918 darin 2009-10-26 17:43:13 -0700 Comment on attachment 41918 Patch with test cases > + if (window.eventSender) > + eventSender.keyDown(String.fromCharCode(0x0d)); I'm kind of sad that we had to use eventSender to test this. Wasn't there any other way to do it? 158073 16 dbates 2009-10-26 19:57:56 -0700 Not that I know of. The <isindex> element includes no submit button (probably because the submit button did not even exist in the HTML 1.2 spec when <isindex> came out). So, to submit the <isindex> value you need to press the return/enter key on the keyboard. DRT does not appear to have a general submit form method. Hence I used window.eventSender to simulate a key press. (In reply to comment #15) > (From update of attachment 41918 [details]) > > + if (window.eventSender) > > + eventSender.keyDown(String.fromCharCode(0x0d)); > > I'm kind of sad that we had to use eventSender to test this. Wasn't there any > other way to do it? 158081 17 41918 commit-queue 2009-10-26 20:29:34 -0700 Comment on attachment 41918 Patch with test cases Rejecting patch 41918 from commit-queue. Failed to run "['WebKitTools/Scripts/run-webkit-tests', '--no-launch-safari', '--quiet', '--exit-after-n-failures=1']" exit_code: 1 Running build-dumprendertree Running tests from /Users/eseidel/Projects/CommitQueue/LayoutTests Testing 11526 test cases. http/tests/misc/isindex-with-no-form.html -> failed Exiting early after 1 failures. 8619 tests run. 212.12s total testing time 8618 test cases (99%) succeeded 1 test case (<1%) had incorrect layout 4 test cases (<1%) had stderr output 158099 18 dbates 2009-10-26 23:05:49 -0700 Oops, I forgot to change isindex-with-no-form-expected.txt to have the line: "If you are running this test by hand, press the enter/return key on your keyboard to submit." Will land manually with this correction. (In reply to comment #17) > (From update of attachment 41918 [details]) > Rejecting patch 41918 from commit-queue. > > Failed to run "['WebKitTools/Scripts/run-webkit-tests', '--no-launch-safari', > '--quiet', '--exit-after-n-failures=1']" exit_code: 1 > Running build-dumprendertree > Running tests from /Users/eseidel/Projects/CommitQueue/LayoutTests > Testing 11526 test cases. > http/tests/misc/isindex-with-no-form.html -> failed > > Exiting early after 1 failures. 8619 tests run. > 212.12s total testing time > > 8618 test cases (99%) succeeded > 1 test case (<1%) had incorrect layout > 4 test cases (<1%) had stderr output 158224 19 darin 2009-10-27 09:55:19 -0700 (In reply to comment #16) > The <isindex> element includes no submit button (probably because the submit > button did not even exist in the HTML 1.2 spec when <isindex> came out). I don’t understand what you mean by "submit button" here. > So, to submit the <isindex> value you need to press the return/enter key on the > keyboard. DRT does not appear to have a general submit form method. Hence I > used window.eventSender to simulate a key press. You can simulate the effect of pressing the return/enter key a various ways that do not depend on special features of DumpRenderTree. For example, you can use DOM keyboard events. An example of a test that uses this technique is forms/input-text-enter.html. Another possibility that might well work is to call the click() function on the input element. You should at least try these before landing a test that uses eventSender. 158462 20 dbates 2009-10-27 20:36:00 -0700 (In reply to comment #19) > (In reply to comment #16) > > The <isindex> element includes no submit button (probably because the submit > > button did not even exist in the HTML 1.2 spec when <isindex> came out). > I don’t understand what you mean by "submit button" here. Disregarding stylistic markup, you can think of the <isindex> element as semantically equivalent to the HTML markup: <form method="get"><input type="text"/></form>. Notice, the absence of a submit button (i.e. <input type="submit" .../>). So, how does a user submit such a form? They have to first give <input> focus, then press the return/enter key on their keyboard (at least as far as I know). > > So, to submit the <isindex> value you need to press the return/enter key on the > > keyboard. DRT does not appear to have a general submit form method. Hence I > > used window.eventSender to simulate a key press. > > You can simulate the effect of pressing the return/enter key a various ways > that do not depend on special features of DumpRenderTree. > > For example, you can use DOM keyboard events. An example of a test that uses > this technique is forms/input-text-enter.html. I tried to use DOM keyboard events (first thing I tried) to simulate pressing the return/enter key but it didn't work for submitting a form. I'll take a second look. > Another possibility that might well work is to call the click() function on the > input element. I did not try this, so I will take a look. But I am sketical since I do not believe clicking on an <input type="text" ...> is sufficient to submit its value. Instead, I would figure it just gives focus to the input. > > You should at least try these before landing a test that uses eventSender. 158468 21 darin 2009-10-27 22:15:05 -0700 (In reply to comment #20) > I tried to use DOM keyboard events (first thing I tried) to simulate pressing > the return/enter key but it didn't work for submitting a form. I'll take a > second look. You should definitely try again; a little debugging should reveal why it's not working. Maybe you sent the wrong type of keyboard event? It's a good idea to start with the input-text-enter.html test because it definitely works and is quite similar to what you're trying to do. 159194 22 dbates 2009-10-29 19:36:59 -0700 It appears that it is not working because DOM keyboard events are broken (bug #16735). Moreover, DOM Level 3 Keyboard Events are not working (bug #9933). We need to fix these bugs for us to be able to use DOM keyboard events instead of the DRT eventSender. On another note, notice that fast/forms/input-text-enter.html also uses DRT eventSender. I suspect this is to work around these bugs. (In reply to comment #21) > (In reply to comment #20) > > I tried to use DOM keyboard events (first thing I tried) to simulate pressing > > the return/enter key but it didn't work for submitting a form. I'll take a > > second look. > > You should definitely try again; a little debugging should reveal why it's not > working. Maybe you sent the wrong type of keyboard event? It's a good idea to > start with the input-text-enter.html test because it definitely works and is > quite similar to what you're trying to do. 159204 23 42172 dbates 2009-10-29 19:50:27 -0700 Created attachment 42172 KeyboardEvent Test For reference, I have attached the test I wrote. If I have some time, I'll clean up the test, document it better, and file it under the appropriate bug (or create one if needed). There are actually three bugs (that I have found so far) that are running around here (ordered by what I think is causing the test to fail): #16735, #9933, #13368 159338 24 darin 2009-10-30 10:19:37 -0700 (In reply to comment #22) > On another note, notice that fast/forms/input-text-enter.html also uses DRT > eventSender. I suspect this is to work around these bugs. I don't think that's why. I originally wrote this test three years ago. I think what happened is that I accidentally left both eventSender and DOM keyboard code in the test. 159405 25 dbates 2009-10-30 12:43:13 -0700 Do you have any insight into why the test case KeyboardEvent Test does not work? If you substitute the line initKeyboardEvent line from input-text-enter.html verbatim for the line: keyPressEvent.initKeyboardEvent("keypress", true, true, document.defaultView, "U+000D" /* carriage return */, 0, false, false, false, false, false); the test still does not run under Safari. The only change I made from input-text-enter.html was that I replaced "Enter" with "U+000D" which is the Unicode value for the carriage return key because "Enter" did not work, and I just wanted to make sure I was simulating the same key code. Compare the result of this test under Firefox. Moreover, notice, the captured keycode for the automatically generated keyboard event is: (*) keypress - key: U+000D@0 (keyCode/charCode: 0/0) modifiers: false,false,false,false But it should be something of the form: keypress - key: U+000D@0 (keyCode/charCode: 13/0) modifiers: false,false,false,false OR (**) keypress - key: U+000D@0 (keyCode/charCode: 13/13) modifiers: false,false,false,false And if you manually submit the test (click to focus on the input field then return the return key on the keyboard), notice we get something of the form like (**), but the test still fails. The missing keyCode/charCode = 0 in (*) is very troubling (i.e. how does it know what key to press, does it trust the keyIdentifier? or the keyCode? or the charCode?). Hence, this sounds like bug #16735. At least with my test, it doesn't appear to trust the keyIdentifier because it doesn't submit the form, and thus makes me think WebKit is using either the keyCode or charCode when simulating a key but I haven't looked at the code yet to confirm. Also, from writing my test, I was neither able to explicitly set keyCode nor charCode for the event. When I tried, the change was never made. For example, add the following code under the line that contains "keyPressEvent.initKeyboardEvent": keyPressEvent.keyCode = 13; alert(keyPressEvent.keyCode); Notice, when the run the test, the alert says "0", which is not 13. Repeat the test substituting charCode for keyCode in the above lines and you will get the same result. Why are these properties act like they are read-only? (I haven't checked the spec yet, but I don't get the feeling that they should be). (In reply to comment #24) > (In reply to comment #22) > > On another note, notice that fast/forms/input-text-enter.html also uses DRT > > eventSender. I suspect this is to work around these bugs. > > I don't think that's why. I originally wrote this test three years ago. I think > what happened is that I accidentally left both eventSender and DOM keyboard > code in the test. 159409 26 darin 2009-10-30 12:56:43 -0700 (In reply to comment #25) > The only change I made from > input-text-enter.html was that I replaced "Enter" with "U+000D" which is the > Unicode value for the carriage return key because "Enter" did not work, and I > just wanted to make sure I was simulating the same key code. You can’t just change that. The code uses "Enter" as the key identifier for that key, not "U+000D". This matches the version of the DOM 3 specification at the time we implemented the class. > Moreover, notice, the captured keycode for the automatically generated keyboard > event is: > (*) keypress - key: U+000D@0 (keyCode/charCode: 0/0) modifiers: > false,false,false,false > > But it should be something of the form: > > keypress - key: U+000D@0 (keyCode/charCode: 13/0) modifiers: > false,false,false,false > > OR > > (**) keypress - key: U+000D@0 (keyCode/charCode: 13/13) modifiers: > false,false,false,false Yes, that's definitely a bug, probably separate from the question of why a DOM-created event doesn't work. To figure out how to make such events work is tricky. The standard ignores the keyCode and charCode properties, so it’s hard to know how they should be set. > And if you manually submit the test (click to focus on the input field then > return the return key on the keyboard), notice we get something of the form > like (**), but the test still fails. The missing keyCode/charCode = 0 in (*) > is very troubling (i.e. how does it know what key to press, does it trust the > keyIdentifier? or the keyCode? or the charCode?). You are talking here like you can’t read the code that does the form submission. But you can. It’s right there in the WebCore DOM source code. If you find the relevant function you can answer the question about how it figures out which event is a form submission. You should stop guessing about this and look at the source. > Hence, this sounds like bug > #16735. At least with my test, it doesn't appear to trust the keyIdentifier > because it doesn't submit the form, and thus makes me think WebKit is using > either the keyCode or charCode when simulating a key but I haven't looked at > the code yet to confirm. Also, from writing my test, I was neither able to > explicitly set keyCode nor charCode for the event. When I tried, the change was > never made. For example, > add the following code under the line that contains > "keyPressEvent.initKeyboardEvent": > > keyPressEvent.keyCode = 13; > alert(keyPressEvent.keyCode); > > Notice, when the run the test, the alert says "0", which is not 13. Repeat the > test substituting charCode for keyCode in the above lines and you will get the > same result. Why are these properties act like they are read-only? (I haven't > checked the spec yet, but I don't get the feeling that they should be). All tangentially related to why it's hard to use keyboard events to make a test, but possibly not critical. If you ignore some of these side issues you can look at the WebCore DOM source code and figure out what the event would have to have on it to work for testing purposes. Some of the bugs in the DOM event classes, though, actually reflect DOM 3 standard design issues. It is difficult to use keyboard events that are compatible with the DOM 3 specification, and also the web. It's not clear if DOM 3 offers APIs sufficient to create events that are sufficiently like the real events web pages receive in response to actual input. A closely related issue is how built in behavior in the engine gets information for events. It's actually a kind of deep subject and worthwhile to look at one issue at a time. 159424 27 dbates 2009-10-30 13:28:27 -0700 (In reply to comment #26) > > You are talking here like you can’t read the code that does the form > submission. But you can. It’s right there in the WebCore DOM source code. If > you find the relevant function you can answer the question about how it figures > out which event is a form submission. You should stop guessing about this and > look at the source. Ok. I'll take a look and get back to you shortly. 161032 28 dbates 2009-11-05 18:16:18 -0800 Weird, I could have sworn I committed this with bugzilla-tool. Yet, it neither closed this bug (which I need to re-open anyway) nor recorded the changeset of the commit. Committed r50132: <http://trac.webkit.org/changeset/50132> 161033 29 dbates 2009-11-05 18:17:51 -0800 Re-opening this bug to work on getting rid of the use of window.eventSender from the layout test committed as part of the patch for this bug. 161043 30 41918 dbates 2009-11-05 19:13:23 -0800 Comment on attachment 41918 Patch with test cases Clearing the commit-queue flag. 161391 31 dbates 2009-11-07 19:38:20 -0800 On Maciej's suggestion, I am closing this bug since the issue has been addressed. I filed a new bug #31234 to address making the tests cases: http/tests/misc/isindex-with-no-form-base-href.html http/tests/misc/isindex-with-no-form.html work using DOM keyboard events. 41437 2009-10-19 12:17:00 -0700 2009-10-24 18:36:11 -0700 Layout tests isindex-layouttests.patch text/plain 5142 dbates SW5kZXg6IExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS1i YXNlLWhyZWYuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mv aXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0 bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTQgQEAKKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0 PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgIGxheW91dFRlc3RDb250 cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQ2hpbGRG cmFtZXNBc1RleHQoKTsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7 Cit9Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGlmcmFtZSBzcmM9InJlc291cmNlcy9p c2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYuaHRtbCI+PC9pZnJhbWU+Cis8L2JvZHk+Cis8 L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2lzaW5k ZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3Rz L2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVm Lmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3Vy Y2VzL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sCShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDIzIEBACis8aHRtbD4KKzxoZWFkPgorPGJhc2UgaHJlZj0iaHR0cDovL2xvY2FsaG9z dDo4MDAwL21pc2MvcmVzb3VyY2VzL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi1zdWJt aXQuaHRtbCI+Cis8c2NyaXB0PgorZnVuY3Rpb24gdGVzdCgpCit7CisgICAgdmFyIGlzaW5kZXhF bG0gPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiaXNpbmRleCIpOworICAgIGlzaW5kZXhFbG0u dmFsdWUgPSAiVGhpcyBpcyBhIHRlc3QiOworICAgIGlzaW5kZXhFbG0uZm9jdXMoKTsKKworICAg IGlmICh3aW5kb3cuZXZlbnRTZW5kZXIpCisgICAgICAgIGV2ZW50U2VuZGVyLmtleURvd24oU3Ry aW5nLmZyb21DaGFyQ29kZSgweDBkKSk7Cit9CisKK3dpbmRvdy5vbmxvYWQgPSB0ZXN0OworPC9z Y3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwPlRoaXMgcGFnZSB0ZXN0cyB0aGF0IHdlIGNvcnJl Y3RseSBwdXQgdGhlIHZhbHVlIG9mIGFuIDx0dD4mbHQ7aXNpbmRleCZndDs8L3R0PiBlbGVtZW50 IGludG8gdGhlIGZvcm0gZGF0YS48L3A+Cis8cD5JZiB5b3UgYXJlIHJ1bm5pbmcgdGhpcyB0ZXN0 IGJ5IGhhbmQsIHN1Ym1pdCB0aGUgcGhyYXNlOiAmcXVvdDtUaGlzIGlzIGEgdGVzdCZxdW90OyAo d2l0aG91dCBxdW90ZXMpLjwvcD4KKzxpc2luZGV4IGlkPSJpc2luZGV4Ij48L2lzaW5kZXg+Cis8 L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3Vy Y2VzL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi1zdWJtaXQuaHRtbAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2lzaW5kZXgtd2l0aC1u by1mb3JtLWJhc2UtaHJlZi1zdWJtaXQuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3Rz L2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVm LXN1Ym1pdC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI4IEBACis8aHRtbD4KKzxoZWFk PgorPHNjcmlwdD4KK2Z1bmN0aW9uIHRlc3QoKQoreyAgICAKKyAgICB2YXIgZXhwZWN0ZWQgPSAi P1RoaXMraXMrYSt0ZXN0IjsKKyAgICBpZiAobG9jYXRpb24uc2VhcmNoICE9IGV4cGVjdGVkKQor ICAgICAgICBsb2coIkZBSUw6IEV4cGVjdGVkIFwiIiArIGV4cGVjdGVkICsgIlwiIGJ1dCBnb3Qg XCIiICsgbG9jYXRpb24uc2VhcmNoICsgIlwiIik7CisgICAgZWxzZQorICAgICAgICBsb2coIlBB U1MiKTsKK30KKworZnVuY3Rpb24gbG9nKG1zZykKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgibG9nIikuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobXNnICsgIlxu IikpOworfQorCit3aW5kb3cub25sb2FkID0gdGVzdDsKKzwvc2NyaXB0PgorPC9oZWFkPgorPGJv ZHk+Cis8cHJlIGlkPSJsb2ciPjwvcHJlPgorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVz dENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworPC9z Y3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvaXNpbmRleC13aXRoLW5vLWZvcm0tZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91 dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS1leHBlY3RlZC50eHQJ KHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRo LW5vLWZvcm0tZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDcgQEAKK1RoaXMg cGFnZSB0ZXN0cyB0aGF0IHdlIGNvcnJlY3RseSBwdXQgdGhlIHZhbHVlIG9mIGFuIDxpc2luZGV4 PiBlbGVtZW50IGludG8gdGhlIGZvcm0gZGF0YS4KKworSWYgeW91IGFyZSBydW5uaW5nIHRoaXMg dGVzdCBieSBoYW5kLCBzdWJtaXQgdGhlIHBocmFzZTogIlRoaXMgaXMgYSB0ZXN0IiAod2l0aG91 dCBxdW90ZXMpLgorCitUaGlzIGlzIGEgc2VhcmNoYWJsZSBpbmRleC4gRW50ZXIgc2VhcmNoIGtl eXdvcmRzOiAKK1BBU1MKKwpJbmRleDogTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5k ZXgtd2l0aC1uby1mb3JtLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0uaHRtbAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSw0NCBAQAorPGh0bWw+Cis8aGVhZD4KKzxzY3JpcHQ+CitmdW5jdGlvbiB0 ZXN0KCkKK3sKKyAgICB2YXIgaXNpbmRleEVsbSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJp c2luZGV4Iik7CisgICAgaWYgKCFsb2NhdGlvbi5zZWFyY2gubGVuZ3RoKSB7CisgICAgICAgIGlm ICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVy LndhaXRVbnRpbERvbmUoKTsKKyAgICAgICAgfQorCisgICAgICAgIGlzaW5kZXhFbG0udmFsdWUg PSAiVGhpcyBpcyBhIHRlc3QiOworICAgICAgICBpc2luZGV4RWxtLmZvY3VzKCk7CisgICAgICAg IAorICAgICAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKQorICAgICAgICAgICAgZXZlbnRTZW5k ZXIua2V5RG93bihTdHJpbmcuZnJvbUNoYXJDb2RlKDB4MGQpKTsKKyAgICB9IGVsc2UgeworICAg ICAgICB2YXIgZXhwZWN0ZWQgPSAiP1RoaXMraXMrYSt0ZXN0IjsKKyAgICAgICAgaWYgKGxvY2F0 aW9uLnNlYXJjaCAhPSBleHBlY3RlZCkKKyAgICAgICAgICAgIGxvZygiRkFJTDogRXhwZWN0ZWQg XCIiICsgZXhwZWN0ZWQgKyAiXCIgYnV0IGdvdCBcIiIgKyBsb2NhdGlvbi5zZWFyY2ggKyAiXCIi KTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgbG9nKCJQQVNTIik7CisgICAgICAgICAgICAK KyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGxh eW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9uIGxv Zyhtc2cpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxvZyIpLmFwcGVuZENoaWxk KGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1zZyArICJcbiIpKTsKK30KKword2luZG93Lm9ubG9h ZCA9IHRlc3Q7Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHA+VGhpcyBwYWdlIHRlc3Rz IHRoYXQgd2UgY29ycmVjdGx5IHB1dCB0aGUgdmFsdWUgb2YgYW4gPHR0PiZsdDtpc2luZGV4Jmd0 OzwvdHQ+IGVsZW1lbnQgaW50byB0aGUgZm9ybSBkYXRhLjwvcD4KKzxwPklmIHlvdSBhcmUgcnVu bmluZyB0aGlzIHRlc3QgYnkgaGFuZCwgc3VibWl0IHRoZSBwaHJhc2U6ICZxdW90O1RoaXMgaXMg YSB0ZXN0JnF1b3Q7ICh3aXRob3V0IHF1b3RlcykuPC9wPgorPGlzaW5kZXggaWQ9ImlzaW5kZXgi PjwvaXNpbmRleD4KKzxwcmUgaWQ9ImxvZyI+PC9wcmU+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4 OiBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1o cmVmLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLWV4cGVjdGVkLnR4dAkocmV2aXNpb24g MCkKKysrIExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS1i YXNlLWhyZWYtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDcgQEAKKworCist LS0tLS0tLQorRnJhbWU6ICc8IS0tZnJhbWVQYXRoIC8vPCEtLWZyYW1lMC0tPi0tPicKKy0tLS0t LS0tCitQQVNTCisK 41804 2009-10-24 18:36:11 -0700 2009-10-24 20:14:29 -0700 Patch with test cases (work in progress) Bug30491_wip.patch text/plain 6598 dbates SW5kZXg6IFdlYkNvcmUvaHRtbC9IVE1MUGFyc2VyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L2h0bWwvSFRNTFBhcnNlci5jcHAJKHJldmlzaW9uIDQ5ODEwKQorKysgV2ViQ29yZS9odG1sL0hU TUxQYXJzZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xNTg0LDExICsxNTg0LDI2IEBACiAKIFBh c3NSZWZQdHI8Tm9kZT4gSFRNTFBhcnNlcjo6aGFuZGxlSXNpbmRleChUb2tlbiogdCkKIHsKLSAg ICBSZWZQdHI8Tm9kZT4gbiA9IG5ldyBIVE1MRGl2RWxlbWVudChkaXZUYWcsIG1fZG9jdW1lbnQp OworICAgIEhUTUxGb3JtRWxlbWVudCogZm9ybSA9IDA7CisgICAgUmVmUHRyPE5vZGU+IG47CiAK KyAgICBpZiAobV9jdXJyZW50Rm9ybUVsZW1lbnQpCisgICAgICAgIG4gPSBuZXcgSFRNTERpdkVs ZW1lbnQoZGl2VGFnLCBtX2RvY3VtZW50KTsKKyAgICBlbHNlIHsKKyAgICAgICAgLy8gU2luY2Ug dGhpcyA8aXNpbmRleD4gaXMgbm90IGNvbnRhaW5lZCB3aXRoaW4gYSA8Zm9ybT4sIHdlIGNyZWF0 ZSBvbmUuCisgICAgICAgIGZvcm0gPSBuZXcgSFRNTEZvcm1FbGVtZW50KGZvcm1UYWcsIG1fZG9j dW1lbnQpOworICAgICAgICBmb3JtLT5zZXRNZXRob2QoImdldCIpOworICAgICAgICBpZiAoIW1f ZG9jdW1lbnQtPmJhc2VVUkwoKS5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAgIC8vIFdlIHRyZWF0 IHRoZSBocmVmIHByb3BlcnR5IG9mIHRoZSA8YmFzZT4gZWxlbWVudCBhcyB0aGUgZm9ybSBhY3Rp b24sIGFzIHBlciBzZWN0aW9uIDcuNSAKKyAgICAgICAgICAgIC8vICJRdWVyaWVzIGFuZCBJbmRl eGVzIiBvZiB0aGUgSFRNTCAyLjAgc3BlYy4gPGh0dHA6Ly93d3cudzMub3JnL01hcmtVcC9odG1s LXNwZWMvaHRtbC1zcGVjXzcuaHRtbCNTRUM3LjU+LgorICAgICAgICAgICAgZm9ybS0+c2V0QWN0 aW9uKG1fZG9jdW1lbnQtPmJhc2VVUkwoKS5zdHJpbmcoKSk7CisgICAgICAgIH0KKyAgICAgICAg biA9IGZvcm07CisgICAgfQorCiAgICAgTmFtZWRNYXBwZWRBdHRyTWFwKiBhdHRycyA9IHQtPmF0 dHJzLmdldCgpOwogCi0gICAgUmVmUHRyPEhUTUxJc0luZGV4RWxlbWVudD4gaXNJbmRleCA9IG5l dyBIVE1MSXNJbmRleEVsZW1lbnQoaXNpbmRleFRhZywgbV9kb2N1bWVudCwgbV9jdXJyZW50Rm9y bUVsZW1lbnQuZ2V0KCkpOworICAgIFJlZlB0cjxIVE1MSXNJbmRleEVsZW1lbnQ+IGlzSW5kZXgg PSBuZXcgSFRNTElzSW5kZXhFbGVtZW50KGlzaW5kZXhUYWcsIG1fZG9jdW1lbnQsIG1fY3VycmVu dEZvcm1FbGVtZW50PyBtX2N1cnJlbnRGb3JtRWxlbWVudC5nZXQoKSA6IGZvcm0pOwogICAgIGlz SW5kZXgtPnNldEF0dHJpYnV0ZU1hcChhdHRycyk7CiAgICAgaXNJbmRleC0+c2V0QXR0cmlidXRl KHR5cGVBdHRyLCAia2h0bWxfaXNpbmRleCIpOwogCkluZGV4OiBMYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0bWwKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2Ut aHJlZi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lz aW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDE0IEBACis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIpIHsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcENoaWxkRnJhbWVzQXNUZXh0KCk7CisgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8 Ym9keT4KKzxpZnJhbWUgc3JjPSJyZXNvdXJjZXMvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1o cmVmLmh0bWwiPjwvaWZyYW1lPgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYu aHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9ybS1i YXNlLWhyZWYuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMyBAQAorPGh0bWw+Cis8aGVh ZD4KKzxiYXNlIGhyZWY9Imh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC9taXNjL3Jlc291cmNlcy9pc2lu ZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYtc3VibWl0Lmh0bWwiPgorPHNjcmlwdD4KK2Z1bmN0 aW9uIHRlc3QoKQoreworICAgIHZhciBpc2luZGV4RWxtID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoImlzaW5kZXgiKTsKKyAgICBpc2luZGV4RWxtLnZhbHVlID0gIlRoaXMgaXMgYSB0ZXN0IjsK KyAgICBpc2luZGV4RWxtLmZvY3VzKCk7CisKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKQor ICAgICAgICBldmVudFNlbmRlci5rZXlEb3duKFN0cmluZy5mcm9tQ2hhckNvZGUoMHgwZCkpOwor fQorCit3aW5kb3cub25sb2FkID0gdGVzdDsKKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8 cD5UaGlzIHBhZ2UgdGVzdHMgdGhhdCB3ZSBjb3JyZWN0bHkgcHV0IHRoZSB2YWx1ZSBvZiBhbiA8 dHQ+Jmx0O2lzaW5kZXgmZ3Q7PC90dD4gZWxlbWVudCBpbnRvIHRoZSBmb3JtIGRhdGEuPC9wPgor PHA+SWYgeW91IGFyZSBydW5uaW5nIHRoaXMgdGVzdCBieSBoYW5kLCBzdWJtaXQgdGhlIHBocmFz ZTogJnF1b3Q7VGhpcyBpcyBhIHRlc3QmcXVvdDsgKHdpdGhvdXQgcXVvdGVzKS48L3A+Cis8aXNp bmRleCBpZD0iaXNpbmRleCI+PC9pc2luZGV4PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9ybS1i YXNlLWhyZWYtc3VibWl0Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYtc3VibWl0Lmh0 bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi1zdWJtaXQuaHRtbAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSwyOCBAQAorPGh0bWw+Cis8aGVhZD4KKzxzY3JpcHQ+CitmdW5jdGlvbiB0ZXN0 KCkKK3sgICAgCisgICAgdmFyIGV4cGVjdGVkID0gIj9UaGlzK2lzK2ErdGVzdCI7CisgICAgaWYg KGxvY2F0aW9uLnNlYXJjaCAhPSBleHBlY3RlZCkKKyAgICAgICAgbG9nKCJGQUlMOiBFeHBlY3Rl ZCBcIiIgKyBleHBlY3RlZCArICJcIiBidXQgZ290IFwiIiArIGxvY2F0aW9uLnNlYXJjaCArICJc IiIpOworICAgIGVsc2UKKyAgICAgICAgbG9nKCJQQVNTIik7Cit9CisKK2Z1bmN0aW9uIGxvZyht c2cpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImxvZyIpLmFwcGVuZENoaWxkKGRv Y3VtZW50LmNyZWF0ZVRleHROb2RlKG1zZyArICJcbiIpKTsKK30KKword2luZG93Lm9ubG9hZCA9 IHRlc3Q7Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPHByZSBpZD0ibG9nIj48L3ByZT4K KzxzY3JpcHQ+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRl c3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpJ bmRleDogTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWV4 cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNp bmRleC13aXRoLW5vLWZvcm0tZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSw3IEBACitUaGlzIHBhZ2UgdGVzdHMgdGhhdCB3ZSBjb3JyZWN0 bHkgcHV0IHRoZSB2YWx1ZSBvZiBhbiA8aXNpbmRleD4gZWxlbWVudCBpbnRvIHRoZSBmb3JtIGRh dGEuCisKK0lmIHlvdSBhcmUgcnVubmluZyB0aGlzIHRlc3QgYnkgaGFuZCwgc3VibWl0IHRoZSBw aHJhc2U6ICJUaGlzIGlzIGEgdGVzdCIgKHdpdGhvdXQgcXVvdGVzKS4KKworVGhpcyBpcyBhIHNl YXJjaGFibGUgaW5kZXguIEVudGVyIHNlYXJjaCBrZXl3b3JkczogCitQQVNTCisKSW5kZXg6IExh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS5odG1sCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9y bS5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5k ZXgtd2l0aC1uby1mb3JtLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNDQgQEAKKzxodG1s PgorPGhlYWQ+Cis8c2NyaXB0PgorZnVuY3Rpb24gdGVzdCgpCit7CisgICAgdmFyIGlzaW5kZXhF bG0gPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiaXNpbmRleCIpOworICAgIGlmICghbG9jYXRp b24uc2VhcmNoLmxlbmd0aCkgeworICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKSB7CisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cisg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CisgICAgICAg IH0KKworICAgICAgICBpc2luZGV4RWxtLnZhbHVlID0gIlRoaXMgaXMgYSB0ZXN0IjsKKyAgICAg ICAgaXNpbmRleEVsbS5mb2N1cygpOworICAgICAgICAKKyAgICAgICAgaWYgKHdpbmRvdy5ldmVu dFNlbmRlcikKKyAgICAgICAgICAgIGV2ZW50U2VuZGVyLmtleURvd24oU3RyaW5nLmZyb21DaGFy Q29kZSgweDBkKSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgdmFyIGV4cGVjdGVkID0gIj9UaGlz K2lzK2ErdGVzdCI7CisgICAgICAgIGlmIChsb2NhdGlvbi5zZWFyY2ggIT0gZXhwZWN0ZWQpCisg ICAgICAgICAgICBsb2coIkZBSUw6IEV4cGVjdGVkIFwiIiArIGV4cGVjdGVkICsgIlwiIGJ1dCBn b3QgXCIiICsgbG9jYXRpb24uc2VhcmNoICsgIlwiIik7CisgICAgICAgIGVsc2UKKyAgICAgICAg ICAgIGxvZygiUEFTUyIpOworICAgICAgICAgICAgCisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlE b25lKCk7CisgICAgfQorfQorCitmdW5jdGlvbiBsb2cobXNnKQoreworICAgIGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJsb2ciKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSht c2cgKyAiXG4iKSk7Cit9CisKK3dpbmRvdy5vbmxvYWQgPSB0ZXN0OworPC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keT4KKzxwPlRoaXMgcGFnZSB0ZXN0cyB0aGF0IHdlIGNvcnJlY3RseSBwdXQgdGhl IHZhbHVlIG9mIGFuIDx0dD4mbHQ7aXNpbmRleCZndDs8L3R0PiBlbGVtZW50IGludG8gdGhlIGZv cm0gZGF0YS48L3A+Cis8cD5JZiB5b3UgYXJlIHJ1bm5pbmcgdGhpcyB0ZXN0IGJ5IGhhbmQsIHN1 Ym1pdCB0aGUgcGhyYXNlOiAmcXVvdDtUaGlzIGlzIGEgdGVzdCZxdW90OyAod2l0aG91dCBxdW90 ZXMpLjwvcD4KKzxpc2luZGV4IGlkPSJpc2luZGV4Ij48L2lzaW5kZXg+Cis8cHJlIGlkPSJsb2ci PjwvcHJlPgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9t aXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi1leHBlY3RlZC50eHQKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJh c2UtaHJlZi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSw3IEBACisKKworLS0tLS0tLS0KK0ZyYW1lOiAnPCEtLWZyYW1l UGF0aCAvLzwhLS1mcmFtZTAtLT4tLT4nCistLS0tLS0tLQorUEFTUworCg== 41807 2009-10-24 20:14:29 -0700 2009-10-24 22:40:25 -0700 Patch with test cases Bug30491_1.patch text/plain 9015 dbates SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MDAzNykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjYgQEAKKzIwMDktMTAtMjQgIERhbmllbCBCYXRlcyAgPGRiYXRlc0B3ZWJraXQu b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zMDQ5MQorCisgICAgICAgIEZp eGVzIGFuIGlzc3VlIHdoZXJlIHByZXNzaW5nIHJldHVybi9lbnRlciBvbiB0aGUga2V5Ym9hcmQg CisgICAgICAgIGluIDxpc2luZGV4PiBkb2VzIG5vdCBzdWJtaXQgaXQgaWYgaXMgbm90IHdpdGhp biBhIDxmb3JtPi4KKworICAgICAgICBBY2NvcmRpbmcgdG8gdGhlIEhUTUwgMi4wIHRocnUgSFRN TCA0LjAxIHNwZWMgCisgICAgICAgIChodHRwOi8vd3d3LnczLm9yZy9NYXJrVXAvaHRtbC1zcGVj L2h0bWwtc3BlY183Lmh0bWwjU0VDNy41KSwgdGhlIAorICAgICAgICA8aXNpbmRleD4gZWxlbWVu dCBkb2VzIG5vdCBuZWVkIHRvIGJlIHdpdGhpbiBhIDxmb3JtPiBlbGVtZW50IGluIAorICAgICAg ICBvcmRlciB0byBzdWJtaXQgaXQuIEl0IGNhbiBzdWJtaXR0ZWQgb24gaXRzIG93bi4gQWxzbywg aWYgcHJlc2VudCwKKyAgICAgICAgdGhlIGhyZWYgcHJvcGVydHkgb2YgdGhlIDxiYXNlPiBlbGVt ZW50IHdpbGwgZGljdGF0ZSB3aGVyZSB0byBzdWJtaXQKKyAgICAgICAgdGhlIHZhbHVlIG9mIHRo ZSA8aXNpbmRleD4gZWxlbWVudCAodGhpcyBpcyBhbmFsb2dvdXMgdG8gdGhlIGFjdGlvbiAKKyAg ICAgICAgcHJvcGVydHkgb2YgdGhlIDxmb3JtPiBlbGVtZW50KS4KKworICAgICAgICBUZXN0czog aHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sCisgICAg ICAgICAgICAgICBodHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0uaHRtbAorCisg ICAgICAgICogaHRtbC9IVE1MUGFyc2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxQYXJz ZXI6OmhhbmRsZUlzaW5kZXgpOiBDcmVhdGVzIGEgPGZvcm0+IGlmIG5vbmUgaXMgcHJlc2VudC4K KwogMjAwOS0xMC0yNCAgU2FtIFdlaW5pZyAgPHNhbUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IERhbiBCZXJuc3RlaW4uCkluZGV4OiBXZWJDb3JlL2h0bWwvSFRNTFBhcnNlci5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9odG1sL0hUTUxQYXJzZXIuY3BwCShyZXZpc2lvbiA0 OTgxMCkKKysrIFdlYkNvcmUvaHRtbC9IVE1MUGFyc2VyLmNwcAkod29ya2luZyBjb3B5KQpAQCAt MTU4NCwxMSArMTU4NCwyNiBAQCB2b2lkIEhUTUxQYXJzZXI6OmNyZWF0ZUhlYWQoKQogCiBQYXNz UmVmUHRyPE5vZGU+IEhUTUxQYXJzZXI6OmhhbmRsZUlzaW5kZXgoVG9rZW4qIHQpCiB7Ci0gICAg UmVmUHRyPE5vZGU+IG4gPSBuZXcgSFRNTERpdkVsZW1lbnQoZGl2VGFnLCBtX2RvY3VtZW50KTsK KyAgICBIVE1MRm9ybUVsZW1lbnQqIGZvcm0gPSAwOworICAgIFJlZlB0cjxOb2RlPiBuOworCisg ICAgaWYgKG1fY3VycmVudEZvcm1FbGVtZW50KQorICAgICAgICBuID0gbmV3IEhUTUxEaXZFbGVt ZW50KGRpdlRhZywgbV9kb2N1bWVudCk7CisgICAgZWxzZSB7CisgICAgICAgIC8vIFNpbmNlIHRo aXMgPGlzaW5kZXg+IGlzIG5vdCBjb250YWluZWQgd2l0aGluIGEgPGZvcm0+LCB3ZSBjcmVhdGUg b25lLgorICAgICAgICBmb3JtID0gbmV3IEhUTUxGb3JtRWxlbWVudChmb3JtVGFnLCBtX2RvY3Vt ZW50KTsKKyAgICAgICAgZm9ybS0+c2V0TWV0aG9kKCJHRVQiKTsKKyAgICAgICAgaWYgKCFtX2Rv Y3VtZW50LT5iYXNlVVJMKCkuaXNFbXB0eSgpKSB7CisgICAgICAgICAgICAvLyBXZSB0cmVhdCB0 aGUgaHJlZiBwcm9wZXJ0eSBvZiB0aGUgPGJhc2U+IGVsZW1lbnQgYXMgdGhlIGZvcm0gYWN0aW9u LCBhcyBwZXIgc2VjdGlvbiA3LjUgCisgICAgICAgICAgICAvLyAiUXVlcmllcyBhbmQgSW5kZXhl cyIgb2YgdGhlIEhUTUwgMi4wIHNwZWMuIDxodHRwOi8vd3d3LnczLm9yZy9NYXJrVXAvaHRtbC1z cGVjL2h0bWwtc3BlY183Lmh0bWwjU0VDNy41Pi4KKyAgICAgICAgICAgIGZvcm0tPnNldEFjdGlv bihtX2RvY3VtZW50LT5iYXNlVVJMKCkuc3RyaW5nKCkpOworICAgICAgICB9CisgICAgICAgIG4g PSBmb3JtOworICAgIH0KIAogICAgIE5hbWVkTWFwcGVkQXR0ck1hcCogYXR0cnMgPSB0LT5hdHRy cy5nZXQoKTsKIAotICAgIFJlZlB0cjxIVE1MSXNJbmRleEVsZW1lbnQ+IGlzSW5kZXggPSBuZXcg SFRNTElzSW5kZXhFbGVtZW50KGlzaW5kZXhUYWcsIG1fZG9jdW1lbnQsIG1fY3VycmVudEZvcm1F bGVtZW50LmdldCgpKTsKKyAgICBSZWZQdHI8SFRNTElzSW5kZXhFbGVtZW50PiBpc0luZGV4ID0g bmV3IEhUTUxJc0luZGV4RWxlbWVudChpc2luZGV4VGFnLCBtX2RvY3VtZW50LCBtX2N1cnJlbnRG b3JtRWxlbWVudD8gbV9jdXJyZW50Rm9ybUVsZW1lbnQuZ2V0KCkgOiBmb3JtKTsKICAgICBpc0lu ZGV4LT5zZXRBdHRyaWJ1dGVNYXAoYXR0cnMpOwogICAgIGlzSW5kZXgtPnNldEF0dHJpYnV0ZSh0 eXBlQXR0ciwgImtodG1sX2lzaW5kZXgiKTsKIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9n Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNTAwMzcpCisr KyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwyMCBAQAor MjAwOS0xMC0yNCAgRGFuaWVsIEJhdGVzICA8ZGJhdGVzQHdlYmtpdC5vcmc+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTMwNDkxCisKKyAgICAgICAgVGVzdCB0aGF0IHRoZSA8aXNp bmRleD4gZWxlbWVudCBjYW4gYmUgc3VibWl0dGVkIHdpdGhvdXQgYmVpbmcgZW5jbG9zZWQKKyAg ICAgICAgd2l0aGluIGEgPGZvcm0+IGVsZW1lbnQuIEFsc28gdGVzdHMgdGhhdCB0aGUgaHJlZiBw cm9wZXJ0eSBvZiB0aGUgPGJhc2U+CisgICAgICAgIGVsZW1lbnQgY2FuIGJlIHVzZWQgdG8gZGly ZWN0IHdoZXJlIHRoZSBzdWJtaXNzaW9uIGlzIHNlbnQuCisKKyAgICAgICAgKiBodHRwL3Rlc3Rz L21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJl Zi5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5v LWZvcm0tZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvaXNp bmRleC13aXRoLW5vLWZvcm0uaHRtbDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNj L3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYtc3VibWl0Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvaXNpbmRleC13aXRoLW5v LWZvcm0tYmFzZS1ocmVmLmh0bWw6IEFkZGVkLgorCiAyMDA5LTEwLTI0ICBTYW0gV2VpbmlnICA8 c2FtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4KSW5k ZXg6IExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNl LWhyZWYtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYtZXhwZWN0ZWQudHh0CShyZXZpc2lv biAwKQorKysgTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3Jt LWJhc2UtaHJlZi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNyBAQAorCisK Ky0tLS0tLS0tCitGcmFtZTogJzwhLS1mcmFtZVBhdGggLy88IS0tZnJhbWUwLS0+LS0+JworLS0t LS0tLS0KK1BBU1MKKwpJbmRleDogTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgt d2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2h0 dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYuaHRtbAkocmV2aXNp b24gMCkKKysrIExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9y bS1iYXNlLWhyZWYuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxNCBAQAorPGh0bWw+Cis8 aGVhZD4KKzxzY3JpcHQ+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgIGxheW91dFRlc3RDb250cm9s bGVyLmR1bXBDaGlsZEZyYW1lc0FzVGV4dCgpOworICAgIGxheW91dFRlc3RDb250cm9sbGVyLndh aXRVbnRpbERvbmUoKTsKK30KKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8aWZyYW1lIHNy Yz0icmVzb3VyY2VzL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sIj48L2lmcmFt ZT4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9p c2luZGV4LXdpdGgtbm8tZm9ybS1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8t Zm9ybS1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNyBAQAorVGhpcyBwYWdl IHRlc3RzIHRoYXQgd2UgY29ycmVjdGx5IHB1dCB0aGUgdmFsdWUgb2YgYW4gPGlzaW5kZXg+IGVs ZW1lbnQgaW50byB0aGUgZm9ybSBkYXRhLgorCitJZiB5b3UgYXJlIHJ1bm5pbmcgdGhpcyB0ZXN0 IGJ5IGhhbmQsIHN1Ym1pdCB0aGUgcGhyYXNlOiAiVGhpcyBpcyBhIHRlc3QiICh3aXRob3V0IHF1 b3RlcykuCisKK1RoaXMgaXMgYSBzZWFyY2hhYmxlIGluZGV4LiBFbnRlciBzZWFyY2gga2V5d29y ZHM6IAorUEFTUworCkluZGV4OiBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13 aXRoLW5vLWZvcm0uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvaXNpbmRleC13aXRoLW5vLWZvcm0uaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3Rz L2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS5odG1sCShyZXZpc2lvbiAwKQpA QCAtMCwwICsxLDQ0IEBACis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdD4KK2Z1bmN0aW9uIHRlc3Qo KQoreworICAgIHZhciBpc2luZGV4RWxtID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImlzaW5k ZXgiKTsKKyAgICBpZiAoIWxvY2F0aW9uLnNlYXJjaC5sZW5ndGgpIHsKKyAgICAgICAgaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2Fp dFVudGlsRG9uZSgpOworICAgICAgICB9CisKKyAgICAgICAgaXNpbmRleEVsbS52YWx1ZSA9ICJU aGlzIGlzIGEgdGVzdCI7CisgICAgICAgIGlzaW5kZXhFbG0uZm9jdXMoKTsKKyAgICAgICAgCisg ICAgICAgIGlmICh3aW5kb3cuZXZlbnRTZW5kZXIpCisgICAgICAgICAgICBldmVudFNlbmRlci5r ZXlEb3duKFN0cmluZy5mcm9tQ2hhckNvZGUoMHgwZCkpOworICAgIH0gZWxzZSB7CisgICAgICAg IHZhciBleHBlY3RlZCA9ICI/VGhpcytpcythK3Rlc3QiOworICAgICAgICBpZiAobG9jYXRpb24u c2VhcmNoICE9IGV4cGVjdGVkKQorICAgICAgICAgICAgbG9nKCJGQUlMOiBFeHBlY3RlZCBcIiIg KyBleHBlY3RlZCArICJcIiBidXQgZ290IFwiIiArIGxvY2F0aW9uLnNlYXJjaCArICJcIiIpOwor ICAgICAgICBlbHNlCisgICAgICAgICAgICBsb2coIlBBU1MiKTsKKyAgICAgICAgICAgIAorICAg ICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgIH0KK30KKworZnVuY3Rpb24gbG9nKG1z ZykKK3sKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgibG9nIikuYXBwZW5kQ2hpbGQoZG9j dW1lbnQuY3JlYXRlVGV4dE5vZGUobXNnICsgIlxuIikpOworfQorCit3aW5kb3cub25sb2FkID0g dGVzdDsKKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cD5UaGlzIHBhZ2UgdGVzdHMgdGhh dCB3ZSBjb3JyZWN0bHkgcHV0IHRoZSB2YWx1ZSBvZiBhbiA8dHQ+Jmx0O2lzaW5kZXgmZ3Q7PC90 dD4gZWxlbWVudCBpbnRvIHRoZSBmb3JtIGRhdGEuPC9wPgorPHA+SWYgeW91IGFyZSBydW5uaW5n IHRoaXMgdGVzdCBieSBoYW5kLCBzdWJtaXQgdGhlIHBocmFzZTogJnF1b3Q7VGhpcyBpcyBhIHRl c3QmcXVvdDsgKHdpdGhvdXQgcXVvdGVzKS48L3A+Cis8aXNpbmRleCBpZD0iaXNpbmRleCI+PC9p c2luZGV4PgorPHByZSBpZD0ibG9nIj48L3ByZT4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvaXNpbmRleC13aXRoLW5vLWZvcm0t YmFzZS1ocmVmLXN1Ym1pdC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2h0dHAvdGVz dHMvbWlzYy9yZXNvdXJjZXMvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLXN1Ym1pdC5o dG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNl cy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYtc3VibWl0Lmh0bWwJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsMjggQEAKKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0PgorZnVuY3Rpb24gdGVz dCgpCit7ICAgIAorICAgIHZhciBleHBlY3RlZCA9ICI/VGhpcytpcythK3Rlc3QiOworICAgIGlm IChsb2NhdGlvbi5zZWFyY2ggIT0gZXhwZWN0ZWQpCisgICAgICAgIGxvZygiRkFJTDogRXhwZWN0 ZWQgXCIiICsgZXhwZWN0ZWQgKyAiXCIgYnV0IGdvdCBcIiIgKyBsb2NhdGlvbi5zZWFyY2ggKyAi XCIiKTsKKyAgICBlbHNlCisgICAgICAgIGxvZygiUEFTUyIpOworfQorCitmdW5jdGlvbiBsb2co bXNnKQoreworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJsb2ciKS5hcHBlbmRDaGlsZChk b2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtc2cgKyAiXG4iKSk7Cit9CisKK3dpbmRvdy5vbmxvYWQg PSB0ZXN0OworPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwcmUgaWQ9ImxvZyI+PC9wcmU+ Cis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K SW5kZXg6IExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvaXNpbmRleC13aXRo LW5vLWZvcm0tYmFzZS1ocmVmLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYuaHRtbAko cmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvaXNp bmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEs MjMgQEAKKzxodG1sPgorPGhlYWQ+Cis8YmFzZSBocmVmPSJodHRwOi8vbG9jYWxob3N0OjgwMDAv bWlzYy9yZXNvdXJjZXMvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLXN1Ym1pdC5odG1s Ij4KKzxzY3JpcHQ+CitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICB2YXIgaXNpbmRleEVsbSA9IGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJpc2luZGV4Iik7CisgICAgaXNpbmRleEVsbS52YWx1ZSA9 ICJUaGlzIGlzIGEgdGVzdCI7CisgICAgaXNpbmRleEVsbS5mb2N1cygpOworCisgICAgaWYgKHdp bmRvdy5ldmVudFNlbmRlcikKKyAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bihTdHJpbmcuZnJv bUNoYXJDb2RlKDB4MGQpKTsKK30KKword2luZG93Lm9ubG9hZCA9IHRlc3Q7Cis8L3NjcmlwdD4K KzwvaGVhZD4KKzxib2R5PgorPHA+VGhpcyBwYWdlIHRlc3RzIHRoYXQgd2UgY29ycmVjdGx5IHB1 dCB0aGUgdmFsdWUgb2YgYW4gPHR0PiZsdDtpc2luZGV4Jmd0OzwvdHQ+IGVsZW1lbnQgaW50byB0 aGUgZm9ybSBkYXRhLjwvcD4KKzxwPklmIHlvdSBhcmUgcnVubmluZyB0aGlzIHRlc3QgYnkgaGFu ZCwgc3VibWl0IHRoZSBwaHJhc2U6ICZxdW90O1RoaXMgaXMgYSB0ZXN0JnF1b3Q7ICh3aXRob3V0 IHF1b3RlcykuPC9wPgorPGlzaW5kZXggaWQ9ImlzaW5kZXgiPjwvaXNpbmRleD4KKzwvYm9keT4K KzwvaHRtbD4K 41814 2009-10-24 22:40:25 -0700 2009-10-26 17:33:23 -0700 Patch with test cases Bug30491_4.patch text/plain 9166 dbates SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MDAzOCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMDktMTAtMjQgIERhbmllbCBCYXRlcyAgPGRiYXRlc0B3ZWJraXQu b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zMDQ5MQorCisgICAgICAgIEZp eGVzIGFuIGlzc3VlIHdoZXJlIHByZXNzaW5nIHJldHVybi9lbnRlciBvbiB0aGUga2V5Ym9hcmQg CisgICAgICAgIGluIDxpc2luZGV4PiBkb2VzIG5vdCBzdWJtaXQgaXQgaWYgaXMgbm90IHdpdGhp biBhIDxmb3JtPi4KKworICAgICAgICBBY2NvcmRpbmcgdG8gdGhlIEhUTUwgMi4wIHRocnUgSFRN TCA0LjAxIHNwZWMgCisgICAgICAgIChodHRwOi8vd3d3LnczLm9yZy9NYXJrVXAvaHRtbC1zcGVj L2h0bWwtc3BlY183Lmh0bWwjU0VDNy41KSwgdGhlIAorICAgICAgICA8aXNpbmRleD4gZWxlbWVu dCBkb2VzIG5vdCBuZWVkIHRvIGJlIHdpdGhpbiBhIDxmb3JtPiBlbGVtZW50IGluIAorICAgICAg ICBvcmRlciB0byBzdWJtaXQgaXQuIEl0IGNhbiBzdWJtaXR0ZWQgb24gaXRzIG93bi4gQWxzbywg aWYgcHJlc2VudCwKKyAgICAgICAgdGhlIGhyZWYgcHJvcGVydHkgb2YgdGhlIDxiYXNlPiBlbGVt ZW50IHdpbGwgZGljdGF0ZSB3aGVyZSB0byBzdWJtaXQKKyAgICAgICAgdGhlIHZhbHVlIG9mIHRo ZSA8aXNpbmRleD4gZWxlbWVudCAodGhpcyBpcyBhbmFsb2dvdXMgdG8gdGhlIGFjdGlvbiAKKyAg ICAgICAgcHJvcGVydHkgb2YgdGhlIDxmb3JtPiBlbGVtZW50KS4KKworICAgICAgICBUZXN0czog aHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sCisgICAg ICAgICAgICAgICBodHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0uaHRtbAorCisg ICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOiBDcmVhdGVzIGEgPGZvcm0+IGlm IAorICAgICAgICBub25lIGlzIHByZXNlbnQgYW5kIHdlIGFyZSBhbiA8aXNpbmRleD4gZWxlbWVu dC4KKwogMjAwOS0xMC0yNCAgQnJpYW4gV2VpbnN0ZWluICA8YndlaW5zdGVpbkBhcHBsZS5jb20+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgVGltb3RoeSBIYXRjaGVyLgpJbmRleDogV2ViQ29yZS9o dG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1M SW5wdXRFbGVtZW50LmNwcAkocmV2aXNpb24gNDk4MTApCisrKyBXZWJDb3JlL2h0bWwvSFRNTElu cHV0RWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE1NDksOSArMTU0OSwyOCBAQCB2b2lk IEhUTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsCiAgICAgICAgICAgICBpZiAociAm JiByLT5pc1RleHRGaWVsZCgpKQogICAgICAgICAgICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wo ciktPnNldEVkaXRlZChmYWxzZSk7CiAgICAgICAgIH0KKworICAgICAgICBSZWZQdHI8SFRNTEZv cm1FbGVtZW50PiBteUZvcm0gPSBmb3JtKCk7CisgICAgICAgIGJvb2wgaXNJc0luZGV4RWxlbWVu dEFuZFRoZXJlSXNOb0Zvcm0gPSAoaW5wdXRUeXBlKCkgPT0gSVNJTkRFWCkgJiYgIWZvcm0oKTsK KyAgICAgICAgaWYgKGlzSXNJbmRleEVsZW1lbnRBbmRUaGVyZUlzTm9Gb3JtKSB7CisgICAgICAg ICAgICAvLyBTaW5jZSB0aGlzIDxpc2luZGV4PiBpcyBub3QgY29udGFpbmVkIHdpdGhpbiBhIDxm b3JtPiwgd2UgY3JlYXRlIG9uZS4KKyAgICAgICAgICAgIG15Rm9ybSA9IG5ldyBIVE1MRm9ybUVs ZW1lbnQoZm9ybVRhZywgZG9jdW1lbnQoKSk7CisgICAgICAgICAgICBteUZvcm0tPnJlZ2lzdGVy Rm9ybUVsZW1lbnQodGhpcyk7CisgICAgICAgICAgICBteUZvcm0tPnNldE1ldGhvZCgiR0VUIik7 CisgICAgICAgICAgICBpZiAoIWRvY3VtZW50KCktPmJhc2VVUkwoKS5pc0VtcHR5KCkpIHsKKyAg ICAgICAgICAgICAgICAvLyBXZSB0cmVhdCB0aGUgaHJlZiBwcm9wZXJ0eSBvZiB0aGUgPGJhc2U+ IGVsZW1lbnQgYXMgdGhlIGZvcm0gYWN0aW9uLCBhcyBwZXIgc2VjdGlvbiA3LjUgCisgICAgICAg ICAgICAgICAgLy8gIlF1ZXJpZXMgYW5kIEluZGV4ZXMiIG9mIHRoZSBIVE1MIDIuMCBzcGVjLiA8 aHR0cDovL3d3dy53My5vcmcvTWFya1VwL2h0bWwtc3BlYy9odG1sLXNwZWNfNy5odG1sI1NFQzcu NT4uCisgICAgICAgICAgICAgICAgbXlGb3JtLT5zZXRBY3Rpb24oZG9jdW1lbnQoKS0+YmFzZVVS TCgpLnN0cmluZygpKTsKKyAgICAgICAgICAgIH0gICAgICAgICAgICAKKyAgICAgICAgfQorCiAg ICAgICAgIC8vIEZvcm0gbWF5IG5ldmVyIGhhdmUgYmVlbiBwcmVzZW50LCBvciBtYXkgaGF2ZSBi ZWVuIGRlc3Ryb3llZCBieSB0aGUgY2hhbmdlIGV2ZW50LgotICAgICAgICBpZiAoZm9ybSgpKQot ICAgICAgICAgICAgZm9ybSgpLT5zdWJtaXRDbGljayhldnQpOworICAgICAgICBpZiAobXlGb3Jt KQorICAgICAgICAgICAgbXlGb3JtLT5zdWJtaXRDbGljayhldnQpOworCisgICAgICAgIGlmIChp c0lzSW5kZXhFbGVtZW50QW5kVGhlcmVJc05vRm9ybSkKKyAgICAgICAgICAgIG15Rm9ybS5jbGVh cigpOworCiAgICAgICAgIGV2dC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKICAgICAgICAgcmV0dXJu OwogICAgIH0KSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDUwMDM4KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMjAgQEAKKzIwMDktMTAtMjQgIERhbmllbCBC YXRlcyAgPGRiYXRlc0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0zMDQ5MQorCisgICAgICAgIFRlc3QgdGhhdCB0aGUgPGlzaW5kZXg+IGVsZW1lbnQgY2FuIGJl IHN1Ym1pdHRlZCB3aXRob3V0IGJlaW5nIGVuY2xvc2VkCisgICAgICAgIHdpdGhpbiBhIDxmb3Jt PiBlbGVtZW50LiBBbHNvIHRlc3RzIHRoYXQgdGhlIGhyZWYgcHJvcGVydHkgb2YgdGhlIDxiYXNl PgorICAgICAgICBlbGVtZW50IGNhbiBiZSB1c2VkIHRvIGRpcmVjdCB3aGVyZSB0aGUgc3VibWlz c2lvbiBpcyBzZW50LgorCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1u by1mb3JtLWJhc2UtaHJlZi1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVz dHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYuaHRtbDogQWRkZWQuCisgICAg ICAgICogaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWV4cGVjdGVkLnR4dDog QWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvaXNpbmRleC13 aXRoLW5vLWZvcm0tYmFzZS1ocmVmLXN1Ym1pdC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBodHRw L3Rlc3RzL21pc2MvcmVzb3VyY2VzL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1s OiBBZGRlZC4KKwogMjAwOS0xMC0yNCAgU2FtIFdlaW5pZyAgPHNhbUB3ZWJraXQub3JnPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IERhbiBCZXJuc3RlaW4uCkluZGV4OiBMYXlvdXRUZXN0cy9odHRw L3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLWV4cGVjdGVkLnR4dAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5v LWZvcm0tYmFzZS1ocmVmLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3Rz L2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYtZXhwZWN0ZWQu dHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDcgQEAKKworCistLS0tLS0tLQorRnJhbWU6ICc8 IS0tZnJhbWVQYXRoIC8vPCEtLWZyYW1lMC0tPi0tPicKKy0tLS0tLS0tCitQQVNTCisKSW5kZXg6 IExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhy ZWYuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRl eC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0bWwJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsMTQgQEAKKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0PgoraWYg KHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgIGxheW91dFRlc3RDb250cm9sbGVy LmR1bXBBc1RleHQoKTsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQ2hpbGRGcmFtZXNB c1RleHQoKTsKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7Cit9Cis8 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGlmcmFtZSBzcmM9InJlc291cmNlcy9pc2luZGV4 LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYuaHRtbCI+PC9pZnJhbWU+Cis8L2JvZHk+Cis8L2h0bWw+ CkluZGV4OiBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0t ZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9p c2luZGV4LXdpdGgtbm8tZm9ybS1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tZXhwZWN0ZWQudHh0CShy ZXZpc2lvbiAwKQpAQCAtMCwwICsxLDcgQEAKK1RoaXMgcGFnZSB0ZXN0cyB0aGF0IHdlIGNvcnJl Y3RseSBwdXQgdGhlIHZhbHVlIG9mIGFuIDxpc2luZGV4PiBlbGVtZW50IGludG8gdGhlIGZvcm0g ZGF0YS4KKworSWYgeW91IGFyZSBydW5uaW5nIHRoaXMgdGVzdCBieSBoYW5kLCBzdWJtaXQgdGhl IHBocmFzZTogIlRoaXMgaXMgYSB0ZXN0IiAod2l0aG91dCBxdW90ZXMpLgorCitUaGlzIGlzIGEg c2VhcmNoYWJsZSBpbmRleC4gRW50ZXIgc2VhcmNoIGtleXdvcmRzOiAKK1BBU1MKKwpJbmRleDog TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLmh0bWwKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1m b3JtLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNp bmRleC13aXRoLW5vLWZvcm0uaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0NCBAQAorPGh0 bWw+Cis8aGVhZD4KKzxzY3JpcHQ+CitmdW5jdGlvbiB0ZXN0KCkKK3sKKyAgICB2YXIgaXNpbmRl eEVsbSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJpc2luZGV4Iik7CisgICAgaWYgKCFsb2Nh dGlvbi5zZWFyY2gubGVuZ3RoKSB7CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIHsKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsK KyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICAg ICAgfQorCisgICAgICAgIGlzaW5kZXhFbG0udmFsdWUgPSAiVGhpcyBpcyBhIHRlc3QiOworICAg ICAgICBpc2luZGV4RWxtLmZvY3VzKCk7CisgICAgICAgIAorICAgICAgICBpZiAod2luZG93LmV2 ZW50U2VuZGVyKQorICAgICAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bihTdHJpbmcuZnJvbUNo YXJDb2RlKDB4MGQpKTsKKyAgICB9IGVsc2UgeworICAgICAgICB2YXIgZXhwZWN0ZWQgPSAiP1Ro aXMraXMrYSt0ZXN0IjsKKyAgICAgICAgaWYgKGxvY2F0aW9uLnNlYXJjaCAhPSBleHBlY3RlZCkK KyAgICAgICAgICAgIGxvZygiRkFJTDogRXhwZWN0ZWQgXCIiICsgZXhwZWN0ZWQgKyAiXCIgYnV0 IGdvdCBcIiIgKyBsb2NhdGlvbi5zZWFyY2ggKyAiXCIiKTsKKyAgICAgICAgZWxzZQorICAgICAg ICAgICAgbG9nKCJQQVNTIik7CisgICAgICAgICAgICAKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlm eURvbmUoKTsKKyAgICB9Cit9CisKK2Z1bmN0aW9uIGxvZyhtc2cpCit7CisgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoImxvZyIpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2Rl KG1zZyArICJcbiIpKTsKK30KKword2luZG93Lm9ubG9hZCA9IHRlc3Q7Cis8L3NjcmlwdD4KKzwv aGVhZD4KKzxib2R5PgorPHA+VGhpcyBwYWdlIHRlc3RzIHRoYXQgd2UgY29ycmVjdGx5IHB1dCB0 aGUgdmFsdWUgb2YgYW4gPHR0PiZsdDtpc2luZGV4Jmd0OzwvdHQ+IGVsZW1lbnQgaW50byB0aGUg Zm9ybSBkYXRhLjwvcD4KKzxwPklmIHlvdSBhcmUgcnVubmluZyB0aGlzIHRlc3QgYnkgaGFuZCwg c3VibWl0IHRoZSBwaHJhc2U6ICZxdW90O1RoaXMgaXMgYSB0ZXN0JnF1b3Q7ICh3aXRob3V0IHF1 b3RlcykuPC9wPgorPGlzaW5kZXggaWQ9ImlzaW5kZXgiPjwvaXNpbmRleD4KKzxwcmUgaWQ9Imxv ZyI+PC9wcmU+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L21pc2MvcmVzb3VyY2VzL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi1zdWJtaXQuaHRt bAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2lz aW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi1zdWJtaXQuaHRtbAkocmV2aXNpb24gMCkKKysr IExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvaXNpbmRleC13aXRoLW5vLWZv cm0tYmFzZS1ocmVmLXN1Ym1pdC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI4IEBACis8 aHRtbD4KKzxoZWFkPgorPHNjcmlwdD4KK2Z1bmN0aW9uIHRlc3QoKQoreyAgICAKKyAgICB2YXIg ZXhwZWN0ZWQgPSAiP1RoaXMraXMrYSt0ZXN0IjsKKyAgICBpZiAobG9jYXRpb24uc2VhcmNoICE9 IGV4cGVjdGVkKQorICAgICAgICBsb2coIkZBSUw6IEV4cGVjdGVkIFwiIiArIGV4cGVjdGVkICsg IlwiIGJ1dCBnb3QgXCIiICsgbG9jYXRpb24uc2VhcmNoICsgIlwiIik7CisgICAgZWxzZQorICAg ICAgICBsb2coIlBBU1MiKTsKK30KKworZnVuY3Rpb24gbG9nKG1zZykKK3sKKyAgICBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgibG9nIikuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5v ZGUobXNnICsgIlxuIikpOworfQorCit3aW5kb3cub25sb2FkID0gdGVzdDsKKzwvc2NyaXB0Pgor PC9oZWFkPgorPGJvZHk+Cis8cHJlIGlkPSJsb2ciPjwvcHJlPgorPHNjcmlwdD4KK2lmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5 RG9uZSgpOworPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5o dG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMv aXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJh c2UtaHJlZi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDIzIEBACis8aHRtbD4KKzxoZWFk PgorPGJhc2UgaHJlZj0iaHR0cDovL2xvY2FsaG9zdDo4MDAwL21pc2MvcmVzb3VyY2VzL2lzaW5k ZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi1zdWJtaXQuaHRtbCI+Cis8c2NyaXB0PgorZnVuY3Rp b24gdGVzdCgpCit7CisgICAgdmFyIGlzaW5kZXhFbG0gPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgiaXNpbmRleCIpOworICAgIGlzaW5kZXhFbG0udmFsdWUgPSAiVGhpcyBpcyBhIHRlc3QiOwor ICAgIGlzaW5kZXhFbG0uZm9jdXMoKTsKKworICAgIGlmICh3aW5kb3cuZXZlbnRTZW5kZXIpCisg ICAgICAgIGV2ZW50U2VuZGVyLmtleURvd24oU3RyaW5nLmZyb21DaGFyQ29kZSgweDBkKSk7Cit9 CisKK3dpbmRvdy5vbmxvYWQgPSB0ZXN0OworPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxw PlRoaXMgcGFnZSB0ZXN0cyB0aGF0IHdlIGNvcnJlY3RseSBwdXQgdGhlIHZhbHVlIG9mIGFuIDx0 dD4mbHQ7aXNpbmRleCZndDs8L3R0PiBlbGVtZW50IGludG8gdGhlIGZvcm0gZGF0YS48L3A+Cis8 cD5JZiB5b3UgYXJlIHJ1bm5pbmcgdGhpcyB0ZXN0IGJ5IGhhbmQsIHN1Ym1pdCB0aGUgcGhyYXNl OiAmcXVvdDtUaGlzIGlzIGEgdGVzdCZxdW90OyAod2l0aG91dCBxdW90ZXMpLjwvcD4KKzxpc2lu ZGV4IGlkPSJpc2luZGV4Ij48L2lzaW5kZXg+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 41918 2009-10-26 17:33:23 -0700 2009-11-05 19:13:23 -0800 Patch with test cases Bug30491_5.patch text/plain 10169 dbates SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MDExNikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjkgQEAKKzIwMDktMTAtMjYgIERhbmllbCBCYXRlcyAgPGRiYXRlc0B3ZWJraXQu b3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zMDQ5MQorCisgICAgICAgIEZp eGVzIGFuIGlzc3VlIHdoZXJlIHByZXNzaW5nIHJldHVybi9lbnRlciBvbiB0aGUga2V5Ym9hcmQg CisgICAgICAgIGluIDxpc2luZGV4PiBkb2VzIG5vdCBzdWJtaXQgaXQgaWYgaXMgbm90IHdpdGhp biBhIDxmb3JtPi4KKworICAgICAgICBBY2NvcmRpbmcgdG8gdGhlIEhUTUwgMi4wIHRocnUgSFRN TCA0LjAxIHNwZWMgCisgICAgICAgIChodHRwOi8vd3d3LnczLm9yZy9NYXJrVXAvaHRtbC1zcGVj L2h0bWwtc3BlY183Lmh0bWwjU0VDNy41KSwgdGhlIAorICAgICAgICA8aXNpbmRleD4gZWxlbWVu dCBkb2VzIG5vdCBuZWVkIHRvIGJlIHdpdGhpbiBhIDxmb3JtPiBlbGVtZW50IGluIAorICAgICAg ICBvcmRlciB0byBzdWJtaXQgaXQuIEl0IGNhbiBzdWJtaXR0ZWQgb24gaXRzIG93bi4gQWxzbywg aWYgcHJlc2VudCwKKyAgICAgICAgdGhlIGhyZWYgcHJvcGVydHkgb2YgdGhlIDxiYXNlPiBlbGVt ZW50IHdpbGwgZGljdGF0ZSB3aGVyZSB0byBzdWJtaXQKKyAgICAgICAgdGhlIHZhbHVlIG9mIHRo ZSA8aXNpbmRleD4gZWxlbWVudCAodGhpcyBpcyBhbmFsb2dvdXMgdG8gdGhlIGFjdGlvbiAKKyAg ICAgICAgcHJvcGVydHkgb2YgdGhlIDxmb3JtPiBlbGVtZW50KS4KKworICAgICAgICBUZXN0czog aHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sCisgICAg ICAgICAgICAgICBodHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0uaHRtbAorCisg ICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZXIpOiBDYWxscyBjcmVhdGVUZW1wb3Jh cnlGb3JtRm9ySXNJbmRleCgpCisgICAgICAgIHRvIGNyZWF0ZSBhIDxmb3JtPiBpZiBub25lIGlz IHByZXNlbnQgYW5kIHdlIGFyZSBhbiA8aXNpbmRleD4gZWxlbWVudC4KKyAgICAgICAgKFdlYkNv cmU6OkhUTUxJbnB1dEVsZW1lbnQ6OmNyZWF0ZVRlbXBvcmFyeUZvcm1Gb3JJc0luZGV4KTogQWRk ZWQuCisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50Lmg6CisKIDIwMDktMTAtMjYgIEJy YWR5IEVpZHNvbiAgPGJlaWRzb25AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERh cmluIEFkbGVyLgpJbmRleDogV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAkocmV2aXNpb24gNDk4 MTApCisrKyBXZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTE1NDksOSArMTU0OSwxNiBAQCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVu dEhhbmRsCiAgICAgICAgICAgICBpZiAociAmJiByLT5pc1RleHRGaWVsZCgpKQogICAgICAgICAg ICAgICAgIHRvUmVuZGVyVGV4dENvbnRyb2wociktPnNldEVkaXRlZChmYWxzZSk7CiAgICAgICAg IH0KLSAgICAgICAgLy8gRm9ybSBtYXkgbmV2ZXIgaGF2ZSBiZWVuIHByZXNlbnQsIG9yIG1heSBo YXZlIGJlZW4gZGVzdHJveWVkIGJ5IHRoZSBjaGFuZ2UgZXZlbnQuCi0gICAgICAgIGlmIChmb3Jt KCkpCi0gICAgICAgICAgICBmb3JtKCktPnN1Ym1pdENsaWNrKGV2dCk7CisKKyAgICAgICAgUmVm UHRyPEhUTUxGb3JtRWxlbWVudD4gZm9ybUZvclN1Ym1pc3Npb24gPSBmb3JtKCk7CisgICAgICAg IC8vIElmIHRoZXJlIGlzIG5vIGZvcm0gYW5kIHRoZSBlbGVtZW50IGlzIGFuIDxpc2luZGV4Piwg dGhlbiBjcmVhdGUgYSB0ZW1wb3JhcnkgZm9ybSBqdXN0IHRvIGJlIHVzZWQgZm9yIHN1Ym1pc3Np b24uCisgICAgICAgIGlmICghZm9ybUZvclN1Ym1pc3Npb24gJiYgaW5wdXRUeXBlKCkgPT0gSVNJ TkRFWCkKKyAgICAgICAgICAgIGZvcm1Gb3JTdWJtaXNzaW9uID0gY3JlYXRlVGVtcG9yYXJ5Rm9y bUZvcklzSW5kZXgoKTsKKworICAgICAgICAvLyBGb3JtIG1heSBuZXZlciBoYXZlIGJlZW4gcHJl c2VudCwgb3IgbWF5IGhhdmUgYmVlbiBkZXN0cm95ZWQgYnkgY29kZSByZXNwb25kaW5nIHRvIHRo ZSBjaGFuZ2UgZXZlbnQuCisgICAgICAgIGlmIChmb3JtRm9yU3VibWlzc2lvbikKKyAgICAgICAg ICAgIGZvcm1Gb3JTdWJtaXNzaW9uLT5zdWJtaXRDbGljayhldnQpOworCiAgICAgICAgIGV2dC0+ c2V0RGVmYXVsdEhhbmRsZWQoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KQEAgLTE1NjksNiAr MTU3NiwxOSBAQCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsCiAgICAg ICAgIEhUTUxGb3JtQ29udHJvbEVsZW1lbnRXaXRoU3RhdGU6OmRlZmF1bHRFdmVudEhhbmRsZXIo ZXZ0KTsKIH0KIAorUGFzc1JlZlB0cjxIVE1MRm9ybUVsZW1lbnQ+IEhUTUxJbnB1dEVsZW1lbnQ6 OmNyZWF0ZVRlbXBvcmFyeUZvcm1Gb3JJc0luZGV4KCkKK3sKKyAgICBSZWZQdHI8SFRNTEZvcm1F bGVtZW50PiBmb3JtID0gbmV3IEhUTUxGb3JtRWxlbWVudChmb3JtVGFnLCBkb2N1bWVudCgpKTsK KyAgICBmb3JtLT5yZWdpc3RlckZvcm1FbGVtZW50KHRoaXMpOworICAgIGZvcm0tPnNldE1ldGhv ZCgiR0VUIik7CisgICAgaWYgKCFkb2N1bWVudCgpLT5iYXNlVVJMKCkuaXNFbXB0eSgpKSB7Cisg ICAgICAgIC8vIFdlIHRyZWF0IHRoZSBocmVmIHByb3BlcnR5IG9mIHRoZSA8YmFzZT4gZWxlbWVu dCBhcyB0aGUgZm9ybSBhY3Rpb24sIGFzIHBlciBzZWN0aW9uIDcuNSAKKyAgICAgICAgLy8gIlF1 ZXJpZXMgYW5kIEluZGV4ZXMiIG9mIHRoZSBIVE1MIDIuMCBzcGVjLiA8aHR0cDovL3d3dy53My5v cmcvTWFya1VwL2h0bWwtc3BlYy9odG1sLXNwZWNfNy5odG1sI1NFQzcuNT4uCisgICAgICAgIGZv cm0tPnNldEFjdGlvbihkb2N1bWVudCgpLT5iYXNlVVJMKCkuc3RyaW5nKCkpOworICAgIH0KKyAg ICByZXR1cm4gZm9ybS5yZWxlYXNlKCk7Cit9CisKIGJvb2wgSFRNTElucHV0RWxlbWVudDo6aXNV UkxBdHRyaWJ1dGUoQXR0cmlidXRlICphdHRyKSBjb25zdAogewogICAgIHJldHVybiAoYXR0ci0+ bmFtZSgpID09IHNyY0F0dHIpOwpJbmRleDogV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oCShyZXZpc2lv biA0OTgxMCkKKysrIFdlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgJKHdvcmtpbmcgY29w eSkKQEAgLTI1Niw2ICsyNTYsOCBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgYm9vbCBpc09wdGlv bmFsRm9ybUNvbnRyb2woKSBjb25zdCB7IHJldHVybiAhaXNSZXF1aXJlZEZvcm1Db250cm9sKCk7 IH0KICAgICB2aXJ0dWFsIGJvb2wgaXNSZXF1aXJlZEZvcm1Db250cm9sKCkgY29uc3Q7CiAKKyAg ICBQYXNzUmVmUHRyPEhUTUxGb3JtRWxlbWVudD4gY3JlYXRlVGVtcG9yYXJ5Rm9ybUZvcklzSW5k ZXgoKTsKKwogI2lmIEVOQUJMRShEQVRBTElTVCkKICAgICBIVE1MRGF0YUxpc3RFbGVtZW50KiBk YXRhTGlzdCgpIGNvbnN0OwogI2VuZGlmCkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA1MDExNikKKysrIExh eW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIwIEBACisyMDA5 LTEwLTI2ICBEYW5pZWwgQmF0ZXMgIDxkYmF0ZXNAd2Via2l0Lm9yZz4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MzA0OTEKKworICAgICAgICBUZXN0IHRoYXQgdGhlIDxpc2luZGV4 PiBlbGVtZW50IGNhbiBiZSBzdWJtaXR0ZWQgd2l0aG91dCBiZWluZyBlbmNsb3NlZAorICAgICAg ICB3aXRoaW4gYSA8Zm9ybT4gZWxlbWVudC4gQWxzbyB0ZXN0cyB0aGF0IHRoZSBocmVmIHByb3Bl cnR5IG9mIHRoZSA8YmFzZT4KKyAgICAgICAgZWxlbWVudCBjYW4gYmUgdXNlZCB0byBkaXJlY3Qg d2hlcmUgdGhlIHN1Ym1pc3Npb24gaXMgc2VudC4KKworICAgICAgICAqIGh0dHAvdGVzdHMvbWlz Yy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAg ICAgICAgKiBodHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdpdGgtbm8tZm9y bS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9pc2luZGV4 LXdpdGgtbm8tZm9ybS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVz b3VyY2VzL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi1zdWJtaXQuaHRtbDogQWRkZWQu CisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9y bS1iYXNlLWhyZWYuaHRtbDogQWRkZWQuCisKIDIwMDktMTAtMjYgIEJyYWR5IEVpZHNvbiAgPGJl aWRzb25AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJbmRl eDogTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2Ut aHJlZi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9t aXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi1leHBlY3RlZC50eHQJKHJldmlzaW9u IDApCisrKyBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0t YmFzZS1ocmVmLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw3IEBACisKKwor LS0tLS0tLS0KK0ZyYW1lOiAnPCEtLWZyYW1lUGF0aCAvLzwhLS1mcmFtZTAtLT4tLT4nCistLS0t LS0tLQorUEFTUworCkluZGV4OiBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13 aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLWJhc2UtaHJlZi5odG1sCShyZXZpc2lv biAwKQorKysgTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3Jt LWJhc2UtaHJlZi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE0IEBACis8aHRtbD4KKzxo ZWFkPgorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICBs YXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIuZHVtcENoaWxkRnJhbWVzQXNUZXh0KCk7CisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2Fp dFVudGlsRG9uZSgpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxpZnJhbWUgc3Jj PSJyZXNvdXJjZXMvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLmh0bWwiPjwvaWZyYW1l PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lz aW5kZXgtd2l0aC1uby1mb3JtLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL21pc2MvaXNpbmRleC13aXRoLW5vLWZvcm0tZXhwZWN0ZWQudHh0CShyZXZp c2lvbiAwKQorKysgTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1m b3JtLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw3IEBACitUaGlzIHBhZ2Ug dGVzdHMgdGhhdCB3ZSBjb3JyZWN0bHkgcHV0IHRoZSB2YWx1ZSBvZiBhbiA8aXNpbmRleD4gZWxl bWVudCBpbnRvIHRoZSBmb3JtIGRhdGEuCisKK0lmIHlvdSBhcmUgcnVubmluZyB0aGlzIHRlc3Qg YnkgaGFuZCwgc3VibWl0IHRoZSBwaHJhc2U6ICJUaGlzIGlzIGEgdGVzdCIgKHdpdGhvdXQgcXVv dGVzKS4KKworVGhpcyBpcyBhIHNlYXJjaGFibGUgaW5kZXguIEVudGVyIHNlYXJjaCBrZXl3b3Jk czogCitQQVNTCisKSW5kZXg6IExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9pc2luZGV4LXdp dGgtbm8tZm9ybS5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlz Yy9pc2luZGV4LXdpdGgtbm8tZm9ybS5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9taXNjL2lzaW5kZXgtd2l0aC1uby1mb3JtLmh0bWwJKHJldmlzaW9uIDApCkBA IC0wLDAgKzEsNDQgQEAKKzxodG1sPgorPGhlYWQ+Cis8c2NyaXB0PgorZnVuY3Rpb24gdGVzdCgp Cit7CisgICAgdmFyIGlzaW5kZXhFbG0gPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiaXNpbmRl eCIpOworICAgIGlmICghbG9jYXRpb24uc2VhcmNoLmxlbmd0aCkgeworICAgICAgICBpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJv bGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0 VW50aWxEb25lKCk7CisgICAgICAgIH0KKworICAgICAgICBpc2luZGV4RWxtLnZhbHVlID0gIlRo aXMgaXMgYSB0ZXN0IjsKKyAgICAgICAgaXNpbmRleEVsbS5mb2N1cygpOworCisgICAgICAgIGlm ICh3aW5kb3cuZXZlbnRTZW5kZXIpCisgICAgICAgICAgICBldmVudFNlbmRlci5rZXlEb3duKFN0 cmluZy5mcm9tQ2hhckNvZGUoMHgwZCkpOworICAgIH0gZWxzZSB7CisgICAgICAgIHZhciBleHBl Y3RlZCA9ICI/VGhpcytpcythK3Rlc3QiOworICAgICAgICBpZiAobG9jYXRpb24uc2VhcmNoICE9 IGV4cGVjdGVkKQorICAgICAgICAgICAgbG9nKCJGQUlMOiBFeHBlY3RlZCBcIiIgKyBleHBlY3Rl ZCArICJcIiBidXQgZ290IFwiIiArIGxvY2F0aW9uLnNlYXJjaCArICJcIiIpOworICAgICAgICBl bHNlCisgICAgICAgICAgICBsb2coIlBBU1MiKTsKKworICAgICAgICBpZiAod2luZG93LmxheW91 dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5 RG9uZSgpOworICAgIH0KK30KKworZnVuY3Rpb24gbG9nKG1zZykKK3sKKyAgICBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgibG9nIikuYXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUo bXNnICsgIlxuIikpOworfQorCit3aW5kb3cub25sb2FkID0gdGVzdDsKKzwvc2NyaXB0PgorPC9o ZWFkPgorPGJvZHk+Cis8cD5UaGlzIHBhZ2UgdGVzdHMgdGhhdCB3ZSBjb3JyZWN0bHkgcHV0IHRo ZSB2YWx1ZSBvZiBhbiA8dHQ+Jmx0O2lzaW5kZXgmZ3Q7PC90dD4gZWxlbWVudCBpbnRvIHRoZSBm b3JtIGRhdGEuPC9wPgorPHA+SWYgeW91IGFyZSBydW5uaW5nIHRoaXMgdGVzdCBieSBoYW5kLCBw cmVzcyB0aGUgZW50ZXIvcmV0dXJuIGtleSBvbiB5b3VyIGtleWJvYXJkIHRvIHN1Ym1pdC48L3A+ Cis8aXNpbmRleCBpZD0iaXNpbmRleCI+PC9pc2luZGV4PgorPHByZSBpZD0ibG9nIj48L3ByZT4K KzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNv dXJjZXMvaXNpbmRleC13aXRoLW5vLWZvcm0tYmFzZS1ocmVmLXN1Ym1pdC5odG1sCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIExheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvaXNpbmRleC13aXRo LW5vLWZvcm0tYmFzZS1ocmVmLXN1Ym1pdC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhy ZWYtc3VibWl0Lmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjggQEAKKzxodG1sPgorPGhl YWQ+Cis8c2NyaXB0PgorZnVuY3Rpb24gdGVzdCgpCit7CisgICAgdmFyIGV4cGVjdGVkID0gIj9U aGlzK2lzK2ErdGVzdCI7CisgICAgaWYgKGxvY2F0aW9uLnNlYXJjaCAhPSBleHBlY3RlZCkKKyAg ICAgICAgbG9nKCJGQUlMOiBFeHBlY3RlZCBcIiIgKyBleHBlY3RlZCArICJcIiBidXQgZ290IFwi IiArIGxvY2F0aW9uLnNlYXJjaCArICJcIiIpOworICAgIGVsc2UKKyAgICAgICAgbG9nKCJQQVNT Iik7Cit9CisKK2Z1bmN0aW9uIGxvZyhtc2cpCit7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoImxvZyIpLmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKG1zZyArICJcbiIp KTsKK30KKword2luZG93Lm9ubG9hZCA9IHRlc3Q7Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5 PgorPHByZSBpZD0ibG9nIj48L3ByZT4KKzxzY3JpcHQ+CitpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKzwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNj L3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYuaHRtbAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBMYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2lzaW5kZXgtd2l0aC1u by1mb3JtLWJhc2UtaHJlZi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9ybS1iYXNlLWhyZWYuaHRtbAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMyBAQAorPGh0bWw+Cis8aGVhZD4KKzxiYXNlIGhyZWY9 Imh0dHA6Ly9sb2NhbGhvc3Q6ODAwMC9taXNjL3Jlc291cmNlcy9pc2luZGV4LXdpdGgtbm8tZm9y bS1iYXNlLWhyZWYtc3VibWl0Lmh0bWwiPgorPHNjcmlwdD4KK2Z1bmN0aW9uIHRlc3QoKQorewor ICAgIHZhciBpc2luZGV4RWxtID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImlzaW5kZXgiKTsK KyAgICBpc2luZGV4RWxtLnZhbHVlID0gIlRoaXMgaXMgYSB0ZXN0IjsKKyAgICBpc2luZGV4RWxt LmZvY3VzKCk7CisKKyAgICBpZiAod2luZG93LmV2ZW50U2VuZGVyKQorICAgICAgICBldmVudFNl bmRlci5rZXlEb3duKFN0cmluZy5mcm9tQ2hhckNvZGUoMHgwZCkpOworfQorCit3aW5kb3cub25s b2FkID0gdGVzdDsKKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cD5UaGlzIHBhZ2UgdGVz dHMgdGhhdCB3ZSBjb3JyZWN0bHkgcHV0IHRoZSB2YWx1ZSBvZiBhbiA8dHQ+Jmx0O2lzaW5kZXgm Z3Q7PC90dD4gZWxlbWVudCBpbnRvIHRoZSBmb3JtIGRhdGEuPC9wPgorPHA+SWYgeW91IGFyZSBy dW5uaW5nIHRoaXMgdGVzdCBieSBoYW5kLCBwcmVzcyB0aGUgZW50ZXIvcmV0dXJuIGtleSBvbiB5 b3VyIGtleWJvYXJkIHRvIHN1Ym1pdC48L3A+Cis8aXNpbmRleCBpZD0iaXNpbmRleCI+PC9pc2lu ZGV4PgorPC9ib2R5PgorPC9odG1sPgo= 42172 2009-10-29 19:50:27 -0700 2009-10-29 19:50:27 -0700 KeyboardEvent Test keyeventTest.html text/html 2277 dbates PGh0bWw+CjxoZWFkPgo8Ym9keT4KPHA+T24gbG9hZGluZyB0aGlzIHBhZ2UsIHRoZSBmb3JtIChi ZWxvdykgc2hvdWxkIGJlIGF1dG9tYXRpY2FsbHkgc3VibWl0dGVkIHZpYSBhIHNpbXVsYXRlZCBr ZXkgcHJlc3Mgb2YgdGhlIGVudGVyIGtleS4gT24gc3VjY2VzcywgeW91IHNob3VsZCBzZWUgdGhl IGFsZXJ0ICJUZXN0IHBhc3NlZC4iIElmIHlvdSBkbyBub3Qgc2VlIGFuIGFsZXJ0LCB0aGVuIHRo ZSB0ZXN0IGZhaWxlZC48L3A+CjxwPkZvciBjb21wYXJpc29uLCB0cnkgbWFudWFsbHkgc3VibWl0 dGluZyB0aGlzIGZvcm0uIFRoZW4gY29tcGFyZSB0aGUgY2FwdHVyZWQga2V5IGV2ZW50IG9mIHRo aXMgc3VibWlzc2lvbiB0byB0aGUgYXV0b21hdGljYWxseSBnZW5lcmF0ZWQgb25lLiBUaGV5IHNo b3VsZCBiZSB0aGUgc2FtZS48L3A+Cjxmb3JtIGFjdGlvbj0iamF2YXNjcmlwdDphbGVydCgnVGVz dCBwYXNzZWQuJykiPgogICAgPGlucHV0IGlkPSJxIiB0eXBlPSJ0ZXh0IiBuYW1lPSJxIiB2YWx1 ZT0iVGhpcyBpcyBhIHRlc3QiLz4KPC9mb3JtPgo8Yj5LZXlFdmVudHMgY2FwdHVyZWQ6PC9iPgo8 ZGl2IGlkPSJyZXN1bHQiPjwvZGl2Pgo8c2NyaXB0Pgp2YXIgcmV0dXJuS2V5Q29kZSA9IDEzOyAv LyBBU0NJSSBrZXkgY29kZSBmb3IgY2FycmlhZ2UgcmV0dXJuLgp2YXIgZmllbGQgPSBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgicSIpOwpmaWVsZC5hZGRFdmVudExpc3RlbmVyKCJrZXlwcmVzcyIs IGtleWV2ZW50LCB0cnVlKTsKCnZhciBrZXlQcmVzc0V2ZW50ID0gZG9jdW1lbnQuY3JlYXRlRXZl bnQoJ0tleWJvYXJkRXZlbnQnKTsKCmlmIChrZXlQcmVzc0V2ZW50LmluaXRLZXlFdmVudCkgewog ICAgLy8gVGhpcyBpcyB0aGUgTW96aWxsYS9GaXJlZm94IEFQSSwgc2VlIDxodHRwczovL2RldmVs b3Blci5tb3ppbGxhLm9yZy9lbi9ET00vZXZlbnQuaW5pdEtleUV2ZW50Pi4KICAgIGtleVByZXNz RXZlbnQuaW5pdEtleUV2ZW50KCJrZXlwcmVzcyIsIHRydWUsIHRydWUsIGRvY3VtZW50LmRlZmF1 bHRWaWV3LCBmYWxzZSwgZmFsc2UsIGZhbHNlLCBmYWxzZSwgcmV0dXJuS2V5Q29kZSwgMCk7Cn0g ZWxzZSBpZiAoa2V5UHJlc3NFdmVudC5pbml0S2V5Ym9hcmRFdmVudCkgewogICAgLy8gVGhpcyBp cyBhIHF1YXNpLVczQyBET00gTGV2ZWwgMyBBUEkuIFdoeSAicXVhc2kiPyBCZWNhdXNlIEkgY2Fu bm90IGZpbmQgdGhpcyBmdW5jdGlvbiBwcm90b3R5cGUgaW4gdGhlIFczQyBET00gTGV2ZWwgMyBz cGVjCiAgICAvLyAoaHR0cDovL3d3dy53My5vcmcvVFIvRE9NLUxldmVsLTMtRXZlbnRzLyNldmVu dHMtRXZlbnRzLUtleWJvYXJkRXZlbnQtaW5pdEtleWJvYXJkRXZlbnQpLCBzZWUgYnVnICMxMzM2 OC4gSSBmb3VuZCB0aGlzIAogICAgLy8gZnVuY3Rpb24gcHJvdG90eXBlIGluIGZpbGUgZmFzdC9m b3Jtcy9pbnB1dC10ZXh0LWVudGVyLmh0bWwuIAogICAgLy8KICAgIC8vIEZJWE1FOiBLZXlib2Fy ZEV2ZW50cyBkbyBub3Qgd29yayBpbiBXZWJLaXQsIHNlZSBidWcgIzE2NzM1LiBNb3Jlb3Zlciwg RE9NIExldmVsIDMgRXZlbnRzIGFyZSBicm9rZW4sIHNlZSBidWcgIzk5MzMuCiAgICAvLyBVbnRp bCB3ZSBjb3JyZWN0IHRoZXNlIGJ1Z3MsIHRoaXMgZXZlbnQgZG9lcyBub3Qgd29yay4KICAgIGtl eVByZXNzRXZlbnQuaW5pdEtleWJvYXJkRXZlbnQoImtleXByZXNzIiwgdHJ1ZSwgdHJ1ZSwgZG9j dW1lbnQuZGVmYXVsdFZpZXcsICJVKzAwMEQiIC8qIGNhcnJpYWdlIHJldHVybiAqLywgMCwgZmFs c2UsIGZhbHNlLCBmYWxzZSwgZmFsc2UsIGZhbHNlKTsKfSAgIApmaWVsZC5kaXNwYXRjaEV2ZW50 KGtleVByZXNzRXZlbnQpOwoKZnVuY3Rpb24ga2V5ZXZlbnQoZXZlbnQpIHsKICAgIHZhciBwID0g ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgicCIpOwogICAgcC5hcHBlbmRDaGlsZChkb2N1bWVudC5j cmVhdGVUZXh0Tm9kZShldmVudC50eXBlICsgIiAtIGtleTogIiArIGV2ZW50LmtleUlkZW50aWZp ZXIgKyAiQCIgKyBldmVudC5rZXlMb2NhdGlvbiArICIgKGtleUNvZGUvY2hhckNvZGU6ICIgKyBl dmVudC5rZXlDb2RlICsgIi8iICsgZXZlbnQuY2hhckNvZGUgKyAiKSIgKyAiIG1vZGlmaWVyczog IiArIGV2ZW50LmN0cmxLZXkgKyAiLCIgKyBldmVudC5hbHRLZXkgKyAiLCIgKyBldmVudC5zaGlm dEtleSArICIsIiArIGV2ZW50Lm1ldGFLZXkpKTsKICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlk KCJyZXN1bHQiKS5hcHBlbmRDaGlsZChwKTsKfQo8L3NjcmlwdD4KPC9ib2R5Pgo8L2h0bWw+