directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From akaras...@apache.org
Subject svn commit: rev 9765 - in incubator/directory/snickers/trunk: . ber ber/src/java/org/apache/snickers ber/src/java/org/apache/snickers/asn ber/src/java/org/apache/snickers/ber ber/src/test/org/apache/snickers ber/src/test/org/apache/snickers/ber codec-stateful codec-stateful/src/java/org/apache/commons/codec/stateful xdocs xdocs/ber-codec xdocs/stub-compiler
Date Sat, 27 Mar 2004 01:11:12 GMT
Author: akarasulu
Date: Fri Mar 26 17:11:11 2004
New Revision: 9765

Added:
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/AbstractBufferedDecoderTestCase.java   (props changed)
      - copied unchanged from rev 9764, incubator/directory/snickers/branches/buffer-branch/ber/src/java/org/apache/snickers/ber/AbstractBufferedDecoderTestCase.java
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/AbstractChunkingBERDecoderTestCase.java   (props changed)
      - copied unchanged from rev 9764, incubator/directory/snickers/branches/buffer-branch/ber/src/java/org/apache/snickers/ber/AbstractChunkingBERDecoderTestCase.java
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERBufferedDecoder.java   (props changed)
      - copied unchanged from rev 9764, incubator/directory/snickers/branches/buffer-branch/ber/src/java/org/apache/snickers/ber/BERBufferedDecoder.java
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/ChunkingBERDecoder.java   (props changed)
      - copied unchanged from rev 9764, incubator/directory/snickers/branches/buffer-branch/ber/src/java/org/apache/snickers/ber/ChunkingBERDecoder.java
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/ChunkingTuple.java   (props changed)
      - copied unchanged from rev 9764, incubator/directory/snickers/branches/buffer-branch/ber/src/java/org/apache/snickers/ber/ChunkingTuple.java
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/BERBufferedDecoderTest.java   (props changed)
      - copied unchanged from rev 9764, incubator/directory/snickers/branches/buffer-branch/ber/src/test/org/apache/snickers/ber/BERBufferedDecoderTest.java
