     bytearray_bad[5]=0xB8;
     bytearray_bad[6]=0x80;
     AddTestCase(
-      "ByteArray with partial bad utf-8 sequence",
-      "\u4e00\u00E4\u4e00",
-      bytearray_bad.toString());
+		"ByteArray with partial bad utf-8 sequence",
+		"\u4e00\u00E4\u4e00",
+		bytearray_bad.toString());
 
 // truncated utf-8 sequence
     bytearray_bad = new ByteArray();
     bytearray_bad[0]=0xE4; // truncated sequence
     bytearray_bad[1]=0xB8;
     AddTestCase(
-      "ByteArray with truncated utf-8 sequence",
-      "\u00E4\u00B8",
-      bytearray_bad.toString());
+		"ByteArray with truncated utf-8 sequence",
+		"\u00E4\u00B8",
+		bytearray_bad.toString());
 
 // utf-8 sequence > 0x1FFFF
     bytearray_bad = new ByteArray();

      "ByteArray write/read boolean false",
      false,
      bytearray.readBoolean());

// short
    bytearray.position=0;
    bytearray.writeShort(100);
    bytearray.position=0;
    AddTestCase(
     "ByteArray readShort",
     100,
     bytearray.readShort());

// short
    bytearray.position=0;
    bytearray.writeShort(-65436);
    bytearray.position=0;
    AddTestCase(
     "ByteArray readUnsignedShort",
     100,
     bytearray.readUnsignedShort());

// int
    bytearray.position=0;
    bytearray.writeInt(100);
    bytearray.position=0;
    AddTestCase(
     "ByteArray readInt",
     100,
     bytearray.readInt());
   
// unsigned int
    bytearray.position=0;
    bytearray.writeUnsignedInt(100);
    bytearray.position=0;
    AddTestCase(
     "ByteArray readUnsignedInt",
     100,
     bytearray.readUnsignedInt());

// float
    bytearray.position=0;
    bytearray.writeFloat(-3.14);
    bytearray.position=0;
    AddTestCase(
     "ByteArray readFloat with 0.001",
     true,
     -3.14-bytearray.readFloat()<0.01);

// float
    bytearray.position=0;
    bytearray.writeDouble(-3.14);
    bytearray.position=0;
    AddTestCase(
     "ByteArray readDouble with 0.001",
     true,
     -3.14-bytearray.readDouble()<0.01);

//  byte
    bytearray.position=0;
    bytearray.writeByte(-257);
    bytearray.position=0;
    AddTestCase(
     "ByteArray readByte",
     -1,
     bytearray.readByte());

// unsigned byte
    bytearray.position=0;
    bytearray.writeByte(-259);
    bytearray.position=0;
    AddTestCase(
     "ByteArray readByte",
     253,
     bytearray.readUnsignedByte());

// utf
    bytearray.position=0;
    bytearray.writeUTF("string");
    bytearray.position=0;
    AddTestCase(
     "ByteArray length of utf string",
     8,
     bytearray.length);
    AddTestCase(
     "ByteArray readUTF",
     "string",
     bytearray.readUTF());

// utf
    bytearray.position=0;
    bytearray.length=0;
    bytearray.writeUTFBytes("string");
    bytearray.position=0;
    AddTestCase(
     "ByteArray length of utf bytes string",
     6,
     bytearray.length);
    AddTestCase(
     "ByteArray readUTFBytes",
     "string",
     bytearray.readUTFBytes(6));

// compress/uncompress
    bytearray.compress();
    AddTestCase(
     "ByteArray length after compress",
     14,
     bytearray.length);

    bytearray.uncompress();
    AddTestCase(
     "ByteArray length after uncompress",
     6,
     bytearray.length);

    bytearray.length=0;
    bytearray.compress();
    AddTestCase(
     "ByteArray length after empty compress",
     0,
     bytearray.length);

    bytearray.uncompress();
    AddTestCase(
     "ByteArray length after empty uncompress",
     0,
     bytearray.length);

// endian
    AddTestCase(
     "get default endian",
     "bigEndian",
     bytearray.endian);

    bytearray.endian="littleEndian";
    AddTestCase(
     "set endian littleEndian",
     "littleEndian",
     bytearray.endian);

    bytearray.endian="bigEndian";
    AddTestCase(
     "set endian bigEndian",
     "bigEndian",
     bytearray.endian);

    var err="none";
    try {

        err=e.toString();
    }
    AddTestCase(
		"exception thrown when endian is to littleEndian or bigEndian",
		"ArgumentError: Error #2008",
		err.substring(0,26));
    AddTestCase(
		"endian value is uchanged after invalid set",
		"bigEndian",
		bytearray.endian);
}

testEndian();

