<?php
/** DomFramework - Tests
  * @package domframework
  * @author Dominique Fournier <dominique@fournier38.fr>
  * @license BSD
  */

namespace Domframework\Tests;

use Domframework\Dblayeroo;

class DblayerooTest{ENGINE} extends \PHPUnit_Framework_TestCase
{
// Test with column name 'group', 'object', 'where', 'with space'
// Test with table name 'group', 'object', 'where', 'with space'
// For the 3 DB engines

  public $engine="{ENGINE}";
  public $confs = array (
    "sqlite" => array (
      "dsn" => "sqlite:/tmp/databaseDBLayeroo.db",
      "username" => null,
      "password" => null,
      "driver_options" => null,
      "tableprefix" => "",
    ),
    "mysql" => array (
      "dsn" => "mysql:host=127.0.0.1;port=3306;dbname=test",
      "username" => "root",
      "password" => "lqsym",
      "driver_options" => null,
      "tableprefix" => "",
    ),
    "pgsql" => array (
      "dsn" => "pgsql:host=127.0.0.1;port=5432;dbname=dbname",
      "username" => "root",
      "password" => "root",
      "driver_options" => null,
      "tableprefix" => "",
    ),
  );

  private function tbl1 ()
  {
    $dbconfig = $this->confs["{ENGINE}"];
    $tbl1 = new Dblayeroo ($dbconfig["dsn"], $dbconfig["username"],
                           $dbconfig["password"], $dbconfig["driver_options"]);
    $tbl1->table ("groupedoo");
    $tbl1->fields (array ("group"=>array ("varchar(255)", "not null"),
                          "object"=>array ("varchar(255)", "not null"),
                          "where"=>array ("varchar(255)", "not null"),
                          "with space"=>array ("varchar(255)")));
    $tbl1->unique (array ());
    $tbl1->primary ("group");
    $tbl1->realTypes (array ("group" => "regex(/^\S{1,10}$/)"));
    return $tbl1;
  }

  private function tbl2 ()
  {
    $dbconfig = $this->confs["{ENGINE}"];
    $tbl2 = new Dblayeroo ($dbconfig["dsn"], $dbconfig["username"],
                           $dbconfig["password"], $dbconfig["driver_options"]);
    $tbl2->table ("usersoo");
    $tbl2->fields (array ("uid"=>array ("integer", "not null", "autoincrement"),
                          "gecos"=>array ("varchar(255)", "not null"),
                          "password"=>array ("varchar(255)", "not null"),
                          "group" => array ("varchar(255)", "not null"),
                         ));
    $tbl2->unique (array ("gecos","password"));
    $tbl2->primary ("uid");
    $tbl2->foreign (array ("group" => array ("groupedoo", "group",
                                             "ON DELETE CASCADE")));
    return $tbl2;
  }

  private function tbl3 ()
  {
    $dbconfig = $this->confs["{ENGINE}"];
    $tbl3 = new Dblayeroo ($dbconfig["dsn"], $dbconfig["username"],
                           $dbconfig["password"], $dbconfig["driver_options"]);
    return $tbl3;
  }

  private function tbl4 ()
  {
    $dbconfig = $this->confs["{ENGINE}"];
    $tbl4 = new Dblayeroo ($dbconfig["dsn"], $dbconfig["username"],
                          $dbconfig["password"], $dbconfig["driver_options"]);
    $tbl4->table ("rightsoo");
    $tbl4->fields (array ("id"=>array ("integer", "not null", "autoincrement"),
                          "name"=>array ("varchar(255)", "not null"),
                          "group" => array ("varchar(255)", "not null"),
                         ));
    $tbl4->unique (array ("name"));
    $tbl4->primary ("id");
    $tbl4->foreign (array ("group" => array ("groupedoo", "group",
                                            "ON DELETE CASCADE")));
    return $tbl4;
  }

  public function test_dropTable ()
  {
    $dbconfig = $this->confs["{ENGINE}"];
    $db = new Dblayeroo ($dbconfig["dsn"], $dbconfig["username"],
                       $dbconfig["password"], $dbconfig["driver_options"]);
    foreach (array ("rightsoo", "usersoo", "groupedoo",
                    "multipleoo", "multiple2oo", "users3oo",
                    "readORoo") as
             $table)
    {
      $db->table ($table);
      try
      {
        $res = $db->dropTable();
      }
      catch (\Exception $e)
      {
      }
    }
    $db->disconnect ();
    // Never generate an error, just drop the table if it exists, and do noting
    // if it doesn't exists
  }

  public function test_createTable1 ()
  {
    // Create a table named groupedoo
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->createTable ();
    $tbl1->disconnect ();
    $this->assertSame (0, $res);
  }

