fix(test): correct assertions and remove duplicate tests

- Remove duplicate test in safer-buffer.test.mts
- Add missing .toThrow() assertions to "Invalid calls throw" test
- Fix incomplete expect() statements (add .toBe(true) to ok assertions)
- Remove invalid expect() calls with two arguments but no matcher
- Add explanatory comment for Windows platform skip in date.test.mts

These fixes ensure tests properly validate behavior and don't silently
pass when they should fail.

Author: jdalton

test/npm/date.test.mts

@@ -93,6 +93,8 @@ describe('date', () => {
     })
   })
 
+  // Date string formatting is platform-dependent and may produce different
+  // output on Windows due to timezone and locale differences.
   describe(
     'Date string formatting',
     { skip: process.platform === 'win32' },

test/npm/safer-buffer.test.mts

@@ -224,142 +224,142 @@ describe(`${eco} > ${sockRegPkgName}`, { skip }, () => {
     for (const impl of implementations) {
       expect(() => {
         impl.Buffer.from(0)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from(10)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from(10, 'utf-8')
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from('string', 'invalid encoding')
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from(-10)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from(1e90)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from(Number.POSITIVE_INFINITY)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from(Number.NEGATIVE_INFINITY)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from(Number.NaN)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from(null)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from(undefined)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from()
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.from({})
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc('')
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc('string')
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc('string', 'utf-8')
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc('b25ldHdvdGhyZWU=', 'base64')
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc(-10)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc(1e90)
-      })
+      }).toThrow()
       // Modern builtin Buffer.alloc does NOT throw.
       // https://github.com/ChALkeR/safer-buffer/issues/16
       expect(() => {
         impl.Buffer.alloc(2 * (1 << 30))
       }).not.toThrow()
       expect(() => {
         impl.Buffer.alloc(Number.POSITIVE_INFINITY)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc(Number.NEGATIVE_INFINITY)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc(null)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc(undefined)
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc()
       }).toThrow()
       expect(() => {
         impl.Buffer.alloc([])
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc([0, 42, 3])
-      })
+      }).toThrow()
       expect(() => {
         impl.Buffer.alloc({})
-      })
+      }).toThrow()
     }
     for (const method of ['allocUnsafe', 'allocUnsafeSlow']) {
       expect(() => {
         dangerous.Buffer[method]('')
-      })
+      }).toThrow()
       expect(() => {
         dangerous.Buffer[method]('string')
-      })
+      }).toThrow()
       expect(() => {
         dangerous.Buffer[method]('string', 'utf-8')
-      })
+      }).toThrow()
       // Modern builtin Buffer.allocUnsafe and Buffer.allocUnsafeSlow do NOT throw.
       // https://github.com/ChALkeR/safer-buffer/issues/16
       expect(() => {
         dangerous.Buffer[method](2 * (1 << 30))
       }).not.toThrow()
       expect(() => {
         dangerous.Buffer[method](Number.POSITIVE_INFINITY)
-      })
+      }).toThrow()
       if (dangerous.Buffer[method] === buffer.Buffer.allocUnsafe) {
         logger.info(
           'Skipping, older impl of allocUnsafe coerced negative sizes to 0',
         )
       } else {
         expect(() => {
           dangerous.Buffer[method](-10)
-        })
+        }).toThrow()
         expect(() => {
           dangerous.Buffer[method](-1e90)
-        })
+        }).toThrow()
         expect(() => {
           dangerous.Buffer[method](Number.NEGATIVE_INFINITY)
-        })
+        }).toThrow()
       }
       expect(() => {
         dangerous.Buffer[method](null)
-      })
+      }).toThrow()
       expect(() => {
         dangerous.Buffer[method](undefined)
-      })
+      }).toThrow()
       expect(() => {
         dangerous.Buffer[method]()
-      })
+      }).toThrow()
       expect(() => {
         dangerous.Buffer[method]([])
-      })
+      }).toThrow()
       expect(() => {
         dangerous.Buffer[method]([0, 42, 3])
-      })
+      }).toThrow()
       expect(() => {
         dangerous.Buffer[method]({})
-      })
+      }).toThrow()
     }
   })
 
@@ -382,8 +382,6 @@ describe(`${eco} > ${sockRegPkgName}`, { skip }, () => {
   })
 
   it('Buffers have appropriate lengths (2)', () => {
-    expect(safer.Buffer.alloc, safer.Buffer.alloc)
-    expect(safer.Buffer.alloc, dangerous.Buffer.alloc)
     let ok = true
     for (const method of [
       safer.Buffer.alloc,
@@ -401,12 +399,10 @@ describe(`${eco} > ${sockRegPkgName}`, { skip }, () => {
         }
       }
     }
-    expect(ok)
+    expect(ok).toBe(true)
   })
 
   it('.alloc(size) is zero-filled and has correct length', () => {
-    expect(safer.Buffer.alloc, safer.Buffer.alloc)
-    expect(safer.Buffer.alloc, dangerous.Buffer.alloc)
     let ok = true
     for (let i = 0; i < 1e2; i += 1) {
       const length = Math.round(Math.random() * 2e6)
@@ -431,7 +427,7 @@ describe(`${eco} > ${sockRegPkgName}`, { skip }, () => {
         }
       }
     }
-    expect(ok)
+    expect(ok).toBe(true)
   })
 
   it('.allocUnsafe / .allocUnsafeSlow are fillable and have correct lengths', () => {
@@ -461,36 +457,11 @@ describe(`${eco} > ${sockRegPkgName}`, { skip }, () => {
           }
         }
       }
-      expect(ok, method)
-    }
-  })
-
-  it('.alloc(size, fill) is `fill`-filled', () => {
-    expect(safer.Buffer.alloc, safer.Buffer.alloc)
-    expect(safer.Buffer.alloc, dangerous.Buffer.alloc)
-    let ok = true
-    for (let i = 0; i < 1e2; i += 1) {
-      const length = Math.round(Math.random() * 2e6)
-      const fill = Math.round(Math.random() * 255)
-      const buf = safer.Buffer.alloc(length, fill)
-      if (!buffer.Buffer.isBuffer(buf)) {
-        ok = false
-      }
-      if (buf.length !== length) {
-        ok = false
-      }
-      for (let j = 0; j < length; j += 1) {
-        if (buf[j] !== fill) {
-          ok = false
-        }
-      }
+      expect(ok).toBe(true)
     }
-    expect(ok)
   })
 
   it('.alloc(size, fill) is `fill`-filled', () => {
-    expect(safer.Buffer.alloc, safer.Buffer.alloc)
-    expect(safer.Buffer.alloc, dangerous.Buffer.alloc)
     let ok = true
     for (let i = 0; i < 1e2; i += 1) {
       const length = Math.round(Math.random() * 2e6)
@@ -508,7 +479,7 @@ describe(`${eco} > ${sockRegPkgName}`, { skip }, () => {
         }
       }
     }
-    expect(ok)
+    expect(ok).toBe(true)
     expect(safer.Buffer.alloc(9, 'a')).toEqual(safer.Buffer.alloc(9, 97))
     expect(safer.Buffer.alloc(9, 'a')).not.toEqual(safer.Buffer.alloc(9, 98))