public static bool TryParse(Utf8String utf8Text, out uint value, out int bytesConsumed)
        {
            Precondition.Require(utf8Text.Length > 0);

            value = 0;
            bytesConsumed = 0;

            for (int byteIndex = 0; byteIndex < utf8Text.Length; byteIndex++)
            {
                byte nextByte = (byte)utf8Text[byteIndex];
                if (nextByte < '0' || nextByte > '9')
                {
                    if (bytesConsumed == 0)
                    {
                        value = default(uint);
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                uint candidate = value * 10;
                candidate += (uint)nextByte - '0';
                if (candidate >= value)
                {
                    value = candidate;
                }
                bytesConsumed++;
            }

            return true;
        }

        public void DecodeInPlace()
        {
            var list = new List<byte>();
            for (int value = 0; value < 256; value++) {
                list.Add((byte)value);
            }
            var testBytes = list.ToArray();

            for (int value = 0; value < 256; value++) {
                var sourceBytes = testBytes.Slice(0, value + 1);
                var buffer = new byte[Base64.ComputeEncodedLength(sourceBytes.Length)];
                var bufferSlice = buffer.Slice();

                Base64.Encode(sourceBytes, bufferSlice);

                var encodedText = new Utf8String(bufferSlice).ToString();
                var expectedText = Convert.ToBase64String(testBytes, 0, value + 1);
                Assert.Equal(expectedText, encodedText);

                var decodedByteCount = Base64.DecodeInPlace(bufferSlice);
                Assert.Equal(sourceBytes.Length, decodedByteCount);

                for (int i = 0; i < decodedByteCount; i++) {
                    Assert.Equal(sourceBytes[i], buffer[i]);
                }
            }
        }

        public void EndsWithUtf8String(string s, string pattern)
        {
            Utf8String u8s = new Utf8String(s);
            Utf8String u8pattern = new Utf8String(pattern);

            Assert.Equal(s.EndsWith(pattern), u8s.EndsWith(u8pattern));
        }

        public void BasicEncodingDecoding()
        {
            var list = new List<byte>();
            for(int value=0; value < 256; value++) {
                list.Add((byte)value);
            }
            var testBytes = list.ToArray();

            for (int value = 0; value < 256; value++) {

                var sourceBytes = testBytes.Slice(0, value + 1);
                var encodedBytes = new byte[Base64.ComputeEncodedLength(sourceBytes.Length)].Slice();
                var encodedBytesCount = Base64.Encode(sourceBytes, encodedBytes);
                Assert.Equal(encodedBytes.Length, encodedBytesCount);

                var encodedText = new Utf8String(encodedBytes).ToString();
                var expectedText = Convert.ToBase64String(testBytes, 0, value + 1);
                Assert.Equal(expectedText, encodedText);

                var decodedBytes = new byte[sourceBytes.Length];
                var decodedByteCount = Base64.Decode(encodedBytes, decodedBytes.Slice());
                Assert.Equal(sourceBytes.Length, decodedByteCount);

                for (int i=0; i<decodedBytes.Length; i++) {
                    Assert.Equal(sourceBytes[i], decodedBytes[i]);
                }
            } 
        }

        public void NonAllocatingRead()
        {
            var jsonText = new Utf8String("{\"First\":\"John\",\"Age\":25}");
            JsonDynamicObject json = JsonDynamicObject.Parse(jsonText);

            Assert.Equal(new Utf8String("John"), json.First());
            Assert.Equal(25U, json.Age());
        }

 public JsonReader(Utf8String str)
 {
     _str = str;
     _index = 0;
     _insideObject = 0;
     _insideArray = 0;
     TokenType = 0;
 }

 public JsonReader(string str)
 {
     _str = new Utf8String(str);
     _index = 0;
     _insideObject = 0;
     _insideArray = 0;
     TokenType = JsonTokenType.Start;
 }

 public bool Equals(Utf8String other)
 {
     if (Length != other.Length) return false;
     for(int i=0; i<Length; i++) {
         if (_bytes[i] != other.Bytes[i]) return false;
     }
     return true;
 }

 public JsonReader(string str)
 {
     _str = new Utf8String(str);
     _index = 0;
     _insideObject = 0;
     _insideArray = 0;
     TokenType = 0;
     _length = _str.Length;
 }

 public JsonReader(string str)
 {
     _str = new Utf8String(str).Trim();
     _index = 0;
     _insideObject = 0;
     _insideArray = 0;
     TokenType = 0;
     _jsonStartIsObject = (byte)_str[0] == '{';
 }

 public unsafe void LengthPointerTest()
 {
     byte[] utf8Bytes = Encoding.UTF8.GetBytes("1258");
     fixed (byte* bytes = utf8Bytes)
     {
         var utf8String = new Utf8String(bytes, utf8Bytes.Length);
         Assert.Equal(4, utf8Bytes.Length);
     }
 }

        //[Fact(Skip = "issue #869")]
        public void Bug869DoesNotRepro()
        {
            var bytes = new byte[] { 0xF0, 0xA4, 0xAD, 0xA2 };
            var utf8String = new Utf8String(bytes);
            var str = "