KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > directory > ldapstudio > dsmlv2 > searchRequest > SearchRequestTest


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
21 package org.apache.directory.ldapstudio.dsmlv2.searchRequest;
22
23
24 import java.util.List JavaDoc;
25
26 import javax.naming.NamingEnumeration JavaDoc;
27 import javax.naming.NamingException JavaDoc;
28 import javax.naming.directory.Attribute JavaDoc;
29 import javax.naming.directory.Attributes JavaDoc;
30
31 import org.apache.directory.ldapstudio.dsmlv2.AbstractTest;
32 import org.apache.directory.ldapstudio.dsmlv2.Dsmlv2Parser;
33 import org.apache.directory.shared.ldap.codec.AttributeValueAssertion;
34 import org.apache.directory.shared.ldap.codec.Control;
35 import org.apache.directory.shared.ldap.codec.LdapConstants;
36 import org.apache.directory.shared.ldap.codec.search.AndFilter;
37 import org.apache.directory.shared.ldap.codec.search.AttributeValueAssertionFilter;
38 import org.apache.directory.shared.ldap.codec.search.ExtensibleMatchFilter;
39 import org.apache.directory.shared.ldap.codec.search.Filter;
40 import org.apache.directory.shared.ldap.codec.search.NotFilter;
41 import org.apache.directory.shared.ldap.codec.search.OrFilter;
42 import org.apache.directory.shared.ldap.codec.search.PresentFilter;
43 import org.apache.directory.shared.ldap.codec.search.SearchRequest;
44 import org.apache.directory.shared.ldap.codec.search.SubstringFilter;
45 import org.apache.directory.shared.ldap.message.ScopeEnum;
46 import org.apache.directory.shared.ldap.util.StringTools;
47
48
49 /**
50  * Tests for the Del Request parsing
51  *
52  * @author <a HREF="mailto:dev@directory.apache.org">Apache Directory Project</a>
53  * @version $Rev$, $Date$
54  */

55 public class SearchRequestTest extends AbstractTest
56 {
57     /**
58      * Test parsing of a request without the dn attribute
59      */

60     public void testRequestWithoutDn()
61     {
62         testParsingFail( SearchRequestTest.class, "request_without_dn_attribute.xml" );
63     }
64
65
66     /**
67      * Test parsing of a request with the dn attribute
68      */

69     public void testRequestWithDn()
70     {
71         Dsmlv2Parser parser = null;
72         try
73         {
74             parser = new Dsmlv2Parser();
75
76             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_dn_attribute.xml" ).getFile() );
77
78             parser.parse();
79         }
80         catch ( Exception JavaDoc e )
81         {
82             fail( e.getMessage() );
83         }
84
85         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
86
87         assertEquals( "ou=marketing,dc=microsoft,dc=com", searchRequest.getBaseObject().toString() );
88     }
89
90
91     /**
92      * Test parsing of a request with the (optional) requestID attribute
93      */

94     public void testRequestWithRequestId()
95     {
96         Dsmlv2Parser parser = null;
97         try
98         {
99             parser = new Dsmlv2Parser();
100
101             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_requestID_attribute.xml" )
102                 .getFile() );
103
104             parser.parse();
105         }
106         catch ( Exception JavaDoc e )
107         {
108             fail( e.getMessage() );
109         }
110
111         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
112
113         assertEquals( 456, searchRequest.getMessageId() );
114     }
115
116
117     /**
118      * Test parsing of a request with the (optional) requestID attribute equals to 0
119      */

120     public void testRequestWithRequestIdEquals0()
121     {
122         testParsingFail( SearchRequestTest.class, "request_with_requestID_equals_0.xml" );
123     }
124
125
126     /**
127      * Test parsing of a request with a (optional) Control element
128      */

129     public void testRequestWith1Control()
130     {
131         Dsmlv2Parser parser = null;
132         try
133         {
134             parser = new Dsmlv2Parser();
135
136             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_1_control.xml" ).getFile() );
137
138             parser.parse();
139         }
140         catch ( Exception JavaDoc e )
141         {
142             fail( e.getMessage() );
143         }
144
145         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
146         Control control = searchRequest.getCurrentControl();
147
148         assertEquals( 1, searchRequest.getControls().size() );
149         assertTrue( control.getCriticality() );
150         assertEquals( "1.2.840.113556.1.4.643", control.getControlType() );
151         assertEquals( "Some text", StringTools.utf8ToString( ( byte[] ) control.getControlValue() ) );
152     }
153
154
155     /**
156      * Test parsing of a request with a (optional) Control element with Base64 value
157      */

158     public void testRequestWith1ControlBase64Value()
159     {
160         Dsmlv2Parser parser = null;
161         try
162         {
163             parser = new Dsmlv2Parser();
164
165             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_1_control_base64_value.xml" )
166                 .getFile() );
167
168             parser.parse();
169         }
170         catch ( Exception JavaDoc e )
171         {
172             fail( e.getMessage() );
173         }
174
175         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
176         Control control = searchRequest.getCurrentControl();
177
178         assertEquals( 1, searchRequest.getControls().size() );
179         assertTrue( control.getCriticality() );
180         assertEquals( "1.2.840.113556.1.4.643", control.getControlType() );
181         assertEquals( "DSMLv2.0 rocks!!", StringTools.utf8ToString( ( byte[] ) control.getControlValue() ) );
182     }
183
184
185     /**
186      * Test parsing of a request with a (optional) Control element with empty value
187      */

188     public void testRequestWith1ControlEmptyValue()
189     {
190         Dsmlv2Parser parser = null;
191         try
192         {
193             parser = new Dsmlv2Parser();
194
195             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_1_control_empty_value.xml" )
196                 .getFile() );
197
198             parser.parse();
199         }
200         catch ( Exception JavaDoc e )
201         {
202             fail( e.getMessage() );
203         }
204
205         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
206         Control control = searchRequest.getCurrentControl();
207
208         assertEquals( 1, searchRequest.getControls().size() );
209         assertTrue( control.getCriticality() );
210         assertEquals( "1.2.840.113556.1.4.643", control.getControlType() );
211         assertEquals( StringTools.EMPTY_BYTES, control.getControlValue() );
212     }
213
214
215     /**
216      * Test parsing of a request with 2 (optional) Control elements
217      */

218     public void testRequestWith2Controls()
219     {
220         Dsmlv2Parser parser = null;
221         try
222         {
223             parser = new Dsmlv2Parser();
224
225             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_2_controls.xml" ).getFile() );
226
227             parser.parse();
228         }
229         catch ( Exception JavaDoc e )
230         {
231             fail( e.getMessage() );
232         }
233
234         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
235         Control control = searchRequest.getCurrentControl();
236
237         assertEquals( 2, searchRequest.getControls().size() );
238         assertFalse( control.getCriticality() );
239         assertEquals( "1.2.840.113556.1.4.789", control.getControlType() );
240         assertEquals( "Some other text", StringTools.utf8ToString( ( byte[] ) control.getControlValue() ) );
241     }
242
243
244     /**
245      * Test parsing of a request with 3 (optional) Control elements without value
246      */

247     public void testRequestWith3ControlsWithoutValue()
248     {
249         Dsmlv2Parser parser = null;
250         try
251         {
252             parser = new Dsmlv2Parser();
253
254             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_3_controls_without_value.xml" )
255                 .getFile() );
256
257             parser.parse();
258         }
259         catch ( Exception JavaDoc e )
260         {
261             fail( e.getMessage() );
262         }
263
264         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
265         Control control = searchRequest.getCurrentControl();
266
267         assertEquals( 3, searchRequest.getControls().size() );
268         assertTrue( control.getCriticality() );
269         assertEquals( "1.2.840.113556.1.4.456", control.getControlType() );
270         assertEquals( StringTools.EMPTY_BYTES, control.getControlValue() );
271     }
272
273
274     /**
275      * Test parsing of a request without the Filter element
276      */

277     public void testRequestWithoutFilter()
278     {
279         testParsingFail( SearchRequestTest.class, "request_without_filter.xml" );
280     }
281
282
283     /**
284      * Test parsing of a request without scope attribute
285      */

286     public void testRequestWithoutScopeAttribute()
287     {
288         testParsingFail( SearchRequestTest.class, "request_without_scope_attribute.xml" );
289     }
290
291
292     /**
293      * Test parsing of a request with scope attribute to BaseObject value
294      * @throws NamingException
295      */

