Improved coverage. Fixed issues with methods.

Author: electricessence

Source/Extensions._.cs

@@ -333,7 +333,7 @@ public static void WriteLineNoTabs(this TextWriter writer, string? s = null)
 			if (writer is null) throw new ArgumentNullException(nameof(writer));
 			Contract.EndContractBlock();
 
-			if (s != null) writer.Write(s);
+			if (s is not null) writer.Write(s);
 			writer.Write(NEWLINE);
 		}
 
@@ -345,7 +345,7 @@ public static void WriteLineNoTabs(this TextWriter writer, string? s = null)
 		/// <param name="values">The values to inject.</param>
 		/// <param name="cultureInfo">The optional culture info.  Default is invariant.</param>
 		/// <returns>The resultant string.</returns>
-		public static string Supplant<T>(this string format, T[] values, CultureInfo? cultureInfo = default)
+		public static string Supplant<T>(this string format, T[]? values, CultureInfo? cultureInfo = default)
 			=> values is null ? format : values.Length switch
 			{
 				0 => format,

Source/Open.Text.csproj

@@ -17,7 +17,7 @@
 		<RepositoryUrl>https://github.com/Open-NET-Libraries/Open.Text</RepositoryUrl>
 		<RepositoryType>git</RepositoryType>
 		<PackageTags>dotnet, dotnetcore, string, span, readonlyspan, text, format, split, trim, equals, trimmed equals, first, last, preceding, following, stringbuilder, extensions</PackageTags>
-		<Version>3.2.0</Version>
+		<Version>3.2.1</Version>
 		<PackageReleaseNotes></PackageReleaseNotes>
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<PublishRepositoryUrl>true</PublishRepositoryUrl>

Source/StringSegment.cs

@@ -61,36 +61,38 @@ public override string ToString()
 		/// <summary>
 		/// Gets the string segment that precedes this one.
 		/// </summary>
-		public StringSegment Preceding()
-			=> IsValid ? Create(Source, 0, Index) : default;
+		/// <param name="includeSegment">When true, will include this segment.</param>
+		public StringSegment Preceding(bool includeSegment = false)
+			=> IsValid ? Create(Source, 0, includeSegment ? (Index + Length) : Index) : default;
 
 		/// <summary>
 		/// Gets the string segment that follows this one.
 		/// </summary>
-		public StringSegment Following()
-			=> IsValid ? Create(Source, Index + Length) : default;
+		/// <param name="includeSegment">When true, will include this segment.</param>
+		public StringSegment Following(bool includeSegment = false)
+			=> IsValid ? Create(Source, includeSegment ? Index : (Index + Length)) : default;
 
 		/// <inheritdoc cref="Preceding"/>
 		/// <param name="maxCharacters">The max number of characters to get.</param>
-		public StringSegment Preceding(int maxCharacters)
+		public StringSegment Preceding(int maxCharacters, bool includeSegment = false)
 		{
 			if (maxCharacters < 0) throw new ArgumentOutOfRangeException(nameof(maxCharacters), maxCharacters, "Must be at least zero.");
 			if (!IsValid) return default;
-			if (maxCharacters == 0) return new(Source, Index, 0);
+			if (maxCharacters == 0) return includeSegment ? this : new(Source, Index, 0);
 			var start = Math.Max(0, Index - maxCharacters);
-			return new(Source, start, Index - start);
+			return new(Source, start, includeSegment ? (Index - start + Length) : (Index - start));
 		}
 
 		/// <inheritdoc cref="Following"/>
 		/// <param name="maxCharacters">The max number of characters to get.</param>
-		public StringSegment Following(int maxCharacters)
+		public StringSegment Following(int maxCharacters, bool includeSegment = false)
 		{
 			if (maxCharacters < 0) throw new ArgumentOutOfRangeException(nameof(maxCharacters), maxCharacters, "Must be at least zero.");
 			if (!IsValid) return default;
-			var start = Index + Length;
-			if (maxCharacters == 0) return new(Source, start, 0);
-			var len = Source.Length;
-			return new(Source, start, Math.Min(maxCharacters, len - start));
+			var start = includeSegment ? Index : (Index + Length);
+			if (maxCharacters == 0) return includeSegment ? this : new(Source, start, 0);
+			var len = Math.Min(includeSegment ? (maxCharacters + Length) : maxCharacters, Source.Length - start);
+			return new(Source, start, len);
 		}
 
 		/// <summary>
@@ -130,7 +132,11 @@ public StringSegment OffsetLength(int offset)
 		///	</param>
 		public StringSegment Slice(int offset, int length, bool ignoreLengthBoundary = false)
 		{
-			if (!IsValid) return default;
+			if (!IsValid)
+			{
+				if (offset == 0 && length == 0) return this;
+				throw new InvalidOperationException("Cannot slice a null value.");
+			}
 			var newIndex = Index + offset;
 			if (newIndex < 0) throw new ArgumentOutOfRangeException(nameof(offset), offset, "Cannot index less than the start of the string.");
 			var newEnd = newIndex + length;
@@ -142,7 +148,7 @@ public StringSegment Slice(int offset, int length, bool ignoreLengthBoundary = f
 					if (newIndex > end) throw new ArgumentOutOfRangeException(nameof(offset), offset, "Index is greater than the end of the source string.");
 					throw new ArgumentOutOfRangeException(nameof(length), length, "Desired length will extend greater than the end of the source string.");
 				}
-				return new(Source, newIndex, end);
+				return new(Source, newIndex, length);
 			}
 			else
 			{
@@ -152,7 +158,7 @@ public StringSegment Slice(int offset, int length, bool ignoreLengthBoundary = f
 					if (newIndex > end) throw new ArgumentOutOfRangeException(nameof(offset), offset, "Index is greater than the length of the segment.");
 					throw new ArgumentOutOfRangeException(nameof(length), length, "Desired length will extend greater than the length of the segment.");
 				}
-				return new(Source, newIndex, end);
+				return new(Source, newIndex, length);
 			}
 
 		}