function testBracketSyntax() {
    var bytearray:ByteArray = makeByteArray();
    bytearray.position=0;
    bytearray.writeByte(10);
    bytearray.writeByte(11);
    bytearray.writeByte(12);
    bytearray.position = 0;

    AddTestCase(
		"ByteArray get [] syntax",
		12,
		bytearray[2]);
   
    bytearray[2]=13;
    AddTestCase(
		"ByteArray set [] syntax",
		13,
		bytearray[2]);

    // We can write negative values but should read positive values
    bytearray[2] = -13;
    AddTestCase(
		"ByteArray set [] / get [] syntax",
		243,
		bytearray[2]);

    // This is sad, but it is the traditional behavior: reading
    // outside the range returns undefined, it does not throw or
    // return 0.  Ergo bytearray "byte" reads are not monotyped.
    AddTestCase("Bytearray get[] out of range",
				undefined,
				bytearray[3]);

    // When writing out of range, extend the bytearray and zero-fill
    bytearray[4] = 37;

    AddTestCase("ByteArray set[] out of range: changed element",
				37,
				bytearray[4]);

    AddTestCase("ByteArray set[] out of range: length",
				5,
				bytearray.length);

    AddTestCase("ByteArray set[] out of range: zero-fill",
				0,
				bytearray[3]);

    // Sanity: all this reading and writing has not changed the position
    AddTestCase("ByteArray get[] and set[]: position",
				0,
				bytearray.position);

    // Sanity: accesses with Atom are correct.  We could have more tests here.
    var v = {}
    v[String.prototype.toLowerCase.call("X")] = 2;  // Defeat most reasonable optimizations
    
    bytearray[v.x] = 42;
    AddTestCase("ByteArray set[] with Atom index",
				42,
				bytearray[2]);

    bytearray[2] = 112;
    AddTestCase("ByteArray get[] with Atom index",
				112,
				bytearray[v.x]);
}

testBracketSyntax();

function testLengthManipulation() {
    var bytearray:ByteArray = new ByteArray;
    bytearray.length=10;
    AddTestCase(
		"ByteArray empty slots filled with 0",
		0,
		bytearray[9]);

    var bytearray_shrink=new ByteArray;
    bytearray_shrink.length=10;
    bytearray_shrink.length=5;
    AddTestCase(
		"ByteArray shrink length",
		5,
		bytearray_shrink.length);
}

testLengthManipulation();

function testReadBytes() {
    var bytearray:ByteArray = makeByteArray();
    bytearray.writeUTF("abcdefghijk");
    bytearray.position = 0;

    var bytearray2:ByteArray=new ByteArray;
    bytearray.readBytes(bytearray2,0,0);

	for ( var i="a".charCodeAt(0), k=0 ; i <= "k".charCodeAt(0) ; i++, k++ )
		AddTestCase("readBytes correct content",
					i,
					bytearray2[k+2]);

    var bytearray3:ByteArray=new ByteArray;
	var pos = bytearray.position;
    bytearray.readBytes(bytearray3,8);
    AddTestCase(
		"ByteArray readBytes 8 length copies values, check size",
		8,
		bytearray3.length);
	AddTestCase(
		"ByteArray readBytes 8 length copies values, check position",
		pos, // Position *is not* updated by readBytes()
		bytearray.position);

	expectEOF("EOF in readBytes",
			  (function () {
				  bytearray.position = 0;
				  bytearray.readBytes(bytearray3, 0, bytearray.length+1);
			  }));

	// TODO: test more combinations of offset and count
}

testReadBytes();

function testWriteBytes() {
    var bytearray:ByteArray = makeByteArray();
	for ( var i=0 ; i < 10 ; i++ )
		bytearray.writeByte(i);

    var bytearray4=new ByteArray;
    bytearray4.writeBytes(bytearray);
    AddTestCase(
		"ByteArray writeBytes: length",
		10,
		bytearray4.length);

	AddTestCase(
		"ByteArray writeBytes: position",
		10, // Position *is* updated by writeBytes()
		bytearray4.position);

	for ( var i=0 ; i < 10 ; i++ ) {
		AddTestCase(
			"ByteArray writeBytes: content",
			i,
			bytearray4[i]);
	}

    var bytearray5=new ByteArray;
    bytearray5.writeBytes(bytearray,1,5);
    AddTestCase(
		"ByteArray writeBytes",
		5,
		bytearray5.length);

	// TODO: test more combinations of offset and count
}

testWriteBytes();

function testHasAtomProperty() {
    var bytearray_atom:ByteArray=new ByteArray;
    bytearray_atom.writeByte(1);
    bytearray_atom.writeByte(2);
    bytearray_atom.writeByte(3);
    AddTestCase(
		"ByteArray hasAtomProperty true",
		true,
		1 in bytearray_atom);
    AddTestCase(
		"ByteArray hasAtomProperty false",
		false,
		5 in bytearray_atom);
}

testHasAtomProperty();    

function testFileIO() {
    var bytearray_atom:ByteArray=new ByteArray;
    bytearray_atom.writeByte(1);
    bytearray_atom.writeByte(2);
    bytearray_atom.writeByte(3);

    File.writeByteArray('test.ba', bytearray_atom);
    var bytearray_read:ByteArray=File.readByteArray('test.ba');
    AddTestCase(
		"ByteArray read/writeFile",
		3,
		bytearray_read.length);

    var err2="";
    try {
        var bytearray_badread:ByteArray=File.readByteArray('foo.ba');
    } catch (e) {
        err2=e.toString();
    }
    AddTestCase(
		"ByteArray read/writeFile exception",
		"Error: Error #1500",
		err2.substring(0,18));
}

testFileIO();

function testBOM() {
    var bytearray_bom:ByteArray=new ByteArray;
    bytearray_bom[0]=0xef;
    bytearray_bom[1]=0xbb;
    bytearray_bom[2]=0xbf;
