/// <summary> /// Create a new NamedValue lookup given name and value. /// </summary> /// <param name="name">The name of the value. Or null if the name was not used for this value.</param> /// <param name="value">The value - a literal.</param> public NamedValue(string name, LiteralToken value) { ExceptionUtils.CheckArgumentNotNull(value, "value"); this.name = name; this.value = value; }
public void Run(ICommandInteraction writer, [Values("Noisy", "Debug", "Info", "Warning", "Error")] StringToken level, LiteralToken backendName, LiteralToken peripheralName) { if(!SetLogLevel(LogLevel.Parse(level.Value), backendName.Value, peripheralName.Value)) { writer.WriteError(string.Format("Could not find emulation element or backend")); } }
public void Run(ICommandInteraction writer, LiteralToken variable, Token value) { var varName = variable.Value; varName = GetVariableName(varName); SetVariable(varName, value); }
public void Run(ICommandInteraction writer, [Values(-1L, 0L, 1L, 2L, 3L)] NumericToken level, LiteralToken backendName, LiteralToken peripheralName) { if(!SetLogLevel((LogLevel)level.Value, backendName.Value, peripheralName.Value)) { writer.WriteError(string.Format("Could not find emulation element or backend")); } }
public void Run(ICommandInteraction writer, LiteralToken peripheralName) { var emu = EmulationManager.Instance.CurrentEmulation; IPeripheral p; string fake; var m = monitor.Machine; if(m == null || !m.TryGetByName(peripheralName.Value, out p, out fake)) { writer.WriteError(string.Format("Peripheral not found: {0}", peripheralName.Value)); return; } IAnalyzableBackend backend; if(!emu.BackendManager.TryGetBackendFor(p, out backend)) { writer.WriteError(string.Format("No backend found for {0}", peripheralName.Value)); return; } foreach(var a in emu.BackendManager.GetAvailableAnalyzersFor(backend)) { writer.WriteLine(a); } }
public static RangeNode BuildRangeNode(LiteralToken from, LiteralToken to) { var rangeNode = new RangeNode(TokenBuilder.BuildRangeToken()); rangeNode.ChildNodes.Add(BuildLiteralNode(from)); rangeNode.ChildNodes.Add(BuildLiteralNode(to)); return rangeNode; }
public void NamedValueDefaultTest() { LiteralToken literal = new LiteralToken(null); NamedValue keyValue = new NamedValue("a", literal); this.Assert.AreEqual("a", keyValue.Name, "The Name property has an unexpected value."); this.Assert.AreEqual(literal, keyValue.Value, "The Value property has an unexpected value."); }
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName, BooleanToken traceReturn, params LiteralToken[] types) { var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm)); var cpuTracer = EnsureTracer(cpu); var handler = new DefaultFunctionHandler(cpu); var paramList = new List<FunctionCallParameter>(); foreach(var parameter in types) { FunctionCallParameterType paramType; if(!Enum.TryParse(parameter.Value, out paramType)) { throw new RecoverableException("{0} is not a proper parameter type.".FormatWith(parameter.Value)); } paramList.Add(new FunctionCallParameter{ Type = paramType }); } handler.CallParameters = paramList.Take(paramList.Count - (traceReturn.Value ? 1 : 0)); handler.ReturnParameter = traceReturn.Value ? paramList.Last() : (FunctionCallParameter?)null; if(traceReturn.Value) { cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler, handler.ReturnParameter, handler.ReturnHandler); } else { cpuTracer.TraceFunction(functionName.Value, handler.CallParameters, handler.CallHandler); } }
public void UnsupportedTokenBinderErrorTest() { IEdmModel model = QueryTestMetadata.BuildTestMetadata(this.PrimitiveTypeResolver, this.UntypedDataServiceProviderFactory); var binder = new ErrorMetadataBinder(model); var token = new LiteralToken("d"); Action action = () => binder.Bind(token); action.ShouldThrow<ODataException>().WithMessage(ODataErrorStrings.MetadataBinder_BoundNodeCannotBeNull(token.Kind)); }
public void Run(ICommandInteraction writer, [Values(-1L, 0L, 1L, 2L, 3L)] DecimalIntegerToken level, LiteralToken peripheralOrBackendName) { if(!SetLogLevel((LogLevel)level.Value, null, peripheralOrBackendName.Value) && !SetLogLevel((LogLevel)level.Value, peripheralOrBackendName.Value, null)) { writer.WriteError(string.Format("Could not find emulation element or backend named: {0}", peripheralOrBackendName.Value)); } }
public void UnaryOperatorQueryTokenDefaultTest() { LiteralToken operand = new LiteralToken(null); UnaryOperatorToken unary = new UnaryOperatorToken(UnaryOperatorKind.Negate, operand); this.Assert.AreEqual(QueryTokenKind.UnaryOperator, unary.Kind, "The InternalKind property has an unexpected value."); this.Assert.AreEqual(UnaryOperatorKind.Negate, unary.OperatorKind, "The OperatorKind property should be Negate."); this.Assert.AreEqual(operand, unary.Operand, "The Operand property has an unexpected value."); }
public void Run(ICommandInteraction writer, [Values("Noisy", "Debug", "Info", "Warning", "Error")] StringToken level, LiteralToken peripheralOrBackendName) { var logLevel = LogLevel.Parse(level.Value); if(!SetLogLevel(logLevel, null, peripheralOrBackendName.Value) && !SetLogLevel(logLevel, peripheralOrBackendName.Value, null)) { writer.WriteError(string.Format("Could not find emulation element or backend named: {0}", peripheralOrBackendName.Value)); } }
/// <summary> /// Parses null literals. /// </summary> /// <param name="lexer">The lexer to use.</param> /// <returns>The literal token produced by building the given literal.</returns> private static LiteralToken ParseNullLiteral(ExpressionLexer lexer) { Debug.Assert(lexer != null, "lexer != null"); Debug.Assert(lexer.CurrentToken.Kind == ExpressionTokenKind.NullLiteral, "this.lexer.CurrentToken.InternalKind == ExpressionTokenKind.NullLiteral"); LiteralToken result = new LiteralToken(null, lexer.CurrentToken.Text); lexer.NextToken(); return(result); }
public void SetStateTokenizeLiteral() { var lexer = new Lexer(); var tokens = lexer.Tokenize("[e"); var expected = new LiteralToken { Character = 'e' }; Assert.AreEqual(tokens.Last(), expected); }
public void EscapeStateTokenizeLiteral() { var lexer = new Lexer(nodeBuilder.TokenBuilder); var tokens = lexer.Tokenize("\\z"); var expected = new LiteralToken { Character = 'z' }; Assert.AreEqual(tokens.Last(), expected); }
public void CommandHelp(ICommandInteraction writer, LiteralToken commandName) { if(!GetCommands().Any(x => x.Name == commandName.Value)) { writer.WriteError(String.Format("No such command: {0}.", commandName.Value)); return; } var command = GetCommands().First(x => x.Name == commandName.Value); command.PrintHelp(writer); }
public void BinaryOperatorQueryTokenDefaultTest() { LiteralToken left = new LiteralToken(null); LiteralToken right = new LiteralToken(null); BinaryOperatorToken binary = new BinaryOperatorToken(BinaryOperatorKind.Or, left, right); this.Assert.AreEqual(QueryTokenKind.BinaryOperator, binary.Kind, "The InternalKind property has an unexpected value."); this.Assert.AreEqual(BinaryOperatorKind.Or, binary.OperatorKind, "The OperatorKind property should be Or."); this.Assert.AreEqual(left, binary.Left, "The Left property has an unexpected value."); this.Assert.AreEqual(right, binary.Right, "The Right property has an unexpected value."); }
/// <summary> /// Binds a literal value to a ConstantNode /// </summary> /// <param name="literalToken">Literal token to bind.</param> /// <returns>Bound query node.</returns> internal static ConstantNode BindLiteral(LiteralToken literalToken) { ExceptionUtils.CheckArgumentNotNull(literalToken, "literalToken"); if (!string.IsNullOrEmpty(literalToken.OriginalText)) { return(new ConstantNode(literalToken.Value, literalToken.OriginalText)); } return(new ConstantNode(literalToken.Value)); }
public void CommandHelp(ICommandInteraction writer, LiteralToken commandName) { if (!GetCommands().Any(x => x.Name == commandName.Value)) { writer.WriteError(String.Format("No such command: {0}.", commandName.Value)); return; } var command = GetCommands().First(x => x.Name == commandName.Value); command.PrintHelp(writer); }
public void NullValueShouldThrow() { const string text = "(1,2,3)"; var expectedType = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false))); object collection = ODataUriConversionUtils.ConvertFromCollectionValue("[1,2,3]", HardCodedTestModel.TestModel, expectedType); LiteralToken literalToken = new LiteralToken(collection, text, expectedType); Action target = () => new CollectionConstantNode(null, text, expectedType); Assert.Throws <ArgumentNullException>("objectCollection", target); }
public void NullCollectionTypeShouldThrow() { const string text = "(1,2,3)"; var expectedType = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false))); object collection = ODataUriConversionUtils.ConvertFromCollectionValue("[1,2,3]", HardCodedTestModel.TestModel, expectedType); LiteralToken literalToken = new LiteralToken(collection, text, expectedType); Action target = () => new CollectionConstantNode((literalToken.Value as ODataCollectionValue)?.Items, text, null); target.ShouldThrow <ArgumentNullException>().Where(e => e.Message.Contains("collectionType")); }
public void KindIsSetCorrectly() { const string text = "(1,2,3)"; var expectedType = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false))); object collection = ODataUriConversionUtils.ConvertFromCollectionValue("[1,2,3]", HardCodedTestModel.TestModel, expectedType); LiteralToken literalToken = new LiteralToken(collection, text, expectedType); CollectionConstantNode collectionConstantNode = new CollectionConstantNode( (literalToken.Value as ODataCollectionValue)?.Items, text, expectedType); Assert.Equal(InternalQueryNodeKind.CollectionConstant, collectionConstantNode.InternalKind); }
protected StringToken ParseString() { //System.Diagnostics.Debugger.Launch(); LiteralToken stringToken = (LiteralToken)Eat(TokenType.Literal); if (stringToken.LiteralType != LiteralTokenType.String) { ReportError(Resources.ParserTokenUnexpected, stringToken.ToString()); throw new NotSupportedException(); } return((StringToken)stringToken); }
public void Equals_ValuesAreEqual_ReturnsTrue() { // arrange var sut1 = new LiteralToken(new SourceLocation(3, 6), 'a'); var sut2 = new LiteralToken(new SourceLocation(3, 6), 'a'); // act var result = sut1.Equals(sut2); // assert Assert.True(result); }
public void Equals_ValueIsDifferent_ReturnsFalse() { // arrange var sut1 = new LiteralToken(new SourceLocation(3, 6), 'a'); var sut2 = new LiteralToken(new SourceLocation(3, 6), 'b'); // act var result = sut1.Equals(sut2); // assert Assert.False(result); }
public void ItemTypeIsSetCorrectly() { const string text = "(1,2,3)"; var expectedType = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(false))); object collection = ODataUriConversionUtils.ConvertFromCollectionValue("[1,2,3]", HardCodedTestModel.TestModel, expectedType); LiteralToken literalToken = new LiteralToken(collection, text, expectedType); CollectionConstantNode collectionConstantNode = new CollectionConstantNode( (literalToken.Value as ODataCollectionValue)?.Items, text, expectedType); collectionConstantNode.ItemType.FullName().Should().Be("Edm.Int32"); }
public virtual Token GetToken() { Skip(); var t = TryLiteral() ?? TryVariable() ?? TryParameter() ?? TryUnary() ?? TryGroup() ?? TryObject() ?? (Token)TryShortArray(); if (t == null) { return(t); } if (t is VariableToken vt) { if (settings.TryGetKnownValue(vt.Name, out var value)) { t = new LiteralToken(value); } else if (vt.Name == "new") { Skip(); t = (Token)TryObject() ?? GetArray(); } } if (Done()) { return(t); } Token r; do { Skip(); r = t; t = TryMember(t) ?? TryIndexer(t) ?? TryLambda(t) ?? TryCall(t) ?? TryTernary(t) ?? (Token)TryBinary(t); } while (t != null); return(r); }
public void GetHashCode_ValuesAreEqual_ReturnsSameHashCode() { // arrange var sut1 = new LiteralToken(new SourceLocation(3, 6), 'a'); var sut2 = new LiteralToken(new SourceLocation(3, 6), 'a'); // act var hashCode1 = sut1.GetHashCode(); var hashCode2 = sut2.GetHashCode(); // assert Assert.Equal(hashCode1, hashCode2); }
public void Ctor_WhenCalled_SetsProperties() { // arrange var location = new SourceLocation(2, 3); // act var sut = new LiteralToken(location, 'b'); // assert Assert.Equal(2, sut.Location.LineNumber); Assert.Equal(3, sut.Location.CharacterNumber); Assert.Equal('b', sut.Value); }
public void GetHashCode_ValuesAreNotEqual_ReturnsDifferentHashCodes() { // arrange var sut1 = new LiteralToken(new SourceLocation(3, 6), 'a'); var sut2 = new LiteralToken(new SourceLocation(3, 6), 'b'); // act var hashCode1 = sut1.GetHashCode(); var hashCode2 = sut2.GetHashCode(); // act, assert Assert.NotEqual(hashCode1, hashCode2); }
public void Run(ICommandInteraction writer, [Values("set")] LiteralToken action, DecimalIntegerToken number) { var machines = EmulationManager.Instance.CurrentEmulation.Machines.ToArray(); if (machines.Length > number.Value && number.Value >= 0) { SetCurrentMachine(machines[number.Value]); } else { writer.WriteError("Wrong machine number. Type {0} to show a list of available machines.".FormatWith(Name)); } }
public void AnyTokenWithNonConstantExpressionNullParameter() { this.expressionQueryNode = new UnaryOperatorNode(UnaryOperatorKind.Negate, new ConstantNode(false)); var binder = new LambdaBinder(this.FakeBindMethod); var state = this.GetBindingStateForTest(HardCodedTestModel.GetPersonTypeReference(), HardCodedTestModel.GetPeopleSet()); var expression = new LiteralToken("foo"); var parent = new LiteralToken("bar"); var anyToken = new AnyToken(expression, null, parent); var result = binder.BindLambdaToken(anyToken, state); result.ShouldBeAnyQueryNode().And.Source.ShouldBeEntitySetQueryNode(HardCodedTestModel.GetPeopleSet()); result.Body.ShouldBeUnaryOperatorNode(UnaryOperatorKind.Negate); }
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand, TraceDisableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName) { if (enable.Value == TraceEnableCommand) { Execute(writer, cpuToken, functionName.Value, false, null); } else { var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm)); var cpuTracer = EnsureTracer(cpu); cpuTracer.RemoveTracing(functionName.Value); } }
public void Run(ICommandInteraction writer, [Values(TraceEnableCommand, TraceDisableCommand)] LiteralToken enable, LiteralToken cpuToken, StringToken functionName) { if(enable.Value == TraceEnableCommand) { Execute(writer, cpuToken, functionName.Value, false, null); } else { var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm)); var cpuTracer = EnsureTracer(cpu); cpuTracer.RemoveTracing(functionName.Value); } }
public void InnerFilterSetCorrectly() { // Arrange & Act QueryToken filter = new LiteralToken(21); SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null), filter, null, null, null, null, null, null, null); // Assert Assert.NotNull(selectTerm.FilterOption); LiteralToken literalToken = Assert.IsType <LiteralToken>(selectTerm.FilterOption); Assert.Equal(QueryTokenKind.Literal, literalToken.Kind); Assert.Equal(21, literalToken.Value); }
public void SetOrAdd(ICommandInteraction writer, [Values("set", "add")] LiteralToken action, PathToken path) { switch (action.Value) { case "set": monitorPath.Path = path.Value; break; case "add": monitorPath.Append(path.Value); break; } PrintCurrentPath(writer); }
private void Execute(ICommandInteraction writer, LiteralToken cpuToken, String functionName, bool traceReturn, int?numberOfParameters) { var cpu = (Arm)monitor.ConvertValueOrThrowRecoverable(cpuToken.Value, typeof(Arm)); var cpuTracer = EnsureTracer(cpu); Type handlerType; IFunctionHandler handler; if (!handlers.TryGetValue(functionName, out handlerType)) { if (numberOfParameters.HasValue) { var paramList = new List <FunctionCallParameter>(); for (var i = 0; i < numberOfParameters; ++i) { paramList.Add(new FunctionCallParameter { Type = FunctionCallParameterType.UInt32 }); } FunctionCallParameter?returnParameter = null; if (traceReturn) { returnParameter = new FunctionCallParameter { Type = FunctionCallParameterType.UInt32 }; } var defHandler = new DefaultFunctionHandler(cpu); defHandler.CallParameters = paramList; defHandler.ReturnParameter = returnParameter; handler = defHandler; } else { throw new RecoverableException("Handler for {0} not register. You must provide numberOfParameters to use default handler.".FormatWith(functionName)); } } else { handler = Dynamic.InvokeConstructor(handlerType, cpu); } if (traceReturn) { cpuTracer.TraceFunction(functionName, handler.CallParameters, handler.CallHandler, handler.ReturnParameter, handler.ReturnHandler); } else { cpuTracer.TraceFunction(functionName, handler.CallParameters, handler.CallHandler); } }
Token GetToken() { Skip(); Token t = TryLiteral() ?? TryVariable() ?? TryParameter() ?? TryUnary() ?? (Token)TryGroup(); if (t == null) { return(t); } if (t is VariableToken vt) { if (knowns.TryGetValue(vt.Name, out var value)) { t = new LiteralToken(value); } else if (vt.Name == "new") { t = GetObject(); } } if (Done()) { return(t); } Token r; do { Skip(); r = t; t = TryMember(t) ?? TryIndexer(t) ?? TryLambda(t) ?? TryCall(t) ?? TryTernary(t) ?? (Token)TryBinary(t); } while (t != null); return(r); }
public override Exp Analy( ) { if (this.IsAnalyed) { return(this); } RetType = AnalyLiteralZType(); if (RetType == null) { Errorf(this.Position, LiteralToken.ToCode() + "不是正确的值"); } IsAnalyed = true; return(this); }
private static void VerifyBinaryOperatorToken <T>(string expectedEndPathIdentifier, BinaryOperatorKind expectedOperator, T expectedLiteralValue, BinaryOperatorToken actual) { Assert.NotNull(actual); Assert.Equal(actual.OperatorKind, expectedOperator); EndPathToken left = actual.Left as EndPathToken; Assert.NotNull(left); Assert.Equal(left.Identifier, expectedEndPathIdentifier); LiteralToken right = actual.Right as LiteralToken; Assert.NotNull(right); Assert.Equal(right.Value, expectedLiteralValue); }
public void Run(ICommandInteraction writer, LiteralToken use) { if(use.Value == "-") { GetUsings().Clear(); } else { var dotted = use.Value + (use.Value.Last() == '.' ? "" : "."); //dot suffix if(!GetUsings().Contains(dotted)) { GetUsings().Add(dotted); } } }
public void Run(ICommandInteraction writer, [Values("create", "clear")] LiteralToken action) { switch (action.Value) { case "clear": SetCurrentMachine(null); break; case "create": var machine = new Machine(); EmulationManager.Instance.CurrentEmulation.AddMachine(machine); SetCurrentMachine(machine); break; } }
private static void VerifyBinaryOperatorToken <T>(string expectedEndPathIdentifier, BinaryOperatorKind expectedOperator, T expectedLiteralValue, BinaryOperatorToken actual) { actual.Should().NotBeNull(); actual.OperatorKind.Should().Be(expectedOperator); EndPathToken left = actual.Left as EndPathToken; left.Should().NotBeNull(); left.Identifier.Should().Be(expectedEndPathIdentifier); LiteralToken right = actual.Right as LiteralToken; right.Should().NotBeNull(); right.Value.Should().Be(expectedLiteralValue); }
public void Run(ICommandInteraction writer, LiteralToken use) { if (use.Value == "-") { GetUsings().Clear(); } else { var dotted = use.Value + (use.Value.Last() == '.' ? "" : "."); //dot suffix if (!GetUsings().Contains(dotted)) { GetUsings().Add(dotted); } } }
public void FilterSetCorrectly() { QueryToken filter = new LiteralToken(1); ExpandTermToken expandTerm = new ExpandTermToken(new NonSystemToken("stuff", null, null), filter, null /*orderByOption*/, null /*topOption*/, null /*skipOption*/, null /*countQueryOption*/, null /*levelsOption*/, null /*searchOption*/, null /*selectOption*/, null /*expandOption*/); expandTerm.FilterOption.ShouldBeLiteralQueryToken(1); }
internal override bool Apply(StringReader reader, ref Token parentToken, ref Token previousToken) { var temp = previousToken as LiteralToken; if (temp != null) { temp.AddChar(reader.CurrentChar); } else { var token = new LiteralToken(reader.CurrentChar); parentToken.AddChild(token); previousToken = token; } return true; }
/// <summary> /// Binds a literal value to a ConstantNode /// </summary> /// <param name="literalToken">Literal token to bind.</param> /// <returns>Bound query node.</returns> internal static ConstantNode BindLiteral(LiteralToken literalToken) { ExceptionUtils.CheckArgumentNotNull(literalToken, "literalToken"); if (!string.IsNullOrEmpty(literalToken.OriginalText)) { if (literalToken.ExpectedEdmTypeReference != null) { return new ConstantNode(literalToken.Value, literalToken.OriginalText, literalToken.ExpectedEdmTypeReference); } return new ConstantNode(literalToken.Value, literalToken.OriginalText); } return new ConstantNode(literalToken.Value); }
public void Run(ICommandInteraction writer, StringToken analyzerName, LiteralToken peripheral, LiteralToken analyzerTypeName) { try { var analyzer = GetAnalyzer(peripheral.Value, analyzerTypeName == null ? null : analyzerTypeName.Value); if (analyzerName != null) { EmulationManager.Instance.CurrentEmulation.ExternalsManager.AddExternal((IExternal)analyzer, analyzerName.Value); } analyzer.Show(); } catch (Exception e) { throw new RecoverableException(string.Format("Received '{0}' error while initializng analyzer for: {1}. Are you missing a required plugin?", e.Message, peripheral.Value)); } }
public void Run(ICommandInteraction writer, [Values("default")] LiteralToken @default, LiteralToken peripheralName) { var emu = EmulationManager.Instance.CurrentEmulation; IPeripheral p; string fake; var m = monitor.Machine; if(m == null || !m.TryGetByName(peripheralName.Value, out p, out fake)) { writer.WriteError(string.Format("Peripheral not found: {0}", peripheralName.Value)); return; } IAnalyzableBackend backend; if(!emu.BackendManager.TryGetBackendFor(p, out backend)) { writer.WriteError(string.Format("No backend found for {0}", peripheralName.Value)); return; } var def = emu.BackendManager.GetPreferredAnalyzerFor(backend); writer.WriteLine(def ?? "No default analyzer found."); }
public void Run(ICommandInteraction writer, LiteralToken peripheral, LiteralToken analyzerTypeName) { Run(writer, null, peripheral, analyzerTypeName); }
public void Run(ICommandInteraction writer, LiteralToken peripheral) { Run(writer, peripheral, null); }
public void Run(ICommandInteraction writer, StringToken analyzerName, LiteralToken peripheral) { Run(writer, analyzerName, peripheral, null); }
public FieldStatement(TypeStatement type, LiteralToken name, Expression expression) { Type = type; Name = name; Expression = expression; }
public void Run(ICommandInteraction writer, LiteralToken peripheral, StringToken viewId) { Run(writer, null, peripheral, viewId); }
protected override QueryNode BindLiteral(LiteralToken literalToken) { return null; }
private AnyToken CreateTestAnyQueryToken() { var expression = new LiteralToken("foo"); var parent = new LiteralToken("bar"); return new AnyToken(expression, "p", parent); }
private static void VerifyLiteralQueryTokensAreEqual(LiteralToken expected, LiteralToken actual, AssertionHandler assert) { assert.AreEqual(expected.Value, actual.Value, "Literal values are different."); }