third_party/WebKit/LayoutTests/fast/files/resources/read-common.js

   1 // Builds a blob from a list of items.
   2 // The 'contentType' argument is optional.
   3 // If the 'builder' argument is not provided, create a new one.
   4 function buildBlob(items, contentType)
   5 {
   6     if (contentType === undefined)
   7         return new Blob(items);
   8     return new Blob(items, {type:contentType});
   9 }
  10
  11 // Reads a blob either asynchronously or synchronously.
  12 function readBlobAsArrayBuffer(testFiles, blob)
  13 {
  14     if (isReadAsAsync())
  15         _readBlobAsArrayBufferAsync(testFiles, blob);
  16     else
  17         _readBlobAsArrayBufferSync(testFiles, blob);
  18 }
  19
  20 function readBlobAsBinaryString(testFiles, blob)
  21 {
  22     if (isReadAsAsync())
  23         _readBlobAsBinaryStringAsync(testFiles, blob);
  24     else
  25         _readBlobAsBinaryStringSync(testFiles, blob);
  26 }
  27
  28 function readBlobAsText(testFiles, blob, encoding)
  29 {
  30     if (isReadAsAsync())
  31         _readBlobAsTextAsync(testFiles, blob, encoding);
  32     else
  33         _readBlobAsTextSync(testFiles, blob, encoding);
  34 }
  35
  36 function readBlobAsDataURL(testFiles, blob)
  37 {
  38     if (isReadAsAsync())
  39         _readBlobAsDataURLAsync(testFiles, blob);
  40     else
  41         _readBlobAsDataURLSync(testFiles, blob);
  42 }
  43
  44 // Reads a blob asynchronously.
  45 function _readBlobAsArrayBufferAsync(testFiles, blob)
  46 {
  47     var reader = createReaderAsync(testFiles);
  48     reader.readAsArrayBuffer(blob)
  49 }
  50
  51 function _readBlobAsBinaryStringAsync(testFiles, blob)
  52 {
  53     var reader = createReaderAsync(testFiles);
  54     reader.readAsBinaryString(blob)
  55 }
  56
  57 function _readBlobAsTextAsync(testFiles, blob, encoding)
  58 {
  59     var reader = createReaderAsync(testFiles);
  60     reader.readAsText(blob, encoding)
  61 }
  62
  63 function _readBlobAsDataURLAsync(testFiles, blob)
  64 {
  65     var reader = createReaderAsync(testFiles);
  66     reader.readAsDataURL(blob)
  67 }
  68
  69 // Reads a blob synchronously.
  70 function _readBlobAsArrayBufferSync(testFiles, blob)
  71 {
  72     var reader = createReaderSync();
  73     try {
  74         var result = reader.readAsArrayBuffer(blob);
  75         logResult(result);
  76     } catch (error) {
  77         log("Received exception, name: " + error.name + ", message: " + error.message);
  78     }
  79
  80     try {
  81         var result = reader.readAsArrayBuffer(12345);
  82         logResult(result);
  83     } catch (error) {
  84         log("Received exception, name: " + error.name + ", message: " + error.message);
  85     }
  86
  87     runNextTest(testFiles);
  88 }
  89
  90 function _readBlobAsBinaryStringSync(testFiles, blob)
  91 {
  92     var reader = createReaderSync();
  93     try {
  94         var result = reader.readAsBinaryString(blob);
  95         logResult(result);
  96     } catch (error) {
  97         log("Received exception, name: " + error.name + ", message: " + error.message);
  98     }
  99
 100     try {
 101         var result = reader.readAsBinaryString(12345);
 102         logResult(result);
 103     } catch (error) {
 104         log("Received exception, name: " + error.name + ", message: " + error.message);
 105     }
 106
 107     runNextTest(testFiles);
 108 }
 109
 110 function _readBlobAsTextSync(testFiles, blob, encoding)
 111 {
 112     var reader = createReaderSync();
 113     try {
 114         var result = reader.readAsText(blob, encoding);
 115         logResult(result);
 116     } catch (error) {
 117         log("Received exception, name: " + error.name + ", message: " + error.message);
 118     }
 119
 120     try {
 121         var result = reader.readAsText(12345, encoding);
 122         logResult(result);
 123     } catch (error) {
 124         log("Received exception, name: " + error.name + ", message: " + error.message);
 125     }
 126
 127     runNextTest(testFiles);
 128 }
 129
 130 function _readBlobAsDataURLSync(testFiles, blob)
 131 {
 132     var reader = createReaderSync();
 133     try {
 134         var result = reader.readAsDataURL(blob);
 135         logResult(result);
 136     } catch (error) {
 137         log("Received exception, name: " + error.name + ", message: " + error.message);
 138     }
 139
 140     try {
 141         var result = reader.readAsDataURL(12345);
 142         logResult(result);
 143     } catch (error) {
 144         log("Received exception, name: " + error.name + ", message: " + error.message);
 145     }
 146
 147     runNextTest(testFiles);
 148 }
 149
 150 // Creates a reader for asynchronous reading.
 151 function createReaderAsync(testFiles)
 152 {
 153     var reader = new FileReader();
 154
 155     reader.onloadstart = loadStarted;
 156     reader.onload = loaded;
 157     reader.onabort = logEvent;
 158     reader.onloadend = function(event) { loadEnded(testFiles, event); }
 159     reader.onerror = loadFailed;
 160
 161     log("readyState: " + reader.readyState);
 162     return reader;
 163 }
 164
 165 // Creates a reader for synchronous reading.
 166 function createReaderSync()
 167 {
 168     return new FileReaderSync();
 169 }
 170
 171 // 'result' can be either an ArrayBuffer object or a string.
 172 function logResult(result)
 173 {
 174     if (result === null) {
 175         log("result: null");
 176         return;
 177     }
 178     if (typeof result == 'object') {
 179         log("result size: " + result.byteLength);
 180         result = new Uint8Array(result, 0, result.byteLength);
 181     } else
 182         log("result size: " + result.length);
 183
 184     var resultOutput = _isASCIIString(result) ? _toString(result) : _toHexadecimal(result);
 185     log("result: " + resultOutput);
 186 }
 187
 188 function logEvent(event)
 189 {
 190     log("Received " + event.type + " event");
 191 }
 192
 193 function loadStarted(event)
 194 {
 195     logEvent(event);
 196     log("readyState: " + event.target.readyState);
 197 }
 198
 199 function loaded(event)
 200 {
 201     logEvent(event);
 202     log("readyState: " + event.target.readyState);
 203
 204     var result = event.target.result;
 205     logResult(result);
 206 }
 207
 208 function loadFailed(event)
 209 {
 210     logEvent(event);
 211     log("readyState: " + event.target.readyState);
 212     log("error name: " + event.target.error.name);
 213     logResult(event.target.result);
 214 }
 215
 216 function loadEnded(testFiles, event)
 217 {
 218     logEvent(event);
 219     runNextTest(testFiles);
 220 }
 221
 222 // Helper functions.
 223
 224 // 'value' can be either an ArrayBufferView object or a string.
 225 function _toString(value)
 226 {
 227     if (typeof value == 'string')
 228         return value;
 229     var result = "";
 230     for (var i = 0; i < value.length; ++i)
 231         result += String.fromCharCode(value[i]);
 232     return result;
 233 }
 234
 235 // 'value' can be either an ArrayBufferView object or a string.
 236 function _isASCIIString(value)
 237 {
 238     for (var i = 0; i < value.length; ++i) {
 239         if (_getElementAt(value, i) >= 128)
 240             return false;
 241     }
 242     return true;
 243 }
 244
 245 // 'value' can be either an ArrayBufferView object or a string.
 246 function _toHexadecimal(value)
 247 {
 248     var result = "";
 249     for (var i = 0; i < value.length; ++i) {
 250         var hex = "0x" + (_getElementAt(value, i) & 0xFF).toString(16);
 251         if (i > 0)
 252             result += " ";
 253         result += hex;
 254     }
 255     return result;
 256 }
 257
 258 function _getElementAt(value, i)
 259 {
 260     return (typeof value == 'string') ? value.charCodeAt(i) : value[i];
 261 }