directory-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Alex Karasulu <aok...@bellsouth.net>
Subject Re: svn commit: r155926 [2/2] - in incubator/directory/asn1/trunk: ber/src/java/org/apache/asn1/ber/ ber/src/java/org/apache/asn1/ber/digester/rules/ ber/src/test/org/apache/asn1/ber/ ber/src/test/org/apache/asn1/ber/digester/rules/ ber/xdocs/ codec/src/java/org/apache/asn1/codec/stateful/ xdocs/
Date Mon, 07 Mar 2005 22:45:36 GMT
How come your log message did not say this?

Alan D. Cabrera wrote:

> The word indefinite was misspelled  If you look carefully, you'll see 
> that each file has it corrected.  It seems that my editor removed the 
> extra spaces on the end of some lines.
>
>
> Regards,
> Alan
>
> Alex Karasulu wrote:
>
>> Alan I don't see these diffs doing anything.  What was the point for 
>> these modifications?
>>
>> Alex
>>
>> adc@apache.org wrote:
>>
>>> Modified: 
>>> incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/DefaultMutableTupleNodeTest.java 
>>>
>>> URL: 
>>> http://svn.apache.org/viewcvs/incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/DefaultMutableTupleNodeTest.java?view=diff&r1=155925&r2=155926 
>>>
>>> ============================================================================== 
>>>
>>> --- 
>>> incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/DefaultMutableTupleNodeTest.java 
>>> (original)
>>> +++ 
>>> incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/DefaultMutableTupleNodeTest.java 
>>> Wed Mar  2 07:14:39 2005
>>> @@ -1,5 +1,5 @@
>>> /*
>>> - *   Copyright 2004 The Apache Software Foundation
>>> + *   Copyright 2004-2005 The Apache Software Foundation
>>>  *
>>>  *   Licensed under the Apache License, Version 2.0 (the "License");
>>>  *   you may not use this file except in compliance with the License.
>>> @@ -37,7 +37,7 @@
>>> {
>>>     public DefaultMutableTupleNodeTest()
>>>     {
>>> -        super ( DefaultMutableTupleNodeTest.class.getName() ) ; 
>>> +        super ( DefaultMutableTupleNodeTest.class.getName() ) ;
>>>     }
>>>
>>>
>>> @@ -85,7 +85,7 @@
>>>         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
>>>         parent.insert( (MutableTupleNode) node, 0 ) ;
>>>         node.setParent( (MutableTupleNode) parent) ;
>>> -        +
>>>         assertEquals(1,parent.getChildCount()) ;
>>>         node.removeFromParent() ;
>>>         assertEquals(0,parent.getChildCount()) ;
>>> @@ -147,7 +147,7 @@
>>>         assertTrue( parent.getChildren().hasNext()) ;
>>>     }
>>>
>>> -    +
>>>     public void testGetChildTupleNodeAt()
>>>     {
>>>     }
>>> @@ -175,13 +175,13 @@
>>>         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
>>>         parent.insert( (MutableTupleNode) node, 0 ) ;
>>>         node.setParent( (MutableTupleNode) parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         parent.setTuple( constructed ) ;
>>>         node.setTuple( primitive ) ;
>>> -        -        // fact that we use the indefinate form we 
>>> automatically add two to
>>> +
>>> +        // fact that we use the indefinite form we automatically 
>>> add two to
>>>         // the contained size
>>>         assertEquals(9, parent.size()) ;
>>>     }
>>> @@ -192,12 +192,12 @@
>>>         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
>>>         parent.insert( (MutableTupleNode) node, 0 ) ;
>>>         node.setParent( (MutableTupleNode) parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
>>>         parent.setTuple( constructed ) ;
>>>         node.setTuple( primitive ) ;
>>> -        +
>>>         assertEquals(7, parent.size()) ;
>>>     }
>>>
>>> @@ -206,7 +206,7 @@
>>>         DefaultMutableTupleNode parent = new 
>>> DefaultMutableTupleNode() ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         parent.setTuple( constructed ) ;
>>> -        +
>>>         assertEquals(4, parent.size()) ;
>>>     }
>>>
>>> @@ -219,7 +219,7 @@
>>>         ByteBuffer buf = ByteBuffer.allocate( 4 ) ;
>>>         parent.encode( buf ) ;
>>>
>>> -        +
>>>         /*
>>>         final ArrayList list = new ArrayList() ;
>>>         TupleTreeDecoder decoder = new TupleTreeDecoder() ;
>>> @@ -228,10 +228,10 @@
>>>             {
>>>                 list.add( arg1 ) ;
>>>             }}) ;
>>> -        +
>>>         decoder.decode(buf.flip()) ;
>>> -        DefaultMutableTupleNode decoded = ( DefaultMutableTupleNode 
>>> ) -            list.get(0); +        DefaultMutableTupleNode decoded 
>>> = ( DefaultMutableTupleNode )
>>> +            list.get(0);
>>>         assertEquals( decoded.getTuple(), parent.getTuple()) ;
>>>         */
>>>     }
>>> @@ -248,13 +248,13 @@
>>>     {
>>>         DefaultMutableTupleNode parent = new 
>>> DefaultMutableTupleNode() ;
>>>         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
>>> -        +
>>>         DefaultMutableTupleNode end = new DefaultMutableTupleNode() ;
>>>         parent.insert( (MutableTupleNode) end, 0 ) ;
>>>         end.setParent( (MutableTupleNode) parent) ;
>>>         parent.insert( (MutableTupleNode) node, 0 ) ;
>>>         node.setParent( (MutableTupleNode) parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         Tuple terminator = new Tuple( 0, 0, true, 
>>> TypeClass.UNIVERSAL ) ;
>>> @@ -262,9 +262,9 @@
>>>         parent.setTuple( constructed ) ;
>>>         node.setTuple( primitive ) ;
>>>         end.setTuple(terminator) ;
>>> -        +
>>>         assertEquals(9, parent.size()) ;
>>> -        +
>>>         ByteBuffer buf = ByteBuffer.allocate( 9 ) ;
>>>         parent.encode( buf ) ;
>>>
>>> @@ -276,10 +276,10 @@
>>>             {
>>>                 list.add( arg1 ) ;
>>>             }}) ;
>>> -        +
>>>         decoder.decode(buf.flip()) ;
>>> -        DefaultMutableTupleNode decoded = ( DefaultMutableTupleNode 
>>> ) -            list.get(0); +        DefaultMutableTupleNode decoded 
>>> = ( DefaultMutableTupleNode )
>>> +            list.get(0);
>>>         assertEquals( decoded.getTuple(), parent.getTuple()) ;
>>>         */
>>>     }
>>> @@ -290,15 +290,15 @@
>>>         DefaultMutableTupleNode node = new DefaultMutableTupleNode() ;
>>>         parent.insert( (MutableTupleNode) node, 0 ) ;
>>>         node.setParent( (MutableTupleNode) parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         parent.setTuple( constructed ) ;
>>>         node.setTuple( primitive ) ;
>>> -        -        // 2 extra bytes added for indefinate form
>>> +
>>> +        // 2 extra bytes added for indefinite form
>>>         assertEquals(9, parent.size()) ;
>>> -        +
>>>         ByteBuffer buf = ByteBuffer.allocate( 9 ) ;
>>>         parent.encode( buf ) ;
>>>
>>> @@ -310,10 +310,10 @@
>>>             {
>>>                 list.add( arg1 ) ;
>>>             }}) ;
>>> -        +
>>>         decoder.decode(buf.flip()) ;
>>> -        DefaultMutableTupleNode decoded = ( DefaultMutableTupleNode 
>>> ) -            list.get(0); +        DefaultMutableTupleNode decoded 
>>> = ( DefaultMutableTupleNode )
>>> +            list.get(0);
>>>         assertEquals( decoded.getTuple(), parent.getTuple()) ;
>>>         */
>>>     }
>>> @@ -327,18 +327,18 @@
>>>         middle.setParent( (MutableTupleNode) top) ;
>>>         middle.insert( (MutableTupleNode) bottom, 0 ) ;
>>>         bottom.setParent( (MutableTupleNode) middle) ;
>>> -        +
>>>         Tuple middleTuple = new Tuple( 1, 3, TypeClass.APPLICATION  ) ;
>>>         Tuple topTuple = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
>>>         Tuple bottomTuple = new Tuple( 3, 1, true, 
>>> TypeClass.APPLICATION ) ;
>>> -        +
>>>         bottomTuple.typeClass = TypeClass.UNIVERSAL ;
>>>         top.setTuple( topTuple ) ;
>>>         middle.setTuple( middleTuple ) ;
>>>         bottom.setTuple( bottomTuple ) ;
>>> -        +
>>>         assertEquals(7, top.size()) ;
>>> -        +
>>>         ByteBuffer buf = ByteBuffer.allocate( 7 ) ;
>>>         top.encode( buf ) ;
>>>
>>> @@ -350,15 +350,15 @@
>>>             {
>>>                 list.add( arg1 ) ;
>>>             }}) ;
>>> -        +
>>>         decoder.decode(buf.flip()) ;
>>> -        DefaultMutableTupleNode decoded = ( DefaultMutableTupleNode 
>>> ) -            list.get(0); +        DefaultMutableTupleNode decoded 
>>> = ( DefaultMutableTupleNode )
>>> +            list.get(0);
>>>         assertEquals( decoded.getTuple(), top.getTuple()) ;
>>>         */
>>>     }
>>>
>>> -    +
>>>     public void testEquals()
>>>     {
>>>         DefaultMutableTupleNode top = new DefaultMutableTupleNode() ;
>>> @@ -368,18 +368,18 @@
>>>         middle.setParent( (MutableTupleNode) top) ;
>>>         middle.insert( (MutableTupleNode) bottom, 0 ) ;
>>>         bottom.setParent( (MutableTupleNode) middle) ;
>>> -        +
>>>         Tuple middleTuple = new Tuple( 1, 3, TypeClass.APPLICATION  ) ;
>>>         Tuple topTuple = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
>>>         Tuple bottomTuple = new Tuple( 3, 1, true, 
>>> TypeClass.APPLICATION ) ;
>>> -        +
>>>         bottomTuple.typeClass = TypeClass.UNIVERSAL ;
>>>         top.setTuple( topTuple ) ;
>>>         middle.setTuple( middleTuple ) ;
>>>         bottom.setTuple( bottomTuple ) ;
>>>
>>>         assertTrue( top.equals( top ) ) ;
>>> -        +
>>>         DefaultMutableTupleNode topClone = new 
>>> DefaultMutableTupleNode() ;
>>>         topClone.setTuple( topTuple ) ;
>>>         assertFalse( top.equals(topClone)) ;
>>> @@ -387,7 +387,7 @@
>>>         topClone = new DefaultMutableTupleNode() ;
>>>         topClone.setTuple( bottomTuple ) ;
>>>         assertFalse( top.equals(topClone)) ;
>>> -        +
>>>         topClone = new DefaultMutableTupleNode() ;
>>>         DefaultMutableTupleNode middleClone = new 
>>> DefaultMutableTupleNode() ;
>>>         DefaultMutableTupleNode bottomClone = new 
>>> DefaultMutableTupleNode() ;
>>> @@ -395,11 +395,11 @@
>>>         middleClone.setParent( (MutableTupleNode) topClone) ;
>>>         middleClone.insert( (MutableTupleNode) bottomClone, 0 ) ;
>>>         bottomClone.setParent( (MutableTupleNode) middleClone) ;
>>> -        +
>>>         Tuple middleTupleClone = new Tuple( 1, 3, 
>>> TypeClass.APPLICATION  ) ;
>>>         Tuple topTupleClone = new Tuple ( 2, 5, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple bottomTupleClone= new Tuple( 3, 1, true, 
>>> TypeClass.APPLICATION ) ;
>>> -        +
>>>         bottomTupleClone.typeClass = TypeClass.UNIVERSAL ;
>>>         topClone.setTuple( topTupleClone ) ;
>>>         middleClone.setTuple( middleTupleClone ) ;
>>> @@ -409,8 +409,8 @@
>>>         assertTrue( middle.equals( middleClone ) ) ;
>>>         assertTrue( top.equals( topClone ) ) ;
>>>      }
>>> -    -    +
>>> +
>>>     public void testEquals2()
>>>     {
>>>         DefaultMutableTupleNode top = new DefaultMutableTupleNode() ;
>>> @@ -420,11 +420,11 @@
>>>         middle.setParent( (MutableTupleNode) top) ;
>>>         middle.insert( (MutableTupleNode) bottom, 0 ) ;
>>>         bottom.setParent( (MutableTupleNode) middle) ;
>>> -        +
>>>         Tuple middleTuple = new Tuple( 1, 3, TypeClass.APPLICATION  ) ;
>>>         Tuple topTuple = new Tuple ( 2, 5, TypeClass.APPLICATION ) ;
>>>         Tuple bottomTuple = new Tuple( 3, 1, true, 
>>> TypeClass.APPLICATION ) ;
>>> -        +
>>>         bottomTuple.typeClass = TypeClass.UNIVERSAL ;
>>>         top.setTuple( topTuple ) ;
>>>         middle.setTuple( middleTuple ) ;
>>> @@ -433,7 +433,7 @@
>>>         assertTrue( top.equals( top ) ) ;
>>>
>>>         top.printDepthFirst(new StringBuffer(), 0 ) ;
>>> -        +
>>>         DefaultMutableTupleNode topClone = new 
>>> DefaultMutableTupleNode() ;
>>>         topClone.setTuple( topTuple ) ;
>>>         assertFalse( top.equals(topClone)) ;
>>> @@ -441,7 +441,7 @@
>>>         topClone = new DefaultMutableTupleNode() ;
>>>         topClone.setTuple( bottomTuple ) ;
>>>         assertFalse( top.equals(topClone)) ;
>>> -        +
>>>         topClone = new DefaultMutableTupleNode() ;
>>>         DefaultMutableTupleNode middleClone = new 
>>> DefaultMutableTupleNode() ;
>>>         DefaultMutableTupleNode bottomClone = new 
>>> DefaultMutableTupleNode() ;
>>> @@ -449,11 +449,11 @@
>>>         middleClone.setParent( (MutableTupleNode) topClone) ;
>>>         middleClone.insert( (MutableTupleNode) bottomClone, 0 ) ;
>>>         bottomClone.setParent( (MutableTupleNode) middleClone) ;
>>> -        +
>>>         Tuple middleTupleClone = new Tuple( 1, 3, 
>>> TypeClass.APPLICATION  ) ;
>>>         Tuple topTupleClone = new Tuple ( 2, 5, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple bottomTupleClone= new Tuple( 3, 1, true, 
>>> TypeClass.APPLICATION ) ;
>>> -        +
>>>         bottomTupleClone.typeClass = TypeClass.UNIVERSAL ;
>>>         topClone.setTuple( topTupleClone ) ;
>>>         middleClone.setTuple( bottomTupleClone ) ;
>>> @@ -465,8 +465,8 @@
>>>         assertFalse( top.equals( new Object() ) ) ;
>>>         assertFalse( top.equals( null ) ) ;
>>>      }
>>> -    -    +
>>> +
>>>     /*
>>>      * Class to test for String toString()
>>>      */
>>> @@ -479,7 +479,7 @@
>>>         end.setParent( parent) ;
>>>         parent.insert( node, 0 ) ;
>>>         node.setParent( parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         Tuple terminator = new Tuple( 0, 0, true, 
>>> TypeClass.UNIVERSAL ) ;
>>> @@ -487,7 +487,7 @@
>>>         parent.setTuple( constructed ) ;
>>>         node.setTuple( primitive ) ;
>>>         end.setTuple( terminator ) ;
>>> -        +
>>>         assertNotNull( parent.toString() ) ;
>>>     }
>>>
>>> @@ -500,7 +500,7 @@
>>>         end.setParent( parent) ;
>>>         parent.insert( node, 0 ) ;
>>>         node.setParent( parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         Tuple terminator = new Tuple( 0, 0, true, 
>>> TypeClass.UNIVERSAL ) ;
>>> @@ -508,7 +508,7 @@
>>>         parent.setTuple( constructed ) ;
>>>         node.setTuple( primitive, Collections.EMPTY_LIST ) ;
>>>         end.setTuple( terminator ) ;
>>> -        +
>>>         assertTrue( node.getValueChunks().isEmpty() ) ;
>>>
>>>
>>> @@ -525,7 +525,7 @@
>>>         end.setParent( parent) ;
>>>         parent.insert( node, 0 ) ;
>>>         node.setParent( parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         Tuple terminator = new Tuple( 0, 0, true, 
>>> TypeClass.UNIVERSAL ) ;
>>> @@ -533,18 +533,18 @@
>>>         parent.setTuple( constructed ) ;
>>>         node.setTuple( primitive ) ;
>>>         end.setTuple( terminator ) ;
>>> -        +
>>>         Iterator list = parent.getChildren() ;
>>> -        +
>>>         assertEquals( node, list.next() ) ;
>>>         assertEquals( end, list.next() ) ;
>>> -        +
>>>         try
>>>         {
>>>             list.next() ;
>>>             fail( "should never get here due to thrown exception" ) ;
>>>         }
>>> -        catch( Throwable t ) +        catch( Throwable t )
>>>         {
>>>             assertNotNull( t ) ;
>>>         }
>>> @@ -559,7 +559,7 @@
>>>         end.setParent( parent) ;
>>>         parent.insert( node, 0 ) ;
>>>         node.setParent( parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         Tuple terminator = new Tuple( 0, 0, true, 
>>> TypeClass.UNIVERSAL ) ;
>>> @@ -578,7 +578,7 @@
>>>         end.setParent( parent) ;
>>>         parent.addFront( node ) ;
>>>         node.setParent( parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         Tuple terminator = new Tuple( 0, 0, true, 
>>> TypeClass.UNIVERSAL ) ;
>>> @@ -589,7 +589,7 @@
>>>         parent.toDepthFirstString() ;
>>>     }
>>>
>>> -    +
>>>     public void testAddLast()
>>>     {
>>>         DefaultMutableTupleNode parent = new 
>>> DefaultMutableTupleNode() ;
>>> @@ -599,7 +599,7 @@
>>>         node.setParent( (MutableTupleNode) parent) ;
>>>         parent.addLast( end ) ;
>>>         end.setParent( (MutableTupleNode) parent) ;
>>> -        +
>>>         Tuple primitive = new Tuple( 1, 3, true, 
>>> TypeClass.APPLICATION ) ;
>>>         Tuple constructed = new Tuple ( 2, TypeClass.APPLICATION ) ;
>>>         Tuple terminator = new Tuple( 0, 0, true, 
>>> TypeClass.UNIVERSAL ) ;
>>>
>>> Modified: 
>>> incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/TupleTest.java 
>>>
>>> URL: 
>>> http://svn.apache.org/viewcvs/incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/TupleTest.java?view=diff&r1=155925&r2=155926 
>>>
>>> ============================================================================== 
>>>
>>> --- 
>>> incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/TupleTest.java 
>>> (original)
>>> +++ 
>>> incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/TupleTest.java 
>>> Wed Mar  2 07:14:39 2005
>>> @@ -1,5 +1,5 @@
>>> /*
>>> - *   Copyright 2004 The Apache Software Foundation
>>> + *   Copyright 2004-2005 The Apache Software Foundation
>>>  *
>>>  *   Licensed under the Apache License, Version 2.0 (the "License");
>>>  *   you may not use this file except in compliance with the License.
>>> @@ -142,14 +142,14 @@
>>>         assertEquals( 2, t.getId() ) ;
>>>         assertEquals( TypeClass.PRIVATE, t.getTypeClass() ) ;
>>>         assertEquals( false, t.isPrimitive() ) ;
>>> -        assertEquals( Length.INDEFINATE, t.getLength() ) ;
>>> +        assertEquals( Length.INDEFINITE, t.getLength() ) ;
>>>         assertEquals( EMPTY_BUFFER, t.getLastValueChunk() ) ;
>>>
>>>         t = new Tuple( 2, (TypeClass) null ) ;
>>>         assertEquals( 2, t.getId() ) ;
>>>         assertEquals( TypeClass.APPLICATION, t.getTypeClass() ) ;
>>>         assertEquals( false, t.isPrimitive() ) ;
>>> -        assertEquals( Length.INDEFINATE, t.getLength() ) ;
>>> +        assertEquals( Length.INDEFINITE, t.getLength() ) ;
>>>         assertEquals( EMPTY_BUFFER, t.getLastValueChunk() ) ;
>>>     }
>>>
>>> @@ -162,8 +162,8 @@
>>>         t.id = 21 ;
>>>         assertEquals( 21, t.getId() ) ;
>>>     }
>>> -    -    +
>>> +
>>>     public void testSize()
>>>     {
>>>         Tuple t = new Tuple( 1, TypeClass.APPLICATION ) ;
>>> @@ -178,7 +178,7 @@
>>>         assertEquals( 5, t.size() ) ;
>>>         t.id = 1 << 21 ;
>>>         assertEquals( 6, t.size() ) ;
>>> -        +
>>>         t.length = 127 ;
>>>         assertEquals( 6+127, t.size() ) ;
>>>         t.length = 128 ;
>>> @@ -188,28 +188,28 @@
>>>         t.length = 256 ;
>>>         assertEquals( 8+256, t.size() ) ;
>>>     }
>>> -    -    -    public void testIsIndefinate()
>>> +
>>> +
>>> +    public void testIsIndefinite()
>>>     {
>>>         Tuple t = new Tuple() ;
>>> -        assertFalse( t.isIndefinate() ) ;
>>> -        t.length = Length.INDEFINATE ;
>>> -        assertTrue( t.isIndefinate() ) ;
>>> +        assertFalse( t.isIndefinite() ) ;
>>> +        t.length = Length.INDEFINITE ;
>>> +        assertTrue( t.isIndefinite() ) ;
>>>     }
>>> -   -    public void testIsIndefinateTerminator()
>>> +
>>> +    public void testIsIndefiniteTerminator()
>>>     {
>>>         Tuple t = new Tuple() ;
>>> -        assertFalse( t.isIndefinateTerminator() ) ;
>>> +        assertFalse( t.isIndefiniteTerminator() ) ;
>>>         t.id = 0 ;
>>>         t.length = 0 ;
>>>         t.isPrimitive = true ;
>>>         t.typeClass = TypeClass.UNIVERSAL ;
>>> -        assertTrue( t.isIndefinateTerminator() ) ;
>>> +        assertTrue( t.isIndefiniteTerminator() ) ;
>>>     }
>>> -    +
>>>
>>>     public void testIsPrimitive()
>>>     {
>>> @@ -300,13 +300,13 @@
>>>         Tuple tnull1 = new Tuple() ;
>>>         tnull1.valueChunk = null ;
>>>         tnull0.equals( tnull1 ) ;
>>> -        +
>>>         tnull1.equals( tnull1 ) ;
>>>         tnull0.equals( tnull0 ) ;
>>> -        +
>>>         Tuple t0 = new Tuple() ;
>>>         Tuple t1 = ( Tuple ) t0.clone() ;
>>> -        +
>>>         assertTrue( t0.equals( t1 ) ) ;
>>>         t0.id = 23 ;
>>>         assertFalse( t0.equals( t1 ) ) ;
>>> @@ -346,10 +346,10 @@
>>>
>>>         t0.valueChunk = ByteBuffer.allocate( 4 ) ;
>>>         t1.valueChunk = null ;
>>> -        +
>>>         // The buffer does not factor into equality
>>>         assertTrue( t0.equals( t1 ) ) ;
>>> -        +
>>>         t1 = ( Tuple ) t0.clone() ;
>>>         assertTrue( t0.equals( t1 ) ) ;
>>>
>>> @@ -567,13 +567,13 @@
>>>                 , toAsciiString( encoded ) ) ;
>>>     }
>>>
>>> -    +
>>>     public String toAsciiString( ByteBuffer buf )
>>>     {
>>>         return BinaryCodec.toAsciiString( buf.array() ) ;
>>>     }
>>> -    -    +
>>> +
>>>     public void testSetTagBufferint()
>>>     {
>>>         ByteBuffer bites = ByteBuffer.allocate( 1 ) ;
>>> @@ -581,7 +581,7 @@
>>>         t.setTag( bites, 1 ) ;
>>>         String binary = toAsciiString( bites ) ;
>>>         assertEquals( "01100000", binary ) ;
>>> -        +
>>>         bites = ByteBuffer.allocate( 1 ) ;
>>>         t = new Tuple( 30, 0 ) ;
>>>         t.setTag( bites, 1 ) ;
>>> @@ -617,8 +617,8 @@
>>>         t = new Tuple( BIT_13 - 1, 0 ) ;
>>>         t.setTag( bites, 3 ) ;
>>>         binary = toAsciiString( bites ) ;
>>> -        assertEquals( "01111111" + -                      
>>> "11111111" + +        assertEquals( "01111111" +
>>> +                      "11111111" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 4 ) ;
>>> @@ -627,7 +627,7 @@
>>>         binary = toAsciiString( bites ) ;
>>>         assertEquals( "00000000" +
>>>                       "10000000" +
>>> -                      "10000001" + +                      "10000001" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 4 ) ;
>>> @@ -636,16 +636,16 @@
>>>         binary = toAsciiString( bites ) ;
>>>         assertEquals( "00000001" +
>>>                       "10000000" +
>>> -                      "10000001" + +                      "10000001" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 4 ) ;
>>>         t = new Tuple( BIT_20 - 1, 0 ) ;
>>>         t.setTag( bites, 4 ) ;
>>>         binary = toAsciiString( bites ) ;
>>> -        assertEquals( "01111111" + -                      
>>> "11111111" + -                      "11111111" + +        
>>> assertEquals( "01111111" +
>>> +                      "11111111" +
>>> +                      "11111111" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 5 ) ;
>>> @@ -655,7 +655,7 @@
>>>         assertEquals( "00000000" +
>>>                       "10000000" +
>>>                       "10000000" +
>>> -                      "10000001" + +                      "10000001" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 5 ) ;
>>> @@ -665,22 +665,22 @@
>>>         assertEquals( "00000001" +
>>>                       "10000000" +
>>>                       "10000000" +
>>> -                      "10000001" + +                      "10000001" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 5 ) ;
>>>         t = new Tuple( BIT_27 - 1, 0 ) ;
>>>         t.setTag( bites, 5 ) ;
>>>         binary = toAsciiString( bites ) ;
>>> -        assertEquals( "01111111" + -                      
>>> "11111111" + -                      "11111111" + 
>>> -                      "11111111" + +        assertEquals( "01111111" +
>>> +                      "11111111" +
>>> +                      "11111111" +
>>> +                      "11111111" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 6 ) ;
>>>         t = new Tuple( BIT_27, 0 ) ;
>>> -        +
>>>         try
>>>         {
>>>             t.setTag( bites, 6 ) ;
>>> @@ -699,7 +699,7 @@
>>>         t.setTag( bites, 1 ) ;
>>>         String binary = toAsciiString( bites ) ;
>>>         assertEquals( "01100000", binary ) ;
>>> -        +
>>>         bites = ByteBuffer.allocate( 1 ) ;
>>>         t = new Tuple( 30, 0 ) ;
>>>         t.setTag( bites, 1 ) ;
>>> @@ -735,8 +735,8 @@
>>>         t = new Tuple( BIT_13 - 1, 0 ) ;
>>>         t.setTag( bites, 3 ) ;
>>>         binary = toAsciiString( bites ) ;
>>> -        assertEquals( "01111111" + -                      
>>> "11111111" + +        assertEquals( "01111111" +
>>> +                      "11111111" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 4 ) ;
>>> @@ -745,7 +745,7 @@
>>>         binary = toAsciiString( bites ) ;
>>>         assertEquals( "00000000" +
>>>                       "10000000" +
>>> -                      "10000001" + +                      "10000001" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 4 ) ;
>>> @@ -754,16 +754,16 @@
>>>         binary = toAsciiString( bites ) ;
>>>         assertEquals( "00000001" +
>>>                       "10000000" +
>>> -                      "10000001" + +                      "10000001" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 4 ) ;
>>>         t = new Tuple( BIT_20 - 1, 0 ) ;
>>>         t.setTag( bites, 4 ) ;
>>>         binary = toAsciiString( bites ) ;
>>> -        assertEquals( "01111111" + -                      
>>> "11111111" + -                      "11111111" + +        
>>> assertEquals( "01111111" +
>>> +                      "11111111" +
>>> +                      "11111111" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 5 ) ;
>>> @@ -773,7 +773,7 @@
>>>         assertEquals( "00000000" +
>>>                       "10000000" +
>>>                       "10000000" +
>>> -                      "10000001" + +                      "10000001" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 5 ) ;
>>> @@ -783,22 +783,22 @@
>>>         assertEquals( "00000001" +
>>>                       "10000000" +
>>>                       "10000000" +
>>> -                      "10000001" + +                      "10000001" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 5 ) ;
>>>         t = new Tuple( BIT_27 - 1, 0 ) ;
>>>         t.setTag( bites, 5 ) ;
>>>         binary = toAsciiString( bites ) ;
>>> -        assertEquals( "01111111" + -                      
>>> "11111111" + -                      "11111111" + 
>>> -                      "11111111" + +        assertEquals( "01111111" +
>>> +                      "11111111" +
>>> +                      "11111111" +
>>> +                      "11111111" +
>>>                       "01111111", binary ) ;
>>>
>>>         bites = ByteBuffer.allocate( 6 ) ;
>>>         t = new Tuple( BIT_27, 0 ) ;
>>> -        +
>>>         try
>>>         {
>>>             t.setTag( bites, 6 ) ;
>>> @@ -809,8 +809,8 @@
>>>             assertNotNull( e ) ;
>>>         }
>>>     }
>>> -    -    +
>>> +
>>>     String toAsciiString( int raw )
>>>     {
>>>         byte[] intBytes = new byte[4] ;
>>> @@ -818,10 +818,10 @@
>>>         intBytes[1] = (byte) ( (int) ( 0x0000ff00 & raw ) >> 8 ) ;
>>>         intBytes[2] = (byte) ( (int) ( 0x00ff0000 & raw ) >> 16 ) ;
>>>         intBytes[3] = (byte) ( (int) ( 0xff000000 & raw ) >> 24 ) ;
>>> -        +
>>>         return BinaryCodec.toAsciiString( intBytes ) ;
>>>     }
>>> -    +
>>>
>>>     public void testSetLengthBuffer()
>>>     {
>>> @@ -1064,7 +1064,7 @@
>>>         assertEquals( 4, t.getTagLength() ) ;
>>>         t.id = BIT_13 + 100 ;
>>>         assertEquals( 4, t.getTagLength() ) ;
>>> -        +
>>>         t.id = BIT_20 - 1 ;
>>>         assertEquals( 4, t.getTagLength() ) ;
>>>         t.id = BIT_20 ;
>>> @@ -1076,7 +1076,7 @@
>>>         assertEquals( 5, t.getTagLength() ) ;
>>>
>>>         t.id = BIT_27 ;
>>> -        +
>>>         try
>>>         {
>>>             assertEquals( 6, t.getTagLength() ) ;
>>> @@ -1107,7 +1107,7 @@
>>>         assertEquals( 4, t.getLengthLength() ) ;
>>>         t.length = BIT_15 + 100 ;
>>>         assertEquals( 4, t.getLengthLength() ) ;
>>> -        +
>>>         t.length = BIT_23 - 1 ;
>>>         assertEquals( 4, t.getLengthLength() ) ;
>>>         t.length = BIT_23 ;
>>> @@ -1118,7 +1118,7 @@
>>>         t.length = Integer.MAX_VALUE ;
>>>         assertEquals( 5, t.getLengthLength() ) ;
>>>
>>> -        +
>>>         t.length = Integer.MAX_VALUE + 1 ;
>>>         try
>>>         {
>>> @@ -1129,6 +1129,6 @@
>>>         {
>>>             assertNotNull( e ) ;
>>>         }
>>> -        +
>>>     }
>>> }
>>>
>>> Modified: 
>>> incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/digester/rules/PrimitiveOctetStringRuleTest.java 
>>>
>>> URL: 
>>> http://svn.apache.org/viewcvs/incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/digester/rules/PrimitiveOctetStringRuleTest.java?view=diff&r1=155925&r2=155926 
>>>
>>> ============================================================================== 
>>>
>>> --- 
>>> incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/digester/rules/PrimitiveOctetStringRuleTest.java 
>>> (original)
>>> +++ 
>>> incubator/directory/asn1/trunk/ber/src/test/org/apache/asn1/ber/digester/rules/PrimitiveOctetStringRuleTest.java 
>>> Wed Mar  2 07:14:39 2005
>>> @@ -1,5 +1,5 @@
>>> /*
>>> - *   Copyright 2004 The Apache Software Foundation
>>> + *   Copyright 2004-2005 The Apache Software Foundation
>>>  *
>>>  *   Licensed under the Apache License, Version 2.0 (the "License");
>>>  *   you may not use this file except in compliance with the License.
>>> @@ -99,12 +99,12 @@
>>>
>>>
>>>     /**
>>> -     * Tests when the length is indefinate.
>>> +     * Tests when the length is indefinite.
>>>      */
>>> -    public void testIndefinateLength()
>>> +    public void testIndefiniteLength()
>>>     {
>>>         rule.tag( UniversalTag.OCTET_STRING.getTagId(), true, null ) ;
>>> -        rule.length( Length.INDEFINATE ) ;
>>> +        rule.length( Length.INDEFINITE ) ;
>>>         rule.finish() ;
>>>         ByteBuffer buf = ( ByteBuffer ) digester.pop() ;
>>>         assertFalse( buf.hasRemaining() ) ;
>>> @@ -112,12 +112,12 @@
>>>
>>>
>>>     /**
>>> -     * Tests when the length is indefinate.
>>> +     * Tests when the length is indefinite.
>>>      */
>>>     public void testNullValue()
>>>     {
>>>         rule.tag( UniversalTag.OCTET_STRING.getTagId(), true, null ) ;
>>> -        rule.length( Length.INDEFINATE ) ;
>>> +        rule.length( Length.INDEFINITE ) ;
>>>         rule.value( null ) ;
>>>         rule.value( ByteBuffer.allocate( 0 ) ) ;
>>>         rule.finish() ;
>>>
>>> Modified: incubator/directory/asn1/trunk/ber/xdocs/BERDecoderDesign.xml
>>> URL: 
>>> http://svn.apache.org/viewcvs/incubator/directory/asn1/trunk/ber/xdocs/BERDecoderDesign.xml?view=diff&r1=155925&r2=155926 
>>>
>>> ============================================================================== 
>>>
>>> --- incubator/directory/asn1/trunk/ber/xdocs/BERDecoderDesign.xml 
>>> (original)
>>> +++ incubator/directory/asn1/trunk/ber/xdocs/BERDecoderDesign.xml 
>>> Wed Mar  2 07:14:39 2005
>>> @@ -22,7 +22,7 @@
>>>         <p>
>>>           A constructed TLV tuple contains other TLV tuples nested 
>>> within the
>>>           Value field, and so on, recursively.  The nesting depth is 
>>> usually
>>> -          indefinate and dependent on the data structures being 
>>> transformed.
>>> +          indefinite and dependent on the data structures being 
>>> transformed.
>>>           This fact drastically affects the way the decoder is 
>>> designed and
>>>           hence operates.
>>>         </p>
>>> @@ -61,7 +61,7 @@
>>>
>>>         <p>
>>>           Now let's try to figure out how to handle constructed TLV 
>>> tuples
>>> -          which recursively nest other tuples indefinately.  State now
>>> +          which recursively nest other tuples indefinitely.  State now
>>>           is more that just where you left off in the current tuple 
>>> being
>>>           processed.  When processing an inner tuple the decoder 
>>> must also know
>>>           where it left off in the outter tuple to resume 
>>> processing.  More
>>>
>>> Modified: 
>>> incubator/directory/asn1/trunk/codec/src/java/org/apache/asn1/codec/stateful/CallbackHistory.java 
>>>
>>> URL: 
>>> http://svn.apache.org/viewcvs/incubator/directory/asn1/trunk/codec/src/java/org/apache/asn1/codec/stateful/CallbackHistory.java?view=diff&r1=155925&r2=155926 
>>>
>>> ============================================================================== 
>>>
>>> --- 
>>> incubator/directory/asn1/trunk/codec/src/java/org/apache/asn1/codec/stateful/CallbackHistory.java 
>>> (original)
>>> +++ 
>>> incubator/directory/asn1/trunk/codec/src/java/org/apache/asn1/codec/stateful/CallbackHistory.java 
>>> Wed Mar  2 07:14:39 2005
>>> @@ -1,5 +1,5 @@
>>> /*
>>> - *   Copyright 2004 The Apache Software Foundation
>>> + *   Copyright 2004-2005 The Apache Software Foundation
>>>  *
>>>  *   Licensed under the Apache License, Version 2.0 (the "License");
>>>  *   you may not use this file except in compliance with the License.
>>> @@ -36,33 +36,33 @@
>>>     private final LinkedList history ;
>>>     /** the length of callback history stored */
>>>     private final int length ;
>>> -    +
>>>
>>>     /**
>>> -     * Creates an auditing callback that manages a history of 
>>> indefinate length.
>>> +     * Creates an auditing callback that manages a history of 
>>> indefinite length.
>>>      */
>>>     public CallbackHistory()
>>>     {
>>>         this( -1 ) ;
>>>     }
>>> -    -    +
>>> +
>>>     /**
>>> -     * Creates an auditing callback that manages a history of fixed 
>>> or -     * indefinate length.  If the length is fixed the history 
>>> effectively +     * Creates an auditing callback that manages a 
>>> history of fixed or
>>> +     * indefinite length.  If the length is fixed the history 
>>> effectively
>>>      * becomes a FIFO structure.
>>> -     * +     *
>>>      * @param length the maximum length of callback history to store 
>>> before
>>> -     *  dropping decoded items, a length of zero or 1 corresponds 
>>> to indefinate
>>> -     *  history +     *  dropping decoded items, a length of zero 
>>> or 1 corresponds to indefinite
>>> +     *  history
>>>      */
>>>     public CallbackHistory( int length )
>>>     {
>>>         this.length = length ;
>>>         history = new LinkedList() ;
>>>     }
>>> -    -    +
>>> +
>>>     /* (non-Javadoc)
>>>      * @see 
>>> org.apache.asn1.codec.stateful.DecoderCallback#decodeOccurred(
>>>      * org.apache.asn1.codec.stateful.StatefulDecoder, 
>>> java.lang.Object)
>>> @@ -70,13 +70,13 @@
>>>     public void decodeOccurred( StatefulDecoder decoder, Object 
>>> decoded )
>>>     {
>>>         if ( length > 0 )
>>> -        {    +        {
>>>             while ( history.size() >= length )
>>>             {
>>>                 history.removeLast() ;
>>>             }
>>>         }
>>> -        +
>>>         history.addFirst( decoded ) ;
>>>     }
>>>
>>> @@ -103,7 +103,7 @@
>>>
>>>     /**
>>>      * Gets the most recent decoded object if one exists.
>>> -     * +     *
>>>      * @return the most recent decoded object
>>>      * @throws java.util.NoSuchElementException if the history is empty
>>>      */
>>> @@ -111,11 +111,11 @@
>>>     {
>>>         return history.getFirst() ;
>>>     }
>>> -    -    +
>>> +
>>>     /**
>>>      * Gets the oldest decoded object if one exists.
>>> -     * +     *
>>>      * @return the oldest decoded object
>>>      * @throws java.util.NoSuchElementException if the history is empty
>>>      */
>>> @@ -123,19 +123,19 @@
>>>     {
>>>         return history.getLast() ;
>>>     }
>>> -    -    +
>>> +
>>>     /**
>>>      * Tests to see if the history is empty.
>>> -     * +     *
>>>      * @return true if the history is empty, false otherwise
>>>      */
>>>     public boolean isEmpty()
>>>     {
>>>         return history.isEmpty() ;
>>>     }
>>> -    -    +
>>> +
>>>     /**
>>>      * Clears the history of decoded items.
>>>      */
>>> @@ -143,11 +143,11 @@
>>>     {
>>>         history.clear() ;
>>>     }
>>> -    -    +
>>> +
>>>     /**
>>>      * Gets the number of decoded items in the callback history.
>>> -     * +     *
>>>      * @return the number of decoded items in the callback history
>>>      */
>>>     public int size()
>>>
>>> Modified: incubator/directory/asn1/trunk/xdocs/refactor.xml
>>> URL: 
>>> http://svn.apache.org/viewcvs/incubator/directory/asn1/trunk/xdocs/refactor.xml?view=diff&r1=155925&r2=155926 
>>>
>>> ============================================================================== 
>>>
>>> --- incubator/directory/asn1/trunk/xdocs/refactor.xml (original)
>>> +++ incubator/directory/asn1/trunk/xdocs/refactor.xml Wed Mar  2 
>>> 07:14:39 2005
>>> @@ -166,7 +166,7 @@
>>>           are still abstract.  This is because we need to 
>>> differentiate further
>>>           for buffered verses streamed Tuples in the case of 
>>> primitive Tuples.
>>>           For constructed Tuples we need to differentiate between 
>>> definate
>>> -          length verses indefinate length Tuples.  With our 
>>> approach, only the +          length verses indefinite length 
>>> Tuples.  With our approach, only the           leaf nodes of the 
>>> inheritance hierarchy will be concrete.  Below is
>>>           the definition for the PrimitiveTuple.
>>>         </p>
>>> @@ -251,10 +251,10 @@
>>>
>>>     /**
>>>      * Gets whether or not the length of this constructed Tuple is 
>>> of the -     * definate form or of the indefinate length form.
>>> +     * definate form or of the indefinite length form.
>>>      *
>>>      * @return true if the length is definate, false if the length 
>>> is of the
>>> -     * indefinate form
>>> +     * indefinite form
>>>      */
>>>     public abstract boolean isLengthDefinate();
>>> }
>>> @@ -264,21 +264,21 @@
>>>           ConstructedTuple implements the 
>>> <code>isConstructed()</code> method           as final since it will 
>>> always return false for this lineage of           Tuples.  Also a 
>>> new abstract method isLengthDefinate() is introduced -          to 
>>> see if the Tuple uses the indefinate length form or not.  +          
>>> to see if the Tuple uses the indefinite length form or not.          
>>> </p>
>>>       </subsection>
>>>
>>> -      <subsection name="Definate Vs. Indefinate Length">
>>> +      <subsection name="Definate Vs. Indefinite Length">
>>>         <p>
>>>           The ConstructedTuple can be further differentiated into 
>>> two -          subclasses to represent definate and indefinate 
>>> length constructed -          TLV Tuples.  The indefinate form does 
>>> not have a length value +          subclasses to represent definate 
>>> and indefinite length constructed +          TLV Tuples.  The 
>>> indefinite form does not have a length value           associated 
>>> with it where as the definate lenght form does.  Let's
>>> -          explore the concrete IndefinateLegthTuple definition.
>>> +          explore the concrete IndefiniteLegthTuple definition.
>>>         </p>
>>>
>>> <source>
>>> -public class IndefinateLength extends ConstructedTuple
>>> +public class IndefiniteLength extends ConstructedTuple
>>> {
>>>     public final boolean isLengthDefinate()
>>>     {
>>>
>>>
>>>
>>>  
>>>
>
>


Mime
View raw message