archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-16 05:58:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge branch 'PHP-8.2' into PHP-8.3

Browse source 
* PHP-8.2:
  ext/gmp: Fix segfault when null is encountered on an overloaded operator
  ext/gmp: Add behavioural tests for operator overloading
This commit is contained in:
Gina Peter Banyard 2024-11-02 17:40:41 +00:00
commit 65d42342a1
No known key found for this signature in database
GPG key ID: 3306078E3194AEBD
13 changed files with 1095 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

2
NEWS
View file

@ -71,6 +71,8 @@ PHP NEWS
(David Carlier) (David Carlier)
. Fixed gmp_pow() overflow bug with large base/exponents. . Fixed gmp_pow() overflow bug with large base/exponents.
(David Carlier) (David Carlier)
. Fixed segfaults and other issues related to operator overloading with
GMP objects. (Girgias)
- MBstring: - MBstring:
. Fixed bug GH-16361 (mb_substr overflow on start/length arguments). . Fixed bug GH-16361 (mb_substr overflow on start/length arguments).

88
ext/gmp/gmp.c
View file

@ -333,8 +333,34 @@ static zend_object *gmp_clone_obj(zend_object *obj) /* {{{ */
} }
/* }}} */ /* }}} */
static void shift_operator_helper(gmp_binary_ui_op_t op, zval *return_value, zval *op1, zval *op2, uint8_t opcode) { static zend_result shift_operator_helper(gmp_binary_ui_op_t op, zval *return_value, zval *op1, zval *op2, uint8_t opcode) {
zend_long shift = zval_get_long(op2); zend_long shift = 0;
if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) {
if (UNEXPECTED(!IS_GMP(op2))) {
// For PHP 8.3 and up use zend_try_get_long()
switch (Z_TYPE_P(op2)) {
case IS_DOUBLE:
shift = zval_get_long(op2);
if (UNEXPECTED(EG(exception))) {
return FAILURE;
}
break;
case IS_STRING:
if (is_numeric_str_function(Z_STR_P(op2), &shift, NULL) != IS_LONG) {
goto valueof_op_failure;
}
break;
default:
goto typeof_op_failure;
}
} else {
// TODO We shouldn't cast the GMP object to int here
shift = zval_get_long(op2);
}
} else {
shift = Z_LVAL_P(op2);
}
if (shift < 0) { if (shift < 0) {
zend_throw_error( zend_throw_error(
@ -342,16 +368,54 @@ static void shift_operator_helper(gmp_binary_ui_op_t op, zval *return_value, zva
opcode == ZEND_POW ? "Exponent" : "Shift" opcode == ZEND_POW ? "Exponent" : "Shift"
); );
ZVAL_UNDEF(return_value); ZVAL_UNDEF(return_value);
return; return FAILURE;
} else { } else {
mpz_ptr gmpnum_op, gmpnum_result; mpz_ptr gmpnum_op, gmpnum_result;
gmp_temp_t temp; gmp_temp_t temp;
FETCH_GMP_ZVAL(gmpnum_op, op1, temp, 1); /* We do not use FETCH_GMP_ZVAL(...); here as we don't use convert_to_gmp()
* as we want to handle the emitted exception ourself. */
if (UNEXPECTED(!IS_GMP(op1))) {
if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) {
goto typeof_op_failure;
}
mpz_init(temp.num);
mpz_set_si(temp.num, Z_LVAL_P(op1));
temp.is_used = 1;
gmpnum_op = temp.num;
} else {
gmpnum_op = GET_GMP_FROM_ZVAL(op1);
temp.is_used = 0;
}
INIT_GMP_RETVAL(gmpnum_result); INIT_GMP_RETVAL(gmpnum_result);
op(gmpnum_result, gmpnum_op, (gmp_ulong) shift); op(gmpnum_result, gmpnum_op, (gmp_ulong) shift);
FREE_GMP_TEMP(temp); FREE_GMP_TEMP(temp);
return SUCCESS;
} }
typeof_op_failure: ;
/* Returning FAILURE without throwing an exception would emit the
* Unsupported operand types: GMP OP TypeOfOp2
* However, this leads to the engine trying to interpret the GMP object as an integer
* and doing the operation that way, which is not something we want. */
const char *op_sigil;
switch (opcode) {
case ZEND_POW:
op_sigil = "**";
break;
case ZEND_SL:
op_sigil = "<<";
break;
case ZEND_SR:
op_sigil = ">>";
break;
EMPTY_SWITCH_DEFAULT_CASE();
}
zend_type_error("Unsupported operand types: %s %s %s", zend_zval_type_name(op1), op_sigil, zend_zval_type_name(op2));
return FAILURE;
valueof_op_failure:
zend_value_error("Number is not an integer string");
return FAILURE;
} }
#define DO_BINARY_UI_OP_EX(op, uop, check_b_zero) \ #define DO_BINARY_UI_OP_EX(op, uop, check_b_zero) \
@ -380,18 +444,15 @@ static zend_result gmp_do_operation_ex(uint8_t opcode, zval *result, zval *op1,
case ZEND_MUL: case ZEND_MUL:
DO_BINARY_UI_OP(mpz_mul); DO_BINARY_UI_OP(mpz_mul);
case ZEND_POW: case ZEND_POW:
shift_operator_helper(mpz_pow_ui, result, op1, op2, opcode); return shift_operator_helper(mpz_pow_ui, result, op1, op2, opcode);
return SUCCESS;
case ZEND_DIV: case ZEND_DIV:
DO_BINARY_UI_OP_EX(mpz_tdiv_q, gmp_mpz_tdiv_q_ui, 1); DO_BINARY_UI_OP_EX(mpz_tdiv_q, gmp_mpz_tdiv_q_ui, 1);
case ZEND_MOD: case ZEND_MOD:
DO_BINARY_UI_OP_EX(mpz_mod, gmp_mpz_mod_ui, 1); DO_BINARY_UI_OP_EX(mpz_mod, gmp_mpz_mod_ui, 1);
case ZEND_SL: case ZEND_SL:
shift_operator_helper(mpz_mul_2exp, result, op1, op2, opcode); return shift_operator_helper(mpz_mul_2exp, result, op1, op2, opcode);
return SUCCESS;
case ZEND_SR: case ZEND_SR:
shift_operator_helper(mpz_fdiv_q_2exp, result, op1, op2, opcode); return shift_operator_helper(mpz_fdiv_q_2exp, result, op1, op2, opcode);
return SUCCESS;
case ZEND_BW_OR: case ZEND_BW_OR:
DO_BINARY_OP(mpz_ior); DO_BINARY_OP(mpz_ior);
case ZEND_BW_AND: case ZEND_BW_AND:
@ -619,6 +680,13 @@ static zend_result convert_to_gmp(mpz_t gmpnumber, zval *val, zend_long base, ui
case IS_STRING: { case IS_STRING: {
return convert_zstr_to_gmp(gmpnumber, Z_STR_P(val), base, arg_pos); return convert_zstr_to_gmp(gmpnumber, Z_STR_P(val), base, arg_pos);
} }
case IS_NULL:
/* Just reject null for operator overloading */
if (arg_pos == 0) {
zend_type_error("Number must be of type GMP|string|int, %s given", zend_zval_type_name(val));
return FAILURE;
}
ZEND_FALLTHROUGH;
default: { default: {
zend_long lval; zend_long lval;
if (!zend_parse_arg_long_slow(val, &lval, arg_pos)) { if (!zend_parse_arg_long_slow(val, &lval, arg_pos)) {

53
ext/gmp/tests/overloading_cmp_op_with_null.phpt Normal file
View file

@ -0,0 +1,53 @@
--TEST--
GMP comparison operator overloading supports null
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
try {
var_dump($num < null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num > null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num <= null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >= null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num == null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num <=> null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
bool(false)
bool(true)
bool(false)
bool(true)
bool(false)
int(1)

84
ext/gmp/tests/overloading_with_array.phpt Normal file
View file

@ -0,0 +1,84 @@
--TEST--
GMP operator overloading does not support []
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
try {
var_dump($num + []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> []);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
TypeError: Number must be of type GMP|string|int, array given
TypeError: Number must be of type GMP|string|int, array given
TypeError: Number must be of type GMP|string|int, array given
TypeError: Number must be of type GMP|string|int, array given
TypeError: Number must be of type GMP|string|int, array given
TypeError: Unsupported operand types: GMP ** array
TypeError: Number must be of type GMP|string|int, array given
TypeError: Number must be of type GMP|string|int, array given
TypeError: Number must be of type GMP|string|int, array given
TypeError: Unsupported operand types: GMP << array
TypeError: Unsupported operand types: GMP >> array

117
ext/gmp/tests/overloading_with_float.phpt Normal file
View file

@ -0,0 +1,117 @@
--TEST--
GMP operator overloading does support float with no fractional
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
try {
var_dump($num + 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> 42.0);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
object(GMP)#2 (1) {
["num"]=>
string(2) "84"
}
object(GMP)#2 (1) {
["num"]=>
string(1) "0"
}
object(GMP)#2 (1) {
["num"]=>
string(4) "1764"
}
object(GMP)#2 (1) {
["num"]=>
string(1) "1"
}
object(GMP)#2 (1) {
["num"]=>
string(1) "0"
}
object(GMP)#2 (1) {
["num"]=>
string(69) "150130937545296572356771972164254457814047970568738777235893533016064"
}
object(GMP)#2 (1) {
["num"]=>
string(2) "42"
}
object(GMP)#2 (1) {
["num"]=>
string(2) "42"
}
object(GMP)#2 (1) {
["num"]=>
string(1) "0"
}
object(GMP)#2 (1) {
["num"]=>
string(15) "184717953466368"
}
object(GMP)#2 (1) {
["num"]=>
string(1) "0"
}

