fix: correct divRound rounding for negative operands

lib/bn.js

@@ -2014,7 +2014,10 @@
       this.words[i] = carry;
       this.length++;
     }
-    this.length = num === 0 ? 1 : this.length;
+    if (num === 0) {
+      this.length = 1;
+      this._normSign();
+    }
 
     return isNegNum ? this.ineg() : this;
   };
@@ -2553,17 +2556,19 @@
     // Fast case - exact division
     if (dm.mod.isZero()) return dm.div;
 
-    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
+    var mod = dm.mod.abs();
 
-    var half = num.ushrn(1);
-    var r2 = num.andln(1);
+    var half = num.abs().iushrn(1);
+    var r2 = num.words[0] & 1;
     var cmp = mod.cmp(half);
 
     // Round down
     if (cmp < 0 || (r2 === 1 && cmp === 0)) return dm.div;
 
-    // Round up
-    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
+    // Round up, away from zero
+    var up = new BN(1);
+    up.negative = this.negative ^ num.negative;
+    return dm.div.iadd(up);
   };
 
   BN.prototype.modrn = function modrn (num) {

test/arithmetic-test.js

@@ -315,6 +315,15 @@ describe('BN.js/Arithmetic', function () {
       assert.equal(b.clone().imuln(0).isZero(), true);
       assert.equal(b.clone().muln(0).isZero(), true);
     });
+
+    it('should not keep the sign when multiplying a negative by zero', function () {
+      var a = new BN(-42);
+      assert.equal(a.clone().imuln(0).negative, 0);
+      assert.equal(a.clone().imuln(0).toString(), '0');
+      assert.equal(a.clone().muln(0).toString(), '0');
+      assert.equal(a.clone().muln(0).isNeg(), false);
+      assert.equal(a.clone().muln(0).eq(new BN(0)), true);
+    });
   });
 
   describe('.pow()', function () {
@@ -450,8 +459,70 @@ describe('BN.js/Arithmetic', function () {
         '-8');
     });
 
+    it('should round with negative operands', function () {
+      assert.equal(new BN(-40).divRound(new BN(-13)).toString(10), '3');
+      assert.equal(new BN(40).divRound(new BN(-13)).toString(10), '-3');
+      assert.equal(new BN(-40).divRound(new BN(13)).toString(10), '-3');
+      assert.equal(new BN(-30).divRound(new BN(40)).toString(10), '-1');
+      assert.equal(new BN(30).divRound(new BN(-40)).toString(10), '-1');
+      assert.equal(new BN(-7).divRound(new BN(2)).toString(10), '-4');
+      assert.equal(new BN(7).divRound(new BN(-2)).toString(10), '-4');
+      assert.equal(new BN(-25).divRound(new BN(10)).toString(10), '-3');
+      // odd divisor, remainder exactly floor(|divisor| / 2): round toward zero
+      assert.equal(new BN(-4).divRound(new BN(3)).toString(10), '-1');
+      assert.equal(new BN(4).divRound(new BN(-3)).toString(10), '-1');
+      assert.equal(new BN(-7).divRound(new BN(5)).toString(10), '-1');
+      assert.equal(new BN(7).divRound(new BN(-5)).toString(10), '-1');
+    });
+
+    it('should round values smaller than the divisor', function () {
+      assert.equal(new BN(4).divRound(new BN(10)).toString(10), '0');
+      assert.equal(new BN(-4).divRound(new BN(10)).toString(10), '0');
+      assert.equal(new BN(4).divRound(new BN(-10)).toString(10), '0');
+      assert.equal(new BN(6).divRound(new BN(10)).toString(10), '1');
+      assert.equal(new BN(-6).divRound(new BN(10)).toString(10), '-1');
+      assert.equal(new BN(6).divRound(new BN(-10)).toString(10), '-1');
+    });
+
+    it('should round with large multi-word operands', function () {
+      assert.equal(
+        new BN('123456789012345678901234567890')
+          .divRound(new BN('98765432109876543210')).toString(10),
+        '1249999989');
+      assert.equal(
+        new BN('-123456789012345678901234567890')
+          .divRound(new BN('98765432109876543210')).toString(10),
+        '-1249999989');
+      assert.equal(
+        new BN('123456789012345678901234567890')
+          .divRound(new BN('-98765432109876543210')).toString(10),
+        '-1249999989');
+      assert.equal(
+        new BN('-123456789012345678901234567890')
+          .divRound(new BN('-98765432109876543210')).toString(10),
+        '1249999989');
+    });
+
+    it('should round large multi-word ties away from zero', function () {
+      assert.equal(
+        new BN('3048315750647767350192043944016156078651272672090')
+          .divRound(new BN('246913578024691357802469135780')).toString(10),
+        '12345678901234567891');
+      assert.equal(
+        new BN('-3048315750647767350192043944016156078651272672090')
+          .divRound(new BN('246913578024691357802469135780')).toString(10),
+        '-12345678901234567891');
+      assert.equal(
+        new BN('3048315750647767350192043944016156078651272672090')
+          .divRound(new BN('-246913578024691357802469135780')).toString(10),
+        '-12345678901234567891');
+    });
+
     it('should return 1 on exact division', function () {
       assert.equal(new BN(144).divRound(new BN(144)).toString(10), '1');
+      assert.equal(new BN(-144).divRound(new BN(144)).toString(10), '-1');
+      assert.equal(new BN(144).divRound(new BN(-144)).toString(10), '-1');
+      assert.equal(new BN(-144).divRound(new BN(-144)).toString(10), '1');
     });
   });