tests/smack_security/smackSecurityTest1/js/WAC2.0/TestFilesystem.js

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 // -------------------------| Globals
  17 var MAX_PATH_LENGTH = 256;
  18
  19 var LOCATION_SPECIFIERS = new Array(
  20     'wgt-package',
  21     'wgt-private',
  22     'wgt-private-tmp',
  23     'documents',
  24     'images',
  25     'videos',
  26     'removable',
  27     'downloads'
  28 );
  29
  30 var TEST_ROOT_LOCATION = 'downloads';
  31
  32 // -------------------------| Error verification prerequisites
  33 TestEngine.setErrorType(Object);
  34 TestEngine.setErrorField('code');
  35 var TYPE_MISMATCH_ERR = 17;
  36 var IO_ERR = 100;
  37 var INVALID_VALUES_ERR = 22;
  38 var SECURITY_ERR = 18;
  39 var NOT_FOUND_ERR = 8;
  40 var UNKNOWN_ERR = 0;
  41
  42 // -------------------------| Setting up environment.
  43 try {
  44   function on_resolve_error(err) { }
  45   function on_resolve_success(file) {
  46     function on_listFiles_success(files) {
  47       for (i = 0; i < files.length; ++i) {
  48         if (files[i].name.match(/^test_wac20_filesystem_/)) {
  49           files[i].isDirectory ? deleteDirectory(file, files[i]) : deleteFile(file, files[i]);
  50         }
  51       }
  52     }
  53     function on_listFiles_error(err) {
  54       TestEngine.log("Error while listing files.");
  55     }
  56     file.listFiles(on_listFiles_success, on_listFiles_error);
  57   }
  58   deviceapis.filesystem.resolve(on_resolve_success, on_resolve_error, TEST_ROOT_LOCATION);
  59 }
  60 catch (e) {
  61   TestEngine.log("Exception while setting up environment.");
  62 }
  63
  64 // -------------------------| Tests
  65 // WAC2-FILESYSTEM-001: Check filesystem manager properties.
  66 function test_filesystem_properties_001() {
  67   var props = new Array();
  68   props.push(new Array('maxPathLength', MAX_PATH_LENGTH, 0, true, TestEngine.NUMBER));
  69   TestEngine.testProperties(deviceapis.filesystem, props);
  70 }
  71
  72 // WAC2-FILESYSTEM-002: Resolve a file.
  73 function test_filesystem_resolve_002() {
  74   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
  75   function on_resolve_success(file) { TestEngine.test("resolve()", isFileObject(file));}
  76   resolve_root(on_resolve_success, on_resolve_error);
  77 }
  78
  79 // WAC-FILESYSTEM-003: Resolve a non-existent file.
  80 function test_filesystem_resolve_003() {
  81   function on_resolve_error(err) {
  82     TestEngine.test("resolve() non-existent file [IO_ERR]", (err.code == IO_ERR));
  83   }
  84   function on_resolve_success(file) {
  85     TestEngine.test("resolve() non-existent file [IO_ERR]", false);
  86   }
  87   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
  88   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, "locationdd");
  89 }
  90
  91 // WAC-FILESYSTEM-004: List files from root directory.
  92 function test_file_listFiles_004() {
  93   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
  94   function on_resolve_success(file) {
  95     TestEngine.test("resolve()", isFileObject(file));
  96     function on_listFiles_error(err) {
  97       TestEngine.test("listFiles() [" + err.code + "]", false);
  98     }
  99     function on_listFiles_success(files) {
 100       TestEngine.test("listFiles()", isArray(files));
 101     }
 102     var cb = TestEngine.registerCallback("listFiles", on_listFiles_success, on_listFiles_error);
 103     file.listFiles(cb.successCallback, cb.errorCallback);
 104   }
 105   resolve_root(on_resolve_success, on_resolve_error);
 106 }
 107
 108 // WAC-FILESYSTEM-005: Open file in read mode.
 109 function test_file_open_005() {
 110   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 111   function on_resolve_success(file) {
 112     TestEngine.test("resolve()", isFileObject(file));
 113     var file2 = file.createFile(getFileName());
 114     TestEngine.test("createFile()", isFile(file2));
 115     function on_openStream_success(stream) {
 116       TestEngine.test("openStream()", isFilestream(stream));
 117       stream.close();
 118       deleteFile(file, file2);
 119     }
 120     function on_openStream_error(err) {
 121       TestEngine.test("openStream() [" + err.code + "]", false);
 122     }
 123     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 124     var stream = file2.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 125   }
 126   resolve_root(on_resolve_success, on_resolve_error);
 127 }
 128
 129 // WAC-FILESYSTEM-006: Open file in write mode.
 130 function test_file_open_006() {
 131   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 132   function on_resolve_success(file) {
 133     var file2 = file.createFile(getFileName());
 134     function on_openStream_success(stream) {
 135       TestEngine.test("openStream()", isFilestream(stream));
 136       stream.close();
 137       deleteFile(file, file2);
 138     }
 139     function on_openStream_error(err) {
 140       TestEngine.test("openStream() [" + err.code + "]", false);
 141     }
 142     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 143     var stream = file2.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
 144   }
 145   resolve_root(on_resolve_success, on_resolve_error);
 146 }
 147
 148 // WAC-FILESYSTEM-007: Open file in append mode.
 149 function test_file_open_007() {
 150   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 151   function on_resolve_success(file) {
 152     var file2 = file.createFile(getFileName());
 153     TestEngine.test("createFile()", isFile(file2));
 154     function on_openStream_success(stream) {
 155       TestEngine.test("openStream()", isFilestream(stream));
 156       stream.close();
 157       deleteFile(file, file2);
 158     }
 159     function on_openStream_error(err) {
 160       TestEngine.test("openStream() [" + err.code + "]", false);
 161     }
 162     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 163     var stream = file2.openStream(cb.successCallback, cb.errorCallback, "a", "UTF-8");
 164   }
 165   resolve_root(on_resolve_success, on_resolve_error);
 166 }
 167
 168 // WAC-FILESYSTEM-008: Call open function with invalid value of parameter 'mode'.
 169 function test_file_open_error_008() {
 170   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 171   function on_resolve_success(file) {
 172     function on_openStream_error(err) {
 173       TestEngine.test("Calling openStream() with invalid mode.", err.code === err.INVALID_VALUES_ERR);
 174       deleteFile(file, file2);
 175     }
 176     function on_openStream_success(fs) {
 177       TestEngine.test("Calling openStream() with invalid mode.", false);
 178       fs.close();
 179       deleteFile(file, file2);
 180     }
 181     var file2 = file.createFile(getFileName());
 182     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 183     file2.openStream(cb.successCallback, cb.errorCallback, "x", "UTF-8");
 184   }
 185   resolve_root(on_resolve_success, on_resolve_error);
 186 }
 187
 188 // WAC-FILESYSTEM-009: Call open function with invalid value of parameter 'encoding'.
 189 function test_file_open_error_009() {
 190   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 191   function on_resolve_success(file) {
 192     function on_openStream_error(err) {
 193       TestEngine.test("Calling openStream() with invalid encoding.", err.code === err.INVALID_VALUES_ERR);
 194       deleteFile(file, file2);
 195     }
 196     function on_openStream_success(fs) {
 197       TestEngine.test("Calling openStream() with invalid encoding.", false);
 198       fs.close();
 199       deleteFile(file, file2);
 200     }
 201     var file2 = file.createFile(getFileName());
 202     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 203     file2.openStream(cb.successCallback, cb.errorCallback, "r", "cp-1250");
 204   }
 205   resolve_root(on_resolve_success, on_resolve_error);
 206 }
 207
 208 // WAC-FILESYSTEM-010: Copy file w/o overwrite.
 209 function test_file_copyTo_010() {
 210   var g_file = null;
 211   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 212   function on_resolve_success(file) {
 213     g_file = file.createFile(getFileName());
 214     TestEngine.test("createFile()", isFile(g_file));
 215     function on_copyTo_error(err) {
 216       TestEngine.test("copyTo() [" + err.code + "]", false);
 217       deleteFile(file, g_file);
 218     }
 219     function on_copyTo_success(file2) {
 220       TestEngine.test("copyTo()", isFile(file2));
 221       deleteFile(file, file2);
 222       deleteFile(file, g_file);
 223     }
 224     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
 225     file.copyTo(cb.successCallback, cb.errorCallback, g_file.fullPath, file.fullPath + "/" + getFileName(), false);
 226   }
 227   resolve_root(on_resolve_success, on_resolve_error);
 228 }
 229
 230 // WAC-FILESYSTEM-011: Copy file w/o overwrite when destination exists.
 231 function test_file_copyTo_error_011() {
 232   var g_file = null;
 233   var g_dest = null;
 234   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 235   function on_resolve_success(file) {
 236     g_dest = file.createFile(getFileName());
 237     TestEngine.test("createFile()", isFile(g_dest));
 238
 239     g_file = file.createFile(getFileName());
 240     TestEngine.test("createFile()", isFile(g_file));
 241
 242     function on_copyTo_error(err) {
 243       TestEngine.test("copyTo() [" + err.code + "]", (err.code == IO_ERR));
 244       deleteFile(file, g_file);
 245       deleteFile(file, g_dest);
 246     }
 247     function on_copyTo_success(file2) {
 248       TestEngine.test("copyTo()", false);
 249       deleteFile(file, file2);
 250       deleteFile(file, g_file);
 251       deleteFile(file, g_dest);
 252     }
 253     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
 254     file.copyTo(cb.successCallback, cb.errorCallback, g_file.fullPath, file.fullPath + "/" + g_dest.name, false);
 255   }
 256   resolve_root(on_resolve_success, on_resolve_error);
 257 }
 258
 259 // WAC-FILESYSTEM-012: Copy file with overwrite when destination exists.
 260 function test_file_copyTo_012() {
 261   var g_file = null;
 262   var g_dest = null;
 263   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 264   function on_resolve_success(file) {
 265     g_dest = file.createFile(getFileName());
 266     TestEngine.test("createFile()", isFile(g_dest));
 267
 268     g_file = file.createFile(getFileName());
 269     TestEngine.test("createFile()", isFile(g_file));
 270     function on_copyTo_error(err) {
 271       TestEngine.test("copyTo() [" + err.code + "]", false);
 272       deleteFile(file, g_file);
 273       deleteFile(file, g_dest);
 274     }
 275     function on_copyTo_success(file2) {
 276       TestEngine.test("copyTo()", isFile(file2));
 277       deleteFile(file, file2);
 278       deleteFile(file, g_file);
 279     }
 280     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
 281     file.copyTo(cb.successCallback, cb.errorCallback, g_file.fullPath, file.fullPath + "/" + g_dest.name, true);
 282   }
 283   resolve_root(on_resolve_success, on_resolve_error);
 284 }
 285
 286 // WAC-FILESYSTEM-013: Create file.
 287 function test_file_createFile_013() {
 288   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 289   function on_resolve_success(file) {
 290     var file1 = file.createFile(getFileName());
 291     TestEngine.test("createFile()", isFile(file1));
 292     deleteFile(file, file1);
 293   }
 294   resolve_root(on_resolve_success, on_resolve_error);
 295 }
 296
 297 // WAC-FILESYSTEM-014: Create file with invalid characters in path.
 298 function test_file_createFile_error_014() {
 299   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 300   function on_resolve_success(file) {
 301     TestEngine.log("Calling createFile() with invalid characters in path. [NULL OBJECT]");
 302     TestEngine.catchErrorType("code", 100, file, "createFile", "!@#$%^&*(");
 303   }
 304   resolve_root(on_resolve_success, on_resolve_error);
 305 }
 306
 307 // WAC-FILESYSTEM-015: Create file when it already exists.
 308 function test_file_createFile_error_015() {
 309   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 310   function on_resolve_success(file) {
 311     var file1 = file.createFile(getFileName());
 312     TestEngine.test("createFile()", isFile(file1));
 313     TestEngine.log("Calling createFile() with path that already exists. [NULL OBJECT]");
 314     TestEngine.catchErrorType("code", 100, file, "createFile", file1.name);
 315     deleteFile(file, file1);
 316   }
 317   resolve_root(on_resolve_success, on_resolve_error);
 318 }
 319
 320 // WAC-FILESYSTEM-016: Create file in file instead of directory.
 321 function test_file_createFile_error_016() {
 322   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 323   function on_resolve_success(file) {
 324     var file1 = file.createFile(getFileName());
 325     TestEngine.test("createFile()", isFile(file1));
 326     TestEngine.log("Calling createFile() on file object. [NULL OBJECT]");
 327     TestEngine.catchErrorType("code", 100, file1, "createFile", getFileName());
 328     deleteFile(file, file1);
 329   }
 330   resolve_root(on_resolve_success, on_resolve_error);
 331 }
 332
 333 // WAC-FILESYSTEM-017: Create file with invalid path componenet - "..".
 334 function test_file_createFile_error_017() {
 335   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 336   function on_resolve_success(file) {
 337     TestEngine.testPresetError(
 338         "Calling createFile() with invalid path component - \"..\".",
 339         function(){file.createFile("../testFile_021");},
 340         INVALID_VALUES_ERR
 341     );
 342   }
 343   resolve_root(on_resolve_success, on_resolve_error);
 344 }
 345
 346 // WAC-FILESYSTEM-018: Create directory.
 347 function test_file_createDirectory_018() {
 348   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 349   function on_resolve_success(file) {
 350     var dir = file.createDirectory(getDirName());
 351     TestEngine.test("createDirectory()", isDir(dir));
 352     deleteDirectory(file, dir);
 353   }
 354   resolve_root(on_resolve_success, on_resolve_error);
 355 }
 356
 357 // WAC-FILESYSTEM-019: Create directory with invalid character in path.
 358 function test_file_createDirectory_error_019() {
 359   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 360   function on_resolve_success(file) {
 361     TestEngine.log("Calling createDirectory() with invalid character in path. - [NULL OBJECT]");
 362     TestEngine.catchErrorType("code", 100, file, "createDirectory", "!@#$%^&*(");
 363   }
 364   resolve_root(on_resolve_success, on_resolve_error);
 365 }
 366
 367 // WAC-FILESYSTEM-020: Create directory when it already exists.
 368 function test_file_createDirectory_error_020() {
 369   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 370   function on_resolve_success(file) {
 371     var dir = file.createDirectory(getDirName());
 372     TestEngine.test("createDirectory()", isDir(dir));
 373     TestEngine.log("Calling createDirectory() with path that already exists. - [NULL OBJECT]");
 374     TestEngine.catchErrorType("code", 100, file, "createDirectory", dir.name);
 375     deleteDirectory(file, dir);
 376   }
 377   resolve_root(on_resolve_success, on_resolve_error);
 378 }
 379
 380 // WAC-FILESYSTEM-021: Create directory in file instead of directory.
 381 function test_file_createDirectory_error_021() {
 382   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 383   function on_resolve_success(file) {
 384     var file1 = file.createFile(getFileName());
 385     TestEngine.test("createFile()", isFile(file1));
 386     TestEngine.log("Calling createDirectory() on file object. - [NULL OBJECT]");
 387     TestEngine.catchErrorType("code", 100, file1, "createDirectory", getDirName());
 388     deleteFile(file, file1);
 389   }
 390   resolve_root(on_resolve_success, on_resolve_error);
 391 }
 392
 393 // WAC-FILESYSTEM-022: Create file with invalid path componenet - "..".
 394 function test_file_createDirectory_error_022() {
 395   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 396   function on_resolve_success(file) {
 397     TestEngine.testPresetError(
 398       "Calling createDirectory() with invalid path component - \"..\".",
 399       function(){file.createDirectory("../" + getDirName());},
 400       INVALID_VALUES_ERR
 401     );
 402   }
 403   resolve_root(on_resolve_success, on_resolve_error);
 404 }
 405
 406 // WAC-FILESYSTEM-023: Move file w/o overwrite.
 407 function test_file_moveTo_023() {
 408   var g_file = null;
 409   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 410   function on_resolve_success(file) {
 411     g_file = file.createFile(getFileName());
 412     TestEngine.test("createFile()", isFile(g_file));
 413     function on_moveTo_error(err) {
 414       TestEngine.test("moveTo() [" + err.code + "]", false);
 415       deleteFile(file, g_file);
 416     }
 417     function on_moveTo_success(file1) {
 418       TestEngine.test("moveTo()", true);
 419       deleteFile(file, file1);
 420     }
 421     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
 422     file.moveTo(cb.successCallback, cb.errorCallback, g_file.fullPath, file.fullPath + "/" + getFileName(), false);
 423   }
 424   resolve_root(on_resolve_success, on_resolve_error);
 425 }
 426
 427 // WAC-FILESYSTEM-024: Move file w/o overwrite when destination exists.
 428 function test_file_moveTo_error_024() {
 429   var g_file = null;
 430   var g_dest = null;
 431   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 432   function on_resolve_success(file) {
 433     g_dest = file.createFile(getFileName());
 434     TestEngine.test("createFile()", isFile(g_dest));
 435     g_file = file.createFile(getFileName());
 436     TestEngine.test("createFile()", isFile(g_file));
 437
 438     function on_moveTo_error(err) {
 439       TestEngine.test("moveTo() [IO_ERR]", (err.code == IO_ERR));
 440       deleteFile(file, g_file);
 441       deleteFile(file, g_dest);
 442     }
 443     function on_moveTo_success(file1) {
 444       TestEngine.test("moveTo()", false);
 445       deleteFile(file, file1);
 446       deleteFile(file, g_dest);
 447     }
 448     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
 449     file.moveTo(cb.successCallback, cb.errorCallback, g_file.fullPath, g_dest.fullPath, false);
 450   }
 451   resolve_root(on_resolve_success, on_resolve_error);
 452 }
 453
 454 // WAC-FILESYSTEM-025: Move file with overwrite when destination exists.
 455 function test_file_moveTo_025() {
 456   var g_file = null;
 457   var g_dest = null;
 458   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 459   function on_resolve_success(file) {
 460     g_dest = file.createFile(getFileName());
 461     TestEngine.test("createFile()", isFile(g_dest));
 462     g_file = file.createFile(getFileName());
 463     TestEngine.test("createFile()", isFile(g_file));
 464
 465     function on_moveTo_error(err) {
 466       TestEngine.test("moveTo() [" + err.code + "]", false);
 467       deleteFile(file, g_file);
 468       deleteFile(file, g_dest);
 469     }
 470     function on_moveTo_success(file1) {
 471       TestEngine.test("moveTo()", isFile(file1));
 472       deleteFile(file, file1);
 473     }
 474     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
 475     file.moveTo(cb.successCallback, cb.errorCallback, g_file.fullPath, g_dest.fullPath, true);
 476   }
 477   resolve_root(on_resolve_success, on_resolve_error);
 478 }
 479
 480 // WAC-FILESYSTEM-026: Delete a file.
 481 function test_file_deleteFile_026() {
 482   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 483   function on_resolve_success(file) {
 484     var f = file.createFile(getFileName());
 485     TestEngine.test("createFile()", isFile(f));
 486     deleteFile(file, f);
 487   }
 488   resolve_root(on_resolve_success, on_resolve_error);
 489 }
 490
 491 // WAC-FILESYSTEM-027: Call deleteFile() on a directory.
 492 function test_file_deleteFile_error_027() {
 493   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 494   function on_resolve_success(file) {
 495     var dir = file.createDirectory(getDirName());
 496     TestEngine.test("createDirectory()", isDir(dir));
 497     function on_deleteFile_error(err) {
 498       TestEngine.test("deleteFile() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
 499       deleteDirectory(file, dir);
 500     }
 501     function on_deleteFile_success() {
 502       TestEngine.test("deleteFile()", false);
 503     }
 504     var cb = TestEngine.registerCallback("deleteFile", on_deleteFile_success, on_deleteFile_error);
 505     file.deleteFile(cb.successCallback, cb.errorCallback, dir.fullPath);
 506   }
 507   resolve_root(on_resolve_success, on_resolve_error);
 508 }
 509
 510 // WAC-FILESYSTEM-028: Call deleteFile() on a file.
 511 function test_file_deleteFile_error_028() {
 512   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 513   function on_resolve_success(file) {
 514     var file1 = file.createFile(getFileName());
 515     TestEngine.test("createFile()", isFile(file1));
 516     var file2 = file.createFile(getFileName());
 517     TestEngine.test("createFile()", isFile(file2));
 518     function on_deleteFile_error(err) {
 519       TestEngine.test("Call deleteFile() on a file. [IO_ERR]", (err.code == IO_ERR));
 520       deleteFile(file, file1);
 521       deleteFile(file, file2);
 522     }
 523     function on_deleteFile_success() {
 524       TestEngine.test("Call deleteFile() on a file. [IO_ERR]", false);
 525       deleteFile(file, file2);
 526     }
 527     var cb = TestEngine.registerCallback("deleteFile", on_deleteFile_success, on_deleteFile_error);
 528     file1.deleteFile(cb.successCallback, cb.errorCallback, file2.fullPath);
 529   }
 530   resolve_root(on_resolve_success, on_resolve_error);
 531 }
 532
 533 // WAC-FILESYSTEM-029: Call deleteFile() on the same file twice.
 534 function test_file_deleteFile_error_029() {
 535   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 536   function on_resolve_success(file) {
 537     var f = file.createFile(getFileName());
 538     TestEngine.test("createFile()", isFile(f));
 539     deleteFile(file, f);
 540     function on_deleteFile_error(err) {
 541       TestEngine.test("Call deleteFile() on a file that has already been deleted. [IO_ERR]", (err.code == IO_ERR));
 542     }
 543     function on_deleteFile_success() {
 544       TestEngine.test("Call deleteFile() on a file that has already been deleted. [IO_ERR]", false);
 545     }
 546     var cb = TestEngine.registerCallback("deleteFile", on_deleteFile_success, on_deleteFile_error);
 547     file.deleteFile(cb.successCallback, cb.errorCallback, f.fullPath);
 548   }
 549   resolve_root(on_resolve_success, on_resolve_error);
 550 }
 551
 552 // WAC-FILESYSTEM-030: Call deleteFile() on opened file.
 553 function test_file_deleteFile_error_030() {
 554   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 555   function on_resolve_success(file) {
 556     var f = file.createFile(getFileName());
 557     TestEngine.test("createFile()", isFile(f));
 558     function on_openStream_success(stream) {
 559       TestEngine.test("openStream()", isFilestream(stream));
 560       function on_deleteFile_error(err) {
 561         TestEngine.test("Call deleteFile() on opened file. [IO_ERR]", (err.code == IO_ERR));
 562         stream.close();
 563         deleteFile(file, f);
 564       }
 565       function on_deleteFile_success() {
 566         TestEngine.test("Call deleteFile() on opened file. [IO_ERR]", false);
 567         stream.close();
 568       }
 569       var cb = TestEngine.registerCallback("deleteFile", on_deleteFile_success, on_deleteFile_error);
 570       file.deleteFile(cb.successCallback, cb.errorCallback, f.fullPath);
 571     }
 572     function on_openStream_error(err) {
 573       TestEngine.test("openStream() [" + err.code + "]", false);
 574     }
 575     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 576     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 577   }
 578   resolve_root(on_resolve_success, on_resolve_error);
 579 }
 580
 581 // WAC-FILESYSTEM-031: Delete a directory.
 582 function test_file_deleteDirectory_031() {
 583   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 584   function on_resolve_success(file) {
 585     var dir = file.createDirectory(getDirName());
 586     TestEngine.test("createDirectory()", isDir(dir));
 587     deleteDirectory(file, dir);
 588   }
 589   resolve_root(on_resolve_success, on_resolve_error);
 590 }
 591
 592 // WAC-FILESYSTEM-032: Call deleteDirectory() on a file.
 593 function test_file_deleteDirectory_error_032() {
 594   var g_file = null;
 595   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 596   function on_resolve_success(file) {
 597     g_file = file.createFile(getFileName());
 598     TestEngine.test("createFile()", isFile(g_file));
 599     function on_deleteDirectory_error(err) {
 600       TestEngine.test("Call deleteDirectory() on a file. [IO_ERR] [" + err.code + "]", (err.code == IO_ERR));
 601       deleteFile(file, g_file);
 602     }
 603     function on_deleteDirectory_success(file) {
 604       TestEngine.test("deleteDirectory()", false);
 605       deleteFile(file, g_file);
 606     }
 607     var cb = TestEngine.registerCallback("deleteDirectory", on_deleteDirectory_success, on_deleteDirectory_error);
 608     g_file.deleteDirectory(cb.successCallback, cb.errorCallback, "foo", true);
 609   }
 610   resolve_root(on_resolve_success, on_resolve_error);
 611 }
 612
 613 // WAC-FILESYSTEM-033: Call deleteDirectory() on the same directory twice.
 614 function test_file_deleteDirectory_error_033() {
 615   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 616   function on_resolve_success(file) {
 617     var dir = file.createDirectory(getDirName());
 618     TestEngine.test("createDirectory()", isDir(dir));
 619       function on_deleteDirectory2_error(err) {
 620         TestEngine.test("Call deleteDirectory() on a dir that has already been deleted. [IO_ERR] [" + err.code + "]", (err.code == IO_ERR));
 621       }
 622       function on_deleteDirectory2_success(file) {
 623         TestEngine.test("deleteDirectory()", false);
 624       }
 625     deleteDirectory(file, dir);
 626     var cb = TestEngine.registerCallback("deleteDirectory", on_deleteDirectory2_success, on_deleteDirectory2_error);
 627     file.deleteDirectory(cb.successCallback, cb.errorCallback, dir.fullPath, true);
 628   }
 629   resolve_root(on_resolve_success, on_resolve_error);
 630 }
 631
 632 // WAC-FILESYSTEM-034: Call deleteDirectory() non-recursively on non-empty directory.
 633 function test_file_deleteDirectory_error_034() {
 634   var g_dir = null;
 635   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 636   function on_resolve_success(file) {
 637     g_dir = file.createDirectory(getDirName());
 638     TestEngine.test("createDirectory()", isDir(g_dir));
 639     TestEngine.test("createFile()", isFile(g_dir.createFile(getFileName())));
 640     function on_deleteDirectory_error(err) {
 641       TestEngine.test("Call deleteDirectory() non-recursively on non-empty dir. [IO_ERR]", (err.code == IO_ERR));
 642       deleteDirectory(file, g_dir);
 643     }
 644     function on_deleteDirectory_success() {
 645       TestEngine.test("deleteDirectory()", false);
 646     }
 647     var cb = TestEngine.registerCallback("deleteDirectory", on_deleteDirectory_success, on_deleteDirectory_error);
 648     file.deleteDirectory(cb.successCallback, cb.errorCallback, g_dir.fullPath, false);
 649   }
 650   resolve_root(on_resolve_success, on_resolve_error);
 651 }
 652
 653 // WAC-FILESYSTEM-035: Call write()/read() on a stream.
 654 function test_filestream_write_read_035() {
 655   var test_string = "It's alive! Alive!";
 656   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 657   function on_resolve_success(file) {
 658     var f = file.createFile(getFileName());
 659     TestEngine.test("createFile()", isFile(f));
 660     function on_openStream_success(stream1) {
 661       TestEngine.test("openStream()", isFilestream(stream1));
 662       stream1.write(test_string);
 663       stream1.close();
 664       function on_openStream1_success(r_stream) {
 665         TestEngine.test("openStream()", isFilestream(r_stream));
 666         var read_string = r_stream.read(test_string.length);
 667         r_stream.close();
 668         TestEngine.test("write()/read()", (read_string === test_string));
 669         deleteFile(file, f);
 670       }
 671       function on_openStream1_error(err) {
 672         TestEngine.test("openStream() [" + err.code + "]", false);
 673       }
 674       var cb = TestEngine.registerCallback("openStream", on_openStream1_success, on_openStream1_error);
 675       f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 676     }
 677     function on_openStream_error(err) {
 678       TestEngine.test("openStream() [" + err.code + "]", false);
 679     }
 680     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 681     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
 682   }
 683   resolve_root(on_resolve_success, on_resolve_error);
 684 }
 685
 686 // WAC-FILESYSTEM-036: Call read() on a closed stream.
 687 function test_filestream_read_error_036() {
 688   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 689   function on_resolve_success(file) {
 690     var f = file.createFile(getFileName());
 691     TestEngine.test("createFile()", isFile(f));
 692     function on_openStream_success(stream) {
 693       TestEngine.test("openStream()", isFilestream(stream));
 694       stream.close();
 695       TestEngine.testPresetError(
 696         "Call read() on a closed stream. [IO_ERR]",
 697         function(){stream.read(3);},
 698         IO_ERR
 699       );
 700       deleteFile(file, f);
 701     }
 702     function on_openStream_error(err) {
 703       TestEngine.test("openStream() [" + err.code + "]", false);
 704       deleteFile(file, f);
 705     }
 706     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 707     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 708   }
 709   resolve_root(on_resolve_success, on_resolve_error);
 710 }
 711
 712 // WAC-FILESYSTEM-037: Call read() on a stream with EOF flag set.
 713 function test_filestream_read_error_037() {
 714   var test_string = "It's alive! Alive!";
 715   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 716   function on_resolve_success(file) {
 717     var f = file.createFile(getFileName());
 718     TestEngine.test("createFile()", isFile(f));
 719     function on_openStream_success(stream) {
 720       TestEngine.test("openStream()", isFilestream(stream));
 721       stream.write(test_string);
 722       stream.close();
 723       function on_openStream1_success(stream1) {
 724         TestEngine.test("openStream()", isFilestream(stream1));
 725         var read_string = stream1.read(test_string.length);
 726         TestEngine.testPresetError(
 727           "Call read() on stream with EOF set. [IO_ERR]",
 728           function(){stream1.read(1);},
 729           IO_ERR
 730         );
 731         stream1.close();
 732         deleteFile(file, f);
 733       }
 734       function on_openStream1_error(err) {
 735         TestEngine.test("openStream() [" + err.code + "]", false);
 736         deleteFile(file, f);
 737       }
 738       var cb = TestEngine.registerCallback("openStream", on_openStream1_success, on_openStream1_error);
 739       f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 740     }
 741     function on_openStream_error(err) {
 742       TestEngine.test("openStream() [" + err.code + "]", false);
 743       deleteFile(file, f);
 744     }
 745     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 746     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
 747   }
 748   resolve_root(on_resolve_success, on_resolve_error);
 749 }
 750
 751 // WAC-FILESYSTEM-038: Call openStream() on a directory.
 752 function test_file_open_error_038() {
 753   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 754   function on_resolve_success(file) {
 755     var dir = file.createDirectory(getDirName());
 756     TestEngine.test("createDirectory()", isDir(dir));
 757     function on_openStream_success(stream) {
 758       TestEngine.test("Call openStream() on a directory.", false);
 759       stream.close();
 760     }
 761     function on_openStream_error(err) {
 762       TestEngine.test("Call openStream() on a directory. [IO_ERR]", (err.code == IO_ERR));
 763     }
 764     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 765     dir.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 766     deleteDirectory(file, dir);
 767   }
 768   resolve_root(on_resolve_success, on_resolve_error);
 769 }
 770
 771 // WAC-FILESYSTEM-040: Call read() on write-only stream.
 772 function test_filestream_read_error_040() {
 773   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 774   function on_resolve_success(file) {
 775     var f = file.createFile(getFileName());
 776     TestEngine.test("createFile()", isFile(f));
 777     function on_openStream_success(stream) {
 778       TestEngine.test("openStream()", isFilestream(stream));
 779       TestEngine.testPresetError(
 780         "Call read() on write-only stream. [IO_ERR]",
 781         function(){stream.read(0);},
 782         IO_ERR
 783       );
 784       stream.close();
 785       deleteFile(file, f);
 786     }
 787     function on_openStream_error(err) {
 788       TestEngine.test("openStream()", false);
 789       deleteFile(file, f);
 790     }
 791     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 792     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
 793   }
 794   resolve_root(on_resolve_success, on_resolve_error);
 795 }
 796
 797 // WAC-FILESYSTEM-041: Call write() on a closed stream.
 798 function test_filestream_write_error_041() {
 799   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 800   function on_resolve_success(file) {
 801     var f = file.createFile(getFileName());
 802     TestEngine.test("createFile()", isFile(f));
 803     function on_openStream_success(stream) {
 804       TestEngine.test("openStream()", isFilestream(stream));
 805       stream.close();
 806       TestEngine.testPresetError(
 807         "Call write() on a closed stream. [IO_ERR]",
 808         function(){stream.write('test');},
 809         IO_ERR
 810       );
 811       deleteFile(file, f);
 812     }
 813     function on_openStream_error(err) {
 814       TestEngine.test("openStream()", false);
 815       deleteFile(file, f);
 816     }
 817     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 818     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
 819   }
 820   resolve_root(on_resolve_success, on_resolve_error);
 821 }
 822
 823 // WAC-FILESYSTEM-042: Call write() on read-only stream.
 824 function test_filestream_write_error_042() {
 825   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 826   function on_resolve_success(file) {
 827     var f = file.createFile(getFileName());
 828     TestEngine.test("createFile()", isFile(f));
 829     function on_openStream_success(stream) {
 830       TestEngine.test("openStream()", isFilestream(stream));
 831       TestEngine.testPresetError(
 832         "Call write() on read-only stream. [IO_ERR]",
 833         function(){stream.write('test');},
 834         IO_ERR
 835       );
 836       stream.close();
 837       deleteFile(file, f);
 838     }
 839     function on_openStream_error(err) {
 840       TestEngine.test("openStream()", false);
 841       deleteFile(file, f);
 842     }
 843     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 844     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 845   }
 846   resolve_root(on_resolve_success, on_resolve_error);
 847 }
 848
 849 // WAC-FILESYSTEM-043
 850 // Parameters: stringData = array
 851 // Result: Test passes (toString() called on JS Array).
 852 function test_filestream_write_error_043() {
 853   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 854   function on_resolve_success(file) {
 855     var f = file.createFile(getFileName());
 856     TestEngine.test("createFile()", isFile(f));
 857     function on_openStream_success(stream) {
 858       TestEngine.test("openStream()", isFilestream(stream));
 859       stream.write(new Array('t','e','s','t'));
 860       TestEngine.test("write()", true);
 861       stream.close();
 862       deleteFile(file, f);
 863     }
 864     function on_openStream_error(err) {
 865       TestEngine.test("openStream()", false);
 866       deleteFile(file, f);
 867     }
 868     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 869     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
 870   }
 871   resolve_root(on_resolve_success, on_resolve_error);
 872 }
 873
 874 // WAC-FILESYSTEM-044: Call write() w/o argument.
 875 function test_filestream_write_error_044() {
 876   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 877   function on_resolve_success(file) {
 878     var f = file.createFile(getFileName());
 879     TestEngine.test("createFile()", isFile(f));
 880     function on_openStream_success(stream) {
 881       TestEngine.test("openStream()", isFilestream(stream));
 882       TestEngine.testPresetError(
 883         "Call write() w/o argument. [TYPE_MISMATCH_ERR]",
 884         function(){stream.write();},
 885         TYPE_MISMATCH_ERR
 886       );
 887       stream.close();
 888       deleteFile(file, f);
 889     }
 890     function on_openStream_error(err) {
 891       TestEngine.test("openStream()", false);
 892       deleteFile(file, f);
 893     }
 894     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 895     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
 896   }
 897   resolve_root(on_resolve_success, on_resolve_error);
 898 }
 899
 900 // WAC-FILESYSTEM-045: Call read() with invalid argument type.
 901 function test_filestream_read_error_045() {
 902   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 903   function on_resolve_success(file) {
 904     var f = file.createFile(getFileName());
 905     TestEngine.test("createFile()", isFile(f));
 906     function on_openStream_success(stream) {
 907       TestEngine.test("openStream()", isFilestream(stream));
 908       TestEngine.test("read()", stream.read('should be a number') == '');
 909       stream.close();
 910       deleteFile(file, f);
 911     }
 912     function on_openStream_error(err) {
 913       TestEngine.test("openStream() [" + err.code + "]", false);
 914       deleteFile(file, f);
 915     }
 916     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 917     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 918   }
 919   resolve_root(on_resolve_success, on_resolve_error);
 920 }
 921
 922 // WAC-FILESYSTEM-046: Call read() w/o argument.
 923 function test_filestream_read_error_046() {
 924   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 925   function on_resolve_success(file) {
 926     var f = file.createFile(getFileName());
 927     TestEngine.test("createFile()", isFile(f));
 928     function on_openStream_success(stream) {
 929       TestEngine.test("openStream()", isFilestream(stream));
 930       TestEngine.testPresetError(
 931         "Call read() w/o argument. [TYPE_MISMATCH_ERR]",
 932         function(){stream.read();},
 933         TYPE_MISMATCH_ERR
 934       );
 935       stream.close();
 936       deleteFile(file, f);
 937     }
 938     function on_openStream_error(err) {
 939       TestEngine.test("openStream() [" + err.code + "]", false);
 940       deleteFile(file, f);
 941     }
 942     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 943     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 944   }
 945   resolve_root(on_resolve_success, on_resolve_error);
 946 }
 947
 948 // WAC-FILESYSTEM-047: Call writeBytes()/readBytes() on a stream.
 949 function test_filestream_writeBytes_readBytes_047() {
 950   var test_array = new Array(1, 2, 3, 4);
 951   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 952   function on_resolve_success(file) {
 953     var f = file.createFile(getFileName());
 954     TestEngine.test("createFile()", isFile(f));
 955     function on_openStream_success(stream) {
 956       TestEngine.test("openStream()", isFilestream(stream));
 957       stream.writeBytes(test_array);
 958       stream.close();
 959       function on_openStream1_success(stream1) {
 960         TestEngine.test("openStream()", isFilestream(stream1));
 961         var read_array = stream1.readBytes(test_array.length);
 962         stream1.close();
 963         var cmp = false;
 964         if (test_array.length == read_array.length) {
 965           cmp = true;
 966           for (i = 0; i < test_array.length; ++i) {
 967             if (test_array[i] != read_array[i]) {
 968               cmp = false;
 969               break;
 970             }
 971           }
 972         }
 973         TestEngine.test("writeBytes()/readBytes()", cmp);
 974         deleteFile(file, f);
 975       }
 976       function on_openStream1_error(err) {
 977         TestEngine.test("openStream() [" + err.code + "]", false);
 978         deleteFile(file, f);
 979       }
 980       var cb = TestEngine.registerCallback("openStream", on_openStream1_success, on_openStream1_error);
 981       f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
 982     }
 983     function on_openStream_error(err) {
 984       TestEngine.test("openStream() [" + err.code + "]", false);
 985       deleteFile(file, f);
 986     }
 987     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
 988     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
 989   }
 990   resolve_root(on_resolve_success, on_resolve_error);
 991 }
 992
 993 // WAC-FILESYSTEM-048: Call readBytes() on a closed stream.
 994 function test_filestream_readBytes_error_048() {
 995   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
 996   function on_resolve_success(file) {
 997     var f = file.createFile(getFileName());
 998     TestEngine.test("createFile()", isFile(f));
 999     function on_openStream_success(stream) {
1000       TestEngine.test("openStream()", isFilestream(stream));
1001       stream.close();
1002       TestEngine.testPresetError(
1003         "Call readBytes() on a closed stream. [IO_ERR]",
1004         function(){stream.readBytes(3);},
1005         IO_ERR
1006       );
1007       deleteFile(file, f);
1008     }
1009     function on_openStream_error(err) {
1010       TestEngine.test("openStream() [" + err.code + "]", false);
1011       deleteFile(file, f);
1012     }
1013     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1014     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1015   }
1016   resolve_root(on_resolve_success, on_resolve_error);
1017 }
1018
1019 // WAC-FILESYSTEM-049: Call readBytes() on a stream with EOF flag set.
1020 function test_filestream_readBytes_error_049() {
1021   var test_array = new Array(1, 2, 3, 4);
1022   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1023   function on_resolve_success(file) {
1024     var f = file.createFile(getFileName());
1025     TestEngine.test("createFile()", isFile(f));
1026     function on_openStream_success(stream) {
1027       TestEngine.test("openStream()", isFilestream(stream));
1028       stream.writeBytes(test_array);
1029       stream.close();
1030       function on_openStream1_success(stream1) {
1031         TestEngine.test("openStream()", isFilestream(stream1));
1032         var read_array = stream1.readBytes(100);
1033         TestEngine.testPresetError(
1034           "Call readBytes() on stream with EOF set. [IO_ERR]",
1035           function(){stream1.readBytes(1);},
1036           IO_ERR
1037         );
1038         stream1.close();
1039         deleteFile(file, f);
1040       }
1041       function on_openStream1_error(err) {
1042         TestEngine.test("openStream() [" + err.code + "]", false);
1043         deleteFile(file, f);
1044       }
1045       var cb = TestEngine.registerCallback("openStream", on_openStream1_success, on_openStream1_error);
1046       f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1047     }
1048     function on_openStream_error(err) {
1049       TestEngine.test("openStream() [" + err.code + "]", false);
1050       deleteFile(file, f);
1051     }
1052     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1053     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1054   }
1055   resolve_root(on_resolve_success, on_resolve_error);
1056 }
1057
1058 // WAC-FILESYSTEM-051: Call readBytes() on write-only stream.
1059 function test_filestream_readBytes_error_051() {
1060   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1061   function on_resolve_success(file) {
1062     var f = file.createFile(getFileName());
1063     TestEngine.test("createFile()", isFile(f));
1064     function on_openStream_success(stream) {
1065       TestEngine.test("openStream()", isFilestream(stream));
1066       TestEngine.testPresetError(
1067         "Call readBytes() on write-only stream. [IO_ERR]",
1068         function(){stream.readBytes(0);},
1069         IO_ERR
1070       );
1071       stream.close();
1072       deleteFile(file, f);
1073     }
1074     function on_openStream_error(err) {
1075       TestEngine.test("openStream() [" + err.code + "]", false);
1076       deleteFile(file, f);
1077     }
1078     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1079     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1080   }
1081   resolve_root(on_resolve_success, on_resolve_error);
1082 }
1083
1084 // WAC-FILESYSTEM-052
1085 // Parameters: byteCount = string
1086 // Result: Test passes (conversion exception).
1087 function test_filestream_readBytes_error_052() {
1088   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1089   function on_resolve_success(file) {
1090     var f = file.createFile(getFileName());
1091     TestEngine.test("createFile()", isFile(f));
1092     function on_openStream_success(stream) {
1093       TestEngine.test("openStream()", isFilestream(stream));
1094       TestEngine.test("readBytes()", stream.readBytes('should be a number').length == 0);
1095       stream.close();
1096       deleteFile(file, f);
1097     }
1098     function on_openStream_error(err) {
1099       TestEngine.test("openStream() [" + err.code + "]", false);
1100       deleteFile(file, f);
1101     }
1102     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1103     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1104   }
1105   resolve_root(on_resolve_success, on_resolve_error);
1106 }
1107
1108 // WAC-FILESYSTEM-053: Call readBytes() w/o argument.
1109 function test_filestream_readBytes_error_053() {
1110   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1111   function on_resolve_success(file) {
1112     var f = file.createFile(getFileName());
1113     TestEngine.test("createFile()", isFile(f));
1114     function on_openStream_success(stream) {
1115       TestEngine.test("openStream()", isFilestream(stream));
1116       TestEngine.testPresetError(
1117         "Call read() w/o argument. [TYPE_MISMATCH_ERR]",
1118         function(){stream.readBytes();},
1119         TYPE_MISMATCH_ERR
1120       );
1121       stream.close();
1122       deleteFile(file, f);
1123     }
1124     function on_openStream_error(err) {
1125       TestEngine.test("openStream() [" + err.code + "]", false);
1126       deleteFile(file, f);
1127     }
1128     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1129     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1130   }
1131   resolve_root(on_resolve_success, on_resolve_error);
1132 }
1133
1134 // WAC-FILESYSTEM-054: Call writeBytes() on a closed stream.
1135 function test_filestream_writeBytes_error_054() {
1136   var test_array = new Array(1, 2, 3, 4);
1137   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1138   function on_resolve_success(file) {
1139     var f = file.createFile(getFileName());
1140     TestEngine.test("createFile()", isFile(f));
1141     function on_openStream_success(stream) {
1142       TestEngine.test("openStream()", isFilestream(stream));
1143       stream.close();
1144       TestEngine.testPresetError(
1145         "Call writeBytes() on a closed stream. [IO_ERR]",
1146         function(){stream.writeBytes(test_array);},
1147         IO_ERR
1148       );
1149       deleteFile(file, f);
1150     }
1151     function on_openStream_error(err) {
1152       TestEngine.test("openStream() [" + err.code + "]", false);
1153       deleteFile(file, f);
1154     }
1155     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1156     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1157   }
1158   resolve_root(on_resolve_success, on_resolve_error);
1159 }
1160
1161 // WAC-FILESYSTEM-055: Call writeBytes() on read-only stream.
1162 function test_filestream_writeBytes_error_055() {
1163   var test_array = new Array(1, 2, 3, 4);
1164   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1165   function on_resolve_success(file) {
1166     var f = file.createFile(getFileName());
1167     TestEngine.test("createFile()", isFile(f));
1168     function on_openStream_success(stream) {
1169       TestEngine.test("openStream()", isFilestream(stream));
1170       TestEngine.testPresetError(
1171         "Call writeBytes() on read-only stream. [IO_ERR]",
1172         function(){stream.writeBytes(test_array);},
1173         IO_ERR
1174       );
1175       stream.close();
1176       deleteFile(file, f);
1177     }
1178     function on_openStream_error(err) {
1179       TestEngine.test("openStream() [" + err.code + "]", false);
1180       deleteFile(file, f);
1181     }
1182     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1183     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1184   }
1185   resolve_root(on_resolve_success, on_resolve_error);
1186 }
1187
1188 // WAC-FILESYSTEM-056: Call writeBytes() with invalid argument type.
1189 function test_filestream_writeBytes_error_056() {
1190   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1191   function on_resolve_success(file) {
1192     var f = file.createFile(getFileName());
1193     TestEngine.test("createFile()", isFile(f));
1194     function on_openStream_success(stream) {
1195       TestEngine.test("openStream()", isFilestream(stream));
1196       TestEngine.testPresetError(
1197         "Call writeBytes() with invalid argument. [TYPE_MISMATCH_ERR]",
1198         function(){stream.writeBytes(3);},
1199         TYPE_MISMATCH_ERR
1200       );
1201       stream.close();
1202       deleteFile(file, f);
1203     }
1204     function on_openStream_error(err) {
1205       TestEngine.test("openStream() [" + err.code + "]", false);
1206       deleteFile(file, f);
1207     }
1208     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1209     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1210   }
1211   resolve_root(on_resolve_success, on_resolve_error);
1212 }
1213
1214 // WAC-FILESYSTEM-057: Call writeBytes() w/o argument.
1215 function test_filestream_writeBytes_057() {
1216   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1217   function on_resolve_success(file) {
1218     var f = file.createFile(getFileName());
1219     TestEngine.test("createFile()", isFile(f));
1220     function on_openStream_success(stream) {
1221       TestEngine.test("openStream()", isFilestream(stream));
1222       stream.writeBytes();
1223       stream.close();
1224
1225       function on_openStream_read_success(stream) {
1226         TestEngine.test("openStream()", isFilestream(stream));
1227         var readData = stream.readBytes(256);
1228         stream.close();
1229         TestEngine.test("readBytes()", isArray(readData) && readData.length == 0);
1230         deleteFile(file, f);
1231       }
1232
1233       var cb = TestEngine.registerCallback("openStream", on_openStream_read_success, on_openStream_error);
1234       f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1235     }
1236     function on_openStream_error(err) {
1237       TestEngine.test("openStream() [" + err.code + "]", false);
1238       deleteFile(file, f);
1239     }
1240     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1241     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1242   }
1243   resolve_root(on_resolve_success, on_resolve_error);
1244 }
1245
1246 // WAC-FILESYSTEM-058: Call writeBase64()/readBase64() on a stream.
1247 function test_filestream_writeBase64_readBase64_058() {
1248   var test_base64 = 'dGVzdA==';
1249   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1250   function on_resolve_success(file) {
1251     var f = file.createFile(getFileName());
1252     TestEngine.test("createFile()", isFile(f));
1253     function on_openStream_success(stream) {
1254       TestEngine.test("openStream()", isFilestream(stream));
1255       stream.writeBase64(test_base64);
1256       stream.close();
1257       function on_openStream1_success(stream1) {
1258         TestEngine.test("openStream()", isFilestream(stream1));
1259         var read_base64 = stream1.readBase64(100);
1260         stream1.close();
1261         TestEngine.test("writeBase64()/readBase64()", (test_base64 === read_base64));
1262         deleteFile(file, f);
1263       }
1264       function on_openStream1_error(err) {
1265         TestEngine.test("openStream() [" + err.code + "]", false);
1266         deleteFile(file, f);
1267       }
1268       var cb = TestEngine.registerCallback("openStream", on_openStream1_success, on_openStream1_error);
1269       f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1270     }
1271     function on_openStream_error(err) {
1272       TestEngine.test("openStream() [" + err.code + "]", false);
1273       deleteFile(file, f);
1274     }
1275     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1276     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1277   }
1278   resolve_root(on_resolve_success, on_resolve_error);
1279 }
1280
1281 // WAC-FILESYSTEM-059: Call writeBase64()/read() on a stream.
1282 function test_filestream_writeBase64_read_059() {
1283   var test_base64 = 'dGVzdA==';
1284   var test_string = 'test';
1285   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1286   function on_resolve_success(file) {
1287     var f = file.createFile(getFileName());
1288     TestEngine.test("createFile()", isFile(f));
1289     function on_openStream_success(stream) {
1290       TestEngine.test("openStream()", isFilestream(stream));
1291       stream.writeBase64(test_base64);
1292       stream.close();
1293       function on_openStream1_success(stream1) {
1294         TestEngine.test("openStream()", isFilestream(stream1));
1295         var read_string = stream1.read(test_string.length);
1296         stream1.close();
1297         TestEngine.test("writeBase64()/read()", (test_string === read_string));
1298         deleteFile(file, f);
1299       }
1300       function on_openStream1_error(err) {
1301         TestEngine.test("openStream() [" + err.code + "]", false);
1302         deleteFile(file, f);
1303       }
1304       var cb = TestEngine.registerCallback("openStream", on_openStream1_success, on_openStream1_error);
1305       f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1306     }
1307     function on_openStream_error(err) {
1308       TestEngine.test("openStream() [" + err.code + "]", false);
1309       deleteFile(file, f);
1310     }
1311     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1312     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1313   }
1314   resolve_root(on_resolve_success, on_resolve_error);
1315 }
1316
1317 // WAC-FILESYSTEM-060: Call write()/readBase64() on a stream.
1318 function test_filestream_write_readBase64_060() {
1319   var test_base64 = 'dGVzdA==';
1320   var test_string = 'test';
1321   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1322   function on_resolve_success(file) {
1323     var f = file.createFile(getFileName());
1324     TestEngine.test("createFile()", isFile(f));
1325     function on_openStream_success(stream) {
1326       TestEngine.test("openStream()", isFilestream(stream));
1327       stream.write(test_string);
1328       stream.close();
1329       function on_openStream1_success(stream1) {
1330         TestEngine.test("openStream()", isFilestream(stream1));
1331         var read_base64 = stream1.readBase64(100);
1332         stream1.close();
1333         TestEngine.test("write()/readBase64()", (test_base64 === read_base64));
1334         deleteFile(file, f);
1335       }
1336       function on_openStream1_error(err) {
1337         TestEngine.test("openStream() [" + err.code + "]", false);
1338         deleteFile(file, f);
1339       }
1340       var cb = TestEngine.registerCallback("openStream", on_openStream1_success, on_openStream1_error);
1341       f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1342     }
1343     function on_openStream_error(err) {
1344       TestEngine.test("openStream() [" + err.code + "]", false);
1345       deleteFile(file, f);
1346     }
1347     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1348     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1349   }
1350   resolve_root(on_resolve_success, on_resolve_error);
1351 }
1352
1353 // WAC-FILESYSTEM-061: Call readBase64() on a closed stream.
1354 function test_filestream_readBase64_error_061() {
1355   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1356   function on_resolve_success(file) {
1357     var f = file.createFile(getFileName());
1358     TestEngine.test("createFile()", isFile(f));
1359     function on_openStream_success(stream) {
1360       TestEngine.test("openStream()", isFilestream(stream));
1361       stream.close();
1362       TestEngine.testPresetError(
1363         "Call readBase64() on a closed stream. [IO_ERR]",
1364         function(){stream.readBase64(3);},
1365         IO_ERR
1366       );
1367       deleteFile(file, f);
1368     }
1369     function on_openStream_error(err) {
1370       TestEngine.test("openStream() [" + err.code + "]", false);
1371       deleteFile(file, f);
1372     }
1373     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1374     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1375   }
1376   resolve_root(on_resolve_success, on_resolve_error);
1377 }
1378
1379 // WAC-FILESYSTEM-062: Call readBase64() on a stream with EOF flag set.
1380 function test_filestream_readBase64_error_062() {
1381   var test_base64 = 'dGVzdA==';
1382   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1383   function on_resolve_success(file) {
1384     var f = file.createFile(getFileName());
1385     TestEngine.test("createFile()", isFile(f));
1386     function on_openStream_success(stream) {
1387       TestEngine.test("openStream()", isFilestream(stream));
1388       stream.writeBase64(test_base64);
1389       stream.close();
1390       function on_openStream1_success(stream1) {
1391         TestEngine.test("openStream()", isFilestream(stream1));
1392         var read_base64 = stream1.readBase64(100);
1393         TestEngine.testPresetError(
1394           "Call readBase64() on stream with EOF set. [IO_ERR]",
1395           function(){stream1.readBase64(1);},
1396           IO_ERR
1397         );
1398         stream1.close();
1399         deleteFile(file, f);
1400       }
1401       function on_openStream1_error(err) {
1402         TestEngine.test("openStream() [" + err.code + "]", false);
1403         deleteFile(file, f);
1404       }
1405       var cb = TestEngine.registerCallback("openStream", on_openStream1_success, on_openStream1_error);
1406       f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1407     }
1408     function on_openStream_error(err) {
1409       TestEngine.test("openStream() [" + err.code + "]", false);
1410       deleteFile(file, f);
1411     }
1412     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1413     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1414   }
1415   resolve_root(on_resolve_success, on_resolve_error);
1416 }
1417
1418 // WAC-FILESYSTEM-064: Call readBase64() on write-only stream.
1419 function test_filestream_readBase64_error_064() {
1420   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1421   function on_resolve_success(file) {
1422     var f = file.createFile(getFileName());
1423     TestEngine.test("createFile()", isFile(f));
1424     function on_openStream_success(stream) {
1425       TestEngine.test("openStream()", isFilestream(stream));
1426       TestEngine.testPresetError(
1427         "Call readBase64() on write-only stream. [IO_ERR]",
1428         function(){stream.readBase64(0);},
1429         IO_ERR
1430       );
1431       stream.close();
1432       deleteFile(file, f);
1433     }
1434     function on_openStream_error(err) {
1435       TestEngine.test("openStream() [" + err.code + "]", false);
1436       deleteFile(file, f);
1437     }
1438     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1439     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1440   }
1441   resolve_root(on_resolve_success, on_resolve_error);
1442 }
1443
1444 // WAC-FILESYSTEM-065
1445 // Parameters: byteCount = string
1446 // Result: Test passes (empty string).
1447 function test_filestream_readBase64_error_065() {
1448   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1449   function on_resolve_success(file) {
1450     var f = file.createFile(getFileName());
1451     TestEngine.test("createFile()", isFile(f));
1452     function on_openStream_success(stream) {
1453       TestEngine.test("openStream()", isFilestream(stream));
1454       TestEngine.test("readBase64()", stream.readBase64('should be a number') == '');
1455       stream.close();
1456       deleteFile(file, f);
1457     }
1458     function on_openStream_error(err) {
1459       TestEngine.test("openStream() [" + err.code + "]", false);
1460       deleteFile(file, f);
1461     }
1462     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1463     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1464   }
1465   resolve_root(on_resolve_success, on_resolve_error);
1466 }
1467
1468 // WAC-FILESYSTEM-066: Call readBase64() w/o argument.
1469 function test_filestream_readBase64_error_066() {
1470   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1471   function on_resolve_success(file) {
1472     var f = file.createFile(getFileName());
1473     TestEngine.test("createFile()", isFile(f));
1474     function on_openStream_success(stream) {
1475       TestEngine.test("openStream()", isFilestream(stream));
1476       TestEngine.testPresetError(
1477         "Call readBase64() w/o argument. [TYPE_MISMATCH_ERR]",
1478         function(){stream.readBase64();},
1479         TYPE_MISMATCH_ERR
1480       );
1481       stream.close();
1482       deleteFile(file, f);
1483     }
1484     function on_openStream_error(err) {
1485       TestEngine.test("openStream() [" + err.code + "]", false);
1486       deleteFile(file, f);
1487     }
1488     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1489     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1490   }
1491   resolve_root(on_resolve_success, on_resolve_error);
1492 }
1493
1494 // WAC-FILESYSTEM-067: Call writeBase64() on a closed stream.
1495 function test_filestream_writeBase64_error_067() {
1496   var test_base64 = 'dGVzdA==';
1497   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1498   function on_resolve_success(file) {
1499     var f = file.createFile(getFileName());
1500     TestEngine.test("createFile()", isFile(f));
1501     function on_openStream_success(stream) {
1502       TestEngine.test("openStream()", isFilestream(stream));
1503       stream.close();
1504       TestEngine.testPresetError(
1505         "Call writeBase64() on a closed stream. [IO_ERR]",
1506         function(){stream.writeBase64(test_base64);},
1507         IO_ERR
1508       );
1509       deleteFile(file, f);
1510     }
1511     function on_openStream_error(err) {
1512       TestEngine.test("openStream() [" + err.code + "]", false);
1513       deleteFile(file, f);
1514     }
1515     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1516     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1517   }
1518   resolve_root(on_resolve_success, on_resolve_error);
1519 }
1520
1521 // WAC-FILESYSTEM-068: Call writeBase64() on read-only stream.
1522 function test_filestream_writeBase64_error_068() {
1523   var test_base64 = 'dGVzdA==';
1524   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1525   function on_resolve_success(file) {
1526     var f = file.createFile(getFileName());
1527     TestEngine.test("createFile()", isFile(f));
1528     function on_openStream_success(stream) {
1529       TestEngine.test("openStream()", isFilestream(stream));
1530       TestEngine.testPresetError(
1531         "Call writeBase64() on read-only stream. [IO_ERR]",
1532         function(){stream.writeBase64(test_base64);},
1533         IO_ERR
1534       );
1535       stream.close();
1536       deleteFile(file, f);
1537     }
1538     function on_openStream_error(err) {
1539       TestEngine.test("openStream() [" + err.code + "]", false);
1540       deleteFile(file, f);
1541     }
1542     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1543     f.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
1544   }
1545   resolve_root(on_resolve_success, on_resolve_error);
1546 }
1547
1548 // WAC-FILESYSTEM-069
1549 // Parameters: base64Data = invalid value
1550 // Result: IO_ERR thrown in place.
1551 function test_filestream_writeBase64_error_069() {
1552   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1553   function on_resolve_success(file) {
1554     var f = file.createFile(getFileName());
1555     TestEngine.test("createFile()", isFile(f));
1556     function on_openStream_success(stream) {
1557       TestEngine.test("openStream()", isFilestream(stream));
1558       TestEngine.testPresetError(
1559         "Call writeBase64() with invalid argument.",
1560         function(){stream.writeBase64(3);},
1561         IO_ERR
1562       );
1563       stream.close();
1564       deleteFile(file, f);
1565     }
1566     function on_openStream_error(err) {
1567       TestEngine.test("openStream() [" + err.code + "]", false);
1568       deleteFile(file, f);
1569     }
1570     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1571     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1572   }
1573   resolve_root(on_resolve_success, on_resolve_error);
1574 }
1575
1576 // WAC-FILESYSTEM-070: Call writeBase64() w/o argument.
1577 function test_filestream_writeBase64_error_070() {
1578   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1579   function on_resolve_success(file) {
1580     var f = file.createFile(getFileName());
1581     TestEngine.test("createFile()", isFile(f));
1582     function on_openStream_success(stream) {
1583       TestEngine.test("openStream()", isFilestream(stream));
1584       TestEngine.testPresetError(
1585         "Call writeBase64() w/o argument. [TYPE_MISMATCH_ERR]",
1586         function(){stream.writeBase64();},
1587         TYPE_MISMATCH_ERR
1588       );
1589       stream.close();
1590       deleteFile(file, f);
1591     }
1592     function on_openStream_error(err) {
1593       TestEngine.test("openStream() [" + err.code + "]", false);
1594       deleteFile(file, f);
1595     }
1596     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1597     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1598   }
1599   resolve_root(on_resolve_success, on_resolve_error);
1600 }
1601
1602 // WAC-FILESYSTEM-071: Call createFile() on node resolved in read-only mode.
1603 function test_file_createFile_error_071() {
1604   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1605   function on_resolve_success(file) {
1606     TestEngine.testPresetError(
1607       "Call createFile() on read-only node. [SECURITY_ERR]",
1608       function() {
1609         var f = file.createFile(getFileName());
1610         deleteFile(file, f);
1611       },
1612       SECURITY_ERR
1613     );
1614   }
1615   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
1616   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "r");
1617 }
1618
1619 // WAC-FILESYSTEM-072: Call deleteFile() on node resolved in read-only mode.
1620 function test_file_deleteFile_error_072() {
1621   var filename = getFileName();
1622   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1623   function on_resolve_success(file) {
1624     TestEngine.test("createFile()", isFile(file.createFile(filename)));
1625
1626     function on_resolve1_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1627     function on_resolve1_success(file) {
1628       var f = file.resolve(filename);
1629       TestEngine.test("resolve()", isFile(f));
1630
1631       function on_deleteFile_error(err) {
1632         TestEngine.test("Call deleteFile() on read-only node. [SECURITY_ERR]", (err.code == SECURITY_ERR));
1633         function on_resolve2_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1634         function on_resolve2_success(file) {
1635           var f = file.resolve(filename);
1636           TestEngine.test("resolve()", isFile(f));
1637           deleteFile(file, f);
1638         }
1639         var cb = TestEngine.registerCallback("resolve", on_resolve2_success, on_resolve2_error);
1640         deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "rw");
1641       }
1642       function on_deleteFile_success() {
1643         TestEngine.test("Call deleteFile() on read-only node. [SECURITY_ERR]", false);
1644       }
1645       var cb = TestEngine.registerCallback("deleteFile", on_deleteFile_success, on_deleteFile_error);
1646       file.deleteFile(cb.successCallback, cb.errorCallback, f.fullPath);
1647     }
1648     var cb = TestEngine.registerCallback("resolve", on_resolve1_success, on_resolve1_error);
1649     deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "r");
1650   }
1651   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
1652   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "rw");
1653 }
1654
1655 // WAC-FILESYSTEM-073: Call deleteDirectory() on node resolved in read-only mode.
1656 function test_file_deleteDirectory_error_073() {
1657   var dirname = getDirName();
1658   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1659   function on_resolve_success(file) {
1660     TestEngine.test("createDirectory()", isDir(file.createDirectory(dirname)));
1661
1662     function on_resolve1_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1663     function on_resolve1_success(file) {
1664       var dir = file.resolve(dirname);
1665       TestEngine.test("resolve()", isDir(dir));
1666
1667       function on_deleteDirectory_error(err) {
1668         TestEngine.test("Call deleteDirectory() on read-only node. [SECURITY_ERR]", (err.code == SECURITY_ERR));
1669         function on_resolve2_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1670         function on_resolve2_success(file) {
1671           var dir = file.resolve(dirname);
1672           TestEngine.test("resolve()", isDir(dir));
1673           deleteDirectory(file, dir);
1674         }
1675         var cb = TestEngine.registerCallback("resolve", on_resolve2_success, on_resolve2_error);
1676         deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "rw");
1677       }
1678       function on_deleteDirectory_success() {
1679         TestEngine.test("Call deleteDirectory() on read-only node. [SECURITY_ERR]", false);
1680       }
1681       var cb = TestEngine.registerCallback("deleteDirectory", on_deleteDirectory_success, on_deleteDirectory_error);
1682       file.deleteDirectory(cb.successCallback, cb.errorCallback, dir.fullPath, true);
1683     }
1684     var cb = TestEngine.registerCallback("resolve", on_resolve1_success, on_resolve1_error);
1685     deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "r");
1686   }
1687   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
1688   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "rw");
1689 }
1690
1691 // WAC-FILESYSTEM-074: Call moveTo() on node resolved in read-only mode.
1692 function test_file_moveTo_error_074() {
1693   var src_filename = getFileName();
1694   var dst_filename = getFileName();
1695   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1696   function on_resolve_success(file) {
1697     var f = file.createFile(src_filename);
1698     TestEngine.test("createFile()", isFile(f));
1699
1700     function on_resolve1_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1701     function on_resolve1_success(file) {
1702       var f = file.resolve(src_filename);
1703       TestEngine.test("resolve()", isFile(f));
1704
1705       function on_moveTo_error(err) {
1706         TestEngine.test("Call moveTo() on read-only mode. [SECURITY_ERR]", (err.code == SECURITY_ERR));
1707         function on_resolve2_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1708         function on_resolve2_success(file) {
1709           var f = file.resolve(src_filename);
1710           TestEngine.test("resolve()", isFile(f));
1711           deleteFile(file, f);
1712         }
1713         var cb = TestEngine.registerCallback("resolve", on_resolve2_success, on_resolve2_error);
1714         deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "rw");
1715       }
1716       function on_moveTo_success(file1) {
1717         TestEngine.test("Call moveTo() on read-only mode. [SECURITY_ERR]", false);
1718         function on_resolve2_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1719         function on_resolve2_success(file) {
1720           var f = file.resolve(dst_filename);
1721           TestEngine.test("resolve()", isFile(f));
1722           deleteFile(file, f);
1723         }
1724         var cb = TestEngine.registerCallback("resolve", on_resolve2_success, on_resolve2_error);
1725         deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "rw");
1726       }
1727       var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
1728       file.moveTo(cb.successCallback, cb.errorCallback, f.fullPath, file.fullPath + '/' + dst_filename, true);
1729     }
1730     var cb = TestEngine.registerCallback("resolve", on_resolve1_success, on_resolve1_error);
1731     deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "r");
1732   }
1733   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
1734   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "rw");
1735 }
1736
1737 // WAC-FILESYSTEM-075: Call openStream() in write-only mode on node resolved in read-only mode.
1738 function test_file_openStream_error_075() {
1739   var filename = getFileName();
1740   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1741   function on_resolve_success(file) {
1742     var f = file.createFile(filename);
1743     TestEngine.test("createFile()", isFile(f));
1744
1745     function on_resolve1_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1746     function on_resolve1_success(r_file) {
1747       var f = r_file.resolve(filename);
1748       TestEngine.test("resolve()", isFile(f));
1749
1750       function on_openStream_success(stream) {
1751         TestEngine.test("Call openStream() in write-only mode on read-only node. [SECURITY_ERR]", false);
1752         stream.close();
1753         deleteFile(file, f);
1754       }
1755       function on_openStream_error(err) {
1756         TestEngine.test("Call openStream() in write-only mode on read-only node. [SECURITY_ERR]", (err.code == SECURITY_ERR));
1757         deleteFile(file, f);
1758       }
1759       var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1760       f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1761     }
1762     var cb = TestEngine.registerCallback("resolve", on_resolve1_success, on_resolve1_error);
1763     deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "r");
1764   }
1765   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
1766   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, "rw");
1767 }
1768
1769 // WAC-FILESYSTEM-076: Call readAsText() on a file.
1770 function test_file_readAsText_076() {
1771   var test_content = "Ala ma kota";
1772   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1773   function on_resolve_success(file) {
1774     var f = file.createFile(getFileName());
1775     TestEngine.test("createFile()", isFile(f));
1776
1777     function on_openStream_success(stream) {
1778       TestEngine.test("openStream()", isFilestream(stream));
1779       stream.write(test_content);
1780       stream.close();
1781       function on_readAsText_error(err) {
1782         TestEngine.test("readAsText() [" + err.code + "]", false);
1783         deleteFile(file, f);
1784       }
1785       function on_readAsText_success(str) {
1786         TestEngine.test("readAsText()", (str === test_content));
1787         deleteFile(file, f);
1788       }
1789       var cb = TestEngine.registerCallback("readAsText", on_readAsText_success, on_readAsText_error);
1790       f.readAsText(cb.successCallback, cb.errorCallback, "UTF-8");
1791     }
1792     function on_openStream_error(err) {
1793       TestEngine.test("openStream() [" + err.code + "]", false);
1794       deleteFile(file, f);
1795     }
1796     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1797     f.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
1798   }
1799   resolve_root(on_resolve_success, on_resolve_error);
1800 }
1801
1802 // WAC-FILESYSTEM-077: Call readAsText() on a directory.
1803 function test_file_readAsText_error_077() {
1804   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1805   function on_resolve_success(file) {
1806     var dir = file.createDirectory(getDirName());
1807     TestEngine.test("createDirectory()", isDir(dir));
1808
1809     function on_readAsText_error(err) {
1810       TestEngine.test("Call readAsText() on a directory [IO_ERR]", (err.code == IO_ERR));
1811     }
1812     function on_readAsText_success(str) {
1813       TestEngine.test("Call readAsText() on a directory [IO_ERR]", false);
1814     }
1815     var cb = TestEngine.registerCallback("readAsText", on_readAsText_success, on_readAsText_error);
1816     dir.readAsText(cb.successCallback, cb.errorCallback, "UTF-8");
1817     deleteDirectory(file, dir);
1818   }
1819   resolve_root(on_resolve_success, on_resolve_error);
1820 }
1821
1822 // WAC-FILESYSTEM-078: Call readAsText() on a deleted file.
1823 function test_file_readAsText_error_078() {
1824   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1825   function on_resolve_success(root) {
1826     var file = root.createFile(getFileName());
1827     TestEngine.test("createFile()", isFile(file));
1828
1829     function on_deleteFile_error(err) { TestEngine.test("deleteFile() [" + err.code + "]", false); }
1830     function on_deleteFile_success() {
1831       function on_readAsText_error(err) {
1832         TestEngine.test("Call readAsText() on a deleted file [IO_ERR]", (err.code == IO_ERR));
1833       }
1834       function on_readAsText_success(str) {
1835         TestEngine.test("Call readAsText() on a deleted file [IO_ERR]", false);
1836       }
1837       var cb = TestEngine.registerCallback("readAsText", on_readAsText_success, on_readAsText_error);
1838       file.readAsText(cb.successCallback, cb.errorCallback, "UTF-8");
1839     }
1840     var cb = TestEngine.registerCallback("deleteFile", on_deleteFile_success, on_deleteFile_error);
1841     root.deleteFile(cb.successCallback, cb.errorCallback, file.fullPath);
1842   }
1843   resolve_root(on_resolve_success, on_resolve_error);
1844 }
1845
1846 // WAC-FILESYSTEM-079: Call toUri() on file located in root folder.
1847 function test_file_toUri_079() {
1848   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1849   function on_resolve_success(file) {
1850     var f = file.createFile(getFileName());
1851     TestEngine.test("createFile()", isFile(f));
1852     var uri = f.toURI();
1853     TestEngine.test("Call toUri() returns non empty string", isString(uri) && uri.length > 0);
1854     TestEngine.log("created uri: " + uri);
1855     deleteFile(file, f);
1856   }
1857   resolve_root(on_resolve_success, on_resolve_error);
1858 }
1859
1860 // WAC-FILESYSTEM-080: Resolve a file with mode set to null.
1861 function test_filesystem_resolve_080() {
1862   function on_resolve_error(err) {
1863     TestEngine.test("resolve()", false);
1864   }
1865   function on_resolve_success(file) {
1866     TestEngine.test("resolve()", true);
1867   }
1868   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
1869   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, null);
1870 }
1871
1872 // WAC-FILESYSTEM-081: List files with null passed as filter.
1873 function test_file_listFiles_081() {
1874   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1875   function on_resolve_success(file) {
1876     TestEngine.test("resolve()", isFileObject(file));
1877     function on_listFiles_error(err) {
1878       TestEngine.test("listFiles() [" + err.code + "]", false);
1879     }
1880     function on_listFiles_success(files) {
1881       TestEngine.test("listFiles()", isArray(files));
1882     }
1883     var cb = TestEngine.registerCallback("listFiles", on_listFiles_success, on_listFiles_error);
1884     file.listFiles(cb.successCallback, cb.errorCallback, null);
1885   }
1886   resolve_root(on_resolve_success, on_resolve_error);
1887 }
1888
1889 // WAC-FILESYSTEM-082: List files with undefined passed as filter.
1890 function test_file_listFiles_082() {
1891   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1892   function on_resolve_success(file) {
1893     TestEngine.test("resolve()", isFileObject(file));
1894     function on_listFiles_error(err) {
1895       TestEngine.test("listFiles() [" + err.code + "]", false);
1896     }
1897     function on_listFiles_success(files) {
1898       TestEngine.test("listFiles()", isArray(files));
1899     }
1900     var cb = TestEngine.registerCallback("listFiles", on_listFiles_success, on_listFiles_error);
1901     file.listFiles(cb.successCallback, cb.errorCallback, undefined);
1902   }
1903   resolve_root(on_resolve_success, on_resolve_error);
1904 }
1905
1906 // WAC-FILESYSTEM-083
1907 // Parameters: filter = 1, others = valid
1908 // Result: Test passes.
1909 function test_file_listFiles_error_083() {
1910   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1911   function on_resolve_success(file) {
1912     TestEngine.test("resolve()", isFileObject(file));
1913
1914     function on_listFiles_error(err) {
1915       TestEngine.test("listFiles()", false);
1916     }
1917     function on_listFiles_success(files) {
1918       TestEngine.test("listFiles()", isArray(files));
1919     }
1920     var cb = TestEngine.registerCallback("listFiles", on_listFiles_success, on_listFiles_error);
1921     file.listFiles(cb.successCallback, cb.errorCallback, 1);
1922   }
1923   resolve_root(on_resolve_success, on_resolve_error);
1924 }
1925
1926 // WAC-FILESYSTEM-084: List files with null passed as success callback.
1927 function test_file_listFiles_error_084() {
1928   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1929   function on_resolve_success(file) {
1930     TestEngine.test("resolve()", isFileObject(file));
1931     function on_listFiles_error(err) {
1932       TestEngine.test("listFiles() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
1933     }
1934     function on_listFiles_success(files) {
1935       TestEngine.test("listFiles()", false);
1936     }
1937     var cb = TestEngine.registerCallback("listFiles", on_listFiles_success, on_listFiles_error);
1938     file.listFiles(null, cb.errorCallback);
1939   }
1940   resolve_root(on_resolve_success, on_resolve_error);
1941 }
1942
1943 // WAC-FILESYSTEM-085
1944 // Parameters: successCallback = undefined, others = valid
1945 // Result: INVALID_VALUES_ERR thrown via error callback.
1946 function test_file_listFiles_error_085() {
1947   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1948   function on_resolve_success(file) {
1949     TestEngine.test("resolve()", isFileObject(file));
1950     function on_listFiles_error(err) {
1951       TestEngine.test("listFiles()", (err.code == INVALID_VALUES_ERR));
1952     }
1953     var cb = TestEngine.registerCallback("listFiles", undefined, on_listFiles_error);
1954     file.listFiles(cb.successCallback, cb.errorCallback);
1955   }
1956   resolve_root(on_resolve_success, on_resolve_error);
1957 }
1958
1959 // WAC-FILESYSTEM-086: List files with both callbacks set to null. Nothing should happen.
1960 function test_file_listFiles_error_086() {
1961   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1962   function on_resolve_success(file) {
1963     TestEngine.test("resolve()", isFileObject(file));
1964     function on_listFiles_error(err) {
1965       TestEngine.test("listFiles() [" + err.code + "]", false);
1966     }
1967     function on_listFiles_success(files) {
1968       TestEngine.test("listFiles()", false);
1969     }
1970     // Pass callbacks directly to prevent "widget run timeout".
1971     file.listFiles(null, null);
1972   }
1973   resolve_root(on_resolve_success, on_resolve_error);
1974 }
1975
1976 // WAC-FILESYSTEM-087: Test optionality of the last parameter.
1977 function test_file_open_087() {
1978   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
1979   function on_resolve_success(file) {
1980     TestEngine.test("resolve()", isFileObject(file));
1981     var file2 = file.createFile(getFileName());
1982     TestEngine.test("createFile()", isFile(file2));
1983     function on_openStream_success(stream) {
1984       TestEngine.test("openStream()", isFilestream(stream));
1985       stream.close();
1986       deleteFile(file, file2);
1987     }
1988     function on_openStream_error(err) {
1989       TestEngine.test("openStream() [" + err.code + "]", false);
1990     }
1991     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
1992     var stream = file2.openStream(cb.successCallback, cb.errorCallback, "r");
1993   }
1994   resolve_root(on_resolve_success, on_resolve_error);
1995 }
1996
1997 // WAC-FILESYSTEM-088: Test success callback set to null.
1998 function test_file_open_error_088() {
1999   function on_resolve_success(root) {
2000     function on_openStream_error(err) {
2001       TestEngine.test("openStream() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
2002       deleteFile(root, file);
2003     }
2004     var file = createFileForParent(root);
2005     // Pass callbacks directly to prevent "widget run timeout".
2006     var cb = TestEngine.registerCallback("openStream", null, on_openStream_error);
2007     var stream = file.openStream(null, cb.errorCallback, "r");
2008   }
2009   resolve_root_location(on_resolve_success);
2010 }
2011
2012 // WAC-FILESYSTEM-089
2013 // Parameters: successCallback = undefined, others = valid
2014 // Result: INVALID_VALUES_ERR thrown via error callback.
2015 function test_file_open_error_089() {
2016   function on_resolve_success(root) {
2017     var file = createFileForParent(root);
2018
2019     function on_openStream_error(err) {
2020       TestEngine.test("openStream()", (err.code == INVALID_VALUES_ERR));
2021       deleteFile(root, file);
2022     }
2023
2024     var cb = TestEngine.registerCallback("openStream", undefined, on_openStream_error);
2025     var stream = file.openStream(cb.successCallback, cb.errorCallback, "r");
2026   }
2027   resolve_root_location(on_resolve_success);
2028 }
2029
2030 // WAC-FILESYSTEM-090: Test passing invalid mode with error callback set to null.
2031 function test_file_open_error_090() {
2032   function on_resolve_success(root) {
2033     function on_openStream_success(fs) {
2034       TestEngine.test("Calling openStream() with invalid mode.", false);
2035       fs.close();
2036       deleteFile(root, file);
2037     }
2038     var file = createFileForParent(root);
2039     testNoExceptionWithMessage("openStream()", function() {
2040       // Pass callbacks directly to prevent "widget run timeout".
2041       file.openStream(on_openStream_success, null, "x", "UTF-8");
2042     });
2043     deleteFile(root, file);
2044   }
2045   resolve_root_location(on_resolve_success);
2046 }
2047
2048 // WAC-FILESYSTEM-091: Call readAsText() w/o specifing encoding parameter.
2049 function test_file_readAsText_091() {
2050   var test_content = "Ala ma kota";
2051   function on_resolve_success(root) {
2052     var file = createFileForParent(root)
2053
2054     function on_openStream_success(stream) {
2055       TestEngine.test("openStream()", isFilestream(stream));
2056       stream.write(test_content);
2057       stream.close();
2058
2059       function on_readAsText_error(err) {
2060         TestEngine.test("readAsText() [" + err.code + "]", false);
2061         deleteFile(root, file);
2062       }
2063       function on_readAsText_success(str) {
2064         TestEngine.test("readAsText()", (str === test_content));
2065         deleteFile(root, file);
2066       }
2067       var cb = TestEngine.registerCallback("readAsText", on_readAsText_success, on_readAsText_error);
2068       file.readAsText(cb.successCallback, cb.errorCallback);
2069     }
2070     function on_openStream_error(err) {
2071       TestEngine.test("openStream() [" + err.code + "]", false);
2072       deleteFile(root, file);
2073     }
2074     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2075     file.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
2076   }
2077   resolve_root_location(on_resolve_success);
2078 }
2079
2080 // WAC-FILESYSTEM-092: Call readAsText() with encoding parameter set to null.
2081 function test_file_readAsText_092() {
2082   var test_content = "Ala ma kota";
2083   function on_resolve_success(root) {
2084     var file = createFileForParent(root)
2085
2086     function on_openStream_success(stream) {
2087       TestEngine.test("openStream()", isFilestream(stream));
2088       stream.write(test_content);
2089       stream.close();
2090
2091       function on_readAsText_error(err) {
2092         TestEngine.test("readAsText() [" + err.code + "]", false);
2093         deleteFile(root, file);
2094       }
2095       function on_readAsText_success(str) {
2096         TestEngine.test("readAsText()", (str === test_content));
2097         deleteFile(root, file);
2098       }
2099       var cb = TestEngine.registerCallback("readAsText", on_readAsText_success, on_readAsText_error);
2100       file.readAsText(cb.successCallback, cb.errorCallback, null);
2101     }
2102     function on_openStream_error(err) {
2103       TestEngine.test("openStream() [" + err.code + "]", false);
2104       deleteFile(root, file);
2105     }
2106     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2107     file.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
2108   }
2109   resolve_root_location(on_resolve_success);
2110 }
2111
2112 // WAC-FILESYSTEM-093: Call readAsText() with error callback set to null.
2113 function test_file_readAsText_093() {
2114   var test_content = "Ala ma kota";
2115   function on_resolve_success(root) {
2116     var file = createFileForParent(root)
2117
2118     function on_openStream_success(stream) {
2119       TestEngine.test("openStream()", isFilestream(stream));
2120       stream.write(test_content);
2121       stream.close();
2122
2123       function on_readAsText_success(str) {
2124         TestEngine.test("readAsText()", (str === test_content));
2125         deleteFile(root, file);
2126       }
2127       var cb = TestEngine.registerCallback("readAsText", on_readAsText_success, null);
2128       file.readAsText(cb.successCallback, null);
2129     }
2130     function on_openStream_error(err) {
2131       TestEngine.test("openStream() [" + err.code + "]", false);
2132       deleteFile(root, file);
2133     }
2134     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2135     file.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
2136   }
2137   resolve_root_location(on_resolve_success);
2138 }
2139
2140 // WAC-FILESYSTEM-094: Call readAsText() w/o specifing error callback.
2141 function test_file_readAsText_094() {
2142   var test_content = "Ala ma kota";
2143   function on_resolve_success(root) {
2144     var file = createFileForParent(root)
2145
2146     function on_openStream_success(stream) {
2147       TestEngine.test("openStream()", isFilestream(stream));
2148       stream.write(test_content);
2149       stream.close();
2150
2151       function on_readAsText_success(str) {
2152         TestEngine.test("readAsText()", (str === test_content));
2153         deleteFile(root, file);
2154       }
2155       var cb = TestEngine.registerCallback("readAsText", on_readAsText_success, null);
2156       file.readAsText(cb.successCallback);
2157     }
2158     function on_openStream_error(err) {
2159       TestEngine.test("openStream() [" + err.code + "]", false);
2160       deleteFile(root, file);
2161     }
2162     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2163     file.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
2164   }
2165   resolve_root_location(on_resolve_success);
2166 }
2167
2168 // WAC-FILESYSTEM-095: Call readAsText() with success callback set to null.
2169 function test_file_readAsText_error_095() {
2170   var test_content = "Ala ma kota";
2171   function on_resolve_success(root) {
2172     var file = createFileForParent(root)
2173
2174     function on_openStream_success(stream) {
2175       TestEngine.test("openStream()", isFilestream(stream));
2176       stream.write(test_content);
2177       stream.close();
2178
2179       function on_readAsText_error(err) {
2180         TestEngine.test("readAsText() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
2181         deleteFile(root, file);
2182       }
2183       var cb = TestEngine.registerCallback("readAsText", null, on_readAsText_error);
2184       file.readAsText(null, cb.errorCallback);
2185     }
2186     function on_openStream_error(err) {
2187       TestEngine.test("openStream() [" + err.code + "]", false);
2188       deleteFile(root, file);
2189     }
2190     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2191     file.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
2192   }
2193   resolve_root_location(on_resolve_success);
2194 }
2195
2196 // WAC-FILESYSTEM-096: Call readAsText() with both callbacks set to null.
2197 function test_file_readAsText_error_096() {
2198   var test_content = "Ala ma kota";
2199   function on_resolve_success(root) {
2200     var file = createFileForParent(root)
2201
2202     function on_openStream_success(stream) {
2203       TestEngine.test("openStream()", isFilestream(stream));
2204       stream.write(test_content);
2205       stream.close();
2206
2207       testNoExceptionWithMessage("readAsText()", function() {
2208         file.readAsText(null, null);
2209       });
2210       deleteFile(root, file);
2211     }
2212     function on_openStream_error(err) {
2213       TestEngine.test("openStream() [" + err.code + "]", false);
2214       deleteFile(root, file);
2215     }
2216     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2217     file.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
2218   }
2219   resolve_root_location(on_resolve_success);
2220 }
2221
2222 // WAC-FILESYSTEM-097
2223 // Parameters: successCallback = undefined, others = valid
2224 // Result: INVALID_VALUES_ERR thrown via error callback.
2225 function test_file_readAsText_error_097() {
2226   var test_content = "Ala ma kota";
2227   function on_resolve_success(root) {
2228     var file = createFileForParent(root)
2229
2230     function on_openStream_success(stream) {
2231       TestEngine.test("openStream()", isFilestream(stream));
2232       stream.write(test_content);
2233       stream.close();
2234
2235       function on_readAsText_error(err) {
2236         TestEngine.test("readAsText()", (err.code == INVALID_VALUES_ERR));
2237         deleteFile(root, file);
2238       }
2239
2240       var cb = TestEngine.registerCallback("readAsText", undefined, on_readAsText_error);
2241       file.readAsText(cb.successCallback, cb.errorCallback, "r");
2242     }
2243     function on_openStream_error(err) {
2244       TestEngine.test("openStream() [" + err.code + "]", false);
2245       deleteFile(root, file);
2246     }
2247     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2248     file.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
2249   }
2250   resolve_root_location(on_resolve_success);
2251 }
2252
2253 // WAC-FILESYSTEM-098: Call readAsText() with invalid encoding parameter.
2254 function test_file_readAsText_error_098() {
2255   var test_content = "Ala ma kota";
2256   function on_resolve_success(root) {
2257     var file = createFileForParent(root)
2258
2259     function on_openStream_success(stream) {
2260       TestEngine.test("openStream()", isFilestream(stream));
2261       stream.write(test_content);
2262       stream.close();
2263
2264       function on_readAsText_error(err) {
2265         TestEngine.test("readAsText() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
2266         deleteFile(root, file);
2267       }
2268       function on_readAsText_success(str) {
2269         TestEngine.test("readAsText()", false);
2270         deleteFile(root, file);
2271       }
2272       var cb = TestEngine.registerCallback("readAsText", on_readAsText_success, on_readAsText_error);
2273       file.readAsText(cb.successCallback, cb.errorCallback, "INVALID");
2274     }
2275     function on_openStream_error(err) {
2276       TestEngine.test("openStream() [" + err.code + "]", false);
2277       deleteFile(root, file);
2278     }
2279     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2280     file.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
2281   }
2282   resolve_root_location(on_resolve_success);
2283 }
2284
2285 // WAC-FILESYSTEM-099: Call deleteDirectory() with error callback set to null.
2286 function test_file_deleteDirectory_099() {
2287   function on_resolve_success(root) {
2288     var dir = createDirForParent(root);
2289     function on_deleteDirectory_success() {
2290       TestEngine.test("deleteDirectory()", true);
2291     }
2292     var cb = TestEngine.registerCallback("deleteDirectory", on_deleteDirectory_success, null);
2293     root.deleteDirectory(cb.successCallback, null, dir.fullPath, true);
2294   }
2295   resolve_root_location(on_resolve_success);
2296 }
2297
2298 // WAC-FILESYSTEM-100: Call deleteDirectory() with error callback set to null
2299 //                     and directory set to invalid value.
2300 function test_file_deleteDirectory_error_100() {
2301   function on_resolve_success(root) {
2302     function on_deleteDirectory_success() {
2303       TestEngine.test("deleteDirectory()", false);
2304     }
2305     testNoExceptionWithMessage("deleteDirectory()", function() {
2306       // Pass callbacks directly to prevent "widget run timeout".
2307       root.deleteDirectory(on_deleteDirectory_success, null, "../", true);
2308     });
2309   }
2310   resolve_root_location(on_resolve_success);
2311 }
2312
2313 // WAC-FILESYSTEM-101: Call deleteDirectory() with success callback set to null.
2314 function test_file_deleteDirectory_error_101() {
2315   function on_resolve_success(root) {
2316     var dir = createDirForParent(root);
2317     function on_deleteDirectory_error(err) {
2318       TestEngine.test("deleteDirectory() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
2319       deleteDirectory(root, dir);
2320     }
2321     var cb = TestEngine.registerCallback("deleteDirectory", null, on_deleteDirectory_error);
2322     root.deleteDirectory(null, cb.errorCallback, dir.fullPath, true);
2323   }
2324   resolve_root_location(on_resolve_success);
2325 }
2326
2327 // WAC-FILESYSTEM-102
2328 // Parameters: successCallback = undefined, others = valid
2329 // Result: INVALID_VALUES_ERR thrown via error callback.
2330 function test_file_deleteDirectory_error_102() {
2331   function on_resolve_success(root) {
2332     var dir = createDirForParent(root);
2333     function on_deleteDirectory_error(err) {
2334       TestEngine.test("deleteDirectory()", (err.code == INVALID_VALUES_ERR));
2335       deleteDirectory(root, dir);
2336     }
2337     var cb = TestEngine.registerCallback("deleteDirectory", undefined, on_deleteDirectory_error);
2338     root.deleteDirectory(cb.successCallback, cb.errorCallback, dir.fullPath, true);
2339   }
2340   resolve_root_location(on_resolve_success);
2341 }
2342
2343 // WAC-FILESYSTEM-103
2344 // Parameters: directory = undefined, others = valid
2345 // Result: INVALID_VALUES_ERR thrown via error callback.
2346 function test_file_deleteDirectory_error_103() {
2347   function on_resolve_success(root) {
2348     var dir = createDirForParent(root);
2349     function on_deleteDirectory_error(err) {
2350       TestEngine.test("deleteDirectory()", (err.code == INVALID_VALUES_ERR));
2351       deleteDirectory(root, dir);
2352     }
2353     function on_deleteDirectory_success() {
2354       TestEngine.test("deleteDirectory()", false);
2355       deleteDirectory(root, dir);
2356     }
2357     var cb = TestEngine.registerCallback("deleteDirectory", on_deleteDirectory_success, on_deleteDirectory_error);
2358     root.deleteDirectory(cb.successCallback, cb.errorCallback, undefined, true);
2359   }
2360   resolve_root_location(on_resolve_success);
2361 }
2362
2363 // WAC-FILESYSTEM-104
2364 // Parameters: recursive = undefined, others = valid
2365 // Result: Test passes.
2366 function test_file_deleteDirectory_error_104() {
2367   function on_resolve_success(root) {
2368     var dir = createDirForParent(root);
2369     function on_deleteDirectory_error(err) {
2370       TestEngine.test("deleteDirectory()", false);
2371       deleteDirectory(root, dir);
2372     }
2373     function on_deleteDirectory_success() {
2374       TestEngine.test("deleteDirectory()", true);
2375     }
2376
2377     var cb = TestEngine.registerCallback("deleteDirectory", on_deleteDirectory_success, on_deleteDirectory_error);
2378     root.deleteDirectory(cb.successCallback, cb.errorCallback, dir.fullPath, undefined);
2379   }
2380   resolve_root_location(on_resolve_success);
2381 }
2382
2383 // WAC-FILESYSTEM-105: Call deleteDirectory() with directory parameter pointing to a file.
2384 function test_file_deleteDirectory_error_105() {
2385   function on_resolve_success(root) {
2386     var file = createFileForParent(root);
2387     function on_deleteDirectory_error(err) {
2388       TestEngine.test("deleteDirectory() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
2389       deleteFile(root, file);
2390     }
2391     function on_deleteDirectory_success() {
2392       TestEngine.test("deleteDirectory()", false);
2393       deleteFile(root, file);
2394     }
2395     var cb = TestEngine.registerCallback("deleteDirectory", on_deleteDirectory_success, on_deleteDirectory_error);
2396     root.deleteDirectory(cb.successCallback, cb.errorCallback, file.fullPath, true);
2397   }
2398   resolve_root_location(on_resolve_success);
2399 }
2400
2401 // WAC-FILESYSTEM-106: Call deleteFile() with error callback set to null.
2402 function test_file_deleteFile_106() {
2403   function on_resolve_success(root) {
2404     var file = createFileForParent(root);
2405     function on_deleteFile_success() {
2406       TestEngine.test("deleteFile()", true);
2407     }
2408     var cb = TestEngine.registerCallback("deleteFile", on_deleteFile_success, null);
2409     root.deleteFile(cb.successCallback, null, file.fullPath);
2410   }
2411   resolve_root_location(on_resolve_success);
2412 }
2413
2414 // WAC-FILESYSTEM-107: Call deleteFile() with error callback set to null
2415 //                     and file set to invalid value.
2416 function test_file_deleteFile_error_107() {
2417   function on_resolve_success(root) {
2418     function on_deleteFile_success() {
2419       TestEngine.test("deleteFile()", false);
2420     }
2421     testNoExceptionWithMessage("deleteFile()", function() {
2422       // Pass callbacks directly to prevent "widget run timeout".
2423       root.deleteFile(on_deleteFile_success, null, "../");
2424     });
2425   }
2426   resolve_root_location(on_resolve_success);
2427 }
2428
2429 // WAC-FILESYSTEM-108: Call deleteFile() with success callback set to null.
2430 function test_file_deleteFile_error_108() {
2431   function on_resolve_success(root) {
2432     var file = createFileForParent(root);
2433     function on_deleteFile_error(err) {
2434       TestEngine.test("deleteFile() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
2435       deleteFile(root, file);
2436     }
2437     var cb = TestEngine.registerCallback("deleteFile", null, on_deleteFile_error);
2438     root.deleteFile(null, cb.errorCallback, file.fullPath);
2439   }
2440   resolve_root_location(on_resolve_success);
2441 }
2442
2443 // WAC-FILESYSTEM-109
2444 // Parameters: successCallback = undefined, others valid
2445 // Result: INVALID_VALUES_ERR thrown via error callback.
2446 function test_file_deleteFile_error_109() {
2447   function on_resolve_success(root) {
2448     var file = createFileForParent(root);
2449     function on_deleteFile_error(err) {
2450       TestEngine.test("deleteFile()", (err.code == INVALID_VALUES_ERR));
2451       deleteFile(root, file);
2452     }
2453     var cb = TestEngine.registerCallback("deleteFile", undefined, on_deleteFile_error);
2454     root.deleteFile(cb.successCallback, cb.errorCallback, file.fullPath);
2455   }
2456   resolve_root_location(on_resolve_success);
2457 }
2458
2459 // WAC-FILESYSTEM-110
2460 // Parameters: file = undefined, others = valid
2461 // Result: INVALID_VALUES_ERR thrown via error callback.
2462 function test_file_deleteFile_error_110() {
2463   function on_resolve_success(root) {
2464     function on_deleteFile_error(err) {
2465       TestEngine.test("deleteFile()", (err.code == INVALID_VALUES_ERR));
2466     }
2467     function on_deleteFile_success() {
2468       TestEngine.test("deleteFile()", false);
2469     }
2470     var cb = TestEngine.registerCallback("deleteFile", on_deleteFile_success, on_deleteFile_error);
2471     root.deleteFile(cb.successCallback, cb.errorCallback, undefined);
2472   }
2473   resolve_root_location(on_resolve_success);
2474 }
2475
2476 // WAC-FILESYSTEM-111
2477 // Parameters: errorCallback = undefined, others = valid
2478 // Result: Test passes.
2479 function test_file_deleteFile_error_111() {
2480   function on_resolve_success(root) {
2481     var file = createFileForParent(root);
2482     function on_deleteFile_success() {
2483       TestEngine.test("deleteFile()", true);
2484     }
2485     var cb = TestEngine.registerCallback("deleteFile", on_deleteFile_success, undefined);
2486     root.deleteFile(cb.successCallback, cb.errorCallback, file.fullPath);
2487   }
2488   resolve_root_location(on_resolve_success);
2489 }
2490
2491 // WAC-FILESYSTEM-112
2492 // Parameters: mode = undefined, others = valid
2493 // Result: Test passes.
2494 function test_filesystem_resolve_112() {
2495   function on_resolve_error(err) {
2496    TestEngine.test("resolve() [" + err.code + "]", false);
2497   }
2498   function on_resolve_success(root) {
2499    TestEngine.test("resolve()", true);
2500   }
2501   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
2502   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION, undefined);
2503 }
2504
2505 // WAC-FILESYSTEM-113
2506 // Parameters: encoding = undefined, others = valid
2507 // Result: Test passes.
2508 function test_file_readAsText_113() {
2509   var test_content = "Ala ma kota";
2510   function on_resolve_success(root) {
2511     var file = createFileForParent(root)
2512
2513     function on_openStream_success(stream) {
2514       TestEngine.test("openStream()", isFilestream(stream));
2515       stream.write(test_content);
2516       stream.close();
2517
2518       function on_readAsText_error(err) {
2519         TestEngine.test("readAsText() [" + err.code + "]", false);
2520         deleteFile(root, file);
2521       }
2522       function on_readAsText_success(str) {
2523         TestEngine.test("readAsText()", (str === test_content));
2524         deleteFile(root, file);
2525       }
2526       var cb = TestEngine.registerCallback("readAsText", on_readAsText_success, on_readAsText_error);
2527       file.readAsText(cb.successCallback, cb.errorCallback, undefined);
2528     }
2529     function on_openStream_error(err) {
2530       TestEngine.test("openStream() [" + err.code + "]", false);
2531       deleteFile(root, file);
2532     }
2533     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2534     file.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
2535   }
2536   resolve_root_location(on_resolve_success);
2537 }
2538
2539 // WAC-FILESYSTEM-114
2540 // Parameters: encoding = undefined, others = valid
2541 // Result: INVALID_VALUES_ERR thrown via error callback.
2542 function test_file_open_114() {
2543   function on_resolve_success(root) {
2544     var file = createFileForParent(root);
2545     function on_openStream_error(err) {
2546       TestEngine.test("openStream()", (err.code == INVALID_VALUES_ERR));
2547       deleteFile(root, file);
2548     }
2549     function on_openStream_success(stream) {
2550       TestEngine.test("openStream()", false);
2551       stream.close();
2552       deleteFile(root, file);
2553     }
2554     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
2555     var stream = file.openStream(cb.successCallback, cb.errorCallback, "r", undefined);
2556   }
2557   resolve_root_location(on_resolve_success);
2558 }
2559
2560 // WAC-FILESYSTEM-115
2561 // Parameters: originFilePath = (empty) directory, overwrite = false
2562 // Result: Test passes.
2563 function test_file_copyTo_115() {
2564   function on_resolve_success(root) {
2565     var dir = createDirForParent(root);
2566     function on_copyTo_error(err) {
2567       TestEngine.test("copyTo() [" + err.code + "]", false);
2568       deleteDirectory(root, dir);
2569     }
2570     function on_copyTo_success(copy) {
2571       TestEngine.test("copyTo()", isDir(copy));
2572       deleteDirectory(root, copy);
2573       deleteDirectory(root, dir);
2574     }
2575     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2576     root.copyTo(cb.successCallback, cb.errorCallback, dir.fullPath, root.fullPath + "/" + getDirName(), false);
2577   }
2578   resolve_root_location(on_resolve_success);
2579 }
2580
2581 // WAC-FILESYSTEM-116
2582 // Parameters: originFilePath = (non-empty) directory, overwrite = false
2583 // Result: Test passes.
2584 function test_file_copyTo_116() {
2585   function on_resolve_success(root) {
2586     var dir = createDirForParent(root);
2587     var file = createFileForParent(dir);
2588     function on_copyTo_error(err) {
2589       TestEngine.test("copyTo() [" + err.code + "]", false);
2590       deleteDirectory(root, dir);
2591     }
2592     function on_copyTo_success(copy) {
2593       TestEngine.test("copyTo()", isDir(copy));
2594       var child = copy.resolve(file.name);
2595       TestEngine.test("copyTo()", isFile(child));
2596       deleteDirectory(root, copy);
2597       deleteDirectory(root, dir);
2598     }
2599     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2600     root.copyTo(cb.successCallback, cb.errorCallback, dir.fullPath, root.fullPath + "/" + getDirName(), false);
2601   }
2602   resolve_root_location(on_resolve_success);
2603 }
2604
2605 // WAC-FILESYSTEM-117
2606 // Parameters: originFilePath = undefined, other params = valid.
2607 // Result: INVALID_VALUES_ERR thrown via errorCallback.
2608 function test_file_copyTo_error_117() {
2609   function on_resolve_success(root) {
2610     function on_copyTo_error(err) {
2611       TestEngine.test("copyTo()", (err.code == INVALID_VALUES_ERR));
2612     }
2613     function on_copyTo_success(copy) {
2614       TestEngine.test("copyTo()", false);
2615       deleteDirectory(root, copy);
2616     }
2617     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2618     root.copyTo(cb.successCallback, cb.errorCallback, undefined, root.fullPath + "/" + getDirName(), false);
2619   }
2620   resolve_root_location(on_resolve_success);
2621 }
2622
2623 // WAC-FILESYSTEM-118
2624 // Parameters: originFilePath = invalid path, overwrite = false
2625 // Result: INVALID_VALUES_ERR returned by error callback.
2626 function test_file_copyTo_error_118() {
2627   function on_resolve_success(root) {
2628    function on_copyTo_error(err) {
2629      TestEngine.test("copyTo() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
2630    }
2631    function on_copyTo_success(copy) {
2632      TestEngine.test("copyTo()", false);
2633      deleteDirectory(root, copy);
2634    }
2635    var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2636    root.copyTo(cb.successCallback, cb.errorCallback, "../", root.fullPath + "/" + getDirName(), false);
2637   }
2638   resolve_root_location(on_resolve_success);
2639 }
2640
2641 // WAC-FILESYSTEM-119
2642 // Parameters: originFilePath = valid file, destinationFilePath = valid directory, overwrite = true
2643 // Result: Test passes (replacing destination directory with a origin file).
2644 function test_file_copyTo_119() {
2645   function on_resolve_success(root) {
2646     var file = createFileForParent(root);
2647     var dir = createDirForParent(root);
2648     function on_copyTo_error(err) {
2649       TestEngine.test("copyTo() [" + err.code + "]", false);
2650       deleteDirectory(root, dir);
2651       deleteFile(root, file);
2652     }
2653     function on_copyTo_success(copy) {
2654       TestEngine.test("copyTo()", (copy.fullPath == dir.fullPath) && isFile(copy));
2655       deleteFile(root, copy);
2656       deleteFile(root, file);
2657     }
2658     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2659     root.copyTo(cb.successCallback, cb.errorCallback, file.fullPath, dir.fullPath, true);
2660   }
2661   resolve_root_location(on_resolve_success);
2662 }
2663
2664 // WAC-FILESYSTEM-120
2665 // Parameters: originFilePath = valid file, destinationFilePath = valid directory, overwrite = false
2666 // Result: IO_ERR passed via error callback.
2667 function test_file_copyTo_error_120() {
2668   function on_resolve_success(root) {
2669    var file = createFileForParent(root);
2670    var dir = createDirForParent(root);
2671    function on_copyTo_error(err) {
2672      TestEngine.test("copyTo() [" + err.code + "]", (err.code == IO_ERR));
2673      deleteDirectory(root, dir);
2674      deleteFile(root, file);
2675    }
2676    function on_copyTo_success(copy) {
2677      TestEngine.test("copyTo()", false);
2678      deleteFile(root, copy);
2679      deleteFile(root, file);
2680    }
2681    var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2682    root.copyTo(cb.successCallback, cb.errorCallback, file.fullPath, dir.fullPath, false);
2683   }
2684   resolve_root_location(on_resolve_success);
2685 }
2686
2687 // WAC-FILESYSTEM-121
2688 // Parameters: originFilePath = valid directory, destinationFilePath = valid file, overwrite = true
2689 // Result: Test passes (replacing destination file with a origin directory).
2690 function test_file_copyTo_121() {
2691   function on_resolve_success(root) {
2692    var file = createFileForParent(root);
2693    var dir = createDirForParent(root);
2694    var child = createFileForParent(dir);
2695    function on_copyTo_error(err) {
2696      TestEngine.test("copyTo() [" + err.code + "]", false);
2697      deleteDirectory(root, dir);
2698      deleteFile(root, file);
2699    }
2700    function on_copyTo_success(copy) {
2701      TestEngine.test("copyTo()", (copy.fullPath == file.fullPath) && isDir(copy));
2702      TestEngine.test("resolve()", isFile(copy.resolve(child.name)));
2703      deleteDirectory(root, copy);
2704      deleteDirectory(root, dir);
2705    }
2706    var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2707    root.copyTo(cb.successCallback, cb.errorCallback, dir.fullPath, file.fullPath, true);
2708   }
2709   resolve_root_location(on_resolve_success);
2710 }
2711
2712 // WAC-FILESYSTEM-122
2713 // Parameters: originFilePath = valid directory, destinationFilePath = valid file, overwrite = false
2714 // Result: IO_ERR passed via error callback.
2715 function test_file_copyTo_error_122() {
2716   function on_resolve_success(root) {
2717     var file = createFileForParent(root);
2718     var dir = createDirForParent(root);
2719     function on_copyTo_error(err) {
2720       TestEngine.test("copyTo() [" + err.code + "]", (err.code == IO_ERR));
2721       deleteDirectory(root, dir);
2722       deleteFile(root, file);
2723     }
2724     function on_copyTo_success(copy) {
2725       TestEngine.test("copyTo()", false);
2726       deleteDirectory(root, copy);
2727       deleteDirectory(root, dir);
2728     }
2729     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2730     root.copyTo(cb.successCallback, cb.errorCallback, dir.fullPath, file.fullPath, false);
2731   }
2732   resolve_root_location(on_resolve_success);
2733 }
2734
2735 // WAC-FILESYSTEM-123
2736 // Parameters: originFilePath = valid directory, destinationFilePath = valid directory, overwrite = true
2737 // Result: Test passes (replacing destination directory with a origin directory).
2738 function test_file_copyTo_123() {
2739   function on_resolve_success(root) {
2740     var src = createDirForParent(root);
2741     var dest = createDirForParent(root);
2742     var child = createFileForParent(src);
2743     function on_copyTo_error(err) {
2744       TestEngine.test("copyTo() [" + err.code + "]", false);
2745       deleteDirectory(root, src);
2746       deleteDirectory(root, dest);
2747     }
2748     function on_copyTo_success(copy) {
2749       TestEngine.test("copyTo()", (copy.fullPath == dest.fullPath) && isDir(copy));
2750       TestEngine.test("resolve()", isFile(copy.resolve(child.name)));
2751       deleteDirectory(root, copy);
2752       deleteDirectory(root, src);
2753     }
2754     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2755     root.copyTo(cb.successCallback, cb.errorCallback, src.fullPath, dest.fullPath, true);
2756   }
2757   resolve_root_location(on_resolve_success);
2758 }
2759
2760 // WAC-FILESYSTEM-124
2761 // Parameters: originFilePath = valid directory, destinationFilePath = valid directory, overwrite = false
2762 // Result: IO_ERR passed via error callback.
2763 function test_file_copyTo_error_124() {
2764   function on_resolve_success(root) {
2765     var src = createDirForParent(root);
2766     var dest = createDirForParent(root);
2767     function on_copyTo_error(err) {
2768      TestEngine.test("copyTo() [" + err.code + "]", (err.code == IO_ERR));
2769      deleteDirectory(root, src);
2770      deleteDirectory(root, dest);
2771     }
2772     function on_copyTo_success(copy) {
2773      TestEngine.test("copyTo()", false);
2774      deleteDirectory(root, copy);
2775      deleteDirectory(root, src);
2776     }
2777     var cb = TestEngine.registerCallback("copyTo", on_copyTo_success, on_copyTo_error);
2778     root.copyTo(cb.successCallback, cb.errorCallback, src.fullPath, dest.fullPath, false);
2779   }
2780   resolve_root_location(on_resolve_success);
2781 }
2782
2783 // WAC-FILESYSTEM-125
2784 // Parameters: originFilePath = (empty) directory, overwrite = false
2785 // Result: Test passes.
2786 function test_file_moveTo_125() {
2787   function on_resolve_success(root) {
2788     var src = createDirForParent(root);
2789     var dest = root.fullPath + "/" + getDirName();
2790     function on_moveTo_error(err) {
2791       TestEngine.test("moveTo() [" + err.code + "]", false);
2792       deleteDirectory(root, src);
2793     }
2794     function on_moveTo_success(result) {
2795       TestEngine.test("moveTo()", isDir(result));
2796       TestEngine.testPresetError(
2797         "resolve() [NOT_FOUND_ERR]",
2798         function() { root.resolve(src.name) },
2799         NOT_FOUND_ERR
2800       );
2801       deleteDirectory(root, result);
2802     }
2803     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
2804     root.moveTo(cb.successCallback, cb.errorCallback, src.fullPath, dest, false);
2805   }
2806   resolve_root_location(on_resolve_success);
2807 }
2808
2809 // WAC-FILESYSTEM-126
2810 // Parameters: originFilePath = (non-empty) directory, overwrite = false
2811 // Result: Test passes.
2812 function test_file_moveTo_126() {
2813   function on_resolve_success(root) {
2814     var src = createDirForParent(root);
2815     var file = createFileForParent(src);
2816     var dest = root.fullPath + "/" + getDirName();
2817     function on_moveTo_error(err) {
2818       TestEngine.test("moveTo() [" + err.code + "]", false);
2819       deleteDirectory(root, src);
2820     }
2821     function on_moveTo_success(result) {
2822       TestEngine.test("moveTo()", isDir(result));
2823       var child = result.resolve(file.name);
2824       TestEngine.test("resolve()", isFile(child));
2825       TestEngine.testPresetError(
2826         "resolve() [NOT_FOUND_ERR]",
2827         function() { root.resolve(src.name) },
2828         NOT_FOUND_ERR
2829       );
2830       deleteDirectory(root, result);
2831     }
2832     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
2833     root.moveTo(cb.successCallback, cb.errorCallback, src.fullPath, dest, false);
2834   }
2835   resolve_root_location(on_resolve_success);
2836 }
2837
2838 // WAC-FILESYSTEM-127
2839 // Parameters: originFilePath = undefined, other params = valid.
2840 // Result: INVALID_VALUES_ERR thrown via errorCallback.
2841 function test_file_moveTo_error_127() {
2842   function on_resolve_success(root) {
2843     var dest = root.fullPath + "/" + getDirName();
2844     function on_moveTo_error(err) {
2845       TestEngine.test("moveTo()", (err.code == INVALID_VALUES_ERR));
2846     }
2847     function on_moveTo_success(result) {
2848       TestEngine.test("moveTo()", false);
2849     }
2850     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
2851     root.moveTo(cb.successCallback, cb.errorCallback, undefined, dest, false);
2852   }
2853   resolve_root_location(on_resolve_success);
2854 }
2855
2856 // WAC-FILESYSTEM-128
2857 // Parameters: originFilePath = invalid path, overwrite = false
2858 // Result: INVALID_VALUES_ERR returned by error callback.
2859 function test_file_moveTo_error_128() {
2860   function on_resolve_success(root) {
2861     var src = "../";
2862     var dest = root.fullPath + "/" + getDirName();
2863     function on_moveTo_error(err) {
2864       TestEngine.test("moveTo() [" + err.code + "]", (err.code == INVALID_VALUES_ERR));
2865     }
2866     function on_moveTo_success(result) {
2867       TestEngine.test("moveTo()", false);
2868     }
2869     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
2870     root.moveTo(cb.successCallback, cb.errorCallback, src, dest, false);
2871   }
2872   resolve_root_location(on_resolve_success);
2873 }
2874
2875 // WAC-FILESYSTEM-129
2876 // Parameters: originFilePath = valid file, destinationFilePath = valid directory, overwrite = true
2877 // Result: IO_ERR passed via error callback.
2878 function test_file_moveTo_129() {
2879   function on_resolve_success(root) {
2880     var src = createFileForParent(root);
2881     var dest = createDirForParent(root);
2882     function on_moveTo_error(err) {
2883       TestEngine.test("moveTo() [" + err.code + "]", (err.code == IO_ERR));
2884       deleteFile(root, src);
2885       deleteDirectory(root, dest);
2886     }
2887     function on_moveTo_success(result) {
2888       TestEngine.test("moveTo()", false);
2889       deleteFile(root, result);
2890     }
2891     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
2892     root.moveTo(cb.successCallback, cb.errorCallback, src.fullPath, dest.fullPath, true);
2893   }
2894   resolve_root_location(on_resolve_success);
2895 }
2896
2897 // WAC-FILESYSTEM-130
2898 // Parameters: originFilePath = valid file, destinationFilePath = valid directory, overwrite = false
2899 // Result: IO_ERR passed via error callback.
2900 function test_file_moveTo_error_130() {
2901   function on_resolve_success(root) {
2902     var src = createFileForParent(root);
2903     var dest = createDirForParent(root);
2904     function on_moveTo_error(err) {
2905       TestEngine.test("moveTo() [" + err.code + "]", (err.code == IO_ERR));
2906       deleteFile(root, src);
2907       deleteDirectory(root, dest);
2908     }
2909     function on_moveTo_success(result) {
2910       TestEngine.test("moveTo()", false);
2911       deleteFile(root, result);
2912     }
2913     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
2914     root.moveTo(cb.successCallback, cb.errorCallback, src.fullPath, dest.fullPath, false);
2915   }
2916   resolve_root_location(on_resolve_success);
2917 }
2918
2919 // WAC-FILESYSTEM-131
2920 // Parameters: originFilePath = valid directory, destinationFilePath = valid file, overwrite = true
2921 // Result: IO_ERR passed via error callback.
2922 function test_file_moveTo_131() {
2923   function on_resolve_success(root) {
2924     var src = createDirForParent(root);
2925     var child = createFileForParent(src);
2926     var dest = createFileForParent(root);
2927     function on_moveTo_error(err) {
2928       TestEngine.test("moveTo() [" + err.code + "]", (err.code == IO_ERR));
2929       deleteDirectory(root, src);
2930       deleteFile(root, dest);
2931     }
2932     function on_moveTo_success(result) {
2933       TestEngine.test("moveTo()", false);
2934       deleteFile(root, result);
2935     }
2936     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
2937     root.moveTo(cb.successCallback, cb.errorCallback, src.fullPath, dest.fullPath, true);
2938   }
2939   resolve_root_location(on_resolve_success);
2940 }
2941
2942 // WAC-FILESYSTEM-132
2943 // Parameters: originFilePath = valid directory, destinationFilePath = valid file, overwrite = false
2944 // Result: IO_ERR passed via error callback.
2945 function test_file_moveTo_error_132() {
2946   function on_resolve_success(root) {
2947     var src = createDirForParent(root);
2948     var child = createFileForParent(src);
2949     var dest = createFileForParent(root);
2950     function on_moveTo_error(err) {
2951       TestEngine.test("moveTo() [" + err.code + "]", (err.code == IO_ERR));
2952       deleteDirectory(root, src);
2953       deleteFile(root, dest);
2954     }
2955     function on_moveTo_success(result) {
2956       TestEngine.test("moveTo()", false);
2957       deleteDirectory(root, result);
2958     }
2959     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
2960     root.moveTo(cb.successCallback, cb.errorCallback, src.fullPath, dest.fullPath, false);
2961   }
2962   resolve_root_location(on_resolve_success);
2963 }
2964
2965 // WAC-FILESYSTEM-133
2966 // Parameters: originFilePath = valid directory, destinationFilePath = valid directory, overwrite = true
2967 // Result: Test passes (replacing destination directory with a origin directory).
2968 function test_file_moveTo_133() {
2969   function on_resolve_success(root) {
2970     var src = createDirForParent(root);
2971     var child = createFileForParent(src);
2972     var dest = createDirForParent(root);
2973     function on_moveTo_error(err) {
2974       TestEngine.test("moveTo() [" + err.code + "]", false);
2975       deleteDirectory(root, src);
2976       deleteDirectory(root, dest);
2977     }
2978     function on_moveTo_success(result) {
2979       TestEngine.test("moveTo()", (result.fullPath == dest.fullPath) && isDir(result));
2980       TestEngine.test("resolve()", isFile(result.resolve(child.name)));
2981       TestEngine.testPresetError(
2982         "resolve() [NOT_FOUND_ERR]",
2983         function() { root.resolve(src.name); },
2984         NOT_FOUND_ERR
2985       );
2986       deleteDirectory(root, result);
2987     }
2988     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
2989     root.moveTo(cb.successCallback, cb.errorCallback, src.fullPath, dest.fullPath, true);
2990   }
2991   resolve_root_location(on_resolve_success);
2992 }
2993
2994 // WAC-FILESYSTEM-134
2995 // Parameters: originFilePath = valid directory, destinationFilePath = valid directory, overwrite = false
2996 // Result: IO_ERR passed via error callback.
2997 function test_file_moveTo_error_134() {
2998   function on_resolve_success(root) {
2999     var src = createDirForParent(root);
3000     var child = createFileForParent(src);
3001     var dest = createDirForParent(root);
3002     function on_moveTo_error(err) {
3003       TestEngine.test("moveTo() [" + err.code + "]", (err.code == IO_ERR));
3004       deleteDirectory(root, src);
3005       deleteDirectory(root, dest);
3006     }
3007     function on_moveTo_success(result) {
3008       TestEngine.test("moveTo()", false);
3009       deleteDirectory(root, result);
3010     }
3011     var cb = TestEngine.registerCallback("moveTo", on_moveTo_success, on_moveTo_error);
3012     root.moveTo(cb.successCallback, cb.errorCallback, src.fullPath, dest.fullPath, false);
3013   }
3014   resolve_root_location(on_resolve_success);
3015 }
3016
3017 // WAC-FILESYSTEM-135
3018 // Parameters: filePath = valid path to an existing file
3019 // Result: Test passes.
3020 function test_file_resolve_135() {
3021   function on_resolve_success(root) {
3022     var file = createFileForParent(root);
3023     var resolved = root.resolve(file.name);
3024     TestEngine.test("resolve()", isFile(resolved) && (file.fullPath == resolved.fullPath));
3025     deleteFile(root, file);
3026   }
3027   resolve_root_location(on_resolve_success);
3028 }
3029
3030 // WAC-FILESYSTEM-136
3031 // Parameters: filePath = valid path to non-existing file
3032 // Result: NOT_FOUND_ERR thrown in place.
3033 function test_file_resolve_error_136() {
3034   function on_resolve_success(root) {
3035     var fileNotExist = getFileName();
3036     TestEngine.testPresetError(
3037       "resolve() [NOT_FOUND_ERR]",
3038       function() { root.resolve(fileNotExist); },
3039       NOT_FOUND_ERR
3040     );
3041   }
3042   resolve_root_location(on_resolve_success);
3043 }
3044
3045 // WAC-FILESYSTEM-137
3046 // Parameters: filePath = invalid path
3047 // Result: NOT_FOUND_ERR thrown in place.
3048 function test_file_resolve_error_137() {
3049   function on_resolve_success(root) {
3050    var invalidPath = "../";
3051    TestEngine.testPresetError(
3052      "resolve() [INVALID_VALUES_ERR]",
3053      function() { root.resolve(invalidPath); },
3054      INVALID_VALUES_ERR
3055    );
3056   }
3057   resolve_root_location(on_resolve_success);
3058 }
3059
3060 // WAC-FILESYSTEM-138: Open file in append mode and test append mode.
3061 function test_file_append_behaviour_138() {
3062   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
3063   function on_resolve_success(file) {
3064     var file2 = file.createFile(getFileName());
3065     TestEngine.test("createFile()", isFile(file2));
3066     function on_openStream_success(stream) {
3067       function on_openStream_success2(stream) {
3068         function on_openStream_success3(stream) {
3069             var array = stream.readBytes(4);
3070             TestEngine.test("readBytes(4)", array.length === 4);
3071             TestEngine.test("array[0]", array[0] === 1);
3072             TestEngine.test("array[1]", array[1] === 2);
3073             TestEngine.test("array[2]", array[2] === 3);
3074             TestEngine.test("array[3]", array[3] === 4);
3075             stream.close();
3076             deleteFile(file, file2);
3077         }
3078         TestEngine.test("openStream()", isFilestream(stream));
3079         stream.writeBytes([3, 4]);
3080         stream.close();
3081         //reopen in read mode
3082         var cb = TestEngine.registerCallback("openStream", on_openStream_success3, on_openStream_error);
3083         file2.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
3084       }
3085       TestEngine.test("openStream()", isFilestream(stream));
3086       stream.writeBytes([1, 2]);
3087       stream.close();
3088       //reopen again in append mode
3089       var cb = TestEngine.registerCallback("openStream", on_openStream_success2, on_openStream_error);
3090       file2.openStream(cb.successCallback, cb.errorCallback, "a", "UTF-8");
3091     }
3092     function on_openStream_error(err) {
3093       TestEngine.test("openStream() [" + err.code + "]", false);
3094     }
3095     var cb = TestEngine.registerCallback("openStream", on_openStream_success, on_openStream_error);
3096     file2.openStream(cb.successCallback, cb.errorCallback, "a", "UTF-8");
3097   }
3098   resolve_root(on_resolve_success, on_resolve_error);
3099 }
3100
3101 // WAC-FILESYSTEM-139: Set postion.
3102 function test_file_set_position_139() {
3103   function on_resolve_error(err) {
3104       TestEngine.test("resolve() [" + err.code + "]", false);
3105   }
3106   function on_resolve_success(file) {
3107     function on_openStream_success(stream) {
3108       function on_openStream_success2(stream) {
3109         TestEngine.test("Correct postion after opening",
3110             stream.position === 0);
3111         var array = stream.readBytes(5);
3112         TestEngine.test("Correct number of bytes read", array.length === 4);
3113         TestEngine.test("Correct values of bytes read", array[0] === 5 &&
3114             array[1] === 6 && array[2] === 7 && array[3] === 8);
3115         stream.position = 2;
3116         array = stream.readBytes(1);
3117         TestEngine.test("Correct values of bytes read at pos 2",
3118             array.length === 1 && array[0] === 7);
3119         stream.position = 1;
3120         array = stream.readBytes(1);
3121         TestEngine.test("Correct values of bytes read at pos 1",
3122             array.length === 1 && array[0] === 6);
3123         stream.position = 0;
3124         array = stream.readBytes(1);
3125         TestEngine.test("Correct values of bytes read at pos 0",
3126             array.length === 1 && array[0] === 5);
3127         stream.position = 3;
3128         array = stream.readBytes(1);
3129         TestEngine.test("Correct values of bytes read at pos 3",
3130             array.length === 1 && array[0] === 8);
3131         stream.close();
3132         deleteFile(file, file2);
3133       }
3134       TestEngine.test("openStream()", isFilestream(stream));
3135       TestEngine.test("Correct postion after opening",
3136           stream.position === 0);
3137       stream.writeBytes([1, 2, 3, 4]);
3138       TestEngine.test("Correct postion after write ", stream.position === 4);
3139       stream.position = 0;
3140       TestEngine.test("Correct postion after setting postion",
3141           stream.position === 0);
3142       stream.writeBytes([5, 6, 7, 8]);
3143       stream.close();
3144       var cb = TestEngine.registerCallback("openStream",
3145           on_openStream_success2, on_openStream_error);
3146       file2.openStream(cb.successCallback, cb.errorCallback, "r", "UTF-8");
3147     }
3148     function on_openStream_error(err) {
3149       TestEngine.test("openStream() [" + err.code + "]", false);
3150     }
3151     var file2 = file.createFile(getFileName());
3152     TestEngine.test("createFile()", isFile(file2));
3153     var cb = TestEngine.registerCallback("openStream",
3154         on_openStream_success, on_openStream_error);
3155     file2.openStream(cb.successCallback, cb.errorCallback, "w", "UTF-8");
3156   }
3157   resolve_root(on_resolve_success, on_resolve_error);
3158 }
3159
3160 // WAC2-FILESYSTEM-140: Resolve wgt-package in rw mode.
3161 // Result: UNKNOWN_ERR thrown via error callback.
3162 function test_filesystem_resolve_error_140() {
3163   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", (err.code == UNKNOWN_ERR)); }
3164   function on_resolve_success(file) { TestEngine.test("resolve()", false);}
3165   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
3166   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, 'wgt-package', 'rw');
3167 }
3168
3169 // WAC2-FILESYSTEM-141: Resolve wgt-package/config.xml in rw mode.
3170 // Result: UNKNOWN_ERR thrown via error callback.
3171 function test_filesystem_resolve_error_141() {
3172   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", (err.code == UNKNOWN_ERR)); }
3173   function on_resolve_success(file) { TestEngine.test("resolve()", false);}
3174   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
3175   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, 'wgt-package/config.xml', 'rw');
3176 }
3177
3178 // WAC2-FILESYSTEM-142: Resolve wgt-package in r mode.
3179 // Result: Success.
3180 function test_filesystem_resolve_142() {
3181   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
3182   function on_resolve_success(file) { TestEngine.test("resolve()", isFileObject(file));}
3183   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
3184   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, 'wgt-package', 'r');
3185 }
3186
3187 // WAC2-FILESYSTEM-143: Resolve wgt-package/config.xml in r mode.
3188 // Result: Success.
3189 function test_filesystem_resolve_143() {
3190   function on_resolve_error(err) { TestEngine.test("resolve() [" + err.code + "]", false); }
3191   function on_resolve_success(file) { TestEngine.test("resolve()", isFileObject(file));}
3192   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
3193   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, 'wgt-package/config.xml', 'r');
3194 }
3195
3196 //=============================================================================
3197 TestEngine.setTestSuiteName("[WAC2.0][Filesystem]");
3198 //TestEngine.addTest(true, test_filesystem_properties_001, "WAC-FILESYSTEM-001");
3199 //TestEngine.addTest(true, test_filesystem_resolve_002, "WAC-FILESYSTEM-002");
3200 //TestEngine.addTest(true, test_filesystem_resolve_003, "WAC-FILESYSTEM-003");
3201 //TestEngine.addTest(true, test_file_listFiles_004, "WAC-FILESYSTEM-004");
3202 //TestEngine.addTest(true, test_file_open_005, "WAC-FILESYSTEM-005");
3203 //TestEngine.addTest(true, test_file_open_006, "WAC-FILESYSTEM-006");
3204 //TestEngine.addTest(true, test_file_open_007, "WAC-FILESYSTEM-007");
3205 //TestEngine.addTest(true, test_file_open_error_008, "WAC-FILESYSTEM-008");
3206 //TestEngine.addTest(true, test_file_open_error_009, "WAC-FILESYSTEM-009");
3207 //TestEngine.addTest(true, test_file_copyTo_010, "WAC-FILESYSTEM-010");
3208 //TestEngine.addTest(true, test_file_copyTo_error_011, "WAC-FILESYSTEM-011");
3209 //TestEngine.addTest(true, test_file_copyTo_012, "WAC-FILESYSTEM-012");
3210 //TestEngine.addTest(true, test_file_createFile_013, "WAC-FILESYSTEM-013");
3211 //TestEngine.addTest(true, test_file_createFile_error_014, "WAC-FILESYSTEM-014");
3212 //TestEngine.addTest(true, test_file_createFile_error_015, "WAC-FILESYSTEM-015");
3213 //TestEngine.addTest(true, test_file_createFile_error_016, "WAC-FILESYSTEM-016");
3214 //TestEngine.addTest(true, test_file_createFile_error_017, "WAC-FILESYSTEM-017");
3215 //TestEngine.addTest(true, test_file_createDirectory_018, "WAC-FILESYSTEM-018");
3216 //TestEngine.addTest(true, test_file_createDirectory_error_019, "WAC-FILESYSTEM-019");
3217 //TestEngine.addTest(true, test_file_createDirectory_error_020, "WAC-FILESYSTEM-020");
3218 //TestEngine.addTest(true, test_file_createDirectory_error_021, "WAC-FILESYSTEM-021");
3219 //TestEngine.addTest(true, test_file_createDirectory_error_022, "WAC-FILESYSTEM-022");
3220 //TestEngine.addTest(true, test_file_moveTo_023, "WAC-FILESYSTEM-023");
3221 //TestEngine.addTest(true, test_file_moveTo_error_024, "WAC-FILESYSTEM-024");
3222 //TestEngine.addTest(true, test_file_moveTo_025, "WAC-FILESYSTEM-025");
3223 //TestEngine.addTest(true, test_file_deleteFile_026, "WAC-FILESYSTEM-026");
3224 //TestEngine.addTest(true, test_file_deleteFile_error_027, "WAC-FILESYSTEM-027");
3225 //TestEngine.addTest(true, test_file_deleteFile_error_028, "WAC-FILESYSTEM-028");
3226 //TestEngine.addTest(true, test_file_deleteFile_error_029, "WAC-FILESYSTEM-029");
3227 //TestEngine.addTest(true, test_file_deleteFile_error_030, "WAC-FILESYSTEM-030");
3228 //TestEngine.addTest(true, test_file_deleteDirectory_031, "WAC-FILESYSTEM-031");
3229 //TestEngine.addTest(true, test_file_deleteDirectory_error_032, "WAC-FILESYSTEM-032");
3230 //TestEngine.addTest(true, test_file_deleteDirectory_error_033, "WAC-FILESYSTEM-033");
3231 //TestEngine.addTest(true, test_file_deleteDirectory_error_034, "WAC-FILESYSTEM-034");
3232 //TestEngine.addTest(true, test_filestream_write_read_035, "WAC-FILESYSTEM-035");
3233 TestEngine.addTest(true, test_filestream_read_error_036, "WAC-FILESYSTEM-036");
3234 //TestEngine.addTest(true, test_filestream_read_error_037, "WAC-FILESYSTEM-037");
3235 //TestEngine.addTest(true, test_file_open_error_038, "WAC-FILESYSTEM-038");
3236 //TestEngine.addTest(true, test_filestream_read_error_040, "WAC-FILESYSTEM-040");
3237 //TestEngine.addTest(true, test_filestream_write_error_041, "WAC-FILESYSTEM-041");
3238 //TestEngine.addTest(true, test_filestream_write_error_042, "WAC-FILESYSTEM-042");
3239 //TestEngine.addTest(true, test_filestream_write_error_043, "WAC-FILESYSTEM-043");
3240 //TestEngine.addTest(true, test_filestream_write_error_044, "WAC-FILESYSTEM-044");
3241 //TestEngine.addTest(true, test_filestream_read_error_045, "WAC-FILESYSTEM-045");
3242 //TestEngine.addTest(true, test_filestream_read_error_046, "WAC-FILESYSTEM-046");
3243 //TestEngine.addTest(true, test_filestream_writeBytes_readBytes_047, "WAC-FILESYSTEM-047");
3244 //TestEngine.addTest(true, test_filestream_readBytes_error_048, "WAC-FILESYSTEM-048");
3245 //TestEngine.addTest(true, test_filestream_readBytes_error_049, "WAC-FILESYSTEM-049");
3246 //TestEngine.addTest(true, test_filestream_readBytes_error_051, "WAC-FILESYSTEM-051");
3247 //TestEngine.addTest(true, test_filestream_readBytes_error_052, "WAC-FILESYSTEM-052");
3248 //TestEngine.addTest(true, test_filestream_readBytes_error_053, "WAC-FILESYSTEM-053");
3249 //TestEngine.addTest(true, test_filestream_writeBytes_error_054, "WAC-FILESYSTEM-054");
3250 //TestEngine.addTest(true, test_filestream_writeBytes_error_055, "WAC-FILESYSTEM-055");
3251 //TestEngine.addTest(true, test_filestream_writeBytes_error_056, "WAC-FILESYSTEM-056");
3252 //TestEngine.addTest(true, test_filestream_writeBytes_057, "WAC-FILESYSTEM-057");
3253 //TestEngine.addTest(true, test_filestream_writeBase64_readBase64_058, "WAC-FILESYSTEM-058");
3254 //TestEngine.addTest(true, test_filestream_writeBase64_read_059, "WAC-FILESYSTEM-059");
3255 //TestEngine.addTest(true, test_filestream_write_readBase64_060, "WAC-FILESYSTEM-060");
3256 //TestEngine.addTest(true, test_filestream_readBase64_error_061, "WAC-FILESYSTEM-061");
3257 //TestEngine.addTest(true, test_filestream_readBase64_error_062, "WAC-FILESYSTEM-062");
3258 //TestEngine.addTest(true, test_filestream_readBase64_error_064, "WAC-FILESYSTEM-064");
3259 //TestEngine.addTest(true, test_filestream_readBase64_error_065, "WAC-FILESYSTEM-065");
3260 //TestEngine.addTest(true, test_filestream_readBase64_error_066, "WAC-FILESYSTEM-066");
3261 //TestEngine.addTest(true, test_filestream_writeBase64_error_067, "WAC-FILESYSTEM-067");
3262 //TestEngine.addTest(true, test_filestream_writeBase64_error_068, "WAC-FILESYSTEM-068");
3263 //TestEngine.addTest(true, test_filestream_writeBase64_error_069, "WAC-FILESYSTEM-069");
3264 //TestEngine.addTest(true, test_filestream_writeBase64_error_070, "WAC-FILESYSTEM-070");
3265 //TestEngine.addTest(true, test_file_createFile_error_071, "WAC-FILESYSTEM-071");
3266 //TestEngine.addTest(true, test_file_deleteFile_error_072, "WAC-FILESYSTEM-072");
3267 //TestEngine.addTest(true, test_file_deleteDirectory_error_073, "WAC-FILESYSTEM-073");
3268 //TestEngine.addTest(true, test_file_moveTo_error_074, "WAC-FILESYSTEM-074");
3269 //TestEngine.addTest(true, test_file_openStream_error_075, "WAC-FILESYSTEM-075");
3270 //TestEngine.addTest(true, test_file_readAsText_076, "WAC-FILESYSTEM-076");
3271 //TestEngine.addTest(true, test_file_readAsText_error_077, "WAC-FILESYSTEM-077");
3272 //TestEngine.addTest(true, test_file_readAsText_error_078, "WAC-FILESYSTEM-078");
3273 //TestEngine.addTest(true, test_file_toUri_079, "WAC-FILESYSTEM-079");
3274 //TestEngine.addTest(true, test_filesystem_resolve_080, "WAC-FILESYSTEM-080");
3275 //TestEngine.addTest(true, test_file_listFiles_081, "WAC-FILESYSTEM-081");
3276 //TestEngine.addTest(true, test_file_listFiles_082, "WAC-FILESYSTEM-082");
3277 //TestEngine.addTest(true, test_file_listFiles_error_083, "WAC-FILESYSTEM-083");
3278 //TestEngine.addTest(true, test_file_listFiles_error_084, "WAC-FILESYSTEM-084");
3279 //TestEngine.addTest(true, test_file_listFiles_error_085, "WAC-FILESYSTEM-085");
3280 //TestEngine.addTest(true, test_file_listFiles_error_086, "WAC-FILESYSTEM-086");
3281 //TestEngine.addTest(true, test_file_open_087, "WAC-FILESYSTEM-087");
3282 //TestEngine.addTest(true, test_file_open_error_088, "WAC-FILESYSTEM-088");
3283 //TestEngine.addTest(true, test_file_open_error_089, "WAC-FILESYSTEM-089");
3284 //TestEngine.addTest(true, test_file_open_error_090, "WAC-FILESYSTEM-090");
3285 //TestEngine.addTest(true, test_file_readAsText_091, "WAC-FILESYSTEM-091");
3286 //TestEngine.addTest(true, test_file_readAsText_092, "WAC-FILESYSTEM-092");
3287 //TestEngine.addTest(true, test_file_readAsText_093, "WAC-FILESYSTEM-093");
3288 //TestEngine.addTest(true, test_file_readAsText_094, "WAC-FILESYSTEM-094");
3289 //TestEngine.addTest(true, test_file_readAsText_error_095, "WAC-FILESYSTEM-095");
3290 //TestEngine.addTest(true, test_file_readAsText_error_096, "WAC-FILESYSTEM-096");
3291 //TestEngine.addTest(true, test_file_readAsText_error_097, "WAC-FILESYSTEM-097");
3292 //TestEngine.addTest(true, test_file_readAsText_error_098, "WAC-FILESYSTEM-098");
3293 //TestEngine.addTest(true, test_file_deleteDirectory_099, "WAC-FILESYSTEM-099");
3294 //TestEngine.addTest(true, test_file_deleteDirectory_error_100, "WAC-FILESYSTEM-100");
3295 //TestEngine.addTest(true, test_file_deleteDirectory_error_101, "WAC-FILESYSTEM-101");
3296 //TestEngine.addTest(true, test_file_deleteDirectory_error_102, "WAC-FILESYSTEM-102");
3297 //TestEngine.addTest(true, test_file_deleteDirectory_error_103, "WAC-FILESYSTEM-103");
3298 //TestEngine.addTest(true, test_file_deleteDirectory_error_104, "WAC-FILESYSTEM-104");
3299 //TestEngine.addTest(true, test_file_deleteDirectory_error_105, "WAC-FILESYSTEM-105");
3300 //TestEngine.addTest(true, test_file_deleteFile_106, "WAC-FILESYSTEM-106");
3301 //TestEngine.addTest(true, test_file_deleteFile_error_107, "WAC-FILESYSTEM-107");
3302 //TestEngine.addTest(true, test_file_deleteFile_error_108, "WAC-FILESYSTEM-108");
3303 //TestEngine.addTest(true, test_file_deleteFile_error_109, "WAC-FILESYSTEM-109");
3304 //TestEngine.addTest(true, test_file_deleteFile_error_110, "WAC-FILESYSTEM-110");
3305 //TestEngine.addTest(true, test_file_deleteFile_error_111, "WAC-FILESYSTEM-111");
3306 //TestEngine.addTest(true, test_filesystem_resolve_112, "WAC-FILESYSTEM-112");
3307 //TestEngine.addTest(true, test_file_readAsText_113, "WAC-FILESYSTEM-113");
3308 //TestEngine.addTest(true, test_file_open_114, "WAC-FILESYSTEM-114");
3309 //TestEngine.addTest(true, test_file_copyTo_115, "WAC-FILESYSTEM-115");
3310 //TestEngine.addTest(true, test_file_copyTo_116, "WAC-FILESYSTEM-116");
3311 //TestEngine.addTest(true, test_file_copyTo_error_117, "WAC-FILESYSTEM-117");
3312 //TestEngine.addTest(true, test_file_copyTo_error_118, "WAC-FILESYSTEM-118");
3313 //TestEngine.addTest(true, test_file_copyTo_119, "WAC-FILESYSTEM-119");
3314 //TestEngine.addTest(true, test_file_copyTo_error_120, "WAC-FILESYSTEM-120");
3315 //TestEngine.addTest(true, test_file_copyTo_121, "WAC-FILESYSTEM-121");
3316 //TestEngine.addTest(true, test_file_copyTo_error_122, "WAC-FILESYSTEM-122");
3317 //TestEngine.addTest(true, test_file_copyTo_123, "WAC-FILESYSTEM-123");
3318 //TestEngine.addTest(true, test_file_copyTo_error_124, "WAC-FILESYSTEM-124");
3319 //TestEngine.addTest(true, test_file_moveTo_125, "WAC-FILESYSTEM-125");
3320 //TestEngine.addTest(true, test_file_moveTo_126, "WAC-FILESYSTEM-126");
3321 //TestEngine.addTest(true, test_file_moveTo_error_127, "WAC-FILESYSTEM-127");
3322 //TestEngine.addTest(true, test_file_moveTo_error_128, "WAC-FILESYSTEM-128");
3323 //TestEngine.addTest(true, test_file_moveTo_129, "WAC-FILESYSTEM-129");
3324 //TestEngine.addTest(true, test_file_moveTo_error_130, "WAC-FILESYSTEM-130");
3325 //TestEngine.addTest(true, test_file_moveTo_131, "WAC-FILESYSTEM-131");
3326 //TestEngine.addTest(true, test_file_moveTo_error_132, "WAC-FILESYSTEM-132");
3327 //TestEngine.addTest(true, test_file_moveTo_133, "WAC-FILESYSTEM-133");
3328 //TestEngine.addTest(true, test_file_moveTo_error_134, "WAC-FILESYSTEM-134");
3329 //TestEngine.addTest(true, test_file_resolve_135, "WAC-FILESYSTEM-135");
3330 //TestEngine.addTest(true, test_file_resolve_error_136, "WAC-FILESYSTEM-136");
3331 //TestEngine.addTest(true, test_file_resolve_error_137, "WAC-FILESYSTEM-137");
3332 //TestEngine.addTest(true, test_file_append_behaviour_138, "WAC-FILESYSTEM-138");
3333 //TestEngine.addTest(true, test_file_set_position_139, "WAC-FILESYSTEM-139");
3334 //TestEngine.addTest(true, test_filesystem_resolve_error_140, "WAC-FILESYSTEM-140");
3335 //TestEngine.addTest(true, test_filesystem_resolve_error_141, "WAC-FILESYSTEM-141");
3336 //TestEngine.addTest(true, test_filesystem_resolve_142, "WAC-FILESYSTEM-142");
3337 //TestEngine.addTest(true, test_filesystem_resolve_143, "WAC-FILESYSTEM-143");
3338
3339 //=============================================================================
3340 // --------------------------| Utilities
3341
3342 function isFileObject(obj) {
3343   return (obj instanceof deviceapis.filesystem.File);
3344 }
3345
3346 function isFile(obj) {
3347   return (isFileObject(obj) && !obj.isDirectory);
3348 }
3349
3350 function isDir(obj) {
3351   return (isFileObject(obj) && obj.isDirectory);
3352 }
3353
3354 function isFilestream(obj) {
3355   return (obj instanceof deviceapis.filesystem.FileStream);
3356 }
3357
3358 function deleteDirectory(parent, dir) {
3359   function on_error(err) {
3360     TestEngine.test("deleteDirectory() [" + err.code + "]", false);
3361   }
3362   function on_success() {
3363     TestEngine.test("deleteDirectory()", true);
3364   }
3365   var cb = TestEngine.registerCallback("deleteDirectory", on_success, on_error);
3366   parent.deleteDirectory(cb.successCallback, cb.errorCallback, dir.fullPath, true);
3367 }
3368
3369 function deleteFile(parent, file) {
3370   function on_error(err) {
3371     TestEngine.test("deleteFile() [" + err.code + "]", false);
3372   }
3373   function on_success() {
3374     TestEngine.test("deleteFile()", true);
3375   }
3376   var cb = TestEngine.registerCallback("deleteFile", on_success, on_error);
3377   parent.deleteFile(cb.successCallback, cb.errorCallback, file.fullPath);
3378 }
3379
3380 // For common behaviour use resolve_root_location
3381 function resolve_root(on_success_callback, on_error_callback) {
3382   var cb = TestEngine.registerCallback("resolve", on_success_callback, on_error_callback);
3383   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION);
3384 }
3385
3386 function resolve_root_location(handler) {
3387   function on_resolve_error(err) {
3388     TestEngine.test("resolve() [" + err.code + "]", false);
3389   }
3390   function on_resolve_success(file) {
3391     TestEngine.test("resolve()", isFileObject(file));
3392     handler(file);
3393   }
3394   var cb = TestEngine.registerCallback("resolve", on_resolve_success, on_resolve_error);
3395   deviceapis.filesystem.resolve(cb.successCallback, cb.errorCallback, TEST_ROOT_LOCATION);
3396 }
3397
3398 var counter = 1;
3399
3400 function getFileName() {
3401   var nr = Math.floor(Math.random() * 1000);
3402   var date = new Date();
3403   return "test_wac20_filesystem_file_" + nr + "_" + (counter++) + "_"
3404          + date.getMinutes() + date.getSeconds() + date.getMilliseconds();
3405 }
3406
3407 function getDirName() {
3408   var nr = Math.floor(Math.random() * 1000);
3409   var date = new Date();
3410   return "test_wac20_filesystem_dir_" + nr + "_" + (counter++) + "_"
3411          + date.getMinutes() + date.getSeconds() + date.getMilliseconds();
3412 }
3413
3414 function createFileForParent(parent) {
3415   var result = parent.createFile(getFileName());
3416   TestEngine.test("createFile()", isFile(result));
3417   return result;
3418 }
3419
3420 function createDirForParent(parent) {
3421   var result = parent.createDirectory(getDirName());
3422   TestEngine.test("createDirectory()", isDir(result));
3423   return result;
3424 }
3425
3426 function testNoExceptionWithMessage(message, fun) {
3427   var testResult = true;
3428   try {
3429     fun();
3430   }
3431   catch (e) {
3432     testResult = false;
3433   }
3434   TestEngine.test(message, testResult);
3435 }