/*************************************************************************
/* jdk11.java -- java.io.File 1.1 tests
/*
/* Copyright (c) 2001, 2002 Free Software Foundation, Inc.
/*
/* This program is free software; you can redistribute it and/or modify
/* it under the terms of the GNU General Public License as published
/* by the Free Software Foundation, either version 2 of the License, or
/* (at your option) any later version.
/*
/* This program is distributed in the hope that it will be useful, but
/* WITHOUT ANY WARRANTY; without even the implied warranty of
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
/* GNU General Public License for more details.
/*
/* You should have received a copy of the GNU General Public License
/* along with this program; if not, write to the Free Software Foundation
/* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
/*************************************************************************/
// Tags: JDK1.1
package gnu.testlet.wonka.io.RandomAccessFile;
import gnu.testlet.TestHarness;
import gnu.testlet.Testlet;
import java.io.EOFException;
import java.io.File;
import java.io.FileDescriptor;
import java.io.IOException;
import java.io.RandomAccessFile;
public class jdk11
implements Testlet
{
public void test (TestHarness testharness)
{
testharness.setclass("java.io.RandomAccessFile");
TestHarness harness = testharness;
String fname = "raftmpfile";
RandomAccessFile raf;
int rdcnt;
byte[] buf = {0, 0, 0, 0};
// Start by deleting test file, if it exists,
// to clear out any leftover data
File f = new File(fname);
if (f.exists())
f.delete();
// new RandomAccessFile(filename, mode);
try
{
raf = new RandomAccessFile(fname, "rw");
}
catch (IOException e)
{
harness.fail("new RandomAccessFile(Filename, mode): Can't open file "
+ fname);
return; // can't proceed without open file
}
try
{
FileDescriptor fd = raf.getFD();
}
catch (IOException e)
{
harness.fail("getFD(): Can't get FileDescriptor");
return; // shouldn't proceed if no FileDescriptor
}
// Test skipBytes
String teststr = "foobar";
int testlength = teststr.length();
byte[] testbytes = new byte[testlength];
;
for (int i = 0; i < teststr.length(); i++)
testbytes[i] = (byte) teststr.charAt(i);
try
{
// write(b[])
raf.write(testbytes);
harness.check(testlength, raf.length(), "write(b[])/length()");
harness.debug("File size = " + raf.length() + "; should = " + testlength);
raf.seek(0);
// Make sure skipBytes goes all the way to the end of the file and no further
int skipped = 0;
for (int i = 0; i < testbytes.length + 1; i++)
{ // last skip should return 0 bytes
int offset = raf.skipBytes(1);
harness.debug("skipped " + offset + " bytes@ "+raf.getFilePointer()+" fsize = "+raf.length());
skipped += offset;
}
harness.check(skipped, testlength, "skipBytes() did not skip past EOF");
// read()
raf.seek(0);
char ch1 = (char) raf.read();
char ch2 = teststr.charAt(0);
harness.check(ch1, ch2, "read()");
harness.debug("Read " + ch1 + "; should be " + ch2);
// getFilePointer() (sneak this one in because all the setup is done already)
harness.check(raf.getFilePointer(), 1, "getFilePointer()");
// read(b[], off, len)
raf.seek(0); // test seek and read multiple bytes all at once
rdcnt = raf.read(buf, 0, 3);
harness.check(rdcnt, 3,
"read(b[], off, len):Reading correct number of bytes");
harness.debug("Read " + rdcnt + " bytes; should have been 3.");
String str = new String(buf);
harness.check(str.substring(0, 3).equals(teststr.substring(0, 3)),
"read(b[], off, len):Reading at correct offset");
harness.debug("array read: read " + str + "; expected "
+ teststr.substring(0, 3));
// read(b[])
raf.seek(0);
rdcnt = raf.read(buf);
harness.check(rdcnt, buf.length, "read(b[])");
harness.debug("buffer fill: read " + str + "; expected "
+ teststr.substring(0, 3));
// readFully(b[])
int buf2ln = teststr.length() + 5; // make a buffer big enough to hold all the data
byte[] buf2 = new byte[buf2ln];
for (int i = 0; i < buf2ln; i++)
buf2[i] = 0; // fill with zeroes so we can test length
raf.seek(0);
try
{
raf.readFully(buf2);
}
catch (EOFException eofe)
{
harness.check(buf2[testlength - 1],
teststr.charAt(teststr.length() - 1),
"readFully(b[]):Enough bytes read");
harness.check(buf2[testlength], 0, "readFully(b[]):Too many bytes");
}
// readFully(b[], off, len)
for (int i = 0; i < buf2ln; i++)
buf2[i] = 0; // fill with zeroes so we can test length
raf.seek(0);
try
{
raf.readFully(buf2, 0, testlength + 2);
}
catch (EOFException eofe)
{
harness.check(buf2[testlength - 1],
teststr.charAt(teststr.length() - 1),
"readFully(b[],off,len):Enough bytes read");
harness.check(buf2[testlength], 0,
"readFully(b[],off,len):Too many bytes");
}
// write(b[], off, len);
raf.seek(0);
raf.write(testbytes, 2, 3);
raf.seek(0);
raf.read(buf2, 0, 3);
String t1;
String b1;
t1 = new String(testbytes, 2, 3);
b1 = new String(buf2, 0, 3);
harness.check(t1, b1, "write(b[], off, len");
harness.debug("write(b[], off, len):Wrote " + t1 + ", read " + b1);
// write(byte)/writeByte(byte)/readByte()
raf.seek(0);
raf.write(12);
raf.seek(0);
harness.check(raf.readByte(), 12, "write(byte)/readByte(), positive");
raf.seek(0);
raf.writeByte(-12);
raf.seek(0);
harness.check(raf.readByte(), -12, "writeByte(byte)/readByte(), negative");
// writeBoolean/readBoolean
raf.seek(0);
raf.writeBoolean(true);
raf.writeBoolean(false);
raf.seek(0);
harness.check(raf.readBoolean(), "writeBoolean(T)/readBoolean()");
harness.check(!raf.readBoolean(), "writeBoolean(F)/readBoolean()");
// writeShort/readShort
raf.seek(0);
raf.writeShort(527);
raf.seek(0);
harness.check(raf.readShort(), 527, "writeShort(n)/readShort()");
// writeUTF/readUTF
raf.seek(0);
raf.writeUTF(teststr);
raf.seek(0);
harness.check(raf.readShort(), testlength, "writeUTF(s): length encoding");
raf.seek(0);
harness.check(raf.readUTF(), teststr,
"writeUTF(s)/readUTF: string recovery");
// writeBytes/readLine
// N.B.: This test actually tests to the JDK1.2 specification. JDK1.1 says, in part:
// The line-terminating character(s), if any, are included as part of the string returned.
// The actual behavior, and spec'd in 1.2, is to strip the line terminator. Its presence is
// inferred from readLine's returning the correct string up to, but not including, the terminator.
raf.seek(0);
raf.writeBytes("foobar\n");
raf.seek(0);
harness.check(raf.readLine(), "foobar", "writeBytes(s)/readLine()");
// writeChar(c)/writeChars(s)/readChar()
raf.seek(0);
raf.writeChar('f');
raf.writeChars("oobar");
raf.seek(0);
String s = "";
for (int i = 0; i < 6; i++)
s += raf.readChar();
harness.check(s, "foobar", "writeChar/writeChars/readChar()");
// writeLong/readLong
raf.seek(0);
raf.writeLong(123456L);
raf.seek(0);
harness.check(raf.readLong(), 123456L, "writeLong(l)/readLong()");
// writeFloat/readFloat
raf.seek(0);
raf.writeFloat(123.45F);
raf.seek(0);
harness.check(raf.readFloat(), 123.45F, "writeFloat(l)/readFloat()");
// writeDouble/readDouble
raf.seek(0);
raf.writeDouble(123.45D);
raf.seek(0);
harness.check(raf.readDouble(), 123.45D, "writeDouble(l)/readDouble()");
// writeInt/readInt
raf.seek(0);
raf.writeInt(12345);
raf.seek(0);
harness.check(raf.readInt(), 12345, "writeInt(l)/readInt()");
// readUnsignedByte/readUnsignedShort
raf.seek(2);
harness.check(raf.readUnsignedByte(), 48, "readUnsignedByte()");
raf.seek(2);
harness.check(raf.readUnsignedShort(), 12345, "readUnsignedShort()");
}
catch (IOException e)
{
harness.debug(e);
harness.fail("IOException after opening file");
}
// close()
try
{
raf.close();
}
catch (IOException e)
{
harness.check(false, "close()");
}
}
}