1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *  
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *  
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License. 
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   * Tests to for OneLevelScopeEvaluator and OneLevelScopeCursor.
58   *
59   * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
60   * @version $$Rev$$
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          // setup the standard registries
76          BootstrapSchemaLoader loader = new BootstrapSchemaLoader();
77          OidRegistry oidRegistry = new DefaultOidRegistry();
78          registries = new DefaultRegistries( "bootstrap", loader, oidRegistry );
79          SerializableComparator.setRegistry( registries.getComparatorRegistry() );
80  
81          // load essential bootstrap schemas
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          // setup the working directory for the store
99          wkdir = File.createTempFile( getClass().getSimpleName(), "db" );
100         wkdir.delete();
101         wkdir = new File( wkdir.getParentFile(), getClass().getSimpleName() );
102         wkdir.mkdirs();
103 
104         // initialize the store
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         // --------- Test beforeFirst() ---------
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         // --------- Test first() ---------
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         // --------- Test afterLast() ---------
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         // --------- Test last() ---------
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         // --------- Test previous() before positioning ---------
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         // --------- Test next() before positioning ---------
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         // --------- Test beforeFirst() ---------
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         // --------- Test first() ---------
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         // --------- Test afterLast() ---------
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         // --------- Test last() ---------
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         // --------- Test previous() before positioning ---------
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         // --------- Test next() before positioning ---------
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         // --------- Test beforeFirst() ---------
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         // --------- Test first() ---------
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         // --------- Test afterLast() ---------
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         // --------- Test last() ---------
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         // --------- Test previous() before positioning ---------
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         // --------- Test beforeFirst() ---------
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         // --------- Test first() ---------
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         // --------- Test afterLast() ---------
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         // --------- Test last() ---------
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         // --------- Test previous() before positioning ---------
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         // --------- Test beforeFirst() ---------
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         // --------- Test first() ---------
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         // --------- Test afterLast() ---------
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         // --------- Test last() ---------
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         // --------- Test previous() before positioning ---------
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         // --------- Test next() before positioning ---------
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          * Although immediately subordinate to the base, the OneLevelEvaluator
928          * will not accept an alias candidate because aliases are not returned
929          * when alias dereferencing while searching is enabled.
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         // test before()
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         // test after()
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 }