Revert "third_party/protobuf: Update to HEAD (83d681ee2c)"

third_party/protobuf/csharp/src/Google.Protobuf.Test/JsonFormatterTest.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 20 matching lines @@
 #endregion
 
 using System;
 using Google.Protobuf.TestProtos;
 using NUnit.Framework;
 using UnitTest.Issues.TestProtos;
 using Google.Protobuf.WellKnownTypes;
 using Google.Protobuf.Reflection;
 
 using static Google.Protobuf.JsonParserTest; // For WrapInQuotes
-using System.IO;
-using Google.Protobuf.Collections;
 
 namespace Google.Protobuf
 {
     /// <summary>
     /// Tests for the JSON formatter. Note that in these tests, double quotes are replaced with apostrophes
     /// for the sake of readability (embedding \" everywhere is painful). See the AssertJson method for details.
     /// </summary>
     public class JsonFormatterTest
     {
         [Test]
@@ skipping 169 matching lines @@
             Assert.Throws<ArgumentException>(() => JsonFormatter.Default.Format(message));
 
             // Lone high surrogate
             message = new TestAllTypes { SingleString = "a\uD801b" };
             Assert.Throws<ArgumentException>(() => JsonFormatter.Default.Format(message));
         }
 
         [Test]
         [TestCase("foo_bar", "fooBar")]
         [TestCase("bananaBanana", "bananaBanana")]
-        [TestCase("BANANABanana", "BANANABanana")]
-        [TestCase("simple", "simple")]
-        [TestCase("ACTION_AND_ADVENTURE", "ACTIONANDADVENTURE")]
-        [TestCase("action_and_adventure", "actionAndAdventure")]
-        [TestCase("kFoo", "kFoo")]
-        [TestCase("HTTPServer", "HTTPServer")]
-        [TestCase("CLIENT", "CLIENT")]
-        public void ToJsonName(string original, string expected)
+        [TestCase("BANANABanana", "bananaBanana")]
+        public void ToCamelCase(string original, string expected)
         {
-            Assert.AreEqual(expected, JsonFormatter.ToJsonName(original));
+            Assert.AreEqual(expected, JsonFormatter.ToCamelCase(original));
         }
 
         [Test]
         [TestCase(null, "{ }")]
         [TestCase("x", "{ 'fooString': 'x' }")]
         [TestCase("", "{ 'fooString': '' }")]
         public void Oneof(string fooStringValue, string expectedJson)
         {
             var message = new TestOneof();
             if (fooStringValue != null)
@@ skipping 261 matching lines @@
 
         [Test]
         public void AnyUnknownType()
         {
             // The default type registry doesn't have any types in it.
             var message = new TestAllTypes();
             var any = Any.Pack(message);
             Assert.Throws<InvalidOperationException>(() => JsonFormatter.Default.Format(any));
         }
 
-        [Test]
-        [TestCase(typeof(BoolValue), true, "true")]
-        [TestCase(typeof(Int32Value), 32, "32")]
-        [TestCase(typeof(Int64Value), 32L, "\"32\"")]
-        [TestCase(typeof(UInt32Value), 32U, "32")]
-        [TestCase(typeof(UInt64Value), 32UL, "\"32\"")]
-        [TestCase(typeof(StringValue), "foo", "\"foo\"")]
-        [TestCase(typeof(FloatValue), 1.5f, "1.5")]
-        [TestCase(typeof(DoubleValue), 1.5d, "1.5")]
-        public void Wrappers_Standalone(System.Type wrapperType, object value, string expectedJson)
-        {
-            IMessage populated = (IMessage)Activator.CreateInstance(wrapperType);
-            populated.Descriptor.Fields[WrappersReflection.WrapperValueFieldNumber].Accessor.SetValue(populated, value);
-            Assert.AreEqual(expectedJson, JsonFormatter.Default.Format(populated));
-        }
-
-        // Sanity tests for WriteValue. Not particularly comprehensive, as it's all covered above already,
-        // as FormatMessage uses WriteValue.
-
-        [TestCase(null, "null")]
-        [TestCase(1, "1")]
-        [TestCase(1L, "'1'")]
-        [TestCase(0.5f, "0.5")]
-        [TestCase(0.5d, "0.5")]
-        [TestCase("text", "'text'")]
-        [TestCase("x\ny", @"'x\ny'")]
-        [TestCase(ForeignEnum.ForeignBar, "'FOREIGN_BAR'")]
-        public void WriteValue_Constant(object value, string expectedJson)
-        {
-            AssertWriteValue(value, expectedJson);
-        }
-
-        [Test]
-        public void WriteValue_Timestamp()
-        {
-            var value = new DateTime(1673, 6, 19, 12, 34, 56, DateTimeKind.Utc).ToTimestamp();
-            AssertWriteValue(value, "'1673-06-19T12:34:56Z'");
-        }
-
-        [Test]
-        public void WriteValue_Message()
-        {
-            var value = new TestAllTypes { SingleInt32 = 100, SingleInt64 = 3210987654321L };
-            AssertWriteValue(value, "{ 'singleInt32': 100, 'singleInt64': '3210987654321' }");
-        }
-
-        [Test]
-        public void WriteValue_List()
-        {
-            var value = new RepeatedField<int> { 1, 2, 3 };
-            AssertWriteValue(value, "[ 1, 2, 3 ]");
-        }
-
-        private static void AssertWriteValue(object value, string expectedJson)
-        {
-            var writer = new StringWriter();
-            JsonFormatter.Default.WriteValue(writer, value);
-            string actual = writer.ToString();
-            AssertJson(expectedJson, actual);
-        }
-
         /// <summary>
         /// Checks that the actual JSON is the same as the expected JSON - but after replacing
         /// all apostrophes in the expected JSON with double quotes. This basically makes the tests easier
         /// to read.
         /// </summary>
         private static void AssertJson(string expectedJsonWithApostrophes, string actualJson)
         {
             var expectedJson = expectedJsonWithApostrophes.Replace("'", "\"");
             Assert.AreEqual(expectedJson, actualJson);
         }
     }
 }