~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_rio.py

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

• reverse the comparison (1185.49.21 to 4011.6.1)
• stop comparing with revision 4011.6.1

Show diffs side-by-side

added

removed

bzrlib/tests/test_rio.py

1

 

# Copyright (C) 2005, 2006 Canonical Ltd

 

1

# Copyright (C) 2005 by Canonical Ltd

2

2

#

3

3

# This program is free software; you can redistribute it and/or modify

4

4

# it under the terms of the GNU General Public License as published by

22

22

but this depends on the transport.

23

23

"""

24

24

 

25

 

import cStringIO

26

25

import os

27

 

import re

28

26

import sys

29

27

from tempfile import TemporaryFile

30

28

 

31

 

from bzrlib import (

32

 

    rio,

33

 

    )

34

29

from bzrlib.tests import TestCaseInTempDir, TestCase

35

 

from bzrlib.rio import (RioWriter, Stanza, read_stanza, read_stanzas, rio_file,

36

 

                        RioReader)

 

30

from bzrlib.rio import RioWriter, Stanza, read_stanza, read_stanzas

37

31

 

38

32

 

39

33

class TestRio(TestCase):

70

64

                ['name: fred\n',

71

65

                 'number: 42\n'])

72

66

 

73

 

    def test_as_dict(self):

74

 

        """Convert rio Stanza to dictionary"""

75

 

        s = Stanza(number='42', name='fred')

76

 

        sd = s.as_dict()

77

 

        self.assertEquals(sd, dict(number='42', name='fred'))

78

 

 

79

67

    def test_to_file(self):

80

68

        """Write rio to file"""

81

69

        tmpf = TemporaryFile()

162

150

""")

163

151

        s2 = read_stanza(s.to_lines())

164

152

        self.assertEquals(s, s2)

165

 

        self.rio_file_stanzas([s])

166

153

 

167

154

    def test_quoted(self):

168

155

        """rio quoted string cases"""

178

165

                   )

179

166

        s2 = read_stanza(s.to_lines())

180

167

        self.assertEquals(s, s2)

181

 

        # apparent bug in read_stanza

182

 

        # s3 = read_stanza(self.stanzas_to_str([s]))

183

 

        # self.assertEquals(s, s3)

184

168

 

185

169

    def test_read_empty(self):

186

170

        """Detect end of rio file"""

238

222

        self.assertEquals(s, Stanza(name="bar", val='129319'))

239

223

        s = read_stanza(tmpf)

240

224

        self.assertEquals(s, None)

241

 

        self.check_rio_file(tmpf)

242

 

 

243

 

    def check_rio_file(self, real_file):

244

 

        real_file.seek(0)

245

 

        read_write = rio_file(RioReader(real_file)).read()

246

 

        real_file.seek(0)

247

 

        self.assertEquals(read_write, real_file.read())

248

 

 

249

 

    @staticmethod

250

 

    def stanzas_to_str(stanzas):

251

 

        return rio_file(stanzas).read()

252

 

 

253

 

    def rio_file_stanzas(self, stanzas):

254

 

        new_stanzas = list(RioReader(rio_file(stanzas)))

255

 

        self.assertEqual(new_stanzas, stanzas)

256

225

 

257

226

    def test_tricky_quoted(self):

258

227

        tmpf = TemporaryFile()

304

273

            ]

305

274

        for expected in expected_vals:

306

275

            stanza = read_stanza(tmpf)

307

 

            self.rio_file_stanzas([stanza])

308

276

            self.assertEquals(len(stanza), 1)

309

277

            self.assertEqualDiff(stanza.get('s'), expected)

310

278

 

312

280

        """Write empty stanza"""

313

281

        l = list(Stanza().to_lines())

314

282

        self.assertEquals(l, [])

315

 

 

316

 

    def test_rio_raises_type_error(self):

317

 

        """TypeError on adding invalid type to Stanza"""

318

 

        s = Stanza()

319

 

        self.assertRaises(TypeError, s.add, 'foo', {})

320

 

 

321

 

    def test_rio_raises_type_error_key(self):

322

 

        """TypeError on adding invalid type to Stanza"""

