← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Jelmer Vernooij
  • Date: 2005-11-04 17:26:05 UTC
  • mfrom: (1185.16.146)
  • mto: (1185.33.1)
  • mto: This revision was merged to the branch mainline in revision 1509.
  • Revision ID: jelmer@samba.org-20051104172605-9288f261492667fd
Merge from Martin

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
62
62
    def test_init_branch(self):
63
63
        self.runbzr(['init'])
64
64
 
 
65
        # Can it handle subdirectories as well?
 
66
        self.runbzr('init subdir1')
 
67
        self.assert_(os.path.exists('subdir1'))
 
68
        self.assert_(os.path.exists('subdir1/.bzr'))
 
69
 
 
70
        self.runbzr('init subdir2/nothere', retcode=2)
 
71
        
 
72
        os.mkdir('subdir2')
 
73
        self.runbzr('init subdir2')
 
74
        self.runbzr('init subdir2', retcode=1)
 
75
 
 
76
        self.runbzr('init subdir2/subsubdir1')
 
77
        self.assert_(os.path.exists('subdir2/subsubdir1/.bzr'))
 
78
 
65
79
    def test_whoami(self):
66
80
        # this should always identify something, if only "john@localhost"
67
81
        self.runbzr("whoami")
140
154
 
141
155
        file('foo.tmp', 'wt').write('tmp files are ignored')
142
156
        self.assertEquals(list(b.unknowns()), [])
143
 
        assert self.capture('unknowns') == ''
 
157
        self.assertEquals(self.capture('unknowns'), '')
144
158
 
145
159
        file('foo.c', 'wt').write('int main() {}')
146
160
        self.assertEquals(list(b.unknowns()), ['foo.c'])
147
 
        assert self.capture('unknowns') == 'foo.c\n'
 
161
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
148
162
 
149
163
        self.runbzr(['add', 'foo.c'])
150
 
        assert self.capture('unknowns') == ''
 
164
        self.assertEquals(self.capture('unknowns'), '')
151
165
 
152
166
        # 'ignore' works when creating the .bzignore file
153
167
        file('foo.blah', 'wt').write('blah')
154
168
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
155
169
        self.runbzr('ignore *.blah')
156
170
        self.assertEquals(list(b.unknowns()), [])
157
 
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
 
171
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
158
172
 
159
173
        # 'ignore' works when then .bzrignore file already exists
160
174
        file('garh', 'wt').write('garh')
161
175
        self.assertEquals(list(b.unknowns()), ['garh'])
162
 
        assert self.capture('unknowns') == 'garh\n'
 
176
        self.assertEquals(self.capture('unknowns'), 'garh\n')
163
177
        self.runbzr('ignore garh')
164
178
        self.assertEquals(list(b.unknowns()), [])
165
 
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
 
179
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
166
180
 
167
181
    def test_revert(self):
168
182
        self.runbzr('init')
255
269
        self.runbzr('export ../latest')
256
270
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
257
271
        self.runbzr('export ../first -r 1')
258
 
        assert not os.path.exists('../first/goodbye')
 
272
        self.assert_(not os.path.exists('../first/goodbye'))
259
273
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
260
274
        self.runbzr('export ../first.gz -r 1')
261
275
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
262
276
        self.runbzr('export ../first.bz2 -r 1')
263
277
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
264
278
        self.runbzr('export ../first.tar -r 1')
265
 
        assert os.path.isfile('../first.tar')
 
279
        self.assert_(os.path.isfile('../first.tar'))
266
280
        from tarfile import TarFile
267
281
        tf = TarFile('../first.tar')
268
 
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
282
        self.assert_('first/hello' in tf.getnames(), tf.getnames())
269
283
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
270
284
        self.runbzr('export ../first.tar.gz -r 1')
271
 
        assert os.path.isfile('../first.tar.gz')
 
285
        self.assert_(os.path.isfile('../first.tar.gz'))
272
286
        self.runbzr('export ../first.tbz2 -r 1')
273
 
        assert os.path.isfile('../first.tbz2')
 
287
        self.assert_(os.path.isfile('../first.tbz2'))
274
288
        self.runbzr('export ../first.tar.bz2 -r 1')
275
 
        assert os.path.isfile('../first.tar.bz2')
 
289
        self.assert_(os.path.isfile('../first.tar.bz2'))
276
290
        self.runbzr('export ../first.tar.tbz2 -r 1')
277
 
        assert os.path.isfile('../first.tar.tbz2')
 
291
        self.assert_(os.path.isfile('../first.tar.tbz2'))
278
292
        from bz2 import BZ2File
