~abentley/bzrtools/bzrtools.dev : revision 147.1.70

23

pybaz = None

24

import os

25

from bzrlib.plugins.bzrtools.baz_import import (import_version, revision_id,

26

cmd_baz_import)

26

cmd_baz_import, make_archive)

27

from bzrlib.errors import NoSuchRevision

28

import shutil

29

from StringIO import StringIO

30

import tempfile

31

from testresources import (TestResource, TestLoader, OptimisingTestSuite,

32

ResourcedTestCase)

32

ResourcedTestCase)

33

34

from bzrlib.plugins.bzrtools.fai import namespace_previous

34

35

from bzrlib.branch import Branch

35

36

37

def test_suite():

37

38

if pybaz is None:

38

return OptimisingTestSuite()

39

from unittest import TestSuite

40

return TestSuite()

39

41

return TestLoader().loadTestsFromName(__name__)

40

42

41

43

53

55

os.environ['HOME'] = self._homedir

54

56

55

57

self._archiveroot = os.path.join(self._tmpdir, 'archive')

56

self._archive = pybaz.make_archive('demo@DONOTUSE', str(self._archiveroot))

58

self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))

57

59

pybaz.set_my_id("Test User<test@example.org>")

58

60

59

61

self.make_empty_import()

81

83

82

84

# tree, two commits, includes merge of other branch

83

85

self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'

84

self._empty_merged_tag_2_bzr_base = revision_id(self._empty_merged_tag_2 + '--base-0')

85

self._empty_merged_tag_2_bzr = revision_id(self._empty_merged_tag_2 + '--patch-1')

86

self._empty_merged_tag_2_bzr_base = revision_id(

87

self._empty_merged_tag_2 + '--base-0')

88

self._empty_merged_tag_2_bzr = revision_id(

89

self._empty_merged_tag_2 + '--patch-1')

86

90

pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(

87

91

pybaz.Version(self._empty_merged_tag_2))

88

92

tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (

102

106

tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(

103

107

os.path.join(self._tmpdir, 'tree'))

104

108

from bzrlib.plugins.bzrtools.baz_import import add_file

105

add_file(os.path.join(self._tmpdir,'tree/path'), 'text', 'this_id/needs%escaping')

109

add_file(os.path.join(self._tmpdir,'tree/path'), 'text',

110

'this_id/needs%escaping')

106

111

msg = tree.log_message()

107

112

msg["summary"] = "commit something which needs escaping."

108

113

tree.commit(msg)

110

115

111

116

self.make_import_symlink()

112

117

self.make_missing_ancestor()

118

self.make_inbranch_continuation()

113

119

114

120

def make_import_symlink(self):

115

121

self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'

116

self._import_symlink_bzr = revision_id(self._import_symlink + '--base-0')

122

self._import_symlink_bzr = revision_id(

123

self._import_symlink + '--base-0')

117

124

os.mkdir(os.path.join(self._tmpdir, 'tree'))

118

125

tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),

119

126

self._import_symlink)

131

138

def make_empty_import(self):

132

139

self._import = 'demo@DONOTUSE/c--import--0'

133

140

os.mkdir(os.path.join(self._tmpdir, 'tree'))

134

tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)

141

tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),

142

self._import)

135

143

msg = tree.log_message()

136

144

msg["summary"] = "I am importing now"

137

145

tree.import_(msg)

139

147

140

148

def make_missing_ancestor(self):

141

149

self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')

142

self._archive = pybaz.make_archive('demo-gone@DONOTUSE',

143

str(self._archivegoneroot))

150

self._archive = make_archive('demo-gone@DONOTUSE',

151

str(self._archivegoneroot))

144

152

self._missing_import = 'demo-gone@DONOTUSE/c--import--0'

145

153

self._missing_import_bzr = revision_id(self._missing_import

146

154

+ '--base-0')

173

181

# and make it inaccessible

174

182

pybaz.Archive('demo-gone@DONOTUSE').unregister()

175

183

184

def make_inbranch_continuation(self):

185

self._inbranch_tag = 'demo@DONOTUSE/c--inbranch-tag--0'

186

