Fix bit-or and bit-xor for two negative bigints.

runtime/vm/bigint_operations_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/unit_test.h"
 
@@ skipping 1012 matching lines @@
                    "0x4000000000000000");
   TestBigintBitAnd("0x123456789ABCDEF01234567890",
                    "0x4000000000000000",  // Max Smi for 64 bits + 1.
                    "0x0");
 }
 
 
 static void TestBigintBitOr(const char* a, const char* b, const char* result) {
   const Bigint& bigint_a = Bigint::Handle(BigintOperations::NewFromCString(a));
   const Bigint& bigint_b = Bigint::Handle(BigintOperations::NewFromCString(b));
-  const Bigint& anded =
+  const Bigint& ored =
       Bigint::Handle(BigintOperations::BitOr(bigint_a, bigint_b));
-  const char* str_anded = BigintOperations::ToHexCString(anded, &ZoneAllocator);
-  EXPECT_STREQ(result, str_anded);
-  const Bigint& anded2 =
+  const char* str_ored = BigintOperations::ToHexCString(ored, &ZoneAllocator);
+  EXPECT_STREQ(result, str_ored);
+  const Bigint& ored2 =
       Bigint::Handle(BigintOperations::BitOr(bigint_b, bigint_a));
-  const char* str_anded2 = BigintOperations::ToHexCString(anded2,
-                                                          &ZoneAllocator);
-  EXPECT_STREQ(result, str_anded2);
+  const char* str_ored2 = BigintOperations::ToHexCString(ored2, &ZoneAllocator);
+  EXPECT_STREQ(result, str_ored2);
 }
 
 
 TEST_CASE(BigintBitOr) {
   const char* zero = "0x0";
   const char* one = "0x1";
   const char* minus_one = "-0x1";
 
   TestBigintBitOr(one, zero, one);
   TestBigintBitOr(one, one, one);
@@ skipping 45 matching lines @@
   TestBigintBitOr("-0x100000000000000",
                    "-0x100000000000000",
                    "-0x100000000000000");
   TestBigintBitOr("-0x10000000000000000",
                    "-0x10000000000000000",
                    "-0x10000000000000000");
   TestBigintBitOr("-0x10000000", "-0x10000001", "-0x1");
   TestBigintBitOr("-0x100000000", "-0x100000001", "-0x1");
   TestBigintBitOr("-0x100000000000000", "-0x100000000000001", "-0x1");
   TestBigintBitOr("-0x10000000000000000", "-0x10000000000000001", "-0x1");
+  TestBigintBitOr("-0x10000000000000000", "-0x1", "-0x1");
 }
 
 
 static void TestBigintBitXor(const char* a, const char* b, const char* result) {
   const Bigint& bigint_a = Bigint::Handle(BigintOperations::NewFromCString(a));
   const Bigint& bigint_b = Bigint::Handle(BigintOperations::NewFromCString(b));
   const Bigint& xored =
       Bigint::Handle(BigintOperations::BitXor(bigint_a, bigint_b));
   const char* str_xored = BigintOperations::ToHexCString(xored, &ZoneAllocator);
   EXPECT_STREQ(result, str_xored);
   const Bigint& xored2 =
       Bigint::Handle(BigintOperations::BitXor(bigint_b, bigint_a));
   const char* str_xored2 = BigintOperations::ToHexCString(xored2,
                                                           &ZoneAllocator);
   EXPECT_STREQ(result, str_xored2);
+  const Bigint& xored3 =
+      Bigint::Handle(BigintOperations::BitXor(bigint_a, xored2));
+  const char* str_xored3 = BigintOperations::ToHexCString(xored3,
+                                                          &ZoneAllocator);
+  EXPECT_STREQ(b, str_xored3);
+  const Bigint& xored4 =
+      Bigint::Handle(BigintOperations::BitXor(xored2, bigint_a));
+  const char* str_xored4 = BigintOperations::ToHexCString(xored4,
+                                                          &ZoneAllocator);
+  EXPECT_STREQ(b, str_xored4);
+  const Bigint& xored5 =
+      Bigint::Handle(BigintOperations::BitXor(bigint_b, xored2));
+  const char* str_xored5 = BigintOperations::ToHexCString(xored5,
+                                                          &ZoneAllocator);
+  EXPECT_STREQ(a, str_xored5);
+  const Bigint& xored6 =
+      Bigint::Handle(BigintOperations::BitXor(xored2, bigint_b));
+  const char* str_xored6 = BigintOperations::ToHexCString(xored6,
+                                                          &ZoneAllocator);
+  EXPECT_STREQ(a, str_xored6);
 }
 
 
 TEST_CASE(BigintBitXor) {
   const char* zero = "0x0";
   const char* one = "0x1";
   const char* minus_one = "-0x1";
 
   TestBigintBitXor(one, zero, one);
   TestBigintBitXor(one, one, zero);
@@ skipping 976 matching lines @@
       "123456789012345678901234567890123456789012345678901234567890123456789012"
       "345678901234567890123456789012345678901234567890123456789012345678901234"
       "567890123456789012345678901234567890123456789012345678901234567890123456"
       "789012345678901234567890123456789012345678901234567890123456789012345678"
       "90123456789012345678901234567890",
       "0x1234567890ABCDEF01234567890ABCDEF01234567890ABCDEF01234567890ABCDEF"
       "01234567890ABCDEE");
 }
 
 }  // namespace dart