132
ext/gmp/tests/overloading_with_float_fractional.phpt Normal file
View file

@ -0,0 +1,132 @@
--TEST--
GMP operator overloading support for float with fractional is deprecated
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
try {
var_dump($num + 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> 42.5);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECTF--
Deprecated: Implicit conversion from float 42.5 to int loses precision in %s on line %d
object(GMP)#2 (1) {
["num"]=>
string(2) "84"
}
Deprecated: Implicit conversion from float 42.5 to int loses precision in %s on line %d
object(GMP)#2 (1) {
["num"]=>
string(1) "0"
}
Deprecated: Implicit conversion from float 42.5 to int loses precision in %s on line %d
object(GMP)#2 (1) {
["num"]=>
string(4) "1764"
}
Deprecated: Implicit conversion from float 42.5 to int loses precision in %s on line %d
object(GMP)#2 (1) {
["num"]=>
string(1) "1"
}
Deprecated: Implicit conversion from float 42.5 to int loses precision in %s on line %d
object(GMP)#2 (1) {
["num"]=>
string(1) "0"
}
object(GMP)#2 (1) {
["num"]=>
string(69) "150130937545296572356771972164254457814047970568738777235893533016064"
}
Deprecated: Implicit conversion from float 42.5 to int loses precision in %s on line %d
object(GMP)#2 (1) {
["num"]=>
string(2) "42"
}
Deprecated: Implicit conversion from float 42.5 to int loses precision in %s on line %d
object(GMP)#2 (1) {
["num"]=>
string(2) "42"
}
Deprecated: Implicit conversion from float 42.5 to int loses precision in %s on line %d
object(GMP)#2 (1) {
["num"]=>
string(1) "0"
}
object(GMP)#2 (1) {
["num"]=>
string(15) "184717953466368"
}
object(GMP)#2 (1) {
["num"]=>
string(1) "0"
}