279
293
        tf = TarFile('../first.tar.tbz2', 
280
294
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
281
 
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
295
        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
282
296
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
283
297
        self.runbzr('export ../first2.tar -r 1 --root pizza')
284
298
        tf = TarFile('../first2.tar')
285
 
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
299
        self.assert_('pizza/hello' in tf.getnames(), tf.getnames())
286
300
 
287
301
    def test_diff(self):
288
302
        self.example_branch()
365
379
        b = Branch.open('../b')
366
380
        a.get_revision_xml(b.last_revision())
367
381
        self.log('pending merges: %s', a.pending_merges())
368
 
        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
369
 
            % (a.pending_merges(), b.last_patch())
 
382
        self.assertEquals(a.pending_merges(), [b.last_revision()])
370
383
        self.runbzr('commit -m merged')
371
384
        self.runbzr('merge ../b -r last:1')
372
385
        self.assertEqual(Branch.open('.').pending_merges(), [])
399
412
        print >> file('sub/c.txt', 'ab'), "something"
400
413
        self.runbzr(('commit', '-m', 'Modified a.txt'))
401
414
        self.runbzr('merge ../a/', retcode=1)
402
 
        assert os.path.exists('sub/a.txt.THIS')
403
 
        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'))
404
417
        os.chdir('../a')
405
418
        self.runbzr('merge ../b/', retcode=1)
406
 
        assert os.path.exists('sub/a.txt.OTHER')
407
 
        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'))
408
421
 
409
422
    def test_pull(self):
410
423
        """Pull changes from one branch to another."""
430
443
        os.chdir('../a')
431
444
        a = Branch.open('.')
432
445
        b = Branch.open('../b')
433
 
        assert a.revision_history() == b.revision_history()[:-1]
 
446
        self.assertEquals(a.revision_history(), b.revision_history()[:-1])
434
447
        self.runbzr('pull ../b')
435
 
        assert a.revision_history() == b.revision_history()
 
448
        self.assertEquals(a.revision_history(), b.revision_history())
436
449
        self.runbzr('commit -m blah2 --unchanged')
437
450
        os.chdir('../b')
438
451
        self.runbzr('commit -m blah3 --unchanged')
450
463
        self.runbzr('commit -m blah4 --unchanged')
451
464
        os.chdir('../b/subdir')
452
465
        self.runbzr('pull ../../a')
453
 
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
466
        self.assertEquals(a.revision_history()[-1], b.revision_history()[-1])
454
467
        self.runbzr('commit -m blah5 --unchanged')
455
468
        self.runbzr('commit -m blah6 --unchanged')
456
469
        os.chdir('..')
643
656
        self.runbzr('commit -m this')
644
657
        self.runbzr('merge ../other --show-base', retcode=1)
645
658
        conflict_text = file('hello').read()
646
 
        assert '<<<<<<<' in conflict_text
647
 
        assert '>>>>>>>' in conflict_text
648
 
        assert '=======' in conflict_text
649
 
        assert '|||||||' in conflict_text
650
 
        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)
651
664
        self.runbzr('revert')
652
665
        self.runbzr('resolve --all')
653
666
        self.runbzr('merge ../other', retcode=1)
654
667
        conflict_text = file('hello').read()
655
 
        assert '|||||||' not in conflict_text
656
 
        assert 'hi world' not in conflict_text
 
668
        self.assert_('|||||||' not in conflict_text)
 
669
        self.assert_('hi world' not in conflict_text)
657
670
        result = self.runbzr('conflicts', backtick=1)
658
671
        self.assertEquals(result, "hello\nquestion\n")
659
672
        result = self.runbzr('status', backtick=1)
660
 
        assert "conflicts:\n  hello\n  question\n" in result, result
 
673
        self.assert_("conflicts:\n  hello\n  question\n" in result, result)
661
674
        self.runbzr('resolve hello')
662
675
        result = self.runbzr('conflicts', backtick=1)
663
676
        self.assertEquals(result, "question\n")
781
794
        self.assertEquals(capture('unknowns'), 'test.txt\n')
782
795
 
783
796
        out = capture("status")
784
 
        assert out == 'unknown:\n  test.txt\n'
 
797
        self.assertEquals(out, 'unknown:\n  test.txt\n')
785
798
 
786
799
        out = capture("status --all")
787
 
        assert out == "unknown:\n  test.txt\n"
 
800
        self.assertEquals(out, "unknown:\n  test.txt\n")
788
801
 
789
802
        out = capture("status test.txt --all")
790
 
        assert out == "unknown:\n  test.txt\n"
 
803
        self.assertEquals(out, "unknown:\n  test.txt\n")
791
804
 
792
805
        f = file('test2.txt', 'wt')