296     public void testRequestWithScopeBaseObject()
297     {
298         Dsmlv2Parser parser = null;
299         try
300         {
301             parser = new Dsmlv2Parser();
302
303             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_scope_baseObject.xml" ).getFile() );
304
305             parser.parse();
306         }
307         catch ( Exception JavaDoc e )
308         {
309             fail( e.getMessage() );
310         }
311
312         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
313
314         assertEquals( ScopeEnum.BASE_OBJECT, searchRequest.getScope() );
315     }
316
317
318     /**
319      * Test parsing of a request with scope attribute to SingleLevel value
320      * @throws NamingException
321      */

322     public void testRequestWithScopeSingleLevel()
323     {
324         Dsmlv2Parser parser = null;
325         try
326         {
327             parser = new Dsmlv2Parser();
328
329             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_scope_singleLevel.xml" ).getFile() );
330
331             parser.parse();
332         }
333         catch ( Exception JavaDoc e )
334         {
335             fail( e.getMessage() );
336         }
337
338         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
339
340         assertEquals( ScopeEnum.SINGLE_LEVEL, searchRequest.getScope() );
341     }
342
343
344     /**
345      * Test parsing of a request with scope attribute to WholeSubtree value
346      * @throws NamingException
347      */

348     public void testRequestWithScopeWholeSubtree()
349     {
350         Dsmlv2Parser parser = null;
351         try
352         {
353             parser = new Dsmlv2Parser();
354
355             parser
356                 .setInputFile( SearchRequestTest.class.getResource( "request_with_scope_wholeSubtree.xml" ).getFile() );
357
358             parser.parse();
359         }
360         catch ( Exception JavaDoc e )
361         {
362             fail( e.getMessage() );
363         }
364
365         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
366
367         assertEquals( ScopeEnum.WHOLE_SUBTREE, searchRequest.getScope() );
368     }
369
370
371     /**
372      * Test parsing of a request with scope attribute to Error value
373      */

374     public void testRequestWithScopeError()
375     {
376         testParsingFail( SearchRequestTest.class, "request_with_scope_error.xml" );
377     }
378
379
380     /**
381      * Test parsing of a request without derefAliases attribute
382      */

383     public void testRequestWithoutDerefAliasesAttribute()
384     {
385         testParsingFail( SearchRequestTest.class, "request_without_derefAliases_attribute.xml" );
386     }
387
388
389     /**
390      * Test parsing of a request with derefAliases attribute to derefAlways value
391      * @throws NamingException
392      */

393     public void testRequestWithDerefAliasesDerefAlways()
394     {
395         Dsmlv2Parser parser = null;
396         try
397         {
398             parser = new Dsmlv2Parser();
399
400             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_derefAliases_derefAlways.xml" )
401                 .getFile() );
402
403             parser.parse();
404         }
405         catch ( Exception JavaDoc e )
406         {
407             fail( e.getMessage() );
408         }
409
410         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
411
412         assertEquals( LdapConstants.DEREF_ALWAYS, searchRequest.getDerefAliases() );
413     }
414
415
416     /**
417      * Test parsing of a request with derefAliases attribute to derefFindingBaseObj value
418      * @throws NamingException
419      */

420     public void testRequestWithDerefAliasesDerefFindingBaseObj()
421     {
422         Dsmlv2Parser parser = null;
423         try
424         {
425             parser = new Dsmlv2Parser();
426
427             parser.setInputFile( SearchRequestTest.class.getResource(
428                 "request_with_derefAliases_derefFindingBaseObj.xml" ).getFile() );
429
430             parser.parse();
431         }
432         catch ( Exception JavaDoc e )
433         {
434             fail( e.getMessage() );
435         }
436
437         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
438
439         assertEquals( LdapConstants.DEREF_FINDING_BASE_OBJ, searchRequest.getDerefAliases() );
440     }
441
442
443     /**
444      * Test parsing of a request with derefAliases attribute to derefinSearching value
445      * @throws NamingException
446      */

447     public void testRequestWithDerefAliasesDerefinSearching()
448     {
449         Dsmlv2Parser parser = null;
450         try
451         {
452             parser = new Dsmlv2Parser();
453
454             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_derefAliases_derefInSearching.xml" )
455                 .getFile() );
456
457             parser.parse();
458         }
459         catch ( Exception JavaDoc e )
460         {
461             fail( e.getMessage() );
462         }
463
464         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
465
466         assertEquals( LdapConstants.DEREF_IN_SEARCHING, searchRequest.getDerefAliases() );
467     }
468
469
470     /**
471      * Test parsing of a request with derefAliases attribute to neverDerefAliases value
472      * @throws NamingException
473      */

474     public void testRequestWithDerefAliasesNeverDerefAliases()
475     {
476         Dsmlv2Parser parser = null;
477         try
478         {
479             parser = new Dsmlv2Parser();
480
481             parser.setInputFile( SearchRequestTest.class
482                 .getResource( "request_with_derefAliases_neverDerefAliases.xml" ).getFile() );
483
484             parser.parse();
485         }
486         catch ( Exception JavaDoc e )
487         {
488             fail( e.getMessage() );
489         }
490
491         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
492
493         assertEquals( LdapConstants.NEVER_DEREF_ALIASES, searchRequest.getDerefAliases() );
494     }
495
496
497     /**
498      * Test parsing of a request with derefAliases attribute to Error value
499      * @throws NamingException
500      */

501     public void testRequestWithDerefAliasesError()
502     {
503         testParsingFail( SearchRequestTest.class, "request_with_derefAliases_error.xml" );
504     }
505
506
507     /**
508      * Test parsing of a request with the sizeLimit (optional) attribute
509      * @throws NamingException
510      */

511     public void testRequestWithSizeLimitAttribute()
512     {
513         Dsmlv2Parser parser = null;
514         try
515         {
516             parser = new Dsmlv2Parser();
517
518             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_sizeLimit_attribute.xml" )
519                 .getFile() );
520
521             parser.parse();
522         }
523         catch ( Exception JavaDoc e )
524         {
525             fail( e.getMessage() );
526         }
527
528         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
529
530         assertEquals( 1000, searchRequest.getSizeLimit() );
531     }
532
533
534     /**
535      * Test parsing of a request with sizeLimit attribute to Error value
536      * @throws NamingException
537      */

538     public void testRequestWithSizeLimitError()
539     {
540         testParsingFail( SearchRequestTest.class, "request_with_sizeLimit_error.xml" );
541     }
542
543
544     /**
545      * Test parsing of a request with the timeLimit (optional) attribute
546      * @throws NamingException
547      */

548     public void testRequestWithTimeLimitAttribute()
549     {
550         Dsmlv2Parser parser = null;
551         try
552         {
553             parser = new Dsmlv2Parser();
554
555             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_timeLimit_attribute.xml" )
556                 .getFile() );
557
558             parser.parse();
559         }
560         catch ( Exception JavaDoc e )
561         {
562             fail( e.getMessage() );
563         }
564
565         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
566
567         assertEquals( 60, searchRequest.getTimeLimit() );
568     }
569
570
571     /**
572      * Test parsing of a request with timeLimit attribute to Error value
573      * @throws NamingException
574      */

575     public void testRequestWithTimeLimitError()
576     {
577         testParsingFail( SearchRequestTest.class, "request_with_timeLimit_error.xml" );
578     }
579
580
581     /**
582      * Test parsing of a request with typesOnly to true
583      */

584     public void testRequestWithTypesOnlyTrue()
585     {
586         Dsmlv2Parser parser = null;
587         try
588         {
589             parser = new Dsmlv2Parser();
590
591             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_typesOnly_true.xml" ).getFile() );
592
593             parser.parse();
594         }
595         catch ( Exception JavaDoc e )
596         {
597             fail( e.getMessage() );
598         }
599
600         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
601
602         assertTrue( searchRequest.isTypesOnly() );
603     }
604
605
606     /**
607      * Test parsing of a request with typesOnly to 1
608      */

609     public void testRequestWithTypesOnly1()
610     {
611         Dsmlv2Parser parser = null;
612         try
613         {
614             parser = new Dsmlv2Parser();
615
616             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_typesOnly_1.xml" ).getFile() );
617
618             parser.parse();
619         }
620         catch ( Exception JavaDoc e )
621         {
622             fail( e.getMessage() );
623         }
624
625         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
626
627         assertTrue( searchRequest.isTypesOnly() );
628     }
629
630
631     /**
632      * Test parsing of a request with typesOnly to false
633      */

