fixin: adding predicate checks to converted tests

Author: tegefaulkes

tests/EncryptedFS.concurrent.test.ts

@@ -307,29 +307,35 @@ describe(`${EncryptedFS.name} Concurrency`, () => {
   });
   describe('concurrent file writes', () => {
     test('EncryptedFS.write on multiple file descriptors', async () => {
-      const contents = ['one', 'two'];
+      // Concurrent writes of different length results in "last write wins" or a merge
+      const contents = ['one', 'two', 'one1', 'two2'];
       await fc.assert(
         fc.asyncProperty(fc.scheduler(), async (s) => {
           const fds: Array<FdIndex> = [
             await efs.open('test', constants.O_RDWR | constants.O_CREAT),
             await efs.open('test', constants.O_RDWR | constants.O_CREAT),
+            await efs.open('test', constants.O_RDWR | constants.O_CREAT),
+            await efs.open('test', constants.O_RDWR | constants.O_CREAT),
           ];
 
+          // Concurrent writes of the same length results in "last write wins"
           const prom = Promise.all([
             scheduleCall(s, () => efs.write(fds[0], contents[0]), 'write 1'),
             scheduleCall(s, () => efs.write(fds[1], contents[1]), 'write 2'),
+            scheduleCall(s, () => efs.write(fds[2], contents[2]), 'write 3'),
+            scheduleCall(s, () => efs.write(fds[3], contents[3]), 'write 4'),
           ]);
           await s.waitAll();
           await prom;
 
-          expect(
+          expect(['one', 'two', 'one1', 'one2', 'two2', 'two1']).toContainEqual(
             await efs.readFile('test', { encoding: 'utf-8' }),
-          ).toHaveLength(3);
+          );
           for (const fd of fds) {
             await efs.close(fd);
           }
         }),
-        { numRuns: 20, interruptAfterTimeLimit },
+        { numRuns: 50, interruptAfterTimeLimit },
       );
     });
     test('EncryptedFS.write on the same file descriptor', async () => {
@@ -345,9 +351,9 @@ describe(`${EncryptedFS.name} Concurrency`, () => {
           await s.waitAll();
           await prom;
 
-          expect(
+          expect(['aaabbb', 'bbbaaa']).toContainEqual(
             await efs.readFile('test', { encoding: 'utf-8' }),
-          ).toHaveLength(6);
+          );
           await efs.close(fd);
         }),
         { numRuns: 20, interruptAfterTimeLimit },
@@ -356,26 +362,30 @@ describe(`${EncryptedFS.name} Concurrency`, () => {
     test('EncryptedFS.writeFile', async () => {
       await fc.assert(
         fc.asyncProperty(fc.scheduler(), async (s) => {
+          // Concurrent writes of different length results in "last write wins" or a merge
           await efs.writeFile('test', '');
 
           const prom = Promise.all([
             scheduleCall(s, () => efs.writeFile('test', 'one'), 'writeFile 1'),
+            scheduleCall(s, () => efs.writeFile('test', 'one1'), 'writeFile 2'),
+            scheduleCall(s, () => efs.writeFile('test', 'two'), 'writeFile 2'),
             scheduleCall(s, () => efs.writeFile('test', 'two2'), 'writeFile 2'),
           ]);
           await s.waitAll();
           await prom;
 
-          expect(
+          expect(['one', 'two', 'one1', 'one2', 'two2', 'two1']).toContainEqual(
             await efs.readFile('test', { encoding: 'utf-8' }),
-          ).toHaveLength(4);
+          );
           expect(await totalINodes(iNodeMgr)).toEqual(2);
         }),
-        { numRuns: 20, interruptAfterTimeLimit },
+        { numRuns: 50, interruptAfterTimeLimit },
       );
     });
     test('EncryptedFS.appendFile', async () => {
       await fc.assert(
         fc.asyncProperty(fc.scheduler(), async (s) => {
+          // Concurrent appends results in mutually exclusive writes
           await efs.writeFile('test', 'original');
 
           const prom = Promise.all([