~bzr-pqm/bzr/bzr.dev : revision 1563.2.35

66

def runTest(self):

67

k = Weave()

68

self.assertFalse('foo' in k)

69

k.add('foo', [], TEXT_1)

69

k.add_lines('foo', [], TEXT_1)

70

self.assertTrue('foo' in k)

71

72

79

"""Store and retrieve a simple text."""

80

def runTest(self):

81

k = Weave()

82

idx = k.add('text0', [], TEXT_0)

83

self.assertEqual(k.get(idx), TEXT_0)

82

idx = k.add_lines('text0', [], TEXT_0)

83

self.assertEqual(k.get_lines(idx), TEXT_0)

84

self.assertEqual(idx, 0)

85

86

87

class AnnotateOne(TestBase):

88

def runTest(self):

89

k = Weave()

90

k.add('text0', [], TEXT_0)

91

self.assertEqual(k.annotate(0),

92

[(0, TEXT_0[0])])

90

k.add_lines('text0', [], TEXT_0)

91

self.assertEqual(k.annotate('text0'),

92

[('text0', TEXT_0[0])])

93

94

95

class StoreTwo(TestBase):

96

def runTest(self):

97

k = Weave()

98

99

idx = k.add('text0', [], TEXT_0)

99

idx = k.add_lines('text0', [], TEXT_0)

100

self.assertEqual(idx, 0)

101

102

idx = k.add('text1', [], TEXT_1)

102

idx = k.add_lines('text1', [], TEXT_1)

103

self.assertEqual(idx, 1)

104

105

self.assertEqual(k.get(0), TEXT_0)

106

self.assertEqual(k.get(1), TEXT_1)

107

108

109

class AddWithGivenSha(TestBase):

110

def runTest(self):

111

"""Add with caller-supplied SHA-1"""

112

k = Weave()

113

114

t = 'text0'

115

k.add('text0', [], [t], sha1=sha_string(t))

105

self.assertEqual(k.get_lines(0), TEXT_0)

106

self.assertEqual(k.get_lines(1), TEXT_1)

116

107

117

108

118

109

class GetSha1(TestBase):

119

110

def test_get_sha1(self):

120

111

k = Weave()

121

k.add('text0', [], 'text0')

112

k.add_lines('text0', [], 'text0')

122

113

self.assertEqual('34dc0e430c642a26c3dd1c2beb7a8b4f4445eb79',

123

114

k.get_sha1('text0'))

124

115