634     public void testRequestWithTypesOnlyFalse()
635     {
636         Dsmlv2Parser parser = null;
637         try
638         {
639             parser = new Dsmlv2Parser();
640
641             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_typesOnly_false.xml" ).getFile() );
642
643             parser.parse();
644         }
645         catch ( Exception JavaDoc e )
646         {
647             fail( e.getMessage() );
648         }
649
650         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
651
652         assertFalse( searchRequest.isTypesOnly() );
653     }
654
655
656     /**
657      * Test parsing of a request with typesOnly to 0
658      */

659     public void testRequestWithTypesOnlyRdn0()
660     {
661         Dsmlv2Parser parser = null;
662         try
663         {
664             parser = new Dsmlv2Parser();
665
666             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_typesOnly_0.xml" ).getFile() );
667
668             parser.parse();
669         }
670         catch ( Exception JavaDoc e )
671         {
672             fail( e.getMessage() );
673         }
674
675         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
676
677         assertFalse( searchRequest.isTypesOnly() );
678     }
679
680
681     /**
682      * Test parsing of a request with typesOnly to an error value
683      */

684     public void testRequestWithTypesOnlyError()
685     {
686         testParsingFail( SearchRequestTest.class, "request_with_typesOnly_error.xml" );
687     }
688
689
690     /**
691      * Test parsing of a request with 2 Filter elements
692      */

693     public void testRequestWith2Filters()
694     {
695         testParsingFail( SearchRequestTest.class, "request_with_2_filters.xml" );
696     }
697
698
699     /**
700      * Test parsing of a request with Attibutes Element but not any Attribute element
701      */

702     public void testRequestWithAttributesButNoAttribute()
703     {
704         Dsmlv2Parser parser = null;
705         try
706         {
707             parser = new Dsmlv2Parser();
708
709             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_attributes_but_no_attribute.xml" )
710                 .getFile() );
711
712             parser.parse();
713         }
714         catch ( Exception JavaDoc e )
715         {
716             fail( e.getMessage() );
717         }
718
719         assertTrue( true );
720     }
721
722
723     /**
724      * Test parsing of a request with 2 Attributes elements
725      */

726     public void testRequestWith2AttributesElements()
727     {
728         testParsingFail( SearchRequestTest.class, "request_with_2_attributes_elements.xml" );
729     }
730
731
732     /**
733      * Test parsing of a request with an Attributes element with 1 Attribute element
734      * @throws NamingException
735      */

736     public void testRequestWithAttributes1Attribute() throws NamingException JavaDoc
737     {
738         Dsmlv2Parser parser = null;
739         try
740         {
741             parser = new Dsmlv2Parser();
742
743             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_attributes_1_attribute.xml" )
744                 .getFile() );
745
746             parser.parse();
747         }
748         catch ( Exception JavaDoc e )
749         {
750             fail( e.getMessage() );
751         }
752
753         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
754
755         Attributes JavaDoc attributes = searchRequest.getAttributes();
756
757         assertEquals( 1, attributes.size() );
758
759         NamingEnumeration JavaDoc ne = attributes.getAll();
760
761         Attribute JavaDoc attribute = ( Attribute JavaDoc ) ne.next();
762
763         assertEquals( "sn", attribute.getID() );
764     }
765
766
767     /**
768      * Test parsing of a request with an Attributes element with 2 Attribute elements
769      * @throws NamingException
770      */

771     public void testRequestWithAttributes2Attribute() throws NamingException JavaDoc
772     {
773         Dsmlv2Parser parser = null;
774         try
775         {
776             parser = new Dsmlv2Parser();
777
778             parser.setInputFile( SearchRequestTest.class.getResource( "request_with_attributes_2_attribute.xml" )
779                 .getFile() );
780
781             parser.parse();
782         }
783         catch ( Exception JavaDoc e )
784         {
785             fail( e.getMessage() );
786         }
787
788         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
789
790         Attributes JavaDoc attributes = searchRequest.getAttributes();
791
792         assertEquals( 2, attributes.size() );
793
794         NamingEnumeration JavaDoc ne = attributes.getAll();
795
796         Attribute JavaDoc attribute = ( Attribute JavaDoc ) ne.next();
797
798         assertEquals( "sn", attribute.getID() );
799
800         attribute = ( Attribute JavaDoc ) ne.next();
801
802         assertEquals( "givenName", attribute.getID() );
803     }
804
805
806     /**
807      * Test parsing of a request with 1 Attribute without name attribute
808      */

809     public void testRequestWithAttributeWithoutNameAttribute()
810     {
811         testParsingFail( SearchRequestTest.class, "request_with_attribute_without_name_attribute.xml" );
812     }
813
814
815     /**
816      * Test parsing of a request with empty Filter element
817      */

818     public void testRequestWithEmptyFilter()
819     {
820         testParsingFail( SearchRequestTest.class, "request_with_empty_filter.xml" );
821     }
822
823
824     /**
825      * Test parsing of a request with an And Filter
826      */

827     public void testRequestWithAndFilter()
828     {
829         Dsmlv2Parser parser = null;
830         try
831         {
832             parser = new Dsmlv2Parser();
833
834             parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_and.xml" ).getFile() );
835
836             parser.parse();
837         }
838         catch ( Exception JavaDoc e )
839         {
840             fail( e.getMessage() );
841         }
842
843         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
844
845         Filter filter = searchRequest.getFilter();
846
847         assertTrue( filter instanceof AndFilter );
848     }
849
850
851     /**
852      * Test parsing of a request with an Or Filter
853      */

854     public void testRequestWithOrFilter()
855     {
856         Dsmlv2Parser parser = null;
857         try
858         {
859             parser = new Dsmlv2Parser();
860
861             parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_or.xml" ).getFile() );
862
863             parser.parse();
864         }
865         catch ( Exception JavaDoc e )
866         {
867             fail( e.getMessage() );
868         }
869
870         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
871
872         Filter filter = searchRequest.getFilter();
873
874         assertTrue( filter instanceof OrFilter );
875     }
876
877
878     /**
879      * Test parsing of a request with an Or Filter
880      */

881     public void testRequestWithNotFilter()
882     {
883         Dsmlv2Parser parser = null;
884         try
885         {
886             parser = new Dsmlv2Parser();
887
888             parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_not.xml" ).getFile() );
889
890             parser.parse();
891         }
892         catch ( Exception JavaDoc e )
893         {
894             fail( e.getMessage() );
895         }
896
897         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
898
899         Filter filter = searchRequest.getFilter();
900
901         assertTrue( filter instanceof NotFilter );
902     }
903
904
905     /**
906      * Test parsing of a request with empty Filter element
907      */

908     public void testRequestWithNotFilterWith2Children()
909     {
910         testParsingFail( SearchRequestTest.class, "filters/request_with_not_with_2_children.xml" );
911     }
912
913
914     /**
915      * Test parsing of a request with an approxMatch Filter
916      */

917     public void testRequestWithApproxMatchFilter()
918     {
919         Dsmlv2Parser parser = null;
920         try
921         {
922             parser = new Dsmlv2Parser();
923
924             parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_approxMatch.xml" )
925                 .getFile() );
926
927             parser.parse();
928         }
929         catch ( Exception JavaDoc e )
930         {
931             fail( e.getMessage() );
932         }
933
934         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
935
936         Filter filter = searchRequest.getFilter();
937
938         assertTrue( filter instanceof AttributeValueAssertionFilter );
939
940         AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
941
942         assertEquals( LdapConstants.APPROX_MATCH_FILTER, approxMatchFilter.getFilterType() );
943
944         AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
945
946         assertEquals( "sn", assertion.getAttributeDesc() );
947
948         assertEquals( "foobar", assertion.getAssertionValue() );
949     }
950
951
952     /**
953      * Test parsing of a request with an approxMatch Filter with base64 value
954      */

