simple-update-in 0.1.0

Immutable nested update with structural sharing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

//! SameValue equality, the check that decides whether an update changed
//! anything. Mirrors the three polyfill assertions from the source suite.

use simple_update_in::Value;

#[test]
fn same_string_is_equal() {
    assert!(Value::String("abc".into()).same_value(&Value::String("abc".into())));
}

#[test]
fn nan_equals_nan() {
    assert!(Value::Number(f64::NAN).same_value(&Value::Number(f64::NAN)));
}

#[test]
fn nan_equals_nan_across_bit_patterns() {
    // Object.is treats every NaN as equal, even with a different sign or
    // payload, so writing one NaN over another stays a no-op.
    let a = Value::Number(f64::NAN);
    let b = Value::Number(-f64::NAN);
    assert!(f64::NAN.to_bits() != (-f64::NAN).to_bits());
    assert!(a.same_value(&b));
}

#[test]
fn zero_and_negative_zero_differ() {
    assert!(!Value::Number(0.0).same_value(&Value::Number(-0.0)));
}

#[test]
fn equal_numbers_are_equal() {
    assert!(Value::Number(42.0).same_value(&Value::Number(42.0)));
}

#[test]
fn different_types_are_not_equal() {
    assert!(!Value::Number(1.0).same_value(&Value::String("1".into())));
    assert!(!Value::Null.same_value(&Value::Undefined));
}

#[test]
fn distinct_arrays_are_not_same_value() {
    // SameValue on containers is pointer identity, not deep equality.
    let a = Value::array(vec![Value::Number(1.0)]);
    let b = Value::array(vec![Value::Number(1.0)]);
    assert!(!a.same_value(&b));
    assert!(a.same_value(&a.clone()));
}