private async Task IsModulus(object modulusOf, string modulusAsString, object isAModulus, object notAModulus) { var config = new EventRuleDto { Type = EventRuleType.Modulus, Source = EventRuleSource.EventParameter, EventParameterNumber = 1, Value = modulusAsString }; var rule = new EventRule(_mockEventSubscription.Object, 1, config); var decodedEvent = _sampleTransferLog.ToDecodedEvent(_transferEventAbi); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = modulusOf; Assert.True(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = isAModulus; Assert.True(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = null; Assert.False(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = notAModulus; Assert.False(await rule.HandleAsync(decodedEvent)); }
private async Task IsLessOrEqual(object maxValue, string maxValueAsString, object higherValue, object lesserValue) { var config = new EventRuleDto { Type = EventRuleType.LessThanOrEqualTo, Source = EventRuleSource.EventParameter, EventParameterNumber = 1, Value = maxValueAsString }; var rule = new EventRule(_mockEventSubscription.Object, 1, config); var decodedEvent = _sampleTransferLog.ToDecodedEvent(_transferEventAbi); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = maxValue; Assert.True(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = lesserValue; Assert.True(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = null; Assert.False(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = higherValue; Assert.False(await rule.HandleAsync(decodedEvent)); }
/// <summary> /// Adds a new event parsing rule. /// </summary> public EventRule AddEvent(string inId) { CheckLocked(); EventRule rule = FindOrCreateEventRule(inId); return(rule); }
/// <summary> /// Adds a new event parsing rule processed with the given delegate. /// </summary> public EventRule AddEvent(string inId, StringHash32 inEventId, EventDelegate inDelegate) { CheckLocked(); EventRule rule = new EventRule(inId); rule.ProcessWith(inEventId, inDelegate); return(rule); }
/// <summary> /// Adds a new event parsing rule. /// </summary> public EventRule AddEvent(string inId, StringHash32 inEventId) { CheckLocked(); EventRule rule = FindOrCreateEventRule(inId); rule.ProcessWith(inEventId); return(rule); }
public int getframeshift(EventRule e) { ButtonPressDelay(); if (e.YourID) { Advance(10); time_delay(); } return(index); }
public void TestSerialization() { EventRule toSeralize = new EventRule(); toSeralize.EventName = "attribute"; toSeralize.EventSource = ActiveConfig.DB.GetAttribute("supervisor"); UniqueIDCache.ClearIdCache(); EventRule deserialized = (EventRule)UnitTestControl.XmlSerializeRoundTrip <EventRule>(toSeralize); Assert.AreEqual(toSeralize.EventName, deserialized.EventName); Assert.AreEqual(toSeralize.EventSource, deserialized.EventSource); }
private EventRule FindOrCreateEventRule(string inPattern) { foreach (var rule in m_EventRules) { if (rule.Id() == inPattern) { return(rule); } } EventRule newRule = new EventRule(inPattern); m_EventRules.Add(newRule); return(newRule); }
/// <summary> /// Initializes a new instance of the <see cref="FakeManager"/> class. /// </summary> /// <param name="fakeObjectType">The faked type.</param> /// <param name="proxy">The faked proxy object.</param> /// <param name="fakeObjectName">The name of the fake object.</param> internal FakeManager(Type fakeObjectType, object proxy, string?fakeObjectName) { Guard.AgainstNull(fakeObjectType, nameof(fakeObjectType)); Guard.AgainstNull(proxy, nameof(proxy)); this.objectReference = new WeakReference(proxy); this.FakeObjectType = fakeObjectType; this.FakeObjectName = fakeObjectName; this.eventRule = new EventRule(this); this.allUserRules = new LinkedList <CallRuleMetadata>(); this.recordedCalls = new ConcurrentQueue <CompletedFakeObjectCall>(); this.interceptionListeners = new LinkedList <IInterceptionListener>(); }
public bool TryProcess(TagData inData, object inContext, out TagEventData outEvent) { EventRule rule = m_EventRules.FindMatch(inData.Id); if (rule != null) { return(rule.Evaluate(inData, inContext, out outEvent)); } if (m_EventInheritFrom != null) { return(m_EventInheritFrom.TryProcess(inData, inContext, out outEvent)); } outEvent = default(TagEventData); return(false); }
public void EvaluateOnSimpleEvent() { Guid newId = Guid.NewGuid(); try { MAObjectHologram maObject = ActiveConfig.DB.CreateMAObject(newId, "person"); AcmaEvent maevent = GetAccountNameChangedEvent(); RaisedEvent exitEvent = new RaisedEvent(maevent, maObject); maObject.IncomingEvents = new List <RaisedEvent>() { exitEvent }; // Positive Tests EventRule target = new EventRule(); target.EventName = "accountNameChanged"; Assert.IsTrue(target.Evaluate(maObject)); // Negative Tests maevent = GetSupervisorChangedEvent(); exitEvent = new RaisedEvent(maevent, maObject); maObject.IncomingEvents = new List <RaisedEvent>() { exitEvent }; target.EventName = "accountNameChanged"; Assert.IsFalse(target.Evaluate(maObject)); target.EventName = "accountNameChanged"; target.EventSource = ActiveConfig.DB.GetAttribute("supervisor"); Assert.IsFalse(target.Evaluate(maObject)); } finally { ActiveConfig.DB.DeleteMAObjectPermanent(newId); } }
public async Task IsEmpty() { var config = new EventRuleDto { Type = EventRuleType.Empty, Source = EventRuleSource.EventParameter, EventParameterNumber = 1 }; var rule = new EventRule(_mockEventSubscription.Object, 1, config); var decodedEvent = _sampleTransferLog.ToDecodedEvent(_transferEventAbi); Assert.False(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = null; Assert.True(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = string.Empty; Assert.True(await rule.HandleAsync(decodedEvent)); }
public void EvaluateOnSourceEvent() { Guid supervisorId = Guid.NewGuid(); Guid targetId = Guid.NewGuid(); try { MAObjectHologram supervisorObject = ActiveConfig.DB.CreateMAObject(supervisorId, "person"); MAObjectHologram targetObject = ActiveConfig.DB.CreateMAObject(targetId, "person"); AcmaSchemaAttribute supervisorAttribute = ActiveConfig.DB.GetAttribute("supervisor"); targetObject.SetAttributeValue(supervisorAttribute, supervisorObject.ObjectID); targetObject.CommitCSEntryChange(); AcmaEvent maevent = GetAccountNameChangedEvent(); RaisedEvent exitEvent = new RaisedEvent(maevent, supervisorObject); targetObject.IncomingEvents = new List <RaisedEvent>() { exitEvent }; // Positive Tests EventRule target = new EventRule(); target.EventName = "accountNameChanged"; target.EventSource = ActiveConfig.DB.GetAttribute("supervisor"); Assert.IsTrue(target.Evaluate(targetObject)); // Negative Tests target = new EventRule(); target.EventName = "accountNameChanged"; target.EventSource = ActiveConfig.DB.GetAttribute("directReports"); Assert.IsFalse(target.Evaluate(targetObject)); } finally { ActiveConfig.DB.DeleteMAObjectPermanent(targetId); ActiveConfig.DB.DeleteMAObjectPermanent(supervisorId); } }
private async Task IsEqual(object val, string valAsString, object differentValue) { var config = new EventRuleDto { Type = EventRuleType.Equals, Source = EventRuleSource.EventParameter, EventParameterNumber = 1, Value = valAsString }; var rule = new EventRule(_mockEventSubscription.Object, 1, config); var decodedEvent = _sampleTransferLog.ToDecodedEvent(_transferEventAbi); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = val; Assert.True(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = null; Assert.False(await rule.HandleAsync(decodedEvent)); decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = differentValue; Assert.False(await rule.HandleAsync(decodedEvent)); }
public RNGResult GenerateEvent(EventRule e) { RNGResult st = new RNGResult(); index = 0; st.row_r = Rand[0]; st.Clock = (int)(st.row_r % 17); st.Blink = ((int)(st.row_r & 0x7F)) > 0 ? 0 : 1; // Reset NPC Status if (!createtimeline) { ResetNPCStatus(); } // ---Start here when press A button--- if (Considerdelay) { st.frameshift = getframeshift(e); } //Encryption Constant & PID switch (e.PIDType) { case 0: st.EC = (uint)(getrand() & 0xFFFFFFFF); st.PID = (uint)(getrand() & 0xFFFFFFFF); st.PSV = ((st.PID >> 16) ^ (st.PID & 0xFFFF)) >> 4; if (st.PSV == TSV) { st.Shiny = true; } break; case 1: Advance(2); st.Shiny = true; break; case 2: Advance(2); st.Shiny = false; break; case 3: break; } //IV st.IVs = (int[])e.IVs.Clone(); int cnt = e.IVsCount; while (cnt > 0) { int ran = (int)(getrand() % 6); if (st.IVs[ran] < 0) { st.IVs[ran] = 31; cnt--; } } for (int i = 0; i < 6; i++) { if (st.IVs[i] < 0) { st.IVs[i] = (int)(getrand() & 0x1F); } } //Ability if (!e.AbilityLocked) { st.Ability = (int)(getrand() & 1) + 1; } //Nature if (!e.NatureLocked) { st.Nature = (int)(currentrand() % 25); } //Gender if (nogender || e.GenderLocked) { st.Gender = 0; } else { st.Gender = ((int)(getrand() % 252) >= gender_ratio) ? 1 : 2; } return(st); }
public EventRuleViewModel(EventRule model, bool canUseProposedValues) : base(model, canUseProposedValues) { this.typedModel = model; this.AnySender = this.typedModel.EventSource == null; }