  public function test_createTable2 ()
  {
    // Create a table named usersoo
    $tbl2 = $this->tbl2 ();
    $res = $tbl2->createTable ();
    $tbl2->disconnect ();
    $this->assertSame (0, $res);
  }

  public function test_createTable4 ()
  {
    // Create a table named rightsoo
    $tbl4 = $this->tbl4 ();
    $res = $tbl4->createTable ();
    $tbl4->disconnect ();
    $this->assertSame (0, $res);
  }

  public function test_select1 ()
  {
    // Select all on the table : nothing
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->select()->execute ();
    $tbl1->disconnect ();
    $this->assertSame (array (), $res);
  }

  public function test_insert1 ()
  {
    // Insert without value : raise an exception
    $this->setExpectedException ("Exception");
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->insert()->execute ();
    $tbl1->disconnect ();
  }

  public function test_insert2 ()
  {
    // Insert : missing not null field : exception
    $this->setExpectedException ("Exception");
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->insert()
                ->setValues(array ("group"=>"group1", "where"=>"where"))
                ->execute ();
    $tbl1->disconnect ();
  }

  public function test_insert3 ()
  {
    // Insert : first row inserted
    $tbl1 = $this->tbl1 ();
    // Normalize the value to be inserted too
    $res = $tbl1->insert()->setValues(array ("group"=>"  group1  ",
                                             "where"=>"where",
                                             "object"=>"object"))->execute ();
    $tbl1->disconnect ();
    // As the key is not an autoincrement, the lastInsertID can be 0 or 1
    $this->assertSame ($res, "group1");
  }

  public function test_select2 ()
  {
    // Select all on the table : nothing
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->select()->execute ();
    $tbl1->disconnect ();
    $this->assertSame (array (array ("group"=>"group1", "object"=>"object",
                                     "where"=>"where", "with space"=>null)),
                       $res);
  }

  public function test_update1 ()
  {
    // update the all the rows of the table (without WHERE)
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->update()->setValues(array ("group"=>"group2",
                                             "where"=>"where",
                                             "object"=>"object"))->execute ();
    $tbl1->disconnect ();
    $this->assertSame (1, $res);
  }

  public function test_select3 ()
  {
    // Select all on the table after update
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->select()->execute ();
    $tbl1->disconnect ();
    $this->assertSame (array (array ("group"=>"group2", "object"=>"object",
                                     "where"=>"where", "with space"=>null)),
                       $res);
  }

  public function test_update2 ()
  {
    // update the all the rows of the table (with inexisting WHERE)
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->update()
               ->setValues(array ("group"=>"group2", "where"=>"where",
                                  "object"=>"object"))
               ->whereAdd ("group", "=", "group1")
               ->execute ();
    $tbl1->disconnect ();
    $this->assertSame (0, $res);
  }

  public function test_update3 ()
  {
    // update the all the rows of the table (with existing WHERE)
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->update()
               ->setValues(array ("group"=>"group1", "where"=>"where",
                                  "object"=>"object"))
               ->whereAdd ("group", "=", "group2")
               ->execute ();
    $tbl1->disconnect ();
    $this->assertSame (1, $res);
  }

  public function test_update4 ()
  {
    // update the all the rows of the table : NOT NULL value not provided
    // (already existing in the table)
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->update()
               ->setValues(array ("group"=>"group1"))
               ->execute ();
    $tbl1->disconnect ();
    $this->assertSame (1, $res);
  }

  public function test_delete1 ()
  {
    // Delete : WHERE return nothing
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->delete ()
               ->whereAdd ("group", "=", "group2")
               ->execute ();
    $tbl1->disconnect ();
    $this->assertSame (0, $res);
  }

  public function test_delete2 ()
  {
    // Delete all
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->delete ()
               ->execute ();
    $tbl1->disconnect ();
    $this->assertSame (1, $res);
  }

  public function test_select4 ()
  {
    // Select all on the table : nothing
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->select()->execute ();
    $tbl1->disconnect ();
    $this->assertSame (array (), $res);
  }

  public function test_insert5 ()
  {
    // Insert : first row inserted for TABLE 2 tests
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->insert()->setValues(array ("group"=>"group1",
                                             "where"=>"where",
                                             "object"=>"object"))->execute ();
    $tbl1->disconnect ();
    // As the key is not an autoincrement, the lastInsertID can be 0 or 1
    $this->assertSame ($res, "group1");
  }

  ///////////////////
  ///   TABLE 2   ///
  ///////////////////
  public function test_insertAutoincrement1 ()
  {
    // Test autoincrement
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl2->setForeignObj ($tbl1);
    $res = $tbl2->insert()->setValues(array ("gecos"=>"name",
                                             "password"=>"toto",
                                             "group"=>"group1"))->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame ("1", $res);
  }