Modified:
   incubator/directory/snickers/trunk/ber/berlib.properties   (props changed)
   incubator/directory/snickers/trunk/ber/project.properties   (props changed)
   incubator/directory/snickers/trunk/ber/project.xml   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/SnickersDecoder.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/asn/BERDecoderUtils.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/asn/Primitive.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/AbstractDecoderTestCase.java   (contents, props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoder.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderCallback.java   (contents, props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderCallbackAdapter.java   (contents, props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderMonitor.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderState.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/DefaultMutableTupleNode.java   (contents, props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/IntStack.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/Length.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/LengthDecoder.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/MutableTupleNode.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/Tag.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/TagDecoder.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/Tuple.java   (contents, props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/TupleNode.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/TupleTreeAnalyzer.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/TupleTreeDecoder.java   (contents, props changed)
   incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/TypeClass.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/SnickersDecoderTest.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/AbstractDecoderTestCaseTest.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/BERDecoderCallbackAdapterTest.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/BERDecoderStateTest.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/BERDecoderTest.java   (contents, props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/ConstructedTLVTests.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/DefaultMutableTupleNodeTest.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/EncodeDecodeTests.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/IntStackTest.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/LdapMessageTests.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/LengthTest.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/MultiByteLengthTests.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/MultiByteTagTests.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/ObjectVersePrimitiveTest.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/SimplePrimitiveTLVTests.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/SingleByteLengthTests.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/SingleByteTagTests.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TagTest.java   (props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TupleTest.java   (contents, props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TupleTreeDecoderTest.java   (contents, props changed)
   incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TypeClassTest.java   (props changed)
   incubator/directory/snickers/trunk/codec-stateful/project.properties   (props changed)
   incubator/directory/snickers/trunk/codec-stateful/project.xml   (props changed)
   incubator/directory/snickers/trunk/codec-stateful/src/java/org/apache/commons/codec/stateful/AbstractStatefulDecoder.java   (props changed)
   incubator/directory/snickers/trunk/codec-stateful/src/java/org/apache/commons/codec/stateful/CallbackHistory.java   (props changed)
   incubator/directory/snickers/trunk/codec-stateful/src/java/org/apache/commons/codec/stateful/DecoderCallback.java   (props changed)
   incubator/directory/snickers/trunk/codec-stateful/src/java/org/apache/commons/codec/stateful/DecoderMonitor.java   (props changed)
   incubator/directory/snickers/trunk/codec-stateful/src/java/org/apache/commons/codec/stateful/DecoderMonitorAdapter.java   (props changed)
   incubator/directory/snickers/trunk/codec-stateful/src/java/org/apache/commons/codec/stateful/StatefulDecoder.java   (props changed)
   incubator/directory/snickers/trunk/maven.xml   (props changed)
   incubator/directory/snickers/trunk/project.properties   (props changed)
   incubator/directory/snickers/trunk/project.xml   (props changed)
   incubator/directory/snickers/trunk/xdocs/ber-codec/design.xml   (props changed)
   incubator/directory/snickers/trunk/xdocs/ber-codec/eureka.xml   (props changed)
   incubator/directory/snickers/trunk/xdocs/ber-codec/index.xml   (props changed)
   incubator/directory/snickers/trunk/xdocs/ber-codec/navigation.xml   (props changed)
   incubator/directory/snickers/trunk/xdocs/index.xml   (props changed)
   incubator/directory/snickers/trunk/xdocs/navigation.xml   (props changed)
   incubator/directory/snickers/trunk/xdocs/stub-compiler/index.xml   (props changed)
   incubator/directory/snickers/trunk/xdocs/stub-compiler/navigation.xml   (props changed)
Log:
merged buffer-branch changes r9743:9764 to trunk

Modified: incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/AbstractDecoderTestCase.java
==============================================================================
--- incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/AbstractDecoderTestCase.java	(original)
+++ incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/AbstractDecoderTestCase.java	Fri Mar 26 17:11:11 2004
@@ -215,7 +215,7 @@
      */
     public Tuple decode( Tuple tlv ) throws DecoderException
     {
-        ByteBuffer buf = ByteBuffer.wrap( tlv.encode() ) ;
+        ByteBuffer buf = ByteBuffer.wrap( tlv.toEncodedArray() ) ;
         int lastSize = tlvList.size() ;
         decoder.decode( buf ) ;
         
@@ -302,6 +302,15 @@
     {
         assertTrue( decoder.getCurrentTuple().equals( tlv ) ) ;
         assertEquals( BERDecoderState.TAG, decoder.getState() ) ;
+    }
+    
+    
+    /* (non-Javadoc)
+     * @see org.apache.snickers.ber.BERDecoderCallback#partialValueDecoded(
+     * org.apache.snickers.ber.Tuple)
+     */
+    public void partialValueDecoded( Tuple tlv )
+    {
     }
 
 

Modified: incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderCallback.java
==============================================================================
--- incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderCallback.java	(original)
+++ incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderCallback.java	Fri Mar 26 17:11:11 2004
@@ -55,4 +55,11 @@
      * @param tlv the TLV tuple
      */
     void lengthDecoded( Tuple tlv ) ;
+    
+    /**
+     * Method used to recieve notification that a part of the value was decoded.
+     * 
+     * @param tlv the TLV tuple 
+     */
+    void partialValueDecoded( Tuple tlv ) ;
 }

Modified: incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderCallbackAdapter.java
==============================================================================
--- incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderCallbackAdapter.java	(original)
+++ incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/BERDecoderCallbackAdapter.java	Fri Mar 26 17:11:11 2004
@@ -48,6 +48,15 @@
 
     
     /* (non-Javadoc)
+     * @see org.apache.snickers.ber.BERDecoderCallback#partialValueDecoded(
+     * org.apache.snickers.ber.Tuple)
+     */
+    public void partialValueDecoded(Tuple tlv)
+    {
+    }
+
+    
+    /* (non-Javadoc)
      * @see org.apache.commons.codec.stateful.DecoderCallback#decodeOccurred(
      * org.apache.commons.codec.stateful.StatefulDecoder, java.lang.Object)
      */

Modified: incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/DefaultMutableTupleNode.java
==============================================================================
--- incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/DefaultMutableTupleNode.java	(original)
+++ incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/DefaultMutableTupleNode.java	Fri Mar 26 17:11:11 2004
@@ -262,7 +262,7 @@
      */
     public void encode( ByteBuffer dest )
     {
-        dest.put( tuple.encode() ) ;
+        dest.put( tuple.toEncodedArray() ) ;
         
         if ( tuple.isPrimitive() )
         {

Modified: incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/Tuple.java
==============================================================================
--- incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/Tuple.java	(original)
+++ incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/Tuple.java	Fri Mar 26 17:11:11 2004
@@ -17,15 +17,15 @@
 package org.apache.snickers.ber ;
 
 
+import java.nio.ByteBuffer ;
+
 import org.apache.commons.lang.ArrayUtils ;
-import org.apache.commons.codec.binary.Binary ;
 
 
 /**
- * Simple TLV Tuple.  Because the length fields is a primitive int it's maximum
+ * Simple TLV Tuple.  Because the length field is a primitive int it's maximum
  * value is 2,147,483,647 a single TLV's tuple cannot have a length over this
- * amount or a value size over 2 GB.  I don't think we'll be hitting this soon
- * especially with the value size protection feature planned for the decoder.
+ * amount or a value size over 2 GB.
  * 
  * @author <a href="mailto:directory-dev@incubator.apache.org">
  * Apache Directory Project</a>
@@ -33,10 +33,16 @@
  */
 public class Tuple
 {
-    /** precalculated left shift of 1 by 7 places */
-    static final int BIT_6 = 1 << 7 ;
-    /** precalculated left shift of 1 by 8 places */
-    static final int BIT_7 = 1 << 8 ;
+    private static final ByteBuffer EMPTY_BUFFER =
+        ByteBuffer.wrap( ArrayUtils.EMPTY_BYTE_ARRAY ) ;
+    
+    /** mask for bit 5 with 0-based index */
+    private static final int BIT_5 = 0x20 ;
+    /** mask for bit 6 with 0-based index */
+    private static final int BIT_6 = 0x40 ;
+    /** mask for bit 7 with 0-based index */
+    private static final int BIT_7 = 0x80 ;
+    
     /** precalculated left shift of 1 by 14 places */
     static final int BIT_13 = 1 << 14 ;
     /** precalculated left shift of 1 by 16 places */
@@ -57,7 +63,7 @@
     /** the length for this TLV tuple */
     int length = 0 ;
     /** the value for this TLV tuple */
-    Object value = ArrayUtils.EMPTY_BYTE_ARRAY ;
+    Object value ;
     
     /** tlv byte index */
     int index = Length.UNDEFINED ;
@@ -74,7 +80,8 @@
      * Empty do nothing tuple.
      */
     Tuple() 
-    { 
+    {
+        value = ArrayUtils.EMPTY_BYTE_ARRAY ;
     }
     
     
@@ -130,6 +137,19 @@
     
     
     /**
+     * Creates primitive application type tlv tuples.  This will be the primary
+     * constructor used to build primitives.
+     * 
+     * @param id the tag id of the tlv
+     * @param value the value portion for this Tuple
+     */
+    public Tuple( int id, ByteBuffer value )
+    {
+        this( id, TypeClass.APPLICATION, true, value ) ;
+    }
+    
+    
+    /**
      * Creates an application type tlv with a set value and length.  
      * 
      * @param id the tag id of the tlv
@@ -143,6 +163,19 @@
     
     
     /**
+     * Creates an application type tlv with a set value and length.  
+     * 
+     * @param id the tag id of the tlv
+     * @param isPrimitive whether or not the tlv is primitive or constructed
+     * @param value the value portion for this Tuple
+     */
+    public Tuple( int id, boolean isPrimitive, ByteBuffer value )
+    {
+        this( id, TypeClass.APPLICATION, isPrimitive, value ) ;
+    }
+    
+    
+    /**
      * Creates a tuple where the length is indefinate.  The tuple according to
      * the BER encoding must be of the constructed type.
      * 
@@ -185,6 +218,42 @@
             this.value = value ;
             this.length = value.length ;
         }
+        else
+        {
+            this.value = ArrayUtils.EMPTY_BYTE_ARRAY ;
+        }
+        
+        if ( typeClass != null )
+        {
+            this.typeClass = typeClass ;
+        }
+    }
+    
+    
+    /**
+     * Creates a tuple where every member is specified including the length 
+     * which is taken from the value array.
+     * 
+     * @param id the tag id of the tlv
+     * @param typeClass the type class for the tlv
+     * @param isPrimitive whether or not the tlv is primitive or constructed
+     * @param value the value portion for this Tuple
+     */
+    public Tuple( int id, TypeClass typeClass, boolean isPrimitive, 
+                  ByteBuffer value )
+    {
+        this.id = id ;
+        this.isPrimitive = isPrimitive ;
+        
+        if ( value != null )
+        {
+            this.value = value ;
+            this.length = value.remaining() ;
+        }
+        else
+        {
+            this.value = EMPTY_BUFFER ;
+        }
         
         if ( typeClass != null )
         {
@@ -359,14 +428,39 @@
             
             if ( t.value == null && value == null )
             {
-                
+                return true ;
+            }
+            else if ( t.value == null || value == null )
+            {
+                return false ;
             }
-            else if ( ! ArrayUtils.isEquals( t.value, value ) )
+            else if ( t.value == value )
             {
+                return true ;
+            }
+            else if ( t.value.getClass() != value.getClass() )
+            {
+                if ( t.value instanceof ByteBuffer && value instanceof byte[] )
+                {
+                    ByteBuffer bb = ByteBuffer.wrap( ( byte[] ) value ) ;
+                    return bb.equals( t.value ) ;
+                }
+                else if ( value instanceof ByteBuffer && 
+                            t.value instanceof byte[] )
+                {
+                    ByteBuffer bb = ByteBuffer.wrap( ( byte[] ) t.value ) ;
+                    return bb.equals( value ) ;
+                }
+                
                 return false ;
             }
+            else if ( t.value instanceof byte[] &&
+                        ArrayUtils.isEquals( t.value, value ) )
+            {  
+                return true ;
+            }
             
-            return true ;
+            return t.value.equals( value ) ;
         }
         
         return false ;
@@ -384,7 +478,29 @@
         t.isPrimitive = isPrimitive ;
         t.typeClass = typeClass ;
         t.length = length ;
-        t.value = value ;
+        
+        if ( value instanceof byte[] )
+        {
+            byte[] bites = ( byte[] ) value ;
+            t.value = bites.clone() ;
+        }
+        else if ( value instanceof ByteBuffer )
+        {
+            ByteBuffer bb = ( ByteBuffer ) value ;
+            ByteBuffer cloned = ByteBuffer.allocate( bb.capacity() ) ;
+            int oldPos = bb.position() ;
+            bb.rewind() ;
+            cloned.put( bb ) ;
+            cloned.limit( bb.limit() ) ;
+            bb.position( oldPos ) ;
+            cloned.rewind() ;
+            t.value = cloned ;
+        }
+        else
+        {    
+            t.value = value ;
+        }
+        
         t.index = index ;
         t.valueIndex = valueIndex ;
         
@@ -404,7 +520,7 @@
      * 
      * @return partial encoded image if constructed or complete TLV if primitive
      */
-    public byte[] encode()
+    public byte[] toEncodedArray()
     {
         byte[] octets = null ;
         int tagLength = getTagLength() ;
@@ -433,6 +549,57 @@
     
     
     /**
+     * If this is a primitive TLV then it is encoded fully.  If it is not then
+     * only the TL part of the tuple is encoded leaving the value to be encoded
+     * by the set of child TLVs.
+     * 
+     * @return partial encoded image if constructed or complete TLV if primitive
+     */
+    public ByteBuffer toEncodedBuffer()
+    {
+        ByteBuffer octets = null ;
+        int tagLength = getTagLength() ;
+        int lengthLength = getLengthLength() ;
+        int valueLength = 0 ;
+        int total = tagLength + lengthLength ;
+
+        if ( isPrimitive )
+        {
+            if ( value instanceof ByteBuffer )
+            {
+                valueLength = ( ( ByteBuffer ) value ).remaining() ;
+            }
+            else if ( value instanceof byte[] )
+            {    
+                valueLength = ( ( byte[] ) value ).length ;
+            }
+            
+            total += valueLength ;
+        }
+        
+        octets = ByteBuffer.allocate( total ) ;
+        setTag( octets, tagLength ) ;
+        setLength( octets, lengthLength ) ;
+        
+        if ( isPrimitive )
+        {
+            int destPos = tagLength + lengthLength ;
+            
+            if ( value instanceof ByteBuffer )
+            {    
+                octets.put( ( ByteBuffer ) value ) ;
+            }
+            else if ( value instanceof byte[] )
+            {    
+                octets.put( ( byte [] ) value ) ;
+            }
+        }
+        
+        return ( ByteBuffer ) octets.flip() ;
+    }
+    
+    
+    /**
      * Sets the tag section within the array at the start of the array.
      * 
      * @param octets the array of bytes to set the tag in
@@ -444,7 +611,7 @@
         
         if ( ! isPrimitive )
         {
-            octets[0] |= Binary.BIT_5 ;
+            octets[0] |= BIT_5 ;
         }
         
         if ( tagLength == 1 )
@@ -458,11 +625,11 @@
         
         if ( tagLength >= 2 )
         {
-            octets[1] = ( byte ) ( ( int ) 0x0000007f & id ) ;
+            octets[1] = ( byte ) ( ( int ) 0x7f & id ) ;
             
             if ( tagLength > 2 )
             {
-                octets[1] |= Binary.BIT_7 ;
+                octets[1] |= BIT_7 ;
             }
         }
         else
@@ -484,7 +651,7 @@
             
             if ( tagLength > 3 )
             {
-                octets[2] |= Binary.BIT_7 ;
+                octets[2] |= BIT_7 ;
             }
         }
         else
@@ -506,7 +673,7 @@
             
             if ( tagLength > 4 )
             {
-                octets[3] |= Binary.BIT_7 ;
+                octets[3] |= BIT_7 ;
             }
         }
         else
@@ -528,7 +695,118 @@
             
             if ( tagLength > 5 )
             {
-                octets[4] |= Binary.BIT_7 ;
+                octets[4] |= BIT_7 ;
+            }
+        }
+        else
+        {
+            return ;
+        }
+        
+        if ( tagLength >= 6 )
+        {    
+            throw new IllegalArgumentException( "cannot support id's as large "
+                    + "as " + id + " unless we start using longs for the id" ) ;
+        }
+    }
+
+
+    /**
+     * Sets the tag section within the buffer.
+     * 
+     * @param octets the buffer to set the tag in
+     * @param tagLength the length of the tag section
+     */
+    void setTag( ByteBuffer octets, int tagLength )
+    {
+        octets.put( ( byte ) typeClass.getValue() ) ;
+        
+        if ( ! isPrimitive )
+        {
+            octets.put( 0, ( byte ) ( octets.get( 0 ) | BIT_5 ) ) ;
+        }
+        
+        if ( tagLength == 1 )
+        {
+            octets.put( 0, ( byte ) ( octets.get( 0 ) | id ) ) ;
+            return ;
+        }
+        
+        octets.put( 0, ( byte ) ( octets.get( 0 ) | Tag.SHORT_MASK ) ) ;
+        
+        if ( tagLength >= 2 )
+        {
+            octets.put( ( byte ) ( ( int ) 0x7f & id ) ) ;
+            
+            if ( tagLength > 2 )
+            {
+                octets.put( 1, ( byte ) ( octets.get( 1 ) | BIT_7 ) ) ;
+            }
+        }
+        else
+        {
+            return ;
+        }
+        
+        /* 
+         * Take bits [8-14] (1 based bit indexing) inclusive in id and set the
+         * value for the second byte to this when shifted down 7 positions so
+         * we need the following mask:
+         * 
+         * 0011 1111 1000 0000 => 0x3f80
+         * 
+         */
+        if ( tagLength >= 3 )
+        {
+            octets.put( ( byte ) ( ( ( int ) 0x3f80 & id ) >> 7 ) ) ;
+            
+            if ( tagLength > 3 )
+            {
+                octets.put( 2, ( byte ) ( octets.get( 2 ) | BIT_7 ) ) ;
+            }
+        }
+        else
+        {
+            return ;
+        }
+        
+        /* 
+         * Take bits [15-21] (1 based bit indexing) inclusive in id and set the
+         * value for the second byte to this when shifted down 14 positions so
+         * we need the following mask:
+         * 
+         * 0001 1111 1100 0000 0000 0000 => 0x1fc000
+         * 
+         */
+        if ( tagLength >= 4 )
+        {
+            octets.put( ( byte ) ( ( ( int ) 0x1fc000 & id ) >> 14 ) ) ;
+            
+            if ( tagLength > 4 )
+            {
+                octets.put( 3, ( byte ) ( octets.get( 3 ) | BIT_7 ) ) ;
+            }
+        }
+        else
+        {
+            return ;
+        }
+        
+        /* 
+         * Take bits [22-28] (1 based bit indexing) inclusive in id and set the
+         * value for the second byte to this when shifted down 21 positions so
+         * we need the following mask:
+         * 
+         * 0000 1111 1110 0000 0000 0000 0000 0000 => 0x0fe00000
+         * 
+         */
+        if ( tagLength >= 5 )
+        {
+            octets.put( ( byte ) ( ( ( int ) 0x0fe00000 & id ) >> 21 ) ) ;
+            
+            if ( tagLength > 5 )
+            {
+                octets.put( 4, ( byte ) ( octets.get( 4 ) | BIT_7 ) ) ;
             }
         }
         else
@@ -551,20 +829,108 @@
      * @param offset the offset in the array to start the length section in
      * @param lengthBytes the number bytes for the length section
      */
+    void setLength( ByteBuffer octets, int lengthBytes )
+    {
+        if ( length == Length.INDEFINATE )
+        {
+            octets.put( ( byte ) BIT_7 ) ;
+            return ;
+        }
+        else if ( lengthBytes == 1 )
+        {
+            octets.put( ( byte ) length ) ;
+            return ;
+        }
+        else
+        {
+            /*
+             * the lengthBytes argument is the number of octets for the L field
+             * total which for the long form includes the first octet for the 
+             * length of length (N) value where N < 127.  Technically with the 
+             * 7 bits we can specify an N of up to 127 but this value of N is 
+             * reserved.  Anyway below we subtract one from lengthBytes to get
+             * N which is set as the last 7 bits of the first octet of the L
+             * field. 
+             */
+            octets.put( ( byte ) ( BIT_7 | ( lengthBytes - 1 ) ) ) ;
+        }
+        
+        if ( lengthBytes >= 2 )
+        {
+            octets.put( ( byte ) ( 0xff & length ) ) ;
+        }
+        else
+        {
+            return ;
+        }
+        
+        if ( lengthBytes >= 3 )
+        {
+            octets.put( ( byte ) ( ( 0xff00 & length ) >> 8 ) ) ;
+        }
+        else
+        {
+            return ;
+        }
+        
+        if ( lengthBytes >= 4 )
+        {
+            octets.put( ( byte ) ( ( 0xff0000 & length ) >> 16 ) ) ;
+        }
+        else
+        {
+            return ;
+        }
+        
+        if ( lengthBytes >= 5 )
+        {
+            octets.put( ( byte ) ( ( 0xff000000 & length ) >> 24 ) ) ;
+        }
+        else
+        {
+            return ;
+        }
+        
+        if ( lengthBytes >= 6 )
+        {    
+            throw new IllegalArgumentException( "cannot support lengths as "
+                    + "large as " + length 
+                    + " unless we start using longs for the length" ) ;
+        }
+    }
+
+
+    /**
+     * Sets the length bytes.
+     * 
+     * @param octets the byte [] to set length in
+     * @param offset the offset in the array to start the length section in
+     * @param lengthBytes the number bytes for the length section
+     */
     void setLength( byte[] octets, int offset, int lengthBytes )
     {
         if ( length == Length.INDEFINATE )
         {
-            octets[offset] |= BIT_6 ;
+            octets[offset] = ( byte ) BIT_7 ;
             return ;
         }
         else if ( lengthBytes == 1 )
         {
-            octets[offset] |= length ;
+            octets[offset] = ( byte ) length ;
+            return ;
         }
         else
         {
-            octets[offset] |= Binary.BIT_7 | lengthBytes - 1 ;
+            /*
+             * the lengthBytes argument is the number of octets for the L field
+             * total which for the long form includes the first octet for the 
+             * length of length (N) value where N < 127.  Technically with the 
+             * 7 bits we can specify an N of up to 127 but this value of N is 
+             * reserved.  Anyway below we subtract one from lengthBytes to get
+             * N which is set as the last 7 bits of the first octet of the L
+             * field. 
+             */
+            octets[offset] |= BIT_7 | lengthBytes - 1 ;
         }
         
         if ( lengthBytes >= 2 )
@@ -665,12 +1031,12 @@
                     + " - unless we start using longs for"
                     + " the id there you've hit a limitation" ) ;
         }
-        else if ( length < BIT_6 )
+        else if ( length < BIT_7 )
         {
             return 1 ;
         }
-        else if ( length < BIT_7 )
-        {    
+        else if ( length < 256 )
+        {
             return 2 ;
         }
         else if ( length < BIT_15 )

Modified: incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/TupleTreeDecoder.java
==============================================================================
--- incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/TupleTreeDecoder.java	(original)
+++ incubator/directory/snickers/trunk/ber/src/java/org/apache/snickers/ber/TupleTreeDecoder.java	Fri Mar 26 17:11:11 2004
@@ -57,6 +57,8 @@
         BERDecoderCallback berCallback = new BERDecoderCallback()
         {
             public void tagDecoded( Tuple tlv ) { }
+            
+            public void partialValueDecoded( Tuple tlv ) { }
         
             public void lengthDecoded( Tuple tlv )
             {

Modified: incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/BERDecoderTest.java
==============================================================================
--- incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/BERDecoderTest.java	(original)
+++ incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/BERDecoderTest.java	Fri Mar 26 17:11:11 2004
@@ -140,7 +140,7 @@
         Tuple top = new Tuple( 1, t0.size() + t1.size() ) ;
         assertTrue( decode( top ).equals( top ) ) ;
 
-        byte[] all = t0.encode() ;
+        byte[] all = t0.toEncodedArray() ;
         byte[][] fragments = fragment( all, 10 ) ;
         Tuple decoded = null ;
         

Modified: incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TupleTest.java
==============================================================================
--- incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TupleTest.java	(original)
+++ incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TupleTest.java	Fri Mar 26 17:11:11 2004
@@ -17,6 +17,8 @@
 package org.apache.snickers.ber ;
 
 
+import java.nio.ByteBuffer;
+
 import org.apache.commons.lang.ArrayUtils ;
 import org.apache.commons.codec.binary.Binary ;
 
@@ -126,7 +128,7 @@
         assertEquals( 0, t.getLength() ) ;
         assertEquals( ArrayUtils.EMPTY_BYTE_ARRAY, t.getValue() ) ;
 
-        t = new Tuple( 2, TypeClass.PRIVATE, true, null ) ;
+        t = new Tuple( 2, TypeClass.PRIVATE, true, (byte[]) null ) ;
         assertEquals( 2, t.getId() ) ;
         assertEquals( TypeClass.PRIVATE, t.getTypeClass() ) ;
         assertEquals( true, t.isPrimitive() ) ;
@@ -141,7 +143,7 @@
         assertEquals( 7, t.getLength() ) ;
         assertEquals( bites, t.getValue() ) ;
         
-        t = new Tuple( 2, null, false,  null ) ; 
+        t = new Tuple( 2, null, false, (byte[]) null ) ; 
         assertEquals( 2, t.getId() ) ;
         assertEquals( TypeClass.APPLICATION, t.getTypeClass() ) ;
         assertEquals( false, t.isPrimitive() ) ;
@@ -152,6 +154,45 @@
     /*
      * Class to test for void Tuple(int, int, TypeClass, boolean, byte[])
      */
+    public void testTupleintTypeClassbooleanBuffer()
+    {
+        Tuple t = new Tuple( 2, TypeClass.PRIVATE, true, 
+                ByteBuffer.wrap( ArrayUtils.EMPTY_BYTE_ARRAY ) ) ;
+        assertEquals( 2, t.getId() ) ;
+        assertEquals( TypeClass.PRIVATE, t.getTypeClass() ) ;
+        assertEquals( true, t.isPrimitive() ) ;
+        assertEquals( 0, t.getLength() ) ;
+        assertEquals( ByteBuffer.wrap( ArrayUtils.EMPTY_BYTE_ARRAY ), 
+                t.getValue() ) ;
+
+        t = new Tuple( 2, TypeClass.PRIVATE, true, (ByteBuffer) null ) ;
+        assertEquals( 2, t.getId() ) ;
+        assertEquals( TypeClass.PRIVATE, t.getTypeClass() ) ;
+        assertEquals( true, t.isPrimitive() ) ;
+        assertEquals( 0, t.getLength() ) ;
+        assertEquals( ByteBuffer.wrap( ArrayUtils.EMPTY_BYTE_ARRAY ), 
+                t.getValue() ) ;
+
+        ByteBuffer bites = ByteBuffer.allocate( 7 ) ;
+        t = new Tuple( 2, (TypeClass) null, false, bites ) ;
+        assertEquals( 2, t.getId() ) ;
+        assertEquals( TypeClass.APPLICATION, t.getTypeClass() ) ;
+        assertEquals( false, t.isPrimitive() ) ;
+        assertEquals( 7, t.getLength() ) ;
+        assertEquals( bites, t.getValue() ) ;
+        
+        t = new Tuple( 2, null, false, (ByteBuffer) null ) ; 
+        assertEquals( 2, t.getId() ) ;
+        assertEquals( TypeClass.APPLICATION, t.getTypeClass() ) ;
+        assertEquals( false, t.isPrimitive() ) ;
+        assertEquals( 0, t.getLength() ) ;
+        assertEquals( ByteBuffer.wrap( ArrayUtils.EMPTY_BYTE_ARRAY ), 
+                t.getValue() ) ;
+    }
+
+    /*
+     * Class to test for void Tuple(int, int, TypeClass, boolean, byte[])
+     */
     public void testTupleintbyteArray()
     {
         Tuple t = new Tuple( 2, ArrayUtils.EMPTY_BYTE_ARRAY ) ;
@@ -173,6 +214,29 @@
     /*
      * Class to test for void Tuple(int, int, TypeClass, boolean, byte[])
      */
+    public void testTupleintBuffer()
+    {
+        Tuple t = new Tuple( 2, 
+                ByteBuffer.wrap( ArrayUtils.EMPTY_BYTE_ARRAY ) ) ;
+        assertEquals( 2, t.getId() ) ;
+        assertEquals( TypeClass.APPLICATION, t.getTypeClass() ) ;
+        assertEquals( true, t.isPrimitive() ) ;
+        assertEquals( 0, t.getLength() ) ;
+        assertEquals( ByteBuffer.wrap( ArrayUtils.EMPTY_BYTE_ARRAY ), 
+                t.getValue() ) ;
+        
+        ByteBuffer bites = ByteBuffer.allocate( 5 ) ;
+        t = new Tuple( 2, bites ) ;
+        assertEquals( 2, t.getId() ) ;
+        assertEquals( TypeClass.APPLICATION, t.getTypeClass() ) ;
+        assertEquals( true, t.isPrimitive() ) ;
+        assertEquals( 5, t.getLength() ) ;
+        assertEquals( bites, t.getValue() ) ;
+    }
+
+    /*
+     * Class to test for void Tuple(int, int, TypeClass, boolean, byte[])
+     */
     public void testTupleintbooleanbyteArray()
     {
         Tuple t = new Tuple( 2, false, ArrayUtils.EMPTY_BYTE_ARRAY ) ;
@@ -194,6 +258,29 @@
     /*
      * Class to test for void Tuple(int, int, TypeClass, boolean, byte[])
      */
+    public void testTupleintbooleanBuffer()
+    {
+        Tuple t = new Tuple( 2, false, 
+                ByteBuffer.wrap( ArrayUtils.EMPTY_BYTE_ARRAY ) ) ;
+        assertEquals( 2, t.getId() ) ;
+        assertEquals( TypeClass.APPLICATION, t.getTypeClass() ) ;
+        assertEquals( false, t.isPrimitive() ) ;
+        assertEquals( 0, t.getLength() ) ;
+        assertEquals( ByteBuffer.wrap( ArrayUtils.EMPTY_BYTE_ARRAY ), 
+                t.getValue() ) ;
+        
+        ByteBuffer bites = ByteBuffer.allocate( 5 ) ;
+        t = new Tuple( 2, false, bites ) ;
+        assertEquals( 2, t.getId() ) ;
+        assertEquals( TypeClass.APPLICATION, t.getTypeClass() ) ;
+        assertEquals( false, t.isPrimitive() ) ;
+        assertEquals( 5, t.getLength() ) ;
+        assertEquals( bites, t.getValue() ) ;
+    }
+
+    /*
+     * Class to test for void Tuple(int, int, TypeClass, boolean, byte[])
+     */
     public void testTupleintTypeClass()
     {
         Tuple t = new Tuple( 2, TypeClass.PRIVATE ) ;
@@ -229,7 +316,7 @@
         t.id = 32 ;
         assertEquals( 3, t.size() ) ;
         t.id = 127 ;
-        assertEquals( 3, t.size() ) ;
+        assertEquals( 4, t.size() ) ;
         t.id = 128 ;
         assertEquals( 4, t.size() ) ;
         t.id = 1 << 14 ;
@@ -422,14 +509,14 @@
         assertTrue( t.equals( t.clone() ) ) ;
     }
 
-    public void testEncodeConstructed()
+    public void testToEncodedArrayConstructed()
     {
         Tuple t = null ;
         byte[] encoded ;
         String binary ;
         
         t = new Tuple( 0, 0 ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -437,7 +524,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
 
         t = new Tuple( 2, 0 ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -445,7 +532,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
 
         t = new Tuple( 30, 0 ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -453,7 +540,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
 
         t = new Tuple( 31, 0 ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -462,7 +549,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
 
         t = new Tuple( 128, 0 ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -472,7 +559,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
 
         t = new Tuple( 128, 127 ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "01111111" +
@@ -482,7 +569,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
 
         t = new Tuple( 128, 128 ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "10000000" +
@@ -493,7 +580,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
 
         t = new Tuple( 128, 255 ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "11111111" +
@@ -504,7 +591,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
 
         t = new Tuple( 128, 256 ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000001" +
@@ -516,7 +603,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
 
         t = new Tuple( Tuple.BIT_27-1, Integer.MAX_VALUE ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( Binary.toAsciiString( Integer.MAX_VALUE ) + 
                 "10000100" +
@@ -528,7 +615,7 @@
                 , Binary.toAsciiString( encoded ) ) ;
     }
 
-    public void testEncodePrimitive()
+    public void testToEncodedArrayPrimitive()
     {
         Tuple t = null ;
         byte[] encoded ;
@@ -537,7 +624,7 @@
         
         data = new byte[0] ;
         t = new Tuple( 0, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -546,7 +633,7 @@
 
         data = new byte[0] ;
         t = new Tuple( 2, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -555,7 +642,7 @@
 
         data = new byte[0] ;
         t = new Tuple( 30, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -564,7 +651,7 @@
 
         data = new byte[0] ;
         t = new Tuple( 31, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -574,7 +661,7 @@
 
         data = new byte[0] ;
         t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -585,7 +672,7 @@
 
         data = new byte[1] ;
         t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( 
                 "00000000" +
@@ -597,7 +684,7 @@
 
         data = new byte[127] ;
         t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( Binary.toAsciiString( data ) +
                 "01111111" +
@@ -608,7 +695,7 @@
 
         data = new byte[128] ;
         t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( Binary.toAsciiString( data ) +
                 "10000000" +
@@ -620,7 +707,7 @@
 
         data = new byte[255] ;
         t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( Binary.toAsciiString( data ) +
                 "11111111" +
@@ -632,7 +719,7 @@
 
         data = new byte[256] ;
         t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
-        encoded = t.encode() ;
+        encoded = t.toEncodedArray() ;
         binary = Binary.toAsciiString( encoded ) ;
         assertEquals( Binary.toAsciiString( data ) + 
                 "00000001" +
@@ -644,7 +731,355 @@
                 , Binary.toAsciiString( encoded ) ) ;
     }
 
-    public void testSetTag()
+    
+    public void testToEncodedBufferConstructed()
+    {
+        Tuple t = null ;
+        ByteBuffer encoded ;
+        String binary ;
+        
+        t = new Tuple( 0, 0 ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "01100000"
+                , toAsciiString( encoded ) ) ;
+
+        t = new Tuple( 2, 0 ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "01100010"
+                , toAsciiString( encoded ) ) ;
+
+        t = new Tuple( 30, 0 ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "01111110"
+                , toAsciiString( encoded ) ) ;
+
+        t = new Tuple( 31, 0 ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "00011111" +
+                "01111111"
+                , toAsciiString( encoded ) ) ;
+
+        t = new Tuple( 128, 0 ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "00000001" +
+                "10000000" +
+                "01111111"
+                , toAsciiString( encoded ) ) ;
+
+        t = new Tuple( 128, 127 ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "01111111" +
+                "00000001" +
+                "10000000" +
+                "01111111"
+                , toAsciiString( encoded ) ) ;
+
+        t = new Tuple( 128, 128 ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "10000000" +
+                "10000001" +
+                "00000001" +
+                "10000000" +
+                "01111111"
+                , toAsciiString( encoded ) ) ;
+
+        t = new Tuple( 128, 255 ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "11111111" +
+                "10000001" +
+                "00000001" +
+                "10000000" +
+                "01111111"
+                , toAsciiString( encoded ) ) ;
+
+        t = new Tuple( 128, 256 ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000001" +
+                "00000000" +
+                "10000010" +
+                "00000001" +
+                "10000000" +
+                "01111111"
+                , toAsciiString( encoded ) ) ;
+
+        t = new Tuple( Tuple.BIT_27-1, Integer.MAX_VALUE ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( Binary.toAsciiString( Integer.MAX_VALUE ) + 
+                "10000100" +
+                "01111111" +
+                "11111111" +
+                "11111111" +
+                "11111111" +
+                "01111111"
+                , toAsciiString( encoded ) ) ;
+    }
+
+    public void testToEncodedBufferPrimitive()
+    {
+        Tuple t = null ;
+        ByteBuffer encoded ;
+        byte[] data ;
+        String binary ;
+        
+        data = new byte[0] ;
+        t = new Tuple( 0, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "01000000"
+                , toAsciiString( encoded ) ) ;
+
+        data = new byte[0] ;
+        t = new Tuple( 2, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "01000010"
+                , toAsciiString( encoded ) ) ;
+
+        data = new byte[0] ;
+        t = new Tuple( 30, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "01011110"
+                , toAsciiString( encoded ) ) ;
+
+        data = new byte[0] ;
+        t = new Tuple( 31, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "00011111" +
+                "01011111"
+                , toAsciiString( encoded ) ) ;
+
+        data = new byte[0] ;
+        t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "00000001" +
+                "10000000" +
+                "01011111"
+                , toAsciiString( encoded ) ) ;
+
+        data = new byte[1] ;
+        t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( 
+                "00000000" +
+                "00000001" +
+                "00000001" +
+                "10000000" +
+                "01011111"
+                , toAsciiString( encoded ) ) ;
+
+        data = new byte[127] ;
+        t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( Binary.toAsciiString( data ) +
+                "01111111" +
+                "00000001" +
+                "10000000" +
+                "01011111"
+                , toAsciiString( encoded ) ) ;
+
+        data = new byte[128] ;
+        t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( Binary.toAsciiString( data ) +
+                "10000000" +
+                "10000001" +
+                "00000001" +
+                "10000000" +
+                "01011111"
+                , toAsciiString( encoded ) ) ;
+
+        data = new byte[255] ;
+        t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( Binary.toAsciiString( data ) +
+                "11111111" +
+                "10000001" +
+                "00000001" +
+                "10000000" +
+                "01011111"
+                , toAsciiString( encoded ) ) ;
+
+        data = new byte[256] ;
+        t = new Tuple( 128, TypeClass.APPLICATION, true, data ) ;
+        encoded = t.toEncodedBuffer() ;
+        binary = toAsciiString( encoded ) ;
+        assertEquals( Binary.toAsciiString( data ) + 
+                "00000001" +
+                "00000000" +
+                "10000010" +
+                "00000001" +
+                "10000000" +
+                "01011111"
+                , toAsciiString( encoded ) ) ;
+    }
+
+    
+    public String toAsciiString( ByteBuffer buf )
+    {
+        return Binary.toAsciiString( buf.array() ) ;
+    }
+    
+    
+    public void testSetTagBufferint()
+    {
+        ByteBuffer bites = ByteBuffer.allocate( 1 ) ;
+        Tuple t = new Tuple( 0, 0 ) ;
+        t.setTag( bites, 1 ) ;
+        String binary = toAsciiString( bites ) ;
+        assertEquals( "01100000", binary ) ;
+        
+        bites = ByteBuffer.allocate( 1 ) ;
+        t = new Tuple( 30, 0 ) ;
+        t.setTag( bites, 1 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "01111110", binary ) ;
+
+        bites = ByteBuffer.allocate( 1 ) ;
+        t = new Tuple( 30, 0 ) ;
+        t.isPrimitive = true ;
+        t.setTag( bites, 1 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "01011110", binary ) ;
+
+        bites = ByteBuffer.allocate( 2 ) ;
+        t = new Tuple( 31, 0 ) ;
+        t.setTag( bites, 2 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00011111" + "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 2 ) ;
+        t = new Tuple( 127, 0 ) ;
+        t.setTag( bites, 2 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "01111111" + "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 3 ) ;
+        t = new Tuple( 128, 0 ) ;
+        t.setTag( bites, 3 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" + "10000000" + "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 3 ) ;
+        t = new Tuple( Tuple.BIT_13 - 1, 0 ) ;
+        t.setTag( bites, 3 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "01111111" + 
+                      "11111111" + 
+                      "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 4 ) ;
+        t = new Tuple( Tuple.BIT_13, 0 ) ;
+        t.setTag( bites, 4 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" +
+                      "10000000" +
+                      "10000000" + 
+                      "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 4 ) ;
+        t = new Tuple( Tuple.BIT_13 + 1, 0 ) ;
+        t.setTag( bites, 4 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" +
+                      "10000000" +
+                      "10000001" + 
+                      "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 4 ) ;
+        t = new Tuple( Tuple.BIT_20 - 1, 0 ) ;
+        t.setTag( bites, 4 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "01111111" + 
+                      "11111111" + 
+                      "11111111" + 
+                      "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 5 ) ;
+        t = new Tuple( Tuple.BIT_20, 0 ) ;
+        t.setTag( bites, 5 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" +
+                      "10000000" +
+                      "10000000" +
+                      "10000000" + 
+                      "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 5 ) ;
+        t = new Tuple( Tuple.BIT_20 + 1, 0 ) ;
+        t.setTag( bites, 5 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" +
+                      "10000000" +
+                      "10000000" +
+                      "10000001" + 
+                      "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 5 ) ;
+        t = new Tuple( Tuple.BIT_27 - 1, 0 ) ;
+        t.setTag( bites, 5 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "01111111" + 
+                      "11111111" + 
+                      "11111111" + 
+                      "11111111" + 
+                      "01111111", binary ) ;
+
+        bites = ByteBuffer.allocate( 6 ) ;
+        t = new Tuple( Tuple.BIT_27, 0 ) ;
+        
+        try
+        {
+            t.setTag( bites, 6 ) ;
+            fail( "should never reach this point due to thrown exception" ) ;
+        }
+        catch( IllegalArgumentException e )
+        {
+            assertNotNull( e ) ;
+        }
+    }
+
+    public void testSetTagbyteArrayint()
     {
         byte[] bites = new byte[1] ;
         Tuple t = new Tuple( 0, 0 ) ;
@@ -762,7 +1197,126 @@
         }
     }
 
-    public void testSetLength()
+    public void testSetLengthBuffer()
+    {
+        ByteBuffer bites = ByteBuffer.allocate( 1 ) ;
+        Tuple t = new Tuple( 0, 0 ) ;
+        t.setLength( bites, 1 ) ;
+        String binary = toAsciiString( bites ) ;
+        assertEquals( "00000000", binary ) ;
+
+        bites = ByteBuffer.allocate( 1 ) ;
+        t = new Tuple( 30, 15 ) ;
+        t.setLength( bites, 1 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00001111", binary ) ;
+
+        bites = ByteBuffer.allocate( 1 ) ;
+        t = new Tuple( 30, 127 ) ;
+        t.setLength( bites, 1 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "01111111", binary ) ;
+        
+        bites = ByteBuffer.allocate( 2 ) ;
+        t = new Tuple( 30, 128 ) ;
+        t.setLength( bites, 2 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "10000000" +
+                      "10000001", binary ) ;
+        
+        bites = ByteBuffer.allocate( 2 ) ;
+        t = new Tuple( 30, 255 ) ;
+        t.setLength( bites, 2 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "11111111" +
+                      "10000001", binary ) ;
+        
+        bites = ByteBuffer.allocate( 3 ) ;
+        t = new Tuple( 30, 256 ) ;
+        t.setLength( bites, 3 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" +
+                      "00000000" +
+                      "10000010", binary ) ;
+        
+        bites = ByteBuffer.allocate( 3 ) ;
+        t = new Tuple( 30, Tuple.BIT_15 - 1 ) ;
+        t.setLength( bites, 3 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "11111111" +
+                      "11111111" +
+                      "10000010", binary ) ;
+        
+        bites = ByteBuffer.allocate( 4 ) ;
+        t = new Tuple( 30, Tuple.BIT_15 ) ;
+        t.setLength( bites, 4 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" +
+                      "00000000" +
+                      "00000000" +
+                      "10000011", binary ) ;
+        
+        bites = ByteBuffer.allocate( 4 ) ;
+        t = new Tuple( 30, Tuple.BIT_15 + 1 ) ;
+        t.setLength( bites, 4 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" +
+                      "00000000" +
+                      "00000001" +
+                      "10000011", binary ) ;
+        
+        bites = ByteBuffer.allocate( 4 ) ;
+        t = new Tuple( 30, Tuple.BIT_23 - 1 ) ;
+        t.setLength( bites, 4 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "11111111" +
+                      "11111111" +
+                      "11111111" +
+                      "10000011", binary ) ;
+        
+        bites = ByteBuffer.allocate( 5 ) ;
+        t = new Tuple( 30, Tuple.BIT_23 ) ;
+        t.setLength( bites, 5 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" +
+                      "00000000" +
+                      "00000000" +
+                      "00000000" +
+                      "10000100", binary ) ;
+        
+        bites = ByteBuffer.allocate( 5 ) ;
+        t = new Tuple( 30, Tuple.BIT_23 + 1 ) ;
+        t.setLength( bites, 5 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( "00000001" +
+                      "00000000" +
+                      "00000000" +
+                      "00000001" +
+                      "10000100", binary ) ;
+        
+        bites = ByteBuffer.allocate( 5 ) ;
+        t = new Tuple( 30, Integer.MAX_VALUE ) ;
+        t.setLength( bites, 5 ) ;
+        binary = toAsciiString( bites ) ;
+        assertEquals( Binary.toAsciiString( Integer.MAX_VALUE ) +
+                      "10000100", binary ) ;
+        
+        
+        bites = ByteBuffer.allocate( 6 ) ;
+        t = new Tuple( 30, Integer.MAX_VALUE + 1 ) ;
+
+        try
+        {
+            t.setLength( bites, 6 ) ;
+            fail( "should never get here due to thrown exception" ) ;
+        }
+        catch( IllegalArgumentException e ) 
+        {
+            assertNotNull( e ) ;
+        }
+    }
+
+    public void testSetLengthbyteArrayintint()
     {
         byte[] bites = new byte[1] ;
         Tuple t = new Tuple( 0, 0 ) ;
@@ -891,9 +1445,9 @@
         t.id = 31 ;
         assertEquals( 2, t.getTagLength() ) ;
         t.id = 100 ;
-        assertEquals( 2, t.getTagLength() ) ;
+        assertEquals( 3, t.getTagLength() ) ;
         t.id = 127 ;
-        assertEquals( 2, t.getTagLength() ) ;
+        assertEquals( 3, t.getTagLength() ) ;
         t.id = 128 ;
         assertEquals( 3, t.getTagLength() ) ;
         t.id = 129 ;

Modified: incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TupleTreeDecoderTest.java
==============================================================================
--- incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TupleTreeDecoderTest.java	(original)
+++ incubator/directory/snickers/trunk/ber/src/test/org/apache/snickers/ber/TupleTreeDecoderTest.java	Fri Mar 26 17:11:11 2004
@@ -64,15 +64,15 @@
     {
         TupleTreeDecoder decoder = new TupleTreeDecoder() ;
         decoder.decode(ByteBuffer.wrap( 
-                        new Tuple( 1, ArrayUtils.EMPTY_BYTE_ARRAY ).encode())) ;
+                        new Tuple( 1, ArrayUtils.EMPTY_BYTE_ARRAY ).toEncodedArray())) ;
         decoder.decode( ByteBuffer.wrap( new Tuple( 1, 
-                                ArrayUtils.EMPTY_BYTE_ARRAY ).encode() ) ) ;
+                                ArrayUtils.EMPTY_BYTE_ARRAY ).toEncodedArray() ) ) ;
     }    
     
 
     public void testTTD4() throws Exception
     {
-        byte[] bites = new Tuple( 1, ArrayUtils.EMPTY_BYTE_ARRAY ).encode() ;
+        byte[] bites = new Tuple( 1, ArrayUtils.EMPTY_BYTE_ARRAY ).toEncodedArray() ;
         byte[] shorter = new byte[bites.length-1] ;
         System.arraycopy( bites, 0, shorter, 0, shorter.length ) ;
         

Mime
View raw message