self._inbranch_tag_base = self._inbranch_tag + '--base-0'

187

self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base)

188

pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(

189

pybaz.Version(self._inbranch_tag))

190

self._inbranch_tag_head = self._inbranch_tag + '--patch-1'

191

self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head)

192

pybaz.Revision(self._inbranch_tag_base).make_continuation(

193

pybaz.Version(self._inbranch_tag))

194

176

195

@classmethod

177

196

def _makeResource(self):

178

197

return BazTreeResource()

201

220

self.output.write("\n")

202

221

203

222

def test_import_empty(self):

204

import_version('output', pybaz.Version(self._baz._import), self.collect)

223

import_version('output', pybaz.Version(self._baz._import),

224

self.collect)

205

225

# expected results:

206

# one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'

226

# one commit, no files, revision identifier of

227

# 'demo@DONOTUSE_c--import--0--base-0'

207

228

branch = Branch.open('output')

229

repo = branch.repository

208

230

self.assertEqual(branch.revision_history(),

209

231

['Arch-1:demo@DONOTUSE%c--import--0--base-0'])

210

rev = branch.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')

232

rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')

211

233

# and again.

212

234

import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),

213

235

self.collect)

214

236

branch2 = Branch.open('output2')

237

repo2 = branch2.repository

215

238

self.assertEqual(branch.revision_history(), branch2.revision_history())

216

rev2 = branch2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')

239

rev2 = repo2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')

217

240

# they must be the same

218

241

self.assertEqual(rev, rev2)

219

242

234

257

self.assertEqual(branch.revision_history(),

235

258

['Arch-1:demo@DONOTUSE%c--import--0--base-0',

236

259

self._baz._empty_tag_bzr])

237

rev = branch.get_revision(self._baz._empty_tag_bzr)

260

rev = branch.repository.get_revision(self._baz._empty_tag_bzr)

238

261

# and again.

239

262

import_version('output2', pybaz.Version(self._baz._empty_tag),

240

263

self.collect)

241

264

branch2 = Branch.open('output2')

242

265

self.assertEqual(branch.revision_history(), branch2.revision_history())

243

rev2 = branch2.get_revision(self._baz._empty_tag_bzr)

266

rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)

244

267

# they must be the same

245

268

self.assertEqual(rev, rev2)

246

269

247

270

# and we should get some expected values:

248

271

self.assertEqual(rev.committer, "Test User<test@example.org>")

249

self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")

272

self.assertEqual(rev.message,

273

"tag of demo@DONOTUSE/c--import--0--base-0")

250

274

self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)

251

275

252

276

def test_empty_merged_tagged(self):

260

284

# and a merged revision from the latter of

261

285

# self._baz._empty_tag_bzr

262

286

branch = Branch.open('output')

287

repo = branch.repository

263

288

self.assertEqual(branch.revision_history(),

264

289

['Arch-1:demo@DONOTUSE%c--import--0--base-0',

265

290

self._baz._empty_merged_tag_bzr_base,

268

293

import_version('output2', pybaz.Version(self._baz._empty_merged_tag),

269

294

self.collect)

270

295

branch2 = Branch.open('output2')

296

repo2 = branch2.repository

271

297

# and import what we should be merged up against for checking with.

272

298

import_version('output3', pybaz.Version(self._baz._empty_tag),

273

299

self.collect)

274

300

branch3 = Branch.open('output3')

275

301

276

302

self.assertEqual(branch.revision_history(), branch2.revision_history())

277

self.assertNotEqual(branch.revision_history(), branch3.revision_history())

303

self.assertNotEqual(branch.revision_history(),

304

branch3.revision_history())

278

305

# check revisions in the history.

279

rev = branch.get_revision(self._baz._empty_merged_tag_bzr_base)

280

rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr_base)

306

rev = repo.get_revision(self._baz._empty_merged_tag_bzr_base)

307

rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr_base)

281

308

# they must be the same

282

309

self.assertEqual(rev, rev2)

283

310

# and we should get some expected values:

284

311

self.assertEqual(rev.committer, "Test User<test@example.org>")

285

self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")

312

