/// <summary>
/// Creates a new lightweight representation of an open generic type.
/// </summary>
/// <param name="assembly">Assembly defining the type.</param>
/// <param name="name">Name of the type.</param>
/// <returns>A new lightweight representation of an open generic type.</returns>
public static GenericDefinitionTypeSlim GenericDefinition(AssemblySlim assembly, string name)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Type name can not be null or empty.", nameof(name));
}
return(new GenericDefinitionTypeSlim(assembly, name));
}
/// <summary>
/// Creates a new lightweight representation of a simple type, i.e. not constructed from other types.
/// </summary>
/// <param name="assembly">Assembly defining the type.</param>
/// <param name="name">Name of the type.</param>
/// <returns>A new lightweight representation of a simple type, i.e. not constructed from other types.</returns>
public static SimpleTypeSlim Simple(AssemblySlim assembly, string name)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Type name can not be null or empty.", nameof(name));
}
return(new SimpleTypeSlim(assembly, name));
}
public void MemberInfoSlimEqualityComparer_Property_Index()
{
var tq = new TypeSlimEqualityComparer();
var eq = new MemberInfoSlimEqualityComparer(tq);
var asm = new AssemblySlim("foo");
var tp1 = TypeSlim.Simple(asm, "bar");
var i4 = typeof(int).ToTypeSlim();
var i8 = typeof(long).ToTypeSlim();
var indxs0 = new List <TypeSlim> {
i4
}.AsReadOnly();
var indxs1 = new List <TypeSlim> {
i8
}.AsReadOnly();
var indxs2 = new List <TypeSlim> {
i4, i8
}.AsReadOnly();
var indxs3 = new List <TypeSlim> {
i8, i4
}.AsReadOnly();
var prp_i4_0_0 = PropertyInfoSlim.Make(tp1, "Item", i4, indxs0, canWrite: true);
var prp_i4_0_1 = PropertyInfoSlim.Make(tp1, "Item", i4, indxs0, canWrite: true);
var prp_i4_1_0 = PropertyInfoSlim.Make(tp1, "Item", i4, indxs1, canWrite: true);
var prp_i4_2_0 = PropertyInfoSlim.Make(tp1, "Item", i4, indxs2, canWrite: true);
var prp_i4_3_0 = PropertyInfoSlim.Make(tp1, "Item", i4, indxs3, canWrite: true);
var prp_i4_3_1 = PropertyInfoSlim.Make(tp1, "Item", i4, indxs3, canWrite: true);
var prp_i8_0_0 = PropertyInfoSlim.Make(tp1, "Item", i8, indxs0, canWrite: true);
var prp_i8_1_0 = PropertyInfoSlim.Make(tp1, "Item", i8, indxs1, canWrite: true);
var prp_i8_2_0 = PropertyInfoSlim.Make(tp1, "Item", i8, indxs2, canWrite: true);
var prp_i8_3_0 = PropertyInfoSlim.Make(tp1, "Item", i8, indxs3, canWrite: true);
Assert.IsTrue(eq.Equals(prp_i4_0_0, prp_i4_0_0));
Assert.IsTrue(eq.Equals(prp_i4_0_0, prp_i4_0_1));
Assert.IsTrue(eq.Equals(prp_i4_0_1, prp_i4_0_0));
Assert.IsTrue(eq.Equals(prp_i4_3_0, prp_i4_3_1));
Assert.IsTrue(eq.Equals(prp_i4_3_1, prp_i4_3_0));
Assert.IsFalse(eq.Equals(prp_i4_0_0, prp_i4_1_0));
Assert.IsFalse(eq.Equals(prp_i4_1_0, prp_i4_0_0));
Assert.IsFalse(eq.Equals(prp_i4_2_0, prp_i4_3_0));
Assert.IsFalse(eq.Equals(prp_i4_3_0, prp_i4_2_0));
Assert.IsFalse(eq.Equals(prp_i4_0_0, prp_i8_0_0));
Assert.IsFalse(eq.Equals(prp_i4_1_0, prp_i8_1_0));
Assert.IsFalse(eq.Equals(prp_i4_2_0, prp_i8_2_0));
Assert.IsFalse(eq.Equals(prp_i4_3_0, prp_i8_3_0));
Assert.AreEqual(eq.GetHashCode(prp_i4_0_0), eq.GetHashCode(prp_i4_0_1));
Assert.AreEqual(eq.GetHashCode(prp_i4_3_0), eq.GetHashCode(prp_i4_3_1));
}
public void MemberInfoSlimEqualityComparer_Property_NoIndex()
{
var tq = new TypeSlimEqualityComparer();
var eq = new MemberInfoSlimEqualityComparer(tq);
var asm = new AssemblySlim("foo");
var tp1 = TypeSlim.Simple(asm, "bar");
var tp2 = TypeSlim.Simple(asm, "baz");
var i4 = typeof(int).ToTypeSlim();
var i8 = typeof(long).ToTypeSlim();
var indxs = Array.Empty <TypeSlim>().ToList().AsReadOnly();
var prp11_0 = PropertyInfoSlim.Make(tp1, "qux1", i4, indxs, canWrite: true);
var prp12_0 = PropertyInfoSlim.Make(tp1, "qux2", i4, indxs, canWrite: true);
var prp13_0 = PropertyInfoSlim.Make(tp1, "qux3", i8, indxs, canWrite: true);
var prp11_1 = PropertyInfoSlim.Make(tp1, "qux1", i4, indxs, canWrite: true);
var prp12_1 = PropertyInfoSlim.Make(tp1, "qux2", i4, indxs, canWrite: true);
var prp13_1 = PropertyInfoSlim.Make(tp1, "qux3", i8, indxs, canWrite: true);
var prp21_0 = PropertyInfoSlim.Make(tp2, "qux1", i4, indxs, canWrite: true);
Assert.IsTrue(eq.Equals(prp11_0, prp11_0));
Assert.IsTrue(eq.Equals(prp11_0, prp11_1));
Assert.IsTrue(eq.Equals(prp11_1, prp11_0));
Assert.IsTrue(eq.Equals(prp11_1, prp11_1));
Assert.IsTrue(eq.Equals(prp12_0, prp12_0));
Assert.IsTrue(eq.Equals(prp12_0, prp12_1));
Assert.IsTrue(eq.Equals(prp12_1, prp12_0));
Assert.IsTrue(eq.Equals(prp12_1, prp12_1));
Assert.IsTrue(eq.Equals(prp13_0, prp13_0));
Assert.IsTrue(eq.Equals(prp13_0, prp13_1));
Assert.IsTrue(eq.Equals(prp13_1, prp13_0));
Assert.IsTrue(eq.Equals(prp13_1, prp13_1));
Assert.IsFalse(eq.Equals(prp11_0, prp12_0));
Assert.IsFalse(eq.Equals(prp12_0, prp11_0));
Assert.IsFalse(eq.Equals(prp11_0, prp21_0));
Assert.IsFalse(eq.Equals(prp21_0, prp11_0));
Assert.AreEqual(eq.GetHashCode(prp11_0), eq.GetHashCode(prp11_1));
Assert.AreEqual(eq.GetHashCode(prp12_0), eq.GetHashCode(prp12_1));
Assert.AreEqual(eq.GetHashCode(prp13_0), eq.GetHashCode(prp13_1));
}
public void MemberInfoSlimEqualityComparer_Field()
{
var tq = new TypeSlimEqualityComparer();
var eq = new MemberInfoSlimEqualityComparer(tq);
var asm = new AssemblySlim("foo");
var tp1 = TypeSlim.Simple(asm, "bar");
var tp2 = TypeSlim.Simple(asm, "baz");
var i4 = typeof(int).ToTypeSlim();
var i8 = typeof(long).ToTypeSlim();
var fld11_0 = new FieldInfoSlim(tp1, "qux1", i4);
var fld12_0 = new FieldInfoSlim(tp1, "qux2", i4);
var fld13_0 = new FieldInfoSlim(tp1, "qux3", i8);
var fld11_1 = new FieldInfoSlim(tp1, "qux1", i4);
var fld12_1 = new FieldInfoSlim(tp1, "qux2", i4);
var fld13_1 = new FieldInfoSlim(tp1, "qux3", i8);
var fld21_0 = new FieldInfoSlim(tp2, "qux1", i4);
Assert.IsTrue(eq.Equals(fld11_0, fld11_0));
Assert.IsTrue(eq.Equals(fld11_0, fld11_1));
Assert.IsTrue(eq.Equals(fld11_1, fld11_0));
Assert.IsTrue(eq.Equals(fld11_1, fld11_1));
Assert.IsTrue(eq.Equals(fld12_0, fld12_0));
Assert.IsTrue(eq.Equals(fld12_0, fld12_1));
Assert.IsTrue(eq.Equals(fld12_1, fld12_0));
Assert.IsTrue(eq.Equals(fld12_1, fld12_1));
Assert.IsTrue(eq.Equals(fld13_0, fld13_0));
Assert.IsTrue(eq.Equals(fld13_0, fld13_1));
Assert.IsTrue(eq.Equals(fld13_1, fld13_0));
Assert.IsTrue(eq.Equals(fld13_1, fld13_1));
Assert.IsFalse(eq.Equals(fld11_0, fld12_0));
Assert.IsFalse(eq.Equals(fld12_0, fld11_0));
Assert.IsFalse(eq.Equals(fld11_0, fld21_0));
Assert.IsFalse(eq.Equals(fld21_0, fld11_0));
Assert.AreEqual(eq.GetHashCode(fld11_0), eq.GetHashCode(fld11_1));
Assert.AreEqual(eq.GetHashCode(fld12_0), eq.GetHashCode(fld12_1));
Assert.AreEqual(eq.GetHashCode(fld13_0), eq.GetHashCode(fld13_1));
}
public void AssemblySlim_ToString()
{
var assembly = new AssemblySlim("Foo");
Assert.AreEqual("Foo", assembly.ToString());
}
// CONSIDER: In this version, the representation of an open generic type is
// is basically equivalent to the representation of a simple type.
//
// In the future, we should consider adding properties for the
// generic parameters to represent generic parameter attributes,
// such as covariance and contravariance.
/// <summary>
/// Creates a new open generic type definition representation object.
/// </summary>
/// <param name="assembly">Assembly defining the type.</param>
/// <param name="name">Name of the type.</param>
internal GenericDefinitionTypeSlim(AssemblySlim assembly, string name)
: base(assembly, name)
{
}
/// <summary>
/// Creates a new generic type definition representation object.
/// </summary>
/// <param name="assembly">Assembly defining the type.</param>
/// <param name="name">Name of the type.</param>
public SimpleTypeSlim(AssemblySlim assembly, string name)
: base(assembly, name)
{
}
/// <summary>
/// Creates a new generic type definition representation object.
/// </summary>
/// <param name="assembly">Assembly defining the type.</param>
/// <param name="name">Name of the type.</param>
protected SimpleTypeSlimBase(AssemblySlim assembly, string name)
{
Assembly = assembly;
Name = name;
}
