Added new tests.

Due to support zts broke the ability to run tests without installation - fixed.

5 files changed, 324 insertions, 3 deletions

diff --git a/tests/cpp/Makefile b/tests/cpp/Makefile
index e0c32ba..6239170 100644
--- a/tests/cpp/Makefile
+++ b/tests/cpp/Makefile
@@ -88,7 +88,7 @@ LINKER				=	g++
 #
 
 LIB_DIR=$(shell cd ../.. && pwd)
-COMPILER_FLAGS		=	-Wall -c -O2 -std=c++11 -fpic  -I"${LIB_DIR}/include" -o
+COMPILER_FLAGS		=	-Wall -c -O2 -std=c++11 -fpic  -I"${LIB_DIR}/include" -I"./zts" -o
 LINKER_FLAGS		=	-shared -L"${LIB_DIR}"
 LINKER_DEPENDENCIES	=	-lphpcpp
 
diff --git a/tests/cpp/include/testValueIterator.h b/tests/cpp/include/ValueIterator.h
index a9329c9..a9329c9 100644
--- a/tests/cpp/include/testValueIterator.h
+++ b/tests/cpp/include/ValueIterator.h
diff --git a/tests/cpp/include/variables.h b/tests/cpp/include/variables.h
new file mode 100644
index 0000000..f242653
--- /dev/null
+++ b/tests/cpp/include/variables.h
@@ -0,0 +1,293 @@
+/**
+ *
+ *  Test variables
+ *
+ */
+
+/**
+ *  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 &params) {
+	    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 &params)
+	{
+	    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;
+
+	    Php::out  << "   long:" << value1    << "\n string:" << value2  << "\n double:" << value3  << "\n   bool:" << bool2str(value4) << std::endl;
+	}
+
+	/*
+	 * Test Php::Value casting operators
+	 */
+	void value_cast2str(Php::Parameters &params)
+	{
+	    std::string value = params[0];
+	    Php::out  << value  << std::endl;
+	}
+
+	/*
+	 * Test Php::Value overloaded operators
+	 */
+	void overloaded_op(Php::Parameters &params)
+	{
+	    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;
+	}
+
+	/*
+	 * Test Php::Value resize
+	 */
+	void ghfghfhf2(Php::Parameters &params)
+	{
+
+
+	}
+
+
+
+
+
+
+
+/**
+ *  End of namespace
+ */
+}
+
diff --git a/tests/cpp/main.cpp b/tests/cpp/main.cpp
index 154b61b..2928f60 100644
--- a/tests/cpp/main.cpp
+++ b/tests/cpp/main.cpp
@@ -8,8 +8,10 @@
 #include <phpcpp.h>
 
 // Test includes
-#include "include/testValueIterator.h"
+#include "include/ValueIterator.h"
 #include "include/MyCustomClass.h"
+#include "include/variables.h"
+
 
 
 
@@ -43,10 +45,35 @@ extern "C"
         // add the class to the extension
         extension.add(customClass);
 
-
+        /**
+         *  tests for Iterators
+         * 
+         */
         // add function to extension
         //extension.add("TestValueIterator\\loopValue", TestValueIterator::loopValue/*, {
         extension.add("TestValueIterator\\loopValue", TestValueIterator::loopValue);
+
+
+        /**
+         *  tests for variables
+         * 
+         */
+        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);
+        extension.add("TestVariables\\scalar_store",      TestVariables::scalar_store);
+        extension.add("TestVariables\\value_casting",     TestVariables::value_casting);
+        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);
+
+
+
+
+
+
         
         // return the extension module
         return extension;
diff --git a/tests/cpp/zts/.gitignore b/tests/cpp/zts/.gitignore
new file mode 100644
index 0000000..8d82a92
--- /dev/null
+++ b/tests/cpp/zts/.gitignore
@@ -0,0 +1 @@
+phpcpp/config.h