public void TestNextComponent(string pathString, int numberOfCalls, bool expectedResult) { // Arrange var path = Path.Create(pathString); var sut = new PathWalker(path); bool result = false; // Act for(int i = 0; i < numberOfCalls; i++) { result = sut.NextComponent(); } // Assert Assert.AreEqual(expectedResult, result); }
public void TestCurrentComponent(string pathString, int component, int expectedPartCount) { // Arrange var path = Path.Create(pathString); var sut = new PathWalker(path); int result = 0; // Act for(int i = 0; i < component; i++) { sut.NextComponent(); result = sut.CurrentComponent.Parts.Count; } // Assert Assert.AreEqual(expectedPartCount, result); }
/// <summary> /// Attempts to get a root object, from which to begin traversal of the path. /// </summary> /// <returns><c>true</c>, if the root object was retrieved, <c>false</c> otherwise.</returns> /// <param name="walker">A TALES path walker.</param> /// <param name="element">A ZPT element.</param> /// <param name="model">The TALES model.</param> /// <param name="result">Exposes the result of this operation.</param> protected virtual bool TryGetTraversalRoot(PathWalker walker, ZptElement element, TalesModel model, out object result) { bool output; if(walker.NextPart() && model.TryGetLocalRootObject(walker.CurrentPart.Value, element, out result)) { output = true; } else { output = false; result = null; } return output; }
public void TestCurrentPart(string pathString, int component, int part, string expectedValue) { // Arrange var path = Path.Create(pathString); var sut = new PathWalker(path); for(int i = 0; i < component; i++) { sut.NextComponent(); } // Act for(int i = 0; i < part; i++) { sut.NextPart(); } // Assert Assert.NotNull(sut.CurrentPart, "Result nullability"); Assert.AreEqual(expectedValue, sut.CurrentPart.Value, "Result value"); }
/// <summary> /// Evaluate the specified expression, for the given element and model. /// </summary> /// <param name="expression">The expression to evaluate.</param> /// <param name="context">The rendering context for the expression being evaluated.</param> /// <param name="model">The ZPT model, providing the context for evaluation.</param> public override ExpressionResult Evaluate(Expression expression, IRenderingContext context, ITalesModel model) { if(expression == null) { throw new ArgumentNullException(nameof(expression)); } if(context == null) { throw new ArgumentNullException(nameof(context)); } if(model == null) { throw new ArgumentNullException(nameof(model)); } var expressionText = expression.Content; var path = Path.Create(expressionText); var walker = new PathWalker(path); object output; try { output = this.WalkPath(walker, context, model); } catch(TraversalException ex) { string message = String.Format(Resources.ExceptionMessages.CouldNotWalkAnyPathsWithExpression, expressionText, context?.Element?.Name); throw new ModelEvaluationException(message, ex) { ExpressionText = expressionText, ElementName = context?.Element?.Name }; } return new ExpressionResult(output); }
/// <summary> /// Walks and evaluates a TALES path. /// </summary> /// <returns>The evaluated value of the path.</returns> /// <param name="walker">A TALES path walker, containing a path.</param> /// <param name="context">The rendering context for the expression being evaluated.</param> /// <param name="model">The ZPT model, providing the context for evaluation.</param> private object WalkPath(PathWalker walker, IRenderingContext context, ITalesModel model) { object output = null; bool success = false; while(walker.NextComponent() && !success) { success = this.WalkComponent(walker, context, model, out output); } if(!success) { throw new TraversalException(Resources.ExceptionMessages.CouldNotWalkAnyPaths); } return output; }
/// <summary> /// Walks and evaluates a single TALES path component. /// </summary> /// <returns> /// <c>true</c>, if the path component was successfully evaluated, <c>false</c> otherwise. /// </returns> /// <param name="walker">A TALES path walker, containing a path.</param> /// <param name="context">The rendering context for the expression being evaluated.</param> /// <param name="model">The ZPT model, providing the context for evaluation.</param> /// <param name="result">Exposes the result of the evaluation.</param> private bool WalkComponent(PathWalker walker, IRenderingContext context, ITalesModel model, out object result) { bool output; if(this.TryGetTraversalRoot(walker, context, model, out result)) { object traversalChild; output = true; while(walker.NextPart()) { string partName; if(this.TryGetPartName(walker.CurrentPart, context, model, out partName) && ObjectTraverser.Default.Traverse(result, partName, out traversalChild, context)) { result = traversalChild; } else { output = false; result = null; break; } } } else { output = false; result = null; } return output; }
/// <summary> /// Attempts to get a root object, from which to begin traversal of the path. /// </summary> /// <returns><c>true</c>, if the root object was retrieved, <c>false</c> otherwise.</returns> /// <param name="walker">A TALES path walker.</param> /// <param name="context">The rendering context.</param> /// <param name="model">The TALES model.</param> /// <param name="result">Exposes the result of this operation.</param> protected virtual bool TryGetTraversalRoot(PathWalker walker, IRenderingContext context, ITalesModel model, out object result) { bool output; if(walker.NextPart() && model.TryGetRootObject(walker.CurrentPart.Value, context, out result)) { output = true; } else { output = false; result = null; } return output; }
public void TestReset() { // Arrange var path = Path.Create("foo/bar|wibble/wobble"); var sut = new PathWalker(path); sut.NextComponent(); sut.NextComponent(); sut.NextPart(); sut.NextPart(); // Act sut.Reset(); // Assert Assert.IsTrue(sut.NextComponent(), "NextComponent result"); Assert.IsTrue(sut.NextPart(), "NextPart result"); Assert.AreEqual("foo", sut.CurrentPart.Value, "CurrentPart"); }
public void TestNextPartException() { // Arrange var path = Path.Create("foo/bar"); var sut = new PathWalker(path); // Act sut.NextPart(); // Assert (by observing an exception) }