ZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuZXF1aW5veC5odHRwLnNlcnZsZXQudGVzdHMvc3JjL29yZy9lY2xpcHNlL2VxdWlub3gvaHR0cC9zZXJ2bGV0L3Rlc3RzL0Rpc3BhdGNoaW5nVGVzdC5qYXZhIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5lcXVpbm94Lmh0dHAuc2VydmxldC50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvZXF1aW5veC9odHRwL3NlcnZsZXQvdGVzdHMvRGlzcGF0Y2hpbmdUZXN0LmphdmEKaW5kZXggNmY4MzQwYi4uZTFmODlhMSAxMDA2NDQKLS0tIGEvYnVuZGxlcy9vcmcuZWNsaXBzZS5lcXVpbm94Lmh0dHAuc2VydmxldC50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvZXF1aW5veC9odHRwL3NlcnZsZXQvdGVzdHMvRGlzcGF0Y2hpbmdUZXN0LmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5lcXVpbm94Lmh0dHAuc2VydmxldC50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvZXF1aW5veC9odHRwL3NlcnZsZXQvdGVzdHMvRGlzcGF0Y2hpbmdUZXN0LmphdmEKQEAgLTIzLDYgKzIzLDkgQEAKIGltcG9ydCBqYXZhLnV0aWwuTG9jYWxlOwogaW1wb3J0IGphdmEudXRpbC5NYXA7CiBpbXBvcnQgamF2YS51dGlsLlRpbWVab25lOworaW1wb3J0IGphdmEudXRpbC5jb25jdXJyZW50LmF0b21pYy5BdG9taWNCb29sZWFuOworaW1wb3J0IGphdmEudXRpbC5jb25jdXJyZW50LmF0b21pYy5BdG9taWNJbnRlZ2VyOworaW1wb3J0IGphdmEudXRpbC5jb25jdXJyZW50LmF0b21pYy5BdG9taWNMb25nOwogaW1wb3J0IGphdmEudXRpbC5jb25jdXJyZW50LmF0b21pYy5BdG9taWNSZWZlcmVuY2U7CiAKIGltcG9ydCBqYXZheC5zZXJ2bGV0LkRpc3BhdGNoZXJUeXBlOwpAQCAtMzEsNiArMzQsNyBAQAogaW1wb3J0IGphdmF4LnNlcnZsZXQuUmVxdWVzdERpc3BhdGNoZXI7CiBpbXBvcnQgamF2YXguc2VydmxldC5TZXJ2bGV0OwogaW1wb3J0IGphdmF4LnNlcnZsZXQuU2VydmxldENvbnRleHQ7CitpbXBvcnQgamF2YXguc2VydmxldC5TZXJ2bGV0T3V0cHV0U3RyZWFtOwogaW1wb3J0IGphdmF4LnNlcnZsZXQuU2VydmxldEV4Y2VwdGlvbjsKIGltcG9ydCBqYXZheC5zZXJ2bGV0LlNlcnZsZXRSZXF1ZXN0OwogaW1wb3J0IGphdmF4LnNlcnZsZXQuU2VydmxldFJlc3BvbnNlOwpAQCAtNDIsNiArNDYsOCBAQAogaW1wb3J0IG9yZy5lY2xpcHNlLmVxdWlub3guaHR0cC5zZXJ2bGV0LnRlc3RiYXNlLkJhc2VUZXN0OwogaW1wb3J0IG9yZy5lY2xpcHNlLmVxdWlub3guaHR0cC5zZXJ2bGV0LnRlc3RzLnV0aWwuQmFzZVNlcnZsZXQ7CiBpbXBvcnQgb3JnLmVjbGlwc2UuZXF1aW5veC5odHRwLnNlcnZsZXQudGVzdHMudXRpbC5EaXNwYXRjaFJlc3VsdFNlcnZsZXQ7CitpbXBvcnQgb3JnLmVjbGlwc2UuZXF1aW5veC5odHRwLnNlcnZsZXQudGVzdHMudXRpbC5FdmVudEhhbmRsZXI7CitpbXBvcnQgb3JnLmVjbGlwc2UuZXF1aW5veC5odHRwLnNlcnZsZXQudGVzdHMudXRpbC5TZXJ2bGV0UmVxdWVzdEFkdmlzb3I7CiBpbXBvcnQgb3JnLmp1bml0LkFzc2VydDsKIGltcG9ydCBvcmcuanVuaXQuVGVzdDsKIGltcG9ydCBvcmcub3NnaS5zZXJ2aWNlLmh0dHAuSHR0cENvbnRleHQ7CkBAIC0xNDE5LDQgKzE0MjUsMTU2IEBACiAJCUFzc2VydC5hc3NlcnRFcXVhbHMoImRvZyIsIHJlc3BvbnNlLmdldCgiWC1hbmltYWwiKS5nZXQoMCkpOwogCX0KIAorCS8vIEJ1ZyA0OTM1ODMKKwlAVGVzdAorCXB1YmxpYyB2b2lkIHRlc3Rfc3RyZWFtZWRfcmVzcG9uc2Vfb3V0cHV0c3RyZWFtKCkgdGhyb3dzIEV4Y2VwdGlvbiB7CisJCWZpbmFsIGxvbmcgaW50ZXJ2YWwgPSAxMDBMOworCisJCVNlcnZsZXQgc2VydmxldDEgPSBuZXcgQmFzZVNlcnZsZXQoKSB7CisJCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKKworCQkJQE92ZXJyaWRlCisJCQlwcm90ZWN0ZWQgdm9pZCBzZXJ2aWNlKEh0dHBTZXJ2bGV0UmVxdWVzdCByZXF1ZXN0LCBIdHRwU2VydmxldFJlc3BvbnNlIHJlc3BvbnNlKQorCQkJCXRocm93cyBTZXJ2bGV0RXhjZXB0aW9uLCBJT0V4Y2VwdGlvbiB7CisKKwkJICAgICAgICByZXNwb25zZS5zZXRDb250ZW50VHlwZSgidGV4dC9ldmVudC1zdHJlYW0iKTsKKwkJICAgICAgICByZXNwb25zZS5zZXRDaGFyYWN0ZXJFbmNvZGluZygiVVRGLTgiKTsKKworCQkJCXRyeSAoU2VydmxldE91dHB1dFN0cmVhbSBvdXQgPSByZXNwb25zZS5nZXRPdXRwdXRTdHJlYW0oKSkgeworCQkJCQlmb3IgKGludCBpID0gMTsgaSA8PSAxMDsgKytpKSB7CisJCQkJCQl0cnkgeworCQkJCQkJCVRocmVhZC5zbGVlcChpbnRlcnZhbCk7CisJCQkJCQl9CisJCQkJCQljYXRjaCAoSW50ZXJydXB0ZWRFeGNlcHRpb24gZSkgeworCQkJCQkJCXRocm93IG5ldyBTZXJ2bGV0RXhjZXB0aW9uKGUpOworCQkJCQkJfQorCisJCQkJCQlvdXQucHJpbnQoImRhdGE6ICIpOworCQkJCQkJb3V0LnByaW50KFN5c3RlbS5jdXJyZW50VGltZU1pbGxpcygpKTsKKwkJCQkJCW91dC5wcmludCgiXG5cbiIpOworCQkJCQkJb3V0LmZsdXNoKCk7CisJCQkJCX0KKwkJCQl9CisJCQl9CisJCX07CisKKwkJRGljdGlvbmFyeTxTdHJpbmcsIE9iamVjdD4gcHJvcHMgPSBuZXcgSGFzaHRhYmxlPFN0cmluZywgT2JqZWN0PigpOworCQlwcm9wcy5wdXQoSHR0cFdoaXRlYm9hcmRDb25zdGFudHMuSFRUUF9XSElURUJPQVJEX1NFUlZMRVRfUEFUVEVSTiwgIi9zMS8qIik7CisJCXJlZ2lzdHJhdGlvbnMuYWRkKGdldEJ1bmRsZUNvbnRleHQoKS5yZWdpc3RlclNlcnZpY2UoU2VydmxldC5jbGFzcywgc2VydmxldDEsIHByb3BzKSk7CisKKwkJZmluYWwgQXRvbWljTG9uZyBwcmV2aW91c1RpbWUgPSBuZXcgQXRvbWljTG9uZyhTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKSk7CisJCWZpbmFsIEF0b21pY0ludGVnZXIgY291bnRlciA9IG5ldyBBdG9taWNJbnRlZ2VyKCk7CisJCWZpbmFsIEF0b21pY0Jvb2xlYW4gcmVzdWx0ID0gbmV3IEF0b21pY0Jvb2xlYW4odHJ1ZSk7CisKKwkJRXZlbnRIYW5kbGVyIGhhbmRsZXIgPSBuZXcgRXZlbnRIYW5kbGVyKCkgeworCisJCQlAT3ZlcnJpZGUKKwkJCXB1YmxpYyB2b2lkIGhhbmRsZShNYXA8U3RyaW5nLCBTdHJpbmc+IGV2ZW50TWFwKSB7CisJCQkJc3VwZXIuaGFuZGxlKGV2ZW50TWFwKTsKKworCQkJCWxvbmcgY3VycmVudFRpbWUgPSBTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKTsKKworCQkJCWxvbmcgZGlmZiA9IChjdXJyZW50VGltZSAtIHByZXZpb3VzVGltZS5nZXQoKSk7CisKKwkJCQlTeXN0ZW0ub3V0LnByaW50bG4oIkRpZmZlcmVudGlhbDogIiArIGRpZmYpOworCisJCQkJLy8gY2hlY2sgdGhhdCB0aGVyZSBpcyBhdCBsZWFzdCBhIGRpZmZlcmVudGlhbCBvZiBoYWxmIHRoZSBpbnRlcnZhbAorCQkJCS8vIGJlY2F1c2Ugd2UgY2FuJ3QgcmVhbGx5IGd1YXJhbnRlZSB0aGF0IG1hY2hpbmUgdGltZSB3aWxsIGFjY3VyYXRlbHkKKwkJCQkvLyByZWZsZWN0IHRoZSB0aW1lb3V0cyB3ZSd2ZSBzZXQKKwkJCQlpZiAoZGlmZiA8IChpbnRlcnZhbCAvIDIpKSB7CisJCQkJCXJlc3VsdC5zZXQoZmFsc2UpOworCQkJCX0KKworCQkJCXByZXZpb3VzVGltZS5zZXQoY3VycmVudFRpbWUpOworCQkJCWNvdW50ZXIuaW5jcmVtZW50QW5kR2V0KCk7CisJCQl9CisKKwkJfTsKKworCQlyZXF1ZXN0QWR2aXNvci5ldmVudFNvdXJjZSgiczEiLCBudWxsLCBoYW5kbGVyKTsKKworCQloYW5kbGVyLmNsb3NlKCk7CisKKwkJQXNzZXJ0LmFzc2VydFRydWUoCisJCQkiVGhlIGludGVydmFsIGJldHdlZW4gZXZlbnRzIHdhcyB0b28gc2hvcnQuIEl0IG1lYW5zIHRoYXQgdGhlIHJlc3BvbnNlIHdhcyBub3QgcHJvcGVybHkgc3RyZWFtZWQuIiwKKwkJCXJlc3VsdC5nZXQoKSk7CisJCUFzc2VydC5hc3NlcnRFcXVhbHMoMTAsIGNvdW50ZXIuZ2V0KCkpOworCX0KKworCS8vIEJ1ZyA0OTM1ODMKKwlAVGVzdAorCXB1YmxpYyB2b2lkIHRlc3Rfc3RyZWFtZWRfcmVzcG9uc2Vfd3JpdGVyKCkgdGhyb3dzIEV4Y2VwdGlvbiB7CisJCWZpbmFsIGxvbmcgaW50ZXJ2YWwgPSAxMDBMOworCisJCVNlcnZsZXQgc2VydmxldDEgPSBuZXcgQmFzZVNlcnZsZXQoKSB7CisJCQlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKKworCQkJQE92ZXJyaWRlCisJCQlwcm90ZWN0ZWQgdm9pZCBzZXJ2aWNlKEh0dHBTZXJ2bGV0UmVxdWVzdCByZXF1ZXN0LCBIdHRwU2VydmxldFJlc3BvbnNlIHJlc3BvbnNlKQorCQkJCXRocm93cyBTZXJ2bGV0RXhjZXB0aW9uLCBJT0V4Y2VwdGlvbiB7CisKKwkJICAgICAgICByZXNwb25zZS5zZXRDb250ZW50VHlwZSgidGV4dC9ldmVudC1zdHJlYW0iKTsKKwkJICAgICAgICByZXNwb25zZS5zZXRDaGFyYWN0ZXJFbmNvZGluZygiVVRGLTgiKTsKKworCQkJCXRyeSAoUHJpbnRXcml0ZXIgd3JpdGVyID0gcmVzcG9uc2UuZ2V0V3JpdGVyKCkpIHsKKwkJCQkJZm9yIChpbnQgaSA9IDE7IGkgPD0gMTA7ICsraSkgeworCQkJCQkJdHJ5IHsKKwkJCQkJCQlUaHJlYWQuc2xlZXAoaW50ZXJ2YWwpOworCQkJCQkJfQorCQkJCQkJY2F0Y2ggKEludGVycnVwdGVkRXhjZXB0aW9uIGUpIHsKKwkJCQkJCQl0aHJvdyBuZXcgU2VydmxldEV4Y2VwdGlvbihlKTsKKwkJCQkJCX0KKworCQkJCQkJd3JpdGVyLnByaW50KCJkYXRhOiAiKTsKKwkJCQkJCXdyaXRlci5wcmludChTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKSk7CisJCQkJCQl3cml0ZXIucHJpbnQoIlxuXG4iKTsKKwkJCQkJCXdyaXRlci5mbHVzaCgpOworCQkJCQl9CisJCQkJfQorCQkJfQorCQl9OworCisJCURpY3Rpb25hcnk8U3RyaW5nLCBPYmplY3Q+IHByb3BzID0gbmV3IEhhc2h0YWJsZTxTdHJpbmcsIE9iamVjdD4oKTsKKwkJcHJvcHMucHV0KEh0dHBXaGl0ZWJvYXJkQ29uc3RhbnRzLkhUVFBfV0hJVEVCT0FSRF9TRVJWTEVUX1BBVFRFUk4sICIvczEvKiIpOworCQlyZWdpc3RyYXRpb25zLmFkZChnZXRCdW5kbGVDb250ZXh0KCkucmVnaXN0ZXJTZXJ2aWNlKFNlcnZsZXQuY2xhc3MsIHNlcnZsZXQxLCBwcm9wcykpOworCisJCWZpbmFsIEF0b21pY0xvbmcgcHJldmlvdXNUaW1lID0gbmV3IEF0b21pY0xvbmcoU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCkpOworCQlmaW5hbCBBdG9taWNJbnRlZ2VyIGNvdW50ZXIgPSBuZXcgQXRvbWljSW50ZWdlcigpOworCQlmaW5hbCBBdG9taWNCb29sZWFuIHJlc3VsdCA9IG5ldyBBdG9taWNCb29sZWFuKHRydWUpOworCisJCUV2ZW50SGFuZGxlciBoYW5kbGVyID0gbmV3IEV2ZW50SGFuZGxlcigpIHsKKworCQkJQE92ZXJyaWRlCisJCQlwdWJsaWMgdm9pZCBoYW5kbGUoTWFwPFN0cmluZywgU3RyaW5nPiBldmVudE1hcCkgeworCQkJCXN1cGVyLmhhbmRsZShldmVudE1hcCk7CisKKwkJCQlsb25nIGN1cnJlbnRUaW1lID0gU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCk7CisKKwkJCQlsb25nIGRpZmYgPSAoY3VycmVudFRpbWUgLSBwcmV2aW91c1RpbWUuZ2V0KCkpOworCisJCQkJU3lzdGVtLm91dC5wcmludGxuKCJEaWZmZXJlbnRpYWw6ICIgKyBkaWZmKTsKKworCQkJCS8vIGNoZWNrIHRoYXQgdGhlcmUgaXMgYXQgbGVhc3QgYSBkaWZmZXJlbnRpYWwgb2YgaGFsZiB0aGUgaW50ZXJ2YWwKKwkJCQkvLyBiZWNhdXNlIHdlIGNhbid0IHJlYWxseSBndWFyYW50ZWUgdGhhdCBtYWNoaW5lIHRpbWUgd2lsbCBhY2N1cmF0ZWx5CisJCQkJLy8gcmVmbGVjdCB0aGUgdGltZW91dHMgd2UndmUgc2V0CisJCQkJaWYgKGRpZmYgPCAoaW50ZXJ2YWwgLyAyKSkgeworCQkJCQlyZXN1bHQuc2V0KGZhbHNlKTsKKwkJCQl9CisKKwkJCQlwcmV2aW91c1RpbWUuc2V0KGN1cnJlbnRUaW1lKTsKKwkJCQljb3VudGVyLmluY3JlbWVudEFuZEdldCgpOworCQkJfQorCisJCX07CisKKwkJcmVxdWVzdEFkdmlzb3IuZXZlbnRTb3VyY2UoInMxIiwgbnVsbCwgaGFuZGxlcik7CisKKwkJaGFuZGxlci5jbG9zZSgpOworCisJCUFzc2VydC5hc3NlcnRUcnVlKAorCQkJIlRoZSBpbnRlcnZhbCBiZXR3ZWVuIGV2ZW50cyB3YXMgdG9vIHNob3J0LiBJdCBtZWFucyB0aGF0IHRoZSByZXNwb25zZSB3YXMgbm90IHByb3Blcmx5IHN0cmVhbWVkLiIsCisJCQlyZXN1bHQuZ2V0KCkpOworCQlBc3NlcnQuYXNzZXJ0RXF1YWxzKDEwLCBjb3VudGVyLmdldCgpKTsKKwl9CisKIH0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmVxdWlub3guaHR0cC5zZXJ2bGV0LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9lcXVpbm94L2h0dHAvc2VydmxldC90ZXN0cy91dGlsL0V2ZW50SGFuZGxlci5qYXZhIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5lcXVpbm94Lmh0dHAuc2VydmxldC50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvZXF1aW5veC9odHRwL3NlcnZsZXQvdGVzdHMvdXRpbC9FdmVudEhhbmRsZXIuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40N2U2ODEzCi0tLSAvZGV2L251bGwKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5lcXVpbm94Lmh0dHAuc2VydmxldC50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvZXF1aW5veC9odHRwL3NlcnZsZXQvdGVzdHMvdXRpbC9FdmVudEhhbmRsZXIuamF2YQpAQCAtMCwwICsxLDExNiBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIENvcHlyaWdodCAoYykgMjAxNiBSYXltb25kIEF1Z+kgYW5kIG90aGVycy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgIFJheW1vbmQgQXVn6SA8cmF5bW9uZC5hdWdlQGxpZmVyYXkuY29tPiAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworcGFja2FnZSBvcmcuZWNsaXBzZS5lcXVpbm94Lmh0dHAuc2VydmxldC50ZXN0cy51dGlsOworCitpbXBvcnQgamF2YS5pby5CdWZmZXJlZFJlYWRlcjsKK2ltcG9ydCBqYXZhLmlvLklPRXhjZXB0aW9uOworaW1wb3J0IGphdmEuaW8uSW5wdXRTdHJlYW07CitpbXBvcnQgamF2YS5pby5JbnB1dFN0cmVhbVJlYWRlcjsKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuTWFwOworCitwdWJsaWMgY2xhc3MgRXZlbnRIYW5kbGVyIHsKKworCXB1YmxpYyB2b2lkIGNsb3NlKCkgeworCQl0cnkgeworCQkJdGhyZWFkLmpvaW4oKTsKKwkJfSBjYXRjaCAoSW50ZXJydXB0ZWRFeGNlcHRpb24gZSkgeworCQkJZS5wcmludFN0YWNrVHJhY2UoKTsKKwkJfQorCX0KKworCXB1YmxpYyB2b2lkIGhhbmRsZShNYXA8U3RyaW5nLCBTdHJpbmc+IGV2ZW50TWFwKSB7CisJCVN5c3RlbS5vdXQucHJpbnRsbigiPT1ldmVudD09XG4iICsgZXZlbnRNYXAuZ2V0KCJkYXRhIikpOworCX0KKworCXB1YmxpYyB2b2lkIG9wZW4oZmluYWwgSW5wdXRTdHJlYW0gaW5wdXRTdHJlYW0pIHsKKwkJUnVubmFibGUgc3RyZWFtUHJvY2Vzc29yVGhyZWFkID0gbmV3IFJ1bm5hYmxlKCkgeworCisJCQlAT3ZlcnJpZGUKKwkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKKwkJCQlTeXN0ZW0ub3V0LnByaW50bG4oIj09ZXZlbnQgc3RyZWFtIG9wZW5lZD09Iik7CisKKwkJCQkvLyBSZWY6IGh0dHBzOi8vaHRtbC5zcGVjLndoYXR3Zy5vcmcvbXVsdGlwYWdlL2NvbW1zLmh0bWwjc2VydmVyLXNlbnQtZXZlbnRzCisKKwkJCQlNYXA8U3RyaW5nLCBTdHJpbmc+IGV2ZW50TWFwID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+KCk7CisKKwkJCQlCdWZmZXJlZFJlYWRlciByZWFkZXIgPSBuZXcgQnVmZmVyZWRSZWFkZXIobmV3IElucHV0U3RyZWFtUmVhZGVyKGlucHV0U3RyZWFtKSk7CisKKwkJCQlTdHJpbmcgY3VycmVudDsKKworCQkJCXRyeSB7CisJCQkJCXdoaWxlICgoY3VycmVudCA9IHJlYWRlci5yZWFkTGluZSgpKSAhPSBudWxsKSB7CisJCQkJCQlpZiAoY3VycmVudC5sZW5ndGgoKSA9PSAwKSB7CisJCQkJCQkJaGFuZGxlKGV2ZW50TWFwKTsKKworCQkJCQkJCWV2ZW50TWFwID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+KCk7CisKKwkJCQkJCQljb250aW51ZTsKKwkJCQkJCX0KKworCQkJCQkJaW50IGNvbG9uID0gY3VycmVudC5pbmRleE9mKCdcdTAwM0EnKTsKKworCQkJCQkJaWYgKGNvbG9uID09IDApIHsKKwkJCQkJCQkvLyBpZ25vcmUgY29tbWVudCBsaW5lcworCisJCQkJCQkJY29udGludWU7CisJCQkJCQl9CisJCQkJCQllbHNlIGlmIChjb2xvbiA8IDApIHsKKwkJCQkJCQkvLyBObyBjb2xvbj8gRW50aXJlIGxpbmUgbXVzdCBiZSB0cmVhdGVkIGFzIHRoZSBrZXkgd2l0aCBibGFuayB2YWx1ZQorCisJCQkJCQkJZXZlbnRNYXAucHV0KGN1cnJlbnQsICIiKTsKKworCQkJCQkJCWNvbnRpbnVlOworCQkJCQkJfQorCisJCQkJCQlTdHJpbmcga2V5ID0gY3VycmVudC5zdWJzdHJpbmcoMCwgY29sb24pOworCQkJCQkJU3RyaW5nIHZhbHVlID0gY3VycmVudC5zdWJzdHJpbmcoY29sb24gKyAxKTsKKworCQkJCQkJaWYgKHZhbHVlLnN0YXJ0c1dpdGgoIlx1MDAyMCIpKSB7CisJCQkJCQkJdmFsdWUgPSB2YWx1ZS5zdWJzdHJpbmcoMSk7CisJCQkJCQl9CisKKwkJCQkJCWlmIChldmVudE1hcC5jb250YWluc0tleShrZXkpKSB7CisJCQkJCQkJU3RyaW5nIGN1cnJlbnRWYWx1ZSA9IGV2ZW50TWFwLmdldChrZXkpOworCisJCQkJCQkJdmFsdWUgPSBjdXJyZW50VmFsdWUgKyAnXG4nICsgdmFsdWU7CisJCQkJCQl9CisKKwkJCQkJCWV2ZW50TWFwLnB1dChrZXksIHZhbHVlKTsKKwkJCQkJfQorCQkJCX0KKwkJCQljYXRjaCAoSU9FeGNlcHRpb24gZSkgeworCQkJCQllLnByaW50U3RhY2tUcmFjZSgpOworCQkJCX0KKwkJCQlmaW5hbGx5IHsKKwkJCQkJdHJ5IHsKKwkJCQkJCWlucHV0U3RyZWFtLmNsb3NlKCk7CisJCQkJCX0KKwkJCQkJY2F0Y2ggKElPRXhjZXB0aW9uIGUpIHsKKwkJCQkJCWUucHJpbnRTdGFja1RyYWNlKCk7CisJCQkJCX0KKwkJCQl9CisKKwkJCQkvLyBJZ25vcmUgcmVtYWluaW5nIGNvbnRlbnQgd2hpY2ggaXMgbm90IGEgd2VsbCBmb3JtZWQgZXZlbnQKKworCQkJCVN5c3RlbS5vdXQucHJpbnRsbigiPT1ldmVudCBzdHJlYW0gY2xvc2VkPT0iKTsKKwkJCX0KKworCQl9OworCisJCXRocmVhZCA9IG5ldyBUaHJlYWQoc3RyZWFtUHJvY2Vzc29yVGhyZWFkKTsKKworCQl0aHJlYWQuc3RhcnQoKTsKKwl9CisKKwlwcml2YXRlIFRocmVhZCB0aHJlYWQ7CisKK30KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9idW5kbGVzL29yZy5lY2xpcHNlLmVxdWlub3guaHR0cC5zZXJ2bGV0LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9lcXVpbm94L2h0dHAvc2VydmxldC90ZXN0cy91dGlsL1NlcnZsZXRSZXF1ZXN0QWR2aXNvci5qYXZhIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5lcXVpbm94Lmh0dHAuc2VydmxldC50ZXN0cy9zcmMvb3JnL2VjbGlwc2UvZXF1aW5veC9odHRwL3NlcnZsZXQvdGVzdHMvdXRpbC9TZXJ2bGV0UmVxdWVzdEFkdmlzb3IuamF2YQppbmRleCA5ZmRjODljLi5jZjViNGE5IDEwMDY0NAotLS0gYS9idW5kbGVzL29yZy5lY2xpcHNlLmVxdWlub3guaHR0cC5zZXJ2bGV0LnRlc3RzL3NyYy9vcmcvZWNsaXBzZS9lcXVpbm94L2h0dHAvc2VydmxldC90ZXN0cy91dGlsL1NlcnZsZXRSZXF1ZXN0QWR2aXNvci5qYXZhCisrKyBiL2J1bmRsZXMvb3JnLmVjbGlwc2UuZXF1aW5veC5odHRwLnNlcnZsZXQudGVzdHMvc3JjL29yZy9lY2xpcHNlL2VxdWlub3gvaHR0cC9zZXJ2bGV0L3Rlc3RzL3V0aWwvU2VydmxldFJlcXVlc3RBZHZpc29yLmphdmEKQEAgLTEzNyw2ICsxMzcsNDYgQEAKIAkJfQogCX0KIAorCXB1YmxpYyBNYXA8U3RyaW5nLCBMaXN0PFN0cmluZz4+IGV2ZW50U291cmNlKFN0cmluZyB2YWx1ZSwgTWFwPFN0cmluZywgTGlzdDxTdHJpbmc+PiBoZWFkZXJzLCBmaW5hbCBFdmVudEhhbmRsZXIgaGFuZGxlcikgdGhyb3dzIElPRXhjZXB0aW9uIHsKKwkJU3RyaW5nIHNwZWMgPSBjcmVhdGVVcmxTcGVjKHZhbHVlKTsKKwkJbG9nKCJSZXF1ZXN0aW5nICIgKyBzcGVjKTsgLy8kTk9OLU5MUy0xJAorCQlVUkwgdXJsID0gbmV3IFVSTChzcGVjKTsKKwkJSHR0cFVSTENvbm5lY3Rpb24gY29ubmVjdGlvbiA9IChIdHRwVVJMQ29ubmVjdGlvbil1cmwub3BlbkNvbm5lY3Rpb24oKTsKKworCQljb25uZWN0aW9uLnNldENodW5rZWRTdHJlYW1pbmdNb2RlKDApOworCQljb25uZWN0aW9uLnNldERvT3V0cHV0KHRydWUpOworCQkvL2Nvbm5lY3Rpb24uc2V0UmVxdWVzdFByb3BlcnR5KCJDb25uZWN0aW9uIiwgIkNsb3NlIik7CisJCWNvbm5lY3Rpb24uc2V0SW5zdGFuY2VGb2xsb3dSZWRpcmVjdHMoZmFsc2UpOworCQljb25uZWN0aW9uLnNldENvbm5lY3RUaW1lb3V0KDE1MCAqIDEwMDApOworCQljb25uZWN0aW9uLnNldFJlYWRUaW1lb3V0KDE1MCAqIDEwMDApOworCisJCWlmIChoZWFkZXJzICE9IG51bGwpIHsKKwkJCWZvcihNYXAuRW50cnk8U3RyaW5nLCBMaXN0PFN0cmluZz4+IGVudHJ5IDogaGVhZGVycy5lbnRyeVNldCgpKSB7CisJCQkJZm9yKFN0cmluZyBlbnRyeVZhbHVlIDogZW50cnkuZ2V0VmFsdWUoKSkgeworCQkJCQljb25uZWN0aW9uLnNldFJlcXVlc3RQcm9wZXJ0eShlbnRyeS5nZXRLZXkoKSwgZW50cnlWYWx1ZSk7CisJCQkJfQorCQkJfQorCQl9CisKKwkJaW50IHJlc3BvbnNlQ29kZSA9IGNvbm5lY3Rpb24uZ2V0UmVzcG9uc2VDb2RlKCk7CisKKwkJTWFwPFN0cmluZywgTGlzdDxTdHJpbmc+PiBtYXAgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIExpc3Q8U3RyaW5nPj4oY29ubmVjdGlvbi5nZXRIZWFkZXJGaWVsZHMoKSk7CisJCW1hcC5wdXQoInJlc3BvbnNlQ29kZSIsIENvbGxlY3Rpb25zLnNpbmdsZXRvbkxpc3QoU3RyaW5nLnZhbHVlT2YocmVzcG9uc2VDb2RlKSkpOworCisJCUlucHV0U3RyZWFtIHN0cmVhbTsKKworCQlpZiAocmVzcG9uc2VDb2RlID49IDQwMCkgeworCQkJc3RyZWFtID0gY29ubmVjdGlvbi5nZXRFcnJvclN0cmVhbSgpOworCQl9CisJCWVsc2UgeworCQkJc3RyZWFtID0gY29ubmVjdGlvbi5nZXRJbnB1dFN0cmVhbSgpOworCQl9CisKKwkJaGFuZGxlci5vcGVuKHN0cmVhbSk7CisKKwkJcmV0dXJuIG1hcDsKKwl9CisKIAlwdWJsaWMgTWFwPFN0cmluZywgTGlzdDxTdHJpbmc+PiB1cGxvYWQoU3RyaW5nIHZhbHVlLCBNYXA8U3RyaW5nLCBMaXN0PE9iamVjdD4+IGhlYWRlcnMpIHRocm93cyBJT0V4Y2VwdGlvbiB7CiAJCVN0cmluZyBzcGVjID0gY3JlYXRlVXJsU3BlYyh2YWx1ZSk7CiAJCWxvZygiUmVxdWVzdGluZyAiICsgc3BlYyk7IC8vJE5PTi1OTFMtMSQKZGlmZiAtLWdpdCBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuZXF1aW5veC5odHRwLnNlcnZsZXQvc3JjL29yZy9lY2xpcHNlL2VxdWlub3gvaHR0cC9zZXJ2bGV0L2ludGVybmFsL3NlcnZsZXQvSHR0cFNlcnZsZXRSZXNwb25zZVdyYXBwZXJJbXBsLmphdmEgYi9idW5kbGVzL29yZy5lY2xpcHNlLmVxdWlub3guaHR0cC5zZXJ2bGV0L3NyYy9vcmcvZWNsaXBzZS9lcXVpbm94L2h0dHAvc2VydmxldC9pbnRlcm5hbC9zZXJ2bGV0L0h0dHBTZXJ2bGV0UmVzcG9uc2VXcmFwcGVySW1wbC5qYXZhCmluZGV4IDBiNzUxOGQuLmE3YzVmNWYgMTAwNjQ0Ci0tLSBhL2J1bmRsZXMvb3JnLmVjbGlwc2UuZXF1aW5veC5odHRwLnNlcnZsZXQvc3JjL29yZy9lY2xpcHNlL2VxdWlub3gvaHR0cC9zZXJ2bGV0L2ludGVybmFsL3NlcnZsZXQvSHR0cFNlcnZsZXRSZXNwb25zZVdyYXBwZXJJbXBsLmphdmEKKysrIGIvYnVuZGxlcy9vcmcuZWNsaXBzZS5lcXVpbm94Lmh0dHAuc2VydmxldC9zcmMvb3JnL2VjbGlwc2UvZXF1aW5veC9odHRwL3NlcnZsZXQvaW50ZXJuYWwvc2VydmxldC9IdHRwU2VydmxldFJlc3BvbnNlV3JhcHBlckltcGwuamF2YQpAQCAtOTksNiArOTksMTYgQEAKIAkJfQogCiAJCUBPdmVycmlkZQorCQlwdWJsaWMgdm9pZCBjbG9zZSgpIHRocm93cyBJT0V4Y2VwdGlvbiB7CisJCQlvcmlnaW5hbE91dHB1dFN0cmVhbS5jbG9zZSgpOworCQl9CisKKwkJQE92ZXJyaWRlCisJCXB1YmxpYyB2b2lkIGZsdXNoKCkgdGhyb3dzIElPRXhjZXB0aW9uIHsKKwkJCW9yaWdpbmFsT3V0cHV0U3RyZWFtLmZsdXNoKCk7CisJCX0KKworCQlAT3ZlcnJpZGUKIAkJcHVibGljIGJvb2xlYW4gaXNSZWFkeSgpIHsKIAkJCXJldHVybiBvcmlnaW5hbE91dHB1dFN0cmVhbS5pc1JlYWR5KCk7CiAJCX0K