1   /*
2    *   Copyright 2004-2005 The Apache Software Foundation
3    *
4    *   Licensed under the Apache License, Version 2.0 (the "License");
5    *   you may not use this file except in compliance with the License.
6    *   You may obtain a copy of the License at
7    *
8    *       http://www.apache.org/licenses/LICENSE-2.0
9    *
10   *   Unless required by applicable law or agreed to in writing, software
11   *   distributed under the License is distributed on an "AS IS" BASIS,
12   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   *   See the License for the specific language governing permissions and
14   *   limitations under the License.
15   *
16   */
17  package org.apache.asn1.ber ;
18  
19  
20  import java.util.Collections;
21  import java.util.Iterator ;
22  
23  import java.nio.ByteBuffer ;
24  
25  import org.apache.asn1.ber.AbstractDecoderTestCase;
26  import org.apache.asn1.ber.DefaultMutableTupleNode;
27  
28  
29  /***
30   * Tests the default MutableTupleNode implementation.
31   *
32   * @author <a href="mailto:dev@directory.apache.org">
33   * Apache Directory Project</a>
34   * @version $Rev: 157644 $
35   */
36  public class DefaultMutableTupleNodeTest extends AbstractDecoderTestCase
37  {
38      public DefaultMutableTupleNodeTest()
39      {
40          super ( DefaultMutableTupleNodeTest.class.getName() ) ;
41      }
42  
43  
44      /*
45       * Class to test for void insert(MutableTupleNode, int)
46       */
47      public void testInsertMutableTupleNodeint()
48      {
49      }
50  
51      /*
52       * Class to test for void remove(int)
53       */
54      public void testRemoveint()
55      {
56          DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
57          DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
58          parent.insert( (MutableTupleNode) node, 0 ) ;
59          assertEquals(1,parent.getChildCount()) ;
60          parent.remove( 0 ) ;
61          assertEquals(0,parent.getChildCount()) ;
62      }
63  
64      /*
65       * Class to test for void remove(MutableTupleNode)
66       */
67      public void testRemoveMutableTupleNode()
68      {
69          DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
70          DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
71          parent.insert( (MutableTupleNode) node, 0 ) ;
72          assertEquals(1,parent.getChildCount()) ;
73          parent.remove( (MutableTupleNode) node ) ;
74          assertEquals(0,parent.getChildCount()) ;
75  
76          parent.insert( node, 0 ) ;
77          assertEquals(1,parent.getChildCount()) ;
78          parent.remove( node ) ;
79          assertEquals(0,parent.getChildCount()) ;
80      }
81  
82      public void testRemoveFromParent()
83      {
84          DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
85          DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
86          parent.insert( (MutableTupleNode) node, 0 ) ;
87          node.setParent( (MutableTupleNode) parent) ;
88  
89          assertEquals(1,parent.getChildCount()) ;
90          node.removeFromParent() ;
91          assertEquals(0,parent.getChildCount()) ;
92      }
93  
94      /*
95       * Class to test for void setParent(MutableTupleNode)
96       */
97      public void testSetParentMutableTupleNode()
98      {
99          DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
100         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
101         parent.insert( (MutableTupleNode) node, 0 ) ;
102         node.setParent( (MutableTupleNode) parent) ;
103         assertEquals(parent, node.getParentTupleNode()) ;
104         node.setParent((MutableTupleNode)new DefaultMutableTupleNode()) ;
105         assertNotSame(parent, node.getParentTupleNode()) ;
106     }
107 
108     /*
109      * Class to test for void setParent(MutableTupleNode)
110      */
111     public void testSetParentMutableTreeNode()
112     {
113         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
114         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
115         parent.insert( node, 0 ) ;
116         node.setParent( parent) ;
117         assertEquals(parent, node.getParentTupleNode()) ;
118         node.setParent( new DefaultMutableTupleNode()) ;
119         assertNotSame( parent, node.getParentTupleNode() ) ;
120     }
121 
122     public void testSetTuple()
123     {
124         Tuple t = new Tuple() ;
125         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
126         node.setTuple( t ) ;
127         assertEquals(t, node.getTuple()) ;
128     }
129 
130     public void testGetParentTupleNode()
131     {
132         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
133         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
134         parent.insert( (MutableTupleNode) node, 0 ) ;
135         node.setParent( (MutableTupleNode) parent) ;
136         assertSame(parent, node.getParentTupleNode()) ;
137         assertSame(parent, node.getParentTupleNode()) ;
138     }
139 
140     public void testGetChildren()
141     {
142         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
143         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
144         parent.insert( (MutableTupleNode) node, 0 ) ;
145         node.setParent( (MutableTupleNode) parent) ;
146         assertSame(parent, node.getParentTupleNode()) ;
147         assertTrue( parent.getChildren().hasNext()) ;
148     }
149 
150 
151     public void testGetChildTupleNodeAt()
152     {
153     }
154 
155     /*
156      * Class to test for int getIndex(TupleNode)
157      */
158     public void testGetIndexTupleNode()
159     {
160         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
161         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
162         parent.insert( (MutableTupleNode) node, 0 ) ;
163         node.setParent( (MutableTupleNode) parent) ;
164         assertEquals( 0, parent.getIndex((MutableTupleNode)node));
165         assertEquals( 0, parent.getIndex(node));
166     }
167 
168     public void testGetChildCount()
169     {
170     }
171 
172     public void testSize()
173     {
174         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
175         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
176         parent.insert( (MutableTupleNode) node, 0 ) ;
177         node.setParent( (MutableTupleNode) parent) ;
178 
179         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
180         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
181         parent.setTuple( constructed ) ;
182         node.setTuple( primitive ) ;
183 
184         // fact that we use the indefinite form we automatically add two to
185         // the contained size
186         assertEquals(9, parent.size()) ;
187     }
188 
189     public void testSize2()
190     {
191         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
192         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
193         parent.insert( (MutableTupleNode) node, 0 ) ;
194         node.setParent( (MutableTupleNode) parent) ;
195 
196         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
197         Tuple constructed = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
198         parent.setTuple( constructed ) ;
199         node.setTuple( primitive ) ;
200 
201         assertEquals(7, parent.size()) ;
202     }
203 
204     public void testSize3()
205     {
206         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
207         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
208         parent.setTuple( constructed ) ;
209 
210         assertEquals(4, parent.size()) ;
211     }
212 
213     public void testEncode3() throws Exception
214     {
215         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
216         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
217         parent.setTuple( constructed ) ;
218         assertEquals(4, parent.size()) ;
219         ByteBuffer buf = ByteBuffer.allocate( 4 ) ;
220         parent.encode( buf ) ;
221 
222 
223         /*
224         final ArrayList list = new ArrayList() ;
225         TupleTreeDecoder decoder = new TupleTreeDecoder() ;
226         decoder.setCallback( new DecoderCallback(){
227             public void decodeOccurred(StatefulDecoder arg0, Object arg1)
228             {
229                 list.add( arg1 ) ;
230             }}) ;
231 
232         decoder.decode(buf.flip()) ;
233         DefaultMutableTupleNode decoded = ( DefaultMutableTupleNode )
234             list.get(0);
235         assertEquals( decoded.getTuple(), parent.getTuple()) ;
236         */
237     }
238 
239     public void testGetTuple()
240     {
241         Tuple t = new Tuple() ;
242         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
243         node.setTuple(t) ;
244         assertSame(t, node.getTuple()) ;
245     }
246 
247     public void testEncode0() throws Exception
248     {
249         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
250         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
251 
252         DefaultMutableTupleNode end = new DefaultMutableTupleNode() ;
253         parent.insert( (MutableTupleNode) end, 0 ) ;
254         end.setParent( (MutableTupleNode) parent) ;
255         parent.insert( (MutableTupleNode) node, 0 ) ;
256         node.setParent( (MutableTupleNode) parent) ;
257 
258         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
259         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
260         Tuple terminator = new Tuple( 0, 0, true, TypeClass.UNIVERSAL ) ;
261         terminator.typeClass = TypeClass.UNIVERSAL ;
262         parent.setTuple( constructed ) ;
263         node.setTuple( primitive ) ;
264         end.setTuple(terminator) ;
265 
266         assertEquals(9, parent.size()) ;
267 
268         ByteBuffer buf = ByteBuffer.allocate( 9 ) ;
269         parent.encode( buf ) ;
270 
271         /***
272         final ArrayList list = new ArrayList() ;
273         TupleTreeDecoder decoder = new TupleTreeDecoder() ;
274         decoder.setCallback( new DecoderCallback(){
275             public void decodeOccurred(StatefulDecoder arg0, Object arg1)
276             {
277                 list.add( arg1 ) ;
278             }}) ;
279 
280         decoder.decode(buf.flip()) ;
281         DefaultMutableTupleNode decoded = ( DefaultMutableTupleNode )
282             list.get(0);
283         assertEquals( decoded.getTuple(), parent.getTuple()) ;
284         */
285     }
286 
287     public void testEncode1() throws Exception
288     {
289         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
290         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
291         parent.insert( (MutableTupleNode) node, 0 ) ;
292         node.setParent( (MutableTupleNode) parent) ;
293 
294         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
295         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
296         parent.setTuple( constructed ) ;
297         node.setTuple( primitive ) ;
298 
299         // 2 extra bytes added for indefinite form
300         assertEquals(9, parent.size()) ;
301 
302         ByteBuffer buf = ByteBuffer.allocate( 9 ) ;
303         parent.encode( buf ) ;
304 
305         /*
306         final ArrayList list = new ArrayList() ;
307         TupleTreeDecoder decoder = new TupleTreeDecoder() ;
308         decoder.setCallback( new DecoderCallback(){
309             public void decodeOccurred(StatefulDecoder arg0, Object arg1)
310             {
311                 list.add( arg1 ) ;
312             }}) ;
313 
314         decoder.decode(buf.flip()) ;
315         DefaultMutableTupleNode decoded = ( DefaultMutableTupleNode )
316             list.get(0);
317         assertEquals( decoded.getTuple(), parent.getTuple()) ;
318         */
319     }
320 
321     public void testEncode2() throws Exception
322     {
323         DefaultMutableTupleNode top = new DefaultMutableTupleNode() ;
324         DefaultMutableTupleNode middle = new DefaultMutableTupleNode() ;
325         DefaultMutableTupleNode bottom = new DefaultMutableTupleNode() ;
326         top.insert( (MutableTupleNode) middle, 0 ) ;
327         middle.setParent( (MutableTupleNode) top) ;
328         middle.insert( (MutableTupleNode) bottom, 0 ) ;
329         bottom.setParent( (MutableTupleNode) middle) ;
330 
331         Tuple middleTuple = new Tuple( 1, 3, TypeClass.APPLICATION  ) ;
332         Tuple topTuple = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
333         Tuple bottomTuple = new Tuple( 3, 1, true, TypeClass.APPLICATION ) ;
334 
335         bottomTuple.typeClass = TypeClass.UNIVERSAL ;
336         top.setTuple( topTuple ) ;
337         middle.setTuple( middleTuple ) ;
338         bottom.setTuple( bottomTuple ) ;
339 
340         assertEquals(7, top.size()) ;
341 
342         ByteBuffer buf = ByteBuffer.allocate( 7 ) ;
343         top.encode( buf ) ;
344 
345         /*
346         final ArrayList list = new ArrayList() ;
347         TupleTreeDecoder decoder = new TupleTreeDecoder() ;
348         decoder.setCallback( new DecoderCallback(){
349             public void decodeOccurred(StatefulDecoder arg0, Object arg1)
350             {
351                 list.add( arg1 ) ;
352             }}) ;
353 
354         decoder.decode(buf.flip()) ;
355         DefaultMutableTupleNode decoded = ( DefaultMutableTupleNode )
356             list.get(0);
357         assertEquals( decoded.getTuple(), top.getTuple()) ;
358         */
359     }
360 
361 
362     public void testEquals()
363     {
364         DefaultMutableTupleNode top = new DefaultMutableTupleNode() ;
365         DefaultMutableTupleNode middle = new DefaultMutableTupleNode() ;
366         DefaultMutableTupleNode bottom = new DefaultMutableTupleNode() ;
367         top.insert( (MutableTupleNode) middle, 0 ) ;
368         middle.setParent( (MutableTupleNode) top) ;
369         middle.insert( (MutableTupleNode) bottom, 0 ) ;
370         bottom.setParent( (MutableTupleNode) middle) ;
371 
372         Tuple middleTuple = new Tuple( 1, 3, TypeClass.APPLICATION  ) ;
373         Tuple topTuple = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
374         Tuple bottomTuple = new Tuple( 3, 1, true, TypeClass.APPLICATION ) ;
375 
376         bottomTuple.typeClass = TypeClass.UNIVERSAL ;
377         top.setTuple( topTuple ) ;
378         middle.setTuple( middleTuple ) ;
379         bottom.setTuple( bottomTuple ) ;
380 
381         assertTrue( top.equals( top ) ) ;
382 
383         DefaultMutableTupleNode topClone = new DefaultMutableTupleNode() ;
384         topClone.setTuple( topTuple ) ;
385         assertFalse( top.equals(topClone)) ;
386 
387         topClone = new DefaultMutableTupleNode() ;
388         topClone.setTuple( bottomTuple ) ;
389         assertFalse( top.equals(topClone)) ;
390 
391         topClone = new DefaultMutableTupleNode() ;
392         DefaultMutableTupleNode middleClone = new DefaultMutableTupleNode() ;
393         DefaultMutableTupleNode bottomClone = new DefaultMutableTupleNode() ;
394         topClone.insert( (MutableTupleNode) middleClone, 0 ) ;
395         middleClone.setParent( (MutableTupleNode) topClone) ;
396         middleClone.insert( (MutableTupleNode) bottomClone, 0 ) ;
397         bottomClone.setParent( (MutableTupleNode) middleClone) ;
398 
399         Tuple middleTupleClone = new Tuple( 1, 3, TypeClass.APPLICATION  ) ;
400         Tuple topTupleClone = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
401         Tuple bottomTupleClone= new Tuple( 3, 1, true, TypeClass.APPLICATION ) ;
402 
403         bottomTupleClone.typeClass = TypeClass.UNIVERSAL ;
404         topClone.setTuple( topTupleClone ) ;
405         middleClone.setTuple( middleTupleClone ) ;
406         bottomClone.setTuple( bottomTupleClone ) ;
407 
408         assertTrue( bottom.equals( bottomClone ) ) ;
409         assertTrue( middle.equals( middleClone ) ) ;
410         assertTrue( top.equals( topClone ) ) ;
411      }
412 
413 
414     public void testEquals2()
415     {
416         DefaultMutableTupleNode top = new DefaultMutableTupleNode() ;
417         DefaultMutableTupleNode middle = new DefaultMutableTupleNode() ;
418         DefaultMutableTupleNode bottom = new DefaultMutableTupleNode() ;
419         top.insert( (MutableTupleNode) middle, 0 ) ;
420         middle.setParent( (MutableTupleNode) top) ;
421         middle.insert( (MutableTupleNode) bottom, 0 ) ;
422         bottom.setParent( (MutableTupleNode) middle) ;
423 
424         Tuple middleTuple = new Tuple( 1, 3, TypeClass.APPLICATION  ) ;
425         Tuple topTuple = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
426         Tuple bottomTuple = new Tuple( 3, 1, true, TypeClass.APPLICATION ) ;
427 
428         bottomTuple.typeClass = TypeClass.UNIVERSAL ;
429         top.setTuple( topTuple ) ;
430         middle.setTuple( middleTuple ) ;
431         bottom.setTuple( bottomTuple ) ;
432 
433         assertTrue( top.equals( top ) ) ;
434 
435         top.printDepthFirst(new StringBuffer(), 0 ) ;
436 
437         DefaultMutableTupleNode topClone = new DefaultMutableTupleNode() ;
438         topClone.setTuple( topTuple ) ;
439         assertFalse( top.equals(topClone)) ;
440 
441         topClone = new DefaultMutableTupleNode() ;
442         topClone.setTuple( bottomTuple ) ;
443         assertFalse( top.equals(topClone)) ;
444 
445         topClone = new DefaultMutableTupleNode() ;
446         DefaultMutableTupleNode middleClone = new DefaultMutableTupleNode() ;
447         DefaultMutableTupleNode bottomClone = new DefaultMutableTupleNode() ;
448         topClone.insert( (MutableTupleNode) middleClone, 0 ) ;
449         middleClone.setParent( (MutableTupleNode) topClone) ;
450         middleClone.insert( (MutableTupleNode) bottomClone, 0 ) ;
451         bottomClone.setParent( (MutableTupleNode) middleClone) ;
452 
453         Tuple middleTupleClone = new Tuple( 1, 3, TypeClass.APPLICATION  ) ;
454         Tuple topTupleClone = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
455         Tuple bottomTupleClone= new Tuple( 3, 1, true, TypeClass.APPLICATION ) ;
456 
457         bottomTupleClone.typeClass = TypeClass.UNIVERSAL ;
458         topClone.setTuple( topTupleClone ) ;
459         middleClone.setTuple( bottomTupleClone ) ;
460         bottomClone.setTuple( middleTupleClone ) ;
461 
462         assertFalse( bottom.equals( bottomClone ) ) ;
463         assertFalse( middle.equals( middleClone ) ) ;
464         assertFalse( top.equals( topClone ) ) ;
465         assertFalse( top.equals( new Object() ) ) ;
466         assertFalse( top.equals( null ) ) ;
467      }
468 
469 
470     /*
471      * Class to test for String toString()
472      */
473     public void testToString()
474     {
475         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
476         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
477         DefaultMutableTupleNode end = new DefaultMutableTupleNode() ;
478         parent.insert( end, 0 ) ;
479         end.setParent( parent) ;
480         parent.insert( node, 0 ) ;
481         node.setParent( parent) ;
482 
483         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
484         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
485         Tuple terminator = new Tuple( 0, 0, true, TypeClass.UNIVERSAL ) ;
486         terminator.typeClass = TypeClass.UNIVERSAL ;
487         parent.setTuple( constructed ) ;
488         node.setTuple( primitive ) ;
489         end.setTuple( terminator ) ;
490 
491         assertNotNull( parent.toString() ) ;
492     }
493 
494     public void testSetTupleTupleList()
495     {
496         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
497         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
498         DefaultMutableTupleNode end = new DefaultMutableTupleNode() ;
499         parent.insert( end, 0 ) ;
500         end.setParent( parent) ;
501         parent.insert( node, 0 ) ;
502         node.setParent( parent) ;
503 
504         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
505         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
506         Tuple terminator = new Tuple( 0, 0, true, TypeClass.UNIVERSAL ) ;
507         terminator.typeClass = TypeClass.UNIVERSAL ;
508         parent.setTuple( constructed ) ;
509         node.setTuple( primitive, Collections.EMPTY_LIST ) ;
510         end.setTuple( terminator ) ;
511 
512         assertTrue( node.getValueChunks().isEmpty() ) ;
513 
514 
515         node.addValueChunk( ByteBuffer.allocate( 3 ) ) ;
516         assertFalse( node.getValueChunks().isEmpty() ) ;
517     }
518 
519     public void testChildren()
520     {
521         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
522         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
523         DefaultMutableTupleNode end = new DefaultMutableTupleNode() ;
524         parent.insert( end, 0 ) ;
525         end.setParent( parent) ;
526         parent.insert( node, 0 ) ;
527         node.setParent( parent) ;
528 
529         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
530         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
531         Tuple terminator = new Tuple( 0, 0, true, TypeClass.UNIVERSAL ) ;
532         terminator.typeClass = TypeClass.UNIVERSAL ;
533         parent.setTuple( constructed ) ;
534         node.setTuple( primitive ) ;
535         end.setTuple( terminator ) ;
536 
537         Iterator list = parent.getChildren() ;
538 
539         assertEquals( node, list.next() ) ;
540         assertEquals( end, list.next() ) ;
541 
542         try
543         {
544             list.next() ;
545             fail( "should never get here due to thrown exception" ) ;
546         }
547         catch( Throwable t )
548         {
549             assertNotNull( t ) ;
550         }
551     }
552 
553     public void testGetAllowsChildren()
554     {
555         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
556         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
557         DefaultMutableTupleNode end = new DefaultMutableTupleNode() ;
558         parent.insert( end, 0 ) ;
559         end.setParent( parent) ;
560         parent.insert( node, 0 ) ;
561         node.setParent( parent) ;
562 
563         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
564         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
565         Tuple terminator = new Tuple( 0, 0, true, TypeClass.UNIVERSAL ) ;
566         terminator.typeClass = TypeClass.UNIVERSAL ;
567         parent.setTuple( constructed ) ;
568         node.setTuple( primitive ) ;
569         end.setTuple( terminator ) ;
570     }
571 
572     public void testAddFirst()
573     {
574         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
575         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
576         DefaultMutableTupleNode end = new DefaultMutableTupleNode() ;
577         parent.addFront( end ) ;
578         end.setParent( parent) ;
579         parent.addFront( node ) ;
580         node.setParent( parent) ;
581 
582         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
583         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
584         Tuple terminator = new Tuple( 0, 0, true, TypeClass.UNIVERSAL ) ;
585         terminator.typeClass = TypeClass.UNIVERSAL ;
586         parent.setTuple( constructed ) ;
587         node.setTuple( primitive ) ;
588         end.setTuple( terminator ) ;
589         parent.toDepthFirstString() ;
590     }
591 
592 
593     public void testAddLast()
594     {
595         DefaultMutableTupleNode parent = new DefaultMutableTupleNode() ;
596         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
597         DefaultMutableTupleNode end = new DefaultMutableTupleNode() ;
598         parent.addFront( node ) ;
599         node.setParent( (MutableTupleNode) parent) ;
600         parent.addLast( end ) ;
601         end.setParent( (MutableTupleNode) parent) ;
602 
603         Tuple primitive = new Tuple( 1, 3, true, TypeClass.APPLICATION ) ;
604         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
605         Tuple terminator = new Tuple( 0, 0, true, TypeClass.UNIVERSAL ) ;
606         terminator.typeClass = TypeClass.UNIVERSAL ;
607         parent.setTuple( constructed ) ;
608         node.setTuple( primitive ) ;
609         end.setTuple(terminator) ;
610     }
611 }