self.assertRaises(errors.RevisionNotPresent,

132

123

def runTest(self):

133

124

k = Weave()

134

125

135

self.assertRaises(IndexError,

136

k.add,

126

self.assertRaises(errors.RevisionNotPresent,

127

k.add_lines,

137

128

'text0',

138

[69],

129

['69'],

139

130

['new text!'])

140

131

141

132

143

134

"""Add the same version twice; harmless."""

144

135

def runTest(self):

145

136

k = Weave()

146

idx = k.add('text0', [], TEXT_0)

147

idx2 = k.add('text0', [], TEXT_0)

137

idx = k.add_lines('text0', [], TEXT_0)

138

idx2 = k.add_lines('text0', [], TEXT_0)

148

139

self.assertEqual(idx, idx2)

149

140

150

141

151

142

class InvalidRepeatedAdd(TestBase):

152

143

def runTest(self):

153

144

k = Weave()

154

idx = k.add('text0', [], TEXT_0)

145

k.add_lines('basis', [], TEXT_0)

146

idx = k.add_lines('text0', [], TEXT_0)

155

147

self.assertRaises(errors.RevisionAlreadyPresent,

156

k.add,

148

k.add_lines,

157

149

'text0',

158

150

[],

159

151

['not the same text'])

160

152

self.assertRaises(errors.RevisionAlreadyPresent,

161

k.add,

153

k.add_lines,

162

154

'text0',

163

[12], # not the right parents

155

['basis'], # not the right parents

164

156

TEXT_0)

165

157

166

158

172

164

def runTest(self):

173

165

k = Weave()

174

166

175

k.add('text0', [], ['line 1'])

176

k.add('text1', [0], ['line 1', 'line 2'])

177

178

self.assertEqual(k.annotate(0),

179

[(0, 'line 1')])

180

181

self.assertEqual(k.get(1),

167

k.add_lines('text0', [], ['line 1'])

168

k.add_lines('text1', ['text0'], ['line 1', 'line 2'])

169

170

self.assertEqual(k.annotate('text0'),

171

[('text0', 'line 1')])

172

173

self.assertEqual(k.get_lines(1),

182

174

['line 1',

183

175

'line 2'])

184

176

185

self.assertEqual(k.annotate(1),

186

[(0, 'line 1'),

187

(1, 'line 2')])

188

189

k.add('text2', [0], ['line 1', 'diverged line'])

190

191

self.assertEqual(k.annotate(2),

192

[(0, 'line 1'),

193

(2, 'diverged line')])

177

self.assertEqual(k.annotate('text1'),

178

[('text0', 'line 1'),

179

('text1', 'line 2')])

180

181

k.add_lines('text2', ['text0'], ['line 1', 'diverged line'])

182

183

self.assertEqual(k.annotate('text2'),

184

[('text0', 'line 1'),

185

('text2', 'diverged line')])

194

186

195

187

text3 = ['line 1', 'middle line', 'line 2']

196

k.add('text3',

197

[0, 1],

188

k.add_lines('text3',

189

['text0', 'text1'],

198

190

text3)

199

191

200

192

# self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))

201

193

202

194

self.log("k._weave=" + pformat(k._weave))

203

195

204

self.assertEqual(k.annotate(3),

205

[(0, 'line 1'),

206

(3, 'middle line'),

207

(1, 'line 2')])

196

self.assertEqual(k.annotate('text3'),

197

[('text0', 'line 1'),

198

('text3', 'middle line'),

199

('text1', 'line 2')])

208

200

209

201

# now multiple insertions at different places

210

k.add('text4',

211

[0, 1, 3],

202

k.add_lines('text4',

203

['text0', 'text1', 'text3'],

212

204

['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])

213

205

214

self.assertEqual(k.annotate(4),

215

[(0, 'line 1'),

216

(4, 'aaa'),

217

(3, 'middle line'),

218

(4, 'bbb'),

219

(1, 'line 2'),

220

(4, 'ccc')])

206

self.assertEqual(k.annotate('text4'),

207

[('text0', 'line 1'),

208

('text4', 'aaa'),

209

('text3', 'middle line'),

210

('text4', 'bbb'),

211

('text1', 'line 2'),

212

('text4', 'ccc')])

221

213

222

214

223

215

class DeleteLines(TestBase):

229

221

230

222

base_text = ['one', 'two', 'three', 'four']

231

223

232

k.add('text0', [], base_text)

224

k.add_lines('text0', [], base_text)

233

225

234

226

texts = [['one', 'two', 'three'],

235

227

['two', 'three', 'four'],

239

231

240

232

i = 1

241

233

for t in texts:

242

ver = k.add('text%d' % i,

243

[0], t)

234

ver = k.add_lines('text%d' % i,

235

['text0'], t)

244

236

i += 1

245

237

246

238

self.log('final weave:')

247

239

self.log('k._weave=' + pformat(k._weave))

248

240

249

241

for i in range(len(texts)):

250

self.assertEqual(k.get(i+1),

242

self.assertEqual(k.get_lines(i+1),

251

243

texts[i])

252

244

253

245

270

262

return

271

263

272

264

self.assertRaises(WeaveFormatError,

273

k.get,

265

k.get_lines,

274

266

0)

275

267

276

268

293

285

k._sha1s = [sha_string('first lineline to be deletedlast line')

294

286

, sha_string('first linelast line')]

295

287

296

self.assertEqual(k.get(0),

288

self.assertEqual(k.get_lines(0),

297

289

['first line',

298

290

'line to be deleted',

299

291

'last line',

300

292

])

301

293

302

self.assertEqual(k.get(1),

294

self.assertEqual(k.get_lines(1),

303

295

['first line',

304

296

'last line',

305

297

])

327

319

k._sha1s = [sha_string('first lineline to be deletedlast line')

328

320

, sha_string('first linereplacement linelast line')]

329

321

330

self.assertEqual(k.get(0),

322

self.assertEqual(k.get_lines(0),

331

323

['first line',

332

324

'line to be deleted',

333

325

'last line',

334

326

])

335

327

336

self.assertEqual(k.get(1),

328

self.assertEqual(k.get_lines(1),

337

329

['first line',

338

330

'replacement line',

339

331

'last line',

431

423

, sha_string('foo { added in version 1 added in v2 also from v1}')

432

424

]

433

425

434

self.assertEqual(k.get(0),

426

self.assertEqual(k.get_lines(0),

435

427

['foo {',

436

428

'}'])

437

429

438

self.assertEqual(k.get(1),

430

self.assertEqual(k.get_lines(1),

439

431

['foo {',

440

432

' added in version 1',

441

433

' also from v1',

442

434

'}'])

443

435

444

self.assertEqual(k.get(2),

436

self.assertEqual(k.get_lines(2),

445

437

['foo {',

446

438

' added in v2',

447

439

'}'])

448

440

449

self.assertEqual(k.get(3),

441

self.assertEqual(k.get_lines(3),

450

442

['foo {',

451

443

' added in version 1',

452

444

' added in v2',

462

454

def runTest(self):

463

455

k = Weave()

464

456

465

k.add('text0', [], ["line the first",

457

k.add_lines('text0', [], ["line the first",

466

458

"line 2",

467

459

"line 3",

468

460

"fine"])

469

461

470

self.assertEqual(len(k.get(0)), 4)

462

self.assertEqual(len(k.get_lines(0)), 4)

471

463

472

k.add('text1', [0], ["line the first",

464

k.add_lines('text1', ['text0'], ["line the first",

473

465

"fine"])

474

466

475

self.assertEqual(k.get(1),

467

self.assertEqual(k.get_lines(1),

476

468

["line the first",

477

469

"fine"])

478

470

479

self.assertEqual(k.annotate(1),

480

[(0, "line the first"),

481

(0, "fine")])

471

self.assertEqual(k.annotate('text1'),

472

[('text0', "line the first"),

473

('text0', "fine")])

482

474

483

475

484

476

class IncludeVersions(TestBase):

505

497

k._sha1s = [sha_string('first line')

506

498

, sha_string('first linesecond line')]

507

499

508

self.assertEqual(k.get(1),

500

self.assertEqual(k.get_lines(1),

509

501

["first line",

510

502

"second line"])

511

503

512

self.assertEqual(k.get(0),

504

self.assertEqual(k.get_lines(0),

513

505

["first line"])

514

506

515

507

521

513

k = Weave()

522

514

523

515

k._names = ['0', '1', '2']

516

k._name_map = {'0':0, '1':1, '2':2}

524

517

k._parents = [frozenset(),

525

518

frozenset([0]),

526

519

frozenset([0]),

540

533

, sha_string('first linesecond line')

541

534

, sha_string('first linealternative second line')]

542

535

543

self.assertEqual(k.get(0),

536

self.assertEqual(k.get_lines(0),

544

537

["first line"])

545

538

546

self.assertEqual(k.get(1),

539

self.assertEqual(k.get_lines(1),

547

540

["first line",

548

541

"second line"])

549

542

550

self.assertEqual(k.get(2),

543

self.assertEqual(k.get_lines('2'),

551

544

["first line",

552

545

"alternative second line"])

553

546

554

self.assertEqual(list(k.inclusions([2])),

547

self.assertEqual(list(k.get_ancestry(['2'])),

555

548

['0', '2'])

556

549

557

550

562

555

text0 = ['cheddar', 'stilton', 'gruyere']

563

556

text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']

564

557

565

k.add('text0', [], text0)

566

k.add('text1', [0], text1)

558

k.add_lines('text0', [], text0)

559

k.add_lines('text1', ['text0'], text1)

567

560

568

561

self.log('k._weave=' + pformat(k._weave))

569

562

570

self.assertEqual(k.get(0), text0)

571

self.assertEqual(k.get(1), text1)

563

self.assertEqual(k.get_lines(0), text0)

564

self.assertEqual(k.get_lines(1), text1)

572

565

573

566

574

567

class Merge(TestBase):

582

575

['header', '', 'line from 1', 'fixup line', 'line from 2'],

583

576

]

584

577

585

k.add('text0', [], texts[0])

586

k.add('text1', [0], texts[1])

587

k.add('text2', [0], texts[2])

588

k.add('merge', [0, 1, 2], texts[3])

578

k.add_lines('text0', [], texts[0])

579

k.add_lines('text1', ['text0'], texts[1])

580

k.add_lines('text2', ['text0'], texts[2])

581

k.add_lines('merge', ['text0', 'text1', 'text2'], texts[3])

589

582

590

583

for i, t in enumerate(texts):

591

self.assertEqual(k.get(i), t)

584

self.assertEqual(k.get_lines(i), t)

592

585

593

self.assertEqual(k.annotate(3),

594

[(0, 'header'),

595

(1, ''),

596

(1, 'line from 1'),

597

(3, 'fixup line'),

598

(2, 'line from 2'),

586

self.assertEqual(k.annotate('merge'),

587

[('text0', 'header'),

588

('text1', ''),

589

('text1', 'line from 1'),

590

('merge', 'fixup line'),

591

('text2', 'line from 2'),

599

592

])

600

593

601

self.assertEqual(list(k.inclusions([3])),

594

self.assertEqual(list(k.get_ancestry(['merge'])),

602

595

['text0', 'text1', 'text2', 'merge'])

603

596

604

597

self.log('k._weave=' + pformat(k._weave))

616

609

return # NOT RUN

617

610

k = Weave()

618

611

619

k.add([], ['aaa', 'bbb'])

620

k.add([0], ['aaa', '111', 'bbb'])

621

k.add([1], ['aaa', '222', 'bbb'])

612

k.add_lines([], ['aaa', 'bbb'])

613

k.add_lines([0], ['aaa', '111', 'bbb'])

614

k.add_lines([1], ['aaa', '222', 'bbb'])

622

615

623

616

merged = k.merge([1, 2])

624

617

635

628

return # NOT RUN

636

629

k = Weave()

637

630

638

k.add([], ['aaa', 'bbb'])

639

k.add([0], ['111', 'aaa', 'ccc', 'bbb'])

640

k.add([1], ['aaa', 'ccc', 'bbb', '222'])

631

k.add_lines([], ['aaa', 'bbb'])

632

k.add_lines([0], ['111', 'aaa', 'ccc', 'bbb'])

633

k.add_lines([1], ['aaa', 'ccc', 'bbb', '222'])

641

634

642

635

643

636

class Khayyam(TestBase):

675

668

parents = set()

676

669

i = 0

677

670

for t in texts:

678

ver = k.add('text%d' % i,

671

ver = k.add_lines('text%d' % i,

679

672

list(parents), t)

680

parents.add(ver)

673

parents.add('text%d' % i)

681

674

i += 1

682

675

683

676

self.log("k._weave=" + pformat(k._weave))

684

677

685

678

for i, t in enumerate(texts):

686

self.assertEqual(k.get(i), t)

679

self.assertEqual(k.get_lines(i), t)

687

680

688

681

self.check_read_write(k)

689

682

697

690

return x + '\n'

698

691

699

692

w = Weave()

700

w.add('text0', [], map(addcrlf, base))

701

w.add('text1', [0], map(addcrlf, a))

702

w.add('text2', [0], map(addcrlf, b))

693

w.add_lines('text0', [], map(addcrlf, base))

694

w.add_lines('text1', ['text0'], map(addcrlf, a))

695

w.add_lines('text2', ['text0'], map(addcrlf, b))

703

696

704

697

self.log('weave is:')

705

698

tmpf = StringIO()

707

700

self.log(tmpf.getvalue())

708

701

709

702

self.log('merge plan:')

710

p = list(w.plan_merge(1, 2))

703

p = list(w.plan_merge('text1', 'text2'))

711

704

for state, line in p:

712

705

if line:

713

706

self.log('%12s | %s' % (state, line[:-1]))

794

787

self.weave1 = Weave()

795

788

self.lines1 = ['hello\n']

796

789

self.lines3 = ['hello\n', 'cruel\n', 'world\n']

797

self.weave1.add('v1', [], self.lines1)

798

self.weave1.add('v2', [0], ['hello\n', 'world\n'])

799

self.weave1.add('v3', [1], self.lines3)

790

self.weave1.add_lines('v1', [], self.lines1)

791

self.weave1.add_lines('v2', ['v1'], ['hello\n', 'world\n'])

792

self.weave1.add_lines('v3', ['v2'], self.lines3)

800

793

801

794

def test_join_empty(self):

802

795

"""Join two empty weaves."""

804

797

w1 = Weave()

805

798

w2 = Weave()

806

799

w1.join(w2)

807

eq(w1.numversions(), 0)

800

eq(len(w1), 0)

808

801

809

802

def test_join_empty_to_nonempty(self):

810

803

"""Join empty weave onto nonempty."""

814

807

def test_join_unrelated(self):

815

808

"""Join two weaves with no history in common."""

816

809

wb = Weave()

817

wb.add('b1', [], ['line from b\n'])

810

wb.add_lines('b1', [], ['line from b\n'])

818

811

w1 = self.weave1

819

812

w1.join(wb)

820

813

eq = self.assertEqual

821

814

eq(len(w1), 4)

822

eq(sorted(list(w1.iter_names())),

815

eq(sorted(w1.versions()),

823

816

['b1', 'v1', 'v2', 'v3'])

824

817

825

818

def test_join_related(self):

826

819

wa = self.weave1.copy()

827

820

wb = self.weave1.copy()

828

wa.add('a1', ['v3'], ['hello\n', 'sweet\n', 'world\n'])

829

wb.add('b1', ['v3'], ['hello\n', 'pale blue\n', 'world\n'])

821

wa.add_lines('a1', ['v3'], ['hello\n', 'sweet\n', 'world\n'])

822

wb.add_lines('b1', ['v3'], ['hello\n', 'pale blue\n', 'world\n'])

830

823

eq = self.assertEquals

831

824

eq(len(wa), 4)

832

825

eq(len(wb), 4)

839

832

#join reconciles differening parents into a union.

840

833

wa = Weave()

841

834

wb = Weave()

842

wa.add('v1', [], ['hello\n'])

843

wb.add('v0', [], [])

844

wb.add('v1', ['v0'], ['hello\n'])

835

wa.add_lines('v1', [], ['hello\n'])

836

wb.add_lines('v0', [], [])

837

wb.add_lines('v1', ['v0'], ['hello\n'])

845

838

wa.join(wb)

846

839

self.assertEqual(['v0'], wa.get_parents('v1'))

847

840

849

842

"""Cannot join weaves with different texts for a version."""

850

843

wa = Weave()

851

844

wb = Weave()

852

wa.add('v1', [], ['hello\n'])

853

wb.add('v1', [], ['not\n', 'hello\n'])

845

wa.add_lines('v1', [], ['hello\n'])

846

wb.add_lines('v1', [], ['not\n', 'hello\n'])

854

847

self.assertRaises(WeaveError,

855

848

wa.join, wb)

856

849

860

853

The source weave contains a different version at index 0."""

861

854

wa = self.weave1.copy()

862

855

wb = Weave()

863

wb.add('x1', [], ['line from x1\n'])

864

wb.add('v1', [], ['hello\n'])

865

wb.add('v2', ['v1'], ['hello\n', 'world\n'])

856

wb.add_lines('x1', [], ['line from x1\n'])

857

wb.add_lines('v1', [], ['hello\n'])

858

wb.add_lines('v2', ['v1'], ['hello\n', 'world\n'])

866

859

wa.join(wb)

867

860

eq = self.assertEquals

868

eq(sorted(wa.iter_names()), ['v1', 'v2', 'v3', 'x1',])

861

eq(sorted(wa.versions()), ['v1', 'v2', 'v3', 'x1',])

869

862

eq(wa.get_text('x1'), 'line from x1\n')

870

863

871

864

def test_written_detection(self):

877

870

from cStringIO import StringIO

878

871

879

872

w = Weave()

880

w.add('v1', [], ['hello\n'])

881

w.add('v2', ['v1'], ['hello\n', 'there\n'])

873

w.add_lines('v1', [], ['hello\n'])

874

w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])

882

875

883

876

tmpf = StringIO()

884

877

write_weave(w, tmpf)

901

894

self.assertEqual('hello\n', w.get_text('v1'))

902

895

self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')

903

896

self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')

904

self.assertRaises(errors.WeaveInvalidChecksum, list, w.get_iter('v2'))

905

897

self.assertRaises(errors.WeaveInvalidChecksum, w.check)

906

898

907

899

# Change the sha checksum

915

907

self.assertEqual('hello\n', w.get_text('v1'))

916

908

self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')

917

909

self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')

918

self.assertRaises(errors.WeaveInvalidChecksum, list, w.get_iter('v2'))

919

910

self.assertRaises(errors.WeaveInvalidChecksum, w.check)

920

911

921

912

943

934

txt2 = ['a\n', 'c\n']

944

935

txt3 = ['a\n', 'b\n', 'c\n']

945

936

946

w1.add('txt0', [], txt0) # extract 1a

947

w2.add('txt0', [], txt0) # extract 1b

948

w1.add('txt1', [0], txt1)# extract 2a

949

w2.add('txt2', [0], txt2)# extract 2b

937

w1.add_lines('txt0', [], txt0) # extract 1a

938

w2.add_lines('txt0', [], txt0) # extract 1b

939

w1.add_lines('txt1', ['txt0'], txt1)# extract 2a

940

w2.add_lines('txt2', ['txt0'], txt2)# extract 2b

950

941

w1.join(w2) # extract 3a to add txt2

951

942

w2.join(w1) # extract 3b to add txt1

952

943

953

w1.add('txt3', [1, 2], txt3) # extract 4a

954

w2.add('txt3', [1, 2], txt3) # extract 4b

944

w1.add_lines('txt3', ['txt1', 'txt2'], txt3) # extract 4a

945

w2.add_lines('txt3', ['txt2', 'txt1'], txt3) # extract 4b

955

946

# These secretly have inverted parents

956

947

957

948

# This should not have to do any extractions

972

963

txt2 = ['a\n', 'c\n']

973

964

txt3 = ['a\n', 'b\n', 'c\n']

974

965

975

w1.add('txt0', [], txt0)

976

w2.add('txt0', [], txt0)

977

w1.add('txt1', [0], txt1)

978

w2.add('txt1', [0,0], txt1)

966

w1.add_lines('txt0', [], txt0)

967

w2.add_lines('txt0', [], txt0)

968

w1.add_lines('txt1', ['txt0'], txt1)

969

w2.add_lines('txt1', ['txt0', 'txt0'], txt1)

979

970

# Same text, effectively the same, because the

980

971

# parent is only repeated

981

972

w1.join(w2) # extract 3a to add txt2

982

973

w2.join(w1) # extract 3b to add txt1

983

974

984

975

985

class MismatchedTexts(TestCase):

986

"""Test that merging two weaves with different texts fails."""

987

988

def test_reweave(self):

989

w1 = Weave('a')

990

w2 = Weave('b')

991

992

w1.add('txt0', [], ['a\n'])

993

w2.add('txt0', [], ['a\n'])

994

w1.add('txt1', [0], ['a\n', 'b\n'])

995

w2.add('txt1', [0], ['a\n', 'c\n'])

996

997

self.assertRaises(errors.WeaveTextDiffers, w1.reweave, w2)

998

999

1000

976

class TestNeedsRweave(TestCase):

1001

977

"""Internal corner cases for when reweave is needed."""

1002

978