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