     // check the uncompress/compress length should equal original length 7
     var restoredlength=bytearray_compress.length;
     var restorestate=(bytearray_compress[0]==0xef &&
-                       bytearray_compress[1]==0xbb &&
-                       bytearray_compress[2]==0xbf &&
-                       bytearray_compress[3]==100 &&
-                       bytearray_compress[4]==97 &&
-                       bytearray_compress[5]==110 &&
-                       bytearray_compress[6]==33
-                     );
+					  bytearray_compress[1]==0xbb &&
+					  bytearray_compress[2]==0xbf &&
+					  bytearray_compress[3]==100 &&
+					  bytearray_compress[4]==97 &&
+					  bytearray_compress[5]==110 &&
+					  bytearray_compress[6]==33
+		);
     AddTestCase("ByteArray.compress bytearray length is different",
                 origlength==compresslength,false);
     AddTestCase("ByteArray.compress bytearray contents differ",

        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);

// [] syntax
    bytearray.position=0;
    bytearray.writeByte(10);
    bytearray.writeByte(11);
    bytearray.writeByte(12);
    AddTestCase(
     "ByteArray get [] syntax",
     12,
     bytearray[2]);
   
    bytearray[2]=13;
    AddTestCase(
     "ByteArray set [] syntax",
     13,
     bytearray[2]);

// fill empty spaces with 0s
    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);

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

    AddTestCase(
     "ByteArray constructor with ByteArray copies values, check values",
     103,
     bytearray2[2]);

    var bytearray3:ByteArray=new ByteArray;
    bytearray.readBytes(bytearray3,8);
    AddTestCase(
     "ByteArray readBytes 8 length copies values, check size",
     8,
     bytearray3.length);

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

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

// hasAtomProperty
    var bytearray_atom=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);
    
// read/write file
    File.writeByteArray('test.ba', bytearray_atom);
    var bytearray_read=File.readByteArray('test.ba');
    AddTestCase(
      "ByteArray read/writeFile",
      3,
      bytearray_read.length);

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

// bom/toString
    bytearray_bom=new ByteArray;
    bytearray_bom[0]=0xef;
    bytearray_bom[1]=0xbb;
    bytearray_bom[2]=0xbf;


    writeHeaderToLog( SECTION + " "+ TITLE );

// Utility to make and pad a ByteArray
function makeByteArray(padding=0) : ByteArray
{
    var bytearray:ByteArray=new ByteArray();
    for ( var i=0 ; i < padding ; i++ )
		bytearray.writeByte(0);
    return bytearray;
}

// Utility to test for EOFError
function expectEOF(tag, thunk)
{
	var exn_ok = "No exn";
	try                 { thunk(); }
	catch (e: EOFError) { exn_ok = "OK"; }
	catch (e)           { exn_ok = "Wrong type"; }
	AddTestCase(tag, "OK", exn_ok);
}

function testBasicProperties() {
    var bytearray:ByteArray=new ByteArray();

    AddTestCase(
      "ByteArray constructor no args",
      true,