  public function test_insertAutoincrement2 ()
  {
    // Test autoincrement
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl2->setForeignObj ($tbl1);
    $res = $tbl2->insert()->setValues(array ("gecos"=>"firstname2",
                                             "password"=>"toto2",
                                             "group"=>"group1"))->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame ("2", $res);
  }

  public function test_insertAutoincrement3 ()
  {
    // Test autoincrement
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl2->setForeignObj ($tbl1);
    $res = $tbl2->insert()->setValues(array ("gecos"=>"firstname3",
                                             "password"=>"toto3",
                                             "group"=>"group1"))->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame ("3", $res);
  }

  public function test_delete3 ()
  {
    // Delete with WHERE clause
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl2->setForeignObj ($tbl1);
    $res = $tbl2->delete ()
               ->whereAdd ("gecos", "LIKE", "firstname%")
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame (2, $res);
  }

  public function test_select5 ()
  {
    // Select all on the table : one entry "gecos"=>"name"
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl2->setForeignObj ($tbl1);
    $res = $tbl2->select()->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame (array (array ("uid"=>1,
                                     "gecos"=>"name",
                                     "password"=>"toto",
                                     "group"=>"group1")), $res);
  }

  ///   SCHEMA MANAGEMENT   ///
  public function test_getTableSchema1 ()
  {
    $tbl3 = $this->tbl3 ();
    $res = $tbl3->getTableSchema ("usersoo");
    $tbl3->disconnect ();
    $this->assertSame (
      array ("table" => "usersoo",
             "fields" => array (
                "uid" => array ("integer", "not null", "autoincrement"),
                "gecos" => array ("varchar(255)", "not null"),
                "password" => array ("varchar(255)", "not null"),
                "group" => array ("varchar(255)", "not null"),
                ),
             "primary" => "uid",
             "unique" => array ("gecos","password","uid"),
             "foreign" => array (
                "group" => array ('groupedoo', 'group', 'ON DELETE CASCADE'),
             ),
             "foreignUsed" => array (
             ),
      ), $res);
  }

  public function test_getTableSchema2 ()
  {
    $tbl3 = $this->tbl3 ();
    $res = $tbl3->getTableSchema ("groupedoo");
    $tbl3->disconnect ();
    $this->assertSame (
      array (
        "table" => "groupedoo",
        "fields" => array (
          "group" => array ("varchar(255)", "not null"),
          "object" => array ("varchar(255)", "not null"),
          "where" => array ("varchar(255)", "not null"),
          "with space" => array ("varchar(255)")),
        "primary" => "group",
        "unique" => array ("group"),
        "foreign" => array (),
        "foreignUsed" => array (
          "group" => array (
            array ("rightsoo", "group"),
            array ("usersoo", "group"),
          ),
        ),
      ), $res);
  }

