39184 2010-05-16 13:36:08 -0700 Add support for parsing a SVN property 2010-05-16 23:10:33 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 39170 38885 1 dbates webkit-unassigned cjerdonek eric oldest_to_newest 226529 0 dbates 2010-05-16 13:36:08 -0700 We need to add support for parsing a SVN property so that we can use it to parse a SVN property change diff (Bug #38885) that contains one or more SVN properties. 226545 1 56197 dbates 2010-05-16 14:23:04 -0700 Created attachment 56197 Patch with unit tests 226554 2 56197 cjerdonek 2010-05-16 15:32:02 -0700 Comment on attachment 56197 Patch with unit tests Thanks for this patch, Dan! Overall this looks pretty good, but several minor comments below. > Index: WebKitTools/ChangeLog > + Adds function VCSUtils::parseSvnProperty to parse an SVN property with > + either a single-line or multi-line value. I would add the word "change" at the end because the property can have two "value" sections if there is both a "-" and "+". So, "...with either a single-line or multi-line value change." > + > + * Scripts/VCSUtils.pm: > + - Added function parseSvnProperty. We will use this function > + towards resolving Bug #38885 <https://bugs.webkit.org/show_bug.cgi?id=38885>. alignment > + - Removed FIXME comment above function parseSvnPropertyValue, since > + it is being used by parseSvnProperty. > + - (*) Modified function parseSvnPropertyValue to break out of "while (<$fileHandle>)" > + loop when it encounters the start of the next property so that it can be > + processed by its caller, parseSvnPropertyValue. Instead of saying "(*)", I would say include an additional sentence saying, "We reference this bullet below by (*)." I was confused by what the "(*)" meant until I read to the end of the entry. > + * Scripts/webkitperl/VCSUtils_unittest/parseSvnProperty.pl: Added. > + - Added unit tests. > + * Scripts/webkitperl/VCSUtils_unittest/parseSvnPropertyValue.pl: > + - Changed the name of the unit test "simple multi-line '-' change" to > + "single-line '-' change followed by empty line" since the former was an > + incorrect description of this test. > + - Added unit test "single-line '-' change followed by the next property", and > + "multi-line '-' change followed by the next property" to test (*). I would insert the word "above" at the end as in "to test (*) above". > Index: WebKitTools/Scripts/VCSUtils.pm > +my $svnPropertyStartRegEx = qr#^(Modified|Name|Added|Deleted): ([^\r\n]+)#; # $1 is the name of the property. Should the comment say $2? > +# Parse the next SVN property from the given file handle, and advance the handle so the last > +# line read is the first line after the property. > +# > +# This subroutine dies if the first line is an invalid SVN property > +# (i.e. a line that does not match $svnPropertyStartRegEx) or > +# the value of the property is missing. I would rewrite this as "...if the first line is not a valid start of an SVN property (e.g. if the value of the property is missing)." > +# Returns ($propertyHashRef, $lastReadLine): > +# $propertyHashRef: a hash reference representing a SVN property. > +# name: the name of the property. > +# value: the last-most value of the property. For instance, suppose the property is "Modified". > +# Then it has both a '-' and '+' property value in that order. Therefore, the value > +# of this key is the value of the '+' property by ordering (since it is the last-most value). I would be consistent with your uses above and use two spaces after each period. Also, instead of "last-most", I would just say, "the last property value." > +# propertyChangeDelta: the value 1 or -1 if the property was added or > +# removed, respectively. alignment (from before) > +# $lastReadLine: the line last read from $fileHandle. > +# > +# FIXME: This method is unused as of (05/16/2010). We will call this function > +# as part of parsing a SVN footer. See <https://bugs.webkit.org/show_bug.cgi?id=38885>. Two spaces after each period. Also do this below (I will stop mentioning it.) > +sub parseSvnProperty($$) > +{ > + my ($fileHandle, $line) = @_; > + > + $_ = $line; > + > + my $propertyName; > + my $propertyNamePrefix; Maybe $propertyChangeType instead of prefix? propertyNamePrefix makes it seem like it's the prefix of the name -- e.g. the "svn" in "svn:executable". > + if (/$svnPropertyStartRegEx/) { > + $propertyNamePrefix = $1; > + $propertyName = $2; > + } else { > + die("Failed to find SVN property: \"$_\"."); > + } > + > + $_ = <$fileHandle>; # Not defined if end-of-file reached. > + > + my $propertyValue; > + my $propertyValuePrefix; Again, for similar reasons, maybe propertyValueType? > + while (defined($_)) { > + while (defined($_) && /$svnPropertyValueStartRegEx/) { > + # Note, a '-' property may be followed by '+' property in the case of a "Modified" > + # or "Name" property. We only care about the actual change (i.e. the '+' property) Maybe "ending value" instead of "actual change" would be clearer? > + # in such circumstances. So, we take the property value for the property to be its > + # last parsed property value. > + # FIXME: We may want to consider strictly enforcing a '-', '+' property ordering or > + # add error checking to prevent '+', '+', ..., '+' and other invalid combinations. > + $propertyValuePrefix = $1; > + ($propertyValue, $_) = parseSvnPropertyValue($fileHandle, $_); Does this while loop handle the case of empty lines between property values? If we don't need to support that for some reason, it might be worth mentioning commenting why. > + } > + > + # We skip over everything that isn't an empty line or $svnPropertyStartRegEx. There is an > + # empty line before the contents of a binary patch. I'm confused. Once you have the last property value, why do you need to keep looping through the while loop? It seems like you can just exit since you have the last value. This also makes it seem like you only need one while loop and not two nested loops. > + last if (!defined($_) || /^[\r\n]*\z/ || /$svnPropertyStartRegEx/); > + $_ = <$fileHandle>; # Not defined if end-of-file reached. > + } > + > + if (!$propertyValue) { > + die("Failed to find the property value for the SVN property \"$propertyName\": \"$_\"."); > + } > + > + my $propertyChangeDelta; > + if ($propertyValuePrefix eq '+') { > + $propertyChangeDelta = 1; > + } elsif ($propertyValuePrefix eq '-') { > + $propertyChangeDelta = -1; > + } else { > + # Not reached. > + die; > + } > + > + my $expectedChangeDelta; I would add a comment here that you are doing additional validation, if that is what you're doing. > + if ($propertyNamePrefix eq "Name") { > + $expectedChangeDelta = 0; > + } elsif ($propertyNamePrefix eq "Modified") { > + $expectedChangeDelta = 0; > + } elsif ($propertyNamePrefix eq "Added") { > + $expectedChangeDelta = 1; > + } elsif ($propertyNamePrefix eq "Deleted") { > + $expectedChangeDelta = -1; > + } else { > + # Not reached. > + die; > + } > + > + if ($propertyChangeDelta == -1 * $expectedChangeDelta) { Why aren't you doing "if ($propertyChangeDelta != $expectedChangeDelta)"? > + die("Property change prefix \"$propertyValuePrefix\" does not match " . > + "the property name prefix \"$propertyNamePrefix\"."); I don't think "match" is the right word since they're not really supposed to be the same. Maybe "The final property value type found \"$propertyValueType\" does not correspond to the property change type found \"$propertyChangeType\"."? How hard would it be to include the correct property value type in the message? > -# $line: the line last read from $fileHandle > +# $line: the line last read from $fileHandle. Thanks. > - if (/^$/ || /$svnPropertyValueStartRegEx/) { > + if (/^$/ || /$svnPropertyValueStartRegEx/ || /$svnPropertyStartRegEx/) { > # Note, we may encounter an empty line before the contents of a binary patch. > # Also, we check for $svnPropertyValueStartRegEx because a '-' property may be > # followed by a '+' property in the case of a "Modified" or "Name" property. > + # We check for $svnPropertyStartRegEx because it indicates the start of the > + # next property to parse. Does this mean that there is not always an empty line separating one property change from another? > Index: WebKitTools/Scripts/webkitperl/VCSUtils_unittest/parseSvnProperty.pl Thanks for your unit tests. It seems like you should be putting lines after the property changes in each of your test cases to test the expectedNextLine and last read line in each case. > +{ > + # New test > + diffName => "simple: add svn:executable", > + inputText => <<'END', > +Added: svn:executable > + + * For example, include a blank line and a line marking the beginning of the next diff here. In most use cases, you will have stuff after the property value. This will also let you test your handling of empty lines, etc. in relation to the while loops above. > +{ > + # New test > + diffName => "multi-line '+' change, followed by svn:executable", > + inputText => <<'END', > +Name: documentation > + + A > +long sentence that spans > +multiple lines. > +Name: svn:executable > + + * > +END I thought there was also an empty line between successive properties, or did you recently find that that is not the case? 226563 3 dbates 2010-05-16 17:11:47 -0700 (In reply to comment #2) > (From update of attachment 56197 [details]) > Thanks for this patch, Dan! Overall this looks pretty good, but several minor comments below. > > > Index: WebKitTools/ChangeLog > > + Adds function VCSUtils::parseSvnProperty to parse an SVN property with > > + either a single-line or multi-line value. > > I would add the word "change" at the end because the property can have two > "value" sections if there is both a "-" and "+". So, "...with either a > single-line or multi-line value change." Will add. > > > + > > + * Scripts/VCSUtils.pm: > > + - Added function parseSvnProperty. We will use this function > > + towards resolving Bug #38885 <https://bugs.webkit.org/show_bug.cgi?id=38885>. > > alignment > > > + - Removed FIXME comment above function parseSvnPropertyValue, since > > + it is being used by parseSvnProperty. > > + - (*) Modified function parseSvnPropertyValue to break out of "while (<$fileHandle>)" > > + loop when it encounters the start of the next property so that it can be > > + processed by its caller, parseSvnPropertyValue. > > Instead of saying "(*)", I would say include an additional sentence saying, > "We reference this bullet below by (*)." I was confused by what the "(*)" > meant until I read to the end of the entry. Will change. > > + * Scripts/webkitperl/VCSUtils_unittest/parseSvnProperty.pl: Added. > > + - Added unit tests. > > + * Scripts/webkitperl/VCSUtils_unittest/parseSvnPropertyValue.pl: > > + - Changed the name of the unit test "simple multi-line '-' change" to > > + "single-line '-' change followed by empty line" since the former was an > > + incorrect description of this test. > > + - Added unit test "single-line '-' change followed by the next property", and > > + "multi-line '-' change followed by the next property" to test (*). > > I would insert the word "above" at the end as in "to test (*) above". Will change. > > > Index: WebKitTools/Scripts/VCSUtils.pm > > +my $svnPropertyStartRegEx = qr#^(Modified|Name|Added|Deleted): ([^\r\n]+)#; # $1 is the name of the property. > > Should the comment say $2? Good catch. Will change. > > > +# Parse the next SVN property from the given file handle, and advance the handle so the last > > +# line read is the first line after the property. > > +# > > +# This subroutine dies if the first line is an invalid SVN property > > +# (i.e. a line that does not match $svnPropertyStartRegEx) or > > +# the value of the property is missing. > > I would rewrite this as "...if the first line is not a valid start of an > SVN property (e.g. if the value of the property is missing)." I am unclear if you are implying we should lump together, for documentation purposes, the cases where we die when the first line is invalid and also when the property value is missing? Without loss of generality, this function dies if the the first line is not of the form "Added: svn:executable". Following from this, suppose the input to this function is: Added: svn:executable Index: Makefile.shared ========================================================== [...] This is a malformed patch since it is missing a property value. So, I chose to die if there is no property value. Hence, we also die if the value for the property is missing. Maybe we should assume this is just improbable and/or simply return a property hash whose value and propertyChangeDelta keys are undefined? Note, I inadvertently left out that we also die if there is disagreement between the $propertyNamePrefix (e.g. "Added" , "Deleted") and the value prefix (e.g. '+', '-'), such as: Added: svn:executable - * > > > > +# Returns ($propertyHashRef, $lastReadLine): > > +# $propertyHashRef: a hash reference representing a SVN property. > > +# name: the name of the property. > > +# value: the last-most value of the property. For instance, suppose the property is "Modified". > > +# Then it has both a '-' and '+' property value in that order. Therefore, the value > > +# of this key is the value of the '+' property by ordering (since it is the last-most value). > > I would be consistent with your uses above and use two spaces after each period. > Also, instead of "last-most", I would just say, "the last property value." Will change both. > > > > +# propertyChangeDelta: the value 1 or -1 if the property was added or > > +# removed, respectively. > > alignment (from before) Will fix alignment of second line of comment. > > > +# $lastReadLine: the line last read from $fileHandle. > > +# > > +# FIXME: This method is unused as of (05/16/2010). We will call this function > > +# as part of parsing a SVN footer. See <https://bugs.webkit.org/show_bug.cgi?id=38885>. > > Two spaces after each period. Also do this below (I will stop mentioning it.) Will change. > > > +sub parseSvnProperty($$) > > +{ > > + my ($fileHandle, $line) = @_; > > + > > + $_ = $line; > > + > > + my $propertyName; > > + my $propertyNamePrefix; > > Maybe $propertyChangeType instead of prefix? propertyNamePrefix makes it > seem like it's the prefix of the name -- e.g. the "svn" in "svn:executable". > I agree. Will change. > > > > + if (/$svnPropertyStartRegEx/) { > > + $propertyNamePrefix = $1; > > + $propertyName = $2; > > + } else { > > + die("Failed to find SVN property: \"$_\"."); > > + } > > + > > + $_ = <$fileHandle>; # Not defined if end-of-file reached. > > + > > + my $propertyValue; > > + my $propertyValuePrefix; > > Again, for similar reasons, maybe propertyValueType? > > > + while (defined($_)) { > > + while (defined($_) && /$svnPropertyValueStartRegEx/) { > > + # Note, a '-' property may be followed by '+' property in the case of a "Modified" > > + # or "Name" property. We only care about the actual change (i.e. the '+' property) > > Maybe "ending value" instead of "actual change" would be clearer? Will change. > > > + # in such circumstances. So, we take the property value for the property to be its > > + # last parsed property value. > > + # FIXME: We may want to consider strictly enforcing a '-', '+' property ordering or > > + # add error checking to prevent '+', '+', ..., '+' and other invalid combinations. > > + $propertyValuePrefix = $1; > > + ($propertyValue, $_) = parseSvnPropertyValue($fileHandle, $_); > > Does this while loop handle the case of empty lines between property values? > If we don't need to support that for some reason, it might be worth > mentioning commenting why. The "svn diff" command does not insert newlines between property values or successive properties. So, these new lines would be part of the property value. This patch does not support property values that end with trailing newlines as it does not have support to disambiguate between these new lines and the new line that precedes the contents of a binary patch. I would suggest adding such support in a future patch. I'll add a FIXME to clarify this. > > > + } > > + > > + # We skip over everything that isn't an empty line or $svnPropertyStartRegEx. There is an > > + # empty line before the contents of a binary patch. > > I'm confused. Once you have the last property value, why do you need to > keep looping through the while loop? It seems like you can just exit > since you have the last value. This also makes it seem like you only > need one while loop and not two nested loops. We don't need the outer while loop, will remove. > > > + last if (!defined($_) || /^[\r\n]*\z/ || /$svnPropertyStartRegEx/); > > + $_ = <$fileHandle>; # Not defined if end-of-file reached. > > + } > > + > > + if (!$propertyValue) { > > + die("Failed to find the property value for the SVN property \"$propertyName\": \"$_\"."); > > + } > > + > > + my $propertyChangeDelta; > > + if ($propertyValuePrefix eq '+') { > > + $propertyChangeDelta = 1; > > + } elsif ($propertyValuePrefix eq '-') { > > + $propertyChangeDelta = -1; > > + } else { > > + # Not reached. > > + die; > > + } > > + > > + my $expectedChangeDelta; > > I would add a comment here that you are doing additional validation, > if that is what you're doing. Will add comment. > > > + if ($propertyNamePrefix eq "Name") { > > + $expectedChangeDelta = 0; > > + } elsif ($propertyNamePrefix eq "Modified") { > > + $expectedChangeDelta = 0; > > + } elsif ($propertyNamePrefix eq "Added") { > > + $expectedChangeDelta = 1; > > + } elsif ($propertyNamePrefix eq "Deleted") { > > + $expectedChangeDelta = -1; > > + } else { > > + # Not reached. > > + die; > > + } > > + > > + if ($propertyChangeDelta == -1 * $expectedChangeDelta) { > > Why aren't you doing "if ($propertyChangeDelta != $expectedChangeDelta)"? Take $propertyChangeDelta := 1, and $expectedChangeDelta := 0. Then we would die with a mismatch error. Notice, $expectedChangeDelta is zero when the property type is "Name" or "Modified" since we cannot infer whether this is an addition or a removal of a property. Instead, we must inspect the +/- line(s) that follow this line in the diff. Alternatively, we could write this as "if ($expectedChangeDelta && $propertyChangeDelta != $expectedChangeDelta)". > > > + die("Property change prefix \"$propertyValuePrefix\" does not match " . > > + "the property name prefix \"$propertyNamePrefix\"."); > > I don't think "match" is the right word since they're not really supposed > to be the same. Maybe "The final property value type found \"$propertyValueType\" > does not correspond to the property change type found \"$propertyChangeType\"."? > > How hard would it be to include the correct property value type in the message? As aforementioned above, it is not always possible to infer what is the correct property value type. > > > -# $line: the line last read from $fileHandle > > +# $line: the line last read from $fileHandle. > > Thanks. > > > - if (/^$/ || /$svnPropertyValueStartRegEx/) { > > + if (/^$/ || /$svnPropertyValueStartRegEx/ || /$svnPropertyStartRegEx/) { > > # Note, we may encounter an empty line before the contents of a binary patch. > > # Also, we check for $svnPropertyValueStartRegEx because a '-' property may be > > # followed by a '+' property in the case of a "Modified" or "Name" property. > > + # We check for $svnPropertyStartRegEx because it indicates the start of the > > + # next property to parse. > > Does this mean that there is not always an empty line separating one > property change from another? Right. As aforementioned above, the "svn diff" command does not insert newlines between property values. > > > Index: WebKitTools/Scripts/webkitperl/VCSUtils_unittest/parseSvnProperty.pl > > Thanks for your unit tests. It seems like you should be putting lines > after the property changes in each of your test cases to test the > expectedNextLine and last read line in each case. > > > +{ > > + # New test > > + diffName => "simple: add svn:executable", > > + inputText => <<'END', > > +Added: svn:executable > > + + * > > For example, include a blank line and a line marking the beginning of the > next diff here. In most use cases, you will have stuff after the property > value. This will also let you test your handling of empty lines, etc. > in relation to the while loops above. Will add a case for the simple scenario. This is already covered for multi-lines in tests: ""multi-line '+' change and start of binary patch", and "multi-line '-' change followed by multi-line '+' change followed by start of binary patch". > > > +{ > > + # New test > > + diffName => "multi-line '+' change, followed by svn:executable", > > + inputText => <<'END', > > +Name: documentation > > + + A > > +long sentence that spans > > +multiple lines. > > +Name: svn:executable > > + + * > > +END > > I thought there was also an empty line between successive properties, > or did you recently find that that is not the case? As aforementioned, the "svn diff" command does not insert newlines between successive properties. The property value may contain trailing newlines. This patch does not support properties whose values end in trailing new lines (mentioned above). 226564 4 dbates 2010-05-16 17:16:22 -0700 (In reply to comment #3) > (In reply to comment #2) > > (From update of attachment 56197 [details] [details]) > > This is a malformed patch since it is missing a property value. So, I chose to die if there is no property > value. Hence, we also die if the value for the property is missing. Maybe we should assume this is just > improbable and/or simply return a property hash whose value and propertyChangeDelta keys are > undefined? This should read: This is a malformed patch since it is missing a property value. So, I chose to die if there is no property value. Maybe we should assume this is just improbable and/or simply return a property hash whose value and propertyChangeDelta keys are undefined? 226583 5 56204 dbates 2010-05-16 18:22:19 -0700 Created attachment 56204 Patch with unit tests Updated patch based on Chris's suggestions. Added test cases: "add svn:executable, followed by empty line" "add svn:executable, followed by empty line and start of binary patch" "single-line '-' change with trailing new line, and single-line '+' change" "multi-line '-' change with trailing new line, and multi-line '+' change" "single-line '+' with trailing new line, followed by empty line and start of binary patch" "single-line '+' change followed by custom property with single-line '+' change" 226585 6 56205 dbates 2010-05-16 18:37:33 -0700 Created attachment 56205 Patch with unit tests Fix alignment issue in change log. 226620 7 56212 dbates 2010-05-16 22:21:03 -0700 Created attachment 56212 Patch with unit tests Spoke with Chris tonight, and we decided to change the line "if ($propertyChangeDelta == -1 * $expectedChangeDelta)" to "if ($expectedChangeDelta && $propertyChangeDelta != $expectedChangeDelta)" to make it clearer to a reader that we should only die if the property change type (e.g. "Added") differs from the property value type (e.g. "+"), for "Added" and "Deleted" change types only. 226621 8 cjerdonek 2010-05-16 22:22:11 -0700 (In reply to comment #3) > > I would rewrite this as "...if the first line is not a valid start of an > > SVN property (e.g. if the value of the property is missing)." > > I am unclear if you are implying we should lump together, for documentation purposes, the cases where we die when the first line is invalid and also when the property value is missing? No, I didn't mean to lump them together. You can ignore the comment. I just didn't understand from what you wrote that you were also checking the validity of the later lines. > The "svn diff" command does not insert newlines between property values or successive properties. So, these new lines would be part of the property value. This patch does not support property values that end with trailing newlines as it does not have support to disambiguate between these new lines and the new line that precedes the contents of a binary patch. I would suggest adding such support in a future patch. I'll add a FIXME to clarify this. Okay. Yes, it might help in case people leave trailing empty lines when setting the svn:ignore value. > > > + if ($propertyChangeDelta == -1 * $expectedChangeDelta) { > > > > Why aren't you doing "if ($propertyChangeDelta != $expectedChangeDelta)"? > > Take $propertyChangeDelta := 1, and $expectedChangeDelta := 0. Then we would die with a mismatch error. > > Notice, $expectedChangeDelta is zero when the property type is "Name" or "Modified" since we cannot infer whether this is an addition or a removal of a property. Instead, we must inspect the +/- line(s) that follow this line in the diff. Okay. Then I would consider using undef instead of 0 when it cannot be inferred. > Alternatively, we could write this as "if ($expectedChangeDelta && $propertyChangeDelta != $expectedChangeDelta)". Yes, this makes it a bit clearer. And then you can say defined($expectedChangeDelta) instead of $expectedChangeDelta if you switch to undef. 226624 9 56212 cjerdonek 2010-05-16 22:36:31 -0700 Comment on attachment 56212 Patch with unit tests Feel free to consider these nits and minor comments below before landing. r=me. > +# value: the last property value. For instance, suppose the property is "Modified". > +# Then it has both a '-' and '+' property value in that order. Therefore, > +# the value of this key is the value of the '+' property by ordering (since > +# it is the last-most value). Nit: last instead of last-most. > + # FIXME: We do not support property values that contain tailing new line characters trailing, newline (instead of new line) > + # as it is difficult to disambiguate these trailing new lines from the empty newline > + # line that preceeds the contents of a binary patch. precedes > + my $propertyValue; > + my $propertyValueType; > + while (defined($_) && /$svnPropertyValueStartRegEx/) { > + # Note, a '-' property may be followed by '+' property in the case of a "Modified" a '+' property > + my $propertyChangeDelta; > + if ($propertyValueType eq '+') { > + $propertyChangeDelta = 1; > + } elsif ($propertyValueType eq '-') { > + $propertyChangeDelta = -1; > + } else { > + # Not reached. > + die; Would die("Not reached.") be better? Just in case. :) > + # New test > + diffName => "single-line '+' with trailing new line, followed by empty line and start of binary patch", Did you do any tests for property value followed by start of next diff? 226625 10 dbates 2010-05-16 22:54:14 -0700 Thanks Chris for the review. (In reply to comment #9) > (From update of attachment 56212 [details]) > Feel free to consider these nits and minor comments below before landing. r=me. > > > > +# value: the last property value. For instance, suppose the property is "Modified". > > +# Then it has both a '-' and '+' property value in that order. Therefore, > > +# the value of this key is the value of the '+' property by ordering (since > > +# it is the last-most value). > > Nit: last instead of last-most. Will change. > > > + # FIXME: We do not support property values that contain tailing new line characters > > trailing, newline (instead of new line) Will change. > > > + # as it is difficult to disambiguate these trailing new lines from the empty > > newline Will change. > > > + # line that preceeds the contents of a binary patch. > > precedes Will change. > > > > + my $propertyValue; > > + my $propertyValueType; > > + while (defined($_) && /$svnPropertyValueStartRegEx/) { > > + # Note, a '-' property may be followed by '+' property in the case of a "Modified" > > a '+' property Will change. > > > + my $propertyChangeDelta; > > + if ($propertyValueType eq '+') { > > + $propertyChangeDelta = 1; > > + } elsif ($propertyValueType eq '-') { > > + $propertyChangeDelta = -1; > > + } else { > > + # Not reached. > > + die; > > Would die("Not reached.") be better? Just in case. :) Will change. Note, Die() already returns the file and line number where it was called. > > > + # New test > > + diffName => "single-line '+' with trailing new line, followed by empty line and start of binary patch", > > Did you do any tests for property value followed by start of next diff? I will add some more test cases. The included test coverage is sufficient since the code does not explicitly check for the start of the next diff or a binary patch. Instead, it checks for the presence of an empty line, which always follows the SVN footer. 226626 11 cjerdonek 2010-05-16 22:58:57 -0700 (In reply to comment #10) > > Did you do any tests for property value followed by start of next diff? > > I will add some more test cases. > > The included test coverage is sufficient since the code does not explicitly check for the start of the next diff or a binary patch. Instead, it checks for the presence of an empty line, which always follows the SVN footer. Okay, thanks. I wasn't sure because it seemed like you were giving special emphasis to test cases involving binary patches. 226630 12 dbates 2010-05-16 23:10:33 -0700 Committed r59593: <http://trac.webkit.org/changeset/59593> 56197 2010-05-16 14:23:04 -0700 2010-05-16 18:22:19 -0700 Patch with unit tests Bug39184_1.patch text/plain 16010 dbates SW5kZXg6IFdlYktpdFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9D aGFuZ2VMb2cJKHJldmlzaW9uIDU5NTgwKQorKysgV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpCkBAIC0xLDMgKzEsMjkgQEAKKzIwMTAtMDUtMTYgIERhbmllbCBCYXRlcyAgPGRi YXRlc0ByaW0uY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTE4NAorCisg ICAgICAgIEFkZHMgZnVuY3Rpb24gVkNTVXRpbHM6OnBhcnNlU3ZuUHJvcGVydHkgdG8gcGFyc2Ug YW4gU1ZOIHByb3BlcnR5IHdpdGgKKyAgICAgICAgZWl0aGVyIGEgc2luZ2xlLWxpbmUgb3IgbXVs dGktbGluZSB2YWx1ZS4KKworICAgICAgICAqIFNjcmlwdHMvVkNTVXRpbHMucG06CisgICAgICAg ICAgLSBBZGRlZCBmdW5jdGlvbiBwYXJzZVN2blByb3BlcnR5LiBXZSB3aWxsIHVzZSB0aGlzIGZ1 bmN0aW9uCisgICAgICAgICAgdG93YXJkcyByZXNvbHZpbmcgQnVnICMzODg4NSA8aHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4ODg1Pi4KKyAgICAgICAgICAtIFJlbW92 ZWQgRklYTUUgY29tbWVudCBhYm92ZSBmdW5jdGlvbiBwYXJzZVN2blByb3BlcnR5VmFsdWUsIHNp bmNlCisgICAgICAgICAgICBpdCBpcyBiZWluZyB1c2VkIGJ5IHBhcnNlU3ZuUHJvcGVydHkuCisg ICAgICAgICAgLSAoKikgTW9kaWZpZWQgZnVuY3Rpb24gcGFyc2VTdm5Qcm9wZXJ0eVZhbHVlIHRv IGJyZWFrIG91dCBvZiAid2hpbGUgKDwkZmlsZUhhbmRsZT4pIgorICAgICAgICAgICAgbG9vcCB3 aGVuIGl0IGVuY291bnRlcnMgdGhlIHN0YXJ0IG9mIHRoZSBuZXh0IHByb3BlcnR5IHNvIHRoYXQg aXQgY2FuIGJlCisgICAgICAgICAgICBwcm9jZXNzZWQgYnkgaXRzIGNhbGxlciwgcGFyc2VTdm5Q cm9wZXJ0eVZhbHVlLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cGVybC9WQ1NVdGlsc191bml0 dGVzdC9wYXJzZVN2blByb3BlcnR5LnBsOiBBZGRlZC4KKyAgICAgICAgICAtIEFkZGVkIHVuaXQg dGVzdHMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0ZXN0L3Bh cnNlU3ZuUHJvcGVydHlWYWx1ZS5wbDoKKyAgICAgICAgICAtIENoYW5nZWQgdGhlIG5hbWUgb2Yg dGhlIHVuaXQgdGVzdCAic2ltcGxlIG11bHRpLWxpbmUgJy0nIGNoYW5nZSIgdG8KKyAgICAgICAg ICAgICJzaW5nbGUtbGluZSAnLScgY2hhbmdlIGZvbGxvd2VkIGJ5IGVtcHR5IGxpbmUiIHNpbmNl IHRoZSBmb3JtZXIgd2FzIGFuCisgICAgICAgICAgICBpbmNvcnJlY3QgZGVzY3JpcHRpb24gb2Yg dGhpcyB0ZXN0LgorICAgICAgICAgIC0gQWRkZWQgdW5pdCB0ZXN0ICJzaW5nbGUtbGluZSAnLScg Y2hhbmdlIGZvbGxvd2VkIGJ5IHRoZSBuZXh0IHByb3BlcnR5IiwgYW5kCisgICAgICAgICAgICAi bXVsdGktbGluZSAnLScgY2hhbmdlIGZvbGxvd2VkIGJ5IHRoZSBuZXh0IHByb3BlcnR5IiB0byB0 ZXN0ICgqKS4KKwogMjAxMC0wNS0xNiAgUm9iZXJ0IEhvZ2FuICA8cm9iZXJ0QHdlYmtpdC5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4uCkluZGV4 OiBXZWJLaXRUb29scy9TY3JpcHRzL1ZDU1V0aWxzLnBtCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRv b2xzL1NjcmlwdHMvVkNTVXRpbHMucG0JKHJldmlzaW9uIDU5NTc5KQorKysgV2ViS2l0VG9vbHMv U2NyaXB0cy9WQ1NVdGlscy5wbQkod29ya2luZyBjb3B5KQpAQCAtOTAsNiArOTAsNyBAQCBteSAk Y2hhbmdlTG9nVGltZVpvbmUgPSAiUFNUOFBEVCI7CiAKIG15ICRnaXREaWZmU3RhcnRSZWdFeCA9 IHFyI15kaWZmIC0tZ2l0IChcdy8pPyguKykgKFx3Lyk/KFteXHJcbl0rKSM7CiBteSAkc3ZuRGlm ZlN0YXJ0UmVnRXggPSBxciNeSW5kZXg6IChbXlxyXG5dKykjOworbXkgJHN2blByb3BlcnR5U3Rh cnRSZWdFeCA9IHFyI14oTW9kaWZpZWR8TmFtZXxBZGRlZHxEZWxldGVkKTogKFteXHJcbl0rKSM7 ICMgJDEgaXMgdGhlIG5hbWUgb2YgdGhlIHByb3BlcnR5LgogbXkgJHN2blByb3BlcnR5VmFsdWVT dGFydFJlZ0V4ID0gcXIjXiAgIChcK3wtKSAoW15cclxuXSspIzsgIyAkMiBpcyB0aGUgc3RhcnQg b2YgdGhlIHByb3BlcnR5J3MgdmFsdWUgKHdoaWNoIG1heSBzcGFuIG11bHRpcGxlIGxpbmVzKS4K IAogIyBUaGlzIG1ldGhvZCBpcyBmb3IgcG9ydGFiaWxpdHkuIFJldHVybiB0aGUgc3lzdGVtLWFw cHJvcHJpYXRlIGV4aXQKQEAgLTgzNyw2ICs4MzgsMTA4IEBAIHN1YiBwYXJzZURpZmYoJCQpCiAg ICAgcmV0dXJuIChcQGRpZmZIYXNoUmVmcywgJGxpbmUpOwogfQogCisjIFBhcnNlIHRoZSBuZXh0 IFNWTiBwcm9wZXJ0eSBmcm9tIHRoZSBnaXZlbiBmaWxlIGhhbmRsZSwgYW5kIGFkdmFuY2UgdGhl IGhhbmRsZSBzbyB0aGUgbGFzdAorIyBsaW5lIHJlYWQgaXMgdGhlIGZpcnN0IGxpbmUgYWZ0ZXIg dGhlIHByb3BlcnR5LgorIworIyBUaGlzIHN1YnJvdXRpbmUgZGllcyBpZiB0aGUgZmlyc3QgbGlu ZSBpcyBhbiBpbnZhbGlkIFNWTiBwcm9wZXJ0eQorIyAoaS5lLiBhIGxpbmUgdGhhdCBkb2VzIG5v dCBtYXRjaCAkc3ZuUHJvcGVydHlTdGFydFJlZ0V4KSBvcgorIyB0aGUgdmFsdWUgb2YgdGhlIHBy b3BlcnR5IGlzIG1pc3NpbmcuCisjCisjIEFyZ3M6CisjICAgJGZpbGVIYW5kbGU6IGFkdmFuY2Vk IHNvIHRoZSBsYXN0IGxpbmUgcmVhZCBmcm9tIHRoZSBoYW5kbGUgaXMgdGhlIGZpcnN0CisjICAg ICAgICAgICAgICAgIGxpbmUgb2YgdGhlIHByb3BlcnR5IHRvIHBhcnNlLiAgVGhpcyBzaG91bGQg YmUgYSBsaW5lCisjICAgICAgICAgICAgICAgIHRoYXQgbWF0Y2hlcyAkc3ZuUHJvcGVydHlTdGFy dFJlZ0V4LgorIyAgICRsaW5lOiB0aGUgbGluZSBsYXN0IHJlYWQgZnJvbSAkZmlsZUhhbmRsZS4K KyMKKyMgUmV0dXJucyAoJHByb3BlcnR5SGFzaFJlZiwgJGxhc3RSZWFkTGluZSk6CisjICAgJHBy b3BlcnR5SGFzaFJlZjogYSBoYXNoIHJlZmVyZW5jZSByZXByZXNlbnRpbmcgYSBTVk4gcHJvcGVy dHkuCisjICAgICBuYW1lOiB0aGUgbmFtZSBvZiB0aGUgcHJvcGVydHkuCisjICAgICB2YWx1ZTog dGhlIGxhc3QtbW9zdCB2YWx1ZSBvZiB0aGUgcHJvcGVydHkuIEZvciBpbnN0YW5jZSwgc3VwcG9z ZSB0aGUgcHJvcGVydHkgaXMgIk1vZGlmaWVkIi4KKyMgICAgICAgICAgICBUaGVuIGl0IGhhcyBi b3RoIGEgJy0nIGFuZCAnKycgcHJvcGVydHkgdmFsdWUgaW4gdGhhdCBvcmRlci4gVGhlcmVmb3Jl LCB0aGUgdmFsdWUKKyMgICAgICAgICAgICBvZiB0aGlzIGtleSBpcyB0aGUgdmFsdWUgb2YgdGhl ICcrJyBwcm9wZXJ0eSBieSBvcmRlcmluZyAoc2luY2UgaXQgaXMgdGhlIGxhc3QtbW9zdCB2YWx1 ZSkuCisjICAgICBwcm9wZXJ0eUNoYW5nZURlbHRhOiB0aGUgdmFsdWUgMSBvciAtMSBpZiB0aGUg cHJvcGVydHkgd2FzIGFkZGVkIG9yCisjICAgICAgICAgICAgICAgICAgICAgICAgIHJlbW92ZWQs IHJlc3BlY3RpdmVseS4KKyMgICAkbGFzdFJlYWRMaW5lOiB0aGUgbGluZSBsYXN0IHJlYWQgZnJv bSAkZmlsZUhhbmRsZS4KKyMKKyMgRklYTUU6IFRoaXMgbWV0aG9kIGlzIHVudXNlZCBhcyBvZiAo MDUvMTYvMjAxMCkuIFdlIHdpbGwgY2FsbCB0aGlzIGZ1bmN0aW9uCisjICAgICAgICBhcyBwYXJ0 IG9mIHBhcnNpbmcgYSBTVk4gZm9vdGVyLiBTZWUgPGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0zODg4NT4uCitzdWIgcGFyc2VTdm5Qcm9wZXJ0eSgkJCkKK3sKKyAgICBt eSAoJGZpbGVIYW5kbGUsICRsaW5lKSA9IEBfOworCisgICAgJF8gPSAkbGluZTsKKworICAgIG15 ICRwcm9wZXJ0eU5hbWU7CisgICAgbXkgJHByb3BlcnR5TmFtZVByZWZpeDsKKyAgICBpZiAoLyRz dm5Qcm9wZXJ0eVN0YXJ0UmVnRXgvKSB7CisgICAgICAgICRwcm9wZXJ0eU5hbWVQcmVmaXggPSAk MTsKKyAgICAgICAgJHByb3BlcnR5TmFtZSA9ICQyOworICAgIH0gZWxzZSB7CisgICAgICAgIGRp ZSgiRmFpbGVkIHRvIGZpbmQgU1ZOIHByb3BlcnR5OiBcIiRfXCIuIik7CisgICAgfQorCisgICAg JF8gPSA8JGZpbGVIYW5kbGU+OyAjIE5vdCBkZWZpbmVkIGlmIGVuZC1vZi1maWxlIHJlYWNoZWQu CisKKyAgICBteSAkcHJvcGVydHlWYWx1ZTsKKyAgICBteSAkcHJvcGVydHlWYWx1ZVByZWZpeDsK KyAgICB3aGlsZSAoZGVmaW5lZCgkXykpIHsKKyAgICAgICAgd2hpbGUgKGRlZmluZWQoJF8pICYm IC8kc3ZuUHJvcGVydHlWYWx1ZVN0YXJ0UmVnRXgvKSB7CisgICAgICAgICAgICAjIE5vdGUsIGEg Jy0nIHByb3BlcnR5IG1heSBiZSBmb2xsb3dlZCBieSAnKycgcHJvcGVydHkgaW4gdGhlIGNhc2Ug b2YgYSAiTW9kaWZpZWQiCisgICAgICAgICAgICAjIG9yICJOYW1lIiBwcm9wZXJ0eS4gV2Ugb25s eSBjYXJlIGFib3V0IHRoZSBhY3R1YWwgY2hhbmdlIChpLmUuIHRoZSAnKycgcHJvcGVydHkpCisg ICAgICAgICAgICAjIGluIHN1Y2ggY2lyY3Vtc3RhbmNlcy4gU28sIHdlIHRha2UgdGhlIHByb3Bl cnR5IHZhbHVlIGZvciB0aGUgcHJvcGVydHkgdG8gYmUgaXRzCisgICAgICAgICAgICAjIGxhc3Qg cGFyc2VkIHByb3BlcnR5IHZhbHVlLgorICAgICAgICAgICAgIyBGSVhNRTogV2UgbWF5IHdhbnQg dG8gY29uc2lkZXIgc3RyaWN0bHkgZW5mb3JjaW5nIGEgJy0nLCAnKycgcHJvcGVydHkgb3JkZXJp bmcgb3IKKyAgICAgICAgICAgICMgYWRkIGVycm9yIGNoZWNraW5nIHRvIHByZXZlbnQgJysnLCAn KycsIC4uLiwgJysnIGFuZCBvdGhlciBpbnZhbGlkIGNvbWJpbmF0aW9ucy4KKyAgICAgICAgICAg ICRwcm9wZXJ0eVZhbHVlUHJlZml4ID0gJDE7CisgICAgICAgICAgICAoJHByb3BlcnR5VmFsdWUs ICRfKSA9IHBhcnNlU3ZuUHJvcGVydHlWYWx1ZSgkZmlsZUhhbmRsZSwgJF8pOworICAgICAgICB9 CisKKyAgICAgICAgIyBXZSBza2lwIG92ZXIgZXZlcnl0aGluZyB0aGF0IGlzbid0IGFuIGVtcHR5 IGxpbmUgb3IgJHN2blByb3BlcnR5U3RhcnRSZWdFeC4gVGhlcmUgaXMgYW4KKyAgICAgICAgIyBl bXB0eSBsaW5lIGJlZm9yZSB0aGUgY29udGVudHMgb2YgYSBiaW5hcnkgcGF0Y2guCisgICAgICAg IGxhc3QgaWYgKCFkZWZpbmVkKCRfKSB8fCAvXltcclxuXSpcei8gfHwgLyRzdm5Qcm9wZXJ0eVN0 YXJ0UmVnRXgvKTsKKyAgICAgICAgJF8gPSA8JGZpbGVIYW5kbGU+OyAjIE5vdCBkZWZpbmVkIGlm IGVuZC1vZi1maWxlIHJlYWNoZWQuCisgICAgfQorCisgICAgaWYgKCEkcHJvcGVydHlWYWx1ZSkg eworICAgICAgICBkaWUoIkZhaWxlZCB0byBmaW5kIHRoZSBwcm9wZXJ0eSB2YWx1ZSBmb3IgdGhl IFNWTiBwcm9wZXJ0eSBcIiRwcm9wZXJ0eU5hbWVcIjogXCIkX1wiLiIpOworICAgIH0KKworICAg IG15ICRwcm9wZXJ0eUNoYW5nZURlbHRhOworICAgIGlmICgkcHJvcGVydHlWYWx1ZVByZWZpeCBl cSAnKycpIHsKKyAgICAgICAgJHByb3BlcnR5Q2hhbmdlRGVsdGEgPSAxOworICAgIH0gZWxzaWYg KCRwcm9wZXJ0eVZhbHVlUHJlZml4IGVxICctJykgeworICAgICAgICAkcHJvcGVydHlDaGFuZ2VE ZWx0YSA9IC0xOworICAgIH0gZWxzZSB7CisgICAgICAgICMgTm90IHJlYWNoZWQuCisgICAgICAg IGRpZTsKKyAgICB9CisKKyAgICBteSAkZXhwZWN0ZWRDaGFuZ2VEZWx0YTsKKyAgICBpZiAoJHBy b3BlcnR5TmFtZVByZWZpeCBlcSAiTmFtZSIpIHsKKyAgICAgICAgJGV4cGVjdGVkQ2hhbmdlRGVs dGEgPSAwOworICAgIH0gZWxzaWYgKCRwcm9wZXJ0eU5hbWVQcmVmaXggZXEgIk1vZGlmaWVkIikg eworICAgICAgICAkZXhwZWN0ZWRDaGFuZ2VEZWx0YSA9IDA7CisgICAgfSBlbHNpZiAoJHByb3Bl cnR5TmFtZVByZWZpeCBlcSAiQWRkZWQiKSB7CisgICAgICAgICRleHBlY3RlZENoYW5nZURlbHRh ID0gMTsKKyAgICB9IGVsc2lmICgkcHJvcGVydHlOYW1lUHJlZml4IGVxICJEZWxldGVkIikgewor ICAgICAgICAkZXhwZWN0ZWRDaGFuZ2VEZWx0YSA9IC0xOworICAgIH0gZWxzZSB7CisgICAgICAg ICMgTm90IHJlYWNoZWQuCisgICAgICAgIGRpZTsKKyAgICB9CisKKyAgICBpZiAoJHByb3BlcnR5 Q2hhbmdlRGVsdGEgPT0gLTEgKiAkZXhwZWN0ZWRDaGFuZ2VEZWx0YSkgeworICAgICAgICBkaWUo IlByb3BlcnR5IGNoYW5nZSBwcmVmaXggXCIkcHJvcGVydHlWYWx1ZVByZWZpeFwiIGRvZXMgbm90 IG1hdGNoICIgLgorICAgICAgICAgICAgInRoZSBwcm9wZXJ0eSBuYW1lIHByZWZpeCBcIiRwcm9w ZXJ0eU5hbWVQcmVmaXhcIi4iKTsKKyAgICB9CisKKyAgICBteSAlcHJvcGVydHlIYXNoOworICAg ICRwcm9wZXJ0eUhhc2h7bmFtZX0gPSAkcHJvcGVydHlOYW1lOworICAgICRwcm9wZXJ0eUhhc2h7 cHJvcGVydHlDaGFuZ2VEZWx0YX0gPSAkcHJvcGVydHlDaGFuZ2VEZWx0YTsKKyAgICAkcHJvcGVy dHlIYXNoe3ZhbHVlfSA9ICRwcm9wZXJ0eVZhbHVlOworICAgIHJldHVybiAoXCVwcm9wZXJ0eUhh c2gsICRfKTsKK30KKwogIyBQYXJzZSB0aGUgdmFsdWUgb2YgYW4gU1ZOIHByb3BlcnR5IGZyb20g dGhlIGdpdmVuIGZpbGUgaGFuZGxlLCBhbmQgYWR2YW5jZQogIyB0aGUgaGFuZGxlIHNvIHRoZSBs YXN0IGxpbmUgcmVhZCBpcyB0aGUgZmlyc3QgbGluZSBhZnRlciB0aGUgcHJvcGVydHkgdmFsdWUu CiAjCkBAIC04NDcsMTQgKzk1MCwxMSBAQCBzdWIgcGFyc2VEaWZmKCQkKQogIyAgICRmaWxlSGFu ZGxlOiBhZHZhbmNlZCBzbyB0aGUgbGFzdCBsaW5lIHJlYWQgZnJvbSB0aGUgaGFuZGxlIGlzIHRo ZSBmaXJzdAogIyAgICAgICAgICAgICAgICBsaW5lIG9mIHRoZSBwcm9wZXJ0eSB2YWx1ZSB0byBw YXJzZS4gIFRoaXMgc2hvdWxkIGJlIGEgbGluZQogIyAgICAgICAgICAgICAgICBiZWdpbm5pbmcg d2l0aCAiICAgKyIgb3IgIiAgIC0iLgotIyAgICRsaW5lOiB0aGUgbGluZSBsYXN0IHJlYWQgZnJv bSAkZmlsZUhhbmRsZQorIyAgICRsaW5lOiB0aGUgbGluZSBsYXN0IHJlYWQgZnJvbSAkZmlsZUhh bmRsZS4KICMKICMgUmV0dXJucyAoJHByb3BlcnR5VmFsdWUsICRsYXN0UmVhZExpbmUpOgogIyAg ICRwcm9wZXJ0eVZhbHVlOiB0aGUgdmFsdWUgb2YgdGhlIHByb3BlcnR5LgogIyAgICRsYXN0UmVh ZExpbmU6IHRoZSBsaW5lIGxhc3QgcmVhZCBmcm9tICRmaWxlSGFuZGxlLgotIwotIyBGSVhNRTog VGhpcyBtZXRob2QgaXMgdW51c2VkIGFzIG9mICgwNS8xNS8yMDEwKS4gV2Ugd2lsbCBjYWxsIHRo aXMgZnVuY3Rpb24KLSMgICAgICAgIGFzIHBhcnQgb2YgcGFyc2luZyBhIHByb3BlcnR5IGZyb20g dGhlIFNWTiBmb290ZXIuIFNlZSA8aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTM4ODg1Pi4KIHN1YiBwYXJzZVN2blByb3BlcnR5VmFsdWUoJCQpCiB7CiAgICAgbXkgKCRm aWxlSGFuZGxlLCAkbGluZSkgPSBAXzsKQEAgLTg3MSwxMiArOTcxLDE1IEBAIHN1YiBwYXJzZVN2 blByb3BlcnR5VmFsdWUoJCQpCiAgICAgfQogCiAgICAgd2hpbGUgKDwkZmlsZUhhbmRsZT4pIHsK LSAgICAgICAgaWYgKC9eJC8gfHwgLyRzdm5Qcm9wZXJ0eVZhbHVlU3RhcnRSZWdFeC8pIHsKKyAg ICAgICAgaWYgKC9eJC8gfHwgLyRzdm5Qcm9wZXJ0eVZhbHVlU3RhcnRSZWdFeC8gfHwgLyRzdm5Q cm9wZXJ0eVN0YXJ0UmVnRXgvKSB7CiAgICAgICAgICAgICAjIE5vdGUsIHdlIG1heSBlbmNvdW50 ZXIgYW4gZW1wdHkgbGluZSBiZWZvcmUgdGhlIGNvbnRlbnRzIG9mIGEgYmluYXJ5IHBhdGNoLgog ICAgICAgICAgICAgIyBBbHNvLCB3ZSBjaGVjayBmb3IgJHN2blByb3BlcnR5VmFsdWVTdGFydFJl Z0V4IGJlY2F1c2UgYSAnLScgcHJvcGVydHkgbWF5IGJlCiAgICAgICAgICAgICAjIGZvbGxvd2Vk IGJ5IGEgJysnIHByb3BlcnR5IGluIHRoZSBjYXNlIG9mIGEgIk1vZGlmaWVkIiBvciAiTmFtZSIg cHJvcGVydHkuCisgICAgICAgICAgICAjIFdlIGNoZWNrIGZvciAkc3ZuUHJvcGVydHlTdGFydFJl Z0V4IGJlY2F1c2UgaXQgaW5kaWNhdGVzIHRoZSBzdGFydCBvZiB0aGUKKyAgICAgICAgICAgICMg bmV4dCBwcm9wZXJ0eSB0byBwYXJzZS4KICAgICAgICAgICAgIGxhc3Q7CiAgICAgICAgIH0KKwog ICAgICAgICAjIFRlbXBvcmFyaWx5IHN0cmlwIG9mZiBhbnkgZW5kLW9mLWxpbmUgY2hhcmFjdGVy cy4gV2UgYWRkIHRoZSBlbmQtb2YtbGluZSBjaGFyYWN0ZXJzCiAgICAgICAgICMgZnJvbSB0aGUg cHJldmlvdXNseSBwcm9jZXNzZWQgbGluZSB0byB0aGUgc3RhcnQgb2YgdGhpcyBsaW5lIHNvIHRo YXQgdGhlIGxhc3QgbGluZQogICAgICAgICAjIG9mIHRoZSBwcm9wZXJ0eSB2YWx1ZSBkb2VzIG5v dCBlbmQgaW4gZW5kLW9mLWxpbmUgY2hhcmFjdGVycy4KSW5kZXg6IFdlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cGVybC9WQ1NVdGlsc191bml0dGVzdC9wYXJzZVN2blByb3BlcnR5LnBsCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cGVybC9WQ1NVdGlsc191bml0dGVz dC9wYXJzZVN2blByb3BlcnR5LnBsCShyZXZpc2lvbiAwKQorKysgV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0ZXN0L3BhcnNlU3ZuUHJvcGVydHkucGwJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsMjEwIEBACisjIS91c3IvYmluL3BlcmwgLXcKKyMKKyMgQ29weXJp Z2h0IChDKSBSZXNlYXJjaCBpbiBNb3Rpb24gTGltaXRlZCAyMDEwLiBBbGwgUmlnaHRzIFJlc2Vy dmVkLgorIyBDb3B5cmlnaHQgKEMpIDIwMTAgQ2hyaXMgSmVyZG9uZWsgKGNocmlzLmplcmRvbmVr QGdtYWlsLmNvbSkKKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMgbWV0OgorIwor IyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorIyBpbiB0aGUg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisj IGRpc3RyaWJ1dGlvbi4KKyMgICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBBcHBsZSBDb21wdXRl ciwgSW5jLiAoIkFwcGxlIikgbm9yIHRoZSBuYW1lcyBvZgorIyBpdHMgY29udHJpYnV0b3JzIG1h eSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCisjIGZyb20g dGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4K KyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMg QU5EIENPTlRSSUJVVE9SUworIyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklH SFQKKyMgT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisjIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWQorIyBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCisjIFVu aXQgdGVzdHMgb2YgcGFyc2VTdm5Qcm9wZXJ0eSgpLgorCit1c2Ugc3RyaWN0OwordXNlIHdhcm5p bmdzOworCit1c2UgVGVzdDo6TW9yZTsKK3VzZSBWQ1NVdGlsczsKKworbXkgQHRlc3RDYXNlSGFz aFJlZnMgPSAoCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW1wbGU6IGFk ZCBzdm46ZXhlY3V0YWJsZSIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitBZGRlZDogc3Zu OmV4ZWN1dGFibGUKKyAgICsgKgorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAg IG5hbWUgPT4gInN2bjpleGVjdXRhYmxlIiwKKyAgICBwcm9wZXJ0eUNoYW5nZURlbHRhID0+IDEs CisgICAgdmFsdWUgPT4gIioiLAorfSwKK3VuZGVmXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+ IHVuZGVmLAorfSwKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gInNpbXBsZTog ZGVsZXRlIHN2bjpleGVjdXRhYmxlIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK0RlbGV0 ZWQ6IHN2bjpleGVjdXRhYmxlCisgICAtICoKK0VORAorICAgIGV4cGVjdGVkUmV0dXJuID0+IFsK K3sKKyAgICBuYW1lID0+ICJzdm46ZXhlY3V0YWJsZSIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0 YSA9PiAtMSwKKyAgICB2YWx1ZSA9PiAiKiIsCit9LAordW5kZWZdLAorICAgIGV4cGVjdGVkTmV4 dExpbmUgPT4gdW5kZWYsCit9LAoreworICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9PiAi c2ltcGxlOiBkZWxldGUgc3ZuOmV4ZWN1dGFibGUgdXNpbmcgU1ZOIDEuNCBzeW50YXgiLAorICAg IGlucHV0VGV4dCA9PiA8PCdFTkQnLAorTmFtZTogc3ZuOmV4ZWN1dGFibGUKKyAgIC0gKgorRU5E CisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4gInN2bjpleGVjdXRhYmxl IiwKKyAgICBwcm9wZXJ0eUNoYW5nZURlbHRhID0+IC0xLAorICAgIHZhbHVlID0+ICIqIiwKK30s Cit1bmRlZl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiB1bmRlZiwKK30sCit7CisgICAgIyBO ZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW1wbGU6IGFkZCBzdm46ZXhlY3V0YWJsZSB1c2lu ZyBTVk4gMS40IHN5bnRheCIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitOYW1lOiBzdm46 ZXhlY3V0YWJsZQorICAgKyAqCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAg bmFtZSA9PiAic3ZuOmV4ZWN1dGFibGUiLAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gMSwK KyAgICB2YWx1ZSA9PiAiKiIsCit9LAordW5kZWZdLAorICAgIGV4cGVjdGVkTmV4dExpbmUgPT4g dW5kZWYsCit9LAoreworICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9PiAibXVsdGktbGlu ZSAnKycgY2hhbmdlIGFuZCBzdGFydCBvZiBiaW5hcnkgcGF0Y2giLAorICAgIGlucHV0VGV4dCA9 PiA8PCdFTkQnLAorTmFtZTogZG9jdW1lbnRhdGlvbgorICAgKyBBCitsb25nIHNlbnRlbmNlIHRo YXQgc3BhbnMKK211bHRpcGxlIGxpbmVzLgorCitRMWRUQngwQUFBQjQyaXRnNEdsZ1lKakd3TURE eU9ETXhNRHczNEdCZ1FFQUpQUURKQT09CitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7 CisgICAgbmFtZSA9PiAiZG9jdW1lbnRhdGlvbiIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9 PiAxLAorICAgIHZhbHVlID0+ICJBXG5sb25nIHNlbnRlbmNlIHRoYXQgc3BhbnNcbm11bHRpcGxl IGxpbmVzLiIsCit9LAorIlxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiAiUTFkVEJ4MEFB QUI0Mml0ZzRHbGdZSmpHd01ERHlPRE14TUR3MzRHQmdRRUFKUFFESkE9PVxuIiwKK30sCit7Cisg ICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJtdWx0aS1saW5lICcrJyBjaGFuZ2UsIGZv bGxvd2VkIGJ5IHN2bjpleGVjdXRhYmxlIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK05h bWU6IGRvY3VtZW50YXRpb24KKyAgICsgQQorbG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zCittdWx0 aXBsZSBsaW5lcy4KK05hbWU6IHN2bjpleGVjdXRhYmxlCisgICArICoKK0VORAorICAgIGV4cGVj dGVkUmV0dXJuID0+IFsKK3sKKyAgICBuYW1lID0+ICJkb2N1bWVudGF0aW9uIiwKKyAgICBwcm9w ZXJ0eUNoYW5nZURlbHRhID0+IDEsCisgICAgdmFsdWUgPT4gIkFcbmxvbmcgc2VudGVuY2UgdGhh dCBzcGFuc1xubXVsdGlwbGUgbGluZXMuIiwKK30sCisiTmFtZTogc3ZuOmV4ZWN1dGFibGVcbiJd LAorICAgIGV4cGVjdGVkTmV4dExpbmUgPT4gIiAgICsgKlxuIiwKK30sCit7CisgICAgIyBOZXcg dGVzdAorICAgIGRpZmZOYW1lID0+ICJtdWx0aS1saW5lICctJyBjaGFuZ2UgZm9sbG93ZWQgYnkg bXVsdGktbGluZSAnKycgY2hhbmdlIGZvbGxvd2VkIGJ5IHN0YXJ0IG9mIGJpbmFyeSBwYXRjaCIs CisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitNb2RpZmllZDogZG9jdW1lbnRhdGlvbgorICAg LSBBCitsb25nIHNlbnRlbmNlIHRoYXQgc3BhbnMKK211bHRpcGxlIGxpbmVzLgorICAgKyBBbm90 aGVyCitsb25nIHNlbnRlbmNlIHRoYXQgc3BhbnMKK211bHRpcGxlIGxpbmVzLgorCitRMWRUQngw QUFBQjQyaXRnNEdsZ1lKakd3TUREeU9ETXhNRHczNEdCZ1FFQUpQUURKQT09CitFTkQKKyAgICBl eHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAiZG9jdW1lbnRhdGlvbiIsCisgICAg cHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVlID0+ICJBbm90aGVyXG5sb25nIHNl bnRlbmNlIHRoYXQgc3BhbnNcbm11bHRpcGxlIGxpbmVzLiIsCit9LAorIlxuIl0sCisgICAgZXhw ZWN0ZWROZXh0TGluZSA9PiAiUTFkVEJ4MEFBQUI0Mml0ZzRHbGdZSmpHd01ERHlPRE14TUR3MzRH QmdRRUFKUFFESkE9PVxuIiwKK30sCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ ICJtdWx0aS1saW5lICctJyBjaGFuZ2UgZm9sbG93ZWQgYnkgbXVsdGktbGluZSAnKycgY2hhbmdl IGZvbGxvd2VkIGJ5IHN2bjpleGVjdXRhYmxlIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywK K01vZGlmaWVkOiBkb2N1bWVudGF0aW9uCisgICAtIEEKK2xvbmcgc2VudGVuY2UgdGhhdCBzcGFu cworbXVsdGlwbGUgbGluZXMuCisgICArIEFub3RoZXIKK2xvbmcgc2VudGVuY2UgdGhhdCBzcGFu cworbXVsdGlwbGUgbGluZXMuCitBZGRlZDogc3ZuOmV4ZWN1dGFibGUKKyAgICsgKgorRU5ECisg ICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4gImRvY3VtZW50YXRpb24iLAor ICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gMSwKKyAgICB2YWx1ZSA9PiAiQW5vdGhlclxubG9u ZyBzZW50ZW5jZSB0aGF0IHNwYW5zXG5tdWx0aXBsZSBsaW5lcy4iLAorfSwKKyJBZGRlZDogc3Zu OmV4ZWN1dGFibGVcbiJdLAorICAgIGV4cGVjdGVkTmV4dExpbmUgPT4gIiAgICsgKlxuIiwKK30s CispOworCitteSAkdGVzdENhc2VzQ291bnQgPSBAdGVzdENhc2VIYXNoUmVmczsKK3BsYW4odGVz dHMgPT4gMiAqICR0ZXN0Q2FzZXNDb3VudCk7ICMgVG90YWwgbnVtYmVyIG9mIGFzc2VydGlvbnMu CisKK2ZvcmVhY2ggbXkgJHRlc3RDYXNlIChAdGVzdENhc2VIYXNoUmVmcykgeworICAgIG15ICR0 ZXN0TmFtZVN0YXJ0ID0gInBhcnNlU3ZuUHJvcGVydHkoKTogJHRlc3RDYXNlLT57ZGlmZk5hbWV9 OiBjb21wYXJpbmciOworCisgICAgbXkgJGZpbGVIYW5kbGU7CisgICAgb3BlbigkZmlsZUhhbmRs ZSwgIjwiLCBcJHRlc3RDYXNlLT57aW5wdXRUZXh0fSk7CisgICAgbXkgJGxpbmUgPSA8JGZpbGVI YW5kbGU+OworCisgICAgbXkgQGdvdCA9IFZDU1V0aWxzOjpwYXJzZVN2blByb3BlcnR5KCRmaWxl SGFuZGxlLCAkbGluZSk7CisgICAgbXkgJGV4cGVjdGVkUmV0dXJuID0gJHRlc3RDYXNlLT57ZXhw ZWN0ZWRSZXR1cm59OworCisgICAgaXNfZGVlcGx5KFxAZ290LCAkZXhwZWN0ZWRSZXR1cm4sICIk dGVzdE5hbWVTdGFydCByZXR1cm4gdmFsdWUuIik7CisKKyAgICBteSAkZ290TmV4dExpbmUgPSA8 JGZpbGVIYW5kbGU+OworICAgIGlzKCRnb3ROZXh0TGluZSwgJHRlc3RDYXNlLT57ZXhwZWN0ZWRO ZXh0TGluZX0sICAiJHRlc3ROYW1lU3RhcnQgbmV4dCByZWFkIGxpbmUuIik7Cit9CkluZGV4OiBX ZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHBlcmwvVkNTVXRpbHNfdW5pdHRlc3QvcGFyc2VTdm5Q cm9wZXJ0eVZhbHVlLnBsCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cGVybC9WQ1NVdGlsc191bml0dGVzdC9wYXJzZVN2blByb3BlcnR5VmFsdWUucGwJKHJldmlzaW9u IDU5NTc5KQorKysgV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0 ZXN0L3BhcnNlU3ZuUHJvcGVydHlWYWx1ZS5wbAkod29ya2luZyBjb3B5KQpAQCAtNTgsNyArNTgs NyBAQCBFTkQKIH0sCiB7CiAgICAgIyBOZXcgdGVzdAotICAgIGRpZmZOYW1lID0+ICJzaW1wbGUg bXVsdGktbGluZSAnLScgY2hhbmdlIiwKKyAgICBkaWZmTmFtZSA9PiAic2luZ2xlLWxpbmUgJy0n IGNoYW5nZSBmb2xsb3dlZCBieSBlbXB0eSBsaW5lIiwKICAgICBpbnB1dFRleHQgPT4gPDwnRU5E JywKICAgIC0gKgogCkBAIC02OCw2ICs2OCwxNiBAQCBFTkQKIH0sCiB7CiAgICAgIyBOZXcgdGVz dAorICAgIGRpZmZOYW1lID0+ICJzaW5nbGUtbGluZSAnLScgY2hhbmdlIGZvbGxvd2VkIGJ5IHRo ZSBuZXh0IHByb3BlcnR5IiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKKyAgIC0gKgorRGVs ZXRlZDogc3ZuOmV4ZWN1dGFibGUKK0VORAorICAgIGV4cGVjdGVkUmV0dXJuID0+IFsiKiIsICJE ZWxldGVkOiBzdm46ZXhlY3V0YWJsZVxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiB1bmRl ZiwKK30sCit7CisgICAgIyBOZXcgdGVzdAogICAgIGRpZmZOYW1lID0+ICJtdWx0aS1saW5lICcr JyBjaGFuZ2UgYW5kIHN0YXJ0IG9mIGJpbmFyeSBwYXRjaCIsCiAgICAgaW5wdXRUZXh0ID0+IDw8 J0VORCcsCiAgICArIEEKQEAgLTkzLDYgKzEwMywxOCBAQCBFTkQKIH0sCiB7CiAgICAgIyBOZXcg dGVzdAorICAgIGRpZmZOYW1lID0+ICJtdWx0aS1saW5lICctJyBjaGFuZ2UgZm9sbG93ZWQgYnkg dGhlIG5leHQgcHJvcGVydHkiLAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorICAgLSBBCits b25nIHNlbnRlbmNlIHRoYXQgc3BhbnMKK211bHRpcGxlIGxpbmVzLgorQWRkZWQ6IHN2bjpleGVj dXRhYmxlCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbIkFcbmxvbmcgc2VudGVuY2UgdGhh dCBzcGFuc1xubXVsdGlwbGUgbGluZXMuIiwgIkFkZGVkOiBzdm46ZXhlY3V0YWJsZVxuIl0sCisg ICAgZXhwZWN0ZWROZXh0TGluZSA9PiB1bmRlZiwKK30sCit7CisgICAgIyBOZXcgdGVzdAogICAg IGRpZmZOYW1lID0+ICJtdWx0aS1saW5lICctJyBjaGFuZ2UgZm9sbG93ZWQgYnkgJysnIG11bHRp LWxpbmUgY2hhbmdlIiwKICAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKICAgIC0gQQo= 56204 2010-05-16 18:22:19 -0700 2010-05-16 18:37:33 -0700 Patch with unit tests Bug39184_3.patch text/plain 19447 dbates SW5kZXg6IFdlYktpdFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9D aGFuZ2VMb2cJKHJldmlzaW9uIDU5NTgwKQorKysgV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTAtMDUtMTYgIERhbmllbCBCYXRlcyAgPGRi YXRlc0ByaW0uY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTE4NAorCisg ICAgICAgIEFkZHMgZnVuY3Rpb24gVkNTVXRpbHM6OnBhcnNlU3ZuUHJvcGVydHkgdG8gcGFyc2Ug YW4gU1ZOIHByb3BlcnR5IHdpdGgKKyAgICAgICAgZWl0aGVyIGEgc2luZ2xlLWxpbmUgb3IgbXVs dGktbGluZSB2YWx1ZSBjaGFuZ2UuCisKKyAgICAgICAgKiBTY3JpcHRzL1ZDU1V0aWxzLnBtOgor ICAgICAgICAgIC0gQWRkZWQgZnVuY3Rpb24gcGFyc2VTdm5Qcm9wZXJ0eS4gV2Ugd2lsbCB1c2Ug dGhpcyBmdW5jdGlvbgorICAgICAgICAgIHRvd2FyZHMgcmVzb2x2aW5nIEJ1ZyAjMzg4ODUgPGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODg4NT4uCisgICAgICAgICAg LSBSZW1vdmVkIEZJWE1FIGNvbW1lbnQgYWJvdmUgZnVuY3Rpb24gcGFyc2VTdm5Qcm9wZXJ0eVZh bHVlLCBzaW5jZQorICAgICAgICAgICAgaXQgaXMgYmVpbmcgdXNlZCBieSBwYXJzZVN2blByb3Bl cnR5LgorICAgICAgICAgIC0gTW9kaWZpZWQgZnVuY3Rpb24gcGFyc2VTdm5Qcm9wZXJ0eVZhbHVl IHRvIGJyZWFrIG91dCBvZiAid2hpbGUgKDwkZmlsZUhhbmRsZT4pIgorICAgICAgICAgICAgbG9v cCB3aGVuIGl0IGVuY291bnRlcnMgdGhlIHN0YXJ0IG9mIHRoZSBuZXh0IHByb3BlcnR5IHNvIHRo YXQgaXQgY2FuIGJlCisgICAgICAgICAgICBwcm9jZXNzZWQgYnkgaXRzIGNhbGxlciwgcGFyc2VT dm5Qcm9wZXJ0eVZhbHVlLiBXZSByZWZlcmVuY2UgdGhpcyBidWxsZXQgYmVsb3cKKyAgICAgICAg ICAgIGJ5ICgqKS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHBlcmwvVkNTVXRpbHNfdW5pdHRl c3QvcGFyc2VTdm5Qcm9wZXJ0eS5wbDogQWRkZWQuCisgICAgICAgICAgLSBBZGRlZCB1bml0IHRl c3RzLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cGVybC9WQ1NVdGlsc191bml0dGVzdC9wYXJz ZVN2blByb3BlcnR5VmFsdWUucGw6CisgICAgICAgICAgLSBDaGFuZ2VkIHRoZSBuYW1lIG9mIHRo ZSB1bml0IHRlc3QgInNpbXBsZSBtdWx0aS1saW5lICctJyBjaGFuZ2UiIHRvCisgICAgICAgICAg ICAic2luZ2xlLWxpbmUgJy0nIGNoYW5nZSBmb2xsb3dlZCBieSBlbXB0eSBsaW5lIiBzaW5jZSB0 aGUgZm9ybWVyIHdhcyBhbgorICAgICAgICAgICAgaW5jb3JyZWN0IGRlc2NyaXB0aW9uIG9mIHRo aXMgdGVzdC4KKyAgICAgICAgICAtIEFkZGVkIHVuaXQgdGVzdCAic2luZ2xlLWxpbmUgJy0nIGNo YW5nZSBmb2xsb3dlZCBieSB0aGUgbmV4dCBwcm9wZXJ0eSIsIGFuZAorICAgICAgICAgICAgIm11 bHRpLWxpbmUgJy0nIGNoYW5nZSBmb2xsb3dlZCBieSB0aGUgbmV4dCBwcm9wZXJ0eSIgdG8gdGVz dCAoKikgYWJvdmUuCisKIDIwMTAtMDUtMTYgIFJvYmVydCBIb2dhbiAgPHJvYmVydEB3ZWJraXQu b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9oZGUgQ2hyaXN0aWFuc2VuLgpJ bmRleDogV2ViS2l0VG9vbHMvU2NyaXB0cy9WQ1NVdGlscy5wbQo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXRUb29scy9TY3JpcHRzL1ZDU1V0aWxzLnBtCShyZXZpc2lvbiA1OTU3OSkKKysrIFdlYktpdFRv b2xzL1NjcmlwdHMvVkNTVXRpbHMucG0JKHdvcmtpbmcgY29weSkKQEAgLTkwLDYgKzkwLDcgQEAg bXkgJGNoYW5nZUxvZ1RpbWVab25lID0gIlBTVDhQRFQiOwogCiBteSAkZ2l0RGlmZlN0YXJ0UmVn RXggPSBxciNeZGlmZiAtLWdpdCAoXHcvKT8oLispIChcdy8pPyhbXlxyXG5dKykjOwogbXkgJHN2 bkRpZmZTdGFydFJlZ0V4ID0gcXIjXkluZGV4OiAoW15cclxuXSspIzsKK215ICRzdm5Qcm9wZXJ0 eVN0YXJ0UmVnRXggPSBxciNeKE1vZGlmaWVkfE5hbWV8QWRkZWR8RGVsZXRlZCk6IChbXlxyXG5d KykjOyAjICQyIGlzIHRoZSBuYW1lIG9mIHRoZSBwcm9wZXJ0eS4KIG15ICRzdm5Qcm9wZXJ0eVZh bHVlU3RhcnRSZWdFeCA9IHFyI14gICAoXCt8LSkgKFteXHJcbl0rKSM7ICMgJDIgaXMgdGhlIHN0 YXJ0IG9mIHRoZSBwcm9wZXJ0eSdzIHZhbHVlICh3aGljaCBtYXkgc3BhbiBtdWx0aXBsZSBsaW5l cykuCiAKICMgVGhpcyBtZXRob2QgaXMgZm9yIHBvcnRhYmlsaXR5LiBSZXR1cm4gdGhlIHN5c3Rl bS1hcHByb3ByaWF0ZSBleGl0CkBAIC04MzcsNiArODM4LDExMSBAQCBzdWIgcGFyc2VEaWZmKCQk KQogICAgIHJldHVybiAoXEBkaWZmSGFzaFJlZnMsICRsaW5lKTsKIH0KIAorIyBQYXJzZSB0aGUg bmV4dCBTVk4gcHJvcGVydHkgZnJvbSB0aGUgZ2l2ZW4gZmlsZSBoYW5kbGUsIGFuZCBhZHZhbmNl IHRoZSBoYW5kbGUgc28gdGhlIGxhc3QKKyMgbGluZSByZWFkIGlzIHRoZSBmaXJzdCBsaW5lIGFm dGVyIHRoZSBwcm9wZXJ0eS4KKyMKKyMgVGhpcyBzdWJyb3V0aW5lIGRpZXMgaWYgdGhlIGZpcnN0 IGxpbmUgaXMgbm90IGEgdmFsaWQgc3RhcnQgb2YgYW4gU1ZOIHByb3BlcnR5LAorIyBvciB0aGUg cHJvcGVydHkgaXMgbWlzc2luZyBhIHZhbHVlLCBvciB0aGUgcHJvcGVydHkgY2hhbmdlIHR5cGUg KGUuZy4gIkFkZGVkIikKKyMgZG9lcyBub3QgY29ycmVzcG9uZCB0byB0aGUgcHJvcGVydHkgdmFs dWUgdHlwZSAoZS5nLiAiKyIpLgorIworIyBBcmdzOgorIyAgICRmaWxlSGFuZGxlOiBhZHZhbmNl ZCBzbyB0aGUgbGFzdCBsaW5lIHJlYWQgZnJvbSB0aGUgaGFuZGxlIGlzIHRoZSBmaXJzdAorIyAg ICAgICAgICAgICAgICBsaW5lIG9mIHRoZSBwcm9wZXJ0eSB0byBwYXJzZS4gIFRoaXMgc2hvdWxk IGJlIGEgbGluZQorIyAgICAgICAgICAgICAgICB0aGF0IG1hdGNoZXMgJHN2blByb3BlcnR5U3Rh cnRSZWdFeC4KKyMgICAkbGluZTogdGhlIGxpbmUgbGFzdCByZWFkIGZyb20gJGZpbGVIYW5kbGUu CisjCisjIFJldHVybnMgKCRwcm9wZXJ0eUhhc2hSZWYsICRsYXN0UmVhZExpbmUpOgorIyAgICRw cm9wZXJ0eUhhc2hSZWY6IGEgaGFzaCByZWZlcmVuY2UgcmVwcmVzZW50aW5nIGEgU1ZOIHByb3Bl cnR5LgorIyAgICAgbmFtZTogdGhlIG5hbWUgb2YgdGhlIHByb3BlcnR5LgorIyAgICAgdmFsdWU6 IHRoZSBsYXN0IHByb3BlcnR5IHZhbHVlLiAgRm9yIGluc3RhbmNlLCBzdXBwb3NlIHRoZSBwcm9w ZXJ0eSBpcyAiTW9kaWZpZWQiLgorIyAgICAgICAgICAgIFRoZW4gaXQgaGFzIGJvdGggYSAnLScg YW5kICcrJyBwcm9wZXJ0eSB2YWx1ZSBpbiB0aGF0IG9yZGVyLiAgVGhlcmVmb3JlLAorIyAgICAg ICAgICAgIHRoZSB2YWx1ZSBvZiB0aGlzIGtleSBpcyB0aGUgdmFsdWUgb2YgdGhlICcrJyBwcm9w ZXJ0eSBieSBvcmRlcmluZyAoc2luY2UKKyMgICAgICAgICAgICBpdCBpcyB0aGUgbGFzdC1tb3N0 IHZhbHVlKS4KKyMgICAgIHByb3BlcnR5Q2hhbmdlRGVsdGE6IHRoZSB2YWx1ZSAxIG9yIC0xIGlm IHRoZSBwcm9wZXJ0eSB3YXMgYWRkZWQgb3IKKyMgICAgICAgICAgICAgICAgICAgICAgICAgIHJl bW92ZWQsIHJlc3BlY3RpdmVseS4KKyMgICAkbGFzdFJlYWRMaW5lOiB0aGUgbGluZSBsYXN0IHJl YWQgZnJvbSAkZmlsZUhhbmRsZS4KKyMKKyMgRklYTUU6IFRoaXMgbWV0aG9kIGlzIHVudXNlZCBh cyBvZiAoMDUvMTYvMjAxMCkuICBXZSB3aWxsIGNhbGwgdGhpcyBmdW5jdGlvbgorIyAgICAgICAg YXMgcGFydCBvZiBwYXJzaW5nIGEgU1ZOIGZvb3Rlci4gIFNlZSA8aHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTM4ODg1Pi4KK3N1YiBwYXJzZVN2blByb3BlcnR5KCQkKQor eworICAgIG15ICgkZmlsZUhhbmRsZSwgJGxpbmUpID0gQF87CisKKyAgICAkXyA9ICRsaW5lOwor CisgICAgbXkgJHByb3BlcnR5TmFtZTsKKyAgICBteSAkcHJvcGVydHlDaGFuZ2VUeXBlOworICAg IGlmICgvJHN2blByb3BlcnR5U3RhcnRSZWdFeC8pIHsKKyAgICAgICAgJHByb3BlcnR5Q2hhbmdl VHlwZSA9ICQxOworICAgICAgICAkcHJvcGVydHlOYW1lID0gJDI7CisgICAgfSBlbHNlIHsKKyAg ICAgICAgZGllKCJGYWlsZWQgdG8gZmluZCBTVk4gcHJvcGVydHk6IFwiJF9cIi4iKTsKKyAgICB9 CisKKyAgICAkXyA9IDwkZmlsZUhhbmRsZT47ICMgTm90IGRlZmluZWQgaWYgZW5kLW9mLWZpbGUg cmVhY2hlZC4KKworICAgICMgVGhlICJzdm4gZGlmZiIgY29tbWFuZCBuZWl0aGVyIGluc2VydHMg bmV3IGxpbmUgY2hhcmFjdGVycyBiZXR3ZWVuIHByb3BlcnR5IHZhbHVlcworICAgICMgbm9yIGJl dHdlZW4gc3VjY2Vzc2l2ZSBwcm9wZXJ0aWVzLgorICAgICMKKyAgICAjIEZJWE1FOiBXZSBkbyBu b3Qgc3VwcG9ydCBwcm9wZXJ0eSB2YWx1ZXMgdGhhdCBjb250YWluIHRhaWxpbmcgbmV3IGxpbmUg Y2hhcmFjdGVycworICAgICMgICAgICAgIGFzIGl0IGlzIGRpZmZpY3VsdCB0byBkaXNhbWJpZ3Vh dGUgdGhlc2UgdHJhaWxpbmcgbmV3IGxpbmVzIGZyb20gdGhlIGVtcHR5CisgICAgIyAgICAgICAg bGluZSB0aGF0IHByZWNlZWRzIHRoZSBjb250ZW50cyBvZiBhIGJpbmFyeSBwYXRjaC4KKyAgICBt eSAkcHJvcGVydHlWYWx1ZTsKKyAgICBteSAkcHJvcGVydHlWYWx1ZVR5cGU7CisgICAgd2hpbGUg KGRlZmluZWQoJF8pICYmIC8kc3ZuUHJvcGVydHlWYWx1ZVN0YXJ0UmVnRXgvKSB7CisgICAgICAg ICMgTm90ZSwgYSAnLScgcHJvcGVydHkgbWF5IGJlIGZvbGxvd2VkIGJ5ICcrJyBwcm9wZXJ0eSBp biB0aGUgY2FzZSBvZiBhICJNb2RpZmllZCIKKyAgICAgICAgIyBvciAiTmFtZSIgcHJvcGVydHku ICBXZSBvbmx5IGNhcmUgYWJvdXQgdGhlIGVuZGluZyB2YWx1ZSAoaS5lLiB0aGUgJysnIHByb3Bl cnR5KQorICAgICAgICAjIGluIHN1Y2ggY2lyY3Vtc3RhbmNlcy4gIFNvLCB3ZSB0YWtlIHRoZSBw cm9wZXJ0eSB2YWx1ZSBmb3IgdGhlIHByb3BlcnR5IHRvIGJlIGl0cworICAgICAgICAjIGxhc3Qg cGFyc2VkIHByb3BlcnR5IHZhbHVlLgorICAgICAgICAjCisgICAgICAgICMgRklYTUU6IFdlIG1h eSB3YW50IHRvIGNvbnNpZGVyIHN0cmljdGx5IGVuZm9yY2luZyBhICctJywgJysnIHByb3BlcnR5 IG9yZGVyaW5nIG9yCisgICAgICAgICMgICAgICAgIGFkZCBlcnJvciBjaGVja2luZyB0byBwcmV2 ZW50ICcrJywgJysnLCAuLi4sICcrJyBhbmQgb3RoZXIgaW52YWxpZCBjb21iaW5hdGlvbnMuCisg ICAgICAgICRwcm9wZXJ0eVZhbHVlVHlwZSA9ICQxOworICAgICAgICAoJHByb3BlcnR5VmFsdWUs ICRfKSA9IHBhcnNlU3ZuUHJvcGVydHlWYWx1ZSgkZmlsZUhhbmRsZSwgJF8pOworICAgIH0KKwor ICAgIGlmICghJHByb3BlcnR5VmFsdWUpIHsKKyAgICAgICAgZGllKCJGYWlsZWQgdG8gZmluZCB0 aGUgcHJvcGVydHkgdmFsdWUgZm9yIHRoZSBTVk4gcHJvcGVydHkgXCIkcHJvcGVydHlOYW1lXCI6 IFwiJF9cIi4iKTsKKyAgICB9CisKKyAgICBteSAkcHJvcGVydHlDaGFuZ2VEZWx0YTsKKyAgICBp ZiAoJHByb3BlcnR5VmFsdWVUeXBlIGVxICcrJykgeworICAgICAgICAkcHJvcGVydHlDaGFuZ2VE ZWx0YSA9IDE7CisgICAgfSBlbHNpZiAoJHByb3BlcnR5VmFsdWVUeXBlIGVxICctJykgeworICAg ICAgICAkcHJvcGVydHlDaGFuZ2VEZWx0YSA9IC0xOworICAgIH0gZWxzZSB7CisgICAgICAgICMg Tm90IHJlYWNoZWQuCisgICAgICAgIGRpZTsKKyAgICB9CisKKyAgICAjIFdlIHBlcmZvcm0gYSBz aW1wbGUgdmFsaWRhdGlvbiB0aGF0IGFuICJBZGRlZCIgb3IgIkRlbGV0ZWQiIHByb3BlcnR5Cisg ICAgIyBjaGFuZ2UgdHlwZSBjb3JyZXNwb25kcyB3aXRoIGEgIisiIGFuZCAiLSIgdmFsdWUgdHlw ZSwgcmVzcGVjdGl2ZWx5LgorICAgIG15ICRleHBlY3RlZENoYW5nZURlbHRhOworICAgIGlmICgk cHJvcGVydHlDaGFuZ2VUeXBlIGVxICJOYW1lIikgeworICAgICAgICAkZXhwZWN0ZWRDaGFuZ2VE ZWx0YSA9IDA7CisgICAgfSBlbHNpZiAoJHByb3BlcnR5Q2hhbmdlVHlwZSBlcSAiTW9kaWZpZWQi KSB7CisgICAgICAgICRleHBlY3RlZENoYW5nZURlbHRhID0gMDsKKyAgICB9IGVsc2lmICgkcHJv cGVydHlDaGFuZ2VUeXBlIGVxICJBZGRlZCIpIHsKKyAgICAgICAgJGV4cGVjdGVkQ2hhbmdlRGVs dGEgPSAxOworICAgIH0gZWxzaWYgKCRwcm9wZXJ0eUNoYW5nZVR5cGUgZXEgIkRlbGV0ZWQiKSB7 CisgICAgICAgICRleHBlY3RlZENoYW5nZURlbHRhID0gLTE7CisgICAgfSBlbHNlIHsKKyAgICAg ICAgIyBOb3QgcmVhY2hlZC4KKyAgICAgICAgZGllOworICAgIH0KKworICAgIGlmICgkcHJvcGVy dHlDaGFuZ2VEZWx0YSA9PSAtMSAqICRleHBlY3RlZENoYW5nZURlbHRhKSB7CisgICAgICAgIGRp ZSgiVGhlIGZpbmFsIHByb3BlcnR5IHZhbHVlIHR5cGUgZm91bmQgXCIkcHJvcGVydHlWYWx1ZVR5 cGVcIiBkb2VzIG5vdCAiIC4KKyAgICAgICAgICAgICJjb3JyZXNwb25kIHRvIHRoZSBwcm9wZXJ0 eSBjaGFuZ2UgdHlwZSBmb3VuZCBcIiRwcm9wZXJ0eUNoYW5nZVR5cGVcIi4iKTsKKyAgICB9CisK KyAgICBteSAlcHJvcGVydHlIYXNoOworICAgICRwcm9wZXJ0eUhhc2h7bmFtZX0gPSAkcHJvcGVy dHlOYW1lOworICAgICRwcm9wZXJ0eUhhc2h7cHJvcGVydHlDaGFuZ2VEZWx0YX0gPSAkcHJvcGVy dHlDaGFuZ2VEZWx0YTsKKyAgICAkcHJvcGVydHlIYXNoe3ZhbHVlfSA9ICRwcm9wZXJ0eVZhbHVl OworICAgIHJldHVybiAoXCVwcm9wZXJ0eUhhc2gsICRfKTsKK30KKwogIyBQYXJzZSB0aGUgdmFs dWUgb2YgYW4gU1ZOIHByb3BlcnR5IGZyb20gdGhlIGdpdmVuIGZpbGUgaGFuZGxlLCBhbmQgYWR2 YW5jZQogIyB0aGUgaGFuZGxlIHNvIHRoZSBsYXN0IGxpbmUgcmVhZCBpcyB0aGUgZmlyc3QgbGlu ZSBhZnRlciB0aGUgcHJvcGVydHkgdmFsdWUuCiAjCkBAIC04NDcsMTQgKzk1MywxMSBAQCBzdWIg cGFyc2VEaWZmKCQkKQogIyAgICRmaWxlSGFuZGxlOiBhZHZhbmNlZCBzbyB0aGUgbGFzdCBsaW5l IHJlYWQgZnJvbSB0aGUgaGFuZGxlIGlzIHRoZSBmaXJzdAogIyAgICAgICAgICAgICAgICBsaW5l IG9mIHRoZSBwcm9wZXJ0eSB2YWx1ZSB0byBwYXJzZS4gIFRoaXMgc2hvdWxkIGJlIGEgbGluZQog IyAgICAgICAgICAgICAgICBiZWdpbm5pbmcgd2l0aCAiICAgKyIgb3IgIiAgIC0iLgotIyAgICRs aW5lOiB0aGUgbGluZSBsYXN0IHJlYWQgZnJvbSAkZmlsZUhhbmRsZQorIyAgICRsaW5lOiB0aGUg bGluZSBsYXN0IHJlYWQgZnJvbSAkZmlsZUhhbmRsZS4KICMKICMgUmV0dXJucyAoJHByb3BlcnR5 VmFsdWUsICRsYXN0UmVhZExpbmUpOgogIyAgICRwcm9wZXJ0eVZhbHVlOiB0aGUgdmFsdWUgb2Yg dGhlIHByb3BlcnR5LgogIyAgICRsYXN0UmVhZExpbmU6IHRoZSBsaW5lIGxhc3QgcmVhZCBmcm9t ICRmaWxlSGFuZGxlLgotIwotIyBGSVhNRTogVGhpcyBtZXRob2QgaXMgdW51c2VkIGFzIG9mICgw NS8xNS8yMDEwKS4gV2Ugd2lsbCBjYWxsIHRoaXMgZnVuY3Rpb24KLSMgICAgICAgIGFzIHBhcnQg b2YgcGFyc2luZyBhIHByb3BlcnR5IGZyb20gdGhlIFNWTiBmb290ZXIuIFNlZSA8aHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4ODg1Pi4KIHN1YiBwYXJzZVN2blByb3Bl cnR5VmFsdWUoJCQpCiB7CiAgICAgbXkgKCRmaWxlSGFuZGxlLCAkbGluZSkgPSBAXzsKQEAgLTg3 MSwxMiArOTc0LDE1IEBAIHN1YiBwYXJzZVN2blByb3BlcnR5VmFsdWUoJCQpCiAgICAgfQogCiAg ICAgd2hpbGUgKDwkZmlsZUhhbmRsZT4pIHsKLSAgICAgICAgaWYgKC9eJC8gfHwgLyRzdm5Qcm9w ZXJ0eVZhbHVlU3RhcnRSZWdFeC8pIHsKKyAgICAgICAgaWYgKC9eJC8gfHwgLyRzdm5Qcm9wZXJ0 eVZhbHVlU3RhcnRSZWdFeC8gfHwgLyRzdm5Qcm9wZXJ0eVN0YXJ0UmVnRXgvKSB7CiAgICAgICAg ICAgICAjIE5vdGUsIHdlIG1heSBlbmNvdW50ZXIgYW4gZW1wdHkgbGluZSBiZWZvcmUgdGhlIGNv bnRlbnRzIG9mIGEgYmluYXJ5IHBhdGNoLgogICAgICAgICAgICAgIyBBbHNvLCB3ZSBjaGVjayBm b3IgJHN2blByb3BlcnR5VmFsdWVTdGFydFJlZ0V4IGJlY2F1c2UgYSAnLScgcHJvcGVydHkgbWF5 IGJlCiAgICAgICAgICAgICAjIGZvbGxvd2VkIGJ5IGEgJysnIHByb3BlcnR5IGluIHRoZSBjYXNl IG9mIGEgIk1vZGlmaWVkIiBvciAiTmFtZSIgcHJvcGVydHkuCisgICAgICAgICAgICAjIFdlIGNo ZWNrIGZvciAkc3ZuUHJvcGVydHlTdGFydFJlZ0V4IGJlY2F1c2UgaXQgaW5kaWNhdGVzIHRoZSBz dGFydCBvZiB0aGUKKyAgICAgICAgICAgICMgbmV4dCBwcm9wZXJ0eSB0byBwYXJzZS4KICAgICAg ICAgICAgIGxhc3Q7CiAgICAgICAgIH0KKwogICAgICAgICAjIFRlbXBvcmFyaWx5IHN0cmlwIG9m ZiBhbnkgZW5kLW9mLWxpbmUgY2hhcmFjdGVycy4gV2UgYWRkIHRoZSBlbmQtb2YtbGluZSBjaGFy YWN0ZXJzCiAgICAgICAgICMgZnJvbSB0aGUgcHJldmlvdXNseSBwcm9jZXNzZWQgbGluZSB0byB0 aGUgc3RhcnQgb2YgdGhpcyBsaW5lIHNvIHRoYXQgdGhlIGxhc3QgbGluZQogICAgICAgICAjIG9m IHRoZSBwcm9wZXJ0eSB2YWx1ZSBkb2VzIG5vdCBlbmQgaW4gZW5kLW9mLWxpbmUgY2hhcmFjdGVy cy4KSW5kZXg6IFdlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cGVybC9WQ1NVdGlsc191bml0dGVz dC9wYXJzZVN2blByb3BlcnR5LnBsCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cGVybC9WQ1NVdGlsc191bml0dGVzdC9wYXJzZVN2blByb3BlcnR5LnBsCShyZXZpc2lv biAwKQorKysgV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0ZXN0 L3BhcnNlU3ZuUHJvcGVydHkucGwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzQwIEBACisjIS91 c3IvYmluL3BlcmwgLXcKKyMKKyMgQ29weXJpZ2h0IChDKSBSZXNlYXJjaCBpbiBNb3Rpb24gTGlt aXRlZCAyMDEwLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorIyBDb3B5cmlnaHQgKEMpIDIwMTAgQ2hy aXMgSmVyZG9uZWsgKGNocmlzLmplcmRvbmVrQGdtYWlsLmNvbSkKKyMKKyMgUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisj IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucyBhcmUKKyMgbWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjICAgICAq IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUK KyMgY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lcgorIyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMgICAgICogTmVpdGhl ciB0aGUgbmFtZSBvZiBBcHBsZSBDb21wdXRlciwgSW5jLiAoIkFwcGxlIikgbm9yIHRoZSBuYW1l cyBvZgorIyBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 ZSBwcm9kdWN0cyBkZXJpdmVkCisjIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmlj IHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworIyAiQVMgSVMiIEFO RCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAor IyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IKKyMgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyMgT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQRUNJQUws IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QK KyMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsCisjIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorIyBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgorCisjIFVuaXQgdGVzdHMgb2YgcGFyc2VTdm5Qcm9wZXJ0eSgp LgorCit1c2Ugc3RyaWN0OwordXNlIHdhcm5pbmdzOworCit1c2UgVGVzdDo6TW9yZTsKK3VzZSBW Q1NVdGlsczsKKworbXkgQHRlc3RDYXNlSGFzaFJlZnMgPSAoCisjIyMjCisjIFNpbXBsZSB0ZXN0 IGNhc2VzCisjIworeworICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9PiAic2ltcGxlOiBh ZGQgc3ZuOmV4ZWN1dGFibGUiLAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorQWRkZWQ6IHN2 bjpleGVjdXRhYmxlCisgICArICoKK0VORAorICAgIGV4cGVjdGVkUmV0dXJuID0+IFsKK3sKKyAg ICBuYW1lID0+ICJzdm46ZXhlY3V0YWJsZSIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAx LAorICAgIHZhbHVlID0+ICIqIiwKK30sCit1bmRlZl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9 PiB1bmRlZiwKK30sCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW1wbGU6 IGRlbGV0ZSBzdm46ZXhlY3V0YWJsZSIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitEZWxl dGVkOiBzdm46ZXhlY3V0YWJsZQorICAgLSAqCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBb Cit7CisgICAgbmFtZSA9PiAic3ZuOmV4ZWN1dGFibGUiLAorICAgIHByb3BlcnR5Q2hhbmdlRGVs dGEgPT4gLTEsCisgICAgdmFsdWUgPT4gIioiLAorfSwKK3VuZGVmXSwKKyAgICBleHBlY3RlZE5l eHRMaW5lID0+IHVuZGVmLAorfSwKKyMjIyMKKyMgVXNpbmcgU1ZOIDEuNCBzeW50YXgKKyMjCit7 CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW1wbGU6IGRlbGV0ZSBzdm46ZXhl Y3V0YWJsZSB1c2luZyBTVk4gMS40IHN5bnRheCIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcs CitOYW1lOiBzdm46ZXhlY3V0YWJsZQorICAgLSAqCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9 PiBbCit7CisgICAgbmFtZSA9PiAic3ZuOmV4ZWN1dGFibGUiLAorICAgIHByb3BlcnR5Q2hhbmdl RGVsdGEgPT4gLTEsCisgICAgdmFsdWUgPT4gIioiLAorfSwKK3VuZGVmXSwKKyAgICBleHBlY3Rl ZE5leHRMaW5lID0+IHVuZGVmLAorfSwKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUg PT4gInNpbXBsZTogYWRkIHN2bjpleGVjdXRhYmxlIHVzaW5nIFNWTiAxLjQgc3ludGF4IiwKKyAg ICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK05hbWU6IHN2bjpleGVjdXRhYmxlCisgICArICoKK0VO RAorICAgIGV4cGVjdGVkUmV0dXJuID0+IFsKK3sKKyAgICBuYW1lID0+ICJzdm46ZXhlY3V0YWJs ZSIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVlID0+ICIqIiwKK30s Cit1bmRlZl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiB1bmRlZiwKK30sCisjIyMjCisjIFBy b3BlcnR5IHZhbHVlIGZvbGxvd2VkIGJ5IGVtcHR5IGxpbmUgYW5kIHN0YXJ0IG9mIGJpbmFyeSBw YXRjaAorIyMKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gImFkZCBzdm46ZXhl Y3V0YWJsZSwgZm9sbG93ZWQgYnkgZW1wdHkgbGluZSBhbmQgc3RhcnQgb2YgYmluYXJ5IHBhdGNo IiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK0FkZGVkOiBzdm46ZXhlY3V0YWJsZQorICAg KyAqCisKK1ExZFRCeDBBQUFCNDJpdGc0R2xnWUpqR3dNRER5T0RNeE1EdzM0R0JnUUVBSlBRREpB PT0KK0VORAorICAgIGV4cGVjdGVkUmV0dXJuID0+IFsKK3sKKyAgICBuYW1lID0+ICJzdm46ZXhl Y3V0YWJsZSIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVlID0+ICIq IiwKK30sCisiXG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+ICJRMWRUQngwQUFBQjQyaXRn NEdsZ1lKakd3TUREeU9ETXhNRHczNEdCZ1FFQUpQUURKQT09XG4iLAorfSwKK3sKKyAgICAjIE5l dyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gIm11bHRpLWxpbmUgJysnIGNoYW5nZSwgZm9sbG93ZWQg YnkgZW1wdHkgbGluZSBhbmQgc3RhcnQgb2YgYmluYXJ5IHBhdGNoIiwKKyAgICBpbnB1dFRleHQg PT4gPDwnRU5EJywKK05hbWU6IGRvY3VtZW50YXRpb24KKyAgICsgQQorbG9uZyBzZW50ZW5jZSB0 aGF0IHNwYW5zCittdWx0aXBsZSBsaW5lcy4KKworUTFkVEJ4MEFBQUI0Mml0ZzRHbGdZSmpHd01E RHlPRE14TUR3MzRHQmdRRUFKUFFESkE9PQorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWwor eworICAgIG5hbWUgPT4gImRvY3VtZW50YXRpb24iLAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEg PT4gMSwKKyAgICB2YWx1ZSA9PiAiQVxubG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zXG5tdWx0aXBs ZSBsaW5lcy4iLAorfSwKKyJcbiJdLAorICAgIGV4cGVjdGVkTmV4dExpbmUgPT4gIlExZFRCeDBB QUFCNDJpdGc0R2xnWUpqR3dNRER5T0RNeE1EdzM0R0JnUUVBSlBRREpBPT1cbiIsCit9LAorewor ICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9PiAibXVsdGktbGluZSAnLScgY2hhbmdlLCBm b2xsb3dlZCBieSBtdWx0aS1saW5lICcrJyBjaGFuZ2UsIGVtcHR5IGxpbmUsIGFuZCBzdGFydCBv ZiBiaW5hcnkgcGF0Y2giLAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorTW9kaWZpZWQ6IGRv Y3VtZW50YXRpb24KKyAgIC0gQQorbG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zCittdWx0aXBsZSBs aW5lcy4KKyAgICsgQW5vdGhlcgorbG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zCittdWx0aXBsZSBs aW5lcy4KKworUTFkVEJ4MEFBQUI0Mml0ZzRHbGdZSmpHd01ERHlPRE14TUR3MzRHQmdRRUFKUFFE SkE9PQorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4gImRvY3Vt ZW50YXRpb24iLAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gMSwKKyAgICB2YWx1ZSA9PiAi QW5vdGhlclxubG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zXG5tdWx0aXBsZSBsaW5lcy4iLAorfSwK KyJcbiJdLAorICAgIGV4cGVjdGVkTmV4dExpbmUgPT4gIlExZFRCeDBBQUFCNDJpdGc0R2xnWUpq R3dNRER5T0RNeE1EdzM0R0JnUUVBSlBRREpBPT1cbiIsCit9LAorIyMjIworIyBTdWNjZXNzaXZl IHByb3BlcnRpZXMKKyMjCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW5n bGUtbGluZSAnKycgY2hhbmdlIGZvbGxvd2VkIGJ5IGN1c3RvbSBwcm9wZXJ0eSB3aXRoIHNpbmds ZS1saW5lICcrJyBjaGFuZ2UiLAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorQWRkZWQ6IHN2 bjpleGVjdXRhYmxlCisgICArICoKK0FkZGVkOiBkb2N1bWVudGF0aW9uCisgICArIEEgc2VudGVu Y2UuCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAic3ZuOmV4 ZWN1dGFibGUiLAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gMSwKKyAgICB2YWx1ZSA9PiAi KiIsCit9LAorIkFkZGVkOiBkb2N1bWVudGF0aW9uXG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5l ID0+ICIgICArIEEgc2VudGVuY2UuXG4iLAorfSwKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlm Zk5hbWUgPT4gIm11bHRpLWxpbmUgJysnIGNoYW5nZSwgZm9sbG93ZWQgYnkgc3ZuOmV4ZWN1dGFi bGUiLAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorTmFtZTogZG9jdW1lbnRhdGlvbgorICAg KyBBCitsb25nIHNlbnRlbmNlIHRoYXQgc3BhbnMKK211bHRpcGxlIGxpbmVzLgorTmFtZTogc3Zu OmV4ZWN1dGFibGUKKyAgICsgKgorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAg IG5hbWUgPT4gImRvY3VtZW50YXRpb24iLAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gMSwK KyAgICB2YWx1ZSA9PiAiQVxubG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zXG5tdWx0aXBsZSBsaW5l cy4iLAorfSwKKyJOYW1lOiBzdm46ZXhlY3V0YWJsZVxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGlu ZSA9PiAiICAgKyAqXG4iLAorfSwKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4g Im11bHRpLWxpbmUgJy0nIGNoYW5nZSwgZm9sbG93ZWQgYnkgbXVsdGktbGluZSAnKycgY2hhbmdl IGFuZCBhZGQgc3ZuOmV4ZWN1dGFibGUiLAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorTW9k aWZpZWQ6IGRvY3VtZW50YXRpb24KKyAgIC0gQQorbG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zCitt dWx0aXBsZSBsaW5lcy4KKyAgICsgQW5vdGhlcgorbG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zCitt dWx0aXBsZSBsaW5lcy4KK0FkZGVkOiBzdm46ZXhlY3V0YWJsZQorICAgKyAqCitFTkQKKyAgICBl eHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAiZG9jdW1lbnRhdGlvbiIsCisgICAg cHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVlID0+ICJBbm90aGVyXG5sb25nIHNl bnRlbmNlIHRoYXQgc3BhbnNcbm11bHRpcGxlIGxpbmVzLiIsCit9LAorIkFkZGVkOiBzdm46ZXhl Y3V0YWJsZVxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiAiICAgKyAqXG4iLAorfSwKKyMj IyMKKyMgUHJvcGVydHkgdmFsdWVzIHdpdGggdHJhaWxpbmcgbmV3IGxpbmVzLgorIyMKKyMgRklY TUU6IFdlIGRvIG5vdCBzdXBwb3J0IHByb3BlcnR5IHZhbHVlcyB3aXRoIHRyYWlsaW5nIG5ldyBs aW5lcywgc2luY2UgaXQgaXMgZGlmZmljdWx0IHRvCisjICAgICAgICBkaXNhbWJpZ3VhdGUgdGhl bSBmcm9tIHRoZSBlbXB0eSBsaW5lIHRoYXQgcHJlY2VlZHMgdGhlIGNvbnRlbnRzIG9mIGEgYmlu YXJ5IHBhdGNoIGFzCisjICAgICAgICBpbiB0aGUgdGVzdCBjYXNlIChhYm92ZSk6ICJtdWx0aS1s aW5lICcrJyBjaGFuZ2UsIGZvbGxvd2VkIGJ5IGVtcHR5IGxpbmUgYW5kIHN0YXJ0IG9mIGJpbmFy eSBwYXRjaCIuCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW5nbGUtbGlu ZSAnKycgd2l0aCB0cmFpbGluZyBuZXcgbGluZSIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcs CitBZGRlZDogZG9jdW1lbnRhdGlvbgorICAgKyBBIHNlbnRlbmNlLgorCitFTkQKKyAgICBleHBl Y3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAiZG9jdW1lbnRhdGlvbiIsCisgICAgcHJv cGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVlID0+ICJBIHNlbnRlbmNlLiIsCit9LAor IlxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiB1bmRlZiwKK30sCit7CisgICAgIyBOZXcg dGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW5nbGUtbGluZSAnKycgd2l0aCB0cmFpbGluZyBuZXcg bGluZSwgZm9sbG93ZWQgYnkgZW1wdHkgbGluZSBhbmQgc3RhcnQgb2YgYmluYXJ5IHBhdGNoIiwK KyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK0FkZGVkOiBkb2N1bWVudGF0aW9uCisgICArIEEg c2VudGVuY2UuCisKKworUTFkVEJ4MEFBQUI0Mml0ZzRHbGdZSmpHd01ERHlPRE14TUR3MzRHQmdR RUFKUFFESkE9PQorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4g ImRvY3VtZW50YXRpb24iLAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gMSwKKyAgICB2YWx1 ZSA9PiAiQSBzZW50ZW5jZS4iLAorfSwKKyJcbiJdLAorICAgIGV4cGVjdGVkTmV4dExpbmUgPT4g IlxuIiwKK30sCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW5nbGUtbGlu ZSAnLScgY2hhbmdlIHdpdGggdHJhaWxpbmcgbmV3IGxpbmUsIGFuZCBzaW5nbGUtbGluZSAnKycg Y2hhbmdlIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK01vZGlmaWVkOiBkb2N1bWVudGF0 aW9uCisgICAtIEEgbG9uZyBzZW50ZW5jZS4KKworICAgKyBBIHNlbnRlbmNlLgorRU5ECisgICAg ZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4gImRvY3VtZW50YXRpb24iLAorICAg IHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gLTEsICMgU2luY2Ugd2Ugb25seSBpbnRlcnByZXQgdGhl ICctJyBwcm9wZXJ0eS4KKyAgICB2YWx1ZSA9PiAiQSBsb25nIHNlbnRlbmNlLiIsCit9LAorIlxu Il0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiAiICAgKyBBIHNlbnRlbmNlLlxuIiwKK30sCit7 CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJtdWx0aS1saW5lICctJyBjaGFuZ2Ug d2l0aCB0cmFpbGluZyBuZXcgbGluZSwgYW5kIG11bHRpLWxpbmUgJysnIGNoYW5nZSIsCisgICAg aW5wdXRUZXh0ID0+IDw8J0VORCcsCitNb2RpZmllZDogZG9jdW1lbnRhdGlvbgorICAgLSBBCits b25nIHNlbnRlbmNlIHRoYXQgc3BhbnMKK211bHRpcGxlIGxpbmVzLgorCisgICArIEFub3RoZXIK K2xvbmcgc2VudGVuY2UgdGhhdCBzcGFucworbXVsdGlwbGUgbGluZXMuCitFTkQKKyAgICBleHBl Y3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAiZG9jdW1lbnRhdGlvbiIsCisgICAgcHJv cGVydHlDaGFuZ2VEZWx0YSA9PiAtMSwgIyBTaW5jZSB3ZSBvbmx5IGludGVycHJldCB0aGUgJy0n IHByb3BlcnR5LgorICAgIHZhbHVlID0+ICJBXG5sb25nIHNlbnRlbmNlIHRoYXQgc3BhbnNcbm11 bHRpcGxlIGxpbmVzLiIsCit9LAorIlxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiAiICAg KyBBbm90aGVyXG4iLAorfSwKKyk7CisKK215ICR0ZXN0Q2FzZXNDb3VudCA9IEB0ZXN0Q2FzZUhh c2hSZWZzOworcGxhbih0ZXN0cyA9PiAyICogJHRlc3RDYXNlc0NvdW50KTsgIyBUb3RhbCBudW1i ZXIgb2YgYXNzZXJ0aW9ucy4KKworZm9yZWFjaCBteSAkdGVzdENhc2UgKEB0ZXN0Q2FzZUhhc2hS ZWZzKSB7CisgICAgbXkgJHRlc3ROYW1lU3RhcnQgPSAicGFyc2VTdm5Qcm9wZXJ0eSgpOiAkdGVz dENhc2UtPntkaWZmTmFtZX06IGNvbXBhcmluZyI7CisKKyAgICBteSAkZmlsZUhhbmRsZTsKKyAg ICBvcGVuKCRmaWxlSGFuZGxlLCAiPCIsIFwkdGVzdENhc2UtPntpbnB1dFRleHR9KTsKKyAgICBt eSAkbGluZSA9IDwkZmlsZUhhbmRsZT47CisKKyAgICBteSBAZ290ID0gVkNTVXRpbHM6OnBhcnNl U3ZuUHJvcGVydHkoJGZpbGVIYW5kbGUsICRsaW5lKTsKKyAgICBteSAkZXhwZWN0ZWRSZXR1cm4g PSAkdGVzdENhc2UtPntleHBlY3RlZFJldHVybn07CisKKyAgICBpc19kZWVwbHkoXEBnb3QsICRl eHBlY3RlZFJldHVybiwgIiR0ZXN0TmFtZVN0YXJ0IHJldHVybiB2YWx1ZS4iKTsKKworICAgIG15 ICRnb3ROZXh0TGluZSA9IDwkZmlsZUhhbmRsZT47CisgICAgaXMoJGdvdE5leHRMaW5lLCAkdGVz dENhc2UtPntleHBlY3RlZE5leHRMaW5lfSwgICIkdGVzdE5hbWVTdGFydCBuZXh0IHJlYWQgbGlu ZS4iKTsKK30KSW5kZXg6IFdlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cGVybC9WQ1NVdGlsc191 bml0dGVzdC9wYXJzZVN2blByb3BlcnR5VmFsdWUucGwKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0ZXN0L3BhcnNlU3ZuUHJvcGVydHlW YWx1ZS5wbAkocmV2aXNpb24gNTk1NzkpCisrKyBXZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHBl cmwvVkNTVXRpbHNfdW5pdHRlc3QvcGFyc2VTdm5Qcm9wZXJ0eVZhbHVlLnBsCSh3b3JraW5nIGNv cHkpCkBAIC01OCw3ICs1OCw3IEBAIEVORAogfSwKIHsKICAgICAjIE5ldyB0ZXN0Ci0gICAgZGlm Zk5hbWUgPT4gInNpbXBsZSBtdWx0aS1saW5lICctJyBjaGFuZ2UiLAorICAgIGRpZmZOYW1lID0+ ICJzaW5nbGUtbGluZSAnLScgY2hhbmdlIGZvbGxvd2VkIGJ5IGVtcHR5IGxpbmUiLAogICAgIGlu cHV0VGV4dCA9PiA8PCdFTkQnLAogICAgLSAqCiAKQEAgLTY4LDYgKzY4LDE2IEBAIEVORAogfSwK IHsKICAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gInNpbmdsZS1saW5lICctJyBjaGFu Z2UgZm9sbG93ZWQgYnkgdGhlIG5leHQgcHJvcGVydHkiLAorICAgIGlucHV0VGV4dCA9PiA8PCdF TkQnLAorICAgLSAqCitEZWxldGVkOiBzdm46ZXhlY3V0YWJsZQorRU5ECisgICAgZXhwZWN0ZWRS ZXR1cm4gPT4gWyIqIiwgIkRlbGV0ZWQ6IHN2bjpleGVjdXRhYmxlXG4iXSwKKyAgICBleHBlY3Rl ZE5leHRMaW5lID0+IHVuZGVmLAorfSwKK3sKKyAgICAjIE5ldyB0ZXN0CiAgICAgZGlmZk5hbWUg PT4gIm11bHRpLWxpbmUgJysnIGNoYW5nZSBhbmQgc3RhcnQgb2YgYmluYXJ5IHBhdGNoIiwKICAg ICBpbnB1dFRleHQgPT4gPDwnRU5EJywKICAgICsgQQpAQCAtOTMsNiArMTAzLDE4IEBAIEVORAog fSwKIHsKICAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gIm11bHRpLWxpbmUgJy0nIGNo YW5nZSBmb2xsb3dlZCBieSB0aGUgbmV4dCBwcm9wZXJ0eSIsCisgICAgaW5wdXRUZXh0ID0+IDw8 J0VORCcsCisgICAtIEEKK2xvbmcgc2VudGVuY2UgdGhhdCBzcGFucworbXVsdGlwbGUgbGluZXMu CitBZGRlZDogc3ZuOmV4ZWN1dGFibGUKK0VORAorICAgIGV4cGVjdGVkUmV0dXJuID0+IFsiQVxu bG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zXG5tdWx0aXBsZSBsaW5lcy4iLCAiQWRkZWQ6IHN2bjpl eGVjdXRhYmxlXG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+IHVuZGVmLAorfSwKK3sKKyAg ICAjIE5ldyB0ZXN0CiAgICAgZGlmZk5hbWUgPT4gIm11bHRpLWxpbmUgJy0nIGNoYW5nZSBmb2xs b3dlZCBieSAnKycgbXVsdGktbGluZSBjaGFuZ2UiLAogICAgIGlucHV0VGV4dCA9PiA8PCdFTkQn LAogICAgLSBBCg== 56205 2010-05-16 18:37:33 -0700 2010-05-16 22:21:03 -0700 Patch with unit tests Bug39184_3.patch text/plain 19449 dbates SW5kZXg6IFdlYktpdFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9D aGFuZ2VMb2cJKHJldmlzaW9uIDU5NTgwKQorKysgV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTAtMDUtMTYgIERhbmllbCBCYXRlcyAgPGRi YXRlc0ByaW0uY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTE4NAorCisg ICAgICAgIEFkZHMgZnVuY3Rpb24gVkNTVXRpbHM6OnBhcnNlU3ZuUHJvcGVydHkgdG8gcGFyc2Ug YW4gU1ZOIHByb3BlcnR5IHdpdGgKKyAgICAgICAgZWl0aGVyIGEgc2luZ2xlLWxpbmUgb3IgbXVs dGktbGluZSB2YWx1ZSBjaGFuZ2UuCisKKyAgICAgICAgKiBTY3JpcHRzL1ZDU1V0aWxzLnBtOgor ICAgICAgICAgIC0gQWRkZWQgZnVuY3Rpb24gcGFyc2VTdm5Qcm9wZXJ0eS4gV2Ugd2lsbCB1c2Ug dGhpcyBmdW5jdGlvbgorICAgICAgICAgICAgdG93YXJkcyByZXNvbHZpbmcgQnVnICMzODg4NSA8 aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4ODg1Pi4KKyAgICAgICAg ICAtIFJlbW92ZWQgRklYTUUgY29tbWVudCBhYm92ZSBmdW5jdGlvbiBwYXJzZVN2blByb3BlcnR5 VmFsdWUsIHNpbmNlCisgICAgICAgICAgICBpdCBpcyBiZWluZyB1c2VkIGJ5IHBhcnNlU3ZuUHJv cGVydHkuCisgICAgICAgICAgLSBNb2RpZmllZCBmdW5jdGlvbiBwYXJzZVN2blByb3BlcnR5VmFs dWUgdG8gYnJlYWsgb3V0IG9mICJ3aGlsZSAoPCRmaWxlSGFuZGxlPikiCisgICAgICAgICAgICBs b29wIHdoZW4gaXQgZW5jb3VudGVycyB0aGUgc3RhcnQgb2YgdGhlIG5leHQgcHJvcGVydHkgc28g dGhhdCBpdCBjYW4gYmUKKyAgICAgICAgICAgIHByb2Nlc3NlZCBieSBpdHMgY2FsbGVyLCBwYXJz ZVN2blByb3BlcnR5VmFsdWUuIFdlIHJlZmVyZW5jZSB0aGlzIGJ1bGxldCBiZWxvdworICAgICAg ICAgICAgYnkgKCopLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cGVybC9WQ1NVdGlsc191bml0 dGVzdC9wYXJzZVN2blByb3BlcnR5LnBsOiBBZGRlZC4KKyAgICAgICAgICAtIEFkZGVkIHVuaXQg dGVzdHMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0ZXN0L3Bh cnNlU3ZuUHJvcGVydHlWYWx1ZS5wbDoKKyAgICAgICAgICAtIENoYW5nZWQgdGhlIG5hbWUgb2Yg dGhlIHVuaXQgdGVzdCAic2ltcGxlIG11bHRpLWxpbmUgJy0nIGNoYW5nZSIgdG8KKyAgICAgICAg ICAgICJzaW5nbGUtbGluZSAnLScgY2hhbmdlIGZvbGxvd2VkIGJ5IGVtcHR5IGxpbmUiIHNpbmNl IHRoZSBmb3JtZXIgd2FzIGFuCisgICAgICAgICAgICBpbmNvcnJlY3QgZGVzY3JpcHRpb24gb2Yg dGhpcyB0ZXN0LgorICAgICAgICAgIC0gQWRkZWQgdW5pdCB0ZXN0ICJzaW5nbGUtbGluZSAnLScg Y2hhbmdlIGZvbGxvd2VkIGJ5IHRoZSBuZXh0IHByb3BlcnR5IiwgYW5kCisgICAgICAgICAgICAi bXVsdGktbGluZSAnLScgY2hhbmdlIGZvbGxvd2VkIGJ5IHRoZSBuZXh0IHByb3BlcnR5IiB0byB0 ZXN0ICgqKSBhYm92ZS4KKwogMjAxMC0wNS0xNiAgUm9iZXJ0IEhvZ2FuICA8cm9iZXJ0QHdlYmtp dC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4u CkluZGV4OiBXZWJLaXRUb29scy9TY3JpcHRzL1ZDU1V0aWxzLnBtCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YktpdFRvb2xzL1NjcmlwdHMvVkNTVXRpbHMucG0JKHJldmlzaW9uIDU5NTc5KQorKysgV2ViS2l0 VG9vbHMvU2NyaXB0cy9WQ1NVdGlscy5wbQkod29ya2luZyBjb3B5KQpAQCAtOTAsNiArOTAsNyBA QCBteSAkY2hhbmdlTG9nVGltZVpvbmUgPSAiUFNUOFBEVCI7CiAKIG15ICRnaXREaWZmU3RhcnRS ZWdFeCA9IHFyI15kaWZmIC0tZ2l0IChcdy8pPyguKykgKFx3Lyk/KFteXHJcbl0rKSM7CiBteSAk c3ZuRGlmZlN0YXJ0UmVnRXggPSBxciNeSW5kZXg6IChbXlxyXG5dKykjOworbXkgJHN2blByb3Bl cnR5U3RhcnRSZWdFeCA9IHFyI14oTW9kaWZpZWR8TmFtZXxBZGRlZHxEZWxldGVkKTogKFteXHJc bl0rKSM7ICMgJDIgaXMgdGhlIG5hbWUgb2YgdGhlIHByb3BlcnR5LgogbXkgJHN2blByb3BlcnR5 VmFsdWVTdGFydFJlZ0V4ID0gcXIjXiAgIChcK3wtKSAoW15cclxuXSspIzsgIyAkMiBpcyB0aGUg c3RhcnQgb2YgdGhlIHByb3BlcnR5J3MgdmFsdWUgKHdoaWNoIG1heSBzcGFuIG11bHRpcGxlIGxp bmVzKS4KIAogIyBUaGlzIG1ldGhvZCBpcyBmb3IgcG9ydGFiaWxpdHkuIFJldHVybiB0aGUgc3lz dGVtLWFwcHJvcHJpYXRlIGV4aXQKQEAgLTgzNyw2ICs4MzgsMTExIEBAIHN1YiBwYXJzZURpZmYo JCQpCiAgICAgcmV0dXJuIChcQGRpZmZIYXNoUmVmcywgJGxpbmUpOwogfQogCisjIFBhcnNlIHRo ZSBuZXh0IFNWTiBwcm9wZXJ0eSBmcm9tIHRoZSBnaXZlbiBmaWxlIGhhbmRsZSwgYW5kIGFkdmFu Y2UgdGhlIGhhbmRsZSBzbyB0aGUgbGFzdAorIyBsaW5lIHJlYWQgaXMgdGhlIGZpcnN0IGxpbmUg YWZ0ZXIgdGhlIHByb3BlcnR5LgorIworIyBUaGlzIHN1YnJvdXRpbmUgZGllcyBpZiB0aGUgZmly c3QgbGluZSBpcyBub3QgYSB2YWxpZCBzdGFydCBvZiBhbiBTVk4gcHJvcGVydHksCisjIG9yIHRo ZSBwcm9wZXJ0eSBpcyBtaXNzaW5nIGEgdmFsdWUsIG9yIHRoZSBwcm9wZXJ0eSBjaGFuZ2UgdHlw ZSAoZS5nLiAiQWRkZWQiKQorIyBkb2VzIG5vdCBjb3JyZXNwb25kIHRvIHRoZSBwcm9wZXJ0eSB2 YWx1ZSB0eXBlIChlLmcuICIrIikuCisjCisjIEFyZ3M6CisjICAgJGZpbGVIYW5kbGU6IGFkdmFu Y2VkIHNvIHRoZSBsYXN0IGxpbmUgcmVhZCBmcm9tIHRoZSBoYW5kbGUgaXMgdGhlIGZpcnN0Cisj ICAgICAgICAgICAgICAgIGxpbmUgb2YgdGhlIHByb3BlcnR5IHRvIHBhcnNlLiAgVGhpcyBzaG91 bGQgYmUgYSBsaW5lCisjICAgICAgICAgICAgICAgIHRoYXQgbWF0Y2hlcyAkc3ZuUHJvcGVydHlT dGFydFJlZ0V4LgorIyAgICRsaW5lOiB0aGUgbGluZSBsYXN0IHJlYWQgZnJvbSAkZmlsZUhhbmRs ZS4KKyMKKyMgUmV0dXJucyAoJHByb3BlcnR5SGFzaFJlZiwgJGxhc3RSZWFkTGluZSk6CisjICAg JHByb3BlcnR5SGFzaFJlZjogYSBoYXNoIHJlZmVyZW5jZSByZXByZXNlbnRpbmcgYSBTVk4gcHJv cGVydHkuCisjICAgICBuYW1lOiB0aGUgbmFtZSBvZiB0aGUgcHJvcGVydHkuCisjICAgICB2YWx1 ZTogdGhlIGxhc3QgcHJvcGVydHkgdmFsdWUuICBGb3IgaW5zdGFuY2UsIHN1cHBvc2UgdGhlIHBy b3BlcnR5IGlzICJNb2RpZmllZCIuCisjICAgICAgICAgICAgVGhlbiBpdCBoYXMgYm90aCBhICct JyBhbmQgJysnIHByb3BlcnR5IHZhbHVlIGluIHRoYXQgb3JkZXIuICBUaGVyZWZvcmUsCisjICAg ICAgICAgICAgdGhlIHZhbHVlIG9mIHRoaXMga2V5IGlzIHRoZSB2YWx1ZSBvZiB0aGUgJysnIHBy b3BlcnR5IGJ5IG9yZGVyaW5nIChzaW5jZQorIyAgICAgICAgICAgIGl0IGlzIHRoZSBsYXN0LW1v c3QgdmFsdWUpLgorIyAgICAgcHJvcGVydHlDaGFuZ2VEZWx0YTogdGhlIHZhbHVlIDEgb3IgLTEg aWYgdGhlIHByb3BlcnR5IHdhcyBhZGRlZCBvcgorIyAgICAgICAgICAgICAgICAgICAgICAgICAg cmVtb3ZlZCwgcmVzcGVjdGl2ZWx5LgorIyAgICRsYXN0UmVhZExpbmU6IHRoZSBsaW5lIGxhc3Qg cmVhZCBmcm9tICRmaWxlSGFuZGxlLgorIworIyBGSVhNRTogVGhpcyBtZXRob2QgaXMgdW51c2Vk IGFzIG9mICgwNS8xNi8yMDEwKS4gIFdlIHdpbGwgY2FsbCB0aGlzIGZ1bmN0aW9uCisjICAgICAg ICBhcyBwYXJ0IG9mIHBhcnNpbmcgYSBTVk4gZm9vdGVyLiAgU2VlIDxodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg4ODU+Lgorc3ViIHBhcnNlU3ZuUHJvcGVydHkoJCQp Cit7CisgICAgbXkgKCRmaWxlSGFuZGxlLCAkbGluZSkgPSBAXzsKKworICAgICRfID0gJGxpbmU7 CisKKyAgICBteSAkcHJvcGVydHlOYW1lOworICAgIG15ICRwcm9wZXJ0eUNoYW5nZVR5cGU7Cisg ICAgaWYgKC8kc3ZuUHJvcGVydHlTdGFydFJlZ0V4LykgeworICAgICAgICAkcHJvcGVydHlDaGFu Z2VUeXBlID0gJDE7CisgICAgICAgICRwcm9wZXJ0eU5hbWUgPSAkMjsKKyAgICB9IGVsc2Ugewor ICAgICAgICBkaWUoIkZhaWxlZCB0byBmaW5kIFNWTiBwcm9wZXJ0eTogXCIkX1wiLiIpOworICAg IH0KKworICAgICRfID0gPCRmaWxlSGFuZGxlPjsgIyBOb3QgZGVmaW5lZCBpZiBlbmQtb2YtZmls ZSByZWFjaGVkLgorCisgICAgIyBUaGUgInN2biBkaWZmIiBjb21tYW5kIG5laXRoZXIgaW5zZXJ0 cyBuZXcgbGluZSBjaGFyYWN0ZXJzIGJldHdlZW4gcHJvcGVydHkgdmFsdWVzCisgICAgIyBub3Ig YmV0d2VlbiBzdWNjZXNzaXZlIHByb3BlcnRpZXMuCisgICAgIworICAgICMgRklYTUU6IFdlIGRv IG5vdCBzdXBwb3J0IHByb3BlcnR5IHZhbHVlcyB0aGF0IGNvbnRhaW4gdGFpbGluZyBuZXcgbGlu ZSBjaGFyYWN0ZXJzCisgICAgIyAgICAgICAgYXMgaXQgaXMgZGlmZmljdWx0IHRvIGRpc2FtYmln dWF0ZSB0aGVzZSB0cmFpbGluZyBuZXcgbGluZXMgZnJvbSB0aGUgZW1wdHkKKyAgICAjICAgICAg ICBsaW5lIHRoYXQgcHJlY2VlZHMgdGhlIGNvbnRlbnRzIG9mIGEgYmluYXJ5IHBhdGNoLgorICAg IG15ICRwcm9wZXJ0eVZhbHVlOworICAgIG15ICRwcm9wZXJ0eVZhbHVlVHlwZTsKKyAgICB3aGls ZSAoZGVmaW5lZCgkXykgJiYgLyRzdm5Qcm9wZXJ0eVZhbHVlU3RhcnRSZWdFeC8pIHsKKyAgICAg ICAgIyBOb3RlLCBhICctJyBwcm9wZXJ0eSBtYXkgYmUgZm9sbG93ZWQgYnkgJysnIHByb3BlcnR5 IGluIHRoZSBjYXNlIG9mIGEgIk1vZGlmaWVkIgorICAgICAgICAjIG9yICJOYW1lIiBwcm9wZXJ0 eS4gIFdlIG9ubHkgY2FyZSBhYm91dCB0aGUgZW5kaW5nIHZhbHVlIChpLmUuIHRoZSAnKycgcHJv cGVydHkpCisgICAgICAgICMgaW4gc3VjaCBjaXJjdW1zdGFuY2VzLiAgU28sIHdlIHRha2UgdGhl IHByb3BlcnR5IHZhbHVlIGZvciB0aGUgcHJvcGVydHkgdG8gYmUgaXRzCisgICAgICAgICMgbGFz dCBwYXJzZWQgcHJvcGVydHkgdmFsdWUuCisgICAgICAgICMKKyAgICAgICAgIyBGSVhNRTogV2Ug bWF5IHdhbnQgdG8gY29uc2lkZXIgc3RyaWN0bHkgZW5mb3JjaW5nIGEgJy0nLCAnKycgcHJvcGVy dHkgb3JkZXJpbmcgb3IKKyAgICAgICAgIyAgICAgICAgYWRkIGVycm9yIGNoZWNraW5nIHRvIHBy ZXZlbnQgJysnLCAnKycsIC4uLiwgJysnIGFuZCBvdGhlciBpbnZhbGlkIGNvbWJpbmF0aW9ucy4K KyAgICAgICAgJHByb3BlcnR5VmFsdWVUeXBlID0gJDE7CisgICAgICAgICgkcHJvcGVydHlWYWx1 ZSwgJF8pID0gcGFyc2VTdm5Qcm9wZXJ0eVZhbHVlKCRmaWxlSGFuZGxlLCAkXyk7CisgICAgfQor CisgICAgaWYgKCEkcHJvcGVydHlWYWx1ZSkgeworICAgICAgICBkaWUoIkZhaWxlZCB0byBmaW5k IHRoZSBwcm9wZXJ0eSB2YWx1ZSBmb3IgdGhlIFNWTiBwcm9wZXJ0eSBcIiRwcm9wZXJ0eU5hbWVc IjogXCIkX1wiLiIpOworICAgIH0KKworICAgIG15ICRwcm9wZXJ0eUNoYW5nZURlbHRhOworICAg IGlmICgkcHJvcGVydHlWYWx1ZVR5cGUgZXEgJysnKSB7CisgICAgICAgICRwcm9wZXJ0eUNoYW5n ZURlbHRhID0gMTsKKyAgICB9IGVsc2lmICgkcHJvcGVydHlWYWx1ZVR5cGUgZXEgJy0nKSB7Cisg ICAgICAgICRwcm9wZXJ0eUNoYW5nZURlbHRhID0gLTE7CisgICAgfSBlbHNlIHsKKyAgICAgICAg IyBOb3QgcmVhY2hlZC4KKyAgICAgICAgZGllOworICAgIH0KKworICAgICMgV2UgcGVyZm9ybSBh IHNpbXBsZSB2YWxpZGF0aW9uIHRoYXQgYW4gIkFkZGVkIiBvciAiRGVsZXRlZCIgcHJvcGVydHkK KyAgICAjIGNoYW5nZSB0eXBlIGNvcnJlc3BvbmRzIHdpdGggYSAiKyIgYW5kICItIiB2YWx1ZSB0 eXBlLCByZXNwZWN0aXZlbHkuCisgICAgbXkgJGV4cGVjdGVkQ2hhbmdlRGVsdGE7CisgICAgaWYg KCRwcm9wZXJ0eUNoYW5nZVR5cGUgZXEgIk5hbWUiKSB7CisgICAgICAgICRleHBlY3RlZENoYW5n ZURlbHRhID0gMDsKKyAgICB9IGVsc2lmICgkcHJvcGVydHlDaGFuZ2VUeXBlIGVxICJNb2RpZmll ZCIpIHsKKyAgICAgICAgJGV4cGVjdGVkQ2hhbmdlRGVsdGEgPSAwOworICAgIH0gZWxzaWYgKCRw cm9wZXJ0eUNoYW5nZVR5cGUgZXEgIkFkZGVkIikgeworICAgICAgICAkZXhwZWN0ZWRDaGFuZ2VE ZWx0YSA9IDE7CisgICAgfSBlbHNpZiAoJHByb3BlcnR5Q2hhbmdlVHlwZSBlcSAiRGVsZXRlZCIp IHsKKyAgICAgICAgJGV4cGVjdGVkQ2hhbmdlRGVsdGEgPSAtMTsKKyAgICB9IGVsc2UgeworICAg ICAgICAjIE5vdCByZWFjaGVkLgorICAgICAgICBkaWU7CisgICAgfQorCisgICAgaWYgKCRwcm9w ZXJ0eUNoYW5nZURlbHRhID09IC0xICogJGV4cGVjdGVkQ2hhbmdlRGVsdGEpIHsKKyAgICAgICAg ZGllKCJUaGUgZmluYWwgcHJvcGVydHkgdmFsdWUgdHlwZSBmb3VuZCBcIiRwcm9wZXJ0eVZhbHVl VHlwZVwiIGRvZXMgbm90ICIgLgorICAgICAgICAgICAgImNvcnJlc3BvbmQgdG8gdGhlIHByb3Bl cnR5IGNoYW5nZSB0eXBlIGZvdW5kIFwiJHByb3BlcnR5Q2hhbmdlVHlwZVwiLiIpOworICAgIH0K KworICAgIG15ICVwcm9wZXJ0eUhhc2g7CisgICAgJHByb3BlcnR5SGFzaHtuYW1lfSA9ICRwcm9w ZXJ0eU5hbWU7CisgICAgJHByb3BlcnR5SGFzaHtwcm9wZXJ0eUNoYW5nZURlbHRhfSA9ICRwcm9w ZXJ0eUNoYW5nZURlbHRhOworICAgICRwcm9wZXJ0eUhhc2h7dmFsdWV9ID0gJHByb3BlcnR5VmFs dWU7CisgICAgcmV0dXJuIChcJXByb3BlcnR5SGFzaCwgJF8pOworfQorCiAjIFBhcnNlIHRoZSB2 YWx1ZSBvZiBhbiBTVk4gcHJvcGVydHkgZnJvbSB0aGUgZ2l2ZW4gZmlsZSBoYW5kbGUsIGFuZCBh ZHZhbmNlCiAjIHRoZSBoYW5kbGUgc28gdGhlIGxhc3QgbGluZSByZWFkIGlzIHRoZSBmaXJzdCBs aW5lIGFmdGVyIHRoZSBwcm9wZXJ0eSB2YWx1ZS4KICMKQEAgLTg0NywxNCArOTUzLDExIEBAIHN1 YiBwYXJzZURpZmYoJCQpCiAjICAgJGZpbGVIYW5kbGU6IGFkdmFuY2VkIHNvIHRoZSBsYXN0IGxp bmUgcmVhZCBmcm9tIHRoZSBoYW5kbGUgaXMgdGhlIGZpcnN0CiAjICAgICAgICAgICAgICAgIGxp bmUgb2YgdGhlIHByb3BlcnR5IHZhbHVlIHRvIHBhcnNlLiAgVGhpcyBzaG91bGQgYmUgYSBsaW5l CiAjICAgICAgICAgICAgICAgIGJlZ2lubmluZyB3aXRoICIgICArIiBvciAiICAgLSIuCi0jICAg JGxpbmU6IHRoZSBsaW5lIGxhc3QgcmVhZCBmcm9tICRmaWxlSGFuZGxlCisjICAgJGxpbmU6IHRo ZSBsaW5lIGxhc3QgcmVhZCBmcm9tICRmaWxlSGFuZGxlLgogIwogIyBSZXR1cm5zICgkcHJvcGVy dHlWYWx1ZSwgJGxhc3RSZWFkTGluZSk6CiAjICAgJHByb3BlcnR5VmFsdWU6IHRoZSB2YWx1ZSBv ZiB0aGUgcHJvcGVydHkuCiAjICAgJGxhc3RSZWFkTGluZTogdGhlIGxpbmUgbGFzdCByZWFkIGZy b20gJGZpbGVIYW5kbGUuCi0jCi0jIEZJWE1FOiBUaGlzIG1ldGhvZCBpcyB1bnVzZWQgYXMgb2Yg KDA1LzE1LzIwMTApLiBXZSB3aWxsIGNhbGwgdGhpcyBmdW5jdGlvbgotIyAgICAgICAgYXMgcGFy dCBvZiBwYXJzaW5nIGEgcHJvcGVydHkgZnJvbSB0aGUgU1ZOIGZvb3Rlci4gU2VlIDxodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzg4ODU+Lgogc3ViIHBhcnNlU3ZuUHJv cGVydHlWYWx1ZSgkJCkKIHsKICAgICBteSAoJGZpbGVIYW5kbGUsICRsaW5lKSA9IEBfOwpAQCAt ODcxLDEyICs5NzQsMTUgQEAgc3ViIHBhcnNlU3ZuUHJvcGVydHlWYWx1ZSgkJCkKICAgICB9CiAK ICAgICB3aGlsZSAoPCRmaWxlSGFuZGxlPikgewotICAgICAgICBpZiAoL14kLyB8fCAvJHN2blBy b3BlcnR5VmFsdWVTdGFydFJlZ0V4LykgeworICAgICAgICBpZiAoL14kLyB8fCAvJHN2blByb3Bl cnR5VmFsdWVTdGFydFJlZ0V4LyB8fCAvJHN2blByb3BlcnR5U3RhcnRSZWdFeC8pIHsKICAgICAg ICAgICAgICMgTm90ZSwgd2UgbWF5IGVuY291bnRlciBhbiBlbXB0eSBsaW5lIGJlZm9yZSB0aGUg Y29udGVudHMgb2YgYSBiaW5hcnkgcGF0Y2guCiAgICAgICAgICAgICAjIEFsc28sIHdlIGNoZWNr IGZvciAkc3ZuUHJvcGVydHlWYWx1ZVN0YXJ0UmVnRXggYmVjYXVzZSBhICctJyBwcm9wZXJ0eSBt YXkgYmUKICAgICAgICAgICAgICMgZm9sbG93ZWQgYnkgYSAnKycgcHJvcGVydHkgaW4gdGhlIGNh c2Ugb2YgYSAiTW9kaWZpZWQiIG9yICJOYW1lIiBwcm9wZXJ0eS4KKyAgICAgICAgICAgICMgV2Ug Y2hlY2sgZm9yICRzdm5Qcm9wZXJ0eVN0YXJ0UmVnRXggYmVjYXVzZSBpdCBpbmRpY2F0ZXMgdGhl IHN0YXJ0IG9mIHRoZQorICAgICAgICAgICAgIyBuZXh0IHByb3BlcnR5IHRvIHBhcnNlLgogICAg ICAgICAgICAgbGFzdDsKICAgICAgICAgfQorCiAgICAgICAgICMgVGVtcG9yYXJpbHkgc3RyaXAg b2ZmIGFueSBlbmQtb2YtbGluZSBjaGFyYWN0ZXJzLiBXZSBhZGQgdGhlIGVuZC1vZi1saW5lIGNo YXJhY3RlcnMKICAgICAgICAgIyBmcm9tIHRoZSBwcmV2aW91c2x5IHByb2Nlc3NlZCBsaW5lIHRv IHRoZSBzdGFydCBvZiB0aGlzIGxpbmUgc28gdGhhdCB0aGUgbGFzdCBsaW5lCiAgICAgICAgICMg b2YgdGhlIHByb3BlcnR5IHZhbHVlIGRvZXMgbm90IGVuZCBpbiBlbmQtb2YtbGluZSBjaGFyYWN0 ZXJzLgpJbmRleDogV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0 ZXN0L3BhcnNlU3ZuUHJvcGVydHkucGwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0ZXN0L3BhcnNlU3ZuUHJvcGVydHkucGwJKHJldmlz aW9uIDApCisrKyBXZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHBlcmwvVkNTVXRpbHNfdW5pdHRl c3QvcGFyc2VTdm5Qcm9wZXJ0eS5wbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzNDAgQEAKKyMh L3Vzci9iaW4vcGVybCAtdworIworIyBDb3B5cmlnaHQgKEMpIFJlc2VhcmNoIGluIE1vdGlvbiBM aW1pdGVkIDIwMTAuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisjIENvcHlyaWdodCAoQykgMjAxMCBD aHJpcyBKZXJkb25layAoY2hyaXMuamVyZG9uZWtAZ21haWwuY29tKQorIworIyBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zIGFyZQorIyBtZXQ6CisjCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgICAg ICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZQorIyBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyCisjIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyMgZGlzdHJpYnV0aW9uLgorIyAgICAgKiBOZWl0 aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3IgdGhlIG5h bWVzIG9mCisjIGl0cyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9t b3RlIHByb2R1Y3RzIGRlcml2ZWQKKyMgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lm aWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisjICJBUyBJUyIg QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U CisjIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorIyBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorIyBPV05FUiBPUiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyMgU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VAorIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwKKyMgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisjIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyMgKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKyMgVW5pdCB0ZXN0cyBvZiBwYXJzZVN2blByb3BlcnR5 KCkuCisKK3VzZSBzdHJpY3Q7Cit1c2Ugd2FybmluZ3M7CisKK3VzZSBUZXN0OjpNb3JlOwordXNl IFZDU1V0aWxzOworCitteSBAdGVzdENhc2VIYXNoUmVmcyA9ICgKKyMjIyMKKyMgU2ltcGxlIHRl c3QgY2FzZXMKKyMjCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW1wbGU6 IGFkZCBzdm46ZXhlY3V0YWJsZSIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitBZGRlZDog c3ZuOmV4ZWN1dGFibGUKKyAgICsgKgorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworewor ICAgIG5hbWUgPT4gInN2bjpleGVjdXRhYmxlIiwKKyAgICBwcm9wZXJ0eUNoYW5nZURlbHRhID0+ IDEsCisgICAgdmFsdWUgPT4gIioiLAorfSwKK3VuZGVmXSwKKyAgICBleHBlY3RlZE5leHRMaW5l ID0+IHVuZGVmLAorfSwKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gInNpbXBs ZTogZGVsZXRlIHN2bjpleGVjdXRhYmxlIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK0Rl bGV0ZWQ6IHN2bjpleGVjdXRhYmxlCisgICAtICoKK0VORAorICAgIGV4cGVjdGVkUmV0dXJuID0+ IFsKK3sKKyAgICBuYW1lID0+ICJzdm46ZXhlY3V0YWJsZSIsCisgICAgcHJvcGVydHlDaGFuZ2VE ZWx0YSA9PiAtMSwKKyAgICB2YWx1ZSA9PiAiKiIsCit9LAordW5kZWZdLAorICAgIGV4cGVjdGVk TmV4dExpbmUgPT4gdW5kZWYsCit9LAorIyMjIworIyBVc2luZyBTVk4gMS40IHN5bnRheAorIyMK K3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gInNpbXBsZTogZGVsZXRlIHN2bjpl eGVjdXRhYmxlIHVzaW5nIFNWTiAxLjQgc3ludGF4IiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5E JywKK05hbWU6IHN2bjpleGVjdXRhYmxlCisgICAtICoKK0VORAorICAgIGV4cGVjdGVkUmV0dXJu ID0+IFsKK3sKKyAgICBuYW1lID0+ICJzdm46ZXhlY3V0YWJsZSIsCisgICAgcHJvcGVydHlDaGFu Z2VEZWx0YSA9PiAtMSwKKyAgICB2YWx1ZSA9PiAiKiIsCit9LAordW5kZWZdLAorICAgIGV4cGVj dGVkTmV4dExpbmUgPT4gdW5kZWYsCit9LAoreworICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFt ZSA9PiAic2ltcGxlOiBhZGQgc3ZuOmV4ZWN1dGFibGUgdXNpbmcgU1ZOIDEuNCBzeW50YXgiLAor ICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorTmFtZTogc3ZuOmV4ZWN1dGFibGUKKyAgICsgKgor RU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4gInN2bjpleGVjdXRh YmxlIiwKKyAgICBwcm9wZXJ0eUNoYW5nZURlbHRhID0+IDEsCisgICAgdmFsdWUgPT4gIioiLAor fSwKK3VuZGVmXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+IHVuZGVmLAorfSwKKyMjIyMKKyMg UHJvcGVydHkgdmFsdWUgZm9sbG93ZWQgYnkgZW1wdHkgbGluZSBhbmQgc3RhcnQgb2YgYmluYXJ5 IHBhdGNoCisjIworeworICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9PiAiYWRkIHN2bjpl eGVjdXRhYmxlLCBmb2xsb3dlZCBieSBlbXB0eSBsaW5lIGFuZCBzdGFydCBvZiBiaW5hcnkgcGF0 Y2giLAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorQWRkZWQ6IHN2bjpleGVjdXRhYmxlCisg ICArICoKKworUTFkVEJ4MEFBQUI0Mml0ZzRHbGdZSmpHd01ERHlPRE14TUR3MzRHQmdRRUFKUFFE SkE9PQorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4gInN2bjpl eGVjdXRhYmxlIiwKKyAgICBwcm9wZXJ0eUNoYW5nZURlbHRhID0+IDEsCisgICAgdmFsdWUgPT4g IioiLAorfSwKKyJcbiJdLAorICAgIGV4cGVjdGVkTmV4dExpbmUgPT4gIlExZFRCeDBBQUFCNDJp dGc0R2xnWUpqR3dNRER5T0RNeE1EdzM0R0JnUUVBSlBRREpBPT1cbiIsCit9LAoreworICAgICMg TmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9PiAibXVsdGktbGluZSAnKycgY2hhbmdlLCBmb2xsb3dl ZCBieSBlbXB0eSBsaW5lIGFuZCBzdGFydCBvZiBiaW5hcnkgcGF0Y2giLAorICAgIGlucHV0VGV4 dCA9PiA8PCdFTkQnLAorTmFtZTogZG9jdW1lbnRhdGlvbgorICAgKyBBCitsb25nIHNlbnRlbmNl IHRoYXQgc3BhbnMKK211bHRpcGxlIGxpbmVzLgorCitRMWRUQngwQUFBQjQyaXRnNEdsZ1lKakd3 TUREeU9ETXhNRHczNEdCZ1FFQUpQUURKQT09CitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBb Cit7CisgICAgbmFtZSA9PiAiZG9jdW1lbnRhdGlvbiIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0 YSA9PiAxLAorICAgIHZhbHVlID0+ICJBXG5sb25nIHNlbnRlbmNlIHRoYXQgc3BhbnNcbm11bHRp cGxlIGxpbmVzLiIsCit9LAorIlxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiAiUTFkVEJ4 MEFBQUI0Mml0ZzRHbGdZSmpHd01ERHlPRE14TUR3MzRHQmdRRUFKUFFESkE9PVxuIiwKK30sCit7 CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJtdWx0aS1saW5lICctJyBjaGFuZ2Us IGZvbGxvd2VkIGJ5IG11bHRpLWxpbmUgJysnIGNoYW5nZSwgZW1wdHkgbGluZSwgYW5kIHN0YXJ0 IG9mIGJpbmFyeSBwYXRjaCIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitNb2RpZmllZDog ZG9jdW1lbnRhdGlvbgorICAgLSBBCitsb25nIHNlbnRlbmNlIHRoYXQgc3BhbnMKK211bHRpcGxl IGxpbmVzLgorICAgKyBBbm90aGVyCitsb25nIHNlbnRlbmNlIHRoYXQgc3BhbnMKK211bHRpcGxl IGxpbmVzLgorCitRMWRUQngwQUFBQjQyaXRnNEdsZ1lKakd3TUREeU9ETXhNRHczNEdCZ1FFQUpQ UURKQT09CitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAiZG9j dW1lbnRhdGlvbiIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVlID0+ ICJBbm90aGVyXG5sb25nIHNlbnRlbmNlIHRoYXQgc3BhbnNcbm11bHRpcGxlIGxpbmVzLiIsCit9 LAorIlxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiAiUTFkVEJ4MEFBQUI0Mml0ZzRHbGdZ SmpHd01ERHlPRE14TUR3MzRHQmdRRUFKUFFESkE9PVxuIiwKK30sCisjIyMjCisjIFN1Y2Nlc3Np dmUgcHJvcGVydGllcworIyMKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gInNp bmdsZS1saW5lICcrJyBjaGFuZ2UgZm9sbG93ZWQgYnkgY3VzdG9tIHByb3BlcnR5IHdpdGggc2lu Z2xlLWxpbmUgJysnIGNoYW5nZSIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitBZGRlZDog c3ZuOmV4ZWN1dGFibGUKKyAgICsgKgorQWRkZWQ6IGRvY3VtZW50YXRpb24KKyAgICsgQSBzZW50 ZW5jZS4KK0VORAorICAgIGV4cGVjdGVkUmV0dXJuID0+IFsKK3sKKyAgICBuYW1lID0+ICJzdm46 ZXhlY3V0YWJsZSIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVlID0+ ICIqIiwKK30sCisiQWRkZWQ6IGRvY3VtZW50YXRpb25cbiJdLAorICAgIGV4cGVjdGVkTmV4dExp bmUgPT4gIiAgICsgQSBzZW50ZW5jZS5cbiIsCit9LAoreworICAgICMgTmV3IHRlc3QKKyAgICBk aWZmTmFtZSA9PiAibXVsdGktbGluZSAnKycgY2hhbmdlLCBmb2xsb3dlZCBieSBzdm46ZXhlY3V0 YWJsZSIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitOYW1lOiBkb2N1bWVudGF0aW9uCisg ICArIEEKK2xvbmcgc2VudGVuY2UgdGhhdCBzcGFucworbXVsdGlwbGUgbGluZXMuCitOYW1lOiBz dm46ZXhlY3V0YWJsZQorICAgKyAqCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7Cisg ICAgbmFtZSA9PiAiZG9jdW1lbnRhdGlvbiIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAx LAorICAgIHZhbHVlID0+ICJBXG5sb25nIHNlbnRlbmNlIHRoYXQgc3BhbnNcbm11bHRpcGxlIGxp bmVzLiIsCit9LAorIk5hbWU6IHN2bjpleGVjdXRhYmxlXG4iXSwKKyAgICBleHBlY3RlZE5leHRM aW5lID0+ICIgICArICpcbiIsCit9LAoreworICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9 PiAibXVsdGktbGluZSAnLScgY2hhbmdlLCBmb2xsb3dlZCBieSBtdWx0aS1saW5lICcrJyBjaGFu Z2UgYW5kIGFkZCBzdm46ZXhlY3V0YWJsZSIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitN b2RpZmllZDogZG9jdW1lbnRhdGlvbgorICAgLSBBCitsb25nIHNlbnRlbmNlIHRoYXQgc3BhbnMK K211bHRpcGxlIGxpbmVzLgorICAgKyBBbm90aGVyCitsb25nIHNlbnRlbmNlIHRoYXQgc3BhbnMK K211bHRpcGxlIGxpbmVzLgorQWRkZWQ6IHN2bjpleGVjdXRhYmxlCisgICArICoKK0VORAorICAg IGV4cGVjdGVkUmV0dXJuID0+IFsKK3sKKyAgICBuYW1lID0+ICJkb2N1bWVudGF0aW9uIiwKKyAg ICBwcm9wZXJ0eUNoYW5nZURlbHRhID0+IDEsCisgICAgdmFsdWUgPT4gIkFub3RoZXJcbmxvbmcg c2VudGVuY2UgdGhhdCBzcGFuc1xubXVsdGlwbGUgbGluZXMuIiwKK30sCisiQWRkZWQ6IHN2bjpl eGVjdXRhYmxlXG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+ICIgICArICpcbiIsCit9LAor IyMjIworIyBQcm9wZXJ0eSB2YWx1ZXMgd2l0aCB0cmFpbGluZyBuZXcgbGluZXMuCisjIworIyBG SVhNRTogV2UgZG8gbm90IHN1cHBvcnQgcHJvcGVydHkgdmFsdWVzIHdpdGggdHJhaWxpbmcgbmV3 IGxpbmVzLCBzaW5jZSBpdCBpcyBkaWZmaWN1bHQgdG8KKyMgICAgICAgIGRpc2FtYmlndWF0ZSB0 aGVtIGZyb20gdGhlIGVtcHR5IGxpbmUgdGhhdCBwcmVjZWVkcyB0aGUgY29udGVudHMgb2YgYSBi aW5hcnkgcGF0Y2ggYXMKKyMgICAgICAgIGluIHRoZSB0ZXN0IGNhc2UgKGFib3ZlKTogIm11bHRp LWxpbmUgJysnIGNoYW5nZSwgZm9sbG93ZWQgYnkgZW1wdHkgbGluZSBhbmQgc3RhcnQgb2YgYmlu YXJ5IHBhdGNoIi4KK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gInNpbmdsZS1s aW5lICcrJyB3aXRoIHRyYWlsaW5nIG5ldyBsaW5lIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5E JywKK0FkZGVkOiBkb2N1bWVudGF0aW9uCisgICArIEEgc2VudGVuY2UuCisKK0VORAorICAgIGV4 cGVjdGVkUmV0dXJuID0+IFsKK3sKKyAgICBuYW1lID0+ICJkb2N1bWVudGF0aW9uIiwKKyAgICBw cm9wZXJ0eUNoYW5nZURlbHRhID0+IDEsCisgICAgdmFsdWUgPT4gIkEgc2VudGVuY2UuIiwKK30s CisiXG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+IHVuZGVmLAorfSwKK3sKKyAgICAjIE5l dyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gInNpbmdsZS1saW5lICcrJyB3aXRoIHRyYWlsaW5nIG5l dyBsaW5lLCBmb2xsb3dlZCBieSBlbXB0eSBsaW5lIGFuZCBzdGFydCBvZiBiaW5hcnkgcGF0Y2gi LAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorQWRkZWQ6IGRvY3VtZW50YXRpb24KKyAgICsg QSBzZW50ZW5jZS4KKworCitRMWRUQngwQUFBQjQyaXRnNEdsZ1lKakd3TUREeU9ETXhNRHczNEdC Z1FFQUpQUURKQT09CitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9 PiAiZG9jdW1lbnRhdGlvbiIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZh bHVlID0+ICJBIHNlbnRlbmNlLiIsCit9LAorIlxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9 PiAiXG4iLAorfSwKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gInNpbmdsZS1s aW5lICctJyBjaGFuZ2Ugd2l0aCB0cmFpbGluZyBuZXcgbGluZSwgYW5kIHNpbmdsZS1saW5lICcr JyBjaGFuZ2UiLAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorTW9kaWZpZWQ6IGRvY3VtZW50 YXRpb24KKyAgIC0gQSBsb25nIHNlbnRlbmNlLgorCisgICArIEEgc2VudGVuY2UuCitFTkQKKyAg ICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAiZG9jdW1lbnRhdGlvbiIsCisg ICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAtMSwgIyBTaW5jZSB3ZSBvbmx5IGludGVycHJldCB0 aGUgJy0nIHByb3BlcnR5LgorICAgIHZhbHVlID0+ICJBIGxvbmcgc2VudGVuY2UuIiwKK30sCisi XG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+ICIgICArIEEgc2VudGVuY2UuXG4iLAorfSwK K3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gIm11bHRpLWxpbmUgJy0nIGNoYW5n ZSB3aXRoIHRyYWlsaW5nIG5ldyBsaW5lLCBhbmQgbXVsdGktbGluZSAnKycgY2hhbmdlIiwKKyAg ICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK01vZGlmaWVkOiBkb2N1bWVudGF0aW9uCisgICAtIEEK K2xvbmcgc2VudGVuY2UgdGhhdCBzcGFucworbXVsdGlwbGUgbGluZXMuCisKKyAgICsgQW5vdGhl cgorbG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zCittdWx0aXBsZSBsaW5lcy4KK0VORAorICAgIGV4 cGVjdGVkUmV0dXJuID0+IFsKK3sKKyAgICBuYW1lID0+ICJkb2N1bWVudGF0aW9uIiwKKyAgICBw cm9wZXJ0eUNoYW5nZURlbHRhID0+IC0xLCAjIFNpbmNlIHdlIG9ubHkgaW50ZXJwcmV0IHRoZSAn LScgcHJvcGVydHkuCisgICAgdmFsdWUgPT4gIkFcbmxvbmcgc2VudGVuY2UgdGhhdCBzcGFuc1xu bXVsdGlwbGUgbGluZXMuIiwKK30sCisiXG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+ICIg ICArIEFub3RoZXJcbiIsCit9LAorKTsKKworbXkgJHRlc3RDYXNlc0NvdW50ID0gQHRlc3RDYXNl SGFzaFJlZnM7CitwbGFuKHRlc3RzID0+IDIgKiAkdGVzdENhc2VzQ291bnQpOyAjIFRvdGFsIG51 bWJlciBvZiBhc3NlcnRpb25zLgorCitmb3JlYWNoIG15ICR0ZXN0Q2FzZSAoQHRlc3RDYXNlSGFz aFJlZnMpIHsKKyAgICBteSAkdGVzdE5hbWVTdGFydCA9ICJwYXJzZVN2blByb3BlcnR5KCk6ICR0 ZXN0Q2FzZS0+e2RpZmZOYW1lfTogY29tcGFyaW5nIjsKKworICAgIG15ICRmaWxlSGFuZGxlOwor ICAgIG9wZW4oJGZpbGVIYW5kbGUsICI8IiwgXCR0ZXN0Q2FzZS0+e2lucHV0VGV4dH0pOworICAg IG15ICRsaW5lID0gPCRmaWxlSGFuZGxlPjsKKworICAgIG15IEBnb3QgPSBWQ1NVdGlsczo6cGFy c2VTdm5Qcm9wZXJ0eSgkZmlsZUhhbmRsZSwgJGxpbmUpOworICAgIG15ICRleHBlY3RlZFJldHVy biA9ICR0ZXN0Q2FzZS0+e2V4cGVjdGVkUmV0dXJufTsKKworICAgIGlzX2RlZXBseShcQGdvdCwg JGV4cGVjdGVkUmV0dXJuLCAiJHRlc3ROYW1lU3RhcnQgcmV0dXJuIHZhbHVlLiIpOworCisgICAg bXkgJGdvdE5leHRMaW5lID0gPCRmaWxlSGFuZGxlPjsKKyAgICBpcygkZ290TmV4dExpbmUsICR0 ZXN0Q2FzZS0+e2V4cGVjdGVkTmV4dExpbmV9LCAgIiR0ZXN0TmFtZVN0YXJ0IG5leHQgcmVhZCBs aW5lLiIpOworfQpJbmRleDogV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRwZXJsL1ZDU1V0aWxz X3VuaXR0ZXN0L3BhcnNlU3ZuUHJvcGVydHlWYWx1ZS5wbAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHBlcmwvVkNTVXRpbHNfdW5pdHRlc3QvcGFyc2VTdm5Qcm9wZXJ0 eVZhbHVlLnBsCShyZXZpc2lvbiA1OTU3OSkKKysrIFdlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cGVybC9WQ1NVdGlsc191bml0dGVzdC9wYXJzZVN2blByb3BlcnR5VmFsdWUucGwJKHdvcmtpbmcg Y29weSkKQEAgLTU4LDcgKzU4LDcgQEAgRU5ECiB9LAogewogICAgICMgTmV3IHRlc3QKLSAgICBk aWZmTmFtZSA9PiAic2ltcGxlIG11bHRpLWxpbmUgJy0nIGNoYW5nZSIsCisgICAgZGlmZk5hbWUg PT4gInNpbmdsZS1saW5lICctJyBjaGFuZ2UgZm9sbG93ZWQgYnkgZW1wdHkgbGluZSIsCiAgICAg aW5wdXRUZXh0ID0+IDw8J0VORCcsCiAgICAtICoKIApAQCAtNjgsNiArNjgsMTYgQEAgRU5ECiB9 LAogewogICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9PiAic2luZ2xlLWxpbmUgJy0nIGNo YW5nZSBmb2xsb3dlZCBieSB0aGUgbmV4dCBwcm9wZXJ0eSIsCisgICAgaW5wdXRUZXh0ID0+IDw8 J0VORCcsCisgICAtICoKK0RlbGV0ZWQ6IHN2bjpleGVjdXRhYmxlCitFTkQKKyAgICBleHBlY3Rl ZFJldHVybiA9PiBbIioiLCAiRGVsZXRlZDogc3ZuOmV4ZWN1dGFibGVcbiJdLAorICAgIGV4cGVj dGVkTmV4dExpbmUgPT4gdW5kZWYsCit9LAoreworICAgICMgTmV3IHRlc3QKICAgICBkaWZmTmFt ZSA9PiAibXVsdGktbGluZSAnKycgY2hhbmdlIGFuZCBzdGFydCBvZiBiaW5hcnkgcGF0Y2giLAog ICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAogICAgKyBBCkBAIC05Myw2ICsxMDMsMTggQEAgRU5E CiB9LAogewogICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9PiAibXVsdGktbGluZSAnLScg Y2hhbmdlIGZvbGxvd2VkIGJ5IHRoZSBuZXh0IHByb3BlcnR5IiwKKyAgICBpbnB1dFRleHQgPT4g PDwnRU5EJywKKyAgIC0gQQorbG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zCittdWx0aXBsZSBsaW5l cy4KK0FkZGVkOiBzdm46ZXhlY3V0YWJsZQorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWyJB XG5sb25nIHNlbnRlbmNlIHRoYXQgc3BhbnNcbm11bHRpcGxlIGxpbmVzLiIsICJBZGRlZDogc3Zu OmV4ZWN1dGFibGVcbiJdLAorICAgIGV4cGVjdGVkTmV4dExpbmUgPT4gdW5kZWYsCit9LAorewor ICAgICMgTmV3IHRlc3QKICAgICBkaWZmTmFtZSA9PiAibXVsdGktbGluZSAnLScgY2hhbmdlIGZv bGxvd2VkIGJ5ICcrJyBtdWx0aS1saW5lIGNoYW5nZSIsCiAgICAgaW5wdXRUZXh0ID0+IDw8J0VO RCcsCiAgICAtIEEK 56212 2010-05-16 22:21:03 -0700 2010-05-16 22:36:30 -0700 Patch with unit tests Bug39184_4.patch text/plain 19240 dbates SW5kZXg6IFdlYktpdFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9D aGFuZ2VMb2cJKHJldmlzaW9uIDU5NTkxKQorKysgV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTAtMDUtMTYgIERhbmllbCBCYXRlcyAgPGRi YXRlc0ByaW0uY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zOTE4NAorCisg ICAgICAgIEFkZHMgZnVuY3Rpb24gVkNTVXRpbHM6OnBhcnNlU3ZuUHJvcGVydHkgdG8gcGFyc2Ug YW4gU1ZOIHByb3BlcnR5IHdpdGgKKyAgICAgICAgZWl0aGVyIGEgc2luZ2xlLWxpbmUgb3IgbXVs dGktbGluZSB2YWx1ZSBjaGFuZ2UuCisKKyAgICAgICAgKiBTY3JpcHRzL1ZDU1V0aWxzLnBtOgor ICAgICAgICAgIC0gQWRkZWQgZnVuY3Rpb24gcGFyc2VTdm5Qcm9wZXJ0eS4gV2Ugd2lsbCB1c2Ug dGhpcyBmdW5jdGlvbgorICAgICAgICAgICAgdG93YXJkcyByZXNvbHZpbmcgQnVnICMzODg4NSA8 aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4ODg1Pi4KKyAgICAgICAg ICAtIFJlbW92ZWQgRklYTUUgY29tbWVudCBhYm92ZSBmdW5jdGlvbiBwYXJzZVN2blByb3BlcnR5 VmFsdWUsIHNpbmNlCisgICAgICAgICAgICBpdCBpcyBiZWluZyB1c2VkIGJ5IHBhcnNlU3ZuUHJv cGVydHkuCisgICAgICAgICAgLSBNb2RpZmllZCBmdW5jdGlvbiBwYXJzZVN2blByb3BlcnR5VmFs dWUgdG8gYnJlYWsgb3V0IG9mICJ3aGlsZSAoPCRmaWxlSGFuZGxlPikiCisgICAgICAgICAgICBs b29wIHdoZW4gaXQgZW5jb3VudGVycyB0aGUgc3RhcnQgb2YgdGhlIG5leHQgcHJvcGVydHkgc28g dGhhdCBpdCBjYW4gYmUKKyAgICAgICAgICAgIHByb2Nlc3NlZCBieSBpdHMgY2FsbGVyLCBwYXJz ZVN2blByb3BlcnR5VmFsdWUuIFdlIHJlZmVyZW5jZSB0aGlzIGJ1bGxldCBiZWxvdworICAgICAg ICAgICAgYnkgKCopLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cGVybC9WQ1NVdGlsc191bml0 dGVzdC9wYXJzZVN2blByb3BlcnR5LnBsOiBBZGRlZC4KKyAgICAgICAgICAtIEFkZGVkIHVuaXQg dGVzdHMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0ZXN0L3Bh cnNlU3ZuUHJvcGVydHlWYWx1ZS5wbDoKKyAgICAgICAgICAtIENoYW5nZWQgdGhlIG5hbWUgb2Yg dGhlIHVuaXQgdGVzdCAic2ltcGxlIG11bHRpLWxpbmUgJy0nIGNoYW5nZSIgdG8KKyAgICAgICAg ICAgICJzaW5nbGUtbGluZSAnLScgY2hhbmdlIGZvbGxvd2VkIGJ5IGVtcHR5IGxpbmUiIHNpbmNl IHRoZSBmb3JtZXIgd2FzIGFuCisgICAgICAgICAgICBpbmNvcnJlY3QgZGVzY3JpcHRpb24gb2Yg dGhpcyB0ZXN0LgorICAgICAgICAgIC0gQWRkZWQgdW5pdCB0ZXN0ICJzaW5nbGUtbGluZSAnLScg Y2hhbmdlIGZvbGxvd2VkIGJ5IHRoZSBuZXh0IHByb3BlcnR5IiwgYW5kCisgICAgICAgICAgICAi bXVsdGktbGluZSAnLScgY2hhbmdlIGZvbGxvd2VkIGJ5IHRoZSBuZXh0IHByb3BlcnR5IiB0byB0 ZXN0ICgqKSBhYm92ZS4KKwogMjAxMC0wNS0xNiAgVG9ueSBDaGFuZyAgPHRvbnlAY2hyb21pdW0u b3JnPgogCiAgICAgICAgIE5vdCByZXZpZXdlZCwgZml4aW5nIGxheW91dCB0ZXN0LgpJbmRleDog V2ViS2l0VG9vbHMvU2NyaXB0cy9WQ1NVdGlscy5wbQo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29s cy9TY3JpcHRzL1ZDU1V0aWxzLnBtCShyZXZpc2lvbiA1OTU5MSkKKysrIFdlYktpdFRvb2xzL1Nj cmlwdHMvVkNTVXRpbHMucG0JKHdvcmtpbmcgY29weSkKQEAgLTkwLDYgKzkwLDcgQEAgbXkgJGNo YW5nZUxvZ1RpbWVab25lID0gIlBTVDhQRFQiOwogCiBteSAkZ2l0RGlmZlN0YXJ0UmVnRXggPSBx ciNeZGlmZiAtLWdpdCAoXHcvKT8oLispIChcdy8pPyhbXlxyXG5dKykjOwogbXkgJHN2bkRpZmZT dGFydFJlZ0V4ID0gcXIjXkluZGV4OiAoW15cclxuXSspIzsKK215ICRzdm5Qcm9wZXJ0eVN0YXJ0 UmVnRXggPSBxciNeKE1vZGlmaWVkfE5hbWV8QWRkZWR8RGVsZXRlZCk6IChbXlxyXG5dKykjOyAj ICQyIGlzIHRoZSBuYW1lIG9mIHRoZSBwcm9wZXJ0eS4KIG15ICRzdm5Qcm9wZXJ0eVZhbHVlU3Rh cnRSZWdFeCA9IHFyI14gICAoXCt8LSkgKFteXHJcbl0rKSM7ICMgJDIgaXMgdGhlIHN0YXJ0IG9m IHRoZSBwcm9wZXJ0eSdzIHZhbHVlICh3aGljaCBtYXkgc3BhbiBtdWx0aXBsZSBsaW5lcykuCiAK ICMgVGhpcyBtZXRob2QgaXMgZm9yIHBvcnRhYmlsaXR5LiBSZXR1cm4gdGhlIHN5c3RlbS1hcHBy b3ByaWF0ZSBleGl0CkBAIC04MzcsNiArODM4LDEwNCBAQCBzdWIgcGFyc2VEaWZmKCQkKQogICAg IHJldHVybiAoXEBkaWZmSGFzaFJlZnMsICRsaW5lKTsKIH0KIAorIyBQYXJzZSB0aGUgbmV4dCBT Vk4gcHJvcGVydHkgZnJvbSB0aGUgZ2l2ZW4gZmlsZSBoYW5kbGUsIGFuZCBhZHZhbmNlIHRoZSBo YW5kbGUgc28gdGhlIGxhc3QKKyMgbGluZSByZWFkIGlzIHRoZSBmaXJzdCBsaW5lIGFmdGVyIHRo ZSBwcm9wZXJ0eS4KKyMKKyMgVGhpcyBzdWJyb3V0aW5lIGRpZXMgaWYgdGhlIGZpcnN0IGxpbmUg aXMgbm90IGEgdmFsaWQgc3RhcnQgb2YgYW4gU1ZOIHByb3BlcnR5LAorIyBvciB0aGUgcHJvcGVy dHkgaXMgbWlzc2luZyBhIHZhbHVlLCBvciB0aGUgcHJvcGVydHkgY2hhbmdlIHR5cGUgKGUuZy4g IkFkZGVkIikKKyMgZG9lcyBub3QgY29ycmVzcG9uZCB0byB0aGUgcHJvcGVydHkgdmFsdWUgdHlw ZSAoZS5nLiAiKyIpLgorIworIyBBcmdzOgorIyAgICRmaWxlSGFuZGxlOiBhZHZhbmNlZCBzbyB0 aGUgbGFzdCBsaW5lIHJlYWQgZnJvbSB0aGUgaGFuZGxlIGlzIHRoZSBmaXJzdAorIyAgICAgICAg ICAgICAgICBsaW5lIG9mIHRoZSBwcm9wZXJ0eSB0byBwYXJzZS4gIFRoaXMgc2hvdWxkIGJlIGEg bGluZQorIyAgICAgICAgICAgICAgICB0aGF0IG1hdGNoZXMgJHN2blByb3BlcnR5U3RhcnRSZWdF eC4KKyMgICAkbGluZTogdGhlIGxpbmUgbGFzdCByZWFkIGZyb20gJGZpbGVIYW5kbGUuCisjCisj IFJldHVybnMgKCRwcm9wZXJ0eUhhc2hSZWYsICRsYXN0UmVhZExpbmUpOgorIyAgICRwcm9wZXJ0 eUhhc2hSZWY6IGEgaGFzaCByZWZlcmVuY2UgcmVwcmVzZW50aW5nIGEgU1ZOIHByb3BlcnR5Lgor IyAgICAgbmFtZTogdGhlIG5hbWUgb2YgdGhlIHByb3BlcnR5LgorIyAgICAgdmFsdWU6IHRoZSBs YXN0IHByb3BlcnR5IHZhbHVlLiAgRm9yIGluc3RhbmNlLCBzdXBwb3NlIHRoZSBwcm9wZXJ0eSBp cyAiTW9kaWZpZWQiLgorIyAgICAgICAgICAgIFRoZW4gaXQgaGFzIGJvdGggYSAnLScgYW5kICcr JyBwcm9wZXJ0eSB2YWx1ZSBpbiB0aGF0IG9yZGVyLiAgVGhlcmVmb3JlLAorIyAgICAgICAgICAg IHRoZSB2YWx1ZSBvZiB0aGlzIGtleSBpcyB0aGUgdmFsdWUgb2YgdGhlICcrJyBwcm9wZXJ0eSBi eSBvcmRlcmluZyAoc2luY2UKKyMgICAgICAgICAgICBpdCBpcyB0aGUgbGFzdC1tb3N0IHZhbHVl KS4KKyMgICAgIHByb3BlcnR5Q2hhbmdlRGVsdGE6IHRoZSB2YWx1ZSAxIG9yIC0xIGlmIHRoZSBw cm9wZXJ0eSB3YXMgYWRkZWQgb3IKKyMgICAgICAgICAgICAgICAgICAgICAgICAgIHJlbW92ZWQs IHJlc3BlY3RpdmVseS4KKyMgICAkbGFzdFJlYWRMaW5lOiB0aGUgbGluZSBsYXN0IHJlYWQgZnJv bSAkZmlsZUhhbmRsZS4KKyMKKyMgRklYTUU6IFRoaXMgbWV0aG9kIGlzIHVudXNlZCBhcyBvZiAo MDUvMTYvMjAxMCkuICBXZSB3aWxsIGNhbGwgdGhpcyBmdW5jdGlvbgorIyAgICAgICAgYXMgcGFy dCBvZiBwYXJzaW5nIGEgU1ZOIGZvb3Rlci4gIFNlZSA8aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTM4ODg1Pi4KK3N1YiBwYXJzZVN2blByb3BlcnR5KCQkKQoreworICAg IG15ICgkZmlsZUhhbmRsZSwgJGxpbmUpID0gQF87CisKKyAgICAkXyA9ICRsaW5lOworCisgICAg bXkgJHByb3BlcnR5TmFtZTsKKyAgICBteSAkcHJvcGVydHlDaGFuZ2VUeXBlOworICAgIGlmICgv JHN2blByb3BlcnR5U3RhcnRSZWdFeC8pIHsKKyAgICAgICAgJHByb3BlcnR5Q2hhbmdlVHlwZSA9 ICQxOworICAgICAgICAkcHJvcGVydHlOYW1lID0gJDI7CisgICAgfSBlbHNlIHsKKyAgICAgICAg ZGllKCJGYWlsZWQgdG8gZmluZCBTVk4gcHJvcGVydHk6IFwiJF9cIi4iKTsKKyAgICB9CisKKyAg ICAkXyA9IDwkZmlsZUhhbmRsZT47ICMgTm90IGRlZmluZWQgaWYgZW5kLW9mLWZpbGUgcmVhY2hl ZC4KKworICAgICMgVGhlICJzdm4gZGlmZiIgY29tbWFuZCBuZWl0aGVyIGluc2VydHMgbmV3IGxp bmUgY2hhcmFjdGVycyBiZXR3ZWVuIHByb3BlcnR5IHZhbHVlcworICAgICMgbm9yIGJldHdlZW4g c3VjY2Vzc2l2ZSBwcm9wZXJ0aWVzLgorICAgICMKKyAgICAjIEZJWE1FOiBXZSBkbyBub3Qgc3Vw cG9ydCBwcm9wZXJ0eSB2YWx1ZXMgdGhhdCBjb250YWluIHRhaWxpbmcgbmV3IGxpbmUgY2hhcmFj dGVycworICAgICMgICAgICAgIGFzIGl0IGlzIGRpZmZpY3VsdCB0byBkaXNhbWJpZ3VhdGUgdGhl c2UgdHJhaWxpbmcgbmV3IGxpbmVzIGZyb20gdGhlIGVtcHR5CisgICAgIyAgICAgICAgbGluZSB0 aGF0IHByZWNlZWRzIHRoZSBjb250ZW50cyBvZiBhIGJpbmFyeSBwYXRjaC4KKyAgICBteSAkcHJv cGVydHlWYWx1ZTsKKyAgICBteSAkcHJvcGVydHlWYWx1ZVR5cGU7CisgICAgd2hpbGUgKGRlZmlu ZWQoJF8pICYmIC8kc3ZuUHJvcGVydHlWYWx1ZVN0YXJ0UmVnRXgvKSB7CisgICAgICAgICMgTm90 ZSwgYSAnLScgcHJvcGVydHkgbWF5IGJlIGZvbGxvd2VkIGJ5ICcrJyBwcm9wZXJ0eSBpbiB0aGUg Y2FzZSBvZiBhICJNb2RpZmllZCIKKyAgICAgICAgIyBvciAiTmFtZSIgcHJvcGVydHkuICBXZSBv bmx5IGNhcmUgYWJvdXQgdGhlIGVuZGluZyB2YWx1ZSAoaS5lLiB0aGUgJysnIHByb3BlcnR5KQor ICAgICAgICAjIGluIHN1Y2ggY2lyY3Vtc3RhbmNlcy4gIFNvLCB3ZSB0YWtlIHRoZSBwcm9wZXJ0 eSB2YWx1ZSBmb3IgdGhlIHByb3BlcnR5IHRvIGJlIGl0cworICAgICAgICAjIGxhc3QgcGFyc2Vk IHByb3BlcnR5IHZhbHVlLgorICAgICAgICAjCisgICAgICAgICMgRklYTUU6IFdlIG1heSB3YW50 IHRvIGNvbnNpZGVyIHN0cmljdGx5IGVuZm9yY2luZyBhICctJywgJysnIHByb3BlcnR5IG9yZGVy aW5nIG9yCisgICAgICAgICMgICAgICAgIGFkZCBlcnJvciBjaGVja2luZyB0byBwcmV2ZW50ICcr JywgJysnLCAuLi4sICcrJyBhbmQgb3RoZXIgaW52YWxpZCBjb21iaW5hdGlvbnMuCisgICAgICAg ICRwcm9wZXJ0eVZhbHVlVHlwZSA9ICQxOworICAgICAgICAoJHByb3BlcnR5VmFsdWUsICRfKSA9 IHBhcnNlU3ZuUHJvcGVydHlWYWx1ZSgkZmlsZUhhbmRsZSwgJF8pOworICAgIH0KKworICAgIGlm ICghJHByb3BlcnR5VmFsdWUpIHsKKyAgICAgICAgZGllKCJGYWlsZWQgdG8gZmluZCB0aGUgcHJv cGVydHkgdmFsdWUgZm9yIHRoZSBTVk4gcHJvcGVydHkgXCIkcHJvcGVydHlOYW1lXCI6IFwiJF9c Ii4iKTsKKyAgICB9CisKKyAgICBteSAkcHJvcGVydHlDaGFuZ2VEZWx0YTsKKyAgICBpZiAoJHBy b3BlcnR5VmFsdWVUeXBlIGVxICcrJykgeworICAgICAgICAkcHJvcGVydHlDaGFuZ2VEZWx0YSA9 IDE7CisgICAgfSBlbHNpZiAoJHByb3BlcnR5VmFsdWVUeXBlIGVxICctJykgeworICAgICAgICAk cHJvcGVydHlDaGFuZ2VEZWx0YSA9IC0xOworICAgIH0gZWxzZSB7CisgICAgICAgICMgTm90IHJl YWNoZWQuCisgICAgICAgIGRpZTsKKyAgICB9CisKKyAgICAjIFdlIHBlcmZvcm0gYSBzaW1wbGUg dmFsaWRhdGlvbiB0aGF0IGFuICJBZGRlZCIgb3IgIkRlbGV0ZWQiIHByb3BlcnR5CisgICAgIyBj aGFuZ2UgdHlwZSBjb3JyZXNwb25kcyB3aXRoIGEgIisiIGFuZCAiLSIgdmFsdWUgdHlwZSwgcmVz cGVjdGl2ZWx5LgorICAgIG15ICRleHBlY3RlZENoYW5nZURlbHRhOworICAgIGlmICgkcHJvcGVy dHlDaGFuZ2VUeXBlIGVxICJBZGRlZCIpIHsKKyAgICAgICAgJGV4cGVjdGVkQ2hhbmdlRGVsdGEg PSAxOworICAgIH0gZWxzaWYgKCRwcm9wZXJ0eUNoYW5nZVR5cGUgZXEgIkRlbGV0ZWQiKSB7Cisg ICAgICAgICRleHBlY3RlZENoYW5nZURlbHRhID0gLTE7CisgICAgfQorCisgICAgaWYgKCRleHBl Y3RlZENoYW5nZURlbHRhICYmICRwcm9wZXJ0eUNoYW5nZURlbHRhICE9ICRleHBlY3RlZENoYW5n ZURlbHRhKSB7CisgICAgICAgIGRpZSgiVGhlIGZpbmFsIHByb3BlcnR5IHZhbHVlIHR5cGUgZm91 bmQgXCIkcHJvcGVydHlWYWx1ZVR5cGVcIiBkb2VzIG5vdCAiIC4KKyAgICAgICAgICAgICJjb3Jy ZXNwb25kIHRvIHRoZSBwcm9wZXJ0eSBjaGFuZ2UgdHlwZSBmb3VuZCBcIiRwcm9wZXJ0eUNoYW5n ZVR5cGVcIi4iKTsKKyAgICB9CisKKyAgICBteSAlcHJvcGVydHlIYXNoOworICAgICRwcm9wZXJ0 eUhhc2h7bmFtZX0gPSAkcHJvcGVydHlOYW1lOworICAgICRwcm9wZXJ0eUhhc2h7cHJvcGVydHlD aGFuZ2VEZWx0YX0gPSAkcHJvcGVydHlDaGFuZ2VEZWx0YTsKKyAgICAkcHJvcGVydHlIYXNoe3Zh bHVlfSA9ICRwcm9wZXJ0eVZhbHVlOworICAgIHJldHVybiAoXCVwcm9wZXJ0eUhhc2gsICRfKTsK K30KKwogIyBQYXJzZSB0aGUgdmFsdWUgb2YgYW4gU1ZOIHByb3BlcnR5IGZyb20gdGhlIGdpdmVu IGZpbGUgaGFuZGxlLCBhbmQgYWR2YW5jZQogIyB0aGUgaGFuZGxlIHNvIHRoZSBsYXN0IGxpbmUg cmVhZCBpcyB0aGUgZmlyc3QgbGluZSBhZnRlciB0aGUgcHJvcGVydHkgdmFsdWUuCiAjCkBAIC04 NDcsMTQgKzk0NiwxMSBAQCBzdWIgcGFyc2VEaWZmKCQkKQogIyAgICRmaWxlSGFuZGxlOiBhZHZh bmNlZCBzbyB0aGUgbGFzdCBsaW5lIHJlYWQgZnJvbSB0aGUgaGFuZGxlIGlzIHRoZSBmaXJzdAog IyAgICAgICAgICAgICAgICBsaW5lIG9mIHRoZSBwcm9wZXJ0eSB2YWx1ZSB0byBwYXJzZS4gIFRo aXMgc2hvdWxkIGJlIGEgbGluZQogIyAgICAgICAgICAgICAgICBiZWdpbm5pbmcgd2l0aCAiICAg KyIgb3IgIiAgIC0iLgotIyAgICRsaW5lOiB0aGUgbGluZSBsYXN0IHJlYWQgZnJvbSAkZmlsZUhh bmRsZQorIyAgICRsaW5lOiB0aGUgbGluZSBsYXN0IHJlYWQgZnJvbSAkZmlsZUhhbmRsZS4KICMK ICMgUmV0dXJucyAoJHByb3BlcnR5VmFsdWUsICRsYXN0UmVhZExpbmUpOgogIyAgICRwcm9wZXJ0 eVZhbHVlOiB0aGUgdmFsdWUgb2YgdGhlIHByb3BlcnR5LgogIyAgICRsYXN0UmVhZExpbmU6IHRo ZSBsaW5lIGxhc3QgcmVhZCBmcm9tICRmaWxlSGFuZGxlLgotIwotIyBGSVhNRTogVGhpcyBtZXRo b2QgaXMgdW51c2VkIGFzIG9mICgwNS8xNS8yMDEwKS4gV2Ugd2lsbCBjYWxsIHRoaXMgZnVuY3Rp b24KLSMgICAgICAgIGFzIHBhcnQgb2YgcGFyc2luZyBhIHByb3BlcnR5IGZyb20gdGhlIFNWTiBm b290ZXIuIFNlZSA8aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4ODg1 Pi4KIHN1YiBwYXJzZVN2blByb3BlcnR5VmFsdWUoJCQpCiB7CiAgICAgbXkgKCRmaWxlSGFuZGxl LCAkbGluZSkgPSBAXzsKQEAgLTg3MSwxMiArOTY3LDE1IEBAIHN1YiBwYXJzZVN2blByb3BlcnR5 VmFsdWUoJCQpCiAgICAgfQogCiAgICAgd2hpbGUgKDwkZmlsZUhhbmRsZT4pIHsKLSAgICAgICAg aWYgKC9eJC8gfHwgLyRzdm5Qcm9wZXJ0eVZhbHVlU3RhcnRSZWdFeC8pIHsKKyAgICAgICAgaWYg KC9eJC8gfHwgLyRzdm5Qcm9wZXJ0eVZhbHVlU3RhcnRSZWdFeC8gfHwgLyRzdm5Qcm9wZXJ0eVN0 YXJ0UmVnRXgvKSB7CiAgICAgICAgICAgICAjIE5vdGUsIHdlIG1heSBlbmNvdW50ZXIgYW4gZW1w dHkgbGluZSBiZWZvcmUgdGhlIGNvbnRlbnRzIG9mIGEgYmluYXJ5IHBhdGNoLgogICAgICAgICAg ICAgIyBBbHNvLCB3ZSBjaGVjayBmb3IgJHN2blByb3BlcnR5VmFsdWVTdGFydFJlZ0V4IGJlY2F1 c2UgYSAnLScgcHJvcGVydHkgbWF5IGJlCiAgICAgICAgICAgICAjIGZvbGxvd2VkIGJ5IGEgJysn IHByb3BlcnR5IGluIHRoZSBjYXNlIG9mIGEgIk1vZGlmaWVkIiBvciAiTmFtZSIgcHJvcGVydHku CisgICAgICAgICAgICAjIFdlIGNoZWNrIGZvciAkc3ZuUHJvcGVydHlTdGFydFJlZ0V4IGJlY2F1 c2UgaXQgaW5kaWNhdGVzIHRoZSBzdGFydCBvZiB0aGUKKyAgICAgICAgICAgICMgbmV4dCBwcm9w ZXJ0eSB0byBwYXJzZS4KICAgICAgICAgICAgIGxhc3Q7CiAgICAgICAgIH0KKwogICAgICAgICAj IFRlbXBvcmFyaWx5IHN0cmlwIG9mZiBhbnkgZW5kLW9mLWxpbmUgY2hhcmFjdGVycy4gV2UgYWRk IHRoZSBlbmQtb2YtbGluZSBjaGFyYWN0ZXJzCiAgICAgICAgICMgZnJvbSB0aGUgcHJldmlvdXNs eSBwcm9jZXNzZWQgbGluZSB0byB0aGUgc3RhcnQgb2YgdGhpcyBsaW5lIHNvIHRoYXQgdGhlIGxh c3QgbGluZQogICAgICAgICAjIG9mIHRoZSBwcm9wZXJ0eSB2YWx1ZSBkb2VzIG5vdCBlbmQgaW4g ZW5kLW9mLWxpbmUgY2hhcmFjdGVycy4KSW5kZXg6IFdlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cGVybC9WQ1NVdGlsc191bml0dGVzdC9wYXJzZVN2blByb3BlcnR5LnBsCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cGVybC9WQ1NVdGlsc191bml0dGVzdC9wYXJzZVN2 blByb3BlcnR5LnBsCShyZXZpc2lvbiAwKQorKysgV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw ZXJsL1ZDU1V0aWxzX3VuaXR0ZXN0L3BhcnNlU3ZuUHJvcGVydHkucGwJKHJldmlzaW9uIDApCkBA IC0wLDAgKzEsMzQwIEBACisjIS91c3IvYmluL3BlcmwgLXcKKyMKKyMgQ29weXJpZ2h0IChDKSBS ZXNlYXJjaCBpbiBNb3Rpb24gTGltaXRlZCAyMDEwLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorIyBD b3B5cmlnaHQgKEMpIDIwMTAgQ2hyaXMgSmVyZG9uZWsgKGNocmlzLmplcmRvbmVrQGdtYWlsLmNv bSkKKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMgbWV0OgorIworIyAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorIyBpbiB0aGUgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisjIGRpc3RyaWJ1 dGlvbi4KKyMgICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBBcHBsZSBDb21wdXRlciwgSW5jLiAo IkFwcGxlIikgbm9yIHRoZSBuYW1lcyBvZgorIyBpdHMgY29udHJpYnV0b3JzIG1heSBiZSB1c2Vk IHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCisjIGZyb20gdGhpcyBzb2Z0 d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyMKKyMgVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRS SUJVVE9SUworIyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQQVJUSUNVTEFSIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyMgT1dO RVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsCisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VT IChJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisjIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorIyBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUCisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCisjIFVuaXQgdGVzdHMg b2YgcGFyc2VTdm5Qcm9wZXJ0eSgpLgorCit1c2Ugc3RyaWN0OwordXNlIHdhcm5pbmdzOworCit1 c2UgVGVzdDo6TW9yZTsKK3VzZSBWQ1NVdGlsczsKKworbXkgQHRlc3RDYXNlSGFzaFJlZnMgPSAo CisjIyMjCisjIFNpbXBsZSB0ZXN0IGNhc2VzCisjIworeworICAgICMgTmV3IHRlc3QKKyAgICBk aWZmTmFtZSA9PiAic2ltcGxlOiBhZGQgc3ZuOmV4ZWN1dGFibGUiLAorICAgIGlucHV0VGV4dCA9 PiA8PCdFTkQnLAorQWRkZWQ6IHN2bjpleGVjdXRhYmxlCisgICArICoKK0VORAorICAgIGV4cGVj dGVkUmV0dXJuID0+IFsKK3sKKyAgICBuYW1lID0+ICJzdm46ZXhlY3V0YWJsZSIsCisgICAgcHJv cGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVlID0+ICIqIiwKK30sCit1bmRlZl0sCisg ICAgZXhwZWN0ZWROZXh0TGluZSA9PiB1bmRlZiwKK30sCit7CisgICAgIyBOZXcgdGVzdAorICAg IGRpZmZOYW1lID0+ICJzaW1wbGU6IGRlbGV0ZSBzdm46ZXhlY3V0YWJsZSIsCisgICAgaW5wdXRU ZXh0ID0+IDw8J0VORCcsCitEZWxldGVkOiBzdm46ZXhlY3V0YWJsZQorICAgLSAqCitFTkQKKyAg ICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAic3ZuOmV4ZWN1dGFibGUiLAor ICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gLTEsCisgICAgdmFsdWUgPT4gIioiLAorfSwKK3Vu ZGVmXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+IHVuZGVmLAorfSwKKyMjIyMKKyMgVXNpbmcg U1ZOIDEuNCBzeW50YXgKKyMjCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJz aW1wbGU6IGRlbGV0ZSBzdm46ZXhlY3V0YWJsZSB1c2luZyBTVk4gMS40IHN5bnRheCIsCisgICAg aW5wdXRUZXh0ID0+IDw8J0VORCcsCitOYW1lOiBzdm46ZXhlY3V0YWJsZQorICAgLSAqCitFTkQK KyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAic3ZuOmV4ZWN1dGFibGUi LAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gLTEsCisgICAgdmFsdWUgPT4gIioiLAorfSwK K3VuZGVmXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+IHVuZGVmLAorfSwKK3sKKyAgICAjIE5l dyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gInNpbXBsZTogYWRkIHN2bjpleGVjdXRhYmxlIHVzaW5n IFNWTiAxLjQgc3ludGF4IiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK05hbWU6IHN2bjpl eGVjdXRhYmxlCisgICArICoKK0VORAorICAgIGV4cGVjdGVkUmV0dXJuID0+IFsKK3sKKyAgICBu YW1lID0+ICJzdm46ZXhlY3V0YWJsZSIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAor ICAgIHZhbHVlID0+ICIqIiwKK30sCit1bmRlZl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiB1 bmRlZiwKK30sCisjIyMjCisjIFByb3BlcnR5IHZhbHVlIGZvbGxvd2VkIGJ5IGVtcHR5IGxpbmUg YW5kIHN0YXJ0IG9mIGJpbmFyeSBwYXRjaAorIyMKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlm Zk5hbWUgPT4gImFkZCBzdm46ZXhlY3V0YWJsZSwgZm9sbG93ZWQgYnkgZW1wdHkgbGluZSBhbmQg c3RhcnQgb2YgYmluYXJ5IHBhdGNoIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK0FkZGVk OiBzdm46ZXhlY3V0YWJsZQorICAgKyAqCisKK1ExZFRCeDBBQUFCNDJpdGc0R2xnWUpqR3dNRER5 T0RNeE1EdzM0R0JnUUVBSlBRREpBPT0KK0VORAorICAgIGV4cGVjdGVkUmV0dXJuID0+IFsKK3sK KyAgICBuYW1lID0+ICJzdm46ZXhlY3V0YWJsZSIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9 PiAxLAorICAgIHZhbHVlID0+ICIqIiwKK30sCisiXG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5l ID0+ICJRMWRUQngwQUFBQjQyaXRnNEdsZ1lKakd3TUREeU9ETXhNRHczNEdCZ1FFQUpQUURKQT09 XG4iLAorfSwKK3sKKyAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gIm11bHRpLWxpbmUg JysnIGNoYW5nZSwgZm9sbG93ZWQgYnkgZW1wdHkgbGluZSBhbmQgc3RhcnQgb2YgYmluYXJ5IHBh dGNoIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK05hbWU6IGRvY3VtZW50YXRpb24KKyAg ICsgQQorbG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zCittdWx0aXBsZSBsaW5lcy4KKworUTFkVEJ4 MEFBQUI0Mml0ZzRHbGdZSmpHd01ERHlPRE14TUR3MzRHQmdRRUFKUFFESkE9PQorRU5ECisgICAg ZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4gImRvY3VtZW50YXRpb24iLAorICAg IHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gMSwKKyAgICB2YWx1ZSA9PiAiQVxubG9uZyBzZW50ZW5j ZSB0aGF0IHNwYW5zXG5tdWx0aXBsZSBsaW5lcy4iLAorfSwKKyJcbiJdLAorICAgIGV4cGVjdGVk TmV4dExpbmUgPT4gIlExZFRCeDBBQUFCNDJpdGc0R2xnWUpqR3dNRER5T0RNeE1EdzM0R0JnUUVB SlBRREpBPT1cbiIsCit9LAoreworICAgICMgTmV3IHRlc3QKKyAgICBkaWZmTmFtZSA9PiAibXVs dGktbGluZSAnLScgY2hhbmdlLCBmb2xsb3dlZCBieSBtdWx0aS1saW5lICcrJyBjaGFuZ2UsIGVt cHR5IGxpbmUsIGFuZCBzdGFydCBvZiBiaW5hcnkgcGF0Y2giLAorICAgIGlucHV0VGV4dCA9PiA8 PCdFTkQnLAorTW9kaWZpZWQ6IGRvY3VtZW50YXRpb24KKyAgIC0gQQorbG9uZyBzZW50ZW5jZSB0 aGF0IHNwYW5zCittdWx0aXBsZSBsaW5lcy4KKyAgICsgQW5vdGhlcgorbG9uZyBzZW50ZW5jZSB0 aGF0IHNwYW5zCittdWx0aXBsZSBsaW5lcy4KKworUTFkVEJ4MEFBQUI0Mml0ZzRHbGdZSmpHd01E RHlPRE14TUR3MzRHQmdRRUFKUFFESkE9PQorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWwor eworICAgIG5hbWUgPT4gImRvY3VtZW50YXRpb24iLAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEg PT4gMSwKKyAgICB2YWx1ZSA9PiAiQW5vdGhlclxubG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zXG5t dWx0aXBsZSBsaW5lcy4iLAorfSwKKyJcbiJdLAorICAgIGV4cGVjdGVkTmV4dExpbmUgPT4gIlEx ZFRCeDBBQUFCNDJpdGc0R2xnWUpqR3dNRER5T0RNeE1EdzM0R0JnUUVBSlBRREpBPT1cbiIsCit9 LAorIyMjIworIyBTdWNjZXNzaXZlIHByb3BlcnRpZXMKKyMjCit7CisgICAgIyBOZXcgdGVzdAor ICAgIGRpZmZOYW1lID0+ICJzaW5nbGUtbGluZSAnKycgY2hhbmdlIGZvbGxvd2VkIGJ5IGN1c3Rv bSBwcm9wZXJ0eSB3aXRoIHNpbmdsZS1saW5lICcrJyBjaGFuZ2UiLAorICAgIGlucHV0VGV4dCA9 PiA8PCdFTkQnLAorQWRkZWQ6IHN2bjpleGVjdXRhYmxlCisgICArICoKK0FkZGVkOiBkb2N1bWVu dGF0aW9uCisgICArIEEgc2VudGVuY2UuCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7 CisgICAgbmFtZSA9PiAic3ZuOmV4ZWN1dGFibGUiLAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEg PT4gMSwKKyAgICB2YWx1ZSA9PiAiKiIsCit9LAorIkFkZGVkOiBkb2N1bWVudGF0aW9uXG4iXSwK KyAgICBleHBlY3RlZE5leHRMaW5lID0+ICIgICArIEEgc2VudGVuY2UuXG4iLAorfSwKK3sKKyAg ICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4gIm11bHRpLWxpbmUgJysnIGNoYW5nZSwgZm9s bG93ZWQgYnkgc3ZuOmV4ZWN1dGFibGUiLAorICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorTmFt ZTogZG9jdW1lbnRhdGlvbgorICAgKyBBCitsb25nIHNlbnRlbmNlIHRoYXQgc3BhbnMKK211bHRp cGxlIGxpbmVzLgorTmFtZTogc3ZuOmV4ZWN1dGFibGUKKyAgICsgKgorRU5ECisgICAgZXhwZWN0 ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4gImRvY3VtZW50YXRpb24iLAorICAgIHByb3Bl cnR5Q2hhbmdlRGVsdGEgPT4gMSwKKyAgICB2YWx1ZSA9PiAiQVxubG9uZyBzZW50ZW5jZSB0aGF0 IHNwYW5zXG5tdWx0aXBsZSBsaW5lcy4iLAorfSwKKyJOYW1lOiBzdm46ZXhlY3V0YWJsZVxuIl0s CisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiAiICAgKyAqXG4iLAorfSwKK3sKKyAgICAjIE5ldyB0 ZXN0CisgICAgZGlmZk5hbWUgPT4gIm11bHRpLWxpbmUgJy0nIGNoYW5nZSwgZm9sbG93ZWQgYnkg bXVsdGktbGluZSAnKycgY2hhbmdlIGFuZCBhZGQgc3ZuOmV4ZWN1dGFibGUiLAorICAgIGlucHV0 VGV4dCA9PiA8PCdFTkQnLAorTW9kaWZpZWQ6IGRvY3VtZW50YXRpb24KKyAgIC0gQQorbG9uZyBz ZW50ZW5jZSB0aGF0IHNwYW5zCittdWx0aXBsZSBsaW5lcy4KKyAgICsgQW5vdGhlcgorbG9uZyBz ZW50ZW5jZSB0aGF0IHNwYW5zCittdWx0aXBsZSBsaW5lcy4KK0FkZGVkOiBzdm46ZXhlY3V0YWJs ZQorICAgKyAqCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAi ZG9jdW1lbnRhdGlvbiIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVl ID0+ICJBbm90aGVyXG5sb25nIHNlbnRlbmNlIHRoYXQgc3BhbnNcbm11bHRpcGxlIGxpbmVzLiIs Cit9LAorIkFkZGVkOiBzdm46ZXhlY3V0YWJsZVxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9 PiAiICAgKyAqXG4iLAorfSwKKyMjIyMKKyMgUHJvcGVydHkgdmFsdWVzIHdpdGggdHJhaWxpbmcg bmV3IGxpbmVzLgorIyMKKyMgRklYTUU6IFdlIGRvIG5vdCBzdXBwb3J0IHByb3BlcnR5IHZhbHVl cyB3aXRoIHRyYWlsaW5nIG5ldyBsaW5lcywgc2luY2UgaXQgaXMgZGlmZmljdWx0IHRvCisjICAg ICAgICBkaXNhbWJpZ3VhdGUgdGhlbSBmcm9tIHRoZSBlbXB0eSBsaW5lIHRoYXQgcHJlY2VlZHMg dGhlIGNvbnRlbnRzIG9mIGEgYmluYXJ5IHBhdGNoIGFzCisjICAgICAgICBpbiB0aGUgdGVzdCBj YXNlIChhYm92ZSk6ICJtdWx0aS1saW5lICcrJyBjaGFuZ2UsIGZvbGxvd2VkIGJ5IGVtcHR5IGxp bmUgYW5kIHN0YXJ0IG9mIGJpbmFyeSBwYXRjaCIuCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRp ZmZOYW1lID0+ICJzaW5nbGUtbGluZSAnKycgd2l0aCB0cmFpbGluZyBuZXcgbGluZSIsCisgICAg aW5wdXRUZXh0ID0+IDw8J0VORCcsCitBZGRlZDogZG9jdW1lbnRhdGlvbgorICAgKyBBIHNlbnRl bmNlLgorCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAiZG9j dW1lbnRhdGlvbiIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAxLAorICAgIHZhbHVlID0+ ICJBIHNlbnRlbmNlLiIsCit9LAorIlxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiB1bmRl ZiwKK30sCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJzaW5nbGUtbGluZSAn Kycgd2l0aCB0cmFpbGluZyBuZXcgbGluZSwgZm9sbG93ZWQgYnkgZW1wdHkgbGluZSBhbmQgc3Rh cnQgb2YgYmluYXJ5IHBhdGNoIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKK0FkZGVkOiBk b2N1bWVudGF0aW9uCisgICArIEEgc2VudGVuY2UuCisKKworUTFkVEJ4MEFBQUI0Mml0ZzRHbGdZ SmpHd01ERHlPRE14TUR3MzRHQmdRRUFKUFFESkE9PQorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4g PT4gWworeworICAgIG5hbWUgPT4gImRvY3VtZW50YXRpb24iLAorICAgIHByb3BlcnR5Q2hhbmdl RGVsdGEgPT4gMSwKKyAgICB2YWx1ZSA9PiAiQSBzZW50ZW5jZS4iLAorfSwKKyJcbiJdLAorICAg IGV4cGVjdGVkTmV4dExpbmUgPT4gIlxuIiwKK30sCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRp ZmZOYW1lID0+ICJzaW5nbGUtbGluZSAnLScgY2hhbmdlIHdpdGggdHJhaWxpbmcgbmV3IGxpbmUs IGFuZCBzaW5nbGUtbGluZSAnKycgY2hhbmdlIiwKKyAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywK K01vZGlmaWVkOiBkb2N1bWVudGF0aW9uCisgICAtIEEgbG9uZyBzZW50ZW5jZS4KKworICAgKyBB IHNlbnRlbmNlLgorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWworeworICAgIG5hbWUgPT4g ImRvY3VtZW50YXRpb24iLAorICAgIHByb3BlcnR5Q2hhbmdlRGVsdGEgPT4gLTEsICMgU2luY2Ug d2Ugb25seSBpbnRlcnByZXQgdGhlICctJyBwcm9wZXJ0eS4KKyAgICB2YWx1ZSA9PiAiQSBsb25n IHNlbnRlbmNlLiIsCit9LAorIlxuIl0sCisgICAgZXhwZWN0ZWROZXh0TGluZSA9PiAiICAgKyBB IHNlbnRlbmNlLlxuIiwKK30sCit7CisgICAgIyBOZXcgdGVzdAorICAgIGRpZmZOYW1lID0+ICJt dWx0aS1saW5lICctJyBjaGFuZ2Ugd2l0aCB0cmFpbGluZyBuZXcgbGluZSwgYW5kIG11bHRpLWxp bmUgJysnIGNoYW5nZSIsCisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCitNb2RpZmllZDogZG9j dW1lbnRhdGlvbgorICAgLSBBCitsb25nIHNlbnRlbmNlIHRoYXQgc3BhbnMKK211bHRpcGxlIGxp bmVzLgorCisgICArIEFub3RoZXIKK2xvbmcgc2VudGVuY2UgdGhhdCBzcGFucworbXVsdGlwbGUg bGluZXMuCitFTkQKKyAgICBleHBlY3RlZFJldHVybiA9PiBbCit7CisgICAgbmFtZSA9PiAiZG9j dW1lbnRhdGlvbiIsCisgICAgcHJvcGVydHlDaGFuZ2VEZWx0YSA9PiAtMSwgIyBTaW5jZSB3ZSBv bmx5IGludGVycHJldCB0aGUgJy0nIHByb3BlcnR5LgorICAgIHZhbHVlID0+ICJBXG5sb25nIHNl bnRlbmNlIHRoYXQgc3BhbnNcbm11bHRpcGxlIGxpbmVzLiIsCit9LAorIlxuIl0sCisgICAgZXhw ZWN0ZWROZXh0TGluZSA9PiAiICAgKyBBbm90aGVyXG4iLAorfSwKKyk7CisKK215ICR0ZXN0Q2Fz ZXNDb3VudCA9IEB0ZXN0Q2FzZUhhc2hSZWZzOworcGxhbih0ZXN0cyA9PiAyICogJHRlc3RDYXNl c0NvdW50KTsgIyBUb3RhbCBudW1iZXIgb2YgYXNzZXJ0aW9ucy4KKworZm9yZWFjaCBteSAkdGVz dENhc2UgKEB0ZXN0Q2FzZUhhc2hSZWZzKSB7CisgICAgbXkgJHRlc3ROYW1lU3RhcnQgPSAicGFy c2VTdm5Qcm9wZXJ0eSgpOiAkdGVzdENhc2UtPntkaWZmTmFtZX06IGNvbXBhcmluZyI7CisKKyAg ICBteSAkZmlsZUhhbmRsZTsKKyAgICBvcGVuKCRmaWxlSGFuZGxlLCAiPCIsIFwkdGVzdENhc2Ut PntpbnB1dFRleHR9KTsKKyAgICBteSAkbGluZSA9IDwkZmlsZUhhbmRsZT47CisKKyAgICBteSBA Z290ID0gVkNTVXRpbHM6OnBhcnNlU3ZuUHJvcGVydHkoJGZpbGVIYW5kbGUsICRsaW5lKTsKKyAg ICBteSAkZXhwZWN0ZWRSZXR1cm4gPSAkdGVzdENhc2UtPntleHBlY3RlZFJldHVybn07CisKKyAg ICBpc19kZWVwbHkoXEBnb3QsICRleHBlY3RlZFJldHVybiwgIiR0ZXN0TmFtZVN0YXJ0IHJldHVy biB2YWx1ZS4iKTsKKworICAgIG15ICRnb3ROZXh0TGluZSA9IDwkZmlsZUhhbmRsZT47CisgICAg aXMoJGdvdE5leHRMaW5lLCAkdGVzdENhc2UtPntleHBlY3RlZE5leHRMaW5lfSwgICIkdGVzdE5h bWVTdGFydCBuZXh0IHJlYWQgbGluZS4iKTsKK30KSW5kZXg6IFdlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cGVybC9WQ1NVdGlsc191bml0dGVzdC9wYXJzZVN2blByb3BlcnR5VmFsdWUucGwKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRwZXJsL1ZDU1V0aWxzX3VuaXR0 ZXN0L3BhcnNlU3ZuUHJvcGVydHlWYWx1ZS5wbAkocmV2aXNpb24gNTk1OTEpCisrKyBXZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHBlcmwvVkNTVXRpbHNfdW5pdHRlc3QvcGFyc2VTdm5Qcm9wZXJ0 eVZhbHVlLnBsCSh3b3JraW5nIGNvcHkpCkBAIC01OCw3ICs1OCw3IEBAIEVORAogfSwKIHsKICAg ICAjIE5ldyB0ZXN0Ci0gICAgZGlmZk5hbWUgPT4gInNpbXBsZSBtdWx0aS1saW5lICctJyBjaGFu Z2UiLAorICAgIGRpZmZOYW1lID0+ICJzaW5nbGUtbGluZSAnLScgY2hhbmdlIGZvbGxvd2VkIGJ5 IGVtcHR5IGxpbmUiLAogICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAogICAgLSAqCiAKQEAgLTY4 LDYgKzY4LDE2IEBAIEVORAogfSwKIHsKICAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUgPT4g InNpbmdsZS1saW5lICctJyBjaGFuZ2UgZm9sbG93ZWQgYnkgdGhlIG5leHQgcHJvcGVydHkiLAor ICAgIGlucHV0VGV4dCA9PiA8PCdFTkQnLAorICAgLSAqCitEZWxldGVkOiBzdm46ZXhlY3V0YWJs ZQorRU5ECisgICAgZXhwZWN0ZWRSZXR1cm4gPT4gWyIqIiwgIkRlbGV0ZWQ6IHN2bjpleGVjdXRh YmxlXG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5lID0+IHVuZGVmLAorfSwKK3sKKyAgICAjIE5l dyB0ZXN0CiAgICAgZGlmZk5hbWUgPT4gIm11bHRpLWxpbmUgJysnIGNoYW5nZSBhbmQgc3RhcnQg b2YgYmluYXJ5IHBhdGNoIiwKICAgICBpbnB1dFRleHQgPT4gPDwnRU5EJywKICAgICsgQQpAQCAt OTMsNiArMTAzLDE4IEBAIEVORAogfSwKIHsKICAgICAjIE5ldyB0ZXN0CisgICAgZGlmZk5hbWUg PT4gIm11bHRpLWxpbmUgJy0nIGNoYW5nZSBmb2xsb3dlZCBieSB0aGUgbmV4dCBwcm9wZXJ0eSIs CisgICAgaW5wdXRUZXh0ID0+IDw8J0VORCcsCisgICAtIEEKK2xvbmcgc2VudGVuY2UgdGhhdCBz cGFucworbXVsdGlwbGUgbGluZXMuCitBZGRlZDogc3ZuOmV4ZWN1dGFibGUKK0VORAorICAgIGV4 cGVjdGVkUmV0dXJuID0+IFsiQVxubG9uZyBzZW50ZW5jZSB0aGF0IHNwYW5zXG5tdWx0aXBsZSBs aW5lcy4iLCAiQWRkZWQ6IHN2bjpleGVjdXRhYmxlXG4iXSwKKyAgICBleHBlY3RlZE5leHRMaW5l ID0+IHVuZGVmLAorfSwKK3sKKyAgICAjIE5ldyB0ZXN0CiAgICAgZGlmZk5hbWUgPT4gIm11bHRp LWxpbmUgJy0nIGNoYW5nZSBmb2xsb3dlZCBieSAnKycgbXVsdGktbGluZSBjaGFuZ2UiLAogICAg IGlucHV0VGV4dCA9PiA8PCdFTkQnLAogICAgLSBBCg==