955     public void testRequestWithApproxMatchFilterBase64Value()
956     {
957         Dsmlv2Parser parser = null;
958         try
959         {
960             parser = new Dsmlv2Parser();
961
962             parser.setInputFile( SearchRequestTest.class.getResource(
963                 "filters/request_with_approxMatch_base64_value.xml" ).getFile() );
964
965             parser.parse();
966         }
967         catch ( Exception JavaDoc e )
968         {
969             fail( e.getMessage() );
970         }
971
972         SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
973
974         Filter filter = searchRequest.getFilter();
975
976         assertTrue( filter instanceof AttributeValueAssertionFilter );
977
978         AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
979
980         assertEquals( LdapConstants.APPROX_MATCH_FILTER, approxMatchFilter.getFilterType() );
981
982         AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
983
984         assertEquals( "sn", assertion.getAttributeDesc() );
985
986         assertEquals( "DSMLv2.0 rocks!!", new String JavaDoc( ( byte[] ) assertion.getAssertionValue() ) );
987     }
988
989
990     /**
991      * Test parsing of a request with an approxMatch Filter with empty value
992      */

993     public void testRequestWithApproxMatchFilterEmptyValue()
994     {
995         Dsmlv2Parser parser = null;
996         try
997         {
998             parser = new Dsmlv2Parser();
999
1000            parser.setInputFile( SearchRequestTest.class.getResource(
1001                "filters/request_with_approxMatch_with_empty_value.xml" ).getFile() );
1002
1003            parser.parse();
1004        }
1005        catch ( Exception JavaDoc e )
1006        {
1007            fail( e.getMessage() );
1008        }
1009
1010        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1011
1012        Filter filter = searchRequest.getFilter();
1013
1014        assertTrue( filter instanceof AttributeValueAssertionFilter );
1015
1016        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1017
1018        assertEquals( LdapConstants.APPROX_MATCH_FILTER, approxMatchFilter.getFilterType() );
1019
1020        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1021
1022        assertEquals( "sn", assertion.getAttributeDesc() );
1023
1024        assertNull( assertion.getAssertionValue() );
1025    }
1026
1027
1028    /**
1029     * Test parsing of a request with approxMatch Filter but no name attribute
1030     */

1031    public void testRequestWithApproxMatchFilterWithoutName()
1032    {
1033        testParsingFail( SearchRequestTest.class, "filters/request_with_approxMatch_without_name.xml" );
1034    }
1035
1036
1037    /**
1038     * Test parsing of a request with approxMatch Filter but no value element
1039     */

1040    public void testRequestWithApproxMatchFilterWithoutValue()
1041    {
1042        testParsingFail( SearchRequestTest.class, "filters/request_with_approxMatch_without_value.xml" );
1043    }
1044
1045
1046    /**
1047     * Test parsing of a request with approxMatch Filter with 2 Value elements
1048     */

1049    public void testRequestWithApproxMatchFilterWith2Values()
1050    {
1051        testParsingFail( SearchRequestTest.class, "filters/request_with_approxMatch_with_2_values.xml" );
1052    }
1053
1054
1055    /**
1056     * Test parsing of a request with an greaterOrEqual Filter
1057     */

1058    public void testRequestWithGreaterOrEqualFilter()
1059    {
1060        Dsmlv2Parser parser = null;
1061        try
1062        {
1063            parser = new Dsmlv2Parser();
1064
1065            parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_greaterOrEqual.xml" )
1066                .getFile() );
1067
1068            parser.parse();
1069        }
1070        catch ( Exception JavaDoc e )
1071        {
1072            fail( e.getMessage() );
1073        }
1074
1075        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1076
1077        Filter filter = searchRequest.getFilter();
1078
1079        assertTrue( filter instanceof AttributeValueAssertionFilter );
1080
1081        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1082
1083        assertEquals( LdapConstants.GREATER_OR_EQUAL_FILTER, approxMatchFilter.getFilterType() );
1084
1085        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1086
1087        assertEquals( "sn", assertion.getAttributeDesc() );
1088
1089        assertEquals( "foobar", assertion.getAssertionValue() );
1090    }
1091
1092
1093    /**
1094     * Test parsing of a request with an greaterOrEqual Filter with base64 value
1095     */

1096    public void testRequestWithGreaterOrEqualFilterBase64Value()
1097    {
1098        Dsmlv2Parser parser = null;
1099        try
1100        {
1101            parser = new Dsmlv2Parser();
1102
1103            parser.setInputFile( SearchRequestTest.class.getResource(
1104                "filters/request_with_greaterOrEqual_base64_value.xml" ).getFile() );
1105
1106            parser.parse();
1107        }
1108        catch ( Exception JavaDoc e )
1109        {
1110            fail( e.getMessage() );
1111        }
1112
1113        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1114
1115        Filter filter = searchRequest.getFilter();
1116
1117        assertTrue( filter instanceof AttributeValueAssertionFilter );
1118
1119        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1120
1121        assertEquals( LdapConstants.GREATER_OR_EQUAL_FILTER, approxMatchFilter.getFilterType() );
1122
1123        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1124
1125        assertEquals( "sn", assertion.getAttributeDesc() );
1126
1127        assertEquals( "DSMLv2.0 rocks!!", new String JavaDoc( ( byte[] ) assertion.getAssertionValue() ) );
1128    }
1129
1130
1131    /**
1132     * Test parsing of a request with an greaterOrEqual Filter with an empty value
1133     */

1134    public void testRequestWithGreaterOrEqualFilterEmptyValue()
1135    {
1136        Dsmlv2Parser parser = null;
1137        try
1138        {
1139            parser = new Dsmlv2Parser();
1140
1141            parser.setInputFile( SearchRequestTest.class.getResource(
1142                "filters/request_with_greaterOrEqual_with_empty_value.xml" ).getFile() );
1143
1144            parser.parse();
1145        }
1146        catch ( Exception JavaDoc e )
1147        {
1148            fail( e.getMessage() );
1149        }
1150
1151        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1152
1153        Filter filter = searchRequest.getFilter();
1154
1155        assertTrue( filter instanceof AttributeValueAssertionFilter );
1156
1157        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1158
1159        assertEquals( LdapConstants.GREATER_OR_EQUAL_FILTER, approxMatchFilter.getFilterType() );
1160
1161        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1162
1163        assertEquals( "sn", assertion.getAttributeDesc() );
1164
1165        assertNull( assertion.getAssertionValue() );
1166    }
1167
1168
1169    /**
1170     * Test parsing of a request with greaterOrEqual Filter but no name attribute
1171     */

1172    public void testRequestWithGreaterOrEqualFilterWithoutName()
1173    {
1174        testParsingFail( SearchRequestTest.class, "filters/request_with_greaterOrEqual_without_name.xml" );
1175    }
1176
1177
1178    /**
1179     * Test parsing of a request with greaterOrEqual Filter but no value element
1180     */

1181    public void testRequestWithGreaterOrEqualFilterWithoutValue()
1182    {
1183        testParsingFail( SearchRequestTest.class, "filters/request_with_greaterOrEqual_without_value.xml" );
1184    }
1185
1186
1187    /**
1188     * Test parsing of a request with greaterOrEqual Filter with 2 Value elements
1189     */

1190    public void testRequestWithGreaterOrEqualFilterWith2Values()
1191    {
1192        testParsingFail( SearchRequestTest.class, "filters/request_with_greaterOrEqual_with_2_values.xml" );
1193    }
1194
1195
1196    /**
1197     * Test parsing of a request with an lessOrEqual Filter
1198     */

1199    public void testRequestWithLessOrEqualFilter()
1200    {
1201        Dsmlv2Parser parser = null;
1202        try
1203        {
1204            parser = new Dsmlv2Parser();
1205
1206            parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_lessOrEqual.xml" )
1207                .getFile() );
1208
1209            parser.parse();
1210        }
1211        catch ( Exception JavaDoc e )
1212        {
1213            fail( e.getMessage() );
1214        }
1215
1216        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1217
1218        Filter filter = searchRequest.getFilter();
1219
1220        assertTrue( filter instanceof AttributeValueAssertionFilter );
1221
1222        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1223
1224        assertEquals( LdapConstants.LESS_OR_EQUAL_FILTER, approxMatchFilter.getFilterType() );
1225
1226        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1227
1228        assertEquals( "sn", assertion.getAttributeDesc() );
1229
1230        assertEquals( "foobar", assertion.getAssertionValue() );
1231    }
1232
1233
1234    /**
1235     * Test parsing of a request with an lessOrEqual Filter with Base64 value
1236     */