793
806
        f.write('goodbye cruel world...\n')
794
807
        f.close()
795
808
 
796
809
        out = capture("status test.txt")
797
 
        assert out == "unknown:\n  test.txt\n"
 
810
        self.assertEquals(out, "unknown:\n  test.txt\n")
798
811
 
799
812
        out = capture("status")
800
 
        assert out == ("unknown:\n"
801
 
                       "  test.txt\n"
802
 
                       "  test2.txt\n")
 
813
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
803
814
 
804
815
        os.unlink('test2.txt')
805
816
 
806
817
        progress("command aliases")
807
818
        out = capture("st --all")
808
 
        assert out == ("unknown:\n"
809
 
                       "  test.txt\n")
 
819
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
810
820
 
811
821
        out = capture("stat")
812
 
        assert out == ("unknown:\n"
813
 
                       "  test.txt\n")
 
822
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
814
823
 
815
824
        progress("command help")
816
825
        runbzr("help st")
827
836
        progress("adding a file")
828
837
 
829
838
        runbzr("add test.txt")
830
 
        assert capture("unknowns") == ''
831
 
        assert capture("status --all") == ("added:\n"
832
 
                                                "  test.txt\n")
 
839
        self.assertEquals(capture("unknowns"), '')
 
840
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
833
841
 
834
842
        progress("rename newly-added file")
835
843
        runbzr("rename test.txt hello.txt")
836
 
        assert os.path.exists("hello.txt")
837
 
        assert not os.path.exists("test.txt")
 
844
        self.assert_(os.path.exists("hello.txt"))
 
845
        self.assert_(not os.path.exists("test.txt"))
838
846
 
839
 
        assert capture("revno") == '0\n'
 
847
        self.assertEquals(capture("revno"), '0\n')
840
848
 
841
849
        progress("add first revision")
842
850
        runbzr(['commit', '-m', 'add first revision'])
853
861
        self.assertEqual(capture("relpath sub2/hello.txt"),
854
862
                         os.path.join("sub2", "hello.txt\n"))
855
863
 
856
 
        assert exists("sub2")
857
 
        assert exists("sub2/hello.txt")
858
 
        assert not exists("sub1")
859
 
        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"))
860
868
 
861
869
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
862
870
 
863
871
        mkdir("sub1")
864
872
        runbzr('add sub1')
865
873
        runbzr('move sub2/hello.txt sub1')
866
 
        assert not exists('sub2/hello.txt')
867
 
        assert exists('sub1/hello.txt')
 
874
        self.assert_(not exists('sub2/hello.txt'))
 
875
        self.assert_(exists('sub1/hello.txt'))
868
876
        runbzr('move sub2 sub1')
869
 
        assert not exists('sub2')
870
 
        assert exists('sub1/sub2')
 
877
        self.assert_(not exists('sub2'))
 
878
        self.assert_(exists('sub1/sub2'))
871
879
 
872
880
        runbzr(['commit', '-m', 'rename nested subdirectories'])
873
881
 
875
883
        self.assertEquals(capture('root')[:-1],
876
884
                          os.path.join(self.test_dir, 'branch1'))
877
885
        runbzr('move ../hello.txt .')
878
 
        assert exists('./hello.txt')
 
886
        self.assert_(exists('./hello.txt'))
879
887
        self.assertEquals(capture('relpath hello.txt'),
880
888
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
881
 
        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'))
882
890
        runbzr(['commit', '-m', 'move to parent directory'])
883
891
        chdir('..')
884
 
        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'))
885
893
 
886
894
        runbzr('move sub2/hello.txt .')
887
 
        assert exists('hello.txt')
 
895
        self.assert_(exists('hello.txt'))
888
896
 
889
897
        f = file('hello.txt', 'wt')
890
898
        f.write('some nice new content\n')
896
904
 
897
905
        runbzr('commit -F msg.tmp')
898
906
 
899
 
        assert capture('revno') == '5\n'
 
907
        self.assertEquals(capture('revno'), '5\n')
900
908
        runbzr('export -r 5 export-5.tmp')
901
909
        runbzr('export export.tmp')
902
910
 
905
913
        runbzr('log -v --forward')
906
914
        runbzr('log -m', retcode=1)
907
915
        log_out = capture('log -m commit')
908
 
        assert "this is my new commit\n  and" in log_out
909
 
        assert "rename nested" not in log_out
910
 
        assert 'revision-id' not in log_out
911
 
        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'))
912
920
 
913
921
        log_out = capture('log --line')
914
922
        for line in log_out.splitlines():
915
 
            assert len(line) <= 79, len(line)
916
 
        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)
917
925
 
918
926
 
919
927
        progress("file with spaces in name")
