diff --git a/.eslintrc.json b/.eslintrc.json
deleted file mode 100644
index 8252235c..00000000
--- a/.eslintrc.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
- "root": true,
- "parser": "@typescript-eslint/parser",
- "parserOptions": {
- "ecmaVersion": 6,
- "sourceType": "module"
- },
- "plugins": [
- "@typescript-eslint"
- ],
- "rules": {
- }
-}
diff --git a/.gitignore b/.gitignore
index 4079519f..2ec8a070 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,13 +1,7 @@
-.vscode/*
-!.vscode/extensions.json
-!.vscode/launch.json
-!.vscode/tasks.json
-node_modules
-out/
-src/language/generated/
-static/bundle/
-static/monaco-editor-workers/
-static/worker/
+.cache
+
+test/
syntaxes/
-examples/out
-**/__pycache__/*
+node_modules/
+public/solver*
+lib/language/generated
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
deleted file mode 100644
index 25933b03..00000000
--- a/.vscode/extensions.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- // See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
- // Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
-
- // List of extensions which should be recommended for users of this workspace.
- "recommendations": [
- "langium.langium-vscode"
- ]
-}
diff --git a/.vscode/launch.json b/.vscode/launch.json
deleted file mode 100644
index e44e9fbc..00000000
--- a/.vscode/launch.json
+++ /dev/null
@@ -1,35 +0,0 @@
-// A launch configuration that launches the extension inside a new window
-// Use IntelliSense to learn about possible attributes.
-// Hover to view descriptions of existing attributes.
-// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-{
- "version": "0.2.0",
- "configurations": [
- {
- "name": "Run Extension",
- "type": "extensionHost",
- "request": "launch",
- "args": [
- "--extensionDevelopmentPath=${workspaceFolder}"
- ],
- "sourceMaps": true,
- "outFiles": [
- "${workspaceFolder}/out/**/*.js"
- ]
- },
- {
- "name": "Attach to Language Server",
- "type": "node",
- "port": 6009,
- "request": "attach",
- "skipFiles": [
- " This is my issue Without a 'Box' like type there will not be any direct support in the language for storing objects in Records and Tuples.
- Box use-cases include:
-
-
-
If Records and Tuples are not objects then a
ToObjectoperation will return an object wrapper - which will have its own unique identity:
Object(#[]) !== Object(#[])." -} - -issue objectWrapperInConsistency { - summary - "being objects" - description - "
Code may assume that if a value's typeof is not 'object' or 'function' then it is not an object, but if
ToObjectreturns the value as is this implies that it is an object. -
If Tuples are objects this means that the methods on their '[[prototype]]' will be linked to the realm (e.g. iframe) in which they were created. - As opposed to primitives, where property access triggers a
ToObjectin the current executing realm. - This would mean that two Tuples created in different realms will carry around different prototypes. - The choice here is that either two objects with different prototypes can still be === equal to each other. - Or Tuples from different realms are never equal even if their contents are equal. - " -} - -issue noBoxesInWeakSets { - summary - "performance" - description - "Libraries may want to create values based on Records that contain boxes. For example, - mapping over a record and mapping each Box to something else. If this work is expensive, it - may be beneficial to memoize the work using a WeakMap. But this wouldn't be possible if - Records with Boxes can't be WeakMaps keys." -} - -issue unequalTupleNan { - summary - "consistency change" - description - "Currently the only value not equal to itself is NaN, and this can be used as a reliable - check for NaN. If any record or tuple containing a NaN within its tree is also not equal to - itself, then there would be an infinite number of values not equal to themselves. - " -} - -issue noNegativeZero { - summary - "no negative zero" - description - "
- Negative zero can be stored in a standard Array. If negative zero was transformed into - positive zero when stored in a tuple, then mapping arrays of numbers to and from tuples - would not be isomorphic. -
-Being able to store a negative zero is considered important to some users.
- " -} - -issue impossibleEqualityOfZeros { - summary - "impossible equality" - description - "If negative zero can not be stored in a Tuple (converted to +0). Then #[-0] cannot compare - unequal to #[+0]." -} - -issue observableDifferentButIsEqual { - summary - "Object.is semantics" - description - "Putting aside that two NaNs can be observably different, by storing them in a TypedArray and - reading the bits. If Object.is returns true for two values this means the two values are not - observably different, this is useful for memoization techniques. For a pure function, if the - inputs have not changed in an observable way then neither should the output. React.js for - example uses Object.is for its change-detection. If two Tuples compare equal, but have - observably different values (one has positive zero and the other has negative zero), then - this changes the semantics of Object.is, and the use cases it can be applied to." -} - -issue nanNotIsNan { - summary - "Object.is NaN semantics" - description - "if both 'Object.is(NaN, NaN)' and '#[NaN] === #[NaN]'' are true, there does not appear to be - a reason for Object.is(#[NaN], #[NaN]) to not be true." -} - -issue canNotAlwaysIntern { - summary - "can not always intern" - description - "Object interning is a technique used to reduce memory and speed up certain operations after - the initial interning cost. If #[+0] equals #[-0] and storing negative zero in a tuple is - preserved then records and tuple equality can not solely rely on interning." -} - -issue zerosNotTripleEqual { - summary - "Triple equality semantics" - description - "As -0 === +0 on their own, it may surprise people that they are no longer treated as triple - equal when compared via a record or tuple. This could lead to bugs. - " -} - -issue storingPrimitiveInBox { - summary - "storing primitives* in a Box" - description - "- primitives*: For want of a more appropriate term, in this section the term primitive will have the meaning: a value that can be directly stored in a Record or Tuple. - i.e. records, tuples, boxes, null, undefined, booleans, numbers, strings, symbols, and bigints. -
-- The original rationale for introducing Box is to allow Records and Tuples to explicitly reference a value that would otherwise be disallowed - to be 'stored' directly within Records and Tuples e.g. functions. - Values like numbers can already be stored in a Record or Tuple. - While allowing primitives* to be stored in a Box may be ergonomic for the producer of the Box, - complexity has been moved to the consumers of Boxes. Consumers can no longer rely on the guarantee that a Box will always - reference a 'non-primitive*'. -
-- It appears that there might be situations where checking if a Record contains an Object or not will be important, because of the difference in semantics. - e.g. checking for cycles, passing values across a ShadowRealm boundary, - or storing values in a WeakMap. - If primitives* can be stored in a Box, then code checking if a Record/Tuple transitively contains an Object can no - longer be performed with a single call to a
Box.containsBoxespredicate, instead different/additional helpers would be needed for this use-case. - e.g.
Object.containsObjector
Box.containsBoxWithIdentity. These helpers may be harder to explain than 'containsBoxes'. - Note: These helpers can be implemented in user-land, recursively walking the tree inspecting the values. They do not necessarily need to be built-in. - - " -} - -issue noPrimitivesInBox { - summary - "Box construction ergonomics" - description - "If the Box constructor throws for values that can be 'stored' directly in a Record and - Tuple, such as strings, numbers, booleans. This adds complexity for code that is trying to - use Boxes generically, they will now need to check if a value can be put in a Box before - attempting to construct the Box, or be sure to handle the possibility that an exception will - be thrown. From a different perspective there could be an advantage to an exception being - thrown - it may help clarify the purpose of Boxes and make unnecessary boxing - impossible." -} - -issue recordProxies { - summary - "Record proxies" - description - "It appears that a Record-Proxy would not be able to be much different from 'new - Proxy(Object.freeze({...record}), handler)'. This is because if the Proxy still retained - Record semantics, then equality checks would need to trigger the traps. Causing arbitrary JS - to run during previously safe operations like '==='. This means that the returning proxy can - not be transparent, and will instead be an object and not a record. It could be better to - throw instead so this API space remains open for new ideas on how to achieve this in the - future." -} - -issue proxyThrowTypeofObject { - summary - "proxy ergonomics" - description - "Usually if something has typeof 'object' then it would be safe to create a proxy of it. But - if records and tuples are typeof 'object' and throw when passed to the proxy constructor, - this causes users to update their code to manually convert Records/Tuples into their frozen - object counterparts before passing them to the proxy constructor." -} - -issue differenceBetweenEqualityForTypeofObject { - summary - "different equality of an object-like value" - description - "
- In current JavaScript if two values, 'a' and 'b', both have typeof 'object' then 'a === - b' and 'Object.is(a, b)' will always return the same result. -
-- The current laboratory setup would mean that this is no longer an invariant of the - language. Because given two almost identical tuples, except one has positive zero, and - the other has negative zero. These would both have typeof 'object' and be '===' equal to - each other, but not equal when compared by Object.is. -
" -} - -issue boxType { - summary - "Box type" - description - "- Introducing a Box type to the language adds more complexity to the language. -
" -} - -issue objectsDontHaveWrappers { - summary - "Value is already an object" - description - "- If Records and Tuples are objects then
ToObjectshould be an identity function. - " -} - -issue tuplePrototypeEquality { - summary - "Tuple prototype equality" - description - "
- Records do not have a '[[prototype]]', it is null. Tuples on the other hand do have a '[[prototype]]', being lists they - can have many of the typical generic list operations (e.g. map, filter etc). - In fact Tuples have all the same non-mutating methods as Arrays. -
-- If Tuples are objects this means that the methods on their '[[prototype]]' will be linked to the realm (e.g. iframe) in which they were created. - As opposed to primitives, where property access triggers a
ToObjectin the current executing realm. - This would mean that two Tuples created in different realms will carry around different prototypes. - The choice here is that either two objects with different prototypes can still be === equal to each other. - Or Tuples from different realms are never equal even if their contents are equal. - " -}""" - -LAB_TWEAKABLES_TEMPLATE = """\ -tweakable typeofArray{lab_index} {{ - expression "typeof []" - default value "object" -}} - -tweakable typeofNan{lab_index} {{ - expression "typeof NaN" - default value "number" -}} - -tweakable zeroTripleEqualsNegativZero{lab_index} {{ - expression "+0 === -0" - default value true -}} - -tweakable zeroObjectIsNegativeZero{lab_index} {{ - expression "Object.is(+0, -0)" - default value false -}} - -tweakable arrayWithNegativeZeroIncludesZero{lab_index} {{ - expression "[-0].includes(+0)" - default value true -}} - -tweakable nanTripleEqualsNan{lab_index} {{ - expression "NaN === NaN" - default value false -}} - -tweakable nanObjectIsNan{lab_index} {{ - expression "Object.is(NaN, Nan)" - default value true -}} - -tweakable arrayWithNanIncludesNan{lab_index} {{ - expression "[NaN].includes(NaN)" - default value true -}} - -tweakable arrayWithZeroTripleEqualsArrayWithZero{lab_index} {{ - expression "[0] === [0]" - default value false -}} - -tweakable tupleWithZeroTripleEqualsTupleWithZero{lab_index} {{ - expression "#[0] === #[0]" - default value true -}} - -tweakable objectIsFrozenTupleWithZero{lab_index} {{ - expression "Object.isFrozen(#[0])" - default value true -}} - -/* - Tweakables -*/ - -tweakable storeNegativeZero{lab_index} {{ - expression "Object.is(#[-0].at(0), -0)" - default value true - value false {{ - raise noNegativeZero - }} -}} - -tweakable zerosAreTripleEqual{lab_index} {{ - expression "#[+0] === #[-0]" - default value true {{ - raise canNotAlwaysIntern when storeNegativeZero{lab_index} is true - }} - value False {{ - raise zerosNotTripleEqual when storeNegativeZero{lab_index} is true - raise impossibleEqualityOfZeros when storeNegativeZero{lab_index} is false - }} -}} - -tweakable tupleNaNAreTripleEqual{lab_index} {{ - expression "#[NaN] === #[NaN]" - default value true - value false {{ - raise unequalTupleNan - }} -}} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero{lab_index} {{ - expression "Object.is(#[+0], #[-0])" - default value false {{ - raise impossibleEqualityOfZeros when storeNegativeZero{lab_index} is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple{lab_index} is "object" and zerosAreTripleEqual{lab_index} is true - }} - value true {{ - raise observableDifferentButIsEqual when storeNegativeZero{lab_index} is true - }} -}} - -tweakable tupleWithNanObjectIsTupleWithNan{lab_index} {{ - expression "Object.is(#[NaN], #[NaN])" - default value true - value false {{ - raise nanNotIsNan when tupleNaNAreTripleEqual{lab_index} is true - }} -}} - -tweakable typeofTuple{lab_index} {{ - expression "typeof #[]" - default value "tuple" {{ - raise slotSensitiveTypeof when typeOfTupleWithBox{lab_index} is "tuple" and typeofBoxConstructor{lab_index} is "function" - }} - value "object" {{ - raise slotSensitiveTypeof when typeOfTupleWithBox{lab_index} is "object" and typeofBoxConstructor{lab_index} is "function" - raise tuplePrototypeEquality - }} -}} - -tweakable tupleWrappedInObjectTripleEqualsTuple{lab_index} {{ - expression "Object(#[]) === #[]" - default value false {{ - raise objectsDontHaveWrappers when typeofTuple{lab_index} is "object" - raise objectWrappers - }} - value true {{ - raise objectWrapperInConsistency when typeofTuple{lab_index} is "tuple" - }} -}} - -tweakable addingTupleToWeakSetThrows{lab_index} {{ - expression "new WeakSet().add(#[])" - default value "ShouldThrow" {{ - raise validWeakValue when typeofTuple{lab_index} is "object" - }} - value "ShouldSucceed" {{ - raise weakSetLeak - }} -}} - -tweakable tupleAsArgumentOfNewProxyThrows{lab_index} {{ - expression "new Proxy(#[])" - default value "ShouldThrow" {{ - raise proxyThrowTypeofObject when typeofTuple{lab_index} is "object" - }} - value "ShouldSucceed" {{ - raise recordProxies - }} -}} - -tweakable typeofBoxConstructor{lab_index} {{ - expression "typeof Box" - default value "undefined" {{ - raise withoutBox - }} - value "function" {{ - raise boxType - }} -}} - -tweakable typeofBoxInstance{lab_index} {{ - expression "typeof Box({{}})" - default value "box" {{ - raise typeofPowerfulObjectIsNotObject - }} - value "object" - disabled {{ - message "typeof Box === 'undefined'" when typeofBoxConstructor{lab_index} is "undefined" - }} -}} - -tweakable typeOfTupleWithBox{lab_index} {{ - expression "typeof #[Box({{}})]" - default value "tuple" {{ - raise confusingTypeof when typeofTuple{lab_index} is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance{lab_index} is "object" - }} - value "object" - disabled {{ - message "typeof Box === 'undefined'" when typeofBoxConstructor{lab_index} is "undefined" - }} -}} - -tweakable boxConstructorWithPrimitives{lab_index} {{ - expression "Box(42)" - default value "ShouldThrow" {{ - raise noPrimitivesInBox - }} - value "ShouldSucceed" {{ - raise storingPrimitiveInBox - }} - disabled {{ - message "typeof Box === 'undefined'" when typeofBoxConstructor{lab_index} is "undefined" - }} -}} - -tweakable addingTuplesWithBoxesToWeakSets{lab_index} {{ - expression "new WeakSet().add(#[Box({{}})])" - default value "ShouldThrow" {{ - raise noBoxesInWeakSets - }} - value "ShouldSucceed" - disabled {{ - message "typeof Box === 'undefined'" when typeofBoxConstructor{lab_index} is "undefined" - }} -}} - -tweakable tupleWithBoxAsArgumentForNewProxy{lab_index} {{ - expression "new Proxy(#[Box({{}})])" - default value "ShouldThrow" {{ - raise proxyThrowTypeofObject when typeOfTupleWithBox{lab_index} is "object" - }} - value "ShouldSucceed" {{ - raise recordProxies - }} - disabled {{ - message "typeof Box === 'undefined'" when typeofBoxConstructor{lab_index} is "undefined" - }} -}} -""" - -with open("./lab.jspl", 'w') as output: - output.write(LAB_PREFIX) - - randt_copies = ceil(WANTED_TWEAKABLES / TWEAKABLES_IN_R_AND_T) - total_tweakables = randt_copies * TWEAKABLES_IN_R_AND_T - - print(f"Duplicating R&T {randt_copies} times, resulting in {total_tweakables} Tweakables.") - - for i in range(randt_copies): - - output.write(LAB_TWEAKABLES_TEMPLATE.format(lab_index = str(i))) \ No newline at end of file diff --git a/examples/in/randt_times_n/times_67.jspl b/examples/in/randt_times_n/times_67.jspl deleted file mode 100644 index 06a42e41..00000000 --- a/examples/in/randt_times_n/times_67.jspl +++ /dev/null @@ -1,14787 +0,0 @@ - -laboratory { - title "Records and Tuples Laboratory 🔬" - description MD "🏗 Work in progress - [raise technical issue](https://github.com/acutmore/record-tuple-laboratory/issues/new)" - icon "./res/favicon.svg" - author "Ashley Claymore" - format HTML - version "2" -} - -issue withoutBox { - summary - "complexity moved to ecosystem" - description - "
Without a 'Box' like type there will not be any direct support in the language for storing objects in Records and Tuples.
- Instead using symbols-as-weakmap-keys, - symbols in Record and Tuples could still refer to objects/functions via a WeakMap. - Code will need to ensure the necessary code has access to these WeakMap side tables. - APIs conventions will need to be established to distinguish when symbols are being used in this way. - Care will need to be taken with the WeakMaps, if a Map is used by accident there is a risk of memory leaks. - Unless direct access to the WeakMap is hidden behind a wrapper, other code could remove/replace the referenced - object. -- Box use-cases include: -
If Records and Tuples are not objects then a
ToObjectoperation will return an object wrapper - which will have its own unique identity:
Object(#[]) !== Object(#[])." -} - -issue objectWrapperInConsistency { - summary - "being objects" - description - "
Code may assume that if a value's typeof is not 'object' or 'function' then it is not an object, but if
ToObjectreturns the value as is this implies that it is an object. -
If Tuples are objects this means that the methods on their '[[prototype]]' will be linked to the realm (e.g. iframe) in which they were created. - As opposed to primitives, where property access triggers a
ToObjectin the current executing realm. - This would mean that two Tuples created in different realms will carry around different prototypes. - The choice here is that either two objects with different prototypes can still be === equal to each other. - Or Tuples from different realms are never equal even if their contents are equal. - " -} - -issue noBoxesInWeakSets { - summary - "performance" - description - "Libraries may want to create values based on Records that contain boxes. For example, - mapping over a record and mapping each Box to something else. If this work is expensive, it - may be beneficial to memoize the work using a WeakMap. But this wouldn't be possible if - Records with Boxes can't be WeakMaps keys." -} - -issue unequalTupleNan { - summary - "consistency change" - description - "Currently the only value not equal to itself is NaN, and this can be used as a reliable - check for NaN. If any record or tuple containing a NaN within its tree is also not equal to - itself, then there would be an infinite number of values not equal to themselves. - " -} - -issue noNegativeZero { - summary - "no negative zero" - description - "
- Negative zero can be stored in a standard Array. If negative zero was transformed into - positive zero when stored in a tuple, then mapping arrays of numbers to and from tuples - would not be isomorphic. -
-Being able to store a negative zero is considered important to some users.
- " -} - -issue impossibleEqualityOfZeros { - summary - "impossible equality" - description - "If negative zero can not be stored in a Tuple (converted to +0). Then #[-0] cannot compare - unequal to #[+0]." -} - -issue observableDifferentButIsEqual { - summary - "Object.is semantics" - description - "Putting aside that two NaNs can be observably different, by storing them in a TypedArray and - reading the bits. If Object.is returns true for two values this means the two values are not - observably different, this is useful for memoization techniques. For a pure function, if the - inputs have not changed in an observable way then neither should the output. React.js for - example uses Object.is for its change-detection. If two Tuples compare equal, but have - observably different values (one has positive zero and the other has negative zero), then - this changes the semantics of Object.is, and the use cases it can be applied to." -} - -issue nanNotIsNan { - summary - "Object.is NaN semantics" - description - "if both 'Object.is(NaN, NaN)' and '#[NaN] === #[NaN]'' are true, there does not appear to be - a reason for Object.is(#[NaN], #[NaN]) to not be true." -} - -issue canNotAlwaysIntern { - summary - "can not always intern" - description - "Object interning is a technique used to reduce memory and speed up certain operations after - the initial interning cost. If #[+0] equals #[-0] and storing negative zero in a tuple is - preserved then records and tuple equality can not solely rely on interning." -} - -issue zerosNotTripleEqual { - summary - "Triple equality semantics" - description - "As -0 === +0 on their own, it may surprise people that they are no longer treated as triple - equal when compared via a record or tuple. This could lead to bugs. - " -} - -issue storingPrimitiveInBox { - summary - "storing primitives* in a Box" - description - "- primitives*: For want of a more appropriate term, in this section the term primitive will have the meaning: a value that can be directly stored in a Record or Tuple. - i.e. records, tuples, boxes, null, undefined, booleans, numbers, strings, symbols, and bigints. -
-- The original rationale for introducing Box is to allow Records and Tuples to explicitly reference a value that would otherwise be disallowed - to be 'stored' directly within Records and Tuples e.g. functions. - Values like numbers can already be stored in a Record or Tuple. - While allowing primitives* to be stored in a Box may be ergonomic for the producer of the Box, - complexity has been moved to the consumers of Boxes. Consumers can no longer rely on the guarantee that a Box will always - reference a 'non-primitive*'. -
-- It appears that there might be situations where checking if a Record contains an Object or not will be important, because of the difference in semantics. - e.g. checking for cycles, passing values across a ShadowRealm boundary, - or storing values in a WeakMap. - If primitives* can be stored in a Box, then code checking if a Record/Tuple transitively contains an Object can no - longer be performed with a single call to a
Box.containsBoxespredicate, instead different/additional helpers would be needed for this use-case. - e.g.
Object.containsObjector
Box.containsBoxWithIdentity. These helpers may be harder to explain than 'containsBoxes'. - Note: These helpers can be implemented in user-land, recursively walking the tree inspecting the values. They do not necessarily need to be built-in. - - " -} - -issue noPrimitivesInBox { - summary - "Box construction ergonomics" - description - "If the Box constructor throws for values that can be 'stored' directly in a Record and - Tuple, such as strings, numbers, booleans. This adds complexity for code that is trying to - use Boxes generically, they will now need to check if a value can be put in a Box before - attempting to construct the Box, or be sure to handle the possibility that an exception will - be thrown. From a different perspective there could be an advantage to an exception being - thrown - it may help clarify the purpose of Boxes and make unnecessary boxing - impossible." -} - -issue recordProxies { - summary - "Record proxies" - description - "It appears that a Record-Proxy would not be able to be much different from 'new - Proxy(Object.freeze({...record}), handler)'. This is because if the Proxy still retained - Record semantics, then equality checks would need to trigger the traps. Causing arbitrary JS - to run during previously safe operations like '==='. This means that the returning proxy can - not be transparent, and will instead be an object and not a record. It could be better to - throw instead so this API space remains open for new ideas on how to achieve this in the - future." -} - -issue proxyThrowTypeofObject { - summary - "proxy ergonomics" - description - "Usually if something has typeof 'object' then it would be safe to create a proxy of it. But - if records and tuples are typeof 'object' and throw when passed to the proxy constructor, - this causes users to update their code to manually convert Records/Tuples into their frozen - object counterparts before passing them to the proxy constructor." -} - -issue differenceBetweenEqualityForTypeofObject { - summary - "different equality of an object-like value" - description - "
- In current JavaScript if two values, 'a' and 'b', both have typeof 'object' then 'a === - b' and 'Object.is(a, b)' will always return the same result. -
-- The current laboratory setup would mean that this is no longer an invariant of the - language. Because given two almost identical tuples, except one has positive zero, and - the other has negative zero. These would both have typeof 'object' and be '===' equal to - each other, but not equal when compared by Object.is. -
" -} - -issue boxType { - summary - "Box type" - description - "- Introducing a Box type to the language adds more complexity to the language. -
" -} - -issue objectsDontHaveWrappers { - summary - "Value is already an object" - description - "- If Records and Tuples are objects then
ToObjectshould be an identity function. - " -} - -issue tuplePrototypeEquality { - summary - "Tuple prototype equality" - description - "
- Records do not have a '[[prototype]]', it is null. Tuples on the other hand do have a '[[prototype]]', being lists they - can have many of the typical generic list operations (e.g. map, filter etc). - In fact Tuples have all the same non-mutating methods as Arrays. -
-- If Tuples are objects this means that the methods on their '[[prototype]]' will be linked to the realm (e.g. iframe) in which they were created. - As opposed to primitives, where property access triggers a
ToObjectin the current executing realm. - This would mean that two Tuples created in different realms will carry around different prototypes. - The choice here is that either two objects with different prototypes can still be === equal to each other. - Or Tuples from different realms are never equal even if their contents are equal. - " -}tweakable typeofArray0 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan0 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero0 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero0 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero0 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan0 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan0 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan0 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero0 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero0 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero0 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero0 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual0 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero0 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero0 is true - raise impossibleEqualityOfZeros when storeNegativeZero0 is false - } -} - -tweakable tupleNaNAreTripleEqual0 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero0 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero0 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple0 is "object" and zerosAreTripleEqual0 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero0 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan0 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual0 is true - } -} - -tweakable typeofTuple0 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox0 is "tuple" and typeofBoxConstructor0 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox0 is "object" and typeofBoxConstructor0 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple0 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple0 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple0 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows0 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple0 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows0 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple0 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor0 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance0 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor0 is "undefined" - } -} - -tweakable typeOfTupleWithBox0 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple0 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance0 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor0 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives0 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor0 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets0 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor0 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy0 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox0 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor0 is "undefined" - } -} -tweakable typeofArray1 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan1 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero1 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero1 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero1 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan1 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan1 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan1 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero1 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero1 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero1 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero1 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual1 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero1 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero1 is true - raise impossibleEqualityOfZeros when storeNegativeZero1 is false - } -} - -tweakable tupleNaNAreTripleEqual1 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero1 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero1 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple1 is "object" and zerosAreTripleEqual1 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero1 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan1 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual1 is true - } -} - -tweakable typeofTuple1 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox1 is "tuple" and typeofBoxConstructor1 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox1 is "object" and typeofBoxConstructor1 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple1 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple1 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple1 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows1 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple1 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows1 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple1 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor1 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance1 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor1 is "undefined" - } -} - -tweakable typeOfTupleWithBox1 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple1 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance1 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor1 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives1 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor1 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets1 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor1 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy1 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox1 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor1 is "undefined" - } -} -tweakable typeofArray2 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan2 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero2 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero2 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero2 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan2 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan2 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan2 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero2 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero2 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero2 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero2 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual2 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero2 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero2 is true - raise impossibleEqualityOfZeros when storeNegativeZero2 is false - } -} - -tweakable tupleNaNAreTripleEqual2 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero2 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero2 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple2 is "object" and zerosAreTripleEqual2 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero2 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan2 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual2 is true - } -} - -tweakable typeofTuple2 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox2 is "tuple" and typeofBoxConstructor2 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox2 is "object" and typeofBoxConstructor2 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple2 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple2 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple2 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows2 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple2 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows2 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple2 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor2 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance2 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor2 is "undefined" - } -} - -tweakable typeOfTupleWithBox2 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple2 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance2 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor2 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives2 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor2 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets2 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor2 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy2 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox2 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor2 is "undefined" - } -} -tweakable typeofArray3 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan3 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero3 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero3 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero3 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan3 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan3 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan3 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero3 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero3 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero3 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero3 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual3 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero3 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero3 is true - raise impossibleEqualityOfZeros when storeNegativeZero3 is false - } -} - -tweakable tupleNaNAreTripleEqual3 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero3 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero3 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple3 is "object" and zerosAreTripleEqual3 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero3 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan3 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual3 is true - } -} - -tweakable typeofTuple3 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox3 is "tuple" and typeofBoxConstructor3 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox3 is "object" and typeofBoxConstructor3 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple3 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple3 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple3 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows3 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple3 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows3 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple3 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor3 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance3 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor3 is "undefined" - } -} - -tweakable typeOfTupleWithBox3 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple3 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance3 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor3 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives3 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor3 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets3 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor3 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy3 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox3 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor3 is "undefined" - } -} -tweakable typeofArray4 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan4 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero4 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero4 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero4 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan4 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan4 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan4 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero4 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero4 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero4 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero4 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual4 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero4 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero4 is true - raise impossibleEqualityOfZeros when storeNegativeZero4 is false - } -} - -tweakable tupleNaNAreTripleEqual4 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero4 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero4 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple4 is "object" and zerosAreTripleEqual4 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero4 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan4 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual4 is true - } -} - -tweakable typeofTuple4 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox4 is "tuple" and typeofBoxConstructor4 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox4 is "object" and typeofBoxConstructor4 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple4 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple4 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple4 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows4 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple4 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows4 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple4 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor4 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance4 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor4 is "undefined" - } -} - -tweakable typeOfTupleWithBox4 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple4 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance4 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor4 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives4 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor4 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets4 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor4 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy4 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox4 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor4 is "undefined" - } -} -tweakable typeofArray5 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan5 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero5 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero5 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero5 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan5 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan5 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan5 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero5 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero5 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero5 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero5 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual5 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero5 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero5 is true - raise impossibleEqualityOfZeros when storeNegativeZero5 is false - } -} - -tweakable tupleNaNAreTripleEqual5 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero5 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero5 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple5 is "object" and zerosAreTripleEqual5 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero5 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan5 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual5 is true - } -} - -tweakable typeofTuple5 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox5 is "tuple" and typeofBoxConstructor5 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox5 is "object" and typeofBoxConstructor5 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple5 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple5 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple5 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows5 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple5 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows5 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple5 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor5 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance5 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor5 is "undefined" - } -} - -tweakable typeOfTupleWithBox5 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple5 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance5 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor5 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives5 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor5 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets5 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor5 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy5 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox5 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor5 is "undefined" - } -} -tweakable typeofArray6 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan6 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero6 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero6 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero6 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan6 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan6 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan6 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero6 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero6 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero6 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero6 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual6 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero6 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero6 is true - raise impossibleEqualityOfZeros when storeNegativeZero6 is false - } -} - -tweakable tupleNaNAreTripleEqual6 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero6 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero6 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple6 is "object" and zerosAreTripleEqual6 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero6 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan6 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual6 is true - } -} - -tweakable typeofTuple6 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox6 is "tuple" and typeofBoxConstructor6 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox6 is "object" and typeofBoxConstructor6 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple6 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple6 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple6 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows6 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple6 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows6 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple6 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor6 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance6 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor6 is "undefined" - } -} - -tweakable typeOfTupleWithBox6 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple6 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance6 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor6 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives6 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor6 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets6 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor6 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy6 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox6 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor6 is "undefined" - } -} -tweakable typeofArray7 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan7 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero7 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero7 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero7 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan7 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan7 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan7 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero7 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero7 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero7 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero7 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual7 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero7 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero7 is true - raise impossibleEqualityOfZeros when storeNegativeZero7 is false - } -} - -tweakable tupleNaNAreTripleEqual7 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero7 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero7 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple7 is "object" and zerosAreTripleEqual7 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero7 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan7 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual7 is true - } -} - -tweakable typeofTuple7 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox7 is "tuple" and typeofBoxConstructor7 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox7 is "object" and typeofBoxConstructor7 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple7 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple7 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple7 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows7 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple7 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows7 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple7 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor7 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance7 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor7 is "undefined" - } -} - -tweakable typeOfTupleWithBox7 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple7 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance7 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor7 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives7 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor7 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets7 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor7 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy7 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox7 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor7 is "undefined" - } -} -tweakable typeofArray8 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan8 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero8 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero8 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero8 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan8 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan8 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan8 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero8 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero8 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero8 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero8 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual8 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero8 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero8 is true - raise impossibleEqualityOfZeros when storeNegativeZero8 is false - } -} - -tweakable tupleNaNAreTripleEqual8 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero8 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero8 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple8 is "object" and zerosAreTripleEqual8 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero8 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan8 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual8 is true - } -} - -tweakable typeofTuple8 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox8 is "tuple" and typeofBoxConstructor8 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox8 is "object" and typeofBoxConstructor8 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple8 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple8 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple8 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows8 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple8 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows8 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple8 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor8 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance8 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor8 is "undefined" - } -} - -tweakable typeOfTupleWithBox8 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple8 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance8 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor8 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives8 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor8 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets8 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor8 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy8 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox8 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor8 is "undefined" - } -} -tweakable typeofArray9 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan9 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero9 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero9 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero9 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan9 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan9 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan9 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero9 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero9 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero9 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero9 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual9 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero9 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero9 is true - raise impossibleEqualityOfZeros when storeNegativeZero9 is false - } -} - -tweakable tupleNaNAreTripleEqual9 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero9 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero9 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple9 is "object" and zerosAreTripleEqual9 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero9 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan9 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual9 is true - } -} - -tweakable typeofTuple9 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox9 is "tuple" and typeofBoxConstructor9 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox9 is "object" and typeofBoxConstructor9 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple9 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple9 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple9 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows9 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple9 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows9 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple9 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor9 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance9 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor9 is "undefined" - } -} - -tweakable typeOfTupleWithBox9 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple9 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance9 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor9 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives9 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor9 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets9 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor9 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy9 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox9 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor9 is "undefined" - } -} -tweakable typeofArray10 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan10 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero10 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero10 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero10 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan10 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan10 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan10 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero10 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero10 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero10 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero10 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual10 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero10 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero10 is true - raise impossibleEqualityOfZeros when storeNegativeZero10 is false - } -} - -tweakable tupleNaNAreTripleEqual10 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero10 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero10 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple10 is "object" and zerosAreTripleEqual10 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero10 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan10 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual10 is true - } -} - -tweakable typeofTuple10 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox10 is "tuple" and typeofBoxConstructor10 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox10 is "object" and typeofBoxConstructor10 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple10 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple10 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple10 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows10 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple10 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows10 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple10 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor10 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance10 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor10 is "undefined" - } -} - -tweakable typeOfTupleWithBox10 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple10 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance10 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor10 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives10 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor10 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets10 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor10 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy10 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox10 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor10 is "undefined" - } -} -tweakable typeofArray11 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan11 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero11 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero11 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero11 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan11 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan11 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan11 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero11 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero11 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero11 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero11 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual11 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero11 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero11 is true - raise impossibleEqualityOfZeros when storeNegativeZero11 is false - } -} - -tweakable tupleNaNAreTripleEqual11 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero11 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero11 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple11 is "object" and zerosAreTripleEqual11 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero11 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan11 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual11 is true - } -} - -tweakable typeofTuple11 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox11 is "tuple" and typeofBoxConstructor11 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox11 is "object" and typeofBoxConstructor11 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple11 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple11 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple11 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows11 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple11 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows11 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple11 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor11 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance11 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor11 is "undefined" - } -} - -tweakable typeOfTupleWithBox11 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple11 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance11 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor11 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives11 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor11 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets11 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor11 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy11 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox11 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor11 is "undefined" - } -} -tweakable typeofArray12 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan12 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero12 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero12 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero12 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan12 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan12 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan12 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero12 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero12 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero12 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero12 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual12 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero12 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero12 is true - raise impossibleEqualityOfZeros when storeNegativeZero12 is false - } -} - -tweakable tupleNaNAreTripleEqual12 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero12 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero12 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple12 is "object" and zerosAreTripleEqual12 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero12 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan12 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual12 is true - } -} - -tweakable typeofTuple12 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox12 is "tuple" and typeofBoxConstructor12 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox12 is "object" and typeofBoxConstructor12 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple12 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple12 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple12 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows12 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple12 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows12 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple12 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor12 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance12 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor12 is "undefined" - } -} - -tweakable typeOfTupleWithBox12 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple12 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance12 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor12 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives12 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor12 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets12 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor12 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy12 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox12 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor12 is "undefined" - } -} -tweakable typeofArray13 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan13 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero13 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero13 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero13 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan13 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan13 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan13 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero13 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero13 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero13 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero13 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual13 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero13 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero13 is true - raise impossibleEqualityOfZeros when storeNegativeZero13 is false - } -} - -tweakable tupleNaNAreTripleEqual13 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero13 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero13 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple13 is "object" and zerosAreTripleEqual13 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero13 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan13 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual13 is true - } -} - -tweakable typeofTuple13 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox13 is "tuple" and typeofBoxConstructor13 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox13 is "object" and typeofBoxConstructor13 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple13 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple13 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple13 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows13 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple13 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows13 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple13 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor13 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance13 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor13 is "undefined" - } -} - -tweakable typeOfTupleWithBox13 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple13 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance13 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor13 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives13 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor13 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets13 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor13 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy13 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox13 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor13 is "undefined" - } -} -tweakable typeofArray14 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan14 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero14 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero14 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero14 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan14 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan14 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan14 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero14 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero14 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero14 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero14 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual14 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero14 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero14 is true - raise impossibleEqualityOfZeros when storeNegativeZero14 is false - } -} - -tweakable tupleNaNAreTripleEqual14 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero14 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero14 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple14 is "object" and zerosAreTripleEqual14 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero14 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan14 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual14 is true - } -} - -tweakable typeofTuple14 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox14 is "tuple" and typeofBoxConstructor14 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox14 is "object" and typeofBoxConstructor14 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple14 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple14 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple14 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows14 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple14 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows14 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple14 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor14 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance14 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor14 is "undefined" - } -} - -tweakable typeOfTupleWithBox14 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple14 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance14 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor14 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives14 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor14 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets14 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor14 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy14 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox14 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor14 is "undefined" - } -} -tweakable typeofArray15 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan15 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero15 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero15 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero15 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan15 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan15 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan15 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero15 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero15 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero15 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero15 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual15 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero15 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero15 is true - raise impossibleEqualityOfZeros when storeNegativeZero15 is false - } -} - -tweakable tupleNaNAreTripleEqual15 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero15 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero15 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple15 is "object" and zerosAreTripleEqual15 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero15 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan15 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual15 is true - } -} - -tweakable typeofTuple15 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox15 is "tuple" and typeofBoxConstructor15 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox15 is "object" and typeofBoxConstructor15 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple15 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple15 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple15 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows15 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple15 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows15 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple15 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor15 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance15 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor15 is "undefined" - } -} - -tweakable typeOfTupleWithBox15 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple15 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance15 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor15 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives15 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor15 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets15 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor15 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy15 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox15 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor15 is "undefined" - } -} -tweakable typeofArray16 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan16 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero16 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero16 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero16 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan16 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan16 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan16 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero16 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero16 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero16 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero16 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual16 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero16 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero16 is true - raise impossibleEqualityOfZeros when storeNegativeZero16 is false - } -} - -tweakable tupleNaNAreTripleEqual16 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero16 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero16 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple16 is "object" and zerosAreTripleEqual16 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero16 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan16 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual16 is true - } -} - -tweakable typeofTuple16 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox16 is "tuple" and typeofBoxConstructor16 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox16 is "object" and typeofBoxConstructor16 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple16 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple16 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple16 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows16 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple16 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows16 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple16 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor16 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance16 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor16 is "undefined" - } -} - -tweakable typeOfTupleWithBox16 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple16 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance16 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor16 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives16 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor16 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets16 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor16 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy16 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox16 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor16 is "undefined" - } -} -tweakable typeofArray17 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan17 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero17 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero17 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero17 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan17 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan17 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan17 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero17 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero17 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero17 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero17 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual17 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero17 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero17 is true - raise impossibleEqualityOfZeros when storeNegativeZero17 is false - } -} - -tweakable tupleNaNAreTripleEqual17 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero17 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero17 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple17 is "object" and zerosAreTripleEqual17 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero17 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan17 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual17 is true - } -} - -tweakable typeofTuple17 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox17 is "tuple" and typeofBoxConstructor17 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox17 is "object" and typeofBoxConstructor17 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple17 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple17 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple17 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows17 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple17 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows17 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple17 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor17 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance17 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor17 is "undefined" - } -} - -tweakable typeOfTupleWithBox17 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple17 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance17 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor17 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives17 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor17 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets17 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor17 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy17 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox17 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor17 is "undefined" - } -} -tweakable typeofArray18 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan18 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero18 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero18 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero18 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan18 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan18 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan18 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero18 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero18 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero18 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero18 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual18 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero18 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero18 is true - raise impossibleEqualityOfZeros when storeNegativeZero18 is false - } -} - -tweakable tupleNaNAreTripleEqual18 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero18 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero18 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple18 is "object" and zerosAreTripleEqual18 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero18 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan18 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual18 is true - } -} - -tweakable typeofTuple18 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox18 is "tuple" and typeofBoxConstructor18 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox18 is "object" and typeofBoxConstructor18 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple18 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple18 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple18 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows18 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple18 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows18 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple18 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor18 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance18 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor18 is "undefined" - } -} - -tweakable typeOfTupleWithBox18 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple18 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance18 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor18 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives18 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor18 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets18 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor18 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy18 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox18 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor18 is "undefined" - } -} -tweakable typeofArray19 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan19 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero19 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero19 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero19 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan19 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan19 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan19 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero19 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero19 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero19 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero19 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual19 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero19 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero19 is true - raise impossibleEqualityOfZeros when storeNegativeZero19 is false - } -} - -tweakable tupleNaNAreTripleEqual19 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero19 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero19 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple19 is "object" and zerosAreTripleEqual19 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero19 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan19 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual19 is true - } -} - -tweakable typeofTuple19 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox19 is "tuple" and typeofBoxConstructor19 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox19 is "object" and typeofBoxConstructor19 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple19 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple19 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple19 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows19 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple19 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows19 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple19 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor19 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance19 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor19 is "undefined" - } -} - -tweakable typeOfTupleWithBox19 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple19 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance19 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor19 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives19 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor19 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets19 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor19 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy19 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox19 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor19 is "undefined" - } -} -tweakable typeofArray20 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan20 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero20 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero20 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero20 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan20 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan20 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan20 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero20 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero20 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero20 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero20 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual20 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero20 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero20 is true - raise impossibleEqualityOfZeros when storeNegativeZero20 is false - } -} - -tweakable tupleNaNAreTripleEqual20 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero20 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero20 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple20 is "object" and zerosAreTripleEqual20 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero20 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan20 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual20 is true - } -} - -tweakable typeofTuple20 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox20 is "tuple" and typeofBoxConstructor20 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox20 is "object" and typeofBoxConstructor20 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple20 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple20 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple20 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows20 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple20 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows20 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple20 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor20 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance20 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor20 is "undefined" - } -} - -tweakable typeOfTupleWithBox20 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple20 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance20 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor20 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives20 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor20 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets20 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor20 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy20 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox20 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor20 is "undefined" - } -} -tweakable typeofArray21 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan21 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero21 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero21 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero21 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan21 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan21 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan21 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero21 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero21 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero21 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero21 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual21 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero21 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero21 is true - raise impossibleEqualityOfZeros when storeNegativeZero21 is false - } -} - -tweakable tupleNaNAreTripleEqual21 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero21 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero21 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple21 is "object" and zerosAreTripleEqual21 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero21 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan21 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual21 is true - } -} - -tweakable typeofTuple21 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox21 is "tuple" and typeofBoxConstructor21 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox21 is "object" and typeofBoxConstructor21 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple21 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple21 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple21 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows21 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple21 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows21 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple21 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor21 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance21 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor21 is "undefined" - } -} - -tweakable typeOfTupleWithBox21 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple21 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance21 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor21 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives21 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor21 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets21 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor21 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy21 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox21 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor21 is "undefined" - } -} -tweakable typeofArray22 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan22 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero22 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero22 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero22 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan22 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan22 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan22 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero22 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero22 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero22 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero22 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual22 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero22 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero22 is true - raise impossibleEqualityOfZeros when storeNegativeZero22 is false - } -} - -tweakable tupleNaNAreTripleEqual22 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero22 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero22 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple22 is "object" and zerosAreTripleEqual22 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero22 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan22 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual22 is true - } -} - -tweakable typeofTuple22 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox22 is "tuple" and typeofBoxConstructor22 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox22 is "object" and typeofBoxConstructor22 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple22 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple22 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple22 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows22 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple22 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows22 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple22 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor22 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance22 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor22 is "undefined" - } -} - -tweakable typeOfTupleWithBox22 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple22 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance22 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor22 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives22 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor22 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets22 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor22 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy22 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox22 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor22 is "undefined" - } -} -tweakable typeofArray23 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan23 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero23 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero23 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero23 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan23 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan23 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan23 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero23 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero23 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero23 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero23 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual23 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero23 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero23 is true - raise impossibleEqualityOfZeros when storeNegativeZero23 is false - } -} - -tweakable tupleNaNAreTripleEqual23 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero23 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero23 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple23 is "object" and zerosAreTripleEqual23 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero23 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan23 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual23 is true - } -} - -tweakable typeofTuple23 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox23 is "tuple" and typeofBoxConstructor23 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox23 is "object" and typeofBoxConstructor23 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple23 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple23 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple23 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows23 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple23 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows23 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple23 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor23 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance23 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor23 is "undefined" - } -} - -tweakable typeOfTupleWithBox23 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple23 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance23 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor23 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives23 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor23 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets23 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor23 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy23 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox23 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor23 is "undefined" - } -} -tweakable typeofArray24 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan24 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero24 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero24 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero24 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan24 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan24 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan24 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero24 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero24 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero24 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero24 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual24 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero24 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero24 is true - raise impossibleEqualityOfZeros when storeNegativeZero24 is false - } -} - -tweakable tupleNaNAreTripleEqual24 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero24 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero24 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple24 is "object" and zerosAreTripleEqual24 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero24 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan24 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual24 is true - } -} - -tweakable typeofTuple24 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox24 is "tuple" and typeofBoxConstructor24 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox24 is "object" and typeofBoxConstructor24 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple24 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple24 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple24 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows24 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple24 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows24 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple24 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor24 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance24 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor24 is "undefined" - } -} - -tweakable typeOfTupleWithBox24 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple24 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance24 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor24 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives24 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor24 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets24 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor24 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy24 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox24 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor24 is "undefined" - } -} -tweakable typeofArray25 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan25 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero25 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero25 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero25 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan25 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan25 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan25 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero25 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero25 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero25 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero25 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual25 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero25 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero25 is true - raise impossibleEqualityOfZeros when storeNegativeZero25 is false - } -} - -tweakable tupleNaNAreTripleEqual25 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero25 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero25 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple25 is "object" and zerosAreTripleEqual25 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero25 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan25 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual25 is true - } -} - -tweakable typeofTuple25 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox25 is "tuple" and typeofBoxConstructor25 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox25 is "object" and typeofBoxConstructor25 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple25 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple25 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple25 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows25 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple25 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows25 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple25 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor25 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance25 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor25 is "undefined" - } -} - -tweakable typeOfTupleWithBox25 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple25 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance25 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor25 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives25 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor25 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets25 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor25 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy25 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox25 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor25 is "undefined" - } -} -tweakable typeofArray26 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan26 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero26 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero26 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero26 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan26 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan26 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan26 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero26 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero26 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero26 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero26 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual26 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero26 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero26 is true - raise impossibleEqualityOfZeros when storeNegativeZero26 is false - } -} - -tweakable tupleNaNAreTripleEqual26 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero26 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero26 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple26 is "object" and zerosAreTripleEqual26 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero26 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan26 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual26 is true - } -} - -tweakable typeofTuple26 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox26 is "tuple" and typeofBoxConstructor26 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox26 is "object" and typeofBoxConstructor26 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple26 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple26 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple26 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows26 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple26 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows26 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple26 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor26 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance26 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor26 is "undefined" - } -} - -tweakable typeOfTupleWithBox26 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple26 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance26 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor26 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives26 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor26 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets26 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor26 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy26 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox26 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor26 is "undefined" - } -} -tweakable typeofArray27 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan27 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero27 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero27 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero27 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan27 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan27 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan27 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero27 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero27 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero27 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero27 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual27 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero27 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero27 is true - raise impossibleEqualityOfZeros when storeNegativeZero27 is false - } -} - -tweakable tupleNaNAreTripleEqual27 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero27 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero27 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple27 is "object" and zerosAreTripleEqual27 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero27 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan27 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual27 is true - } -} - -tweakable typeofTuple27 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox27 is "tuple" and typeofBoxConstructor27 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox27 is "object" and typeofBoxConstructor27 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple27 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple27 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple27 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows27 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple27 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows27 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple27 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor27 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance27 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor27 is "undefined" - } -} - -tweakable typeOfTupleWithBox27 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple27 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance27 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor27 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives27 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor27 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets27 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor27 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy27 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox27 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor27 is "undefined" - } -} -tweakable typeofArray28 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan28 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero28 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero28 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero28 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan28 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan28 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan28 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero28 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero28 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero28 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero28 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual28 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero28 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero28 is true - raise impossibleEqualityOfZeros when storeNegativeZero28 is false - } -} - -tweakable tupleNaNAreTripleEqual28 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero28 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero28 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple28 is "object" and zerosAreTripleEqual28 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero28 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan28 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual28 is true - } -} - -tweakable typeofTuple28 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox28 is "tuple" and typeofBoxConstructor28 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox28 is "object" and typeofBoxConstructor28 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple28 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple28 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple28 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows28 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple28 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows28 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple28 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor28 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance28 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor28 is "undefined" - } -} - -tweakable typeOfTupleWithBox28 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple28 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance28 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor28 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives28 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor28 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets28 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor28 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy28 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox28 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor28 is "undefined" - } -} -tweakable typeofArray29 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan29 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero29 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero29 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero29 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan29 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan29 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan29 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero29 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero29 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero29 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero29 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual29 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero29 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero29 is true - raise impossibleEqualityOfZeros when storeNegativeZero29 is false - } -} - -tweakable tupleNaNAreTripleEqual29 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero29 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero29 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple29 is "object" and zerosAreTripleEqual29 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero29 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan29 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual29 is true - } -} - -tweakable typeofTuple29 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox29 is "tuple" and typeofBoxConstructor29 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox29 is "object" and typeofBoxConstructor29 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple29 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple29 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple29 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows29 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple29 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows29 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple29 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor29 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance29 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor29 is "undefined" - } -} - -tweakable typeOfTupleWithBox29 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple29 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance29 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor29 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives29 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor29 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets29 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor29 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy29 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox29 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor29 is "undefined" - } -} -tweakable typeofArray30 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan30 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero30 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero30 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero30 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan30 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan30 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan30 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero30 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero30 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero30 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero30 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual30 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero30 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero30 is true - raise impossibleEqualityOfZeros when storeNegativeZero30 is false - } -} - -tweakable tupleNaNAreTripleEqual30 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero30 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero30 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple30 is "object" and zerosAreTripleEqual30 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero30 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan30 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual30 is true - } -} - -tweakable typeofTuple30 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox30 is "tuple" and typeofBoxConstructor30 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox30 is "object" and typeofBoxConstructor30 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple30 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple30 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple30 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows30 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple30 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows30 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple30 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor30 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance30 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor30 is "undefined" - } -} - -tweakable typeOfTupleWithBox30 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple30 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance30 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor30 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives30 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor30 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets30 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor30 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy30 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox30 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor30 is "undefined" - } -} -tweakable typeofArray31 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan31 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero31 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero31 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero31 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan31 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan31 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan31 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero31 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero31 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero31 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero31 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual31 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero31 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero31 is true - raise impossibleEqualityOfZeros when storeNegativeZero31 is false - } -} - -tweakable tupleNaNAreTripleEqual31 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero31 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero31 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple31 is "object" and zerosAreTripleEqual31 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero31 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan31 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual31 is true - } -} - -tweakable typeofTuple31 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox31 is "tuple" and typeofBoxConstructor31 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox31 is "object" and typeofBoxConstructor31 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple31 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple31 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple31 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows31 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple31 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows31 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple31 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor31 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance31 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor31 is "undefined" - } -} - -tweakable typeOfTupleWithBox31 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple31 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance31 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor31 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives31 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor31 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets31 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor31 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy31 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox31 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor31 is "undefined" - } -} -tweakable typeofArray32 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan32 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero32 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero32 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero32 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan32 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan32 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan32 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero32 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero32 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero32 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero32 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual32 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero32 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero32 is true - raise impossibleEqualityOfZeros when storeNegativeZero32 is false - } -} - -tweakable tupleNaNAreTripleEqual32 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero32 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero32 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple32 is "object" and zerosAreTripleEqual32 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero32 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan32 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual32 is true - } -} - -tweakable typeofTuple32 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox32 is "tuple" and typeofBoxConstructor32 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox32 is "object" and typeofBoxConstructor32 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple32 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple32 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple32 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows32 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple32 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows32 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple32 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor32 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance32 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor32 is "undefined" - } -} - -tweakable typeOfTupleWithBox32 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple32 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance32 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor32 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives32 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor32 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets32 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor32 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy32 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox32 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor32 is "undefined" - } -} -tweakable typeofArray33 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan33 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero33 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero33 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero33 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan33 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan33 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan33 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero33 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero33 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero33 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero33 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual33 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero33 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero33 is true - raise impossibleEqualityOfZeros when storeNegativeZero33 is false - } -} - -tweakable tupleNaNAreTripleEqual33 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero33 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero33 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple33 is "object" and zerosAreTripleEqual33 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero33 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan33 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual33 is true - } -} - -tweakable typeofTuple33 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox33 is "tuple" and typeofBoxConstructor33 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox33 is "object" and typeofBoxConstructor33 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple33 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple33 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple33 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows33 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple33 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows33 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple33 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor33 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance33 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor33 is "undefined" - } -} - -tweakable typeOfTupleWithBox33 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple33 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance33 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor33 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives33 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor33 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets33 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor33 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy33 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox33 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor33 is "undefined" - } -} -tweakable typeofArray34 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan34 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero34 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero34 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero34 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan34 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan34 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan34 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero34 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero34 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero34 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero34 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual34 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero34 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero34 is true - raise impossibleEqualityOfZeros when storeNegativeZero34 is false - } -} - -tweakable tupleNaNAreTripleEqual34 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero34 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero34 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple34 is "object" and zerosAreTripleEqual34 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero34 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan34 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual34 is true - } -} - -tweakable typeofTuple34 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox34 is "tuple" and typeofBoxConstructor34 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox34 is "object" and typeofBoxConstructor34 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple34 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple34 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple34 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows34 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple34 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows34 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple34 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor34 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance34 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor34 is "undefined" - } -} - -tweakable typeOfTupleWithBox34 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple34 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance34 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor34 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives34 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor34 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets34 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor34 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy34 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox34 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor34 is "undefined" - } -} -tweakable typeofArray35 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan35 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero35 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero35 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero35 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan35 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan35 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan35 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero35 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero35 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero35 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero35 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual35 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero35 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero35 is true - raise impossibleEqualityOfZeros when storeNegativeZero35 is false - } -} - -tweakable tupleNaNAreTripleEqual35 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero35 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero35 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple35 is "object" and zerosAreTripleEqual35 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero35 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan35 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual35 is true - } -} - -tweakable typeofTuple35 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox35 is "tuple" and typeofBoxConstructor35 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox35 is "object" and typeofBoxConstructor35 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple35 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple35 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple35 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows35 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple35 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows35 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple35 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor35 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance35 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor35 is "undefined" - } -} - -tweakable typeOfTupleWithBox35 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple35 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance35 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor35 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives35 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor35 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets35 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor35 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy35 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox35 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor35 is "undefined" - } -} -tweakable typeofArray36 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan36 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero36 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero36 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero36 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan36 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan36 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan36 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero36 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero36 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero36 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero36 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual36 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero36 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero36 is true - raise impossibleEqualityOfZeros when storeNegativeZero36 is false - } -} - -tweakable tupleNaNAreTripleEqual36 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero36 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero36 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple36 is "object" and zerosAreTripleEqual36 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero36 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan36 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual36 is true - } -} - -tweakable typeofTuple36 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox36 is "tuple" and typeofBoxConstructor36 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox36 is "object" and typeofBoxConstructor36 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple36 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple36 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple36 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows36 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple36 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows36 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple36 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor36 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance36 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor36 is "undefined" - } -} - -tweakable typeOfTupleWithBox36 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple36 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance36 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor36 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives36 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor36 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets36 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor36 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy36 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox36 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor36 is "undefined" - } -} -tweakable typeofArray37 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan37 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero37 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero37 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero37 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan37 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan37 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan37 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero37 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero37 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero37 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero37 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual37 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero37 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero37 is true - raise impossibleEqualityOfZeros when storeNegativeZero37 is false - } -} - -tweakable tupleNaNAreTripleEqual37 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero37 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero37 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple37 is "object" and zerosAreTripleEqual37 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero37 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan37 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual37 is true - } -} - -tweakable typeofTuple37 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox37 is "tuple" and typeofBoxConstructor37 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox37 is "object" and typeofBoxConstructor37 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple37 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple37 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple37 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows37 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple37 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows37 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple37 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor37 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance37 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor37 is "undefined" - } -} - -tweakable typeOfTupleWithBox37 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple37 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance37 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor37 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives37 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor37 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets37 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor37 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy37 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox37 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor37 is "undefined" - } -} -tweakable typeofArray38 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan38 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero38 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero38 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero38 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan38 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan38 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan38 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero38 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero38 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero38 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero38 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual38 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero38 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero38 is true - raise impossibleEqualityOfZeros when storeNegativeZero38 is false - } -} - -tweakable tupleNaNAreTripleEqual38 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero38 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero38 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple38 is "object" and zerosAreTripleEqual38 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero38 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan38 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual38 is true - } -} - -tweakable typeofTuple38 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox38 is "tuple" and typeofBoxConstructor38 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox38 is "object" and typeofBoxConstructor38 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple38 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple38 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple38 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows38 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple38 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows38 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple38 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor38 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance38 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor38 is "undefined" - } -} - -tweakable typeOfTupleWithBox38 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple38 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance38 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor38 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives38 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor38 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets38 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor38 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy38 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox38 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor38 is "undefined" - } -} -tweakable typeofArray39 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan39 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero39 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero39 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero39 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan39 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan39 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan39 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero39 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero39 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero39 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero39 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual39 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero39 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero39 is true - raise impossibleEqualityOfZeros when storeNegativeZero39 is false - } -} - -tweakable tupleNaNAreTripleEqual39 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero39 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero39 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple39 is "object" and zerosAreTripleEqual39 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero39 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan39 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual39 is true - } -} - -tweakable typeofTuple39 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox39 is "tuple" and typeofBoxConstructor39 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox39 is "object" and typeofBoxConstructor39 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple39 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple39 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple39 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows39 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple39 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows39 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple39 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor39 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance39 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor39 is "undefined" - } -} - -tweakable typeOfTupleWithBox39 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple39 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance39 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor39 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives39 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor39 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets39 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor39 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy39 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox39 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor39 is "undefined" - } -} -tweakable typeofArray40 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan40 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero40 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero40 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero40 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan40 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan40 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan40 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero40 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero40 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero40 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero40 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual40 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero40 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero40 is true - raise impossibleEqualityOfZeros when storeNegativeZero40 is false - } -} - -tweakable tupleNaNAreTripleEqual40 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero40 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero40 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple40 is "object" and zerosAreTripleEqual40 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero40 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan40 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual40 is true - } -} - -tweakable typeofTuple40 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox40 is "tuple" and typeofBoxConstructor40 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox40 is "object" and typeofBoxConstructor40 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple40 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple40 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple40 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows40 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple40 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows40 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple40 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor40 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance40 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor40 is "undefined" - } -} - -tweakable typeOfTupleWithBox40 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple40 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance40 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor40 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives40 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor40 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets40 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor40 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy40 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox40 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor40 is "undefined" - } -} -tweakable typeofArray41 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan41 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero41 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero41 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero41 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan41 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan41 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan41 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero41 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero41 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero41 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero41 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual41 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero41 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero41 is true - raise impossibleEqualityOfZeros when storeNegativeZero41 is false - } -} - -tweakable tupleNaNAreTripleEqual41 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero41 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero41 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple41 is "object" and zerosAreTripleEqual41 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero41 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan41 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual41 is true - } -} - -tweakable typeofTuple41 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox41 is "tuple" and typeofBoxConstructor41 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox41 is "object" and typeofBoxConstructor41 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple41 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple41 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple41 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows41 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple41 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows41 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple41 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor41 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance41 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor41 is "undefined" - } -} - -tweakable typeOfTupleWithBox41 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple41 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance41 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor41 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives41 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor41 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets41 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor41 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy41 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox41 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor41 is "undefined" - } -} -tweakable typeofArray42 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan42 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero42 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero42 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero42 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan42 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan42 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan42 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero42 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero42 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero42 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero42 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual42 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero42 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero42 is true - raise impossibleEqualityOfZeros when storeNegativeZero42 is false - } -} - -tweakable tupleNaNAreTripleEqual42 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero42 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero42 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple42 is "object" and zerosAreTripleEqual42 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero42 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan42 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual42 is true - } -} - -tweakable typeofTuple42 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox42 is "tuple" and typeofBoxConstructor42 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox42 is "object" and typeofBoxConstructor42 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple42 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple42 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple42 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows42 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple42 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows42 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple42 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor42 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance42 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor42 is "undefined" - } -} - -tweakable typeOfTupleWithBox42 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple42 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance42 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor42 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives42 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor42 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets42 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor42 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy42 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox42 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor42 is "undefined" - } -} -tweakable typeofArray43 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan43 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero43 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero43 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero43 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan43 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan43 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan43 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero43 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero43 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero43 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero43 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual43 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero43 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero43 is true - raise impossibleEqualityOfZeros when storeNegativeZero43 is false - } -} - -tweakable tupleNaNAreTripleEqual43 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero43 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero43 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple43 is "object" and zerosAreTripleEqual43 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero43 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan43 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual43 is true - } -} - -tweakable typeofTuple43 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox43 is "tuple" and typeofBoxConstructor43 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox43 is "object" and typeofBoxConstructor43 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple43 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple43 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple43 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows43 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple43 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows43 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple43 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor43 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance43 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor43 is "undefined" - } -} - -tweakable typeOfTupleWithBox43 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple43 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance43 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor43 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives43 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor43 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets43 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor43 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy43 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox43 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor43 is "undefined" - } -} -tweakable typeofArray44 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan44 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero44 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero44 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero44 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan44 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan44 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan44 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero44 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero44 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero44 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero44 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual44 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero44 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero44 is true - raise impossibleEqualityOfZeros when storeNegativeZero44 is false - } -} - -tweakable tupleNaNAreTripleEqual44 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero44 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero44 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple44 is "object" and zerosAreTripleEqual44 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero44 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan44 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual44 is true - } -} - -tweakable typeofTuple44 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox44 is "tuple" and typeofBoxConstructor44 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox44 is "object" and typeofBoxConstructor44 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple44 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple44 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple44 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows44 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple44 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows44 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple44 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor44 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance44 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor44 is "undefined" - } -} - -tweakable typeOfTupleWithBox44 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple44 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance44 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor44 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives44 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor44 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets44 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor44 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy44 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox44 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor44 is "undefined" - } -} -tweakable typeofArray45 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan45 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero45 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero45 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero45 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan45 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan45 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan45 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero45 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero45 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero45 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero45 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual45 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero45 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero45 is true - raise impossibleEqualityOfZeros when storeNegativeZero45 is false - } -} - -tweakable tupleNaNAreTripleEqual45 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero45 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero45 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple45 is "object" and zerosAreTripleEqual45 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero45 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan45 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual45 is true - } -} - -tweakable typeofTuple45 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox45 is "tuple" and typeofBoxConstructor45 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox45 is "object" and typeofBoxConstructor45 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple45 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple45 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple45 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows45 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple45 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows45 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple45 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor45 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance45 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor45 is "undefined" - } -} - -tweakable typeOfTupleWithBox45 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple45 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance45 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor45 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives45 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor45 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets45 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor45 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy45 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox45 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor45 is "undefined" - } -} -tweakable typeofArray46 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan46 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero46 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero46 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero46 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan46 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan46 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan46 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero46 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero46 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero46 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero46 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual46 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero46 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero46 is true - raise impossibleEqualityOfZeros when storeNegativeZero46 is false - } -} - -tweakable tupleNaNAreTripleEqual46 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero46 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero46 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple46 is "object" and zerosAreTripleEqual46 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero46 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan46 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual46 is true - } -} - -tweakable typeofTuple46 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox46 is "tuple" and typeofBoxConstructor46 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox46 is "object" and typeofBoxConstructor46 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple46 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple46 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple46 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows46 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple46 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows46 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple46 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor46 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance46 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor46 is "undefined" - } -} - -tweakable typeOfTupleWithBox46 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple46 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance46 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor46 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives46 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor46 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets46 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor46 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy46 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox46 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor46 is "undefined" - } -} -tweakable typeofArray47 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan47 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero47 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero47 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero47 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan47 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan47 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan47 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero47 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero47 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero47 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero47 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual47 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero47 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero47 is true - raise impossibleEqualityOfZeros when storeNegativeZero47 is false - } -} - -tweakable tupleNaNAreTripleEqual47 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero47 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero47 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple47 is "object" and zerosAreTripleEqual47 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero47 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan47 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual47 is true - } -} - -tweakable typeofTuple47 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox47 is "tuple" and typeofBoxConstructor47 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox47 is "object" and typeofBoxConstructor47 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple47 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple47 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple47 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows47 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple47 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows47 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple47 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor47 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance47 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor47 is "undefined" - } -} - -tweakable typeOfTupleWithBox47 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple47 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance47 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor47 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives47 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor47 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets47 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor47 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy47 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox47 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor47 is "undefined" - } -} -tweakable typeofArray48 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan48 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero48 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero48 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero48 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan48 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan48 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan48 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero48 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero48 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero48 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero48 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual48 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero48 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero48 is true - raise impossibleEqualityOfZeros when storeNegativeZero48 is false - } -} - -tweakable tupleNaNAreTripleEqual48 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero48 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero48 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple48 is "object" and zerosAreTripleEqual48 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero48 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan48 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual48 is true - } -} - -tweakable typeofTuple48 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox48 is "tuple" and typeofBoxConstructor48 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox48 is "object" and typeofBoxConstructor48 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple48 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple48 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple48 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows48 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple48 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows48 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple48 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor48 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance48 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor48 is "undefined" - } -} - -tweakable typeOfTupleWithBox48 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple48 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance48 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor48 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives48 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor48 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets48 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor48 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy48 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox48 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor48 is "undefined" - } -} -tweakable typeofArray49 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan49 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero49 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero49 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero49 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan49 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan49 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan49 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero49 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero49 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero49 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero49 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual49 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero49 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero49 is true - raise impossibleEqualityOfZeros when storeNegativeZero49 is false - } -} - -tweakable tupleNaNAreTripleEqual49 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero49 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero49 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple49 is "object" and zerosAreTripleEqual49 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero49 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan49 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual49 is true - } -} - -tweakable typeofTuple49 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox49 is "tuple" and typeofBoxConstructor49 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox49 is "object" and typeofBoxConstructor49 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple49 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple49 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple49 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows49 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple49 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows49 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple49 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor49 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance49 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor49 is "undefined" - } -} - -tweakable typeOfTupleWithBox49 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple49 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance49 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor49 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives49 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor49 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets49 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor49 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy49 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox49 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor49 is "undefined" - } -} -tweakable typeofArray50 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan50 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero50 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero50 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero50 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan50 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan50 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan50 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero50 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero50 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero50 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero50 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual50 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero50 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero50 is true - raise impossibleEqualityOfZeros when storeNegativeZero50 is false - } -} - -tweakable tupleNaNAreTripleEqual50 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero50 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero50 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple50 is "object" and zerosAreTripleEqual50 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero50 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan50 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual50 is true - } -} - -tweakable typeofTuple50 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox50 is "tuple" and typeofBoxConstructor50 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox50 is "object" and typeofBoxConstructor50 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple50 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple50 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple50 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows50 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple50 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows50 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple50 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor50 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance50 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor50 is "undefined" - } -} - -tweakable typeOfTupleWithBox50 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple50 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance50 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor50 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives50 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor50 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets50 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor50 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy50 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox50 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor50 is "undefined" - } -} -tweakable typeofArray51 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan51 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero51 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero51 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero51 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan51 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan51 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan51 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero51 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero51 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero51 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero51 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual51 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero51 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero51 is true - raise impossibleEqualityOfZeros when storeNegativeZero51 is false - } -} - -tweakable tupleNaNAreTripleEqual51 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero51 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero51 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple51 is "object" and zerosAreTripleEqual51 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero51 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan51 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual51 is true - } -} - -tweakable typeofTuple51 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox51 is "tuple" and typeofBoxConstructor51 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox51 is "object" and typeofBoxConstructor51 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple51 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple51 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple51 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows51 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple51 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows51 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple51 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor51 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance51 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor51 is "undefined" - } -} - -tweakable typeOfTupleWithBox51 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple51 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance51 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor51 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives51 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor51 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets51 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor51 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy51 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox51 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor51 is "undefined" - } -} -tweakable typeofArray52 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan52 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero52 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero52 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero52 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan52 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan52 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan52 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero52 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero52 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero52 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero52 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual52 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero52 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero52 is true - raise impossibleEqualityOfZeros when storeNegativeZero52 is false - } -} - -tweakable tupleNaNAreTripleEqual52 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero52 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero52 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple52 is "object" and zerosAreTripleEqual52 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero52 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan52 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual52 is true - } -} - -tweakable typeofTuple52 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox52 is "tuple" and typeofBoxConstructor52 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox52 is "object" and typeofBoxConstructor52 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple52 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple52 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple52 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows52 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple52 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows52 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple52 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor52 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance52 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor52 is "undefined" - } -} - -tweakable typeOfTupleWithBox52 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple52 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance52 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor52 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives52 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor52 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets52 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor52 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy52 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox52 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor52 is "undefined" - } -} -tweakable typeofArray53 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan53 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero53 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero53 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero53 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan53 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan53 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan53 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero53 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero53 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero53 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero53 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual53 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero53 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero53 is true - raise impossibleEqualityOfZeros when storeNegativeZero53 is false - } -} - -tweakable tupleNaNAreTripleEqual53 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero53 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero53 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple53 is "object" and zerosAreTripleEqual53 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero53 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan53 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual53 is true - } -} - -tweakable typeofTuple53 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox53 is "tuple" and typeofBoxConstructor53 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox53 is "object" and typeofBoxConstructor53 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple53 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple53 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple53 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows53 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple53 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows53 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple53 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor53 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance53 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor53 is "undefined" - } -} - -tweakable typeOfTupleWithBox53 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple53 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance53 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor53 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives53 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor53 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets53 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor53 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy53 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox53 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor53 is "undefined" - } -} -tweakable typeofArray54 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan54 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero54 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero54 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero54 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan54 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan54 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan54 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero54 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero54 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero54 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero54 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual54 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero54 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero54 is true - raise impossibleEqualityOfZeros when storeNegativeZero54 is false - } -} - -tweakable tupleNaNAreTripleEqual54 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero54 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero54 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple54 is "object" and zerosAreTripleEqual54 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero54 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan54 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual54 is true - } -} - -tweakable typeofTuple54 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox54 is "tuple" and typeofBoxConstructor54 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox54 is "object" and typeofBoxConstructor54 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple54 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple54 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple54 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows54 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple54 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows54 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple54 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor54 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance54 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor54 is "undefined" - } -} - -tweakable typeOfTupleWithBox54 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple54 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance54 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor54 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives54 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor54 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets54 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor54 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy54 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox54 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor54 is "undefined" - } -} -tweakable typeofArray55 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan55 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero55 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero55 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero55 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan55 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan55 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan55 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero55 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero55 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero55 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero55 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual55 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero55 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero55 is true - raise impossibleEqualityOfZeros when storeNegativeZero55 is false - } -} - -tweakable tupleNaNAreTripleEqual55 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero55 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero55 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple55 is "object" and zerosAreTripleEqual55 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero55 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan55 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual55 is true - } -} - -tweakable typeofTuple55 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox55 is "tuple" and typeofBoxConstructor55 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox55 is "object" and typeofBoxConstructor55 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple55 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple55 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple55 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows55 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple55 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows55 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple55 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor55 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance55 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor55 is "undefined" - } -} - -tweakable typeOfTupleWithBox55 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple55 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance55 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor55 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives55 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor55 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets55 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor55 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy55 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox55 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor55 is "undefined" - } -} -tweakable typeofArray56 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan56 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero56 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero56 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero56 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan56 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan56 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan56 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero56 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero56 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero56 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero56 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual56 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero56 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero56 is true - raise impossibleEqualityOfZeros when storeNegativeZero56 is false - } -} - -tweakable tupleNaNAreTripleEqual56 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero56 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero56 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple56 is "object" and zerosAreTripleEqual56 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero56 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan56 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual56 is true - } -} - -tweakable typeofTuple56 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox56 is "tuple" and typeofBoxConstructor56 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox56 is "object" and typeofBoxConstructor56 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple56 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple56 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple56 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows56 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple56 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows56 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple56 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor56 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance56 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor56 is "undefined" - } -} - -tweakable typeOfTupleWithBox56 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple56 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance56 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor56 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives56 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor56 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets56 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor56 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy56 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox56 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor56 is "undefined" - } -} -tweakable typeofArray57 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan57 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero57 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero57 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero57 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan57 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan57 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan57 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero57 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero57 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero57 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero57 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual57 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero57 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero57 is true - raise impossibleEqualityOfZeros when storeNegativeZero57 is false - } -} - -tweakable tupleNaNAreTripleEqual57 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero57 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero57 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple57 is "object" and zerosAreTripleEqual57 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero57 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan57 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual57 is true - } -} - -tweakable typeofTuple57 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox57 is "tuple" and typeofBoxConstructor57 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox57 is "object" and typeofBoxConstructor57 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple57 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple57 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple57 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows57 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple57 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows57 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple57 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor57 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance57 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor57 is "undefined" - } -} - -tweakable typeOfTupleWithBox57 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple57 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance57 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor57 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives57 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor57 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets57 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor57 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy57 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox57 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor57 is "undefined" - } -} -tweakable typeofArray58 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan58 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero58 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero58 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero58 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan58 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan58 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan58 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero58 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero58 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero58 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero58 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual58 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero58 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero58 is true - raise impossibleEqualityOfZeros when storeNegativeZero58 is false - } -} - -tweakable tupleNaNAreTripleEqual58 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero58 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero58 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple58 is "object" and zerosAreTripleEqual58 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero58 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan58 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual58 is true - } -} - -tweakable typeofTuple58 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox58 is "tuple" and typeofBoxConstructor58 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox58 is "object" and typeofBoxConstructor58 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple58 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple58 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple58 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows58 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple58 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows58 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple58 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor58 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance58 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor58 is "undefined" - } -} - -tweakable typeOfTupleWithBox58 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple58 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance58 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor58 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives58 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor58 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets58 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor58 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy58 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox58 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor58 is "undefined" - } -} -tweakable typeofArray59 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan59 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero59 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero59 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero59 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan59 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan59 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan59 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero59 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero59 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero59 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero59 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual59 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero59 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero59 is true - raise impossibleEqualityOfZeros when storeNegativeZero59 is false - } -} - -tweakable tupleNaNAreTripleEqual59 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero59 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero59 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple59 is "object" and zerosAreTripleEqual59 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero59 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan59 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual59 is true - } -} - -tweakable typeofTuple59 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox59 is "tuple" and typeofBoxConstructor59 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox59 is "object" and typeofBoxConstructor59 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple59 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple59 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple59 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows59 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple59 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows59 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple59 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor59 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance59 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor59 is "undefined" - } -} - -tweakable typeOfTupleWithBox59 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple59 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance59 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor59 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives59 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor59 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets59 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor59 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy59 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox59 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor59 is "undefined" - } -} -tweakable typeofArray60 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan60 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero60 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero60 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero60 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan60 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan60 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan60 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero60 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero60 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero60 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero60 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual60 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero60 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero60 is true - raise impossibleEqualityOfZeros when storeNegativeZero60 is false - } -} - -tweakable tupleNaNAreTripleEqual60 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero60 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero60 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple60 is "object" and zerosAreTripleEqual60 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero60 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan60 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual60 is true - } -} - -tweakable typeofTuple60 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox60 is "tuple" and typeofBoxConstructor60 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox60 is "object" and typeofBoxConstructor60 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple60 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple60 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple60 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows60 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple60 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows60 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple60 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor60 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance60 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor60 is "undefined" - } -} - -tweakable typeOfTupleWithBox60 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple60 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance60 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor60 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives60 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor60 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets60 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor60 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy60 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox60 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor60 is "undefined" - } -} -tweakable typeofArray61 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan61 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero61 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero61 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero61 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan61 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan61 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan61 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero61 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero61 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero61 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero61 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual61 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero61 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero61 is true - raise impossibleEqualityOfZeros when storeNegativeZero61 is false - } -} - -tweakable tupleNaNAreTripleEqual61 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero61 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero61 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple61 is "object" and zerosAreTripleEqual61 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero61 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan61 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual61 is true - } -} - -tweakable typeofTuple61 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox61 is "tuple" and typeofBoxConstructor61 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox61 is "object" and typeofBoxConstructor61 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple61 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple61 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple61 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows61 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple61 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows61 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple61 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor61 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance61 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor61 is "undefined" - } -} - -tweakable typeOfTupleWithBox61 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple61 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance61 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor61 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives61 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor61 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets61 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor61 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy61 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox61 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor61 is "undefined" - } -} -tweakable typeofArray62 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan62 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero62 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero62 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero62 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan62 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan62 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan62 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero62 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero62 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero62 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero62 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual62 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero62 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero62 is true - raise impossibleEqualityOfZeros when storeNegativeZero62 is false - } -} - -tweakable tupleNaNAreTripleEqual62 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero62 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero62 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple62 is "object" and zerosAreTripleEqual62 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero62 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan62 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual62 is true - } -} - -tweakable typeofTuple62 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox62 is "tuple" and typeofBoxConstructor62 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox62 is "object" and typeofBoxConstructor62 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple62 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple62 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple62 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows62 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple62 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows62 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple62 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor62 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance62 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor62 is "undefined" - } -} - -tweakable typeOfTupleWithBox62 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple62 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance62 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor62 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives62 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor62 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets62 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor62 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy62 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox62 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor62 is "undefined" - } -} -tweakable typeofArray63 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan63 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero63 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero63 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero63 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan63 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan63 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan63 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero63 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero63 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero63 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero63 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual63 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero63 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero63 is true - raise impossibleEqualityOfZeros when storeNegativeZero63 is false - } -} - -tweakable tupleNaNAreTripleEqual63 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero63 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero63 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple63 is "object" and zerosAreTripleEqual63 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero63 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan63 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual63 is true - } -} - -tweakable typeofTuple63 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox63 is "tuple" and typeofBoxConstructor63 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox63 is "object" and typeofBoxConstructor63 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple63 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple63 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple63 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows63 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple63 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows63 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple63 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor63 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance63 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor63 is "undefined" - } -} - -tweakable typeOfTupleWithBox63 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple63 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance63 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor63 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives63 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor63 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets63 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor63 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy63 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox63 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor63 is "undefined" - } -} -tweakable typeofArray64 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan64 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero64 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero64 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero64 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan64 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan64 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan64 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero64 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero64 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero64 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero64 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual64 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero64 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero64 is true - raise impossibleEqualityOfZeros when storeNegativeZero64 is false - } -} - -tweakable tupleNaNAreTripleEqual64 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero64 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero64 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple64 is "object" and zerosAreTripleEqual64 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero64 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan64 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual64 is true - } -} - -tweakable typeofTuple64 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox64 is "tuple" and typeofBoxConstructor64 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox64 is "object" and typeofBoxConstructor64 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple64 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple64 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple64 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows64 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple64 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows64 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple64 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor64 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance64 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor64 is "undefined" - } -} - -tweakable typeOfTupleWithBox64 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple64 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance64 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor64 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives64 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor64 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets64 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor64 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy64 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox64 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor64 is "undefined" - } -} -tweakable typeofArray65 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan65 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero65 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero65 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero65 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan65 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan65 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan65 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero65 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero65 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero65 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero65 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual65 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero65 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero65 is true - raise impossibleEqualityOfZeros when storeNegativeZero65 is false - } -} - -tweakable tupleNaNAreTripleEqual65 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero65 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero65 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple65 is "object" and zerosAreTripleEqual65 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero65 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan65 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual65 is true - } -} - -tweakable typeofTuple65 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox65 is "tuple" and typeofBoxConstructor65 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox65 is "object" and typeofBoxConstructor65 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple65 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple65 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple65 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows65 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple65 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows65 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple65 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor65 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance65 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor65 is "undefined" - } -} - -tweakable typeOfTupleWithBox65 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple65 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance65 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor65 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives65 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor65 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets65 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor65 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy65 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox65 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor65 is "undefined" - } -} -tweakable typeofArray66 { - expression "typeof []" - default value "object" -} - -tweakable typeofNan66 { - expression "typeof NaN" - default value "number" -} - -tweakable zeroTripleEqualsNegativZero66 { - expression "+0 === -0" - default value true -} - -tweakable zeroObjectIsNegativeZero66 { - expression "Object.is(+0, -0)" - default value false -} - -tweakable arrayWithNegativeZeroIncludesZero66 { - expression "[-0].includes(+0)" - default value true -} - -tweakable nanTripleEqualsNan66 { - expression "NaN === NaN" - default value false -} - -tweakable nanObjectIsNan66 { - expression "Object.is(NaN, Nan)" - default value true -} - -tweakable arrayWithNanIncludesNan66 { - expression "[NaN].includes(NaN)" - default value true -} - -tweakable arrayWithZeroTripleEqualsArrayWithZero66 { - expression "[0] === [0]" - default value false -} - -tweakable tupleWithZeroTripleEqualsTupleWithZero66 { - expression "#[0] === #[0]" - default value true -} - -tweakable objectIsFrozenTupleWithZero66 { - expression "Object.isFrozen(#[0])" - default value true -} - -/* - Tweakables -*/ - -tweakable storeNegativeZero66 { - expression "Object.is(#[-0].at(0), -0)" - default value true - value false { - raise noNegativeZero - } -} - -tweakable zerosAreTripleEqual66 { - expression "#[+0] === #[-0]" - default value true { - raise canNotAlwaysIntern when storeNegativeZero66 is true - } - value False { - raise zerosNotTripleEqual when storeNegativeZero66 is true - raise impossibleEqualityOfZeros when storeNegativeZero66 is false - } -} - -tweakable tupleNaNAreTripleEqual66 { - expression "#[NaN] === #[NaN]" - default value true - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithZeroObjectIsTupleWithNegativeZero66 { - expression "Object.is(#[+0], #[-0])" - default value false { - raise impossibleEqualityOfZeros when storeNegativeZero66 is false - raise differenceBetweenEqualityForTypeofObject when typeofTuple66 is "object" and zerosAreTripleEqual66 is true - } - value true { - raise observableDifferentButIsEqual when storeNegativeZero66 is true - } -} - -tweakable tupleWithNanObjectIsTupleWithNan66 { - expression "Object.is(#[NaN], #[NaN])" - default value true - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual66 is true - } -} - -tweakable typeofTuple66 { - expression "typeof #[]" - default value "tuple" { - raise slotSensitiveTypeof when typeOfTupleWithBox66 is "tuple" and typeofBoxConstructor66 is "function" - } - value "object" { - raise slotSensitiveTypeof when typeOfTupleWithBox66 is "object" and typeofBoxConstructor66 is "function" - raise tuplePrototypeEquality - } -} - -tweakable tupleWrappedInObjectTripleEqualsTuple66 { - expression "Object(#[]) === #[]" - default value false { - raise objectsDontHaveWrappers when typeofTuple66 is "object" - raise objectWrappers - } - value true { - raise objectWrapperInConsistency when typeofTuple66 is "tuple" - } -} - -tweakable addingTupleToWeakSetThrows66 { - expression "new WeakSet().add(#[])" - default value "ShouldThrow" { - raise validWeakValue when typeofTuple66 is "object" - } - value "ShouldSucceed" { - raise weakSetLeak - } -} - -tweakable tupleAsArgumentOfNewProxyThrows66 { - expression "new Proxy(#[])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeofTuple66 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } -} - -tweakable typeofBoxConstructor66 { - expression "typeof Box" - default value "undefined" { - raise withoutBox - } - value "function" { - raise boxType - } -} - -tweakable typeofBoxInstance66 { - expression "typeof Box({})" - default value "box" { - raise typeofPowerfulObjectIsNotObject - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor66 is "undefined" - } -} - -tweakable typeOfTupleWithBox66 { - expression "typeof #[Box({})]" - default value "tuple" { - raise confusingTypeof when typeofTuple66 is "object" - raise typeofPowerfulObjectIsNotObject when typeofBoxInstance66 is "object" - } - value "object" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor66 is "undefined" - } -} - -tweakable boxConstructorWithPrimitives66 { - expression "Box(42)" - default value "ShouldThrow" { - raise noPrimitivesInBox - } - value "ShouldSucceed" { - raise storingPrimitiveInBox - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor66 is "undefined" - } -} - -tweakable addingTuplesWithBoxesToWeakSets66 { - expression "new WeakSet().add(#[Box({})])" - default value "ShouldThrow" { - raise noBoxesInWeakSets - } - value "ShouldSucceed" - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor66 is "undefined" - } -} - -tweakable tupleWithBoxAsArgumentForNewProxy66 { - expression "new Proxy(#[Box({})])" - default value "ShouldThrow" { - raise proxyThrowTypeofObject when typeOfTupleWithBox66 is "object" - } - value "ShouldSucceed" { - raise recordProxies - } - disabled { - message "typeof Box === 'undefined'" when typeofBoxConstructor66 is "undefined" - } -} diff --git a/examples/in/records_and_tuples.jspl b/examples/in/records_and_tuples.spa similarity index 95% rename from examples/in/records_and_tuples.jspl rename to examples/in/records_and_tuples.spa index 387e6d55..9d0f519d 100644 --- a/examples/in/records_and_tuples.jspl +++ b/examples/in/records_and_tuples.spa @@ -1,9 +1,8 @@ laboratory { title "Records and Tuples Laboratory 🔬" - description MD "🏗 Work in progress - [raise technical issue](https://github.com/acutmore/record-tuple-laboratory/issues/new)" + description "🏗 Work in progress - [raise technical issue](https://github.com/acutmore/record-tuple-laboratory/issues/new)" icon "./res/favicon.svg" author "Ashley Claymore" - format HTML version "2" } @@ -11,24 +10,21 @@ issue withoutBox { summary "complexity moved to ecosystem" description - "
Without a 'Box' like type there will not be any direct support in the language for storing objects in Records and Tuples.
- Instead using symbols-as-weakmap-keys, + " + Without a 'Box' like type there will not be any direct support in the language for storing objects in Records and Tuples. + Instead using [symbols-as-weakmap-keys](https://github.com/tc39/proposal-symbols-as-weakmap-keys), symbols in Record and Tuples could still refer to objects/functions via a WeakMap. Code will need to ensure the necessary code has access to these WeakMap side tables. APIs conventions will need to be established to distinguish when symbols are being used in this way. Care will need to be taken with the WeakMaps, if a Map is used by accident there is a risk of memory leaks. Unless direct access to the WeakMap is hidden behind a wrapper, other code could remove/replace the referenced - object. -- Box use-cases include: -
If Records and Tuples are not objects then a
ToObjectoperation will return an object wrapper - which will have its own unique identity:
Object(#[]) !== Object(#[])." + "If Records and Tuples are not objects then a `ToObject` operation will return an object wrapper + which will have its own unique identity: `Object(#[]) !== Object(#[])`." } issue objectWrapperInConsistency { diff --git a/examples/in/running_example.jspl b/examples/in/running_example.jspl deleted file mode 100644 index b9e88727..00000000 --- a/examples/in/running_example.jspl +++ /dev/null @@ -1,45 +0,0 @@ -issue unequalTupleNan { - summary - "consistency change" - description - "Currently the only value not equal to itself is NaN, and this can be used as a reliable - check for NaN. If any record or tuple containing a NaN within its tree is also not equal to - itself, then there would be an infinite number of values not equal to themselves. - " -} - -issue nanNotIsNan { - summary - "Object.is NaN semantics" - description - "if both 'Object.is(NaN, NaN)' and '#[NaN] === #[NaN]'' are true, there does not appear to be - a reason for Object.is(#[NaN], #[NaN]) to not be true." -} - - -/* - Tweakables -*/ - - -tweakable tupleNaNAreTripleEqual { - expression "#[NaN] === #[NaN]" - default value true {} - value false { - raise unequalTupleNan - } -} - -tweakable tupleWithNanObjectIsTupleWithNan { - expression "Object.is(#[NaN], #[NaN])" - default value true {} - value false { - raise nanNotIsNan when tupleNaNAreTripleEqual is true - } -} \ No newline at end of file diff --git a/examples/in/test.jspl b/examples/in/test.jspl deleted file mode 100644 index 3638b6c8..00000000 --- a/examples/in/test.jspl +++ /dev/null @@ -1,42 +0,0 @@ -laboratory { - title "Basic Test Laboratory" - description "This is a basic test to try out DSL components" - icon "./res/favicon.svg" - author "Philipp" - format HTML - version "2" -} - -issue concerning { - summary "a != b" - description "We need a to be equal to b." -} - -issue concerning2 { - summary "" - description "" -} - -tweakable first { - expression "a == 0" - default value True { - raise concerning when second is False - } - value False { - raise concerning when second is True - raise concerning2 - } -} - -condition unequal holds when -(first is True and second is False) or (first is False and second is True) - -tweakable second { - expression "b == 0" - value True { - raise concerning when unequal is True - } - default value False { - raise concerning when unequal is True - } -} diff --git a/examples/in/very_simple.jspl b/examples/in/very_simple.jspl deleted file mode 100644 index cc2a1e20..00000000 --- a/examples/in/very_simple.jspl +++ /dev/null @@ -1,24 +0,0 @@ -issue concerning { - summary "a != b" - description "We need a to be equal to b." -} - -tweakable first { - expression "a == 0" - default value True { - raise concerning when second is False - } - value False { - raise concerning when second is True - } -} - -tweakable second { - expression "b == 0" - value True { - raise concerning when first is False - } - default value False { - raise concerning when first is True - } -} \ No newline at end of file diff --git a/graphviz.dot b/graphviz.dot deleted file mode 100644 index 811d2e7b..00000000 --- a/graphviz.dot +++ /dev/null @@ -1,52 +0,0 @@ -digraph G { - typeofArray [shape=oval, color=black]; - typeofNan [shape=oval, color=black]; - zeroTripleEqualsNegativZero [shape=oval, color=black]; - zeroObjectIsNegativeZero [shape=oval, color=black]; - arrayWithNegativeZeroIncludesZero [shape=oval, color=black]; - nanTripleEqualsNan [shape=oval, color=black]; - nanObjectIsNan [shape=oval, color=black]; - arrayWithNanIncludesNan [shape=oval, color=black]; - arrayWithZeroTripleEqualsArrayWithZero [shape=oval, color=black]; - tupleWithZeroTripleEqualsTupleWithZero [shape=oval, color=black]; - objectIsFrozenTupleWithZero [shape=oval, color=black]; - storeNegativeZero [shape=oval, color=black]; - zerosAreTripleEqual [shape=oval, color=black]; - storeNegativeZero -> zerosAreTripleEqual [labelfontcolor="#ffba08", color="#ffba08"]; - storeNegativeZero -> zerosAreTripleEqual [labelfontcolor="#ffba08", color="#ffba08"]; - storeNegativeZero -> zerosAreTripleEqual [labelfontcolor="#ffba08", color="#ffba08"]; - tupleNaNAreTripleEqual [shape=oval, color=black]; - tupleWithZeroObjectIsTupleWithNegativeZero [shape=oval, color=black]; - storeNegativeZero -> tupleWithZeroObjectIsTupleWithNegativeZero [labelfontcolor="#ffba08", color="#ffba08"]; - typeofTuple -> tupleWithZeroObjectIsTupleWithNegativeZero [labelfontcolor="#ffba08", color="#ffba08"]; - zerosAreTripleEqual -> tupleWithZeroObjectIsTupleWithNegativeZero [labelfontcolor="#ffba08", color="#ffba08"]; - storeNegativeZero -> tupleWithZeroObjectIsTupleWithNegativeZero [labelfontcolor="#ffba08", color="#ffba08"]; - tupleWithNanObjectIsTupleWithNan [shape=oval, color=black]; - tupleNaNAreTripleEqual -> tupleWithNanObjectIsTupleWithNan [labelfontcolor="#ffba08", color="#ffba08"]; - typeofTuple [shape=oval, color=black]; - typeOfTupleWithBox -> typeofTuple [labelfontcolor="#ffba08", color="#ffba08"]; - typeofBoxConstructor -> typeofTuple [labelfontcolor="#ffba08", color="#ffba08"]; - typeOfTupleWithBox -> typeofTuple [labelfontcolor="#ffba08", color="#ffba08"]; - typeofBoxConstructor -> typeofTuple [labelfontcolor="#ffba08", color="#ffba08"]; - tupleWrappedInObjectTripleEqualsTuple [shape=oval, color=black]; - typeofTuple -> tupleWrappedInObjectTripleEqualsTuple [labelfontcolor="#ffba08", color="#ffba08"]; - typeofTuple -> tupleWrappedInObjectTripleEqualsTuple [labelfontcolor="#ffba08", color="#ffba08"]; - addingTupleToWeakSetThrows [shape=oval, color=black]; - typeofTuple -> addingTupleToWeakSetThrows [labelfontcolor="#ffba08", color="#ffba08"]; - tupleAsArgumentOfNewProxyThrows [shape=oval, color=black]; - typeofTuple -> tupleAsArgumentOfNewProxyThrows [labelfontcolor="#ffba08", color="#ffba08"]; - typeofBoxConstructor [shape=oval, color=black]; - typeofBoxInstance [shape=oval, color=black]; - noBox -> typeofBoxInstance [labelfontcolor="#9d0208", color="#9d0208"]; - typeOfTupleWithBox [shape=oval, color=black]; - typeofTuple -> typeOfTupleWithBox [labelfontcolor="#ffba08", color="#ffba08"]; - typeofBoxInstance -> typeOfTupleWithBox [labelfontcolor="#ffba08", color="#ffba08"]; - noBox -> typeOfTupleWithBox [labelfontcolor="#9d0208", color="#9d0208"]; - boxConstructorWithPrimitives [shape=oval, color=black]; - noBox -> boxConstructorWithPrimitives [labelfontcolor="#9d0208", color="#9d0208"]; - addingTuplesWithBoxesToWeakSets [shape=oval, color=black]; - noBox -> addingTuplesWithBoxesToWeakSets [labelfontcolor="#9d0208", color="#9d0208"]; - tupleWithBoxAsArgumentForNewProxy [shape=oval, color=black]; - typeOfTupleWithBox -> tupleWithBoxAsArgumentForNewProxy [labelfontcolor="#ffba08", color="#ffba08"]; - noBox -> tupleWithBoxAsArgumentForNewProxy [labelfontcolor="#9d0208", color="#9d0208"]; -} diff --git a/icon.png b/icon.png deleted file mode 100644 index fe85553e..00000000 Binary files a/icon.png and /dev/null differ diff --git a/index.html b/index.html new file mode 100644 index 00000000..8db6e0f0 --- /dev/null +++ b/index.html @@ -0,0 +1,16 @@ + + + + + + +
::value, this);
+ auto left = next();
+
+ if (!left)
+ {
+ return left;
+ }
+
+ auto op = res ::value)))
+ {
+ auto right = next();
+
+ if (!right)
+ {
+ return right;
+ }
+
+ left = std::make_unique