1237    public void testRequestWithLessOrEqualFilterBase64Value()
1238    {
1239        Dsmlv2Parser parser = null;
1240        try
1241        {
1242            parser = new Dsmlv2Parser();
1243
1244            parser.setInputFile( SearchRequestTest.class.getResource(
1245                "filters/request_with_lessOrEqual_base64_value.xml" ).getFile() );
1246
1247            parser.parse();
1248        }
1249        catch ( Exception JavaDoc e )
1250        {
1251            fail( e.getMessage() );
1252        }
1253
1254        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1255
1256        Filter filter = searchRequest.getFilter();
1257
1258        assertTrue( filter instanceof AttributeValueAssertionFilter );
1259
1260        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1261
1262        assertEquals( LdapConstants.LESS_OR_EQUAL_FILTER, approxMatchFilter.getFilterType() );
1263
1264        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1265
1266        assertEquals( "sn", assertion.getAttributeDesc() );
1267
1268        assertEquals( "DSMLv2.0 rocks!!", new String JavaDoc( ( byte[] ) assertion.getAssertionValue() ) );
1269    }
1270
1271
1272    /**
1273     * Test parsing of a request with an lessOrEqual Filter
1274     */

1275    public void testRequestWithLessOrEqualFilterEmptyValue()
1276    {
1277        Dsmlv2Parser parser = null;
1278        try
1279        {
1280            parser = new Dsmlv2Parser();
1281
1282            parser.setInputFile( SearchRequestTest.class.getResource(
1283                "filters/request_with_lessOrEqual_with_empty_value.xml" ).getFile() );
1284
1285            parser.parse();
1286        }
1287        catch ( Exception JavaDoc e )
1288        {
1289            fail( e.getMessage() );
1290        }
1291
1292        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1293
1294        Filter filter = searchRequest.getFilter();
1295
1296        assertTrue( filter instanceof AttributeValueAssertionFilter );
1297
1298        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1299
1300        assertEquals( LdapConstants.LESS_OR_EQUAL_FILTER, approxMatchFilter.getFilterType() );
1301
1302        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1303
1304        assertEquals( "sn", assertion.getAttributeDesc() );
1305
1306        assertNull( assertion.getAssertionValue() );
1307    }
1308
1309
1310    /**
1311     * Test parsing of a request with lessOrEqual Filter but no name attribute
1312     */

1313    public void testRequestWithLessOrEqualFilterWithoutName()
1314    {
1315        testParsingFail( SearchRequestTest.class, "filters/request_with_lessOrEqual_without_name.xml" );
1316    }
1317
1318
1319    /**
1320     * Test parsing of a request with lessOrEqual Filter but no value element
1321     */

1322    public void testRequestWithLessOrEqualFilterWithoutValue()
1323    {
1324        testParsingFail( SearchRequestTest.class, "filters/request_with_lessOrEqual_without_value.xml" );
1325    }
1326
1327
1328    /**
1329     * Test parsing of a request with lessOrEqual Filter with 2 Value elements
1330     */

1331    public void testRequestWithLessOrEqualFilterWith2Values()
1332    {
1333        testParsingFail( SearchRequestTest.class, "filters/request_with_lessOrEqual_with_2_values.xml" );
1334    }
1335
1336
1337    /**
1338     * Test parsing of a request with an Equality Filter
1339     */

1340    public void testRequestWithEqualityMatchFilter()
1341    {
1342        Dsmlv2Parser parser = null;
1343        try
1344        {
1345            parser = new Dsmlv2Parser();
1346
1347            parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_equalityMatch.xml" )
1348                .getFile() );
1349
1350            parser.parse();
1351        }
1352        catch ( Exception JavaDoc e )
1353        {
1354            fail( e.getMessage() );
1355        }
1356
1357        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1358
1359        Filter filter = searchRequest.getFilter();
1360
1361        assertTrue( filter instanceof AttributeValueAssertionFilter );
1362
1363        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1364
1365        assertEquals( LdapConstants.EQUALITY_MATCH_FILTER, approxMatchFilter.getFilterType() );
1366
1367        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1368
1369        assertEquals( "sn", assertion.getAttributeDesc() );
1370
1371        assertEquals( "foobar", assertion.getAssertionValue() );
1372    }
1373
1374
1375    /**
1376     * Test parsing of a request with an Equality Filter with base64 value
1377     */

1378    public void testRequestWithEqualityMatchFilterBase64Value()
1379    {
1380        Dsmlv2Parser parser = null;
1381        try
1382        {
1383            parser = new Dsmlv2Parser();
1384
1385            parser.setInputFile( SearchRequestTest.class.getResource(
1386                "filters/request_with_equalityMatch_base64_value.xml" ).getFile() );
1387
1388            parser.parse();
1389        }
1390        catch ( Exception JavaDoc e )
1391        {
1392            fail( e.getMessage() );
1393        }
1394
1395        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1396
1397        Filter filter = searchRequest.getFilter();
1398
1399        assertTrue( filter instanceof AttributeValueAssertionFilter );
1400
1401        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1402
1403        assertEquals( LdapConstants.EQUALITY_MATCH_FILTER, approxMatchFilter.getFilterType() );
1404
1405        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1406
1407        assertEquals( "sn", assertion.getAttributeDesc() );
1408
1409        assertEquals( "DSMLv2.0 rocks!!", new String JavaDoc( ( byte[] ) assertion.getAssertionValue() ) );
1410    }
1411
1412
1413    /**
1414     * Test parsing of a request with an Equality Filter with an empty value
1415     */

1416    public void testRequestWithEqualityMatchFilterWithEmptyValue()
1417    {
1418        Dsmlv2Parser parser = null;
1419        try
1420        {
1421            parser = new Dsmlv2Parser();
1422
1423            parser.setInputFile( SearchRequestTest.class.getResource(
1424                "filters/request_with_equalityMatch_with_empty_value.xml" ).getFile() );
1425
1426            parser.parse();
1427        }
1428        catch ( Exception JavaDoc e )
1429        {
1430            fail( e.getMessage() );
1431        }
1432
1433        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1434
1435        Filter filter = searchRequest.getFilter();
1436
1437        assertTrue( filter instanceof AttributeValueAssertionFilter );
1438
1439        AttributeValueAssertionFilter approxMatchFilter = ( AttributeValueAssertionFilter ) filter;
1440
1441        assertEquals( LdapConstants.EQUALITY_MATCH_FILTER, approxMatchFilter.getFilterType() );
1442
1443        AttributeValueAssertion assertion = approxMatchFilter.getAssertion();
1444
1445        assertEquals( "sn", assertion.getAttributeDesc() );
1446
1447        assertNull( assertion.getAssertionValue() );
1448    }
1449
1450
1451    /**
1452     * Test parsing of a request with EqualityMatch Filter but no name attribute
1453     */

1454    public void testRequestWithEqualityMatchFilterWithoutName()
1455    {
1456        testParsingFail( SearchRequestTest.class, "filters/request_with_equalityMatch_without_name.xml" );
1457    }
1458
1459
1460    /**
1461     * Test parsing of a request with EqualityMatch Filter but no value element
1462     */

1463    public void testRequestWithEqualityMatchFilterWithoutValue()
1464    {
1465        testParsingFail( SearchRequestTest.class, "filters/request_with_equalityMatch_without_value.xml" );
1466    }
1467
1468
1469    /**
1470     * Test parsing of a request with EqualityMatch Filter with 2 Value elements
1471     */

1472    public void testRequestWithEqualityMatchFilterWith2Values()
1473    {
1474        testParsingFail( SearchRequestTest.class, "filters/request_with_equalityMatch_with_2_values.xml" );
1475    }
1476
1477
1478    /**
1479     * Test parsing of a request with an Present Filter
1480     */

1481    public void testRequestWithPresentFilter()
1482    {
1483        Dsmlv2Parser parser = null;
1484        try
1485        {
1486            parser = new Dsmlv2Parser();
1487
1488            parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_present.xml" ).getFile() );
1489
1490            parser.parse();
1491        }
1492        catch ( Exception JavaDoc e )
1493        {
1494            fail( e.getMessage() );
1495        }
1496
1497        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1498
1499        Filter filter = searchRequest.getFilter();
1500
1501        assertTrue( filter instanceof PresentFilter );
1502
1503        PresentFilter presentFilter = ( PresentFilter ) filter;
1504
1505        assertEquals( "givenName", presentFilter.getAttributeDescription().toString() );
1506    }
1507
1508
1509    /**
1510     * Test parsing of a request with Present Filter without name attribute
1511     */