self.assertEqual(rev.message,

313

"tag of demo@DONOTUSE/c--import--0--base-0")

286

314

self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr_base)

287

315

self.assertEqual(['Arch-1:demo@DONOTUSE%c--import--0--base-0'],

288

316

rev.parent_ids)

289

317

290

318

# check next revisions in the history.

291

rev = branch.get_revision(self._baz._empty_merged_tag_bzr)

292

rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr)

319

rev = repo.get_revision(self._baz._empty_merged_tag_bzr)

320

rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr)

293

321

# they must be the same

294

322

self.assertEqual(rev, rev2)

295

323

# and we should get some expected values:

315

343

# and a merged revision from the latter of

316

344

# self._baz._empty_merged_tag_bzr

317

345

branch = Branch.open('output')

346

repo = branch.repository

318

347

self.assertEqual(branch.revision_history(),

319

348

['Arch-1:demo@DONOTUSE%c--import--0--base-0',

320

349

self._baz._empty_merged_tag_2_bzr_base,

323

352

import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),

324

353

self.collect)

325

354

branch2 = Branch.open('output2')

355

repo2 = branch2.repository

326

356

# and import what we should be merged up against for checking with.

327

357

import_version('output3', pybaz.Version(self._baz._empty_merged_tag),

328

358

self.collect)

329

359

branch3 = Branch.open('output3')

330

360

331

361

self.assertEqual(branch.revision_history(), branch2.revision_history())

332

self.assertNotEqual(branch.revision_history(), branch3.revision_history())

362

self.assertNotEqual(branch.revision_history(),

363

branch3.revision_history())

333

364

# check revisions in the history.

334

rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr_base)

335

rev2 = branch2.get_revision(self._baz._empty_merged_tag_2_bzr_base)

365

rev = repo.get_revision(self._baz._empty_merged_tag_2_bzr_base)

366

rev2 = repo2.get_revision(self._baz._empty_merged_tag_2_bzr_base)

336

367

# they must be the same

337

368

self.assertEqual(rev, rev2)

338

369

# and we should get some expected values:

339

370

self.assertEqual(rev.committer, "Test User<test@example.org>")

340

self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")

341

self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr_base)

371

self.assertEqual(rev.message,

372

"tag of demo@DONOTUSE/c--import--0--base-0")

373

self.assertEqual(rev.revision_id,

374

self._baz._empty_merged_tag_2_bzr_base)

342

375

343

376

# check next revisions in the history.

344

rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr)

345

rev2 = branch2.get_revision(self._baz._empty_merged_tag_2_bzr)

377

rev = repo.get_revision(self._baz._empty_merged_tag_2_bzr)

378

rev2 = repo2.get_revision(self._baz._empty_merged_tag_2_bzr)

346

379

# they must be the same

347

380

self.assertEqual(rev, rev2)

348

381

# and we should get some expected values:

362

395

import_version('output', pybaz.Version(self._baz._import_symlink),

363

396

self.collect)

364

397

# expected results:

365

# one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'

398

# one commit, no files, revision identifier of

399

# 'demo@DONOTUSE_c--import--0--base-0'

366

400

branch = Branch.open('output')

367

401

self.assertEqual(branch.revision_history(),

368

402

[self._baz._import_symlink_bzr])

369

rev = branch.get_revision(self._baz._import_symlink_bzr)

403

rev = branch.repository.get_revision(self._baz._import_symlink_bzr)

370

404

# and again.

371

405

import_version('output2', pybaz.Version(self._baz._import_symlink),

372

406

self.collect)

373

407

branch2 = Branch.open('output2')

374

408

self.assertEqual(branch.revision_history(), branch2.revision_history())

375

rev2 = branch2.get_revision(self._baz._import_symlink_bzr)

409

rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)

376

410

# they must be the same

377

411

self.assertEqual(rev, rev2)

378

412

382

416

self.assertEqual(rev.revision_id, self._baz._import_symlink_bzr)

383

417

384

418

# and we want the symlink alink with target 'missing-file-name'

385

inv = branch.get_inventory(rev.revision_id)

419

inv = branch.repository.get_inventory(rev.revision_id)

