/** Test whether the read is forbiden while somebody is writing

     */

    public void  testWriteReadExclusion () throws Exception {

        checkSetUp();

        FileObject fold = getTestFolder1(root);

        final FileObject fo1 = getTestFile1(fold);

        String testStr = "text";

        try {

            writeStr(fo1, testStr);

        } catch (IOException iex) {

            fsAssert(

                "expected move will success on writable FS",

                fs.isReadOnly() || fo1.isReadOnly()

            );

            return;

        }

        class DoWorkInOtherThread implements Runnable {

            Exception ex;

            public void run () {

                try {

                    FileLock lock = fo1.lock();

                    OutputStream os = fo1.getOutputStream (lock);

                    os.write (1);

                    os.write (2);

                    os.flush ();

                    synchronized (this) {

                        notify ();

                        // block for a while so the other thread

                        // can do the partial read

                        wait (1000);

                    }

                    os.write (3);

                    os.write (4);

                    os.close ();

                    lock.releaseLock();

                } catch (Exception ex) {

                    this.ex = ex;

                }

            }

            public void executeDirectly () throws Exception {

                synchronized (this) {

                    new RequestProcessor ("Writes with delay").post (this);

                    wait ();

                }

                try {

                    InputStream is = fo1.getInputStream ();

                    byte[] arr = new byte[200];

                    int len = is.read (arr);

                    assertEquals ("Read all four bytes", 4, len);

                    for (int i = 0; i < 4; i++) {

                        assertEquals (i + " th byte is " + i, i, arr[i]);

                    }

                } catch (InterruptedIOException ex) {

                    // InterruptedIOException is fine, means we could not read the stream

                } finally {

                    synchronized (this) {

                        // let the writer thread finish

                        notifyAll ();

                    }

                }

            }

        }

        DoWorkInOtherThread d = new DoWorkInOtherThread ();

        d.executeDirectly ();

    }