| To: vim_dev@googlegroups.com |
| Subject: Patch 7.3.1100 |
| Fcc: outbox |
| From: Bram Moolenaar <Bram@moolenaar.net> |
| Mime-Version: 1.0 |
| Content-Type: text/plain; charset=UTF-8 |
| Content-Transfer-Encoding: 8bit |
| |
| |
| Patch 7.3.1100 |
| Problem: Python: a few more memory problems. |
| Solution: Add and remove Py_XDECREF(). (ZyX) |
| Files: src/if_py_both.h, src/testdir/test86.in, src/testdir/test86.ok, |
| src/testdir/test87.in, src/testdir/test87.ok |
| |
| |
| |
| |
| |
| *** 1236,1241 **** |
| --- 1236,1242 ---- |
| if (*key == NUL) |
| { |
| RAISE_NO_EMPTY_KEYS; |
| + Py_XDECREF(todecref); |
| return -1; |
| } |
| |
| |
| *** 1254,1264 **** |
| --- 1255,1269 ---- |
| hi = hash_find(&dict->dv_hashtab, di->di_key); |
| hash_remove(&dict->dv_hashtab, hi); |
| dictitem_free(di); |
| + Py_XDECREF(todecref); |
| return 0; |
| } |
| |
| if (ConvertFromPyObject(valObject, &tv) == -1) |
| + { |
| + Py_XDECREF(todecref); |
| return -1; |
| + } |
| |
| if (di == NULL) |
| { |
| |
| *** 2505,2515 **** |
| PyObject *todecref; |
| |
| if ((val = StringToChars(valObject, &todecref))) |
| - { |
| r = set_option_value_for(key, 0, val, opt_flags, |
| self->opt_type, self->from); |
| - Py_XDECREF(todecref); |
| - } |
| else |
| r = -1; |
| } |
| --- 2510,2517 ---- |
| |
| |
| |
| *** 867,872 **** |
| --- 867,873 ---- |
| return subexpr_test(expr, 'ConvertFromPyObject', ( |
| 'None', # Not conversible |
| '{"": 1}', # Empty key not allowed |
| + '{u"": 1}', # Same, but with unicode object |
| 'FailingMapping()', # |
| 'FailingMappingKey()', # |
| )) |
| |
| |
| |
| *** 503,508 **** |
| --- 503,509 ---- |
| >>> Testing ConvertFromPyObject using d["a"] = {"abc" : %s} |
| d["a"] = {"abc" : None}:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| d["a"] = {"abc" : {"": 1}}:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + d["a"] = {"abc" : {u"": 1}}:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| d["a"] = {"abc" : FailingMapping()}:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| d["a"] = {"abc" : FailingMappingKey()}:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 528,533 **** |
| --- 529,535 ---- |
| >>> Testing ConvertFromPyObject using d["a"] = Mapping({"abc" : %s}) |
| d["a"] = Mapping({"abc" : None}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| d["a"] = Mapping({"abc" : {"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + d["a"] = Mapping({"abc" : {u"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| d["a"] = Mapping({"abc" : FailingMapping()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| d["a"] = Mapping({"abc" : FailingMappingKey()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 538,543 **** |
| --- 540,546 ---- |
| >>> Testing ConvertFromPyObject using d["a"] = %s |
| d["a"] = None:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| d["a"] = {"": 1}:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + d["a"] = {u"": 1}:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| d["a"] = FailingMapping():(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| d["a"] = FailingMappingKey():(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 568,573 **** |
| --- 571,577 ---- |
| >>> Testing ConvertFromPyObject using d.update({"abc" : %s}) |
| d.update({"abc" : None}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| d.update({"abc" : {"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + d.update({"abc" : {u"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update({"abc" : FailingMapping()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| d.update({"abc" : FailingMappingKey()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 593,598 **** |
| --- 597,603 ---- |
| >>> Testing ConvertFromPyObject using d.update(Mapping({"abc" : %s})) |
| d.update(Mapping({"abc" : None})):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| d.update(Mapping({"abc" : {"": 1}})):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + d.update(Mapping({"abc" : {u"": 1}})):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update(Mapping({"abc" : FailingMapping()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| d.update(Mapping({"abc" : FailingMappingKey()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 603,608 **** |
| --- 608,614 ---- |
| >>> Testing ConvertFromPyObject using d.update(%s) |
| d.update(None):(<type 'exceptions.TypeError'>, TypeError("'NoneType' object is not iterable",)) |
| d.update({"": 1}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + d.update({u"": 1}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update(FailingMapping()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| d.update(FailingMappingKey()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 633,638 **** |
| --- 639,645 ---- |
| >>> Testing ConvertFromPyObject using d.update((("a", {"abc" : %s}),)) |
| d.update((("a", {"abc" : None}),)):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| d.update((("a", {"abc" : {"": 1}}),)):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + d.update((("a", {"abc" : {u"": 1}}),)):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update((("a", {"abc" : FailingMapping()}),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| d.update((("a", {"abc" : FailingMappingKey()}),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 658,663 **** |
| --- 665,671 ---- |
| >>> Testing ConvertFromPyObject using d.update((("a", Mapping({"abc" : %s})),)) |
| d.update((("a", Mapping({"abc" : None})),)):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| d.update((("a", Mapping({"abc" : {"": 1}})),)):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + d.update((("a", Mapping({"abc" : {u"": 1}})),)):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update((("a", Mapping({"abc" : FailingMapping()})),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| d.update((("a", Mapping({"abc" : FailingMappingKey()})),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 668,673 **** |
| --- 676,682 ---- |
| >>> Testing ConvertFromPyObject using d.update((("a", %s),)) |
| d.update((("a", None),)):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| d.update((("a", {"": 1}),)):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + d.update((("a", {u"": 1}),)):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update((("a", FailingMapping()),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| d.update((("a", FailingMappingKey()),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 701,706 **** |
| --- 710,716 ---- |
| >>> Testing ConvertFromPyObject using vim.List([{"abc" : %s}]) |
| vim.List([{"abc" : None}]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| vim.List([{"abc" : {"": 1}}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + vim.List([{"abc" : {u"": 1}}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| vim.List([{"abc" : FailingMapping()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| vim.List([{"abc" : FailingMappingKey()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 726,731 **** |
| --- 736,742 ---- |
| >>> Testing ConvertFromPyObject using vim.List([Mapping({"abc" : %s})]) |
| vim.List([Mapping({"abc" : None})]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| vim.List([Mapping({"abc" : {"": 1}})]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + vim.List([Mapping({"abc" : {u"": 1}})]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| vim.List([Mapping({"abc" : FailingMapping()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| vim.List([Mapping({"abc" : FailingMappingKey()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 736,741 **** |
| --- 747,753 ---- |
| >>> Testing ConvertFromPyObject using vim.List([%s]) |
| vim.List([None]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| vim.List([{"": 1}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + vim.List([{u"": 1}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| vim.List([FailingMapping()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| vim.List([FailingMappingKey()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 768,773 **** |
| --- 780,786 ---- |
| >>> Testing ConvertFromPyObject using l[:] = [{"abc" : %s}] |
| l[:] = [{"abc" : None}]:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| l[:] = [{"abc" : {"": 1}}]:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + l[:] = [{"abc" : {u"": 1}}]:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| l[:] = [{"abc" : FailingMapping()}]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| l[:] = [{"abc" : FailingMappingKey()}]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 793,798 **** |
| --- 806,812 ---- |
| >>> Testing ConvertFromPyObject using l[:] = [Mapping({"abc" : %s})] |
| l[:] = [Mapping({"abc" : None})]:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| l[:] = [Mapping({"abc" : {"": 1}})]:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + l[:] = [Mapping({"abc" : {u"": 1}})]:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| l[:] = [Mapping({"abc" : FailingMapping()})]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| l[:] = [Mapping({"abc" : FailingMappingKey()})]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 803,808 **** |
| --- 817,823 ---- |
| >>> Testing ConvertFromPyObject using l[:] = [%s] |
| l[:] = [None]:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| l[:] = [{"": 1}]:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + l[:] = [{u"": 1}]:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| l[:] = [FailingMapping()]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| l[:] = [FailingMappingKey()]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 829,834 **** |
| --- 844,850 ---- |
| >>> Testing ConvertFromPyObject using l.extend([{"abc" : %s}]) |
| l.extend([{"abc" : None}]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| l.extend([{"abc" : {"": 1}}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + l.extend([{"abc" : {u"": 1}}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| l.extend([{"abc" : FailingMapping()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| l.extend([{"abc" : FailingMappingKey()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 854,859 **** |
| --- 870,876 ---- |
| >>> Testing ConvertFromPyObject using l.extend([Mapping({"abc" : %s})]) |
| l.extend([Mapping({"abc" : None})]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| l.extend([Mapping({"abc" : {"": 1}})]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + l.extend([Mapping({"abc" : {u"": 1}})]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| l.extend([Mapping({"abc" : FailingMapping()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| l.extend([Mapping({"abc" : FailingMappingKey()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 864,869 **** |
| --- 881,887 ---- |
| >>> Testing ConvertFromPyObject using l.extend([%s]) |
| l.extend([None]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| l.extend([{"": 1}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + l.extend([{u"": 1}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| l.extend([FailingMapping()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| l.extend([FailingMappingKey()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 899,904 **** |
| --- 917,923 ---- |
| >>> Testing ConvertFromPyObject using f({"abc" : %s}) |
| f({"abc" : None}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| f({"abc" : {"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + f({"abc" : {u"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| f({"abc" : FailingMapping()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| f({"abc" : FailingMappingKey()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 924,929 **** |
| --- 943,949 ---- |
| >>> Testing ConvertFromPyObject using f(Mapping({"abc" : %s})) |
| f(Mapping({"abc" : None})):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| f(Mapping({"abc" : {"": 1}})):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + f(Mapping({"abc" : {u"": 1}})):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| f(Mapping({"abc" : FailingMapping()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| f(Mapping({"abc" : FailingMappingKey()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 934,939 **** |
| --- 954,960 ---- |
| >>> Testing ConvertFromPyObject using f(%s) |
| f(None):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| f({"": 1}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + f({u"": 1}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| f(FailingMapping()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| f(FailingMappingKey()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 959,964 **** |
| --- 980,986 ---- |
| >>> Testing ConvertFromPyObject using fd(self={"abc" : %s}) |
| fd(self={"abc" : None}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| fd(self={"abc" : {"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + fd(self={"abc" : {u"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| fd(self={"abc" : FailingMapping()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| fd(self={"abc" : FailingMappingKey()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 984,989 **** |
| --- 1006,1012 ---- |
| >>> Testing ConvertFromPyObject using fd(self=Mapping({"abc" : %s})) |
| fd(self=Mapping({"abc" : None})):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| fd(self=Mapping({"abc" : {"": 1}})):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + fd(self=Mapping({"abc" : {u"": 1}})):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| fd(self=Mapping({"abc" : FailingMapping()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| fd(self=Mapping({"abc" : FailingMappingKey()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| *** 994,999 **** |
| --- 1017,1023 ---- |
| >>> Testing ConvertFromPyObject using fd(self=%s) |
| fd(self=None):(<type 'exceptions.TypeError'>, TypeError('unable to convert object to vim dictionary',)) |
| fd(self={"": 1}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| + fd(self={u"": 1}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| fd(self=FailingMapping()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| fd(self=FailingMappingKey()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| <<< Finished |
| |
| |
| |
| *** 833,839 **** |
| iter_test(expr) |
| return subexpr_test(expr, 'ConvertFromPyObject', ( |
| 'None', # Not conversible |
| ! '{"": 1}', # Empty key not allowed |
| 'FailingMapping()', # |
| 'FailingMappingKey()', # |
| )) |
| --- 833,840 ---- |
| iter_test(expr) |
| return subexpr_test(expr, 'ConvertFromPyObject', ( |
| 'None', # Not conversible |
| ! '{b"": 1}', # Empty key not allowed |
| ! '{"": 1}', # Same, but with unicode object |
| 'FailingMapping()', # |
| 'FailingMappingKey()', # |
| )) |
| |
| |
| |
| *** 495,500 **** |
| --- 495,501 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using d["a"] = {"abc" : %s} |
| d["a"] = {"abc" : None}:(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + d["a"] = {"abc" : {b"": 1}}:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d["a"] = {"abc" : {"": 1}}:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d["a"] = {"abc" : FailingMapping()}:(<class 'NotImplementedError'>, NotImplementedError()) |
| d["a"] = {"abc" : FailingMappingKey()}:(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 520,525 **** |
| --- 521,527 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using d["a"] = Mapping({"abc" : %s}) |
| d["a"] = Mapping({"abc" : None}):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + d["a"] = Mapping({"abc" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d["a"] = Mapping({"abc" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d["a"] = Mapping({"abc" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError()) |
| d["a"] = Mapping({"abc" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 530,535 **** |
| --- 532,538 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using d["a"] = %s |
| d["a"] = None:(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + d["a"] = {b"": 1}:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d["a"] = {"": 1}:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d["a"] = FailingMapping():(<class 'NotImplementedError'>, NotImplementedError()) |
| d["a"] = FailingMappingKey():(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 564,569 **** |
| --- 567,573 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using d.update({"abc" : %s}) |
| d.update({"abc" : None}):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + d.update({"abc" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update({"abc" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update({"abc" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError()) |
| d.update({"abc" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 589,594 **** |
| --- 593,599 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using d.update(Mapping({"abc" : %s})) |
| d.update(Mapping({"abc" : None})):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + d.update(Mapping({"abc" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update(Mapping({"abc" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update(Mapping({"abc" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError()) |
| d.update(Mapping({"abc" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 599,604 **** |
| --- 604,610 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using d.update(%s) |
| d.update(None):(<class 'TypeError'>, TypeError("'NoneType' object is not iterable",)) |
| + d.update({b"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update({"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update(FailingMapping()):(<class 'NotImplementedError'>, NotImplementedError()) |
| d.update(FailingMappingKey()):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 629,634 **** |
| --- 635,641 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using d.update((("a", {"abc" : %s}),)) |
| d.update((("a", {"abc" : None}),)):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + d.update((("a", {"abc" : {b"": 1}}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update((("a", {"abc" : {"": 1}}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update((("a", {"abc" : FailingMapping()}),)):(<class 'NotImplementedError'>, NotImplementedError()) |
| d.update((("a", {"abc" : FailingMappingKey()}),)):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 654,659 **** |
| --- 661,667 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using d.update((("a", Mapping({"abc" : %s})),)) |
| d.update((("a", Mapping({"abc" : None})),)):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + d.update((("a", Mapping({"abc" : {b"": 1}})),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update((("a", Mapping({"abc" : {"": 1}})),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update((("a", Mapping({"abc" : FailingMapping()})),)):(<class 'NotImplementedError'>, NotImplementedError()) |
| d.update((("a", Mapping({"abc" : FailingMappingKey()})),)):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 664,669 **** |
| --- 672,678 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using d.update((("a", %s),)) |
| d.update((("a", None),)):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + d.update((("a", {b"": 1}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update((("a", {"": 1}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| d.update((("a", FailingMapping()),)):(<class 'NotImplementedError'>, NotImplementedError()) |
| d.update((("a", FailingMappingKey()),)):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 701,706 **** |
| --- 710,716 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using vim.List([{"abc" : %s}]) |
| vim.List([{"abc" : None}]):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + vim.List([{"abc" : {b"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| vim.List([{"abc" : {"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| vim.List([{"abc" : FailingMapping()}]):(<class 'NotImplementedError'>, NotImplementedError()) |
| vim.List([{"abc" : FailingMappingKey()}]):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 726,731 **** |
| --- 736,742 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using vim.List([Mapping({"abc" : %s})]) |
| vim.List([Mapping({"abc" : None})]):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + vim.List([Mapping({"abc" : {b"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| vim.List([Mapping({"abc" : {"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| vim.List([Mapping({"abc" : FailingMapping()})]):(<class 'NotImplementedError'>, NotImplementedError()) |
| vim.List([Mapping({"abc" : FailingMappingKey()})]):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 736,741 **** |
| --- 747,753 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using vim.List([%s]) |
| vim.List([None]):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + vim.List([{b"": 1}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| vim.List([{"": 1}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| vim.List([FailingMapping()]):(<class 'NotImplementedError'>, NotImplementedError()) |
| vim.List([FailingMappingKey()]):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 772,777 **** |
| --- 784,790 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using l[:] = [{"abc" : %s}] |
| l[:] = [{"abc" : None}]:(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + l[:] = [{"abc" : {b"": 1}}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l[:] = [{"abc" : {"": 1}}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l[:] = [{"abc" : FailingMapping()}]:(<class 'NotImplementedError'>, NotImplementedError()) |
| l[:] = [{"abc" : FailingMappingKey()}]:(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 797,802 **** |
| --- 810,816 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using l[:] = [Mapping({"abc" : %s})] |
| l[:] = [Mapping({"abc" : None})]:(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + l[:] = [Mapping({"abc" : {b"": 1}})]:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l[:] = [Mapping({"abc" : {"": 1}})]:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l[:] = [Mapping({"abc" : FailingMapping()})]:(<class 'NotImplementedError'>, NotImplementedError()) |
| l[:] = [Mapping({"abc" : FailingMappingKey()})]:(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 807,812 **** |
| --- 821,827 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using l[:] = [%s] |
| l[:] = [None]:(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + l[:] = [{b"": 1}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l[:] = [{"": 1}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l[:] = [FailingMapping()]:(<class 'NotImplementedError'>, NotImplementedError()) |
| l[:] = [FailingMappingKey()]:(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 837,842 **** |
| --- 852,858 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using l.extend([{"abc" : %s}]) |
| l.extend([{"abc" : None}]):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + l.extend([{"abc" : {b"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l.extend([{"abc" : {"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l.extend([{"abc" : FailingMapping()}]):(<class 'NotImplementedError'>, NotImplementedError()) |
| l.extend([{"abc" : FailingMappingKey()}]):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 862,867 **** |
| --- 878,884 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using l.extend([Mapping({"abc" : %s})]) |
| l.extend([Mapping({"abc" : None})]):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + l.extend([Mapping({"abc" : {b"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l.extend([Mapping({"abc" : {"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l.extend([Mapping({"abc" : FailingMapping()})]):(<class 'NotImplementedError'>, NotImplementedError()) |
| l.extend([Mapping({"abc" : FailingMappingKey()})]):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 872,877 **** |
| --- 889,895 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using l.extend([%s]) |
| l.extend([None]):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + l.extend([{b"": 1}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l.extend([{"": 1}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| l.extend([FailingMapping()]):(<class 'NotImplementedError'>, NotImplementedError()) |
| l.extend([FailingMappingKey()]):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 907,912 **** |
| --- 925,931 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using f({"abc" : %s}) |
| f({"abc" : None}):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + f({"abc" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| f({"abc" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| f({"abc" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError()) |
| f({"abc" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 932,937 **** |
| --- 951,957 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using f(Mapping({"abc" : %s})) |
| f(Mapping({"abc" : None})):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + f(Mapping({"abc" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| f(Mapping({"abc" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| f(Mapping({"abc" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError()) |
| f(Mapping({"abc" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 942,947 **** |
| --- 962,968 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using f(%s) |
| f(None):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + f({b"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| f({"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| f(FailingMapping()):(<class 'NotImplementedError'>, NotImplementedError()) |
| f(FailingMappingKey()):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 967,972 **** |
| --- 988,994 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using fd(self={"abc" : %s}) |
| fd(self={"abc" : None}):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + fd(self={"abc" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| fd(self={"abc" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| fd(self={"abc" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError()) |
| fd(self={"abc" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 992,997 **** |
| --- 1014,1020 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using fd(self=Mapping({"abc" : %s})) |
| fd(self=Mapping({"abc" : None})):(<class 'TypeError'>, TypeError('unable to convert to vim structure',)) |
| + fd(self=Mapping({"abc" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| fd(self=Mapping({"abc" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| fd(self=Mapping({"abc" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError()) |
| fd(self=Mapping({"abc" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| *** 1002,1007 **** |
| --- 1025,1031 ---- |
| <<< Finished |
| >>> Testing ConvertFromPyObject using fd(self=%s) |
| fd(self=None):(<class 'TypeError'>, TypeError('unable to convert object to vim dictionary',)) |
| + fd(self={b"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| fd(self={"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',)) |
| fd(self=FailingMapping()):(<class 'NotImplementedError'>, NotImplementedError()) |
| fd(self=FailingMappingKey()):(<class 'NotImplementedError'>, NotImplementedError()) |
| |
| |
| |
| *** 730,731 **** |
| --- 730,733 ---- |
| { /* Add new patch number below this line */ |
| + /**/ |
| + 1100, |
| /**/ |
| |
| -- |
| hundred-and-one symptoms of being an internet addict: |
| 48. You get a tatoo that says "This body best viewed with Netscape 3.1 or |
| higher." |
| |
| /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\ |
| /// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\ |
| \\\ an exciting new programming language -- http://www.Zimbu.org /// |
| \\\ help me help AIDS victims -- http://ICCF-Holland.org /// |