From dc0cb00a036d83c29fc1c7dac6881681e199d098 Mon Sep 17 00:00:00 2001 From: David Wendt Date: Sat, 7 Mar 2020 20:17:07 -0500 Subject: [PATCH] Add a test for `propertyIsEnumerable`. --- core/tests/regression_tests.rs | 1 + .../swfs/avm2/property_is_enumerable/Test.as | 177 ++++++++++++++++++ .../avm2/property_is_enumerable/output.txt | 102 ++++++++++ .../swfs/avm2/property_is_enumerable/test.fla | Bin 0 -> 3983 bytes .../swfs/avm2/property_is_enumerable/test.swf | Bin 0 -> 2431 bytes 5 files changed, 280 insertions(+) create mode 100644 core/tests/swfs/avm2/property_is_enumerable/Test.as create mode 100644 core/tests/swfs/avm2/property_is_enumerable/output.txt create mode 100644 core/tests/swfs/avm2/property_is_enumerable/test.fla create mode 100644 core/tests/swfs/avm2/property_is_enumerable/test.swf diff --git a/core/tests/regression_tests.rs b/core/tests/regression_tests.rs index eb2f51311..191809e25 100644 --- a/core/tests/regression_tests.rs +++ b/core/tests/regression_tests.rs @@ -242,6 +242,7 @@ swf_tests! { (as3_class_enumeration, "avm2/class_enumeration", 1), (as3_is_prototype_of, "avm2/is_prototype_of", 1), (as3_has_own_property, "avm2/has_own_property", 1), + (as3_property_is_enumerable, "avm2/property_is_enumerable", 1), } // TODO: These tests have some inaccuracies currently, so we use approx_eq to test that numeric values are close enough. diff --git a/core/tests/swfs/avm2/property_is_enumerable/Test.as b/core/tests/swfs/avm2/property_is_enumerable/Test.as new file mode 100644 index 000000000..505dc6be8 --- /dev/null +++ b/core/tests/swfs/avm2/property_is_enumerable/Test.as @@ -0,0 +1,177 @@ +package { + public class Test {} +} + +class ES4Class extends Object { + public var test_var = "var"; + public const test_const = "const"; + + public function test_function() { + trace("test_function"); + } + + public function get test_virt() { + return "test_virt"; + } + + public function set test_virt(val) { + trace("test_virt"); + } + + public static var test_static_var = "var"; + public static const test_static_const = "const"; + + public static function test_static_function() { + trace("test_static_function"); + } + + public static function get test_static_virt() { + return "test_static_virt"; + } + + public static function set test_static_virt(val) { + trace("test_static_virt"); + } + + private var test_private_var = "private_var"; + private const test_private_const = "private_const"; + + private function test_private_function() { + trace("test_private_function"); + } + + private function get test_private_virt() { + return "test_private_virt"; + } + + private function set test_private_virt(val) { + trace("test_private_virt"); + } +} + +function ES3Class() { + this.test_var = "var"; +} + +ES3Class.test_static_var = "var"; + +ES3Class.test_static_function = function () { + trace("test_static_function"); +} + +ES3Class.prototype.test_function = function() { + trace("test_function"); +} + +ES3Class.prototype.test_proto = "proto_var"; + +var es4inst = new ES4Class(); +var es3inst = new ES3Class(); + +trace("//es4inst.propertyIsEnumerable('test_var')"); +trace(es4inst.propertyIsEnumerable('test_var')); +trace("//es4inst.propertyIsEnumerable('test_const')"); +trace(es4inst.propertyIsEnumerable('test_const')); +trace("//es4inst.propertyIsEnumerable('test_function')"); +trace(es4inst.propertyIsEnumerable('test_function')); +trace("//es4inst.propertyIsEnumerable('test_virt')"); +trace(es4inst.propertyIsEnumerable('test_virt')); +trace("//es4inst.propertyIsEnumerable('test_static_var')"); +trace(es4inst.propertyIsEnumerable('test_static_var')); +trace("//es4inst.propertyIsEnumerable('test_static_const')"); +trace(es4inst.propertyIsEnumerable('test_static_const')); +trace("//es4inst.propertyIsEnumerable('test_static_function')"); +trace(es4inst.propertyIsEnumerable('test_static_function')); +trace("//es4inst.propertyIsEnumerable('test_static_virt')"); +trace(es4inst.propertyIsEnumerable('test_static_virt')); +trace("//es4inst.propertyIsEnumerable('test_private_var')"); +trace(es4inst.propertyIsEnumerable('test_private_var')); +trace("//es4inst.propertyIsEnumerable('test_private_const')"); +trace(es4inst.propertyIsEnumerable('test_private_const')); +trace("//es4inst.propertyIsEnumerable('test_private_function')"); +trace(es4inst.propertyIsEnumerable('test_private_function')); +trace("//es4inst.propertyIsEnumerable('test_private_virt')"); +trace(es4inst.propertyIsEnumerable('test_private_virt')); + +trace("//ES4Class.propertyIsEnumerable('test_var')"); +trace(ES4Class.propertyIsEnumerable('test_var')); +trace("//ES4Class.propertyIsEnumerable('test_const')"); +trace(ES4Class.propertyIsEnumerable('test_const')); +trace("//ES4Class.propertyIsEnumerable('test_function')"); +trace(ES4Class.propertyIsEnumerable('test_function')); +trace("//ES4Class.propertyIsEnumerable('test_virt')"); +trace(ES4Class.propertyIsEnumerable('test_virt')); +trace("//ES4Class.propertyIsEnumerable('test_static_var')"); +trace(ES4Class.propertyIsEnumerable('test_static_var')); +trace("//ES4Class.propertyIsEnumerable('test_static_const')"); +trace(ES4Class.propertyIsEnumerable('test_static_const')); +trace("//ES4Class.propertyIsEnumerable('test_static_function')"); +trace(ES4Class.propertyIsEnumerable('test_static_function')); +trace("//ES4Class.propertyIsEnumerable('test_static_virt')"); +trace(ES4Class.propertyIsEnumerable('test_static_virt')); +trace("//ES4Class.propertyIsEnumerable('test_private_var')"); +trace(ES4Class.propertyIsEnumerable('test_private_var')); +trace("//ES4Class.propertyIsEnumerable('test_private_const')"); +trace(ES4Class.propertyIsEnumerable('test_private_const')); +trace("//ES4Class.propertyIsEnumerable('test_private_function')"); +trace(ES4Class.propertyIsEnumerable('test_private_function')); +trace("//ES4Class.propertyIsEnumerable('test_private_virt')"); +trace(ES4Class.propertyIsEnumerable('test_private_virt')); + +trace("//ES4Class.prototype.propertyIsEnumerable('test_var')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_var')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_const')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_const')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_function')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_function')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_virt')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_virt')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_static_var')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_static_var')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_static_const')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_static_const')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_static_function')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_static_function')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_static_virt')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_static_virt')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_private_var')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_private_var')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_private_const')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_private_const')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_private_function')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_private_function')); +trace("//ES4Class.prototype.propertyIsEnumerable('test_private_virt')"); +trace(ES4Class.prototype.propertyIsEnumerable('test_private_virt')); + +trace("//es3inst.propertyIsEnumerable('test_var')"); +trace(es3inst.propertyIsEnumerable('test_var')); +trace("//es3inst.propertyIsEnumerable('test_function')"); +trace(es3inst.propertyIsEnumerable('test_function')); +trace("//es3inst.propertyIsEnumerable('test_proto')"); +trace(es3inst.propertyIsEnumerable('test_proto')); +trace("//es3inst.propertyIsEnumerable('test_static_var')"); +trace(es3inst.propertyIsEnumerable('test_static_var')); +trace("//es3inst.propertyIsEnumerable('test_static_function')"); +trace(es3inst.propertyIsEnumerable('test_static_function')); + +trace("//ES3Class.propertyIsEnumerable('test_var')"); +trace(ES3Class.propertyIsEnumerable('test_var')); +trace("//ES3Class.propertyIsEnumerable('test_function')"); +trace(ES3Class.propertyIsEnumerable('test_function')); +trace("//ES3Class.propertyIsEnumerable('test_proto')"); +trace(ES3Class.propertyIsEnumerable('test_proto')); +trace("//ES3Class.propertyIsEnumerable('test_static_var')"); +trace(ES3Class.propertyIsEnumerable('test_static_var')); +trace("//ES3Class.propertyIsEnumerable('test_static_function')"); +trace(ES3Class.propertyIsEnumerable('test_static_function')); + +trace("//ES3Class.prototype.propertyIsEnumerable('test_var')"); +trace(ES3Class.prototype.propertyIsEnumerable('test_var')); +trace("//ES3Class.prototype.propertyIsEnumerable('test_function')"); +trace(ES3Class.prototype.propertyIsEnumerable('test_function')); +trace("//ES3Class.prototype.propertyIsEnumerable('test_proto')"); +trace(ES3Class.prototype.propertyIsEnumerable('test_proto')); +trace("//ES3Class.prototype.propertyIsEnumerable('test_static_var')"); +trace(ES3Class.prototype.propertyIsEnumerable('test_static_var')); +trace("//ES3Class.prototype.propertyIsEnumerable('test_static_function')"); +trace(ES3Class.prototype.propertyIsEnumerable('test_static_function')); \ No newline at end of file diff --git a/core/tests/swfs/avm2/property_is_enumerable/output.txt b/core/tests/swfs/avm2/property_is_enumerable/output.txt new file mode 100644 index 000000000..67ee3c596 --- /dev/null +++ b/core/tests/swfs/avm2/property_is_enumerable/output.txt @@ -0,0 +1,102 @@ +//es4inst.propertyIsEnumerable('test_var') +false +//es4inst.propertyIsEnumerable('test_const') +false +//es4inst.propertyIsEnumerable('test_function') +false +//es4inst.propertyIsEnumerable('test_virt') +false +//es4inst.propertyIsEnumerable('test_static_var') +false +//es4inst.propertyIsEnumerable('test_static_const') +false +//es4inst.propertyIsEnumerable('test_static_function') +false +//es4inst.propertyIsEnumerable('test_static_virt') +false +//es4inst.propertyIsEnumerable('test_private_var') +false +//es4inst.propertyIsEnumerable('test_private_const') +false +//es4inst.propertyIsEnumerable('test_private_function') +false +//es4inst.propertyIsEnumerable('test_private_virt') +false +//ES4Class.propertyIsEnumerable('test_var') +false +//ES4Class.propertyIsEnumerable('test_const') +false +//ES4Class.propertyIsEnumerable('test_function') +false +//ES4Class.propertyIsEnumerable('test_virt') +false +//ES4Class.propertyIsEnumerable('test_static_var') +false +//ES4Class.propertyIsEnumerable('test_static_const') +false +//ES4Class.propertyIsEnumerable('test_static_function') +false +//ES4Class.propertyIsEnumerable('test_static_virt') +false +//ES4Class.propertyIsEnumerable('test_private_var') +false +//ES4Class.propertyIsEnumerable('test_private_const') +false +//ES4Class.propertyIsEnumerable('test_private_function') +false +//ES4Class.propertyIsEnumerable('test_private_virt') +false +//ES4Class.prototype.propertyIsEnumerable('test_var') +false +//ES4Class.prototype.propertyIsEnumerable('test_const') +false +//ES4Class.prototype.propertyIsEnumerable('test_function') +false +//ES4Class.prototype.propertyIsEnumerable('test_virt') +false +//ES4Class.prototype.propertyIsEnumerable('test_static_var') +false +//ES4Class.prototype.propertyIsEnumerable('test_static_const') +false +//ES4Class.prototype.propertyIsEnumerable('test_static_function') +false +//ES4Class.prototype.propertyIsEnumerable('test_static_virt') +false +//ES4Class.prototype.propertyIsEnumerable('test_private_var') +false +//ES4Class.prototype.propertyIsEnumerable('test_private_const') +false +//ES4Class.prototype.propertyIsEnumerable('test_private_function') +false +//ES4Class.prototype.propertyIsEnumerable('test_private_virt') +false +//es3inst.propertyIsEnumerable('test_var') +true +//es3inst.propertyIsEnumerable('test_function') +false +//es3inst.propertyIsEnumerable('test_proto') +false +//es3inst.propertyIsEnumerable('test_static_var') +false +//es3inst.propertyIsEnumerable('test_static_function') +false +//ES3Class.propertyIsEnumerable('test_var') +false +//ES3Class.propertyIsEnumerable('test_function') +false +//ES3Class.propertyIsEnumerable('test_proto') +false +//ES3Class.propertyIsEnumerable('test_static_var') +true +//ES3Class.propertyIsEnumerable('test_static_function') +true +//ES3Class.prototype.propertyIsEnumerable('test_var') +false +//ES3Class.prototype.propertyIsEnumerable('test_function') +true +//ES3Class.prototype.propertyIsEnumerable('test_proto') +true +//ES3Class.prototype.propertyIsEnumerable('test_static_var') +false +//ES3Class.prototype.propertyIsEnumerable('test_static_function') +false diff --git a/core/tests/swfs/avm2/property_is_enumerable/test.fla b/core/tests/swfs/avm2/property_is_enumerable/test.fla new file mode 100644 index 0000000000000000000000000000000000000000..9117e9f0beb567f07719301e8775ac7b9d90c7dc GIT binary patch literal 3983 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 literal 0 HcmV?d00001 diff --git a/core/tests/swfs/avm2/property_is_enumerable/test.swf b/core/tests/swfs/avm2/property_is_enumerable/test.swf new file mode 100644 index 0000000000000000000000000000000000000000..60a6b4460e6d41d76661d13ddc47cce06a6e4a0b GIT binary patch literal 2431 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 literal 0 HcmV?d00001