936
944
            runbzr('init')
937
945
            os.symlink("NOWHERE1", "link1")
938
946
            runbzr('add link1')
939
 
            assert self.capture('unknowns') == ''
 
947
            self.assertEquals(self.capture('unknowns'), '')
940
948
            runbzr(['commit', '-m', '1: added symlink link1'])
941
949
    
942
950
            mkdir('d1')
943
951
            runbzr('add d1')
944
 
            assert self.capture('unknowns') == ''
 
952
            self.assertEquals(self.capture('unknowns'), '')
945
953
            os.symlink("NOWHERE2", "d1/link2")
946
 
            assert self.capture('unknowns') == 'd1/link2\n'
 
954
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
947
955
            # is d1/link2 found when adding d1
948
956
            runbzr('add d1')
949
 
            assert self.capture('unknowns') == ''
 
957
            self.assertEquals(self.capture('unknowns'), '')
950
958
            os.symlink("NOWHERE3", "d1/link3")
951
 
            assert self.capture('unknowns') == 'd1/link3\n'
 
959
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
952
960
            runbzr(['commit', '-m', '2: added dir, symlink'])
953
961
    
954
962
            runbzr('rename d1 d2')
955
963
            runbzr('move d2/link2 .')
956
964
            runbzr('move link1 d2')
957
 
            assert os.readlink("./link2") == "NOWHERE2"
958
 
            assert os.readlink("d2/link1") == "NOWHERE1"
 
965
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
 
966
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
959
967
            runbzr('add d2/link3')
960
968
            runbzr('diff', retcode=1)
961
969
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
965
973
            os.unlink("d2/link1")
966
974
            os.symlink("TARGET 1", "d2/link1")
967
975
            runbzr('diff', retcode=1)
968
 
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
976
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
969
977
            runbzr(['commit', '-m', '4: retarget of two links'])
970
978
    
971
979
            runbzr('remove d2/link1')
972
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
980
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
973
981
            runbzr(['commit', '-m', '5: remove d2/link1'])
974
982
            # try with the rm alias
975
983
            runbzr('add d2/link1')
976
984
            runbzr(['commit', '-m', '6: add d2/link1'])
977
985
            runbzr('rm d2/link1')
978
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
986
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
979
987
            runbzr(['commit', '-m', '7: remove d2/link1'])
980
988
    
981
989
            os.mkdir("d1")
982
990
            runbzr('add d1')
983
991
            runbzr('rename d2/link3 d1/link3new')
984
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
992
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
985
993
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
986
994
            
987
995
            runbzr(['check'])
988
996
            
989
997
            runbzr(['export', '-r', '1', 'exp1.tmp'])
990
998
            chdir("exp1.tmp")
991
 
            assert listdir_sorted(".") == [ "link1" ]
992
 
            assert os.readlink("link1") == "NOWHERE1"
 
999
            self.assertEquals(listdir_sorted("."), [ "link1" ])
 
1000
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
993
1001
            chdir("..")
994
1002
            
995
1003
            runbzr(['export', '-r', '2', 'exp2.tmp'])
996
1004
            chdir("exp2.tmp")
997
 
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
1005
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
998
1006
            chdir("..")
999
1007
            
1000
1008
            runbzr(['export', '-r', '3', 'exp3.tmp'])
1001
1009
            chdir("exp3.tmp")
1002
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
1003
 
            assert listdir_sorted("d2") == [ "link1", "link3" ]
1004
 
            assert os.readlink("d2/link1") == "NOWHERE1"
1005
 
            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")
1006
1014
            chdir("..")
1007
1015
            
1008
1016
            runbzr(['export', '-r', '4', 'exp4.tmp'])
1009
1017
            chdir("exp4.tmp")
1010
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
1011
 
            assert os.readlink("d2/link1") == "TARGET 1"
1012
 
            assert os.readlink("link2")    == "TARGET 2"
1013
 
            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" ])
1014
1022
            chdir("..")
1015
1023
            
1016
1024
            runbzr(['export', '-r', '5', 'exp5.tmp'])
1017
1025
            chdir("exp5.tmp")
1018
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
1019
 
            assert os.path.islink("link2")
1020
 
            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" ])
1021
1029
            chdir("..")
1022
1030
            
1023
1031
            runbzr(['export', '-r', '8', 'exp6.tmp'])
1024
1032
            chdir("exp6.tmp")
1025
1033
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
1026
 
            assert listdir_sorted("d1") == [ "link3new" ]
1027
 
            assert listdir_sorted("d2") == []
1028
 
            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")
1029
1037
            chdir("..")
1030
1038
        else:
1031
1039
            progress("skipping symlink tests")