681 lines
22 KiB
Rust
681 lines
22 KiB
Rust
use crate::avm1::return_value::ReturnValue;
|
|
use crate::avm1::{Avm1, Error, ObjectCell, UpdateContext};
|
|
use gc_arena::GcCell;
|
|
use std::f64::NAN;
|
|
|
|
#[derive(Clone, Debug)]
|
|
#[allow(dead_code)]
|
|
pub enum Value<'gc> {
|
|
Undefined,
|
|
Null,
|
|
Bool(bool),
|
|
Number(f64),
|
|
String(String),
|
|
Object(ObjectCell<'gc>),
|
|
}
|
|
|
|
impl<'gc> From<String> for Value<'gc> {
|
|
fn from(string: String) -> Self {
|
|
Value::String(string)
|
|
}
|
|
}
|
|
|
|
impl<'gc> From<&str> for Value<'gc> {
|
|
fn from(string: &str) -> Self {
|
|
Value::String(string.to_owned())
|
|
}
|
|
}
|
|
|
|
impl<'gc> From<bool> for Value<'gc> {
|
|
fn from(value: bool) -> Self {
|
|
Value::Bool(value)
|
|
}
|
|
}
|
|
|
|
impl<'gc> From<ObjectCell<'gc>> for Value<'gc> {
|
|
fn from(object: ObjectCell<'gc>) -> Self {
|
|
Value::Object(object)
|
|
}
|
|
}
|
|
|
|
impl<'gc> From<f64> for Value<'gc> {
|
|
fn from(value: f64) -> Self {
|
|
Value::Number(value)
|
|
}
|
|
}
|
|
|
|
impl<'gc> From<f32> for Value<'gc> {
|
|
fn from(value: f32) -> Self {
|
|
Value::Number(f64::from(value))
|
|
}
|
|
}
|
|
|
|
impl<'gc> From<u8> for Value<'gc> {
|
|
fn from(value: u8) -> Self {
|
|
Value::Number(f64::from(value))
|
|
}
|
|
}
|
|
|
|
impl<'gc> From<i32> for Value<'gc> {
|
|
fn from(value: i32) -> Self {
|
|
Value::Number(f64::from(value))
|
|
}
|
|
}
|
|
|
|
impl<'gc> From<u32> for Value<'gc> {
|
|
fn from(value: u32) -> Self {
|
|
Value::Number(f64::from(value))
|
|
}
|
|
}
|
|
|
|
impl<'gc> From<usize> for Value<'gc> {
|
|
fn from(value: usize) -> Self {
|
|
Value::Number(value as f64)
|
|
}
|
|
}
|
|
|
|
unsafe impl<'gc> gc_arena::Collect for Value<'gc> {
|
|
fn trace(&self, cc: gc_arena::CollectionContext) {
|
|
if let Value::Object(object) = self {
|
|
object.trace(cc);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq for Value<'_> {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
match self {
|
|
Value::Undefined => match other {
|
|
Value::Undefined => true,
|
|
_ => false,
|
|
},
|
|
Value::Null => match other {
|
|
Value::Null => true,
|
|
_ => false,
|
|
},
|
|
Value::Bool(value) => match other {
|
|
Value::Bool(other_value) => value == other_value,
|
|
_ => false,
|
|
},
|
|
Value::Number(value) => match other {
|
|
Value::Number(other_value) => {
|
|
(value == other_value) || (value.is_nan() && other_value.is_nan())
|
|
}
|
|
_ => false,
|
|
},
|
|
Value::String(value) => match other {
|
|
Value::String(other_value) => value == other_value,
|
|
_ => false,
|
|
},
|
|
Value::Object(value) => match other {
|
|
Value::Object(other_value) => value.as_ptr() == other_value.as_ptr(),
|
|
_ => false,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'gc> Value<'gc> {
|
|
pub fn into_number_v1(self) -> f64 {
|
|
match self {
|
|
Value::Bool(true) => 1.0,
|
|
Value::Number(v) => v,
|
|
Value::String(v) => v.parse().unwrap_or(0.0),
|
|
_ => 0.0,
|
|
}
|
|
}
|
|
|
|
/// ECMA-262 2nd edtion s. 9.3 ToNumber (after calling `to_primitive_num`)
|
|
///
|
|
/// Flash diverges from spec in a number of ways. These ways are, as far as
|
|
/// we are aware, version-gated:
|
|
///
|
|
/// * In SWF6 and lower, `undefined` is coerced to `0.0` (like `false`)
|
|
/// rathern than `NaN` as required by spec.
|
|
fn primitive_as_number(
|
|
&self,
|
|
avm: &mut Avm1<'gc>,
|
|
_context: &mut UpdateContext<'_, 'gc, '_>,
|
|
) -> f64 {
|
|
match self {
|
|
Value::Undefined if avm.current_swf_version() < 7 => 0.0,
|
|
Value::Null if avm.current_swf_version() < 7 => 0.0,
|
|
Value::Undefined => NAN,
|
|
Value::Null => NAN,
|
|
Value::Bool(false) => 0.0,
|
|
Value::Bool(true) => 1.0,
|
|
Value::Number(v) => *v,
|
|
Value::String(v) => match v.as_str() {
|
|
v if v.starts_with("0x") => {
|
|
let mut n: u32 = 0;
|
|
for c in v[2..].bytes() {
|
|
n = n.wrapping_shl(4);
|
|
n |= match c {
|
|
b'0' => 0,
|
|
b'1' => 1,
|
|
b'2' => 2,
|
|
b'3' => 3,
|
|
b'4' => 4,
|
|
b'5' => 5,
|
|
b'6' => 6,
|
|
b'7' => 7,
|
|
b'8' => 8,
|
|
b'9' => 9,
|
|
b'a' | b'A' => 10,
|
|
b'b' | b'B' => 11,
|
|
b'c' | b'C' => 12,
|
|
b'd' | b'D' => 13,
|
|
b'e' | b'E' => 14,
|
|
b'f' | b'F' => 15,
|
|
_ => return NAN,
|
|
}
|
|
}
|
|
f64::from(n as i32)
|
|
}
|
|
"" => 0.0,
|
|
_ => v.parse().unwrap_or(NAN),
|
|
},
|
|
Value::Object(_) => NAN,
|
|
}
|
|
}
|
|
|
|
/// ECMA-262 2nd edition s. 9.3 ToNumber
|
|
pub fn as_number(
|
|
&self,
|
|
avm: &mut Avm1<'gc>,
|
|
context: &mut UpdateContext<'_, 'gc, '_>,
|
|
) -> Result<f64, Error> {
|
|
Ok(match self {
|
|
Value::Object(_) => self
|
|
.to_primitive_num(avm, context)?
|
|
.primitive_as_number(avm, context),
|
|
val => val.primitive_as_number(avm, context),
|
|
})
|
|
}
|
|
|
|
/// ECMA-262 2nd edition s. 9.1 ToPrimitive (hint: Number)
|
|
///
|
|
/// Flash diverges from spec in a number of ways. These ways are, as far as
|
|
/// we are aware, version-gated:
|
|
///
|
|
/// * `toString` is never called when `ToPrimitive` is invoked with number
|
|
/// hint.
|
|
/// * Objects with uncallable `valueOf` implementations are coerced to
|
|
/// `undefined`. This is not a special-cased behavior: All values are
|
|
/// callable in `AVM1`. Values that are not callable objects instead
|
|
/// return `undefined` rather than yielding a runtime error.
|
|
pub fn to_primitive_num(
|
|
&self,
|
|
avm: &mut Avm1<'gc>,
|
|
context: &mut UpdateContext<'_, 'gc, '_>,
|
|
) -> Result<Value<'gc>, Error> {
|
|
Ok(match self {
|
|
Value::Object(object) => {
|
|
let value_of_impl = object
|
|
.read()
|
|
.get("valueOf", avm, context, *object)?
|
|
.resolve(avm, context)?;
|
|
|
|
let fake_args = Vec::new();
|
|
value_of_impl
|
|
.call(avm, context, *object, &fake_args)?
|
|
.resolve(avm, context)?
|
|
}
|
|
val => val.to_owned(),
|
|
})
|
|
}
|
|
|
|
/// ECMA-262 2nd edition s. 11.8.5 Abstract relational comparison algorithm
|
|
#[allow(clippy::float_cmp)]
|
|
pub fn abstract_lt(
|
|
&self,
|
|
other: Value<'gc>,
|
|
avm: &mut Avm1<'gc>,
|
|
context: &mut UpdateContext<'_, 'gc, '_>,
|
|
) -> Result<Value<'gc>, Error> {
|
|
let prim_self = self.to_primitive_num(avm, context)?;
|
|
let prim_other = other.to_primitive_num(avm, context)?;
|
|
|
|
if let (Value::String(a), Value::String(b)) = (&prim_self, &prim_other) {
|
|
return Ok(a.to_string().bytes().lt(b.to_string().bytes()).into());
|
|
}
|
|
|
|
let num_self = prim_self.primitive_as_number(avm, context);
|
|
let num_other = prim_other.primitive_as_number(avm, context);
|
|
|
|
if num_self.is_nan() || num_other.is_nan() {
|
|
return Ok(Value::Undefined);
|
|
}
|
|
|
|
if num_self == num_other
|
|
|| num_self == 0.0 && num_other == -0.0
|
|
|| num_self == -0.0 && num_other == 0.0
|
|
|| num_self.is_infinite() && num_self.is_sign_positive()
|
|
|| num_other.is_infinite() && num_other.is_sign_negative()
|
|
{
|
|
return Ok(false.into());
|
|
}
|
|
|
|
if num_self.is_infinite() && num_self.is_sign_negative()
|
|
|| num_other.is_infinite() && num_other.is_sign_positive()
|
|
{
|
|
return Ok(true.into());
|
|
}
|
|
|
|
Ok((num_self < num_other).into())
|
|
}
|
|
|
|
/// ECMA-262 2nd edition s. 11.9.3 Abstract equality comparison algorithm
|
|
pub fn abstract_eq(
|
|
&self,
|
|
other: Value<'gc>,
|
|
avm: &mut Avm1<'gc>,
|
|
context: &mut UpdateContext<'_, 'gc, '_>,
|
|
coerced: bool,
|
|
) -> Result<Value<'gc>, Error> {
|
|
match (self, &other) {
|
|
(Value::Undefined, Value::Undefined) => Ok(true.into()),
|
|
(Value::Null, Value::Null) => Ok(true.into()),
|
|
(Value::Number(a), Value::Number(b)) => {
|
|
if !coerced && a.is_nan() && b.is_nan() {
|
|
return Ok(true.into());
|
|
}
|
|
|
|
if a == b {
|
|
return Ok(true.into());
|
|
}
|
|
|
|
if *a == 0.0 && *b == -0.0 || *a == -0.0 && *b == 0.0 {
|
|
return Ok(true.into());
|
|
}
|
|
|
|
Ok(false.into())
|
|
}
|
|
(Value::String(a), Value::String(b)) => Ok((a == b).into()),
|
|
(Value::Bool(a), Value::Bool(b)) => Ok((a == b).into()),
|
|
(Value::Object(a), Value::Object(b)) => Ok(GcCell::ptr_eq(*a, *b).into()),
|
|
(Value::Object(a), Value::Null) | (Value::Object(a), Value::Undefined) => {
|
|
Ok((a.as_ptr() == avm.global_object_cell().as_ptr()).into())
|
|
}
|
|
(Value::Null, Value::Object(b)) | (Value::Undefined, Value::Object(b)) => {
|
|
Ok((b.as_ptr() == avm.global_object_cell().as_ptr()).into())
|
|
}
|
|
(Value::Undefined, Value::Null) => Ok(true.into()),
|
|
(Value::Null, Value::Undefined) => Ok(true.into()),
|
|
(Value::Number(_), Value::String(_)) => Ok(self.abstract_eq(
|
|
Value::Number(other.as_number(avm, context)?),
|
|
avm,
|
|
context,
|
|
true,
|
|
)?),
|
|
(Value::String(_), Value::Number(_)) => {
|
|
Ok(Value::Number(self.as_number(avm, context)?)
|
|
.abstract_eq(other, avm, context, true)?)
|
|
}
|
|
(Value::Bool(_), _) => Ok(Value::Number(self.as_number(avm, context)?)
|
|
.abstract_eq(other, avm, context, true)?),
|
|
(_, Value::Bool(_)) => Ok(self.abstract_eq(
|
|
Value::Number(other.as_number(avm, context)?),
|
|
avm,
|
|
context,
|
|
true,
|
|
)?),
|
|
(Value::String(_), Value::Object(_)) => {
|
|
let non_obj_other = other.to_primitive_num(avm, context)?;
|
|
if let Value::Object(_) = non_obj_other {
|
|
return Ok(false.into());
|
|
}
|
|
|
|
Ok(self.abstract_eq(non_obj_other, avm, context, true)?)
|
|
}
|
|
(Value::Number(_), Value::Object(_)) => {
|
|
let non_obj_other = other.to_primitive_num(avm, context)?;
|
|
if let Value::Object(_) = non_obj_other {
|
|
return Ok(false.into());
|
|
}
|
|
|
|
Ok(self.abstract_eq(non_obj_other, avm, context, true)?)
|
|
}
|
|
(Value::Object(_), Value::String(_)) => {
|
|
let non_obj_self = self.to_primitive_num(avm, context)?;
|
|
if let Value::Object(_) = non_obj_self {
|
|
return Ok(false.into());
|
|
}
|
|
|
|
Ok(non_obj_self.abstract_eq(other, avm, context, true)?)
|
|
}
|
|
(Value::Object(_), Value::Number(_)) => {
|
|
let non_obj_self = self.to_primitive_num(avm, context)?;
|
|
if let Value::Object(_) = non_obj_self {
|
|
return Ok(false.into());
|
|
}
|
|
|
|
Ok(non_obj_self.abstract_eq(other, avm, context, true)?)
|
|
}
|
|
_ => Ok(false.into()),
|
|
}
|
|
}
|
|
|
|
pub fn from_bool_v1(value: bool, swf_version: u8) -> Value<'gc> {
|
|
// SWF version 4 did not have true bools and will push bools as 0 or 1.
|
|
// e.g. SWF19 p. 72:
|
|
// "If the numbers are equal, true is pushed to the stack for SWF 5 and later. For SWF 4, 1 is pushed to the stack."
|
|
if swf_version >= 5 {
|
|
Value::Bool(value)
|
|
} else {
|
|
Value::Number(if value { 1.0 } else { 0.0 })
|
|
}
|
|
}
|
|
|
|
/// Coerce a value to a string without calling object methods.
|
|
pub fn into_string(self) -> String {
|
|
match self {
|
|
Value::Undefined => "undefined".to_string(),
|
|
Value::Null => "null".to_string(),
|
|
Value::Bool(v) => v.to_string(),
|
|
Value::Number(v) => v.to_string(), // TODO(Herschel): Rounding for int?
|
|
Value::String(v) => v,
|
|
Value::Object(object) => object.read().as_string(),
|
|
}
|
|
}
|
|
|
|
/// Coerce a value to a string.
|
|
pub fn coerce_to_string(
|
|
self,
|
|
avm: &mut Avm1<'gc>,
|
|
context: &mut UpdateContext<'_, 'gc, '_>,
|
|
) -> Result<String, Error> {
|
|
Ok(match self {
|
|
Value::Object(object) => {
|
|
let to_string_impl = object
|
|
.read()
|
|
.get("toString", avm, context, object)?
|
|
.resolve(avm, context)?;
|
|
let fake_args = Vec::new();
|
|
match to_string_impl
|
|
.call(avm, context, object, &fake_args)?
|
|
.resolve(avm, context)?
|
|
{
|
|
Value::String(s) => s,
|
|
_ => "[type Object]".to_string(),
|
|
}
|
|
}
|
|
_ => self.into_string(),
|
|
})
|
|
}
|
|
|
|
pub fn as_bool(&self, swf_version: u8) -> bool {
|
|
match self {
|
|
Value::Bool(v) => *v,
|
|
Value::Number(v) => !v.is_nan() && *v != 0.0,
|
|
Value::String(v) => {
|
|
if swf_version >= 7 {
|
|
!v.is_empty()
|
|
} else {
|
|
let num = v.parse().unwrap_or(0.0);
|
|
num != 0.0
|
|
}
|
|
}
|
|
Value::Object(_) => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
pub fn type_of(&self) -> Value<'gc> {
|
|
Value::String(
|
|
match self {
|
|
Value::Undefined => "undefined",
|
|
Value::Null => "null",
|
|
Value::Number(_) => "number",
|
|
Value::Bool(_) => "boolean",
|
|
Value::String(_) => "string",
|
|
Value::Object(object) => object.read().type_of(),
|
|
}
|
|
.to_string(),
|
|
)
|
|
}
|
|
|
|
pub fn as_i32(&self) -> Result<i32, Error> {
|
|
self.as_f64().map(|n| n as i32)
|
|
}
|
|
|
|
pub fn as_u32(&self) -> Result<u32, Error> {
|
|
self.as_f64().map(|n| n as u32)
|
|
}
|
|
|
|
pub fn as_i64(&self) -> Result<i64, Error> {
|
|
self.as_f64().map(|n| n as i64)
|
|
}
|
|
|
|
pub fn as_usize(&self) -> Result<usize, Error> {
|
|
self.as_f64().map(|n| n as usize)
|
|
}
|
|
|
|
pub fn as_f64(&self) -> Result<f64, Error> {
|
|
match *self {
|
|
Value::Number(v) => Ok(v),
|
|
_ => Err(format!("Expected Number, found {:?}", self).into()),
|
|
}
|
|
}
|
|
|
|
pub fn as_string(&self) -> Result<&String, Error> {
|
|
match self {
|
|
Value::String(s) => Ok(s),
|
|
_ => Err(format!("Expected String, found {:?}", self).into()),
|
|
}
|
|
}
|
|
|
|
pub fn as_object(&self) -> Result<ObjectCell<'gc>, Error> {
|
|
if let Value::Object(object) = self {
|
|
Ok(object.to_owned())
|
|
} else {
|
|
Err(format!("Expected Object, found {:?}", self).into())
|
|
}
|
|
}
|
|
|
|
pub fn call(
|
|
&self,
|
|
avm: &mut Avm1<'gc>,
|
|
context: &mut UpdateContext<'_, 'gc, '_>,
|
|
this: ObjectCell<'gc>,
|
|
args: &[Value<'gc>],
|
|
) -> Result<ReturnValue<'gc>, Error> {
|
|
if let Value::Object(object) = self {
|
|
object.read().call(avm, context, this, args)
|
|
} else {
|
|
Ok(Value::Undefined.into())
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use crate::avm1::function::Executable;
|
|
use crate::avm1::globals::create_globals;
|
|
use crate::avm1::object::ObjectCell;
|
|
use crate::avm1::return_value::ReturnValue;
|
|
use crate::avm1::script_object::ScriptObject;
|
|
use crate::avm1::test_utils::with_avm;
|
|
use crate::avm1::{Avm1, Error, Value};
|
|
use crate::context::UpdateContext;
|
|
use enumset::EnumSet;
|
|
use gc_arena::GcCell;
|
|
use std::f64::{INFINITY, NAN, NEG_INFINITY};
|
|
|
|
#[test]
|
|
fn to_primitive_num() {
|
|
with_avm(6, |avm, context, _this| {
|
|
let t = Value::Bool(true);
|
|
let u = Value::Undefined;
|
|
let f = Value::Bool(false);
|
|
let n = Value::Null;
|
|
|
|
assert_eq!(t.to_primitive_num(avm, context).unwrap(), t);
|
|
assert_eq!(u.to_primitive_num(avm, context).unwrap(), u);
|
|
assert_eq!(f.to_primitive_num(avm, context).unwrap(), f);
|
|
assert_eq!(n.to_primitive_num(avm, context).unwrap(), n);
|
|
|
|
let (protos, global) = create_globals(context.gc_context);
|
|
let vglobal = Value::Object(global);
|
|
|
|
assert_eq!(vglobal.to_primitive_num(avm, context).unwrap(), u);
|
|
|
|
fn value_of_impl<'gc>(
|
|
_: &mut Avm1<'gc>,
|
|
_: &mut UpdateContext<'_, 'gc, '_>,
|
|
_: ObjectCell<'gc>,
|
|
_: &[Value<'gc>],
|
|
) -> Result<ReturnValue<'gc>, Error> {
|
|
Ok(5.0.into())
|
|
}
|
|
|
|
let valueof = ScriptObject::function(
|
|
context.gc_context,
|
|
Executable::Native(value_of_impl),
|
|
Some(protos.function),
|
|
None,
|
|
);
|
|
|
|
let o = ScriptObject::object_cell(context.gc_context, Some(protos.object));
|
|
o.write(context.gc_context)
|
|
.define_value("valueOf", valueof.into(), EnumSet::empty());
|
|
|
|
assert_eq!(
|
|
Value::Object(o).to_primitive_num(avm, context).unwrap(),
|
|
Value::Number(5.0)
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
#[allow(clippy::float_cmp)]
|
|
fn to_number_swf7() {
|
|
with_avm(7, |avm, context, _this| {
|
|
let t = Value::Bool(true);
|
|
let u = Value::Undefined;
|
|
let f = Value::Bool(false);
|
|
let n = Value::Null;
|
|
|
|
assert_eq!(t.as_number(avm, context).unwrap(), 1.0);
|
|
assert!(u.as_number(avm, context).unwrap().is_nan());
|
|
assert_eq!(f.as_number(avm, context).unwrap(), 0.0);
|
|
assert!(n.as_number(avm, context).unwrap().is_nan());
|
|
|
|
let bo = Value::Object(GcCell::allocate(
|
|
context.gc_context,
|
|
Box::new(ScriptObject::bare_object()),
|
|
));
|
|
|
|
assert!(bo.as_number(avm, context).unwrap().is_nan());
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
#[allow(clippy::float_cmp)]
|
|
fn to_number_swf6() {
|
|
with_avm(6, |avm, context, _this| {
|
|
let t = Value::Bool(true);
|
|
let u = Value::Undefined;
|
|
let f = Value::Bool(false);
|
|
let n = Value::Null;
|
|
|
|
assert_eq!(t.as_number(avm, context).unwrap(), 1.0);
|
|
assert_eq!(u.as_number(avm, context).unwrap(), 0.0);
|
|
assert_eq!(f.as_number(avm, context).unwrap(), 0.0);
|
|
assert_eq!(n.as_number(avm, context).unwrap(), 0.0);
|
|
|
|
let bo = Value::Object(GcCell::allocate(
|
|
context.gc_context,
|
|
Box::new(ScriptObject::bare_object()),
|
|
));
|
|
|
|
assert_eq!(bo.as_number(avm, context).unwrap(), 0.0);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn abstract_lt_num() {
|
|
with_avm(8, |avm, context, _this| {
|
|
let a = Value::Number(1.0);
|
|
let b = Value::Number(2.0);
|
|
|
|
assert_eq!(a.abstract_lt(b, avm, context).unwrap(), Value::Bool(true));
|
|
|
|
let nan = Value::Number(NAN);
|
|
assert_eq!(a.abstract_lt(nan, avm, context).unwrap(), Value::Undefined);
|
|
|
|
let inf = Value::Number(INFINITY);
|
|
assert_eq!(a.abstract_lt(inf, avm, context).unwrap(), Value::Bool(true));
|
|
|
|
let neg_inf = Value::Number(NEG_INFINITY);
|
|
assert_eq!(
|
|
a.abstract_lt(neg_inf, avm, context).unwrap(),
|
|
Value::Bool(false)
|
|
);
|
|
|
|
let zero = Value::Number(0.0);
|
|
assert_eq!(
|
|
a.abstract_lt(zero, avm, context).unwrap(),
|
|
Value::Bool(false)
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn abstract_gt_num() {
|
|
with_avm(8, |avm, context, _this| {
|
|
let a = Value::Number(1.0);
|
|
let b = Value::Number(2.0);
|
|
|
|
assert_eq!(
|
|
b.abstract_lt(a.clone(), avm, context).unwrap(),
|
|
Value::Bool(false)
|
|
);
|
|
|
|
let nan = Value::Number(NAN);
|
|
assert_eq!(
|
|
nan.abstract_lt(a.clone(), avm, context).unwrap(),
|
|
Value::Undefined
|
|
);
|
|
|
|
let inf = Value::Number(INFINITY);
|
|
assert_eq!(
|
|
inf.abstract_lt(a.clone(), avm, context).unwrap(),
|
|
Value::Bool(false)
|
|
);
|
|
|
|
let neg_inf = Value::Number(NEG_INFINITY);
|
|
assert_eq!(
|
|
neg_inf.abstract_lt(a.clone(), avm, context).unwrap(),
|
|
Value::Bool(true)
|
|
);
|
|
|
|
let zero = Value::Number(0.0);
|
|
assert_eq!(
|
|
zero.abstract_lt(a, avm, context).unwrap(),
|
|
Value::Bool(true)
|
|
);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn abstract_lt_str() {
|
|
with_avm(8, |avm, context, _this| {
|
|
let a = Value::String("a".to_owned());
|
|
let b = Value::String("b".to_owned());
|
|
|
|
assert_eq!(a.abstract_lt(b, avm, context).unwrap(), Value::Bool(true))
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn abstract_gt_str() {
|
|
with_avm(8, |avm, context, _this| {
|
|
let a = Value::String("a".to_owned());
|
|
let b = Value::String("b".to_owned());
|
|
|
|
assert_eq!(b.abstract_lt(a, avm, context).unwrap(), Value::Bool(false))
|
|
})
|
|
}
|
|
}
|