internal bool ManualMap()
{
var injectionMethod = new ManualMap();
// Inject the dll
return(injectionMethod.Inject(_process, _dllPath));
}
public void AddCustomConventionUsingGenerics([Frozen] Mock <IMapperConfiguration> configurationMock, Mapper.SetupMapping map)
{
ManualMap <ClassAModel, ClassA> manualMap = null;
configurationMock.Setup(
x => x.AddMap(It.IsAny <Type>(), It.IsAny <Type>(), It.IsAny <IPropertyMap>()))
.Callback <Type, Type, IPropertyMap>((a, b, c) => manualMap = (ManualMap <ClassAModel, ClassA>)c);
map.From <ClassAModel>().To <ClassA>().WithCustomConvention <SameNameIgnoreCaseConvention>();
Assert.True(manualMap.Conventions.Count == 1);
}
public void SetPropertiesToIgnoreWhenMappingWithConventions([Frozen] Mock <IMapperConfiguration> configurationMock, Mapper.SetupMapping map)
{
ManualMap <ClassAModel, ClassA> manualMap = null;
configurationMock.Setup(
x => x.AddMap(It.IsAny <Type>(), It.IsAny <Type>(), It.IsAny <IPropertyMap>()))
.Callback <Type, Type, IPropertyMap>((a, b, c) => manualMap = (ManualMap <ClassAModel, ClassA>)c);
map.FromTo <ClassAModel, ClassA>().Ignore(x => x.P1, x => x.P2);
Assert.Contains("P1", manualMap.IgnoreProperties);
Assert.Contains("P2", manualMap.IgnoreProperties);
}
public void AddCustomConversion([Frozen] Mock <IMapperConfiguration> configurationMock, Mapper.SetupMapping map)
{
ManualMap <ClassAModel, ClassA> manualMap = null;
configurationMock.Setup(
x => x.AddMap(It.IsAny <Type>(), It.IsAny <Type>(), It.IsAny <IPropertyMap>()))
.Callback <Type, Type, IPropertyMap>((a, b, c) => manualMap = (ManualMap <ClassAModel, ClassA>)c);
map.From <ClassAModel>().To <ClassA>()
.WithCustomConversion <int, string>(i => i.ToString(CultureInfo.CurrentCulture));
Assert.True(manualMap.Conversions.Count == 1);
}
public void AddCustomConvention([Frozen] Mock <IMapperConfiguration> configurationMock, Mapper.SetupMapping map)
{
ManualMap <ClassAModel, ClassA> manualMap = null;
configurationMock.Setup(
x => x.AddMap(It.IsAny <Type>(), It.IsAny <Type>(), It.IsAny <IPropertyMap>()))
.Callback <Type, Type, IPropertyMap>((a, b, c) => manualMap = (ManualMap <ClassAModel, ClassA>)c);
map.From <ClassAModel>().To <ClassA>()
.WithCustomConvention((s, d) =>
from destination in d
join source in s on destination.Name.ToLower() equals source.Name.ToLower()
where source.CanRead && destination.CanWrite
select new { source, destination });
Assert.True(manualMap.Conventions.Count == 1);
}
internal bool ManualMap()
{
// Ensure the operating system supports ManualMap
var osVersion = Environment.Version;
if (osVersion.Major == 5)
{
throw new PlatformNotSupportedException("ManualMap is not supported on Windows XP");
}
using (var injectionMethod = new ManualMap(_process, _dllPath))
{
// Inject the dll
return(injectionMethod.Inject());
}
}
public static void Inject(string process, byte[] data)
{
// process = i.e. csgo.exe
// data = bytes of .dll
Process[] processes = Process.GetProcesses(process);
// Create Portable Executable
var dll = new PortableExecutable(data);
// Create our Mapper
var mapper = new ManualMap();
// Inject it with our Mapper
mapper.Inject(dll, processes[0].Id);
// call this when the injection is finished
Worker.instance.loader.InjectionFinished();
}
public void SetManualMap([Frozen] Mock <IMapperConfiguration> configurationMock, Mapper.SetupMapping map)
{
ManualMap <ClassAModel, ClassA> manualMap = null;
configurationMock.Setup(
x => x.AddMap(It.IsAny <Type>(), It.IsAny <Type>(), It.IsAny <IPropertyMap>()))
.Callback <Type, Type, IPropertyMap>((a, b, c) => manualMap = (ManualMap <ClassAModel, ClassA>)c);
map.From <ClassAModel>().To <ClassA>()
.SetManually((s, d) =>
{
d.P1 = s.P1;
d.P2 = s.P2;
d.P3 = s.P3;
});
Assert.NotNull(manualMap.ObjectMap);
}
