← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

Remove all assert statements from test cases.

Tests should always be evaluated even when run with 'python -O', and so should
use TestCase.assert_ etc.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
154
154
 
155
155
        file('foo.tmp', 'wt').write('tmp files are ignored')
156
156
        self.assertEquals(list(b.unknowns()), [])
157
 
        assert self.capture('unknowns') == ''
 
157
        self.assertEquals(self.capture('unknowns'), '')
158
158
 
159
159
        file('foo.c', 'wt').write('int main() {}')
160
160
        self.assertEquals(list(b.unknowns()), ['foo.c'])
161
 
        assert self.capture('unknowns') == 'foo.c\n'
 
161
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
162
162
 
163
163
        self.runbzr(['add', 'foo.c'])
164
 
        assert self.capture('unknowns') == ''
 
164
        self.assertEquals(self.capture('unknowns'), '')
165
165
 
166
166
        # 'ignore' works when creating the .bzignore file
167
167
        file('foo.blah', 'wt').write('blah')
168
168
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
169
169
        self.runbzr('ignore *.blah')
170
170
        self.assertEquals(list(b.unknowns()), [])
171
 
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
 
171
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
172
172
 
173
173
        # 'ignore' works when then .bzrignore file already exists
174
174
        file('garh', 'wt').write('garh')
175
175
        self.assertEquals(list(b.unknowns()), ['garh'])
176
 
        assert self.capture('unknowns') == 'garh\n'
 
176
        self.assertEquals(self.capture('unknowns'), 'garh\n')
177
177
        self.runbzr('ignore garh')
178
178
        self.assertEquals(list(b.unknowns()), [])
179
 
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
 
179
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
180
180
 
181
181
    def test_revert(self):
182
182
        self.runbzr('init')
269
269
        self.runbzr('export ../latest')
270
270
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
271
271
        self.runbzr('export ../first -r 1')
272
 
        assert not os.path.exists('../first/goodbye')
 
272
        self.assert_(not os.path.exists('../first/goodbye'))
273
273
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
274
274
        self.runbzr('export ../first.gz -r 1')
275
275
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
276
276
        self.runbzr('export ../first.bz2 -r 1')
277
277
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
278
278
        self.runbzr('export ../first.tar -r 1')
279
 
        assert os.path.isfile('../first.tar')
 
279
        self.assert_(os.path.isfile('../first.tar'))
280
280
        from tarfile import TarFile
281
281
        tf = TarFile('../first.tar')
282
 
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
282
        self.assert_('first/hello' in tf.getnames(), tf.getnames())
283
283
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
284
284
        self.runbzr('export ../first.tar.gz -r 1')
285
 
        assert os.path.isfile('../first.tar.gz')
 
285
        self.assert_(os.path.isfile('../first.tar.gz'))
286
286
        self.runbzr('export ../first.tbz2 -r 1')
287
 
        assert os.path.isfile('../first.tbz2')
 
287
        self.assert_(os.path.isfile('../first.tbz2'))
288
288
        self.runbzr('export ../first.tar.bz2 -r 1')
289
 
        assert os.path.isfile('../first.tar.bz2')
 
289
        self.assert_(os.path.isfile('../first.tar.bz2'))
290
290
        self.runbzr('export ../first.tar.tbz2 -r 1')
291
 
        assert os.path.isfile('../first.tar.tbz2')
 
291
        self.assert_(os.path.isfile('../first.tar.tbz2'))
292
292
        from bz2 import BZ2File
