/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_multiparent.py

• browse files at revision 7500.1.1
• compare with another revision
• download diff
• download tarball
• view history from revision 7500.1.1

• reverse the comparison (7500.1.1 to 6858.1.1)
• stop comparing with revision 6858.1.1

Show diffs side-by-side

added

removed

breezy/tests/test_multiparent.py

14

14

# along with this program; if not, write to the Free Software

15

15

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

16

16

 

 

17

import patiencediff

17

18

from unittest import TestCase

18

19

 

19

20

from .. import (

20

21

    multiparent,

21

 

    patiencediff,

22

22

    tests,

23

23

    )

24

24

 

25

25

 

26

 

LINES_1 = "a\nb\nc\nd\ne\n".splitlines(True)

27

 

LINES_2 = "a\nc\nd\ne\n".splitlines(True)

28

 

LINES_3 = "a\nb\nc\nd\n".splitlines(True)

29

 

LF_SPLIT_LINES = ['\x00\n', '\x00\r\x01\n', '\x02\r\xff']

 

26

LINES_1 = b"a\nb\nc\nd\ne\n".splitlines(True)

 

27

LINES_2 = b"a\nc\nd\ne\n".splitlines(True)

 

28

LINES_3 = b"a\nb\nc\nd\n".splitlines(True)

 

29

LF_SPLIT_LINES = [b'\x00\n', b'\x00\r\x01\n', b'\x02\r\xff']

30

30

 

31

31

 

32

32

class Mock(object):

44

44

    def test_compare_one_parent(self):

45

45

        diff = multiparent.MultiParent.from_lines(LINES_1, [LINES_2])

46

46

        self.assertEqual([multiparent.ParentText(0, 0, 0, 1),

47

 

                          multiparent.NewText(['b\n']),

 

47

                          multiparent.NewText([b'b\n']),

48

48

                          multiparent.ParentText(0, 1, 2, 3)],

49

49

                         diff.hunks)

50

50

 

79

79

 

80

80

    def test_range_iterator(self):

81

81

        diff = multiparent.MultiParent.from_lines(LINES_1, [LINES_2, LINES_3])

82

 

        diff.hunks.append(multiparent.NewText(['q\n']))

 

82

        diff.hunks.append(multiparent.NewText([b'q\n']))

83

83

        self.assertEqual([(0, 4, 'parent', (1, 0, 4)),

84

84

                          (4, 5, 'parent', (0, 3, 4)),

85

 

                          (5, 6, 'new', ['q\n'])],

 

85

                          (5, 6, 'new', [b'q\n'])],

86

86

                         list(diff.range_iterator()))

87

87

 

88

88

    def test_eq(self):

100

100

                          multiparent.ParentText(0, 1, 2, 3)]))

101

101

 

102

102

    def test_to_patch(self):

103

 

        self.assertEqual(['i 1\n', 'a\n', '\n', 'c 0 1 2 3\n'],

104

 

            list(multiparent.MultiParent([multiparent.NewText(['a\n']),

105

 

            multiparent.ParentText(0, 1, 2, 3)]).to_patch()))

 

103

        self.assertEqual([b'i 1\n', b'a\n', b'\n', b'c 0 1 2 3\n'],

 

104

                         list(multiparent.MultiParent([multiparent.NewText([b'a\n']),

 

105

                                                       multiparent.ParentText(0, 1, 2, 3)]).to_patch()))

106

106

 

107

107

    def test_from_patch(self):

108

108

        self.assertEqual(multiparent.MultiParent(

109

 

            [multiparent.NewText(['a\n']),

 

109

            [multiparent.NewText([b'a\n']),

110

110

             multiparent.ParentText(0, 1, 2, 3)]),

111

 

             multiparent.MultiParent.from_patch('i 1\na\n\nc 0 1 2 3'))

 

111

            multiparent.MultiParent.from_patch(b'i 1\na\n\nc 0 1 2 3'))

112

112

        self.assertEqual(multiparent.MultiParent(

113

 

            [multiparent.NewText(['a']),

 

113

            [multiparent.NewText([b'a']),

114

114

             multiparent.ParentText(0, 1, 2, 3)]),

115

 

             multiparent.MultiParent.from_patch('i 1\na\nc 0 1 2 3\n'))

 

115

            multiparent.MultiParent.from_patch(b'i 1\na\nc 0 1 2 3\n'))

116

116

 

117

117

    def test_binary_content(self):

