Mercurial > vim

comparison src/testdir/test86.ok @ 4637:4c46e1487c63 v7.3.1066

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
updated for version 7.3.1066 Problem: Python: Insufficient exception and error testing. Solution: Python patch 25. (ZyX)
author Bram Moolenaar <bram@vim.org>
date Thu, 30 May 2013 13:28:41 +0200
parents 4157fef7b950
children 59e6c2bd68e3
comparison
equal deleted inserted replaced
4636:de7b8aca1be2 4637:4c46e1487c63
427 ['a', 'dup_a'] 427 ['a', 'dup_a']
428 ['a', 'a'] 428 ['a', 'a']
429 ['a', 'b', 'c'] 429 ['a', 'b', 'c']
430 [2, 2] 430 [2, 2]
431 [2, 2] 431 [2, 2]
432 (<class 'vim.error'>, error('abc',)) 432 > Output
433 (<class 'vim.error'>, error('def',)) 433 >> OutputSetattr
434 (<class 'vim.error'>, error('ghi',)) 434 del sys.stdout.softspace:(<type 'exceptions.AttributeError'>, AttributeError("can't delete OutputObject attributes",))
435 (<class 'vim.error'>, error('Vim(echoerr):jkl',)) 435 sys.stdout.softspace = []:(<type 'exceptions.TypeError'>, TypeError('softspace must be an integer',))
436 (<class 'vim.error'>, error('Vim:E492: Not an editor command: xxx_non_existent_command_xxx',)) 436 sys.stdout.attr = None:(<type 'exceptions.AttributeError'>, AttributeError('invalid attribute',))
437 (<class 'vim.error'>, error('Vim:E492: Not an editor command: xxx_non_existent_command_xxx',)) 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',))