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

376

index = self.make_index()

377

# reset the transport log

378

del index._transport._activity[:]

379

# do a lookup_keys_via_location call for the middle of the file, which

379

# do a _lookup_keys_via_location call for the middle of the file, which

380

# is what bisection uses.

381

result = index.lookup_keys_via_location(

381

result = index._lookup_keys_via_location(

382

[(index._size // 2, ('missing', ))])

383

# this should have asked for a readv request, with adjust_for_latency,

384

# and two regions: the header, and half-way into the file.

403

index = self.make_index(nodes=[(('name', ), 'data', ())])

404

# reset the transport log

405

del index._transport._activity[:]

406

result = index.lookup_keys_via_location(

406

result = index._lookup_keys_via_location(

407

[(index._size // 2, ('missing', ))])

408

# this should have asked for a readv request, with adjust_for_latency,

409

# and two regions: the header, and half-way into the file.

428

for counter in range(64):

429

nodes.append((make_key(counter), 'Y'*100, ()))

430

index = self.make_index(nodes=nodes)

431

result = index.lookup_keys_via_location(

431

result = index._lookup_keys_via_location(

432

[(index._size // 2, ('40', ))])

433

# and the result should be that the key cannot be present, because key is

434

# in the middle of the observed data from a 4K read - the smallest transport

463

for counter in range(128):

464

nodes.append((make_key(counter), make_value(counter), ()))

465

index = self.make_index(nodes=nodes)

466

result = index.lookup_keys_via_location(

466

result = index._lookup_keys_via_location(

467

[(index._size // 2, ('40', ))])

468

# and we should have a parse map that includes the header and the

469

# region that was parsed after trimming.

471

self.assertEqual([(None, make_key(116)), (make_key(35), make_key(51))],

472

index._parsed_key_map)

473

# now ask for two keys, right before and after the parsed region

474

result = index.lookup_keys_via_location(

474

result = index._lookup_keys_via_location(

475

[(11450, make_key(34)), (15534, make_key(52))])

476

self.assertEqual([

477

((11450, make_key(34)), (index, make_key(34), make_value(34))),

490

nodes.append((make_key(counter), 'Y'*100, ()))

491

index = self.make_index(nodes=nodes)

492

# lookup the keys in the middle of the file

493

result =index.lookup_keys_via_location(

493

result =index._lookup_keys_via_location(

494

[(index._size // 2, ('40', ))])

495

# check the parse map, this determines the test validity

496

self.assertEqual([(0, 3972), (5001, 8914)], index._parsed_byte_map)

503

# be in the index) - even when the byte location we ask for is outside

504

# the parsed region

505

#

506

result = index.lookup_keys_via_location(

506

result = index._lookup_keys_via_location(

507

[(4000, ('40', ))])

508

self.assertEqual([((4000, ('40', )), False)],

509

result)

521

nodes.append((make_key(counter), make_value(counter), ()))

522

index = self.make_index(nodes=nodes)

523

# lookup the keys in the middle of the file

524

result =index.lookup_keys_via_location(

524

result =index._lookup_keys_via_location(

525

[(index._size // 2, ('40', ))])

526

# check the parse map, this determines the test validity

527

self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)

534

# be in the index) - even when the byte location we ask for is outside

535

# the parsed region

536

#

537

result = index.lookup_keys_via_location([(4000, make_key(40))])

537

result = index._lookup_keys_via_location([(4000, make_key(40))])

538

self.assertEqual(

539

[((4000, make_key(40)), (index, make_key(40), make_value(40)))],

540

result)

551

index = self.make_index(nodes=nodes)

552

# ask for the key in the middle, but a key that is located in the

553

# unparsed region before the middle.

554

result =index.lookup_keys_via_location(

554

result =index._lookup_keys_via_location(

555

[(index._size // 2, ('30', ))])

556

# check the parse map, this determines the test validity

557

self.assertEqual([(0, 3972), (5001, 8914)], index._parsed_byte_map)

571

index = self.make_index(nodes=nodes)

572

# ask for the key in the middle, but a key that is located in the

573

# unparsed region after the middle.

574

result =index.lookup_keys_via_location(

574

result =index._lookup_keys_via_location(

575

[(index._size // 2, ('50', ))])

576

# check the parse map, this determines the test validity

577

self.assertEqual([(0, 3972), (5001, 8914)], index._parsed_byte_map)

594

index = self.make_index(ref_lists=1, nodes=nodes)

595

# lookup a key in the middle that does not exist, so that when we can

596

# check that the referred-to-keys are not accessed automatically.

597

result =index.lookup_keys_via_location(

597

result =index._lookup_keys_via_location(

598

[(index._size // 2, ('40', ))])

599

# check the parse map - only the start and middle should have been

600

# parsed.

609

del index._transport._activity[:]

610

# now looking up a key in the portion of the file already parsed should

611

# only perform IO to resolve its key references.

612

result = index.lookup_keys_via_location([(4000, make_key(40))])

612

result = index._lookup_keys_via_location([(4000, make_key(40))])

613

self.assertEqual(

614

[((4000, make_key(40)),

615

(index, make_key(40), make_value(40), ((make_key(60),),)))],