118

118

        patch = list(

119

119

            multiparent.MultiParent.from_lines(LF_SPLIT_LINES).to_patch())

120

 

        multiparent.MultiParent.from_patch(''.join(patch))

 

120

        multiparent.MultiParent.from_patch(b''.join(patch))

121

121

 

122

122

    def test_make_patch_from_binary(self):

123

 

        patch = multiparent.MultiParent.from_texts(''.join(LF_SPLIT_LINES))

 

123

        patch = multiparent.MultiParent.from_texts(b''.join(LF_SPLIT_LINES))

124

124

        expected = multiparent.MultiParent([

125

125

            multiparent.NewText(LF_SPLIT_LINES)])

126

126

        self.assertEqual(expected, patch)

127

127

 

128

128

    def test_num_lines(self):

129

 

        mp = multiparent.MultiParent([multiparent.NewText(['a\n'])])

 

129

        mp = multiparent.MultiParent([multiparent.NewText([b'a\n'])])

130

130

        self.assertEqual(1, mp.num_lines())

131

 

        mp.hunks.append(multiparent.NewText(['b\n', 'c\n']))

 

131

        mp.hunks.append(multiparent.NewText([b'b\n', b'c\n']))

132

132

        self.assertEqual(3, mp.num_lines())

133

133

        mp.hunks.append(multiparent.ParentText(0, 0, 3, 2))

134

134

        self.assertEqual(5, mp.num_lines())

135

 

        mp.hunks.append(multiparent.NewText(['f\n', 'g\n']))

 

135

        mp.hunks.append(multiparent.NewText([b'f\n', b'g\n']))

136

136

        self.assertEqual(7, mp.num_lines())

137

137

 

138

138

    def test_to_lines(self):

139

 

        mpdiff = multiparent.MultiParent.from_texts('a\nb\nc\n', ('b\nc\n',))

140

 

        lines = mpdiff.to_lines(('b\ne\n',))

141

 

        self.assertEqual(['a\n', 'b\n', 'e\n'], lines)

 

139

        mpdiff = multiparent.MultiParent.from_texts(b'a\nb\nc\n', (b'b\nc\n',))

 

140

        lines = mpdiff.to_lines((b'b\ne\n',))

 

141

        self.assertEqual([b'a\n', b'b\n', b'e\n'], lines)

142

142

 

143

143

 

144

144

class TestNewText(TestCase):

145

145

 

146

146

    def test_eq(self):

147

147

        self.assertEqual(multiparent.NewText([]), multiparent.NewText([]))

148

 

        self.assertFalse(multiparent.NewText(['a']) ==

149

 

                         multiparent.NewText(['b']))

150

 

        self.assertFalse(multiparent.NewText(['a']) == Mock(lines=['a']))

 

148

        self.assertFalse(multiparent.NewText([b'a'])

 

149

                         == multiparent.NewText([b'b']))

 

150

        self.assertFalse(multiparent.NewText([b'a']) == Mock(lines=[b'a']))

151

151

 

152

152

    def test_to_patch(self):

