ReadOnlySequence<T>.TryGet() returns empty result

[thargy]

When calling ReadOnlySequence<T>.TryGet(ref position, out memory) with a position of sequence.End or sequence.GetPosition(size) the result is true and memory is an empty slice. As this effectively is not returning a segment or byte, is should probably return false.

As per this comment from @pakrym, I'm raising as a seperate issue.

[davidfowl]

cc @ahsonkhan

[MarcoRossignoli]

As this effectively is not returning a segment or byte, is should probably return false.

@ahsonkhan should we return false if empy segment is returned?

[ahsonkhan]

should we return false if empy segment is returned?

Yes. If anyone would like to submit a fix for this with a test, that would be much appreciated. Otherwise, this issue will move to future.

[MarcoRossignoli]

@ahsonkhan are we sure of this update?Seem a breaking changes there are a lot of tests that fail.
Again there is a tailored made tests on this subject https://github.com/dotnet/corefx/blob/fd9801068f1baf8d69893da2a414eee7556e51b0/src/System.Memory/tests/ReadOnlyBuffer/ReadOnlySequenceTests.Empty.cs#L159

Maybe before go on should be discussed on review?I mean it's a semantic changes.

[ahsonkhan]

Seem a breaking changes there are a lot of tests that fail.
Again there is a tailored made tests on this subject

Aside from the Empty_TryGet test, was there others failing too? That test looks to be written specifically with the current behavior in mind.

Maybe before go on should be discussed on review?I mean it's a semantic changes.

That's a good point. I am going to move it to future at this point given the impact of this issue doesn't seem quite that high to me, to make room for other 3.0 work.

[thargy]

That's a good point. I am going to move it to future at this point given the impact of this issue doesn't seem quite that high to me

I had hoped that this would be changed for 3.0 as ReadOnlySequence<T> gains adoption more and more code would be affected by a breaking change, particularly if it is released in a minor revision later. It is a relatively quick change to implement, though performance testing different approaches would probably be demanded due to the location.

[MarcoRossignoli]

was there others failing too

Yes, did simple update here

https://github.com/dotnet/corefx/blob/74032a608cf39d8eaa2955cc46d0ac677e3ae12c/src/System.Memory/src/System/Buffers/ReadOnlySequence.Helpers.cs#L78

