1/* 2 * Copyright (C) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import { 17 fileIO, FILE_CONTENT, prepareFile, prepare200MFile, nextFileName, isIntNum, describe, it, expect, 18} from '../Common'; 19 20const RAND_READ_BASELINE = 3.5; 21const RAND_WRITE_BASELINE = 0.5; 22const SEQUENCE_READ_BASELINE = 15; 23const SEQUENCE_WRITE_BASELINE = 5; 24 25export default function FileIOFilerw_test() { 26 describe('FileIO_fs_filerw_test', function () { 27 28 async function IOfunc(file, bf, total, rand, read, promise) { 29 let date = new Date(); 30 let startTime = new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 31 date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds()).getTime(); 32 try { 33 var array = new ArrayBuffer(bf); 34 var count = total / bf; 35 for (let i = 0; i < count; i++) { 36 var offset = i * bf; 37 if (rand) { 38 offset = Math.floor(Math.random() * (total - bf)); 39 } 40 if (promise) { 41 if (read) { 42 fileIO.read(file.fd, array, { length: bf, offset: offset }).then((readLen) => { 43 }).catch((e) => { 44 console.log('fileIO_test_read_promise has failed for ' + e.message + ', code: ' + e.code); 45 return -1; 46 }); 47 } else { 48 fileIO.write(file.fd, array, { length: bf, offset: offset, encoding: 'utf-8' }).then((writeLen) => { 49 }).catch((e) => { 50 console.log('fileIO_test_write_promise has failed for ' + e.message + ', code: ' + e.code); 51 return -1; 52 }); 53 } 54 } else { 55 if (read) { 56 fileIO.read(file.fd, array, { length: bf, offset: offset }, (err, readLen) => { 57 if (err) { 58 console.log('fileIO_test_read_callback has failed for ' + err.message + ', code: ' + err.code); 59 return -1; 60 } 61 }); 62 } else { 63 fileIO.write(file.fd, array, { length: bf, offset: offset, encoding: 'utf-8' }, (err, writeLen) => { 64 if (err) { 65 console.log('fileIO_test_write_callback has failed for ' + err.message + ', code: ' + err.code); 66 return -1; 67 } 68 }); 69 } 70 } 71 } 72 fileIO.fsyncSync(file.fd); 73 } catch (e) { 74 console.log('FileIO_fs_filerw_test has failed for ' + e.message + ', code: ' + e.code); 75 } finally { 76 date = new Date(); 77 let endTime = new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 78 date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds()).getTime(); 79 console.log("FileIO_fs_filerw_test finally" + JSON.stringify(endTime)) 80 var interval = endTime - startTime; 81 var average = total * 1000 / interval; 82 var averagerate = average / 0x100000; 83 return averagerate; 84 } 85 } 86 87 /** 88 * @tc.number SUB_DF_FILEIO_FILERW_READ_RANDOM_PROMISE_0000 89 * @tc.name fileIO_test_read_random_promise_000 90 * @tc.desc Test the read() interface. promise. 91 * Open the file, file read() in the random way. 92 * @tc.size MEDIUM 93 * @tc.type Function 94 * @tc.level Level 3 95 * @tc.require 96 */ 97 it('fileIO_test_read_random_promise_000', 0, async function (done) { 98 let fpath = await nextFileName('fileIO_test_read_random_promise_000'); 99 expect(prepare200MFile(fpath)).assertTrue; 100 101 try { 102 let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY); 103 expect(isIntNum(file.fd)).assertTrue(); 104 let averagerate = await IOfunc(file, 0x1000, 0xC800000, true, true, true); 105 console.log("RAND_READ Rate is" + averagerate + "M/s"); 106 expect(averagerate > RAND_READ_BASELINE).assertTrue(); 107 fileIO.closeSync(file); 108 fileIO.unlinkSync(fpath); 109 done(); 110 } catch (e) { 111 console.log('fileIO_test_read_random_promise_000 has failed for ' + e.message + ', code: ' + e.code); 112 expect(false).assertTrue(); 113 } 114 }); 115 116 /** 117 * @tc.number SUB_DF_FILEIO_FILERW_WRITE_RANDOM_PROMISE_0000 118 * @tc.name fileIO_test_write_random_promise_000 119 * @tc.desc Test the write() interface. promise. 120 * Open the file, file write() in the random way. 121 * @tc.size MEDIUM 122 * @tc.type Function 123 * @tc.level Level 3 124 * @tc.require 125 */ 126 it('fileIO_test_write_random_promise_000', 0, async function (done) { 127 let fpath = await nextFileName('fileIO_test_write_random_promise_000'); 128 expect(prepare200MFile(fpath)).assertTrue; 129 130 try { 131 let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE); 132 expect(isIntNum(file.fd)).assertTrue(); 133 let averagerate = await IOfunc(file, 0x1000, 0xC800000, true, false, true); 134 console.log("RAND_WRITE Rate is" + averagerate + "M/s"); 135 expect(averagerate > RAND_WRITE_BASELINE).assertTrue(); 136 fileIO.closeSync(file); 137 fileIO.unlinkSync(fpath); 138 done(); 139 } catch (e) { 140 console.log('fileIO_test_write_random_promise_000 has failed for ' + e.message + ', code: ' + e.code); 141 expect(false).assertTrue(); 142 } 143 }); 144 145 /** 146 * @tc.number SUB_DF_FILEIO_FILERW_READ_SEQUENCE_PROMISE_0000 147 * @tc.name fileIO_test_read_sequence_promise_000 148 * @tc.desc Test the read() interface. promise. 149 * Open the file, file read() in the sequence way. 150 * @tc.size MEDIUM 151 * @tc.type Function 152 * @tc.level Level 3 153 * @tc.require 154 */ 155 it('fileIO_test_read_sequence_promise_000', 0, async function (done) { 156 let fpath = await nextFileName('fileIO_test_read_sequence_promise_000'); 157 expect(prepare200MFile(fpath)).assertTrue; 158 159 try { 160 let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY); 161 expect(isIntNum(file.fd)).assertTrue(); 162 let averagerate = await IOfunc(file, 0x1000, 0xC800000, false, true, true); 163 console.log("SEQUENCE_READ Rate is" + averagerate + "M/s"); 164 expect(averagerate > SEQUENCE_READ_BASELINE).assertTrue(); 165 fileIO.closeSync(file); 166 fileIO.unlinkSync(fpath); 167 done(); 168 } catch (e) { 169 console.log('fileIO_test_read_sequence_promise_000 has failed for ' + e.message + ', code: ' + e.code); 170 expect(false).assertTrue(); 171 } 172 }); 173 174 /** 175 * @tc.number SUB_DF_FILEIO_FILERW_WRITE_SEQUENCE_PROMISE_0000 176 * @tc.name fileIO_test_write_sequence_promise_000 177 * @tc.desc Test the write() interface. promise. 178 * Open the file, file write() in the sequence way. 179 * @tc.size MEDIUM 180 * @tc.type Function 181 * @tc.level Level 3 182 * @tc.require 183 */ 184 it('fileIO_test_write_sequence_promise_000', 0, async function (done) { 185 let fpath = await nextFileName('fileIO_test_write_sequence_promise_000'); 186 expect(prepare200MFile(fpath)).assertTrue; 187 188 try { 189 let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE); 190 expect(isIntNum(file.fd)).assertTrue(); 191 let averagerate = await IOfunc(file, 0x1000, 0xC800000, false, false, true); 192 console.log("SEQUENCE_WRITE Rate is" + averagerate + "M/s"); 193 expect(averagerate > SEQUENCE_WRITE_BASELINE).assertTrue(); 194 fileIO.closeSync(file); 195 fileIO.unlinkSync(fpath); 196 done(); 197 } catch (e) { 198 console.log('fileIO_test_write_sequence_promise_000 has failed for ' + e.message + ', code: ' + e.code); 199 expect(false).assertTrue(); 200 } 201 }); 202 203 /** 204 * @tc.number SUB_DF_FILEIO_FILERW_READ_RANDOM_CALLBACK_0000 205 * @tc.name fileIO_test_read_random_callback_000 206 * @tc.desc Test the read() interface. callback. 207 * Open the file, file read() in the random way. 208 * @tc.size MEDIUM 209 * @tc.type Function 210 * @tc.level Level 3 211 * @tc.require 212 */ 213 it('fileIO_test_read_random_callback_000', 0, async function (done) { 214 let fpath = await nextFileName('fileIO_test_read_random_callback_000'); 215 expect(prepare200MFile(fpath)).assertTrue; 216 217 try { 218 let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY); 219 expect(isIntNum(file.fd)).assertTrue(); 220 let averagerate = await IOfunc(file, 0x1000, 0xC800000, true, true, false); 221 console.log("RAND_READ Rate is" + averagerate + "M/s"); 222 expect(averagerate > RAND_READ_BASELINE).assertTrue(); 223 fileIO.closeSync(file); 224 fileIO.unlinkSync(fpath); 225 done(); 226 } catch (e) { 227 console.log('fileIO_test_read_random_callback_000 has failed for ' + e.message + ', code: ' + e.code); 228 expect(false).assertTrue(); 229 } 230 }); 231 232 /** 233 * @tc.number SUB_DF_FILEIO_FILERW_WRITE_RANDOM_CALLBACK_0000 234 * @tc.name fileIO_test_write_random_callback_000 235 * @tc.desc Test the write() interface. callback. 236 * Open the file, file write() in the random way. 237 * @tc.size MEDIUM 238 * @tc.type Function 239 * @tc.level Level 3 240 * @tc.require 241 */ 242 it('fileIO_test_write_random_callback_000', 0, async function (done) { 243 let fpath = await nextFileName('fileIO_test_write_random_callback_000'); 244 expect(prepare200MFile(fpath)).assertTrue; 245 246 try { 247 let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE); 248 expect(isIntNum(file.fd)).assertTrue(); 249 let averagerate = await IOfunc(file, 0x1000, 0xC800000, true, false, false); 250 console.log("RAND_WRITE Rate is" + averagerate + "M/s"); 251 expect(averagerate > RAND_WRITE_BASELINE).assertTrue(); 252 fileIO.closeSync(file); 253 fileIO.unlinkSync(fpath); 254 done(); 255 } catch (e) { 256 console.log('fileIO_test_write_random_callback_000 has failed for ' + e.message + ', code: ' + e.code); 257 expect(false).assertTrue(); 258 } 259 }); 260 261 /** 262 * @tc.number SUB_DF_FILEIO_FILERW_READ_SEQUENCE_CALLBACK_0000 263 * @tc.name fileIO_test_read_sequence_callback_000 264 * @tc.desc Test the read() interface. callback. 265 * Open the file, file read() in the sequence way. 266 * @tc.size MEDIUM 267 * @tc.type Function 268 * @tc.level Level 3 269 * @tc.require 270 */ 271 it('fileIO_test_read_sequence_callback_000', 0, async function (done) { 272 let fpath = await nextFileName('fileIO_test_read_sequence_callback_000'); 273 expect(prepare200MFile(fpath)).assertTrue; 274 275 try { 276 let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY); 277 expect(isIntNum(file.fd)).assertTrue(); 278 let averagerate = await IOfunc(file, 0x1000, 0xC800000, false, true, false); 279 console.log("SEQUENCE_READ Rate is" + averagerate + "M/s"); 280 expect(averagerate > SEQUENCE_READ_BASELINE).assertTrue(); 281 fileIO.closeSync(file); 282 fileIO.unlinkSync(fpath); 283 done(); 284 } catch (e) { 285 console.log('fileIO_test_read_sequence_callback_000 has failed for ' + e.message + ', code: ' + e.code); 286 expect(false).assertTrue(); 287 } 288 }); 289 290 /** 291 * @tc.number SUB_DF_FILEIO_FILERW_WRITE_SEQUENCE_CALLBACK_0000 292 * @tc.name fileIO_test_write_sequence_callback_000 293 * @tc.desc Test the write() interface. callback. 294 * Open the file, file write() in the sequence way. 295 * @tc.size MEDIUM 296 * @tc.type Function 297 * @tc.level Level 3 298 * @tc.require 299 */ 300 it('fileIO_test_write_sequence_callback_000', 0, async function (done) { 301 let fpath = await nextFileName('fileIO_test_write_sequence_callback_000'); 302 expect(prepare200MFile(fpath)).assertTrue; 303 304 try { 305 let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE); 306 expect(isIntNum(file.fd)).assertTrue(); 307 let averagerate = await IOfunc(file, 0x1000, 0xC800000, false, false, false); 308 console.log("SEQUENCE_WRITE Rate is" + averagerate + "M/s"); 309 expect(averagerate > SEQUENCE_WRITE_BASELINE).assertTrue(); 310 fileIO.closeSync(file); 311 fileIO.unlinkSync(fpath); 312 done(); 313 } catch (e) { 314 console.log('fileIO_test_write_sequence_callback_000 has failed for ' + e.message + ', code: ' + e.code); 315 expect(false).assertTrue(); 316 } 317 }); 318 }); 319}