public void TestGenerics()
{
var testTypes = new[]
{
typeof (TestGenericPortable<int>),
typeof (TestGenericPortable<string>),
typeof (TestGenericPortable<TestGenericPortable<int>>),
typeof (TestGenericPortable<List<Tuple<int, string>>>),
typeof (TestGenericPortable<List<TestGenericPortable<List<Tuple<int, string>>>>>),
typeof (List<TestGenericPortable<List<TestGenericPortable<List<Tuple<int, string>>>>>>),
typeof (TestGenericPortable<int, string>),
typeof (TestGenericPortable<int, TestGenericPortable<string>>),
typeof (TestGenericPortable<int, string, Type>),
typeof (TestGenericPortable<int, string, TestGenericPortable<int, string, Type>>)
};
foreach (var type in testTypes)
{
// Without assembly
var resolvedType = new TypeResolver().ResolveType(type.FullName);
Assert.AreEqual(type.FullName, resolvedType.FullName);
// With assembly
resolvedType = new TypeResolver().ResolveType(type.FullName, type.Assembly.FullName);
Assert.AreEqual(type.FullName, resolvedType.FullName);
// Assembly-qualified
resolvedType = new TypeResolver().ResolveType(type.AssemblyQualifiedName);
Assert.AreEqual(type.FullName, resolvedType.FullName);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="cfg">Configurtaion.</param>
public PortableMarshaller(PortableConfiguration cfg)
{
// Validation.
if (cfg == null)
{
cfg = new PortableConfiguration();
}
if (cfg.TypeConfigurations == null)
{
cfg.TypeConfigurations = new List <PortableTypeConfiguration>();
}
foreach (PortableTypeConfiguration typeCfg in cfg.TypeConfigurations)
{
if (string.IsNullOrEmpty(typeCfg.TypeName))
{
throw new PortableException("Type name cannot be null or empty: " + typeCfg);
}
if (typeCfg.AssemblyName != null && typeCfg.AssemblyName.Length == 0)
{
throw new PortableException("Assembly name cannot be empty string: " + typeCfg);
}
}
// Define predefined types.
AddPredefinedType(typeof(bool), PortableUtils.TypeBool, PortableSystemHandlers.WriteHndBoolTyped, PortableSystemHandlers.WriteHndBool);
AddPredefinedType(typeof(byte), PortableUtils.TypeByte, PortableSystemHandlers.WriteHndByteTyped, PortableSystemHandlers.WriteHndByte);
AddPredefinedType(typeof(short), PortableUtils.TypeShort, PortableSystemHandlers.WriteHndShortTyped, PortableSystemHandlers.WriteHndShort);
AddPredefinedType(typeof(char), PortableUtils.TypeChar, PortableSystemHandlers.WriteHndCharTyped, PortableSystemHandlers.WriteHndChar);
AddPredefinedType(typeof(int), PortableUtils.TypeInt, PortableSystemHandlers.WriteHndIntTyped, PortableSystemHandlers.WriteHndInt);
AddPredefinedType(typeof(long), PortableUtils.TypeLong, PortableSystemHandlers.WriteHndLongTyped, PortableSystemHandlers.WriteHndLong);
AddPredefinedType(typeof(float), PortableUtils.TypeFloat, PortableSystemHandlers.WriteHndFloatTyped, PortableSystemHandlers.WriteHndFloat);
AddPredefinedType(typeof(double), PortableUtils.TypeDouble, PortableSystemHandlers.WriteHndDoubleTyped, PortableSystemHandlers.WriteHndDouble);
AddPredefinedType(typeof(string), PortableUtils.TypeString, PortableSystemHandlers.WriteHndStringTyped, PortableSystemHandlers.WriteHndString);
AddPredefinedType(typeof(decimal), PortableUtils.TypeDecimal, PortableSystemHandlers.WriteHndDecimalTyped, PortableSystemHandlers.WriteHndDecimal);
AddPredefinedType(typeof(DateTime), PortableUtils.TypeDate, PortableSystemHandlers.WriteHndDateTyped, PortableSystemHandlers.WriteHndDate);
AddPredefinedType(typeof(Guid), PortableUtils.TypeGuid, PortableSystemHandlers.WriteHndGuidTyped, PortableSystemHandlers.WriteHndGuid);
// TODO: Remove this registration
AddPredefinedType(typeof(PortableUserObject), PortableUtils.TypePortable, PortableSystemHandlers.WriteHndPortableTyped,
PortableSystemHandlers.WriteHndPortable);
AddPredefinedType(typeof(bool[]), PortableUtils.TypeArrayBool, PortableSystemHandlers.WriteHndBoolArrayTyped,
PortableSystemHandlers.WriteHndBoolArray);
AddPredefinedType(typeof(byte[]), PortableUtils.TypeArrayByte, PortableSystemHandlers.WriteHndByteArrayTyped,
PortableSystemHandlers.WriteHndByteArray);
AddPredefinedType(typeof(short[]), PortableUtils.TypeArrayShort, PortableSystemHandlers.WriteHndShortArrayTyped,
PortableSystemHandlers.WriteHndShortArray);
AddPredefinedType(typeof(char[]), PortableUtils.TypeArrayChar, PortableSystemHandlers.WriteHndCharArrayTyped,
PortableSystemHandlers.WriteHndCharArray);
AddPredefinedType(typeof(int[]), PortableUtils.TypeArrayInt, PortableSystemHandlers.WriteHndIntArrayTyped,
PortableSystemHandlers.WriteHndIntArray);
AddPredefinedType(typeof(long[]), PortableUtils.TypeArrayLong, PortableSystemHandlers.WriteHndLongArrayTyped,
PortableSystemHandlers.WriteHndLongArray);
AddPredefinedType(typeof(float[]), PortableUtils.TypeArrayFloat, PortableSystemHandlers.WriteHndFloatArrayTyped,
PortableSystemHandlers.WriteHndFloatArray);
AddPredefinedType(typeof(double[]), PortableUtils.TypeArrayDouble, PortableSystemHandlers.WriteHndDoubleArrayTyped,
PortableSystemHandlers.WriteHndDoubleArray);
AddPredefinedType(typeof(decimal[]), PortableUtils.TypeArrayDecimal, PortableSystemHandlers.WriteHndDecimalArrayTyped,
PortableSystemHandlers.WriteHndDecimalArray);
AddPredefinedType(typeof(string[]), PortableUtils.TypeArrayString, PortableSystemHandlers.WriteHndStringArrayTyped,
PortableSystemHandlers.WriteHndStringArray);
AddPredefinedType(typeof(DateTime?[]), PortableUtils.TypeArrayDate, PortableSystemHandlers.WriteHndDateArrayTyped,
PortableSystemHandlers.WriteHndDateArray);
AddPredefinedType(typeof(Guid?[]), PortableUtils.TypeArrayGuid, PortableSystemHandlers.WriteHndGuidArrayTyped,
PortableSystemHandlers.WriteHndGuidArray);
// Define system types. They use internal reflective stuff, so configuration doesn't affect them.
AddSystemTypes();
// 2. Define user types.
var dfltSerializer = cfg.DefaultSerializer == null ? new PortableReflectiveSerializer() : null;
var typeResolver = new TypeResolver();
ICollection <PortableTypeConfiguration> typeCfgs = cfg.TypeConfigurations;
if (typeCfgs != null)
{
foreach (PortableTypeConfiguration typeCfg in typeCfgs)
{
AddUserType(cfg, typeCfg, typeResolver, dfltSerializer);
}
}
ICollection <string> types = cfg.Types;
if (types != null)
{
foreach (string type in types)
{
AddUserType(cfg, new PortableTypeConfiguration(type), typeResolver, dfltSerializer);
}
}
if (cfg.DefaultSerializer == null)
{
cfg.DefaultSerializer = dfltSerializer;
}
_cfg = cfg;
}
public void TestReferencedAssemblyLoading()
{
const string dllName = "Apache.Ignite.Core.Tests.TestDll";
const string typeName = "Apache.Ignite.Core.Tests.TestDll.TestClass";
// Check that the dll is not yet loaded
Assert.IsFalse(AppDomain.CurrentDomain.GetAssemblies().Any(x => x.FullName.StartsWith(dllName)));
// Check that the dll is referenced by current assembly
Assert.IsTrue(Assembly.GetExecutingAssembly().GetReferencedAssemblies()
.Any(x => x.FullName.StartsWith(dllName)));
// Check resolver
var type = new TypeResolver().ResolveType(typeName);
Assert.IsNotNull(type);
Assert.AreEqual(typeName, type.FullName);
Assert.IsNotNull(Activator.CreateInstance(type));
// At this moment the dll should be loaded
Assert.IsTrue(AppDomain.CurrentDomain.GetAssemblies().Any(x => x.FullName.StartsWith(dllName)));
}
