Update third_party/protobuf to protobuf-v3.0.0-beta-3

third_party/protobuf/csharp/src/Google.Protobuf.Test/JsonParserTest.cs

 #region Copyright notice and license
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
@@ skipping 21 matching lines @@
 
 using Google.Protobuf.Reflection;
 using Google.Protobuf.TestProtos;
 using Google.Protobuf.WellKnownTypes;
 using NUnit.Framework;
 using System;
 
 namespace Google.Protobuf
 {
     /// <summary>
-    /// Unit tests for JSON parsing. Some tests are ignored at the moment as the desired behaviour
-    /// isn't fully known, either in terms of which exceptions should be thrown or whether they should
-    /// count as valid values.
+    /// Unit tests for JSON parsing.
     /// </summary>
     public class JsonParserTest
     {
         // Sanity smoke test
         [Test]
         public void AllTypesRoundtrip()
         {
             AssertRoundtrip(SampleMessages.CreateFullTestAllTypes());
         }
 
@@ skipping 12 matching lines @@
         [TestCase("1.5")]
         public void IntegerMapKeysAreStrict(string keyText)
         {
             // Test that integer parsing is strict. We assume that if this is correct for int32,
             // it's correct for other numeric key types.
             var json = "{ \"mapInt32Int32\": { \"" + keyText + "\" : \"1\" } }";
             Assert.Throws<InvalidProtocolBufferException>(() => JsonParser.Default.Parse<TestMap>(json));
         }
 
         [Test]
+        public void OriginalFieldNameAccepted()
+        {
+            var json = "{ \"single_int32\": 10 }";
+            var expected = new TestAllTypes { SingleInt32 = 10 };
+            Assert.AreEqual(expected, TestAllTypes.Parser.ParseJson(json));
+        }
+
+        [Test]
         public void SourceContextRoundtrip()
         {
             AssertRoundtrip(new SourceContext { FileName = "foo.proto" });
         }
 
         [Test]
         public void SingularWrappers_DefaultNonNullValues()
         {
             var message = new TestWellKnownTypes
             {
@@ skipping 24 matching lines @@
                 Int64Field = 2,
                 Uint32Field = 3,
                 Uint64Field = 4
             };
             AssertRoundtrip(message);
         }
 
         [Test]
         public void SingularWrappers_ExplicitNulls()
         {
-            var message = new TestWellKnownTypes();
+            // When we parse the "valueField": null part, we remember it... basically, it's one case
+            // where explicit default values don't fully roundtrip.
+            var message = new TestWellKnownTypes { ValueField = Value.ForNull() };
             var json = new JsonFormatter(new JsonFormatter.Settings(true)).Format(message);
             var parsed = JsonParser.Default.Parse<TestWellKnownTypes>(json);
             Assert.AreEqual(message, parsed);
         }
 
         [Test]
         [TestCase(typeof(Int32Value), "32", 32)]
         [TestCase(typeof(Int64Value), "32", 32L)]
         [TestCase(typeof(UInt32Value), "32", 32U)]
         [TestCase(typeof(UInt64Value), "32", 32UL)]
         [TestCase(typeof(StringValue), "\"foo\"", "foo")]
         [TestCase(typeof(FloatValue), "1.5", 1.5f)]
         [TestCase(typeof(DoubleValue), "1.5", 1.5d)]
         public void Wrappers_Standalone(System.Type wrapperType, string json, object expectedValue)
         {
-            IMessage parsed = (IMessage) Activator.CreateInstance(wrapperType);
-            IMessage expected = (IMessage) Activator.CreateInstance(wrapperType);
+            IMessage parsed = (IMessage)Activator.CreateInstance(wrapperType);
+            IMessage expected = (IMessage)Activator.CreateInstance(wrapperType);
             JsonParser.Default.Merge(parsed, "null");
             Assert.AreEqual(expected, parsed);
 
             JsonParser.Default.Merge(parsed, json);
             expected.Descriptor.Fields[WrappersReflection.WrapperValueFieldNumber].Accessor.SetValue(expected, expectedValue);
             Assert.AreEqual(expected, parsed);
         }
 
         [Test]
+        public void ExplicitNullValue()
+        {
+            string json = "{\"valueField\": null}";
+            var message = JsonParser.Default.Parse<TestWellKnownTypes>(json);
+            Assert.AreEqual(new TestWellKnownTypes { ValueField = Value.ForNull() }, message);
+        }
+
+        [Test]
         public void BytesWrapper_Standalone()
         {
             ByteString data = ByteString.CopyFrom(1, 2, 3);
             // Can't do this with attributes...
-            var parsed = JsonParser.Default.Parse<BytesValue>("\"" + data.ToBase64() + "\"");
+            var parsed = JsonParser.Default.Parse<BytesValue>(WrapInQuotes(data.ToBase64()));
             var expected = new BytesValue { Value = data };
             Assert.AreEqual(expected, parsed);
         }
 
         [Test]
         public void RepeatedWrappers()
         {
             var message = new RepeatedWellKnownTypes
             {
                 BoolField = { true, false },
                 BytesField = { ByteString.CopyFrom(1, 2, 3), ByteString.CopyFrom(4, 5, 6), ByteString.Empty },
                 DoubleField = { 12.5, -1.5, 0d },
                 FloatField = { 123.25f, -20f, 0f },
                 Int32Field = { int.MaxValue, int.MinValue, 0 },
                 Int64Field = { long.MaxValue, long.MinValue, 0L },
                 StringField = { "First", "Second", "" },
                 Uint32Field = { uint.MaxValue, uint.MinValue, 0U },
                 Uint64Field = { ulong.MaxValue, ulong.MinValue, 0UL },
             };
             AssertRoundtrip(message);
         }
 
         [Test]
+        public void RepeatedField_NullElementProhibited()
+        {
+            string json = "{ \"repeated_foreign_message\": [null] }";
+            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
+        }
+
+        [Test]
+        public void RepeatedField_NullOverallValueAllowed()
+        {
+            string json = "{ \"repeated_foreign_message\": null }";
+            Assert.AreEqual(new TestAllTypes(), TestAllTypes.Parser.ParseJson(json));
+        }
+
+        [Test]
+        [TestCase("{ \"mapInt32Int32\": { \"10\": null }")]
+        [TestCase("{ \"mapStringString\": { \"abc\": null }")]
+        [TestCase("{ \"mapInt32ForeignMessage\": { \"10\": null }")]
+        public void MapField_NullValueProhibited(string json)
+        {
+            Assert.Throws<InvalidProtocolBufferException>(() => TestMap.Parser.ParseJson(json));
+        }
+
+        [Test]
+        public void MapField_NullOverallValueAllowed()
+        {
+            string json = "{ \"mapInt32Int32\": null }";
+            Assert.AreEqual(new TestMap(), TestMap.Parser.ParseJson(json));
+        }
+
+        [Test]
         public void IndividualWrapperTypes()
         {
             Assert.AreEqual(new StringValue { Value = "foo" }, StringValue.Parser.ParseJson("\"foo\""));
             Assert.AreEqual(new Int32Value { Value = 1 }, Int32Value.Parser.ParseJson("1"));
             // Can parse strings directly too
             Assert.AreEqual(new Int32Value { Value = 1 }, Int32Value.Parser.ParseJson("\"1\""));
         }
 
         private static void AssertRoundtrip<T>(T message) where T : IMessage<T>, new()
         {
             var clone = message.Clone();
-            var json = message.ToString();
+            var json = JsonFormatter.Default.Format(message);
             var parsed = JsonParser.Default.Parse<T>(json);
             Assert.AreEqual(clone, parsed);
         }
 
         [Test]
         [TestCase("0", 0)]
         [TestCase("-0", 0)] // Not entirely clear whether we intend to allow this...
         [TestCase("1", 1)]
         [TestCase("-1", -1)]
         [TestCase("2147483647", 2147483647)]
         [TestCase("-2147483648", -2147483648)]
         public void StringToInt32_Valid(string jsonValue, int expectedParsedValue)
         {
             string json = "{ \"singleInt32\": \"" + jsonValue + "\"}";
             var parsed = TestAllTypes.Parser.ParseJson(json);
             Assert.AreEqual(expectedParsedValue, parsed.SingleInt32);
         }
 
         [Test]
         [TestCase("+0")]
+        [TestCase(" 1")]
+        [TestCase("1 ")]
         [TestCase("00")]
         [TestCase("-00")]
         [TestCase("--1")]
         [TestCase("+1")]
         [TestCase("1.5")]
         [TestCase("1e10")]
         [TestCase("2147483648")]
         [TestCase("-2147483649")]
         public void StringToInt32_Invalid(string jsonValue)
         {
@@ skipping 93 matching lines @@
         }
 
         [Test]
         [TestCase("1.7977e308")]
         [TestCase("-1.7977e308")]
         [TestCase("1e309")]
         [TestCase("1,0")]
         [TestCase("1.0.0")]
         [TestCase("+1")]
         [TestCase("00")]
+        [TestCase("01")]
+        [TestCase("-00")]
+        [TestCase("-01")]
         [TestCase("--1")]
+        [TestCase(" Infinity")]
+        [TestCase(" -Infinity")]
+        [TestCase("NaN ")]
+        [TestCase("Infinity ")]
+        [TestCase("-Infinity ")]
+        [TestCase(" NaN")]
+        [TestCase("INFINITY")]
+        [TestCase("nan")]
         [TestCase("\u00BD")] // 1/2 as a single Unicode character. Just sanity checking...
         public void StringToDouble_Invalid(string jsonValue)
         {
             string json = "{ \"singleDouble\": \"" + jsonValue + "\"}";
             Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
         }
 
         [Test]
         [TestCase("0", 0f)]
         [TestCase("1", 1f)]
@@ skipping 24 matching lines @@
             Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
         }
 
         [Test]
         [TestCase("0", 0)]
         [TestCase("-0", 0)] // Not entirely clear whether we intend to allow this...
         [TestCase("1", 1)]
         [TestCase("-1", -1)]
         [TestCase("2147483647", 2147483647)]
         [TestCase("-2147483648", -2147483648)]
+        [TestCase("1e1", 10)]
+        [TestCase("-1e1", -10)]
+        [TestCase("10.00", 10)]
+        [TestCase("-10.00", -10)]
         public void NumberToInt32_Valid(string jsonValue, int expectedParsedValue)
         {
             string json = "{ \"singleInt32\": " + jsonValue + "}";
             var parsed = TestAllTypes.Parser.ParseJson(json);
             Assert.AreEqual(expectedParsedValue, parsed.SingleInt32);
         }
 
         [Test]
         [TestCase("+0", typeof(InvalidJsonException))]
         [TestCase("00", typeof(InvalidJsonException))]
         [TestCase("-00", typeof(InvalidJsonException))]
         [TestCase("--1", typeof(InvalidJsonException))]
         [TestCase("+1", typeof(InvalidJsonException))]
-        [TestCase("1.5", typeof(InvalidProtocolBufferException), Ignore = true, Reason = "Desired behaviour unclear")]
+        [TestCase("1.5", typeof(InvalidProtocolBufferException))]
+        // Value is out of range
         [TestCase("1e10", typeof(InvalidProtocolBufferException))]
         [TestCase("2147483648", typeof(InvalidProtocolBufferException))]
         [TestCase("-2147483649", typeof(InvalidProtocolBufferException))]
         public void NumberToInt32_Invalid(string jsonValue, System.Type expectedExceptionType)
         {
             string json = "{ \"singleInt32\": " + jsonValue + "}";
             Assert.Throws(expectedExceptionType, () => TestAllTypes.Parser.ParseJson(json));
         }
 
         [Test]
@@ skipping 14 matching lines @@
         public void NumberToUInt32_Invalid(string jsonValue)
         {
             string json = "{ \"singleUint32\": " + jsonValue + "}";
             Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
         }
 
         [Test]
         [TestCase("0", 0L)]
         [TestCase("1", 1L)]
         [TestCase("-1", -1L)]
-        [TestCase("9223372036854775807", 9223372036854775807, Ignore = true, Reason = "Desired behaviour unclear")]
-        [TestCase("-9223372036854775808", -9223372036854775808, Ignore = true, Reason = "Desired behaviour unclear")]
+        // long.MaxValue isn't actually representable as a double. This string value is the highest
+        // representable value which isn't greater than long.MaxValue.
+        [TestCase("9223372036854774784", 9223372036854774784)]
+        [TestCase("-9223372036854775808", -9223372036854775808)]
         public void NumberToInt64_Valid(string jsonValue, long expectedParsedValue)
         {
             string json = "{ \"singleInt64\": " + jsonValue + "}";
             var parsed = TestAllTypes.Parser.ParseJson(json);
             Assert.AreEqual(expectedParsedValue, parsed.SingleInt64);
         }
 
         // Assume that anything non-bounds-related is covered in the Int32 case
         [Test]
-        [TestCase("-9223372036854775809", Ignore = true, Reason = "Desired behaviour unclear")]
-        [TestCase("9223372036854775808", Ignore = true, Reason = "Desired behaviour unclear")]
+        [TestCase("9223372036854775808")]
+        // Theoretical bound would be -9223372036854775809, but when that is parsed to a double
+        // we end up with the exact value of long.MinValue due to lack of precision. The value here
+        // is the "next double down".
+        [TestCase("-9223372036854780000")]
         public void NumberToInt64_Invalid(string jsonValue)
         {
             string json = "{ \"singleInt64\": " + jsonValue + "}";
             Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
         }
 
         [Test]
         [TestCase("0", 0UL)]
         [TestCase("1", 1UL)]
-        [TestCase("18446744073709551615", 18446744073709551615, Ignore = true, Reason = "Desired behaviour unclear")]
+        // ulong.MaxValue isn't representable as a double. This value is the largest double within
+        // the range of ulong.
+        [TestCase("18446744073709549568", 18446744073709549568UL)]
         public void NumberToUInt64_Valid(string jsonValue, ulong expectedParsedValue)
         {
             string json = "{ \"singleUint64\": " + jsonValue + "}";
             var parsed = TestAllTypes.Parser.ParseJson(json);
             Assert.AreEqual(expectedParsedValue, parsed.SingleUint64);
         }
 
         // Assume that anything non-bounds-related is covered in the Int32 case
         [Test]
         [TestCase("-1")]
@@ skipping 21 matching lines @@
         [TestCase("1.79769e308", 1.79769e308)]
         [TestCase("-1.79769e308", -1.79769e308)]
         public void NumberToDouble_Valid(string jsonValue, double expectedParsedValue)
         {
             string json = "{ \"singleDouble\": " + jsonValue + "}";
             var parsed = TestAllTypes.Parser.ParseJson(json);
             Assert.AreEqual(expectedParsedValue, parsed.SingleDouble);
         }
 
         [Test]
-        [TestCase("1.7977e308", Ignore = true, Reason = "Desired behaviour unclear")]
-        [TestCase("-1.7977e308", Ignore = true, Reason = "Desired behaviour unclear")]
-        [TestCase("1e309", Ignore = true, Reason = "Desired behaviour unclear")]
+        [TestCase("1.7977e308")]
+        [TestCase("-1.7977e308")]
+        [TestCase("1e309")]
         [TestCase("1,0")]
         [TestCase("1.0.0")]
         [TestCase("+1")]
         [TestCase("00")]
         [TestCase("--1")]
         [TestCase("\u00BD")] // 1/2 as a single Unicode character. Just sanity checking...
         public void NumberToDouble_Invalid(string jsonValue)
         {
             string json = "{ \"singleDouble\": " + jsonValue + "}";
             Assert.Throws<InvalidJsonException>(() => TestAllTypes.Parser.ParseJson(json));
@@ skipping 67 matching lines @@
         [TestCase("2015-10-08T20:46:23.123456789-18:00", "2015-10-09T14:46:23.123456789Z")]
 
         // Leap years and min/max
         [TestCase("2016-02-29T14:46:23.123456789Z", null)]
         [TestCase("2000-02-29T14:46:23.123456789Z", null)]
         [TestCase("0001-01-01T00:00:00Z", null)]
         [TestCase("9999-12-31T23:59:59.999999999Z", null)]
         public void Timestamp_Valid(string jsonValue, string expectedFormatted)
         {
             expectedFormatted = expectedFormatted ?? jsonValue;
-            string json = "\"" + jsonValue + "\"";
+            string json = WrapInQuotes(jsonValue);
             var parsed = Timestamp.Parser.ParseJson(json);
-            Assert.AreEqual(expectedFormatted, parsed.ToString());
+            Assert.AreEqual(WrapInQuotes(expectedFormatted), parsed.ToString());
         }
-        
+
         [Test]
         [TestCase("2015-10-09 14:46:23.123456789Z", Description = "No T between date and time")]
         [TestCase("2015/10/09T14:46:23.123456789Z", Description = "Wrong date separators")]
         [TestCase("2015-10-09T14.46.23.123456789Z", Description = "Wrong time separators")]
         [TestCase("2015-10-09T14:46:23,123456789Z", Description = "Wrong fractional second separators (valid ISO-8601 though)")]
         [TestCase(" 2015-10-09T14:46:23.123456789Z", Description = "Whitespace at start")]
         [TestCase("2015-10-09T14:46:23.123456789Z ", Description = "Whitespace at end")]
         [TestCase("2015-10-09T14:46:23.1234567890", Description = "Too many digits")]
         [TestCase("2015-10-09T14:46:23.123456789", Description = "No offset")]
         [TestCase("2015-13-09T14:46:23.123456789Z", Description = "Invalid month")]
         [TestCase("2015-10-32T14:46:23.123456789Z", Description = "Invalid day")]
         [TestCase("2015-10-09T24:00:00.000000000Z", Description = "Invalid hour (valid ISO-8601 though)")]
         [TestCase("2015-10-09T14:60:23.123456789Z", Description = "Invalid minutes")]
         [TestCase("2015-10-09T14:46:60.123456789Z", Description = "Invalid seconds")]
         [TestCase("2015-10-09T14:46:23.123456789+18:01", Description = "Offset too large (positive)")]
         [TestCase("2015-10-09T14:46:23.123456789-18:01", Description = "Offset too large (negative)")]
         [TestCase("2015-10-09T14:46:23.123456789-00:00", Description = "Local offset (-00:00) makes no sense here")]
         [TestCase("0001-01-01T00:00:00+00:01", Description = "Value before earliest when offset applied")]
         [TestCase("9999-12-31T23:59:59.999999999-00:01", Description = "Value after latest when offset applied")]
         [TestCase("2100-02-29T14:46:23.123456789Z", Description = "Feb 29th on a non-leap-year")]
         public void Timestamp_Invalid(string jsonValue)
         {
-            string json = "\"" + jsonValue + "\"";
+            string json = WrapInQuotes(jsonValue);
             Assert.Throws<InvalidProtocolBufferException>(() => Timestamp.Parser.ParseJson(json));
         }
 
         [Test]
         public void StructValue_Null()
         {
             Assert.AreEqual(new Value { NullValue = 0 }, Value.Parser.ParseJson("null"));
         }
 
         [Test]
@@ skipping 53 matching lines @@
         [TestCase("0.123s", null)]
         [TestCase("-0.123s", null)]
         [TestCase("123456.123s", null)]
         [TestCase("-123456.123s", null)]
         // Upper and lower bounds
         [TestCase("315576000000s", null)]
         [TestCase("-315576000000s", null)]
         public void Duration_Valid(string jsonValue, string expectedFormatted)
         {
             expectedFormatted = expectedFormatted ?? jsonValue;
-            string json = "\"" + jsonValue + "\"";
+            string json = WrapInQuotes(jsonValue);
             var parsed = Duration.Parser.ParseJson(json);
-            Assert.AreEqual(expectedFormatted, parsed.ToString());
+            Assert.AreEqual(WrapInQuotes(expectedFormatted), parsed.ToString());
         }
 
         // The simplest way of testing that the value has parsed correctly is to reformat it,
         // as we trust the formatting. In many cases that will give the same result as the input,
         // so in those cases we accept an expectedFormatted value of null. Sometimes the results
         // will be different though, due to a different number of digits being provided.
         [Test]
         [TestCase("1.1234567890s", Description = "Too many digits")]
         [TestCase("1.123456789", Description = "No suffix")]
         [TestCase("1.123456789ss", Description = "Too much suffix")]
         [TestCase("1.123456789S", Description = "Upper case suffix")]
         [TestCase("+1.123456789s", Description = "Leading +")]
         [TestCase(".123456789s", Description = "No integer before the fraction")]
         [TestCase("1,123456789s", Description = "Comma as decimal separator")]
         [TestCase("1x1.123456789s", Description = "Non-digit in integer part")]
         [TestCase("1.1x3456789s", Description = "Non-digit in fractional part")]
         [TestCase(" 1.123456789s", Description = "Whitespace before fraction")]
         [TestCase("1.123456789s ", Description = "Whitespace after value")]
         [TestCase("01.123456789s", Description = "Leading zero (positive)")]
         [TestCase("-01.123456789s", Description = "Leading zero (negative)")]
         [TestCase("--0.123456789s", Description = "Double minus sign")]
         // Violate upper/lower bounds in various ways
         [TestCase("315576000001s", Description = "Integer part too large")]
-        [TestCase("315576000000.000000001s", Description = "Integer part is upper bound; non-zero fraction")]
         [TestCase("3155760000000s", Description = "Integer part too long (positive)")]
         [TestCase("-3155760000000s", Description = "Integer part too long (negative)")]
         public void Duration_Invalid(string jsonValue)
         {
-            string json = "\"" + jsonValue + "\"";
+            string json = WrapInQuotes(jsonValue);
             Assert.Throws<InvalidProtocolBufferException>(() => Duration.Parser.ParseJson(json));
         }
 
         // Not as many tests for field masks as I'd like; more to be added when we have more
         // detailed specifications.
 
         [Test]
         [TestCase("")]
         [TestCase("foo", "foo")]
         [TestCase("foo,bar", "foo", "bar")]
         [TestCase("foo.bar", "foo.bar")]
         [TestCase("fooBar", "foo_bar")]
         [TestCase("fooBar.bazQux", "foo_bar.baz_qux")]
         public void FieldMask_Valid(string jsonValue, params string[] expectedPaths)
         {
-            string json = "\"" + jsonValue + "\"";
+            string json = WrapInQuotes(jsonValue);
             var parsed = FieldMask.Parser.ParseJson(json);
             CollectionAssert.AreEqual(expectedPaths, parsed.Paths);
         }
 
         [Test]
+        [TestCase("foo_bar")]
+        public void FieldMask_Invalid(string jsonValue)
+        {
+            string json = WrapInQuotes(jsonValue);
+            Assert.Throws<InvalidProtocolBufferException>(() => FieldMask.Parser.ParseJson(json));
+        }
+
+        [Test]
         public void Any_RegularMessage()
         {
             var registry = TypeRegistry.FromMessages(TestAllTypes.Descriptor);
             var formatter = new JsonFormatter(new JsonFormatter.Settings(false, TypeRegistry.FromMessages(TestAllTypes.Descriptor)));
             var message = new TestAllTypes { SingleInt32 = 10, SingleNestedMessage = new TestAllTypes.Types.NestedMessage { Bb = 20 } };
             var original = Any.Pack(message);
             var json = formatter.Format(original); // This is tested in JsonFormatterTest
             var parser = new JsonParser(new JsonParser.Settings(10, registry));
             Assert.AreEqual(original, parser.Parse<Any>(json));
             string valueFirstJson = "{ \"singleInt32\": 10, \"singleNestedMessage\": { \"bb\": 20 }, \"@type\": \"type.googleapis.com/protobuf_unittest.TestAllTypes\" }";
             Assert.AreEqual(original, parser.Parse<Any>(valueFirstJson));
         }
 
         [Test]
+        public void Any_CustomPrefix()
+        {
+            var registry = TypeRegistry.FromMessages(TestAllTypes.Descriptor);
+            var message = new TestAllTypes { SingleInt32 = 10 };
+            var original = Any.Pack(message, "custom.prefix/middle-part");
+            var parser = new JsonParser(new JsonParser.Settings(10, registry));
+            string json = "{ \"@type\": \"custom.prefix/middle-part/protobuf_unittest.TestAllTypes\", \"singleInt32\": 10 }";
+            Assert.AreEqual(original, parser.Parse<Any>(json));
+        }
+
+        [Test]
         public void Any_UnknownType()
         {
             string json = "{ \"@type\": \"type.googleapis.com/bogus\" }";
             Assert.Throws<InvalidOperationException>(() => Any.Parser.ParseJson(json));
         }
 
         [Test]
+        public void Any_NoTypeUrl()
+        {
+            string json = "{ \"foo\": \"bar\" }";
+            Assert.Throws<InvalidProtocolBufferException>(() => Any.Parser.ParseJson(json));
+        }
+
+        [Test]
         public void Any_WellKnownType()
         {
             var registry = TypeRegistry.FromMessages(Timestamp.Descriptor);
             var formatter = new JsonFormatter(new JsonFormatter.Settings(false, registry));
             var timestamp = new DateTime(1673, 6, 19, 12, 34, 56, DateTimeKind.Utc).ToTimestamp();
             var original = Any.Pack(timestamp);
             var json = formatter.Format(original); // This is tested in JsonFormatterTest
             var parser = new JsonParser(new JsonParser.Settings(10, registry));
             Assert.AreEqual(original, parser.Parse<Any>(json));
             string valueFirstJson = "{ \"value\": \"1673-06-19T12:34:56Z\", \"@type\": \"type.googleapis.com/google.protobuf.Timestamp\" }";
@@ skipping 29 matching lines @@
         {
             string data64 = CodedInputStreamTest.MakeRecursiveMessage(64).ToString();
             string data65 = CodedInputStreamTest.MakeRecursiveMessage(65).ToString();
 
             var parser64 = new JsonParser(new JsonParser.Settings(64));
             CodedInputStreamTest.AssertMessageDepth(parser64.Parse<TestRecursiveMessage>(data64), 64);
             Assert.Throws<InvalidProtocolBufferException>(() => parser64.Parse<TestRecursiveMessage>(data65));
 
             var parser63 = new JsonParser(new JsonParser.Settings(63));
             Assert.Throws<InvalidProtocolBufferException>(() => parser63.Parse<TestRecursiveMessage>(data64));
+        }
 
+        [Test]
+        [TestCase("AQI")]
+        [TestCase("_-==")]
+        public void Bytes_InvalidBase64(string badBase64)
+        {
+            string json = "{ \"singleBytes\": \"" + badBase64 + "\" }";
+            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
+        }
+
+        [Test]
+        [TestCase("\"FOREIGN_BAR\"", ForeignEnum.ForeignBar)]
+        [TestCase("5", ForeignEnum.ForeignBar)]
+        [TestCase("100", (ForeignEnum)100)]
+        public void EnumValid(string value, ForeignEnum expectedValue)
+        {
+            string json = "{ \"singleForeignEnum\": " + value + " }";
+            var parsed = TestAllTypes.Parser.ParseJson(json);
+            Assert.AreEqual(new TestAllTypes { SingleForeignEnum = expectedValue }, parsed);
+        }
+
+        [Test]
+        [TestCase("\"NOT_A_VALID_VALUE\"")]
+        [TestCase("5.5")]
+        public void Enum_Invalid(string value)
+        {
+            string json = "{ \"singleForeignEnum\": " + value + " }";
+            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
+        }
+
+        [Test]
+        public void OneofDuplicate_Invalid()
+        {
+            string json = "{ \"oneofString\": \"x\", \"oneofUint32\": 10 }";
+            Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseJson(json));
+        }
+
+        /// <summary>
+        /// Various tests use strings which have quotes round them for parsing or as the result
+        /// of formatting, but without those quotes being specified in the tests (for the sake of readability).
+        /// This method simply returns the input, wrapped in double quotes.
+        /// </summary>
+        internal static string WrapInQuotes(string text)
+        {
+            return '"' + text + '"';
         }
     }
-}
+}