public void Validate_EventReference_TriggerEventConsumed_ShouldFail()
{
//arrange
var workflow = WorkflowDefinition.Create("fake", "fake", "fake")
.AddEvent(new EventDefinition()
{
Kind = EventKind.Consumed, Name = "fake"
})
.StartsWith("fake", flow => flow.Callback())
.End()
.Build();
var eventRef = new EventReference()
{
TriggerEvent = "fake"
};
//act
var result = new EventReferenceValidator(workflow).Validate(eventRef);
//assert
result.Should()
.NotBeNull();
result.Errors.Should()
.NotBeNullOrEmpty()
.And.Contain(e => e.PropertyName == nameof(EventReference.TriggerEvent));
}
public static void ExecutePendingInteropActions(IStoreSession session, ICalendarItemSeries calendarItemSeries, IStorageTranslator <ICalendarItemBase, Event> eventTranslator = null, IXSOFactory xsoFactory = null, ICalendarInteropLog logger = null)
{
xsoFactory = (xsoFactory ?? XSOFactory.Default);
logger = (logger ?? CalendarInteropLog.Default);
eventTranslator = (eventTranslator ?? EventTranslator.Instance);
try
{
Event @event = eventTranslator.ConvertToEntity(calendarItemSeries);
EventReference eventReference = new EventReference(xsoFactory, calendarItemSeries);
SeriesPendingActionsInterop seriesPendingActionsInterop = new SeriesPendingActionsInterop(logger, null)
{
Entity = @event,
EntityKey = @event.Id,
Scope = (Events)eventReference.Events
};
seriesPendingActionsInterop.Execute(null);
}
catch (Exception ex)
{
ExTraceGlobals.CalendarInteropTracer.TraceError <string, Exception>(0L, "Error executing pending interop actions for series {0}. Error {1}", calendarItemSeries.SeriesId, ex);
logger.SafeLogEntry(session, ex, false, "Error executing pending interop actions for series {0}.", new object[]
{
calendarItemSeries.SeriesId
});
throw;
}
}
public MemberIdentifier(ITypeInfoSource ti, EventReference er)
{
Type = MemberType.Event;
Name = er.Name;
ReturnType = er.EventType;
GenericArgumentCount = 0;
ParameterTypes = null;
ti.CacheProxyNames(er);
var ed = er.Resolve();
if (ed != null)
{
if (ed.AddMethod != null)
{
IsStatic = ed.AddMethod.IsStatic;
}
else if (ed.RemoveMethod != null)
{
IsStatic = ed.RemoveMethod.IsStatic;
}
else
{
// FIXME
IsStatic = false;
}
}
else
{
// FIXME
IsStatic = false;
}
HashCode = Type.GetHashCode() ^ Name.GetHashCode();
}
public RaiseEventExpression(EventReference @event, MethodReference invokeMethodReference, ExpressionCollection arguments, IEnumerable <Instruction> instructions)
: base(instructions)
{
this.Event = @event;
this.InvokeMethodReference = invokeMethodReference;
this.Arguments = arguments;
}
/// <summary>
/// Gets the <see cref="MemberId"/> for the event.
/// </summary>
public static MemberId ToMemberId(this EventReference eventReference)
{
return(new EventId(
eventReference.DeclaringType.ToTypeId(),
eventReference.Name
));
}
/// <summary>
/// Initializes a new instance of the <see cref="EventEmitter"/> class.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="evt">The evt.</param>
public EventEmitter(TypeEmitter parent, EventReference evt)
{
Parent = parent;
Target = evt as EventDefinition ?? evt.Resolve();
if (Target.AddMethod != null)
{
add = new MethodEmitter(parent, Target.AddMethod);
}
else
{
var existing = parent.Target.GetMethod($"add_{Target.Name}", parent.Context.Module.TypeSystem.Void, new[] { evt.EventType }, new GenericParameter[0]);
if (existing != null)
{
Target.AddMethod = existing.Resolve();
add = new MethodEmitter(parent, Target.AddMethod);
}
}
if (Target.RemoveMethod != null)
{
remove = new MethodEmitter(parent, Target.RemoveMethod);
}
else
{
var existing = parent.Target.GetMethod($"remove_{Target.Name}", parent.Context.Module.TypeSystem.Void, new[] { evt.EventType }, new GenericParameter[0]);
if (existing != null)
{
Target.RemoveMethod = existing.Resolve();
remove = new MethodEmitter(parent, Target.RemoveMethod);
}
}
}
/// <summary>
/// Try to resolve definition from reference.
/// </summary>
internal static EventDefinition Resolve(this EventReference evt, ReachableContext context)
{
var declType = evt.DeclaringType.Resolve(context);
var resolver = new GenericsResolver(declType);
return((declType == null) ? null : declType.Events.FirstOrDefault(x => x.AreSame(evt, resolver.Resolve)));
}
static MethodAttributes GetEvtVisibility(EventReference evt)
{
MethodAttributes ret = MethodAttributes.Public;
EventDefinition Definition = evt.Resolve();
if (Definition != null)
{
MethodReference addMethod = Definition.AddMethod;
MethodDefinition addDecl = (addMethod == null) ? null : addMethod.Resolve();
MethodReference removeMethod = Definition.RemoveMethod;
MethodDefinition removeDecl = (removeMethod == null) ? null : removeMethod.Resolve();
MethodReference invokeMethod = Definition.InvokeMethod;
MethodDefinition invokeDecl = (invokeMethod == null) ? null : invokeMethod.Resolve();
if (((addDecl != null) && (removeDecl != null)) && (invokeDecl != null))
{
if (((addDecl.Attributes & MethodAttributes.MemberAccessMask) == (removeDecl.Attributes & MethodAttributes.MemberAccessMask)) && ((addDecl.Attributes & MethodAttributes.MemberAccessMask) == (invokeDecl.Attributes & MethodAttributes.MemberAccessMask)))
{
return(addDecl.Attributes & MethodAttributes.MemberAccessMask);
}
}
else if ((addDecl != null) && (removeDecl != null))
{
if ((addDecl.Attributes & MethodAttributes.MemberAccessMask) == (removeDecl.Attributes & MethodAttributes.MemberAccessMask))
{
return(addDecl.Attributes & MethodAttributes.MemberAccessMask);
}
}
else if ((addDecl != null) && (invokeDecl != null))
{
if ((addDecl.Attributes & MethodAttributes.MemberAccessMask) == (invokeDecl.Attributes & MethodAttributes.MemberAccessMask))
{
return(addDecl.Attributes & MethodAttributes.MemberAccessMask);
}
}
else if ((removeDecl != null) && (invokeDecl != null))
{
if ((removeDecl.Attributes & MethodAttributes.MemberAccessMask) == (invokeDecl.Attributes & MethodAttributes.MemberAccessMask))
{
return(removeDecl.Attributes & MethodAttributes.MemberAccessMask);
}
}
else
{
if (addDecl != null)
{
return(addDecl.Attributes & MethodAttributes.MemberAccessMask);
}
if (removeDecl != null)
{
return(removeDecl.Attributes & MethodAttributes.MemberAccessMask);
}
if (invokeDecl != null)
{
return(invokeDecl.Attributes & MethodAttributes.MemberAccessMask);
}
}
}
return(ret);
}
public void Equality_Default()
{
var a = new EventReference();
var b = new EventReference();
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public static EventReference make(EventReference eventReference, GenericInstanceType git)
{
if (git == null)
{
return(eventReference);
}
return(new EventReferenceInstance(eventReference, git).makeInstance());
}
/// <summary>
/// Are the given events the same?
/// </summary>
public static bool AreSame(this EventReference a, EventReference b, Func <GenericParameter, TypeReference> genericParamResolver)
{
if (a.Name != b.Name)
{
return(false);
}
return(a.EventType.AreSame(b.EventType, genericParamResolver));
}
EventReference GetEventReference(EventReference source)
{
EventReference mr = source;
TypeReference tr = GetTypeReference(mr.DeclaringType, false);
EventReference result = GetEventReference(tr, mr);
return(result);
}
public void DefaultValues()
{
var sut = new EventReference();
Assert.AreEqual(new VariableReference(), sut.Reference);
Assert.AreEqual(Names.UnknownEvent, sut.EventName);
Assert.AreNotEqual(0, sut.GetHashCode());
Assert.AreNotEqual(1, sut.GetHashCode());
}
private void PlaySound(EventReference sound)
{
if (this._playInteractionSound && !sound.IsNull)
{
this._soundEventInstance.stop(STOP_MODE.IMMEDIATE);
this._soundEventInstance = FMODUnity.RuntimeManager.CreateInstance(sound);
this._soundEventInstance.start();
}
}
/// <summary>
/// Creates a new transaction
/// </summary>
/// <param name="reference">The event reference to create the transaction for</param>
/// <returns>An id of the transaction</returns>
private Guid CreateNewTransaction(EventReference reference)
{
var transaction = Guid.NewGuid();
_transactions.Add(transaction);
_activeTransaction.Push(transaction);
_transactionEvents.Add(transaction, CalculateEvents(reference));
return(transaction);
}
void addEventReference(EventReference eventReference)
{
if (eventReference == null)
{
return;
}
addMemberReference(eventReference);
pushMember(eventReference.EventType);
}
public void Collect(EventReference evet)
{
EventDefinition def;
if ((def = evet as EventDefinition ?? evet.Resolve()) != null)
{
Collect(def);
}
}
public void EventReference_static()
{
var sst = new EventReference
{
EventName = Names.Event("static [EventType,P] [DeclaringType,P].E")
};
AssertPrint(sst, "DeclaringType.E");
}
private static string Format(EventReference @event)
{
var sb = new StringBuilder();
sb.Append(CecilFormat.GetTypeName(@event.DeclaringType));
sb.Append('.');
sb.Append(@event.Name);
return(sb.ToString());
}
public EventMeta Resolve(EventReference eventRef)
{
TypeMeta type = this.Resolve(eventRef.DeclaringType);
if (type != null)
{
return(type.Resolve(eventRef));
}
return(null);
}
public void Equality_DifferentReference()
{
var a = new EventReference {
Reference = SomeRef
};
var b = new EventReference();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void EventReference()
{
var sst = new EventReference
{
EventName = Names.Event("[EventType,P] [DeclaringType,P].E"),
Reference = SSTUtil.VariableReference("o")
};
AssertPrint(sst, "o.E");
}
public static EventDefinition TryResolve(this ModuleDefinition scope, EventReference eventRef)
{
var matchingType = TryResolve(scope, eventRef.DeclaringType);
if (matchingType == null)
{
return(null);
}
return(matchingType.Events.FirstOrDefault(e => e.Name == eventRef.Name));
}
public MemberIdentifier(ITypeInfoSource ti, EventReference er)
{
Type = MemberType.Event;
Name = er.Name;
ReturnType = er.EventType;
GenericArgumentCount = 0;
ParameterTypes = null;
ti.CacheProxyNames(er);
HashCode = Type.GetHashCode() ^ Name.GetHashCode();
}
protected virtual string GetEventName(EventReference @event)
{
EventDefinition eventDefinition = @event.Resolve();
if (eventDefinition != null && eventDefinition.Module.FilePath == this.ModuleContext.Module.FilePath)
{
return(this.ModuleContext.RenamedMembersMap[eventDefinition.MetadataToken.ToUInt32()]);
}
return(Utilities.EscapeNameIfNeeded(GenericHelper.GetNonGenericName(@event.Name), this.Language));
}
public void SettingValues()
{
var sut = new EventReference
{
Reference = SomeRef,
EventName = SomeEvent
};
Assert.AreEqual(SomeRef, sut.Reference);
Assert.AreEqual(SomeEvent, sut.EventName);
}
public static EventDefinition TryResolve(this EventReference r)
{
try
{
return(r.Resolve());
}
catch (Exception)
{
return(null);
}
}
public void VisitInstruction(Instruction instr)
{
Instruction instruction = instr;
if (instruction.Operand is FieldReference)
{
FieldReference fr = (FieldReference)instruction.Operand;
if (fr.DeclaringType.Module.Assembly.Name.Name == Context.ExternalAssemblyName)
{
FieldDefinition fd = Context.InternalSymbols.GetField(fr.Name);
if (fd != null)
{
instruction.Operand = fd;
}
else
{
Console.Error.WriteLine("Accessing fields in native libraries in not supported (yet!)");
Environment.Exit(1);
}
}
else
{
TypeReference tr = GetTypeReference(fr.DeclaringType);
if (tr is TypeDefinition)
{
instruction.Operand = (tr as TypeDefinition).Fields.GetField(fr.Name);
}
else
{
instruction.Operand = GetMemberReference(Target.MainModule.MemberReferences, fr);
}
}
fr = (FieldReference)instruction.Operand;
fr.FieldType = GetTypeReference(fr.FieldType);
}
else if (instruction.Operand is MethodReference)
{
MethodReference mr = (MethodReference)instruction.Operand;
instruction.Operand = GetMethodReference(mr);
}
else if (instruction.Operand is TypeReference)
{
TypeReference tr = (TypeReference)instruction.Operand;
instruction.Operand = GetTypeReference(tr);
}
else if (instruction.Operand is EventReference)
{
EventReference et = (EventReference)instruction.Operand;
instruction.Operand = GetEventReference(et);
}
}
private EventDefinition CreateEventDefinition(EventReference reference, TypeDefinition declaringTypeDefinition, bool recursionGuard = true)
{
if (MemberDefinitionMap.ContainsKey(reference) || recursionGuard)
{
return(GetOrCreateMember(reference, declaringTypeDefinition, CreateEventDefinition));
}
EventDefinition definition = new EventDefinition(reference.Name, EventAttributes.None, ImportType(reference.EventType, declaringTypeDefinition, context: null));
declaringTypeDefinition.Events.Add(definition);
return(definition);
}
public static void AcceptVisitor <TResult> (
this EventReference eventReference,
MetadataVisitor <TResult> visitor)
{
if (!visitor.ShouldTraverseInto(visitor.VisitEventReference(eventReference)))
{
return;
}
eventReference.EventType.AcceptVisitor(visitor);
eventReference.DeclaringType.AcceptVisitor(visitor);
}
