215
208
class TestSerializer(TestCase):
216
209
"""Test XML serialization"""
211
def test_canned_inventory(self):
212
"""Test unpacked a canned inventory v4 file."""
213
inp = StringIO(_working_inventory_v4)
214
inv = serializer_v4.read_inventory(inp)
215
self.assertEqual(len(inv), 4)
216
self.assert_('bar-20050901064931-73b4b1138abc9cd2' in inv)
218
def test_unpack_revision(self):
219
"""Test unpacking a canned revision v4"""
220
inp = StringIO(_revision_v4)
221
rev = serializer_v4.read_revision(inp)
222
eq = self.assertEqual
224
"Martin Pool <mbp@sourcefrog.net>")
226
"mbp@sourcefrog.net-20050905080035-e0439293f8b6b9f9")
227
eq(len(rev.parent_ids), 1)
228
eq(rev.parent_ids[0],
229
"mbp@sourcefrog.net-20050905063503-43948f59fa127d92")
218
231
def test_unpack_revision_5(self):
219
232
"""Test unpacking a canned revision v5"""
220
inp = BytesIO(_revision_v5)
221
rev = breezy.bzr.xml5.serializer_v5.read_revision(inp)
233
inp = StringIO(_revision_v5)
234
rev = bzrlib.xml5.serializer_v5.read_revision(inp)
222
235
eq = self.assertEqual
223
236
eq(rev.committer,
224
237
"Martin Pool <mbp@sourcefrog.net>")
225
238
eq(len(rev.parent_ids), 1)
226
239
eq(rev.timezone, 36000)
227
240
eq(rev.parent_ids[0],
228
b"mbp@sourcefrog.net-20050905063503-43948f59fa127d92")
241
"mbp@sourcefrog.net-20050905063503-43948f59fa127d92")
230
243
def test_unpack_revision_5_utc(self):
231
inp = BytesIO(_revision_v5_utc)
232
rev = breezy.bzr.xml5.serializer_v5.read_revision(inp)
244
inp = StringIO(_revision_v5_utc)
245
rev = bzrlib.xml5.serializer_v5.read_revision(inp)
233
246
eq = self.assertEqual
234
247
eq(rev.committer,
235
248
"Martin Pool <mbp@sourcefrog.net>")
236
249
eq(len(rev.parent_ids), 1)
237
250
eq(rev.timezone, 0)
238
251
eq(rev.parent_ids[0],
239
b"mbp@sourcefrog.net-20050905063503-43948f59fa127d92")
252
"mbp@sourcefrog.net-20050905063503-43948f59fa127d92")
241
254
def test_unpack_inventory_5(self):
242
255
"""Unpack canned new-style inventory"""
243
inp = BytesIO(_committed_inv_v5)
244
inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
256
inp = StringIO(_committed_inv_v5)
257
inv = bzrlib.xml5.serializer_v5.read_inventory(inp)
245
258
eq = self.assertEqual
247
ie = inv.get_entry(b'bar-20050824000535-6bc48cfad47ed134')
260
ie = inv['bar-20050824000535-6bc48cfad47ed134']
248
261
eq(ie.kind, 'file')
249
eq(ie.revision, b'mbp@foo-00')
262
eq(ie.revision, 'mbp@foo-00')
250
263
eq(ie.name, 'bar')
251
eq(inv.get_entry(ie.parent_id).kind, 'directory')
264
eq(inv[ie.parent_id].kind, 'directory')
253
266
def test_unpack_basis_inventory_5(self):
254
267
"""Unpack canned new-style inventory"""
255
inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
256
breezy.osutils.split_lines(_basis_inv_v5))
268
inp = StringIO(_basis_inv_v5)
269
inv = bzrlib.xml5.serializer_v5.read_inventory(inp)
257
270
eq = self.assertEqual
260
b'mbp@sourcefrog.net-20050905063503-43948f59fa127d92')
261
ie = inv.get_entry(b'bar-20050824000535-6bc48cfad47ed134')
272
eq(inv.revision_id, 'mbp@sourcefrog.net-20050905063503-43948f59fa127d92')
273
ie = inv['bar-20050824000535-6bc48cfad47ed134']
262
274
eq(ie.kind, 'file')
263
eq(ie.revision, b'mbp@foo-00')
275
eq(ie.revision, 'mbp@foo-00')
264
276
eq(ie.name, 'bar')
265
eq(inv.get_entry(ie.parent_id).kind, 'directory')
277
eq(inv[ie.parent_id].kind, 'directory')
267
279
def test_unpack_inventory_5a(self):
268
inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
269
breezy.osutils.split_lines(_inventory_v5a), revision_id=b'test-rev-id')
270
self.assertEqual(b'test-rev-id', inv.root.revision)
272
def test_unpack_inventory_5a_cache_and_copy(self):
273
# Passing an entry_cache should get populated with the objects
274
# But the returned objects should be copies if return_from_cache is
276
entry_cache = fifo_cache.FIFOCache()
277
inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
278
breezy.osutils.split_lines(_inventory_v5a), revision_id=b'test-rev-id',
279
entry_cache=entry_cache, return_from_cache=False)
280
for entry in inv.iter_just_entries():
281
key = (entry.file_id, entry.revision)
282
if entry.file_id is inv.root.file_id:
283
# The root id is inferred for xml v5
284
self.assertFalse(key in entry_cache)
286
self.assertIsNot(entry, entry_cache[key])
288
def test_unpack_inventory_5a_cache_no_copy(self):
289
# Passing an entry_cache should get populated with the objects
290
# The returned objects should be exact if return_from_cache is
292
entry_cache = fifo_cache.FIFOCache()
293
inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
294
breezy.osutils.split_lines(_inventory_v5a), revision_id=b'test-rev-id',
295
entry_cache=entry_cache, return_from_cache=True)
296
for entry in inv.iter_just_entries():
297
key = (entry.file_id, entry.revision)
298
if entry.file_id is inv.root.file_id:
299
# The root id is inferred for xml v5
300
self.assertFalse(key in entry_cache)
302
self.assertIs(entry, entry_cache[key])
280
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(
281
_inventory_v5a, revision_id='test-rev-id')
282
self.assertEqual('test-rev-id', inv.root.revision)
304
284
def test_unpack_inventory_5b(self):
305
inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
306
breezy.osutils.split_lines(_inventory_v5b), revision_id=b'test-rev-id')
307
self.assertEqual(b'a-rev-id', inv.root.revision)
285
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(
286
_inventory_v5b, revision_id='test-rev-id')
287
self.assertEqual('a-rev-id', inv.root.revision)
309
289
def test_repack_inventory_5(self):
310
inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
311
breezy.osutils.split_lines(_committed_inv_v5))
313
breezy.bzr.xml5.serializer_v5.write_inventory(inv, outp)
290
inp = StringIO(_committed_inv_v5)
291
inv = bzrlib.xml5.serializer_v5.read_inventory(inp)
293
bzrlib.xml5.serializer_v5.write_inventory(inv, outp)
314
294
self.assertEqualDiff(_expected_inv_v5, outp.getvalue())
315
inv2 = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
316
breezy.osutils.split_lines(outp.getvalue()))
295
inv2 = bzrlib.xml5.serializer_v5.read_inventory(StringIO(outp.getvalue()))
317
296
self.assertEqual(inv, inv2)
319
298
def assertRoundTrips(self, xml_string):
320
inp = BytesIO(xml_string)
321
inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
323
breezy.bzr.xml5.serializer_v5.write_inventory(inv, outp)
299
inp = StringIO(xml_string)
300
inv = bzrlib.xml5.serializer_v5.read_inventory(inp)
302
bzrlib.xml5.serializer_v5.write_inventory(inv, outp)
324
303
self.assertEqualDiff(xml_string, outp.getvalue())
325
lines = breezy.bzr.xml5.serializer_v5.write_inventory_to_lines(inv)
304
lines = bzrlib.xml5.serializer_v5.write_inventory_to_lines(inv)
327
306
self.assertEqual(outp.readlines(), lines)
328
inv2 = breezy.bzr.xml5.serializer_v5.read_inventory(
329
BytesIO(outp.getvalue()))
307
inv2 = bzrlib.xml5.serializer_v5.read_inventory(StringIO(outp.getvalue()))
330
308
self.assertEqual(inv, inv2)
332
310
def tests_serialize_inventory_v5_with_root(self):
351
330
def test_pack_revision_5(self):
352
331
"""Pack revision to XML v5"""
353
332
# fixed 20051025, revisions should have final newline
354
rev = breezy.bzr.xml5.serializer_v5.read_revision_from_string(
356
outfile_contents = breezy.bzr.xml5.serializer_v5.write_revision_to_string(rev)
357
self.assertEqual(outfile_contents[-1:], b'\n')
358
self.assertEqualDiff(
360
b''.join(breezy.bzr.xml5.serializer_v5.write_revision_to_lines(rev)))
333
rev = bzrlib.xml5.serializer_v5.read_revision_from_string(_revision_v5)
335
bzrlib.xml5.serializer_v5.write_revision(rev, outp)
336
outfile_contents = outp.getvalue()
337
self.assertEqual(outfile_contents[-1], '\n')
338
self.assertEqualDiff(outfile_contents, bzrlib.xml5.serializer_v5.write_revision_to_string(rev))
361
339
self.assertEqualDiff(outfile_contents, _expected_rev_v5)
363
341
def test_empty_property_value(self):
364
342
"""Create an empty property value check that it serializes correctly"""
365
s_v5 = breezy.bzr.xml5.serializer_v5
343
s_v5 = bzrlib.xml5.serializer_v5
366
344
rev = s_v5.read_revision_from_string(_revision_v5)
367
props = {'empty': '', 'one': 'one'}
346
props = {'empty':'', 'one':'one'}
368
347
rev.properties = props
369
txt = b''.join(s_v5.write_revision_to_lines(rev))
348
txt = s_v5.write_revision_to_string(rev)
370
349
new_rev = s_v5.read_revision_from_string(txt)
371
350
self.assertEqual(props, new_rev.properties)
373
352
def get_sample_inventory(self):
374
inv = Inventory(b'tree-root-321', revision_id=b'rev_outer')
375
inv.add(inventory.InventoryFile(b'file-id', 'file', b'tree-root-321'))
376
inv.add(inventory.InventoryDirectory(b'dir-id', 'dir',
378
inv.add(inventory.InventoryLink(b'link-id', 'link', b'tree-root-321'))
379
inv.get_entry(b'tree-root-321').revision = b'rev_outer'
380
inv.get_entry(b'dir-id').revision = b'rev_outer'
381
inv.get_entry(b'file-id').revision = b'rev_outer'
382
inv.get_entry(b'file-id').text_sha1 = b'A'
383
inv.get_entry(b'file-id').text_size = 1
384
inv.get_entry(b'link-id').revision = b'rev_outer'
385
inv.get_entry(b'link-id').symlink_target = 'a'
353
inv = Inventory('tree-root-321', revision_id='rev_outer')
354
inv.add(inventory.InventoryFile('file-id', 'file', 'tree-root-321'))
355
inv.add(inventory.InventoryDirectory('dir-id', 'dir',
357
inv.add(inventory.InventoryLink('link-id', 'link', 'tree-root-321'))
358
inv['tree-root-321'].revision = 'rev_outer'
359
inv['dir-id'].revision = 'rev_outer'
360
inv['file-id'].revision = 'rev_outer'
361
inv['file-id'].text_sha1 = 'A'
362
inv['file-id'].text_size = 1
363
inv['link-id'].revision = 'rev_outer'
364
inv['link-id'].symlink_target = 'a'
388
367
def test_roundtrip_inventory_v7(self):
389
368
inv = self.get_sample_inventory()
390
inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
391
b'rev_outer', b'rev_inner'))
369
inv.add(inventory.TreeReference('nested-id', 'nested', 'tree-root-321',
370
'rev_outer', 'rev_inner'))
371
txt = xml7.serializer_v7.write_inventory_to_string(inv)
392
372
lines = xml7.serializer_v7.write_inventory_to_lines(inv)
393
self.assertEqualDiff(_expected_inv_v7, b''.join(lines))
394
inv2 = xml7.serializer_v7.read_inventory_from_lines(lines)
373
self.assertEqual(bzrlib.osutils.split_lines(txt), lines)
374
self.assertEqualDiff(_expected_inv_v7, txt)
375
inv2 = xml7.serializer_v7.read_inventory_from_string(txt)
395
376
self.assertEqual(5, len(inv2))
396
377
for path, ie in inv.iter_entries():
397
self.assertEqual(ie, inv2.get_entry(ie.file_id))
399
def test_roundtrip_inventory_v6(self):
400
inv = self.get_sample_inventory()
401
lines = xml6.serializer_v6.write_inventory_to_lines(inv)
402
self.assertEqualDiff(_expected_inv_v6, b''.join(lines))
403
inv2 = xml6.serializer_v6.read_inventory_from_lines(lines)
404
self.assertEqual(4, len(inv2))
405
for path, ie in inv.iter_entries():
406
self.assertEqual(ie, inv2.get_entry(ie.file_id))
378
self.assertEqual(ie, inv2[ie.file_id])
408
380
def test_wrong_format_v7(self):
409
381
"""Can't accidentally open a file with wrong serializer"""
410
s_v6 = breezy.bzr.xml6.serializer_v6
382
s_v6 = bzrlib.xml6.serializer_v6
411
383
s_v7 = xml7.serializer_v7
412
384
self.assertRaises(errors.UnexpectedInventoryFormat,
413
s_v7.read_inventory_from_lines,
414
breezy.osutils.split_lines(_expected_inv_v5))
385
s_v7.read_inventory_from_string, _expected_inv_v5)
415
386
self.assertRaises(errors.UnexpectedInventoryFormat,
416
s_v6.read_inventory_from_lines,
417
breezy.osutils.split_lines(_expected_inv_v7))
387
s_v6.read_inventory_from_string, _expected_inv_v7)
419
389
def test_tree_reference(self):
420
s_v5 = breezy.bzr.xml5.serializer_v5
421
s_v6 = breezy.bzr.xml6.serializer_v6
390
s_v5 = bzrlib.xml5.serializer_v5
391
s_v6 = bzrlib.xml6.serializer_v6
422
392
s_v7 = xml7.serializer_v7
423
inv = Inventory(b'tree-root-321', revision_id=b'rev-outer')
424
inv.root.revision = b'root-rev'
425
inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
426
b'rev-outer', b'rev-inner'))
427
self.assertRaises(errors.UnsupportedInventoryKind,
428
s_v5.write_inventory_to_lines, inv)
429
self.assertRaises(errors.UnsupportedInventoryKind,
430
s_v6.write_inventory_to_lines, inv)
431
lines = s_v7.write_inventory_to_chunks(inv)
432
inv2 = s_v7.read_inventory_from_lines(lines)
433
self.assertEqual(b'tree-root-321',
434
inv2.get_entry(b'nested-id').parent_id)
435
self.assertEqual(b'rev-outer', inv2.get_entry(b'nested-id').revision)
437
b'rev-inner', inv2.get_entry(b'nested-id').reference_revision)
393
inv = Inventory('tree-root-321', revision_id='rev-outer')
394
inv.root.revision = 'root-rev'
395
inv.add(inventory.TreeReference('nested-id', 'nested', 'tree-root-321',
396
'rev-outer', 'rev-inner'))
397
self.assertRaises(errors.UnsupportedInventoryKind,
398
s_v5.write_inventory_to_string, inv)
399
self.assertRaises(errors.UnsupportedInventoryKind,
400
s_v6.write_inventory_to_string, inv)
401
txt = s_v7.write_inventory_to_string(inv)
402
lines = s_v7.write_inventory_to_lines(inv)
403
self.assertEqual(bzrlib.osutils.split_lines(txt), lines)
404
inv2 = s_v7.read_inventory_from_string(txt)
405
self.assertEqual('tree-root-321', inv2['nested-id'].parent_id)
406
self.assertEqual('rev-outer', inv2['nested-id'].revision)
407
self.assertEqual('rev-inner', inv2['nested-id'].reference_revision)
408
self.assertRaises(errors.UnsupportedInventoryKind,
409
s_v6.read_inventory_from_string,
410
txt.replace('format="7"', 'format="6"'))
411
self.assertRaises(errors.UnsupportedInventoryKind,
412
s_v5.read_inventory_from_string,
413
txt.replace('format="7"', 'format="5"'))
439
415
def test_roundtrip_inventory_v8(self):
440
416
inv = self.get_sample_inventory()
441
lines = xml8.serializer_v8.write_inventory_to_lines(inv)
442
inv2 = xml8.serializer_v8.read_inventory_from_lines(lines)
417
txt = xml8.serializer_v8.write_inventory_to_string(inv)
418
inv2 = xml8.serializer_v8.read_inventory_from_string(txt)
443
419
self.assertEqual(4, len(inv2))
444
420
for path, ie in inv.iter_entries():
445
self.assertEqual(ie, inv2.get_entry(ie.file_id))
421
self.assertEqual(ie, inv2[ie.file_id])
447
423
def test_inventory_text_v8(self):
448
424
inv = self.get_sample_inventory()
425
txt = xml8.serializer_v8.write_inventory_to_string(inv)
449
426
lines = xml8.serializer_v8.write_inventory_to_lines(inv)
450
self.assertEqualDiff(_expected_inv_v8, b''.join(lines))
427
self.assertEqual(bzrlib.osutils.split_lines(txt), lines)
428
self.assertEqualDiff(_expected_inv_v8, txt)
452
430
def test_revision_text_v6(self):
453
431
"""Pack revision to XML v6"""
454
rev = breezy.bzr.xml6.serializer_v6.read_revision_from_string(
432
rev = bzrlib.xml6.serializer_v6.read_revision_from_string(
455
433
_expected_rev_v5)
456
serialized = breezy.bzr.xml6.serializer_v6.write_revision_to_lines(
458
self.assertEqualDiff(b''.join(serialized), _expected_rev_v5)
434
serialized = bzrlib.xml6.serializer_v6.write_revision_to_string(rev)
435
self.assertEqualDiff(serialized, _expected_rev_v5)
460
437
def test_revision_text_v7(self):
461
438
"""Pack revision to XML v7"""
462
rev = breezy.bzr.xml7.serializer_v7.read_revision_from_string(
439
rev = bzrlib.xml7.serializer_v7.read_revision_from_string(
463
440
_expected_rev_v5)
464
serialized = breezy.bzr.xml7.serializer_v7.write_revision_to_lines(
466
self.assertEqualDiff(b''.join(serialized), _expected_rev_v5)
441
serialized = bzrlib.xml7.serializer_v7.write_revision_to_string(rev)
442
self.assertEqualDiff(serialized, _expected_rev_v5)
468
444
def test_revision_text_v8(self):
469
445
"""Pack revision to XML v8"""
470
rev = breezy.bzr.xml8.serializer_v8.read_revision_from_string(
446
rev = bzrlib.xml8.serializer_v8.read_revision_from_string(
471
447
_expected_rev_v8)
472
serialized = breezy.bzr.xml8.serializer_v8.write_revision_to_lines(
474
self.assertEqualDiff(b''.join(serialized), _expected_rev_v8)
476
def test_revision_text_v8_complex(self):
477
"""Pack revision to XML v8"""
478
rev = breezy.bzr.xml8.serializer_v8.read_revision_from_string(
479
_expected_rev_v8_complex)
480
serialized = breezy.bzr.xml8.serializer_v8.write_revision_to_lines(
482
self.assertEqualDiff(b''.join(serialized), _expected_rev_v8_complex)
448
serialized = bzrlib.xml8.serializer_v8.write_revision_to_string(rev)
449
self.assertEqualDiff(serialized, _expected_rev_v8)
484
451
def test_revision_ids_are_utf8(self):
485
452
"""Parsed revision_ids should all be utf-8 strings, not unicode."""
486
s_v5 = breezy.bzr.xml5.serializer_v5
453
s_v5 = bzrlib.xml5.serializer_v5
487
454
rev = s_v5.read_revision_from_string(_revision_utf8_v5)
488
self.assertEqual(b'erik@b\xc3\xa5gfors-02', rev.revision_id)
489
self.assertIsInstance(rev.revision_id, bytes)
490
self.assertEqual([b'erik@b\xc3\xa5gfors-01'], rev.parent_ids)
455
self.assertEqual('erik@b\xc3\xa5gfors-02', rev.revision_id)
456
self.assertIsInstance(rev.revision_id, str)
457
self.assertEqual(['erik@b\xc3\xa5gfors-01'], rev.parent_ids)
491
458
for parent_id in rev.parent_ids:
492
self.assertIsInstance(parent_id, bytes)
459
self.assertIsInstance(parent_id, str)
493
460
self.assertEqual(u'Include \xb5nicode characters\n', rev.message)
494
self.assertIsInstance(rev.message, text_type)
461
self.assertIsInstance(rev.message, unicode)
496
463
# ie.revision should either be None or a utf-8 revision id
497
inv = s_v5.read_inventory_from_lines(breezy.osutils.split_lines(_inventory_utf8_v5))
464
inv = s_v5.read_inventory_from_string(_inventory_utf8_v5)
498
465
rev_id_1 = u'erik@b\xe5gfors-01'.encode('utf8')
499
466
rev_id_2 = u'erik@b\xe5gfors-02'.encode('utf8')
500
467
fid_root = u'TRE\xe9_ROOT'.encode('utf8')
505
472
(u'b\xe5r', fid_bar1, fid_root, rev_id_1),
506
473
(u's\xb5bdir', fid_sub, fid_root, rev_id_1),
507
474
(u's\xb5bdir/b\xe5r', fid_bar2, fid_sub, rev_id_2),
509
476
self.assertEqual(rev_id_2, inv.revision_id)
510
self.assertIsInstance(inv.revision_id, bytes)
477
self.assertIsInstance(inv.revision_id, str)
512
479
actual = list(inv.iter_entries_by_dir())
513
480
for ((exp_path, exp_file_id, exp_parent_id, exp_rev_id),
514
481
(act_path, act_ie)) in zip(expected, actual):
515
482
self.assertEqual(exp_path, act_path)
516
self.assertIsInstance(act_path, text_type)
483
self.assertIsInstance(act_path, unicode)
517
484
self.assertEqual(exp_file_id, act_ie.file_id)
518
self.assertIsInstance(act_ie.file_id, bytes)
485
self.assertIsInstance(act_ie.file_id, str)
519
486
self.assertEqual(exp_parent_id, act_ie.parent_id)
520
487
if exp_parent_id is not None:
521
self.assertIsInstance(act_ie.parent_id, bytes)
488
self.assertIsInstance(act_ie.parent_id, str)
522
489
self.assertEqual(exp_rev_id, act_ie.revision)
523
490
if exp_rev_id is not None:
524
self.assertIsInstance(act_ie.revision, bytes)
491
self.assertIsInstance(act_ie.revision, str)
526
493
self.assertEqual(len(expected), len(actual))
528
def test_serialization_error(self):
529
s_v5 = breezy.bzr.xml5.serializer_v5
530
e = self.assertRaises(
531
errors.UnexpectedInventoryFormat,
532
s_v5.read_inventory_from_lines, [b"<Notquitexml"])
533
self.assertEqual(str(e), "unclosed token: line 1, column 0")
536
496
class TestEncodeAndEscape(TestCase):
537
497
"""Whitebox testing of the _encode_and_escape function."""
540
super(TestEncodeAndEscape, self).setUp()
541
501
# Keep the cache clear before and after the test
542
breezy.bzr.xml_serializer._clear_cache()
543
self.addCleanup(breezy.bzr.xml_serializer._clear_cache)
502
bzrlib.xml8._ensure_utf8_re()
503
bzrlib.xml8._clear_cache()
504
self.addCleanup(bzrlib.xml8._clear_cache)
545
506
def test_simple_ascii(self):
546
507
# _encode_and_escape always appends a final ", because these parameters
547
508
# are being used in xml attributes, and by returning it now, we have to
548
509
# do fewer string operations later.
549
val = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
550
self.assertEqual(b'foo bar', val)
510
val = bzrlib.xml8._encode_and_escape('foo bar')
511
self.assertEqual('foo bar"', val)
551
512
# The second time should be cached
552
val2 = breezy.bzr.xml_serializer.encode_and_escape('foo bar')
513
val2 = bzrlib.xml8._encode_and_escape('foo bar')
553
514
self.assertIs(val2, val)
555
516
def test_ascii_with_xml(self):
556
self.assertEqual(b'&'"<>',
557
breezy.bzr.xml_serializer.encode_and_escape('&\'"<>'))
517
self.assertEqual('&'"<>"',
518
bzrlib.xml8._encode_and_escape('&\'"<>'))
559
520
def test_utf8_with_xml(self):
560
521
# u'\xb5\xe5&\u062c'
561
utf8_str = b'\xc2\xb5\xc3\xa5&\xd8\xac'
562
self.assertEqual(b'µå&ج',
563
breezy.bzr.xml_serializer.encode_and_escape(utf8_str))
522
utf8_str = '\xc2\xb5\xc3\xa5&\xd8\xac'
523
self.assertEqual('µå&ج"',
524
bzrlib.xml8._encode_and_escape(utf8_str))
565
526
def test_unicode(self):
566
527
uni_str = u'\xb5\xe5&\u062c'
567
self.assertEqual(b'µå&ج',
568
breezy.bzr.xml_serializer.encode_and_escape(uni_str))
571
class TestMisc(TestCase):
573
def test_unescape_xml(self):
574
"""We get some kind of error when malformed entities are passed"""
575
self.assertRaises(KeyError, breezy.bzr.xml8._unescape_xml, b'foo&bar;')
528
self.assertEqual('µå&ج"',
529
bzrlib.xml8._encode_and_escape(uni_str))
added
removed
bzrlib/tests/test_xml.py