153

 

        self.assertEqual(['i 0\n', '\n'],

 

153

        self.assertEqual([b'i 0\n', b'\n'],

154

154

                         list(multiparent.NewText([]).to_patch()))

155

 

        self.assertEqual(['i 1\n', 'a', '\n'],

156

 

                         list(multiparent.NewText(['a']).to_patch()))

157

 

        self.assertEqual(['i 1\n', 'a\n', '\n'],

158

 

                         list(multiparent.NewText(['a\n']).to_patch()))

 

155

        self.assertEqual([b'i 1\n', b'a', b'\n'],

 

156

                         list(multiparent.NewText([b'a']).to_patch()))

 

157

        self.assertEqual([b'i 1\n', b'a\n', b'\n'],

 

158

                         list(multiparent.NewText([b'a\n']).to_patch()))

159

159

 

160

160

 

161

161

class TestParentText(TestCase):

163

163

    def test_eq(self):

164

164

        self.assertEqual(multiparent.ParentText(1, 2, 3, 4),

165

165

                         multiparent.ParentText(1, 2, 3, 4))

166

 

        self.assertFalse(multiparent.ParentText(1, 2, 3, 4) ==

167

 

                         multiparent.ParentText(2, 2, 3, 4))

168

 

        self.assertFalse(multiparent.ParentText(1, 2, 3, 4) ==

169

 

                         Mock(parent=1, parent_pos=2, child_pos=3,

170

 

                              num_lines=4))

 

166

        self.assertFalse(multiparent.ParentText(1, 2, 3, 4)

 

167

                         == multiparent.ParentText(2, 2, 3, 4))

 

168

        self.assertFalse(multiparent.ParentText(1, 2, 3, 4)

 

169

                         == Mock(parent=1, parent_pos=2, child_pos=3,

 

170

                                 num_lines=4))

171

171

 

172

172

    def test_to_patch(self):

173

 

        self.assertEqual(['c 0 1 2 3\n'],

 

173

        self.assertEqual([b'c 0 1 2 3\n'],

174

174

                         list(multiparent.ParentText(0, 1, 2, 3).to_patch()))

175

175

 

176

176

 

177

 

REV_A = ['a\n', 'b\n', 'c\n', 'd\n']

178

 

REV_B = ['a\n', 'c\n', 'd\n', 'e\n']

179

 

REV_C = ['a\n', 'b\n', 'e\n', 'f\n']

 

177

REV_A = [b'a\n', b'b\n', b'c\n', b'd\n']

 

178

REV_B = [b'a\n', b'c\n', b'd\n', b'e\n']

 

179

REV_C = [b'a\n', b'b\n', b'e\n', b'f\n']

180

180

 

181

181

 

182

182

class TestVersionedFile(TestCase):

183

183

 

184

184

    def add_version(self, vf, text, version_id, parent_ids):

185

 

        vf.add_version([(t+'\n') for t in text], version_id, parent_ids)

 

185

        vf.add_version(

 

186

            [(bytes([t]) + b'\n') for t in bytearray(text)],

 

187

            version_id, parent_ids)

186

188

 

187

189

    def make_vf(self):

188

190

        vf = multiparent.MultiMemoryVersionedFile()

189

 

        self.add_version(vf, 'abcd', 'rev-a', [])

190

 

        self.add_version(vf, 'acde', 'rev-b', [])

191

 

        self.add_version(vf, 'abef', 'rev-c', ['rev-a', 'rev-b'])

 

191

        self.add_version(vf, b'abcd', b'rev-a', [])

 

192

        self.add_version(vf, b'acde', b'rev-b', [])

 

193

        self.add_version(vf, b'abef', b'rev-c', [b'rev-a', b'rev-b'])

192

194

        return vf

193

195

 

194

196

    def test_add_version(self):

195

197

        vf = self.make_vf()

196

 

        self.assertEqual(REV_A, vf._lines['rev-a'])

 

198

        self.assertEqual(REV_A, vf._lines[b'rev-a'])

197

199

        vf.clear_cache()

198

200

        self.assertEqual(vf._lines, {})

199

201

 

200

202

    def test_get_line_list(self):

201

203

        vf = self.make_vf()

202

204

        vf.clear_cache()

203

 

        self.assertEqual(REV_A, vf.get_line_list(['rev-a'])[0])

204

 

        self.assertEqual([REV_B, REV_C], vf.get_line_list(['rev-b', 'rev-c']))

 

205

        self.assertEqual(REV_A, vf.get_line_list([b'rev-a'])[0])

 

206

        self.assertEqual(

 

207

            [REV_B, REV_C], vf.get_line_list([b'rev-b', b'rev-c']))

205

208

 

206

209

    def test_reconstruct_empty(self):

207

210

        vf = multiparent.MultiMemoryVersionedFile()

208

 

        vf.add_version([], 'a', [])

209

 

        self.assertEqual([], self.reconstruct_version(vf, 'a'))

 

211

        vf.add_version([], b'a', [])

 

212

        self.assertEqual([], self.reconstruct_version(vf, b'a'))

210

213

 

211

214

    @staticmethod

212

215

    def reconstruct(vf, revision_id, start, end):

226

229

 

227

230

    def test_reconstructor(self):

228

231

        vf = self.make_vf()

229

 

        self.assertEqual(['a\n', 'b\n'], self.reconstruct(vf, 'rev-a',  0, 2))

230

 

        self.assertEqual(['c\n', 'd\n'], self.reconstruct(vf, 'rev-a',  2, 4))

231

 

        self.assertEqual(['e\n', 'f\n'], self.reconstruct(vf, 'rev-c',  2, 4))

232

 

        self.assertEqual(['a\n', 'b\n', 'e\n', 'f\n'],

233

 

                          self.reconstruct(vf, 'rev-c',  0, 4))

234

 

        self.assertEqual(['a\n', 'b\n', 'e\n', 'f\n'],

235

 

                          self.reconstruct_version(vf, 'rev-c'))

 

232

        self.assertEqual([b'a\n', b'b\n'],

 

233

                         self.reconstruct(vf, b'rev-a', 0, 2))

 

234

        self.assertEqual([b'c\n', b'd\n'],

 

235

                         self.reconstruct(vf, b'rev-a', 2, 4))

 

236

        self.assertEqual([b'e\n', b'f\n'],

 

237

                         self.reconstruct(vf, b'rev-c', 2, 4))

 

238

        self.assertEqual([b'a\n', b'b\n', b'e\n', b'f\n'],

 

239

                         self.reconstruct(vf, b'rev-c', 0, 4))

 

240

        self.assertEqual([b'a\n', b'b\n', b'e\n', b'f\n'],

 

241

                         self.reconstruct_version(vf, b'rev-c'))

236

242

 

237

243

    def test_reordered(self):

238

244

        """Check for a corner case that requires re-starting the cursor"""

239

245

        vf = multiparent.MultiMemoryVersionedFile()

240

246

        # rev-b must have at least two hunks, so split a and b with c.

241

 

        self.add_version(vf, 'c', 'rev-a', [])

242

 

        self.add_version(vf, 'acb', 'rev-b', ['rev-a'])

 

247

        self.add_version(vf, b'c', b'rev-a', [])

 

248

        self.add_version(vf, b'acb', b'rev-b', [b'rev-a'])

243

249

        # rev-c and rev-d must each have a line from a different rev-b hunk

244

 

        self.add_version(vf, 'b', 'rev-c', ['rev-b'])

245

 

        self.add_version(vf, 'a', 'rev-d', ['rev-b'])

 

250

        self.add_version(vf, b'b', b'rev-c', [b'rev-b'])

 

251

        self.add_version(vf, b'a', b'rev-d', [b'rev-b'])

246

252

        # The lines from rev-c and rev-d must appear in the opposite order

247

 

        self.add_version(vf, 'ba', 'rev-e', ['rev-c', 'rev-d'])

 

253

        self.add_version(vf, b'ba', b'rev-e', [b'rev-c', b'rev-d'])

248

254

        vf.clear_cache()

249

 

        lines = vf.get_line_list(['rev-e'])[0]

250

 

        self.assertEqual(['b\n', 'a\n'], lines)

 

255

        lines = vf.get_line_list([b'rev-e'])[0]

 

256

        self.assertEqual([b'b\n', b'a\n'], lines)

251

257

 

252

258

 

253

259

class TestMultiVersionedFile(tests.TestCaseInTempDir):

254

260

 

255

261

    def test_save_load(self):

256

262

        vf = multiparent.MultiVersionedFile('foop')

257

 

        vf.add_version('a\nb\nc\nd'.splitlines(True), 'a', [])

258

 

        vf.add_version('a\ne\nd\n'.splitlines(True), 'b', ['a'])

 

263

        vf.add_version(b'a\nb\nc\nd'.splitlines(True), b'a', [])

 

264

        vf.add_version(b'a\ne\nd\n'.splitlines(True), b'b', [b'a'])

259

265

        vf.save()

260

266

        newvf = multiparent.MultiVersionedFile('foop')

261

267

        newvf.load()

262

 

        self.assertEqual('a\nb\nc\nd', ''.join(newvf.get_line_list(['a'])[0]))

263

 

        self.assertEqual('a\ne\nd\n', ''.join(newvf.get_line_list(['b'])[0]))

 

268

        self.assertEqual(b'a\nb\nc\nd', b''.join(

 

269

            newvf.get_line_list([b'a'])[0]))

 

270

        self.assertEqual(b'a\ne\nd\n', b''.join(

 

271

            newvf.get_line_list([b'b'])[0]))

264

272

 

265

273

    def test_filenames(self):

266

274

        vf = multiparent.MultiVersionedFile('foop')

267

 

        vf.add_version('a\nb\nc\nd'.splitlines(True), 'a', [])

 

275

        vf.add_version(b'a\nb\nc\nd'.splitlines(True), b'a', [])

268

276

        self.assertPathExists('foop.mpknit')

269

277

        self.assertPathDoesNotExist('foop.mpidx')

270

278

        vf.save()

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0