84
ext/gmp/tests/overloading_with_float_string.phpt Normal file
View file

@ -0,0 +1,84 @@
--TEST--
GMP operator overloading does not support float strings
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
try {
var_dump($num + "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> "2.0");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string

117
ext/gmp/tests/overloading_with_int_string.phpt Normal file
View file

@ -0,0 +1,117 @@
--TEST--
GMP operator overloading does support int strings
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
try {
var_dump($num + "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> "2");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
object(GMP)#2 (1) {
["num"]=>
string(2) "44"
}
object(GMP)#2 (1) {
["num"]=>
string(2) "40"
}
object(GMP)#2 (1) {
["num"]=>
string(2) "84"
}
object(GMP)#2 (1) {
["num"]=>
string(2) "21"
}
object(GMP)#2 (1) {
["num"]=>
string(1) "0"
}
object(GMP)#2 (1) {
["num"]=>
string(4) "1764"
}
object(GMP)#2 (1) {
["num"]=>
string(2) "42"
}
object(GMP)#2 (1) {
["num"]=>
string(1) "2"
}
object(GMP)#2 (1) {
["num"]=>
string(2) "40"
}
object(GMP)#2 (1) {
["num"]=>
string(3) "168"
}
object(GMP)#2 (1) {
["num"]=>
string(2) "10"
}