323

 

        s = Stanza()

324

 

        self.assertRaises(TypeError, s.add, 10, {})

325

 

 

326

 

    def test_rio_unicode(self):

327

 

        uni_data = u'\N{KATAKANA LETTER O}'

328

 

        s = Stanza(foo=uni_data)

329

 

        self.assertEquals(s.get('foo'), uni_data)

330

 

        raw_lines = s.to_lines()

331

 

        self.assertEquals(raw_lines,

332

 

                ['foo: ' + uni_data.encode('utf-8') + '\n'])

333

 

        new_s = read_stanza(raw_lines)

334

 

        self.assertEquals(new_s.get('foo'), uni_data)

335

 

 

336

 

    def test_rio_to_unicode(self):

337

 

        uni_data = u'\N{KATAKANA LETTER O}'

338

 

        s = Stanza(foo=uni_data)

339

 

        unicode_str = s.to_unicode()

340

 

        self.assertEqual(u'foo: %s\n' % (uni_data,), unicode_str)

341

 

        new_s = rio.read_stanza_unicode(unicode_str.splitlines(True))

342

 

        self.assertEqual(uni_data, new_s.get('foo'))

343

 

 

344

 

    def test_nested_rio_unicode(self):

345

 

        uni_data = u'\N{KATAKANA LETTER O}'

346

 

        s = Stanza(foo=uni_data)

347

 

        parent_stanza = Stanza(child=s.to_unicode())

348

 

        raw_lines = parent_stanza.to_lines()

349

 

        self.assertEqual(['child: foo: ' + uni_data.encode('utf-8') + '\n',

350

 

                          '\t\n',

351

 

                         ], raw_lines)

352

 

        new_parent = read_stanza(raw_lines)

353

 

        child_text = new_parent.get('child')

354

 

        self.assertEqual(u'foo: %s\n' % uni_data, child_text)

355

 

        new_child = rio.read_stanza_unicode(child_text.splitlines(True))

356

 

        self.assertEqual(uni_data, new_child.get('foo'))

357

 

 

358

 

    def mail_munge(self, lines, dos_nl=True):

359

 

        new_lines = []

360

 

        for line in lines:

361

 

            line = re.sub(' *\n', '\n', line)

362

 

            if dos_nl:

363

 

                line = re.sub('([^\r])\n', '\\1\r\n', line)

364

 

            new_lines.append(line)

365

 

        return new_lines

366

 

 

367

 

    def test_patch_rio(self):

368

 

        stanza = Stanza(data='#\n\r\\r ', space=' ' * 255, hash='#' * 255)

369

 

        lines = rio.to_patch_lines(stanza)

370

 

        for line in lines:

371

 

            self.assertContainsRe(line, '^# ')

372

 

            self.assertTrue(72 >= len(line))

373

 

        for line in rio.to_patch_lines(stanza, max_width=12):

374

 

            self.assertTrue(12 >= len(line))

375

 

        new_stanza = rio.read_patch_stanza(self.mail_munge(lines,

376

 

                                                           dos_nl=False))

377

 

        lines = self.mail_munge(lines)

378

 

        new_stanza = rio.read_patch_stanza(lines)

379

 

        self.assertEqual('#\n\r\\r ', new_stanza.get('data'))

380

 

        self.assertEqual(' '* 255, new_stanza.get('space'))

381

 

        self.assertEqual('#'* 255, new_stanza.get('hash'))

382

 

 

383

 

    def test_patch_rio_linebreaks(self):

384

 

        stanza = Stanza(breaktest='linebreak -/'*30)

385

 

        self.assertContainsRe(rio.to_patch_lines(stanza, 71)[0],

386

 

                              'linebreak\\\\\n')

387

 

        stanza = Stanza(breaktest='linebreak-/'*30)

388

 

        self.assertContainsRe(rio.to_patch_lines(stanza, 70)[0],

389

 

                              'linebreak-\\\\\n')

390

 

        stanza = Stanza(breaktest='linebreak/'*30)

391

 

        self.assertContainsRe(rio.to_patch_lines(stanza, 70)[0],

392

 

                              'linebreak\\\\\n')

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1