From 465f4b7b72a17102e91f05f5d36d024b73e3787c Mon Sep 17 00:00:00 2001 From: valmat Date: Thu, 27 Mar 2014 22:44:38 +0600 Subject: Fix test value-casting-operators --- tests/cpp/include/doubl2str.h | 102 ++++++++++++++++++++++++++++++++++++++++++ tests/cpp/include/variables.h | 36 +++++++++++---- tests/cpp/main.cpp | 5 ++- 3 files changed, 132 insertions(+), 11 deletions(-) create mode 100644 tests/cpp/include/doubl2str.h (limited to 'tests/cpp') diff --git a/tests/cpp/include/doubl2str.h b/tests/cpp/include/doubl2str.h new file mode 100644 index 0000000..1a5e3fc --- /dev/null +++ b/tests/cpp/include/doubl2str.h @@ -0,0 +1,102 @@ +/** + * + * double -> string + * + */ + + + +char num2char(unsigned int num) +{ + switch(num) + { + case 0: + return '0'; + case 1: + return '1'; + case 2: + return '2'; + case 3: + return '3'; + case 4: + return '4'; + case 5: + return '5'; + case 6: + return '6'; + case 7: + return '7'; + case 8: + return '8'; + case 9: + return '9'; + } + + //return '\0'; + return '-'; +} + +std::string double2str(long double D) +{ + int sign = (D > 0) ? 1 : (D*=-1.0, -1); + unsigned long long int Ceil = D; + + // if D is ceil + if(Ceil == D) + { + return std::to_string( (long long)(D*sign) ); + } + + // size of result buffer + const int bs = 32; + + // size of temporary buffer + const int pw = 16; + // Temporary buffer + char buf[pw]; + // Result buffer + char rez[bs]; + + int i, size = 0; + // set sign + if(sign < 0) rez[size++] = '-'; + + // set ceil + std::string sceil = std::to_string(Ceil); + const char * bceil = sceil.c_str(); + int sceillen = sceil.size(); + for(i = 0; i < sceillen; i++) + { + rez[size++] = bceil[i]; + } + + // set point + rez[size++] = '.'; + + unsigned long long int I = D * 10000000000000000; // D * 10**pw + // .14159265359 -> 14159265359000000 + I -= Ceil * 10000000000000000; + + // Remove the tail of zeros + // 14159265359000000 -> 14159265359 + while(0 == I % 10) I /= 10; + + int ind = 0; + while(I > 0) + { + buf[ind++] = num2char(I%10); + I = (I - I%10) / 10; + } + + // set fraction part + for(i = 0; i < ind; i++) + { + rez[size] = buf[ind-i-1]; + size++; + } + + return std::string(rez, size); + //rez[size] = '\0'; +} + + diff --git a/tests/cpp/include/variables.h b/tests/cpp/include/variables.h index f242653..b7063ef 100644 --- a/tests/cpp/include/variables.h +++ b/tests/cpp/include/variables.h @@ -4,6 +4,8 @@ * */ + #include "doubl2str.h" + /** * Set up namespace */ @@ -120,20 +122,36 @@ namespace TestVariables { return r; } + /* - * Test Php::Value casting operators - */ + * Test Php::Value casting operators + */ void value_casting(Php::Parameters ¶ms) { - Php::Value value = params[0]; + Php::Value value = params[0]; - long value1 = value; - std::string value2 = value; - //long double value3 = value; // <------------ error: conversion from ‘Php::Value’ to ‘long double’ is ambiguous - double value3 = value; - bool value4 = value; + long value1 = value; + std::string value2 = value; + bool value4 = value; - Php::out << " long:" << value1 << "\n string:" << value2 << "\n double:" << value3 << "\n bool:" << bool2str(value4) << std::endl; + Php::out << " long:" << value1 << "\n string:" << value2 << "\n bool:" << bool2str(value4) << std::endl; + } + + + /* + * Test Php::Value casting operators + */ + void value_cast2double(Php::Parameters ¶ms) + { + Php::Value value = params[0]; + double value3 = value; + + /* + * The remark (from valmat). + * Somehow std::to_string truncates the tail of numbers of type `double` when converting it to a string. + * So I wrote my own function `double2str()`, which does not have this drawback. + */ + Php::out << double2str(value3) << std::endl; } /* diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp index 2928f60..6b1502b 100644 --- a/tests/cpp/main.cpp +++ b/tests/cpp/main.cpp @@ -63,11 +63,12 @@ extern "C" extension.add("TestVariables\\value_types", TestVariables::value_types); extension.add("TestVariables\\scalar_store", TestVariables::scalar_store); extension.add("TestVariables\\value_casting", TestVariables::value_casting); + extension.add("TestVariables\\value_cast2double", TestVariables::value_cast2double); extension.add("TestVariables\\value_cast2str", TestVariables::value_cast2str); extension.add("TestVariables\\overloaded_op", TestVariables::overloaded_op); extension.add("TestVariables\\value_arrays", TestVariables::value_arrays); - extension.add("TestVariables\\value_object1", TestVariables::value_object1); - extension.add("TestVariables\\value_object2", TestVariables::value_object2); + extension.add("TestVariables\\value_object1", TestVariables::value_object1); + extension.add("TestVariables\\value_object2", TestVariables::value_object2); -- cgit v1.2.3 From b2e2aa93754a12fac360e8de5196e45cd2f0f2aa Mon Sep 17 00:00:00 2001 From: valmat Date: Thu, 27 Mar 2014 23:36:57 +0600 Subject: add test: 007-Iterate-internal-array.phpt Iterate internal array --- tests/cpp/include/ValueIterator.h | 27 ++++++++++++++++++++++ tests/cpp/main.cpp | 1 + tests/php/dbg.php | 3 +++ .../valueiterator/007-Iterate-internal-array.phpt | 15 ++++++++++++ 4 files changed, 46 insertions(+) create mode 100644 tests/php/phpt/valueiterator/007-Iterate-internal-array.phpt (limited to 'tests/cpp') diff --git a/tests/cpp/include/ValueIterator.h b/tests/cpp/include/ValueIterator.h index a9329c9..689797a 100644 --- a/tests/cpp/include/ValueIterator.h +++ b/tests/cpp/include/ValueIterator.h @@ -19,6 +19,33 @@ namespace TestValueIterator { } return; } + + void loopArray(void) + { + + Php::Value value; + /* + If we fill the array in this form, we get the following: + *** Error in `/usr/bin/php': double free or corruption (fasttop): 0x0000000001956d60 *** + value[0] = "val0"; + value[1] = "val1"; + value["third"] = "val3"; + value["fourth"] = "val3"; + */ + value.set(0 , "val0"); + value.set(1 , "val1"); + value.set("third" , "val3"); + value.set("fourth", "val3"); + + std::cout << "Array/Object contains " << value.size() << " items" << std::endl; + // assum the value variable holds an array or object, it then + // is possible to iterator over the values or properties + for (auto &iter : value) + { + // output key and value + Php::out << "["<< iter.first << "]="<< iter.second << std::endl; + } + } /** * End of namespace diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp index 6b1502b..4e781d2 100644 --- a/tests/cpp/main.cpp +++ b/tests/cpp/main.cpp @@ -52,6 +52,7 @@ extern "C" // add function to extension //extension.add("TestValueIterator\\loopValue", TestValueIterator::loopValue/*, { extension.add("TestValueIterator\\loopValue", TestValueIterator::loopValue); + extension.add("TestValueIterator\\loopArray", TestValueIterator::loopArray); /** diff --git a/tests/php/dbg.php b/tests/php/dbg.php index 9a28fc6..4728700 100644 --- a/tests/php/dbg.php +++ b/tests/php/dbg.php @@ -11,3 +11,6 @@ + +//--------- +TestValueIterator\loopArray(); \ No newline at end of file diff --git a/tests/php/phpt/valueiterator/007-Iterate-internal-array.phpt b/tests/php/phpt/valueiterator/007-Iterate-internal-array.phpt new file mode 100644 index 0000000..1f18203 --- /dev/null +++ b/tests/php/phpt/valueiterator/007-Iterate-internal-array.phpt @@ -0,0 +1,15 @@ +--TEST-- +Iterate internal array +--SKIPIF-- + +--FILEEOF-- + Date: Fri, 28 Mar 2014 00:05:14 +0600 Subject: add test variables/005-cast-objects-to-scalars.phpt --- tests/cpp/include/variables.h | 55 ++++++++++++++++++++++ tests/cpp/main.cpp | 4 ++ tests/php/dbg.php | 2 - .../variables/005-cast-objects-to-scalars.phpt | 22 +++++++++ tests/php/phpt/variables/readme | 4 ++ 5 files changed, 85 insertions(+), 2 deletions(-) create mode 100644 tests/php/phpt/variables/005-cast-objects-to-scalars.phpt (limited to 'tests/cpp') diff --git a/tests/cpp/include/variables.h b/tests/cpp/include/variables.h index b7063ef..e8cb526 100644 --- a/tests/cpp/include/variables.h +++ b/tests/cpp/include/variables.h @@ -289,6 +289,61 @@ namespace TestVariables { return object; } + /** + * A sample class, with methods to cast objects to scalars + */ + class Obj2Scalar : public Php::Base + { + public: + /** + * C++ constructor and C++ destructpr + */ + Obj2Scalar() {} + virtual ~Obj2Scalar() {} + + /** + * Cast to a string + * + * Note that now we use const char* as return value, and not Php::Value. + * The __toString function is detected at compile time, and it does + * not have a fixed signature. You can return any value that can be picked + * up by a Php::Value object. + * + * @return const char * + */ + const char *__toString() + { + return "Mount Meru, also called Sumeru (Sanskrit)"; + } + + /** + * Cast to a integer + * @return long + */ + long __toInteger() + { + return 27032014; + } + + /** + * Cast to a floating point number + * @return double + */ + double __toFloat() + { + return 3.14159265359; + } + + /** + * Cast to a boolean + * @return bool + */ + bool __toBool() + { + return true; + } + }; + /* * Test Php::Value resize */ diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp index 4e781d2..e5150ed 100644 --- a/tests/cpp/main.cpp +++ b/tests/cpp/main.cpp @@ -71,6 +71,10 @@ extern "C" extension.add("TestVariables\\value_object1", TestVariables::value_object1); extension.add("TestVariables\\value_object2", TestVariables::value_object2); + // A sample class, with methods to cast objects to scalars + Php::Class cObj2Scalar("Obj2Scalar"); + extension.add(std::move(cObj2Scalar)); + diff --git a/tests/php/dbg.php b/tests/php/dbg.php index 4728700..2040f01 100644 --- a/tests/php/dbg.php +++ b/tests/php/dbg.php @@ -12,5 +12,3 @@ -//--------- -TestValueIterator\loopArray(); \ No newline at end of file diff --git a/tests/php/phpt/variables/005-cast-objects-to-scalars.phpt b/tests/php/phpt/variables/005-cast-objects-to-scalars.phpt new file mode 100644 index 0000000..335acb7 --- /dev/null +++ b/tests/php/phpt/variables/005-cast-objects-to-scalars.phpt @@ -0,0 +1,22 @@ +--TEST-- +cast objects to scalars +--DESCRIPTION-- +http://www.phpcpp.com/documentation/special-features#casting-functions +--SKIPIF-- + +--FILEEOF-- + Date: Fri, 28 Mar 2014 00:42:09 +0600 Subject: add test: class_obj/003-comparable.phpt --- tests/cpp/include/Classes_and_objects.h | 122 +++++++++++++++++++++++++++ tests/cpp/include/MyCustomClass.h | 70 --------------- tests/cpp/main.cpp | 15 +++- tests/php/dbg.php | 34 ++++++++ tests/php/phpt/base/001.phpt | 14 --- tests/php/phpt/base/002.phpt | 14 --- tests/php/phpt/base/readme | 1 - tests/php/phpt/class_obj/001.phpt | 14 +++ tests/php/phpt/class_obj/002.phpt | 14 +++ tests/php/phpt/class_obj/003-comparable.phpt | 46 ++++++++++ tests/php/phpt/class_obj/readme | 1 + 11 files changed, 245 insertions(+), 100 deletions(-) create mode 100644 tests/cpp/include/Classes_and_objects.h delete mode 100644 tests/cpp/include/MyCustomClass.h delete mode 100644 tests/php/phpt/base/001.phpt delete mode 100644 tests/php/phpt/base/002.phpt delete mode 100644 tests/php/phpt/base/readme create mode 100644 tests/php/phpt/class_obj/001.phpt create mode 100644 tests/php/phpt/class_obj/002.phpt create mode 100644 tests/php/phpt/class_obj/003-comparable.phpt create mode 100644 tests/php/phpt/class_obj/readme (limited to 'tests/cpp') diff --git a/tests/cpp/include/Classes_and_objects.h b/tests/cpp/include/Classes_and_objects.h new file mode 100644 index 0000000..e9b7434 --- /dev/null +++ b/tests/cpp/include/Classes_and_objects.h @@ -0,0 +1,122 @@ +/** + * + * + * Classes_and_objects.h + * + */ + + +/** + * Set up namespace + */ +namespace TestBaseClass { + + + + class MyCustomClass : public Php::Base, public Php::Countable + { + private: + int _x = 3; + + public: + MyCustomClass() + { + std::cerr << "MyCustomClass::MyCustomClass()" << std::endl; + } + + MyCustomClass(int value) : _x(value) + { + std::cerr << "MyCustomClass::MyCustomClass(" << value << ")" << std::endl; + } + + MyCustomClass(const MyCustomClass &that) + { + //std::cerr << "MyCustomClass::MyCustomClass copy constructor" << std::endl; + } + + virtual ~MyCustomClass() + { + std::cerr << "MyCustomClass::~MyCustomClass" << std::endl; + } + + virtual long int count() override + { + return 33; + } + + Php::Value myMethod(Php::Parameters ¶ms) + { + // check number of parameters + //if (params.size() != 1) throw Php::Exception("Invalid number of parameters supplied"); + + std::cout << "myMethod is called for object " << _x << std::endl; + + return 5; + + } + }; + + + /** + * custom comparison operator + */ + class Comparable : public Php::Base + { + private: + /** + * Internal value of the class + * @var int + */ + static int count; + int _nom; + int _value; + + public: + /** + * C++ constructor + */ + Comparable() + { + // start with random value + //_value = rand(); + _nom = ++count; + _value = _nom%2+1; + } + + /** + * C++ destructor + */ + virtual ~Comparable() {} + + /** + * Cast the object to a string + * @return std::string + */ + std::string __toString() + { + return "Obj#" + std::to_string(_nom) + "(" + std::to_string(_value) + ")"; + } + + /** + * Compare with a different object + * @param that + * @return int + */ + int __compare(const Comparable &that) const + { + return _value - that._value; + } + }; + int Comparable::count = 0; + + + + + + +/** + * End of namespace + */ +} + + \ No newline at end of file diff --git a/tests/cpp/include/MyCustomClass.h b/tests/cpp/include/MyCustomClass.h deleted file mode 100644 index 02ff44b..0000000 --- a/tests/cpp/include/MyCustomClass.h +++ /dev/null @@ -1,70 +0,0 @@ -/** - * - * - * - * - */ - - -/** - * Set up namespace - */ -namespace TestBaseClass { - - -/** - * Namespace to use - */ - using namespace std; - - class MyCustomClass : public Php::Base, public Php::Countable - { - private: - int _x = 3; - - public: - MyCustomClass() - { - std::cerr << "MyCustomClass::MyCustomClass()" << std::endl; - } - - MyCustomClass(int value) : _x(value) - { - std::cerr << "MyCustomClass::MyCustomClass(" << value << ")" << std::endl; - } - - MyCustomClass(const MyCustomClass &that) - { - //std::cerr << "MyCustomClass::MyCustomClass copy constructor" << std::endl; - } - - virtual ~MyCustomClass() - { - std::cerr << "MyCustomClass::~MyCustomClass" << std::endl; - } - - virtual long int count() override - { - return 33; - } - - Php::Value myMethod(Php::Parameters ¶ms) - { - // check number of parameters - //if (params.size() != 1) throw Php::Exception("Invalid number of parameters supplied"); - - std::cout << "myMethod is called for object " << _x << std::endl; - - return 5; - - } - }; - - - -/** - * End of namespace - */ -} - - \ No newline at end of file diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp index e5150ed..7569a0b 100644 --- a/tests/cpp/main.cpp +++ b/tests/cpp/main.cpp @@ -9,7 +9,7 @@ // Test includes #include "include/ValueIterator.h" -#include "include/MyCustomClass.h" +#include "include/Classes_and_objects.h" #include "include/variables.h" @@ -33,7 +33,14 @@ extern "C" // add the interface to the extension //extension.add(interface); + + + + /** + * Classes and objects + * + */ // we are going to define a class Php::Class customClass("TestBaseClass\\MyClass"); @@ -45,6 +52,12 @@ extern "C" // add the class to the extension extension.add(customClass); + // Comparable + extension.add( Php::Class("TestBaseClass\\Comparable") ); + + + + /** * tests for Iterators * diff --git a/tests/php/dbg.php b/tests/php/dbg.php index 2040f01..b9841c7 100644 --- a/tests/php/dbg.php +++ b/tests/php/dbg.php @@ -12,3 +12,37 @@ +//- + +// initialize a couple of objects +$object1 = new TestBaseClass\Comparable(); +$object2 = new TestBaseClass\Comparable(); +$object3 = new TestBaseClass\Comparable(); + +// compare the objects +if ($object1 < $object2) +{ + echo("$object1 is smaller than $object2\n"); +} +else +{ + echo("$object1 is bigger than $object2\n"); +} + +if ($object1 == $object3) +{ + echo("$object1 is equal to $object3\n"); +} +else +{ + echo("$object1 is not equal to $object3\n"); +} + +if ($object1 != $object2) +{ + echo("$object1 is not equal to $object2\n"); +} +else +{ + echo("$object1 is equal to $object2\n"); +} \ No newline at end of file diff --git a/tests/php/phpt/base/001.phpt b/tests/php/phpt/base/001.phpt deleted file mode 100644 index b22a44c..0000000 --- a/tests/php/phpt/base/001.phpt +++ /dev/null @@ -1,14 +0,0 @@ ---TEST-- -Test constructor & destructor ---SKIPIF-- - ---FILEEOF-- - ---FILEEOF-- - +--FILEEOF-- + +--FILEEOF-- + +--FILEEOF-- + Date: Fri, 28 Mar 2014 02:34:51 +0600 Subject: add test: 004-static-funct.phpt (Test class with static function) --- tests/cpp/include/Classes_and_objects.h | 81 +++++++++++++++++++++++++- tests/cpp/main.cpp | 18 ++++++ tests/php/dbg.php | 35 ----------- tests/php/phpt/class_obj/003-comparable.phpt | 2 +- tests/php/phpt/class_obj/004-static-funct.phpt | 26 +++++++++ 5 files changed, 124 insertions(+), 38 deletions(-) create mode 100644 tests/php/phpt/class_obj/004-static-funct.phpt (limited to 'tests/cpp') diff --git a/tests/cpp/include/Classes_and_objects.h b/tests/cpp/include/Classes_and_objects.h index e9b7434..0977da9 100644 --- a/tests/cpp/include/Classes_and_objects.h +++ b/tests/cpp/include/Classes_and_objects.h @@ -49,7 +49,7 @@ namespace TestBaseClass { // check number of parameters //if (params.size() != 1) throw Php::Exception("Invalid number of parameters supplied"); - std::cout << "myMethod is called for object " << _x << std::endl; + Php::out << "myMethod is called for object " << _x << std::endl; return 5; @@ -58,7 +58,7 @@ namespace TestBaseClass { /** - * custom comparison operator + * Test custom comparison operator */ class Comparable : public Php::Base { @@ -110,6 +110,83 @@ namespace TestBaseClass { int Comparable::count = 0; + /** + * Begin test static functions + */ + + + /** + * Regular function + * + * Because a regular function does not have a 'this' pointer, + * it has the same signature as static methods + * + * @param params Parameters passed to the function + */ + void testStaticRegFunc(Php::Parameters ¶ms) + { + Php::out << "testStatic regular function"<< std::endl; + } + + /** + * A very simple class that will not be exported to PHP + */ + class testStaticPrivClass + { + public: + /** + * C++ constructor and destructor + */ + testStaticPrivClass() {} + virtual ~testStaticPrivClass() {} + + /** + * Static method + * + * A static method also has no 'this' pointer and has + * therefore a signature identical to regular functions + * + * @param params Parameters passed to the method + */ + static void staticMethod(Php::Parameters ¶ms) + { + Php::out << "testStaticPrivClass::staticMethod()"<< std::endl; + } + }; + + /** + * A very simple class that will be exported to PHP + */ + class testStaticPubClass : public Php::Base + { + public: + /** + * C++ constructor and destructor + */ + testStaticPubClass() {} + virtual ~testStaticPubClass() {} + + /** + * Another static method + * + * This static has exactly the same signature as the + * regular function and static method that were mentioned + * before + * + * @param params Parameters passed to the method + */ + static void staticMethod(Php::Parameters ¶ms) + { + Php::out << "testStaticPubClass::staticMethod()"<< std::endl; + } + }; + + + /** + * End test static functions + */ + + diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp index 7569a0b..b892b41 100644 --- a/tests/cpp/main.cpp +++ b/tests/cpp/main.cpp @@ -56,6 +56,24 @@ extern "C" extension.add( Php::Class("TestBaseClass\\Comparable") ); + // test static functions + // + // description of the class so that PHP knows which methods are accessible + Php::Class ClassWithStatic("TestBaseClass\\ClassWithStatic"); + // register the testStaticPubClass::staticMethod to be a static method callable from PHP + ClassWithStatic.method("static1", &TestBaseClass::testStaticPubClass::staticMethod); + // regular functions have the same signatures as static methods. So nothing forbids you to register a normal function as static method too + ClassWithStatic.method("static2", TestBaseClass::testStaticRegFunc); + // and even static methods from completely different classes have the same function signature and can thus be registered + ClassWithStatic.method("static3", &TestBaseClass::testStaticPrivClass::staticMethod); + // add the class to the extension + extension.add(std::move(ClassWithStatic)); + // In fact, because a static method has the same signature + // as a regular function, you can also register static + // C++ methods as regular global PHP functions + extension.add("TestBaseClass\\staticFun1", &TestBaseClass::testStaticPrivClass::staticMethod); + + /** diff --git a/tests/php/dbg.php b/tests/php/dbg.php index b9841c7..9a28fc6 100644 --- a/tests/php/dbg.php +++ b/tests/php/dbg.php @@ -11,38 +11,3 @@ - -//- - -// initialize a couple of objects -$object1 = new TestBaseClass\Comparable(); -$object2 = new TestBaseClass\Comparable(); -$object3 = new TestBaseClass\Comparable(); - -// compare the objects -if ($object1 < $object2) -{ - echo("$object1 is smaller than $object2\n"); -} -else -{ - echo("$object1 is bigger than $object2\n"); -} - -if ($object1 == $object3) -{ - echo("$object1 is equal to $object3\n"); -} -else -{ - echo("$object1 is not equal to $object3\n"); -} - -if ($object1 != $object2) -{ - echo("$object1 is not equal to $object2\n"); -} -else -{ - echo("$object1 is equal to $object2\n"); -} \ No newline at end of file diff --git a/tests/php/phpt/class_obj/003-comparable.phpt b/tests/php/phpt/class_obj/003-comparable.phpt index 8ffc076..3e0b1f6 100644 --- a/tests/php/phpt/class_obj/003-comparable.phpt +++ b/tests/php/phpt/class_obj/003-comparable.phpt @@ -1,5 +1,5 @@ --TEST-- -Test constructor & destructor +Test comparable objects --SKIPIF-- --FILEEOF-- diff --git a/tests/php/phpt/class_obj/004-static-funct.phpt b/tests/php/phpt/class_obj/004-static-funct.phpt new file mode 100644 index 0000000..8c78210 --- /dev/null +++ b/tests/php/phpt/class_obj/004-static-funct.phpt @@ -0,0 +1,26 @@ +--TEST-- +Test class with static function +--SKIPIF-- + +--FILEEOF-- + Date: Fri, 28 Mar 2014 19:00:17 +0600 Subject: Changed the structure of the test file. With the increasing number of tests the old structure became uncomfortable. --- tests/cpp/h/Classes_and_objects.h | 14 + tests/cpp/h/ValueIterator.h | 8 + tests/cpp/h/variables.h | 28 ++ tests/cpp/include/Classes_and_objects.h | 199 ----------- tests/cpp/include/ValueIterator.h | 54 --- tests/cpp/include/bool2str.h | 12 + tests/cpp/include/class_obj/001-002.h | 66 ++++ tests/cpp/include/class_obj/003-comparable.h | 74 +++++ tests/cpp/include/class_obj/004-static-funct.h | 90 +++++ tests/cpp/include/class_obj/tpl.h | 25 ++ tests/cpp/include/valueiterator/001-006.h | 27 ++ tests/cpp/include/valueiterator/007.h | 44 +++ tests/cpp/include/variables.h | 366 --------------------- tests/cpp/include/variables/001-process_globals.h | 57 ++++ .../cpp/include/variables/002-get_complex_array.h | 35 ++ tests/cpp/include/variables/003-value-types.h | 39 +++ .../include/variables/004-store-scalar-variables.h | 48 +++ .../variables/005-cast-objects-to-scalars.h | 75 +++++ tests/cpp/include/variables/006-casting-obj2str.h | 30 ++ .../include/variables/007-overloaded-operators.h | 46 +++ tests/cpp/include/variables/008-value-arrays.h | 57 ++++ tests/cpp/include/variables/009-010-value-object.h | 68 ++++ .../variables/011-012-value-casting-operators.h | 52 +++ tests/cpp/include/variables/tpl.h | 30 ++ tests/cpp/main.cpp | 9 +- .../variables/005-cast-objects-to-scalars.phpt | 4 +- 26 files changed, 932 insertions(+), 625 deletions(-) create mode 100644 tests/cpp/h/Classes_and_objects.h create mode 100644 tests/cpp/h/ValueIterator.h create mode 100644 tests/cpp/h/variables.h delete mode 100644 tests/cpp/include/Classes_and_objects.h delete mode 100644 tests/cpp/include/ValueIterator.h create mode 100644 tests/cpp/include/bool2str.h create mode 100644 tests/cpp/include/class_obj/001-002.h create mode 100644 tests/cpp/include/class_obj/003-comparable.h create mode 100644 tests/cpp/include/class_obj/004-static-funct.h create mode 100644 tests/cpp/include/class_obj/tpl.h create mode 100644 tests/cpp/include/valueiterator/001-006.h create mode 100644 tests/cpp/include/valueiterator/007.h delete mode 100644 tests/cpp/include/variables.h create mode 100644 tests/cpp/include/variables/001-process_globals.h create mode 100644 tests/cpp/include/variables/002-get_complex_array.h create mode 100644 tests/cpp/include/variables/003-value-types.h create mode 100644 tests/cpp/include/variables/004-store-scalar-variables.h create mode 100644 tests/cpp/include/variables/005-cast-objects-to-scalars.h create mode 100644 tests/cpp/include/variables/006-casting-obj2str.h create mode 100644 tests/cpp/include/variables/007-overloaded-operators.h create mode 100644 tests/cpp/include/variables/008-value-arrays.h create mode 100644 tests/cpp/include/variables/009-010-value-object.h create mode 100644 tests/cpp/include/variables/011-012-value-casting-operators.h create mode 100644 tests/cpp/include/variables/tpl.h (limited to 'tests/cpp') diff --git a/tests/cpp/h/Classes_and_objects.h b/tests/cpp/h/Classes_and_objects.h new file mode 100644 index 0000000..8404c69 --- /dev/null +++ b/tests/cpp/h/Classes_and_objects.h @@ -0,0 +1,14 @@ +/** + * + * + * Classes_and_objects.h + * + */ + +#include "../include/class_obj/001-002.h" +#include "../include/class_obj/003-comparable.h" +#include "../include/class_obj/004-static-funct.h" +//#include "../include/class_obj/.h" +//#include "../include/class_obj/.h" +//#include "../include/class_obj/.h" + diff --git a/tests/cpp/h/ValueIterator.h b/tests/cpp/h/ValueIterator.h new file mode 100644 index 0000000..b430008 --- /dev/null +++ b/tests/cpp/h/ValueIterator.h @@ -0,0 +1,8 @@ +/** + * + * TestValueIterator + * + */ + +#include "../include/valueiterator/001-006.h" +#include "../include/valueiterator/007.h" diff --git a/tests/cpp/h/variables.h b/tests/cpp/h/variables.h new file mode 100644 index 0000000..e884481 --- /dev/null +++ b/tests/cpp/h/variables.h @@ -0,0 +1,28 @@ +/** + * + * Test variables + * + */ + +#include "../include/doubl2str.h" +#include "../include/bool2str.h" + +#include "../include/variables/001-process_globals.h" +#include "../include/variables/002-get_complex_array.h" +#include "../include/variables/003-value-types.h" +#include "../include/variables/004-store-scalar-variables.h" +#include "../include/variables/005-cast-objects-to-scalars.h" +#include "../include/variables/006-casting-obj2str.h" +#include "../include/variables/007-overloaded-operators.h" +#include "../include/variables/008-value-arrays.h" +#include "../include/variables/009-010-value-object.h" +#include "../include/variables/011-012-value-casting-operators.h" +//#include "../include/variables/.h" +//#include "../include/variables/.h" +//#include "../include/variables/.h" + + + + + + diff --git a/tests/cpp/include/Classes_and_objects.h b/tests/cpp/include/Classes_and_objects.h deleted file mode 100644 index 0977da9..0000000 --- a/tests/cpp/include/Classes_and_objects.h +++ /dev/null @@ -1,199 +0,0 @@ -/** - * - * - * Classes_and_objects.h - * - */ - - -/** - * Set up namespace - */ -namespace TestBaseClass { - - - - class MyCustomClass : public Php::Base, public Php::Countable - { - private: - int _x = 3; - - public: - MyCustomClass() - { - std::cerr << "MyCustomClass::MyCustomClass()" << std::endl; - } - - MyCustomClass(int value) : _x(value) - { - std::cerr << "MyCustomClass::MyCustomClass(" << value << ")" << std::endl; - } - - MyCustomClass(const MyCustomClass &that) - { - //std::cerr << "MyCustomClass::MyCustomClass copy constructor" << std::endl; - } - - virtual ~MyCustomClass() - { - std::cerr << "MyCustomClass::~MyCustomClass" << std::endl; - } - - virtual long int count() override - { - return 33; - } - - Php::Value myMethod(Php::Parameters ¶ms) - { - // check number of parameters - //if (params.size() != 1) throw Php::Exception("Invalid number of parameters supplied"); - - Php::out << "myMethod is called for object " << _x << std::endl; - - return 5; - - } - }; - - - /** - * Test custom comparison operator - */ - class Comparable : public Php::Base - { - private: - /** - * Internal value of the class - * @var int - */ - static int count; - int _nom; - int _value; - - public: - /** - * C++ constructor - */ - Comparable() - { - // start with random value - //_value = rand(); - _nom = ++count; - _value = _nom%2+1; - } - - /** - * C++ destructor - */ - virtual ~Comparable() {} - - /** - * Cast the object to a string - * @return std::string - */ - std::string __toString() - { - return "Obj#" + std::to_string(_nom) + "(" + std::to_string(_value) + ")"; - } - - /** - * Compare with a different object - * @param that - * @return int - */ - int __compare(const Comparable &that) const - { - return _value - that._value; - } - }; - int Comparable::count = 0; - - - /** - * Begin test static functions - */ - - - /** - * Regular function - * - * Because a regular function does not have a 'this' pointer, - * it has the same signature as static methods - * - * @param params Parameters passed to the function - */ - void testStaticRegFunc(Php::Parameters ¶ms) - { - Php::out << "testStatic regular function"<< std::endl; - } - - /** - * A very simple class that will not be exported to PHP - */ - class testStaticPrivClass - { - public: - /** - * C++ constructor and destructor - */ - testStaticPrivClass() {} - virtual ~testStaticPrivClass() {} - - /** - * Static method - * - * A static method also has no 'this' pointer and has - * therefore a signature identical to regular functions - * - * @param params Parameters passed to the method - */ - static void staticMethod(Php::Parameters ¶ms) - { - Php::out << "testStaticPrivClass::staticMethod()"<< std::endl; - } - }; - - /** - * A very simple class that will be exported to PHP - */ - class testStaticPubClass : public Php::Base - { - public: - /** - * C++ constructor and destructor - */ - testStaticPubClass() {} - virtual ~testStaticPubClass() {} - - /** - * Another static method - * - * This static has exactly the same signature as the - * regular function and static method that were mentioned - * before - * - * @param params Parameters passed to the method - */ - static void staticMethod(Php::Parameters ¶ms) - { - Php::out << "testStaticPubClass::staticMethod()"<< std::endl; - } - }; - - - /** - * End test static functions - */ - - - - - - -/** - * End of namespace - */ -} - - \ No newline at end of file diff --git a/tests/cpp/include/ValueIterator.h b/tests/cpp/include/ValueIterator.h deleted file mode 100644 index 689797a..0000000 --- a/tests/cpp/include/ValueIterator.h +++ /dev/null @@ -1,54 +0,0 @@ -/** - * - * TestValueIterator - * - */ - -/** - * Set up namespace - */ -namespace TestValueIterator { - - - void loopValue(Php::Parameters ¶ms) - { - std::cout << "Array/Object contains " << params[0].size() << " items" << std::endl; - for (auto it=params[0].begin(), itend = params[0].end(); it != itend; ++it) { - std::cout << "["<< it->first << "]="<< it->second << std::endl; - //std::cout << "["<< it->key() << "]="<< it->value() << std::endl; - } - return; - } - - void loopArray(void) - { - - Php::Value value; - /* - If we fill the array in this form, we get the following: - *** Error in `/usr/bin/php': double free or corruption (fasttop): 0x0000000001956d60 *** - value[0] = "val0"; - value[1] = "val1"; - value["third"] = "val3"; - value["fourth"] = "val3"; - */ - value.set(0 , "val0"); - value.set(1 , "val1"); - value.set("third" , "val3"); - value.set("fourth", "val3"); - - std::cout << "Array/Object contains " << value.size() << " items" << std::endl; - // assum the value variable holds an array or object, it then - // is possible to iterator over the values or properties - for (auto &iter : value) - { - // output key and value - Php::out << "["<< iter.first << "]="<< iter.second << std::endl; - } - } - -/** - * End of namespace - */ -} - diff --git a/tests/cpp/include/bool2str.h b/tests/cpp/include/bool2str.h new file mode 100644 index 0000000..26aac80 --- /dev/null +++ b/tests/cpp/include/bool2str.h @@ -0,0 +1,12 @@ +/** + * + * bool -> string + * + */ + + + +std::string bool2str(bool b) +{ + return b ? "Yes" : "No"; +} diff --git a/tests/cpp/include/class_obj/001-002.h b/tests/cpp/include/class_obj/001-002.h new file mode 100644 index 0000000..2a3b4df --- /dev/null +++ b/tests/cpp/include/class_obj/001-002.h @@ -0,0 +1,66 @@ +/** + * + * Test Classes and objects + * 001.phpt + * 002.phpt + * + */ + + + + +/** + * Set up namespace + */ +namespace TestBaseClass { + + + class MyCustomClass : public Php::Base, public Php::Countable + { + private: + int _x = 3; + + public: + MyCustomClass() + { + std::cerr << "MyCustomClass::MyCustomClass()" << std::endl; + } + + MyCustomClass(int value) : _x(value) + { + std::cerr << "MyCustomClass::MyCustomClass(" << value << ")" << std::endl; + } + + MyCustomClass(const MyCustomClass &that) + { + //std::cerr << "MyCustomClass::MyCustomClass copy constructor" << std::endl; + } + + virtual ~MyCustomClass() + { + std::cerr << "MyCustomClass::~MyCustomClass" << std::endl; + } + + virtual long int count() override + { + return 33; + } + + Php::Value myMethod(Php::Parameters ¶ms) + { + // check number of parameters + //if (params.size() != 1) throw Php::Exception("Invalid number of parameters supplied"); + + Php::out << "myMethod is called for object " << _x << std::endl; + + return 5; + + } + }; + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/class_obj/003-comparable.h b/tests/cpp/include/class_obj/003-comparable.h new file mode 100644 index 0000000..8a384dc --- /dev/null +++ b/tests/cpp/include/class_obj/003-comparable.h @@ -0,0 +1,74 @@ +/** + * + * Test Classes and objects + * 003-comparable.phpt + * + */ + + + + +/** + * Set up namespace + */ +namespace TestBaseClass { + + + /** + * Test custom comparison operator + */ + class Comparable : public Php::Base + { + private: + /** + * Internal value of the class + * @var int + */ + static int count; + int _nom; + int _value; + + public: + /** + * C++ constructor + */ + Comparable() + { + // start with random value + //_value = rand(); + _nom = ++count; + _value = _nom%2+1; + } + + /** + * C++ destructor + */ + virtual ~Comparable() {} + + /** + * Cast the object to a string + * @return std::string + */ + std::string __toString() + { + return "Obj#" + std::to_string(_nom) + "(" + std::to_string(_value) + ")"; + } + + /** + * Compare with a different object + * @param that + * @return int + */ + int __compare(const Comparable &that) const + { + return _value - that._value; + } + }; + int Comparable::count = 0; + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/class_obj/004-static-funct.h b/tests/cpp/include/class_obj/004-static-funct.h new file mode 100644 index 0000000..d6816ab --- /dev/null +++ b/tests/cpp/include/class_obj/004-static-funct.h @@ -0,0 +1,90 @@ +/** + * + * Test Classes and objects + * 004-static-funct.phpt + * test static functions + * + */ + + + + +/** + * Set up namespace + */ +namespace TestBaseClass { + + + /** + * Regular function + * + * Because a regular function does not have a 'this' pointer, + * it has the same signature as static methods + * + * @param params Parameters passed to the function + */ + void testStaticRegFunc(Php::Parameters ¶ms) + { + Php::out << "testStatic regular function"<< std::endl; + } + + /** + * A very simple class that will not be exported to PHP + */ + class testStaticPrivClass + { + public: + /** + * C++ constructor and destructor + */ + testStaticPrivClass() {} + virtual ~testStaticPrivClass() {} + + /** + * Static method + * + * A static method also has no 'this' pointer and has + * therefore a signature identical to regular functions + * + * @param params Parameters passed to the method + */ + static void staticMethod(Php::Parameters ¶ms) + { + Php::out << "testStaticPrivClass::staticMethod()"<< std::endl; + } + }; + + /** + * A very simple class that will be exported to PHP + */ + class testStaticPubClass : public Php::Base + { + public: + /** + * C++ constructor and destructor + */ + testStaticPubClass() {} + virtual ~testStaticPubClass() {} + + /** + * Another static method + * + * This static has exactly the same signature as the + * regular function and static method that were mentioned + * before + * + * @param params Parameters passed to the method + */ + static void staticMethod(Php::Parameters ¶ms) + { + Php::out << "testStaticPubClass::staticMethod()"<< std::endl; + } + }; + + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/class_obj/tpl.h b/tests/cpp/include/class_obj/tpl.h new file mode 100644 index 0000000..7dfdcfc --- /dev/null +++ b/tests/cpp/include/class_obj/tpl.h @@ -0,0 +1,25 @@ +/** + * + * Test Classes and objects + * phptname.phpt + * + */ + + + + +/** + * Set up namespace + */ +namespace TestBaseClass { + + + + + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/valueiterator/001-006.h b/tests/cpp/include/valueiterator/001-006.h new file mode 100644 index 0000000..0dc6778 --- /dev/null +++ b/tests/cpp/include/valueiterator/001-006.h @@ -0,0 +1,27 @@ +/** + * + * TestValueIterator + * test valueiterator/001.phpt-valueiterator/006.phpt + * + */ + +/** + * Set up namespace + */ +namespace TestValueIterator { + + + void loopValue(Php::Parameters ¶ms) + { + std::cout << "Array/Object contains " << params[0].size() << " items" << std::endl; + for (auto it=params[0].begin(), itend = params[0].end(); it != itend; ++it) { + std::cout << "["<< it->first << "]="<< it->second << std::endl; + //std::cout << "["<< it->key() << "]="<< it->value() << std::endl; + } + return; + } +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/valueiterator/007.h b/tests/cpp/include/valueiterator/007.h new file mode 100644 index 0000000..3cfcb59 --- /dev/null +++ b/tests/cpp/include/valueiterator/007.h @@ -0,0 +1,44 @@ +/** + * + * TestValueIterator + * test valueiterator/007.phpt + * + */ + +/** + * Set up namespace + */ +namespace TestValueIterator { + + void loopArray(void) + { + + Php::Value value; + /* + If we fill the array in this form, we get the following: + *** Error in `/usr/bin/php': double free or corruption (fasttop): 0x0000000001956d60 *** + value[0] = "val0"; + value[1] = "val1"; + value["third"] = "val3"; + value["fourth"] = "val3"; + */ + value.set(0 , "val0"); + value.set(1 , "val1"); + value.set("third" , "val3"); + value.set("fourth", "val3"); + + std::cout << "Array/Object contains " << value.size() << " items" << std::endl; + // assum the value variable holds an array or object, it then + // is possible to iterator over the values or properties + for (auto &iter : value) + { + // output key and value + Php::out << "["<< iter.first << "]="<< iter.second << std::endl; + } + } + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/variables.h b/tests/cpp/include/variables.h deleted file mode 100644 index e8cb526..0000000 --- a/tests/cpp/include/variables.h +++ /dev/null @@ -1,366 +0,0 @@ -/** - * - * Test variables - * - */ - - #include "doubl2str.h" - -/** - * Set up namespace - */ -namespace TestVariables { - - - /** - * process_globals() - * - * This function reads and modifies global variables - */ - Php::Value process_globals() - { - // all global variables can be accessed via the Php::GLOBALS variable, - // which is more or less the same as the PHP $_GLOBALS variable - - // set a global variable - Php::GLOBALS["a"] = 1; - - // increment a global variable - Php::GLOBALS["b"] += 1; - - // set a global variable to be an array - Php::GLOBALS["c"] = Php::Array(); - - // add a member to an array - Php::GLOBALS["c"]["member"] = 123; - - // and increment it - Php::GLOBALS["c"]["member"] += 77; - - // change value e - Php::GLOBALS["e"] = Php::GLOBALS["e"][0]("hello"); - - // if a global variable holds a function, we can call it - return Php::GLOBALS["d"](1,2,3); - } - - /** - * This function returns complex array - */ - Php::Value get_complex_array() - { - Php::Value r; - r["a"] = 123; - r["b"] = 456; - r["c"][0] = "nested value"; - r["c"][1] = "example"; - r["c"][2] = 7; - return r; - } - - - std::string bool2str(bool b) - { - return b ? "Yes" : "No"; - } - - /* - * Check type of value - * @param array - */ - void value_types(Php::Parameters ¶ms) { - if (params.size() == 0) { - return; - } - - Php::Value arr = params[0]; - - Php::out << "Null: " << bool2str( arr.get("Null").type() == Php::Type::Null ) << std::endl; - Php::out << "Numeric: " << bool2str( arr.get("Numeric").type() == Php::Type::Numeric ) << std::endl; - Php::out << "Float: " << bool2str( arr.get("Float").type() == Php::Type::Float ) << std::endl; - Php::out << "Bool: " << bool2str( arr.get("Bool").type() == Php::Type::Bool ) << std::endl; - Php::out << "Array: " << bool2str( arr.get("Array").type() == Php::Type::Array ) << std::endl; - Php::out << "Object: " << bool2str( arr.get("Object").type() == Php::Type::Object ) << std::endl; - Php::out << "String: " << bool2str( arr.get("String").type() == Php::Type::String ) << std::endl; - Php::out << "Resource: " << bool2str( arr.get("Resource").type() == Php::Type::Resource ) << std::endl; - Php::out << "Constant: " << bool2str( arr.get("Constant").type() == Php::Type::Constant ) << std::endl; - Php::out << "ConstantArray: " << bool2str( arr.get("ConstantArray").type() == Php::Type::ConstantArray ) << std::endl; - Php::out << "Callable1: " << bool2str( arr.get("Callable1").type() == Php::Type::Callable ) << std::endl; - Php::out << "Callable2: " << bool2str( arr.get("Callable2").type() == Php::Type::Callable ) << std::endl; - Php::out << "Callable3: " << bool2str( arr.get("Callable3").type() == Php::Type::Callable ) << std::endl; - Php::out << "Callable4: " << bool2str( arr.get("Callable4").type() == Php::Type::Callable ) << std::endl; - } - - /* - * Test variables defined in PHP-CPP - */ - Php::Value scalar_store(void) { - - Php::Value value1 = 1234; - Php::Value value2 = "this is a string"; - Php::Value value3 = std::string("another string"); - Php::Value value4 = nullptr; - Php::Value value5 = 123.45; - Php::Value value6 = true; - - Php::Value r; - r[0] = value1; - r[1] = value2; - r[2] = value3; - r[3] = value4; - r[4] = value5; - r[5] = value6; - - r[6] = 1234; - r[7] = "this is a string"; - r[8] = std::string("another string"); - r[9] = nullptr; - r[10] = Php::Value(); - r[11] = 123.45; - r[12] = false; - - return r; - } - - - /* - * Test Php::Value casting operators - */ - void value_casting(Php::Parameters ¶ms) - { - Php::Value value = params[0]; - - long value1 = value; - std::string value2 = value; - bool value4 = value; - - Php::out << " long:" << value1 << "\n string:" << value2 << "\n bool:" << bool2str(value4) << std::endl; - } - - - /* - * Test Php::Value casting operators - */ - void value_cast2double(Php::Parameters ¶ms) - { - Php::Value value = params[0]; - double value3 = value; - - /* - * The remark (from valmat). - * Somehow std::to_string truncates the tail of numbers of type `double` when converting it to a string. - * So I wrote my own function `double2str()`, which does not have this drawback. - */ - Php::out << double2str(value3) << std::endl; - } - - /* - * Test Php::Value casting operators - */ - void value_cast2str(Php::Parameters ¶ms) - { - std::string value = params[0]; - Php::out << value << std::endl; - } - - /* - * Test Php::Value overloaded operators - */ - void overloaded_op(Php::Parameters ¶ms) - { - Php::Value value = params[0]; - if (value == "some string") - { - Php::out << "value == 'some string'" << std::endl; - } - - if (value == 12) - { - Php::out << "value == 12" << std::endl; - } - else if (value > 100) - { - Php::out << "value > 100" << std::endl; - } - - value += 10; - Php::out << value << std::endl; - - int r1 = value - 8; - Php::out << r1 << std::endl; - - double r2 = value*123.45; - Php::out << r2 << std::endl; - - double r3 = value/123.45; - Php::out << r3 << std::endl; - - - - } - - /* - * Test Php::Value arrays - */ - Php::Value value_arrays(void) - { - // create a regular array - Php::Value array; - array[0] = "apple"; - array[1] = "banana"; - array[2] = "tomato"; - - // an initializer list can be used to create a filled array - Php::Value filled({ "a", "b", "c", "d"}); - - // create an associative array - Php::Value assoc; - assoc["apple"] = "green"; - assoc["banana"] = "yellow"; - assoc["tomato"] = "green"; - - // the variables in an array do not all have to be of the same type - Php::Value assoc2; - assoc2["x"] = "info@example.com"; - assoc2["y"] = nullptr; - assoc2["z"] = 123; - - // nested arrays are possible too - Php::Value assoc3; - assoc3["x"] = "info@example.com"; - assoc3["y"] = nullptr; - assoc3["z"][0] = "a"; - assoc3["z"][1] = "b"; - assoc3["z"][2] = "c"; - - Php::Value r; - r["array"] = array; - r["filled"] = filled; - r["assoc"] = assoc; - r["assoc2"] = assoc2; - r["assoc3"] = assoc3; - return r; - } - - /* - * Test Php::Value object - */ - Php::Value value_object1(void) - { - - // create empty object of type stdClass - Php::Object object; - - // object properties can be accessed with square brackets - object["property1"] = "value1"; - object["property2"] = "value2"; - - // Php::Value is the base class, so you can assign Php::Object objects - //Php::Value value = object; - - return object; - } - - /* - * Test Php::Value object - */ - Php::Value value_object2(void) - { - - // create empty object of type stdClass - Php::Object object; - - // to create an object of a different type, pass in the class name - // to the constructor with optional constructor parameters - //object = Php::Object("DateTime", "2014-03-27 00:37:15.638276"); - - auto timeZone = Php::Object("DateTimeZone", "Europe/Amsterdam"); - object = Php::Object("DateTime", "2014-03-27 00:37:15", timeZone); - - - // methods can be called with the call() method - Php::out << object.call("format", "Y-m-d H:i:s") << std::endl; - - // all these methods can be called on a Php::Value object too - Php::Value value = Php::Object("DateTime", "2016-03-31 15:48:00", timeZone); - Php::out << value.call("format", "Y-m-d H:i:s") << std::endl; - Php::out << value.call("getOffset") << std::endl; - - return object; - } - - /** - * A sample class, with methods to cast objects to scalars - */ - class Obj2Scalar : public Php::Base - { - public: - /** - * C++ constructor and C++ destructpr - */ - Obj2Scalar() {} - virtual ~Obj2Scalar() {} - - /** - * Cast to a string - * - * Note that now we use const char* as return value, and not Php::Value. - * The __toString function is detected at compile time, and it does - * not have a fixed signature. You can return any value that can be picked - * up by a Php::Value object. - * - * @return const char * - */ - const char *__toString() - { - return "Mount Meru, also called Sumeru (Sanskrit)"; - } - - /** - * Cast to a integer - * @return long - */ - long __toInteger() - { - return 27032014; - } - - /** - * Cast to a floating point number - * @return double - */ - double __toFloat() - { - return 3.14159265359; - } - - /** - * Cast to a boolean - * @return bool - */ - bool __toBool() - { - return true; - } - }; - - /* - * Test Php::Value resize - */ - void ghfghfhf2(Php::Parameters ¶ms) - { - - - } - - - - - - - -/** - * End of namespace - */ -} - diff --git a/tests/cpp/include/variables/001-process_globals.h b/tests/cpp/include/variables/001-process_globals.h new file mode 100644 index 0000000..ae930d2 --- /dev/null +++ b/tests/cpp/include/variables/001-process_globals.h @@ -0,0 +1,57 @@ +/** + * + * Test variables + * 001-process_globals.phpt + * Global variables in PHP-CPP + * + */ + + + + +/** + * Set up namespace + */ +namespace TestVariables { + + + + /** + * process_globals() + * + * This function reads and modifies global variables + */ + Php::Value process_globals() + { + // all global variables can be accessed via the Php::GLOBALS variable, + // which is more or less the same as the PHP $_GLOBALS variable + + // set a global variable + Php::GLOBALS["a"] = 1; + + // increment a global variable + Php::GLOBALS["b"] += 1; + + // set a global variable to be an array + Php::GLOBALS["c"] = Php::Array(); + + // add a member to an array + Php::GLOBALS["c"]["member"] = 123; + + // and increment it + Php::GLOBALS["c"]["member"] += 77; + + // change value e + Php::GLOBALS["e"] = Php::GLOBALS["e"][0]("hello"); + + // if a global variable holds a function, we can call it + return Php::GLOBALS["d"](1,2,3); + } + + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/variables/002-get_complex_array.h b/tests/cpp/include/variables/002-get_complex_array.h new file mode 100644 index 0000000..b12e5ee --- /dev/null +++ b/tests/cpp/include/variables/002-get_complex_array.h @@ -0,0 +1,35 @@ +/** + * + * Test variables + * 002-get_complex_array.phpt + * + */ + + + + +/** + * Set up namespace + */ +namespace TestVariables { + + /** + * This function returns complex array + */ + Php::Value get_complex_array() + { + Php::Value r; + r["a"] = 123; + r["b"] = 456; + r["c"][0] = "nested value"; + r["c"][1] = "example"; + r["c"][2] = 7; + return r; + } + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/variables/003-value-types.h b/tests/cpp/include/variables/003-value-types.h new file mode 100644 index 0000000..e1d31b9 --- /dev/null +++ b/tests/cpp/include/variables/003-value-types.h @@ -0,0 +1,39 @@ +/** + * + * Test variables + * 003-value-types.phpt + * + */ + + +namespace TestVariables { + + /* + * Check type of value + * @param array + */ + void value_types(Php::Parameters ¶ms) { + if (params.size() == 0) { + return; + } + + Php::Value arr = params[0]; + + Php::out << "Null: " << bool2str( arr.get("Null").type() == Php::Type::Null ) << std::endl; + Php::out << "Numeric: " << bool2str( arr.get("Numeric").type() == Php::Type::Numeric ) << std::endl; + Php::out << "Float: " << bool2str( arr.get("Float").type() == Php::Type::Float ) << std::endl; + Php::out << "Bool: " << bool2str( arr.get("Bool").type() == Php::Type::Bool ) << std::endl; + Php::out << "Array: " << bool2str( arr.get("Array").type() == Php::Type::Array ) << std::endl; + Php::out << "Object: " << bool2str( arr.get("Object").type() == Php::Type::Object ) << std::endl; + Php::out << "String: " << bool2str( arr.get("String").type() == Php::Type::String ) << std::endl; + Php::out << "Resource: " << bool2str( arr.get("Resource").type() == Php::Type::Resource ) << std::endl; + Php::out << "Constant: " << bool2str( arr.get("Constant").type() == Php::Type::Constant ) << std::endl; + Php::out << "ConstantArray: " << bool2str( arr.get("ConstantArray").type() == Php::Type::ConstantArray ) << std::endl; + Php::out << "Callable1: " << bool2str( arr.get("Callable1").type() == Php::Type::Callable ) << std::endl; + Php::out << "Callable2: " << bool2str( arr.get("Callable2").type() == Php::Type::Callable ) << std::endl; + Php::out << "Callable3: " << bool2str( arr.get("Callable3").type() == Php::Type::Callable ) << std::endl; + Php::out << "Callable4: " << bool2str( arr.get("Callable4").type() == Php::Type::Callable ) << std::endl; + } + +} + diff --git a/tests/cpp/include/variables/004-store-scalar-variables.h b/tests/cpp/include/variables/004-store-scalar-variables.h new file mode 100644 index 0000000..9ce82e5 --- /dev/null +++ b/tests/cpp/include/variables/004-store-scalar-variables.h @@ -0,0 +1,48 @@ +/** + * + * Test variables + * 004-store-scalar-variables.phpt + * + */ + +/** + * Set up namespace + */ +namespace TestVariables { + + /* + * Test variables defined in PHP-CPP + */ + Php::Value scalar_store(void) { + + Php::Value value1 = 1234; + Php::Value value2 = "this is a string"; + Php::Value value3 = std::string("another string"); + Php::Value value4 = nullptr; + Php::Value value5 = 123.45; + Php::Value value6 = true; + + Php::Value r; + r[0] = value1; + r[1] = value2; + r[2] = value3; + r[3] = value4; + r[4] = value5; + r[5] = value6; + + r[6] = 1234; + r[7] = "this is a string"; + r[8] = std::string("another string"); + r[9] = nullptr; + r[10] = Php::Value(); + r[11] = 123.45; + r[12] = false; + + return r; + } + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/variables/005-cast-objects-to-scalars.h b/tests/cpp/include/variables/005-cast-objects-to-scalars.h new file mode 100644 index 0000000..f053c4d --- /dev/null +++ b/tests/cpp/include/variables/005-cast-objects-to-scalars.h @@ -0,0 +1,75 @@ +/** + * + * Test variables + * 005-cast-objects-to-scalars.phpt + * + */ + + + +/** + * Set up namespace + */ +namespace TestVariables { + + /** + * A sample class, with methods to cast objects to scalars + */ + class Obj2Scalar : public Php::Base + { + public: + /** + * C++ constructor and C++ destructpr + */ + Obj2Scalar() {} + virtual ~Obj2Scalar() {} + + /** + * Cast to a string + * + * Note that now we use const char* as return value, and not Php::Value. + * The __toString function is detected at compile time, and it does + * not have a fixed signature. You can return any value that can be picked + * up by a Php::Value object. + * + * @return const char * + */ + const char *__toString() + { + return "Mount Meru, also called Sumeru (Sanskrit)"; + } + + /** + * Cast to a integer + * @return long + */ + long __toInteger() + { + return 27032014; + } + + /** + * Cast to a floating point number + * @return double + */ + double __toFloat() + { + return 3.14159265359; + } + + /** + * Cast to a boolean + * @return bool + */ + bool __toBool() + { + return true; + } + }; + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/variables/006-casting-obj2str.h b/tests/cpp/include/variables/006-casting-obj2str.h new file mode 100644 index 0000000..879683d --- /dev/null +++ b/tests/cpp/include/variables/006-casting-obj2str.h @@ -0,0 +1,30 @@ +/** + * + * Test variables + * 006-casting-obj2str.phpt + * + */ + + + +/** + * Set up namespace + */ +namespace TestVariables { + + + /* + * Test Php::Value casting operators + */ + void value_cast2str(Php::Parameters ¶ms) + { + std::string value = params[0]; + Php::out << value << std::endl; + } + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/variables/007-overloaded-operators.h b/tests/cpp/include/variables/007-overloaded-operators.h new file mode 100644 index 0000000..88b3117 --- /dev/null +++ b/tests/cpp/include/variables/007-overloaded-operators.h @@ -0,0 +1,46 @@ +/** + * + * Test variables + * 007-overloaded-operators.phpt + * + */ + + + +namespace TestVariables { + + /* + * Test Php::Value overloaded operators + */ + void overloaded_op(Php::Parameters ¶ms) + { + Php::Value value = params[0]; + if (value == "some string") + { + Php::out << "value == 'some string'" << std::endl; + } + + if (value == 12) + { + Php::out << "value == 12" << std::endl; + } + else if (value > 100) + { + Php::out << "value > 100" << std::endl; + } + + value += 10; + Php::out << value << std::endl; + + int r1 = value - 8; + Php::out << r1 << std::endl; + + double r2 = value*123.45; + Php::out << r2 << std::endl; + + double r3 = value/123.45; + Php::out << r3 << std::endl; + } + +} + diff --git a/tests/cpp/include/variables/008-value-arrays.h b/tests/cpp/include/variables/008-value-arrays.h new file mode 100644 index 0000000..937f79a --- /dev/null +++ b/tests/cpp/include/variables/008-value-arrays.h @@ -0,0 +1,57 @@ +/** + * + * Test variables + * 008-value-arrays.phpt + * + */ + + +namespace TestVariables { + + + /* + * Test Php::Value arrays + */ + Php::Value value_arrays(void) + { + // create a regular array + Php::Value array; + array[0] = "apple"; + array[1] = "banana"; + array[2] = "tomato"; + + // an initializer list can be used to create a filled array + Php::Value filled({ "a", "b", "c", "d"}); + + // create an associative array + Php::Value assoc; + assoc["apple"] = "green"; + assoc["banana"] = "yellow"; + assoc["tomato"] = "green"; + + // the variables in an array do not all have to be of the same type + Php::Value assoc2; + assoc2["x"] = "info@example.com"; + assoc2["y"] = nullptr; + assoc2["z"] = 123; + + // nested arrays are possible too + Php::Value assoc3; + assoc3["x"] = "info@example.com"; + assoc3["y"] = nullptr; + assoc3["z"][0] = "a"; + assoc3["z"][1] = "b"; + assoc3["z"][2] = "c"; + + Php::Value r; + r["array"] = array; + r["filled"] = filled; + r["assoc"] = assoc; + r["assoc2"] = assoc2; + r["assoc3"] = assoc3; + return r; + } + + +} + diff --git a/tests/cpp/include/variables/009-010-value-object.h b/tests/cpp/include/variables/009-010-value-object.h new file mode 100644 index 0000000..e3eba85 --- /dev/null +++ b/tests/cpp/include/variables/009-010-value-object.h @@ -0,0 +1,68 @@ +/** + * + * Test variables + * 009-value-object.phpt + * 010-value-object2.phpt + * + */ + + +/** + * Set up namespace + */ +namespace TestVariables { + + + /* + * Test Php::Value object + */ + Php::Value value_object1(void) + { + + // create empty object of type stdClass + Php::Object object; + + // object properties can be accessed with square brackets + object["property1"] = "value1"; + object["property2"] = "value2"; + + // Php::Value is the base class, so you can assign Php::Object objects + //Php::Value value = object; + + return object; + } + + /* + * Test Php::Value object + */ + Php::Value value_object2(void) + { + + // create empty object of type stdClass + Php::Object object; + + // to create an object of a different type, pass in the class name + // to the constructor with optional constructor parameters + //object = Php::Object("DateTime", "2014-03-27 00:37:15.638276"); + + auto timeZone = Php::Object("DateTimeZone", "Europe/Amsterdam"); + object = Php::Object("DateTime", "2014-03-27 00:37:15", timeZone); + + + // methods can be called with the call() method + Php::out << object.call("format", "Y-m-d H:i:s") << std::endl; + + // all these methods can be called on a Php::Value object too + Php::Value value = Php::Object("DateTime", "2016-03-31 15:48:00", timeZone); + Php::out << value.call("format", "Y-m-d H:i:s") << std::endl; + Php::out << value.call("getOffset") << std::endl; + + return object; + } + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/variables/011-012-value-casting-operators.h b/tests/cpp/include/variables/011-012-value-casting-operators.h new file mode 100644 index 0000000..182054b --- /dev/null +++ b/tests/cpp/include/variables/011-012-value-casting-operators.h @@ -0,0 +1,52 @@ +/** + * + * Test variables + * 011-value-casting-operators.phpt + * 012-value-casting-operators-double.phpt + * + */ + + + +/** + * Set up namespace + */ +namespace TestVariables { + + /* + * Test Php::Value casting operators + */ + void value_casting(Php::Parameters ¶ms) + { + Php::Value value = params[0]; + + long value1 = value; + std::string value2 = value; + bool value4 = value; + + Php::out << " long:" << value1 << "\n string:" << value2 << "\n bool:" << bool2str(value4) << std::endl; + } + + + /* + * Test Php::Value casting operators + */ + void value_cast2double(Php::Parameters ¶ms) + { + Php::Value value = params[0]; + double value3 = value; + + /* + * The remark (from valmat). + * Somehow std::to_string truncates the tail of numbers of type `double` when converting it to a string. + * So I wrote my own function `double2str()`, which does not have this drawback. + */ + Php::out << double2str(value3) << std::endl; + } + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/include/variables/tpl.h b/tests/cpp/include/variables/tpl.h new file mode 100644 index 0000000..3c4ed7c --- /dev/null +++ b/tests/cpp/include/variables/tpl.h @@ -0,0 +1,30 @@ +/** + * + * Test variables + * phptname.phpt + * + */ + + + + +/** + * Set up namespace + */ +namespace TestVariables { + + + /* + * Test + */ + void fnname(Php::Parameters ¶ms) + { + + + } + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp index b892b41..c1e33b1 100644 --- a/tests/cpp/main.cpp +++ b/tests/cpp/main.cpp @@ -8,9 +8,9 @@ #include // Test includes -#include "include/ValueIterator.h" -#include "include/Classes_and_objects.h" -#include "include/variables.h" +#include "h/ValueIterator.h" +#include "h/Classes_and_objects.h" +#include "h/variables.h" @@ -90,6 +90,7 @@ extern "C" * tests for variables * */ + // create a nested namespace extension.add("TestVariables\\process_globals", TestVariables::process_globals); extension.add("TestVariables\\get_complex_array", TestVariables::get_complex_array); extension.add("TestVariables\\value_types", TestVariables::value_types); @@ -103,7 +104,7 @@ extern "C" extension.add("TestVariables\\value_object2", TestVariables::value_object2); // A sample class, with methods to cast objects to scalars - Php::Class cObj2Scalar("Obj2Scalar"); + Php::Class cObj2Scalar("TestVariables\\Obj2Scalar"); extension.add(std::move(cObj2Scalar)); diff --git a/tests/php/phpt/variables/005-cast-objects-to-scalars.phpt b/tests/php/phpt/variables/005-cast-objects-to-scalars.phpt index 335acb7..9de9ba5 100644 --- a/tests/php/phpt/variables/005-cast-objects-to-scalars.phpt +++ b/tests/php/phpt/variables/005-cast-objects-to-scalars.phpt @@ -11,7 +11,7 @@ http://www.phpcpp.com/documentation/special-features#casting-functions function bool2str($b) { return $b ? "Yes" : "No"; } -$obj = new Obj2Scalar(); +$obj = new TestVariables\Obj2Scalar(); echo " long: ", (int)$obj, "\n string: ", (string)$obj, "\n double: ", (double)$obj, "\n bool: ", bool2str((bool)$obj); @@ -19,4 +19,4 @@ echo " long: ", (int)$obj, "\n string: ", (string)$obj, "\n double: ", (doubl long: 27032014 string: Mount Meru, also called Sumeru (Sanskrit) double: 3.14159265359 - bool: Yes \ No newline at end of file + bool: Yes -- cgit v1.2.3 From 168eeabc6e52165a71a3130c5e0f26a7fd9382c9 Mon Sep 17 00:00:00 2001 From: valmat Date: Fri, 28 Mar 2014 20:18:15 +0600 Subject: add new tests: Test call function --- tests/cpp/h/variables.h | 2 +- .../variables/013-017-calling-php-functions.h | 87 ++++++++++++++++ tests/cpp/main.cpp | 4 + tests/php/dbg.php | 1 + tests/php/php_alias.sh | 2 +- .../phpt/variables/013-calling-php-functions.phpt | 113 ++++++++++++++++++++ .../phpt/variables/014-calling-php-functions.phpt | 113 ++++++++++++++++++++ .../phpt/variables/015-calling-php-functions.phpt | 109 +++++++++++++++++++ .../phpt/variables/016-calling-php-functions.phpt | 113 ++++++++++++++++++++ .../phpt/variables/017-calling-php-functions.phpt | 115 +++++++++++++++++++++ 10 files changed, 657 insertions(+), 2 deletions(-) create mode 100644 tests/cpp/include/variables/013-017-calling-php-functions.h create mode 100644 tests/php/phpt/variables/013-calling-php-functions.phpt create mode 100644 tests/php/phpt/variables/014-calling-php-functions.phpt create mode 100644 tests/php/phpt/variables/015-calling-php-functions.phpt create mode 100644 tests/php/phpt/variables/016-calling-php-functions.phpt create mode 100644 tests/php/phpt/variables/017-calling-php-functions.phpt (limited to 'tests/cpp') diff --git a/tests/cpp/h/variables.h b/tests/cpp/h/variables.h index e884481..df0d923 100644 --- a/tests/cpp/h/variables.h +++ b/tests/cpp/h/variables.h @@ -17,7 +17,7 @@ #include "../include/variables/008-value-arrays.h" #include "../include/variables/009-010-value-object.h" #include "../include/variables/011-012-value-casting-operators.h" -//#include "../include/variables/.h" +#include "../include/variables/013-017-calling-php-functions.h" //#include "../include/variables/.h" //#include "../include/variables/.h" diff --git a/tests/cpp/include/variables/013-017-calling-php-functions.h b/tests/cpp/include/variables/013-017-calling-php-functions.h new file mode 100644 index 0000000..94367e0 --- /dev/null +++ b/tests/cpp/include/variables/013-017-calling-php-functions.h @@ -0,0 +1,87 @@ +/** + * + * Test call function + * 013-calling-php-functions.phpt + * ... + * 017-calling-php-functions.phpt + * + */ + + +/** + * Set up namespace + */ +namespace TestVariables { + + + /* + * Test call function from user space + */ + void fnFromUserSpace(void) + { + + + Php::out << "fnFromUserSpace" << std::endl; + + Php::Value param5; + param5.set(0, "param5"); + param5.set(1, 3.14159265359); + param5.set(2, 28032014); + param5.set("key", "value"); + + auto timeZone = Php::Object("DateTimeZone", "Asia/Yekaterinburg"); + Php::Value param6 = Php::Object("DateTime", "2014-03-28 19:42:15", timeZone); + + // call a function from user space + Php::call("some_function", "param1"); + Php::call("some_function", "param1", "param2"); + Php::call("some_function", "param1", "param2", "param3"); + Php::call("some_function", "param1", "param2", "param3", "param4"); + Php::call("some_function", "param1", "param2", "param3", "param4", param5); + Php::call("some_function", "param1", "param2", "param3", "param4", param5, param6); + Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7"); + Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8"); + Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9"); + Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9", "param10"); + + } + + /* + * Test call callback + */ + void fnCallback(Php::Parameters ¶ms) + { + Php::out << "call callback" << std::endl; + + Php::Value callback = params[0]; + + + Php::Value param5; + param5.set(0, "param5"); + param5.set(1, 3.14159265359); + param5.set(2, 28032014); + param5.set("key", "value"); + + auto timeZone = Php::Object("DateTimeZone", "Asia/Yekaterinburg"); + Php::Value param6 = Php::Object("DateTime", "2014-03-28 19:42:15", timeZone); + + // call a function from user space + callback("param1"); + callback("param1", "param2"); + callback("param1", "param2", "param3"); + callback("param1", "param2", "param3", "param4"); + callback("param1", "param2", "param3", "param4", param5); + callback("param1", "param2", "param3", "param4", param5, param6); + callback("param1", "param2", "param3", "param4", "param5", "param6", "param7"); + callback("param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8"); + callback("param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9"); + callback("param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9", "param10"); + + } + + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp index c1e33b1..4db7b9c 100644 --- a/tests/cpp/main.cpp +++ b/tests/cpp/main.cpp @@ -102,6 +102,10 @@ extern "C" extension.add("TestVariables\\value_arrays", TestVariables::value_arrays); extension.add("TestVariables\\value_object1", TestVariables::value_object1); extension.add("TestVariables\\value_object2", TestVariables::value_object2); + extension.add("TestVariables\\fnFromUserSpace", TestVariables::fnFromUserSpace); + extension.add("TestVariables\\fnCallback", TestVariables::fnCallback); + + // A sample class, with methods to cast objects to scalars Php::Class cObj2Scalar("TestVariables\\Obj2Scalar"); diff --git a/tests/php/dbg.php b/tests/php/dbg.php index 9a28fc6..2040f01 100644 --- a/tests/php/dbg.php +++ b/tests/php/dbg.php @@ -11,3 +11,4 @@ + diff --git a/tests/php/php_alias.sh b/tests/php/php_alias.sh index 34c2918..f4c7f8f 100755 --- a/tests/php/php_alias.sh +++ b/tests/php/php_alias.sh @@ -16,4 +16,4 @@ fi LD_LIBRARY_PATH="$(cd $PWD/../.. && echo $PWD):${LD_LIBRARY_PATH}" export LD_LIBRARY_PATH -/usr/bin/php -d enable_dl=On -d extension_dir=../ext_dir -d extension=extfortest.so $1 +/usr/bin/php -d extension_dir=../ext_dir -d extension=extfortest.so $1 diff --git a/tests/php/phpt/variables/013-calling-php-functions.phpt b/tests/php/phpt/variables/013-calling-php-functions.phpt new file mode 100644 index 0000000..5ec6644 --- /dev/null +++ b/tests/php/phpt/variables/013-calling-php-functions.phpt @@ -0,0 +1,113 @@ +--TEST-- +calling-php-functions from userspace +--SKIPIF-- + +--FILEEOF-- + 'param1', +)userspace function called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', +)userspace function called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', +)userspace function called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', +)userspace function called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), +)userspace function called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), + 5 => + DateTime::__set_state(array( + 'date' => '2014-03-28 19:42:15', + 'timezone_type' => 3, + 'timezone' => 'Asia/Yekaterinburg', + )), +)userspace function called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', +)userspace function called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', +)userspace function called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', +)userspace function called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', + 9 => 'param10', +) \ No newline at end of file diff --git a/tests/php/phpt/variables/014-calling-php-functions.phpt b/tests/php/phpt/variables/014-calling-php-functions.phpt new file mode 100644 index 0000000..4a05e2a --- /dev/null +++ b/tests/php/phpt/variables/014-calling-php-functions.phpt @@ -0,0 +1,113 @@ +--TEST-- +calling-php-Callback-functions +--SKIPIF-- + +--FILEEOF-- + 'param1', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), + 5 => + DateTime::__set_state(array( + 'date' => '2014-03-28 19:42:15', + 'timezone_type' => 3, + 'timezone' => 'Asia/Yekaterinburg', + )), +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', + 9 => 'param10', +) \ No newline at end of file diff --git a/tests/php/phpt/variables/015-calling-php-functions.phpt b/tests/php/phpt/variables/015-calling-php-functions.phpt new file mode 100644 index 0000000..e9382b2 --- /dev/null +++ b/tests/php/phpt/variables/015-calling-php-functions.phpt @@ -0,0 +1,109 @@ +--TEST-- +calling-php-Callback-functions (lambda) +--SKIPIF-- + +--FILEEOF-- + 'param1', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), + 5 => + DateTime::__set_state(array( + 'date' => '2014-03-28 19:42:15', + 'timezone_type' => 3, + 'timezone' => 'Asia/Yekaterinburg', + )), +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', + 9 => 'param10', +) \ No newline at end of file diff --git a/tests/php/phpt/variables/016-calling-php-functions.phpt b/tests/php/phpt/variables/016-calling-php-functions.phpt new file mode 100644 index 0000000..46fda6e --- /dev/null +++ b/tests/php/phpt/variables/016-calling-php-functions.phpt @@ -0,0 +1,113 @@ +--TEST-- +calling-php-Callback-functions (__invoke) +--SKIPIF-- + +--FILEEOF-- + 'param1', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), + 5 => + DateTime::__set_state(array( + 'date' => '2014-03-28 19:42:15', + 'timezone_type' => 3, + 'timezone' => 'Asia/Yekaterinburg', + )), +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', + 9 => 'param10', +) \ No newline at end of file diff --git a/tests/php/phpt/variables/017-calling-php-functions.phpt b/tests/php/phpt/variables/017-calling-php-functions.phpt new file mode 100644 index 0000000..630399a --- /dev/null +++ b/tests/php/phpt/variables/017-calling-php-functions.phpt @@ -0,0 +1,115 @@ +--TEST-- +calling-php-Callback-functions (method of class) +--SKIPIF-- + +--FILEEOF-- + 'param1', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => + array ( + 0 => 'param5', + 1 => 3.14159265359, + 2 => 28032014, + 'key' => 'value', + ), + 5 => + DateTime::__set_state(array( + 'date' => '2014-03-28 19:42:15', + 'timezone_type' => 3, + 'timezone' => 'Asia/Yekaterinburg', + )), +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', +)Callback called with parameters: +array ( + 0 => 'param1', + 1 => 'param2', + 2 => 'param3', + 3 => 'param4', + 4 => 'param5', + 5 => 'param6', + 6 => 'param7', + 7 => 'param8', + 8 => 'param9', + 9 => 'param10', +) \ No newline at end of file -- cgit v1.2.3 From 4091487adfbfd07750524fd7910d7178af21f816 Mon Sep 17 00:00:00 2001 From: valmat Date: Fri, 28 Mar 2014 21:58:30 +0600 Subject: add test: 018-calling-php-functions --- tests/cpp/h/variables.h | 2 +- .../variables/013-017-calling-php-functions.h | 87 -------------- .../variables/013-018-calling-php-functions.h | 127 +++++++++++++++++++++ tests/cpp/main.cpp | 1 + .../phpt/variables/018-calling-php-functions.phpt | 32 ++++++ 5 files changed, 161 insertions(+), 88 deletions(-) delete mode 100644 tests/cpp/include/variables/013-017-calling-php-functions.h create mode 100644 tests/cpp/include/variables/013-018-calling-php-functions.h create mode 100644 tests/php/phpt/variables/018-calling-php-functions.phpt (limited to 'tests/cpp') diff --git a/tests/cpp/h/variables.h b/tests/cpp/h/variables.h index df0d923..3ff77e9 100644 --- a/tests/cpp/h/variables.h +++ b/tests/cpp/h/variables.h @@ -17,7 +17,7 @@ #include "../include/variables/008-value-arrays.h" #include "../include/variables/009-010-value-object.h" #include "../include/variables/011-012-value-casting-operators.h" -#include "../include/variables/013-017-calling-php-functions.h" +#include "../include/variables/013-018-calling-php-functions.h" //#include "../include/variables/.h" //#include "../include/variables/.h" diff --git a/tests/cpp/include/variables/013-017-calling-php-functions.h b/tests/cpp/include/variables/013-017-calling-php-functions.h deleted file mode 100644 index 94367e0..0000000 --- a/tests/cpp/include/variables/013-017-calling-php-functions.h +++ /dev/null @@ -1,87 +0,0 @@ -/** - * - * Test call function - * 013-calling-php-functions.phpt - * ... - * 017-calling-php-functions.phpt - * - */ - - -/** - * Set up namespace - */ -namespace TestVariables { - - - /* - * Test call function from user space - */ - void fnFromUserSpace(void) - { - - - Php::out << "fnFromUserSpace" << std::endl; - - Php::Value param5; - param5.set(0, "param5"); - param5.set(1, 3.14159265359); - param5.set(2, 28032014); - param5.set("key", "value"); - - auto timeZone = Php::Object("DateTimeZone", "Asia/Yekaterinburg"); - Php::Value param6 = Php::Object("DateTime", "2014-03-28 19:42:15", timeZone); - - // call a function from user space - Php::call("some_function", "param1"); - Php::call("some_function", "param1", "param2"); - Php::call("some_function", "param1", "param2", "param3"); - Php::call("some_function", "param1", "param2", "param3", "param4"); - Php::call("some_function", "param1", "param2", "param3", "param4", param5); - Php::call("some_function", "param1", "param2", "param3", "param4", param5, param6); - Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7"); - Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8"); - Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9"); - Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9", "param10"); - - } - - /* - * Test call callback - */ - void fnCallback(Php::Parameters ¶ms) - { - Php::out << "call callback" << std::endl; - - Php::Value callback = params[0]; - - - Php::Value param5; - param5.set(0, "param5"); - param5.set(1, 3.14159265359); - param5.set(2, 28032014); - param5.set("key", "value"); - - auto timeZone = Php::Object("DateTimeZone", "Asia/Yekaterinburg"); - Php::Value param6 = Php::Object("DateTime", "2014-03-28 19:42:15", timeZone); - - // call a function from user space - callback("param1"); - callback("param1", "param2"); - callback("param1", "param2", "param3"); - callback("param1", "param2", "param3", "param4"); - callback("param1", "param2", "param3", "param4", param5); - callback("param1", "param2", "param3", "param4", param5, param6); - callback("param1", "param2", "param3", "param4", "param5", "param6", "param7"); - callback("param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8"); - callback("param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9"); - callback("param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9", "param10"); - - } - - -/** - * End of namespace - */ -} - diff --git a/tests/cpp/include/variables/013-018-calling-php-functions.h b/tests/cpp/include/variables/013-018-calling-php-functions.h new file mode 100644 index 0000000..c646f60 --- /dev/null +++ b/tests/cpp/include/variables/013-018-calling-php-functions.h @@ -0,0 +1,127 @@ +/** + * + * Test call function + * 013-calling-php-functions.phpt + * ... + * 018-calling-php-functions.phpt + * + */ + + +/** + * Set up namespace + */ +namespace TestVariables { + + + /* + * Test call function from user space + */ + void fnFromUserSpace(void) + { + + + Php::out << "fnFromUserSpace" << std::endl; + + Php::Value param5; + param5.set(0, "param5"); + param5.set(1, 3.14159265359); + param5.set(2, 28032014); + param5.set("key", "value"); + + auto timeZone = Php::Object("DateTimeZone", "Asia/Yekaterinburg"); + Php::Value param6 = Php::Object("DateTime", "2014-03-28 19:42:15", timeZone); + + // call a function from user space + Php::call("some_function", "param1"); + Php::call("some_function", "param1", "param2"); + Php::call("some_function", "param1", "param2", "param3"); + Php::call("some_function", "param1", "param2", "param3", "param4"); + Php::call("some_function", "param1", "param2", "param3", "param4", param5); + Php::call("some_function", "param1", "param2", "param3", "param4", param5, param6); + Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7"); + Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8"); + Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9"); + Php::call("some_function", "param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9", "param10"); + + } + + /* + * Test call callback + */ + void fnCallback(Php::Parameters ¶ms) + { + Php::out << "call callback" << std::endl; + + Php::Value callback = params[0]; + + + Php::Value param5; + param5.set(0, "param5"); + param5.set(1, 3.14159265359); + param5.set(2, 28032014); + param5.set("key", "value"); + + auto timeZone = Php::Object("DateTimeZone", "Asia/Yekaterinburg"); + Php::Value param6 = Php::Object("DateTime", "2014-03-28 19:42:15", timeZone); + + // call a function from user space + callback("param1"); + callback("param1", "param2"); + callback("param1", "param2", "param3"); + callback("param1", "param2", "param3", "param4"); + callback("param1", "param2", "param3", "param4", param5); + callback("param1", "param2", "param3", "param4", param5, param6); + callback("param1", "param2", "param3", "param4", "param5", "param6", "param7"); + callback("param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8"); + callback("param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9"); + callback("param1", "param2", "param3", "param4", "param5", "param6", "param7", "param8", "param9", "param10"); + + } + + /* + * Test + */ + void fnFromUserSpace2(void) + { + + // create an object (this will also call __construct()) + Php::Object time("DateTime", "2014-03-28 21:22:15", Php::Object("DateTimeZone", "Asia/Irkutsk")); + + // call a method on the datetime object + Php::out << time.call("format", "Y-m-d H:i:s") << std::endl; + + // in PHP it is possible to create an array with two parameters, the first + // parameter being an object, and the second parameter should be the name + // of the method, we can do that in PHP-CPP too + Php::Array time_format({time, "format"}); + + // call the method that is stored in the array + Php::out << time_format("Y-m-d H:i:s") << std::endl; + + // call method of class from user space + Php::Object usrspcl("usrspClass", "Mount Meru"); + Php::Array usrspcl_meth({usrspcl, "someMethod"}); + // call the method that is stored in the array + Php::out << usrspcl_meth("is in the Arctics") << std::endl; + + // call callable object of class from user space + Php::Object clbl("CallableClass", "Arctics around mount Meru"); + Php::out << clbl("is the birthplace of the Hyperboreans") << std::endl; + + + + //::someMethod + //(new usrspClass("Mount Meru"))->someMethod("is in the Arctics"); + + + + + + } + +/** + * End of namespace + */ +} + diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp index 4db7b9c..5d0d0a6 100644 --- a/tests/cpp/main.cpp +++ b/tests/cpp/main.cpp @@ -103,6 +103,7 @@ extern "C" extension.add("TestVariables\\value_object1", TestVariables::value_object1); extension.add("TestVariables\\value_object2", TestVariables::value_object2); extension.add("TestVariables\\fnFromUserSpace", TestVariables::fnFromUserSpace); + extension.add("TestVariables\\fnFromUserSpace2", TestVariables::fnFromUserSpace2); extension.add("TestVariables\\fnCallback", TestVariables::fnCallback); diff --git a/tests/php/phpt/variables/018-calling-php-functions.phpt b/tests/php/phpt/variables/018-calling-php-functions.phpt new file mode 100644 index 0000000..1b8bfeb --- /dev/null +++ b/tests/php/phpt/variables/018-calling-php-functions.phpt @@ -0,0 +1,32 @@ +--TEST-- +calling-php-callable +--DESCRIPTION-- +call callable object of class from user space +call method of class from user space +--SKIPIF-- + +--FILEEOF-- +a = $a;} + public function __invoke($b){ echo "CallableClass({$this->a})::__invoke($b)";} + private $a = ""; +} + +class usrspClass { + function __construct($a){ $this->a = $a;} + function someMethod($b) {echo "usrspClass({$this->a})::someMethod($b)";} + private $a = ""; +} + + +TestVariables\fnFromUserSpace2(); + + +--EXPECT-- +2014-03-28 21:22:15 +2014-03-28 21:22:15 +usrspClass(Mount Meru)::someMethod(is in the Arctics) +CallableClass(Arctics around mount Meru)::__invoke(is the birthplace of the Hyperboreans) \ No newline at end of file -- cgit v1.2.3 From 00f105e5490c96d2b39431d320f44e0f2ef040a5 Mon Sep 17 00:00:00 2001 From: valmat Date: Fri, 28 Mar 2014 22:34:50 +0600 Subject: new test: Test class with static property and class constant --- .../include/variables/013-018-calling-php-functions.h | 10 ---------- tests/cpp/main.cpp | 5 +++++ tests/php/phpt/class_obj/004-static-prop.phpt | 19 +++++++++++++++++++ 3 files changed, 24 insertions(+), 10 deletions(-) create mode 100644 tests/php/phpt/class_obj/004-static-prop.phpt (limited to 'tests/cpp') diff --git a/tests/cpp/include/variables/013-018-calling-php-functions.h b/tests/cpp/include/variables/013-018-calling-php-functions.h index c646f60..9a77408 100644 --- a/tests/cpp/include/variables/013-018-calling-php-functions.h +++ b/tests/cpp/include/variables/013-018-calling-php-functions.h @@ -108,16 +108,6 @@ namespace TestVariables { // call callable object of class from user space Php::Object clbl("CallableClass", "Arctics around mount Meru"); Php::out << clbl("is the birthplace of the Hyperboreans") << std::endl; - - - - //::someMethod - //(new usrspClass("Mount Meru"))->someMethod("is in the Arctics"); - - - - - } /** diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp index 5d0d0a6..db2416d 100644 --- a/tests/cpp/main.cpp +++ b/tests/cpp/main.cpp @@ -49,6 +49,11 @@ extern "C" customClass.property("property1", "prop1"); customClass.property("property2", "prop2", Php::Protected); + customClass.property("CONSTANT1", "some string", Php::Const); + customClass.property("EXP", 2.718281828459, Php::Const); + customClass.property("CONSTANT2", -2582341, Php::Const); + customClass.property("CONSTANT1", true, Php::Const); + // add the class to the extension extension.add(customClass); diff --git a/tests/php/phpt/class_obj/004-static-prop.phpt b/tests/php/phpt/class_obj/004-static-prop.phpt new file mode 100644 index 0000000..4073247 --- /dev/null +++ b/tests/php/phpt/class_obj/004-static-prop.phpt @@ -0,0 +1,19 @@ +--TEST-- +Test class with static property and class constant +--SKIPIF-- + +--FILEEOF-- + Date: Sat, 29 Mar 2014 01:38:25 +0600 Subject: Fixed test: variables/003-value-types --- tests/cpp/include/variables/003-value-types.h | 50 +++++++++--------- tests/php/phpt/variables/003-value-types.phpt | 72 ++++++++++++++++++++++++++ tests/php/phpt/variables/003-value-types.phpt- | 72 -------------------------- 3 files changed, 96 insertions(+), 98 deletions(-) create mode 100644 tests/php/phpt/variables/003-value-types.phpt delete mode 100644 tests/php/phpt/variables/003-value-types.phpt- (limited to 'tests/cpp') diff --git a/tests/cpp/include/variables/003-value-types.h b/tests/cpp/include/variables/003-value-types.h index e1d31b9..d24549b 100644 --- a/tests/cpp/include/variables/003-value-types.h +++ b/tests/cpp/include/variables/003-value-types.h @@ -1,39 +1,37 @@ /** * * Test variables - * 003-value-types.phpt + * 003-value-types.phpt * */ - namespace TestVariables { - /* - * Check type of value - * @param array - */ - void value_types(Php::Parameters ¶ms) { - if (params.size() == 0) { - return; - } - + /* + * Check type of value + * @param array + */ + void value_types(Php::Parameters ¶ms) + { + if (params.size() == 0) return; Php::Value arr = params[0]; + + Php::out << "Null: " << bool2str( arr.get("Null").isNull() ) << std::endl; + Php::out << "Numeric: " << bool2str( arr.get("Numeric").isNumeric()) << std::endl; + Php::out << "Float: " << bool2str( arr.get("Float").isFloat() ) << std::endl; + Php::out << "Bool: " << bool2str( arr.get("Bool").isBool() ) << std::endl; + Php::out << "Array: " << bool2str( arr.get("Array").isArray() ) << std::endl; + Php::out << "Object: " << bool2str( arr.get("Object").isObject() ) << std::endl; + Php::out << "String: " << bool2str( arr.get("String").isString() ) << std::endl; + Php::out << "Resource: " << bool2str( arr.get("Resource").type() == Php::Type::Resource ) << std::endl; + Php::out << "Constant: " << bool2str( arr.get("Constant").type() == Php::Type::Constant ) << std::endl; + Php::out << "ConstantArray: " << bool2str( arr.get("ConstantArray").type() == Php::Type::ConstantArray ) << std::endl; + Php::out << "Callable1: " << bool2str( arr.get("Callable1").isCallable() ) << std::endl; + Php::out << "Callable2: " << bool2str( arr.get("Callable2").isCallable() ) << std::endl; + Php::out << "Callable3: " << bool2str( arr.get("Callable3").isCallable() ) << std::endl; + Php::out << "Callable4: " << bool2str( arr.get("Callable4").isCallable() ) << std::endl; - Php::out << "Null: " << bool2str( arr.get("Null").type() == Php::Type::Null ) << std::endl; - Php::out << "Numeric: " << bool2str( arr.get("Numeric").type() == Php::Type::Numeric ) << std::endl; - Php::out << "Float: " << bool2str( arr.get("Float").type() == Php::Type::Float ) << std::endl; - Php::out << "Bool: " << bool2str( arr.get("Bool").type() == Php::Type::Bool ) << std::endl; - Php::out << "Array: " << bool2str( arr.get("Array").type() == Php::Type::Array ) << std::endl; - Php::out << "Object: " << bool2str( arr.get("Object").type() == Php::Type::Object ) << std::endl; - Php::out << "String: " << bool2str( arr.get("String").type() == Php::Type::String ) << std::endl; - Php::out << "Resource: " << bool2str( arr.get("Resource").type() == Php::Type::Resource ) << std::endl; - Php::out << "Constant: " << bool2str( arr.get("Constant").type() == Php::Type::Constant ) << std::endl; - Php::out << "ConstantArray: " << bool2str( arr.get("ConstantArray").type() == Php::Type::ConstantArray ) << std::endl; - Php::out << "Callable1: " << bool2str( arr.get("Callable1").type() == Php::Type::Callable ) << std::endl; - Php::out << "Callable2: " << bool2str( arr.get("Callable2").type() == Php::Type::Callable ) << std::endl; - Php::out << "Callable3: " << bool2str( arr.get("Callable3").type() == Php::Type::Callable ) << std::endl; - Php::out << "Callable4: " << bool2str( arr.get("Callable4").type() == Php::Type::Callable ) << std::endl; - } + } } diff --git a/tests/php/phpt/variables/003-value-types.phpt b/tests/php/phpt/variables/003-value-types.phpt new file mode 100644 index 0000000..477fbe2 --- /dev/null +++ b/tests/php/phpt/variables/003-value-types.phpt @@ -0,0 +1,72 @@ +--TEST-- +get_complex_array +--SKIPIF-- + +--FILEEOF-- + NULL, + 'Numeric' => 2014, + 'Float' => 3.14, + 'Bool' => true, + 'Array' => array(5,'a' => 33, 'str'), + 'Object' => new stdClass(), + 'String' => 'String', + 'Resource' => 7, + 'Constant' => 5, + 'ConstantArray' => 11, + 'Callable1' => 'ret5', + 'Callable2' => $methodVariable, + 'Callable3' => function () {return 5;}, + 'Callable4' => new CallableClass() +); + +TestVariables\value_types($arr); + +//To check uncomment the following lines: +/* +echo "\n\nCallable1:"; +var_export(is_callable($arr['Callable1'])); +echo PHP_EOL,'Callable2:'; +var_export(is_callable($arr['Callable2'])); +echo PHP_EOL,'Callable3:'; +var_export(is_callable($arr['Callable3'])); +echo PHP_EOL,'Callable4:'; +var_export(is_callable($arr['Callable4'])); +echo PHP_EOL,'No Callable:'; +var_export(is_callable(new stdClass)); +*/ + + +echo PHP_EOL; +--EXPECT-- +Null: Yes +Numeric: Yes +Float: Yes +Bool: Yes +Array: Yes +Object: Yes +String: Yes +Resource: No +Constant: No +ConstantArray: No +Callable1: Yes +Callable2: Yes +Callable3: Yes +Callable4: Yes \ No newline at end of file diff --git a/tests/php/phpt/variables/003-value-types.phpt- b/tests/php/phpt/variables/003-value-types.phpt- deleted file mode 100644 index 477fbe2..0000000 --- a/tests/php/phpt/variables/003-value-types.phpt- +++ /dev/null @@ -1,72 +0,0 @@ ---TEST-- -get_complex_array ---SKIPIF-- - ---FILEEOF-- - NULL, - 'Numeric' => 2014, - 'Float' => 3.14, - 'Bool' => true, - 'Array' => array(5,'a' => 33, 'str'), - 'Object' => new stdClass(), - 'String' => 'String', - 'Resource' => 7, - 'Constant' => 5, - 'ConstantArray' => 11, - 'Callable1' => 'ret5', - 'Callable2' => $methodVariable, - 'Callable3' => function () {return 5;}, - 'Callable4' => new CallableClass() -); - -TestVariables\value_types($arr); - -//To check uncomment the following lines: -/* -echo "\n\nCallable1:"; -var_export(is_callable($arr['Callable1'])); -echo PHP_EOL,'Callable2:'; -var_export(is_callable($arr['Callable2'])); -echo PHP_EOL,'Callable3:'; -var_export(is_callable($arr['Callable3'])); -echo PHP_EOL,'Callable4:'; -var_export(is_callable($arr['Callable4'])); -echo PHP_EOL,'No Callable:'; -var_export(is_callable(new stdClass)); -*/ - - -echo PHP_EOL; ---EXPECT-- -Null: Yes -Numeric: Yes -Float: Yes -Bool: Yes -Array: Yes -Object: Yes -String: Yes -Resource: No -Constant: No -ConstantArray: No -Callable1: Yes -Callable2: Yes -Callable3: Yes -Callable4: Yes \ No newline at end of file -- cgit v1.2.3