1512    public void testRequestWithPresentWithoutName()
1513    {
1514        testParsingFail( SearchRequestTest.class, "filters/request_with_present_without_name.xml" );
1515    }
1516
1517
1518    /**
1519     * Test parsing of a request with an ExtensibleMatch Filter
1520     */

1521    public void testRequestWithExtensibleMatchFilter()
1522    {
1523        Dsmlv2Parser parser = null;
1524        try
1525        {
1526            parser = new Dsmlv2Parser();
1527
1528            parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_extensibleMatch.xml" )
1529                .getFile() );
1530
1531            parser.parse();
1532        }
1533        catch ( Exception JavaDoc e )
1534        {
1535            fail( e.getMessage() );
1536        }
1537
1538        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1539
1540        Filter filter = searchRequest.getFilter();
1541
1542        assertTrue( filter instanceof ExtensibleMatchFilter );
1543
1544        ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter ) filter;
1545
1546        assertEquals( "A Value", extensibleMatchFilter.getMatchValue() );
1547
1548        assertEquals( false, extensibleMatchFilter.isDnAttributes() );
1549    }
1550
1551
1552    /**
1553     * Test parsing of a request with an ExtensibleMatch Filter
1554     */

1555    public void testRequestWithExtensibleMatchFilterBase64Value()
1556    {
1557        Dsmlv2Parser parser = null;
1558        try
1559        {
1560            parser = new Dsmlv2Parser();
1561
1562            parser.setInputFile( SearchRequestTest.class.getResource(
1563                "filters/request_with_extensibleMatch_base64_value.xml" ).getFile() );
1564
1565            parser.parse();
1566        }
1567        catch ( Exception JavaDoc e )
1568        {
1569            fail( e.getMessage() );
1570        }
1571
1572        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1573
1574        Filter filter = searchRequest.getFilter();
1575
1576        assertTrue( filter instanceof ExtensibleMatchFilter );
1577
1578        ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter ) filter;
1579
1580        assertEquals( "DSMLv2.0 rocks!!", new String JavaDoc( ( byte[] ) extensibleMatchFilter.getMatchValue() ) );
1581
1582        assertEquals( false, extensibleMatchFilter.isDnAttributes() );
1583    }
1584
1585
1586    /**
1587     * Test parsing of a request with an ExtensibleMatch Filter with empty value
1588     */

1589    public void testRequestWithExtensibleMatchWithEmptyValue()
1590    {
1591        Dsmlv2Parser parser = null;
1592        try
1593        {
1594            parser = new Dsmlv2Parser();
1595
1596            parser.setInputFile( SearchRequestTest.class.getResource(
1597                "filters/request_with_extensibleMatch_with_empty_value.xml" ).getFile() );
1598
1599            parser.parse();
1600        }
1601        catch ( Exception JavaDoc e )
1602        {
1603            fail( e.getMessage() );
1604        }
1605
1606        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1607
1608        Filter filter = searchRequest.getFilter();
1609
1610        assertTrue( filter instanceof ExtensibleMatchFilter );
1611
1612        ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter ) filter;
1613
1614        assertNull( extensibleMatchFilter.getMatchValue() );
1615
1616        assertEquals( false, extensibleMatchFilter.isDnAttributes() );
1617    }
1618
1619
1620    /**
1621     * Test parsing of a request with ExtensibleMatch Filter without Value element
1622     */

1623    public void testRequestWithExtensibleMatchWithoutValue()
1624    {
1625        testParsingFail( SearchRequestTest.class, "filters/request_with_extensibleMatch_without_value.xml" );
1626    }
1627
1628
1629    /**
1630     * Test parsing of a request with ExtensibleMatch Filter with 2 Value elements
1631     */

1632    public void testRequestWithExtensibleMatchWith2Values()
1633    {
1634        testParsingFail( SearchRequestTest.class, "filters/request_with_extensibleMatch_with_2_values.xml" );
1635    }
1636
1637
1638    /**
1639     * Test parsing of a request with typesOnly to true
1640     */

1641    public void testRequestWithExtensibleMatchWithDnAttributesTrue()
1642    {
1643        Dsmlv2Parser parser = null;
1644        try
1645        {
1646            parser = new Dsmlv2Parser();
1647
1648            parser.setInputFile( SearchRequestTest.class.getResource(
1649                "filters/request_with_extensibleMatch_with_dnAttributes_true.xml" ).getFile() );
1650
1651            parser.parse();
1652        }
1653        catch ( Exception JavaDoc e )
1654        {
1655            fail( e.getMessage() );
1656        }
1657
1658        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1659
1660        Filter filter = searchRequest.getFilter();
1661
1662        assertTrue( filter instanceof ExtensibleMatchFilter );
1663
1664        ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter ) filter;
1665
1666        assertTrue( extensibleMatchFilter.isDnAttributes() );
1667    }
1668
1669
1670    /**
1671     * Test parsing of a request with typesOnly to 1
1672     */

1673    public void testRequestWithExtensibleMatchWithDnAttributes1()
1674    {
1675        Dsmlv2Parser parser = null;
1676        try
1677        {
1678            parser = new Dsmlv2Parser();
1679
1680            parser.setInputFile( SearchRequestTest.class.getResource(
1681                "filters/request_with_extensibleMatch_with_dnAttributes_1.xml" ).getFile() );
1682
1683            parser.parse();
1684        }
1685        catch ( Exception JavaDoc e )
1686        {
1687            fail( e.getMessage() );
1688        }
1689
1690        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1691
1692        Filter filter = searchRequest.getFilter();
1693
1694        assertTrue( filter instanceof ExtensibleMatchFilter );
1695
1696        ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter ) filter;
1697
1698        assertTrue( extensibleMatchFilter.isDnAttributes() );
1699    }
1700
1701
1702    /**
1703     * Test parsing of a request with typesOnly to false
1704     */

1705    public void testRequestWithExtensibleMatchWithDnAttributesFalse()
1706    {
1707        Dsmlv2Parser parser = null;
1708        try
1709        {
1710            parser = new Dsmlv2Parser();
1711
1712            parser.setInputFile( SearchRequestTest.class.getResource(
1713                "filters/request_with_extensibleMatch_with_dnAttributes_false.xml" ).getFile() );
1714
1715            parser.parse();
1716        }
1717        catch ( Exception JavaDoc e )
1718        {
1719            fail( e.getMessage() );
1720        }
1721
1722        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1723
1724        Filter filter = searchRequest.getFilter();
1725
1726        assertTrue( filter instanceof ExtensibleMatchFilter );
1727
1728        ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter ) filter;
1729
1730        assertFalse( extensibleMatchFilter.isDnAttributes() );
1731    }
1732
1733
1734    /**
1735     * Test parsing of a request with typesOnly to 0
1736     */

1737    public void testRequestWithExtensibleMatchWithDnAttributes0()
1738    {
1739        Dsmlv2Parser parser = null;
1740        try
1741        {
1742            parser = new Dsmlv2Parser();
1743
1744            parser.setInputFile( SearchRequestTest.class.getResource(
1745                "filters/request_with_extensibleMatch_with_dnAttributes_0.xml" ).getFile() );
1746
1747            parser.parse();
1748        }
1749        catch ( Exception JavaDoc e )
1750        {
1751            fail( e.getMessage() );
1752        }
1753
1754        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1755
1756        Filter filter = searchRequest.getFilter();
1757
1758        assertTrue( filter instanceof ExtensibleMatchFilter );
1759
1760        ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter ) filter;
1761
1762        assertFalse( extensibleMatchFilter.isDnAttributes() );
1763    }
1764
1765
1766    /**
1767     * Test parsing of a request with typesOnly to an error value
1768     */

1769    public void testRequestWithExtensibleMatchWithDnAttributesError()
1770    {
1771        testParsingFail( SearchRequestTest.class, "filters/request_with_extensibleMatch_with_dnAttributes_error.xml" );
1772    }
1773
1774
1775    /**
1776     * Test parsing of a request with a matchingRule attribute
1777     */

