try {
                int bufSize = 64 * 1024 + 512;
                int l = bufSize;
                try ( SmbRandomAccess raf = f.openRandomAccess("rw") ) {
                    writeRandom(bufSize, l, raf);
                }

                try ( SmbRandomAccess raf = f.openRandomAccess("rw") ) {
                    verifyRandom(bufSize, l, raf);
                }
            }

    }


    static void verifyRandom ( int bufSize, long length, InputStream is ) throws IOException {
        verifyRandom(bufSize, length, true, is);
    }


    static void verifyRandom ( int bufSize, long length, boolean expectEof, InputStream is ) throws IOException {
        long start = System.currentTimeMillis();
        byte buffer[] = new byte[bufSize];
        long p = 0;
        Random r = getRandom();

                    }
                }
                finally {
                    d1.delete();
                }
            }
            finally {
                f.delete();
            }
        }
    }


    // #173
    @Test
    public void testCopyTargetExists () throws IOException {
        int bufSize = 65536;

    // reading and so all of the bytes in each new allocated buffer are available for reading from
    // the stream.
    for (int bufSize = initialBufferSize;
        totalLen < MAX_ARRAY_LEN;
        bufSize = IntMath.saturatedMultiply(bufSize, bufSize < 4096 ? 4 : 2)) {
      byte[] buf = new byte[min(bufSize, MAX_ARRAY_LEN - totalLen)];
      bufs.add(buf);
      int off = 0;
      while (off < buf.length) {

        int tryBufferSize = 1023;
        final int bufSize[] = new int[] {
            origBufferSize
        };
        ctx = withConfig(ctx, new DelegatingConfiguration(ctx.getConfig()) {

            @Override
            public int getMaximumBufferSize () {
                return bufSize[ 0 ];
            }
        });
        ctx = withTestNTLMCredentials(ctx);

     */
    public static int readn ( InputStream in, byte[] b, int off, int len ) throws IOException {
        int i = 0, n = -5;

        if ( off + len > b.length ) {
            throw new IOException("Buffer too short, bufsize " + b.length + " read " + len);
        }

        while ( i < len ) {
            n = in.read(b, off + i, len - i);
            if ( n <= 0 ) {
                break;
            }
            i += n;

changes in data layout either in the Go type definitions or in the
layout rules used by the Go compiler.
</p>

<p>
Constants are of the form <code>const_<i>name</i></code>.
For example, given the Go declaration <code>const bufSize =
1024</code>, assembly code can refer to the value of this constant
as <code>const_bufSize</code>.
</p>

<p>
Field offsets are of the form <code><i>type</i>_<i>field</i></code>.