<Rule Id="xUnit1026" Action="None" /> <!-- Theory methods should use all of their parameters -->
<Rule Id="xUnit2005" Action="None" /> <!-- Do not use identity check on value type -->
<Rule Id="xUnit2006" Action="None" /> <!-- Do not use invalid string equality check -->
- <Rule Id="xUnit2009" Action="None" /> <!-- Do not use boolean check to check for substrings -->
<Rule Id="xUnit2013" Action="None" /> <!-- Do not use equality check to check for collection size. -->
<Rule Id="xUnit2017" Action="None" /> <!-- Do not use Contains() to check if a value exists in a collection -->
<Rule Id="xUnit2018" Action="None" /> <!-- Do not compare an object's exact type to an abstract class or interface -->
using Microsoft.DotNet.RemoteExecutor;
using Xunit;
+#pragma warning disable xUnit2009 // these are the tests for String and so should be using the explicit methods on String
+
namespace System.Tests
{
//When add new tests make sure to add checks for both string and span APIs where relevant.
// Property is independent of the actual assembly.
var assemblyInfo = new AssemblyInfo(Assembly.GetExecutingAssembly());
var stackTrace = assemblyInfo.StackTrace;
- Assert.True(stackTrace.Contains(nameof(AssemblyInfoTests)));
+ Assert.Contains(nameof(AssemblyInfoTests), stackTrace);
}
[Fact]
CompareAttribute attribute = new CompareAttribute(nameof(CompareObject.ComparePropertyWithDisplayName));
string oldErrorMessage = attribute.FormatErrorMessage("name");
- Assert.False(oldErrorMessage.Contains("CustomDisplayName"));
+ Assert.DoesNotContain("CustomDisplayName", oldErrorMessage);
Assert.Throws<ValidationException>(() => attribute.Validate("test1", new ValidationContext(new CompareObject("test"))));
string newErrorMessage = attribute.FormatErrorMessage("name");
Assert.NotEqual(oldErrorMessage, newErrorMessage);
- Assert.True(newErrorMessage.Contains("CustomDisplayName"));
+ Assert.Contains("CustomDisplayName", newErrorMessage);
}
private class DerivedCompareAttribute : CompareAttribute
if (rootCauseCount == 1)
{
- Assert.True(line.Contains(SR.CompositionException_SingleErrorWithSinglePath));
+ Assert.Contains(SR.CompositionException_SingleErrorWithSinglePath, line);
}
else
{
var metadata = export.Metadata;
});
- Assert.True(ex.Message.Contains("Bar"));
+ Assert.Contains("Bar", ex.Message);
}
[AttributeUsage(AttributeTargets.All)]
var metadata = export.Metadata;
});
- Assert.True(ex.Message.Contains("DuplicateMetadataName"));
+ Assert.Contains("DuplicateMetadataName", ex.Message);
}
[PartNotDiscoverable]
var metadata = export.Metadata;
});
- Assert.True(ex.Message.Contains("DuplicateMetadataName"));
+ Assert.Contains("DuplicateMetadataName", ex.Message);
}
[Export]
var metadata = export.Metadata;
});
- Assert.True(ex.Message.Contains(CompositionConstants.PartCreationPolicyMetadataName));
+ Assert.Contains(CompositionConstants.PartCreationPolicyMetadataName, ex.Message);
}
#endregion
Assert.False(definition.IsPrerequisite);
Assert.Null(((ICompositionElement)definition).Origin);
Assert.NotNull(((ICompositionElement)definition).DisplayName);
- Assert.True(((ICompositionElement)definition).DisplayName.Contains(expectedMember.GetDisplayName()));
+ Assert.Contains(expectedMember.GetDisplayName(), ((ICompositionElement)definition).DisplayName);
}
[Fact]
var c = CreateContainer(typeof(LogA), typeof(LogB));
var x = Assert.Throws<CompositionFailedException>(() =>
c.GetExport<ILog>());
- Assert.True(x.Message.Contains("LogA"));
- Assert.True(x.Message.Contains("LogB"));
+ Assert.Contains("LogA", x.Message);
+ Assert.Contains("LogB", x.Message);
}
[Fact]
var c = CreateContainer(typeof(LogA), typeof(LogB), typeof(UsesLog));
var x = Assert.Throws<CompositionFailedException>(() =>
c.GetExport<UsesLog>());
- Assert.True(x.Message.Contains("LogA"));
- Assert.True(x.Message.Contains("LogB"));
+ Assert.Contains("LogA", x.Message);
+ Assert.Contains("LogB", x.Message);
}
}
}
}
catch (Exception ex)
{
- Assert.True(ex.Message.Contains("The component (unknown) cannot be created outside the Boundary sharing boundary"));
+ Assert.Contains("The component (unknown) cannot be created outside the Boundary sharing boundary", ex.Message);
}
}
dr = dtParent.Rows[0];
// ToString
- Assert.True(dr.ToString().ToLower().StartsWith("system.data.datarow"));
+ Assert.StartsWith("system.data.datarow", dr.ToString().ToLower());
}
[Fact]
proxy.PauseCopying();
string errorMessage = SystemDataResourceManager.Instance.SQL_Timeout;
Exception exception = Assert.Throws<SqlException>(() => reader.GetValue(0));
- Assert.True(exception.Message.Contains(errorMessage));
+ Assert.Contains(errorMessage, exception.Message);
// Return everything to normal and close
proxy.ResumeCopying();
Assert.Equal(expectedType, type);
Assert.Equal("Microsoft.SqlServer.Types", assembly);
- Assert.True(version.StartsWith("Version"));
- Assert.True(culture.StartsWith("Culture"));
- Assert.True(token.StartsWith("PublicKeyToken"));
+ Assert.StartsWith("Version", version);
+ Assert.StartsWith("Culture", culture);
+ Assert.StartsWith("PublicKeyToken", token);
}
private static string ToHexString(byte[] bytes)
{
Assert.Null(e.Condition);
Assert.False(e.Handled);
- Assert.True(e.Message.Contains(message));
+ Assert.Contains(message, e.Message);
Assert.False(e.Unwind);
e.SetHandled();
}))
{
Assert.Null(e.Condition);
Assert.False(e.Handled);
- Assert.True(e.Message.Contains(message));
+ Assert.Contains(message, e.Message);
Assert.False(e.Unwind);
e.SetHandled();
}))
activity.SetParentId(parentId);
activity.Start();
Assert.Equal(ActivityIdFormat.Hierarchical, activity.IdFormat);
- Assert.True(activity.Id.StartsWith(parentId));
+ Assert.StartsWith(parentId, activity.Id);
}).Dispose();
}
Assert.NotNull(traceparent);
Assert.Equal("some=state", tracestate);
Assert.Equal("k=v", correlationContext);
- Assert.True(traceparent.StartsWith($"00-{parent.TraceId.ToHexString()}-"));
+ Assert.StartsWith($"00-{parent.TraceId.ToHexString()}-", traceparent);
Assert.Matches("^[0-9a-f]{2}-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$", traceparent);
Assert.Null(startRequest.Headers["Request-Id"]);
}
var correlationContext = thisRequest.Headers["Correlation-Context"];
Assert.NotNull(requestId);
- Assert.True(requestId.StartsWith(parentActivity.Id));
+ Assert.StartsWith(parentActivity.Id, requestId);
Assert.NotNull(correlationContext);
Assert.True(correlationContext == "k1=v1,k2=v2" || correlationContext == "k2=v2,k1=v1");
// all requests have Request-Id with proper parent Id
var requestId = request.Headers["Request-Id"];
- Assert.True(requestId.StartsWith(parentActivity.Id));
+ Assert.StartsWith(parentActivity.Id, requestId);
// all request activities are siblings:
var childSuffix = requestId.Substring(0, parentActivity.Id.Length);
Assert.True(childSuffix.IndexOf('.') == childSuffix.Length - 1);
var listener = new TestDefaultTraceListener();
listener.ShouldOverrideWriteLine = false;
listener.Fail("FAIL");
- Assert.False(listener.Output.Contains("FAIL"));
+ Assert.DoesNotContain("FAIL", listener.Output);
}
[Fact]
// We log EventWithXferWeirdArgs in one case and
// WorkWeirdArgs/Send in the other
- Assert.True(evt.EventName.Contains("WeirdArgs"));
+ Assert.Contains("WeirdArgs", evt.EventName);
Assert.Equal("128", evt.PayloadValue(0, "iptr").ToString());
Assert.True((bool)evt.PayloadValue(1, "b"));
{
if (partialResult[i] is SearchResultEntry)
{
- Assert.True(((SearchResultEntry)partialResult[i]).DistinguishedName.Contains("Group9"));
+ Assert.Contains("Group9", ((SearchResultEntry)partialResult[i]).DistinguishedName);
}
}
}
{
foreach (SearchResultEntry entry in response.Entries)
{
- Assert.True(entry.DistinguishedName.Contains("Group9"));
+ Assert.Contains("Group9", entry.DistinguishedName);
}
}
}
foreach (ZipArchiveEntry actualEntry in actual_withbasedir.Entries)
{
string expectedFile = expected.Single(i => Path.GetFileName(i).Equals(actualEntry.Name));
- Assert.True(actualEntry.FullName.StartsWith("normal"));
+ Assert.StartsWith("normal", actualEntry.FullName);
Assert.Equal(new FileInfo(expectedFile).Length, actualEntry.Length);
using (Stream expectedStream = File.OpenRead(expectedFile))
using (Stream actualStream = actualEntry.Open())
using (ZipArchive archive = ZipFile.OpenRead(archivePath))
{
Assert.Equal(1, archive.Entries.Count);
- Assert.True(archive.Entries[0].FullName.StartsWith("empty1"));
+ Assert.StartsWith("empty1", archive.Entries[0].FullName);
}
}
}
private static void AssertStackTrace(Exception ex, string searchTerm)
{
- Assert.True(ex.StackTrace.Contains(searchTerm));
+ Assert.Contains(searchTerm, ex.StackTrace);
}
private sealed class Thrower
if (parent.IdFormat == ActivityIdFormat.Hierarchical)
{
Assert.True(requestId != null, "Request-Id was not injected when instrumentation was enabled");
- Assert.True(requestId.StartsWith(parent.Id));
+ Assert.StartsWith(parent.Id, requestId);
Assert.NotEqual(parent.Id, requestId);
Assert.Null(traceparent);
Assert.Null(tracestate);
{
Assert.Null(requestId);
Assert.True(traceparent != null, "traceparent was not injected when W3C instrumentation was enabled");
- Assert.True(traceparent.StartsWith($"00-{parent.TraceId.ToHexString()}-"));
+ Assert.StartsWith($"00-{parent.TraceId.ToHexString()}-", traceparent);
Assert.Equal(parent.TraceStateString, tracestate);
}
string[] headers = (await server.AcceptConnectionSendResponseAndCloseAsync()).ToArray();
await sendTask;
- Assert.True(headers[1].StartsWith("Host"));
+ Assert.StartsWith("Host", headers[1]);
}
});
}
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
TestHelper.VerifyRequestMethod(response, method);
string responseContent = await response.Content.ReadAsStringAsync();
- Assert.False(responseContent.Contains(ExpectedContent));
+ Assert.DoesNotContain(ExpectedContent, responseContent);
}
}
}
_message.EncodeHeaders(_headers, false);
string encodedHeader = _headers.Get("X-Custom");
- Assert.True(encodedHeader.StartsWith("="));
- Assert.True(encodedHeader.EndsWith("="));
+ Assert.StartsWith("=", encodedHeader);
+ Assert.EndsWith("=", encodedHeader);
//should contain no unicode
Assert.False(ContainsNonAscii(encodedHeader), encodedHeader);
Assert.Equal(1, replyToHeaders.Length);
//all headers that were set via properties should remain
- Assert.True(fromHeaders[0].Contains(validFrom));
- Assert.True(toHeaders[0].Contains(validTo));
- Assert.True(ccHeaders[0].Contains(validCc));
- Assert.True(replyToHeaders[0].Contains(validReplyTo));
+ Assert.Contains(validFrom, fromHeaders[0]);
+ Assert.Contains(validTo, toHeaders[0]);
+ Assert.Contains(validCc, ccHeaders[0]);
+ Assert.Contains(validReplyTo, replyToHeaders[0]);
}
[Fact]
Assert.True(_message.Headers.GetValues("X-Priority").Length == 1, "x-priority was not set");
Assert.True(_message.Headers.GetValues("Priority").Length == 1, "priority was not set");
- Assert.True(_message.Headers.GetValues("Importance")[0].Contains("low"));
- Assert.True(_message.Headers.GetValues("X-Priority")[0].Contains("5"));
- Assert.True(_message.Headers.GetValues("Priority")[0].Contains("non-urgent"));
+ Assert.Contains("low", _message.Headers.GetValues("Importance")[0]);
+ Assert.Contains("5", _message.Headers.GetValues("X-Priority")[0]);
+ Assert.Contains("non-urgent", _message.Headers.GetValues("Priority")[0]);
}
[Fact]
Assert.Equal("correct subject", _message.Subject);
Assert.True(_message.Headers.GetValues("Subject").Length == 1);
- Assert.True(_message.Headers.GetValues("Subject")[0].Contains("correct subject"));
+ Assert.Contains("correct subject", _message.Headers.GetValues("Subject")[0]);
}
[Fact]
string[] s = _message.Headers.GetValues("Reply-To");
Assert.Equal(1, s.Length);
- Assert.False(s[0].Contains("test@example.com"));
- Assert.False(s[0].Contains("test2@example.com"));
- Assert.True(s[0].Contains("test3@example.com"));
+ Assert.DoesNotContain("test@example.com", s[0]);
+ Assert.DoesNotContain("test2@example.com", s[0]);
+ Assert.Contains("test3@example.com", s[0]);
}
[Fact]
string[] s = _message.Headers.GetValues("Reply-To");
Assert.Equal(1, s.Length);
- Assert.True(s[0].Contains("test@example.com"));
- Assert.True(s[0].Contains("test2@example.com"));
- Assert.True(s[0].Contains("test3@example.com"));
+ Assert.Contains("test@example.com", s[0]);
+ Assert.Contains("test2@example.com", s[0]);
+ Assert.Contains("test3@example.com", s[0]);
Assert.Null(_message.ReplyTo);
}
string[] s = _message.Headers.GetValues("Reply-To");
Assert.Equal(1, s.Length);
- Assert.True(s[0].Contains("test@example.com"));
- Assert.True(s[0].Contains("test2@example.com"));
- Assert.True(s[0].Contains("test3@example.com"));
- Assert.False(s[0].Contains("shouldnotbeset@example.com"));
+ Assert.Contains("test@example.com", s[0]);
+ Assert.Contains("test2@example.com", s[0]);
+ Assert.Contains("test3@example.com", s[0]);
+ Assert.DoesNotContain("shouldnotbeset@example.com", s[0]);
Assert.Null(_message.ReplyTo);
}
false));
Assert.NotNull(e.InnerException);
- Assert.True(e.InnerException.Message.Contains("SSL_ERROR_SSL"));
+ Assert.Contains("SSL_ERROR_SSL", e.InnerException.Message);
Assert.NotNull(e.InnerException.InnerException);
- Assert.True(e.InnerException.InnerException.Message.Contains("protocol"));
+ Assert.Contains("protocol", e.InnerException.InnerException.Message);
}
}
Assert.Equal(WebSocketMessageType.Text, recvResult.MessageType);
string headers = WebSocketData.GetTextFromBuffer(new ArraySegment<byte>(buffer, 0, recvResult.Count));
- Assert.True(headers.Contains("X-CustomHeader1:Value1"));
- Assert.True(headers.Contains("X-CustomHeader2:Value2"));
+ Assert.Contains("X-CustomHeader1:Value1", headers);
+ Assert.Contains("X-CustomHeader2:Value2", headers);
await cws.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
}
Assert.Equal(WebSocketMessageType.Text, recvResult.MessageType);
string headers = WebSocketData.GetTextFromBuffer(new ArraySegment<byte>(buffer, 0, recvResult.Count));
- Assert.True(headers.Contains("Cookies=Are Yummy"));
- Assert.True(headers.Contains("Especially=Chocolate Chip"));
+ Assert.Contains("Cookies=Are Yummy", headers);
+ Assert.Contains("Especially=Chocolate Chip", headers);
Assert.Equal(server.Scheme == "wss", headers.Contains("Occasionally=Raisin"));
await cws.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
Uri resolvedUri = resolver.ResolveUri(baseUri, path);
Assert.Equal(Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, path)), resolvedUri.LocalPath);
- Assert.True(resolvedUri.LocalPath.EndsWith(path.Replace('/', Path.DirectorySeparatorChar)));
+ Assert.EndsWith(path.Replace('/', Path.DirectorySeparatorChar), resolvedUri.LocalPath);
}
[Theory]
else
{
string output = ReadAsString(ms);
- Assert.True(output.Contains("<test>abc"));
+ Assert.Contains("<test>abc", output);
Assert.NotEqual(output.Contains("<?xml version"), omitXmlDeclaration);
Assert.Equal(output.Contains(" "), indent);
Assert.Equal(output.Contains("</test>"), writeEndDocumentOnClose);
}
else
{
- Assert.True(Path.GetFullPath(bad).EndsWith(bad));
+ Assert.EndsWith(bad, Path.GetFullPath(bad));
}
Assert.Equal(string.Empty, Path.GetPathRoot(bad));
Assert.False(Path.IsPathRooted(bad));
{
string parameterName = "THISISAPARAMETERNAME";
var exception = new DuplicateWaitObjectException(parameterName);
- Assert.True(exception.Message.Contains(parameterName));
+ Assert.Contains(parameterName, exception.Message);
Assert.Equal(COR_E_DUPLICATEWAITOBJECT, exception.HResult);
}
string parameterName = "THISISAPARAMETERNAME";
string message = "CreatedDuplicateWaitObjectException";
var exception = new DuplicateWaitObjectException(parameterName, message);
- Assert.True(exception.Message.Contains(parameterName));
- Assert.True(exception.Message.Contains(message));
+ Assert.Contains(parameterName, exception.Message);
+ Assert.Contains(message, exception.Message);
}
}
}
string className = "class";
string memberName = "member";
var exception = new MissingFieldException(className, memberName);
- Assert.True(exception.Message.Contains(className));
- Assert.True(exception.Message.Contains(memberName));
+ Assert.Contains(className, exception.Message);
+ Assert.Contains(memberName, exception.Message);
}
}
}
string className = "class";
string memberName = "member";
var exception = new MissingMemberException(className, memberName);
- Assert.True(exception.Message.Contains(className));
- Assert.True(exception.Message.Contains(memberName));
+ Assert.Contains(className, exception.Message);
+ Assert.Contains(memberName, exception.Message);
}
}
}
string className = "class";
string memberName = "member";
var exception = new MissingMethodException(className, memberName);
- Assert.True(exception.Message.Contains(className));
- Assert.True(exception.Message.Contains(memberName));
+ Assert.Contains(className, exception.Message);
+ Assert.Contains(memberName, exception.Message);
}
}
}
PrincipalPermission copy = (PrincipalPermission)p.Copy();
Assert.Equal(p.IsUnrestricted(), copy.IsUnrestricted());
SecurityElement se = p.ToXml();
- Assert.True((se.Attributes["class"] as string).StartsWith(className));
- Assert.Equal("1", (se.Attributes["version"] as string));
+ Assert.StartsWith(className, se.Attributes["class"] as string);
+ Assert.Equal("1", se.Attributes["version"] as string);
}
[Fact]
exceptionThrown = true;
// Exception should contain path.
- Assert.True(exception.ToString().Contains("Path: $.Children[0].MyProperty"));
+ Assert.Contains("Path: $.Children[0].MyProperty", exception.ToString());
}
Assert.True(exceptionThrown);
};
string json = JsonSerializer.Serialize(input);
- Assert.True(json.Contains("[1,2]"));
- Assert.True(json.Contains("[3,4]"));
+ Assert.Contains("[1,2]", json);
+ Assert.Contains("[3,4]", json);
}
[Fact]
});
string json = JsonSerializer.Serialize(input);
- Assert.True(json.Contains("[1,2]"));
- Assert.True(json.Contains("[3,4]"));
+ Assert.Contains("[1,2]", json);
+ Assert.Contains("[3,4]", json);
}
[Fact]
});
string json = JsonSerializer.Serialize(input);
- Assert.True(json.Contains("[1,2]"));
- Assert.True(json.Contains("[3,4]"));
+ Assert.Contains("[1,2]", json);
+ Assert.Contains("[3,4]", json);
}
[Fact]
});
string json = JsonSerializer.Serialize(input);
- Assert.True(json.Contains("[1,2]"));
- Assert.True(json.Contains("[3,4]"));
+ Assert.Contains("[1,2]", json);
+ Assert.Contains("[3,4]", json);
}
[Fact]
});
string json = JsonSerializer.Serialize(input);
- Assert.True(json.Contains("[1,2]"));
- Assert.True(json.Contains("[3,4]"));
+ Assert.Contains("[1,2]", json);
+ Assert.Contains("[3,4]", json);
}
[Fact]
});
string json = JsonSerializer.Serialize(input);
- Assert.True(json.Contains("[1,2]"));
- Assert.True(json.Contains("[3,4]"));
+ Assert.Contains("[1,2]", json);
+ Assert.Contains("[3,4]", json);
}
[Fact]
projects / platform / upstream / dotnet / runtime.git / commitdiff