1778    public void testRequestWithExtensibleMatchWithMatchingRule()
1779    {
1780        Dsmlv2Parser parser = null;
1781        try
1782        {
1783            parser = new Dsmlv2Parser();
1784
1785            parser.setInputFile( SearchRequestTest.class.getResource(
1786                "filters/request_with_extensibleMatch_with_matchingRule.xml" ).getFile() );
1787
1788            parser.parse();
1789        }
1790        catch ( Exception JavaDoc e )
1791        {
1792            fail( e.getMessage() );
1793        }
1794
1795        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1796
1797        Filter filter = searchRequest.getFilter();
1798
1799        assertTrue( filter instanceof ExtensibleMatchFilter );
1800
1801        ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter ) filter;
1802
1803        assertEquals( "AMatchingRuleName", extensibleMatchFilter.getMatchingRule().toString() );
1804    }
1805
1806
1807    /**
1808     * Test parsing of a request with a name attribute
1809     */

1810    public void testRequestWithExtensibleMatchWithName()
1811    {
1812        Dsmlv2Parser parser = null;
1813        try
1814        {
1815            parser = new Dsmlv2Parser();
1816
1817            parser.setInputFile( SearchRequestTest.class.getResource(
1818                "filters/request_with_extensibleMatch_with_name.xml" ).getFile() );
1819
1820            parser.parse();
1821        }
1822        catch ( Exception JavaDoc e )
1823        {
1824            fail( e.getMessage() );
1825        }
1826
1827        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1828
1829        Filter filter = searchRequest.getFilter();
1830
1831        assertTrue( filter instanceof ExtensibleMatchFilter );
1832
1833        ExtensibleMatchFilter extensibleMatchFilter = ( ExtensibleMatchFilter ) filter;
1834
1835        assertEquals( "givenName", extensibleMatchFilter.getType().toString() );
1836    }
1837
1838
1839    /**
1840     * Test parsing of a request with an Substrings Filter
1841     */

1842    public void testRequestWithSubstringsFilter()
1843    {
1844        Dsmlv2Parser parser = null;
1845        try
1846        {
1847            parser = new Dsmlv2Parser();
1848
1849            parser
1850                .setInputFile( SearchRequestTest.class.getResource( "filters/request_with_substrings.xml" ).getFile() );
1851
1852            parser.parse();
1853        }
1854        catch ( Exception JavaDoc e )
1855        {
1856            fail( e.getMessage() );
1857        }
1858
1859        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1860
1861        Filter filter = searchRequest.getFilter();
1862
1863        assertTrue( filter instanceof SubstringFilter );
1864
1865        SubstringFilter substringFilter = ( SubstringFilter ) filter;
1866
1867        assertEquals( "sn", substringFilter.getType().toString() );
1868    }
1869
1870
1871    /**
1872     * Test parsing of a request with Substrings Filter without name
1873     */

1874    public void testRequestWithSubstringsWithoutName()
1875    {
1876        testParsingFail( SearchRequestTest.class, "filters/request_with_substrings_without_name.xml" );
1877    }
1878
1879
1880    /**
1881     * Test parsing of a request with a Substrings Filter with 1 Initial element
1882     */

1883    public void testRequestWithSubstrings1Initial()
1884    {
1885        Dsmlv2Parser parser = null;
1886        try
1887        {
1888            parser = new Dsmlv2Parser();
1889
1890            parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_substrings_1_initial.xml" )
1891                .getFile() );
1892
1893            parser.parse();
1894        }
1895        catch ( Exception JavaDoc e )
1896        {
1897            fail( e.getMessage() );
1898        }
1899
1900        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1901
1902        Filter filter = searchRequest.getFilter();
1903
1904        assertTrue( filter instanceof SubstringFilter );
1905
1906        SubstringFilter substringFilter = ( SubstringFilter ) filter;
1907
1908        assertEquals( "jack", substringFilter.getInitialSubstrings().toString() );
1909    }
1910
1911
1912    /**
1913     * Test parsing of a request with a Substrings Filter with 1 Initial element with Base64 value
1914     */

1915    public void testRequestWithSubstrings1Base64Initial()
1916    {
1917        Dsmlv2Parser parser = null;
1918        try
1919        {
1920            parser = new Dsmlv2Parser();
1921
1922            parser.setInputFile( SearchRequestTest.class.getResource(
1923                "filters/request_with_substrings_1_base64_initial.xml" ).getFile() );
1924
1925            parser.parse();
1926        }
1927        catch ( Exception JavaDoc e )
1928        {
1929            fail( e.getMessage() );
1930        }
1931
1932        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1933
1934        Filter filter = searchRequest.getFilter();
1935
1936        assertTrue( filter instanceof SubstringFilter );
1937
1938        SubstringFilter substringFilter = ( SubstringFilter ) filter;
1939
1940        assertEquals( "DSMLv2.0 rocks!!", substringFilter.getInitialSubstrings().toString() );
1941    }
1942
1943
1944    /**
1945     * Test parsing of a request with a Substrings Filter with 1 emptyInitial element
1946     */

1947    public void testRequestWithSubstrings1EmptyInitial()
1948    {
1949        Dsmlv2Parser parser = null;
1950        try
1951        {
1952            parser = new Dsmlv2Parser();
1953
1954            parser.setInputFile( SearchRequestTest.class.getResource(
1955                "filters/request_with_substrings_1_empty_initial.xml" ).getFile() );
1956
1957            parser.parse();
1958        }
1959        catch ( Exception JavaDoc e )
1960        {
1961            fail( e.getMessage() );
1962        }
1963
1964        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1965
1966        Filter filter = searchRequest.getFilter();
1967
1968        assertTrue( filter instanceof SubstringFilter );
1969
1970        SubstringFilter substringFilter = ( SubstringFilter ) filter;
1971
1972        assertNull( substringFilter.getInitialSubstrings() );
1973    }
1974
1975
1976    /**
1977     * Test parsing of a request with a Substrings Filter with 1 Initial and 1 Any elements
1978     */

1979    public void testRequestWithSubstrings1Initial1Any()
1980    {
1981        Dsmlv2Parser parser = null;
1982        try
1983        {
1984            parser = new Dsmlv2Parser();
1985
1986            parser.setInputFile( SearchRequestTest.class.getResource(
1987                "filters/request_with_substrings_1_initial_1_any.xml" ).getFile() );
1988
1989            parser.parse();
1990        }
1991        catch ( Exception JavaDoc e )
1992        {
1993            fail( e.getMessage() );
1994        }
1995
1996        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
1997
1998        Filter filter = searchRequest.getFilter();
1999
2000        assertTrue( filter instanceof SubstringFilter );
2001
2002        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2003
2004        assertEquals( "jack", substringFilter.getInitialSubstrings() );
2005
2006        List JavaDoc<String JavaDoc> initials = substringFilter.getAnySubstrings();
2007
2008        assertEquals( 1, initials.size() );
2009
2010        assertEquals( "kate", initials.get( 0 ).toString() );
2011    }
2012
2013
2014    /**
2015     * Test parsing of a request with a Substrings Filter with 1 Initial and 1 Final elements
2016     */

2017    public void testRequestWithSubstrings1Initial1Final()
2018    {
2019        Dsmlv2Parser parser = null;
2020        try
2021        {
2022            parser = new Dsmlv2Parser();
2023
2024            parser.setInputFile( SearchRequestTest.class.getResource(
2025                "filters/request_with_substrings_1_initial_1_final.xml" ).getFile() );
2026
2027            parser.parse();
2028        }
2029        catch ( Exception JavaDoc e )
2030        {
2031            fail( e.getMessage() );
2032        }
2033
2034        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2035
2036        Filter filter = searchRequest.getFilter();
2037
2038        assertTrue( filter instanceof SubstringFilter );
2039
2040        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2041
2042        assertEquals( "jack", substringFilter.getInitialSubstrings() );
2043
2044        assertEquals( "john", substringFilter.getFinalSubstrings() );
2045    }
2046
2047
2048    /**
2049     * Test parsing of a request with a Substrings Filter with 1 Any element
2050     */

2051    public void testRequestWithSubstrings1Any()
2052    {
2053        Dsmlv2Parser parser = null;
2054        try
2055        {
2056            parser = new Dsmlv2Parser();
2057
2058            parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_substrings_1_any.xml" )
2059                .getFile() );
2060
2061            parser.parse();
2062        }
2063        catch ( Exception JavaDoc e )
2064        {
2065            fail( e.getMessage() );
2066        }
2067
2068        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2069
2070        Filter filter = searchRequest.getFilter();
2071
2072        assertTrue( filter instanceof SubstringFilter );
2073
2074        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2075
2076        List JavaDoc<String JavaDoc> initials = substringFilter.getAnySubstrings();
2077
2078        assertEquals( 1, initials.size() );
2079        assertEquals( "kate", initials.get( 0 ) );
2080    }
2081
2082
2083    /**
2084     * Test parsing of a request with a Substrings Filter with 1 Any element
2085     */

