<Rule Id="xUnit1024" Action="None" /> <!-- Test methods cannot have overloads -->
<Rule Id="xUnit1026" Action="None" /> <!-- Theory methods should use all of their parameters -->
<Rule Id="xUnit2000" Action="None" /> <!-- Constants and literals should be the expected argument -->
- <Rule Id="xUnit2002" Action="None" /> <!-- Do not use null check on value type -->
<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 -->
using System.Linq;
using Microsoft.DotNet.RemoteExecutor;
using Xunit;
+using Xunit.Sdk;
namespace Microsoft.VisualBasic.Tests
{
{
ex = e;
}
- Assert.NotNull(ex?.GetType() == typeof(TException));
+ if (ex == null)
+ {
+ throw new ThrowsException(typeof(TException));
+ }
+
+ if (ex.GetType() != typeof(TException))
+ {
+ throw new ThrowsException(typeof(TException), ex);
+ }
}
}
}
public static void Constructor_DefaultTest()
{
BitVector32 bv = new BitVector32();
- Assert.NotNull(bv);
Assert.Equal(0, bv.Data);
// Copy constructor results in item with same data.
BitVector32 copied = new BitVector32(bv);
- Assert.NotNull(bv);
Assert.Equal(0, copied.Data);
}
public static void Constructor_DataTest(int data)
{
BitVector32 bv = new BitVector32(data);
- Assert.NotNull(bv);
Assert.Equal(data, bv.Data);
// Copy constructor results in item with same data.
BitVector32 copied = new BitVector32(bv);
- Assert.NotNull(bv);
Assert.Equal(data, copied.Data);
}
}
}
};
- Assert.NotNull(Element.GetHashCode());
}
}
}
}
else
{
- Assert.NotNull(adapter.Fill(ds, tableName));
+ Assert.InRange(adapter.Fill(ds, tableName), 0, int.MaxValue);
}
}
};
HttpWebRequest stopRequest = ReadPublicProperty<HttpWebRequest>(stopEvent.Value, "Request");
Assert.Equal(startRequest, stopRequest);
HttpStatusCode status = ReadPublicProperty<HttpStatusCode>(stopEvent.Value, "StatusCode");
- Assert.NotNull(status);
+ Assert.Equal(HttpStatusCode.OK, status);
WebHeaderCollection headers = ReadPublicProperty<WebHeaderCollection>(stopEvent.Value, "Headers");
Assert.NotNull(headers);
foreach (var keyword in providerMetadata.Keywords)
{
Assert.NotEmpty(keyword.Name);
- Assert.NotNull(keyword.Value);
}
foreach (var logLink in providerMetadata.LogLinks)
{
var endSegment = (BufferSegment)end;
Assert.Same(startSegment, endSegment);
- Assert.NotNull(startSegment.Memory);
Assert.IsType<byte[]>(startSegment.MemoryOwner);
pipe.Reader.AdvanceTo(result.Buffer.End);
Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address);
Assert.Equal(SocketFlags.None, socketFlags);
- Assert.NotNull(ipPacketInformation);
Assert.Equal(connectTo, ipPacketInformation.Address);
}
Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address);
Assert.Equal(SocketFlags.None, socketFlags);
- Assert.NotNull(ipPacketInformation);
Assert.Equal(connectTo, ipPacketInformation.Address);
}
}
Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address);
Assert.Equal(SocketFlags.None, args.SocketFlags);
- Assert.NotNull(args.ReceiveMessageFromPacketInfo);
Assert.Equal(connectTo, args.ReceiveMessageFromPacketInfo.Address);
}
}
}
UdpReceiveResult result = await receiver.ReceiveAsync();
- Assert.NotNull(result);
Assert.NotNull(result.RemoteEndPoint);
Assert.NotNull(result.Buffer);
Assert.InRange(result.Buffer.Length, 1, int.MaxValue);
}
UdpReceiveResult result = await receiver.ReceiveAsync();
- Assert.NotNull(result);
Assert.NotNull(result.RemoteEndPoint);
Assert.NotNull(result.Buffer);
Assert.InRange(result.Buffer.Length, 1, int.MaxValue);
var getDataRequestBodyValue = 3;
var getDataRequestBodyActual = RoundTripWithXmlMembersMapping<int>(getDataRequestBodyValue, memberName, "<?xml version=\"1.0\"?>\r\n<value xmlns=\"http://tempuri.org/\">3</value>");
- Assert.NotNull(getDataRequestBodyActual);
Assert.Equal(getDataRequestBodyValue, getDataRequestBodyActual);
}
var getDataRequestBodyValue = 3;
var getDataRequestBodyActual = RoundTripWithXmlMembersMappingSoap<int>(getDataRequestBodyValue, memberName, "<?xml version=\"1.0\"?>\r\n<int d1p1:type=\"int\" xmlns:d1p1=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://www.w3.org/2001/XMLSchema\">3</int>");
- Assert.NotNull(getDataRequestBodyActual);
Assert.Equal(getDataRequestBodyValue, getDataRequestBodyActual);
}
"<?xml version=\"1.0\"?>\r\n<q1:wrapper xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:q1=\"http://tempuri.org/\">\r\n <value xsi:type=\"xsd:int\">3</value>\r\n</q1:wrapper>",
wrapperName: "wrapper");
- Assert.NotNull(getDataRequestBodyActual);
Assert.Equal(getDataRequestBodyValue, getDataRequestBodyActual);
}
wrapperName: "wrapper",
validate: true);
- Assert.NotNull(getDataRequestBodyActual);
Assert.Equal(getDataRequestBodyValue, getDataRequestBodyActual);
}
using (StringReader reader = new StringReader(xml))
{
TimeSpan deserializedObj = (TimeSpan)serializer.Deserialize(reader);
- Assert.NotNull(deserializedObj);
Assert.Equal(default(TimeSpan), deserializedObj);
}
}
TypeInfo ti = t.GetTypeInfo();
Guid myguid = ti.GUID;
- Assert.NotNull(myguid);
+ Assert.NotEqual(Guid.Empty, myguid);
}
// Verify HasElementType
public void Flags_CurrentlyExecutingAssembly()
{
AssemblyName assemblyName = Helpers.ExecutingAssembly.GetName();
- Assert.NotNull(assemblyName.Flags);
+ Assert.NotEqual(AssemblyNameFlags.None, assemblyName.Flags);
}
[Theory]
{
MethodInfo methodInfo = GetMethod(typeof(MI_SubClass), "ReturnVoidMethod");
MethodAttributes attributes = methodInfo.Attributes;
- Assert.NotNull(attributes);
+ Assert.True(attributes.HasFlag(MethodAttributes.Public));
}
[Fact]
{
MethodInfo methodInfo = GetMethod(typeof(MI_SubClass), "ReturnVoidMethod");
CallingConventions callingConvention = methodInfo.CallingConvention;
- Assert.NotNull(callingConvention);
+ Assert.True(callingConvention.HasFlag(CallingConventions.HasThis));
}
[Theory]
IDictionaryEnumerator enumerator = results.GetEnumerator();
while (enumerator.MoveNext())
{
- Assert.NotNull(enumerator.Entry);
+ Assert.NotNull(enumerator.Entry.Key);
}
if (lookForSetValue)
f.Binder = binder;
Assert.Same(binder, f.Binder);
- Assert.NotNull(f.Context);
Assert.Null(f.Context.Context);
Assert.Equal(StreamingContextStates.All, f.Context.State);
var context = new StreamingContext(StreamingContextStates.Clone);
var x = new KeyValuePair<string, object>("key1", "key1value");
var y = SerializeAndDeserialize<KeyValuePair<string, object>>(x, @"{""key"":""key1"",""value"":""key1value""}");
- Assert.NotNull(y);
Assert.StrictEqual(y.Key, "key1");
Assert.StrictEqual(y.Value, "key1value");
}
},
};
var actual = SerializeAndDeserialize(original, null, dcjsSettings, null, true);
- Assert.NotNull(actual);
Assert.Equal(original, actual);
}
}
};
var original = DateTime.Now;
var actual = SerializeAndDeserialize(original, null, dcjsSettings, null, true);
- Assert.NotNull(actual);
Assert.Equal(original, actual);
}
}
var graph = new DateTimeOffset(2008, 5, 1, 8, 6, 32, new TimeSpan(1, 0, 0));
dcjsSettings = new DataContractJsonSerializerSettings() { DateTimeFormat = jsonTypes.DTF_DMMMM };
var actual3 = SerializeAndDeserialize(graph, "{\"DateTime\":\"1, mayo\",\"OffsetMinutes\":60}", dcjsSettings);
- Assert.NotNull(actual3);
var expected3 = new DateTimeOffset(DateTime.Now.Year, 5, 1, 0, 0, 0, new TimeSpan(1, 0, 0));
Assert.True(actual3 == expected3,
$"{nameof(actual3)} was not as expected.\r\nExpected: {expected3} \r\n Actual: {actual3}");
expectedOutput = string.Format("\"{0}\"", expectedOutput);
dcjsSettings = new DataContractJsonSerializerSettings() { DateTimeFormat = jsonTypes.DTF_DefaultFormatProviderIsDateTimeFormatInfoDotCurrentInfo };
var actual6 = SerializeAndDeserialize(dateTime, expectedOutput, dcjsSettings);
- Assert.NotNull(actual6);
Assert.True(actual6 == dateTime);
}
KnownTypes = new List<Type>()
};
var actual = SerializeAndDeserialize(dateTime, expectedString, dcjsSettings);
- Assert.NotNull(actual);
Assert.True(actual == dateTime);
dcjsSettings = new DataContractJsonSerializerSettings()
string actualam = GetAmString(jsonTypes.DTF_hmsFt);
string baseline = $"\"03:58:32.00 {actualam}\"";
var actual2 = SerializeAndDeserialize(new DateTime(1, 1, 1, 3, 58, 32), baseline, dcjsSettings);
- Assert.NotNull(actual2);
Assert.True(actual2 == new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 3, 58, 32));
dcjsSettings = new DataContractJsonSerializerSettings()
};
var value3 = new DateTime(DateTime.Now.Year, 12, 20);
var actual3 = SerializeAndDeserialize(value3, "\"20, diciembre\"", dcjsSettings);
- Assert.NotNull(actual3);
Assert.Equal(value3, actual3);
dcjsSettings = new DataContractJsonSerializerSettings()
};
var value4 = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 0, 0, 32);
var actual4 = SerializeAndDeserialize(value4, "\"32\"", dcjsSettings);
- Assert.NotNull(actual4);
Assert.Equal(value4, actual4);
dcjsSettings = new DataContractJsonSerializerSettings()
};
var value5 = new DateTime(1998, 1, 1);
var actual5 = SerializeAndDeserialize(value5, "\"1998 A.D.\"", dcjsSettings);
- Assert.NotNull(actual5);
Assert.Equal(value5, actual5);
dcjsSettings = new DataContractJsonSerializerSettings()
};
var value6 = new DateTime(1998, 1, 1, 8, 25, 32, DateTimeKind.Utc);
var actual6 = SerializeAndDeserialize(value6, "\"1998-01-01T08:25:32.000Z\"", dcjsSettings);
- Assert.NotNull(actual6);
Assert.Equal(value6, actual6);
}
void Verify()
{
Assert.NotNull(obj.MyOverflow);
- Assert.NotNull(obj.MyOverflow["MyIntMissing"]);
Assert.Equal(1, obj.MyInt);
Assert.Equal(2, obj.MyOverflow["MyIntMissing"].GetInt32());
projects / platform / upstream / dotnet / runtime.git / commitdiff