Annotation of embedaddon/php/ext/standard/tests/file/file.inc, revision 1.1.1.1
1.1 misho 1: <?php
2: /* Header file for common file test functions
3: Following functions are provided :
4: create_files() : create files with specified contents
5: delete_files() : delete files
6: create_links() : crate links of different types
7: delete_links() : delete links
8: fill_files() : fill file with specified contents
9: change_file_perms() : Change permission of files
10: fill_buffer() : fills buffer with specified contents
11: compare_self_stat() : compares the first 13 elements of the
12: stat with the corresponding named key values of
13: the same stat.
14: compare_stats() : Compares two stat values
15:
16: */
17:
18: define('file_not_found', 2, 1);
19:
20: /*
21: Function: bool create_file(string $filename, string $mode = "w");
22: Description: creates a new file using fopen() call
23: $filename = Name of the file
24: $mode = Mode as specified in fopen call, read documentation of fopen() call for more info
25:
26: Returns:
27: true on success, false otherwise
28: */
29: function create_file($filename, $mode = "w") {
30: $file_handle = fopen ($filename, $mode);
31: if ( $file_handle == false )
32: return false;
33: fclose($file_handle);
34: return true;
35: }
36:
37: /*
38: Function : bool fill_buffer(string &$buffer, string $fill_type, int $fill_size);
39: Description: Fills the $buffer with data as specified with requested size.
40: $buffer = buffer to be filled
41: $fill_type:
42: "text" = fills with string of size $file_size
43: "numeric" = fills with numeric value of size $file_size
44: "text_with_new_line" = similar to "text" fill type but writes with new line
45: "alphanumeric" = fills with alphnumeric values
46: Returns: true on success, false on invalid fill type
47: */
48: function fill_buffer(&$buffer, $fill_type, $fill_size) {
49:
50: if ( $fill_type == "text" ) {
51: $data = "text ";
52: $size_divider = strlen($data);
53: $add_value = strlen($data);
54: } else if ( $fill_type == "text_with_new_line" ) {
55: $data = "line\nline of text\n";
56: $size_divider = strlen($data);
57: $add_value = strlen($data);
58: } else if ( $fill_type == "alphanumeric" ) {
59: $data = "ab12 ";
60: $size_divider = strlen($data);
61: $add_value = strlen($data);
62: } else if ( $fill_type == "numeric" ) {
63: $data = 2;
64: $size_divider = 1;
65: $add_value = 0;
66: } else {
67: // invalid fill type;
68: return false;
69: }
70:
71: $tmp_buff = str_repeat($data, ($fill_size/$size_divider) + $add_value );
72:
73: if ( strlen($tmp_buff) > $fill_size ) {
74: $buffer = substr($tmp_buff, 0, $fill_size);
75: } else {
76: $buffer = $tmp_buff;
77: }
78:
79: return true;
80: }
81:
82: /*
83: Function : bool fill_file(resource $file_handle, string $fill_type, string $file_size);
84: Description: Fills the file with data as specified with requested size.
85: $file_handle = file handle, opened with write options,
86: $fill_type:
87: "text" = fills with string of size $file_size
88: "numeric" = fills with numeric value of size $file_size
89: "empty" = no fill operation performed, returns true
90: "text_with_new_line" = similar to "text" fill type but writes with new line
91: "alphanumeric" = fills with alphnumeric values
92: Returns: true on success, false on failure & invalid fill type
93: */
94:
95: function fill_file($file_handle, $fill_type, $file_size) {
96:
97: if ( $fill_type == "empty" ) {
98: // no fill required, return true
99: return true;
100: } if ( $fill_type == "text" ) {
101: $data = "text ";
102: $size_divider = strlen($data);
103: $add_value = strlen($data);
104: } else if ( $fill_type == "text_with_new_line" ) {
105: $data = "line\nline of text\n";
106: $size_divider = strlen($data);
107: $add_value = strlen($data);
108: } else if ( $fill_type == "alphanumeric" ) {
109: $data = "ab12 ";
110: $size_divider = strlen($data);
111: $add_value = strlen($data);
112: } else if ( $fill_type == "numeric" ) {
113: $data = 2;
114: $size_divider = 1;
115: $add_value = 0;
116: } else {
117: // invalid fill type;
118: return false;
119: }
120:
121: // write in terms of a chunk of 1 K to avoid memory size overflow
122: $size = $file_size;
123: $chunk_size = 1024;
124: if ( $size > $chunk_size ) {
125: $loop_count = 1;
126: do {
127: $loop_count ++;
128: if ( $size <= $chunk_size ) {
129: $chunk_size = $size;
130: }
131: $num_values = str_repeat($data, ($chunk_size/$size_divider) + $add_value );
132: $bytes_written = fwrite($file_handle, $num_values, $chunk_size);
133: if ( $bytes_written != $chunk_size ) {
134: return false;
135: }
136: $size -= $chunk_size;
137: } while ( $size > 0 );
138: } else {
139: $num_values = str_repeat($data, ($chunk_size/$size_divider) + $add_value );
140: $bytes_written = fwrite($file_handle, $num_values, $file_size);
141: if ( $bytes_written != $file_size ) {
142: return false;
143: }
144: }
145:
146: // successful, return true
147: return true;
148: }
149:
150: /*
151: Function: int change_file_perms(string $file_path, int $count = 1, int $perms = 0755,
152: string $name_prefix = "file",
153: string $name_suffix = 1, $file_extension = ".tmp");
154: Description: changes file permission for given file(s).
155: $file_path = dir path where file exists
156: $count = no. of files, default is 1
157: $perms = new permission of the file, similar to $mode args of chmod() call
158: $name_prefix = common name prefix, default is "file"
159: $name_suffix = suffix to end the common name given in name_prefix to create
160: a unique name. default is 1.
161: $file_extension = default is .tmp
162: Returns:
163: Integer, Count of total files permission changed.
164: */
165: function change_file_perms($file_path,
166: $count = 1,
167: $perms = 0755,
168: $name_prefix = "file",
169: $name_suffix = 1,
170: $file_extension = ".tmp" )
171: {
172: $changed = 0;
173:
174: if( $count <= 0 )
175: return $changed;
176:
177: if ( $name_suffix <= 0)
178: $name_suffix = 1;
179:
180: for($loop_counter = 1; $loop_counter <= $count; $loop_counter++) {
181: $filename = $file_path."/".$name_prefix.$name_suffix.$file_extension;
182: if( chmod($filename, $perms) )
183: $changed++;
184: $name_suffix++;
185: }
186: return $changed;
187: }
188:
189: /*
190: Function: array create_files( string $file_path,
191: int $count = 1,
192: string $content_type = "numeric",
193: int $permission = 0755,
194: int $size = 1,
195: string $mode = "w",
196: string $name_prefix = "file",
197: int $name_suffix = 1,
198: string $flag = "kilobytes"
199: string $file_extension = ".tmp"
200: );
201: Description: Creates given number of files with specified mode and
202: permissions. File is filled with content of size specified.
203: $file_path = dir where files will be created
204: $name_prefix = prefix to be used for names, name is suffix with a
205: unqiue numeric value to make the file name unique, default = file
206: $name_suffix = suffix to be used for the name, default = 1
207: $count = total no. of files to be created, default = 1
208: $mode = file open mode as specified in fopen() call. Do not use
209: modes used for only reading the file. Default = "w"
210: $permission = An octal number, This should be similar to $mode
211: specified in chmod() call.
212: $content_type = Specify type of the content to fill in the file.
213: "numeric" = fill file with numeric vlaues
214: "text" = fill file with regular text
215: "empty" = empty file
216: "text_with_new_line" = similar to text fill type, but writes with new line char
217: "alphanumeric" = fill file with alpha numeric text
218: If imporper $content type is specified, file is created as empty
219: $size = size of the fill in terms of kilobyte, i.e size of the file.
220: if $flag is specified as "byte", then then given size is taken in bytes
221: $flag = specifiy if size has to be treated as no of total bytes or
222: multiple of KB.
223: "kilobytes" = take size in terms of multiple of KB
224: "byte" = take size in terms of bytes
225: $file_extension = default is .tmp
226:
227: Returns:
228: An array with following key value pair:
229: created => total file created
230: filled => total files filled
231: perms_changed => total files permission changed
232: */
233: function create_files( $file_path,
234: $count = 1,
235: $content_type = "numeric",
236: $permission = 0755,
237: $size = 1,
238: $mode = "w",
239: $name_prefix = "file",
240: $name_suffix = 1,
241: $flag = "kilobytes",
242: $file_extension = ".tmp"
243: )
244: {
245: $return_value = array('created' => 0, 'filled' => 0, 'perms_changed' => 0);
246:
247: //ensure that suffix is a +ve integer
248: if ($name_suffix <= 0) {
249: $name_suffix = 1;
250: }
251:
252: // check for proper size
253: if ( $size == 0 )
254: return $return_value;
255:
256: // prepare the size based on flag
257: $file_size = $size;
258: if ( $flag == "kilobytes" ) {
259: $file_size = $file_size * 1024;
260: }
261:
262: $tmp_name_suffix = $name_suffix;
263: // create the files with specified mode and permission
264: for($file_created_count = 1; $file_created_count <= $count; $file_created_count ++) {
265: $filename = $file_path."/".$name_prefix.$tmp_name_suffix.$file_extension;
266:
267: $status = create_file($filename, $mode);
268:
269: $tmp_name_suffix++;
270:
271: if ($status == true) {
272: $return_value['created']++;
273: }
274: else {
275: return $return_value;
276: }
277: }
278:
279: if ( $content_type == "empty" ) {
280: $return_value['filled'] = $count;
281: } else {
282: // fill the file with specifiec type of data and size
283: $tmp_name_suffix = $name_suffix;
284: for($loop_counter = 1; $loop_counter <= $count; $loop_counter ++) {
285: $filename = $file_path."/".$name_prefix.$tmp_name_suffix.$file_extension;
286: $file_handle = fopen($filename, $mode);
287: if($file_handle == false) {
288: fclose($file_handle);
289: return $return_value;
290: } // end of if
291:
292: // call fill_file() to fill the file
293: if( fill_file($file_handle, $content_type, $file_size) )
294: $return_value['filled']++;
295:
296: fclose($file_handle);
297:
298: $tmp_name_suffix++;
299: } // end of for
300: }
301:
302: // change all file's permissions
303: $return_value['perms_changed'] = change_file_perms($file_path, $count, $permission, $name_prefix,
304: $name_suffix, $file_extension);
305:
306: return $return_value;
307: }
308:
309:
310: /*
311: Function: function create_links( $file_path,
312: $filename,
313: $link_count = 1,
314: $link_type = "soft",
315: $link_size = 1024,
316: $link_name_prefix = "link",
317: $link_name_suffix = 1,
318: $link_file_content = "text",
319: $link_perms = 0755,
320: $link_file_extension = ".tmp"
321: );
322:
323: Description: Creates given number of links with specified mode and
324: permissions.Link is filled with content of size specified.
325: $file_path = location of the file and where links need to be created
326: $link_name_prefix = prefix to be used for names, name is suffix with a
327: unique numeric value to make the file name unique, default = link
328: $link_name_suffix = suffix to be used for the name, default = 1
329: $link_count = total no. of links to be created to given file, default = 1
330: $link_perms = An octal number, This should be similar to $mode
331: specified in chmod() call.
332: $link_file_content = Type of the content to fill in the file.
333: numeric = fill file with numeric vlaues
334: text = fill file with regular text
335: text_with_new_line = same as text but new lines are written
336: alphanumeric = fill with alphanumeric text
337: If imporper $content type is specified, file is created as empty
338: $size = size of the fill in terms of kilobyte, i.e size of the file.
339: $link_type = type of the link to be created
340: "soft" = soft link
341: "hard" = hard link
342: $filename = file used to create a link on
343:
344: Returns:
345: An array with following key value pair:
346: created => total file created
347: filled => total files filled, always returned as 1
348: perms_changed => total files permission changed
349: */
350: function create_links($file_path,
351: $filename,
352: $link_count = 1,
353: $link_type = "soft",
354: $link_size = 1024,
355: $link_name_prefix = "link",
356: $link_name_suffix = 1,
357: $link_file_content = "text",
358: $link_perms = 0755,
359: $link_file_extension = ".tmp"
360: )
361: {
362: $return_value = array('created' => 0, 'filled' => 0, 'perms_changed' => 0);
363: $tmp_name_suffix = $link_name_suffix;
364: $src_filename = $file_path."/".$filename;
365: switch( $link_type ) {
366: default :
367: case "soft" : // create a soft link
368: for($link_created_count = 1; $link_created_count <= $link_count; $link_created_count++) {
369: $linkname = $file_path."/".$link_name_prefix.$tmp_name_suffix.$link_file_extension;
370: $status = symlink( $src_filename, $linkname);
371: $tmp_name_suffix++;
372: if ($status) {
373: $return_value['created']++;
374: }
375: else {
376: $return_value;
377: }
378: }
379: break;
380:
381: case "hard" : // create a hard link
382: for($link_created_count = 1; $link_created_count <= $link_count; $link_created_count++) {
383: $linkname = $file_path."/".$link_name_prefix.$tmp_name_suffix.$link_file_extension;
384: $status = link($src_filename, $linkname);
385: $tmp_name_suffix++;
386: if ($status) {
387: $return_value['created']++;
388: }
389: else {
390: $return_value;
391: }
392: }
393: break;
394: }
395:
396: if ( $link_file_content == "empty" ) {
397: $return_value['filled'] = 1;
398: return $return_value;
399: }
400:
401: // fill the file with specific type of data and size
402: $tmp_name_suffix = $link_name_suffix;
403: $linkname = $file_path."/".$link_name_prefix.$tmp_name_suffix.$link_file_extension;
404: $file_handle = fopen($linkname, "w");
405: if($file_handle == false) {
406: return $return_value;
407: } // end of if
408:
409: // call fill_file() to fill the file
410: if( fill_file($file_handle, $link_file_content, $link_size) )
411: $return_value['filled']++;
412:
413: // close the link
414: fclose($file_handle);
415:
416: // change the permission of the link file, only if hard link.
417: // this is not applicable to soft links
418: if( $link_type == "hard" ) {
419: $return_value['perms_changed'] = change_file_perms($file_path,
420: $link_count,
421: $link_perms,
422: $link_name_prefix,
423: $link_name_suffix,
424: $link_file_extension );
425: }
426:
427: return $return_value;
428: }
429:
430: /*
431: Function: bool delete_file(string $filename);
432: Description: delete a given file if exists
433: Returns: true on success
434: false on failure
435: file_not_found if file doesn't exist
436: */
437: function delete_file($filename) {
438: // check if file exists
439: if ( file_exists($filename) ) {
440: if ( unlink($filename) )
441: return true;
442: else
443: return false;
444: }
445: return file_not_found;
446: }
447:
448: /*
449: Function: array delete_files(string $file_path, int $count = 1, string $name_prefix = "file",
450: int name_suffix = 1, $file_extension = ".tmp" );
451: Description: Deletes given number of files if exists.
452: $file_path = location of the files
453: $name_prefix = prefix for the filename, rest of the name is incremental(increment by 1 only)
454: numeric starting from suffix upto count
455: $count = number of files to be deleted
456: $name_suffix = first numeric suffix in the name
457: Returns: An array with following key/value pair
458: deleted = Number of files deleted.
459: notfound = Count of non existing file
460: failed = Count of failed to delete
461: */
462: function delete_files($file_path,
463: $count = 1,
464: $name_prefix = "file",
465: $name_suffix = 1,
466: $file_extension = ".tmp")
467: {
468: $return_value = array ('deleted' => 0, 'notfound' => 0, 'failed' => 0);
469:
470: if ( $name_suffix < 1 )
471: $name_suffix = 1;
472: for($loop_counter = 1; $loop_counter <= $count; $loop_counter++) {
473: $filename = $file_path."/".$name_prefix.$name_suffix.$file_extension;
474: $name_suffix++;
475: $status = delete_file($filename);
476: if($status == true) {
477: $return_value['deleted']++;
478: } else if($status == file_not_found) {
479: $return_value['notfound']++;
480: } else {
481: $return_value['failed']++;
482: }
483:
484: } // end of for
485: return $return_value;
486: }
487:
488: /*
489: Function: array delete_links( $file_path,
490: $link_file_count,
491: $link_name_prefix,
492: $link_name_suffix,
493: $link_file_extension );
494: Description: Deletes given number of links if exists. Uses delete_files() function
495: $file_path = location of link files
496: $link_file_count = Number of link files
497: $link_name_prefix = prefix for the linkname, rest of the name is incremental(increment by 1 only)
498: numeric starting from $link_name_suffix upto count
499: $link_name_suffix = first numeric suffix in the name
500:
501: Returns: An array with following key/value pair
502: deleted = Number of links deleted.
503: notfound = Count of non existing link
504: failed = Count of failed to delete
505: */
506: function delete_links($file_path,
507: $link_file_count = 1,
508: $link_name_prefix = "link",
509: $link_name_suffix = 1,
510: $link_file_extension = ".tmp")
511: {
512: // call the delete files to delete links
513: $return_value = delete_files( $file_path,
514: $link_file_count,
515: $link_name_prefix,
516: $link_name_suffix,
517: $link_file_extension );
518: return $return_value;
519: }
520:
521:
522:
523: /*
524: Prototype:
525: function compare_self_stat( array $stat );
526: Description:
527: Compares the each of the first 13 values of the stat array with the
528: corresponding next 13 values of the same stat for equality
529: $stat = stat array
530:
531: Retuns: true when all of them match, false otherwise
532: */
533: function compare_self_stat( array $stat )
534: {
535: //return value
536: $return_value = true;
537:
538: // named keys present in a stat
539: $string_keys = array("dev", "ino", "mode", "nlink", "uid", "gid",
540: "rdev", "size", "atime", "mtime", "ctime",
541: "blksize", "blocks");
542:
543: // first numeric key
544: $key = 0;
545:
546: // compare the values in the stat, which are accessed using numeric key with
547: // values accessed using string keys
548: foreach($string_keys as $str_key)
549: {
550: if($stat[$key] != $stat[$str_key]) {
551: echo "Error: stat[$key] doesn't match with stat[$str_key]\n";
552: $flag = false;
553: $key++;
554: }
555: else {
556: $key++;
557: }
558: } // end of foreach
559:
560: // if the $return_value is false, i.e all the element do not match then
561: // dump the stat array so that its easy to figure out the error
562: if ($return_value == false ) {
563: echo "\n Dumping stat array ...\n";
564: var_dump($stat);
565: }
566:
567: return $return_value;
568: }// end of compare_self_stat
569:
570: /*
571: Prototype:
572: function compare_stats( array $stat1, array $stat2, array $fields,
573: [string $op = "==", [ bool $flag = false] ]);
574: Description:
575: Compares two stat values, stat value should be obtained by stat/lstat
576: $stat1 = first stat array
577: $stat2 = second stat array
578: $op = type of the comparision to be perform between elements of stat1 and stat2
579: "!=" compare for not equal
580: "==" compare for equality
581: ">" if each element of stat1 is > than stat2
582: "<" if each element of stat1 is < than stat2
583: $fields = contains the key of the elements that needs to be compared.
584: type of the comparision is based on $op argument value
585: $flag = specify true to dump the stat1 and stat2
586: */
587:
588: $all_stat_keys = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
589: "dev", "ino", "mode", "nlink", "uid", "gid",
590: "rdev", "size", "atime", "mtime", "ctime",
591: "blksize", "blocks");
592:
593: function compare_stats($stat1, $stat2, $fields, $op = "==", $flag = false ) {
594: // dump the stat if requested
595: if ( $flag == true ) {
596: var_dump($stat1);
597: var_dump($stat2);
598: }
599:
600: $result = true;
601:
602: // compare values of given key from each stat array
603: for($index = 0; $index < count($fields); $index++)
604: {
605: switch( $op )
606: {
607: case "==":
608: if ( $stat1[ $fields[$index] ] != $stat2[ $fields[$index] ] ) {
609: $result = false;
610: echo "Error: stat1 do not match with stat2 at key value: $fields[$index]\n";
611: }
612: break;
613:
614: case "!=":
615: if ( $stat1[ $fields[$index] ] != $stat2[ $fields[$index] ] ) {
616: // do nothing as its not equal, else will take care of if equal
617: } else {
618: $result = false;
619: echo "Error: stat1 equals stat2 at key value: $fields[$index]\n";
620: }
621: break;
622:
623: case ">":
624: if ( $stat1[ $fields[$index] ] <= $stat2[ $fields[$index] ] ) {
625: $result = false;
626: echo "Error: stat1 is not greater than stat2 at key value: $fields[$index]\n";
627: }
628: break;
629:
630: case "<":
631: if ( $stat1[ $fields[$index] ] >= $stat2[ $fields[$index] ] ) {
632: $result = false;
633: echo "Error: stat1 is not lesser than stat2 at key value: $fields[$index]\n";
634: }
635: break;
636: }
637: }
638: // if the result is false(i.e values are not as expected),
639: // dump the stat array so that easy to figure out the error
640: if ( $result == false ) {
641: echo "\n Dumping stat array 1...\n";
642: var_dump($stat1);
643: echo "\n Dumping stat array 2...\n";
644: var_dump($stat2);
645: }
646:
647: return $result;
648: }
649:
650: ?>
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to file.inc CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / standard / tests / file