harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From smish...@apache.org
Subject svn commit: r545554 [7/13] - in /harmony/enhanced/buildtest/branches/2.0/tests/reliability: ./ run/ src/ src/java/ src/java/org/ src/java/org/apache/ src/java/org/apache/harmony/ src/java/org/apache/harmony/test/ src/java/org/apache/harmony/test/reliab...
Date Fri, 08 Jun 2007 16:35:10 GMT
Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferSliceTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferSliceTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferSliceTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferSliceTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay Bannikov
+ * @version $Revision: 1.2 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.buffers;
+
+import org.apache.harmony.test.reliability.share.Test;
+import java.nio.CharBuffer;
+import java.util.Random;
+
+/**
+ * Goal: find resource leaks or intermittent failures caused by CharBuffer.slice() / duplicate() / wrap() operations.
+ *
+ * The test does:
+ *    1. Reads parameters, which are:
+ *          param[0] - number of iterations to call/initialize in a cycle
+ *    2. Excutes a cycle of param[0] iterations, on each iteration:
+ *         Allocates 2 char buffers: wrap(CharSequence csq) / wrap(char[] array) 
+ *         For each of the char buffer:
+ *            - sets random position and mark at its position
+ *            - creates slice
+ *            - checks position
+ *            - creates duplicate
+ *            - checks position
+ *            - set random position for the duplicate
+ *            - resets buffer's position to the previously-marked position
+ *            - checks the duplicate position
+ *            - creates duplicate's slice
+ *            - checks position
+ */
+
+public class CharBufferSliceTest extends Test {
+
+    public int NUMBER_OF_ITERATIONS = 1000000;
+
+    final static int size = 1000;
+
+    static int cnt = 0;
+
+    public static void main(String[] args) {
+        System.exit(new CharBufferSliceTest().test(args));
+    }
+
+    public int test(String[] params) {
+
+        parseParams(params);
+
+        String str = "qwertyuiopasdfghjklzxcvbnm";
+        CharBuffer buff1 = null;
+        CharBuffer slice1 = null;
+        CharBuffer buff2 = null;
+        CharBuffer slice2 = null;
+        CharBuffer buff3 = null;
+        CharBuffer slice3 = null;
+        Random rn = new Random();
+        int size = 0;
+        int initial_size = 0;
+
+        for (int i = 0; i < NUMBER_OF_ITERATIONS; i++) {
+            size = rn.nextInt(str.length());
+            buff1 = CharBuffer.wrap(str);
+            buff1.position(size);
+            buff1.mark();
+            initial_size = size;
+            slice1 = buff1.slice();
+
+            if (slice1.position() != 0) {
+                return fail("Iteration " + i
+                    + " : Slice 1 position (should be 0): "
+                    + slice1.position());
+            }
+
+            size = rn.nextInt(str.length());
+            buff3 = buff1.duplicate();
+
+            if (initial_size != buff3.position()) {
+                return fail("Iteration " + i
+                    + " : position after buff1.duplicate(): "
+                    + buff3.position() + " , but should be " + initial_size);
+            }
+
+            buff3.position(size);
+            initial_size = size;
+            buff1.reset();
+
+            if (initial_size != buff3.position()) {
+                return fail("Iteration " + i
+                    + " : position after buff1.reset(): "
+                    + buff3.position() + " , but should be " + initial_size);
+            }
+
+            slice3 = buff3.slice();
+
+            if (slice3.position() != 0) {
+                return fail("Iteration " + i
+                    + " : Slice 3 position (should be 0): "
+                    + slice3.position());
+            }
+
+            size = rn.nextInt(str.length());
+            buff2 = CharBuffer.wrap(str.toCharArray());
+            buff2.position(size);
+            buff2.mark();
+            initial_size = size;
+            slice2 = buff2.slice();
+
+            if (slice2.position() != 0) {
+                return fail("Iteration " + i
+                    + " : Slice 2 position (should be 0): "
+                    + slice2.position());
+            }
+
+            size = rn.nextInt(str.length());
+            buff3 = buff2.duplicate();
+
+            if (initial_size != buff3.position()) {
+                return fail("Iteration " + i
+                    + " : position after buff2.duplicate(): "
+                    + buff3.position() + " , but should be " + initial_size);
+            }
+
+            buff3.position(size);
+            initial_size = size;
+            buff2.reset();
+
+            if (initial_size != buff3.position()) {
+                return fail("Iteration " + i
+                    + " : position after buff2.reset(): "
+                    + buff3.position() + " , but should be " + initial_size);
+            }
+
+            slice3 = buff3.slice();
+
+            if (slice3.position() != 0) {
+                return fail("Iteration " + i
+                    + " : Slice 3 position (should be 0): "
+                    + slice3.position());
+            }
+
+        }
+
+        return pass("OK");
+    }
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1) {
+            NUMBER_OF_ITERATIONS = Integer.parseInt(params[0]);
+        }
+
+    }
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferSliceTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapGetTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapGetTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapGetTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapGetTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay Bannikov
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.buffers;
+
+import org.apache.harmony.test.reliability.share.Test;
+import java.nio.CharBuffer;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+
+/**
+ * Goal: find memory leaks caused by CharBuffer.wrap()/put()/get() method.
+ *
+ * The test does:
+ *    1. Reads parameters, which are:
+ *          param[0] - number of iterations to call/initialize one wrap/put/get in a cycle
+
+ *    2. starts a cycle of param[0] iterations. On each iteration:
+ *            - Allocates a random byte buffer
+ *            - puts string into the buffer
+ *            - Sets this buffer's mark at random position
+ *            - wraps a subsequence into the buffer
+ *            - check the result
+ *            - runs System.gc()
+ */
+
+public class CharBufferWrapGetTest extends Test {
+
+    public int callSystemGC = 1;
+
+    public int NUMBER_OF_ITERATIONS = 1000000;
+
+    //private char array
+    private char[] array = new char[0];
+
+    public static void main(String[] args) {
+        System.exit(new CharBufferWrapGetTest().test(args));
+    }
+
+    public int test(String[] params) {
+
+        parseParams(params);
+        String str = "qwertyuiopasdfghjklzxcvbnm1234567890";
+        CharBuffer cbuf = null;
+        CharBuffer subbuf = null;
+        String substr = "";
+        char out[] = {};
+        String cbufstr = "";
+        Random rn = new Random();
+        int size = 0;
+
+        for (int i = 0; i < NUMBER_OF_ITERATIONS; ++i) {
+
+            size = rn.nextInt(str.length());
+            cbuf = CharBuffer.allocate(512 + size);
+            if (i % 2 == 0) {
+                cbuf = ByteBuffer.allocateDirect(512 + size).asCharBuffer();
+            }
+            out = new char[cbuf.length()];
+            cbuf.put(str);
+            cbuf.position(size);
+            cbuf.mark();
+            subbuf = CharBuffer.wrap((CharBuffer)cbuf.subSequence(size, size + 1)); 
+            cbufstr = String.valueOf(cbuf.get(size));
+            out = new char[subbuf.length()];
+            cbuf.get(out);
+            substr = new String(out);
+            cbuf.rewind();
+            if(!substr.equals(cbufstr)) {
+                return fail("Expected on step " + i + " : \"" + substr + "\" but got \"" + cbufstr + "\"");
+            }
+
+            // if (i % 100000 == 0) {
+            //    log.add("Iteration: " + i);
+            // }
+
+
+            if (callSystemGC != 0) {
+                System.gc();
+            }
+        }
+        return pass("OK");
+    }
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1) {
+            NUMBER_OF_ITERATIONS = Integer.parseInt(params[0]);
+        }
+
+    }
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapGetTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay Bannikov
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.buffers;
+
+import org.apache.harmony.test.reliability.share.Test;
+import java.nio.CharBuffer;
+
+/**
+ * Goal: find memory leaks caused by CharBuffer.wrap() method.
+ *
+ * The test does:
+ *    1. Reads parameters, which are:
+ *          param[0] - number of iterations to call/initialize one wrap in a cycle
+ 
+ *    2. CharBuffer.wrap() throws IndexOutOfBoundsException 
+ *    3. starts a cycle of param[0] iterations.
+ *    4. runs System.gc()
+ *
+ */
+
+public class CharBufferWrapTest extends Test {
+
+    public int callSystemGC = 1;
+
+    public int NUMBER_OF_WRAP_ITERATIONS = 10000000;
+
+    //private char array
+    private char[] array = new char[0];
+
+    public static void main(String[] args) {
+        System.exit(new CharBufferWrapTest().test(args));
+    }
+
+    public int test(String[] params) {
+
+        parseParams(params);
+
+        for (int i = 0; i < NUMBER_OF_WRAP_ITERATIONS; ++i) {
+
+            // if (i % 1000000 == 0) {
+            //     log.add("Iteration: " + i);
+            // }
+
+            try {
+                CharBuffer.wrap(array, 1, 2);
+                return fail("CharBuffer.wrap doesn't throw IndexOutOfBoundsException");
+            } catch (IndexOutOfBoundsException e) {
+            }
+
+            if (callSystemGC != 0) {
+                System.gc();
+            }
+        }
+        return pass("OK");
+    }
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1) {
+            NUMBER_OF_WRAP_ITERATIONS = Integer.parseInt(params[0]);
+        }
+
+    }
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/CharBufferWrapTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/DoubleBufferWrapGetTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/DoubleBufferWrapGetTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/DoubleBufferWrapGetTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/DoubleBufferWrapGetTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay Bannikov
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.buffers;
+
+
+import org.apache.harmony.test.reliability.share.Test;
+import java.nio.DoubleBuffer;
+import java.nio.ByteOrder;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+
+/**
+ * Goal: find memory leaks caused by DoubleBuffer.wrap()/allocate() and ByteOrder.nativeOrder() methods.
+ *
+ * The test does:
+ *    1. Reads parameters, which are:
+ *          param[0] - number of iterations to call/initialize one wrap/put/get in a cycle
+ *          param[1] - size of allocated buffer 
+
+ *    2. starts a cycle of param[0] iterations. On each iteration:
+ *            - Allocates a double buffer
+ *            - Allocates a direct byte buffer and creates a view of this byte buffer as a double buffer
+ *            - reverses the native byte order 
+ *            - wraps a double array
+ *            - check the result
+ *            - runs System.gc()
+ */
+
+public class DoubleBufferWrapGetTest extends Test {
+
+    public int callSystemGC = 1;
+
+    public int NUMBER_OF_ITERATIONS = 100000;
+
+    public int BUFFER_SIZE = 100;
+
+    //private char array
+    private char[] array = new char[0];
+
+    public static void main(String[] args) {
+        System.exit(new DoubleBufferWrapGetTest().test(args));
+    }
+
+    public int test(String[] params) {
+
+        parseParams(params);
+
+        for (int i = 0; i < NUMBER_OF_ITERATIONS; ++i) {
+            DoubleBuffer[] array = getDoubleBufferArray();
+            Random rn = new Random();
+            int size = 0;
+            array = getDoubleBufferArray();
+            for(int j = 0; j< array.length ; j++) {
+
+                size = array.length - rn.nextInt(array.length);
+                if(size == 0) {
+                    size = 1;
+                }
+                array[j].limit(size);
+                double[] d = new double[size];
+                d[size -1] = Double.MAX_VALUE;
+                double maxvalue = DoubleBuffer.wrap(d).get(size-1);
+                if(maxvalue != Double.MAX_VALUE) {
+                    return fail("Expected on step " + i + " : \"" + Double.MAX_VALUE + "\" but got \"" + maxvalue + "\"");
+                }
+            }
+
+
+            // if (i % 10000 == 0) {
+            //    log.add("Iteration: " + i);
+            // }
+
+
+            if (callSystemGC != 0) {
+                System.gc();
+            }
+        }
+        return pass("OK");
+    }
+
+    public DoubleBuffer[] getDoubleBufferArray() {
+        DoubleBuffer[] db = new DoubleBuffer[5];
+
+        db[0] = DoubleBuffer.allocate(BUFFER_SIZE); 
+        ByteBuffer bb = ByteBuffer.allocate(BUFFER_SIZE);
+        db[1] = bb.asDoubleBuffer();  
+        db[2] = bb.order(changeOrder()).asDoubleBuffer();
+        ByteBuffer dirbuf = ByteBuffer.allocateDirect(BUFFER_SIZE);
+        db[3] = dirbuf.asDoubleBuffer();
+        db[4] = dirbuf.order(changeOrder()).asDoubleBuffer();
+        return db;
+    }
+
+    public ByteOrder changeOrder() {
+        ByteOrder order = ByteOrder.BIG_ENDIAN;
+        if(ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) {
+            order = ByteOrder.LITTLE_ENDIAN ;
+        }
+        return order;
+    }
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1) {
+            NUMBER_OF_ITERATIONS = Integer.parseInt(params[0]);
+        }
+
+        if (params.length >= 2) {
+            BUFFER_SIZE = Integer.parseInt(params[1]);
+        }
+    }
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/DoubleBufferWrapGetTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/FloatBufferWrapGetTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/FloatBufferWrapGetTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/FloatBufferWrapGetTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/FloatBufferWrapGetTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay Bannikov
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.buffers;
+
+
+import org.apache.harmony.test.reliability.share.Test;
+import java.nio.FloatBuffer;
+import java.nio.ByteOrder;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+
+/**
+ * Goal: find memory leaks caused by FloatBuffer.wrap()/allocate() and ByteOrder.nativeOrder() methods.
+ *
+ * The test does:
+ *    1. Reads parameters, which are:
+ *          param[0] - number of iterations to call/initialize one wrap/put/get in a cycle
+ *          param[1] - size of allocated buffer 
+
+ *    2. starts a cycle of param[0] iterations. On each iteration:
+ *            - Allocates a Float buffer
+ *            - Allocates a direct byte buffer and creates a view of this byte buffer as a Float buffer
+ *            - reverses the native byte order 
+ *            - wraps a Float array
+ *            - check the result
+ *            - runs System.gc()
+ */
+
+public class FloatBufferWrapGetTest extends Test {
+
+    public int callSystemGC = 1;
+
+    public int NUMBER_OF_ITERATIONS = 100000;
+
+    public int BUFFER_SIZE = 100;
+
+    //private char array
+    private char[] array = new char[0];
+
+    public static void main(String[] args) {
+        System.exit(new FloatBufferWrapGetTest().test(args));
+    }
+
+    public int test(String[] params) {
+
+        parseParams(params);
+
+        for (int i = 0; i < NUMBER_OF_ITERATIONS; ++i) {
+            FloatBuffer[] array = getFloatBufferArray();
+            Random rn = new Random();
+            int size = 0;
+            array = getFloatBufferArray();
+            for(int j = 0; j< array.length ; j++) {
+
+                size = array.length - rn.nextInt(array.length);
+                if(size == 0) {
+                    size = 1;
+                }
+                array[j].limit(size);
+                float[] d = new float[size];
+                d[size -1] = Float.MAX_VALUE;
+                float maxvalue = FloatBuffer.wrap(d).get(size-1);
+                if(maxvalue != Float.MAX_VALUE) {
+                    return fail("Expected on step " + i + " : \"" + Float.MAX_VALUE + "\" but got \"" + maxvalue + "\"");
+                }
+            }
+
+
+            // if (i % 10000 == 0) {
+            //    log.add("Iteration: " + i);
+            // }
+
+
+            if (callSystemGC != 0) {
+                System.gc();
+            }
+        }
+        return pass("OK");
+    }
+
+    public FloatBuffer[] getFloatBufferArray() {
+        FloatBuffer[] db = new FloatBuffer[5];
+
+        db[0] = FloatBuffer.allocate(BUFFER_SIZE); 
+        ByteBuffer bb = ByteBuffer.allocate(BUFFER_SIZE);
+        db[1] = bb.asFloatBuffer();  
+        db[2] = bb.order(changeOrder()).asFloatBuffer();
+        ByteBuffer dirbuf = ByteBuffer.allocateDirect(BUFFER_SIZE);
+        db[3] = dirbuf.asFloatBuffer();
+        db[4] = dirbuf.order(changeOrder()).asFloatBuffer();
+        return db;
+    }
+
+    public ByteOrder changeOrder() {
+        ByteOrder order = ByteOrder.BIG_ENDIAN;
+        if(ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) {
+            order = ByteOrder.LITTLE_ENDIAN ;
+        }
+        return order;
+    }
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1) {
+            NUMBER_OF_ITERATIONS = Integer.parseInt(params[0]);
+        }
+
+        if (params.length >= 2) {
+            BUFFER_SIZE = Integer.parseInt(params[1]);
+        }
+
+    }
+
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/FloatBufferWrapGetTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/IntBufferWrapGetTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/IntBufferWrapGetTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/IntBufferWrapGetTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/IntBufferWrapGetTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay Bannikov
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.buffers;
+
+
+import org.apache.harmony.test.reliability.share.Test;
+import java.nio.IntBuffer;
+import java.nio.ByteOrder;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+
+/**
+ * Goal: find memory leaks caused by IntBuffer.wrap()/allocate() and ByteOrder.nativeOrder() methods.
+ *
+ * The test does:
+ *    1. Reads parameters, which are:
+ *          param[0] - number of iterations to call/initialize one wrap/put/get in a cycle
+ *          param[1] - size of allocated buffer 
+
+ *    2. starts a cycle of param[0] iterations. On each iteration:
+ *            - Allocates a Int buffer
+ *            - Allocates a direct byte buffer and creates a view of this byte buffer as a Int buffer
+ *            - reverses the native byte order 
+ *            - wraps a Int array
+ *            - check the result
+ *            - runs System.gc()
+ */
+
+public class IntBufferWrapGetTest extends Test {
+
+    public int callSystemGC = 1;
+
+    public int NUMBER_OF_ITERATIONS = 100000;
+
+    public int BUFFER_SIZE = 100;
+
+    //private char array
+    private char[] array = new char[0];
+
+    public static void main(String[] args) {
+        System.exit(new IntBufferWrapGetTest().test(args));
+    }
+
+    public int test(String[] params) {
+
+        parseParams(params);
+
+        for (int i = 0; i < NUMBER_OF_ITERATIONS; ++i) {
+            IntBuffer[] array = getIntBufferArray();
+            Random rn = new Random();
+            int size = 0;
+            array = getIntBufferArray();
+            for(int j = 0; j< array.length ; j++) {
+
+                size = array.length - rn.nextInt(array.length);
+                if(size == 0) {
+                    size = 1;
+                }
+                array[j].limit(size);
+                int[] d = new int[size];
+                d[size -1] = Integer.MAX_VALUE;
+                int maxvalue = IntBuffer.wrap(d).get(size-1);
+                if(maxvalue != Integer.MAX_VALUE) {
+                    return fail("Expected on step " + i + " : \"" + Integer.MAX_VALUE + "\" but got \"" + maxvalue + "\"");
+                }
+            }
+
+
+            // if (i % 10000 == 0) {
+            //    log.add("Iteration: " + i);
+            // }
+
+
+            if (callSystemGC != 0) {
+                System.gc();
+            }
+        }
+        return pass("OK");
+    }
+
+    public IntBuffer[] getIntBufferArray() {
+        IntBuffer[] db = new IntBuffer[5];
+
+        db[0] = IntBuffer.allocate(BUFFER_SIZE); 
+        ByteBuffer bb = ByteBuffer.allocate(BUFFER_SIZE);
+        db[1] = bb.asIntBuffer();  
+        db[2] = bb.order(changeOrder()).asIntBuffer();
+        ByteBuffer dirbuf = ByteBuffer.allocateDirect(BUFFER_SIZE);
+        db[3] = dirbuf.asIntBuffer();
+        db[4] = dirbuf.order(changeOrder()).asIntBuffer();
+        return db;
+    }
+
+    public ByteOrder changeOrder() {
+        ByteOrder order = ByteOrder.BIG_ENDIAN;
+        if(ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) {
+            order = ByteOrder.LITTLE_ENDIAN ;
+        }
+        return order;
+    }
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1) {
+            NUMBER_OF_ITERATIONS = Integer.parseInt(params[0]);
+        }
+
+        if (params.length >= 2) {
+            BUFFER_SIZE = Integer.parseInt(params[1]);
+        }
+
+    }
+
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/IntBufferWrapGetTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/LongBufferWrapGetTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/LongBufferWrapGetTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/LongBufferWrapGetTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/LongBufferWrapGetTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay Bannikov
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.buffers;
+
+import org.apache.harmony.test.reliability.share.Test;
+import java.nio.LongBuffer;
+import java.nio.ByteOrder;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+
+/**
+ * Goal: find memory leaks caused by LongBuffer.wrap()/allocate() and ByteOrder.nativeOrder() methods.
+ *
+ * The test does:
+ *    1. Reads parameters, which are:
+ *          param[0] - number of iterations to call/initialize one wrap/put/get in a cycle
+ *          param[1] - size of allocated buffer 
+
+ *    2. starts a cycle of param[0] iterations. On each iteration:
+ *            - Allocates a Long buffer
+ *            - Allocates a direct byte buffer and creates a view of this byte buffer as a Long buffer
+ *            - reverses the native byte order 
+ *            - wraps a Long array
+ *            - check the result
+ *            - runs System.gc()
+ */
+
+public class LongBufferWrapGetTest extends Test {
+
+    public int callSystemGC = 1;
+
+    public int NUMBER_OF_ITERATIONS = 100000;
+
+    public int BUFFER_SIZE = 100;
+
+    //private char array
+    private char[] array = new char[0];
+
+    public static void main(String[] args) {
+        System.exit(new LongBufferWrapGetTest().test(args));
+    }
+
+    public int test(String[] params) {
+
+        parseParams(params);
+
+        for (int i = 0; i < NUMBER_OF_ITERATIONS; ++i) {
+            LongBuffer[] array = getLongBufferArray();
+            Random rn = new Random();
+            int size = 0;
+            array = getLongBufferArray();
+            for(int j = 0; j< array.length ; j++) {
+
+                size = array.length - rn.nextInt(array.length);
+                if(size == 0) {
+                    size = 1;
+                }
+                array[j].limit(size);
+                long[] d = new long[size];
+                d[size -1] = Long.MAX_VALUE;
+                long maxvalue = LongBuffer.wrap(d).get(size-1);
+                if(maxvalue != Long.MAX_VALUE) {
+                    return fail("Expected on step " + i + " : \"" + Long.MAX_VALUE + "\" but got \"" + maxvalue + "\"");
+                }
+            }
+
+
+            // if (i % 10000 == 0) {
+            //    log.add("Iteration: " + i);
+            //}
+
+
+            if (callSystemGC != 0) {
+                System.gc();
+            }
+        }
+        return pass("OK");
+    }
+
+    public LongBuffer[] getLongBufferArray() {
+        LongBuffer[] db = new LongBuffer[5];
+
+        db[0] = LongBuffer.allocate(BUFFER_SIZE); 
+        ByteBuffer bb = ByteBuffer.allocate(BUFFER_SIZE);
+        db[1] = bb.asLongBuffer();  
+        db[2] = bb.order(changeOrder()).asLongBuffer();
+        ByteBuffer dirbuf = ByteBuffer.allocateDirect(BUFFER_SIZE);
+        db[3] = dirbuf.asLongBuffer();
+        db[4] = dirbuf.order(changeOrder()).asLongBuffer();
+        return db;
+    }
+
+    public ByteOrder changeOrder() {
+        ByteOrder order = ByteOrder.BIG_ENDIAN;
+        if(ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) {
+            order = ByteOrder.LITTLE_ENDIAN ;
+        }
+        return order;
+    }
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1) {
+            NUMBER_OF_ITERATIONS = Integer.parseInt(params[0]);
+        }
+
+        if (params.length >= 2) {
+            BUFFER_SIZE = Integer.parseInt(params[1]);
+        }
+
+    }
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/LongBufferWrapGetTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/ShortBufferWrapGetTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/ShortBufferWrapGetTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/ShortBufferWrapGetTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/ShortBufferWrapGetTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay Bannikov
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.buffers;
+
+import org.apache.harmony.test.reliability.share.Test;
+import java.nio.ShortBuffer;
+import java.nio.ByteOrder;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+
+/**
+ * Goal: find memory leaks caused by ShortBuffer.wrap()/allocate() and ByteOrder.nativeOrder() methods.
+ *
+ * The test does:
+ *    1. Reads parameters, which are:
+ *          param[0] - number of iterations to call/initialize one wrap/put/get in a cycle
+ *          param[1] - size of allocated buffer 
+
+ *    2. starts a cycle of param[0] iterations. On each iteration:
+ *            - Allocates a Short buffer
+ *            - Allocates a direct byte buffer and creates a view of this byte buffer as a Short buffer
+ *            - reverses the native byte order 
+ *            - wraps a Short array
+ *            - check the result
+ *            - runs System.gc()
+ */
+
+public class ShortBufferWrapGetTest extends Test {
+
+    public int callSystemGC = 1;
+
+    public int NUMBER_OF_ITERATIONS = 100000;
+
+    public int BUFFER_SIZE = 100;
+
+    //private char array
+    private char[] array = new char[0];
+
+    public static void main(String[] args) {
+        System.exit(new ShortBufferWrapGetTest().test(args));
+    }
+
+    public int test(String[] params) {
+
+        parseParams(params);
+
+        for (int i = 0; i < NUMBER_OF_ITERATIONS; ++i) {
+            ShortBuffer[] array = getShortBufferArray();
+            Random rn = new Random();
+            int size = 0;
+            array = getShortBufferArray();
+            for(int j = 0; j< array.length ; j++) {
+
+                size = array.length - rn.nextInt(array.length);
+                if(size == 0) {
+                    size = 1;
+                }
+                array[j].limit(size);
+                short[] d = new short[size];
+                d[size -1] = Short.MAX_VALUE;
+                short maxvalue = ShortBuffer.wrap(d).get(size-1);
+                if(maxvalue != Short.MAX_VALUE) {
+                    return fail("Expected on step " + i + " : \"" + Short.MAX_VALUE + "\" but got \"" + maxvalue + "\"");
+                }
+            }
+
+
+            // if (i % 10000 == 0) {
+            //    log.add("Iteration: " + i);
+            // }
+
+
+            if (callSystemGC != 0) {
+                System.gc();
+            }
+        }
+        return pass("OK");
+    }
+
+    public ShortBuffer[] getShortBufferArray() {
+        ShortBuffer[] db = new ShortBuffer[5];
+
+        db[0] = ShortBuffer.allocate(BUFFER_SIZE); 
+        ByteBuffer bb = ByteBuffer.allocate(BUFFER_SIZE);
+        db[1] = bb.asShortBuffer();  
+        db[2] = bb.order(changeOrder()).asShortBuffer();
+        ByteBuffer dirbuf = ByteBuffer.allocateDirect(BUFFER_SIZE);
+        db[3] = dirbuf.asShortBuffer();
+        db[4] = dirbuf.order(changeOrder()).asShortBuffer();
+        return db;
+    }
+
+    public ByteOrder changeOrder() {
+        ByteOrder order = ByteOrder.BIG_ENDIAN;
+        if(ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) {
+            order = ByteOrder.LITTLE_ENDIAN ;
+        }
+        return order;
+    }
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1) {
+            NUMBER_OF_ITERATIONS = Integer.parseInt(params[0]);
+        }
+
+        if (params.length >= 2) {
+            BUFFER_SIZE = Integer.parseInt(params[1]);
+        }
+
+    }
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/buffers/ShortBufferWrapGetTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelFIOSTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelFIOSTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelFIOSTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelFIOSTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,349 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Oleg V. Oleinik
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.channels.filechannel;
+
+import org.apache.harmony.test.reliability.share.Test;
+
+import java.util.Random;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.File;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.ByteBuffer;
+
+
+/**
+ * Goal: check for intermittent errors operating with a file sucessively via FileInputStream and 
+ *       associated channel, FileOutputStream and associated channel.
+ *
+ * Idea: Write into a file via FOS, then channel, then, FOS, then, channel, etc. an array of bytes.
+ *       Then, read from the file via FIS, channel, FIS, channel, etc. Finally, check that read byte
+ *       array has the same content as the original one, thus proving that working via FIS/FOS and
+ *       channels shares input/output state and causes no errors.
+ *
+ * The test does:
+ *
+ *     1. Parses parameters:
+ *             param[0] - a path to an exiting directory where the test can store its files.
+ *
+ *     2. Creates a file with the name param[0]/fileName.
+ *    
+ *     3. Creates FileInputStream, FileOutputStream and associated channels.
+ *
+ *     4. Creates an array of random size (<= SIZE) and fills-in it with random bytes.
+ *
+ *     5. Writes the bytes into the file:
+ *
+ *         a. Splits the byte array into N sub-arrays.
+ *         b. Writes subarrays sequentially via FOS, channel, FOS, channel, etc.
+ *        
+ *     6. Reads bytes from the file by N portions via FIS, channel, FIS, channel, etc.
+ *
+ *     7. Compares initial array and read from the file, expecting they have the same content.
+ *
+ *     8. Truncates created file from 'file size' to 0 successively during N iterations.
+ * 
+ */
+
+public class ChannelFIOSTest extends Test {
+
+    // name of file to write/read byte to/from:
+
+    static final String fileName = "ChannelFIOSTest.file";
+
+    // maximum number of bytes totally to be written into file:
+
+    static final int SIZE = 1000000;
+
+    int actualSize = 0; // will be actual size of the file, a random value
+
+    // number of subarrays to be written / read successively via FOS, channel / FIS, channel:
+
+    static final int N = 50;
+
+    String outputDir = "";
+
+    String workFileName = "";
+
+    FileOutputStream fos = null;
+    FileChannel outChannel = null;
+
+    FileInputStream fis = null;
+    FileChannel inChannel = null;
+
+
+    public static void main(String[] args) {
+        System.exit(new ChannelFIOSTest().test(args));
+    }
+
+
+    public int test(String[] params) {
+
+        File f = null;
+
+        try {
+
+            parseParams(params);
+  
+            f = Utils.createWorkFile(workFileName);
+
+            // Open FIS, FOS and corresponding channels:
+
+            openFISFOSChannels(f);
+                 
+            // Create a byte array of random size which we will play with
+
+            byte[] bytes_to_write = Utils.createRndBytes(getSize());
+
+            // First, we split bytes_to_write array into N equal parts and 
+            // write parts sequntially into the file via FOS, channel, FOS, channel, etc.
+
+            writeBytes(bytes_to_write, f);
+
+            // Second, we read from the file via FIS, channel, FIS, channel, etc.
+
+            byte[] read_bytes = readBytes(f);
+
+            // Third, compare wrote and read bytes.
+  
+            if (!compare(bytes_to_write, read_bytes)) {
+                return fail("Written and read arrays differ...");
+            }
+
+            // Finally, truncate the created file from 'file size' to 0
+            // during N iterations.
+
+            truncateFile();
+
+
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return fail("Exception thrown: " + t);
+
+        } finally {
+
+            try {
+
+                if (fos != null){
+                    fos.close();
+                }
+
+                if (outChannel != null){
+                    outChannel.close();
+                }
+
+                if (fis != null){
+                    fis.close();
+                }
+                if (inChannel != null){
+                    inChannel.close();
+                }
+
+            } catch (Throwable t){
+            }
+
+            if (f != null){
+                f.delete();
+            }
+        }
+
+        return pass("OK");
+    }
+
+
+    // the method truncates the created file from 'file size'  
+    // up to 0 sucessively during N iterations
+
+    void truncateFile() throws Exception {
+
+        long fileSize = outChannel.position(0).size();
+
+        long step = fileSize / N;
+
+        try {
+
+            for (int i = 0; i <= N + 1; ++i) {
+
+                outChannel.truncate(fileSize - step * i);
+
+            }
+
+        } catch (IllegalArgumentException iae) {
+
+            // System.out.println("IAE");
+
+            // this is just in case to check nothing but exception happens 
+            // in case of negative size
+        }
+
+    }
+
+    boolean compare(byte[] b1, byte[] b2){
+
+        if (b1.length != b2.length) {
+            log.add("byte arrays comparison: lengths of arrays are different: " + b1.length + ", " + b2.length);
+            return false;
+        }
+
+        boolean passed = true;
+
+        for (int i = 0; i < b1.length; ++i){
+            if (b1[i] != b2[i]) {
+                log.add("Bytes are different at position " + i + ": " + Byte.toString(b1[i]) + 
+                    " vs. " + Byte.toString(b2[i]));
+                passed = false;
+                break;
+            }
+        }
+
+        return passed;
+    }
+
+
+    // The key method of the test: it reads bytes via FileInputStream, channel,
+    // FileInputStream and channel, etc. expecting that FIS and channel share state,
+    // i.e. reading from channel affects correspondingly FIS and vise versa.
+
+    byte[] readBytes(File f) throws Exception {
+
+        byte[] b_total = new byte[actualSize];
+        int step = actualSize / N;
+
+        byte[] b = new byte[step];
+        ByteBuffer bb = ByteBuffer.allocate(step);
+
+        for (int i = 0; i < N; ++i) {
+                 
+            // READ NEXT PORTION OF BYTES VIA FIS:
+
+            fis.read(b);
+            System.arraycopy(b, 0, b_total, i * step, b.length);
+
+            ++i;
+          
+            if (i < N) {
+
+                bb.clear(); // needed to prepare ByteBuffer for channel read / put operations 
+
+                // READ NEXT PORTION OF BYTES VIA CHANNEL:
+
+                inChannel.read(bb);
+                byte[] arr = bb.array();
+                System.arraycopy(arr, 0, b_total, i * step, arr.length);
+            }
+        }
+
+        return b_total;
+    }
+
+
+    // The key method of the test: it writes bytes via FileOutputStream, channel,
+    // FileOutputStream and channel, etc. expecting that FOS and channel share state,
+    // i.e. writing via channel affects correspondingly FOS and vise versa.
+
+    void writeBytes(byte[] b, File f) throws Exception {
+             
+        ByteBuffer[] bb = splitByteArray(b);
+
+        for (int i = 0; i < bb.length; ++i) {
+
+            // WRITE NEXT PORTION OF BYTES VIA FOS:
+
+            fos.write(bb[i].array()); 
+
+            ++i;
+
+            // WRITE NEXT PORTION OF BYTES VIA CHANNEL:
+
+            if (i < bb.length) {
+                FileLock fl = outChannel.lock();
+                outChannel.write(bb[i]);
+                outChannel.force(false);
+                fl.release();
+            }
+        }
+    }
+
+    // Helpful method which just splits byte array "b" into N equal parts
+    // each part is copied into ByteBuffer (non-direct) and prepared for writing.
+
+    ByteBuffer[] splitByteArray(byte[] b){
+
+        int step = b.length / N;
+
+        ByteBuffer[] bb = new ByteBuffer[N];
+
+        for (int i = 0; i < bb.length; ++i) {
+            bb[i] = ByteBuffer.allocate(step);
+            bb[i].put(b, i * step, step);
+            bb[i].flip(); // needed to prepare ByteBuffer for channel write / get operations
+        }
+
+        return bb;
+    }
+
+
+    // The method just creates FIS, FOS and associated channels
+
+    void openFISFOSChannels(File f) throws Throwable {
+
+        try {
+
+            fos = new FileOutputStream(f);
+            outChannel = fos.getChannel();
+
+            fis = new FileInputStream(f);
+            inChannel = fis.getChannel();
+
+        } catch (Throwable t){
+            log.add(t.toString() +
+                " exception was thrown while creating FileOutputStream or FileInputStream" +
+                " or associated channels for " + f.getPath());
+            throw t;
+        }
+    }
+
+
+    public void parseParams(String[] params) throws Exception {
+
+        // NOTE: outputDir must exist prior to running this test
+
+        if (params.length >= 1) {
+            outputDir =  params[0];
+        } else {
+            throw new Exception("output directory is not specified. Usage: Test <existing output dir name>");
+        }
+        workFileName = outputDir + File.separator + fileName;
+    }
+
+    int getSize() {
+
+        actualSize = (Utils.r.nextInt(SIZE) / N) * N;
+            
+        // log.add("Bytes: " + actualSize);
+
+        return actualSize;
+    }
+
+}

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelFIOSTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelWriteTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelWriteTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelWriteTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelWriteTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,215 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay V. Bannikov
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.channels.filechannel;
+
+import org.apache.harmony.test.reliability.share.Test;
+import org.apache.harmony.test.reliability.share.Result;
+
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+
+/**
+ * The test does:
+ *    1. Reads parameters, which are:
+ *          param[0] - number of threads to run in parallel
+ *          param[1] - allocated size of buffers
+ *          param[2] - number of iterations
+ *          param[3] - size of the byte buffer array
+ *
+ *     2. Starts and, then, joins all started threads
+ *
+ *     3. Checks that in each thread all checks PASSed.
+ *
+ *     4. Each thread, being started:
+ *
+ *         In each of param[2] iterations:
+ *           - creates FileChannel object associated with file output stream
+ *           - allocates some param[3] byte buffers.
+ *           - writes a sequence of bytes to this channel from the given buffers.
+ *           - Calls System.gc()
+ */
+
+
+public class ChannelWriteTest extends Test {
+
+    public int NUMBER_OF_ITERATIONS = 1000;
+
+    // size of the byte buffer array
+    public int NUMBER_OF_BYTE_BUFFERS = 1;
+
+    // How much bytes to read from the input file into byte array
+    public int bufferSize = 1024;
+
+    // Number of threads to run in parallel
+    public int numThreads = 1;
+
+    public int callSystemGC = 1;
+
+    // Each thread sets PASS/FAIL flag into its corresponding array element
+    public int[] statuses;
+
+    // Number bytes to write into the buffer
+    public int write_byte =50;
+
+
+    public static void main(String[] args) {
+        System.exit(new ChannelWriteTest().test(args));
+    }
+
+
+    public int test(String[] params) {
+    
+        parseParams(params);
+
+
+        // Start 'numThreads' threads each reading from file, inflating/deflating
+
+        Thread[] t = new Thread[numThreads];
+
+        statuses = new int[t.length];
+                                
+        for (int i = 0; i < t.length; i++) {
+            t[i] = new Thread(new ChannelWriteThread(i, this));
+            t[i].start();
+            //log.add("Thread " + i + " started");
+        }
+                
+        // Correctly wait for all threads to finish
+
+        for (int i = 0; i < t.length; ++i){
+            try {
+                t[i].join();
+                // log.add("Thread " + i + ": joined() ");
+
+            } catch (InterruptedException ie){
+                return fail("interruptedException while join() of thread #" + i);
+            }
+        }
+
+        // For each thread check whether operations/checks PASSed in the thread
+
+        for (int i = 0; i < statuses.length; ++i){
+            if (statuses[i] != Result.PASS){
+                return fail("thread #" + i + " returned not PASS status");
+            }
+            // log.add("Status of thread " + i + ": is PASS");
+        }
+
+        return pass("OK");
+    }
+
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1 && Integer.parseInt(params[0]) > 0) {
+            numThreads = Integer.parseInt(params[0]);
+        }        
+
+
+        if (params.length >= 2) {
+            bufferSize= Integer.parseInt(params[1]);
+        }        
+
+        if (params.length >= 3) {
+            NUMBER_OF_ITERATIONS = Integer.parseInt(params[2]);
+        }        
+
+        if (params.length >= 4) {
+            NUMBER_OF_BYTE_BUFFERS = Integer.parseInt(params[3]);
+        }        
+
+    }
+
+}
+
+
+class ChannelWriteThread implements Runnable {
+
+    public int id;
+    public ChannelWriteTest base;
+
+    public ChannelWriteThread(int id, ChannelWriteTest base) {
+        this.id = id;
+        this.base = base;
+    }
+
+    public void run() {
+        FileOutputStream fos = null;
+        FileChannel channel = null;
+
+        try {
+            File file = File.createTempFile("test", null);
+            file.deleteOnExit();
+            fos = new FileOutputStream(file);
+            channel = fos.getChannel();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } 
+        base.statuses[id] = Result.PASS;
+        ByteBuffer[] buffer = new ByteBuffer[base.NUMBER_OF_BYTE_BUFFERS];
+
+        for (int i = 0; i < base.NUMBER_OF_ITERATIONS; ++i) {
+            for(int j = 0; j < base.NUMBER_OF_BYTE_BUFFERS; j++) {
+                buffer[j] = ByteBuffer.allocate(2*base.bufferSize); 
+                putByte(buffer[j], base.write_byte);
+                buffer[j].flip(); 
+            }
+
+            try {
+                channel.write(buffer);  
+            } catch (IOException e) {
+                base.statuses[id] = Result.FAIL;
+                base.log.add("Thread " + id + " : IOException while buffer writing");
+            }
+
+            for(int j = 0; j < base.NUMBER_OF_BYTE_BUFFERS; j++) {
+                buffer[j].clear();
+            }
+
+            if (base.callSystemGC != 0){
+                System.gc();
+            }
+        }
+        try {
+            channel.close();
+            fos.close();
+        } catch (IOException e) {
+            base.statuses[id] = Result.FAIL;
+            base.log.add("Thread " + id + " : IOException while closing");
+        }
+    }
+
+    public void putByte(ByteBuffer buf, int cnt) {
+        for (int i=0; i < cnt; i++ ){
+            buf.put( (byte) i);
+            buf.put( (byte) '\n');
+        }
+    }
+
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/ChannelWriteTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/CopyFilesTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/CopyFilesTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/CopyFilesTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/CopyFilesTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,372 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Oleg V. Oleinik
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.channels.filechannel;
+
+import org.apache.harmony.test.reliability.share.Test;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.nio.channels.FileChannel;
+import java.nio.ByteBuffer;
+
+
+/**
+ * Goal: check FileChannel transferFrom/To operations work correctly.
+ *
+ * Idea: Create a file with random content, then, many threads copy the file
+ *       via transferFrom/To, each into its own file.
+ *
+ * The test does:
+ *
+ *     1. Parses parameters:
+ *             param[0] - a path to an exiting directory where the test can store its files.
+ *
+ *     2. Creates a file with the name param[0]/fileName, fills it in with FILE_SIZE random bytes.
+ *    
+ *     3. Starts N_OF_THREADS threads, each thread:
+ *
+ *          a. Transfers from original file's channel FILE_SIZE/2 bytes into copy file.
+ *
+ *          b. Transfers to the copy file's channel the rest of FILE_SIZE/2 bytes from the
+ *             original file's channel.
+ *        
+ *     4. Checks the size of each copy file is equal to the original file.
+ *
+ *     7. Closes channels and deletes all created files.
+ * 
+ */
+
+
+public class CopyFilesTest extends Test {
+
+    // Size of the original file and hence of each file's copy
+
+    static final int FILE_SIZE = 100000;
+
+    // Number of copying threads, i.e. copy files
+
+    static final int N_OF_THREADS = 10;
+
+
+    volatile boolean passed = true;
+
+    String workFileName = "";
+  
+    String fileName = "CopyFilesTest.file";
+
+    String outputDir = "";
+
+
+    public static void main(String[] args) {
+        System.exit(new CopyFilesTest().test(args));
+    }
+
+
+    public int test(String[] params) {
+
+        File f_from = null;
+
+        passed = true;
+
+        try {
+
+            parseParams(params);
+
+            // First, create work file
+            f_from = Utils.createWorkFile(workFileName);
+
+
+            // Second, fill it in with random byte values
+            fillInFile(f_from);
+
+
+            // Third, run threads each copying the file into another file
+            copy(f_from);
+
+
+            // Finally, remove the created work file and return appropriate status
+            if (!passed) {
+                return fail("Failed");
+            }
+
+
+        } catch (Throwable t) {
+
+            t.printStackTrace();
+
+            return fail("Exception thrown: " + t);
+
+        } finally {
+
+            if (f_from != null) {
+                f_from.delete();
+            }
+        }
+
+        return pass("OK");
+    }
+
+
+
+    // The method just fills-in the file 'f' with random byte values
+
+    void fillInFile(File f) throws Exception {
+
+        FileChannel fc = null;
+
+        try {
+
+            fc = new FileOutputStream(f).getChannel();
+
+            byte[] b = Utils.createRndBytes(FILE_SIZE);
+
+            ByteBuffer bb = ByteBuffer.allocateDirect(b.length).wrap(b);
+
+            fc.write(bb);
+
+            fc.force(false);
+
+        } finally {
+
+            if (fc != null) { 
+                fc.close();
+            }
+        }
+
+        return;
+    }
+
+
+    // The key method - runs N_OF_THREADS threads, passing to each a channel
+    // from and to which copy the content, waits for threads' finishing and checks
+    // files' sizes.
+ 
+    void copy(File f_from) throws Exception {
+            
+        Thread[] t = new Thread[N_OF_THREADS];
+
+        File[] f_to = new File[N_OF_THREADS];
+
+        FileChannel[] outChannels = new FileChannel[N_OF_THREADS];
+
+        FileChannel inChannel = null;
+
+        try {
+
+            // First, open a read-only channel of original file
+
+            inChannel = new FileInputStream(f_from).getChannel();
+
+            for (int i = 0; i < t.length; ++i) {
+
+                // Second, create files to copy the original file to
+
+                f_to[i] = new File(f_from.getAbsolutePath() + "_copy_" + i);
+
+                // Third, create write-only channels to copy bytes to
+
+                outChannels[i] = new FileOutputStream(f_to[i]).getChannel();
+
+                // Forth, create and run threads, each copying from inChannel 
+                // into its outChannel[i]
+
+                t[i] = new Copier("" + i, inChannel, outChannels[i], this);
+
+                t[i].start();
+            }
+ 
+            // Fifth, wait threads for finishing
+
+            for (int i = 0; i < t.length; ++i) {
+                t[i].join();
+            }
+
+            // Finally, is there were no errors, check that content of the original
+            // file is equal to the copies
+                               
+            if (passed) {
+ 
+                for (int i = 0; i < f_to.length; ++i) {
+
+                    if (!checkContent(f_from, f_to[i])) {
+
+                        passed = false;
+
+                    }
+                }
+            }
+
+        } catch (Throwable tr) {
+
+            tr.printStackTrace();
+
+            log.add("Exception thrown: " + tr);
+
+            passed = false;
+
+        } finally {
+
+            // Actually, this is final action - we close all channels 
+            // and delete all created files-copies:
+
+            if (inChannel != null){
+                inChannel.close();
+            }
+
+            for (int i = 0; i < outChannels.length; ++i) {
+
+                if (outChannels[i] != null) {
+                    outChannels[i].close();
+                }
+
+                if (f_to[i] != null) {
+                    f_to[i].delete();
+                }
+            }
+        }
+
+        return;
+    }
+
+
+    // Just checks that sizes of two files are the same
+
+    boolean checkContent(File f1, File f2) {
+            
+        if (f1.length() != f2.length()) {
+
+            log.add("Size of " + f1.getName() + " is " + f1.length() + ", while size of " + 
+                f2.getName() + " is " + f2.length());
+
+            return false;
+        }
+
+        return true;
+    }
+
+
+    public void parseParams(String[] params) throws Exception {
+
+        // NOTE: outputDir must exist prior to running this test
+
+        if (params.length >= 1) {
+            outputDir =  params[0];
+        } else {
+            throw new Exception("output directory is not specified. Usage: Test <existing output dir name>");
+        }
+
+        workFileName = outputDir + File.separator + fileName;
+    }
+
+}
+
+
+
+
+class Copier extends Thread {
+
+    FileChannel from = null, to = null;
+
+    CopyFilesTest base = null;
+
+
+    Copier (String id, FileChannel from, FileChannel to, CopyFilesTest base) {
+        super(id);
+        this.from = from;
+        this.to = to;
+        this.base = base; // needed to log failures
+    }
+
+
+    public void run() {
+
+        long size = 0l, transfered = 0l;
+
+        try {
+
+            // First, a lock upon input channel must be aquired - experimants show
+            // operation transferFrom/To is not thread safe
+
+            synchronized (from) {
+
+                Thread.yield();
+
+                // transferFrom/To is not completely thread-safe, we set-up position to 0 explicitely
+
+                from.position(0); 
+
+                // we will transfer by 2 equal portions: 0..size/2 and size/2..size
+
+                size = from.size() / 2; 
+
+                Thread.yield();
+
+                // TESTED METHOD CALL - transferFrom
+
+                transfered = to.transferFrom(from, 0, size);
+
+                if (transfered != size) {
+
+                    base.log.add("Thread " + this.getName() + ": transferFrom transfered " + 
+                        transfered + " bytes, instead of expected " + size + " bytes");
+
+                    base.passed = false;
+   
+                }
+
+                to.force(false);
+
+                // transferFrom/To is not completely thread-safe, we set-up position to the middle 
+                // of file explicitely
+
+                to.position(size);
+
+                // TESTED METHOD CALL - transferTo
+
+                transfered = from.transferTo(size, size, to);
+
+                if (transfered != size) {
+
+                    base.log.add("Thread " + this.getName() + ": transferTo transfered " + 
+                        transfered + " bytes, instead of expected " + size + " bytes");
+
+                    base.passed = false;
+   
+                }
+
+                to.force(false);
+            }
+
+
+        } catch (Exception e) {
+
+            e.printStackTrace();
+
+            base.log.add("Thread " + this.getName() + ": " + e + " while transferFrom/To() operation");
+
+            base.passed = false;
+        }
+    }
+
+}

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/CopyFilesTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelMapTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelMapTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelMapTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelMapTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Nikolay V. Bannikov
+ * @version $Revision: 1.2 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.channels.filechannel;
+
+import org.apache.harmony.test.reliability.share.Test;
+import org.apache.harmony.test.reliability.share.Result;
+
+import java.io.File;
+import java.io.RandomAccessFile;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileChannel.MapMode;
+
+/**
+ * The test does: 
+ * 1. Reads parameters, which are: 
+ *        param[0] - number of threads to run in parallel 
+ *        param[1] - directory where input file is located 
+ *        param[2] - constant for offset within the file 
+ *        param[3] - input file name 
+ *        param[4] - number of iterations each thread does
+ * 
+ * 2. Starts and, then, joins all started threads
+ * 
+ * 3. Checks that in each thread all checks PASSed.
+ * 
+ * 4. Each thread, being started:
+ * 
+ * a. Reads content from input of RandomAccess file (param[1] + "/" + param[3])
+ * to a file channel for mapping into memory
+ * 
+ * b. In each of param[4] iterations: - maps region of this channel's file
+ * directly into memory - the position within the file at which the mapped
+ * region is random
+ */
+
+public class FileChannelMapTest extends Test {
+
+    // Each thread does NUMBER_OF_ITERATIONS mapping operations
+    public int NUMBER_OF_ITERATIONS = 1000;
+
+    // Directory where input file is located
+    public String path_to_file;
+
+    // Input file name
+    public String fileName = "Test.out";
+
+    // constant for offset within the file
+    public int offsetSize = 512;
+
+    // Number of threads to run in parallel
+    public int numThreads = 5;
+
+    public int callSystemGC = 1;
+
+    // Each thread sets PASS/FAIL flag into its corresponding array element
+    public int[] statuses;
+
+    public static void main(String[] args) {
+        System.exit(new FileChannelMapTest().test(args));
+    }
+
+    public int test(String[] params) {
+
+        parseParams(params);
+
+        // Start 'numThreads' threads each reading from file
+
+        Thread[] t = new Thread[numThreads];
+
+        statuses = new int[t.length];
+
+        for (int i = 0; i < t.length; i++) {
+            t[i] = new Thread(new FileChannelThread(i, this));
+            t[i].start();
+            //log.add("Thread " + i + " started");
+        }
+
+        // Correctly wait for all threads to finish
+
+        for (int i = 0; i < t.length; ++i) {
+            try {
+                t[i].join();
+                // log.add("Thread " + i + ": joined() ");
+
+            } catch (InterruptedException ie) {
+                return fail("interruptedException while join() of thread #" + i);
+            }
+        }
+
+        // For each thread check whether operations/checks PASSed in the thread
+
+        for (int i = 0; i < statuses.length; ++i) {
+            if (statuses[i] != Result.PASS) {
+                return fail("thread #" + i + " returned not PASS status");
+            }
+            // log.add("Status of thread " + i + ": is PASS");
+        }
+
+        return pass("OK");
+    }
+
+    public void parseParams(String[] params) {
+
+        if (params.length >= 1 && Integer.parseInt(params[0]) > 0) {
+            numThreads = Integer.parseInt(params[0]);
+        }
+
+        if (params.length >= 2) {
+            path_to_file = params[1];
+        }
+
+        if (params.length >= 3) {
+            offsetSize = Integer.parseInt(params[2]);
+        }
+
+        if (params.length >= 4) {
+            fileName = params[3];
+        }
+
+        if (params.length >= 5) {
+            NUMBER_OF_ITERATIONS = Integer.parseInt(params[4]);
+        }
+
+    }
+
+}
+
+class FileChannelThread implements Runnable {
+
+    public int id;
+
+    public FileChannelMapTest base;
+
+    public FileChannelThread(int id, FileChannelMapTest base) {
+        this.id = id;
+        this.base = base;
+    }
+
+    FileChannel getFileChannelFromFile(String fileName) {
+        File f = null;
+        FileChannel fc = null;
+        try {
+            f = new File(fileName);
+            fc = new RandomAccessFile(f, "r").getChannel();
+        } catch (IOException e) {
+            base.statuses[id] = Result.FAIL;
+            base.log.add("Thread " + id + ": IOException on RandomAccessFile creation");
+            return null;
+        }
+        return fc;
+    }
+
+    public void run() {
+
+        FileChannel.MapMode mode = FileChannel.MapMode.READ_ONLY;
+        FileChannel fc = getFileChannelFromFile(base.path_to_file
+            + File.separator + base.fileName);
+        if (fc == null) {
+            return;
+        }
+        long s = 0;
+        try {
+            s = fc.size();
+        } catch (IOException e) {
+            base.statuses[id] = Result.FAIL;
+            base.log.add("Thread " + id + ": IOException while getting size of channel's file");
+            return;
+        }
+        for (int i = 0; i < base.NUMBER_OF_ITERATIONS; i++) {
+            try {
+                base.statuses[id] = Result.FAIL;
+                long offset = (long) (Math.random() * s);
+                fc.map(mode, Math.min(s - base.offsetSize, offset),
+                    base.offsetSize);
+                base.statuses[id] = Result.PASS;
+            } catch (IOException e) {
+                base.statuses[id] = Result.FAIL;
+                base.log.add("Thread " + id + ", iteration " + i + ": IOException while mapping");
+                return;
+            }
+            if (base.callSystemGC != 0){
+                System.gc();
+            }
+
+        }
+    }
+}

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelMapTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelThrSafetyTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelThrSafetyTest.java?view=auto&rev=545554
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelThrSafetyTest.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelThrSafetyTest.java Fri Jun  8 09:34:52 2007
@@ -0,0 +1,304 @@
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Oleg V. Oleinik
+ * @version $Revision: 1.1 $
+ */
+
+package org.apache.harmony.test.reliability.api.nio.channels.filechannel;
+
+import org.apache.harmony.test.reliability.share.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.RandomAccessFile;
+import java.nio.channels.FileChannel;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+
+
+/**
+ * Goal: check FileChannel write operation for thread safety.
+ *
+ * Idea: Several threads write into a FileChannel equal size chunks of bytes each starting 
+ *       and ending with MARK byte. If write operations are thread unsafe, then chunks 
+ *       will be mixed.
+ *
+ * The test does:
+ *
+ *     1. Parses parameters:
+ *             param[0] - a path to an exiting directory where the test can store its files.
+ *
+ *     2. Creates a file with the name param[0]/fileName.
+ *    
+ *     3. Creates FileInputStream, FileOutputStream and associated channels.
+ *
+ *     4. Starts N_OF_THREADS threads, each thread:
+ *
+ *          a. Creates N_OF_BUFFERS_PER_WRITE byte arrays of (CHUNK_SIZE + 2) size,
+ *            each wrapped into direct ByteBuffer.
+ *
+ *          b. Writes the chunks.
+ *
+ *          c. Repeates the opration N_OF_WRITES_PER_THREAD times.
+ *        
+ *     6. Checks the content of the file: reads bytes from the file by (CHUNK_SIZE + 2) 
+ *        chunks, checks that first and last bytes of each read chunk is MARK.
+ *
+ *     7. Closes channels.
+ * 
+ */
+
+public class FileChannelThrSafetyTest extends Test {
+
+
+    // each written chunk has has size (CHUNK_SIZE + 2) 
+    // and content {MARK, <random bytes>, MARK}
+
+    static final int CHUNK_SIZE = 2000;
+
+
+    // Each thread repeats writing into a channel N_OF_WRITES_PER_THREAD times
+
+    static final int N_OF_WRITES_PER_THREAD = 20;
+
+
+    // Each write operation is called with N_OF_BUFFERS_PER_WRITE ByteBuffers
+
+    static final int N_OF_BUFFERS_PER_WRITE = 20;
+
+
+    // Mark-up byte value
+
+    static final byte MARK = 0x22;
+
+
+    // Number of byte-writing threads to run
+ 
+    static final int N_OF_THREADS = 10;
+
+
+    boolean passed = true;
+
+    String workFileName = "";
+  
+    String fileName = "FileChannelThrSafetyTest.file";
+
+    String outputDir = "";
+
+    FileChannel outChannel = null, inChannel = null;
+
+
+    public static void main(String[] args) {
+        System.exit(new FileChannelThrSafetyTest().test(args));
+    }
+
+
+    public int test(String[] params) {
+
+        File f = null;
+
+        passed = true;
+
+        try {
+
+            parseParams(params);
+
+            f = Utils.createWorkFile(workFileName);
+
+            outChannel = new FileOutputStream(f).getChannel();
+
+            inChannel = new FileInputStream(f).getChannel();
+
+            runThreads();
+
+            if (!passed || !checkWrittenContent()) {
+                return fail("Failed");
+            }
+
+        } catch (Throwable t) {
+
+            t.printStackTrace();
+
+            return fail("Exception thrown: " + t);
+
+        } finally {
+
+            try {
+
+                if (outChannel != null){
+                    outChannel.close();
+                }
+
+                if (inChannel != null){
+                    inChannel.close();
+                }
+                    
+            } catch (Throwable t){
+            }
+
+            if (f != null){
+                f.delete();
+            }
+        }
+
+        return pass("OK");
+    }
+
+
+    // Reads from inChannel by (CHUNK_SIZE + 2) chunks, checks the first and last 
+    // bytes are MARK bytes.
+
+    boolean checkWrittenContent() throws Exception {
+
+        MappedByteBuffer mp = null;
+
+        int steps = N_OF_WRITES_PER_THREAD * N_OF_THREADS * N_OF_BUFFERS_PER_WRITE;
+
+        int size = (CHUNK_SIZE + 2);
+
+        ByteBuffer bb = ByteBuffer.allocate(size); 
+
+        for (int i = 0; i < steps; ++i) {
+
+            bb.clear();
+
+            inChannel.read(bb);
+
+            byte first = bb.get(0);
+
+            byte last = bb.get(bb.capacity() - 1);
+
+            if (first != MARK || last != MARK) {
+
+                log.add("Channel writing is thread-unsafe? - Chunk # " + i + ": first byte is " +
+                    first + ", last byte is " + last + ", While " + MARK + 
+                    " byte is expected for each.");
+
+                return false;
+            }
+
+        }
+
+        return true;
+    }
+
+ 
+    void runThreads() throws Exception {
+
+        Thread[] t = new Thread[N_OF_THREADS];
+
+        for (int i = 0; i < t.length; ++i) {
+            t[i] = new ChunkWriter(this); 
+            t[i].start();
+        }
+
+        for (int i = 0; i < t.length; ++i) {
+            t[i].join();
+        }
+    }
+
+
+    public void parseParams(String[] params) throws Exception {
+
+        // NOTE: outputDir must exist prior to running this test
+
+        if (params.length >= 1) {
+            outputDir =  params[0];
+        } else {
+            throw new Exception("output directory is not specified. Usage: Test <existing output dir name>");
+        }
+        workFileName = outputDir + File.separator + fileName;
+    }
+
+}
+
+
+
+
+class ChunkWriter extends Thread {
+
+    FileChannel outChannel = null;
+
+    FileChannelThrSafetyTest base = null;
+
+
+    ChunkWriter(FileChannelThrSafetyTest base) {
+
+        this.outChannel = base.outChannel;
+
+        this.base = base;
+    }
+
+
+    public void run () {
+
+        try {
+
+            for (int i = 0; i < FileChannelThrSafetyTest.N_OF_WRITES_PER_THREAD; ++i) {
+
+                long written = outChannel.write(createByteChunks());
+
+                // base.log.add("Bytes written " + written);
+
+                Thread.yield();
+
+                Thread.sleep(10);
+            }
+
+            outChannel.force(false);
+
+        } catch (Exception e){
+            base.log.add("Thread " + Thread.currentThread().getId() + ": Exception \"" + e + 
+                "\", while writing ByteBuffer[] into channel");
+            base.passed = false;
+        }
+    }
+
+
+    ByteBuffer[] createByteChunks() {
+
+        ByteBuffer[] bb_arr = new ByteBuffer[FileChannelThrSafetyTest.N_OF_BUFFERS_PER_WRITE];
+
+        for (int i = 0; i < bb_arr.length; ++i) {
+            bb_arr[i] = createByteChunk();
+        }
+       
+        return bb_arr;
+    }
+
+
+    ByteBuffer createByteChunk() {
+
+        byte[] exclusion_bytes = new byte[] {FileChannelThrSafetyTest.MARK, FileChannelThrSafetyTest.MARK};
+
+        byte[] b = Utils.createRndBytes(FileChannelThrSafetyTest.CHUNK_SIZE + 2, exclusion_bytes);
+
+        b[0] = FileChannelThrSafetyTest.MARK;
+  
+        b[b.length - 1] = b[0];
+
+        ByteBuffer bb = ByteBuffer.allocateDirect(b.length).wrap(b);
+
+        return bb;
+    }
+
+}
+

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/reliability/src/java/org/apache/harmony/test/reliability/api/nio/channels/filechannel/FileChannelThrSafetyTest.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message