84
ext/gmp/tests/overloading_with_non_numeric_string.phpt Normal file
View file

@ -0,0 +1,84 @@
--TEST--
GMP operator overloading does not support non-numeric strings
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
try {
var_dump($num + "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> "string");
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string
ValueError: Number is not an integer string

84
ext/gmp/tests/overloading_with_null.phpt Normal file
View file

@ -0,0 +1,84 @@
--TEST--
GMP operator overloading does not support null
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
try {
var_dump($num + null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> null);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
TypeError: Number must be of type GMP|string|int, null given
TypeError: Number must be of type GMP|string|int, null given
TypeError: Number must be of type GMP|string|int, null given
TypeError: Number must be of type GMP|string|int, null given
TypeError: Number must be of type GMP|string|int, null given
TypeError: Unsupported operand types: GMP ** null
TypeError: Number must be of type GMP|string|int, null given
TypeError: Number must be of type GMP|string|int, null given
TypeError: Number must be of type GMP|string|int, null given
TypeError: Unsupported operand types: GMP << null
TypeError: Unsupported operand types: GMP >> null

85
ext/gmp/tests/overloading_with_object_not_stringable.phpt Normal file
View file

@ -0,0 +1,85 @@
--TEST--
GMP operator overloading does not support non-stringable objects
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
$o = new stdClass();
try {
var_dump($num + $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
TypeError: Number must be of type GMP|string|int, stdClass given
TypeError: Number must be of type GMP|string|int, stdClass given
TypeError: Number must be of type GMP|string|int, stdClass given
TypeError: Number must be of type GMP|string|int, stdClass given
TypeError: Number must be of type GMP|string|int, stdClass given
TypeError: Unsupported operand types: GMP ** stdClass
TypeError: Number must be of type GMP|string|int, stdClass given
TypeError: Number must be of type GMP|string|int, stdClass given
TypeError: Number must be of type GMP|string|int, stdClass given
TypeError: Unsupported operand types: GMP << stdClass
TypeError: Unsupported operand types: GMP >> stdClass

91
ext/gmp/tests/overloading_with_object_stringable.phpt Normal file
View file

@ -0,0 +1,91 @@
--TEST--
GMP operator overloading does not support stringable objects
--EXTENSIONS--
gmp
--FILE--
<?php
class T {
public function __toString() {
return "42";
}
}
$num = gmp_init(42);
$o = new T();
try {
var_dump($num + $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> $o);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECTF--
TypeError: Number must be of type GMP|string|int, T given
TypeError: Number must be of type GMP|string|int, T given
TypeError: Number must be of type GMP|string|int, T given
TypeError: Number must be of type GMP|string|int, T given
TypeError: Number must be of type GMP|string|int, T given
TypeError: Unsupported operand types: GMP ** T
TypeError: Number must be of type GMP|string|int, T given
TypeError: Number must be of type GMP|string|int, T given
TypeError: Number must be of type GMP|string|int, T given
TypeError: Unsupported operand types: GMP << T
TypeError: Unsupported operand types: GMP >> T

84
ext/gmp/tests/overloading_with_resource.phpt Normal file
View file

@ -0,0 +1,84 @@
--TEST--
GMP operator overloading does not support resources
--EXTENSIONS--
gmp
--FILE--
<?php
$num = gmp_init(42);
try {
var_dump($num + STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num - STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num * STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num / STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num % STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ** STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num | STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num & STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num ^ STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num << STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
try {
var_dump($num >> STDERR);
} catch (Throwable $e) {
echo $e::class, ': ', $e->getMessage(), PHP_EOL;
}
?>
--EXPECT--
TypeError: Number must be of type GMP|string|int, resource given
TypeError: Number must be of type GMP|string|int, resource given
TypeError: Number must be of type GMP|string|int, resource given
TypeError: Number must be of type GMP|string|int, resource given
TypeError: Number must be of type GMP|string|int, resource given
TypeError: Unsupported operand types: GMP ** resource
TypeError: Number must be of type GMP|string|int, resource given
TypeError: Number must be of type GMP|string|int, resource given
TypeError: Number must be of type GMP|string|int, resource given
TypeError: Unsupported operand types: GMP << resource
TypeError: Unsupported operand types: GMP >> resource