1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.directory.server.xdbm.search.impl;
21
22
23 import org.slf4j.Logger;
24 import org.slf4j.LoggerFactory;
25 import org.apache.directory.server.xdbm.Store;
26 import org.apache.directory.server.xdbm.ForwardIndexEntry;
27 import org.apache.directory.server.xdbm.IndexEntry;
28 import org.apache.directory.server.xdbm.tools.StoreUtils;
29 import org.apache.directory.server.schema.registries.*;
30 import org.apache.directory.server.schema.bootstrap.*;
31 import org.apache.directory.server.schema.SerializableComparator;
32 import org.apache.directory.server.core.partition.impl.btree.jdbm.JdbmStore;
33 import org.apache.directory.server.core.partition.impl.btree.jdbm.JdbmIndex;
34 import org.apache.directory.server.core.cursor.InvalidCursorPositionException;
35 import org.apache.directory.server.core.entry.ServerEntry;
36 import org.apache.directory.server.core.entry.DefaultServerEntry;
37 import org.apache.directory.shared.ldap.constants.SchemaConstants;
38 import org.apache.directory.shared.ldap.filter.ScopeNode;
39 import org.apache.directory.shared.ldap.filter.SearchScope;
40 import org.apache.directory.shared.ldap.message.AliasDerefMode;
41 import org.apache.directory.shared.ldap.name.LdapDN;
42 import org.apache.commons.io.FileUtils;
43 import org.junit.Before;
44 import org.junit.After;
45 import org.junit.Test;
46 import static org.junit.Assert.assertTrue;
47 import static org.junit.Assert.assertFalse;
48 import static org.junit.Assert.assertNotNull;
49 import static org.junit.Assert.assertEquals;
50
51 import java.io.File;
52 import java.util.Set;
53 import java.util.HashSet;
54
55
56
57
58
59
60
61
62 public class OneLevelScopeTest
63 {
64 public static final Logger LOG = LoggerFactory.getLogger( OneLevelScopeTest.class );
65
66
67 File wkdir;
68 Store<ServerEntry> store;
69 Registries registries = null;
70 AttributeTypeRegistry attributeRegistry;
71
72
73 public OneLevelScopeTest() throws Exception
74 {
75
76 BootstrapSchemaLoader loader = new BootstrapSchemaLoader();
77 OidRegistry oidRegistry = new DefaultOidRegistry();
78 registries = new DefaultRegistries( "bootstrap", loader, oidRegistry );
79 SerializableComparator.setRegistry( registries.getComparatorRegistry() );
80
81
82 Set<Schema> bootstrapSchemas = new HashSet<Schema>();
83 bootstrapSchemas.add( new ApachemetaSchema() );
84 bootstrapSchemas.add( new ApacheSchema() );
85 bootstrapSchemas.add( new CoreSchema() );
86 bootstrapSchemas.add( new SystemSchema() );
87 bootstrapSchemas.add( new CollectiveSchema() );
88 loader.loadWithDependencies( bootstrapSchemas, registries );
89 attributeRegistry = registries.getAttributeTypeRegistry();
90 }
91
92
93 @Before
94 public void createStore() throws Exception
95 {
96 destryStore();
97
98
99 wkdir = File.createTempFile( getClass().getSimpleName(), "db" );
100 wkdir.delete();
101 wkdir = new File( wkdir.getParentFile(), getClass().getSimpleName() );
102 wkdir.mkdirs();
103
104
105 store = new JdbmStore<ServerEntry>();
106 store.setName( "example" );
107 store.setCacheSize( 10 );
108 store.setWorkingDirectory( wkdir );
109 store.setSyncOnWrite( true );
110
111 store.addIndex( new JdbmIndex( SchemaConstants.OU_AT_OID ) );
112 store.addIndex( new JdbmIndex( SchemaConstants.CN_AT_OID ) );
113 StoreUtils.loadExampleData( store, registries );
114 LOG.debug( "Created new store" );
115 }
116
117
118 @After
119 public void destryStore() throws Exception
120 {
121 if ( store != null )
122 {
123 store.destroy();
124 }
125
126 store = null;
127 if ( wkdir != null )
128 {
129 FileUtils.deleteDirectory( wkdir );
130 }
131
132 wkdir = null;
133 }
134
135
136 @Test
137 public void testCursorNoDeref() throws Exception
138 {
139 ScopeNode node = new ScopeNode( AliasDerefMode.NEVER_DEREF_ALIASES,
140 SchemaConstants.OU_AT_OID + "=sales," +
141 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
142 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
143 OneLevelScopeCursor cursor = new OneLevelScopeCursor( store, evaluator );
144
145 assertTrue( cursor.isElementReused() );
146
147
148
149
150 cursor.beforeFirst();
151 assertFalse( cursor.available() );
152
153 assertTrue( cursor.next() );
154 assertTrue( cursor.available() );
155 IndexEntry<Long,ServerEntry> indexEntry = cursor.get();
156 assertNotNull( indexEntry );
157 assertEquals( 5L, ( long ) indexEntry.getId() );
158 assertEquals( 2L, ( long ) indexEntry.getValue() );
159
160 assertTrue( cursor.next() );
161 assertTrue( cursor.available() );
162 indexEntry = cursor.get();
163 assertNotNull( indexEntry );
164 assertEquals( 6L, ( long ) indexEntry.getId() );
165 assertEquals( 2L, ( long ) indexEntry.getValue() );
166
167 assertFalse( cursor.next() );
168 assertFalse( cursor.available() );
169
170
171
172 cursor = new OneLevelScopeCursor( store, evaluator );
173 assertFalse( cursor.available() );
174 cursor.first();
175
176 assertTrue( cursor.available() );
177 indexEntry = cursor.get();
178 assertNotNull( indexEntry );
179 assertEquals( 5L, ( long ) indexEntry.getId() );
180 assertEquals( 2L, ( long ) indexEntry.getValue() );
181
182 assertTrue( cursor.next() );
183 assertTrue( cursor.available() );
184 indexEntry = cursor.get();
185 assertNotNull( indexEntry );
186 assertEquals( 6L, ( long ) indexEntry.getId() );
187 assertEquals( 2L, ( long ) indexEntry.getValue() );
188
189 assertFalse( cursor.next() );
190 assertFalse( cursor.available() );
191
192
193
194 cursor = new OneLevelScopeCursor( store, evaluator );
195 cursor.afterLast();
196 assertFalse( cursor.available() );
197
198 assertTrue( cursor.previous() );
199 assertTrue( cursor.available() );
200 indexEntry = cursor.get();
201 assertNotNull( indexEntry );
202 assertEquals( 6L, ( long ) indexEntry.getId() );
203 assertEquals( 2L, ( long ) indexEntry.getValue() );
204
205 assertTrue( cursor.previous() );
206 assertTrue( cursor.available() );
207 indexEntry = cursor.get();
208 assertNotNull( indexEntry );
209 assertEquals( 5L, ( long ) indexEntry.getId() );
210 assertEquals( 2L, ( long ) indexEntry.getValue() );
211
212 assertFalse( cursor.previous() );
213 assertFalse( cursor.available() );
214
215
216
217 cursor = new OneLevelScopeCursor( store, evaluator );
218 assertFalse( cursor.available() );
219 cursor.last();
220
221 assertTrue( cursor.available() );
222 indexEntry = cursor.get();
223 assertNotNull( indexEntry );
224 assertEquals( 6L, ( long ) indexEntry.getId() );
225 assertEquals( 2L, ( long ) indexEntry.getValue() );
226
227 assertTrue( cursor.previous() );
228 assertTrue( cursor.available() );
229 indexEntry = cursor.get();
230 assertNotNull( indexEntry );
231 assertEquals( 5L, ( long ) indexEntry.getId() );
232 assertEquals( 2L, ( long ) indexEntry.getValue() );
233
234 assertFalse( cursor.previous() );
235 assertFalse( cursor.available() );
236
237
238
239 cursor = new OneLevelScopeCursor( store, evaluator );
240 assertFalse( cursor.available() );
241 cursor.previous();
242
243 assertTrue( cursor.available() );
244 indexEntry = cursor.get();
245 assertNotNull( indexEntry );
246 assertEquals( 6L, ( long ) indexEntry.getId() );
247 assertEquals( 2L, ( long ) indexEntry.getValue() );
248
249 assertTrue( cursor.previous() );
250 assertTrue( cursor.available() );
251 indexEntry = cursor.get();
252 assertNotNull( indexEntry );
253 assertEquals( 5L, ( long ) indexEntry.getId() );
254 assertEquals( 2L, ( long ) indexEntry.getValue() );
255
256 assertFalse( cursor.previous() );
257 assertFalse( cursor.available() );
258
259
260
261 cursor = new OneLevelScopeCursor( store, evaluator );
262 assertFalse( cursor.available() );
263 cursor.next();
264
265 assertTrue( cursor.available() );
266 indexEntry = cursor.get();
267 assertNotNull( indexEntry );
268 assertEquals( 5L, ( long ) indexEntry.getId() );
269 assertEquals( 2L, ( long ) indexEntry.getValue() );
270
271 assertTrue( cursor.next() );
272 assertTrue( cursor.available() );
273 indexEntry = cursor.get();
274 assertNotNull( indexEntry );
275 assertEquals( 6L, ( long ) indexEntry.getId() );
276 assertEquals( 2L, ( long ) indexEntry.getValue() );
277
278 assertFalse( cursor.next() );
279 assertFalse( cursor.available() );
280 }
281
282
283 @Test
284 public void testCursorNoDerefReturnAliases() throws Exception
285 {
286 ScopeNode node = new ScopeNode( AliasDerefMode.NEVER_DEREF_ALIASES,
287 SchemaConstants.OU_AT_OID + "=engineering," +
288 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
289 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
290 OneLevelScopeCursor cursor = new OneLevelScopeCursor( store, evaluator );
291
292 assertTrue( cursor.isElementReused() );
293
294
295
296
297 cursor.beforeFirst();
298 assertFalse( cursor.available() );
299
300 assertTrue( cursor.next() );
301 assertTrue( cursor.available() );
302 IndexEntry<Long,ServerEntry> indexEntry = cursor.get();
303 assertNotNull( indexEntry );
304 assertEquals( 8L, ( long ) indexEntry.getId() );
305 assertEquals( 4L, ( long ) indexEntry.getValue() );
306
307 assertTrue( cursor.next() );
308 assertTrue( cursor.available() );
309 indexEntry = cursor.get();
310 assertNotNull( indexEntry );
311 assertEquals( 11L, ( long ) indexEntry.getId() );
312 assertEquals( 4L, ( long ) indexEntry.getValue() );
313
314 assertFalse( cursor.next() );
315 assertFalse( cursor.available() );
316
317
318
319 cursor = new OneLevelScopeCursor( store, evaluator );
320 assertFalse( cursor.available() );
321 cursor.first();
322
323 assertTrue( cursor.available() );
324 indexEntry = cursor.get();
325 assertNotNull( indexEntry );
326 assertEquals( 8L, ( long ) indexEntry.getId() );
327 assertEquals( 4L, ( long ) indexEntry.getValue() );
328
329 assertTrue( cursor.next() );
330 assertTrue( cursor.available() );
331 indexEntry = cursor.get();
332 assertNotNull( indexEntry );
333 assertEquals( 11L, ( long ) indexEntry.getId() );
334 assertEquals( 4L, ( long ) indexEntry.getValue() );
335
336 assertFalse( cursor.next() );
337 assertFalse( cursor.available() );
338
339
340
341 cursor = new OneLevelScopeCursor( store, evaluator );
342 cursor.afterLast();
343 assertFalse( cursor.available() );
344
345 assertTrue( cursor.previous() );
346 assertTrue( cursor.available() );
347 indexEntry = cursor.get();
348 assertNotNull( indexEntry );
349 assertEquals( 11L, ( long ) indexEntry.getId() );
350 assertEquals( 4L, ( long ) indexEntry.getValue() );
351
352 assertTrue( cursor.previous() );
353 assertTrue( cursor.available() );
354 indexEntry = cursor.get();
355 assertNotNull( indexEntry );
356 assertEquals( 8L, ( long ) indexEntry.getId() );
357 assertEquals( 4L, ( long ) indexEntry.getValue() );
358
359 assertFalse( cursor.previous() );
360 assertFalse( cursor.available() );
361
362
363
364 cursor = new OneLevelScopeCursor( store, evaluator );
365 assertFalse( cursor.available() );
366 cursor.last();
367
368 assertTrue( cursor.available() );
369 indexEntry = cursor.get();
370 assertNotNull( indexEntry );
371 assertEquals( 11L, ( long ) indexEntry.getId() );
372 assertEquals( 4L, ( long ) indexEntry.getValue() );
373
374 assertTrue( cursor.previous() );
375 assertTrue( cursor.available() );
376 indexEntry = cursor.get();
377 assertNotNull( indexEntry );
378 assertEquals( 8L, ( long ) indexEntry.getId() );
379 assertEquals( 4L, ( long ) indexEntry.getValue() );
380
381 assertFalse( cursor.previous() );
382 assertFalse( cursor.available() );
383
384
385
386 cursor = new OneLevelScopeCursor( store, evaluator );
387 assertFalse( cursor.available() );
388 cursor.previous();
389
390 assertTrue( cursor.available() );
391 indexEntry = cursor.get();
392 assertNotNull( indexEntry );
393 assertEquals( 11L, ( long ) indexEntry.getId() );
394 assertEquals( 4L, ( long ) indexEntry.getValue() );
395
396 assertTrue( cursor.previous() );
397 assertTrue( cursor.available() );
398 indexEntry = cursor.get();
399 assertNotNull( indexEntry );
400 assertEquals( 8L, ( long ) indexEntry.getId() );
401 assertEquals( 4L, ( long ) indexEntry.getValue() );
402
403 assertFalse( cursor.previous() );
404 assertFalse( cursor.available() );
405
406
407
408 cursor = new OneLevelScopeCursor( store, evaluator );
409 assertFalse( cursor.available() );
410 cursor.next();
411
412 assertTrue( cursor.available() );
413 indexEntry = cursor.get();
414 assertNotNull( indexEntry );
415 assertEquals( 8L, ( long ) indexEntry.getId() );
416 assertEquals( 4L, ( long ) indexEntry.getValue() );
417
418 assertTrue( cursor.next() );
419 assertTrue( cursor.available() );
420 indexEntry = cursor.get();
421 assertNotNull( indexEntry );
422 assertEquals( 11L, ( long ) indexEntry.getId() );
423 assertEquals( 4L, ( long ) indexEntry.getValue() );
424
425 assertFalse( cursor.next() );
426 assertFalse( cursor.available() );
427 }
428
429
430 @Test
431 public void testCursorWithDereferencing() throws Exception
432 {
433 ScopeNode node = new ScopeNode( AliasDerefMode.DEREF_IN_SEARCHING,
434 SchemaConstants.OU_AT_OID + "=board of directors," +
435 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
436 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
437 OneLevelScopeCursor cursor = new OneLevelScopeCursor( store, evaluator );
438
439 assertTrue( cursor.isElementReused() );
440
441
442
443
444 cursor.beforeFirst();
445 assertFalse( cursor.available() );
446
447 assertTrue( cursor.next() );
448 assertTrue( cursor.available() );
449 IndexEntry<Long,ServerEntry> indexEntry = cursor.get();
450 assertNotNull( indexEntry );
451 assertEquals( 7L, ( long ) indexEntry.getId() );
452 assertEquals( 3L, ( long ) indexEntry.getValue() );
453
454 assertTrue( cursor.next() );
455 assertTrue( cursor.available() );
456 indexEntry = cursor.get();
457 assertNotNull( indexEntry );
458 assertEquals( 6L, ( long ) indexEntry.getId() );
459 assertEquals( 3L, ( long ) indexEntry.getValue() );
460
461 assertFalse( cursor.next() );
462 assertFalse( cursor.available() );
463
464
465
466 cursor = new OneLevelScopeCursor( store, evaluator );
467 assertFalse( cursor.available() );
468 cursor.first();
469
470 assertTrue( cursor.available() );
471 indexEntry = cursor.get();
472 assertNotNull( indexEntry );
473 assertEquals( 7L, ( long ) indexEntry.getId() );
474 assertEquals( 3L, ( long ) indexEntry.getValue() );
475
476 assertTrue( cursor.next() );
477 assertTrue( cursor.available() );
478 indexEntry = cursor.get();
479 assertNotNull( indexEntry );
480 assertEquals( 6L, ( long ) indexEntry.getId() );
481 assertEquals( 3L, ( long ) indexEntry.getValue() );
482
483 assertFalse( cursor.next() );
484 assertFalse( cursor.available() );
485
486
487
488 cursor = new OneLevelScopeCursor( store, evaluator );
489 cursor.afterLast();
490 assertFalse( cursor.available() );
491
492 assertTrue( cursor.previous() );
493 assertTrue( cursor.available() );
494 indexEntry = cursor.get();
495 assertNotNull( indexEntry );
496 assertEquals( 6L, ( long ) indexEntry.getId() );
497 assertEquals( 3L, ( long ) indexEntry.getValue() );
498
499 assertTrue( cursor.previous() );
500 assertTrue( cursor.available() );
501 indexEntry = cursor.get();
502 assertNotNull( indexEntry );
503 assertEquals( 7L, ( long ) indexEntry.getId() );
504 assertEquals( 3L, ( long ) indexEntry.getValue() );
505
506 assertFalse( cursor.previous() );
507 assertFalse( cursor.available() );
508
509
510
511 cursor = new OneLevelScopeCursor( store, evaluator );
512 assertFalse( cursor.available() );
513 cursor.last();
514
515 assertTrue( cursor.available() );
516 indexEntry = cursor.get();
517 assertNotNull( indexEntry );
518 assertEquals( 6L, ( long ) indexEntry.getId() );
519 assertEquals( 3L, ( long ) indexEntry.getValue() );
520
521 assertTrue( cursor.previous() );
522 assertTrue( cursor.available() );
523 indexEntry = cursor.get();
524 assertNotNull( indexEntry );
525 assertEquals( 7L, ( long ) indexEntry.getId() );
526 assertEquals( 3L, ( long ) indexEntry.getValue() );
527
528 assertFalse( cursor.previous() );
529 assertFalse( cursor.available() );
530
531
532
533 cursor = new OneLevelScopeCursor( store, evaluator );
534 assertFalse( cursor.available() );
535 cursor.previous();
536
537 assertTrue( cursor.available() );
538 indexEntry = cursor.get();
539 assertNotNull( indexEntry );
540 assertEquals( 6L, ( long ) indexEntry.getId() );
541 assertEquals( 3L, ( long ) indexEntry.getValue() );
542
543 assertTrue( cursor.previous() );
544 assertTrue( cursor.available() );
545 indexEntry = cursor.get();
546 assertNotNull( indexEntry );
547 assertEquals( 7L, ( long ) indexEntry.getId() );
548 assertEquals( 3L, ( long ) indexEntry.getValue() );
549
550 assertFalse( cursor.previous() );
551 assertFalse( cursor.available() );
552 }
553
554
555 @Test
556 public void testCursorWithDereferencing2() throws Exception
557 {
558 ScopeNode node = new ScopeNode( AliasDerefMode.DEREF_IN_SEARCHING,
559 SchemaConstants.OU_AT_OID + "=apache," +
560 SchemaConstants.OU_AT_OID + "=board of directors," +
561 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
562 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
563 OneLevelScopeCursor cursor = new OneLevelScopeCursor( store, evaluator );
564
565 assertTrue( cursor.isElementReused() );
566
567
568
569
570 cursor.beforeFirst();
571 assertFalse( cursor.available() );
572
573 assertTrue( cursor.next() );
574 assertTrue( cursor.available() );
575 IndexEntry<Long,ServerEntry> indexEntry = cursor.get();
576 assertNotNull( indexEntry );
577 assertEquals( 6L, ( long ) indexEntry.getId() );
578 assertEquals( 7L, ( long ) indexEntry.getValue() );
579
580 assertFalse( cursor.next() );
581 assertFalse( cursor.available() );
582
583
584
585 cursor = new OneLevelScopeCursor( store, evaluator );
586 assertFalse( cursor.available() );
587 cursor.first();
588
589 assertTrue( cursor.available() );
590 indexEntry = cursor.get();
591 assertNotNull( indexEntry );
592 assertEquals( 6L, ( long ) indexEntry.getId() );
593 assertEquals( 7L, ( long ) indexEntry.getValue() );
594
595 assertFalse( cursor.next() );
596 assertFalse( cursor.available() );
597
598
599
600 cursor = new OneLevelScopeCursor( store, evaluator );
601 cursor.afterLast();
602 assertFalse( cursor.available() );
603
604 assertTrue( cursor.previous() );
605 assertTrue( cursor.available() );
606 indexEntry = cursor.get();
607 assertNotNull( indexEntry );
608 assertEquals( 6L, ( long ) indexEntry.getId() );
609 assertEquals( 7L, ( long ) indexEntry.getValue() );
610
611 assertFalse( cursor.previous() );
612 assertFalse( cursor.available() );
613
614
615
616 cursor = new OneLevelScopeCursor( store, evaluator );
617 assertFalse( cursor.available() );
618 cursor.last();
619
620 assertTrue( cursor.available() );
621 indexEntry = cursor.get();
622 assertNotNull( indexEntry );
623 assertEquals( 6L, ( long ) indexEntry.getId() );
624 assertEquals( 7L, ( long ) indexEntry.getValue() );
625
626 assertFalse( cursor.previous() );
627 assertFalse( cursor.available() );
628
629
630
631 cursor = new OneLevelScopeCursor( store, evaluator );
632 assertFalse( cursor.available() );
633 cursor.previous();
634
635 assertTrue( cursor.available() );
636 indexEntry = cursor.get();
637 assertNotNull( indexEntry );
638 assertEquals( 6L, ( long ) indexEntry.getId() );
639 assertEquals( 7L, ( long ) indexEntry.getValue() );
640
641 assertFalse( cursor.previous() );
642 assertFalse( cursor.available() );
643 }
644
645
646 @Test
647 public void testCursorWithDereferencing3() throws Exception
648 {
649 LdapDN dn = new LdapDN(
650 SchemaConstants.CN_AT_OID + "=jd," +
651 SchemaConstants.OU_AT_OID + "=board of directors," +
652 SchemaConstants.O_AT_OID + "=good times co."
653 );
654 dn.normalize( attributeRegistry.getNormalizerMapping() );
655
656 ServerEntry attrs = new DefaultServerEntry( registries, dn );
657 attrs.add( "objectClass", "alias", "extensibleObject" );
658 attrs.add( "cn", "jd" );
659 attrs.add( "aliasedObjectName", "cn=Jack Daniels,ou=Engineering,o=Good Times Co." );
660 store.add( dn, attrs );
661
662 dn = new LdapDN(
663 SchemaConstants.CN_AT_OID + "=jdoe," +
664 SchemaConstants.OU_AT_OID + "=board of directors," +
665 SchemaConstants.O_AT_OID + "=good times co."
666 );
667 dn.normalize( attributeRegistry.getNormalizerMapping() );
668
669 attrs = new DefaultServerEntry( registries, dn );
670 attrs.add( "objectClass", "person" );
671 attrs.add( "cn", "jdoe" );
672 attrs.add( "sn", "doe" );
673 store.add( dn, attrs );
674
675 ScopeNode node = new ScopeNode( AliasDerefMode.DEREF_IN_SEARCHING,
676 SchemaConstants.OU_AT_OID + "=board of directors," +
677 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
678 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
679 OneLevelScopeCursor cursor = new OneLevelScopeCursor( store, evaluator );
680
681 assertTrue( cursor.isElementReused() );
682
683
684
685
686 cursor.beforeFirst();
687 assertFalse( cursor.available() );
688
689 assertTrue( cursor.next() );
690 assertTrue( cursor.available() );
691 IndexEntry<Long,ServerEntry> indexEntry = cursor.get();
692 assertNotNull( indexEntry );
693 assertEquals( 7L, ( long ) indexEntry.getId() );
694 assertEquals( 3L, ( long ) indexEntry.getValue() );
695
696 assertTrue( cursor.next() );
697 assertTrue( cursor.available() );
698 indexEntry = cursor.get();
699 assertNotNull( indexEntry );
700 assertEquals( 13L, ( long ) indexEntry.getId() );
701 assertEquals( 3L, ( long ) indexEntry.getValue() );
702
703 assertTrue( cursor.next() );
704 assertTrue( cursor.available() );
705 indexEntry = cursor.get();
706 assertNotNull( indexEntry );
707 assertEquals( 6L, ( long ) indexEntry.getId() );
708 assertEquals( 3L, ( long ) indexEntry.getValue() );
709
710 assertTrue( cursor.next() );
711 assertTrue( cursor.available() );
712 indexEntry = cursor.get();
713 assertNotNull( indexEntry );
714 assertEquals( 8L, ( long ) indexEntry.getId() );
715 assertEquals( 3L, ( long ) indexEntry.getValue() );
716
717 assertFalse( cursor.next() );
718 assertFalse( cursor.available() );
719
720
721
722 cursor = new OneLevelScopeCursor( store, evaluator );
723 assertFalse( cursor.available() );
724 cursor.first();
725
726 assertTrue( cursor.available() );
727 indexEntry = cursor.get();
728 assertNotNull( indexEntry );
729 assertEquals( 7L, ( long ) indexEntry.getId() );
730 assertEquals( 3L, ( long ) indexEntry.getValue() );
731
732 assertTrue( cursor.next() );
733 assertTrue( cursor.available() );
734 indexEntry = cursor.get();
735 assertNotNull( indexEntry );
736 assertEquals( 13L, ( long ) indexEntry.getId() );
737 assertEquals( 3L, ( long ) indexEntry.getValue() );
738
739 assertTrue( cursor.next() );
740 assertTrue( cursor.available() );
741 indexEntry = cursor.get();
742 assertNotNull( indexEntry );
743 assertEquals( 6L, ( long ) indexEntry.getId() );
744 assertEquals( 3L, ( long ) indexEntry.getValue() );
745
746 assertTrue( cursor.next() );
747 assertTrue( cursor.available() );
748 indexEntry = cursor.get();
749 assertNotNull( indexEntry );
750 assertEquals( 8L, ( long ) indexEntry.getId() );
751 assertEquals( 3L, ( long ) indexEntry.getValue() );
752
753 assertFalse( cursor.next() );
754 assertFalse( cursor.available() );
755
756
757
758 cursor = new OneLevelScopeCursor( store, evaluator );
759 cursor.afterLast();
760 assertFalse( cursor.available() );
761
762 assertTrue( cursor.previous() );
763 assertTrue( cursor.available() );
764 indexEntry = cursor.get();
765 assertNotNull( indexEntry );
766 assertEquals( 8L, ( long ) indexEntry.getId() );
767 assertEquals( 3L, ( long ) indexEntry.getValue() );
768
769 assertTrue( cursor.previous() );
770 assertTrue( cursor.available() );
771 indexEntry = cursor.get();
772 assertNotNull( indexEntry );
773 assertEquals( 6L, ( long ) indexEntry.getId() );
774 assertEquals( 3L, ( long ) indexEntry.getValue() );
775
776 assertTrue( cursor.previous() );
777 assertTrue( cursor.available() );
778 indexEntry = cursor.get();
779 assertNotNull( indexEntry );
780 assertEquals( 13L, ( long ) indexEntry.getId() );
781 assertEquals( 3L, ( long ) indexEntry.getValue() );
782
783 assertTrue( cursor.previous() );
784 assertTrue( cursor.available() );
785 indexEntry = cursor.get();
786 assertNotNull( indexEntry );
787 assertEquals( 7L, ( long ) indexEntry.getId() );
788 assertEquals( 3L, ( long ) indexEntry.getValue() );
789
790 assertFalse( cursor.previous() );
791 assertFalse( cursor.available() );
792
793
794
795 cursor = new OneLevelScopeCursor( store, evaluator );
796 assertFalse( cursor.available() );
797 cursor.last();
798
799 assertTrue( cursor.available() );
800 indexEntry = cursor.get();
801 assertNotNull( indexEntry );
802 assertEquals( 8L, ( long ) indexEntry.getId() );
803 assertEquals( 3L, ( long ) indexEntry.getValue() );
804
805 assertTrue( cursor.previous() );
806 assertTrue( cursor.available() );
807 indexEntry = cursor.get();
808 assertNotNull( indexEntry );
809 assertEquals( 6L, ( long ) indexEntry.getId() );
810 assertEquals( 3L, ( long ) indexEntry.getValue() );
811
812 assertTrue( cursor.previous() );
813 assertTrue( cursor.available() );
814 indexEntry = cursor.get();
815 assertNotNull( indexEntry );
816 assertEquals( 13L, ( long ) indexEntry.getId() );
817 assertEquals( 3L, ( long ) indexEntry.getValue() );
818
819 assertTrue( cursor.previous() );
820 assertTrue( cursor.available() );
821 indexEntry = cursor.get();
822 assertNotNull( indexEntry );
823 assertEquals( 7L, ( long ) indexEntry.getId() );
824 assertEquals( 3L, ( long ) indexEntry.getValue() );
825
826 assertFalse( cursor.previous() );
827 assertFalse( cursor.available() );
828
829
830
831 cursor = new OneLevelScopeCursor( store, evaluator );
832 assertFalse( cursor.available() );
833 cursor.previous();
834
835 assertTrue( cursor.available() );
836 indexEntry = cursor.get();
837 assertNotNull( indexEntry );
838 assertEquals( 8L, ( long ) indexEntry.getId() );
839 assertEquals( 3L, ( long ) indexEntry.getValue() );
840
841 assertTrue( cursor.previous() );
842 assertTrue( cursor.available() );
843 indexEntry = cursor.get();
844 assertNotNull( indexEntry );
845 assertEquals( 6L, ( long ) indexEntry.getId() );
846 assertEquals( 3L, ( long ) indexEntry.getValue() );
847
848 assertTrue( cursor.previous() );
849 assertTrue( cursor.available() );
850 indexEntry = cursor.get();
851 assertNotNull( indexEntry );
852 assertEquals( 13L, ( long ) indexEntry.getId() );
853 assertEquals( 3L, ( long ) indexEntry.getValue() );
854
855 assertTrue( cursor.previous() );
856 assertTrue( cursor.available() );
857 indexEntry = cursor.get();
858 assertNotNull( indexEntry );
859 assertEquals( 7L, ( long ) indexEntry.getId() );
860 assertEquals( 3L, ( long ) indexEntry.getValue() );
861
862 assertFalse( cursor.previous() );
863 assertFalse( cursor.available() );
864
865
866
867 cursor = new OneLevelScopeCursor( store, evaluator );
868 assertFalse( cursor.available() );
869 cursor.next();
870
871 assertTrue( cursor.available() );
872 indexEntry = cursor.get();
873 assertNotNull( indexEntry );
874 assertEquals( 7L, ( long ) indexEntry.getId() );
875 assertEquals( 3L, ( long ) indexEntry.getValue() );
876
877 assertTrue( cursor.next() );
878 assertTrue( cursor.available() );
879 indexEntry = cursor.get();
880 assertNotNull( indexEntry );
881 assertEquals( 13L, ( long ) indexEntry.getId() );
882 assertEquals( 3L, ( long ) indexEntry.getValue() );
883
884 assertTrue( cursor.next() );
885 assertTrue( cursor.available() );
886 indexEntry = cursor.get();
887 assertNotNull( indexEntry );
888 assertEquals( 6L, ( long ) indexEntry.getId() );
889 assertEquals( 3L, ( long ) indexEntry.getValue() );
890
891 assertTrue( cursor.next() );
892 assertTrue( cursor.available() );
893 indexEntry = cursor.get();
894 assertNotNull( indexEntry );
895 assertEquals( 8L, ( long ) indexEntry.getId() );
896 assertEquals( 3L, ( long ) indexEntry.getValue() );
897
898 assertFalse( cursor.next() );
899 assertFalse( cursor.available() );
900 }
901
902
903 @Test
904 public void testEvaluatorNoDereferencing() throws Exception
905 {
906 ScopeNode node = new ScopeNode( AliasDerefMode.NEVER_DEREF_ALIASES,
907 SchemaConstants.OU_AT_OID + "=sales," +
908 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
909 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
910
911 ForwardIndexEntry<Long,ServerEntry> indexEntry = new ForwardIndexEntry<Long,ServerEntry>();
912 indexEntry.setId( 6L );
913 assertTrue( evaluator.evaluate( indexEntry ) );
914 }
915
916
917 @Test
918 public void testEvaluatorWithDereferencing() throws Exception
919 {
920 ScopeNode node = new ScopeNode( AliasDerefMode.DEREF_ALWAYS,
921 SchemaConstants.OU_AT_OID + "=engineering," +
922 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
923 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
924 assertEquals( node, evaluator.getExpression() );
925
926
927
928
929
930
931 ForwardIndexEntry<Long,ServerEntry> indexEntry = new ForwardIndexEntry<Long,ServerEntry>();
932 indexEntry.setId( 11L );
933 assertFalse( evaluator.evaluate( indexEntry ) );
934
935 indexEntry = new ForwardIndexEntry<Long,ServerEntry>();
936 indexEntry.setId( 8L );
937 assertTrue( evaluator.evaluate( indexEntry ) );
938
939 indexEntry = new ForwardIndexEntry<Long,ServerEntry>();
940 indexEntry.setId( 5L );
941 assertTrue( evaluator.evaluate( indexEntry ) );
942
943 indexEntry = new ForwardIndexEntry<Long,ServerEntry>();
944 indexEntry.setId( 6L );
945 assertFalse( evaluator.evaluate( indexEntry ) );
946 }
947
948
949 @Test ( expected = InvalidCursorPositionException.class )
950 public void testInvalidCursorPositionException() throws Exception
951 {
952 ScopeNode node = new ScopeNode( AliasDerefMode.NEVER_DEREF_ALIASES,
953 SchemaConstants.OU_AT_OID + "=sales," +
954 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
955 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
956 OneLevelScopeCursor cursor = new OneLevelScopeCursor( store, evaluator );
957 cursor.get();
958 }
959
960
961 @Test ( expected = UnsupportedOperationException.class )
962 public void testUnsupportBeforeWithoutIndex() throws Exception
963 {
964 ScopeNode node = new ScopeNode( AliasDerefMode.NEVER_DEREF_ALIASES,
965 SchemaConstants.OU_AT_OID + "=sales," +
966 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
967 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
968 OneLevelScopeCursor cursor = new OneLevelScopeCursor( store, evaluator );
969
970
971 ForwardIndexEntry<Long,ServerEntry> entry = new ForwardIndexEntry<Long,ServerEntry>();
972 entry.setValue( 3L );
973 cursor.before( entry );
974 }
975
976
977 @Test ( expected = UnsupportedOperationException.class )
978 public void testUnsupportAfterWithoutIndex() throws Exception
979 {
980 ScopeNode node = new ScopeNode( AliasDerefMode.NEVER_DEREF_ALIASES,
981 SchemaConstants.OU_AT_OID + "=sales," +
982 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.ONELEVEL );
983 OneLevelScopeEvaluator<ServerEntry> evaluator = new OneLevelScopeEvaluator<ServerEntry>( store, node );
984 OneLevelScopeCursor cursor = new OneLevelScopeCursor( store, evaluator );
985
986
987 ForwardIndexEntry<Long,ServerEntry> entry = new ForwardIndexEntry<Long,ServerEntry>();
988 entry.setValue( 3L );
989 cursor.after( entry );
990 }
991
992
993 @Test ( expected = IllegalStateException.class )
994 public void testIllegalStateBadScope() throws Exception
995 {
996 ScopeNode node = new ScopeNode( AliasDerefMode.NEVER_DEREF_ALIASES,
997 SchemaConstants.OU_AT_OID + "=sales," +
998 SchemaConstants.O_AT_OID + "=good times co.", SearchScope.SUBTREE );
999 new OneLevelScopeEvaluator<ServerEntry>( store, node );
1000 }
1001 }