  // JOINS
  public function test_insertJoin1 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->insert()
               ->setValues(array ("group"=>"group2",
                                  "object"=>"object",
                                  "where"=>"where"))
               ->execute ();
    $tbl2 = $this->tbl2 ();
    $tbl2->setForeignObj ($tbl1);
    $res = $tbl2->insert()
               ->setValues(array ("gecos"=>"name2",
                                  "password"=>"pwd2",
                                  "group"=>"group1"))
               ->execute ();
    $res = $tbl2->insert()
               ->setValues(array ("gecos"=>"name3",
                                  "password"=>"pwd3",
                                  "group"=>"group1"))
               ->execute ();
    $res = $tbl2->insert()
               ->setValues(array ("gecos"=>"name4",
                                  "password"=>"pwd4",
                                  "group"=>"group1"))
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
  }

  public function test_innerJoin1 ()
  {
    // No filter
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $res = $tbl2->select ()
               ->joinInner ($tbl1, array ("group"=>"group"))
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame (array (
      array (
        'usersoo.uid' => 1,
        'usersoo.gecos' => 'name',
        'usersoo.password' => 'toto',
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
        'groupedoo.object' => 'object',
        'groupedoo.where' => 'where',
        'groupedoo.with space' => NULL,
      ),
      array (
        'usersoo.uid' => 4,
        'usersoo.gecos' => 'name2',
        'usersoo.password' => 'pwd2',
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
        'groupedoo.object' => 'object',
        'groupedoo.where' => 'where',
        'groupedoo.with space' => NULL,
      ),
      array (
        'usersoo.uid' => 5,
        'usersoo.gecos' => 'name3',
        'usersoo.password' => 'pwd3',
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
        'groupedoo.object' => 'object',
        'groupedoo.where' => 'where',
        'groupedoo.with space' => NULL,
      ),
      array (
        'usersoo.uid' => 6,
        'usersoo.gecos' => 'name4',
        'usersoo.password' => 'pwd4',
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
        'groupedoo.object' => 'object',
        'groupedoo.where' => 'where',
        'groupedoo.with space' => NULL,
      ),
    ), $res);
  }

  public function test_innerJoin2 ()
  {
    // No filter. Manage the empty displayAdd
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ();
    $tbl2 = $this->tbl2 ();
    $res = $tbl2->select ()
               ->joinInner ($tbl1, array ("group"=>"group"))
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame (array (
      array (
        'uid' => 1,
        'gecos' => 'name',
        'password' => 'toto',
        'group' => 'group1',
      ),
      array (
        'uid' => 4,
        'gecos' => 'name2',
        'password' => 'pwd2',
        'group' => 'group1',
      ),
      array (
        'uid' => 5,
        'gecos' => 'name3',
        'password' => 'pwd3',
        'group' => 'group1',
      ),
      array (
        'uid' => 6,
        'gecos' => 'name4',
        'password' => 'pwd4',
        'group' => 'group1',
      ),
    ), $res);
  }

  public function test_innerJoin3 ()
  {
    // No filter. Manage the empty displayAdd
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl2->displayAdd ();
    $res = $tbl2->select ()
               ->joinInner ($tbl1, array ("group"=>"group"))
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame (array (
      array (
        'group' => 'group1',
        'object' => 'object',
        'where' => 'where',
        'with space' => NULL,
      ),
      array (
        'group' => 'group1',
        'object' => 'object',
        'where' => 'where',
        'with space' => NULL,
      ),
      array (
        'group' => 'group1',
        'object' => 'object',
        'where' => 'where',
        'with space' => NULL,
      ),
      array (
        'group' => 'group1',
        'object' => 'object',
        'where' => 'where',
        'with space' => NULL,
      ),
    ), $res);
  }

  public function test_leftJoin2 ()
  {
    // No filter
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $res = $tbl1->select ()
               ->joinLeft ($tbl2, array ("group"=>"group"))
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame (array (
      array (
        'groupedoo.group' => 'group1',
        'groupedoo.object' => 'object',
        'groupedoo.where' => 'where',
        'groupedoo.with space' => NULL,
        'usersoo.uid' => 1,
        'usersoo.gecos' => 'name',
        'usersoo.password' => 'toto',
        'usersoo.group' => 'group1',
      ),
      array (
        'groupedoo.group' => 'group1',
        'groupedoo.object' => 'object',
        'groupedoo.where' => 'where',
        'groupedoo.with space' => NULL,
        'usersoo.uid' => 4,
        'usersoo.gecos' => 'name2',
        'usersoo.password' => 'pwd2',
        'usersoo.group' => 'group1',
      ),
      array (
        'groupedoo.group' => 'group1',
        'groupedoo.object' => 'object',
        'groupedoo.where' => 'where',
        'groupedoo.with space' => NULL,
        'usersoo.uid' => 5,
        'usersoo.gecos' => 'name3',
        'usersoo.password' => 'pwd3',
        'usersoo.group' => 'group1',
      ),
      array (
        'groupedoo.group' => 'group1',
        'groupedoo.object' => 'object',
        'groupedoo.where' => 'where',
        'groupedoo.with space' => NULL,
        'usersoo.uid' => 6,
        'usersoo.gecos' => 'name4',
        'usersoo.password' => 'pwd4',
        'usersoo.group' => 'group1',
      ),
      array (
        'groupedoo.group' => 'group2',
        'groupedoo.object' => 'object',
        'groupedoo.where' => 'where',
        'groupedoo.with space' => NULL,
        'usersoo.uid' => NULL,
        'usersoo.gecos' => NULL,
        'usersoo.password' => NULL,
        'usersoo.group' => NULL,
      ),
    ), $res);
  }

  public function test_leftJoin3 ()
  {
    // Filter on the tbl1, do not display tbl2
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl2->displayAdd ();
    $res = $tbl1->select ()
               ->displayAdd ("group")
               ->joinLeft ($tbl2, array ("group"=>"group"))
               ->orderAdd ("group", "ASC")
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame (array (
      array (
        'group' => 'group1',
      ),
      array (
        'group' => 'group1',
      ),
      array (
        'group' => 'group1',
      ),
      array (
        'group' => 'group1',
      ),
      array (
        'group' => 'group2',
      ),
    ), $res);
  }

  public function test_leftJoin4 ()
  {
    // Filter on the tbl1, display one column in tbl2
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl2->displayAdd ("group");
    $res = $tbl1->select ()
               ->displayAdd ("group")
               ->joinLeft ($tbl2, array ("group"=>"group"))
               ->orderAdd ("group", "DESC")
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame (array (
      array (
        'usersoo.group' => NULL,
        'groupedoo.group' => 'group2',
      ),
      array (
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
      ),
      array (
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
      ),
      array (
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
      ),
      array (
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
      ),
    ), $res);
  }

  public function test_leftJoin5 ()
  {
    // Filter on the tbl1 and add order in full mode
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl2->displayAdd ("group");
    $res = $tbl1->select ()
               ->displayAdd ("group")
               ->joinLeft ($tbl2, array ("group"=>"group"))
               ->orderAdd ("group", "DESC")
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame (array (
      array (
        'usersoo.group' => NULL,
        'groupedoo.group' => 'group2',
      ),
      array (
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
      ),
      array (
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
      ),
      array (
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
      ),
      array (
        'usersoo.group' => 'group1',
        'groupedoo.group' => 'group1',
      ),
    ), $res);
  }

  ///   THREE TABLES   ///
  public function test_insert6 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl4 = $this->tbl4 ();
    $tbl4->setForeignObj ($tbl1);
    $res = $tbl4->insert ()
               ->setValues(array ("name"=>"RO",
                                  "group"=>"group1"))
               ->execute ();
    $tbl4->disconnect ();
    // As the key is not an autoincrement, the lastInsertID can be 0 or 1
    $this->assertGreaterThanOrEqual ($res, "0");
  }

  public function test_leftJoin6 ()
  {
    // Two joins tables in left join
    $tbl1 = $this->tbl1 (); // Do not display anything from groupedoo
    $tbl1->displayAdd ("group")
        ->orderAdd ("group", "DESC");

    $tbl2 = $this->tbl2 (); // Display the gecos and group from usersoo
    $tbl2->displayAdd ("gecos")
        ->orderAdd ("gecos", "ASC");

    $tbl4 = $this->tbl4 (); // Display the name in rightsoo
    $tbl4->displayAdd ("name");
    $tbl1->joinLeft ($tbl4, array ("group"=>"group"));
    $res = $tbl1->select ()
               ->joinLeft ($tbl2, array ("group"=>"group"))
               ->execute ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $tbl4->disconnect ();
    $this->assertSame (array (
      array (
        'groupedoo.group' => 'group2',
        'usersoo.gecos' => NULL,
        'rightsoo.name' => NULL,
      ),
      array (
        'groupedoo.group' => 'group1',
        'usersoo.gecos' => 'name',
        'rightsoo.name' => 'RO',
      ),
      array (
        'groupedoo.group' => 'group1',
        'usersoo.gecos' => 'name2',
        'rightsoo.name' => 'RO',
      ),
      array (
        'groupedoo.group' => 'group1',
        'usersoo.gecos' => 'name3',
        'rightsoo.name' => 'RO',
      ),
      array (
        'groupedoo.group' => 'group1',
        'usersoo.gecos' => 'name4',
        'rightsoo.name' => 'RO',
      ),
    ), $res);
  }

  public function test_sortOrder1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->getSortOrder ();
    $tbl1->disconnect ();
    $this->assertSame ("order1", $res);
  }

  public function test_sortOrder2 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->getSortOrder ();
    $res = $tbl1->getSortOrder ();
    $tbl1->disconnect ();
    $this->assertSame ("order2", $res);
  }

  public function test_sortOrder3 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl1->getSortOrder ();
    $tbl1->getSortOrder ();
    $res = $tbl2->getSortOrder ();
    $tbl1->disconnect ();
    $tbl2->disconnect ();
    $this->assertSame ("order3", $res);
  }

  public function test_displayAdd_NotFull1 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group");
    $res = $tbl1->displayGet ();
    $tbl1->disconnect ();
    $this->assertSame (array ("order1" => $tbl1->sep()."group".$tbl1->sep()),
      $res);
  }

  public function test_displayAdd_NotFull2 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("distinct group");
    $res = $tbl1->displayGet ();
    $tbl1->disconnect ();
    $this->assertSame (array (
      "order1" => "DISTINCT ".$tbl1->sep()."group".$tbl1->sep()), $res);
  }

  public function test_displayAdd_NotFull3 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group_concat ( group ) ");
    $res = $tbl1->displayGet ();
    $tbl1->disconnect ();
    if ($this->engine === "pgsql")
      $this->assertSame (array (
        "order1" => "string_agg(".$tbl1->sep()."group".$tbl1->sep().
                    "::character varying, ',' order by \"group\"".
                    ")"), $res);
    else
      $this->assertSame (array (
        "order1" => "GROUP_CONCAT(".$tbl1->sep()."group".$tbl1->sep().")"), $res);
  }

  public function test_displayAdd_NotFull4 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group_concat (distinct group ) ");
    $res = $tbl1->displayGet ();
    $tbl1->disconnect ();
    if ($this->engine === "pgsql")
      $this->assertSame (array (
        "order1" => "string_agg(DISTINCT ".
                    $tbl1->sep()."group".$tbl1->sep().
                    "::character varying, ',' order by \"group\"".
                    ")"), $res);
    else
      $this->assertSame (array (
        "order1" => "GROUP_CONCAT(DISTINCT ".
                    $tbl1->sep()."group".$tbl1->sep().")"), $res);
  }

  public function test_displayAdd_NotFull5 ()
  {
    // With alias
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group_concat (distinct group ) ", "Group Alias");
    $res = $tbl1->displayGet ();
    $tbl1->disconnect ();
    if ($this->engine === "pgsql")
      $this->assertSame (array (
        "order1" => "string_agg(DISTINCT ".
                    $tbl1->sep()."group".$tbl1->sep().
                    "::character varying, ',' order by ".
                    $tbl1->sep()."group".$tbl1->sep().
                    ") AS ".
                    $tbl1->sep()."Group Alias".$tbl1->sep()), $res);
    else
      $this->assertSame (array (
        "order1" => "GROUP_CONCAT(DISTINCT ".
                    $tbl1->sep()."group".$tbl1->sep().") AS ".
                    $tbl1->sep()."Group Alias".$tbl1->sep()), $res);
  }

  public function test_displayAdd_Full1 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group");
    $res = $tbl1->displayGet (true);
    $tbl1->disconnect ();
    $this->assertSame (array (
      "order1" => $tbl1->sep()."groupedoo".$tbl1->sep().".".
                  $tbl1->sep()."group".$tbl1->sep()),
      $res);
  }

  public function test_displayAdd_Full2 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("distinct group");
    $res = $tbl1->displayGet (true);
    $tbl1->disconnect ();
    $this->assertSame (array (
      "order1" => "DISTINCT ".$tbl1->sep()."groupedoo".$tbl1->sep().".".
                  $tbl1->sep()."group".$tbl1->sep()), $res);
  }

  public function test_displayAdd_Full3 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group_concat ( group ) ");
    $res = $tbl1->displayGet (true);
    $tbl1->disconnect ();
    if ($this->engine === "pgsql")
      $this->assertSame (array (
        "order1" => "string_agg(".$tbl1->sep()."groupedoo".$tbl1->sep().".".
                                    $tbl1->sep()."group".$tbl1->sep().
                    "::character varying, ',' order by \"group\"".
                    ")"), $res);
    else
      $this->assertSame (array (
        "order1" => "GROUP_CONCAT(".$tbl1->sep()."groupedoo".$tbl1->sep().".".
                                    $tbl1->sep()."group".$tbl1->sep().")"), $res);
  }

  public function test_displayAdd_Full4 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group_concat (distinct group ) ");
    $res = $tbl1->displayGet (true);
    $tbl1->disconnect ();
    if ($this->engine === "pgsql")
      $this->assertSame (array (
        "order1" => "string_agg(DISTINCT ".
                    $tbl1->sep()."groupedoo".$tbl1->sep().".".
                    $tbl1->sep()."group".$tbl1->sep().
                    "::character varying, ',' order by \"group\"".
                    ")"), $res);
    else
      $this->assertSame (array (
        "order1" => "GROUP_CONCAT(DISTINCT ".
                    $tbl1->sep()."groupedoo".$tbl1->sep().".".
                    $tbl1->sep()."group".$tbl1->sep().")"), $res);
  }

  public function test_displayAdd_Full5 ()
  {
    // With alias
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group_concat (distinct group ) ", "Group Alias");
    $res = $tbl1->displayGet (true);
    $tbl1->disconnect ();
    if ($this->engine === "pgsql")
      $this->assertSame (array (
        "order1" => "string_agg(DISTINCT ".
                    $tbl1->sep()."groupedoo".$tbl1->sep().".".
                    $tbl1->sep()."group".$tbl1->sep().
                    "::character varying, ',' order by \"group\"".
                    ") AS ".
                    $tbl1->sep()."Group Alias".$tbl1->sep()), $res);
    else
      $this->assertSame (array (
        "order1" => "GROUP_CONCAT(DISTINCT ".
                    $tbl1->sep()."groupedoo".$tbl1->sep().".".
                    $tbl1->sep()."group".$tbl1->sep().") AS ".
                    $tbl1->sep()."Group Alias".$tbl1->sep()), $res);
  }

  public function test_displayAdd_Multiple1 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group");
    $tbl1->displayAdd ("where");
    $res = $tbl1->displayGet ();
    $tbl1->disconnect ();
    $this->assertSame (array ("order1" => $tbl1->sep()."group".$tbl1->sep(),
                              "order2" => $tbl1->sep()."where".$tbl1->sep(),),
                       $res);
  }


  public function test_update5 ()
  {
    // Manage to update the non unique fields
    // the "where" column is not unique, so it allow to have twice the same
    // value
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->update()
               ->setValues(array ("where"=>"where2"))
               ->execute ();
    $tbl1->disconnect ();
    $this->assertSame (2, $res);
  }

  public function test_update6 ()
  {
    // Manage to update the primary / unique fields
    // There is 2 lines in the DB, so the unique key "group" can not be updated
    // with the same value twice (the result can not be unique)
    $tbl1 = $this->tbl1 ();
    $this->setExpectedException ("Exception");
    $res = $tbl1->update()
               ->setValues(array ("group"=>"group3"))
               ->execute ();
    $tbl1->disconnect ();
  }

  public function test_displayAdd_ComaFields1 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl1->displayAdd ("group_concat (group ),group ",
                       "Group Alias,Group2");
    $res = $tbl1->select ()
                ->execute ();
    $tbl1->disconnect ();
    if ($this->engine !== "pgsql")
      $this->assertSame (array (
        array ('Group Alias' => 'group1',
               'Group2' => 'group1',),
        array ('Group Alias' => 'group2',
               'Group2' => 'group2',),
      ), $res);
  }

  public function test_displayAdd_DISTINCT1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->select ()
                ->displayAdd ("distinct where", "ALIAS")
                ->execute ();
    $tbl1->disconnect ();
    $this->assertSame (array (0=>array ("ALIAS"=>"where2")),
                       $res);
  }

  public function test_orderAdd_alias1 ()
  {
    $tbl2 = $this->tbl2 ();
    $res = $tbl2->select ()
                ->displayAdd ("uid", "max")
                ->orderAdd ("max","ASC")
                ->execute ();
    $tbl2->disconnect ();
    $this->assertSame (array (
      array ('max' => 1),
      array ('max' => 4),
      array ('max' => 5),
      array ('max' => 6),
    ), $res);
  }

  public function test_displayAdd_MAX_GROUPBY1 ()
  {
    $tbl2 = $this->tbl2 ();
    $res = $tbl2->select ()
                ->displayAdd ("MAX(uid)", "max")
                ->displayAdd ("gecos")
                ->orderAdd ("max","ASC")
                ->execute ();
    $tbl2->disconnect ();
    $this->assertSame (array (
      array ('max' => 1, 'gecos' => 'name'),
      array ('max' => 4, 'gecos' => 'name2'),
      array ('max' => 5, 'gecos' => 'name3'),
      array ('max' => 6, 'gecos' => 'name4')),
      $res);
  }

  public function test_displayAdd_MAX_GROUPBY2 ()
  {
    $tbl2 = $this->tbl2 ();
    $res = $tbl2->select ()
                ->displayAdd ("MAX(uid)")
                ->execute ();
    $tbl2->disconnect ();
    $this->assertSame (array (array ('MAX(uid)' => 6)), $res);
  }

  public function test_displayAdd_MAX_GROUPBY3 ()
  {
    $tbl1 = $this->tbl1 ();
    $tbl2 = $this->tbl2 ();
    $tbl1->select ()
         ->displayAdd ("group");
    $res = $tbl2->select ()
                ->displayAdd ("MAX(uid)")
                ->joinInner ($tbl1, array ("group"=>"group"))
                ->execute ();
    $tbl2->disconnect ();
    $this->assertSame (array (array (
      'groupedoo.group' => 'group1',
      'MAX(usersoo.uid)' => 6,
    )), $res);
  }

  public function test_GROUPCONCATwithAlias1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->select ()
                ->displayAdd ("GROUP_CONCAT(group)", "groups")
                ->execute ();
    $this->assertSame (array (array (
      'groups' => 'group1,group2'
    )), $res);
  }

  public function test_GROUPCONCATwithAlias2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->select ()
                ->displayAdd ("GROUP_CONCAT(group,',')", "groups")
                ->execute ();
    $this->assertSame (array (array (
      'groups' => 'group1,group2'
    )), $res);
  }

  public function test_GROUPCONCATwithAlias3 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->select ()
                ->displayAdd ("GROUP_CONCAT(group,' ')", "groups")
                ->execute ();
    $this->assertSame (array (array (
      'groups' => 'group1 group2'
    )), $res);
  }

  public function test_listTables_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->listTables ();
    if ($this->engine === "sqlite")
      $this->assertSame (array (
        0 => 'groupedoo',
        1 => 'rightsoo',
        2 => 'usersoo',
      ), $res);
    else
      $this->assertSame (array (
        0 => 'grouped',
        1 => 'groupedoo',
        2 => 'multiple',
        3 => 'multiple2',
        4 => 'readOR',
        5 => 'rightsoo',
        6 => 'users',
        7 => 'users3',
        8 => 'usersoo',
      ), $res);
  }

  ////    CHECK REAL TYPES TESTS    ////
  public function test_checkRealType_integerPositive_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_integerPositive",
      "1", "");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_integerPositive_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_integerPositive",
      "-1", "");
    $this->assertSame ("Invalid positive integer : ".
        "can not start by minus sign", $res);
  }
  public function test_checkRealType_integerPositive_3 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_integerPositive",
      "0777", "");
    $this->assertSame ("Invalid positive integer : ".
        "can not start by Zero", $res);
  }
  public function test_checkRealType_integerPositive_4 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_integerPositive",
      "07a7", "");
    $this->assertSame ("Invalid positive integer : ".
        "invalid char", $res);
  }

  public function test_checkRealType_allowedchars_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_allowedchars",
      "1111", "allowedchars(123)");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_allowedchars_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_allowedchars",
      "-1", "allowedchars(123)");
    $this->assertSame ("Invalid char provided", $res);
  }

  public function test_checkRealType_array_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_array",
      "235", "array('123','235','256')");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_array_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_array",
      "777", "array('123','235','256')");
    $this->assertSame ("Invalid value provided : not in allowed list", $res);
  }

  public function test_checkRealType_regex_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_regex",
      "235", "regex(/^\\d+$/)");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_regex_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_regex",
      "235", "regex(/^\\d{3}$/)");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_regex_3 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_regex",
      "235", "regex(/^\\d{4}$/)");
    $this->assertSame ("Invalid value provided : do not match the regex", $res);
  }
  public function test_checkRealType_regex_4 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_regex",
      "abcdef", "regex(/^[a-z]+$/)");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_regex_5 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_regex",
      "Abcdef", "regex(/^[a-z]+$/)");
    $this->assertSame ("Invalid value provided : do not match the regex", $res);
  }

  public function test_checkRealType_mail_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_mail",
      "toto@example.com", "");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_mail_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_mail",
      "toto@", "");
    $this->assertSame ("Invalid mail provided", $res);
  }

  public function test_checkRealType_uuid_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_uuid",
      "4e799e3f-f376-46e5-a5db-85200949987e", "");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_uuid_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_uuid",
      "4E799E3F-F376-46E5-A5DB-85200949987E", "");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_uuid_3 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_uuid",
      "4E799E3F-F376-46E5+A5DB+85200949987E", "");
    $this->assertSame ("Invalid UUID provided : invalid char", $res);
  }
  public function test_checkRealType_uuid_4 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_uuid",
      "4E799E3F5F376546E55A5DB585200949987E", "");
    $this->assertSame ("Invalid UUID provided : missing dash", $res);
  }

  public function test_checkRealType_sqldate_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_sqldate",
      "2018-10-24", "");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_sqldate_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_sqldate",
      "2018/10/24", "");
    $this->assertSame ("Invalid date provided : invalid chars", $res);
  }
  public function test_checkRealType_sqldate_3 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_sqldate",
      "2018-10-32", "");
    $this->assertSame ("Invalid date provided : can not parse the date", $res);
  }

  public function test_checkRealType_sqltime_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_sqltime",
      "12:34:56", "");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_sqltime_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_sqltime",
      "12;22;22", "");
    $this->assertSame ("Invalid time provided : invalid chars", $res);
  }
  public function test_checkRealType_sqltime_3 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_sqltime",
      "32:34:56", "");
    $this->assertSame ("Invalid time provided : can not parse the time", $res);
  }

  public function test_checkRealType_sqldatetime_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_sqldatetime",
      "2018-10-24 22:23:24", "");
    $this->assertSame (null, $res);
  }
  public function test_checkRealType_sqldatetime_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_sqldatetime",
      "2018/10/24", "");
    $this->assertSame ("Invalid date and time provided : invalid length", $res);
  }
  public function test_checkRealType_sqldatetime_3 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $this->invokeMethod ($tbl1, "checkRealType_sqldatetime",
      "2018-10-24 25:12:25", "");
    $this->assertSame ("Invalid date and time provided : ".
      "can not parse the date", $res);
  }

  ////    TEST REAL TYPES    ////
  public function test_checkRealTypes_1 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->checkRealTypes (array ("group" => "notempty"));
    $this->assertSame (array (
      "object" => "The field can not be empty",
      "where" => "The field can not be empty",
      ), $res);
  }
  public function test_checkRealTypes_2 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->checkRealTypes (array ("group" => "not valid"));
    $this->assertSame (array (
      "group" => "Invalid value provided : do not match the regex",
      "object" => "The field can not be empty",
      "where" => "The field can not be empty",
      ), $res);
  }
  public function test_checkRealTypes_3 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->checkRealTypes (array ("group" => "notempty"), true);
    $this->assertSame (array (), $res);
  }
  public function test_checkRealTypes_4 ()
  {
    $tbl1 = $this->tbl1 ();
    $res = $tbl1->checkRealTypes (array ("group" => "not valid"), true);
    $this->assertSame (array (
      "group" => "Invalid value provided : do not match the regex",
      ), $res);
  }
}