Son CV dans un terminal web en Javascript! https://terminal-cv.gregandev.fr
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

795 lines
27 KiB

1 year ago
'use strict';
let path = require('path');
let rimraf = require('rimraf');
let chai = require('chai');
let should = chai.should();
let expect = chai.expect;
let spawn = require('child_process').spawn;
let { open, getLastVersion, bufferToKeyValue, keyValueToBuffer, ABORT } = require('..');
const { ArrayLikeIterable } = require('../util/ArrayLikeIterable')
//var inspector = require('inspector'); inspector.open(9330, null, true); debugger
describe('lmdb-store', function() {
let testDirPath = path.resolve(__dirname, './testdata-ls');
// just to make a reasonable sized chunk of data...
function expand(str) {
str = '(' + str + ')';
str = str + str;
str = str + str;
str = str + str;
str = str + str;
str = str + str;
return str;
}
before(function(done) {
// cleanup previous test directory
rimraf(testDirPath, function(err) {
if (err) {
return done(err);
}
done();
});
});
let testIteration = 1
describe('Basic use', basicTests({ compression: false }));
describe('Basic use with encryption', basicTests({ compression: false, encryptionKey: 'Use this key to encrypt the data' }));
//describe('Check encrypted data', basicTests({ compression: false, checkLast: true }));
describe('Basic use with JSON', basicTests({ encoding: 'json' }));
describe('Basic use with ordered-binary', basicTests({ encoding: 'ordered-binary' }));
if (typeof WeakRef != 'undefined')
describe('Basic use with caching', basicTests({ cache: true }));
function basicTests(options) { return function() {
this.timeout(1000000);
let db, db2, db3;
before(function() {
db = open(testDirPath + '/test-' + testIteration + '.mdb', Object.assign({
name: 'mydb3',
create: true,
useVersions: true,
//asyncTransactionOrder: 'strict',
//useWritemap: true,
//noSync: true,
compression: {
threshold: 256,
},
}, options));
testIteration++;
if (!options.checkLast)
db.clear();
db2 = db.openDB(Object.assign({
name: 'mydb4',
create: true,
dupSort: true,
}));
if (!options.checkLast)
db2.clear();
db3 = db.openDB({
name: 'mydb5',
create: true,
dupSort: true,
encoding: 'ordered-binary',
});
if (!options.checkLast)
db3.clear();
});
if (options.checkLast) {
it('encrypted data can not be accessed', function() {
let data = db.get('key1');
console.log({data})
data.should.deep.equal({foo: 1, bar: true})
})
return
}
it('query of keys', async function() {
let keys = [
Symbol.for('test'),
false,
true,
-33,
-1.1,
3.3,
5,
[5,4],
[5,55],
[5, 'words after number'],
[6, 'abc'],
[ 'Test', null, 1 ],
[ 'Test', Symbol.for('test'), 2 ],
[ 'Test', 'not null', 3 ],
'hello',
['hello', 3],
['hello', 'world'],
[ 'uid', 'I-7l9ySkD-wAOULIjOEnb', 'Rwsu6gqOw8cqdCZG5_YNF' ],
'z'
]
for (let key of keys)
await db.put(key, 3);
let returnedKeys = []
for (let { key, value } of db.getRange({
start: Symbol.for('A')
})) {
returnedKeys.push(key)
value.should.equal(db.get(key))
}
keys.should.deep.equal(returnedKeys)
returnedKeys = []
for (let { key, value } of db.getRange({
reverse: true,
})) {
returnedKeys.unshift(key)
value.should.equal(db.get(key))
}
keys.should.deep.equal(returnedKeys)
});
it('reverse query range', async function() {
const keys = [
[ 'Test', 100, 1 ],
[ 'Test', 10010, 2 ],
[ 'Test', 10010, 3 ]
]
for (let key of keys)
await db.put(key, 3);
for (let { key, value } of db.getRange({
start: ['Test', null],
end: ['Test', null],
reverse: true
})) {
throw new Error('Should not return any results')
}
})
it('more reverse query range', async function() {
db.putSync('0Sdts8FwTqt2Hv5j9KE7ebjsQcFbYDdL/0Sdtsud6g8YGhPwUK04fRVKhuTywhnx8', 1, 1, null);
db.putSync('0Sdts8FwTqt2Hv5j9KE7ebjsQcFbYDdL/0Sdu0mnkm8lS38yIZa4Xte3Q3JUoD84V', 1, 1, null);
const options =
{
start: '0Sdts8FwTqt2Hv5j9KE7ebjsQcFbYDdL/0SdvKaMkMNPoydWV6HxZbFtKeQm5sqz3',
end: '0Sdts8FwTqt2Hv5j9KE7ebjsQcFbYDdL/00000000dKZzSn03pte5dWbaYfrZl4hG',
reverse: true
};
let returnedKeys = Array.from(db.getKeys(options))
returnedKeys.should.deep.equal(['0Sdts8FwTqt2Hv5j9KE7ebjsQcFbYDdL/0Sdu0mnkm8lS38yIZa4Xte3Q3JUoD84V', '0Sdts8FwTqt2Hv5j9KE7ebjsQcFbYDdL/0Sdtsud6g8YGhPwUK04fRVKhuTywhnx8'])
});
it('string', async function() {
await db.put('key1', 'Hello world!');
let data = db.get('key1');
data.should.equal('Hello world!');
await db.remove('key1')
let data2 = db.get('key1');
should.equal(data2, undefined);
});
it('string with version', async function() {
await db.put('key1', 'Hello world!', 53252);
let entry = db.getEntry('key1');
entry.value.should.equal('Hello world!');
entry.version.should.equal(53252);
(await db.remove('key1', 33)).should.equal(false);
entry = db.getEntry('key1');
entry.value.should.equal('Hello world!');
entry.version.should.equal(53252);
(await db.remove('key1', 53252)).should.equal(true);
entry = db.getEntry('key1');
should.equal(entry, undefined);
});
it('string with version branching', async function() {
await db.put('key1', 'Hello world!', 53252);
let entry = db.getEntry('key1');
entry.value.should.equal('Hello world!');
entry.version.should.equal(53252);
(await db.ifVersion('key1', 777, () => {
db.put('newKey', 'test', 6);
db2.put('keyB', 'test', 6);
})).should.equal(false);
should.equal(db.get('newKey'), undefined);
should.equal(db2.get('keyB'), undefined);
let result = (await db.ifVersion('key1', 53252, () => {
db.put('newKey', 'test', 6);
db2.put('keyB', 'test', 6);
}))
should.equal(db.get('newKey'), 'test')
should.equal(db2.get('keyB'), 'test')
should.equal(result, true);
result = await db.ifNoExists('key1', () => {
db.put('newKey', 'changed', 7);
})
should.equal(db.get('newKey'), 'test');
should.equal(result, false);
result = await db.ifNoExists('key-no-exist', () => {
db.put('newKey', 'changed', 7);
})
should.equal(db.get('newKey'), 'changed')
should.equal(result, true);
});
it('string with compression and versions', async function() {
let str = expand('Hello world!')
await db.put('key1', str, 53252);
let entry = db.getEntry('key1');
entry.value.should.equal(str);
entry.version.should.equal(53252);
(await db.remove('key1', 33)).should.equal(false);
let data = db.get('key1');
data.should.equal(str);
(await db.remove('key1', 53252)).should.equal(true);
data = db.get('key1');
should.equal(data, undefined);
});
if (options.encoding == 'ordered-binary')
return // no more tests need to be applied for this
it('store objects', async function() {
let dataIn = {foo: 3, bar: true}
await db.put('key1', dataIn);
let dataOut = db.get('key1');
dataOut.should.deep.equal(dataIn);
db.removeSync('not-there').should.equal(false);
});
it.skip('trigger sync commit', async function() {
let dataIn = {foo: 4, bar: false}
db.immediateBatchThreshold = 1
db.syncBatchThreshold = 1
await db.put('key1', dataIn);
await db.put('key2', dataIn);
db.immediateBatchThreshold = 100000
db.syncBatchThreshold = 1000000
let dataOut = db.get('key1');
dataOut.should.deep.equal(dataIn);
});
function iterateQuery(acrossTransactions) { return async () => {
let data1 = {foo: 1, bar: true}
let data2 = {foo: 2, bar: false}
db.put('key1', data1);
await db.put('key2', data2);
let count = 0
for (let { key, value } of db.getRange({start:'key', end:'keyz', snapshot: !acrossTransactions})) {
if (acrossTransactions)
await delay(10)
count++
switch(key) {
case 'key1': data1.should.deep.equal(value); break;
case 'key2': data2.should.deep.equal(value); break;
}
}
should.equal(count >= 2, true);
should.equal(db.getCount({start:'key', end:'keyz'}) >= 2, true);
}}
it('should iterate over query', iterateQuery(false));
it('should iterate over query, across transactions', iterateQuery(true));
it('should break out of query', async function() {
let data1 = {foo: 1, bar: true}
let data2 = {foo: 2, bar: false}
db.put('key1', data1);
await db.put('key2', data2);
let count = 0;
for (let { key, value } of db.getRange({start:'key', end:'keyz'})) {
if (count > 0)
break;
count++;
data1.should.deep.equal(value);
'key1'.should.equal(key);
}
count.should.equal(1);
});
it('getRange with arrays', async function() {
const keys = [
[ 'foo', 0 ],
[ 'foo', 1 ],
[ 'foo', 2 ],
]
let promise
keys.forEach((key, i) => {
promise = db.put(key, i)
})
await promise
let result = Array.from(db.getRange({
start: [ 'foo'],
end: [ 'foo', 1 ],
}))
result.should.deep.equal([ { key: [ 'foo', 0 ], value: 0 } ])
result = Array.from(db.getRange({
start: [ 'foo', 0 ],
end: [ 'foo', 1 ],
}))
result.should.deep.equal([ { key: [ 'foo', 0 ], value: 0 } ])
result = Array.from(db.getRange({
start: [ 'foo', 2 ],
end: [ 'foo', [2, null] ],
}))
result.should.deep.equal([ { key: [ 'foo', 2 ], value: 2 } ])
})
it('should iterate over query with offset/limit', async function() {
let data1 = {foo: 1, bar: true}
let data2 = {foo: 2, bar: false}
let data3 = {foo: 3, bar: false}
db.put('key1', data1);
db.put('key2', data2);
await db.put('key3', data3);
let count = 0
for (let { key, value } of db.getRange({start:'key', end:'keyz', offset: 1, limit: 1})) {
count++
switch(key) {
case 'key2': data2.should.deep.equal(value); break;
}
}
count.should.equal(1)
count = 0
for (let { key, value } of db.getRange({start:'key', end:'keyz', offset: 3, limit: 3})) {
count++
}
count.should.equal(0)
for (let { key, value } of db.getRange({start:'key', end:'keyz', offset: 10, limit: 3})) {
count++
}
count.should.equal(0)
for (let { key, value } of db.getRange({start:'key', end:'keyz', offset: 2, limit: 3})) {
count++
switch(key) {
case 'key3': data3.should.deep.equal(value); break;
}
}
count.should.equal(1)
});
it('should handle open iterators and cursor renewal', async function() {
let data1 = {foo: 1, bar: true};
let data2 = {foo: 2, bar: false};
let data3 = {foo: 3, bar: false};
db2.put('key1', data1);
db.put('key1', data1);
db.put('key2', data2);
await db.put('key3', data3);
let it1 = db.getRange({start:'key', end:'keyz'})[Symbol.iterator]();
let it2 = db2.getRange({start:'key', end:'keyz'})[Symbol.iterator]();
let it3 = db.getRange({start:'key', end:'keyz'})[Symbol.iterator]();
it1.return();
it2.return();
await new Promise(resolve => setTimeout(resolve, 10));
it1 = db.getRange({start:'key', end:'keyz'})[Symbol.iterator]();
it2 = db2.getRange({start:'key', end:'keyz'})[Symbol.iterator]();
let it4 = db.getRange({start:'key', end:'keyz'})[Symbol.iterator]();
let it5 = db2.getRange({start:'key', end:'keyz'})[Symbol.iterator]();
await new Promise(resolve => setTimeout(resolve, 20));
it4.return()
it5.return()
it1.return()
it2.return()
it3.return()
});
it('should iterate over dupsort query, with removal', async function() {
let data1 = {foo: 1, bar: true}
let data2 = {foo: 2, bar: false}
let data3 = {foo: 3, bar: true}
db2.put('key1', data1);
db2.put('key1', data2);
db2.put('key1', data3);
await db2.put('key2', data3);
let count = 0;
for (let value of db2.getValues('key1')) {
count++
switch(count) {
case 1: data1.should.deep.equal(value); break;
case 2: data2.should.deep.equal(value); break;
case 3: data3.should.deep.equal(value); break;
}
}
count.should.equal(3);
db2.getValuesCount('key1').should.equal(3);
await db2.remove('key1', data2);
count = 0;
for (let value of db2.getValues('key1')) {
count++;
switch(count) {
case 1: data1.should.deep.equal(value); break;
case 2: data3.should.deep.equal(value); break;
}
}
count.should.equal(2)
db2.getValuesCount('key1').should.equal(2);
count = 0;
for (let value of db2.getValues('key1', { reverse: true })) {
count++;
switch(count) {
case 1: data3.should.deep.equal(value); break;
case 2: data1.should.deep.equal(value); break;
}
}
count.should.equal(2);
db2.getValuesCount('key1').should.equal(2);
count = 0;
for (let value of db2.getValues('key0')) {
count++;
}
count.should.equal(0);
db2.getValuesCount('key0').should.equal(0);
db2.getCount({start: 'key1', end: 'key3'}).should.equal(3);
});
it('should iterate over ordered-binary dupsort query with start/end', async function() {
db3.put('key1', 1);
db3.put('key1', 2);
db3.put('key1', 3);
await db3.put('key2', 3);
let count = 0;
for (let value of db3.getValues('key1', { start: 1 })) {
count++
value.should.equal(count)
}
count.should.equal(3);
count = 0;
for (let value of db3.getValues('key1', { end: 3 })) {
count++
value.should.equal(count)
}
count.should.equal(2);
});
it('should count ordered-binary dupsort query with start/end', async function() {
db3.put('key1', 1);
db3.put('key1', 2);
db3.put('key1', 3);
await db3.put('key2', 3);
db3.getValuesCount('key1').should.equal(3);
db3.getValuesCount('key1', { start: 1, end: 3 }).should.equal(2);
db3.getValuesCount('key1', { start: 2, end: 3 }).should.equal(1);
db3.getValuesCount('key1', { start: 2 }).should.equal(2);
db3.getValuesCount('key1', { end: 2 }).should.equal(1);
db3.getValuesCount('key1', { start: 1, end: 2 }).should.equal(1);
db3.getValuesCount('key1', { start: 2, end: 2 }).should.equal(0);
db3.getValuesCount('key1').should.equal(3);
});
it('should reverse iterate ordered-binary dupsort query with start/end', async function() {
db3.put('key1', 1);
db3.put('key1', 2);
db3.put('key1', 3);
await db3.put('key2', 3);
let count = 0;
for (let value of db3.getValues('key1', { reverse: true, start: 2 })) {
count++;
value.should.equal(3 - count);
}
count.should.equal(2);
count = 0;
for (let value of db3.getValues('key1', { reverse: true, start: 2.5 })) {
count++;
value.should.equal(3 - count);
}
count.should.equal(2);
count = 0;
for (let value of db3.getValues('key1', { reverse: true, start: 50 })) {
count++;
value.should.equal(4 - count);
}
count.should.equal(3);
count = 0;
for (let value of db3.getValues('key1', { reverse: true, start: 2, end: 1 })) {
count++;
value.should.equal(3 - count);
}
count.should.equal(1);
count = 0;
for (let value of db3.getValues('key1', { reverse: true, end: 1 })) {
count++;
value.should.equal(4 - count);
}
count.should.equal(2);
count = 0;
for (let value of db3.getValues('key1', { reverse: true, start: 0.5 })) {
count++;
}
count.should.equal(0);
});
it('doesExist', async function() {
let data1 = {foo: 1, bar: true}
let data2 = {foo: 2, bar: false}
let data3 = {foo: 3, bar: true}
db2.put('key1', data1);
db2.put('key1', data3);
db2.put(false, 3);
await db2.put('key2', data3);
should.equal(db2.doesExist('key1'), true);
should.equal(db2.doesExist('key1', data1), true);
should.equal(db2.doesExist('key1', data2), false);
should.equal(db2.doesExist('key1', data3), true);
should.equal(db2.doesExist(false), true);
should.equal(db2.doesExist(false, 3), true);
should.equal(db2.doesExist(false, 4), false);
})
it('should iterate over keys without duplicates', async function() {
let lastKey
for (let key of db2.getKeys({ start: 'k' })) {
if (key == lastKey)
throw new Error('duplicate key returned')
lastKey = key
}
})
it('big keys', async function() {
let keyBase = ''
for (let i = 0; i < 1900; i++) {
keyBase += 'A'
}
let keys = []
let promise
for (let i = 40; i < 120; i++) {
let key = String.fromCharCode(i) + keyBase
keys.push(key)
promise = db.put(key, i)
}
await promise
let returnedKeys = []
for (let { key, value } of db.getRange({})) {
if (key.length > 1000) {
returnedKeys.push(key)
should.equal(key.charCodeAt(0), value)
should.equal(db.get(key), value)
promise = db.remove(key)
}
}
returnedKeys.should.deep.equal(keys)
await promise
should.equal(db.get(returnedKeys[0]), undefined)
});
it('invalid key', async function() {
expect(() => db.get({ foo: 'bar' })).to.throw();
//expect(() => db.put({ foo: 'bar' }, 'hello')).to.throw();
});
it('put options (sync)', function() {
db.putSync('zkey6', 'test', { append: true, version: 33 });
let entry = db.getEntry('zkey6');
entry.value.should.equal('test');
entry.version.should.equal(33);
db.putSync('zkey7', 'test', { append: true, noOverwrite: true });
db2.putSync('zkey6', 'test1', { appendDup: true });
db2.putSync('zkey6', 'test2', { appendDup: true });
expect(() => db.putSync('zkey5', 'test', { append: true, version: 44 })).to.throw();
expect(() => db.putSync('zkey7', 'test', { noOverwrite: true })).to.throw();
expect(() => db2.putSync('zkey6', 'test1', { noDupData: true })).to.throw();
});
it('async transactions', async function() {
let ranTransaction
db.put('key1', 'async initial value'); // should be queued for async write, but should put before queued transaction
let errorHandled
if (!db.cache) {
db.childTransaction(() => {
db.put('key1', 'should be rolled back');
throw new Error('Make sure this is properly propagated without interfering with next transaction')
}).catch(error => {
if (error)
errorHandled = true
})
await db.childTransaction(() => {
should.equal(db.get('key1'), 'async initial value');
db.put('key-a', 'async test a');
should.equal(db.get('key-a'), 'async test a');
})
should.equal(errorHandled, true);
}
await db.transactionAsync(() => {
ranTransaction = true;
should.equal(db.get('key1'), 'async initial value');
db.put('key1', 'async test 1');
should.equal(db.get('key1'), 'async test 1');
for (let { key, value } of db.getRange({start: 'key1', end: 'key1z' })) {
should.equal(value, 'async test 1');
}
db2.put('key2-async', 'async test 2');
should.equal(db2.get('key2-async'), 'async test 2');
});
should.equal(db.get('key1'), 'async test 1');
should.equal(db2.get('key2-async'), 'async test 2');
should.equal(ranTransaction, true);
});
it('child transaction in sync transaction', async function() {
if (db.cache)
return
await db.transactionSync(async () => {
db.put('key3', 'test-sync-txn');
db.childTransaction(() => {
db.put('key3', 'test-child-txn');
return ABORT;
})
should.equal(db.get('key3'), 'test-sync-txn');
db.childTransaction(() => {
db.put('key3', 'test-child-txn');
})
should.equal(db.get('key3'), 'test-child-txn');
await db.childTransaction(async () => {
await new Promise(resolve => setTimeout(resolve, 1))
db.put('key3', 'test-async-child-txn');
})
should.equal(db.get('key3'), 'test-async-child-txn');
})
});
it('async transaction with interrupting sync transaction default order', async function() {
db.strictAsyncOrder = false
let order = []
let ranSyncTxn
db.transactionAsync(() => {
order.push('a1');
db.put('async1', 'test');
if (!ranSyncTxn) {
ranSyncTxn = true;
setImmediate(() => db.transactionSync(() => {
order.push('s1');
db.put('inside-sync', 'test');
}));
}
});
db.put('outside-txn', 'test');
await db.transactionAsync(() => {
order.push('a2');
db.put('async2', 'test');
});
order.should.deep.equal(['a1', 'a2', 's1']);
should.equal(db.get('async1'), 'test');
should.equal(db.get('outside-txn'), 'test');
should.equal(db.get('inside-sync'), 'test');
should.equal(db.get('async2'), 'test');
});
it('big child transactions', async function() {
let ranTransaction
db.put('key1', 'async initial value'); // should be queued for async write, but should put before queued transaction
let errorHandled
if (!db.cache) {
db.childTransaction(() => {
let value
for (let i = 0; i < 5000; i++) {
db.put('key' + i, 'test')
}
})
await db.put('key1', 'test');
should.equal(db.get('key1'), 'test');
}
});
it('read and write with binary encoding', async function() {
let dbBinary = db.openDB(Object.assign({
name: 'mydb5',
create: true,
encoding: 'binary'
}));
dbBinary.put('buffer', Buffer.from('hello'));
dbBinary.put('empty', Buffer.from([]));
await dbBinary.put('Uint8Array', new Uint8Array([1,2,3]));
dbBinary.get('buffer').toString().should.equal('hello');
dbBinary.get('Uint8Array')[1].should.equal(2);
dbBinary.get('empty').length.should.equal(0);
});
it.skip('read and write with binary methods', async function() {
let dbBinary = db.openDB(Object.assign({
name: 'mydb6',
keyIsUint32: true,
create: true,
}));
dbBinary.put(3, Buffer.from('hello'));
await dbBinary.put(4, new Uint8Array([1,2,3]));
console.log(dbBinary.getBinaryLocation(3))
console.log(dbBinary.getBinaryLocation(4))
});
after(function(done) {
db.get('key1');
let iterator = db.getRange({})[Symbol.iterator]()
setTimeout(() => {
db.get('key1');
// should have open read and cursor transactions
db2.close();
db.close();
done();
},10);
});
}}
describe('direct key', function() {
it('should serialize and deserialize keys', function() {
let keys = [
Symbol.for('test'),
false,
true,
-33,
-1.1,
3.3,
5,
[5,4],
[5,55],
'hello',
['hello', 3],
['hello', 'world'],
[ 'uid', 'I-7l9ySkD-wAOULIjOEnb', 'Rwsu6gqOw8cqdCZG5_YNF' ],
'x'.repeat(1978),
'z'
]
let serializedKeys = []
for (let key of keys) {
let buffer = keyValueToBuffer(key)
serializedKeys.push(bufferToKeyValue(buffer))
}
serializedKeys.should.deep.equal(keys)
})
});
describe('uint32 keys', function() {
this.timeout(10000);
let db, db2;
before(function() {
db = open(testDirPath, {
name: 'uint32',
keyIsUint32: true,
compression: true,
});
});
it('write and read range', async function() {
let lastPromise
for (let i = 0; i < 10; i++) {
lastPromise = db.put(i, 'value' + i);
}
await lastPromise
let i = 0
for (let { key, value } of db.getRange()) {
key.should.equal(i);
value.should.equal('value' + i);
i++;
}
i = 0
for (let { key, value } of db.getRange({ start: 0 })) {
key.should.equal(i);
value.should.equal('value' + i);
i++;
}
});
after(function() {
db.close();
});
});
describe('ArrayLikeIterable', function() {
it('concat and iterate', async function() {
let a = new ArrayLikeIterable([1, 2, 3])
let b = new ArrayLikeIterable([4, 5, 6])
let all = []
for (let v of a.concat(b)) {
all.push(v)
}
all.should.deep.equal([1, 2, 3, 4, 5, 6])
});
});
describe('mixed keys', function() {
this.timeout(10000);
let intKeys, strKeys;
before(function() {
const rootDb = open({
name: `root`,
path: testDirPath + '/test-mixedkeys.mdb',
keyIsUint32: false,
})
intKeys = rootDb.openDB({
name: `intKeys`,
keyIsUint32: true,
})
strKeys = rootDb.openDB({
name: `strKeys`,
keyIsUint32: false,
})
})
it('create with keys', async function() {
let lastPromise
for (let intKey = 0; intKey < 100; intKey++) {
const strKey = `k${intKey}`
intKeys.put(intKey, `${intKey}-value`)
lastPromise = strKeys.put(strKey, `${strKey}-value`)
}
await lastPromise
});
});
});
function delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms))
}