293
293
        tf = TarFile('../first.tar.tbz2', 
294
294
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
295
 
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
295
        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
296
296
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
297
297
        self.runbzr('export ../first2.tar -r 1 --root pizza')
298
298
        tf = TarFile('../first2.tar')
299
 
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
299
        self.assert_('pizza/hello' in tf.getnames(), tf.getnames())
300
300
 
301
301
    def test_diff(self):
302
302
        self.example_branch()
379
379
        b = Branch.open('../b')
380
380
        a.get_revision_xml(b.last_revision())
381
381
        self.log('pending merges: %s', a.pending_merges())
382
 
        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
383
 
            % (a.pending_merges(), b.last_patch())
 
382
        self.assertEquals(a.pending_merges(), [b.last_revision()])
384
383
        self.runbzr('commit -m merged')
385
384
        self.runbzr('merge ../b -r last:1')
386
385
        self.assertEqual(Branch.open('.').pending_merges(), [])
413
412
        print >> file('sub/c.txt', 'ab'), "something"
414
413
        self.runbzr(('commit', '-m', 'Modified a.txt'))
415
414
        self.runbzr('merge ../a/', retcode=1)
416
 
        assert os.path.exists('sub/a.txt.THIS')
417
 
        assert os.path.exists('sub/a.txt.BASE')
 
415
        self.assert_(os.path.exists('sub/a.txt.THIS'))
 
416
        self.assert_(os.path.exists('sub/a.txt.BASE'))
418
417
        os.chdir('../a')
419
418
        self.runbzr('merge ../b/', retcode=1)
420
 
        assert os.path.exists('sub/a.txt.OTHER')
421
 
        assert os.path.exists('sub/a.txt.BASE')
 
419
        self.assert_(os.path.exists('sub/a.txt.OTHER'))
 
420
        self.assert_(os.path.exists('sub/a.txt.BASE'))
422
421
 
423
422
    def test_pull(self):
424
423
        """Pull changes from one branch to another."""
444
443
        os.chdir('../a')
445
444
        a = Branch.open('.')
446
445
        b = Branch.open('../b')
447
 
        assert a.revision_history() == b.revision_history()[:-1]
 
446
        self.assertEquals(a.revision_history(), b.revision_history()[:-1])
448
447
        self.runbzr('pull ../b')
449
 
        assert a.revision_history() == b.revision_history()
 
448
        self.assertEquals(a.revision_history(), b.revision_history())
450
449
        self.runbzr('commit -m blah2 --unchanged')
451
450
        os.chdir('../b')
452
451
        self.runbzr('commit -m blah3 --unchanged')
464
463
        self.runbzr('commit -m blah4 --unchanged')
465
464
        os.chdir('../b/subdir')
466
465
        self.runbzr('pull ../../a')
467
 
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
466
        self.assertEquals(a.revision_history()[-1], b.revision_history()[-1])
468
467
        self.runbzr('commit -m blah5 --unchanged')
469
468
        self.runbzr('commit -m blah6 --unchanged')
470
469
        os.chdir('..')
657
656
        self.runbzr('commit -m this')
658
657
        self.runbzr('merge ../other --show-base', retcode=1)
659
658
        conflict_text = file('hello').read()
660
 
        assert '<<<<<<<' in conflict_text
661
 
        assert '>>>>>>>' in conflict_text
662
 
        assert '=======' in conflict_text
663
 
        assert '|||||||' in conflict_text
664
 
        assert 'hi world' in conflict_text
 
659
        self.assert_('<<<<<<<' in conflict_text)
 
660
        self.assert_('>>>>>>>' in conflict_text)
 
661
        self.assert_('=======' in conflict_text)
 
662
        self.assert_('|||||||' in conflict_text)
 
663
        self.assert_('hi world' in conflict_text)
665
664
        self.runbzr('revert')
666
665
        self.runbzr('resolve --all')
667
666
        self.runbzr('merge ../other', retcode=1)
668
667
        conflict_text = file('hello').read()
669
 
        assert '|||||||' not in conflict_text
670
 
        assert 'hi world' not in conflict_text
 
668
        self.assert_('|||||||' not in conflict_text)
 
669
        self.assert_('hi world' not in conflict_text)
671
670
        result = self.runbzr('conflicts', backtick=1)
672
671
        self.assertEquals(result, "hello\nquestion\n")
673
672
        result = self.runbzr('status', backtick=1)
674
 
        assert "conflicts:\n  hello\n  question\n" in result, result
 
673
        self.assert_("conflicts:\n  hello\n  question\n" in result, result)
675
674
        self.runbzr('resolve hello')
676
675
        result = self.runbzr('conflicts', backtick=1)
677
676
        self.assertEquals(result, "question\n")
795
794
        self.assertEquals(capture('unknowns'), 'test.txt\n')
796
795
 
797
796
        out = capture("status")
798
 
        assert out == 'unknown:\n  test.txt\n'
 
797
        self.assertEquals(out, 'unknown:\n  test.txt\n')
799
798
 
800
799
        out = capture("status --all")
801
 
        assert out == "unknown:\n  test.txt\n"
 
800
        self.assertEquals(out, "unknown:\n  test.txt\n")
802
801
 
803
802
        out = capture("status test.txt --all")
804
 
        assert out == "unknown:\n  test.txt\n"
 
803
        self.assertEquals(out, "unknown:\n  test.txt\n")
805
804
 
806
805
        f = file('test2.txt', 'wt')
807
806
        f.write('goodbye cruel world...\n')
808
807
        f.close()
809
808
 
810
809
        out = capture("status test.txt")
811
 
        assert out == "unknown:\n  test.txt\n"
 
810
        self.assertEquals(out, "unknown:\n  test.txt\n")
812
811
 
813
812
        out = capture("status")
814
 
        assert out == ("unknown:\n"
815
 
                       "  test.txt\n"
816
 
                       "  test2.txt\n")
 
813
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
817
814
 
818
815
        os.unlink('test2.txt')
819
816
 
820
817
        progress("command aliases")
821
818
        out = capture("st --all")
822
 
        assert out == ("unknown:\n"
823
 
                       "  test.txt\n")
 
819
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
824
820
 
825
821
        out = capture("stat")
826
 
        assert out == ("unknown:\n"
827
 
                       "  test.txt\n")
 
822
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
828
823
 
829
824
        progress("command help")
830
825
        runbzr("help st")
841
836
        progress("adding a file")
842
837
 
843
838
        runbzr("add test.txt")
844
 
        assert capture("unknowns") == ''
845
 
        assert capture("status --all") == ("added:\n"
846
 
                                                "  test.txt\n")
 
839
        self.assertEquals(capture("unknowns"), '')
 
840
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
847
841
 
848
842
        progress("rename newly-added file")
849
843
        runbzr("rename test.txt hello.txt")
850
 
        assert os.path.exists("hello.txt")
851
 
        assert not os.path.exists("test.txt")
 
844
        self.assert_(os.path.exists("hello.txt"))
 
845
        self.assert_(not os.path.exists("test.txt"))
852
846
 
853
 
        assert capture("revno") == '0\n'
 
847
        self.assertEquals(capture("revno"), '0\n')
854
848
 
855
849
        progress("add first revision")
856
850
        runbzr(['commit', '-m', 'add first revision'])
867
861
        self.assertEqual(capture("relpath sub2/hello.txt"),
868
862
                         os.path.join("sub2", "hello.txt\n"))
869
863
 
870
 
        assert exists("sub2")
871
 
        assert exists("sub2/hello.txt")
872
 
        assert not exists("sub1")
873
 
        assert not exists("hello.txt")
 
864
        self.assert_(exists("sub2"))
 
865
        self.assert_(exists("sub2/hello.txt"))
 
866
        self.assert_(not exists("sub1"))
 
867
        self.assert_(not exists("hello.txt"))
874
868
 
875
869
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
876
870
 
877
871
        mkdir("sub1")
878
872
        runbzr('add sub1')
879
873
        runbzr('move sub2/hello.txt sub1')
880
 
        assert not exists('sub2/hello.txt')
881
 
        assert exists('sub1/hello.txt')
 
874
        self.assert_(not exists('sub2/hello.txt'))
 
875
        self.assert_(exists('sub1/hello.txt'))
882
876
        runbzr('move sub2 sub1')
883
 
        assert not exists('sub2')
884
 
        assert exists('sub1/sub2')
 
877
        self.assert_(not exists('sub2'))
 
878
        self.assert_(exists('sub1/sub2'))
885
879
 
886
880
        runbzr(['commit', '-m', 'rename nested subdirectories'])
887
881
 
889
883
        self.assertEquals(capture('root')[:-1],
890
884
                          os.path.join(self.test_dir, 'branch1'))
891
885
        runbzr('move ../hello.txt .')
892
 
        assert exists('./hello.txt')
 
886
        self.assert_(exists('./hello.txt'))
893
887
        self.assertEquals(capture('relpath hello.txt'),
894
888
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
895
 
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
889
        self.assertEquals(capture('relpath ../../sub1/sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
896
890
        runbzr(['commit', '-m', 'move to parent directory'])
897
891
        chdir('..')
898
 
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
892
        self.assertEquals(capture('relpath sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
899
893
 
900
894
        runbzr('move sub2/hello.txt .')
901
 
        assert exists('hello.txt')
 
895
        self.assert_(exists('hello.txt'))
902
896
 
903
897
        f = file('hello.txt', 'wt')
904
898
        f.write('some nice new content\n')
910
904
 
911
905
        runbzr('commit -F msg.tmp')
912
906
 
913
 
        assert capture('revno') == '5\n'
 
907
        self.assertEquals(capture('revno'), '5\n')
914
908
        runbzr('export -r 5 export-5.tmp')
915
909
        runbzr('export export.tmp')
916
910
 
919
913
        runbzr('log -v --forward')
920
914
        runbzr('log -m', retcode=1)
921
915
        log_out = capture('log -m commit')
922
 
        assert "this is my new commit\n  and" in log_out
923
 
        assert "rename nested" not in log_out
924
 
        assert 'revision-id' not in log_out
925
 
        assert 'revision-id' in capture('log --show-ids -m commit')
 
916
        self.assert_("this is my new commit\n  and" in log_out)
 
917
        self.assert_("rename nested" not in log_out)
 
918
        self.assert_('revision-id' not in log_out)
 
919
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
926
920
 
927
921
        log_out = capture('log --line')
928
922
        for line in log_out.splitlines():
929
 
            assert len(line) <= 79, len(line)
930
 
        assert "this is my new commit and" in log_out
 
923
            self.assert_(len(line) <= 79, len(line))
 
924
        self.assert_("this is my new commit and" in log_out)
931
925
 
932
926
 
933
927
        progress("file with spaces in name")
950
944
            runbzr('init')
951
945
            os.symlink("NOWHERE1", "link1")
952
946
            runbzr('add link1')
953
 
            assert self.capture('unknowns') == ''
 
947
            self.assertEquals(self.capture('unknowns'), '')
954
948
            runbzr(['commit', '-m', '1: added symlink link1'])
955
949
    
956
950
            mkdir('d1')
957
951
            runbzr('add d1')
958
 
            assert self.capture('unknowns') == ''
 
952
            self.assertEquals(self.capture('unknowns'), '')
959
953
            os.symlink("NOWHERE2", "d1/link2")
960
 
            assert self.capture('unknowns') == 'd1/link2\n'
 
954
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
961
955
            # is d1/link2 found when adding d1
962
956
            runbzr('add d1')
963
 
            assert self.capture('unknowns') == ''
 
957
            self.assertEquals(self.capture('unknowns'), '')
964
958
            os.symlink("NOWHERE3", "d1/link3")
965
 
            assert self.capture('unknowns') == 'd1/link3\n'
 
959
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
966
960
            runbzr(['commit', '-m', '2: added dir, symlink'])
967
961
    
968
962
            runbzr('rename d1 d2')
969
963
            runbzr('move d2/link2 .')
970
964
            runbzr('move link1 d2')
971
 
            assert os.readlink("./link2") == "NOWHERE2"
972
 
            assert os.readlink("d2/link1") == "NOWHERE1"
 
965
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
 
966
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
973
967
            runbzr('add d2/link3')
974
968
            runbzr('diff', retcode=1)
975
969
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
979
973
            os.unlink("d2/link1")
980
974
            os.symlink("TARGET 1", "d2/link1")
981
975
            runbzr('diff', retcode=1)
982
 
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
976
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
983
977
            runbzr(['commit', '-m', '4: retarget of two links'])
984
978
    
985
979
            runbzr('remove d2/link1')
986
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
980
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
987
981
            runbzr(['commit', '-m', '5: remove d2/link1'])
988
982
            # try with the rm alias
989
983
            runbzr('add d2/link1')
990
984
            runbzr(['commit', '-m', '6: add d2/link1'])
991
985
            runbzr('rm d2/link1')
992
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
986
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
993
987
            runbzr(['commit', '-m', '7: remove d2/link1'])
994
988
    
995
989
            os.mkdir("d1")
996
990
            runbzr('add d1')
997
991
            runbzr('rename d2/link3 d1/link3new')
998
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
992
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
999
993
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
1000
994
            
1001
995
            runbzr(['check'])
1002
996
            
1003
997
            runbzr(['export', '-r', '1', 'exp1.tmp'])
1004
998
            chdir("exp1.tmp")
1005
 
            assert listdir_sorted(".") == [ "link1" ]
1006
 
            assert os.readlink("link1") == "NOWHERE1"
 
999
            self.assertEquals(listdir_sorted("."), [ "link1" ])
 
1000
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
1007
1001
            chdir("..")
1008
1002
            
1009
1003
            runbzr(['export', '-r', '2', 'exp2.tmp'])
1010
1004
            chdir("exp2.tmp")
1011
 
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
1005
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
1012
1006
            chdir("..")
1013
1007
            
1014
1008
            runbzr(['export', '-r', '3', 'exp3.tmp'])
1015
1009
            chdir("exp3.tmp")
1016
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
1017
 
            assert listdir_sorted("d2") == [ "link1", "link3" ]
1018
 
            assert os.readlink("d2/link1") == "NOWHERE1"
1019
 
            assert os.readlink("link2")    == "NOWHERE2"
 
1010
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1011
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
 
1012
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
1013
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
1020
1014
            chdir("..")
1021
1015
            
1022
1016
            runbzr(['export', '-r', '4', 'exp4.tmp'])
1023
1017
            chdir("exp4.tmp")
1024
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
1025
 
            assert os.readlink("d2/link1") == "TARGET 1"
1026
 
            assert os.readlink("link2")    == "TARGET 2"
1027
 
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
1018
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1019
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
 
1020
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
 
1021
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
1028
1022
            chdir("..")
1029
1023
            
1030
1024
            runbzr(['export', '-r', '5', 'exp5.tmp'])
1031
1025
            chdir("exp5.tmp")
1032
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
1033
 
            assert os.path.islink("link2")
1034
 
            assert listdir_sorted("d2")== [ "link3" ]
 
1026
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1027
            self.assert_(os.path.islink("link2"))
 
1028
            self.assert_(listdir_sorted("d2")== [ "link3" ])
1035
1029
            chdir("..")
1036
1030
            
1037
1031
            runbzr(['export', '-r', '8', 'exp6.tmp'])
1038
1032
            chdir("exp6.tmp")
1039
1033
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
1040
 
            assert listdir_sorted("d1") == [ "link3new" ]
1041
 
            assert listdir_sorted("d2") == []
1042
 
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
1034
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
 
1035
            self.assertEquals(listdir_sorted("d2"), [])
 
1036
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
1043
1037
            chdir("..")
1044
1038
        else:
1045
1039
            progress("skipping symlink tests")