@@ -163,6 +169,21 @@ public StringSegment Slice(int offset, int length, bool ignoreLengthBoundary = f
 		public bool Equals(StringSegment other)
 			=> Index == other.Index & Length == other.Length && Source == other.Source;
 
+
+		/// <inheritdoc cref="string.Equals(string, StringComparison)">
+		public bool Equals(string? other, StringComparison stringComparison = StringComparison.Ordinal)
+		{
+			if (other is null) return !IsValid;
+			if (other.Length != Length) return false;
+			return AsSpan().Equals(other, stringComparison);
+		}
+
+		public bool Equals(in ReadOnlySpan<char> other, StringComparison stringComparison = StringComparison.Ordinal)
+		{
+			if (other.Length != Length) return false;
+			return AsSpan().Equals(other, stringComparison);
+		}
+
 		/// <inheritdoc />
 		public override bool Equals(object? obj)
 			=> obj is StringSegment segment && Equals(segment);

Tests/BeforeAfterTests.cs

@@ -5,6 +5,20 @@ namespace Open.Text.Tests
 {
 	public static class BeforeAfterTests
 	{
+		[Fact]
+		public static void Validity()
+		{
+			var s = default(StringSegment);
+			Assert.False(s.IsValid);
+			Assert.Equal(s, s.SourceSegment);
+			Assert.True(s.Slice(0, 0) == s);
+			Assert.Throws<InvalidOperationException>(() => s.Slice(1, 1));
+			Assert.True(s == s.SourceSegment);
+			Assert.NotEqual(0, s.ToString().Length); // base string.
+			Assert.Equal(0, ((ReadOnlySpan<char>)s).Length);
+			Assert.Equal(0, ((ReadOnlyMemory<char>)s).Length);
+		}
+
 		[Theory]
 		[InlineData("Hello well how are you", "o", "Hell")]
 		[InlineData("Hello well how are you", "ll", "He")]
@@ -15,7 +29,14 @@ public static void BeforeFirst(string source, string pattern, string? expected,
 		{
 			var first = source.First(pattern, comparisonType);
 			if (expected is null) Assert.False(first.IsValid);
-			else Assert.Equal(expected, first.Preceding().ToString());
+			else
+			{
+				var p = first.Preceding();
+				Assert.Equal(expected, p.ToString());
+				Assert.True(p.ToString().Equals(expected, comparisonType));
+				Assert.True(p.AsSpan().Equals(expected, comparisonType));
+				Assert.True(p.AsMemory().Span.Equals(expected, comparisonType));
+			}
 		}
 
 		[Theory]
@@ -61,12 +82,37 @@ public static void AfterLast(string source, string pattern, string? expected, St
 		public static void Offsets()
 		{
 			var segment = "Hello well how are you".First("well how");
+			Assert.Equal("Hello ", segment.Preceding(100).ToString());
+			Assert.Equal("o ", segment.Preceding(2).ToString());
+			Assert.Equal(" are you", segment.Following(100).ToString());
+			Assert.Equal(" a", segment.Following(2).ToString());
+			Assert.Equal("Hello well how", segment.Preceding(100, true).ToString());
+			Assert.Equal("o well how", segment.Preceding(2, true).ToString());
+			Assert.Equal("well how are you", segment.Following(100, true).ToString());
+			Assert.Equal("well how a", segment.Following(2, true).ToString());
+			Assert.Equal("well how", segment.ToString());
 			Assert.Equal("well", segment.OffsetLength(-4).ToString());
 			Assert.Equal("how", segment.OffsetIndex(+5).ToString());
 			Assert.Equal("well how are", segment.OffsetLength(+4).ToString());
 			Assert.Equal("Hello well how", segment.OffsetIndex(-6).ToString());
 			Assert.Throws<ArgumentOutOfRangeException>(() => segment.OffsetIndex(-7));
 			Assert.Throws<ArgumentOutOfRangeException>(() => segment.OffsetLength(9));
 		}
+
+		[Fact]
+		public static void Slice()
+		{
+			var segment = "Hello well how are you".First("well how");
+			Assert.Equal("well how", segment.ToString());
+			var slice = segment.Slice(0, 4);
+			Assert.Equal("well", slice.ToString());
+			Assert.True(slice.Equals("well".AsSpan()));
+			Assert.Throws<ArgumentOutOfRangeException>(() => slice.Slice(5, 5));
+			Assert.Throws<ArgumentOutOfRangeException>(() => slice.Slice(0, 5));
+			Assert.True(slice.Slice(1, 6, true).Equals("ell ho"));
+			Assert.True(slice.Slice(1, 7, true).Equals("ell how"));
+			Assert.True(slice.Slice(1, 15, true).Equals("ell how are you"));
+			Assert.Throws<ArgumentOutOfRangeException>(() => slice.Slice(1, 16, true));
+		}
 	}
 }