Subversion-Projekte lars-tiefland.php_share

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
1 lars 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 
?>