<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="xUnit2007" Action="None" /> <!-- Do not use typeof expression to check the type -->
<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 -->
{
var sortedMap = Empty<int, GenericParameterHelper>().AddRange(Enumerable.Range(1, 100).Select(n => new KeyValuePair<int, GenericParameterHelper>(n, new GenericParameterHelper(n))));
var unsortedMap = sortedMap.ToImmutableDictionary();
- Assert.IsAssignableFrom(typeof(ImmutableDictionary<int, GenericParameterHelper>), unsortedMap);
+ Assert.IsAssignableFrom<ImmutableDictionary<int, GenericParameterHelper>>(unsortedMap);
Assert.Equal(sortedMap.Count, unsortedMap.Count);
Assert.Equal<KeyValuePair<int, GenericParameterHelper>>(sortedMap.ToList(), unsortedMap.ToList());
}
var component = TypeDescriptor.CreateInstance(null, typeof(DescriptorTestComponent), new[] { expectedString.GetType() }, new[] { expectedString });
Assert.NotNull(component);
- Assert.IsType(typeof(DescriptorTestComponent), component);
+ Assert.IsType<DescriptorTestComponent>(component);
Assert.Equal(expectedString, (component as DescriptorTestComponent).StringProperty);
}
.CreateContainer();
DerivedFromBaseWithImport export = container.GetExport<DerivedFromBaseWithImport>();
- Assert.IsAssignableFrom(typeof(Imported), export.Imported);
+ Assert.IsAssignableFrom<Imported>(export.Imported);
}
public class Imported { }
{
CompositionContext cc = CreateContainer(typeof(A), typeof(B), typeof(C), typeof(D));
D d = cc.GetExport<D>();
- Assert.IsAssignableFrom(typeof(A), d.A);
- Assert.IsAssignableFrom(typeof(B), d.B);
- Assert.IsAssignableFrom(typeof(A), d.B.A);
- Assert.IsAssignableFrom(typeof(C), d.C);
- Assert.IsAssignableFrom(typeof(A), d.C.A);
- Assert.IsAssignableFrom(typeof(B), d.C.B);
+ Assert.IsAssignableFrom<A>(d.A);
+ Assert.IsAssignableFrom<B>(d.B);
+ Assert.IsAssignableFrom<A>(d.B.A);
+ Assert.IsAssignableFrom<C>(d.C);
+ Assert.IsAssignableFrom<A>(d.C.A);
+ Assert.IsAssignableFrom<B>(d.C.B);
}
private static CompositionContext CreateContainer(params Type[] types)
{
var cc = CreateContainer(typeof(ACircular), typeof(BLazy));
var x = cc.GetExport<BLazy>();
- Assert.IsAssignableFrom(typeof(ACircular), x.A.Value);
- Assert.IsAssignableFrom(typeof(BLazy), ((ACircular)x.A.Value).B);
+ Assert.IsAssignableFrom<ACircular>(x.A.Value);
+ Assert.IsAssignableFrom<BLazy>(((ACircular)x.A.Value).B);
}
[Fact]
{
var cc = CreateContainer(typeof(ACircular), typeof(BLazy));
var x = cc.GetExport<IA>();
- Assert.IsAssignableFrom(typeof(BLazy), ((ACircular)((ACircular)x).B.A.Value).B);
+ Assert.IsAssignableFrom<BLazy>(((ACircular)((ACircular)x).B.A.Value).B);
}
[Fact]
var consumer = container.GetExport<Consumer>();
- Assert.IsAssignableFrom(typeof(ValueA), consumer.Values["A"]);
- Assert.IsAssignableFrom(typeof(ValueB), consumer.Values["B"]);
+ Assert.IsAssignableFrom<ValueA>(consumer.Values["A"]);
+ Assert.IsAssignableFrom<ValueB>(consumer.Values["B"]);
Assert.Equal(2, consumer.Values.Count());
}
{
var container = CreateContainer(typeof(UnfairRule));
var rule = container.GetExport<IRule>();
- Assert.IsAssignableFrom(typeof(UnfairRule), rule);
+ Assert.IsAssignableFrom<UnfairRule>(rule);
}
[Fact]
{
var container = CreateContainer(new ConventionBuilder(), typeof(UnfairRule));
var rule = container.GetExport<IRule>();
- Assert.IsAssignableFrom(typeof(UnfairRule), rule);
+ Assert.IsAssignableFrom<UnfairRule>(rule);
}
[Fact]
{
var container = CreateContainer(typeof(HomeController), typeof(CloudBus));
var hc = container.GetExport<HomeController>();
- Assert.IsAssignableFrom(typeof(CloudBus), hc.Bus);
+ Assert.IsAssignableFrom<CloudBus>(hc.Bus);
}
private class CustomImportAttribute : ImportAttribute { }
var cc = CreateContainer(typeof(A), typeof(UseExportFactory));
var bef = cc.GetExport<UseExportFactory>();
var a = bef.AFactory.CreateExport();
- Assert.IsAssignableFrom(typeof(A), a.Value);
+ Assert.IsAssignableFrom<A>(a.Value);
Assert.False(((A)a.Value).IsDisposed);
a.Dispose();
Assert.True(((A)a.Value).IsDisposed);
{
var cc = CreateContainer(typeof(A), typeof(BLazy));
var x = cc.GetExport<BLazy>();
- Assert.IsAssignableFrom(typeof(A), x.A.Value);
+ Assert.IsAssignableFrom<A>(x.A.Value);
}
[Fact]
{
var cc = CreateContainer(typeof(A));
var x = cc.GetExport<IA>();
- Assert.IsAssignableFrom(typeof(A), x);
+ Assert.IsAssignableFrom<A>(x);
}
[Fact]
{
var cc = CreateContainer(typeof(A), typeof(B));
var x = cc.GetExport<B>();
- Assert.IsAssignableFrom(typeof(A), x.A);
+ Assert.IsAssignableFrom<A>(x.A);
}
[Fact]
rb.ForType<HasPropertyA>().ImportProperty(a => a.A).Export();
var cc = CreateContainer(rb, typeof(HasPropertyA), typeof(A));
var x = cc.GetExport<HasPropertyA>();
- Assert.IsAssignableFrom(typeof(A), x.A);
+ Assert.IsAssignableFrom<A>(x.A);
}
[Fact]
{
var c = CreateContainer(typeof(Presenter), typeof(Controller));
var ctrl = c.GetExport<Controller>();
- Assert.IsAssignableFrom(typeof(Presenter), ctrl.Presenter);
+ Assert.IsAssignableFrom<Presenter>(ctrl.Presenter);
}
}
}
{
var cc = CreateContainer(typeof(BasicRepository<>));
var r = cc.GetExport<IRepository<string>>();
- Assert.IsAssignableFrom(typeof(BasicRepository<string>), r);
+ Assert.IsAssignableFrom<BasicRepository<string>>(r);
}
[Fact]
var cc = CreateContainer(typeof(BasicRepository<>));
var r = cc.GetExport<IRepository<string>>();
var r2 = cc.GetExport<IRepository<int>>();
- Assert.IsAssignableFrom(typeof(BasicRepository<int>), r2);
+ Assert.IsAssignableFrom<BasicRepository<int>>(r2);
}
[Fact]
{
var cc = CreateContainer(typeof(RepositoryProperty<>));
var r = cc.GetExport<IRepository<string>>();
- Assert.IsAssignableFrom(typeof(BasicRepository<string>), r);
+ Assert.IsAssignableFrom<BasicRepository<string>>(r);
}
[Fact]
{
var cc = CreateContainer(typeof(FirstAndSecond<>));
var first = cc.GetExport<IFirst<string>>();
- Assert.IsAssignableFrom(typeof(FirstAndSecond<string>), first);
+ Assert.IsAssignableFrom<FirstAndSecond<string>>(first);
}
// In future, the set of allowable generic type mappings will be expanded (see
{
var cc = CreateContainer(typeof(ExportSelf<>));
var es = cc.GetExport<ExportSelf<string>>();
- Assert.IsAssignableFrom(typeof(ExportSelf<string>), es);
+ Assert.IsAssignableFrom<ExportSelf<string>>(es);
}
[Fact]
{
var cc = CreateContainer(typeof(ExportsBase<>));
var es = cc.GetExport<SomeGenericType<string>>();
- Assert.IsAssignableFrom(typeof(ExportsBase<string>), es);
+ Assert.IsAssignableFrom<ExportsBase<string>>(es);
}
}
}
// EventListener will return the boxed value of the nullable, which will either be a value or null object reference
else if (wrappedValue != null)
{
- Assert.IsType(typeof(T), wrappedValue);
+ Assert.IsType<T>(wrappedValue);
return (T?)wrappedValue;
}
public void Calendar_Get_InvariantInfo()
{
CultureInfo cultureInfo = CultureInfo.InvariantCulture;
- Assert.IsType(typeof(GregorianCalendar), cultureInfo.Calendar);
+ Assert.IsType<GregorianCalendar>(cultureInfo.Calendar);
Assert.Same(cultureInfo.Calendar, cultureInfo.Calendar);
}
{
CultureInfo cultureInfo = CultureInfo.InvariantCulture;
Assert.Equal(1, cultureInfo.OptionalCalendars.Length);
- Assert.IsType(typeof(GregorianCalendar), cultureInfo.OptionalCalendars[0]);
+ Assert.IsType<GregorianCalendar>(cultureInfo.OptionalCalendars[0]);
}
}
}
Assert.NotNull(part);
Assert.Equal(part.Uri, partUri);
- Assert.IsType(typeof(MockPackagePart), part);
+ Assert.IsType<MockPackagePart>(part);
// Validate we get the same object back if we call GetPart again
Assert.Same(part, mockPackage.GetPart(partUri));
// Server is expected to not have received any request.
cts.Cancel();
AggregateException e = Assert.Throws<AggregateException>(() => serverTask.Wait(10_000));
- Assert.IsType(typeof(TaskCanceledException), e.InnerException);
+ Assert.IsType<TaskCanceledException>(e.InnerException);
}
}
{
// Verify that As does not perform type checks
object o = new object();
- Assert.IsType(typeof(object), Unsafe.As<string>(o));
+ Assert.IsType<object>(Unsafe.As<string>(o));
}
[Fact]
BinaryFormatter reader = new BinaryFormatter();
TargetInvocationException tie = Assert.Throws<TargetInvocationException>(() => reader.Deserialize(ms));
- Assert.IsAssignableFrom(typeof(SerializationException), tie.InnerException);
+ Assert.IsAssignableFrom<SerializationException>(tie.InnerException);
}
}
// Valid case
object obj = CryptoConfig.CreateFromName(className, "Hello");
Assert.NotNull(obj);
- Assert.IsType(typeof(ClassWithCtorArguments), obj);
+ Assert.IsType<ClassWithCtorArguments>(obj);
ClassWithCtorArguments ctorObj = (ClassWithCtorArguments)obj;
Assert.Equal("Hello", ctorObj.MyString);
{
object obj = CryptoConfig.CreateFromName(name);
Assert.NotNull(obj);
- Assert.IsType(typeof(TExpected), obj);
+ Assert.IsType<TExpected>(obj);
}
public class ClassWithCtorArguments
AsymmetricAlgorithm alg = c.PrivateKey;
Assert.NotNull(alg);
Assert.Same(alg, c.PrivateKey);
- Assert.IsAssignableFrom(typeof(RSA), alg);
+ Assert.IsAssignableFrom<RSA>(alg);
VerifyPrivateKey((RSA)alg);
// Currently unable to set PrivateKey
Assert.Same(alg, pk.Key);
Assert.Equal(2048, alg.KeySize);
- Assert.IsAssignableFrom(typeof(RSA), alg);
+ Assert.IsAssignableFrom<RSA>(alg);
VerifyKey_RSA( /* cert */ null, (RSA)alg);
}
}
Assert.Same(alg, pk.Key);
Assert.Equal(1024, alg.KeySize);
- Assert.IsAssignableFrom(typeof(DSA), alg);
+ Assert.IsAssignableFrom<DSA>(alg);
VerifyKey_DSA((DSA)alg);
}
}
public static void Read(Type classType, byte[] data)
{
object obj = JsonSerializer.Deserialize(data, classType);
- Assert.IsAssignableFrom(typeof(ITestClass), obj);
+ Assert.IsAssignableFrom<ITestClass>(obj);
((ITestClass)obj).Verify();
}
stream,
classType).Result;
- Assert.IsAssignableFrom(typeof(ITestClass), obj);
+ Assert.IsAssignableFrom<ITestClass>(obj);
((ITestClass)obj).Verify();
// Try again with a smaller initial buffer size to ensure we handle incomplete data
classType,
new JsonSerializerOptions { DefaultBufferSize = 5 }).Result;
- Assert.IsAssignableFrom(typeof(ITestClass), obj);
+ Assert.IsAssignableFrom<ITestClass>(obj);
((ITestClass)obj).Verify();
}
projects / platform / upstream / dotnet / runtime.git / commitdiff