386

420

self.assertEqual(inv.path2id('alink'), 'x_symlink_tag')

387

421

entry = inv['x_symlink_tag']

388

422

self.assertEqual(entry.kind, 'symlink')

398

432

branch = Branch.open('output')

399

433

self.assertEqual(branch.revision_history(),

400

434

[self._baz._missing_ancestor_bzr])

401

rev = branch.get_revision(self._baz._missing_ancestor_bzr)

435

rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)

402

436

# and again.

403

437

import_version('output2', pybaz.Version(self._baz._missing_ancestor),

404

438

self.collect)

405

439

branch2 = Branch.open('output2')

406

440

self.assertEqual(branch.revision_history(), branch2.revision_history())

407

rev2 = branch2.get_revision(self._baz._missing_ancestor_bzr)

441

rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)

408

442

# they must be the same

409

443

self.assertEqual(rev, rev2)

410

444

411

445

# and we should get some expected values:

412

446

self.assertEqual(rev.committer, "Test User<test@example.org>")

413

self.assertEqual(rev.message, "tag of demo-gone@DONOTUSE/c--import--0--base-0")

447

self.assertEqual(rev.message,

448

"tag of demo-gone@DONOTUSE/c--import--0--base-0")

414

449

self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)

415

450

self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)

416

451

self.assertEqual(1, len(rev.parent_ids))

417

452

418

453

# must NOT be able to get the merged evision

419

self.assertRaises(NoSuchRevision, branch.get_revision,

454

self.assertRaises(NoSuchRevision, branch.repository.get_revision,

420

455

self._baz._missing_import_bzr)

421

456

422

457

def test_missing_ancestor_reusing_history(self):

431

466

self.assertEqual(branch.revision_history(),

432

467

[self._baz._missing_import_bzr,

433

468

self._baz._missing_ancestor_bzr])

434

rev = branch.get_revision(self._baz._missing_ancestor_bzr)

469

rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)

435

470

# and again.

436

471

import_version('output2', pybaz.Version(self._baz._missing_ancestor),

437

472

self.collect,

438

473

reuse_history_from=[self._baz._missing_import_imported])

439

474

branch2 = Branch.open('output2')

440

475

self.assertEqual(branch.revision_history(), branch2.revision_history())

441

rev2 = branch2.get_revision(self._baz._missing_ancestor_bzr)

476

rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)

442

477

# they must be the same

443

478

self.assertEqual(rev, rev2)

444

479

445

480

# must be able to get the missing base revision

446

branch.get_revision(self._baz._missing_import_bzr)

481

branch.repository.get_revision(self._baz._missing_import_bzr)

447

482

448

483

# and we should get some expected values:

449

484

self.assertEqual(rev.committer, "Test User<test@example.org>")

450

self.assertEqual(rev.message, "tag of demo-gone@DONOTUSE/c--import--0--base-0")

485

self.assertEqual(rev.message,

486

"tag of demo-gone@DONOTUSE/c--import--0--base-0")

451

487

self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)

452

488

self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)

453

489

self.assertEqual(1, len(rev.parent_ids))

465

501

['Arch-1:demo@DONOTUSE%c--import--0--base-0',

466

502

self._baz._bad_id_tag_bzr_base,

467

503

self._baz._bad_id_tag_bzr])

468

rev = branch.get_revision(self._baz._bad_id_tag_bzr)

469

inv = branch.get_inventory(self._baz._bad_id_tag_bzr)

504

rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)

505

inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)

470

506

self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')

471

507

self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))

472

508

496

532

['Arch-1:demo@DONOTUSE%c--import--0--base-0',

497

533

self._baz._bad_id_tag_bzr_base,

498

534

self._baz._bad_id_tag_bzr])

499

rev = branch.get_revision(self._baz._bad_id_tag_bzr)

500

inv = branch.get_inventory(self._baz._bad_id_tag_bzr)

535

rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)

536

inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)

501

537

self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')

502

538

self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))

503

539

528

564

['Arch-1:demo@DONOTUSE%c--import--0--base-0',

529

565

self._baz._bad_id_tag_bzr_base,

530

566

self._baz._bad_id_tag_bzr])

