public DashboardView() { InitializeComponent(); AndonManager = new AndonManager(StationList, null, Andonmanager.AndonManager.MODE.MASTER); AndonManager.start(); StationList = new Queue<int>(); Plans = new Plans(); PlanGrid.DataContext = Plans; Actuals = new Models.Actuals(); ActualGrid.DataContext = Actuals; AppTimer = new Timer(1000); AppTimer.AutoReset = false; AppTimer.Elapsed += AppTimer_Elapsed; EfficiencyWatch = new Stopwatch(); using (PSBContext DBContext = new PSBContext()) { Shifts = DBContext.Shifts.ToList(); foreach (Shift s in Shifts) { s.Update(); } } AppTimer.Start(); }
public override TypeValidationResult CheckType() { foreach (var actual in Actuals) { var result = actual.CheckType(); if (result.HasError) { return(result); } } var functionType = SymbolTable.FunctionType(Name); if (functionType == null) { return(TypeValidationResult.Invalid(Position, $"Function '{Name}' has no definition")); } if (functionType.CheckArgs(Actuals.Select(a => a.Type)) == false) { return(TypeValidationResult.Invalid(Position, $"Function {Name}{functionType} called with mismatched arguments {Name}{ActualsTypeString}")); } SymbolTable.AddCaller(Name, SymbolTable.CurrentFunction); Type = functionType.ReturnType; return(TypeValidationResult.Valid(Type)); }
public bool MarkCell(IEnumerable <object> actualValues, Tree <Cell> table, int rowsToSkip) { var actuals = new Actuals(actualValues); if (table.Branches.Count == rowsToSkip + 1 && actuals.UnmatchedCount == 0) { processor.TestStatus.MarkRight(table.ValueAt(rowsToSkip)); } if (!FindMatches(table.Branches.Skip(rowsToSkip + 1), actuals)) { return(false); } var rowCountBeforeSurplus = table.Branches.Count - rowsToSkip - 1; var result = true; if (actuals.UnmatchedCount > 0 && !strategy.SurplusAllowed) { actuals.ForSurplusValues(surplus => AddSurplusRow(surplus, table)); result = false; } if (!MarkRows(table.Branches.Skip(rowsToSkip + 1).Take(rowCountBeforeSurplus), actuals)) { result = false; } return(strategy.FinalCheck(processor.TestStatus) && result); }
bool MarkRows(IEnumerable <Tree <Cell> > expectedRows, Actuals actuals) { var markResult = true; var row = 0; foreach (var markRow in expectedRows) { if (strategy.IsOrdered && actuals.IsOutOfOrder(row)) { MarkAsIncorrect(markRow, "out of order"); markResult = false; } else if (actuals.MatchValue(row) == null) { MarkAsIncorrect(markRow, "missing"); markResult = false; } else { var matchValues = strategy.ActualValues(actuals.MatchValue(row)); var cellNumber = 0; foreach (var cell in markRow.Branches) { if (matchValues[cellNumber].Type != typeof(void) || cell.Value.Text.Length > 0) { processor.Check(matchValues[cellNumber], cell); } cellNumber++; } } row++; } return(markResult); }
bool MarkRows(IEnumerable<Tree<Cell>> expectedRows, Actuals actuals) { var markResult = true; var row = 0; foreach (var markRow in expectedRows) { if (strategy.IsOrdered && actuals.IsOutOfOrder(row)) { MarkAsIncorrect(markRow, "out of order"); markResult = false; } else if (actuals.MatchValue(row) == null) { MarkAsIncorrect(markRow, "missing"); markResult = false; } else { var matchValues = strategy.ActualValues(actuals.MatchValue(row)); var cellNumber = 0; foreach (var cell in markRow.Branches) { if (matchValues[cellNumber].Type != typeof(void) || cell.Value.Text.Length > 0) { processor.Check(matchValues[cellNumber], cell); } cellNumber++; } } row++; } return markResult; }
public bool IsEqual(IEnumerable<object> actualValues, Tree<Cell> expectedValueCell) { var actuals = new Actuals(actualValues); var expectedRowNumber = 0; foreach (var expectedRow in expectedValueCell.Branches[0].Branches.Skip(1)) { var matchRowNumber = actuals.FindMatch(ExactMatch, expectedRowNumber, expectedRow); if (matchRowNumber == Actuals.Unmatched || (matchRowNumber != expectedRowNumber && strategy.IsOrdered)) return false; expectedRowNumber++; } return (actuals.UnmatchedCount == 0); }
/// <summary> /// /// </summary> /// <param name="invocation"></param> /// <param name="method"></param> /// <param name="arguments"></param> /// <returns></returns> public object HandleEventCall(IInvocation invocation, MethodInfo method, object[] arguments) { var actual = new Actuals(method, arguments); actuals.Add(actual); var subscription = (Delegate)arguments[0]; HandleEventSubscription(method, subscription); var eventCollection = container .Where(x => x.Type == ExpectationType.Event) .ToArray(); Expectation expectation = null; for (int entryIndex = 0; entryIndex < eventCollection.Length; entryIndex++) { var entry = eventCollection[entryIndex]; if (!entry.MatchesCall(method, arguments)) { continue; } if (entry.ExpectationSatisfied) { continue; } expectation = entry; break; } //NOTE: this could be where a "strict" mock call would throw an exception if (expectation == null) { return(HandleUnexpectedMethodCall(invocation, method, arguments)); } RhinoMocks.Logger.LogExpectedMethodCall(invocation); expectation.AddActualCall(actual); if (expectation.ThrowsException) { throw expectation.ExceptionToThrow; } if (expectation.ForceProceed) { invocation.Proceed(); return(invocation.ReturnValue); } return(expectation.ReturnValue); }
public bool IsEqual(object theActualValue, Parse theExpectedValueCell) { var actuals = new Actuals((IList)theActualValue, strategy); int expectedRow = 0; foreach (Parse currentRow in new CellRange(theExpectedValueCell.Parts.Parts.More).Cells) { int match = actuals.FindMatch(RowMatches, expectedRow, currentRow.Parts); if (match < 0 || (match != expectedRow && strategy.IsOrdered)) return false; expectedRow++; } return (actuals.UnmatchedCount == 0); }
public bool MarkCell(object systemUnderTest, object theActualValue, Parse theTableRows) { var actuals = new Actuals((IList)theActualValue, strategy); if (theTableRows.More == null && actuals.UnmatchedCount == 0) { processor.TestStatus.MarkRight(theTableRows); } bool result = true; int expectedRow = 0; foreach (Parse currentRow in new CellRange(theTableRows.More).Cells) { try { int match = actuals.FindMatch(RowMatches, expectedRow, currentRow.Parts); if (match < 0) { MarkAsIncorrect(currentRow, "missing"); result = false; } expectedRow++; } catch (Exception e) { processor.TestStatus.MarkException(currentRow.Parts, e); return false; } } if (actuals.UnmatchedCount > 0 && !strategy.SurplusAllowed) { actuals.ShowSurplus(processor, theTableRows.Last); result = false; } Parse markRow = theTableRows.More; for (int row = 0; row < expectedRow; row++) { if (strategy.IsOrdered && actuals.IsOutOfOrder(row)) { MarkAsIncorrect(markRow, "out of order"); result = false; } else if (actuals.Match(row) != null) { TypedValue[] actualValues = strategy.ActualValues(processor, actuals.Match(row)); int i = 0; foreach (Parse cell in new CellRange(markRow.Parts).Cells) { if (actualValues[i].Type != typeof(void) || cell.Text.Length > 0) { new CellOperationImpl(processor).Check(systemUnderTest, actualValues[i], cell); } i++; } } markRow = markRow.More; } if (!strategy.FinalCheck(processor.TestStatus)) return false; return result; }
bool FindMatches(IEnumerable<Tree<Cell>> expectedRows, Actuals actuals) { var expectedRow = 0; foreach (var currentRow in expectedRows) { try { actuals.FindMatch(BestMatch, expectedRow, currentRow); expectedRow++; } catch (System.Exception e) { processor.TestStatus.MarkException(currentRow.ValueAt(0), e); return false; } } return true; }
public bool IsEqual(IEnumerable <object> actualValues, Tree <Cell> expectedValueCell) { var actuals = new Actuals(actualValues); var expectedRowNumber = 0; foreach (var expectedRow in expectedValueCell.Branches[0].Branches.Skip(1)) { var matchRowNumber = actuals.FindMatch(ExactMatch, expectedRowNumber, expectedRow); if (matchRowNumber == Actuals.Unmatched || (matchRowNumber != expectedRowNumber && strategy.IsOrdered)) { return(false); } expectedRowNumber++; } return(actuals.UnmatchedCount == 0); }
public bool IsEqual(IEnumerable <object> theActualValue, Parse theExpectedValueCell) { var actuals = new Actuals(theActualValue, strategy); int expectedRow = 0; foreach (Parse currentRow in new CellRange(theExpectedValueCell.Parts.Parts.More).Cells) { int match = actuals.FindMatch(RowMatches, expectedRow, currentRow.Parts); if (match < 0 || (match != expectedRow && strategy.IsOrdered)) { return(false); } expectedRow++; } return(actuals.UnmatchedCount == 0); }
public override int GetHashCode() { unchecked { int hash = (int)2166136261; hash = hash * 16777619 ^ CostCentre?.GetHashCode() ?? 0; hash = hash * 16777619 ^ Account?.GetHashCode() ?? 0; hash = hash * 16777619 ^ AccountName?.GetHashCode() ?? 0; hash = hash * 16777619 ^ Budget.GetHashCode(); hash = hash * 16777619 ^ Profile.GetHashCode(); hash = hash * 16777619 ^ Actuals.GetHashCode(); hash = hash * 16777619 ^ Variance.GetHashCode(); hash = hash * 16777619 ^ Forecast.GetHashCode(); hash = hash * 16777619 ^ OutturnVariance.GetHashCode(); return(hash); } }
bool FindMatches(IEnumerable <Tree <Cell> > expectedRows, Actuals actuals) { var expectedRow = 0; foreach (var currentRow in expectedRows) { try { actuals.FindMatch(BestMatch, expectedRow, currentRow); expectedRow++; } catch (System.Exception e) { processor.TestStatus.MarkException(currentRow.ValueAt(0), e); return(false); } } return(true); }
public bool MarkCell(IEnumerable<object> actualValues, Tree<Cell> table, int rowsToSkip) { var actuals = new Actuals(actualValues); if (table.Branches.Count == rowsToSkip + 1 && actuals.UnmatchedCount == 0) { processor.TestStatus.MarkRight(table.ValueAt(rowsToSkip)); } if (!FindMatches(table.Branches.Skip(rowsToSkip + 1), actuals)) return false; var rowCountBeforeSurplus = table.Branches.Count - rowsToSkip - 1; var result = true; if (actuals.UnmatchedCount > 0 && !strategy.SurplusAllowed) { actuals.ForSurplusValues(surplus => AddSurplusRow(surplus, table)); result = false; } if (!MarkRows(table.Branches.Skip(rowsToSkip + 1).Take(rowCountBeforeSurplus), actuals)) result = false; return strategy.FinalCheck(processor.TestStatus) && result; }
// reset all values to default by initialization public void ResetAll() { actual = new Actuals(); }
public bool MarkCell(IEnumerable <object> theActualValue, Parse theTableRows) { var actuals = new Actuals(theActualValue, strategy); if (theTableRows.More == null && actuals.UnmatchedCount == 0) { processor.TestStatus.MarkRight(theTableRows); } bool result = true; int expectedRow = 0; foreach (Parse currentRow in new CellRange(theTableRows.More).Cells) { try { int match = actuals.FindMatch(RowMatches, expectedRow, currentRow.Parts); if (match < 0) { MarkAsIncorrect(currentRow, "missing"); result = false; } expectedRow++; } catch (Exception e) { processor.TestStatus.MarkException(currentRow.Parts, e); return(false); } } if (actuals.UnmatchedCount > 0 && !strategy.SurplusAllowed) { actuals.ShowSurplus(processor, theTableRows.Last); result = false; } Parse markRow = theTableRows.More; for (int row = 0; row < expectedRow; row++) { if (strategy.IsOrdered && actuals.IsOutOfOrder(row)) { MarkAsIncorrect(markRow, "out of order"); result = false; } else if (actuals.Match(row) != null) { TypedValue[] actualValues = strategy.ActualValues(actuals.Match(row)); int i = 0; foreach (Parse cell in new CellRange(markRow.Parts).Cells) { if (actualValues[i].Type != typeof(void) || cell.Text.Length > 0) { new CellOperationImpl(processor).Check(actualValues[i], cell); } i++; } } markRow = markRow.More; } if (!strategy.FinalCheck(processor.TestStatus)) { return(false); } return(result); }
/// <summary> /// Handles a property call /// </summary> /// <param name="invocation"></param> /// <param name="method"></param> /// <param name="arguments"></param> /// <returns></returns> public object HandlePropertyCall(IInvocation invocation, MethodInfo method, object[] arguments) { var actual = new Actuals(method, arguments); actuals.Add(actual); var methodName = method.Name; var propertyKey = GeneratePropertyKey(method, arguments); var propertyCollection = container .Where(x => x.Type == ExpectationType.Property) .ToArray(); Expectation expectation = null; for (int entryIndex = 0; entryIndex < propertyCollection.Length; entryIndex++) { var entry = propertyCollection[entryIndex]; if (!entry.MatchesCall(method, arguments)) { continue; } if (entry.ExpectationSatisfied) { continue; } expectation = entry; break; } //NOTE: this could be where a "strict" mock call would throw an exception if (expectation == null) { RhinoMocks.Logger.LogUnexpectedMethodCall(invocation, "Property: Dynamic handling of property."); } else { RhinoMocks.Logger.LogExpectedMethodCall(invocation); expectation.AddActualCall(actual); if (expectation.ThrowsException) { throw expectation.ExceptionToThrow; } if (expectation.ForceProceed) { invocation.Proceed(); return(invocation.ReturnValue); } if (methodName.StartsWith("get_", StringComparison.Ordinal)) { if (expectation.HasReturnValue) { return(expectation.ReturnValue); } } } if (methodName.StartsWith("get_", StringComparison.Ordinal)) { if (dynamicProperties.ContainsKey(propertyKey)) { return(dynamicProperties[propertyKey]); } } if (methodName.StartsWith("set_", StringComparison.Ordinal)) { if (expectation != null && expectation.HasReturnValue) { dynamicProperties[propertyKey] = expectation.ReturnValue; } else { dynamicProperties[propertyKey] = arguments.Last(); } } return(null); }
/// <summary> /// Handle a method call for the underlying mocked object /// </summary> /// <param name="invocation"></param> /// <param name="method"></param> /// <param name="arguments"></param> /// <returns></returns> public object HandleMethodCall(IInvocation invocation, MethodInfo method, object[] arguments) { if (arguments == null) { arguments = new object[0]; } if (method.IsSpecialName) { var methodName = method.Name; if (methodName.StartsWith("get_", StringComparison.Ordinal) || methodName.StartsWith("set_", StringComparison.Ordinal)) { if (container.Any(x => x.Type == ExpectationType.Property)) { return(HandlePropertyCall(invocation, method, arguments)); } } if (methodName.StartsWith("add_", StringComparison.Ordinal) || methodName.StartsWith("remove_", StringComparison.Ordinal)) { if (container.Any(x => x.Type == ExpectationType.Event)) { return(HandleEventCall(invocation, method, arguments)); } } } var actual = new Actuals(method, arguments); actuals.Add(actual); var methodCollection = container .Where(x => x.Type == ExpectationType.Method) .ToArray(); Expectation expectation = null; for (int entryIndex = 0; entryIndex < methodCollection.Length; entryIndex++) { var entry = methodCollection[entryIndex]; if (!entry.MatchesCall(method, arguments)) { continue; } if (entry.ExpectationSatisfied) { continue; } expectation = entry; break; } //NOTE: this could be where a "strict" mock call would throw an exception if (expectation == null) { for (int entryIndex = 0; entryIndex < methodCollection.Length; entryIndex++) { var entry = methodCollection[entryIndex]; if (!entry.MatchesCall(method, arguments)) { continue; } if (entry.ExpectationSatisfied) { entry.AddActualCall(actual); continue; } } return(HandleUnexpectedMethodCall(invocation, method, arguments)); } RhinoMocks.Logger.LogExpectedMethodCall(invocation); expectation.AddActualCall(actual); if (expectation.HasDelegateToInvoke) { var methodParameters = method.GetParameters(); var callback = expectation.DelegateToInvoke; var callbackParameters = callback.Method.GetParameters(); try { if (callbackParameters.Length == 0) { var value = callback.DynamicInvoke(new object[0]); if (callback.Method.ReturnType != (typeof(void)) && expectation.DelegateReturnsValue) { expectation.SetReturnValue(value); } } else { var invokeCallback = true; var invokeArguments = new object[callbackParameters.Length]; for (int index = 0; index < callbackParameters.Length; index++) { var parameter = callbackParameters[index]; var parameterType = parameter.ParameterType; var argument = methodParameters[index]; var argumentType = argument.ParameterType; if (!parameterType.IsAssignableFrom(argumentType)) { invokeCallback = false; break; } } if (invokeCallback) { var value = callback.DynamicInvoke(arguments); if (callback.Method.ReturnType != (typeof(void)) && expectation.DelegateReturnsValue) { expectation.SetReturnValue(value); } } } } catch (TargetInvocationException ex) { throw ex.InnerException; } } if (expectation.ReturnArguments != null && expectation.ReturnArguments.Any()) { var lenth = expectation.ReturnArguments.Length; var parameters = method.GetParameters(); for (int index = 0, returnIndex = 0; index < parameters.Length && returnIndex < lenth; index++) { var parameter = parameters[index]; if (!parameter.IsOut && !parameter.ParameterType.IsByRef) { continue; } arguments[index] = expectation.ReturnArguments[returnIndex]; returnIndex++; } } if (expectation.ThrowsException) { throw expectation.ExceptionToThrow; } if (expectation.ForceProceed) { invocation.Proceed(); if (expectation.HasDelegateToIntercept) { expectation.DelegateToIntercept(new MethodInvocation(invocation)); } return(invocation.ReturnValue); } invocation.ReturnValue = expectation.ReturnValue; if (expectation.HasDelegateToIntercept) { expectation.DelegateToIntercept(new MethodInvocation(invocation)); } return(invocation.ReturnValue); }
public override String Print(int depth) { return(" new " + ClassName + "(" + Actuals.Print(depth) + ")"); }
public override String Print(int depth) { return(Object.Print(depth) + "." + Method + "(" + Actuals.Print(depth) + ")"); }
public override String Print(int depth) { return((Object == null ? "global" : Object.Print(depth)) + "." + (string.IsNullOrEmpty(Method) ? SpecialFunc.Print(depth) : Method) + (Actuals == null ? string.Empty : "(" + Actuals.Print(depth) + ")")); }