Bram Moolenaar | db91395 | 2012-06-29 12:54:53 +0200 | [diff] [blame] | 1 | start: |
| 2 | [1, 'as''d', [1, 2, function('strlen'), {'a': 1}]] |
| 3 | [1, 2, function('strlen'), {'a': 1}] |
| 4 | Vim(put):E684: |
| 5 | [0, 'as''d', [1, 2, function('strlen'), {'a': 1}]] |
| 6 | [0, function('strlen'), [1, 2, function('strlen'), {'a': 1}]] |
Bram Moolenaar | 355fd9b | 2013-05-30 13:14:13 +0200 | [diff] [blame] | 7 | 1 |
| 8 | ['-1', '0', '1', 'b', 'f'] |
| 9 | ['asd', -1L, <vim.Function '1'>, <vim.dictionary object at >, <vim.list object at >] |
| 10 | [('-1', <vim.dictionary object at >), ('0', -1L), ('1', 'asd'), ('b', <vim.list object at >), ('f', <vim.Function '1'>)] |
Bram Moolenaar | db91395 | 2012-06-29 12:54:53 +0200 | [diff] [blame] | 11 | '-1' : {'a': 1} |
Bram Moolenaar | a9922d6 | 2013-05-30 13:01:18 +0200 | [diff] [blame] | 12 | '0' : -1 |
Bram Moolenaar | db91395 | 2012-06-29 12:54:53 +0200 | [diff] [blame] | 13 | '1' : 'asd' |
| 14 | 'b' : [1, 2, function('strlen')] |
Bram Moolenaar | 355fd9b | 2013-05-30 13:14:13 +0200 | [diff] [blame] | 15 | 'f' : function('1') |
Bram Moolenaar | db91395 | 2012-06-29 12:54:53 +0200 | [diff] [blame] | 16 | [0, function('strlen')] |
| 17 | [3] |
Bram Moolenaar | a9922d6 | 2013-05-30 13:01:18 +0200 | [diff] [blame] | 18 | [1, 2, function('strlen')] |
| 19 | [1, 2, function('strlen')] |
| 20 | 1 |
| 21 | 'asd' |
| 22 | 2 |
| 23 | True |
| 24 | False |
| 25 | True |
| 26 | False |
| 27 | ['0'] |
| 28 | {'0': -1} |
| 29 | ('', -1L) |
| 30 | None |
| 31 | [] |
Bram Moolenaar | db91395 | 2012-06-29 12:54:53 +0200 | [diff] [blame] | 32 | [0, 1, 2, 3] |
| 33 | [0, 1, 2, 3] |
| 34 | [0, 1, 3] |
| 35 | [0, 1] |
| 36 | [0, 1] |
| 37 | [0, 1] |
| 38 | [0, 1, 2, 3] |
| 39 | [0, 1, 2, 3] |
| 40 | [0, 2, 3] |
| 41 | [2, 3] |
| 42 | [2, 3] |
| 43 | [2, 3] |
| 44 | ['a', 0, 1, 2, 3] |
| 45 | [0, 'b', 2, 3] |
| 46 | [0, 1, 'c'] |
| 47 | [0, 1, 2, 3, 'd'] |
| 48 | [0, 1, 2, 'e', 3] |
| 49 | ['f', 2, 3] |
| 50 | [0, 1, 'g', 2, 3] |
| 51 | ['h'] |
| 52 | [0, 1, 2, 3] |
| 53 | [function('New'), function('DictNew'), 'NewStart', 1, 2, 3, 'NewEnd'] |
| 54 | [function('New'), function('DictNew'), 'NewStart', 1, 2, 3, 'NewEnd', 'DictNewStart', 1, 2, 3, 'DictNewEnd', {'a': 'b'}] |
| 55 | [function('New'), function('DictNew'), 'NewStart', 1, 2, 3, 'NewEnd', 'DictNewStart', 1, 2, 3, 'DictNewEnd', {'a': 'b'}, 'New'] |
| 56 | Vim(python):E725: |
| 57 | Vim(python):E117: |
| 58 | [0.0, 0.0] |
Bram Moolenaar | af6abb9 | 2013-04-24 13:04:26 +0200 | [diff] [blame] | 59 | KeyError |
Bram Moolenaar | c11073c | 2012-09-05 19:17:42 +0200 | [diff] [blame] | 60 | TypeError |
| 61 | TypeError |
| 62 | ValueError |
| 63 | TypeError |
| 64 | TypeError |
Bram Moolenaar | a9922d6 | 2013-05-30 13:01:18 +0200 | [diff] [blame] | 65 | KeyError |
| 66 | KeyError |
Bram Moolenaar | 66b7985 | 2012-09-21 14:00:35 +0200 | [diff] [blame] | 67 | d : locked:0;scope:0 |
| 68 | dl : locked:1;scope:0 |
| 69 | v: : locked:2;scope:1 |
| 70 | g: : locked:0;scope:2 |
| 71 | d:{'abc': 1} |
| 72 | dl:{'def': 1} |
| 73 | l : locked:0 |
| 74 | ll : locked:1 |
| 75 | l:[0] |
| 76 | ll:[1] |
Bram Moolenaar | db91395 | 2012-06-29 12:54:53 +0200 | [diff] [blame] | 77 | [0, 1, 2] |
| 78 | ['a', 'b'] |
| 79 | ['c', 1] |
| 80 | ['d', ['e']] |
Bram Moolenaar | db91395 | 2012-06-29 12:54:53 +0200 | [diff] [blame] | 81 | 0.0 |
Bram Moolenaar | c11073c | 2012-09-05 19:17:42 +0200 | [diff] [blame] | 82 | "\0": Vim(let):E859: |
| 83 | {"\0": 1}: Vim(let):E859: |
Bram Moolenaar | 995a8cd | 2013-02-20 16:54:27 +0100 | [diff] [blame] | 84 | undefined_name: Vim(let):Trace |
Bram Moolenaar | c11073c | 2012-09-05 19:17:42 +0200 | [diff] [blame] | 85 | vim: Vim(let):E859: |
Bram Moolenaar | 76d711c | 2013-02-13 14:17:08 +0100 | [diff] [blame] | 86 | [1] |
| 87 | [1, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 1] |
Bram Moolenaar | 24b11fb | 2013-04-05 19:32:36 +0200 | [diff] [blame] | 88 | [0, 1, 2, 3] |
| 89 | [2, 3, 4, 5] |
| 90 | [0, 1] |
| 91 | [4, 5] |
| 92 | [2, 3] |
| 93 | [] |
| 94 | [2, 3] |
| 95 | [] |
| 96 | [0, 1, 2, 3, 4, 5] |
| 97 | [0, 1, 2, 3, 4, 5] |
| 98 | [0, 1, 2, 3, 4, 5] |
Bram Moolenaar | 230bb3f | 2013-04-24 14:07:45 +0200 | [diff] [blame] | 99 | Abc |
| 100 | bac |
| 101 | def |
| 102 | bar |
Bram Moolenaar | a472001 | 2013-05-15 16:27:37 +0200 | [diff] [blame] | 103 | jkl |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 104 | >>> paste |
| 105 | p/gopts1: False |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 106 | p/wopts1! KeyError |
| 107 | inv: 2! KeyError |
| 108 | wopts1! KeyError |
| 109 | wopts2! KeyError |
| 110 | wopts3! KeyError |
| 111 | p/bopts1! KeyError |
| 112 | inv: 2! KeyError |
| 113 | bopts1! KeyError |
| 114 | bopts2! KeyError |
| 115 | bopts3! KeyError |
| 116 | G: 1 |
| 117 | W: 1:1 2:1 3:1 4:1 |
| 118 | B: 1:1 2:1 3:1 4:1 |
| 119 | del wopts3! KeyError |
| 120 | del bopts3! KeyError |
| 121 | G: 1 |
| 122 | W: 1:1 2:1 3:1 4:1 |
| 123 | B: 1:1 2:1 3:1 4:1 |
| 124 | >>> previewheight |
| 125 | p/gopts1: 12 |
Bram Moolenaar | 8661b17 | 2013-05-15 15:44:28 +0200 | [diff] [blame] | 126 | inv: 'a'! TypeError |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 127 | p/wopts1! KeyError |
| 128 | inv: 'a'! KeyError |
| 129 | wopts1! KeyError |
| 130 | wopts2! KeyError |
| 131 | wopts3! KeyError |
| 132 | p/bopts1! KeyError |
| 133 | inv: 'a'! KeyError |
| 134 | bopts1! KeyError |
| 135 | bopts2! KeyError |
| 136 | bopts3! KeyError |
| 137 | G: 5 |
| 138 | W: 1:5 2:5 3:5 4:5 |
| 139 | B: 1:5 2:5 3:5 4:5 |
| 140 | del wopts3! KeyError |
| 141 | del bopts3! KeyError |
| 142 | G: 5 |
| 143 | W: 1:5 2:5 3:5 4:5 |
| 144 | B: 1:5 2:5 3:5 4:5 |
| 145 | >>> operatorfunc |
| 146 | p/gopts1: '' |
Bram Moolenaar | 8661b17 | 2013-05-15 15:44:28 +0200 | [diff] [blame] | 147 | inv: 2! TypeError |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 148 | p/wopts1! KeyError |
| 149 | inv: 2! KeyError |
| 150 | wopts1! KeyError |
| 151 | wopts2! KeyError |
| 152 | wopts3! KeyError |
| 153 | p/bopts1! KeyError |
| 154 | inv: 2! KeyError |
| 155 | bopts1! KeyError |
| 156 | bopts2! KeyError |
| 157 | bopts3! KeyError |
| 158 | G: 'A' |
| 159 | W: 1:'A' 2:'A' 3:'A' 4:'A' |
| 160 | B: 1:'A' 2:'A' 3:'A' 4:'A' |
| 161 | del wopts3! KeyError |
| 162 | del bopts3! KeyError |
| 163 | G: 'A' |
| 164 | W: 1:'A' 2:'A' 3:'A' 4:'A' |
| 165 | B: 1:'A' 2:'A' 3:'A' 4:'A' |
| 166 | >>> number |
| 167 | p/gopts1! KeyError |
| 168 | inv: 0! KeyError |
| 169 | gopts1! KeyError |
| 170 | p/wopts1: False |
| 171 | p/bopts1! KeyError |
| 172 | inv: 0! KeyError |
| 173 | bopts1! KeyError |
| 174 | bopts2! KeyError |
| 175 | bopts3! KeyError |
| 176 | G: 0 |
| 177 | W: 1:1 2:1 3:0 4:0 |
| 178 | B: 1:1 2:1 3:0 4:0 |
| 179 | del wopts3! ValueError |
| 180 | del bopts3! KeyError |
| 181 | G: 0 |
| 182 | W: 1:1 2:1 3:0 4:0 |
| 183 | B: 1:1 2:1 3:0 4:0 |
| 184 | >>> numberwidth |
| 185 | p/gopts1! KeyError |
| 186 | inv: -100! KeyError |
| 187 | gopts1! KeyError |
| 188 | p/wopts1: 8 |
Bram Moolenaar | c96ebe7 | 2013-05-21 22:38:18 +0200 | [diff] [blame] | 189 | inv: -100! error |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 190 | p/bopts1! KeyError |
| 191 | inv: -100! KeyError |
| 192 | bopts1! KeyError |
| 193 | bopts2! KeyError |
| 194 | bopts3! KeyError |
| 195 | G: 8 |
| 196 | W: 1:3 2:5 3:2 4:8 |
| 197 | B: 1:3 2:5 3:2 4:8 |
| 198 | del wopts3! ValueError |
| 199 | del bopts3! KeyError |
| 200 | G: 8 |
| 201 | W: 1:3 2:5 3:2 4:8 |
| 202 | B: 1:3 2:5 3:2 4:8 |
| 203 | >>> colorcolumn |
| 204 | p/gopts1! KeyError |
| 205 | inv: 'abc'! KeyError |
| 206 | gopts1! KeyError |
| 207 | p/wopts1: '' |
Bram Moolenaar | c96ebe7 | 2013-05-21 22:38:18 +0200 | [diff] [blame] | 208 | inv: 'abc'! error |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 209 | p/bopts1! KeyError |
| 210 | inv: 'abc'! KeyError |
| 211 | bopts1! KeyError |
| 212 | bopts2! KeyError |
| 213 | bopts3! KeyError |
| 214 | G: '' |
| 215 | W: 1:'+2' 2:'+3' 3:'+1' 4:'' |
| 216 | B: 1:'+2' 2:'+3' 3:'+1' 4:'' |
| 217 | del wopts3! ValueError |
| 218 | del bopts3! KeyError |
| 219 | G: '' |
| 220 | W: 1:'+2' 2:'+3' 3:'+1' 4:'' |
| 221 | B: 1:'+2' 2:'+3' 3:'+1' 4:'' |
| 222 | >>> statusline |
| 223 | p/gopts1: '' |
Bram Moolenaar | 8661b17 | 2013-05-15 15:44:28 +0200 | [diff] [blame] | 224 | inv: 0! TypeError |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 225 | p/wopts1: None |
Bram Moolenaar | 8661b17 | 2013-05-15 15:44:28 +0200 | [diff] [blame] | 226 | inv: 0! TypeError |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 227 | p/bopts1! KeyError |
| 228 | inv: 0! KeyError |
| 229 | bopts1! KeyError |
| 230 | bopts2! KeyError |
| 231 | bopts3! KeyError |
| 232 | G: '1' |
| 233 | W: 1:'2' 2:'4' 3:'1' 4:'1' |
| 234 | B: 1:'2' 2:'4' 3:'1' 4:'1' |
| 235 | del bopts3! KeyError |
| 236 | G: '1' |
| 237 | W: 1:'2' 2:'1' 3:'1' 4:'1' |
| 238 | B: 1:'2' 2:'1' 3:'1' 4:'1' |
| 239 | >>> autoindent |
| 240 | p/gopts1! KeyError |
| 241 | inv: 2! KeyError |
| 242 | gopts1! KeyError |
| 243 | p/wopts1! KeyError |
| 244 | inv: 2! KeyError |
| 245 | wopts1! KeyError |
| 246 | wopts2! KeyError |
| 247 | wopts3! KeyError |
| 248 | p/bopts1: False |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 249 | G: 0 |
Bram Moolenaar | dfa38d4 | 2013-05-15 13:38:47 +0200 | [diff] [blame] | 250 | W: 1:0 2:1 3:0 4:1 |
| 251 | B: 1:0 2:1 3:0 4:1 |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 252 | del wopts3! KeyError |
| 253 | del bopts3! ValueError |
| 254 | G: 0 |
Bram Moolenaar | dfa38d4 | 2013-05-15 13:38:47 +0200 | [diff] [blame] | 255 | W: 1:0 2:1 3:0 4:1 |
| 256 | B: 1:0 2:1 3:0 4:1 |
Bram Moolenaar | 55b8ad3 | 2013-05-17 13:38:04 +0200 | [diff] [blame] | 257 | >>> shiftwidth |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 258 | p/gopts1! KeyError |
| 259 | inv: 3! KeyError |
| 260 | gopts1! KeyError |
| 261 | p/wopts1! KeyError |
| 262 | inv: 3! KeyError |
| 263 | wopts1! KeyError |
| 264 | wopts2! KeyError |
| 265 | wopts3! KeyError |
Bram Moolenaar | 55b8ad3 | 2013-05-17 13:38:04 +0200 | [diff] [blame] | 266 | p/bopts1: 8 |
| 267 | G: 8 |
| 268 | W: 1:0 2:2 3:8 4:1 |
| 269 | B: 1:0 2:2 3:8 4:1 |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 270 | del wopts3! KeyError |
| 271 | del bopts3! ValueError |
Bram Moolenaar | 55b8ad3 | 2013-05-17 13:38:04 +0200 | [diff] [blame] | 272 | G: 8 |
| 273 | W: 1:0 2:2 3:8 4:1 |
| 274 | B: 1:0 2:2 3:8 4:1 |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 275 | >>> omnifunc |
| 276 | p/gopts1! KeyError |
| 277 | inv: 1! KeyError |
| 278 | gopts1! KeyError |
| 279 | p/wopts1! KeyError |
| 280 | inv: 1! KeyError |
| 281 | wopts1! KeyError |
| 282 | wopts2! KeyError |
| 283 | wopts3! KeyError |
| 284 | p/bopts1: '' |
Bram Moolenaar | 8661b17 | 2013-05-15 15:44:28 +0200 | [diff] [blame] | 285 | inv: 1! TypeError |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 286 | G: '' |
Bram Moolenaar | dfa38d4 | 2013-05-15 13:38:47 +0200 | [diff] [blame] | 287 | W: 1:'A' 2:'B' 3:'' 4:'C' |
| 288 | B: 1:'A' 2:'B' 3:'' 4:'C' |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 289 | del wopts3! KeyError |
| 290 | del bopts3! ValueError |
| 291 | G: '' |
Bram Moolenaar | dfa38d4 | 2013-05-15 13:38:47 +0200 | [diff] [blame] | 292 | W: 1:'A' 2:'B' 3:'' 4:'C' |
| 293 | B: 1:'A' 2:'B' 3:'' 4:'C' |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 294 | >>> preserveindent |
| 295 | p/gopts1! KeyError |
| 296 | inv: 2! KeyError |
| 297 | gopts1! KeyError |
| 298 | p/wopts1! KeyError |
| 299 | inv: 2! KeyError |
| 300 | wopts1! KeyError |
| 301 | wopts2! KeyError |
| 302 | wopts3! KeyError |
| 303 | p/bopts1: False |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 304 | G: 0 |
Bram Moolenaar | dfa38d4 | 2013-05-15 13:38:47 +0200 | [diff] [blame] | 305 | W: 1:0 2:1 3:0 4:1 |
| 306 | B: 1:0 2:1 3:0 4:1 |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 307 | del wopts3! KeyError |
| 308 | del bopts3! ValueError |
| 309 | G: 0 |
Bram Moolenaar | dfa38d4 | 2013-05-15 13:38:47 +0200 | [diff] [blame] | 310 | W: 1:0 2:1 3:0 4:1 |
| 311 | B: 1:0 2:1 3:0 4:1 |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 312 | >>> path |
| 313 | p/gopts1: '.,/usr/include,,' |
Bram Moolenaar | 8661b17 | 2013-05-15 15:44:28 +0200 | [diff] [blame] | 314 | inv: 0! TypeError |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 315 | p/wopts1! KeyError |
| 316 | inv: 0! KeyError |
| 317 | wopts1! KeyError |
| 318 | wopts2! KeyError |
| 319 | wopts3! KeyError |
| 320 | p/bopts1: None |
Bram Moolenaar | 8661b17 | 2013-05-15 15:44:28 +0200 | [diff] [blame] | 321 | inv: 0! TypeError |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 322 | G: '.,,' |
Bram Moolenaar | dfa38d4 | 2013-05-15 13:38:47 +0200 | [diff] [blame] | 323 | W: 1:'.,,' 2:',,' 3:'.,,' 4:'.' |
| 324 | B: 1:'.,,' 2:',,' 3:'.,,' 4:'.' |
Bram Moolenaar | 84e0f6c | 2013-05-06 03:52:55 +0200 | [diff] [blame] | 325 | del wopts3! KeyError |
| 326 | G: '.,,' |
Bram Moolenaar | dfa38d4 | 2013-05-15 13:38:47 +0200 | [diff] [blame] | 327 | W: 1:'.,,' 2:',,' 3:'.,,' 4:'.,,' |
| 328 | B: 1:'.,,' 2:',,' 3:'.,,' 4:'.,,' |
Bram Moolenaar | bd80f35 | 2013-05-12 21:16:23 +0200 | [diff] [blame] | 329 | First line |
| 330 | First line |
| 331 | def |
| 332 | First line |
| 333 | Second line |
| 334 | Third line |
| 335 | (7, 2) |
| 336 | <buffer test86.in><buffer > |
| 337 | baz |
| 338 | bar |
| 339 | Second line |
| 340 | Third line |
| 341 | foo |
Bram Moolenaar | e9ba516 | 2013-05-29 22:02:22 +0200 | [diff] [blame] | 342 | 1:BufFilePre:1 |
Bram Moolenaar | 7e28384 | 2013-05-30 11:43:15 +0200 | [diff] [blame] | 343 | 1:BufFilePost:1 |
Bram Moolenaar | e9ba516 | 2013-05-29 22:02:22 +0200 | [diff] [blame] | 344 | testdir/foo |
| 345 | 5:BufFilePre:5 |
| 346 | 5:BufFilePost:5 |
| 347 | testdir/bar |
| 348 | 1:BufFilePre:1 |
Bram Moolenaar | 7e28384 | 2013-05-30 11:43:15 +0200 | [diff] [blame] | 349 | 1:BufFilePost:1 |
Bram Moolenaar | e9ba516 | 2013-05-29 22:02:22 +0200 | [diff] [blame] | 350 | testdir/test86.in |
Bram Moolenaar | 9e822c0 | 2013-05-29 22:15:30 +0200 | [diff] [blame] | 351 | valid: b:False, cb:True |
Bram Moolenaar | b6c589a | 2013-05-15 14:39:52 +0200 | [diff] [blame] | 352 | i:<buffer test86.in> |
| 353 | i2:<buffer test86.in> |
| 354 | i:<buffer a> |
| 355 | i3:<buffer test86.in> |
| 356 | 1:<buffer test86.in>=<buffer test86.in> |
Bram Moolenaar | e9ba516 | 2013-05-29 22:02:22 +0200 | [diff] [blame] | 357 | 8:<buffer a>=<buffer a> |
| 358 | 9:<buffer b>=<buffer b> |
| 359 | 10:<buffer c>=<buffer c> |
Bram Moolenaar | b6c589a | 2013-05-15 14:39:52 +0200 | [diff] [blame] | 360 | 4 |
| 361 | i4:<buffer test86.in> |
| 362 | i4:<buffer test86.in> |
| 363 | StopIteration |
Bram Moolenaar | a472001 | 2013-05-15 16:27:37 +0200 | [diff] [blame] | 364 | Number of tabs: 4 |
| 365 | Current tab pages: |
| 366 | <tabpage 0>(1): 1 windows, current is <window object (unknown)> |
| 367 | Windows: |
Bram Moolenaar | 9e822c0 | 2013-05-29 22:15:30 +0200 | [diff] [blame] | 368 | <window object (unknown)>(1): displays buffer <buffer test86.in>; cursor is at (37, 0) |
Bram Moolenaar | a472001 | 2013-05-15 16:27:37 +0200 | [diff] [blame] | 369 | <tabpage 1>(2): 1 windows, current is <window object (unknown)> |
| 370 | Windows: |
Bram Moolenaar | cabf80f | 2013-05-17 16:18:33 +0200 | [diff] [blame] | 371 | <window object (unknown)>(1): displays buffer <buffer 0>; cursor is at (1, 0) |
Bram Moolenaar | a472001 | 2013-05-15 16:27:37 +0200 | [diff] [blame] | 372 | <tabpage 2>(3): 2 windows, current is <window object (unknown)> |
| 373 | Windows: |
Bram Moolenaar | cabf80f | 2013-05-17 16:18:33 +0200 | [diff] [blame] | 374 | <window object (unknown)>(1): displays buffer <buffer a.1>; cursor is at (1, 0) |
| 375 | <window object (unknown)>(2): displays buffer <buffer 1>; cursor is at (1, 0) |
Bram Moolenaar | a472001 | 2013-05-15 16:27:37 +0200 | [diff] [blame] | 376 | <tabpage 3>(4): 4 windows, current is <window 0> |
| 377 | Windows: |
| 378 | <window 0>(1): displays buffer <buffer c.2>; cursor is at (1, 0) |
| 379 | <window 1>(2): displays buffer <buffer b.2>; cursor is at (1, 0) |
| 380 | <window 2>(3): displays buffer <buffer a.2>; cursor is at (1, 0) |
| 381 | <window 3>(4): displays buffer <buffer 2>; cursor is at (1, 0) |
| 382 | Number of windows in current tab page: 4 |
| 383 | Current tab page: <tabpage 3> |
| 384 | Current window: <window 0>: <window 0> is <window 0> |
| 385 | Current buffer: <buffer c.2>: <buffer c.2> is <buffer c.2> is <buffer c.2> |
| 386 | ValueError at assigning foreign tab window |
| 387 | Type error at assigning None to vim.current.window |
| 388 | Type error at assigning None to vim.current.tabpage |
| 389 | Type error at assigning None to vim.current.buffer |
| 390 | Current tab page: <tabpage 2> |
| 391 | Current window: <window 0> |
| 392 | Current buffer: <buffer test86.in> |
| 393 | Current line: 'Type error at assigning None to vim.current.buffer' |
Bram Moolenaar | 9e822c0 | 2013-05-29 22:15:30 +0200 | [diff] [blame] | 394 | w.valid: [True, False] |
| 395 | t.valid: [True, False, True, False] |
Bram Moolenaar | cac867a | 2013-05-21 19:50:34 +0200 | [diff] [blame] | 396 | vim.vars:Dictionary:True |
| 397 | vim.options:Options:True |
| 398 | vim.bindeval("{}"):Dictionary:True |
| 399 | vim.bindeval("[]"):List:True |
| 400 | vim.bindeval("function('tr')"):Function:True |
| 401 | vim.current.buffer:Buffer:True |
| 402 | vim.current.range:Range:True |
| 403 | vim.current.window:Window:True |
| 404 | vim.current.tabpage:TabPage:True |
Bram Moolenaar | dd8aca6 | 2013-05-29 22:36:10 +0200 | [diff] [blame] | 405 | current:__dir__,__members__,buffer,line,range,tabpage,window |
| 406 | buffer:__dir__,__members__,append,mark,name,number,options,range,valid,vars |
| 407 | window:__dir__,__members__,buffer,col,cursor,height,number,options,row,tabpage,valid,vars |
| 408 | tabpage:__dir__,__members__,number,valid,vars,window,windows |
| 409 | range:__dir__,__members__,append,end,start |
Bram Moolenaar | a9922d6 | 2013-05-30 13:01:18 +0200 | [diff] [blame] | 410 | dictionary:__dir__,__members__,get,has_key,items,keys,locked,pop,popitem,scope,update,values |
Bram Moolenaar | dd8aca6 | 2013-05-29 22:36:10 +0200 | [diff] [blame] | 411 | list:__dir__,__members__,extend,locked |
Bram Moolenaar | 355fd9b | 2013-05-30 13:14:13 +0200 | [diff] [blame] | 412 | function:__dir__,__members__,softspace |
Bram Moolenaar | dd8aca6 | 2013-05-29 22:36:10 +0200 | [diff] [blame] | 413 | output:__dir__,__members__,flush,softspace,write,writelines |
Bram Moolenaar | a9922d6 | 2013-05-30 13:01:18 +0200 | [diff] [blame] | 414 | {} |
| 415 | {'a': 1} |
| 416 | {'a': 1} |
Bram Moolenaar | 78cddbe | 2013-05-30 13:05:58 +0200 | [diff] [blame] | 417 | [] |
| 418 | ['a', 'b', 'c'] |
Bram Moolenaar | 355fd9b | 2013-05-30 13:14:13 +0200 | [diff] [blame] | 419 | function('tr') |
Bram Moolenaar | 01a7a72 | 2013-05-30 12:26:58 +0200 | [diff] [blame] | 420 | ' |
| 421 | abcdef |
| 422 | line : |
| 423 | abcdef |
| 424 | abc |
| 425 | line : |
| 426 | abc' |
Bram Moolenaar | a9922d6 | 2013-05-30 13:01:18 +0200 | [diff] [blame] | 427 | ['a', 'dup_a'] |
Bram Moolenaar | 78cddbe | 2013-05-30 13:05:58 +0200 | [diff] [blame] | 428 | ['a', 'a'] |
| 429 | ['a', 'b', 'c'] |
Bram Moolenaar | 355fd9b | 2013-05-30 13:14:13 +0200 | [diff] [blame] | 430 | [2, 2] |
| 431 | [2, 2] |
Bram Moolenaar | 8600e40 | 2013-05-30 13:28:41 +0200 | [diff] [blame^] | 432 | > Output |
| 433 | >> OutputSetattr |
| 434 | del sys.stdout.softspace:(<type 'exceptions.AttributeError'>, AttributeError("can't delete OutputObject attributes",)) |
| 435 | sys.stdout.softspace = []:(<type 'exceptions.TypeError'>, TypeError('softspace must be an integer',)) |
| 436 | sys.stdout.attr = None:(<type 'exceptions.AttributeError'>, AttributeError('invalid attribute',)) |
| 437 | >> OutputWrite |
| 438 | sys.stdout.write(None):(<type 'exceptions.TypeError'>, TypeError('coercing to Unicode: need string or buffer, NoneType found',)) |
| 439 | >> OutputWriteLines |
| 440 | sys.stdout.writelines(None):(<type 'exceptions.TypeError'>, TypeError("'NoneType' object is not iterable",)) |
| 441 | sys.stdout.writelines([1]):(<type 'exceptions.TypeError'>, TypeError('writelines() requires list of strings',)) |
| 442 | >>> Testing *Iter* using sys.stdout.writelines(%s) |
| 443 | sys.stdout.writelines(FailingIter()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 444 | sys.stdout.writelines(FailingIterNext()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 445 | <<< Finished |
| 446 | > VimCommand |
| 447 | vim.command(1):(<type 'exceptions.TypeError'>, TypeError('must be string, not int',)) |
| 448 | > VimToPython |
| 449 | > VimEval |
| 450 | vim.eval(1):(<type 'exceptions.TypeError'>, TypeError('must be string, not int',)) |
| 451 | > VimEvalPy |
| 452 | vim.bindeval(1):(<type 'exceptions.TypeError'>, TypeError('must be string, not int',)) |
| 453 | > VimStrwidth |
| 454 | vim.strwidth(1):(<type 'exceptions.TypeError'>, TypeError('must be string, not int',)) |
| 455 | > Dictionary |
| 456 | >> DictionaryConstructor |
| 457 | vim.Dictionary("abc"):(<type 'exceptions.ValueError'>, ValueError('expected sequence element of size 2',)) |
| 458 | >> DictionarySetattr |
| 459 | del d.locked:(<type 'exceptions.AttributeError'>, AttributeError('cannot delete vim.Dictionary attributes',)) |
| 460 | d.locked = FailingTrue():(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 461 | vim.vvars.locked = False:(<type 'exceptions.TypeError'>, TypeError('cannot modify fixed dictionary',)) |
| 462 | d.scope = True:(<type 'exceptions.AttributeError'>, AttributeError('cannot set this attribute',)) |
| 463 | d.xxx = True:(<type 'exceptions.AttributeError'>, AttributeError('cannot set this attribute',)) |
| 464 | >> _DictionaryItem |
| 465 | d.get("a", 2, 3):(<type 'exceptions.TypeError'>, TypeError('function takes at most 2 arguments (3 given)',)) |
| 466 | >>> Testing StringToChars using d.get(%s) |
| 467 | d.get(1):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 468 | d.get(u"\0"):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 469 | d.get("\0"):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 470 | <<< Finished |
| 471 | d.pop("a"):(<type 'exceptions.KeyError'>, KeyError('a',)) |
| 472 | dl.pop("a"):(<class 'vim.error'>, error('dict is locked',)) |
| 473 | >> DictionaryIterNext |
| 474 | for i in ned: ned["a"] = 1:(<type 'exceptions.RuntimeError'>, RuntimeError('hashtab changed during iteration',)) |
| 475 | >> DictionaryAssItem |
| 476 | dl["b"] = 1:(<class 'vim.error'>, error('dict is locked',)) |
| 477 | >>> Testing StringToChars using d[%s] = 1 |
| 478 | d[1] = 1:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 479 | d[u"\0"] = 1:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 480 | d["\0"] = 1:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 481 | <<< Finished |
| 482 | >>> Testing StringToChars using d["a"] = {%s : 1} |
| 483 | d["a"] = {1 : 1}:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 484 | d["a"] = {u"\0" : 1}:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 485 | d["a"] = {"\0" : 1}:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 486 | <<< Finished |
| 487 | >>> Testing StringToChars using d["a"] = {"abc" : {%s : 1}} |
| 488 | d["a"] = {"abc" : {1 : 1}}:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 489 | d["a"] = {"abc" : {u"\0" : 1}}:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 490 | d["a"] = {"abc" : {"\0" : 1}}:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 491 | <<< Finished |
| 492 | >>> Testing StringToChars using d["a"] = {"abc" : Mapping({%s : 1})} |
| 493 | d["a"] = {"abc" : Mapping({1 : 1})}:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 494 | d["a"] = {"abc" : Mapping({u"\0" : 1})}:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 495 | d["a"] = {"abc" : Mapping({"\0" : 1})}:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 496 | <<< Finished |
| 497 | >>> Testing *Iter* using d["a"] = {"abc" : %s} |
| 498 | d["a"] = {"abc" : FailingIter()}:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 499 | d["a"] = {"abc" : FailingIterNext()}:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 500 | <<< Finished |
| 501 | >>> Testing ConvertFromPyObject using d["a"] = {"abc" : %s} |
| 502 | d["a"] = {"abc" : None}:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 503 | d["a"] = {"abc" : {"": 1}}:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 504 | d["a"] = {"abc" : FailingMapping()}:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 505 | d["a"] = {"abc" : FailingMappingKey()}:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 506 | <<< Finished |
| 507 | >>> Testing StringToChars using d["a"] = Mapping({%s : 1}) |
| 508 | d["a"] = Mapping({1 : 1}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 509 | d["a"] = Mapping({u"\0" : 1}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 510 | d["a"] = Mapping({"\0" : 1}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 511 | <<< Finished |
| 512 | >>> Testing StringToChars using d["a"] = Mapping({"abc" : {%s : 1}}) |
| 513 | d["a"] = Mapping({"abc" : {1 : 1}}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 514 | d["a"] = Mapping({"abc" : {u"\0" : 1}}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 515 | d["a"] = Mapping({"abc" : {"\0" : 1}}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 516 | <<< Finished |
| 517 | >>> Testing StringToChars using d["a"] = Mapping({"abc" : Mapping({%s : 1})}) |
| 518 | d["a"] = Mapping({"abc" : Mapping({1 : 1})}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 519 | d["a"] = Mapping({"abc" : Mapping({u"\0" : 1})}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 520 | d["a"] = Mapping({"abc" : Mapping({"\0" : 1})}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 521 | <<< Finished |
| 522 | >>> Testing *Iter* using d["a"] = Mapping({"abc" : %s}) |
| 523 | d["a"] = Mapping({"abc" : FailingIter()}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 524 | d["a"] = Mapping({"abc" : FailingIterNext()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 525 | <<< Finished |
| 526 | >>> Testing ConvertFromPyObject using d["a"] = Mapping({"abc" : %s}) |
| 527 | d["a"] = Mapping({"abc" : None}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 528 | d["a"] = Mapping({"abc" : {"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 529 | d["a"] = Mapping({"abc" : FailingMapping()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 530 | d["a"] = Mapping({"abc" : FailingMappingKey()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 531 | <<< Finished |
| 532 | >>> Testing *Iter* using d["a"] = %s |
| 533 | d["a"] = FailingIter():(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 534 | d["a"] = FailingIterNext():(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 535 | <<< Finished |
| 536 | >>> Testing ConvertFromPyObject using d["a"] = %s |
| 537 | d["a"] = None:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 538 | d["a"] = {"": 1}:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 539 | d["a"] = FailingMapping():(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 540 | d["a"] = FailingMappingKey():(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 541 | <<< Finished |
| 542 | >> DictionaryUpdate |
| 543 | >>> kwargs |
| 544 | >>> iter |
| 545 | d.update(FailingMapping()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 546 | d.update([FailingIterNext()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 547 | >>> Testing *Iter* using d.update(%s) |
| 548 | d.update(FailingIter()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 549 | d.update(FailingIterNext()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 550 | <<< Finished |
| 551 | >>> Testing StringToChars using d.update({%s : 1}) |
| 552 | d.update({1 : 1}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 553 | d.update({u"\0" : 1}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 554 | d.update({"\0" : 1}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 555 | <<< Finished |
| 556 | >>> Testing StringToChars using d.update({"abc" : {%s : 1}}) |
| 557 | d.update({"abc" : {1 : 1}}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 558 | d.update({"abc" : {u"\0" : 1}}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 559 | d.update({"abc" : {"\0" : 1}}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 560 | <<< Finished |
| 561 | >>> Testing StringToChars using d.update({"abc" : Mapping({%s : 1})}) |
| 562 | d.update({"abc" : Mapping({1 : 1})}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 563 | d.update({"abc" : Mapping({u"\0" : 1})}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 564 | d.update({"abc" : Mapping({"\0" : 1})}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 565 | <<< Finished |
| 566 | >>> Testing *Iter* using d.update({"abc" : %s}) |
| 567 | d.update({"abc" : FailingIter()}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 568 | d.update({"abc" : FailingIterNext()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 569 | <<< Finished |
| 570 | >>> Testing ConvertFromPyObject using d.update({"abc" : %s}) |
| 571 | d.update({"abc" : None}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 572 | d.update({"abc" : {"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 573 | d.update({"abc" : FailingMapping()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 574 | d.update({"abc" : FailingMappingKey()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 575 | <<< Finished |
| 576 | >>> Testing StringToChars using d.update(Mapping({%s : 1})) |
| 577 | d.update(Mapping({1 : 1})):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 578 | d.update(Mapping({u"\0" : 1})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 579 | d.update(Mapping({"\0" : 1})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 580 | <<< Finished |
| 581 | >>> Testing StringToChars using d.update(Mapping({"abc" : {%s : 1}})) |
| 582 | d.update(Mapping({"abc" : {1 : 1}})):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 583 | d.update(Mapping({"abc" : {u"\0" : 1}})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 584 | d.update(Mapping({"abc" : {"\0" : 1}})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 585 | <<< Finished |
| 586 | >>> Testing StringToChars using d.update(Mapping({"abc" : Mapping({%s : 1})})) |
| 587 | d.update(Mapping({"abc" : Mapping({1 : 1})})):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 588 | d.update(Mapping({"abc" : Mapping({u"\0" : 1})})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 589 | d.update(Mapping({"abc" : Mapping({"\0" : 1})})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 590 | <<< Finished |
| 591 | >>> Testing *Iter* using d.update(Mapping({"abc" : %s})) |
| 592 | d.update(Mapping({"abc" : FailingIter()})):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 593 | d.update(Mapping({"abc" : FailingIterNext()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 594 | <<< Finished |
| 595 | >>> Testing ConvertFromPyObject using d.update(Mapping({"abc" : %s})) |
| 596 | d.update(Mapping({"abc" : None})):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 597 | d.update(Mapping({"abc" : {"": 1}})):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 598 | d.update(Mapping({"abc" : FailingMapping()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 599 | d.update(Mapping({"abc" : FailingMappingKey()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 600 | <<< Finished |
| 601 | >>> Testing *Iter* using d.update(%s) |
| 602 | d.update(FailingIter()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 603 | d.update(FailingIterNext()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 604 | <<< Finished |
| 605 | >>> Testing ConvertFromPyObject using d.update(%s) |
| 606 | d.update(None):(<type 'exceptions.TypeError'>, TypeError("'NoneType' object is not iterable",)) |
| 607 | d.update({"": 1}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 608 | d.update(FailingMapping()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 609 | d.update(FailingMappingKey()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 610 | <<< Finished |
| 611 | >>> Testing StringToChars using d.update(((%s, 0),)) |
| 612 | d.update(((1, 0),)):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 613 | d.update(((u"\0", 0),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 614 | d.update((("\0", 0),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 615 | <<< Finished |
| 616 | >>> Testing StringToChars using d.update((("a", {%s : 1}),)) |
| 617 | d.update((("a", {1 : 1}),)):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 618 | d.update((("a", {u"\0" : 1}),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 619 | d.update((("a", {"\0" : 1}),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 620 | <<< Finished |
| 621 | >>> Testing StringToChars using d.update((("a", {"abc" : {%s : 1}}),)) |
| 622 | d.update((("a", {"abc" : {1 : 1}}),)):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 623 | d.update((("a", {"abc" : {u"\0" : 1}}),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 624 | d.update((("a", {"abc" : {"\0" : 1}}),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 625 | <<< Finished |
| 626 | >>> Testing StringToChars using d.update((("a", {"abc" : Mapping({%s : 1})}),)) |
| 627 | d.update((("a", {"abc" : Mapping({1 : 1})}),)):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 628 | d.update((("a", {"abc" : Mapping({u"\0" : 1})}),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 629 | d.update((("a", {"abc" : Mapping({"\0" : 1})}),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 630 | <<< Finished |
| 631 | >>> Testing *Iter* using d.update((("a", {"abc" : %s}),)) |
| 632 | d.update((("a", {"abc" : FailingIter()}),)):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 633 | d.update((("a", {"abc" : FailingIterNext()}),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 634 | <<< Finished |
| 635 | >>> Testing ConvertFromPyObject using d.update((("a", {"abc" : %s}),)) |
| 636 | d.update((("a", {"abc" : None}),)):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 637 | d.update((("a", {"abc" : {"": 1}}),)):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 638 | d.update((("a", {"abc" : FailingMapping()}),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 639 | d.update((("a", {"abc" : FailingMappingKey()}),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 640 | <<< Finished |
| 641 | >>> Testing StringToChars using d.update((("a", Mapping({%s : 1})),)) |
| 642 | d.update((("a", Mapping({1 : 1})),)):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 643 | d.update((("a", Mapping({u"\0" : 1})),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 644 | d.update((("a", Mapping({"\0" : 1})),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 645 | <<< Finished |
| 646 | >>> Testing StringToChars using d.update((("a", Mapping({"abc" : {%s : 1}})),)) |
| 647 | d.update((("a", Mapping({"abc" : {1 : 1}})),)):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 648 | d.update((("a", Mapping({"abc" : {u"\0" : 1}})),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 649 | d.update((("a", Mapping({"abc" : {"\0" : 1}})),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 650 | <<< Finished |
| 651 | >>> Testing StringToChars using d.update((("a", Mapping({"abc" : Mapping({%s : 1})})),)) |
| 652 | d.update((("a", Mapping({"abc" : Mapping({1 : 1})})),)):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 653 | d.update((("a", Mapping({"abc" : Mapping({u"\0" : 1})})),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 654 | d.update((("a", Mapping({"abc" : Mapping({"\0" : 1})})),)):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 655 | <<< Finished |
| 656 | >>> Testing *Iter* using d.update((("a", Mapping({"abc" : %s})),)) |
| 657 | d.update((("a", Mapping({"abc" : FailingIter()})),)):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 658 | d.update((("a", Mapping({"abc" : FailingIterNext()})),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 659 | <<< Finished |
| 660 | >>> Testing ConvertFromPyObject using d.update((("a", Mapping({"abc" : %s})),)) |
| 661 | d.update((("a", Mapping({"abc" : None})),)):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 662 | d.update((("a", Mapping({"abc" : {"": 1}})),)):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 663 | d.update((("a", Mapping({"abc" : FailingMapping()})),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 664 | d.update((("a", Mapping({"abc" : FailingMappingKey()})),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 665 | <<< Finished |
| 666 | >>> Testing *Iter* using d.update((("a", %s),)) |
| 667 | d.update((("a", FailingIter()),)):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 668 | d.update((("a", FailingIterNext()),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 669 | <<< Finished |
| 670 | >>> Testing ConvertFromPyObject using d.update((("a", %s),)) |
| 671 | d.update((("a", None),)):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 672 | d.update((("a", {"": 1}),)):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 673 | d.update((("a", FailingMapping()),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 674 | d.update((("a", FailingMappingKey()),)):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 675 | <<< Finished |
| 676 | >> DictionaryPopItem |
| 677 | d.popitem(1, 2):(<type 'exceptions.TypeError'>, TypeError('function takes exactly 1 argument (2 given)',)) |
| 678 | >> DictionaryHasKey |
| 679 | d.has_key():(<type 'exceptions.TypeError'>, TypeError('function takes exactly 1 argument (0 given)',)) |
| 680 | > List |
| 681 | >> ListConstructor |
| 682 | vim.List(1, 2):(<type 'exceptions.TypeError'>, TypeError('function takes at most 1 argument (2 given)',)) |
| 683 | vim.List(a=1):(<type 'exceptions.TypeError'>, TypeError('list constructor does not accept keyword arguments',)) |
| 684 | >>> Testing *Iter* using vim.List(%s) |
| 685 | vim.List(FailingIter()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 686 | vim.List(FailingIterNext()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 687 | <<< Finished |
| 688 | >>> Testing StringToChars using vim.List([{%s : 1}]) |
| 689 | vim.List([{1 : 1}]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 690 | vim.List([{u"\0" : 1}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 691 | vim.List([{"\0" : 1}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 692 | <<< Finished |
| 693 | >>> Testing StringToChars using vim.List([{"abc" : {%s : 1}}]) |
| 694 | vim.List([{"abc" : {1 : 1}}]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 695 | vim.List([{"abc" : {u"\0" : 1}}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 696 | vim.List([{"abc" : {"\0" : 1}}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 697 | <<< Finished |
| 698 | >>> Testing StringToChars using vim.List([{"abc" : Mapping({%s : 1})}]) |
| 699 | vim.List([{"abc" : Mapping({1 : 1})}]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 700 | vim.List([{"abc" : Mapping({u"\0" : 1})}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 701 | vim.List([{"abc" : Mapping({"\0" : 1})}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 702 | <<< Finished |
| 703 | >>> Testing *Iter* using vim.List([{"abc" : %s}]) |
| 704 | vim.List([{"abc" : FailingIter()}]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 705 | vim.List([{"abc" : FailingIterNext()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 706 | <<< Finished |
| 707 | >>> Testing ConvertFromPyObject using vim.List([{"abc" : %s}]) |
| 708 | vim.List([{"abc" : None}]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 709 | vim.List([{"abc" : {"": 1}}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 710 | vim.List([{"abc" : FailingMapping()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 711 | vim.List([{"abc" : FailingMappingKey()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 712 | <<< Finished |
| 713 | >>> Testing StringToChars using vim.List([Mapping({%s : 1})]) |
| 714 | vim.List([Mapping({1 : 1})]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 715 | vim.List([Mapping({u"\0" : 1})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 716 | vim.List([Mapping({"\0" : 1})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 717 | <<< Finished |
| 718 | >>> Testing StringToChars using vim.List([Mapping({"abc" : {%s : 1}})]) |
| 719 | vim.List([Mapping({"abc" : {1 : 1}})]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 720 | vim.List([Mapping({"abc" : {u"\0" : 1}})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 721 | vim.List([Mapping({"abc" : {"\0" : 1}})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 722 | <<< Finished |
| 723 | >>> Testing StringToChars using vim.List([Mapping({"abc" : Mapping({%s : 1})})]) |
| 724 | vim.List([Mapping({"abc" : Mapping({1 : 1})})]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 725 | vim.List([Mapping({"abc" : Mapping({u"\0" : 1})})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 726 | vim.List([Mapping({"abc" : Mapping({"\0" : 1})})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 727 | <<< Finished |
| 728 | >>> Testing *Iter* using vim.List([Mapping({"abc" : %s})]) |
| 729 | vim.List([Mapping({"abc" : FailingIter()})]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 730 | vim.List([Mapping({"abc" : FailingIterNext()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 731 | <<< Finished |
| 732 | >>> Testing ConvertFromPyObject using vim.List([Mapping({"abc" : %s})]) |
| 733 | vim.List([Mapping({"abc" : None})]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 734 | vim.List([Mapping({"abc" : {"": 1}})]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 735 | vim.List([Mapping({"abc" : FailingMapping()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 736 | vim.List([Mapping({"abc" : FailingMappingKey()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 737 | <<< Finished |
| 738 | >>> Testing *Iter* using vim.List([%s]) |
| 739 | vim.List([FailingIter()]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 740 | vim.List([FailingIterNext()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 741 | <<< Finished |
| 742 | >>> Testing ConvertFromPyObject using vim.List([%s]) |
| 743 | vim.List([None]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 744 | vim.List([{"": 1}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 745 | vim.List([FailingMapping()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 746 | vim.List([FailingMappingKey()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 747 | <<< Finished |
| 748 | >> ListItem |
| 749 | l[1000]:(<type 'exceptions.IndexError'>, IndexError('list index out of range',)) |
| 750 | >> ListAssItem |
| 751 | ll[1] = 2:(<class 'vim.error'>, error('list is locked',)) |
| 752 | l[1000] = 3:(<type 'exceptions.IndexError'>, IndexError('list index out of range',)) |
| 753 | >> ListAssSlice |
| 754 | ll[1:100] = "abc":(<class 'vim.error'>, error('list is locked',)) |
| 755 | >>> Testing *Iter* using l[:] = %s |
| 756 | l[:] = FailingIter():(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 757 | l[:] = FailingIterNext():(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 758 | <<< Finished |
| 759 | >>> Testing StringToChars using l[:] = [{%s : 1}] |
| 760 | l[:] = [{1 : 1}]:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 761 | l[:] = [{u"\0" : 1}]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 762 | l[:] = [{"\0" : 1}]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 763 | <<< Finished |
| 764 | >>> Testing StringToChars using l[:] = [{"abc" : {%s : 1}}] |
| 765 | l[:] = [{"abc" : {1 : 1}}]:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 766 | l[:] = [{"abc" : {u"\0" : 1}}]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 767 | l[:] = [{"abc" : {"\0" : 1}}]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 768 | <<< Finished |
| 769 | >>> Testing StringToChars using l[:] = [{"abc" : Mapping({%s : 1})}] |
| 770 | l[:] = [{"abc" : Mapping({1 : 1})}]:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 771 | l[:] = [{"abc" : Mapping({u"\0" : 1})}]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 772 | l[:] = [{"abc" : Mapping({"\0" : 1})}]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 773 | <<< Finished |
| 774 | >>> Testing *Iter* using l[:] = [{"abc" : %s}] |
| 775 | l[:] = [{"abc" : FailingIter()}]:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 776 | l[:] = [{"abc" : FailingIterNext()}]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 777 | <<< Finished |
| 778 | >>> Testing ConvertFromPyObject using l[:] = [{"abc" : %s}] |
| 779 | l[:] = [{"abc" : None}]:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 780 | l[:] = [{"abc" : {"": 1}}]:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 781 | l[:] = [{"abc" : FailingMapping()}]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 782 | l[:] = [{"abc" : FailingMappingKey()}]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 783 | <<< Finished |
| 784 | >>> Testing StringToChars using l[:] = [Mapping({%s : 1})] |
| 785 | l[:] = [Mapping({1 : 1})]:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 786 | l[:] = [Mapping({u"\0" : 1})]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 787 | l[:] = [Mapping({"\0" : 1})]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 788 | <<< Finished |
| 789 | >>> Testing StringToChars using l[:] = [Mapping({"abc" : {%s : 1}})] |
| 790 | l[:] = [Mapping({"abc" : {1 : 1}})]:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 791 | l[:] = [Mapping({"abc" : {u"\0" : 1}})]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 792 | l[:] = [Mapping({"abc" : {"\0" : 1}})]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 793 | <<< Finished |
| 794 | >>> Testing StringToChars using l[:] = [Mapping({"abc" : Mapping({%s : 1})})] |
| 795 | l[:] = [Mapping({"abc" : Mapping({1 : 1})})]:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 796 | l[:] = [Mapping({"abc" : Mapping({u"\0" : 1})})]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 797 | l[:] = [Mapping({"abc" : Mapping({"\0" : 1})})]:(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 798 | <<< Finished |
| 799 | >>> Testing *Iter* using l[:] = [Mapping({"abc" : %s})] |
| 800 | l[:] = [Mapping({"abc" : FailingIter()})]:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 801 | l[:] = [Mapping({"abc" : FailingIterNext()})]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 802 | <<< Finished |
| 803 | >>> Testing ConvertFromPyObject using l[:] = [Mapping({"abc" : %s})] |
| 804 | l[:] = [Mapping({"abc" : None})]:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 805 | l[:] = [Mapping({"abc" : {"": 1}})]:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 806 | l[:] = [Mapping({"abc" : FailingMapping()})]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 807 | l[:] = [Mapping({"abc" : FailingMappingKey()})]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 808 | <<< Finished |
| 809 | >>> Testing *Iter* using l[:] = [%s] |
| 810 | l[:] = [FailingIter()]:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 811 | l[:] = [FailingIterNext()]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 812 | <<< Finished |
| 813 | >>> Testing ConvertFromPyObject using l[:] = [%s] |
| 814 | l[:] = [None]:(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 815 | l[:] = [{"": 1}]:(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 816 | l[:] = [FailingMapping()]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 817 | l[:] = [FailingMappingKey()]:(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 818 | <<< Finished |
| 819 | >> ListConcatInPlace |
| 820 | >>> Testing *Iter* using l.extend(%s) |
| 821 | l.extend(FailingIter()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 822 | l.extend(FailingIterNext()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 823 | <<< Finished |
| 824 | >>> Testing StringToChars using l.extend([{%s : 1}]) |
| 825 | l.extend([{1 : 1}]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 826 | l.extend([{u"\0" : 1}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 827 | l.extend([{"\0" : 1}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 828 | <<< Finished |
| 829 | >>> Testing StringToChars using l.extend([{"abc" : {%s : 1}}]) |
| 830 | l.extend([{"abc" : {1 : 1}}]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 831 | l.extend([{"abc" : {u"\0" : 1}}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 832 | l.extend([{"abc" : {"\0" : 1}}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 833 | <<< Finished |
| 834 | >>> Testing StringToChars using l.extend([{"abc" : Mapping({%s : 1})}]) |
| 835 | l.extend([{"abc" : Mapping({1 : 1})}]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 836 | l.extend([{"abc" : Mapping({u"\0" : 1})}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 837 | l.extend([{"abc" : Mapping({"\0" : 1})}]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 838 | <<< Finished |
| 839 | >>> Testing *Iter* using l.extend([{"abc" : %s}]) |
| 840 | l.extend([{"abc" : FailingIter()}]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 841 | l.extend([{"abc" : FailingIterNext()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 842 | <<< Finished |
| 843 | >>> Testing ConvertFromPyObject using l.extend([{"abc" : %s}]) |
| 844 | l.extend([{"abc" : None}]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 845 | l.extend([{"abc" : {"": 1}}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 846 | l.extend([{"abc" : FailingMapping()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 847 | l.extend([{"abc" : FailingMappingKey()}]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 848 | <<< Finished |
| 849 | >>> Testing StringToChars using l.extend([Mapping({%s : 1})]) |
| 850 | l.extend([Mapping({1 : 1})]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 851 | l.extend([Mapping({u"\0" : 1})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 852 | l.extend([Mapping({"\0" : 1})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 853 | <<< Finished |
| 854 | >>> Testing StringToChars using l.extend([Mapping({"abc" : {%s : 1}})]) |
| 855 | l.extend([Mapping({"abc" : {1 : 1}})]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 856 | l.extend([Mapping({"abc" : {u"\0" : 1}})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 857 | l.extend([Mapping({"abc" : {"\0" : 1}})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 858 | <<< Finished |
| 859 | >>> Testing StringToChars using l.extend([Mapping({"abc" : Mapping({%s : 1})})]) |
| 860 | l.extend([Mapping({"abc" : Mapping({1 : 1})})]):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 861 | l.extend([Mapping({"abc" : Mapping({u"\0" : 1})})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 862 | l.extend([Mapping({"abc" : Mapping({"\0" : 1})})]):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 863 | <<< Finished |
| 864 | >>> Testing *Iter* using l.extend([Mapping({"abc" : %s})]) |
| 865 | l.extend([Mapping({"abc" : FailingIter()})]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 866 | l.extend([Mapping({"abc" : FailingIterNext()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 867 | <<< Finished |
| 868 | >>> Testing ConvertFromPyObject using l.extend([Mapping({"abc" : %s})]) |
| 869 | l.extend([Mapping({"abc" : None})]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 870 | l.extend([Mapping({"abc" : {"": 1}})]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 871 | l.extend([Mapping({"abc" : FailingMapping()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 872 | l.extend([Mapping({"abc" : FailingMappingKey()})]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 873 | <<< Finished |
| 874 | >>> Testing *Iter* using l.extend([%s]) |
| 875 | l.extend([FailingIter()]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 876 | l.extend([FailingIterNext()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 877 | <<< Finished |
| 878 | >>> Testing ConvertFromPyObject using l.extend([%s]) |
| 879 | l.extend([None]):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 880 | l.extend([{"": 1}]):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 881 | l.extend([FailingMapping()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 882 | l.extend([FailingMappingKey()]):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 883 | <<< Finished |
| 884 | >> ListSetattr |
| 885 | del l.locked:(<type 'exceptions.AttributeError'>, AttributeError('cannot delete vim.List attributes',)) |
| 886 | l.locked = FailingTrue():(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 887 | l.xxx = True:(<type 'exceptions.AttributeError'>, AttributeError('cannot set this attribute',)) |
| 888 | > Function |
| 889 | >> FunctionConstructor |
| 890 | vim.Function("123"):(<type 'exceptions.ValueError'>, ValueError('unnamed function does not exist',)) |
| 891 | vim.Function("xxx_non_existent_function_xxx"):(<type 'exceptions.ValueError'>, ValueError('function does not exist',)) |
| 892 | vim.Function("xxx#non#existent#function#xxx"):(<type 'exceptions.ValueError'>, ValueError('function does not exist',)) |
| 893 | >> FunctionCall |
| 894 | >>> Testing StringToChars using f({%s : 1}) |
| 895 | f({1 : 1}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 896 | f({u"\0" : 1}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 897 | f({"\0" : 1}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 898 | <<< Finished |
| 899 | >>> Testing StringToChars using f({"abc" : {%s : 1}}) |
| 900 | f({"abc" : {1 : 1}}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 901 | f({"abc" : {u"\0" : 1}}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 902 | f({"abc" : {"\0" : 1}}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 903 | <<< Finished |
| 904 | >>> Testing StringToChars using f({"abc" : Mapping({%s : 1})}) |
| 905 | f({"abc" : Mapping({1 : 1})}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 906 | f({"abc" : Mapping({u"\0" : 1})}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 907 | f({"abc" : Mapping({"\0" : 1})}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 908 | <<< Finished |
| 909 | >>> Testing *Iter* using f({"abc" : %s}) |
| 910 | f({"abc" : FailingIter()}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 911 | f({"abc" : FailingIterNext()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 912 | <<< Finished |
| 913 | >>> Testing ConvertFromPyObject using f({"abc" : %s}) |
| 914 | f({"abc" : None}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 915 | f({"abc" : {"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 916 | f({"abc" : FailingMapping()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 917 | f({"abc" : FailingMappingKey()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 918 | <<< Finished |
| 919 | >>> Testing StringToChars using f(Mapping({%s : 1})) |
| 920 | f(Mapping({1 : 1})):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 921 | f(Mapping({u"\0" : 1})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 922 | f(Mapping({"\0" : 1})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 923 | <<< Finished |
| 924 | >>> Testing StringToChars using f(Mapping({"abc" : {%s : 1}})) |
| 925 | f(Mapping({"abc" : {1 : 1}})):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 926 | f(Mapping({"abc" : {u"\0" : 1}})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 927 | f(Mapping({"abc" : {"\0" : 1}})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 928 | <<< Finished |
| 929 | >>> Testing StringToChars using f(Mapping({"abc" : Mapping({%s : 1})})) |
| 930 | f(Mapping({"abc" : Mapping({1 : 1})})):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 931 | f(Mapping({"abc" : Mapping({u"\0" : 1})})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 932 | f(Mapping({"abc" : Mapping({"\0" : 1})})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 933 | <<< Finished |
| 934 | >>> Testing *Iter* using f(Mapping({"abc" : %s})) |
| 935 | f(Mapping({"abc" : FailingIter()})):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 936 | f(Mapping({"abc" : FailingIterNext()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 937 | <<< Finished |
| 938 | >>> Testing ConvertFromPyObject using f(Mapping({"abc" : %s})) |
| 939 | f(Mapping({"abc" : None})):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 940 | f(Mapping({"abc" : {"": 1}})):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 941 | f(Mapping({"abc" : FailingMapping()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 942 | f(Mapping({"abc" : FailingMappingKey()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 943 | <<< Finished |
| 944 | >>> Testing *Iter* using f(%s) |
| 945 | f(FailingIter()):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 946 | f(FailingIterNext()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 947 | <<< Finished |
| 948 | >>> Testing ConvertFromPyObject using f(%s) |
| 949 | f(None):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 950 | f({"": 1}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 951 | f(FailingMapping()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 952 | f(FailingMappingKey()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 953 | <<< Finished |
| 954 | >>> Testing StringToChars using fd(self={%s : 1}) |
| 955 | fd(self={1 : 1}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 956 | fd(self={u"\0" : 1}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 957 | fd(self={"\0" : 1}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 958 | <<< Finished |
| 959 | >>> Testing StringToChars using fd(self={"abc" : {%s : 1}}) |
| 960 | fd(self={"abc" : {1 : 1}}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 961 | fd(self={"abc" : {u"\0" : 1}}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 962 | fd(self={"abc" : {"\0" : 1}}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 963 | <<< Finished |
| 964 | >>> Testing StringToChars using fd(self={"abc" : Mapping({%s : 1})}) |
| 965 | fd(self={"abc" : Mapping({1 : 1})}):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 966 | fd(self={"abc" : Mapping({u"\0" : 1})}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 967 | fd(self={"abc" : Mapping({"\0" : 1})}):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 968 | <<< Finished |
| 969 | >>> Testing *Iter* using fd(self={"abc" : %s}) |
| 970 | fd(self={"abc" : FailingIter()}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 971 | fd(self={"abc" : FailingIterNext()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 972 | <<< Finished |
| 973 | >>> Testing ConvertFromPyObject using fd(self={"abc" : %s}) |
| 974 | fd(self={"abc" : None}):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 975 | fd(self={"abc" : {"": 1}}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 976 | fd(self={"abc" : FailingMapping()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 977 | fd(self={"abc" : FailingMappingKey()}):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 978 | <<< Finished |
| 979 | >>> Testing StringToChars using fd(self=Mapping({%s : 1})) |
| 980 | fd(self=Mapping({1 : 1})):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 981 | fd(self=Mapping({u"\0" : 1})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 982 | fd(self=Mapping({"\0" : 1})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 983 | <<< Finished |
| 984 | >>> Testing StringToChars using fd(self=Mapping({"abc" : {%s : 1}})) |
| 985 | fd(self=Mapping({"abc" : {1 : 1}})):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 986 | fd(self=Mapping({"abc" : {u"\0" : 1}})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 987 | fd(self=Mapping({"abc" : {"\0" : 1}})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 988 | <<< Finished |
| 989 | >>> Testing StringToChars using fd(self=Mapping({"abc" : Mapping({%s : 1})})) |
| 990 | fd(self=Mapping({"abc" : Mapping({1 : 1})})):(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 991 | fd(self=Mapping({"abc" : Mapping({u"\0" : 1})})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 992 | fd(self=Mapping({"abc" : Mapping({"\0" : 1})})):(<type 'exceptions.TypeError'>, TypeError('expected string without null bytes',)) |
| 993 | <<< Finished |
| 994 | >>> Testing *Iter* using fd(self=Mapping({"abc" : %s})) |
| 995 | fd(self=Mapping({"abc" : FailingIter()})):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 996 | fd(self=Mapping({"abc" : FailingIterNext()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 997 | <<< Finished |
| 998 | >>> Testing ConvertFromPyObject using fd(self=Mapping({"abc" : %s})) |
| 999 | fd(self=Mapping({"abc" : None})):(<type 'exceptions.TypeError'>, TypeError('unable to convert to vim structure',)) |
| 1000 | fd(self=Mapping({"abc" : {"": 1}})):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 1001 | fd(self=Mapping({"abc" : FailingMapping()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 1002 | fd(self=Mapping({"abc" : FailingMappingKey()})):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 1003 | <<< Finished |
| 1004 | >>> Testing *Iter* using fd(self=%s) |
| 1005 | fd(self=FailingIter()):(<type 'exceptions.TypeError'>, TypeError('unable to convert object to vim dictionary',)) |
| 1006 | fd(self=FailingIterNext()):(<type 'exceptions.TypeError'>, TypeError('unable to convert object to vim dictionary',)) |
| 1007 | <<< Finished |
| 1008 | >>> Testing ConvertFromPyObject using fd(self=%s) |
| 1009 | fd(self=None):(<type 'exceptions.TypeError'>, TypeError('unable to convert object to vim dictionary',)) |
| 1010 | fd(self={"": 1}):(<type 'exceptions.ValueError'>, ValueError('empty keys are not allowed',)) |
| 1011 | fd(self=FailingMapping()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 1012 | fd(self=FailingMappingKey()):(<type 'exceptions.NotImplementedError'>, NotImplementedError()) |
| 1013 | <<< Finished |
| 1014 | >>> Testing ConvertFromPyMapping using fd(self=%s) |
| 1015 | fd(self=[]):(<type 'exceptions.TypeError'>, TypeError('unable to convert object to vim dictionary',)) |
| 1016 | <<< Finished |
| 1017 | > TabPage |
| 1018 | >> TabPageAttr |
| 1019 | vim.current.tabpage.xxx:(<type 'exceptions.AttributeError'>, AttributeError('xxx',)) |
| 1020 | > TabList |
| 1021 | >> TabListItem |
| 1022 | vim.tabpages[1000]:(<type 'exceptions.IndexError'>, IndexError('no such tab page',)) |
| 1023 | > Window |
| 1024 | >> WindowAttr |
| 1025 | vim.current.window.xxx:(<type 'exceptions.AttributeError'>, AttributeError('xxx',)) |
| 1026 | >> WindowSetattr |
| 1027 | vim.current.window.buffer = 0:(<type 'exceptions.TypeError'>, TypeError('readonly attribute',)) |
| 1028 | vim.current.window.cursor = (10000000000, 100000000):(<class 'vim.error'>, error('cursor position outside buffer',)) |
| 1029 | vim.current.window.cursor = True:(<type 'exceptions.TypeError'>, TypeError('argument must be 2-item sequence, not bool',)) |
| 1030 | vim.current.window.height = "abc":(<type 'exceptions.TypeError'>, TypeError('an integer is required',)) |
| 1031 | vim.current.window.width = "abc":(<type 'exceptions.TypeError'>, TypeError('an integer is required',)) |
| 1032 | vim.current.window.xxxxxx = True:(<type 'exceptions.AttributeError'>, AttributeError('xxxxxx',)) |
| 1033 | > WinList |
| 1034 | >> WinListItem |
| 1035 | vim.windows[1000]:(<type 'exceptions.IndexError'>, IndexError('no such window',)) |
| 1036 | > Buffer |
| 1037 | >> StringToLine (indirect) |
| 1038 | vim.current.buffer[0] = "\na":(<class 'vim.error'>, error('string cannot contain newlines',)) |
| 1039 | >> SetBufferLine (indirect) |
| 1040 | vim.current.buffer[0] = True:(<type 'exceptions.TypeError'>, TypeError('bad argument type for built-in operation',)) |
| 1041 | >> SetBufferLines (indirect) |
| 1042 | vim.current.buffer[:] = True:(<type 'exceptions.TypeError'>, TypeError('bad argument type for built-in operation',)) |
| 1043 | vim.current.buffer[:] = ["\na", "bc"]:(<class 'vim.error'>, error('string cannot contain newlines',)) |
| 1044 | >> InsertBufferLines (indirect) |
| 1045 | vim.current.buffer.append(None):(<type 'exceptions.TypeError'>, TypeError('bad argument type for built-in operation',)) |
| 1046 | vim.current.buffer.append(["\na", "bc"]):(<class 'vim.error'>, error('string cannot contain newlines',)) |
| 1047 | vim.current.buffer.append("\nbc"):(<class 'vim.error'>, error('string cannot contain newlines',)) |
| 1048 | >> RBItem |
| 1049 | vim.current.buffer[10000000000]:(<type 'exceptions.IndexError'>, IndexError('line number out of range',)) |
| 1050 | >> RBAsItem |
| 1051 | vim.current.buffer[10000000000] = "":(<type 'exceptions.IndexError'>, IndexError('line number out of range',)) |
| 1052 | >> BufferAttr |
| 1053 | vim.current.buffer.xxx:(<type 'exceptions.AttributeError'>, AttributeError('xxx',)) |
| 1054 | >> BufferSetattr |
| 1055 | vim.current.buffer.name = True:(<type 'exceptions.TypeError'>, TypeError('object must be string',)) |
| 1056 | vim.current.buffer.xxx = True:(<type 'exceptions.AttributeError'>, AttributeError('xxx',)) |
| 1057 | >> BufferMark |
| 1058 | vim.current.buffer.mark(0):(<type 'exceptions.TypeError'>, TypeError('must be string, not int',)) |
| 1059 | vim.current.buffer.mark("abc"):(<type 'exceptions.ValueError'>, ValueError('mark name must be a single character',)) |
| 1060 | vim.current.buffer.mark("!"):(<class 'vim.error'>, error('invalid mark name',)) |
| 1061 | >> BufferRange |
| 1062 | vim.current.buffer.range(1, 2, 3):(<type 'exceptions.TypeError'>, TypeError('function takes exactly 2 arguments (3 given)',)) |
| 1063 | > BufMap |
| 1064 | >> BufMapItem |
| 1065 | vim.buffers[None]:(<type 'exceptions.TypeError'>, TypeError('key must be integer',)) |
| 1066 | vim.buffers[100000000]:(<type 'exceptions.KeyError'>, KeyError(100000000,)) |
| 1067 | > Current |
| 1068 | >> CurrentGetattr |
| 1069 | vim.current.xxx:(<type 'exceptions.AttributeError'>, AttributeError('xxx',)) |
| 1070 | >> CurrentSetattr |
| 1071 | vim.current.line = True:(<type 'exceptions.TypeError'>, TypeError('bad argument type for built-in operation',)) |
| 1072 | vim.current.buffer = True:(<type 'exceptions.TypeError'>, TypeError('expected vim.Buffer object',)) |
| 1073 | vim.current.window = True:(<type 'exceptions.TypeError'>, TypeError('expected vim.Window object',)) |
| 1074 | vim.current.tabpage = True:(<type 'exceptions.TypeError'>, TypeError('expected vim.TabPage object',)) |
| 1075 | vim.current.xxx = True:(<type 'exceptions.AttributeError'>, AttributeError('xxx',)) |
| 1076 | vim.command("throw 'abc'"):(<class 'vim.error'>, error('abc',)) |
| 1077 | Exe("throw 'def'"):(<class 'vim.error'>, error('def',)) |
| 1078 | vim.eval("Exe('throw ''ghi''')"):(<class 'vim.error'>, error('ghi',)) |
| 1079 | vim.eval("Exe('echoerr ''jkl''')"):(<class 'vim.error'>, error('Vim(echoerr):jkl',)) |
| 1080 | vim.eval("Exe('xxx_non_existent_command_xxx')"):(<class 'vim.error'>, error('Vim:E492: Not an editor command: xxx_non_existent_command_xxx',)) |
| 1081 | vim.bindeval("Exe('xxx_non_existent_command_xxx')"):(<class 'vim.error'>, error('Vim:E492: Not an editor command: xxx_non_existent_command_xxx',)) |