From 0d1d11066014c25d31124935d4ed088514ce8509 Mon Sep 17 00:00:00 2001
From: Nathan Adams <dinnerbone@dinnerbone.com>
Date: Thu, 27 Jul 2023 09:58:17 +0200
Subject: [PATCH] tests: Port avmplus ByteArray tests

---
 .../as3/ByteArray/ByteArray/Test.as           | 1265 +++++++++++++++++
 .../as3/ByteArray/ByteArray/config.xml        |   13 +
 .../as3/ByteArray/ByteArray/output.txt        |  425 ++++++
 .../as3/ByteArray/ByteArray/test.swf          |  Bin 0 -> 7543 bytes
 .../as3/ByteArray/ByteArray/test.toml         |    2 +
 .../as3/ByteArray/ByteArrayLzma/Test.as       |  924 ++++++++++++
 .../as3/ByteArray/ByteArrayLzma/config.xml    |   13 +
 .../as3/ByteArray/ByteArrayLzma/output.txt    |  397 ++++++
 .../as3/ByteArray/ByteArrayLzma/test.swf      |  Bin 0 -> 6713 bytes
 .../as3/ByteArray/ByteArrayLzma/test.toml     |    5 +
 .../ByteArray/ByteArrayLzmaThirdParty/Test.as |  356 +++++
 .../ByteArrayLzmaThirdParty/config.xml        |   13 +
 .../ByteArrayLzmaThirdParty/output.txt        |    2 +
 .../ByteArrayLzmaThirdParty/test.swf          |  Bin 0 -> 3541 bytes
 .../ByteArrayLzmaThirdParty/test.toml         |    4 +
 15 files changed, 3419 insertions(+)
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/Test.as
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/config.xml
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/output.txt
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/test.swf
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/test.toml
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/Test.as
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/config.xml
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/output.txt
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/test.swf
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/test.toml
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/Test.as
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/config.xml
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/output.txt
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/test.swf
 create mode 100644 tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/test.toml

diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/Test.as b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/Test.as
new file mode 100644
index 000000000..3aac8a7b6
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/Test.as
@@ -0,0 +1,1265 @@
+/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
+/* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// General principles for this test suite:
+//
+//  - never write just one, write at least two (to test that position 
+//    advances correctly and output is placed correctly)
+//  - ditto read
+//  - test both little and big endian for multibyte data
+//  - test both aligned and unaligned access for multibyte data
+//
+// Search for "TODO" for comments about missing tests.
+
+    package {
+import flash.display.MovieClip;
+public class Test extends MovieClip {}
+}
+
+import flash.utils.ByteArray
+    import flash.errors.EOFError
+    import flash.errors.IOError
+import com.adobe.test.Assert;
+
+//     var SECTION = "ByteArray";
+//     var VERSION = "as3";
+//     var TITLE   = "test ByteArray class";
+
+
+// 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 RangeError
+function expectRangeError(tag, thunk)
+{
+    var exn_ok = "No exn";
+    try                   { thunk(); }
+    catch (e: RangeError) { exn_ok = "OK"; }
+    catch (e)             { exn_ok = "Wrong type"; }
+    Assert.expectEq(tag, "OK", exn_ok);
+}
+
+// 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"; }
+    Assert.expectEq(tag, "OK", exn_ok);
+}
+
+// Utility to test for IOError
+function expectIOError(tag, thunk)
+{
+    var exn_ok = "No exn";
+    try                { thunk(); }
+    catch (e: IOError) { exn_ok = "OK"; }
+    catch (e)          { exn_ok = "Wrong type"; }
+    Assert.expectEq(tag, "OK", exn_ok);
+}
+
+function testBasicProperties() {
+    var bytearray:ByteArray=new ByteArray();
+
+    Assert.expectEq(
+      "ByteArray constructor no args",
+      true,
+      bytearray!=null
+      );
+
+    // operations on empty bytearray
+
+    Assert.expectEq(
+      "ByteArray length of empty",
+      0,
+      bytearray.length);
+
+    Assert.expectEq(
+      "ByteArray toString empty",
+      "",
+      bytearray.toString())
+
+    Assert.expectEq(
+      "ByteArray available on empty",
+      0,
+      bytearray.bytesAvailable);
+
+    Assert.expectEq("ByteArray position on empty",
+        0,
+        bytearray.position);
+
+    Assert.expectEq("ByteArray endianness on empty",
+        "bigEndian",
+        bytearray.endian);
+}
+
+testBasicProperties();
+
+function testSetLengthAndPosition() {
+    var bytearray:ByteArray=new ByteArray();
+
+    // Test: setting length to 0 sets position to 0
+
+    bytearray.writeByte(1);
+    bytearray.writeByte(2);
+    Assert.expectEq("ByteArray trivial length",
+        2,
+        bytearray.length);
+    Assert.expectEq("ByteArray trivial position",
+        2,
+        bytearray.position);
+    bytearray.length = 0;
+    Assert.expectEq("ByteArray position after clearing",
+        0,
+        bytearray.position);
+
+    // Test: setting position beyond length does not update length.
+
+    bytearray.length = 0;
+    bytearray.position = 47;
+    Assert.expectEq("ByteArray position can exceed length, #1",
+        47,
+        bytearray.position);
+    Assert.expectEq("ByteArray position can exceed length, #2",
+        0,
+        bytearray.length);
+
+    // Test: writing updates at position > length inserts zero padding and writes
+    // byte at the appropriate position.
+
+    bytearray.writeByte(12);
+
+    Assert.expectEq("ByteArray position can exceed length, #3",
+        48,
+        bytearray.position);
+    Assert.expectEq("ByteArray position can exceed length, #4",
+        48,
+        bytearray.length);
+    Assert.expectEq("ByteArray position can exceed length, #5",
+        0,
+        bytearray[11]);
+    Assert.expectEq("ByteArray position can exceed length, #6",
+        12,
+        bytearray[47]);
+}
+
+testSetLengthAndPosition();
+
+function testBoolean() 
+{
+    var bytearray:ByteArray=makeByteArray();
+    bytearray.writeBoolean(true);
+    bytearray.writeBoolean(false);
+    Assert.expectEq("ByteArray position after writing Booleans",
+        2,
+        bytearray.position);
+
+    bytearray.position=0;
+    Assert.expectEq(
+      "ByteArray move position to 0",
+      0,
+      bytearray.position);
+
+    Assert.expectEq(
+      "ByteArray write/read boolean true",
+      true,
+      bytearray.readBoolean());
+
+    Assert.expectEq(
+      "ByteArray write/read boolean false",
+      false,
+      bytearray.readBoolean());
+}
+
+testBoolean();
+
+function testShort() 
+{
+    // One endianness or the other
+    function readShort_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeShort(100);
+        bytearray.writeShort(-200);
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readShort_1 #1 " + endian,
+                    100,
+                    bytearray.readShort());
+        Assert.expectEq( "ByteArray readShort_1 #2 " + endian,
+                     -200,
+                     bytearray.readShort());
+        Assert.expectEq("ByteArray readShort_1 #3" + endian,
+                    4+offset,
+                    bytearray.position);
+    }
+
+    // Mixed endianness: write with one, read with the other
+    function readShort_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+        bytearray.writeShort(int(0x1234));
+        bytearray.writeShort(int(0xFEDC));
+        bytearray.position=offset;
+        bytearray.endian = "littleEndian";
+        Assert.expectEq("ByteArray readShort_2 #1",
+                    int(0x3412),
+                    bytearray.readShort());
+        Assert.expectEq("ByteArray readShort_2 #2",
+                    int(0xFFFFDCFE),   // Sign extended
+                    bytearray.readShort());
+        Assert.expectEq("ByteArray readShort_2 #3",
+                    4+offset,
+                    bytearray.position);
+    }
+
+    // EOF at various offsets and alignments
+    function readShort_tests3(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);  // use offset to create the alignment
+        bytearray.writeShort(0x1234);
+
+        for ( var i=0 ; i < 2 ; i++ ) {
+            var v;
+            expectEOF("ByteArray readShort_3 #1 " + offset + " " + (i+1),
+                      (function () {
+                          bytearray.position = offset + i + 1;
+                          v = bytearray.readShort();
+                      }));
+        }
+    }
+
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readShort_tests1("bigEndian", offs);
+        readShort_tests1("littleEndian", offs);
+        readShort_tests2(offs);
+        readShort_tests3(offs);
+    }
+}
+
+testShort();
+
+function testUnsignedShort() 
+{
+    // One endianness or the other
+    function readUShort_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeShort(100);
+        bytearray.writeShort(uint(-200) & 65535);
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readUShort_1 #1 " + endian,
+                    uint(100),
+                    bytearray.readUnsignedShort());
+        Assert.expectEq("ByteArray readUShort_1 #2 " + endian,
+                    uint(-200) & 65535,
+                    bytearray.readUnsignedShort());
+        Assert.expectEq("ByteArray readUShort_1 #3" + endian,
+                    4+offset,
+                    bytearray.position);
+    }
+
+    // Mixed endianness: write with one, read with the other
+    function readUShort_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+        bytearray.writeShort(uint(0x1234));
+        bytearray.writeShort(uint(0xFEDC) & 65535);
+        bytearray.position=offset;
+        bytearray.endian = "littleEndian";
+        Assert.expectEq("ByteArray readUShort_2 #1",
+                    uint(0x3412),
+                    bytearray.readUnsignedShort());
+        Assert.expectEq("ByteArray readUShort_2 #2",
+                    uint(0xDCFE),
+                    bytearray.readUnsignedShort());
+        Assert.expectEq("ByteArray readUShort_2 #3",
+                    4+offset,
+                    bytearray.position);
+    }
+
+    // EOF at various offsets and alignments
+    function readUShort_tests3(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);  // use offset to create the alignment
+        bytearray.writeShort(0x1234);
+
+        for ( var i=0 ; i < 2 ; i++ ) {
+            var v;
+            expectEOF("ByteArray readUShort_3 #1 " + offset + " " + (i+1),
+                      (function () {
+                          bytearray.position = offset + i + 1;
+                          v = bytearray.readUnsignedShort();
+                      }));
+        }
+    }
+
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readUShort_tests1("bigEndian", offs);
+        readUShort_tests1("littleEndian", offs);
+        readUShort_tests2(offs);
+        readUShort_tests3(offs);
+    }
+}
+
+testUnsignedShort();
+
+function testInt()
+{
+    // One endianness or the other
+    function readInt_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeInt(100);
+        bytearray.writeInt(-200);
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readInt_1 #1 " + endian,
+                    100,
+                    bytearray.readInt());
+        Assert.expectEq( "ByteArray readInt_1 #2 " + endian,
+                     -200,
+                     bytearray.readInt());
+        Assert.expectEq("ByteArray readInt_1 #3" + endian,
+                    8+offset,
+                    bytearray.position);
+    }
+
+    // Mixed endianness: write with one, read with the other
+    function readInt_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+        bytearray.writeInt(int(0x12345678));
+        bytearray.writeInt(int(0xFEDCBA98));
+        bytearray.position=offset;
+        bytearray.endian = "littleEndian";
+        Assert.expectEq("ByteArray readInt_2 #1",
+                    int(0x78563412),
+                    bytearray.readInt());
+        Assert.expectEq("ByteArray readInt_2 #2",
+                    int(0x98BADCFE),
+                    bytearray.readInt());
+        Assert.expectEq("ByteArray readInt_2 #3",
+                    8+offset,
+                    bytearray.position);
+    }
+
+    // EOF at various offsets and alignments
+    function readInt_tests3(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);  // use offset to create the alignment
+        bytearray.writeInt(0x12345678);
+
+        for ( var i=0 ; i < 4 ; i++ ) {
+            var v;
+            expectEOF("ByteArray readInt_3 #1 " + offset + " " + (i+1),
+                      (function () {
+                          bytearray.position = offset + i + 1;
+                          v = bytearray.readInt();
+                      }));
+        }
+
+        // Testing for wraparound problems when reading with position
+        // much greater than length.  Given that the bytevector size
+        // is 1000, a length of 0xFFFFFFF0 will always wrap around on
+        // a 32-bit system.  On a 64-bit system we depend on the C++
+        // run-time code using uint32_t to represent length and
+        // position; if it did not we might abort due to a too-large
+        // allocation attempt.
+
+        bytearray.length = 1000;
+        expectEOF("ByteArray readInt_3 #2 at position=2^32-16",
+                  (function () {
+                      bytearray.position = 0xFFFFFFF0;
+                      v = bytearray.readInt();
+                    }));
+    }
+
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readInt_tests1("bigEndian", offs);
+        readInt_tests1("littleEndian", offs);
+        readInt_tests2(offs);
+        readInt_tests3(offs);
+    }
+}
+
+testInt();
+   
+function testUnsignedInt()
+{
+    // One endianness or the other
+    function readUInt_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeUnsignedInt(100);
+        bytearray.writeUnsignedInt(uint(-200));
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readUnsignedInt_1 #1 " + endian,
+                    100,
+                    bytearray.readUnsignedInt());
+        Assert.expectEq("ByteArray readUnsignedInt_1 #2 " + endian,
+                    uint(-200),
+                    bytearray.readUnsignedInt());
+        Assert.expectEq("ByteArray readUnsignedInt_1 #3" + endian,
+                    8+offset,
+                    bytearray.position);
+    }
+
+    // Mixed endianness: write with one, read with the other
+    function readUInt_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+        bytearray.writeUnsignedInt(uint(0x12345678));
+        bytearray.writeUnsignedInt(uint(0xFEDCBA98));
+        bytearray.position=offset;
+        bytearray.endian = "littleEndian";
+        Assert.expectEq("ByteArray readUnsignedInt_2 #1",
+                    uint(0x78563412),
+                    bytearray.readUnsignedInt());
+        Assert.expectEq("ByteArray readUnsignedInt_2 #2",
+                    uint(0x98BADCFE),
+                    bytearray.readUnsignedInt());
+        Assert.expectEq("ByteArray readUnsignedInt_2 #3",
+                    8+offset,
+                    bytearray.position);
+    }
+
+    // EOF at various offsets and alignments
+    function readUInt_tests3(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);  // use offset to create the alignment
+        bytearray.writeUnsignedInt(0x12345678);
+
+        for ( var i=0 ; i < 4 ; i++ ) {
+            var v;
+            expectEOF("ByteArray readUInt_3 #1 " + offset + " " + (i+1),
+                      (function () {
+                          bytearray.position = offset + i + 1;
+                          v = bytearray.readInt();
+                      }));
+        }
+    }
+
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readUInt_tests1("bigEndian", offs);
+        readUInt_tests1("littleEndian", offs);
+        readUInt_tests2(offs);
+        readUInt_tests3(offs);
+    }
+}
+
+testUnsignedInt();
+
+function testFloat()
+{
+    // One endianness or the other
+    function readFloat_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeFloat(1.25);
+        bytearray.writeFloat(12345.5);
+        Assert.expectEq("ByteArray writeFloat_1 #1 " + endian,
+                    8+offset,
+                    bytearray.position);
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readFloat_1 #1 " + endian,
+                    1.25,
+                    bytearray.readFloat());
+        Assert.expectEq("ByteArray readFloat_1 #2 " + endian,
+                    12345.5,
+                    bytearray.readFloat());
+        Assert.expectEq("ByteArray readFloat_1 #3" + endian,
+                    8+offset,
+                    bytearray.position);
+    }
+
+    // Mixed endianness: write with one, read with the other.  
+    function readFloat_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        var temp:ByteArray=new ByteArray;
+
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+
+        bytearray.writeFloat(1.25);    // write big
+        bytearray.writeFloat(12345.5); //   endian
+
+        bytearray.endian = "littleEndian";
+        bytearray.position=offset;
+
+        temp.endian = "littleEndian";
+
+        temp.writeFloat(bytearray.readFloat());  // read little endian
+        temp.writeFloat(bytearray.readFloat());  //   and write little endian
+
+        temp.position = 0;
+        temp.endian = "bigEndian";
+        Assert.expectEq("ByteArray readFloat_2 #1",
+                    1.25,
+                    temp.readFloat());           // read big endian
+        Assert.expectEq("ByteArray readFloat_2 #2",
+                    12345.5,
+                    temp.readFloat());
+    }
+
+    // EOF at various offsets and alignments
+    function readFloat_tests3(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);  // use offset to create the alignment
+        bytearray.writeFloat(Math.PI);
+
+        for ( var i=0 ; i < 4 ; i++ ) {
+            var v;
+            expectEOF("ByteArray readFloat_3 #1 " + offset + " " + (i+1),
+                      (function () {
+                          bytearray.position = offset + i + 1;
+                          v = bytearray.readFloat();
+                      }));
+        }
+    }
+
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readFloat_tests1("bigEndian", offs);
+        readFloat_tests1("littleEndian", offs);
+        readFloat_tests2(offs);
+        readFloat_tests3(offs);
+    }
+}
+
+testFloat();
+
+function testDouble() 
+{
+    // One endianness or the other
+    function readDouble_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeDouble(1.25);
+        bytearray.writeDouble(12345.5);
+        Assert.expectEq("ByteArray writeDouble_1 #1 " + endian,
+                    16+offset,
+                    bytearray.position);
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readDouble_1 #1 " + endian,
+                    1.25,
+                    bytearray.readDouble());
+        Assert.expectEq("ByteArray readDouble_1 #2 " + endian,
+                    12345.5,
+                    bytearray.readDouble());
+        Assert.expectEq("ByteArray readDouble_1 #3" + endian,
+                    16+offset,
+                    bytearray.position);
+    }
+
+    // Mixed endianness: write with one, read with the other.  
+    function readDouble_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        var temp:ByteArray=new ByteArray;
+
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+
+        bytearray.writeDouble(1.25);    // write big
+        bytearray.writeDouble(12345.5); //   endian
+
+        bytearray.endian = "littleEndian";
+        bytearray.position=offset;
+
+        temp.endian = "littleEndian";
+
+        temp.writeDouble(bytearray.readDouble());  // read little endian
+        temp.writeDouble(bytearray.readDouble());  //   and write little endian
+
+        temp.position = 0;
+        temp.endian = "bigEndian";
+        Assert.expectEq("ByteArray readDouble_2 #1",
+                    1.25,
+                    temp.readDouble());           // read big endian
+        Assert.expectEq("ByteArray readDouble_2 #2",
+                    12345.5,
+                    temp.readDouble());
+    }
+
+    // EOF at various offsets and alignments
+    function readDouble_tests3(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);  // use offset to create the alignment
+        bytearray.writeDouble(Math.PI);
+
+        for ( var i=0 ; i < 8 ; i++ ) {
+            var v;
+            expectEOF("ByteArray readDouble_3 #1 " + offset + " " + (i+1),
+                      (function () {
+                          bytearray.position = offset + i + 1;
+                          v = bytearray.readDouble();
+                      }));
+        }
+    }
+
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readDouble_tests1("bigEndian", offs);
+        readDouble_tests1("littleEndian", offs);
+        readDouble_tests2(offs);
+        readDouble_tests3(offs);
+    }
+}
+
+testDouble();
+
+function testByte() 
+{
+    var bytearray:ByteArray = makeByteArray();
+    bytearray.position=0;
+    bytearray.writeByte(-257);
+    bytearray.writeByte(37);
+    Assert.expectEq("testByte: ByteArray position",
+                2,
+                bytearray.position);
+    Assert.expectEq("testByte: ByteArray length",
+                2,
+                bytearray.length);
+    bytearray.position=0;
+    Assert.expectEq( "ByteArray readByte",
+                 -1,
+                 bytearray.readByte());
+    Assert.expectEq( "ByteArray readByte",
+                 37,
+                 bytearray.readByte());
+
+    var v;
+    expectEOF("ByteArray readByte EOF",
+              (function () {
+                  bytearray.position = bytearray.length;
+                  v = bytearray.readByte();
+              }));
+}
+
+testByte();
+
+function testUnsignedByte() 
+{
+    var bytearray:ByteArray = makeByteArray();
+    bytearray.position=0;
+    bytearray.writeByte(-259);
+    bytearray.writeByte(37);
+    Assert.expectEq("testUnsignedByte: ByteArray position",
+                2,
+                bytearray.position);
+    Assert.expectEq("testUnsignedByte: ByteArray length",
+                2,
+                bytearray.length);
+    bytearray.position=0;
+    Assert.expectEq( "ByteArray readUnsignedByte",
+                 253,
+                 bytearray.readUnsignedByte());
+    Assert.expectEq( "ByteArray readUnsignedByte",
+                 37,
+                 bytearray.readUnsignedByte());
+
+    var v;
+    expectEOF("ByteArray readUnsignedByte EOF",
+              (function () {
+                  bytearray.position = bytearray.length;
+                  v = bytearray.readUnsignedByte();
+              }));
+}
+
+testUnsignedByte();
+
+function testUtf() 
+{
+    var bytearray:ByteArray = makeByteArray();
+    bytearray.position=0;
+    bytearray.writeUTF("string");
+    Assert.expectEq(
+        "ByteArray position of utf string",
+        8,
+        bytearray.position);
+    bytearray.position=0;
+    Assert.expectEq(
+        "ByteArray length of utf string",
+        8,
+        bytearray.length);
+    Assert.expectEq(
+        "ByteArray readUTF",
+        "string",
+        bytearray.readUTF());
+
+    // Also see the readUTFBytes case below.
+    //
+    // This is arguably a bug but it's how it currently behaves (Bugzilla 687341).
+    // readUTF will return a string consisting of the characters up to and not including
+    // the NUL, but the position will be updated as if the entire string were consumed.
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.endian = "bigEndian";
+    bytearray.writeByte(0);
+    bytearray.writeByte(4);
+    bytearray.writeByte(108);
+    bytearray.writeByte(97);
+    bytearray.writeByte(0);
+    bytearray.writeByte(115);
+
+    bytearray.position = 0;
+    Assert.expectEq("ByteArray readUTF on contents containing NUL: contents",
+                "la",
+                bytearray.readUTF());
+    Assert.expectEq("ByteArray readUTF on contents containing NUL: position",
+                6,
+                bytearray.position);
+
+    // Test EOF in data area
+    expectEOF("ReadUTF EOF in content",
+              (function () {
+                  bytearray.length = 0;
+                  bytearray.endian = "bigEndian";
+                  bytearray.writeUTF("super");
+                  bytearray[1] = 6; // One too much
+                  bytearray.position = 0;
+                  bytearray.readUTF();
+              }));
+
+    // Test EOF in length area
+    expectEOF("ReadUTF EOF in length, #1",
+              (function () {
+                  bytearray.length = 0;
+                  bytearray.readUTF();
+              }));
+
+    expectEOF("ReadUTF EOF in length, #2",
+              (function () {
+                  bytearray.length = 0;
+                  bytearray.writeByte(0);
+                  bytearray.position = 0;
+                  bytearray.readUTF();
+              }));
+
+    // Doc sez: A RangeError will be thrown for writeUTF if the string length exceeds 65535.
+    expectRangeError("RangeError in writeUTF",
+                     (function () {
+                         var s = "86868686";
+                         while (s.length <= 65535)
+                             s = s + s;
+                         bytearray.writeUTF(s);
+                     }));
+
+    // Skip UTF-8 BOM.
+    // This seems fairly ill-defined and ad-hoc since the BOM is skipped but is accounted for in the byte count,
+    // but it's what we do, so test that we continue to do it...
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.endian = "bigEndian";
+    bytearray.writeByte(0);
+    bytearray.writeByte(6);
+    bytearray.writeByte(0xEF);
+    bytearray.writeByte(0xBB);
+    bytearray.writeByte(0xBF);
+    bytearray.writeUTFBytes("string");
+    bytearray.position = 0;
+    Assert.expectEq("ByteArray readUTF skips UTF8 BOM after length bytes but includes it in the length",
+                "str",
+                bytearray.readUTF());
+
+    // TODO: test invalid UTF - we should still get data, in a predictable way (invalid input turns into individual bytes)
+}
+
+testUtf();
+
+function testUtfBytes() 
+{
+    var bytearray:ByteArray = makeByteArray();
+    bytearray.position=0;
+    bytearray.writeUTFBytes("string");
+    bytearray.position=0;
+    Assert.expectEq(
+        "ByteArray length of utf bytes string",
+        6,
+        bytearray.length);
+    Assert.expectEq(
+        "ByteArray readUTFBytes",
+        "string",
+        bytearray.readUTFBytes(6));
+
+    // Also see the readUTF case above.
+    //
+    // This is arguably a bug but it's how it currently behaves (Bugzilla 687341).
+    // readUTF will return a string consisting of the characters up to and not including
+    // the NUL, but the position will be updated as if the entire string were consumed.
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.endian = "bigEndian";
+    bytearray.writeByte(108);
+    bytearray.writeByte(97);
+    bytearray.writeByte(0);
+    bytearray.writeByte(115);
+
+    bytearray.position = 0;
+    Assert.expectEq("ByteArray readUTFBytes on contents containing NUL: contents",
+                "la",
+                bytearray.readUTFBytes(4));
+    Assert.expectEq("ByteArray readUTFBytes on contents containing NUL: position",
+                4,
+                bytearray.position);
+
+    // Test EOF in data area
+    expectEOF("ReadUTFBytes EOF in content",
+              (function () {
+                  bytearray.length = 0;
+                  bytearray.endian = "bigEndian";
+                  bytearray.writeUTF("super");
+                  bytearray.position = 2;
+                  bytearray.readUTFBytes(6); // one too much
+              }));
+
+    // Skip UTF-8 BOM.
+    // This seems fairly ill-defined and ad-hoc since the BOM is skipped but is accounted for in the byte count,
+    // but it's what we do, so test that we continue to do it...
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.endian = "bigEndian";
+    bytearray.writeByte(0xEF);
+    bytearray.writeByte(0xBB);
+    bytearray.writeByte(0xBF);
+    bytearray.writeUTFBytes("string");
+    bytearray.position = 0;
+    Assert.expectEq("ByteArray readUTFBytes skips UTF8 BOM but includes it in the length",
+                "str",
+                bytearray.readUTFBytes(6));
+
+    // TODO: test invalid UTF - we should still get data, in a predictable way (invalid input turns into individual bytes)
+}
+
+testUtfBytes();
+
+function testCompressAndUncompress() {
+    var bytearray:ByteArray = makeByteArray();
+    bytearray.writeUTFBytes("string");
+    bytearray.compress();
+    Assert.expectEq(
+        "ByteArray length after compress",
+        14,
+        bytearray.length);
+
+    bytearray.uncompress();
+    Assert.expectEq(
+        "ByteArray length after uncompress",
+        6,
+        bytearray.length);
+
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.writeUTFBytes("string");
+    bytearray.deflate();
+    Assert.expectEq(
+        "ByteArray length after deflate",
+        8,  // This is what the inflate algorithm produces on 2011-09-22, so we accept it as Truth.
+        bytearray.length);
+
+    bytearray.inflate();
+    Assert.expectEq(
+        "ByteArray length after inflate",
+        6,
+        bytearray.length);
+
+    bytearray.length=0;
+    bytearray.compress();
+    Assert.expectEq(
+        "ByteArray length after empty compress",
+        0,
+        bytearray.length);
+
+    bytearray.uncompress();
+    Assert.expectEq(
+        "ByteArray length after empty uncompress",
+        0,
+        bytearray.length);
+
+    // Bugzilla 691251: ByteArray uncompress and inflate leak memory if presented with invalid data
+    // We should get an IOError here (not a problem) and in Debug builds we should not assert on exit.
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.writeUTFBytes("string");
+    bytearray.compress();
+
+    expectIOError("Uncompress on mangled data",
+                  (function () {
+                      bytearray[0] ^= 0x86;
+                      bytearray.uncompress();
+                  }));
+
+    // Bugzilla 691251: ByteArray uncompress and inflate leak memory if presented with invalid data
+    // We should get an IOError here (not a problem) and in Debug builds we should not assert on exit.
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.writeUTFBytes("string");
+    bytearray.deflate();
+
+    expectIOError("Inflate on mangled data",
+                  (function () {
+                      bytearray[0] ^= 0x86;
+                      bytearray.inflate();
+                  }));
+}
+
+// https://bugzilla.mozilla.org/show_bug.cgi?id=778727
+//testCompressAndUncompress();
+
+function testEndian() {
+    var bytearray:ByteArray = makeByteArray();
+    Assert.expectEq(
+        "get default endian",
+        "bigEndian",
+        bytearray.endian);
+
+    bytearray.endian="littleEndian";
+    Assert.expectEq(
+        "set endian littleEndian",
+        "littleEndian",
+        bytearray.endian);
+
+    bytearray.endian="bigEndian";
+    Assert.expectEq(
+        "set endian bigEndian",
+        "bigEndian",
+        bytearray.endian);
+
+    var err="none";
+    try {
+        bytearray.endian="none";
+    } catch (e) {
+        err=e.toString();
+    }
+    Assert.expectEq(
+        "exception thrown when endian is to littleEndian or bigEndian",
+        "ArgumentError: Error #2008",
+        err.substring(0,26));
+    Assert.expectEq(
+        "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;
+
+    Assert.expectEq(
+        "ByteArray get [] syntax",
+        12,
+        bytearray[2]);
+   
+    bytearray[2]=13;
+    Assert.expectEq(
+        "ByteArray set [] syntax",
+        13,
+        bytearray[2]);
+
+    // We can write negative values but should read positive values
+    bytearray[2] = -13;
+    Assert.expectEq(
+        "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.
+    Assert.expectEq("Bytearray get[] out of range",
+                undefined,
+                bytearray[3]);
+
+    // When writing out of range, extend the bytearray and zero-fill
+    bytearray[4] = 37;
+
+    Assert.expectEq("ByteArray set[] out of range: changed element",
+                37,
+                bytearray[4]);
+
+    Assert.expectEq("ByteArray set[] out of range: length",
+                5,
+                bytearray.length);
+
+    Assert.expectEq("ByteArray set[] out of range: zero-fill",
+                0,
+                bytearray[3]);
+
+    // Sanity: all this reading and writing has not changed the position
+    Assert.expectEq("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;
+    Assert.expectEq("ByteArray set[] with Atom index",
+                42,
+                bytearray[2]);
+
+    bytearray[2] = 112;
+    Assert.expectEq("ByteArray get[] with Atom index",
+                112,
+                bytearray[v.x]);
+}
+
+testBracketSyntax();
+
+function testLengthManipulation() {
+    var bytearray:ByteArray = new ByteArray;
+    bytearray.length=10;
+    Assert.expectEq(
+        "ByteArray empty slots filled with 0",
+        0,
+        bytearray[9]);
+
+    var bytearray_shrink=new ByteArray;
+    bytearray_shrink.length=10;
+    bytearray_shrink.length=5;
+    Assert.expectEq(
+        "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++ )
+        Assert.expectEq("readBytes correct content",
+                    i,
+                    bytearray2[k+2]);
+
+    var bytearray3:ByteArray=new ByteArray;
+    var pos = bytearray.position;
+    bytearray.readBytes(bytearray3,8);
+    Assert.expectEq(
+        "ByteArray readBytes 8 length copies values, check size",
+        8,
+        bytearray3.length);
+    Assert.expectEq(
+        "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);
+              }));
+
+    // Doc sez: A RangeError will be thrown if the value of offset+length exceeds 2^32-1
+    expectRangeError("RangeError in readBytes",
+                     (function () {
+                         bytearray3.position = 0;
+                         bytearray.readBytes(bytearray3, 0xFFFFFFFF, 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);
+    Assert.expectEq(
+        "ByteArray writeBytes: length",
+        10,
+        bytearray4.length);
+
+    Assert.expectEq(
+        "ByteArray writeBytes: position",
+        10, // Position *is* updated by writeBytes()
+        bytearray4.position);
+
+    for ( var i=0 ; i < 10 ; i++ ) {
+        Assert.expectEq(
+            "ByteArray writeBytes: content",
+            i,
+            bytearray4[i]);
+    }
+
+    var bytearray5=new ByteArray;
+    bytearray5.writeBytes(bytearray,1,5);
+    Assert.expectEq(
+        "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);
+    Assert.expectEq(
+        "ByteArray hasAtomProperty true",
+        true,
+        1 in bytearray_atom);
+    Assert.expectEq(
+        "ByteArray hasAtomProperty false",
+        false,
+        5 in bytearray_atom);
+}
+
+testHasAtomProperty();
+
+function testBOM() {
+    var bytearray_bom:ByteArray=new ByteArray;
+
+// TODO: toString also skips little-endian and big-endian UTF-16 BOMs (0xFF 0xFE and 0xFE 0xFF).
+    bytearray_bom[0]=0xef;
+    bytearray_bom[1]=0xbb;
+    bytearray_bom[2]=0xbf;
+    bytearray_bom[3]=100;
+    bytearray_bom[4]=97;
+    bytearray_bom[5]=110;
+    bytearray_bom[6]=33;
+    Assert.expectEq(
+        "ByteArray with bom toString",
+        "dan!",
+        bytearray_bom.toString());
+
+    var bytearray_str:ByteArray=new ByteArray;
+    bytearray_str[0]=100;
+    bytearray_str[1]=97;
+    bytearray_str[2]=110;
+    bytearray_str[3]=33;
+    Assert.expectEq(
+        "ByteArray with no bom toString",
+        "dan!",
+        bytearray_str.toString());
+    
+// bad partial sequence
+    var bytearray_bad : ByteArray = new ByteArray();
+    bytearray_bad[0]=0xE4; // 19968
+    bytearray_bad[1]=0xB8;
+    bytearray_bad[2]=0x80;
+    bytearray_bad[3]=0xE4; // bad sequence
+    bytearray_bad[4]=0xE4; // 19968
+    bytearray_bad[5]=0xB8;
+    bytearray_bad[6]=0x80;
+    Assert.expectEq(
+        "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;
+    Assert.expectEq(
+        "ByteArray with truncated utf-8 sequence",
+        "\u00E4\u00B8",
+        bytearray_bad.toString());
+
+// utf-8 sequence > 0x1FFFF
+    bytearray_bad = new ByteArray();
+    bytearray_bad[0]=0xFB; // character == 0x3FFFF
+    bytearray_bad[1]=0xBF;
+    bytearray_bad[2]=0xBF;
+    bytearray_bad[3]=0xBF;
+    bytearray_bad[4]=0xBF;
+    bytearray_bad[5]=0xE4; // 19968
+    bytearray_bad[6]=0xB8;
+    bytearray_bad[7]=0x80;
+    Assert.expectEq(
+        "ByteArray with out-of-range utf-8 sequence",
+        "\udbbf\udfff\u00BF\u4e00",
+        bytearray_bad.toString());
+
+// compress/uncompress with BOM
+    var bytearray_compress:ByteArray = new ByteArray();
+    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;
+    // original length = 7
+    var origlength=bytearray_compress.length;
+    bytearray_compress.compress();
+    // test the compressed bytearray values are all different from the original
+    var compressstate=(bytearray_compress[0]==0xef ||
+                       bytearray_compress[1]==0xbb ||
+                       bytearray_compress[2]==0xbf ||
+                       bytearray_compress[3]==100 ||
+                       bytearray_compress[4]==97);
+    // check the compressed length = 15 (small strings compress larger in zlib)
+    var compresslength=bytearray_compress.length;
+    bytearray_compress.uncompress();
+    // 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
+        );
+    Assert.expectEq("ByteArray.compress bytearray length is different",
+                origlength==compresslength,false);
+    Assert.expectEq("ByteArray.compress bytearray contents differ",
+                compressstate,false);
+    Assert.expectEq("ByteArray.uncompress bytearray length matches before compress",
+                origlength,restoredlength);
+    Assert.expectEq("ByteArray.uncompress uncompressing compressed string matches original",
+                restorestate,true);
+}
+
+testBOM();
+ 
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/config.xml b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/config.xml
new file mode 100644
index 000000000..18d27f9ba
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/config.xml
@@ -0,0 +1,13 @@
+<flex-config>
+    <compiler>
+        <source-path>
+            <path-element>.</path-element>
+            <path-element>../../../lib</path-element>
+        </source-path>
+        <debug>false</debug>
+        <omit-trace-statements>false</omit-trace-statements>
+        <show-actionscript-warnings>false</show-actionscript-warnings>
+        <strict>false</strict>
+    </compiler>
+    <output>test.swf</output>
+</flex-config>
\ No newline at end of file
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/output.txt b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/output.txt
new file mode 100644
index 000000000..b61ce0ddf
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/output.txt
@@ -0,0 +1,425 @@
+ByteArray constructor no args PASSED!
+ByteArray length of empty PASSED!
+ByteArray toString empty PASSED!
+ByteArray available on empty PASSED!
+ByteArray position on empty PASSED!
+ByteArray endianness on empty PASSED!
+ByteArray trivial length PASSED!
+ByteArray trivial position PASSED!
+ByteArray position after clearing PASSED!
+ByteArray position can exceed length, #1 PASSED!
+ByteArray position can exceed length, #2 PASSED!
+ByteArray position can exceed length, #3 PASSED!
+ByteArray position can exceed length, #4 PASSED!
+ByteArray position can exceed length, #5 PASSED!
+ByteArray position can exceed length, #6 PASSED!
+ByteArray position after writing Booleans PASSED!
+ByteArray move position to 0 PASSED!
+ByteArray write/read boolean true PASSED!
+ByteArray write/read boolean false PASSED!
+ByteArray readShort_1 #1 bigEndian PASSED!
+ByteArray readShort_1 #2 bigEndian PASSED!
+ByteArray readShort_1 #3bigEndian PASSED!
+ByteArray readShort_1 #1 littleEndian PASSED!
+ByteArray readShort_1 #2 littleEndian PASSED!
+ByteArray readShort_1 #3littleEndian PASSED!
+ByteArray readShort_2 #1 PASSED!
+ByteArray readShort_2 #2 PASSED!
+ByteArray readShort_2 #3 PASSED!
+ByteArray readShort_3 #1 0 1 PASSED!
+ByteArray readShort_3 #1 0 2 PASSED!
+ByteArray readShort_1 #1 bigEndian PASSED!
+ByteArray readShort_1 #2 bigEndian PASSED!
+ByteArray readShort_1 #3bigEndian PASSED!
+ByteArray readShort_1 #1 littleEndian PASSED!
+ByteArray readShort_1 #2 littleEndian PASSED!
+ByteArray readShort_1 #3littleEndian PASSED!
+ByteArray readShort_2 #1 PASSED!
+ByteArray readShort_2 #2 PASSED!
+ByteArray readShort_2 #3 PASSED!
+ByteArray readShort_3 #1 1 1 PASSED!
+ByteArray readShort_3 #1 1 2 PASSED!
+ByteArray readShort_1 #1 bigEndian PASSED!
+ByteArray readShort_1 #2 bigEndian PASSED!
+ByteArray readShort_1 #3bigEndian PASSED!
+ByteArray readShort_1 #1 littleEndian PASSED!
+ByteArray readShort_1 #2 littleEndian PASSED!
+ByteArray readShort_1 #3littleEndian PASSED!
+ByteArray readShort_2 #1 PASSED!
+ByteArray readShort_2 #2 PASSED!
+ByteArray readShort_2 #3 PASSED!
+ByteArray readShort_3 #1 2 1 PASSED!
+ByteArray readShort_3 #1 2 2 PASSED!
+ByteArray readShort_1 #1 bigEndian PASSED!
+ByteArray readShort_1 #2 bigEndian PASSED!
+ByteArray readShort_1 #3bigEndian PASSED!
+ByteArray readShort_1 #1 littleEndian PASSED!
+ByteArray readShort_1 #2 littleEndian PASSED!
+ByteArray readShort_1 #3littleEndian PASSED!
+ByteArray readShort_2 #1 PASSED!
+ByteArray readShort_2 #2 PASSED!
+ByteArray readShort_2 #3 PASSED!
+ByteArray readShort_3 #1 3 1 PASSED!
+ByteArray readShort_3 #1 3 2 PASSED!
+ByteArray readUShort_1 #1 bigEndian PASSED!
+ByteArray readUShort_1 #2 bigEndian PASSED!
+ByteArray readUShort_1 #3bigEndian PASSED!
+ByteArray readUShort_1 #1 littleEndian PASSED!
+ByteArray readUShort_1 #2 littleEndian PASSED!
+ByteArray readUShort_1 #3littleEndian PASSED!
+ByteArray readUShort_2 #1 PASSED!
+ByteArray readUShort_2 #2 PASSED!
+ByteArray readUShort_2 #3 PASSED!
+ByteArray readUShort_3 #1 0 1 PASSED!
+ByteArray readUShort_3 #1 0 2 PASSED!
+ByteArray readUShort_1 #1 bigEndian PASSED!
+ByteArray readUShort_1 #2 bigEndian PASSED!
+ByteArray readUShort_1 #3bigEndian PASSED!
+ByteArray readUShort_1 #1 littleEndian PASSED!
+ByteArray readUShort_1 #2 littleEndian PASSED!
+ByteArray readUShort_1 #3littleEndian PASSED!
+ByteArray readUShort_2 #1 PASSED!
+ByteArray readUShort_2 #2 PASSED!
+ByteArray readUShort_2 #3 PASSED!
+ByteArray readUShort_3 #1 1 1 PASSED!
+ByteArray readUShort_3 #1 1 2 PASSED!
+ByteArray readUShort_1 #1 bigEndian PASSED!
+ByteArray readUShort_1 #2 bigEndian PASSED!
+ByteArray readUShort_1 #3bigEndian PASSED!
+ByteArray readUShort_1 #1 littleEndian PASSED!
+ByteArray readUShort_1 #2 littleEndian PASSED!
+ByteArray readUShort_1 #3littleEndian PASSED!
+ByteArray readUShort_2 #1 PASSED!
+ByteArray readUShort_2 #2 PASSED!
+ByteArray readUShort_2 #3 PASSED!
+ByteArray readUShort_3 #1 2 1 PASSED!
+ByteArray readUShort_3 #1 2 2 PASSED!
+ByteArray readUShort_1 #1 bigEndian PASSED!
+ByteArray readUShort_1 #2 bigEndian PASSED!
+ByteArray readUShort_1 #3bigEndian PASSED!
+ByteArray readUShort_1 #1 littleEndian PASSED!
+ByteArray readUShort_1 #2 littleEndian PASSED!
+ByteArray readUShort_1 #3littleEndian PASSED!
+ByteArray readUShort_2 #1 PASSED!
+ByteArray readUShort_2 #2 PASSED!
+ByteArray readUShort_2 #3 PASSED!
+ByteArray readUShort_3 #1 3 1 PASSED!
+ByteArray readUShort_3 #1 3 2 PASSED!
+ByteArray readInt_1 #1 bigEndian PASSED!
+ByteArray readInt_1 #2 bigEndian PASSED!
+ByteArray readInt_1 #3bigEndian PASSED!
+ByteArray readInt_1 #1 littleEndian PASSED!
+ByteArray readInt_1 #2 littleEndian PASSED!
+ByteArray readInt_1 #3littleEndian PASSED!
+ByteArray readInt_2 #1 PASSED!
+ByteArray readInt_2 #2 PASSED!
+ByteArray readInt_2 #3 PASSED!
+ByteArray readInt_3 #1 0 1 PASSED!
+ByteArray readInt_3 #1 0 2 PASSED!
+ByteArray readInt_3 #1 0 3 PASSED!
+ByteArray readInt_3 #1 0 4 PASSED!
+ByteArray readInt_3 #2 at position=2^32-16 PASSED!
+ByteArray readInt_1 #1 bigEndian PASSED!
+ByteArray readInt_1 #2 bigEndian PASSED!
+ByteArray readInt_1 #3bigEndian PASSED!
+ByteArray readInt_1 #1 littleEndian PASSED!
+ByteArray readInt_1 #2 littleEndian PASSED!
+ByteArray readInt_1 #3littleEndian PASSED!
+ByteArray readInt_2 #1 PASSED!
+ByteArray readInt_2 #2 PASSED!
+ByteArray readInt_2 #3 PASSED!
+ByteArray readInt_3 #1 1 1 PASSED!
+ByteArray readInt_3 #1 1 2 PASSED!
+ByteArray readInt_3 #1 1 3 PASSED!
+ByteArray readInt_3 #1 1 4 PASSED!
+ByteArray readInt_3 #2 at position=2^32-16 PASSED!
+ByteArray readInt_1 #1 bigEndian PASSED!
+ByteArray readInt_1 #2 bigEndian PASSED!
+ByteArray readInt_1 #3bigEndian PASSED!
+ByteArray readInt_1 #1 littleEndian PASSED!
+ByteArray readInt_1 #2 littleEndian PASSED!
+ByteArray readInt_1 #3littleEndian PASSED!
+ByteArray readInt_2 #1 PASSED!
+ByteArray readInt_2 #2 PASSED!
+ByteArray readInt_2 #3 PASSED!
+ByteArray readInt_3 #1 2 1 PASSED!
+ByteArray readInt_3 #1 2 2 PASSED!
+ByteArray readInt_3 #1 2 3 PASSED!
+ByteArray readInt_3 #1 2 4 PASSED!
+ByteArray readInt_3 #2 at position=2^32-16 PASSED!
+ByteArray readInt_1 #1 bigEndian PASSED!
+ByteArray readInt_1 #2 bigEndian PASSED!
+ByteArray readInt_1 #3bigEndian PASSED!
+ByteArray readInt_1 #1 littleEndian PASSED!
+ByteArray readInt_1 #2 littleEndian PASSED!
+ByteArray readInt_1 #3littleEndian PASSED!
+ByteArray readInt_2 #1 PASSED!
+ByteArray readInt_2 #2 PASSED!
+ByteArray readInt_2 #3 PASSED!
+ByteArray readInt_3 #1 3 1 PASSED!
+ByteArray readInt_3 #1 3 2 PASSED!
+ByteArray readInt_3 #1 3 3 PASSED!
+ByteArray readInt_3 #1 3 4 PASSED!
+ByteArray readInt_3 #2 at position=2^32-16 PASSED!
+ByteArray readUnsignedInt_1 #1 bigEndian PASSED!
+ByteArray readUnsignedInt_1 #2 bigEndian PASSED!
+ByteArray readUnsignedInt_1 #3bigEndian PASSED!
+ByteArray readUnsignedInt_1 #1 littleEndian PASSED!
+ByteArray readUnsignedInt_1 #2 littleEndian PASSED!
+ByteArray readUnsignedInt_1 #3littleEndian PASSED!
+ByteArray readUnsignedInt_2 #1 PASSED!
+ByteArray readUnsignedInt_2 #2 PASSED!
+ByteArray readUnsignedInt_2 #3 PASSED!
+ByteArray readUInt_3 #1 0 1 PASSED!
+ByteArray readUInt_3 #1 0 2 PASSED!
+ByteArray readUInt_3 #1 0 3 PASSED!
+ByteArray readUInt_3 #1 0 4 PASSED!
+ByteArray readUnsignedInt_1 #1 bigEndian PASSED!
+ByteArray readUnsignedInt_1 #2 bigEndian PASSED!
+ByteArray readUnsignedInt_1 #3bigEndian PASSED!
+ByteArray readUnsignedInt_1 #1 littleEndian PASSED!
+ByteArray readUnsignedInt_1 #2 littleEndian PASSED!
+ByteArray readUnsignedInt_1 #3littleEndian PASSED!
+ByteArray readUnsignedInt_2 #1 PASSED!
+ByteArray readUnsignedInt_2 #2 PASSED!
+ByteArray readUnsignedInt_2 #3 PASSED!
+ByteArray readUInt_3 #1 1 1 PASSED!
+ByteArray readUInt_3 #1 1 2 PASSED!
+ByteArray readUInt_3 #1 1 3 PASSED!
+ByteArray readUInt_3 #1 1 4 PASSED!
+ByteArray readUnsignedInt_1 #1 bigEndian PASSED!
+ByteArray readUnsignedInt_1 #2 bigEndian PASSED!
+ByteArray readUnsignedInt_1 #3bigEndian PASSED!
+ByteArray readUnsignedInt_1 #1 littleEndian PASSED!
+ByteArray readUnsignedInt_1 #2 littleEndian PASSED!
+ByteArray readUnsignedInt_1 #3littleEndian PASSED!
+ByteArray readUnsignedInt_2 #1 PASSED!
+ByteArray readUnsignedInt_2 #2 PASSED!
+ByteArray readUnsignedInt_2 #3 PASSED!
+ByteArray readUInt_3 #1 2 1 PASSED!
+ByteArray readUInt_3 #1 2 2 PASSED!
+ByteArray readUInt_3 #1 2 3 PASSED!
+ByteArray readUInt_3 #1 2 4 PASSED!
+ByteArray readUnsignedInt_1 #1 bigEndian PASSED!
+ByteArray readUnsignedInt_1 #2 bigEndian PASSED!
+ByteArray readUnsignedInt_1 #3bigEndian PASSED!
+ByteArray readUnsignedInt_1 #1 littleEndian PASSED!
+ByteArray readUnsignedInt_1 #2 littleEndian PASSED!
+ByteArray readUnsignedInt_1 #3littleEndian PASSED!
+ByteArray readUnsignedInt_2 #1 PASSED!
+ByteArray readUnsignedInt_2 #2 PASSED!
+ByteArray readUnsignedInt_2 #3 PASSED!
+ByteArray readUInt_3 #1 3 1 PASSED!
+ByteArray readUInt_3 #1 3 2 PASSED!
+ByteArray readUInt_3 #1 3 3 PASSED!
+ByteArray readUInt_3 #1 3 4 PASSED!
+ByteArray writeFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #2 bigEndian PASSED!
+ByteArray readFloat_1 #3bigEndian PASSED!
+ByteArray writeFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #2 littleEndian PASSED!
+ByteArray readFloat_1 #3littleEndian PASSED!
+ByteArray readFloat_2 #1 PASSED!
+ByteArray readFloat_2 #2 PASSED!
+ByteArray readFloat_3 #1 0 1 PASSED!
+ByteArray readFloat_3 #1 0 2 PASSED!
+ByteArray readFloat_3 #1 0 3 PASSED!
+ByteArray readFloat_3 #1 0 4 PASSED!
+ByteArray writeFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #2 bigEndian PASSED!
+ByteArray readFloat_1 #3bigEndian PASSED!
+ByteArray writeFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #2 littleEndian PASSED!
+ByteArray readFloat_1 #3littleEndian PASSED!
+ByteArray readFloat_2 #1 PASSED!
+ByteArray readFloat_2 #2 PASSED!
+ByteArray readFloat_3 #1 1 1 PASSED!
+ByteArray readFloat_3 #1 1 2 PASSED!
+ByteArray readFloat_3 #1 1 3 PASSED!
+ByteArray readFloat_3 #1 1 4 PASSED!
+ByteArray writeFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #2 bigEndian PASSED!
+ByteArray readFloat_1 #3bigEndian PASSED!
+ByteArray writeFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #2 littleEndian PASSED!
+ByteArray readFloat_1 #3littleEndian PASSED!
+ByteArray readFloat_2 #1 PASSED!
+ByteArray readFloat_2 #2 PASSED!
+ByteArray readFloat_3 #1 2 1 PASSED!
+ByteArray readFloat_3 #1 2 2 PASSED!
+ByteArray readFloat_3 #1 2 3 PASSED!
+ByteArray readFloat_3 #1 2 4 PASSED!
+ByteArray writeFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #2 bigEndian PASSED!
+ByteArray readFloat_1 #3bigEndian PASSED!
+ByteArray writeFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #2 littleEndian PASSED!
+ByteArray readFloat_1 #3littleEndian PASSED!
+ByteArray readFloat_2 #1 PASSED!
+ByteArray readFloat_2 #2 PASSED!
+ByteArray readFloat_3 #1 3 1 PASSED!
+ByteArray readFloat_3 #1 3 2 PASSED!
+ByteArray readFloat_3 #1 3 3 PASSED!
+ByteArray readFloat_3 #1 3 4 PASSED!
+ByteArray writeDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #2 bigEndian PASSED!
+ByteArray readDouble_1 #3bigEndian PASSED!
+ByteArray writeDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #2 littleEndian PASSED!
+ByteArray readDouble_1 #3littleEndian PASSED!
+ByteArray readDouble_2 #1 PASSED!
+ByteArray readDouble_2 #2 PASSED!
+ByteArray readDouble_3 #1 0 1 PASSED!
+ByteArray readDouble_3 #1 0 2 PASSED!
+ByteArray readDouble_3 #1 0 3 PASSED!
+ByteArray readDouble_3 #1 0 4 PASSED!
+ByteArray readDouble_3 #1 0 5 PASSED!
+ByteArray readDouble_3 #1 0 6 PASSED!
+ByteArray readDouble_3 #1 0 7 PASSED!
+ByteArray readDouble_3 #1 0 8 PASSED!
+ByteArray writeDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #2 bigEndian PASSED!
+ByteArray readDouble_1 #3bigEndian PASSED!
+ByteArray writeDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #2 littleEndian PASSED!
+ByteArray readDouble_1 #3littleEndian PASSED!
+ByteArray readDouble_2 #1 PASSED!
+ByteArray readDouble_2 #2 PASSED!
+ByteArray readDouble_3 #1 1 1 PASSED!
+ByteArray readDouble_3 #1 1 2 PASSED!
+ByteArray readDouble_3 #1 1 3 PASSED!
+ByteArray readDouble_3 #1 1 4 PASSED!
+ByteArray readDouble_3 #1 1 5 PASSED!
+ByteArray readDouble_3 #1 1 6 PASSED!
+ByteArray readDouble_3 #1 1 7 PASSED!
+ByteArray readDouble_3 #1 1 8 PASSED!
+ByteArray writeDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #2 bigEndian PASSED!
+ByteArray readDouble_1 #3bigEndian PASSED!
+ByteArray writeDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #2 littleEndian PASSED!
+ByteArray readDouble_1 #3littleEndian PASSED!
+ByteArray readDouble_2 #1 PASSED!
+ByteArray readDouble_2 #2 PASSED!
+ByteArray readDouble_3 #1 2 1 PASSED!
+ByteArray readDouble_3 #1 2 2 PASSED!
+ByteArray readDouble_3 #1 2 3 PASSED!
+ByteArray readDouble_3 #1 2 4 PASSED!
+ByteArray readDouble_3 #1 2 5 PASSED!
+ByteArray readDouble_3 #1 2 6 PASSED!
+ByteArray readDouble_3 #1 2 7 PASSED!
+ByteArray readDouble_3 #1 2 8 PASSED!
+ByteArray writeDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #2 bigEndian PASSED!
+ByteArray readDouble_1 #3bigEndian PASSED!
+ByteArray writeDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #2 littleEndian PASSED!
+ByteArray readDouble_1 #3littleEndian PASSED!
+ByteArray readDouble_2 #1 PASSED!
+ByteArray readDouble_2 #2 PASSED!
+ByteArray readDouble_3 #1 3 1 PASSED!
+ByteArray readDouble_3 #1 3 2 PASSED!
+ByteArray readDouble_3 #1 3 3 PASSED!
+ByteArray readDouble_3 #1 3 4 PASSED!
+ByteArray readDouble_3 #1 3 5 PASSED!
+ByteArray readDouble_3 #1 3 6 PASSED!
+ByteArray readDouble_3 #1 3 7 PASSED!
+ByteArray readDouble_3 #1 3 8 PASSED!
+testByte: ByteArray position PASSED!
+testByte: ByteArray length PASSED!
+ByteArray readByte PASSED!
+ByteArray readByte PASSED!
+ByteArray readByte EOF PASSED!
+testUnsignedByte: ByteArray position PASSED!
+testUnsignedByte: ByteArray length PASSED!
+ByteArray readUnsignedByte PASSED!
+ByteArray readUnsignedByte PASSED!
+ByteArray readUnsignedByte EOF PASSED!
+ByteArray position of utf string PASSED!
+ByteArray length of utf string PASSED!
+ByteArray readUTF PASSED!
+ByteArray readUTF on contents containing NUL: contents PASSED!
+ByteArray readUTF on contents containing NUL: position PASSED!
+ReadUTF EOF in content PASSED!
+ReadUTF EOF in length, #1 PASSED!
+ReadUTF EOF in length, #2 PASSED!
+RangeError in writeUTF PASSED!
+ByteArray readUTF skips UTF8 BOM after length bytes but includes it in the length PASSED!
+ByteArray length of utf bytes string PASSED!
+ByteArray readUTFBytes PASSED!
+ByteArray readUTFBytes on contents containing NUL: contents PASSED!
+ByteArray readUTFBytes on contents containing NUL: position PASSED!
+ReadUTFBytes EOF in content PASSED!
+ByteArray readUTFBytes skips UTF8 BOM but includes it in the length PASSED!
+get default endian PASSED!
+set endian littleEndian PASSED!
+set endian bigEndian PASSED!
+exception thrown when endian is to littleEndian or bigEndian PASSED!
+endian value is uchanged after invalid set PASSED!
+ByteArray get [] syntax PASSED!
+ByteArray set [] syntax PASSED!
+ByteArray set [] / get [] syntax PASSED!
+Bytearray get[] out of range PASSED!
+ByteArray set[] out of range: changed element PASSED!
+ByteArray set[] out of range: length PASSED!
+ByteArray set[] out of range: zero-fill PASSED!
+ByteArray get[] and set[]: position PASSED!
+ByteArray set[] with Atom index PASSED!
+ByteArray get[] with Atom index PASSED!
+ByteArray empty slots filled with 0 PASSED!
+ByteArray shrink length PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+readBytes correct content PASSED!
+ByteArray readBytes 8 length copies values, check size PASSED!
+ByteArray readBytes 8 length copies values, check position PASSED!
+EOF in readBytes PASSED!
+RangeError in readBytes PASSED!
+ByteArray writeBytes: length PASSED!
+ByteArray writeBytes: position PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes: content PASSED!
+ByteArray writeBytes PASSED!
+ByteArray hasAtomProperty true PASSED!
+ByteArray hasAtomProperty false PASSED!
+ByteArray with bom toString PASSED!
+ByteArray with no bom toString PASSED!
+ByteArray with partial bad utf-8 sequence PASSED!
+ByteArray with truncated utf-8 sequence PASSED!
+ByteArray with out-of-range utf-8 sequence PASSED!
+ByteArray.compress bytearray length is different PASSED!
+ByteArray.compress bytearray contents differ PASSED!
+ByteArray.uncompress bytearray length matches before compress PASSED!
+ByteArray.uncompress uncompressing compressed string matches original PASSED!
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/test.swf b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/test.swf
new file mode 100644
index 0000000000000000000000000000000000000000..b11d0b3a3965f82cdbf82f72d4c854f63722c958
GIT binary patch
literal 7543
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
NVgIX={|A;cIPZ$R!RY`1

literal 0
HcmV?d00001

diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/test.toml b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/test.toml
new file mode 100644
index 000000000..cce445afe
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArray/test.toml
@@ -0,0 +1,2 @@
+num_ticks = 1
+known_failure = true
\ No newline at end of file
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/Test.as b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/Test.as
new file mode 100644
index 000000000..02c1c2dd7
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/Test.as
@@ -0,0 +1,924 @@
+/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
+/* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// General principles for this test suite:
+//
+//  - never write just one, write at least two (to test that position
+//    advances correctly and output is placed correctly)
+//  - ditto read
+//  - test both little and big endian for multibyte data
+//  - test both aligned and unaligned access for multibyte data
+//
+// Search for "TODO" for comments about missing tests.
+
+package {
+import flash.display.MovieClip;
+public class Test extends MovieClip {}
+}
+
+import flash.errors.EOFError;
+import flash.errors.IOError;
+import flash.errors.MemoryError;
+import flash.utils.ByteArray;
+import flash.utils.CompressionAlgorithm;
+
+import com.adobe.test.Assert;
+
+// var SECTION = "ByteArrayWithLzmaTemplate";
+// var VERSION = "as3";
+// var TITLE   = "test ByteArray class with lzma";
+
+
+// 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 RangeError
+function expectRangeError(tag, thunk)
+{
+    var exn_ok = "No exn";
+    try                   { thunk(); }
+    catch (e: RangeError) { exn_ok = "OK"; }
+    catch (e)             { exn_ok = "Wrong type"; }
+    Assert.expectEq(tag, "OK", exn_ok);
+}
+
+// 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"; }
+    Assert.expectEq(tag, "OK", exn_ok);
+}
+
+// Utility to test for IOError
+function expectIOError(tag, thunk)
+{
+    var exn_ok = "No exn";
+    try                { thunk(); }
+    catch (e: IOError) { exn_ok = "OK"; }
+    catch (e)          { exn_ok = "Wrong type"; }
+    Assert.expectEq(tag, "OK", exn_ok);
+}
+
+function callCompress(byteArray:ByteArray,description:String):void
+{
+    var error_status:String='no error';
+    var len:int = byteArray.length;
+    try
+    {
+        byteArray.compress(CompressionAlgorithm.LZMA);
+        byteArray.uncompress(CompressionAlgorithm.LZMA);
+    }
+    catch(error:Error)
+    {
+        error_status = error.message;
+    }
+    byteArray.position = len;
+    Assert.expectEq(description+": expecting no exception","no error",error_status);
+    Assert.expectEq(description+": expecting length no change ",len,byteArray.length);
+}
+
+function testEmptyByteArrayWithLzma()
+{
+    var bytearray:ByteArray = new ByteArray();
+    callCompress(bytearray,"empty bytearray");
+}
+
+testEmptyByteArrayWithLzma();
+
+function zeroByteArrayWithLzma()
+{
+    var bytearray:ByteArray = new ByteArray();
+    bytearray.writeByte(0);
+    callCompress(bytearray,"zero length bytearray");
+}
+zeroByteArrayWithLzma();
+
+function nullByteArrayWithLzma()
+{
+    var byteArray:ByteArray = null;
+    var error_status:String='no error';
+    try
+    {
+        byteArray.compress(CompressionAlgorithm.LZMA);
+        byteArray.uncompress(CompressionAlgorithm.LZMA);
+    }
+    catch(error:Error)
+    {
+        error_status ='error';
+    }
+    Assert.expectEq("expecting thrown exception","error",error_status);
+
+}
+
+nullByteArrayWithLzma();
+
+function compressWithZlibUncompressLzma()
+{
+    var byteArray:ByteArray = new ByteArray();
+    byteArray.writeUTF("COMPRESS TEST");
+    var error_status:String = 'no error';
+    try
+    {
+        byteArray.compress(CompressionAlgorithm.ZLIB)
+        byteArray.uncompress(CompressionAlgorithm.LZMA);
+    }
+    catch(error:Error)
+    {
+        error_status ='error';
+    }
+
+    Assert.expectEq("expecting thrown exception compressWithZlibUncompressLzma", "error", error_status);
+}
+
+compressWithZlibUncompressLzma()
+
+function uncompressWithoutCompressionLzma()
+{
+    var byteArray:ByteArray = new ByteArray();
+    byteArray.writeUTF("UNCOMPRESS TEST");
+
+    var uncompressedLengthBefore : uint = byteArray.length;
+
+    var error_status:String = 'no error';
+
+    try
+    {
+        byteArray.uncompress(CompressionAlgorithm.LZMA);
+    }
+    catch(error:IOError)
+    {
+        error_status ='error';
+    }
+    catch(error:MemoryError)
+    {
+        error_status ='error';
+    }
+
+    Assert.expectEq("expecting thrown exception uncompressWithZlibUncompressLzma", "error", error_status);
+
+    Assert.expectEq("uncompressWithoutCompressionLzma bytearray length matches before uncompress",
+        uncompressedLengthBefore, byteArray.length);
+}
+
+uncompressWithoutCompressionLzma()
+
+function testBooleanWithLzma()
+{
+    var bytearray:ByteArray=makeByteArray();
+    bytearray.writeBoolean(true);
+    bytearray.writeBoolean(false);
+    Assert.expectEq("ByteArray position after writing Booleans",
+        2,
+        bytearray.position);
+    callCompress(bytearray,"boolean bytearray");
+    bytearray.position=0;
+    Assert.expectEq(
+        "ByteArray move position to 0",
+        0,
+        bytearray.position);
+
+    Assert.expectEq(
+        "ByteArray write/read boolean true",
+        true,
+        bytearray.readBoolean());
+
+    Assert.expectEq(
+        "ByteArray write/read boolean false",
+        false,
+        bytearray.readBoolean());
+}
+
+testBooleanWithLzma();
+
+function testShortWithLzma()
+{
+    // One endianness or the other
+    function readShort_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeShort(100);
+        bytearray.writeShort(-200);
+        callCompress(bytearray,"bytearray of short");
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readShort_1 #1 " + endian,
+            100,
+            bytearray.readShort());
+        Assert.expectEq( "ByteArray readShort_1 #2 " + endian,
+            -200,
+            bytearray.readShort());
+        Assert.expectEq("ByteArray readShort_1 #3" + endian,
+            4+offset,
+            bytearray.position);
+    }
+
+    // Mixed endianness: write with one, read with the other
+    function readShort_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+        bytearray.writeShort(int(0x1234));
+        bytearray.writeShort(int(0xFEDC));
+        callCompress(bytearray,"bytearray of short mixed endianness");
+        bytearray.position=offset;
+        bytearray.endian = "littleEndian";
+        Assert.expectEq("ByteArray readShort_2 #1",
+            int(0x3412),
+            bytearray.readShort());
+        Assert.expectEq("ByteArray readShort_2 #2",
+            int(0xFFFFDCFE),   // Sign extended
+            bytearray.readShort());
+        Assert.expectEq("ByteArray readShort_2 #3",
+            4+offset,
+            bytearray.position);
+    }
+
+    // EOF at various offsets and alignments
+    function readShort_tests3(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);  // use offset to create the alignment
+        bytearray.writeShort(0x1234);
+        callCompress(bytearray,"bytearray of shorts with EOFs at various offsets");
+
+        for ( var i=0 ; i < 2 ; i++ ) {
+            var v;
+            expectEOF("ByteArray readShort_3 #1 " + offset + " " + (i+1),
+                (function () {
+                    bytearray.position = offset + i + 1;
+                    v = bytearray.readShort();
+                }));
+        }
+    }
+
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readShort_tests1("bigEndian", offs);
+        readShort_tests1("littleEndian", offs);
+        readShort_tests2(offs);
+        readShort_tests3(offs);
+    }
+}
+
+testShortWithLzma();
+
+function testUnsignedShortWithLzma()
+{
+    // One endianness or the other
+    function readUShort_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeShort(100);
+        bytearray.writeShort(uint(-200) & 65535);
+        callCompress(bytearray,"unsigned short");
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readUShort_1 #1 " + endian,
+            uint(100),
+            bytearray.readUnsignedShort());
+        Assert.expectEq("ByteArray readUShort_1 #2 " + endian,
+            uint(-200) & 65535,
+            bytearray.readUnsignedShort());
+        Assert.expectEq("ByteArray readUShort_1 #3" + endian,
+            4+offset,
+            bytearray.position);
+    }
+
+    // Mixed endianness: write with one, read with the other
+    function readUShort_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+        bytearray.writeShort(uint(0x1234));
+        bytearray.writeShort(uint(0xFEDC) & 65535);
+        callCompress(bytearray,"unsigned short mixed endianness");
+        bytearray.position=offset;
+        bytearray.endian = "littleEndian";
+        Assert.expectEq("ByteArray readUShort_2 #1",
+            uint(0x3412),
+            bytearray.readUnsignedShort());
+        Assert.expectEq("ByteArray readUShort_2 #2",
+            uint(0xDCFE),
+            bytearray.readUnsignedShort());
+        Assert.expectEq("ByteArray readUShort_2 #3",
+            4+offset,
+            bytearray.position);
+    }
+
+    // EOF at various offsets and alignments
+    function readUShort_tests3(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);  // use offset to create the alignment
+        bytearray.writeShort(0x1234);
+        callCompress(bytearray,"unsigned short eof at various offsets");
+        for ( var i=0 ; i < 2 ; i++ ) {
+            var v;
+            expectEOF("ByteArray readUShort_3 #1 " + offset + " " + (i+1),
+                (function () {
+                    bytearray.position = offset + i + 1;
+                    v = bytearray.readUnsignedShort();
+                }));
+        }
+    }
+ 
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readUShort_tests1("bigEndian", offs);
+        readUShort_tests1("littleEndian", offs);
+        readUShort_tests2(offs);
+        readUShort_tests3(offs);
+    }
+}
+
+testUnsignedShortWithLzma();
+
+function testIntWithLzma()
+{
+    // One endianness or the other
+    function readInt_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeInt(100);
+        bytearray.writeInt(-200);
+        callCompress(bytearray,"int endianness");
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readInt_1 #1 " + endian,
+            100,
+            bytearray.readInt());
+        Assert.expectEq( "ByteArray readInt_1 #2 " + endian,
+            -200,
+            bytearray.readInt());
+        Assert.expectEq("ByteArray readInt_1 #3" + endian,
+            8+offset,
+            bytearray.position);
+    }
+
+    // Mixed endianness: write with one, read with the other
+    function readInt_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+        bytearray.writeInt(int(0x12345678));
+        bytearray.writeInt(int(0xFEDCBA98));
+        callCompress(bytearray,"int mixed endianness");
+        bytearray.position=offset;
+        bytearray.endian = "littleEndian";
+        Assert.expectEq("ByteArray readInt_2 #1",
+            int(0x78563412),
+            bytearray.readInt());
+        Assert.expectEq("ByteArray readInt_2 #2",
+            int(0x98BADCFE),
+            bytearray.readInt());
+        Assert.expectEq("ByteArray readInt_2 #3",
+            8+offset,
+            bytearray.position);
+    }
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readInt_tests1("bigEndian", offs);
+        readInt_tests1("littleEndian", offs);
+        readInt_tests2(offs);
+    }
+}
+
+testIntWithLzma();
+
+function testFloatWithLzma()
+{
+    // One endianness or the other
+    function readFloat_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeFloat(1.25);
+        bytearray.writeFloat(12345.5);
+        callCompress(bytearray,"float");
+        Assert.expectEq("ByteArray writeFloat_1 #1 " + endian,
+            8+offset,
+            bytearray.position);
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readFloat_1 #1 " + endian,
+            1.25,
+            bytearray.readFloat());
+        Assert.expectEq("ByteArray readFloat_1 #2 " + endian,
+            12345.5,
+            bytearray.readFloat());
+        Assert.expectEq("ByteArray readFloat_1 #3" + endian,
+            8+offset,
+            bytearray.position);
+    }
+    
+    // Mixed endianness: write with one, read with the other.  
+    function readFloat_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        var temp:ByteArray=new ByteArray();
+        
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+        
+        bytearray.writeFloat(1.25);    // write big
+        bytearray.writeFloat(12345.5); //   endian
+        callCompress(bytearray,"float mixed endianness");
+        bytearray.endian = "littleEndian";
+        bytearray.position=offset;
+        
+        temp.endian = "littleEndian";
+        
+        temp.writeFloat(bytearray.readFloat());  // read little endian
+        temp.writeFloat(bytearray.readFloat());  //   and write little endian
+        
+        temp.position = 0;
+        temp.endian = "bigEndian";
+        Assert.expectEq("ByteArray readFloat_2 #1",
+            1.25,
+            temp.readFloat());           // read big endian
+        Assert.expectEq("ByteArray readFloat_2 #2",
+            12345.5,
+            temp.readFloat());
+    }
+    
+    
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readFloat_tests1("bigEndian", offs);
+        readFloat_tests1("littleEndian", offs);
+        readFloat_tests2(offs);
+    }
+}
+
+testFloatWithLzma();
+
+function testDoubleWithLzma() 
+{
+    // One endianness or the other
+    function readDouble_tests1(endian, offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        bytearray.endian = endian;
+        bytearray.position=offset;
+        bytearray.writeDouble(1.25);
+        bytearray.writeDouble(12345.5);
+        callCompress(bytearray,"double");
+        Assert.expectEq("ByteArray writeDouble_1 #1 " + endian,
+            16+offset,
+            bytearray.position);
+        bytearray.position=offset;
+        Assert.expectEq("ByteArray readDouble_1 #1 " + endian,
+            1.25,
+            bytearray.readDouble());
+        Assert.expectEq("ByteArray readDouble_1 #2 " + endian,
+            12345.5,
+            bytearray.readDouble());
+        Assert.expectEq("ByteArray readDouble_1 #3" + endian,
+            16+offset,
+            bytearray.position);
+    }
+    
+    // Mixed endianness: write with one, read with the other.  
+    function readDouble_tests2(offset)
+    {
+        var bytearray:ByteArray=makeByteArray(offset);
+        var temp:ByteArray=new ByteArray;
+        
+        bytearray.endian = "bigEndian";
+        bytearray.position=offset;
+        
+        bytearray.writeDouble(1.25);    // write big
+        bytearray.writeDouble(12345.5); //   endian
+        callCompress(bytearray,"double mixed endianness");
+        bytearray.endian = "littleEndian";
+        bytearray.position=offset;
+        
+        temp.endian = "littleEndian";
+        
+        temp.writeDouble(bytearray.readDouble());  // read little endian
+        temp.writeDouble(bytearray.readDouble());  //   and write little endian
+        
+        temp.position = 0;
+        temp.endian = "bigEndian";
+        Assert.expectEq("ByteArray readDouble_2 #1",
+            1.25,
+            temp.readDouble());           // read big endian
+        Assert.expectEq("ByteArray readDouble_2 #2",
+            12345.5,
+            temp.readDouble());
+    }
+    
+    for ( var offs=0 ; offs < 4 ; offs++ ) {
+        readDouble_tests1("bigEndian", offs);
+        readDouble_tests1("littleEndian", offs);
+        readDouble_tests2(offs);
+        
+    }
+}
+
+testDoubleWithLzma();
+
+function testByteWithLzma() 
+{
+    var bytearray:ByteArray = makeByteArray();
+    bytearray.position=0;
+    bytearray.writeByte(-257);
+    bytearray.writeByte(37);
+    callCompress(bytearray,"byte");
+    Assert.expectEq("testByte: ByteArray position",
+        2,
+        bytearray.position);
+    Assert.expectEq("testByte: ByteArray length",
+        2,
+        bytearray.length);
+    bytearray.position=0;
+    Assert.expectEq( "ByteArray readByte",
+        -1,
+        bytearray.readByte());
+    Assert.expectEq( "ByteArray readByte",
+        37,
+        bytearray.readByte());
+    
+    var v;
+    expectEOF("ByteArray readByte EOF",
+        (function () {
+            bytearray.position = bytearray.length;
+            v = bytearray.readByte();
+        }));
+}
+
+testByteWithLzma();
+
+function testUtfWithLzma() 
+{
+    var bytearray:ByteArray = makeByteArray();
+    bytearray.position=0;
+    bytearray.writeUTF("string");
+    callCompress(bytearray,"UTF");
+    Assert.expectEq(
+        "ByteArray position of utf string",
+        8,
+        bytearray.position);
+    bytearray.position=0;
+    Assert.expectEq(
+        "ByteArray length of utf string",
+        8,
+        bytearray.length);
+    Assert.expectEq(
+        "ByteArray readUTF",
+        "string",
+        bytearray.readUTF());
+    
+    // Also see the readUTFBytes case below.
+    //
+    // This is arguably a bug but it's how it currently behaves (Bugzilla 687341).
+    // readUTF will return a string consisting of the characters up to and not including
+    // the NUL, but the position will be updated as if the entire string were consumed.
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.endian = "bigEndian";
+    bytearray.writeByte(0);
+    bytearray.writeByte(4);
+    bytearray.writeByte(108);
+    bytearray.writeByte(97);
+    bytearray.writeByte(0);
+    bytearray.writeByte(115);
+    callCompress(bytearray,"bytes");
+    bytearray.position = 0;
+    Assert.expectEq("ByteArray readUTF on contents containing NUL: contents",
+        "la",
+        bytearray.readUTF());
+    Assert.expectEq("ByteArray readUTF on contents containing NUL: position",
+        6,
+        bytearray.position);
+    
+    // Test EOF in data area
+    expectEOF("ReadUTF EOF in content",
+        (function () {
+            bytearray.length = 0;
+            bytearray.endian = "bigEndian";
+            bytearray.writeUTF("super");
+            bytearray[1] = 6; // One too much
+            bytearray.position = 0;
+            bytearray.readUTF();
+        }));
+    
+    // Test EOF in length area
+    expectEOF("ReadUTF EOF in length, #1",
+        (function () {
+            bytearray.length = 0;
+            bytearray.readUTF();
+        }));
+    
+    expectEOF("ReadUTF EOF in length, #2",
+        (function () {
+            bytearray.length = 0;
+            bytearray.writeByte(0);
+            bytearray.position = 0;
+            bytearray.readUTF();
+        }));
+    
+    // Doc sez: A RangeError will be thrown for writeUTF if the string length exceeds 65535.
+    expectRangeError("RangeError in writeUTF",
+        (function () {
+            var s = "86868686";
+            while (s.length <= 65535)
+                s = s + s;
+            bytearray.writeUTF(s);
+        }));
+    
+    // Skip UTF-8 BOM.
+    // This seems fairly ill-defined and ad-hoc since the BOM is skipped but is accounted for in the byte count,
+    // but it's what we do, so test that we continue to do it...
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.endian = "bigEndian";
+    bytearray.writeByte(0);
+    bytearray.writeByte(6);
+    bytearray.writeByte(0xEF);
+    bytearray.writeByte(0xBB);
+    bytearray.writeByte(0xBF);
+    bytearray.writeUTFBytes("string");
+    callCompress(bytearray,"skip UTF-8 BOM");
+    bytearray.position = 0;
+    Assert.expectEq("ByteArray readUTF skips UTF8 BOM after length bytes but includes it in the length",
+        "str",
+        bytearray.readUTF());
+    
+    // TODO: test invalid UTF - we should still get data, in a predictable way (invalid input turns into individual bytes)
+}
+
+testUtfWithLzma();
+
+function testUtfBytesWithLzma() 
+{
+    var bytearray:ByteArray = makeByteArray();
+    bytearray.position=0;
+    bytearray.writeUTFBytes("string");
+    callCompress(bytearray,"UTF bytes");
+    bytearray.position=0;
+    Assert.expectEq(
+        "ByteArray length of utf bytes string",
+        6,
+        bytearray.length);
+    Assert.expectEq(
+        "ByteArray readUTFBytes",
+        "string",
+        bytearray.readUTFBytes(6));
+    
+    // Also see the readUTF case above.
+    //
+    // This is arguably a bug but it's how it currently behaves (Bugzilla 687341).
+    // readUTF will return a string consisting of the characters up to and not including
+    // the NUL, but the position will be updated as if the entire string were consumed.
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.endian = "bigEndian";
+    bytearray.writeByte(108);
+    bytearray.writeByte(97);
+    bytearray.writeByte(0);
+    bytearray.writeByte(115);
+    callCompress(bytearray,"bytes contains NULL");
+    bytearray.position = 0;
+    Assert.expectEq("ByteArray readUTFBytes on contents containing NUL: contents",
+        "la",
+        bytearray.readUTFBytes(4));
+    Assert.expectEq("ByteArray readUTFBytes on contents containing NUL: position",
+        4,
+        bytearray.position);
+    
+    // Test EOF in data area
+    expectEOF("ReadUTFBytes EOF in content",
+        (function () {
+            bytearray.length = 0;
+            bytearray.endian = "bigEndian";
+            bytearray.writeUTF("super");
+            bytearray.position = 2;
+            bytearray.readUTFBytes(6); // one too much
+        }));
+    
+    // Skip UTF-8 BOM.
+    // This seems fairly ill-defined and ad-hoc since the BOM is skipped but is accounted for in the byte count,
+    // but it's what we do, so test that we continue to do it...
+    bytearray.length = 0;
+    bytearray.position = 0;
+    bytearray.endian = "bigEndian";
+    bytearray.writeByte(0xEF);
+    bytearray.writeByte(0xBB);
+    bytearray.writeByte(0xBF);
+    bytearray.writeUTFBytes("string");
+    callCompress(bytearray,"bytes contain high value bytes");
+    bytearray.position = 0;
+    Assert.expectEq("ByteArray readUTFBytes skips UTF8 BOM but includes it in the length",
+        "str",
+        bytearray.readUTFBytes(6));
+    
+    // TODO: test invalid UTF - we should still get data, in a predictable way (invalid input turns into individual bytes)
+}
+
+testUtfBytesWithLzma();
+
+
+function testBracketSyntaxWithLzma() {
+    var bytearray:ByteArray = makeByteArray();
+    bytearray.position=0;
+    bytearray.writeByte(10);
+    bytearray.writeByte(11);
+    bytearray.writeByte(12);
+    callCompress(bytearray,"bracket syntax");
+    bytearray.position = 0;
+    
+    Assert.expectEq(
+        "ByteArray get [] syntax",
+        12,
+        bytearray[2]);
+    
+    bytearray[2]=13;
+    Assert.expectEq(
+        "ByteArray set [] syntax",
+        13,
+        bytearray[2]);   
+    
+}
+
+testBracketSyntaxWithLzma(); 
+
+
+function testBOMWithLzma() {   
+    // compress/uncompress with BOM
+    var bytearray_compress:ByteArray = new ByteArray();
+    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;
+    // original length = 7
+    var origlength=bytearray_compress.length;
+    bytearray_compress.compress("lzma");
+    // test the compressed bytearray values are all different from the original
+    var compressstate=(bytearray_compress[0]==0xef ||
+        bytearray_compress[1]==0xbb ||
+        bytearray_compress[2]==0xbf ||
+        bytearray_compress[3]==100 ||
+        bytearray_compress[4]==97);
+    // check the compressed length = 15 (small strings compress larger in zlib)
+    var compresslength=bytearray_compress.length;
+    bytearray_compress.uncompress("lzma");
+    // 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
+    );
+    Assert.expectEq("ByteArray.compress bytearray length is different",
+        origlength==compresslength,false);
+    Assert.expectEq("ByteArray.compress bytearray contents differ",
+        compressstate,false);
+    Assert.expectEq("ByteArray.uncompress bytearray length matches before compress",
+        origlength,restoredlength);
+    Assert.expectEq("ByteArray.uncompress uncompressing compressed string matches original",
+        restorestate,true);
+}
+
+testBOMWithLzma();
+
+    // lzma-compressed data format:
+    // 5 bytes: LZMA properties
+    // 8 bytes: uncompressed size k (little-endian)
+    // k bytes: payload (the compressed data)
+
+function testIllFormedLzmaLowSize():void {
+    var b1:ByteArray = new ByteArray();
+    b1.writeUTF("string");
+    b1.compress(CompressionAlgorithm.LZMA);
+
+    var b2:ByteArray = new ByteArray();
+
+    // muck with low 32 bits of size
+    for (var i:uint=0; i < 4; i++) {
+        b2.clear();
+        b1.position = 0;
+        b1.readBytes(b2);
+
+        b2[5 + i] += 1;
+
+        var result;
+        try {
+            b2.uncompress(CompressionAlgorithm.LZMA);
+            result = "unexpected"
+        } catch (e:IOError) {
+            result = "ioerror on wrong size"
+        }
+
+        Assert.expectEq("ByteArray.uncompress ill-formed LZMA size "+i+" byte",
+                    "ioerror on wrong size",result);
+    }
+}
+// comment out test due to bug: https://bugzilla.mozilla.org/show_bug.cgi?id=778727
+//testIllFormedLzmaLowSize();
+
+function testIllFormedLzmaHighSize():void {
+    var b1:ByteArray = new ByteArray();
+    b1.writeUTF("string");
+    b1.compress(CompressionAlgorithm.LZMA);
+
+    var b2:ByteArray = new ByteArray();
+
+
+    // muck with high 32 bits of size
+    for (var i:uint=4; i < 8; i++) {
+        b2.clear();
+        b1.position = 0;
+        b1.readBytes(b2);
+
+        b2[5 + i] += 1;
+
+        var result;
+        try {
+            b2.uncompress(CompressionAlgorithm.LZMA);
+            result = "unexpected"
+        } catch (e:MemoryError) {
+            result = "memoryerror on huge size"
+        }
+
+        Assert.expectEq("ByteArray.uncompress ill-formed LZMA size "+i+" byte",
+                    "memoryerror on huge size",result);
+    }
+}
+// comment out test due to bug: https://bugzilla.mozilla.org/show_bug.cgi?id=778727
+// testIllFormedLzmaHighSize();
+
+// (Below is not necessarily working; in particular Felix would have expected
+//  it to hit the IllFormedLzma cases above, but for some reason it is not.)
+function testFuzzedLzma():void {
+    var b1:ByteArray = new ByteArray();
+    b1.writeUTF("string");
+    b1.compress(CompressionAlgorithm.LZMA);
+
+    var b2:ByteArray = new ByteArray();
+
+    var errors:String="";
+    for (var i:uint=0; i < b1.length * 8; i++) {
+        b2.clear();
+        b1.position = 0;
+        //        print("b1.length A: "+b1.length);
+        b1.readBytes(b2);
+        //        print("b1.length B: "+b1.length);
+
+        var byteOffset:uint = i / 8;
+        var bitOffset:uint  = i % 8;
+
+        var oldByte:uint = b2[byteOffset];
+        var oldBit:uint  = (oldByte >> bitOffset) & 0x1;
+        var newByte:uint = (oldByte ^ (oldBit << bitOffset)) & 0xFF;
+        b2[byteOffset] = newByte;
+
+        //        print('b1 ['+Array.prototype.join.call(b1, ',')+']');
+        //        print('b2 ['+Array.prototype.join.call(b2, ',')+']');
+
+        var result;
+        // This test is largely fishing for segfaults (and striving for code coverage)
+        try {
+            b2.uncompress(CompressionAlgorithm.LZMA);
+
+            // If we get here, then the LZMA algorithm completed and
+            // we have no idea what the resulting byte array contains.
+            result = "expected" // no exn
+        } catch (e:MemoryError) {
+            result = "expected"
+        } catch (e:IOError) {
+            // should also verify that original data was restored
+            result = "expected"
+        }
+        if (result!="expected") {
+            errors+=" error fuzzing bit "+i+" ";
+        }
+    }
+    Assert.expectEq("ByteArray.uncompress fuzzed LZMA input check for errors",
+                    "",errors);
+}
+
+// Commenting out test because it is not behaving the way Felix would
+// expect and he does not want to take the time now to debug it.
+
+// comment out test due to bug: https://bugzilla.mozilla.org/show_bug.cgi?id=778727
+// testFuzzedLzma();
+
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/config.xml b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/config.xml
new file mode 100644
index 000000000..18d27f9ba
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/config.xml
@@ -0,0 +1,13 @@
+<flex-config>
+    <compiler>
+        <source-path>
+            <path-element>.</path-element>
+            <path-element>../../../lib</path-element>
+        </source-path>
+        <debug>false</debug>
+        <omit-trace-statements>false</omit-trace-statements>
+        <show-actionscript-warnings>false</show-actionscript-warnings>
+        <strict>false</strict>
+    </compiler>
+    <output>test.swf</output>
+</flex-config>
\ No newline at end of file
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/output.txt b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/output.txt
new file mode 100644
index 000000000..ad37154b9
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/output.txt
@@ -0,0 +1,397 @@
+empty bytearray: expecting no exception PASSED!
+empty bytearray: expecting length no change  PASSED!
+zero length bytearray: expecting no exception PASSED!
+zero length bytearray: expecting length no change  PASSED!
+expecting thrown exception PASSED!
+expecting thrown exception compressWithZlibUncompressLzma PASSED!
+expecting thrown exception uncompressWithZlibUncompressLzma PASSED!
+uncompressWithoutCompressionLzma bytearray length matches before uncompress PASSED!
+ByteArray position after writing Booleans PASSED!
+boolean bytearray: expecting no exception PASSED!
+boolean bytearray: expecting length no change  PASSED!
+ByteArray move position to 0 PASSED!
+ByteArray write/read boolean true PASSED!
+ByteArray write/read boolean false PASSED!
+bytearray of short: expecting no exception PASSED!
+bytearray of short: expecting length no change  PASSED!
+ByteArray readShort_1 #1 bigEndian PASSED!
+ByteArray readShort_1 #2 bigEndian PASSED!
+ByteArray readShort_1 #3bigEndian PASSED!
+bytearray of short: expecting no exception PASSED!
+bytearray of short: expecting length no change  PASSED!
+ByteArray readShort_1 #1 littleEndian PASSED!
+ByteArray readShort_1 #2 littleEndian PASSED!
+ByteArray readShort_1 #3littleEndian PASSED!
+bytearray of short mixed endianness: expecting no exception PASSED!
+bytearray of short mixed endianness: expecting length no change  PASSED!
+ByteArray readShort_2 #1 PASSED!
+ByteArray readShort_2 #2 PASSED!
+ByteArray readShort_2 #3 PASSED!
+bytearray of shorts with EOFs at various offsets: expecting no exception PASSED!
+bytearray of shorts with EOFs at various offsets: expecting length no change  PASSED!
+ByteArray readShort_3 #1 0 1 PASSED!
+ByteArray readShort_3 #1 0 2 PASSED!
+bytearray of short: expecting no exception PASSED!
+bytearray of short: expecting length no change  PASSED!
+ByteArray readShort_1 #1 bigEndian PASSED!
+ByteArray readShort_1 #2 bigEndian PASSED!
+ByteArray readShort_1 #3bigEndian PASSED!
+bytearray of short: expecting no exception PASSED!
+bytearray of short: expecting length no change  PASSED!
+ByteArray readShort_1 #1 littleEndian PASSED!
+ByteArray readShort_1 #2 littleEndian PASSED!
+ByteArray readShort_1 #3littleEndian PASSED!
+bytearray of short mixed endianness: expecting no exception PASSED!
+bytearray of short mixed endianness: expecting length no change  PASSED!
+ByteArray readShort_2 #1 PASSED!
+ByteArray readShort_2 #2 PASSED!
+ByteArray readShort_2 #3 PASSED!
+bytearray of shorts with EOFs at various offsets: expecting no exception PASSED!
+bytearray of shorts with EOFs at various offsets: expecting length no change  PASSED!
+ByteArray readShort_3 #1 1 1 PASSED!
+ByteArray readShort_3 #1 1 2 PASSED!
+bytearray of short: expecting no exception PASSED!
+bytearray of short: expecting length no change  PASSED!
+ByteArray readShort_1 #1 bigEndian PASSED!
+ByteArray readShort_1 #2 bigEndian PASSED!
+ByteArray readShort_1 #3bigEndian PASSED!
+bytearray of short: expecting no exception PASSED!
+bytearray of short: expecting length no change  PASSED!
+ByteArray readShort_1 #1 littleEndian PASSED!
+ByteArray readShort_1 #2 littleEndian PASSED!
+ByteArray readShort_1 #3littleEndian PASSED!
+bytearray of short mixed endianness: expecting no exception PASSED!
+bytearray of short mixed endianness: expecting length no change  PASSED!
+ByteArray readShort_2 #1 PASSED!
+ByteArray readShort_2 #2 PASSED!
+ByteArray readShort_2 #3 PASSED!
+bytearray of shorts with EOFs at various offsets: expecting no exception PASSED!
+bytearray of shorts with EOFs at various offsets: expecting length no change  PASSED!
+ByteArray readShort_3 #1 2 1 PASSED!
+ByteArray readShort_3 #1 2 2 PASSED!
+bytearray of short: expecting no exception PASSED!
+bytearray of short: expecting length no change  PASSED!
+ByteArray readShort_1 #1 bigEndian PASSED!
+ByteArray readShort_1 #2 bigEndian PASSED!
+ByteArray readShort_1 #3bigEndian PASSED!
+bytearray of short: expecting no exception PASSED!
+bytearray of short: expecting length no change  PASSED!
+ByteArray readShort_1 #1 littleEndian PASSED!
+ByteArray readShort_1 #2 littleEndian PASSED!
+ByteArray readShort_1 #3littleEndian PASSED!
+bytearray of short mixed endianness: expecting no exception PASSED!
+bytearray of short mixed endianness: expecting length no change  PASSED!
+ByteArray readShort_2 #1 PASSED!
+ByteArray readShort_2 #2 PASSED!
+ByteArray readShort_2 #3 PASSED!
+bytearray of shorts with EOFs at various offsets: expecting no exception PASSED!
+bytearray of shorts with EOFs at various offsets: expecting length no change  PASSED!
+ByteArray readShort_3 #1 3 1 PASSED!
+ByteArray readShort_3 #1 3 2 PASSED!
+unsigned short: expecting no exception PASSED!
+unsigned short: expecting length no change  PASSED!
+ByteArray readUShort_1 #1 bigEndian PASSED!
+ByteArray readUShort_1 #2 bigEndian PASSED!
+ByteArray readUShort_1 #3bigEndian PASSED!
+unsigned short: expecting no exception PASSED!
+unsigned short: expecting length no change  PASSED!
+ByteArray readUShort_1 #1 littleEndian PASSED!
+ByteArray readUShort_1 #2 littleEndian PASSED!
+ByteArray readUShort_1 #3littleEndian PASSED!
+unsigned short mixed endianness: expecting no exception PASSED!
+unsigned short mixed endianness: expecting length no change  PASSED!
+ByteArray readUShort_2 #1 PASSED!
+ByteArray readUShort_2 #2 PASSED!
+ByteArray readUShort_2 #3 PASSED!
+unsigned short eof at various offsets: expecting no exception PASSED!
+unsigned short eof at various offsets: expecting length no change  PASSED!
+ByteArray readUShort_3 #1 0 1 PASSED!
+ByteArray readUShort_3 #1 0 2 PASSED!
+unsigned short: expecting no exception PASSED!
+unsigned short: expecting length no change  PASSED!
+ByteArray readUShort_1 #1 bigEndian PASSED!
+ByteArray readUShort_1 #2 bigEndian PASSED!
+ByteArray readUShort_1 #3bigEndian PASSED!
+unsigned short: expecting no exception PASSED!
+unsigned short: expecting length no change  PASSED!
+ByteArray readUShort_1 #1 littleEndian PASSED!
+ByteArray readUShort_1 #2 littleEndian PASSED!
+ByteArray readUShort_1 #3littleEndian PASSED!
+unsigned short mixed endianness: expecting no exception PASSED!
+unsigned short mixed endianness: expecting length no change  PASSED!
+ByteArray readUShort_2 #1 PASSED!
+ByteArray readUShort_2 #2 PASSED!
+ByteArray readUShort_2 #3 PASSED!
+unsigned short eof at various offsets: expecting no exception PASSED!
+unsigned short eof at various offsets: expecting length no change  PASSED!
+ByteArray readUShort_3 #1 1 1 PASSED!
+ByteArray readUShort_3 #1 1 2 PASSED!
+unsigned short: expecting no exception PASSED!
+unsigned short: expecting length no change  PASSED!
+ByteArray readUShort_1 #1 bigEndian PASSED!
+ByteArray readUShort_1 #2 bigEndian PASSED!
+ByteArray readUShort_1 #3bigEndian PASSED!
+unsigned short: expecting no exception PASSED!
+unsigned short: expecting length no change  PASSED!
+ByteArray readUShort_1 #1 littleEndian PASSED!
+ByteArray readUShort_1 #2 littleEndian PASSED!
+ByteArray readUShort_1 #3littleEndian PASSED!
+unsigned short mixed endianness: expecting no exception PASSED!
+unsigned short mixed endianness: expecting length no change  PASSED!
+ByteArray readUShort_2 #1 PASSED!
+ByteArray readUShort_2 #2 PASSED!
+ByteArray readUShort_2 #3 PASSED!
+unsigned short eof at various offsets: expecting no exception PASSED!
+unsigned short eof at various offsets: expecting length no change  PASSED!
+ByteArray readUShort_3 #1 2 1 PASSED!
+ByteArray readUShort_3 #1 2 2 PASSED!
+unsigned short: expecting no exception PASSED!
+unsigned short: expecting length no change  PASSED!
+ByteArray readUShort_1 #1 bigEndian PASSED!
+ByteArray readUShort_1 #2 bigEndian PASSED!
+ByteArray readUShort_1 #3bigEndian PASSED!
+unsigned short: expecting no exception PASSED!
+unsigned short: expecting length no change  PASSED!
+ByteArray readUShort_1 #1 littleEndian PASSED!
+ByteArray readUShort_1 #2 littleEndian PASSED!
+ByteArray readUShort_1 #3littleEndian PASSED!
+unsigned short mixed endianness: expecting no exception PASSED!
+unsigned short mixed endianness: expecting length no change  PASSED!
+ByteArray readUShort_2 #1 PASSED!
+ByteArray readUShort_2 #2 PASSED!
+ByteArray readUShort_2 #3 PASSED!
+unsigned short eof at various offsets: expecting no exception PASSED!
+unsigned short eof at various offsets: expecting length no change  PASSED!
+ByteArray readUShort_3 #1 3 1 PASSED!
+ByteArray readUShort_3 #1 3 2 PASSED!
+int endianness: expecting no exception PASSED!
+int endianness: expecting length no change  PASSED!
+ByteArray readInt_1 #1 bigEndian PASSED!
+ByteArray readInt_1 #2 bigEndian PASSED!
+ByteArray readInt_1 #3bigEndian PASSED!
+int endianness: expecting no exception PASSED!
+int endianness: expecting length no change  PASSED!
+ByteArray readInt_1 #1 littleEndian PASSED!
+ByteArray readInt_1 #2 littleEndian PASSED!
+ByteArray readInt_1 #3littleEndian PASSED!
+int mixed endianness: expecting no exception PASSED!
+int mixed endianness: expecting length no change  PASSED!
+ByteArray readInt_2 #1 PASSED!
+ByteArray readInt_2 #2 PASSED!
+ByteArray readInt_2 #3 PASSED!
+int endianness: expecting no exception PASSED!
+int endianness: expecting length no change  PASSED!
+ByteArray readInt_1 #1 bigEndian PASSED!
+ByteArray readInt_1 #2 bigEndian PASSED!
+ByteArray readInt_1 #3bigEndian PASSED!
+int endianness: expecting no exception PASSED!
+int endianness: expecting length no change  PASSED!
+ByteArray readInt_1 #1 littleEndian PASSED!
+ByteArray readInt_1 #2 littleEndian PASSED!
+ByteArray readInt_1 #3littleEndian PASSED!
+int mixed endianness: expecting no exception PASSED!
+int mixed endianness: expecting length no change  PASSED!
+ByteArray readInt_2 #1 PASSED!
+ByteArray readInt_2 #2 PASSED!
+ByteArray readInt_2 #3 PASSED!
+int endianness: expecting no exception PASSED!
+int endianness: expecting length no change  PASSED!
+ByteArray readInt_1 #1 bigEndian PASSED!
+ByteArray readInt_1 #2 bigEndian PASSED!
+ByteArray readInt_1 #3bigEndian PASSED!
+int endianness: expecting no exception PASSED!
+int endianness: expecting length no change  PASSED!
+ByteArray readInt_1 #1 littleEndian PASSED!
+ByteArray readInt_1 #2 littleEndian PASSED!
+ByteArray readInt_1 #3littleEndian PASSED!
+int mixed endianness: expecting no exception PASSED!
+int mixed endianness: expecting length no change  PASSED!
+ByteArray readInt_2 #1 PASSED!
+ByteArray readInt_2 #2 PASSED!
+ByteArray readInt_2 #3 PASSED!
+int endianness: expecting no exception PASSED!
+int endianness: expecting length no change  PASSED!
+ByteArray readInt_1 #1 bigEndian PASSED!
+ByteArray readInt_1 #2 bigEndian PASSED!
+ByteArray readInt_1 #3bigEndian PASSED!
+int endianness: expecting no exception PASSED!
+int endianness: expecting length no change  PASSED!
+ByteArray readInt_1 #1 littleEndian PASSED!
+ByteArray readInt_1 #2 littleEndian PASSED!
+ByteArray readInt_1 #3littleEndian PASSED!
+int mixed endianness: expecting no exception PASSED!
+int mixed endianness: expecting length no change  PASSED!
+ByteArray readInt_2 #1 PASSED!
+ByteArray readInt_2 #2 PASSED!
+ByteArray readInt_2 #3 PASSED!
+float: expecting no exception PASSED!
+float: expecting length no change  PASSED!
+ByteArray writeFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #2 bigEndian PASSED!
+ByteArray readFloat_1 #3bigEndian PASSED!
+float: expecting no exception PASSED!
+float: expecting length no change  PASSED!
+ByteArray writeFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #2 littleEndian PASSED!
+ByteArray readFloat_1 #3littleEndian PASSED!
+float mixed endianness: expecting no exception PASSED!
+float mixed endianness: expecting length no change  PASSED!
+ByteArray readFloat_2 #1 PASSED!
+ByteArray readFloat_2 #2 PASSED!
+float: expecting no exception PASSED!
+float: expecting length no change  PASSED!
+ByteArray writeFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #2 bigEndian PASSED!
+ByteArray readFloat_1 #3bigEndian PASSED!
+float: expecting no exception PASSED!
+float: expecting length no change  PASSED!
+ByteArray writeFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #2 littleEndian PASSED!
+ByteArray readFloat_1 #3littleEndian PASSED!
+float mixed endianness: expecting no exception PASSED!
+float mixed endianness: expecting length no change  PASSED!
+ByteArray readFloat_2 #1 PASSED!
+ByteArray readFloat_2 #2 PASSED!
+float: expecting no exception PASSED!
+float: expecting length no change  PASSED!
+ByteArray writeFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #2 bigEndian PASSED!
+ByteArray readFloat_1 #3bigEndian PASSED!
+float: expecting no exception PASSED!
+float: expecting length no change  PASSED!
+ByteArray writeFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #2 littleEndian PASSED!
+ByteArray readFloat_1 #3littleEndian PASSED!
+float mixed endianness: expecting no exception PASSED!
+float mixed endianness: expecting length no change  PASSED!
+ByteArray readFloat_2 #1 PASSED!
+ByteArray readFloat_2 #2 PASSED!
+float: expecting no exception PASSED!
+float: expecting length no change  PASSED!
+ByteArray writeFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #1 bigEndian PASSED!
+ByteArray readFloat_1 #2 bigEndian PASSED!
+ByteArray readFloat_1 #3bigEndian PASSED!
+float: expecting no exception PASSED!
+float: expecting length no change  PASSED!
+ByteArray writeFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #1 littleEndian PASSED!
+ByteArray readFloat_1 #2 littleEndian PASSED!
+ByteArray readFloat_1 #3littleEndian PASSED!
+float mixed endianness: expecting no exception PASSED!
+float mixed endianness: expecting length no change  PASSED!
+ByteArray readFloat_2 #1 PASSED!
+ByteArray readFloat_2 #2 PASSED!
+double: expecting no exception PASSED!
+double: expecting length no change  PASSED!
+ByteArray writeDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #2 bigEndian PASSED!
+ByteArray readDouble_1 #3bigEndian PASSED!
+double: expecting no exception PASSED!
+double: expecting length no change  PASSED!
+ByteArray writeDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #2 littleEndian PASSED!
+ByteArray readDouble_1 #3littleEndian PASSED!
+double mixed endianness: expecting no exception PASSED!
+double mixed endianness: expecting length no change  PASSED!
+ByteArray readDouble_2 #1 PASSED!
+ByteArray readDouble_2 #2 PASSED!
+double: expecting no exception PASSED!
+double: expecting length no change  PASSED!
+ByteArray writeDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #2 bigEndian PASSED!
+ByteArray readDouble_1 #3bigEndian PASSED!
+double: expecting no exception PASSED!
+double: expecting length no change  PASSED!
+ByteArray writeDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #2 littleEndian PASSED!
+ByteArray readDouble_1 #3littleEndian PASSED!
+double mixed endianness: expecting no exception PASSED!
+double mixed endianness: expecting length no change  PASSED!
+ByteArray readDouble_2 #1 PASSED!
+ByteArray readDouble_2 #2 PASSED!
+double: expecting no exception PASSED!
+double: expecting length no change  PASSED!
+ByteArray writeDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #2 bigEndian PASSED!
+ByteArray readDouble_1 #3bigEndian PASSED!
+double: expecting no exception PASSED!
+double: expecting length no change  PASSED!
+ByteArray writeDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #2 littleEndian PASSED!
+ByteArray readDouble_1 #3littleEndian PASSED!
+double mixed endianness: expecting no exception PASSED!
+double mixed endianness: expecting length no change  PASSED!
+ByteArray readDouble_2 #1 PASSED!
+ByteArray readDouble_2 #2 PASSED!
+double: expecting no exception PASSED!
+double: expecting length no change  PASSED!
+ByteArray writeDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #1 bigEndian PASSED!
+ByteArray readDouble_1 #2 bigEndian PASSED!
+ByteArray readDouble_1 #3bigEndian PASSED!
+double: expecting no exception PASSED!
+double: expecting length no change  PASSED!
+ByteArray writeDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #1 littleEndian PASSED!
+ByteArray readDouble_1 #2 littleEndian PASSED!
+ByteArray readDouble_1 #3littleEndian PASSED!
+double mixed endianness: expecting no exception PASSED!
+double mixed endianness: expecting length no change  PASSED!
+ByteArray readDouble_2 #1 PASSED!
+ByteArray readDouble_2 #2 PASSED!
+byte: expecting no exception PASSED!
+byte: expecting length no change  PASSED!
+testByte: ByteArray position PASSED!
+testByte: ByteArray length PASSED!
+ByteArray readByte PASSED!
+ByteArray readByte PASSED!
+ByteArray readByte EOF PASSED!
+UTF: expecting no exception PASSED!
+UTF: expecting length no change  PASSED!
+ByteArray position of utf string PASSED!
+ByteArray length of utf string PASSED!
+ByteArray readUTF PASSED!
+bytes: expecting no exception PASSED!
+bytes: expecting length no change  PASSED!
+ByteArray readUTF on contents containing NUL: contents PASSED!
+ByteArray readUTF on contents containing NUL: position PASSED!
+ReadUTF EOF in content PASSED!
+ReadUTF EOF in length, #1 PASSED!
+ReadUTF EOF in length, #2 PASSED!
+RangeError in writeUTF PASSED!
+skip UTF-8 BOM: expecting no exception PASSED!
+skip UTF-8 BOM: expecting length no change  PASSED!
+ByteArray readUTF skips UTF8 BOM after length bytes but includes it in the length PASSED!
+UTF bytes: expecting no exception PASSED!
+UTF bytes: expecting length no change  PASSED!
+ByteArray length of utf bytes string PASSED!
+ByteArray readUTFBytes PASSED!
+bytes contains NULL: expecting no exception PASSED!
+bytes contains NULL: expecting length no change  PASSED!
+ByteArray readUTFBytes on contents containing NUL: contents PASSED!
+ByteArray readUTFBytes on contents containing NUL: position PASSED!
+ReadUTFBytes EOF in content PASSED!
+bytes contain high value bytes: expecting no exception PASSED!
+bytes contain high value bytes: expecting length no change  PASSED!
+ByteArray readUTFBytes skips UTF8 BOM but includes it in the length PASSED!
+bracket syntax: expecting no exception PASSED!
+bracket syntax: expecting length no change  PASSED!
+ByteArray get [] syntax PASSED!
+ByteArray set [] syntax PASSED!
+ByteArray.compress bytearray length is different PASSED!
+ByteArray.compress bytearray contents differ PASSED!
+ByteArray.uncompress bytearray length matches before compress PASSED!
+ByteArray.uncompress uncompressing compressed string matches original PASSED!
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/test.swf b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/test.swf
new file mode 100644
index 0000000000000000000000000000000000000000..c021eb792c06a4be77c1ee50a35afcd46a776de7
GIT binary patch
literal 6713
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
P;@=_ie@ys)P^WxrqUJHW

literal 0
HcmV?d00001

diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/test.toml b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/test.toml
new file mode 100644
index 000000000..cf33c0906
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzma/test.toml
@@ -0,0 +1,5 @@
+num_ticks = 1
+known_failure = true
+
+[required_features]
+lzma = true
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/Test.as b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/Test.as
new file mode 100644
index 000000000..a213f9a5e
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/Test.as
@@ -0,0 +1,356 @@
+/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
+/* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// General principles for this test suite:
+//
+//  - never write just one, write at least two (to test that position
+//    advances correctly and output is placed correctly)
+//  - ditto read
+//  - test both little and big endian for multibyte data
+//  - test both aligned and unaligned access for multibyte data
+//
+// Search for "TODO" for comments about missing tests.
+
+package {
+import flash.display.MovieClip;
+public class Test extends MovieClip {}
+}
+
+import flash.errors.EOFError;
+import flash.errors.IOError;
+import flash.utils.ByteArray;
+import flash.utils.ByteArray;
+import flash.utils.ByteArray;
+import flash.utils.CompressionAlgorithm;
+
+import com.adobe.test.Assert;
+
+// var SECTION = "ByteArrayWithLzmaThirdParty";
+// var VERSION = "as3";
+// var TITLE   = "test ByteArray class with lzma inputs generated via LZMA.jar";
+
+var abc_compressed_hello = new ByteArray();
+abc_compressed_hello.writeByte(0x5D);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x80);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x92);
+abc_compressed_hello.writeByte(0x01);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x24);
+abc_compressed_hello.writeByte(0x19);
+abc_compressed_hello.writeByte(0x49);
+abc_compressed_hello.writeByte(0x98);
+abc_compressed_hello.writeByte(0x6F);
+abc_compressed_hello.writeByte(0x10);
+abc_compressed_hello.writeByte(0x11);
+abc_compressed_hello.writeByte(0xC8);
+abc_compressed_hello.writeByte(0x5F);
+abc_compressed_hello.writeByte(0xE6);
+abc_compressed_hello.writeByte(0xD5);
+abc_compressed_hello.writeByte(0x8A);
+abc_compressed_hello.writeByte(0x64);
+abc_compressed_hello.writeByte(0x72);
+abc_compressed_hello.writeByte(0x70);
+abc_compressed_hello.writeByte(0x9E);
+abc_compressed_hello.writeByte(0xA8);
+abc_compressed_hello.writeByte(0x41);
+abc_compressed_hello.writeByte(0x82);
+abc_compressed_hello.writeByte(0x52);
+abc_compressed_hello.writeByte(0x13);
+abc_compressed_hello.writeByte(0x1B);
+abc_compressed_hello.writeByte(0x09);
+abc_compressed_hello.writeByte(0xB2);
+abc_compressed_hello.writeByte(0x30);
+abc_compressed_hello.writeByte(0x51);
+abc_compressed_hello.writeByte(0xAD);
+abc_compressed_hello.writeByte(0x62);
+abc_compressed_hello.writeByte(0x82);
+abc_compressed_hello.writeByte(0xA4);
+abc_compressed_hello.writeByte(0x1B);
+abc_compressed_hello.writeByte(0x14);
+abc_compressed_hello.writeByte(0x99);
+abc_compressed_hello.writeByte(0xF4);
+abc_compressed_hello.writeByte(0xBB);
+abc_compressed_hello.writeByte(0xCB);
+abc_compressed_hello.writeByte(0x46);
+abc_compressed_hello.writeByte(0xF9);
+abc_compressed_hello.writeByte(0x2F);
+abc_compressed_hello.writeByte(0x5D);
+abc_compressed_hello.writeByte(0x05);
+abc_compressed_hello.writeByte(0x6F);
+abc_compressed_hello.writeByte(0xA1);
+abc_compressed_hello.writeByte(0xA0);
+abc_compressed_hello.writeByte(0x46);
+abc_compressed_hello.writeByte(0xB7);
+abc_compressed_hello.writeByte(0x9D);
+abc_compressed_hello.writeByte(0x4C);
+abc_compressed_hello.writeByte(0x1A);
+abc_compressed_hello.writeByte(0x7F);
+abc_compressed_hello.writeByte(0xB4);
+abc_compressed_hello.writeByte(0xD4);
+abc_compressed_hello.writeByte(0xFC);
+abc_compressed_hello.writeByte(0x7C);
+abc_compressed_hello.writeByte(0x4B);
+abc_compressed_hello.writeByte(0x83);
+abc_compressed_hello.writeByte(0x84);
+abc_compressed_hello.writeByte(0x97);
+abc_compressed_hello.writeByte(0x7C);
+abc_compressed_hello.writeByte(0x25);
+abc_compressed_hello.writeByte(0xCB);
+abc_compressed_hello.writeByte(0x0E);
+abc_compressed_hello.writeByte(0xA4);
+abc_compressed_hello.writeByte(0xEB);
+abc_compressed_hello.writeByte(0x5C);
+abc_compressed_hello.writeByte(0xD5);
+abc_compressed_hello.writeByte(0x69);
+abc_compressed_hello.writeByte(0x91);
+abc_compressed_hello.writeByte(0xE0);
+abc_compressed_hello.writeByte(0xE3);
+abc_compressed_hello.writeByte(0x1B);
+abc_compressed_hello.writeByte(0xD9);
+abc_compressed_hello.writeByte(0x8A);
+abc_compressed_hello.writeByte(0x7F);
+abc_compressed_hello.writeByte(0x63);
+abc_compressed_hello.writeByte(0x44);
+abc_compressed_hello.writeByte(0xB7);
+abc_compressed_hello.writeByte(0x89);
+abc_compressed_hello.writeByte(0x36);
+abc_compressed_hello.writeByte(0x82);
+abc_compressed_hello.writeByte(0x68);
+abc_compressed_hello.writeByte(0x6F);
+abc_compressed_hello.writeByte(0xBD);
+abc_compressed_hello.writeByte(0x1C);
+abc_compressed_hello.writeByte(0x3F);
+abc_compressed_hello.writeByte(0x1F);
+abc_compressed_hello.writeByte(0xE5);
+abc_compressed_hello.writeByte(0xC1);
+abc_compressed_hello.writeByte(0xF9);
+abc_compressed_hello.writeByte(0xE5);
+abc_compressed_hello.writeByte(0x36);
+abc_compressed_hello.writeByte(0xB4);
+abc_compressed_hello.writeByte(0x08);
+abc_compressed_hello.writeByte(0x71);
+abc_compressed_hello.writeByte(0x14);
+abc_compressed_hello.writeByte(0xAC);
+abc_compressed_hello.writeByte(0x9E);
+abc_compressed_hello.writeByte(0xEC);
+abc_compressed_hello.writeByte(0x24);
+abc_compressed_hello.writeByte(0x82);
+abc_compressed_hello.writeByte(0x77);
+abc_compressed_hello.writeByte(0x5E);
+abc_compressed_hello.writeByte(0x68);
+abc_compressed_hello.writeByte(0x00);
+abc_compressed_hello.writeByte(0x23);
+abc_compressed_hello.writeByte(0x75);
+abc_compressed_hello.writeByte(0x68);
+abc_compressed_hello.writeByte(0xEE);
+abc_compressed_hello.writeByte(0x03);
+abc_compressed_hello.writeByte(0x9A);
+abc_compressed_hello.writeByte(0x62);
+abc_compressed_hello.writeByte(0x2D);
+abc_compressed_hello.writeByte(0xFE);
+abc_compressed_hello.writeByte(0xA0);
+abc_compressed_hello.writeByte(0x72);
+abc_compressed_hello.writeByte(0x13);
+abc_compressed_hello.writeByte(0x80);
+abc_compressed_hello.writeByte(0x58);
+abc_compressed_hello.writeByte(0x8B);
+abc_compressed_hello.writeByte(0x79);
+abc_compressed_hello.writeByte(0x63);
+abc_compressed_hello.writeByte(0x6E);
+abc_compressed_hello.writeByte(0x14);
+abc_compressed_hello.writeByte(0xF3);
+abc_compressed_hello.writeByte(0x72);
+abc_compressed_hello.writeByte(0x70);
+abc_compressed_hello.writeByte(0x4F);
+abc_compressed_hello.writeByte(0xFD);
+abc_compressed_hello.writeByte(0x81);
+abc_compressed_hello.writeByte(0xCA);
+abc_compressed_hello.writeByte(0x3D);
+abc_compressed_hello.writeByte(0xD5);
+abc_compressed_hello.writeByte(0xB6);
+abc_compressed_hello.writeByte(0x6F);
+abc_compressed_hello.writeByte(0xD2);
+abc_compressed_hello.writeByte(0xAF);
+abc_compressed_hello.writeByte(0x79);
+abc_compressed_hello.writeByte(0x09);
+abc_compressed_hello.writeByte(0xE5);
+abc_compressed_hello.writeByte(0x27);
+abc_compressed_hello.writeByte(0x03);
+abc_compressed_hello.writeByte(0x8C);
+abc_compressed_hello.writeByte(0x2F);
+abc_compressed_hello.writeByte(0x73);
+abc_compressed_hello.writeByte(0x29);
+abc_compressed_hello.writeByte(0xED);
+abc_compressed_hello.writeByte(0xAC);
+abc_compressed_hello.writeByte(0xC2);
+abc_compressed_hello.writeByte(0xD9);
+abc_compressed_hello.writeByte(0xC3);
+abc_compressed_hello.writeByte(0x86);
+abc_compressed_hello.writeByte(0x27);
+abc_compressed_hello.writeByte(0x38);
+abc_compressed_hello.writeByte(0x23);
+abc_compressed_hello.writeByte(0xDC);
+abc_compressed_hello.writeByte(0x84);
+abc_compressed_hello.writeByte(0x52);
+abc_compressed_hello.writeByte(0xA7);
+abc_compressed_hello.writeByte(0x9F);
+abc_compressed_hello.writeByte(0xF7);
+abc_compressed_hello.writeByte(0x5F);
+abc_compressed_hello.writeByte(0xF3);
+abc_compressed_hello.writeByte(0x1B);
+abc_compressed_hello.writeByte(0x7E);
+abc_compressed_hello.writeByte(0x74);
+abc_compressed_hello.writeByte(0x57);
+abc_compressed_hello.writeByte(0xD6);
+abc_compressed_hello.writeByte(0xEB);
+abc_compressed_hello.writeByte(0x62);
+abc_compressed_hello.writeByte(0xF4);
+abc_compressed_hello.writeByte(0x31);
+abc_compressed_hello.writeByte(0x3B);
+abc_compressed_hello.writeByte(0x11);
+abc_compressed_hello.writeByte(0xE5);
+abc_compressed_hello.writeByte(0x50);
+abc_compressed_hello.writeByte(0x1C);
+abc_compressed_hello.writeByte(0x49);
+abc_compressed_hello.writeByte(0x10);
+abc_compressed_hello.writeByte(0x61);
+abc_compressed_hello.writeByte(0xC9);
+abc_compressed_hello.writeByte(0x5D);
+abc_compressed_hello.writeByte(0x1C);
+abc_compressed_hello.writeByte(0x15);
+abc_compressed_hello.writeByte(0x45);
+abc_compressed_hello.writeByte(0x87);
+abc_compressed_hello.writeByte(0x55);
+abc_compressed_hello.writeByte(0x10);
+abc_compressed_hello.writeByte(0x21);
+abc_compressed_hello.writeByte(0x7F);
+abc_compressed_hello.writeByte(0x83);
+abc_compressed_hello.writeByte(0x1B);
+abc_compressed_hello.writeByte(0xFD);
+abc_compressed_hello.writeByte(0x8E);
+abc_compressed_hello.writeByte(0x4C);
+abc_compressed_hello.writeByte(0xD1);
+abc_compressed_hello.writeByte(0x9B);
+abc_compressed_hello.writeByte(0x27);
+abc_compressed_hello.writeByte(0x01);
+abc_compressed_hello.writeByte(0x0E);
+abc_compressed_hello.writeByte(0x35);
+abc_compressed_hello.writeByte(0x34);
+abc_compressed_hello.writeByte(0xFB);
+abc_compressed_hello.writeByte(0x1D);
+abc_compressed_hello.writeByte(0xA7);
+abc_compressed_hello.writeByte(0xA1);
+abc_compressed_hello.writeByte(0xA9);
+abc_compressed_hello.writeByte(0x1A);
+abc_compressed_hello.writeByte(0x42);
+abc_compressed_hello.writeByte(0xAB);
+abc_compressed_hello.writeByte(0x4F);
+abc_compressed_hello.writeByte(0xA3);
+abc_compressed_hello.writeByte(0x82);
+abc_compressed_hello.writeByte(0xA7);
+abc_compressed_hello.writeByte(0x37);
+abc_compressed_hello.writeByte(0x04);
+abc_compressed_hello.writeByte(0x95);
+abc_compressed_hello.writeByte(0x1E);
+abc_compressed_hello.writeByte(0xF8);
+abc_compressed_hello.writeByte(0x8E);
+abc_compressed_hello.writeByte(0xA5);
+abc_compressed_hello.writeByte(0x0F);
+abc_compressed_hello.writeByte(0x9A);
+abc_compressed_hello.writeByte(0xE4);
+abc_compressed_hello.position = 0;
+
+var abc_compressed_small = new ByteArray();
+abc_compressed_small.writeByte(0x5D);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x80);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x1C);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x22);
+abc_compressed_small.writeByte(0x19);
+abc_compressed_small.writeByte(0x49);
+abc_compressed_small.writeByte(0x86);
+abc_compressed_small.writeByte(0xB0);
+abc_compressed_small.writeByte(0x70);
+abc_compressed_small.writeByte(0x8E);
+abc_compressed_small.writeByte(0xD1);
+abc_compressed_small.writeByte(0xE2);
+abc_compressed_small.writeByte(0xA2);
+abc_compressed_small.writeByte(0x80);
+abc_compressed_small.writeByte(0x2D);
+abc_compressed_small.writeByte(0xE1);
+abc_compressed_small.writeByte(0x85);
+abc_compressed_small.writeByte(0x6F);
+abc_compressed_small.writeByte(0x1E);
+abc_compressed_small.writeByte(0xE6);
+abc_compressed_small.writeByte(0xD5);
+abc_compressed_small.writeByte(0x4B);
+abc_compressed_small.writeByte(0x2A);
+abc_compressed_small.writeByte(0x79);
+abc_compressed_small.writeByte(0x6C);
+abc_compressed_small.writeByte(0x55);
+abc_compressed_small.writeByte(0x20);
+abc_compressed_small.writeByte(0x8E);
+abc_compressed_small.writeByte(0x60);
+abc_compressed_small.writeByte(0x9D);
+abc_compressed_small.writeByte(0x9A);
+abc_compressed_small.writeByte(0x61);
+abc_compressed_small.writeByte(0x26);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.writeByte(0x00);
+abc_compressed_small.position = 0;
+
+
+// Bugzilla 733051: ByteArrayLzma callCompress tests are doing
+// round-trips through compress and uncompress; this test is checking
+// that we correctly handle inputs that have been compressed by
+// third-party utilities (see LZMA.jar attached to Bugzilla 729336).
+function testThirdPartyLzmaInputs()
+{
+    var compressedHello:ByteArray = new ByteArray();
+    compressedHello.writeBytes(abc_compressed_hello);
+    var compressedSmall:ByteArray = new ByteArray();
+    compressedSmall.writeBytes(abc_compressed_small);
+
+    var helloString:String = "Hello World!\n" +
+      "\n" +
+      "More text; Felix wants to illustrate content that is compressed by\n" +
+      "LZMA, but a 13 byte file with just \"Hello World!\\n\" is compressed to a\n" +
+      "31 byte file by LZMA.  (Though perhaps a large portion is LZMA header?\n" +
+      "Not sure yet.)  Easy ending: LZMA LZMA LZMA Hello World LZMA LZMA LZMA\n" +
+      "LZMA LZMA LZMA Hello World LZMA LZMA LZMA Malkovich Malkovich LZMA\n" +
+      "LZMA LZMA Malkovich LZMA LZMA LZMA LZMA.\n";
+    var smallString:String = "Deliberately small snippet.\n";
+
+    compressedHello.uncompress(CompressionAlgorithm.LZMA);
+    var helloString2:String = compressedHello.readUTFBytes(compressedHello.length);
+    Assert.expectEq("Correct lzma uncompression on hello", helloString, helloString2);
+
+    compressedSmall.uncompress(CompressionAlgorithm.LZMA);
+    var smallString2:String = compressedSmall.readUTFBytes(compressedSmall.length);
+    Assert.expectEq("Correct lzma uncompression on small", smallString, smallString2);
+}
+
+testThirdPartyLzmaInputs();
+
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/config.xml b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/config.xml
new file mode 100644
index 000000000..18d27f9ba
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/config.xml
@@ -0,0 +1,13 @@
+<flex-config>
+    <compiler>
+        <source-path>
+            <path-element>.</path-element>
+            <path-element>../../../lib</path-element>
+        </source-path>
+        <debug>false</debug>
+        <omit-trace-statements>false</omit-trace-statements>
+        <show-actionscript-warnings>false</show-actionscript-warnings>
+        <strict>false</strict>
+    </compiler>
+    <output>test.swf</output>
+</flex-config>
\ No newline at end of file
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/output.txt b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/output.txt
new file mode 100644
index 000000000..d1a0a7643
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/output.txt
@@ -0,0 +1,2 @@
+Correct lzma uncompression on hello PASSED!
+Correct lzma uncompression on small PASSED!
diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/test.swf b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/test.swf
new file mode 100644
index 0000000000000000000000000000000000000000..776a8aed4de038657bcb5755b01a42a52a074d5e
GIT binary patch
literal 3541
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
PJO4eoN|gTrkoxwI_|4bv

literal 0
HcmV?d00001

diff --git a/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/test.toml b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/test.toml
new file mode 100644
index 000000000..4ca4f7f15
--- /dev/null
+++ b/tests/tests/swfs/avm2/from_avmplus/as3/ByteArray/ByteArrayLzmaThirdParty/test.toml
@@ -0,0 +1,4 @@
+num_ticks = 1
+
+[required_features]
+lzma = true
\ No newline at end of file