531

rev = branch.get_revision(self._baz._bad_id_tag_bzr)

532

inv = branch.get_inventory(self._baz._bad_id_tag_bzr)

567

rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)

568

inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)

533

569

self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')

534

570

self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))

535

571

572

def test_inbranch_conversion(self):

573

import_version('output', pybaz.Version(self._baz._inbranch_tag),

574

self.collect)

575

# expected results:

576

# three commits, no files, revision identifiers of

577

# 'demo@DONOTUSE_c--import--0--base-0' and

578

# self._baz._inbranch_tag_base_bzr

579

# self._baz._inbranch_tag_head_bzr

580

# with no merges.

581

branch = Branch.open('output')

582

self.assertEqual(branch.revision_history(),

583

['Arch-1:demo@DONOTUSE%c--import--0--base-0',

584

self._baz._inbranch_tag_base_bzr,

585

self._baz._inbranch_tag_head_bzr])

586

# and again.

587

import_version('output2', pybaz.Version(self._baz._inbranch_tag),

588

self.collect)

589

branch2 = Branch.open('output2')

590

591

self.assertEqual(branch.revision_history(), branch2.revision_history())

592

# check revisions in the history.

593

rev = branch.repository.get_revision(self._baz._inbranch_tag_base_bzr)

594

rev2 = branch2.repository.get_revision(self._baz._inbranch_tag_base_bzr)

595

# they must be the same

596

self.assertEqual(rev, rev2)

597

# and we should get some expected values:

598

self.assertEqual(rev.committer, "Test User<test@example.org>")

599

self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")

600

self.assertEqual(rev.revision_id, self._baz._inbranch_tag_base_bzr)

601

602

# check next revisions in the history.

603

rev = branch.repository.get_revision(self._baz._inbranch_tag_head_bzr)

604

rev2 = branch2.repository.get_revision(self._baz._inbranch_tag_head_bzr)

605

# they must be the same

606

self.assertEqual(rev, rev2)

607

# and we should get some expected values:

608

self.assertEqual(rev.committer, "Test User<test@example.org>")

609

self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--inbranch-tag--0--base-0")

610

self.assertEqual(rev.revision_id, self._baz._inbranch_tag_head_bzr)

611

self.assertEqual(rev.parent_ids,

612

[self._baz._inbranch_tag_base_bzr])

613

536

614

537

615

class TestNamespacePrevious(TestCase):

538

616

600

678

os.mkdir(self._homedir)

601

679

os.environ['HOME'] = self._homedir

602

680

self._archiveroot = os.path.join(self._tmpdir, 'archive')

603

self._archive = pybaz.make_archive('demo@DONOTUSE',

604

str(self._archiveroot))

681

self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))

605

682

606

683

def tearDown(self):

607

684

os.environ['HOME'] = self._oldhome

611

688

def make_import(self, namespace):

612

689

self._import = 'demo@DONOTUSE/%s' % namespace

613

690

os.mkdir(os.path.join(self._tmpdir, 'tree'))

614

tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)

691

tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),

692

self._import)

615

693

msg = tree.log_message()

616

694

msg["summary"] = "I am importing now"

617

695

tree.import_(msg)

624

702

command = cmd_baz_import()

625

703

command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')

626

704

self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))

627

self.assertEqual(1,

628

len(list(os.walk(os.path.join(self._tmpdir,'output')))))

705

walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))

706

self.assertEqual(6, walk_len)

629

707

630

708

def test_two_branches(self):

631

709

self.make_import('c--0')

633

711

command = cmd_baz_import()

634

712

command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')

635

713

self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))

636

self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 'c','+trunk')))

637

self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 'c1', '0.2','branch')))

638

self.assertEqual(14,

639

len(list(os.walk(os.path.join(self._tmpdir,'output')))))

714

self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output',

715

'c','+trunk')))

716

self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output',

717

'c1', '0.2','branch')))

718

walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))

719

self.assertEqual(17, walk_len)

640

720

641

721

def test_run_twice(self):

642

722

self.make_import('c--0')