home *** CD-ROM | disk | FTP | other *** search
/ Enter 2004 June / ENTER.ISO / files / xampp-win32-1.4.5-installer.exe / xampp / driver_test.php < prev    next >
Encoding:
PHP Script  |  2004-03-24  |  50.7 KB  |  1,687 lines
  1. <?php
  2. /*
  3.  * driver_test.php
  4.  *
  5.  * @(#) $Header: /repository/pear/MDB/tests/driver_test.php,v 1.21 2003/01/16 16:05:06 lsmith Exp $
  6.  *
  7.  * This is a script intended to be used by Metabase DBMS driver class
  8.  * developers or other users to verify if the implementation of a given
  9.  * driver works in conformance with the documented behavior of the driver
  10.  * class functions.
  11.  *
  12.  * Driver classes that are not compliant may lead to bugs in the Metabase
  13.  * applications that use such drivers.  Make sure that new or updated
  14.  * drivers pass all tests performed by this script before releasing the
  15.  * driver classes to Metabase users.  In the future this script will be
  16.  * updated to perform conformance tests.
  17.  *
  18.  * To use this script, edit the driver_test_configuration.php script and
  19.  * adjust any database setup values that may be needed to use the driver
  20.  * class being tested in your environment.  Read Metabase documentation
  21.  * about the MetabaseSetupDatabase section to learn more about these
  22.  * database setup arguments.
  23.  *
  24.  */
  25.  
  26. // BC hack to define PATH_SEPARATOR for version of PHP prior 4.3
  27. if(!defined('PATH_SEPARATOR')) {
  28.     if(defined('DIRECTORY_SEPARATOR') && DIRECTORY_SEPARATOR == "\\") {
  29.         define('PATH_SEPARATOR', ';');
  30.     } else {
  31.         define('PATH_SEPARATOR', ':');
  32.     }
  33. }
  34. ini_set('include_path', '..'.PATH_SEPARATOR.ini_get('include_path'));
  35.  
  36. require_once 'MDB.php';
  37. MDB::loadFile('metabase_wrapper');
  38. MDB::loadFile('Manager');
  39.  
  40. Function VerifyFetchedValues($database,$result,$row,&$data,&$value,&$field)
  41. {
  42.     return(strcmp($value=MetabaseFetchResult($database,$result,$row,"user_name"),$data[$field="user_name"])
  43.     || strcmp($value=MetabaseFetchResult($database,$result,$row,"user_password"),$data[$field="user_password"])
  44.     || strcmp($value=MetabaseFetchBooleanResult($database,$result,$row,"subscribed"),$data[$field="subscribed"])
  45.     || strcmp($value=MetabaseFetchResult($database,$result,$row,"user_id"),$data[$field="user_id"])
  46.     || ($value=MetabaseFetchDecimalResult($database,$result,$row,"quota"))!=$data[$field="quota"]
  47.     || strcmp($value=MetabaseFetchFloatResult($database,$result,$row,"weight"),$data[$field="weight"])
  48.     || strcmp($value=MetabaseFetchDateResult($database,$result,$row,"access_date"),$data[$field="access_date"])
  49.     || strcmp($value=MetabaseFetchTimeResult($database,$result,$row,"access_time"),$data[$field="access_time"])
  50.     || strcmp($value=MetabaseFetchTimestampResult($database,$result,$row,"approved"),$data[$field="approved"]));
  51. }
  52.  
  53. Function InsertTestValues($database,$prepared_query,&$data)
  54. {
  55.     MetabaseQuerySetText($database,$prepared_query,1,$data["user_name"]);
  56.     MetabaseQuerySetText($database,$prepared_query,2,$data["user_password"]);
  57.     MetabaseQuerySetBoolean($database,$prepared_query,3,$data["subscribed"]);
  58.     MetabaseQuerySetInteger($database,$prepared_query,4,$data["user_id"]);
  59.     MetabaseQuerySetDecimal($database,$prepared_query,5,$data["quota"]);
  60.     MetabaseQuerySetFloat($database,$prepared_query,6,$data["weight"]);
  61.     MetabaseQuerySetDate($database,$prepared_query,7,$data["access_date"]);
  62.     MetabaseQuerySetTime($database,$prepared_query,8,$data["access_time"]);
  63.     MetabaseQuerySetTimestamp($database,$prepared_query,9,$data["approved"]);
  64.     return(MetabaseExecuteQuery($database,$prepared_query));
  65. }
  66.  
  67.     $driver_arguments=array(
  68.     );
  69.  
  70.     $database_variables=array(
  71.         "create"=>"1",
  72.         "name"=>"driver_test"
  73.     );
  74.  
  75.     if(file_exists("driver_test_config.php"))
  76.         include("driver_test_config.php");
  77.  
  78.     $eol=(IsSet($driver_arguments["LogLineBreak"]) ? $driver_arguments["LogLineBreak"] : "\n");
  79.  
  80.     $default_tests=array(
  81.         "storage"=>1,
  82.         "bulkfetch"=>1,
  83.         "preparedqueries"=>1,
  84.         "metadata"=>1,
  85.         "nulls"=>1,
  86.         "escapesequences"=>1,
  87.         "ranges"=>1,
  88.         "sequences"=>1,
  89.         "affectedrows"=>1,
  90.         "transactions"=>1,
  91.         "replace"=>1,
  92.         "lobstorage"=>1,
  93.         "lobfiles"=>1,
  94.         "lobnulls"=>1
  95.     );
  96.     if($argc<=1)
  97.         $tests=$default_tests;
  98.     else
  99.     {
  100.         for($tests=array(),$argument=1;$argument<$argc;$argument++)
  101.         {
  102.             if(!IsSet($default_tests[$argv[$argument]]))
  103.             {
  104.                 echo "Usage: ",$argv[0];
  105.                 for(Reset($default_tests);Key($default_tests);Next($default_tests))
  106.                     echo " [",Key($default_tests),"]";
  107.                 echo $eol;
  108.                 exit;
  109.             }
  110.             $tests[$argv[$argument]]=$default_tests[$argv[$argument]];
  111.         }
  112.     }
  113.  
  114.     set_time_limit(0);
  115.     $input_file="driver_test.schema";
  116.     $manager=new metabase_manager_class;
  117.     $success=$manager->UpdateDatabase($input_file,$input_file.".before",$driver_arguments,$database_variables);
  118.     $debug_output="";
  119.     if(count($manager->warnings)>0)
  120.         $debug_output.="WARNING:$eol".implode($manager->warnings,"!$eol").$eol;
  121.     if($manager->database
  122.     && IsSet($driver_arguments["CaptureDebug"]))
  123.         $debug_output.=MetabaseDebugOutput($manager->database);
  124.     $passed=$failed=0;
  125.     if($success)
  126.     {
  127.         if(!strcmp($error=MetabaseSetupDatabase($driver_arguments,$database),""))
  128.         {
  129.             if(IsSet($driver_arguments["CaptureDebug"]))
  130.                 MetabaseCaptureDebugOutput($database,1);
  131.             MetabaseSetDatabase($database,$database_variables["name"]);
  132.  
  133.             if(IsSet($tests["storage"])
  134.             && $success)
  135.             {
  136.                 $test="storage";
  137.                 echo "Testing typed field storage and retrieval ... ";
  138.                 flush();
  139.                 $pass=1;
  140.                 if(!MetabaseQuery($database,"DELETE FROM users"))
  141.                     $success=0;
  142.                 else
  143.                 {
  144.                     $row=1234;
  145.                     $data=array();
  146.                     $data["user_name"]="user_$row";
  147.                     $data["user_password"]="somepassword";
  148.                     $data["subscribed"]=$row % 2;
  149.                     $data["user_id"]=$row;
  150.                     $data["quota"]=strval($row/100);
  151.                     $data["weight"]=sqrt($row);
  152.                     $data["access_date"]=MetabaseToday();
  153.                     $data["access_time"]=MetabaseTime();
  154.                     $data["approved"]=MetabaseNow();
  155.                     if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO users (user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved) VALUES (?,?,?,?,?,?,?,?,?)")))
  156.                     {
  157.                         if(!InsertTestValues($database,$prepared_query,$data))
  158.                         {
  159.                             $success=0;
  160.                         }
  161.                         MetabaseFreePreparedQuery($database,$prepared_query);
  162.                         if($success)
  163.                         {
  164.                             if(!($result=MetabaseQuery($database,"SELECT user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved FROM users")))
  165.                                 $success=0;
  166.                             else
  167.                             {
  168.                                 if(VerifyFetchedValues($database,$result,0,$data,$value,$field))
  169.                                 {
  170.                                     $pass=0;
  171.                                     echo "FAILED!$eol";
  172.                                     $failed++;
  173.                                     echo "Test $test: the value retrieved for field \"$field\" ($value) doesn't match what was stored (".$data[$field].")$eol";
  174.                                 }
  175.                                 else
  176.                                 {
  177.                                     if(!MetabaseEndOfResult($database,$result))
  178.                                     {
  179.                                         $pass=0;
  180.                                         echo "FAILED!$eol";
  181.                                         $failed++;
  182.                                         echo "Test $test: the query result did not seem to have reached the end of result as expected$eol";
  183.                                     }
  184.                                 }
  185.                                 MetabaseFreeResult($database,$result);
  186.                             }
  187.                         }
  188.                         if($success
  189.                         && $pass)
  190.                         {
  191.                             $passed++;
  192.                             echo "OK.$eol";
  193.                         }
  194.                     }
  195.                     else
  196.                         $success=0;
  197.                 }
  198.             }
  199.  
  200.             if(IsSet($tests["bulkfetch"])
  201.             && $success)
  202.             {
  203.                 $test="bulkfetch";
  204.                 echo "Testing query result data bulk fetching... ";
  205.                 flush();
  206.                 $pass=1;
  207.                 if(!MetabaseQuery($database,"DELETE FROM users"))
  208.                     $success=0;
  209.                 else
  210.                 {
  211.                     if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO users (user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved) VALUES (?,?,?,?,?,?,?,?,?)")))
  212.                     {
  213.                         $data=array();
  214.                         for($total_rows=5,$row=0;$row<$total_rows;$row++)
  215.                         {
  216.                             $data[$row]["user_name"]="user_$row";
  217.                             $data[$row]["user_password"]="somepassword";
  218.                             $data[$row]["subscribed"]=$row % 2;
  219.                             $data[$row]["user_id"]=$row;
  220.                             $data[$row]["quota"]=sprintf("%.2f",strval(1+($row+1)/100));
  221.                             $data[$row]["weight"]=sqrt($row);
  222.                             $data[$row]["access_date"]=MetabaseToday();
  223.                             $data[$row]["access_time"]=MetabaseTime();
  224.                             $data[$row]["approved"]=MetabaseNow();
  225.                             if(!InsertTestValues($database,$prepared_query,$data[$row]))
  226.                             {
  227.                                 $success=0;
  228.                                 break;
  229.                             }
  230.                         }
  231.                         MetabaseFreePreparedQuery($database,$prepared_query);
  232.                         $types=array(
  233.                             "text",
  234.                             "text",
  235.                             "boolean",
  236.                             "integer",
  237.                             "decimal",
  238.                             "float",
  239.                             "date",
  240.                             "time",
  241.                             "timestamp"
  242.                         );
  243.                         if($success)
  244.                         {
  245.                             for($row=0;$row<$total_rows;$row++)
  246.                             {
  247.                                 for(Reset($data[$row]),$column=0;$column<count($data[$row]);Next($data[$row]),$column++)
  248.                                 {
  249.                                     $field=Key($data[$row]);
  250.                                     $type=$types[$column];
  251.                                     if(!($success=MetabaseQueryField($database,"SELECT $field FROM users WHERE user_id=$row",$value,$type)))
  252.                                         break 2;
  253.                                     if(strcmp(strval($data[$row][$field]),strval($value)))
  254.                                     {
  255.                                         $pass=0;
  256.                                         echo "FAILED!$eol";
  257.                                         $failed++;
  258.                                         echo "Test $test: the query field \"$field\" of type $type for row $row was returned in \"$value\" unlike \"".$data[$row][$field]."\" as expected$eol";
  259.                                         break 2;
  260.                                     }
  261.                                 }
  262.                             }
  263.                         }
  264.                         if($success
  265.                         && $pass)
  266.                         {
  267.                             for($fields="",Reset($data[0]),$column=0;$column<count($data[0]);Next($data[0]),$column++)
  268.                             {
  269.                                 if($column>0)
  270.                                     $fields.=",";
  271.                                 $fields.=Key($data[0]);
  272.                             }
  273.                             for($row=0;$row<$total_rows;$row++)
  274.                             {
  275.                                 if(!($success=MetabaseQueryRow($database,"SELECT $fields FROM users WHERE user_id=$row",$value,$types)))
  276.                                     break;
  277.                                 for(Reset($data[$row]),$column=0;$column<count($data[$row]);Next($data[$row]),$column++)
  278.                                 {
  279.                                     $field=Key($data[$row]);
  280.                                     if(strcmp(strval($data[$row][$field]),strval($value[$column])))
  281.                                     {
  282.                                         $pass=0;
  283.                                         echo "FAILED!$eol";
  284.                                         $failed++;
  285.                                         echo "Test $test: the query row field \"$field\" of for row $row was returned in \"".$value[$column]."\" unlike \"".$data[$row][$field]."\" as expected$eol";
  286.                                         break 2;
  287.                                     }
  288.                                 }
  289.                             }
  290.                         }
  291.                         if($success
  292.                         && $pass)
  293.                         {
  294.                             for(Reset($data[0]),$column=0;$column<count($data[0]);Next($data[0]),$column++)
  295.                             {
  296.                                 $field=Key($data[0]);
  297.                                 $type=$types[$column];
  298.                                 if(!($success=MetabaseQueryColumn($database,"SELECT $field,user_id FROM users ORDER BY 2",$value,$type)))
  299.                                     break;
  300.                                 for($row=0;$row<$total_rows;$row++)
  301.                                 {
  302.                                     if(strcmp(strval($data[$row][$field]),strval($value[$row])))
  303.                                     {
  304.                                         $pass=0;
  305.                                         echo "FAILED!$eol";
  306.                                         $failed++;
  307.                                         echo "Test $test: the query column field \"$field\" of type $type for row $row was returned in \"".$value[$row]."\" unlike \"".$data[$row][$field]."\" as expected$eol";
  308.                                         break 2;
  309.                                     }
  310.                                 }
  311.                             }
  312.                         }
  313.                         if($success
  314.                         && $pass)
  315.                         {
  316.                             for($fields="",Reset($data[0]),$column=0;$column<count($data[0]);Next($data[0]),$column++)
  317.                             {
  318.                                 if($column>0)
  319.                                     $fields.=",";
  320.                                 $fields.=Key($data[0]);
  321.                             }
  322.                             if(($success=MetabaseQueryAll($database,"SELECT $fields FROM users ORDER BY user_id",$value,$types)))
  323.                             {
  324.                                 for($row=0;$row<$total_rows;$row++)
  325.                                 {
  326.                                     for(Reset($data[$row]),$column=0;$column<count($data[$row]);Next($data[$row]),$column++)
  327.                                     {
  328.                                         $field=Key($data[$row]);
  329.                                         if(strcmp(strval($data[$row][$field]),strval($value[$row][$column])))
  330.                                         {
  331.                                             $pass=0;
  332.                                             echo "FAILED!$eol";
  333.                                             $failed++;
  334.                                             echo "Test $test: the query all field \"$field\" of for row $row was returned in \"".$value[$row][$column]."\" unlike \"".$data[$row][$field]."\" as expected$eol";
  335.                                             break 2;
  336.                                         }
  337.                                     }
  338.                                 }
  339.                             }
  340.                         }
  341.                         if($success
  342.                         && $pass)
  343.                         {
  344.                             $passed++;
  345.                             echo "OK.$eol";
  346.                         }
  347.                     }
  348.                     else
  349.                         $success=0;
  350.                 }
  351.             }
  352.  
  353.             if(IsSet($tests["preparedqueries"])
  354.             && $success)
  355.             {
  356.                 $test="preparedqueries";
  357.                 echo "Testing prepared queries ... ";
  358.                 flush();
  359.                 $pass=1;
  360.                 if(!MetabaseQuery($database,"DELETE FROM users"))
  361.                     $success=0;
  362.                 else
  363.                 {
  364.                     $question_value=MetabaseGetTextFieldValue($database,"Does this work?");
  365.                     if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO users (user_name,user_password,user_id) VALUES (?,$question_value,1)")))
  366.                     {
  367.                         MetabaseQuerySetText($database,$prepared_query,1,"Sure!");
  368.                         if(!MetabaseExecuteQuery($database,$prepared_query))
  369.                         {
  370.                             $sucess=$pass=0;
  371.                             echo "FAILED!$eol";
  372.                             echo "Test $test: could not execute prepared query with a text value with a question mark. Error: ".MetabaseError($database).$eol;
  373.                             echo "Testing prepared queries ... ";
  374.                             flush();
  375.                         }
  376.                         MetabaseFreePreparedQuery($database,$prepared_query);
  377.                     }
  378.                     else
  379.                     {
  380.                         $sucess=$pass=0;
  381.                         echo "FAILED!$eol";
  382.                         echo "Test $test: could not execute prepared query with a text value with a question mark. Error: ".MetabaseError($database).$eol;
  383.                         echo "Testing prepared queries ... ";
  384.                         flush();
  385.                     }
  386.                     $question_value=MetabaseGetTextFieldValue($database,"Wouldn't it be great if this worked too?");
  387.                     if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO users (user_name,user_password,user_id) VALUES (?,$question_value,2)")))
  388.                     {
  389.                         MetabaseQuerySetText($database,$prepared_query,1,"Sure!");
  390.                         if(!MetabaseExecuteQuery($database,$prepared_query))
  391.                         {
  392.                             $sucess=$pass=0;
  393.                             echo "FAILED!$eol";
  394.                             echo "Test $test: could not execute prepared query with a text value with a quote character before a question mark. Error: ".MetabaseError($database).$eol;
  395.                         }
  396.                         MetabaseFreePreparedQuery($database,$prepared_query);
  397.                     }
  398.                     else
  399.                     {
  400.                         $sucess=$pass=0;
  401.                         echo "FAILED!$eol";
  402.                         echo "Test $test: could not execute prepared query with a text value with a quote character before a question mark. Error: ".MetabaseError($database).$eol;
  403.                     }
  404.                     if($success
  405.                     && $pass)
  406.                     {
  407.                         $passed++;
  408.                         echo "OK.$eol";
  409.                     }
  410.                     else
  411.                         $failed++;
  412.                 }
  413.             }
  414.  
  415.             if(IsSet($tests["metadata"])
  416.             && $success)
  417.             {
  418.                 $test="metadata";
  419.                 echo "Testing retrieval of result metadata... ";
  420.                 flush();
  421.                 $pass=1;
  422.                 if(!MetabaseQuery($database,"DELETE FROM users"))
  423.                     $success=0;
  424.                 else
  425.                 {
  426.                     $row=1234;
  427.                     $data=array();
  428.                     $data["user_name"]="user_$row";
  429.                     $data["user_password"]="somepassword";
  430.                     $data["subscribed"]=$row % 2;
  431.                     $data["user_id"]=$row;
  432.                     $data["quota"]=strval($row/100);
  433.                     $data["weight"]=sqrt($row);
  434.                     $data["access_date"]=MetabaseToday();
  435.                     $data["access_time"]=MetabaseTime();
  436.                     $data["approved"]=MetabaseNow();
  437.                     if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO users (user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved) VALUES (?,?,?,?,?,?,?,?,?)")))
  438.                     {
  439.                         if(!InsertTestValues($database,$prepared_query,$data))
  440.                         {
  441.                             $success=0;
  442.                         }
  443.                         MetabaseFreePreparedQuery($database,$prepared_query);
  444.                         if($success)
  445.                         {
  446.                             if(!($result=MetabaseQuery($database,"SELECT user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved FROM users")))
  447.                                 $success=0;
  448.                             else
  449.                             {
  450.                                 $fields=array(
  451.                                     "user_name",
  452.                                     "user_password",
  453.                                     "subscribed",
  454.                                     "user_id",
  455.                                     "quota",
  456.                                     "weight",
  457.                                     "access_date",
  458.                                     "access_time",
  459.                                     "approved"
  460.                                 );
  461.                                 if(($columns=MetabaseNumberOfColumns($database,$result))==count($fields))
  462.                                 {
  463.                                     if(($success=MetabaseGetColumnNames($database,$result,$column_names)))
  464.                                     {
  465.                                         if($columns==count($column_names))
  466.                                         {
  467.                                             for($column=0;$column<$columns;$column++)
  468.                                             {
  469.                                                 if($column_names[$fields[$column]]!=$column)
  470.                                                 {
  471.                                                     $pass=0;
  472.                                                     echo "FAILED!$eol";
  473.                                                     $failed++;
  474.                                                     echo "Test $test: the query result column \"".$fields[$column]."\" was returned in position ".$column_names[$fields[$column]]." unlike $column as expected$eol";
  475.                                                 }
  476.                                             }
  477.                                         }
  478.                                         else
  479.                                         {
  480.                                             $pass=0;
  481.                                             echo "FAILED!$eol";
  482.                                             $failed++;
  483.                                             echo "Test $test: the query result returned a number of ".count($column_names)." column names unlike $columns as expected$eol";
  484.                                         }
  485.                                     }
  486.                                 }
  487.                                 else
  488.                                 {
  489.                                     if($columns==-1)
  490.                                         $success=0;
  491.                                     else
  492.                                     {
  493.                                         $pass=0;
  494.                                         echo "FAILED!$eol";
  495.                                         $failed++;
  496.                                         echo "Test $test: the query result returned a number of $columns columns unlike ".count($fields)." as expected$eol";
  497.                                     }
  498.                                 }
  499.                                 MetabaseFreeResult($database,$result);
  500.                             }
  501.                         }
  502.                         if($success
  503.                         && $pass)
  504.                         {
  505.                             $passed++;
  506.                             echo "OK.$eol";
  507.                         }
  508.                     }
  509.                     else
  510.                         $success=0;
  511.                 }
  512.             }
  513.  
  514.             if(IsSet($tests["nulls"])
  515.             && $success)
  516.             {
  517.                 $test="nulls";
  518.                 echo "Testing storage and retrieval of NULL values... ";
  519.                 flush();
  520.                 $pass=1;
  521.                 $test_values=array(
  522.                     "test",
  523.                     "NULL",
  524.                     "null",
  525.                     ""
  526.                 );
  527.                 for($test_value=0;$success && $test_value<=count($test_values);$test_value++)
  528.                 {
  529.                     $is_null=($test_value==count($test_values));
  530.                     if($is_null)
  531.                         $value="NULL";
  532.                     else
  533.                         $value=MetabaseGetTextFieldValue($database,$test_values[$test_value]);
  534.                     if(MetabaseQuery($database,"DELETE FROM users")
  535.                     && MetabaseQuery($database,"INSERT INTO users (user_name,user_password,user_id) VALUES ($value,$value,0)")
  536.                     && ($result=MetabaseQuery($database,"SELECT user_name,user_password FROM users")))
  537.                     {
  538.                         if(MetabaseEndOfResult($database,$result))
  539.                         {
  540.                             if($pass)
  541.                             {
  542.                                 $pass=0;
  543.                                 $failed++;
  544.                                 echo "FAILED!$eol";
  545.                             }
  546.                             echo "Test $test: the query result seems to have reached the end of result earlier than expected$eol";
  547.                         }
  548.                         else
  549.                         {
  550.                             if(MetabaseResultIsNull($database,$result,0,0)!=$is_null)
  551.                             {
  552.                                 if($pass)
  553.                                 {
  554.                                     $pass=0;
  555.                                     $failed++;
  556.                                     echo "FAILED!$eol";
  557.                                 }
  558.                                 if($is_null)
  559.                                     echo "Test $test: a query result column is not NULL unlike what was expected$eol";
  560.                                 else
  561.                                     echo "Test $test: a query result column is NULL although it was expected to be \"".$test_values[$test_value]."\"$eol";
  562.                             }
  563.                             else
  564.                             {
  565.                                 if(MetabaseResultIsNull($database,$result,0,1)!=$is_null)
  566.                                 {
  567.                                     if($pass)
  568.                                     {
  569.                                         $pass=0;
  570.                                         $failed++;
  571.                                         echo "FAILED!$eol";
  572.                                     }
  573.                                     if($is_null)
  574.                                         echo "Test $test: a query result column is not NULL unlike what was expected$eol";
  575.                                     else
  576.                                         echo "Test $test: a query result column is NULL although it was expected to be \"".$test_values[$test_value]."\"$eol";
  577.                                 }
  578.                                 else
  579.                                 {
  580.                                     if(!MetabaseEndOfResult($database,$result))
  581.                                     {
  582.                                         if($pass)
  583.                                         {
  584.                                             $pass=0;
  585.                                             $failed++;
  586.                                             echo "FAILED!$eol";
  587.                                         }
  588.                                         echo "Test $test: the query result did not seem to have reached the end of result as expected after testing only if columns are NULLs$eol";
  589.                                     }
  590.                                 }
  591.                             }
  592.                         }
  593.                         MetabaseFreeResult($database,$result);
  594.                     }
  595.                     else
  596.                     {
  597.                         $success=0;
  598.                         break;
  599.                     }
  600.                 }
  601.                 if($success
  602.                 && $pass)
  603.                 {
  604.                     $passed++;
  605.                     echo "OK.$eol";
  606.                 }
  607.             }
  608.  
  609.             if(IsSet($tests["escapesequences"])
  610.             && $success)
  611.             {
  612.                 $test="escapesequences";
  613.                 echo "Testing escaping text values with special characters... ";
  614.                 flush();
  615.                 $pass=1;
  616.                 $test_strings=array(
  617.                     "'",
  618.                     "\"",
  619.                     "\\",
  620.                     "%",
  621.                     "_",
  622.                     "''",
  623.                     "\"\"",
  624.                     "\\\\",
  625.                     "\\'\\'",
  626.                     "\\\"\\\""
  627.                 );
  628.                 for($string=0;$string<count($test_strings);$string++)
  629.                 {
  630.                     $value=MetabaseGetTextFieldValue($database,$test_strings[$string]);
  631.                     if(!MetabaseQuery($database,"DELETE FROM users")
  632.                     || !MetabaseQuery($database,"INSERT INTO users (user_name,user_password,user_id) VALUES ($value,$value,0)")
  633.                     || !($result=MetabaseQuery($database,"SELECT user_name,user_password FROM users")))
  634.                         $success=0;
  635.                     else
  636.                     {
  637.                         if(MetabaseEndOfResult($database,$result))
  638.                         {
  639.                             $pass=0;
  640.                             echo "FAILED!$eol";
  641.                             $failed++;
  642.                             echo "Test $test: the query result seems to have reached the end of result earlier than expected$eol";
  643.                         }
  644.                         else
  645.                         {
  646.                             $field="user_name";
  647.                             if(strcmp($value=MetabaseFetchResult($database,$result,0,$field),$test_strings[$string]))
  648.                             {
  649.                                 $pass=0;
  650.                                 echo "FAILED!$eol";
  651.                                 $failed++;
  652.                                 echo "Test $test: the value retrieved for field \"$field\" (\"$value\") doesn't match what was stored (".$test_strings[$string].")$eol";
  653.                             }
  654.                             else
  655.                             {
  656.                                 $field="user_password";
  657.                                 if(strcmp($value=MetabaseFetchResult($database,$result,0,$field),$test_strings[$string]))
  658.                                 {
  659.                                     $pass=0;
  660.                                     echo "FAILED!$eol";
  661.                                     $failed++;
  662.                                     echo "Test $test: the value retrieved for field \"$field\" (\"$value\") doesn't match what was stored (".$test_string[$string].")$eol";
  663.                                 }
  664.                                 else
  665.                                 {
  666.                                     if(!MetabaseEndOfResult($database,$result))
  667.                                     {
  668.                                         $pass=0;
  669.                                         echo "FAILED!$eol";
  670.                                         $failed++;
  671.                                         echo "Test $test: the query result did not seem to have reached the end of result as expected after testing only if text fields values are correctly escaped$eol";
  672.                                     }
  673.                                 }
  674.                             }
  675.                         }
  676.                         MetabaseFreeResult($database,$result);
  677.                     }
  678.                     if(!$success
  679.                     || !$pass)
  680.                         break;
  681.                 }
  682.                 if($success
  683.                 && $pass)
  684.                 {
  685.                     $passed++;
  686.                     echo "OK.$eol";
  687.                 }
  688.             }
  689.  
  690.             if(IsSet($tests["ranges"])
  691.             && $success)
  692.             {
  693.                 if(MetabaseSupport($database,"SelectRowRanges"))
  694.                 {
  695.                     $test="ranges";
  696.                     echo "Testing paged queries... ";
  697.                     flush();
  698.                     $pass=1;
  699.                     if(!MetabaseQuery($database,"DELETE FROM users"))
  700.                         $success=0;
  701.                     else
  702.                     {
  703.                         if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO users (user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved) VALUES (?,?,?,?,?,?,?,?,?)")))
  704.                         {
  705.                             $data=array();
  706.                             for($total_rows=5,$row=0;$row<$total_rows;$row++)
  707.                             {
  708.                                 $data[$row]["user_name"]="user_$row";
  709.                                 $data[$row]["user_password"]="somepassword";
  710.                                 $data[$row]["subscribed"]=$row % 2;
  711.                                 $data[$row]["user_id"]=$row;
  712.                                 $data[$row]["quota"]=sprintf("%.2f",strval($row/100));
  713.                                 $data[$row]["weight"]=sqrt($row);
  714.                                 $data[$row]["access_date"]=MetabaseToday();
  715.                                 $data[$row]["access_time"]=MetabaseTime();
  716.                                 $data[$row]["approved"]=MetabaseNow();
  717.                                 if(!InsertTestValues($database,$prepared_query,$data[$row]))
  718.                                 {
  719.                                     $success=0;
  720.                                     break;
  721.                                 }
  722.                             }
  723.                             MetabaseFreePreparedQuery($database,$prepared_query);
  724.                             if($success)
  725.                             {
  726.                                 for($rows=2,$start_row=0;$pass && $start_row<$total_rows;$start_row+=$rows)
  727.                                 {
  728.                                     MetabaseSetSelectedRowRange($database,$start_row,$rows);
  729.                                     if(!($result=MetabaseQuery($database,"SELECT user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved FROM users ORDER BY user_id")))
  730.                                     {
  731.                                         $success=0;
  732.                                         break;
  733.                                     }
  734.                                     else
  735.                                     {
  736.                                         for($row=0;$row<$rows && $row+$start_row<$total_rows;$row++)
  737.                                         {
  738.                                             if(VerifyFetchedValues($database,$result,$row,$data[$row+$start_row],$value,$field))
  739.                                             {
  740.                                                 $pass=0;
  741.                                                 echo "FAILED!$eol";
  742.                                                 $failed++;
  743.                                                 echo "Test $test: the value retrieved from row ".($row+$start_row)." for field \"$field\" ($value) doesn't match what was stored (".$data[$row+$start_row][$field].")$eol";
  744.                                                 break;
  745.                                             }
  746.                                         }
  747.                                         if($pass)
  748.                                         {
  749.                                             if(!MetabaseEndOfResult($database,$result))
  750.                                             {
  751.                                                 $pass=0;
  752.                                                 echo "FAILED!$eol";
  753.                                                 $failed++;
  754.                                                 echo "Test $test: the query result did not seem to have reached the end of result as expected starting row $start_row after fetching upto row $row$eol";
  755.                                             }
  756.                                         }
  757.                                         MetabaseFreeResult($database,$result);
  758.                                     }
  759.                                 }
  760.                             }
  761.                             if($success)
  762.                             {
  763.                                 for($rows=2,$start_row=0;$pass && $start_row<$total_rows;$start_row+=$rows)
  764.                                 {
  765.                                     MetabaseSetSelectedRowRange($database,$start_row,$rows);
  766.                                     if(!($result=MetabaseQuery($database,"SELECT user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved FROM users ORDER BY user_id")))
  767.                                     {
  768.                                         $success=0;
  769.                                         break;
  770.                                     }
  771.                                     else
  772.                                     {
  773.                                         if(($result_rows=MetabaseNumberOfRows($database,$result))>$rows)
  774.                                         {
  775.                                             $pass=0;
  776.                                             echo "FAILED!$eol";
  777.                                             $failed++;
  778.                                             echo "Test $test: expected a result of no more than $rows but the returned number of rows is $result_rows";
  779.                                         }
  780.                                         else
  781.                                         {
  782.                                             for($row=0;$row<$result_rows;$row++)
  783.                                             {
  784.                                                 if(MetabaseEndOfResult($database,$result))
  785.                                                 {
  786.                                                     $pass=0;
  787.                                                     echo "FAILED!$eol";
  788.                                                     $failed++;
  789.                                                     echo "Test $test: the query result seem to have reached the end of result at row $row that is before $result_rows as expected$eol";
  790.                                                     break;
  791.                                                 }
  792.                                                 if(VerifyFetchedValues($database,$result,$row,$data[$row+$start_row],$value,$field))
  793.                                                 {
  794.                                                     $pass=0;
  795.                                                     echo "FAILED!$eol";
  796.                                                     $failed++;
  797.                                                     echo "Test $test: the value retrieved from row ".($row+$start_row)." for field \"$field\" ($value) doesn't match what was stored (".$data[$row+$start_row][$field].")$eol";
  798.                                                     break;
  799.                                                 }
  800.                                             }
  801.                                         }
  802.                                         if($pass)
  803.                                         {
  804.                                             if(!MetabaseEndOfResult($database,$result))
  805.                                             {
  806.                                                 $pass=0;
  807.                                                 echo "FAILED!$eol";
  808.                                                 $failed++;
  809.                                                 echo "Test $test: the query result did not seem to have reached the end of result as expected$eol";
  810.                                             }
  811.                                         }
  812.                                         MetabaseFreeResult($database,$result);
  813.                                     }
  814.                                 }
  815.                             }
  816.                             if($success
  817.                             && $pass)
  818.                             {
  819.                                 $passed++;
  820.                                 echo "OK.$eol";
  821.                             }
  822.                         }
  823.                         else
  824.                             $success=0;
  825.                     }
  826.                 }
  827.                 else
  828.                     echo "Selecting rows ranges is not supported.$eol";
  829.             }
  830.  
  831.             if(IsSet($tests["sequences"])
  832.             && $success)
  833.             {
  834.                 if(MetabaseSupport($database,"Sequences"))
  835.                 {
  836.                     $test="sequences";
  837.                     echo "Testing sequences... ";
  838.                     flush();
  839.                     $pass=1;
  840.                     for($start_value=1;$success && $pass && $start_value<4;$start_value++)
  841.                     {
  842.                         $sequence_name="test_sequence_$start_value";
  843.                         MetabaseDropSequence($database,$sequence_name);
  844.                         if(($success=MetabaseCreateSequence($database,$sequence_name,$start_value)))
  845.                         {
  846.                             for($sequence_value=$start_value;$sequence_value<$start_value+4;$sequence_value++)
  847.                             {
  848.                                 if(!($success=MetabaseGetSequenceNextValue($database,$sequence_name,$value)))
  849.                                     break;
  850.                                 if($value!=$sequence_value)
  851.                                 {
  852.                                     $pass=0;
  853.                                     echo "FAILED!$eol";
  854.                                     $failed++;
  855.                                     echo "Test $test: the returned sequence value is $value and not $sequence_value as expected with sequence start value with $start_value$eol";
  856.                                     break;
  857.                                 }
  858.                             }
  859.                             if(!$success)
  860.                                 $error=MetabaseError($database);
  861.                             if(!MetabaseDropSequence($database,$sequence_name))
  862.                             {
  863.                                 if(!$success)
  864.                                     $error.=" - ";
  865.                                 $error.=MetabaseError($database);
  866.                                 $success=0;
  867.                             }
  868.                         }
  869.                     }
  870.                     if($success
  871.                     && $pass)
  872.                     {
  873.                         $passed++;
  874.                         echo "OK.$eol";
  875.                     }
  876.                 }
  877.                 else
  878.                     echo "Sequences are not supported.$eol";
  879.             }
  880.  
  881.             if(IsSet($tests["replace"])
  882.             && $success)
  883.             {
  884.                 if(MetabaseSupport($database,"Replace"))
  885.                 {
  886.                     $test="sequences";
  887.                     echo "Testing the replace query... ";
  888.                     flush();
  889.                     $pass=1;
  890.                     if(!MetabaseQuery($database,"DELETE FROM users"))
  891.                         $success=0;
  892.                     else
  893.                     {
  894.                         $row=1234;
  895.                         $data=array();
  896.                         $data["user_name"]="user_$row";
  897.                         $data["user_password"]="somepassword";
  898.                         $data["subscribed"]=$row % 2;
  899.                         $data["user_id"]=$row;
  900.                         $data["quota"]=strval($row/100);
  901.                         $data["weight"]=sqrt($row);
  902.                         $data["access_date"]=MetabaseToday();
  903.                         $data["access_time"]=MetabaseTime();
  904.                         $data["approved"]=MetabaseNow();
  905.                         $fields=array(
  906.                             "user_name"=>array(
  907.                                 "Value"=>"user_$row",
  908.                                 "Type"=>"text"
  909.                             ),
  910.                             "user_password"=>array(
  911.                                 "Value"=>$data["user_password"],
  912.                                 "Type"=>"text"
  913.                             ),
  914.                             "subscribed"=>array(
  915.                                 "Value"=>$data["subscribed"],
  916.                                 "Type"=>"boolean"
  917.                             ),
  918.                             "user_id"=>array(
  919.                                 "Value"=>$data["user_id"],
  920.                                 "Type"=>"integer",
  921.                                 "Key"=>1
  922.                             ),
  923.                             "quota"=>array(
  924.                                 "Value"=>$data["quota"],
  925.                                 "Type"=>"decimal"
  926.                             ),
  927.                             "weight"=>array(
  928.                                 "Value"=>$data["weight"],
  929.                                 "Type"=>"float"
  930.                             ),
  931.                             "access_date"=>array(
  932.                                 "Value"=>$data["access_date"],
  933.                                 "Type"=>"date"
  934.                             ),
  935.                             "access_time"=>array(
  936.                                 "Value"=>$data["access_time"],
  937.                                 "Type"=>"time"
  938.                             ),
  939.                             "approved"=>array(
  940.                                 "Value"=>$data["approved"],
  941.                                 "Type"=>"timestamp"
  942.                             )
  943.                         );
  944.                         $support_affected_rows=MetabaseSupport($database,"AffectedRows");
  945.                         if(($success=MetabaseReplace($database,"users",$fields))
  946.                         && (!$support_affected_rows
  947.                         || ($success=MetabaseAffectedRows($database,$affected_rows))))
  948.                         {
  949.                             if($support_affected_rows
  950.                             && $affected_rows!=1)
  951.                             {
  952.                                 $pass=0;
  953.                                 echo "FAILED!$eol";
  954.                                 $failed++;
  955.                                 echo "Test $test: replacing a row in an empty table returned $affected_rows unlike 1 as expected$eol";
  956.                             }
  957.                             else
  958.                             {
  959.                                 if(!($result=MetabaseQuery($database,"SELECT user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved FROM users")))
  960.                                     $success=0;
  961.                                 else
  962.                                 {
  963.                                     $verify=VerifyFetchedValues($database,$result,0,$data,$value,$field);
  964.                                     MetabaseFreeResult($database,$result);
  965.                                     if($verify)
  966.                                     {
  967.                                         $pass=0;
  968.                                         echo "FAILED!$eol";
  969.                                         $failed++;
  970.                                         echo "Test $test: the value retrieved for field \"$field\" ($value) doesn't match what was inserted (".$data[$field].")$eol";
  971.                                     }
  972.                                     else
  973.                                     {
  974.                                         $row=4321;
  975.                                         $fields["user_name"]["Value"]=$data["user_name"]="user_$row";
  976.                                         $fields["user_password"]["Value"]=$data["user_password"]="somepassword";
  977.                                         $fields["subscribed"]["Value"]=$data["subscribed"]=$row % 2;
  978.                                         $fields["quota"]["Value"]=$data["quota"]=strval($row/100);
  979.                                         $fields["weight"]["Value"]=$data["weight"]=sqrt($row);
  980.                                         $fields["access_date"]["Value"]=$data["access_date"]=MetabaseToday();
  981.                                         $fields["access_time"]["Value"]=$data["access_time"]=MetabaseTime();
  982.                                         $fields["approved"]["Value"]=$data["approved"]=MetabaseNow();
  983.                                         if(($success=MetabaseReplace($database,"users",$fields))
  984.                                         && (!$support_affected_rows
  985.                                         || ($success=MetabaseAffectedRows($database,$affected_rows))))
  986.                                         {
  987.                                             if(!$support_affected_rows
  988.                                             && $affected_rows!=2)
  989.                                             {
  990.                                                 $pass=0;
  991.                                                 echo "FAILED!$eol";
  992.                                                 $failed++;
  993.                                                 echo "Test $test: replacing a row in an table with a single row returned $affected_rows unlike 2 as expected$eol";
  994.                                             }
  995.                                             if(!($result=MetabaseQuery($database,"SELECT user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved FROM users")))
  996.                                                 $success=0;
  997.                                             else
  998.                                             {
  999.                                                 if(VerifyFetchedValues($database,$result,0,$data,$value,$field))
  1000.                                                 {
  1001.                                                     $pass=0;
  1002.                                                     echo "FAILED!$eol";
  1003.                                                     $failed++;
  1004.                                                     echo "Test $test: the value retrieved for field \"$field\" ($value) doesn't match what was replaced (".$data[$field].")$eol";
  1005.                                                 }
  1006.                                                 else
  1007.                                                 {
  1008.                                                     if(!MetabaseEndOfResult($database,$result))
  1009.                                                     {
  1010.                                                         $pass=0;
  1011.                                                         echo "FAILED!$eol";
  1012.                                                         $failed++;
  1013.                                                         echo "Test $test: the query result did not seem to have reached the end of result as expected$eol";
  1014.                                                     }
  1015.                                                 }
  1016.                                                 MetabaseFreeResult($database,$result);
  1017.                                             }
  1018.                                         }
  1019.                                     }
  1020.                                 }
  1021.                             }
  1022.                         }
  1023.                     }
  1024.                     if($success
  1025.                     && $pass)
  1026.                     {
  1027.                         $passed++;
  1028.                         echo "OK.$eol";
  1029.                     }
  1030.                 }
  1031.                 else
  1032.                     echo "Replace query is not supported.$eol";
  1033.             }
  1034.  
  1035.             if(IsSet($tests["affectedrows"])
  1036.             && $success)
  1037.             {
  1038.                 if(MetabaseSupport($database,"AffectedRows"))
  1039.                 {
  1040.                     $test="affectedrows";
  1041.                     echo "Testing query affected rows... ";
  1042.                     flush();
  1043.                     $pass=1;
  1044.                     if(!MetabaseQuery($database,"DELETE FROM users"))
  1045.                         $success=0;
  1046.                     else
  1047.                     {
  1048.                         if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO users (user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved) VALUES (?,?,?,?,?,?,?,?,?)")))
  1049.                         {
  1050.                             $data=array();
  1051.                             $inserted_rows=7;
  1052.                             for($row=0;$row<$inserted_rows;$row++)
  1053.                             {
  1054.                                 $data["user_name"]="user_$row";
  1055.                                 $data["user_password"]="somepassword";
  1056.                                 $data["subscribed"]=$row % 2;
  1057.                                 $data["user_id"]=$row;
  1058.                                 $data["quota"]=strval($row/100);
  1059.                                 $data["weight"]=sqrt($row);
  1060.                                 $data["access_date"]=MetabaseToday();
  1061.                                 $data["access_time"]=MetabaseTime();
  1062.                                 $data["approved"]=MetabaseNow();
  1063.                                 if(!InsertTestValues($database,$prepared_query,$data)
  1064.                                 || !MetabaseAffectedRows($database,$affected_rows))
  1065.                                 {
  1066.                                     $success=0;
  1067.                                     break;
  1068.                                 }
  1069.                                 if($affected_rows!=1)
  1070.                                 {
  1071.                                     $pass=0;
  1072.                                     echo "FAILED!$eol";
  1073.                                     $failed++;
  1074.                                     echo "Test $test: inserting the row $row return $affected_rows affected row count instead of 1 as expected$eol";
  1075.                                     break;
  1076.                                 }
  1077.                             }
  1078.                             MetabaseFreePreparedQuery($database,$prepared_query);
  1079.                         }
  1080.                         else
  1081.                             $success=0;
  1082.                         if($success
  1083.                         && $pass
  1084.                         && ($prepared_query=MetabasePrepareQuery($database,"UPDATE users SET user_password=? WHERE user_id<?")))
  1085.                         {
  1086.                             for($row=0;$row<$inserted_rows;$row++)
  1087.                             {
  1088.                                 MetabaseQuerySetText($database,$prepared_query,1,"another_password_$row");
  1089.                                 MetabaseQuerySetInteger($database,$prepared_query,2,$row);
  1090.                                 if(!MetabaseExecuteQuery($database,$prepared_query)
  1091.                                 || !MetabaseAffectedRows($database,$affected_rows))
  1092.                                 {
  1093.                                     $success=0;
  1094.                                     break;
  1095.                                 }
  1096.                                 if($affected_rows!=$row)
  1097.                                 {
  1098.                                     $pass=0;
  1099.                                     echo "FAILED!$eol";
  1100.                                     $failed++;
  1101.                                     echo "Test $test: updating the $row rows returned $affected_rows affected row count$eol";
  1102.                                     break;
  1103.                                 }
  1104.                             }
  1105.                             MetabaseFreePreparedQuery($database,$prepared_query);
  1106.                         }
  1107.                         else
  1108.                             $success=0;
  1109.                         if($success
  1110.                         && $pass
  1111.                         && ($prepared_query=MetabasePrepareQuery($database,"DELETE FROM users WHERE user_id>=?")))
  1112.                         {
  1113.                             for($row=$inserted_rows;$inserted_rows;$inserted_rows=$row)
  1114.                             {
  1115.                                 MetabaseQuerySetInteger($database,$prepared_query,1,$row=intval($inserted_rows/2));
  1116.                                 if(!MetabaseExecuteQuery($database,$prepared_query)
  1117.                                 || !MetabaseAffectedRows($database,$affected_rows))
  1118.                                 {
  1119.                                     $success=0;
  1120.                                     break;
  1121.                                 }
  1122.                                 if($affected_rows!=$inserted_rows-$row)
  1123.                                 {
  1124.                                     $pass=0;
  1125.                                     echo "FAILED!$eol";
  1126.                                     $failed++;
  1127.                                     echo "Test $test: deleting ".($inserted_rows-$row)." rows returned $affected_rows affected row count$eol";
  1128.                                     break;
  1129.                                 }
  1130.                             }
  1131.                             MetabaseFreePreparedQuery($database,$prepared_query);
  1132.                         }
  1133.                         else
  1134.                             $success=0;
  1135.                         if($success
  1136.                         && $pass)
  1137.                         {
  1138.                             $passed++;
  1139.                             echo "OK.$eol";
  1140.                         }
  1141.                     }
  1142.                 }
  1143.                 else
  1144.                     echo "Query AffectedRows fetching is not supported.$eol";
  1145.             }
  1146.  
  1147.             if(IsSet($tests["transactions"])
  1148.             && $success)
  1149.             {
  1150.                 if(MetabaseSupport($database,"Transactions"))
  1151.                 {
  1152.                     $test="transactions";
  1153.                     echo "Testing transactions... ";
  1154.                     flush();
  1155.                     $pass=1;
  1156.                     if(!MetabaseQuery($database,"DELETE FROM users")
  1157.                     || !MetabaseAutoCommitTransactions($database,0))
  1158.                         $success=0;
  1159.                     else
  1160.                     {
  1161.                         if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO users (user_name,user_password,subscribed,user_id,quota,weight,access_date,access_time,approved) VALUES (?,?,?,?,?,?,?,?,?)")))
  1162.                         {
  1163.                             $data=array();
  1164.                             $row=0;
  1165.                             $data["user_name"]="user_$row";
  1166.                             $data["user_password"]="somepassword";
  1167.                             $data["subscribed"]=$row % 2;
  1168.                             $data["user_id"]=$row;
  1169.                             $data["quota"]=strval($row/100);
  1170.                             $data["weight"]=sqrt($row);
  1171.                             $data["access_date"]=MetabaseToday();
  1172.                             $data["access_time"]=MetabaseTime();
  1173.                             $data["approved"]=MetabaseNow();
  1174.                             if(!InsertTestValues($database,$prepared_query,$data)
  1175.                             || !MetabaseRollbackTransaction($database)
  1176.                             || !($result=MetabaseQuery($database,"SELECT * FROM users")))
  1177.                             {
  1178.                                 $success=0;
  1179.                             }
  1180.                             else
  1181.                             {
  1182.                                 if(!MetabaseEndOfResult($database,$result))
  1183.                                 {
  1184.                                     $pass=0;
  1185.                                     echo "FAILED!$eol";
  1186.                                     $failed++;
  1187.                                     echo "Test $test: transaction rollback did not revert the row that was inserted$eol";
  1188.                                 }
  1189.                                 MetabaseFreeResult($database,$result);
  1190.                             }
  1191.                             if($success
  1192.                             && $pass)
  1193.                             {
  1194.                                 if(!InsertTestValues($database,$prepared_query,$data)
  1195.                                 || !MetabaseCommitTransaction($database)
  1196.                                 || !($result=MetabaseQuery($database,"SELECT * FROM users")))
  1197.                                     $success=0;
  1198.                                 else
  1199.                                 {
  1200.                                     if(MetabaseEndOfResult($database,$result))
  1201.                                     {
  1202.                                         $pass=0;
  1203.                                         echo "FAILED!$eol";
  1204.                                         $failed++;
  1205.                                         echo "Test $test: transaction commit did not make permanent the row that was inserted$eol";
  1206.                                     }
  1207.                                     MetabaseFreeResult($database,$result);
  1208.                                 }
  1209.                             }
  1210.                             if($success
  1211.                             && $pass)
  1212.                             {
  1213.                                 if(!($result=MetabaseQuery($database,"DELETE FROM users")))
  1214.                                     $success=0;
  1215.                             }
  1216.                             if(!$success)
  1217.                             {
  1218.                                 $error=MetabaseError($database);
  1219.                                 MetabaseRollbackTransaction($database);
  1220.                             }
  1221.                             if(!MetabaseAutoCommitTransactions($database,1))
  1222.                             {
  1223.                                 if(strcmp($error,""))
  1224.                                     $error.=" and then could not end the transactions";
  1225.                                 $success=0;
  1226.                             }
  1227.                             MetabaseFreePreparedQuery($database,$prepared_query);
  1228.                             if($success
  1229.                             && $pass)
  1230.                             {
  1231.                                 if(!($result=MetabaseQuery($database,"SELECT * FROM users")))
  1232.                                     $success=0;
  1233.                                 else
  1234.                                 {
  1235.                                     if(!MetabaseEndOfResult($database,$result))
  1236.                                     {
  1237.                                         $pass=0;
  1238.                                         echo "FAILED!$eol";
  1239.                                         $failed++;
  1240.                                         echo "Test $test: transaction end with implicit commit when re-enabling auto-commit did not make permanent the rows that were deleted$eol";
  1241.                                     }
  1242.                                     MetabaseFreeResult($database,$result);
  1243.                                 }
  1244.                             }
  1245.                         }
  1246.                         else
  1247.                             $success=0;
  1248.                         if($success
  1249.                         && $pass)
  1250.                         {
  1251.                             $passed++;
  1252.                             echo "OK.$eol";
  1253.                         }
  1254.                     }
  1255.                 }
  1256.                 else
  1257.                     echo "Transactions are not supported.$eol";
  1258.             }
  1259.  
  1260.             $support_lobs=MetabaseSupport($database,"LOBs");
  1261.             if((IsSet($tests["lobstorage"])
  1262.             || IsSet($tests["lobfiles"])
  1263.             || IsSet($tests["lobnulls"]))
  1264.             && $success)
  1265.             {
  1266.                 if($support_lobs)
  1267.                 {
  1268.                     $input_file="lob_test.schema";
  1269.                     if(!($success=$manager->UpdateDatabase($input_file,$input_file.".before",$driver_arguments,$database_variables)))
  1270.                         $error=$manager->error;
  1271.                     $debug_output="";
  1272.                     if(count($manager->warnings)>0)
  1273.                         $debug_output.="WARNING:$eol".implode($manager->warnings,"!$eol").$eol;
  1274.                     if($manager->database
  1275.                     && IsSet($driver_arguments["CaptureDebug"]))
  1276.                         $debug_output.=MetabaseDebugOutput($manager->database);
  1277.                 }
  1278.                 else
  1279.                     echo "LOBs are not supported.$eol";
  1280.             }
  1281.  
  1282.             if($support_lobs
  1283.             && IsSet($tests["lobstorage"])
  1284.             && $success)
  1285.             {
  1286.                 $test="lobstorage";
  1287.                 echo "Testing lob storage... ";
  1288.                 flush();
  1289.                 $pass=1;
  1290.                 if(!MetabaseQuery($database,"DELETE FROM files"))
  1291.                     $success=0;
  1292.                 else
  1293.                 {
  1294.                     if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO files (document,picture) VALUES (?,?)")))
  1295.                     {
  1296.                         $character_lob=array(
  1297.                             "Database"=>$database,
  1298.                             "Error"=>"",
  1299.                             "Data"=>""
  1300.                         );
  1301.                         for($code=32;$code<=127;$code++)
  1302.                             $character_lob["Data"].=chr($code);
  1303.                         $binary_lob=array(
  1304.                             "Database"=>$database,
  1305.                             "Error"=>"",
  1306.                             "Data"=>""
  1307.                         );
  1308.                         for($code=0;$code<=255;$code++)
  1309.                             $binary_lob["Data"].=chr($code);
  1310.                         if(($success=MetabaseCreateLOB($character_lob,$clob)))
  1311.                         {
  1312.                             if(($success=MetabaseCreateLOB($binary_lob,$blob)))
  1313.                             {
  1314.                                 MetabaseQuerySetCLOB($database,$prepared_query,1,$clob,"document");
  1315.                                 MetabaseQuerySetBLOB($database,$prepared_query,2,$blob,"picture");
  1316.                                 $success=MetabaseExecuteQuery($database,$prepared_query);
  1317.                                 MetabaseDestroyLOB($blob);
  1318.                             }
  1319.                             else
  1320.                                 $error=$binary_lob["Error"];
  1321.                             MetabaseDestroyLOB($clob);
  1322.                         }
  1323.                         else
  1324.                             $error=$character_lob["Error"];
  1325.                         MetabaseFreePreparedQuery($database,$prepared_query);
  1326.                         if(!$success
  1327.                         || !($result=MetabaseQuery($database,"SELECT document,picture FROM files")))
  1328.                             $success=0;
  1329.                         else
  1330.                         {
  1331.                             if(MetabaseEndOfResult($database,$result))
  1332.                             {
  1333.                                 $pass=0;
  1334.                                 echo "FAILED!$eol";
  1335.                                 $failed++;
  1336.                                 echo "Test $test: the query result seem to have reached the end of result too soon.$eol";
  1337.                             }
  1338.                             else
  1339.                             {
  1340.                                 $clob=MetabaseFetchCLOBResult($database,$result,0,"document");
  1341.                                 if($clob)
  1342.                                 {
  1343.                                     for($value="";!MetabaseEndOfLOB($clob);)
  1344.                                     {
  1345.                                         if(MetabaseReadLOB($clob,$data,8000)<0)
  1346.                                         {
  1347.                                             $error=MetabaseLOBError($clob);
  1348.                                             $success=0;
  1349.                                             break;
  1350.                                         }
  1351.                                         $value.=$data;
  1352.                                     }
  1353.                                     MetabaseDestroyLOB($clob);
  1354.                                     if($success)
  1355.                                     {
  1356.                                         if(strcmp($value,$character_lob["Data"]))
  1357.                                         {
  1358.                                             $pass=0;
  1359.                                             echo "FAILED!$eol";
  1360.                                             $failed++;
  1361.                                             echo "Test $test: retrieved character LOB value (\"".$value."\") is different from what was stored (\"".$character_lob["Data"]."\")$eol";
  1362.                                         }
  1363.                                         else
  1364.                                         {
  1365.                                             $blob=MetabaseFetchBLOBResult($database,$result,0,"picture");
  1366.                                             if($blob)
  1367.                                             {
  1368.                                                 for($value="";!MetabaseEndOfLOB($blob);)
  1369.                                                 {
  1370.                                                     if(MetabaseReadLOB($blob,$data,8000)<0)
  1371.                                                     {
  1372.                                                         $error=MetabaseLOBError($blob);
  1373.                                                         $success=0;
  1374.                                                         break;
  1375.                                                     }
  1376.                                                     $value.=$data;
  1377.                                                 }
  1378.                                                 MetabaseDestroyLOB($blob);
  1379.                                                 if($success)
  1380.                                                 {
  1381.                                                     if(strcmp($value,$binary_lob["Data"]))
  1382.                                                     {
  1383.                                                         $pass=0;
  1384.                                                         echo "FAILED!$eol";
  1385.                                                         $failed++;
  1386.                                                         echo "Test $test: retrieved binary LOB value (\"".$value."\") is different from what was stored (\"".$binary_lob["Data"]."\")$eol";
  1387.                                                     }
  1388.                                                 }
  1389.                                             }
  1390.                                             else
  1391.                                                 $success=0;
  1392.                                         }
  1393.                                     }
  1394.                                 }
  1395.                                 else
  1396.                                     $success=0;
  1397.                             }
  1398.                             MetabaseFreeResult($database,$result);
  1399.                         }
  1400.                     }
  1401.                     else
  1402.                         $success=0;
  1403.                 }
  1404.                 if($success
  1405.                 && $pass)
  1406.                 {
  1407.                     $passed++;
  1408.                     echo "OK.$eol";
  1409.                 }
  1410.             }
  1411.  
  1412.             if($support_lobs
  1413.             && IsSet($tests["lobfiles"])
  1414.             && $success)
  1415.             {
  1416.                 $test="lobfiles";
  1417.                 echo "Testing lob storage from and to files... ";
  1418.                 flush();
  1419.                 $pass=1;
  1420.                 if(!MetabaseQuery($database,"DELETE FROM files"))
  1421.                     $success=0;
  1422.                 else
  1423.                 {
  1424.                     if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO files (document,picture) VALUES (?,?)")))
  1425.                     {
  1426.                         $character_data_file="character_data";
  1427.                         if(($file=fopen($character_data_file,"wb")))
  1428.                         {
  1429.                             for($character_data="",$code=32;$code<=127;$code++)
  1430.                                 $character_data.=chr($code);
  1431.                             $character_lob=array(
  1432.                                 "Type"=>"inputfile",
  1433.                                 "Database"=>$database,
  1434.                                 "Error"=>"",
  1435.                                 "FileName"=>$character_data_file,
  1436.                                 "BufferLength"=>32
  1437.                             );
  1438.                             $success=(fwrite($file,$character_data,strlen($character_data))==strlen($character_data));
  1439.                             fclose($file);
  1440.                             if($success)
  1441.                             {
  1442.                                 $binary_data_file="binary_data";
  1443.                                 if(($file=fopen($binary_data_file,"wb")))
  1444.                                 {
  1445.                                     for($binary_data="",$code=0;$code<=255;$code++)
  1446.                                         $binary_data.=chr($code);
  1447.                                     $binary_lob=array(
  1448.                                         "Type"=>"inputfile",
  1449.                                         "Database"=>$database,
  1450.                                         "Error"=>"",
  1451.                                         "FileName"=>$binary_data_file,
  1452.                                         "BufferLength"=>32
  1453.                                     );
  1454.                                     $success=(fwrite($file,$binary_data,strlen($binary_data))==strlen($binary_data));
  1455.                                     fclose($file);
  1456.                                 }
  1457.                                 else
  1458.                                     $success=0;
  1459.                             }
  1460.                         }
  1461.                         else
  1462.                             $sucess=0;
  1463.                         if($success)
  1464.                         {
  1465.                             if(($success=MetabaseCreateLOB($character_lob,$clob)))
  1466.                             {
  1467.                                 if(($success=MetabaseCreateLOB($binary_lob,$blob)))
  1468.                                 {
  1469.                                     MetabaseQuerySetCLOB($database,$prepared_query,1,$clob,"document");
  1470.                                     MetabaseQuerySetBLOB($database,$prepared_query,2,$blob,"picture");
  1471.                                     $success=MetabaseExecuteQuery($database,$prepared_query);
  1472.                                     MetabaseDestroyLOB($blob);
  1473.                                 }
  1474.                                 else
  1475.                                     $error=$binary_lob["Error"];
  1476.                                 MetabaseDestroyLOB($clob);
  1477.                             }
  1478.                             else
  1479.                                 $error=$character_lob["Error"];
  1480.                             MetabaseFreePreparedQuery($database,$prepared_query);
  1481.                             if(!$success
  1482.                             || !($result=MetabaseQuery($database,"SELECT document,picture FROM files")))
  1483.                                 $success=0;
  1484.                             else
  1485.                             {
  1486.                                 if(MetabaseEndOfResult($database,$result))
  1487.                                 {
  1488.                                     $pass=0;
  1489.                                     echo "FAILED!$eol";
  1490.                                     $failed++;
  1491.                                     echo "Test $test: the query result seem to have reached the end of result too soon.$eol";
  1492.                                 }
  1493.                                 else
  1494.                                 {
  1495.                                     $character_lob=array(
  1496.                                         "Type"=>"outputfile",
  1497.                                         "Database"=>$database,
  1498.                                         "Result"=>$result,
  1499.                                         "Row"=>0,
  1500.                                         "Field"=>"document",
  1501.                                         "Binary"=>0,
  1502.                                         "Error"=>"",
  1503.                                         "FileName"=>$character_data_file,
  1504.                                         "BufferLength"=>32
  1505.                                     );
  1506.                                     if(($success=MetabaseCreateLOB($character_lob,$clob)))
  1507.                                     {
  1508.                                         if(MetabaseReadLOB($clob,$data,0)<0)
  1509.                                         {
  1510.                                             $error=MetabaseLOBError($clob);
  1511.                                             $success=0;
  1512.                                         }
  1513.                                         MetabaseDestroyLOB($clob);
  1514.                                         if($success)
  1515.                                         {
  1516.                                             if(($file=fopen($character_data_file,"rb")))
  1517.                                             {
  1518.                                                 if(GetType($value=fread($file,filesize($character_data_file)))!="string")
  1519.                                                 {
  1520.                                                     $success=0;
  1521.                                                     $error="could not read from the character lob data file";
  1522.                                                 }
  1523.                                                 fclose($file);
  1524.                                             }
  1525.                                             else
  1526.                                             {
  1527.                                                 $success=0;
  1528.                                                 $error="could not reopen the character lob data file";
  1529.                                             }
  1530.                                         }
  1531.                                         if($success)
  1532.                                         {
  1533.                                             if(strcmp($value,$character_data))
  1534.                                             {
  1535.                                                 $pass=0;
  1536.                                                 echo "FAILED!$eol";
  1537.                                                 $failed++;
  1538.                                                 echo "Test $test: retrieved character LOB value (\"".$value."\") is different from what was stored (\"".$character_data."\")$eol";
  1539.                                             }
  1540.                                             else
  1541.                                             {
  1542.                                                 $binary_lob=array(
  1543.                                                     "Type"=>"outputfile",
  1544.                                                     "Database"=>$database,
  1545.                                                     "Result"=>$result,
  1546.                                                     "Row"=>0,
  1547.                                                     "Field"=>"picture",
  1548.                                                     "Binary"=>1,
  1549.                                                     "Error"=>"",
  1550.                                                     "FileName"=>$binary_data_file,
  1551.                                                     "BufferLength"=>32
  1552.                                                 );
  1553.                                                 if(($success=MetabaseCreateLOB($binary_lob,$blob)))
  1554.                                                 {
  1555.                                                     if(MetabaseReadLOB($blob,$data,0)<0)
  1556.                                                     {
  1557.                                                         $error=MetabaseLOBError($clob);
  1558.                                                         $success=0;
  1559.                                                     }
  1560.                                                     MetabaseDestroyLOB($blob);
  1561.                                                     if($success)
  1562.                                                     {
  1563.                                                         if(($file=fopen($binary_data_file,"rb")))
  1564.                                                         {
  1565.                                                             if(GetType($value=fread($file,filesize($binary_data_file)))!="string")
  1566.                                                             {
  1567.                                                                 $success=0;
  1568.                                                                 $error="could not read from the binary lob data file";
  1569.                                                             }
  1570.                                                             fclose($file);
  1571.                                                         }
  1572.                                                         else
  1573.                                                         {
  1574.                                                             $success=0;
  1575.                                                             $error="could not reopen the binary lob data file";
  1576.                                                         }
  1577.                                                     }
  1578.                                                     if($success)
  1579.                                                     {
  1580.                                                         if(strcmp($value,$binary_data))
  1581.                                                         {
  1582.                                                             $pass=0;
  1583.                                                             echo "FAILED!$eol";
  1584.                                                             $failed++;
  1585.                                                             echo "Test $test: retrieved binary LOB value (\"".$value."\") is different from what was stored (\"".$binary_data."\")$eol";
  1586.                                                         }
  1587.                                                     }
  1588.                                                 }
  1589.                                                 else
  1590.                                                     $success=0;
  1591.                                             }
  1592.                                         }
  1593.                                     }
  1594.                                     else
  1595.                                         $error=$character_lob["Error"];
  1596.                                 }
  1597.                                 MetabaseFreeResult($database,$result);
  1598.                             }
  1599.                         }
  1600.                         else
  1601.                             $success=0;
  1602.                     }
  1603.                 }
  1604.                 if($success
  1605.                 && $pass)
  1606.                 {
  1607.                     $passed++;
  1608.                     echo "OK.$eol";
  1609.                 }
  1610.             }
  1611.  
  1612.             if($support_lobs
  1613.             && IsSet($tests["lobnulls"])
  1614.             && $success)
  1615.             {
  1616.                 $test="lobnulls";
  1617.                 echo "Testing lob nulls... ";
  1618.                 flush();
  1619.                 $pass=1;
  1620.                 if(!MetabaseQuery($database,"DELETE FROM files"))
  1621.                     $success=0;
  1622.                 else
  1623.                 {
  1624.                     if(($prepared_query=MetabasePrepareQuery($database,"INSERT INTO files (document,picture) VALUES (?,?)")))
  1625.                     {
  1626.                         MetabaseQuerySetNULL($database,$prepared_query,1,"clob");
  1627.                         MetabaseQuerySetNULL($database,$prepared_query,2,"blob");
  1628.                         $success=MetabaseExecuteQuery($database,$prepared_query);
  1629.                         MetabaseFreePreparedQuery($database,$prepared_query);
  1630.                         if(!$success
  1631.                         || !($result=MetabaseQuery($database,"SELECT document,picture FROM files")))
  1632.                             $success=0;
  1633.                         else
  1634.                         {
  1635.                             if(MetabaseEndOfResult($database,$result))
  1636.                             {
  1637.                                 $pass=0;
  1638.                                 echo "FAILED!$eol";
  1639.                                 $failed++;
  1640.                                 echo "Test $test: the query result seem to have reached the end of result too soon.$eol";
  1641.                             }
  1642.                             else
  1643.                             {
  1644.                                 if(!MetabaseResultIsNull($database,$result,0,$field="document")
  1645.                                 || !MetabaseResultIsNull($database,$result,0,$field="picture"))
  1646.                                 {
  1647.                                     $pass=0;
  1648.                                     echo "FAILED!$eol";
  1649.                                     $failed++;
  1650.                                     echo "Test $test: a query result large object column is not NULL unlike what was expected$eol";
  1651.                                 }
  1652.                             }
  1653.                             MetabaseFreeResult($database,$result);
  1654.                         }
  1655.                     }
  1656.                     else
  1657.                         $success=0;
  1658.                 }
  1659.                 if($success
  1660.                 && $pass)
  1661.                 {
  1662.                     $passed++;
  1663.                     echo "OK.$eol";
  1664.                 }
  1665.             }
  1666.  
  1667.             if(!$success
  1668.             && !strcmp($error,""))
  1669.                 $error=MetabaseError($database);
  1670.             if(IsSet($driver_arguments["CaptureDebug"]))
  1671.                 $debug_output.=MetabaseDebugOutput($database);
  1672.             MetabaseCloseSetup($database);
  1673.         }
  1674.     }
  1675.     else
  1676.         $error=$manager->error;
  1677.     if(strcmp($error,""))
  1678.         echo "Error: $error$eol";
  1679.     else
  1680.     {
  1681.         echo ($failed==0 ? "Passed all the $passed tests that were performed!$eol" : ($passed==1 ? "Passed one test" : "$passed tests passed").", ".($failed==1 ? "Failed one test" : "$failed tests failed")."!$eol");
  1682.     }
  1683.     if(IsSet($driver_arguments["CaptureDebug"]))
  1684.         echo $debug_output;
  1685.     echo "Exiting.$eol"; flush();
  1686. ?>
  1687.