Add BigInteger.Rotate* tests

Author: kzrnm

src/libraries/System.Runtime.Numerics/tests/BigInteger/MyBigInt.cs

@@ -110,6 +110,10 @@ public static BigInteger DoBinaryOperatorMine(BigInteger num1, BigInteger num2,
                     return new BigInteger(ShiftLeft(bytes1, Negate(bytes2)).ToArray());
                 case "b<<":
                     return new BigInteger(ShiftLeft(bytes1, bytes2).ToArray());
+                case "bRotateLeft":
+                    return new BigInteger(RotateLeft(bytes1, bytes2).ToArray());
+                case "bRotateRight":
+                    return new BigInteger(RotateLeft(bytes1, Negate(bytes2)).ToArray());
                 case "b^":
                     return new BigInteger(Xor(bytes1, bytes2).ToArray());
                 case "b|":
@@ -774,6 +778,105 @@ public static List<byte> ShiftRight(List<byte> bytes)
             return bresult;
         }
 
+        public static List<byte> RotateRight(List<byte> bytes)
+        {
+            List<byte> bresult = new List<byte>();
+
+            byte bottom = (byte)(bytes[0] & 0x01);
+
+            for (int i = 0; i < bytes.Count; i++)
+            {
+                byte newbyte = bytes[i];
+
+                newbyte = (byte)(newbyte / 2);
+                if ((i != (bytes.Count - 1)) && ((bytes[i + 1] & 0x01) == 1))
+                {
+                    newbyte += 128;
+                }
+                if ((i == (bytes.Count - 1)) && (bottom != 0))
+                {
+                    newbyte += 128;
+                }
+                bresult.Add(newbyte);
+            }
+
+            return bresult;
+        }
+
+        public static List<byte> RotateLeft(List<byte> bytes)
+        {
+            List<byte> bresult = new List<byte>();
+
+            bool prevHead = (bytes[bytes.Count - 1] & 0x80) != 0;
+
+            for (int i = 0; i < bytes.Count; i++)
+            {
+                byte newbyte = bytes[i];
+
+                newbyte = (byte)(newbyte * 2);
+                if (prevHead)
+                {
+                    newbyte += 1;
+                }
+
+                bresult.Add(newbyte);
+
+                prevHead = (bytes[i] & 0x80) != 0;
+            }
+
+            return bresult;
+        }
+
+
+        public static List<byte> RotateLeft(List<byte> bytes1, List<byte> bytes2)
+        {
+            List<byte> bytes1Copy = Copy(bytes1);
+            int byteShift = (int)new BigInteger(Divide(Copy(bytes2), new List<byte>(new byte[] { 8 })).ToArray());
+            sbyte bitShift = (sbyte)new BigInteger(Remainder(bytes2, new List<byte>(new byte[] { 8 })).ToArray());
+
+            Trim(bytes1);
+
+            byte fill = (bytes1[bytes1.Count - 1] & 0x80) != 0 ? byte.MaxValue : (byte)0;
+
+            if (fill == 0 && bytes1.Count > 1 && bytes1[bytes1.Count - 1] == 0)
+                bytes1.RemoveAt(bytes1.Count - 1);
+
+            while (bytes1.Count % 4 != 0)
+            {
+                bytes1.Add(fill);
+            }
+
+            byteShift %= bytes1.Count;
+            if (byteShift == 0 && bitShift == 0)
+                return bytes1Copy;
+
+            for (int i = 0; i < Math.Abs(bitShift); i++)
+            {
+                if (bitShift < 0)
+                {
+                    bytes1 = RotateRight(bytes1);
+                }
+                else
+                {
+                    bytes1 = RotateLeft(bytes1);
+                }
+            }
+
+            List<byte> temp = new List<byte>();
+            for (int i = 0; i < bytes1.Count; i++)
+            {
+                temp.Add(bytes1[(i - byteShift + bytes1.Count) % bytes1.Count]);
+            }
+            bytes1 = temp;
+
+            if (fill == 0)
+                bytes1.Add(0);
+
+            Trim(bytes1);
+
+            return bytes1;
+        }
+
         public static List<byte> SetLength(List<byte> bytes, int size)
         {
             List<byte> bresult = new List<byte>();