Skip to content

Commit 76b4396

Browse files
dmakodmako
committed
test: extended string extensions tests
1 parent 64caa2a commit 76b4396

File tree

1 file changed

+197
-0
lines changed

1 file changed

+197
-0
lines changed

‎CommonNet.Extensions.Tests/CommonNet.Extensions/StringExtensionsTests.cs‎

Lines changed: 197 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,28 @@ await Assert.That(() => "test".TryParse(out byte _))
2525
.IsFalse();
2626
}
2727

28+
[Test]
29+
public async Task String_Parse_NullInput_ThrowsArgumentNullException()
30+
{
31+
string nullStr = null!;
32+
33+
await Assert.That(() => nullStr.Parse<int>())
34+
.ThrowsExactly<ArgumentNullException>();
35+
}
36+
37+
[Test]
38+
public async Task String_Parse_EmptyString_ReturnsDefault()
39+
{
40+
await Assert.That(() => "".Parse<int>())
41+
.IsEqualTo(0);
42+
await Assert.That(() => "".Parse<bool>())
43+
.IsFalse();
44+
await Assert.That(() => "".Parse<double>())
45+
.IsEqualTo(0.0);
46+
await Assert.That(() => "".Parse<Guid>())
47+
.IsEqualTo(Guid.Empty);
48+
}
49+
2850
[Test]
2951
public async Task String_ParseByte()
3052
{
@@ -50,6 +72,156 @@ await Assert.That(val)
5072
.IsEqualTo((byte)0);
5173
}
5274

