//TODO: this should use ByteSpan
 public void Append(ReadOnlySpan<char> substring)
 {
     for (int i = 0; i < substring.Length; i++)
     {
         Append(substring[i]);
     }
 }

 public static void DangerousGetPinnableReferenceArray()
 {
     int[] a = { 91, 92, 93, 94, 95 };
     ReadOnlySpan<int> span = new ReadOnlySpan<int>(a, 1, 3);
     ref int pinnableReference = ref span.DangerousGetPinnableReference();
     Assert.True(Unsafe.AreSame<int>(ref a[1], ref pinnableReference));
 }

        // TODO: format should be ReadOnlySpan<char>
        internal static bool TryFormatInt64(long value, byte numberOfBytes, Span<byte> buffer, ReadOnlySpan<char> format, EncodingData formattingData, out int bytesWritten)
        {
            Precondition.Require(numberOfBytes <= sizeof(long));

            TextFormat parsedFormat = TextFormat.Parse(format);
            return TryFormatInt64(value, numberOfBytes, buffer, parsedFormat, formattingData, out bytesWritten);
        }

    public void TwoReadOnlySpansCreatedOverSameIntArrayAreEqual()
    {
        for (int i = 0; i < 2; i++)
        {
            var ints = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

            // Try out two ways of creating a slice:
            ReadOnlySpan<int> slice;
            if (i == 0)
            {
                slice = new ReadOnlySpan<int>(ints);
            }
            else
            {
                slice = ints.Slice();
            }
            Assert.Equal(ints.Length, slice.Length);
            // Now try out two ways of walking the slice's contents:
            for (int j = 0; j < ints.Length; j++)
            {
                Assert.Equal(ints[j], slice[j]);
            }
            {
                int j = 0;
                foreach (var x in slice)
                {
                    Assert.Equal(ints[j], x);
                    j++;
                }
            }
        }
    }

        private static bool IsFalse(ReadOnlySpan<char> utf16Chars)
        {
            if (utf16Chars.Length < 5)
                return false;

            char firstChar = utf16Chars[0];
            if (firstChar != 'f' && firstChar != 'F')
                return false;

            char secondChar = utf16Chars[1];
            if (secondChar != 'a' && secondChar != 'A')
                return false;

            char thirdChar = utf16Chars[2];
            if (thirdChar != 'l' && thirdChar != 'L')
                return false;

            char fourthChar = utf16Chars[3];
            if (fourthChar != 's' && fourthChar != 'S')
                return false;

            char fifthChar = utf16Chars[4];
            if (fifthChar != 'e' && fifthChar != 'E')
                return false;

            return true;
        }

        public unsafe void ByteReadOnlySpanEqualsTestsTwoDifferentInstancesOfBuffersWithOneValueDifferent()
        {
            const int bufferLength = 128;
            byte[] buffer1 = new byte[bufferLength];
            byte[] buffer2 = new byte[bufferLength];

            for (int i = 0; i < bufferLength; i++)
            {
                buffer1[i] = (byte)(bufferLength + 1 - i);
                buffer2[i] = (byte)(bufferLength + 1 - i);
            }

            fixed (byte* buffer1pinned = buffer1)
            fixed (byte* buffer2pinned = buffer2)
            {
                ReadOnlySpan<byte> b1 = new ReadOnlySpan<byte>(buffer1pinned, bufferLength);
                ReadOnlySpan<byte> b2 = new ReadOnlySpan<byte>(buffer2pinned, bufferLength);

                for (int i = 0; i < bufferLength; i++)
                {
                    for (int diffPosition = i; diffPosition < bufferLength; diffPosition++)
                    {
                        buffer1[diffPosition] = unchecked((byte)(buffer1[diffPosition] + 1));
                        Assert.False(b1.Slice(i).SequenceEqual(b2.Slice(i)));
                    }
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="source"></param>
        /// <param name="destination"></param>
        /// <returns>Number of bytes written to the destination.</returns>
        public static int Encode(ReadOnlySpan<byte> source, Span<byte> destination)
        {
            int di = 0;
            int si = 0;
            byte b0, b1, b2, b3;
            for (; si<source.Length - 2;) {
                var result = Encode(source.Slice(si));
                si += 3;
                destination.Slice(di).Write(result);
                di += 4;
            }

            if (si == source.Length - 1) {
                Encode(source[si], 0, 0, out b0, out b1, out b2, out b3);
                destination[di++] = b0;
                destination[di++] = b1;
                destination[di++] = s_encodingMap[64];
                destination[di++] = s_encodingMap[64];
            }
            else if(si == source.Length - 2) {
                Encode(source[si++], source[si], 0, out b0, out b1, out b2, out b3);
                destination[di++] = b0;
                destination[di++] = b1;
                destination[di++] = b2;
                destination[di++] = s_encodingMap[64];
            }

            return di; 
        }

 public static void CtorArrayIntStartEqualsLength()
 {
     // Valid for start to equal the array length. This returns an empty span that starts "just past the array."
     int[] a = { 91, 92, 93 };
     ReadOnlySpan<int> span = new ReadOnlySpan<int>(a, 3);
     span.Validate<int>();
 }

 internal JsonObject(ReadOnlySpan<byte> values, ReadOnlySpan<byte> db, BufferPool pool = null, OwnedMemory<byte> dbMemory = null)
 {
     _db = db;
     _values = values;
     _pool = pool;
     _dbMemory = dbMemory;
 }

        // TODO: format should be ReadOnlySpan<T>
        public static Format.Parsed Parse(ReadOnlySpan<char> format)
        {
            if (format.Length == 0)
            {
                return default(Format.Parsed);
            }

            uint precision = NoPrecision;
            if (format.Length > 1)
            {
                var span = format.Slice(1, format.Length - 1);

                if (!PrimitiveParser.TryParseUInt32(span, out precision))
                {
                    throw new NotImplementedException("UnableToParsePrecision");
                }

                if (precision > Parsed.MaxPrecision)
                {
                    // TODO: this is a contract violation
                    throw new Exception("PrecisionValueOutOfRange");
                }
            }

            // TODO: this is duplicated from above. It needs to be refactored
            var specifier = format[0];
            return new Parsed(specifier, (byte)precision);
        }

 public static void SliceIntIntPastEnd()
 {
     int[] a = { 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 };
     ReadOnlySpan<int> span = new ReadOnlySpan<int>(a).Slice(a.Length, 0);
     Assert.Equal(0, span.Length);
     Assert.True(Unsafe.AreSame<int>(ref a[a.Length - 1], ref Unsafe.Subtract<int>(ref span.DangerousGetPinnableReference(), 1)));
 }

 public static void SliceIntIntUpToEnd()
 {
     int[] a = { 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 };
     ReadOnlySpan<int> span = new ReadOnlySpan<int>(a).Slice(4, 6);
     Assert.Equal(6, span.Length);
     Assert.True(Unsafe.AreSame<int>(ref a[4], ref span.DangerousGetPinnableReference()));
 }

        public void CtorReadOnlySpanOverByteArrayValidCasesWithPropertiesAndBasicOperationsChecks(byte[] array)
        {
            ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(array);
            Assert.Equal(array.Length, span.Length);

            Assert.NotSame(array, span.CreateArray());
            Assert.False(span.Equals(array));

            ReadOnlySpan<byte>.Enumerator it = span.GetEnumerator();
            for (int i = 0; i < span.Length; i++)
            {
                Assert.True(it.MoveNext());
                Assert.Equal(array[i], it.Current);
                Assert.Equal(array[i], span.Slice(i).Read<byte>());
                Assert.Equal(array[i], span.Slice(i).Read<MyByte>().Value);

                array[i] = unchecked((byte)(array[i] + 1));
                Assert.Equal(array[i], it.Current);
                Assert.Equal(array[i], span.Slice(i).Read<byte>());
                Assert.Equal(array[i], span.Slice(i).Read<MyByte>().Value);
            }
            Assert.False(it.MoveNext());

            it.Reset();
            for (int i = 0; i < span.Length; i++)
            {
                Assert.True(it.MoveNext());
                Assert.Equal(array[i], it.Current);
            }
            Assert.False(it.MoveNext());
        }

 // Helper methods similar to System.ArrayExtension:
 // String helper methods, offering methods like String on Slice<char>:
 // TODO(joe): culture-sensitive comparisons.
 // TODO: should these move to string/text related assembly
 public static bool Contains(this ReadOnlySpan<char> str, ReadOnlySpan<char> value)
 {
     if (value.Length > str.Length)
     {
         return false;
     }
     return str.IndexOf(value) >= 0;
 }

 public static int GetByteCount(ReadOnlySpan buffer)
 {
     var count = 0;
     foreach (var x in buffer)
         if ((x & 0b1100_0000) != 0b1000_0000)
             count++;
     return count;
 }

 public unsafe static bool TryParseBoolean(char* text, int length, out bool value, out int charactersConsumed)
 {
     var span = new ReadOnlySpan<byte>(text, length * 2);
     int bytesConsumed;
     bool result = PrimitiveParser.TryParseBoolean(span, out value, out bytesConsumed, EncodingData.InvariantUtf16);
     charactersConsumed = bytesConsumed / 2;
     return result;
 }

 public static void ToArray1()
 {
     int[] a = { 91, 92, 93 };
     ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
     int[] copy = span.ToArray();
     Assert.Equal<int>(a, copy);
     Assert.NotSame(a, copy);
 }

        public static void EmptySpansNotUnified()
        {
            ReadOnlySpan<int> left = new ReadOnlySpan<int>(new int[0]);
            ReadOnlySpan<int> right = new ReadOnlySpan<int>(new int[0]);

            Assert.False(left == right);
            Assert.False(!(left != right));
        }

        public static void EqualityComparesRangeNotContent()
        {
            ReadOnlySpan<int> left = new ReadOnlySpan<int>(new int[] { 0, 1, 2 }, 1, 1);
            ReadOnlySpan<int> right = new ReadOnlySpan<int>(new int[] { 0, 1, 2 }, 1, 1);

            Assert.False(left == right);
            Assert.False(!(left != right));
        }

        public static void EqualityReflexivity()
        {
            int[] a = { 91, 92, 93, 94, 95 };
            ReadOnlySpan<int> left = new ReadOnlySpan<int>(a, 2, 3);

            Assert.True(left == left);
            Assert.True(!(left != left));
        }