private static void FormatMsgPackObj(MessagePackObject obj, IndentedStringBuilder builder)
        {
            if (obj.IsMap || obj.IsDictionary)
            {
                FormatMsgPackMap(obj, builder);
            }
            else if (obj.IsArray || obj.IsList)
            {
                FormatMsgPackArray(obj, builder);
            }
            else if (obj.IsNil)
            {
                builder.Append("null");
            }
            else
            {
                var literal = obj.ToObject();

                if (literal is String)
                {
                    builder.AppendQuotedString(obj.AsStringUtf16());
                }
                else if (literal is byte[] byteArray)
                {
                    FormatByteArray(byteArray, builder);
                }
                else if (literal is MessagePackExtendedTypeObject extObject)
                {
                    builder.Append('{');

                    // Indent
                    builder.IncreaseIndent()
                    .AppendLine();

                    // Print TypeCode field
                    builder.AppendQuotedString("TypeCode")
                    .Append(": ")
                    .Append(extObject.TypeCode)
                    .AppendLine(",");

                    // Print Value field
                    builder.AppendQuotedString("Value")
                    .Append(": ");

                    FormatByteArrayAsString(extObject.GetBody(), builder, true);

                    // Unindent
                    builder.DecreaseIndent()
                    .AppendLine();

                    builder.Append('}');
                }
                else
                {
                    builder.Append(literal);
                }
            }
        }
        public void TestAsStringUtf16_Utf16LEWithoutBom_CannotDetected()
        {
            var    target = new MessagePackObject(Encoding.Unicode.GetBytes(_japanese));
            string result;

            try
            {
                result = target.AsStringUtf16();
            }
            catch (InvalidOperationException)
            {
                // It is OK. The bytes cannot be decoded as UTF-16BE.
                return;
            }

            // It is OK. The bytes incidentally can be decoded as UTF-16BE.
            Assert.AreNotEqual(_japanese, result);
        }
		public void TestAsStringUtf16_Utf16BEWithoutBom_Success()
		{
			var target = new MessagePackObject( Encoding.BigEndianUnicode.GetBytes( _japanese ) );
			Assert.AreEqual( _japanese, target.AsStringUtf16() );
		}
		public void TestAsStringUtf16_Utf16LEWithoutBom_CannotDetected()
		{
			var target = new MessagePackObject( Encoding.Unicode.GetBytes( _japanese ) );
			string result;
			try
			{
				result = target.AsStringUtf16();
			}
			catch ( InvalidOperationException )
			{
				// It is OK. The bytes cannot be decoded as UTF-16BE.
				return;
			}

			// It is OK. The bytes incidentally can be decoded as UTF-16BE.
			Assert.AreNotEqual( _japanese, result );
		}
		public void TestAsStringUtf16_Utf16LEWithBom_Success()
		{
			var target = new MessagePackObject( Encoding.Unicode.GetPreamble().Concat( Encoding.Unicode.GetBytes( _japanese ) ).ToArray() );
			Assert.AreEqual( _japanese, target.AsStringUtf16() );
		}
		public void TestAsStringUtf16_NonStringBinary()
		{
			var target = new MessagePackObject( new byte[] { 0xFF } );
			target.AsStringUtf16();
		}
        public void TestAsStringUtf16_Utf16LEWithBom_Success()
        {
            var target = new MessagePackObject(Encoding.Unicode.GetPreamble().Concat(Encoding.Unicode.GetBytes(_japanese)).ToArray());

            Assert.AreEqual(_japanese, target.AsStringUtf16());
        }
		public void TestAsStringUtf16_IsNotString()
		{
			var target = new MessagePackObject( 0 );
			Assert.Throws<InvalidOperationException>( () => target.AsStringUtf16() );
		}
		public void TestAsStringUtf16_EncodingMissmatch()
		{
			var target = new MessagePackObject( Encoding.UTF8.GetBytes( _japanese ) );
			Assert.Throws<InvalidOperationException>( () => target.AsStringUtf16() );
		}
        public void TestAsStringUtf16_IsNotString()
        {
            var target = new MessagePackObject(0);

            Assert.Throws <InvalidOperationException>(() => target.AsStringUtf16());
        }
        public void TestAsStringUtf16_Null_Success()
        {
            var target = new MessagePackObject(default(string));

            Assert.IsNull(target.AsStringUtf16());
        }
        public void TestAsStringUtf16_EncodingMissmatch()
        {
            var target = new MessagePackObject(Encoding.UTF8.GetBytes(_japanese));

            Assert.Throws <InvalidOperationException>(() => target.AsStringUtf16());
        }
        public void TestAsStringUtf16_ForNonEncoded_Success()
        {
            var target = new MessagePackObject(_japanese);

            Assert.AreEqual(_japanese, target.AsStringUtf16());
        }
        public void TestAsStringUtf16_Empty_Success()
        {
            var target = new MessagePackObject(new byte[0]);

            Assert.AreEqual("", target.AsStringUtf16());
        }
        public void TestAsStringUtf16_Utf16BEWithoutBom_Success()
        {
            var target = new MessagePackObject(Encoding.BigEndianUnicode.GetBytes(_japanese));

            Assert.AreEqual(_japanese, target.AsStringUtf16());
        }
		public void TestAsStringUtf16_Empty_Success()
		{
			var target = new MessagePackObject( new byte[ 0 ] );
			Assert.AreEqual( "", target.AsStringUtf16() );
		}
		public void TestAsStringUtf16_ForNonEncoded_Success()
		{
			var target = new MessagePackObject( _japanese );
			Assert.AreEqual( _japanese, target.AsStringUtf16() );
		}
        public void TestAsStringUtf16_NonStringBinary()
        {
            var target = new MessagePackObject(new byte[] { 0xFF });

            Assert.Throws <InvalidOperationException>(() => target.AsStringUtf16());
        }
		public void TestAsStringUtf16_Null_Success()
		{
			var target = new MessagePackObject( default( string ) );
			Assert.IsNull( target.AsStringUtf16() );
		}
		public void TestAsStringUtf16_EncodingMissmatch()
		{
			var target = new MessagePackObject( Encoding.UTF8.GetBytes( _japanese ) );
			var result = target.AsStringUtf16();
		}
		public void TestAsStringUtf16_NonStringBinary()
		{
			var target = new MessagePackObject( new byte[] { 0xFF } );
			Assert.Throws<InvalidOperationException>( () => target.AsStringUtf16() );
		}
		public void TestAsStringUtf16_IsNotString()
		{
			var target = new MessagePackObject( 0 );
			target.AsStringUtf16();
		}