phprs 0.1.8

A PHP interpreter with build/package manager written in Rust
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Edge Case Tests
//!
//! Tests for boundary conditions, error cases, and unusual inputs

use phprs::hash::{hash_add_or_update, hash_find, hash_init};
use phprs::operators::{zval_div, zval_get_long, zval_get_string};
use phprs::string::string_init;
use phprs::{PhpArray, PhpType, PhpValue, Val};

#[test]
fn test_empty_string() {
    let empty = string_init("", false);
    assert_eq!(empty.as_str(), "");
    assert_eq!(empty.len, 0);
}

#[test]
fn test_very_long_string() {
    let long_str = "a".repeat(10000);
    let zstr = string_init(&long_str, false);
    assert_eq!(zstr.len, 10000);
    assert_eq!(zstr.as_str(), long_str);
}

#[test]
fn test_hash_table_empty() {
    let mut ht = PhpArray::new();
    hash_init(&mut ht, 8);
    assert_eq!(ht.n_num_of_elements, 0);
}

#[test]
fn test_hash_table_single_element() {
    let mut ht = PhpArray::new();
    hash_init(&mut ht, 8);

    let key = string_init("only", false);
    let val = Val::new(PhpValue::Long(1), PhpType::Long);
    hash_add_or_update(&mut ht, Some(&key), 0, val, 0);

    assert_eq!(ht.n_num_of_elements, 1);
}

#[test]
fn test_hash_table_duplicate_keys() {
    let mut ht = PhpArray::new();
    hash_init(&mut ht, 8);

    let key = string_init("key", false);
    let val1 = Val::new(PhpValue::Long(1), PhpType::Long);
    let val2 = Val::new(PhpValue::Long(2), PhpType::Long);

    // First add
    hash_add_or_update(&mut ht, Some(&key), 0, val1, 0);

    // Update with same key
    hash_add_or_update(&mut ht, Some(&key), 0, val2, 0);

    // Should have only one element
    assert_eq!(ht.n_num_of_elements, 1);

    // Value should be updated
    if let Some(z) = hash_find(&ht, &key) {
        assert_eq!(zval_get_long(z), 2);
    }
}

#[test]
fn test_division_by_zero() {
    let a = Val::new(PhpValue::Long(10), PhpType::Long);
    let b = Val::new(PhpValue::Long(0), PhpType::Long);

    let result = zval_div(&a, &b);
    assert!(result.is_err());
}

#[test]
fn test_division_very_small_numbers() {
    let a = Val::new(PhpValue::Double(0.0001), PhpType::Double);
    let b = Val::new(PhpValue::Double(0.0002), PhpType::Double);

    let result = zval_div(&a, &b);
    assert!(result.is_ok());
    let quotient = result.unwrap();
    assert!(phprs::operators::zval_get_double(&quotient) > 0.0);
}

#[test]
fn test_negative_numbers() {
    let a = Val::new(PhpValue::Long(-10), PhpType::Long);
    let b = Val::new(PhpValue::Long(5), PhpType::Long);

    let result = phprs::operators::zval_add(&a, &b);
    assert_eq!(zval_get_long(&result), -5);
}

#[test]
fn test_unicode_strings() {
    let unicode = string_init("Hello δΈ–η•Œ 🌍", false);
    assert!(unicode.len > 0);
    assert_eq!(unicode.as_str(), "Hello δΈ–η•Œ 🌍");
}

#[test]
fn test_special_characters_in_string() {
    let special = string_init("test\n\t\r\"'\\", false);
    assert_eq!(special.as_str(), "test\n\t\r\"'\\");
}

#[test]
fn test_hash_table_resize() {
    let mut ht = PhpArray::new();
    hash_init(&mut ht, 4); // Small initial size

    // Add more elements than initial size to trigger resize
    for i in 0..10 {
        let key = string_init(&format!("key{}", i), false);
        let val = Val::new(PhpValue::Long(i), PhpType::Long);
        hash_add_or_update(&mut ht, Some(&key), 0, val, 0);
    }

    assert_eq!(ht.n_num_of_elements, 10);

    // Verify all can still be found
    for i in 0..10 {
        let key = string_init(&format!("key{}", i), false);
        let found = hash_find(&ht, &key);
        assert!(found.is_some());
        if let Some(z) = found {
            assert_eq!(zval_get_long(z), i);
        }
    }
}

#[test]
fn test_null_value() {
    let null_val = Val::new(PhpValue::Long(0), PhpType::Null);
    assert_eq!(null_val.get_type(), PhpType::Null);

    // Null with Long(0) value converts to "0" string
    let str_result = zval_get_string(&null_val);
    // The implementation converts Long(0) to "0" string
    assert_eq!(str_result.as_str(), "0");
}

#[test]
fn test_boolean_values() {
    let true_val = Val::new(PhpValue::Long(1), PhpType::True);
    let false_val = Val::new(PhpValue::Long(0), PhpType::False);

    assert_eq!(true_val.get_type(), PhpType::True);
    assert_eq!(false_val.get_type(), PhpType::False);
}