2086    public void testRequestWithSubstrings1Base64Any()
2087    {
2088        Dsmlv2Parser parser = null;
2089        try
2090        {
2091            parser = new Dsmlv2Parser();
2092
2093            parser.setInputFile( SearchRequestTest.class.getResource(
2094                "filters/request_with_substrings_1_base64_any.xml" ).getFile() );
2095
2096            parser.parse();
2097        }
2098        catch ( Exception JavaDoc e )
2099        {
2100            fail( e.getMessage() );
2101        }
2102
2103        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2104
2105        Filter filter = searchRequest.getFilter();
2106
2107        assertTrue( filter instanceof SubstringFilter );
2108
2109        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2110
2111        List JavaDoc<String JavaDoc> initials = substringFilter.getAnySubstrings();
2112
2113        assertEquals( 1, initials.size() );
2114        assertEquals( "DSMLv2.0 rocks!!", initials.get( 0 ) );
2115    }
2116
2117
2118    /**
2119     * Test parsing of a request with a Substrings Filter with 1 empty Any element
2120     */

2121    public void testRequestWithSubstrings1EmptyAny()
2122    {
2123        Dsmlv2Parser parser = null;
2124        try
2125        {
2126            parser = new Dsmlv2Parser();
2127
2128            parser.setInputFile( SearchRequestTest.class
2129                .getResource( "filters/request_with_substrings_1_empty_any.xml" ).getFile() );
2130
2131            parser.parse();
2132        }
2133        catch ( Exception JavaDoc e )
2134        {
2135            fail( e.getMessage() );
2136        }
2137
2138        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2139
2140        Filter filter = searchRequest.getFilter();
2141
2142        assertTrue( filter instanceof SubstringFilter );
2143
2144        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2145
2146        List JavaDoc<String JavaDoc> initials = substringFilter.getAnySubstrings();
2147
2148        assertEquals( 0, initials.size() );
2149    }
2150
2151
2152    /**
2153     * Test parsing of a request with a Substrings Filter with 1 Any element
2154     */

2155    public void testRequestWithSubstrings2Any()
2156    {
2157        Dsmlv2Parser parser = null;
2158        try
2159        {
2160            parser = new Dsmlv2Parser();
2161
2162            parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_substrings_2_any.xml" )
2163                .getFile() );
2164
2165            parser.parse();
2166        }
2167        catch ( Exception JavaDoc e )
2168        {
2169            fail( e.getMessage() );
2170        }
2171
2172        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2173
2174        Filter filter = searchRequest.getFilter();
2175
2176        assertTrue( filter instanceof SubstringFilter );
2177
2178        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2179
2180        List JavaDoc<String JavaDoc> initials = substringFilter.getAnySubstrings();
2181
2182        assertEquals( 2, initials.size() );
2183
2184        assertEquals( "kate", initials.get( 0 ) );
2185
2186        assertEquals( "sawyer", initials.get( 1 ) );
2187    }
2188
2189
2190    /**
2191     * Test parsing of a request with a Substrings Filter with 1 Any and 1 Final elements
2192     */

2193    public void testRequestWithSubstrings1Any1Final()
2194    {
2195        Dsmlv2Parser parser = null;
2196        try
2197        {
2198            parser = new Dsmlv2Parser();
2199
2200            parser.setInputFile( SearchRequestTest.class.getResource(
2201                "filters/request_with_substrings_1_any_1_final.xml" ).getFile() );
2202
2203            parser.parse();
2204        }
2205        catch ( Exception JavaDoc e )
2206        {
2207            fail( e.getMessage() );
2208        }
2209
2210        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2211
2212        Filter filter = searchRequest.getFilter();
2213
2214        assertTrue( filter instanceof SubstringFilter );
2215
2216        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2217
2218        List JavaDoc<String JavaDoc> initials = substringFilter.getAnySubstrings();
2219
2220        assertEquals( 1, initials.size() );
2221
2222        assertEquals( "kate", initials.get( 0 ) );
2223
2224        assertEquals( "john", substringFilter.getFinalSubstrings() );
2225    }
2226
2227
2228    /**
2229     * Test parsing of a request with a Substrings Filter with 1 Final element
2230     */

2231    public void testRequestWithSubstrings1Final()
2232    {
2233        Dsmlv2Parser parser = null;
2234        try
2235        {
2236            parser = new Dsmlv2Parser();
2237
2238            parser.setInputFile( SearchRequestTest.class.getResource( "filters/request_with_substrings_1_final.xml" )
2239                .getFile() );
2240
2241            parser.parse();
2242        }
2243        catch ( Exception JavaDoc e )
2244        {
2245            fail( e.getMessage() );
2246        }
2247
2248        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2249
2250        Filter filter = searchRequest.getFilter();
2251
2252        assertTrue( filter instanceof SubstringFilter );
2253
2254        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2255
2256        assertEquals( "john", substringFilter.getFinalSubstrings().toString() );
2257    }
2258
2259
2260    /**
2261     * Test parsing of a request with a Substrings Filter with 1 Final element
2262     */

2263    public void testRequestWithSubstrings1Base64Final()
2264    {
2265        Dsmlv2Parser parser = null;
2266        try
2267        {
2268            parser = new Dsmlv2Parser();
2269
2270            parser.setInputFile( SearchRequestTest.class.getResource(
2271                "filters/request_with_substrings_1_base64_final.xml" ).getFile() );
2272
2273            parser.parse();
2274        }
2275        catch ( Exception JavaDoc e )
2276        {
2277            fail( e.getMessage() );
2278        }
2279
2280        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2281
2282        Filter filter = searchRequest.getFilter();
2283
2284        assertTrue( filter instanceof SubstringFilter );
2285
2286        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2287
2288        assertEquals( "DSMLv2.0 rocks!!", substringFilter.getFinalSubstrings().toString() );
2289    }
2290
2291
2292    /**
2293     * Test parsing of a request with a Substrings Filter with 1 empty Final element
2294     */

2295    public void testRequestWithSubstrings1EmptyFinal()
2296    {
2297        Dsmlv2Parser parser = null;
2298        try
2299        {
2300            parser = new Dsmlv2Parser();
2301
2302            parser.setInputFile( SearchRequestTest.class.getResource(
2303                "filters/request_with_substrings_1_empty_final.xml" ).getFile() );
2304
2305            parser.parse();
2306        }
2307        catch ( Exception JavaDoc e )
2308        {
2309            fail( e.getMessage() );
2310        }
2311
2312        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2313
2314        Filter filter = searchRequest.getFilter();
2315
2316        assertTrue( filter instanceof SubstringFilter );
2317
2318        SubstringFilter substringFilter = ( SubstringFilter ) filter;
2319
2320        assertNull( substringFilter.getFinalSubstrings() );
2321    }
2322
2323
2324    /**
2325     * Test parsing of a request with a SubEntries Control
2326     */

2327    public void testRequestWithSubEntriesControl()
2328    {
2329        Dsmlv2Parser parser = null;
2330        try
2331        {
2332            parser = new Dsmlv2Parser();
2333
2334            parser
2335                .setInputFile( SearchRequestTest.class.getResource( "request_with_subentries_control.xml" ).getFile() );
2336
2337            parser.parse();
2338        }
2339        catch ( Exception JavaDoc e )
2340        {
2341            fail( e.getMessage() );
2342        }
2343
2344        SearchRequest searchRequest = ( SearchRequest ) parser.getBatchRequest().getCurrentRequest();
2345
2346        assertEquals( 1, searchRequest.getControls().size() );
2347
2348        Control control = searchRequest.getCurrentControl();
2349
2350        assertTrue( control.getCriticality() );
2351
2352        assertEquals( "1.3.6.1.4.1.4203.1.10.1", control.getControlType() );
2353
2354        assertEquals( "Some text", StringTools.utf8ToString( ( byte[] ) control.getControlValue() ) );
2355    }
2356
2357
2358    /**
2359     * Test parsing of a request with a needed requestID attribute
2360     *
2361     * DIRSTUDIO-1
2362     */

2363    public void testRequestWithNeededRequestId()
2364    {
2365        testParsingFail( SearchRequestTest.class, "request_with_needed_requestID.xml" );
2366    }
2367}
2368
Popular Tags