Fix for CSHARP-379. Have TryParse invoke Parse

Author: sridharn

Bson/BsonUtils.cs

@@ -29,20 +29,43 @@ namespace MongoDB.Bson
     /// </summary>
     public static class BsonUtils
     {
-        // public static methods
+
         /// <summary>
-        /// Parses a hex string to a byte array.
+        /// Parses a hex string into its equivalent byte array.
         /// </summary>
-        /// <param name="s">The hex string.</param>
-        /// <returns>A byte array.</returns>
+        /// <param name="s">The hex string to parse.</param>
+        /// <returns>The byte equivalent of the hex string.</returns>
         public static byte[] ParseHexString(string s)
         {
+            if (string.IsNullOrEmpty(s))
+            {
+                throw new ArgumentNullException("s");
+            }
+
             byte[] bytes;
-            if (!TryParseHexString(s, out bytes))
+            if ((s.Length & 1) != 0) 
+            {
+                s = "0" + s; // make length of s even
+            } 
+            bytes = new byte[s.Length / 2];
+            for (int i = 0; i < bytes.Length; i++)
             {
-                var message = string.Format("'{0}' is not a valid hex string.", s);
-                throw new FormatException(message);
+                string hex = s.Substring(2 * i, 2);
+                try
+                {
+                    byte b = Convert.ToByte(hex, 16);
+                    bytes[i] = b;
+                }
+                catch (FormatException e)
+                {
+                    throw new FormatException(
+                        string.Format("Invalid hex string. Problem with substring {0} starting at position {1}",
+                        hex,
+                        2 * i),
+                        e);
+                }
             }
+
             return bytes;
         }
 
@@ -154,29 +177,17 @@ public static DateTime ToUniversalTime(DateTime dateTime)
         /// <returns>True if the hex string was successfully parsed.</returns>
         public static bool TryParseHexString(string s, out byte[] bytes)
         {
-            if (s != null)
+            try
             {
-                if ((s.Length & 1) != 0) { s = "0" + s; } // make length of s even
-                bytes = new byte[s.Length / 2];
-                for (int i = 0; i < bytes.Length; i++)
-                {
-                    string hex = s.Substring(2 * i, 2);
-                    try
-                    {
-                        byte b = Convert.ToByte(hex, 16);
-                        bytes[i] = b;
-                    }
-                    catch (FormatException)
-                    {
-                        bytes = null;
-                        return false;
-                    }
-                }
-                return true;
+                bytes = ParseHexString(s);
+            }
+            catch
+            {
+                bytes = null;
+                return false;
             }
 
-            bytes = null;
-            return false;
+            return true;
         }
     }
 }

BsonUnitTests/BsonUtilsTests.cs

@@ -83,7 +83,7 @@ public void TestMinToMillisConversion()
         public void TestToUniversalTimeUTCNow()
         {
             var expected = DateTime.UtcNow;
-            var actual = BsonUtils.ToUniversalTime(expected);
+            var actual = BsonUtils.ToUniversalTime(expected.ToLocalTime());
             Assert.AreEqual(expected, actual);
         }
 
@@ -119,5 +119,103 @@ public void TestToHexStringNull()
             var actual = BsonUtils.ToHexString(null);
         }
 
+        [Test]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void TestParseHexStringNull()
+        {
+            var actual = BsonUtils.ParseHexString(null);
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void TestParseHexStringEmpty()
+        {
+            var actual = BsonUtils.ParseHexString(string.Empty);
+        }
+
+        [Test]
+        public void TestParseHexString()
+        {
+            var expected = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 255 };
+            var value = "000102030405060708090a0b0c0d0e0f10ff";
+            var actual = BsonUtils.ParseHexString(value);
+            Assert.AreEqual(expected, actual);
+        }
+
+        [Test]
+        public void TestParseHexStringOdd()
+        {
+            var expected = new byte[] { 0, 15 };
+            var value = "00f";
+            var actual = BsonUtils.ParseHexString(value);
+            Assert.AreEqual(expected, actual);
+        }
+
+        [Test]
+        [ExpectedException(typeof(FormatException))]
+        public void TestParseHexStringInvalid()
+        {
+            var actual = BsonUtils.ParseHexString("1G");
+        }
+
+        [Test]
+        [ExpectedException(typeof(FormatException))]
+        public void TestParseHexStringInvalid2()
+        {
+            var actual = BsonUtils.ParseHexString("00 1");
+        }
+
+        [Test]
+        public void TestTryParseHexStringNull()
+        {
+            byte[] expected;
+            BsonUtils.TryParseHexString(null, out expected);
+            Assert.IsNull(expected);
+        }
+
+        [Test]
+        public void TestTryParseHexStringEmpty()
+        {
+            byte[] expected;
+            var actual = BsonUtils.TryParseHexString(string.Empty, out expected);
+            Assert.IsNull(expected);
+        }
+
+        [Test]
+        public void TestTryParseHexString()
+        {
+            var expected = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 255 };
+            var value = "000102030405060708090a0b0c0d0e0f10ff";
+            byte[] actual;
+            BsonUtils.TryParseHexString(value, out actual);
+            Assert.AreEqual(expected, actual);
+        }
+
+        [Test]
+        public void TestTryParseHexStringOdd()
+        {
+            var expected = new byte[] { 0, 15 };
+            var value = "00f";
+            byte[] actual;
+            BsonUtils.TryParseHexString(value, out actual);
+            Assert.AreEqual(expected, actual);
+        }
+
+        [Test]
+        public void TestTryParseHexStringInvalid()
+        {
+            byte[] expected;
+            var actual = BsonUtils.TryParseHexString("1G", out expected);
+            Assert.IsNull(expected);
+        }
+
+        [Test]
+        public void TestTryParseHexStringInvalid2()
+        {
+            byte[] expected;
+            var actual = BsonUtils.TryParseHexString("00 1", out expected);
+            Assert.IsNull(expected);
+        }
+
     }
 }