public void CustomRemoveMethod()
{
CustomEventEmitter eventEmitter = _classEmitter.CreateEvent("CustomRemoveMethod", EventKind.Static, typeof(EventHandler));
eventEmitter.RemoveMethod = _classEmitter.CreateMethod(
"CustomRemove", MethodAttributes.Public | MethodAttributes.Static, typeof(void), new[] { typeof(EventHandler) });
}
public void StaticEvent()
{
CustomEventEmitter eventEmitter = _classEmitter.CreateEvent("StaticEvent", EventKind.Static, typeof(Func <string>));
Assert.That(eventEmitter.Name, Is.EqualTo("StaticEvent"));
Assert.That(eventEmitter.EventType, Is.EqualTo(typeof(Func <string>)));
Assert.That(eventEmitter.EventKind, Is.EqualTo(EventKind.Static));
ImplementEventAddMethod(eventEmitter);
ImplementEventRemoveMethod(eventEmitter);
Type type = _classEmitter.BuildType();
Assert.That(AddCalled(type), Is.False);
Assert.That(RemoveCalled(type), Is.False);
AddEventMethod(type, eventEmitter, (Func <string>) delegate { return(null); });
Assert.That(AddCalled(type), Is.True);
Assert.That(RemoveCalled(type), Is.False);
RemoveEventMethod(type, eventEmitter, (Func <string>) delegate { return(null); });
Assert.That(AddCalled(type), Is.True);
Assert.That(RemoveCalled(type), Is.True);
}
public void OverridingSimpleMembersOfOpenGenericClass()
{
CustomClassEmitter classEmitter = new CustomClassEmitter(Scope, "OverridingSimpleMembersOfOpenGenericClass", typeof(GenericClassWithAllKindsOfMembers <>), Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
MethodInfo baseMethod = typeof(GenericClassWithAllKindsOfMembers <>).GetMethod("Method");
var overriddenMethod = classEmitter.CreateMethodOverride(baseMethod);
overriddenMethod.ImplementByBaseCall(baseMethod);
PropertyInfo baseProperty = typeof(GenericClassWithAllKindsOfMembers <>).GetProperty("Property");
CustomPropertyEmitter overriddenProperty = classEmitter.CreatePropertyOverride(baseProperty);
overriddenProperty.GetMethod = classEmitter.CreateMethodOverride(baseProperty.GetGetMethod());
overriddenProperty.GetMethod.ImplementByBaseCall(baseProperty.GetGetMethod());
EventInfo baseEvent = typeof(GenericClassWithAllKindsOfMembers <>).GetEvent("Event");
CustomEventEmitter overriddenEvent = classEmitter.CreateEventOverride(baseEvent);
overriddenEvent.AddMethod = classEmitter.CreateMethodOverride(baseEvent.GetAddMethod());
overriddenEvent.AddMethod.ImplementByBaseCall(baseEvent.GetAddMethod());
overriddenEvent.RemoveMethod = classEmitter.CreateMethodOverride(baseEvent.GetRemoveMethod());
overriddenEvent.RemoveMethod.ImplementByBaseCall(baseEvent.GetRemoveMethod());
Type builtType = classEmitter.BuildType();
GenericClassWithAllKindsOfMembers <int> instance =
(GenericClassWithAllKindsOfMembers <int>)Activator.CreateInstance(builtType.MakeGenericType(typeof(int)));
instance.Method(5);
Assert.That(instance.Property, Is.EqualTo(0));
instance.Event += delegate { return(0); };
instance.Event -= delegate { return(0); };
}
public void SimpleEvent()
{
CustomEventEmitter eventEmitter = _classEmitter.CreateEvent("SimpleEvent", EventKind.Instance, typeof(EventHandler));
Assert.That(eventEmitter.Name, Is.EqualTo("SimpleEvent"));
Assert.That(eventEmitter.EventType, Is.EqualTo(typeof(EventHandler)));
Assert.That(eventEmitter.EventKind, Is.EqualTo(EventKind.Instance));
ImplementEventAddMethod(eventEmitter);
ImplementEventRemoveMethod(eventEmitter);
object instance = BuildInstance();
Assert.That(AddCalled(instance), Is.False);
Assert.That(RemoveCalled(instance), Is.False);
AddEventMethod(instance, eventEmitter, (EventHandler) delegate { });
Assert.That(AddCalled(instance), Is.True);
Assert.That(RemoveCalled(instance), Is.False);
RemoveEventMethod(instance, eventEmitter, (EventHandler) delegate { });
Assert.That(AddCalled(instance), Is.True);
Assert.That(RemoveCalled(instance), Is.True);
}
public void RemoveMethodCannotBeSetTwice()
{
CustomEventEmitter eventEmitter = _classEmitter.CreateEvent("AddMethodCannotBeSetTwice", EventKind.Static, typeof(EventHandler));
Dev.Null = eventEmitter.RemoveMethod;
eventEmitter.RemoveMethod = _classEmitter.CreateMethod(
"invalid", MethodAttributes.Public | MethodAttributes.Static, typeof(void), new[] { typeof(EventHandler) });
}
public void DefaultRemoveMethod()
{
CustomEventEmitter eventEmitter = _classEmitter.CreateEvent("DefaultRemoveMethod", EventKind.Static, typeof(EventHandler));
Assert.That(eventEmitter.RemoveMethod, Is.Not.Null);
Type type = _classEmitter.BuildType();
Assert.That(GetEvent(type, eventEmitter).GetRemoveMethod(), Is.Not.Null);
}
// Start is called before the first frame update
void Start()
{
eventEmitter = CustomEventEmitter.instance;
Cursor.lockState = CursorLockMode.Locked;
controller = GetComponent <CharacterController>();
eventIndex = eventEmitter.StartEventThatFollows(FMODEvents.events[(int)FMODEvents.Player.WALK], gameObject, GetComponentInChildren <Rigidbody>());
}
public void AddCustomAttribute()
{
CustomEventEmitter eventEmitter = _classEmitter.CreateEvent("AddCustomAttribute", EventKind.Static, typeof(string));
eventEmitter.AddCustomAttribute(new CustomAttributeBuilder(typeof(SimpleAttribute).GetConstructor(Type.EmptyTypes), new object[0]));
Type type = _classEmitter.BuildType();
Assert.That(GetEvent(type, eventEmitter).IsDefined(typeof(SimpleAttribute), false), Is.True);
Assert.That(GetEvent(type, eventEmitter).GetCustomAttributes(false).Length, Is.EqualTo(1));
Assert.That(GetEvent(type, eventEmitter).GetCustomAttributes(false)[0], Is.EqualTo(new SimpleAttribute()));
}
public void CreateEvent()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateEvent", typeof(object));
CustomEventEmitter eventEmitter = classEmitter.CreateEvent("Eve", EventKind.Instance, typeof(Func <string>));
eventEmitter.AddMethod.AddStatement(new ReturnStatement());
eventEmitter.RemoveMethod.AddStatement(new ReturnStatement());
object instance = Activator.CreateInstance(classEmitter.BuildType());
Assert.That(instance.GetType().GetEvent("Eve"), Is.Not.Null);
}
private void ImplementEventAddMethod(CustomEventEmitter eventEmitter)
{
FieldReference field;
if (eventEmitter.EventKind == EventKind.Static)
{
field = _classEmitter.CreateStaticField("AddCalled", typeof(bool));
}
else
{
field = _classEmitter.CreateField("AddCalled", typeof(bool));
}
eventEmitter.AddMethod.AddStatement(new AssignStatement(field, new ConstReference(true).ToExpression()));
eventEmitter.AddMethod.ImplementByReturningVoid();
}
public void EventNameIsNotChangedOnPublicInterfaceImplementation()
{
var classEmitter = new CustomClassEmitter(Scope, "EventNameIsNotChangedOnPublicInterfaceImplementation", typeof(object), new[] { typeof(IInterfaceWithEvent) },
TypeAttributes.Public | TypeAttributes.Class, false);
CustomEventEmitter eventEmitter = classEmitter.CreatePublicInterfaceEventImplementation(
typeof(IInterfaceWithEvent).GetEvent("Event", _declaredInstanceBindingFlags));
eventEmitter.AddMethod = classEmitter.CreateInterfaceMethodImplementation(
typeof(IInterfaceWithEvent).GetMethod("add_Event", _declaredInstanceBindingFlags));
eventEmitter.AddMethod.AddStatement(new ReturnStatement());
eventEmitter.RemoveMethod = classEmitter.CreateInterfaceMethodImplementation(
typeof(IInterfaceWithEvent).GetMethod("remove_Event", _declaredInstanceBindingFlags));
eventEmitter.RemoveMethod.AddStatement(new ReturnStatement());
Type builtType = classEmitter.BuildType();
Assert.That(builtType.GetEvent("Event", _declaredInstanceBindingFlags), Is.Not.Null);
}
public void EventNamePreservedOnOverride()
{
var classEmitter = new CustomClassEmitter(Scope, "EventNamePreservedOnOverride", typeof(ClassWithAllKindsOfMembers), Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
CustomEventEmitter eventEmitter =
classEmitter.CreateEventOverride(typeof(ClassWithAllKindsOfMembers).GetEvent("Event", _declaredInstanceBindingFlags));
eventEmitter.AddMethod =
classEmitter.CreateMethodOverride(typeof(ClassWithAllKindsOfMembers).GetMethod("add_Event", _declaredInstanceBindingFlags));
eventEmitter.AddMethod.AddStatement(new ReturnStatement());
eventEmitter.RemoveMethod =
classEmitter.CreateMethodOverride(typeof(ClassWithAllKindsOfMembers).GetMethod("remove_Event", _declaredInstanceBindingFlags));
eventEmitter.RemoveMethod.AddStatement(new ReturnStatement());
Type builtType = classEmitter.BuildType();
Assert.That(builtType.GetEvent("Event", _declaredInstanceBindingFlags), Is.Not.Null);
}
// Start is called before the first frame update
void Start()
{
eventEmitter = CustomEventEmitter.instance;
Cursor.lockState = CursorLockMode.Locked;
controller = GetComponent <CharacterController>();
if (!isControllable) //if (!photonView.IsMine) {
{
GetComponentInChildren <Camera>().enabled = false;
AudioListener al = GetComponentInChildren <AudioListener>();
if (al)
{
al.enabled = false;
}
GetComponentInChildren <StudioListener>().enabled = false;
}
eventIndex = eventEmitter.StartEventThatFollows(FMODEvents.events[(int)FMODEvents.Player.WALK], gameObject, GetComponentInChildren <Rigidbody>());
Debug.Log(eventIndex);
}
public void ImplementingSimpleMembersOfOpenGenericInterface()
{
CustomClassEmitter classEmitter =
new CustomClassEmitter(
Scope,
"ImplementingSimpleMembersOfOpenGenericInterface",
typeof(object),
new Type[] { typeof(GenericInterfaceWithAllKindsOfMembers <int>) },
TypeAttributes.Public | TypeAttributes.Class, false);
MethodInfo baseMethod = typeof(GenericInterfaceWithAllKindsOfMembers <int>).GetMethod("Method");
var overriddenMethod = classEmitter.CreateInterfaceMethodImplementation(baseMethod);
overriddenMethod.AddStatement(new ReturnStatement());
PropertyInfo baseProperty = typeof(GenericInterfaceWithAllKindsOfMembers <int>).GetProperty("Property");
CustomPropertyEmitter overriddenProperty = classEmitter.CreateInterfacePropertyImplementation(baseProperty);
overriddenProperty.GetMethod = classEmitter.CreateInterfaceMethodImplementation(baseProperty.GetGetMethod());
overriddenProperty.GetMethod.AddStatement(new ReturnStatement(new ConstReference(13)));
EventInfo baseEvent = typeof(GenericInterfaceWithAllKindsOfMembers <int>).GetEvent("Event");
CustomEventEmitter overriddenEvent = classEmitter.CreateInterfaceEventImplementation(baseEvent);
overriddenEvent.AddMethod = classEmitter.CreateInterfaceMethodImplementation(baseEvent.GetAddMethod());
overriddenEvent.AddMethod.AddStatement(new ReturnStatement());
overriddenEvent.RemoveMethod = classEmitter.CreateInterfaceMethodImplementation(baseEvent.GetRemoveMethod());
overriddenEvent.RemoveMethod.AddStatement(new ReturnStatement());
Type builtType = classEmitter.BuildType();
GenericInterfaceWithAllKindsOfMembers <int> instance = (GenericInterfaceWithAllKindsOfMembers <int>)Activator.CreateInstance(builtType);
instance.Method(7);
Assert.That(instance.Property, Is.EqualTo(13));
instance.Event += delegate { return(0); };
instance.Event -= delegate { return(0); };
}
public void CreateEventOverride()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateEventOverride", typeof(ClassWithAllKindsOfMembers), Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
CustomEventEmitter eventEmitter =
classEmitter.CreateEventOverride(typeof(ClassWithAllKindsOfMembers).GetEvent("Event", _declaredInstanceBindingFlags));
eventEmitter.AddMethod =
classEmitter.CreateMethodOverride(typeof(ClassWithAllKindsOfMembers).GetMethod("add_Event", _declaredInstanceBindingFlags));
eventEmitter.AddMethod.AddStatement(new ReturnStatement());
eventEmitter.RemoveMethod =
classEmitter.CreateMethodOverride(typeof(ClassWithAllKindsOfMembers).GetMethod("remove_Event", _declaredInstanceBindingFlags));
eventEmitter.RemoveMethod.AddStatement(new ReturnStatement());
Type builtType = classEmitter.BuildType();
var instance = (ClassWithAllKindsOfMembers)Activator.CreateInstance(builtType);
EventHandler eventHandler = delegate { };
instance.Event += eventHandler;
instance.Event -= eventHandler;
}
public void CreatePublicInterfaceEventImplementation()
{
var classEmitter = new CustomClassEmitter(Scope, "CreatePublicInterfaceEventImplementation", typeof(object), new[] { typeof(IInterfaceWithEvent) },
TypeAttributes.Public | TypeAttributes.Class, false);
CustomEventEmitter eventEmitter = classEmitter.CreatePublicInterfaceEventImplementation(
typeof(IInterfaceWithEvent).GetEvent("Event", _declaredInstanceBindingFlags));
eventEmitter.AddMethod = classEmitter.CreateInterfaceMethodImplementation(
typeof(IInterfaceWithEvent).GetMethod("add_Event", _declaredInstanceBindingFlags));
eventEmitter.AddMethod.AddStatement(new ReturnStatement());
eventEmitter.RemoveMethod = classEmitter.CreateInterfaceMethodImplementation(
typeof(IInterfaceWithEvent).GetMethod("remove_Event", _declaredInstanceBindingFlags));
eventEmitter.RemoveMethod.AddStatement(new ReturnStatement());
Type builtType = classEmitter.BuildType();
var instance = (IInterfaceWithEvent)Activator.CreateInstance(builtType);
EventHandler eventHandler = delegate { };
instance.Event += eventHandler;
instance.Event -= eventHandler;
}
// Start is called before the first frame update
void Start()
{
line = GetComponent <LineRenderer>();
eventEmitter = CustomEventEmitter.instance;
isControllable = photonView.IsMine || !PhotonNetwork.InRoom;
}
// Start is called before the first frame update
void Start()
{
instance = this;
}
private EventInfo GetEvent(Type builtType, CustomEventEmitter eventEmitter)
{
return(builtType.GetEvent(eventEmitter.Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic));
}
private EventInfo GetEvent(object instance, CustomEventEmitter eventEmitter)
{
return(GetEvent(instance.GetType(), eventEmitter));
}
private void RemoveEventMethod(Type type, CustomEventEmitter eventEmitter, object method)
{
GetEvent(type, eventEmitter).GetRemoveMethod(true).Invoke(null, new object[] { method });
}
private void RemoveEventMethod(object instance, CustomEventEmitter eventEmitter, object method)
{
GetEvent(instance, eventEmitter).GetRemoveMethod(true).Invoke(instance, new object[] { method });
}
private void AddEventMethod(object instance, CustomEventEmitter eventEmitter, object method)
{
GetEvent(instance, eventEmitter).GetAddMethod(true).Invoke(instance, new[] { method });
}
// Start is called before the first frame update
void Start()
{
//PhotonMapper list of player
//Placeholder stuff
eventEmitter = CustomEventEmitter.instance;
}
public void RemoveMethodCannotBeSetToNull()
{
CustomEventEmitter eventEmitter = _classEmitter.CreateEvent("RemoveMethodCannotBeSetToNull", EventKind.Static, typeof(string));
eventEmitter.RemoveMethod = null;
}