with return !memory.IsEmpty; (let me know if it's not correct...I followed code path for tryget)
we only return false if positionObject is null(above code)
And get fails for:

5IEnumerable<String> (129 items)44
--
System.Memory.Tests.ReadOnlySequenceTestsEmpty.Empty_TryGet
System.Memory.Tests.ReadOnlySequenceTestsEmpty.Empty_Enumerator
System.Memory.Tests.SequenceReader.Advance.PastEmptySegments
System.Memory.Tests.ReadOnlySequenceTestsCommonByte.TryGetStopsAtEndWhenEndIsFirstItemOfFull
System.Memory.Tests.ReadOnlySequenceTestsCommonByte.TryGetReturnsEmptySegments
System.Memory.Tests.ReadOnlySequenceTestsCommonByte.EnumerableStopsAtEndWhenEndIsFirstItemOfEmpty
System.Memory.Tests.ReadOnlySequenceTestsCommonByte.EnumerableStopsAtEndWhenEndIsFirstItemOfFull
System.Memory.Tests.ReadOnlySequenceTestsCommonByte.TryGetStopsAtEndWhenEndIsFirstItemOfEmpty
System.Memory.Tests.SequenceReader.SegmentPerByte.TryReadTraversesSegments
System.Memory.Tests.SequenceReader.SegmentPerByte.TryPeekReturnsDefaultInTheEnd
System.Memory.Tests.SequenceReader.SegmentPerByte.AdvanceTo_AdvancePast
System.Memory.Tests.SequenceReader.SegmentPerByte.AdvanceToEndThenPeekReturnsDefault
System.Memory.Tests.SequenceReader.SegmentPerByte.AdvancingPastLengthThrows
System.Memory.Tests.SequenceReader.SegmentPerByte.Advance_PositionIsCorrect(advanceBy: 1)
System.Memory.Tests.SequenceReader.SegmentPerByte.Advance_PositionIsCorrect(advanceBy: 2)
System.Memory.Tests.SequenceReader.SegmentPerByte.Advance_PositionIsCorrect(advanceBy: 3)
System.Memory.Tests.SequenceReader.SegmentPerByte.AdvanceThrowsPastLengthMultipleSegments
System.Memory.Tests.SequenceReader.SegmentPerByte.ReaderIndexIsCorrect
System.Memory.Tests.SequenceReader.SegmentPerByte.AdvanceTraversesSegments
System.Memory.Tests.SequenceReader.SegmentPerByte.AdvanceTo
System.Memory.Tests.SequenceReader.SegmentPerByte.ReturnsCorrectCursor(takes: 0, end: False)
System.Memory.Tests.SequenceReader.SegmentPerByte.ReturnsCorrectCursor(takes: 5, end: False)
System.Memory.Tests.SequenceReader.SegmentPerByte.ReturnsCorrectCursor(takes: 10, end: False)
System.Memory.Tests.SequenceReader.SegmentPerByte.ReturnsCorrectCursor(takes: 11, end: True)
System.Memory.Tests.SequenceReader.SegmentPerByte.ReturnsCorrectCursor(takes: 12, end: True)
System.Memory.Tests.SequenceReader.SegmentPerByte.ReturnsCorrectCursor(takes: 15, end: True)
System.Memory.Tests.SequenceReader.SegmentPerByte.TryPeekTraversesSegments
System.Memory.Tests.SequenceReader.SegmentPerByte.CopyToSmallerBufferWorks
System.Memory.Tests.SequenceReader.SegmentPerByte.EmptySegmentsAreSkippedOnMoveNext
System.Memory.Tests.SequenceReader.ReadTo.TryReadTo_Sequence(advancePastDelimiter: False, useEscapeOverload: False)
System.Memory.Tests.SequenceReader.ReadTo.TryReadTo_Sequence(advancePastDelimiter: False, useEscapeOverload: True)
System.Memory.Tests.SequenceReader.ReadTo.TryReadTo_Sequence(advancePastDelimiter: True, useEscapeOverload: False)
System.Memory.Tests.SequenceReader.ReadTo.TryReadTo_Sequence(advancePastDelimiter: True, useEscapeOverload: True)
System.Memory.Tests.SequenceReader.ReadTo.TryReadToSpan_Sequence(advancePastDelimiter: False)
System.Memory.Tests.SequenceReader.ReadTo.TryReadToSpan_Sequence(advancePastDelimiter: True)
System.Memory.Tests.SequenceReader.ReadTo.TryReadTo_Span(advancePastDelimiter: False, useEscapeOverload: False)
System.Memory.Tests.SequenceReader.ReadTo.TryReadTo_Span(advancePastDelimiter: False, useEscapeOverload: True)
System.Memory.Tests.SequenceReader.ReadTo.TryReadTo_Span(advancePastDelimiter: True, useEscapeOverload: False)
System.Memory.Tests.SequenceReader.ReadTo.TryReadTo_Span(advancePastDelimiter: True, useEscapeOverload: True)
System.Memory.Tests.SequenceReader.SegmentPerChar.AdvanceThrowsPastLengthMultipleSegments
System.Memory.Tests.SequenceReader.SegmentPerChar.AdvanceTo
System.Memory.Tests.SequenceReader.SegmentPerChar.AdvanceTraversesSegments
System.Memory.Tests.SequenceReader.SegmentPerChar.Advance_PositionIsCorrect(advanceBy: 1)
System.Memory.Tests.SequenceReader.SegmentPerChar.Advance_PositionIsCorrect(advanceBy: 2)
System.Memory.Tests.SequenceReader.SegmentPerChar.Advance_PositionIsCorrect(advanceBy: 3)
System.Memory.Tests.SequenceReader.SegmentPerChar.ReaderIndexIsCorrect
System.Memory.Tests.SequenceReader.SegmentPerChar.ReturnsCorrectCursor(takes: 0, end: False)
System.Memory.Tests.SequenceReader.SegmentPerChar.ReturnsCorrectCursor(takes: 5, end: False)
System.Memory.Tests.SequenceReader.SegmentPerChar.ReturnsCorrectCursor(takes: 10, end: False)
System.Memory.Tests.SequenceReader.SegmentPerChar.ReturnsCorrectCursor(takes: 11, end: True)
System.Memory.Tests.SequenceReader.SegmentPerChar.ReturnsCorrectCursor(takes: 12, end: True)
System.Memory.Tests.SequenceReader.SegmentPerChar.ReturnsCorrectCursor(takes: 15, end: True)
System.Memory.Tests.SequenceReader.SegmentPerChar.CopyToSmallerBufferWorks
System.Memory.Tests.SequenceReader.SegmentPerChar.AdvanceTo_AdvancePast
System.Memory.Tests.SequenceReader.SegmentPerChar.TryPeekTraversesSegments
System.Memory.Tests.SequenceReader.SegmentPerChar.AdvancingPastLengthThrows
System.Memory.Tests.SequenceReader.SegmentPerChar.TryReadTraversesSegments
System.Memory.Tests.SequenceReader.SegmentPerChar.EmptySegmentsAreSkippedOnMoveNext
System.Memory.Tests.SequenceReader.SegmentPerChar.TryPeekReturnsDefaultInTheEnd
System.Memory.Tests.SequenceReader.SegmentPerChar.AdvanceToEndThenPeekReturnsDefault
System.Memory.Tests.ReadOnlySequenceTestsByte+SplitInThreeSegments.PositionOf_ReturnsPosition(raw: \"a\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsByte+SplitInThreeSegments.PositionOf_ReturnsPosition(raw: \"ab\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.SequenceReader.Rewind.RewindEmptyFirstSpan
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.ToArrayIsCorrect(length: 8)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"a\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"ab\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"aab\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"acab\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"acab\", searchFor: 'c', expectIndex: 1)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"abcdefghijklmnopqrstuvwxyz\", searchFor: 'l', expectIndex: 11)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwx\"..., searchFor: 'l', expectIndex: 11)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"aaaaaaaaaaacmnopqrstuvwxyzabcdefghijklmnopqrstuvwx\"..., searchFor: 'm', expectIndex: 12)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"aaaaaaaaaaarmnopqrstuvwxyzabcdefghijklmnopqrstuvwx\"..., searchFor: 'r', expectIndex: 11)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"/localhost:5000/PATH/%2FPATH2/ HTTP/1.1\", searchFor: '%', expectIndex: 21)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"/localhost:5000/PATH/%2FPATH2/?key=value HTTP/1.1\", searchFor: '%', expectIndex: 21)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"/localhost:5000/PATH/PATH2/?key=value HTTP/1.1\", searchFor: '?', expectIndex: 27)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.PositionOf_ReturnsPosition(raw: \"/localhost:5000/PATH/PATH2/ HTTP/1.1\", searchFor: ' ', expectIndex: 27)
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_0(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_1(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_2(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_3(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_4(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_5(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_6(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_7(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_8(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_9(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_10(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_11(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_12(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_13(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsByte+SegmentPerByte.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Byte] <get_ValidSliceCases>b__24_14(System.Buffers.ReadOnlySequence`1[System.Byte]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_0(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_1(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_2(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_3(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_4(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_5(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_6(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_7(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_8(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_9(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_10(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_11(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_12(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_13(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.Slice_Works(func: Func`2 { Method = System.Buffers.ReadOnlySequence`1[System.Char] <get_ValidSliceCases>b__25_14(System.Buffers.ReadOnlySequence`1[System.Char]), Target = <>c { } })
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"a\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"ab\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"aab\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"acab\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"acab\", searchFor: 'c', expectIndex: 1)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"abcdefghijklmnopqrstuvwxyz\", searchFor: 'l', expectIndex: 11)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwx\"..., searchFor: 'l', expectIndex: 11)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"aaaaaaaaaaacmnopqrstuvwxyzabcdefghijklmnopqrstuvwx\"..., searchFor: 'm', expectIndex: 12)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"aaaaaaaaaaarmnopqrstuvwxyzabcdefghijklmnopqrstuvwx\"..., searchFor: 'r', expectIndex: 11)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"/localhost:5000/PATH/%2FPATH2/ HTTP/1.1\", searchFor: '%', expectIndex: 21)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"/localhost:5000/PATH/%2FPATH2/?key=value HTTP/1.1\", searchFor: '%', expectIndex: 21)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"/localhost:5000/PATH/PATH2/?key=value HTTP/1.1\", searchFor: '?', expectIndex: 27)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.PositionOf_ReturnsPosition(raw: \"/localhost:5000/PATH/PATH2/ HTTP/1.1\", searchFor: ' ', expectIndex: 27)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.ToArrayIsCorrect(length: 8)
System.Memory.Tests.ReadOnlySequenceTestsChar+SegmentPerChar.ToStringIsCorrect
System.Memory.Tests.ReadOnlySequenceTestsChar+SplitInThreeSegments.PositionOf_ReturnsPosition(raw: \"a\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsChar+SplitInThreeSegments.PositionOf_ReturnsPosition(raw: \"ab\", searchFor: 'a', expectIndex: 0)
System.Memory.Tests.ReadOnlySequenceTestsCommonChar.EnumerableStopsAtEndWhenEndIsFirstItemOfEmpty
System.Memory.Tests.ReadOnlySequenceTestsCommonChar.TryGetStopsAtEndWhenEndIsFirstItemOfEmpty
System.Memory.Tests.ReadOnlySequenceTestsCommonChar.TryGetReturnsEmptySegments
System.Memory.Tests.ReadOnlySequenceTestsCommonChar.EnumerableStopsAtEndWhenEndIsFirstItemOfFull
System.Memory.Tests.ReadOnlySequenceTestsCommonChar.TryGetStopsAtEndWhenEndIsFirstItemOfFull

Same result if only update public TryGet api.