75+
[Test]
76+
public async Task String_ParseBool()
77+
{
78+
await Assert.That(() => "true".Parse<bool>())
79+
.IsTrue();
80+
await Assert.That(() => "True".Parse<bool>())
81+
.IsTrue();
82+
await Assert.That(() => "false".Parse<bool>())
83+
.IsFalse();
84+
await Assert.That(() => "notbool".Parse<bool>())
85+
.ThrowsExactly<FormatException>();
86+
}
87+
88+
[Test]
89+
public async Task String_ParseSByte()
90+
{
91+
await Assert.That(() => "-128".Parse<sbyte>())
92+
.IsEqualTo(sbyte.MinValue);
93+
await Assert.That(() => "127".Parse<sbyte>())
94+
.IsEqualTo(sbyte.MaxValue);
95+
await Assert.That(() => "999".Parse<sbyte>())
96+
.ThrowsExactly<OverflowException>();
97+
}
98+
99+
[Test]
100+
public async Task String_ParseChar()
101+
{
102+
await Assert.That(() => "A".Parse<char>())
103+
.IsEqualTo('A');
104+
await Assert.That(() => "hello".Parse<char>())
105+
.IsEqualTo('h');
106+
}
107+
108+
[Test]
109+
public async Task String_ParseNumericTypes()
110+
{
111+
// short
112+
await Assert.That(() => "-32768".Parse<short>())
113+
.IsEqualTo(short.MinValue);
114+
await Assert.That(() => "32767".Parse<short>())
115+
.IsEqualTo(short.MaxValue);
116+
117+
// ushort
118+
await Assert.That(() => "0".Parse<ushort>())
119+
.IsEqualTo(ushort.MinValue);
120+
await Assert.That(() => "65535".Parse<ushort>())
121+
.IsEqualTo(ushort.MaxValue);
122+
123+
// int
124+
await Assert.That(() => "42".Parse<int>())
125+
.IsEqualTo(42);
126+
await Assert.That(() => "-100".Parse<int>())
127+
.IsEqualTo(-100);
128+
129+
// uint
130+
await Assert.That(() => "42".Parse<uint>())
131+
.IsEqualTo(42u);
132+
133+
// long
134+
await Assert.That(() => "9999999999".Parse<long>())
135+
.IsEqualTo(9999999999L);
136+
137+
// ulong
138+
await Assert.That(() => "18446744073709551615".Parse<ulong>())
139+
.IsEqualTo(ulong.MaxValue);
140+
141+
// double (invariant culture)
142+
await Assert.That(() => "3.14".Parse<double>())
143+
.IsEqualTo(3.14);
144+
await Assert.That(() => "-2.5".Parse<double>())
145+
.IsEqualTo(-2.5);
146+
}
147+
148+
[Test]
149+
public async Task String_ParseDateTime()
150+
{
151+
await Assert.That(() => "2024-01-15".Parse<DateTime>())
152+
.IsEqualTo(new DateTime(2024, 1, 15));
153+
await Assert.That(() => "01/15/2024".Parse<DateTime>())
154+
.IsEqualTo(new DateTime(2024, 1, 15));
155+
}
156+
157+
[Test]
158+
public async Task String_ParseTimeSpan()
159+
{
160+
await Assert.That(() => "01:30:00".Parse<TimeSpan>())
161+
.IsEqualTo(TimeSpan.FromMinutes(90));
162+
await Assert.That(() => "00:00:30".Parse<TimeSpan>())
163+
.IsEqualTo(TimeSpan.FromSeconds(30));
164+
}
165+
166+
[Test]
167+
public async Task String_ParseGuid()
168+
{
169+
var guid = new Guid("12345678-1234-1234-1234-123456789abc");
170+
171+
await Assert.That(() => "12345678-1234-1234-1234-123456789abc".Parse<Guid>())
172+
.IsEqualTo(guid);
173+
}
174+
175+
[Test]
176+
public async Task String_ParseVersion()
177+
{
178+
await Assert.That(() => "1.2.3.4".Parse<Version>())
179+
.IsEqualTo(new Version(1, 2, 3, 4));
180+
await Assert.That(() => "2.0".Parse<Version>())
181+
.IsEqualTo(new Version(2, 0));
182+
}
183+
184+
[Test]
185+
public async Task String_TryParse_NullInput_ThrowsArgumentNullException()
186+
{
187+
string nullStr = null!;
188+
189+
await Assert.That(() => nullStr.TryParse(out int _))
190+
.ThrowsExactly<ArgumentNullException>();
191+
}
192+
193+
[Test]
194+
public async Task String_TryParse_UnsupportedType_ReturnsFalse()
195+
{
196+
var result = "test".TryParse(out object? val);
197+
await Assert.That(result)
198+
.IsFalse();
199+
await Assert.That(val)
200+
.IsNull();
201+
}
202+
203+
[Test]
204+
public async Task String_TryParse_ValidValue_ReturnsTrueWithParsedValue()
205+
{
206+
var intResult = "42".TryParse(out int intVal);
207+
await Assert.That(intResult)
208+
.IsTrue();
209+
await Assert.That(intVal)
210+
.IsEqualTo(42);
211+
212+
var boolResult = "true".TryParse(out bool boolVal);
213+
await Assert.That(boolResult)
214+
.IsTrue();
215+
await Assert.That(boolVal)
216+
.IsTrue();
217+
218+
var doubleResult = "3.14".TryParse(out double doubleVal);
219+
await Assert.That(doubleResult)
220+
.IsTrue();
221+
await Assert.That(doubleVal)
222+
.IsEqualTo(3.14);
223+
}
224+
53225
enum TestEnum
54226
{
55227
Default,
@@ -215,6 +387,17 @@ await Assert.That(() => "test\r\nnew\r\nlines\r\n".AllIndexesOf("\r\n").ToArray(
215387
.IsEquivalentTo([4, 9, 16]);
216388
}
217389

390+
[Test]
391+
public async Task String_AllIndexesOf_OverlappingMatches()
392+
{
393+
await Assert.That(() => "aaa".AllIndexesOf("aa").ToArray())
394+
.IsEquivalentTo([0, 1]);
395+
await Assert.That(() => "abab".AllIndexesOf("ab").ToArray())
396+
.IsEquivalentTo([0, 2]);
397+
await Assert.That(() => "xxxx".AllIndexesOf("xx").ToArray())
398+
.IsEquivalentTo([0, 1, 2]);
399+
}
400+
218401
[Test]
219402
public async Task Char_Repeat_ZeroTimes_ReturnsEmptyString()
220403
{
@@ -285,6 +468,13 @@ await Assert.That(() => "test".PadRight(-1))
285468
.ThrowsExactly<ArgumentOutOfRangeException>();
286469
}
287470

471+
[Test]
472+
public async Task String_PadRight_WithZeroTotalLength_ReturnsSameString()
473+
{
474+
await Assert.That(() => "test".PadRight(0))
475+
.IsEqualTo("test");
476+
}
477+
288478
[Test]
289479
public async Task String_PadLeft_WithDefaultSpaceCharacter()
290480
{
@@ -326,4 +516,11 @@ public async Task String_PadLeft_WithNegativeTotalLength_ThrowsArgumentOutOfRang
326516
await Assert.That(() => "test".PadLeft(-1))
327517
.ThrowsExactly<ArgumentOutOfRangeException>();
328518
}
519+
520+
[Test]
521+
public async Task String_PadLeft_WithZeroTotalLength_ReturnsSameString()
522+
{
523+
await Assert.That(() => "test".PadLeft(0))
524+
.IsEqualTo("test");
525+
}
329526
}

0 commit comments

Comments
 (0)