public Chunk ParseChunk(ParserInput<char> input, out bool success) { this.SetInput(input); Chunk chunk = ParseChunk(out success); if (this.Position < input.Length) { success = false; Error("Failed to parse remaining input."); } return chunk; }
public YamlStream ParseYamlStream(ParserInput<char> input, out bool success) { this.SetInput(input); YamlStream yamlStream = ParseYamlStream(out success); if (this.Position < input.Length) { success = false; Error("Failed to parse remained input."); } return yamlStream; }
public void SetsNameCorrectly(string input, string name) { // Arrange var document = new DocumentBuilder().Build(); var structNode = ParserInput .FromString(input) .ParseInput(parser => parser.enumDefinition()); // Act var symbol = this.Binder.Bind <Enum>(structNode, document); // Assert Assert.Equal(name, symbol.Name); }
public void IndicatesWhenValueIsImplicit(string input, bool isImplicit) { // Arrange var @enum = new EnumBuilder().Build(); var memberNode = ParserInput .FromString(input) .ParseInput(parser => parser.enumMember()); // Act var member = this.Binder.Bind <EnumMember>(memberNode, @enum); // Assert Assert.Equal(isImplicit, member.IsValueImplicit); }
protected override (IParseTree elementNode, ICollectionType collectionType) ParseInput(string input) { var node = ParserInput .FromString(input) .ParseInput(parser => parser.setType()); var setType = new SetTypeBuilder() .SetNode(node) .SetParent(this.Field) .SetBinderProvider(this.BinderProvider) .Build(); return(node.fieldType(), setType); }
public void Bind_StructNameNotSupplied_Null() { // Arrange var document = new DocumentBuilder().Build(); var structContext = ParserInput .FromString("union {}") .ParseInput(parser => parser.unionDefinition()); // Act var union = this.binder.Bind <IUnion>(structContext, document); // Assert Assert.Null(union.Name); }
public void Bind_IdentifierSupplied_SetsIdentifier() { // Arrange var @struct = new StructBuilder().Build(); var fieldContext = ParserInput .FromString("string Name") .ParseInput(parser => parser.field()); // Act var field = this.binder.Bind <Field>(fieldContext, @struct); // Assert Assert.Equal("Name", field.Name); }
public void SetsInvalidValueReasonCorrectly(string input, InvalidEnumValueReason expected) { // Arrange var @enum = new EnumBuilder().Build(); var memberNode = ParserInput .FromString(input) .ParseInput(parser => parser.enumMember()); // Act var member = this.Binder.Bind <EnumMember>(memberNode, @enum); // Assert Assert.Equal(expected, member.InvalidValueReason); }
public void SetsNameCorrectly(string input, string expectedResult) { // Arrange var @enum = new EnumBuilder().Build(); var memberNode = ParserInput .FromString(input) .ParseInput(parser => parser.enumMember()); // Act var member = this.Binder.Bind <EnumMember>(memberNode, @enum); // Assert Assert.Equal(expectedResult, member.Name); }
public void Push(TextReader stream, string filename, int lineNumber = 1, TextWriter sourceWriter = null) { var pi = new ParserInput { FileName = filename, Reader = stream, LineNumberCounter = lineNumber, Writer = sourceWriter }; m_ParserInputs.Add(pi); cur_linenumber = pi.LineNumberCounter; cur_filename = pi.FileName; }
public void Bind_FieldIdSupplied_SetsRawFieldId() { // Arrange var @struct = new StructBuilder().Build(); var fieldContext = ParserInput .FromString("4: i32 Id") .ParseInput(parser => parser.field()); // Act var field = this.binder.Bind <Field>(fieldContext, @struct); // Assert Assert.Equal("4", field.RawFieldId); }
public void NameSupplied_SetsName() { // Arrange var input = ParserInput .FromString("const i32 MaxPageSize = 100") .ParseInput(parser => parser.constDefinition()); var parent = Substitute.For <IDocument>(); // Act var result = this.constantBinder.Bind <IConstant>(input, parent); // Assert Assert.Equal("MaxPageSize", result.Name); }
public void Bind_ExceptionNameNotSupplied_Null() { // Arrange var document = new DocumentBuilder().Build(); var exceptionNode = ParserInput .FromString("exception {}") .ParseInput(parser => parser.exceptionDefinition()); // Act var exception = this.binder.Bind <IException>(exceptionNode, document); // Assert Assert.Null(exception.Name); }
public void Bind_FieldIdNotAnInteger_SetsFieldIdNull() { // Arrange var @struct = new StructBuilder().Build(); var fieldContext = ParserInput .FromString("abc: i32 Id") .ParseInput(parser => parser.field()); // Act var field = this.binder.Bind <Field>(fieldContext, @struct); // Assert Assert.Null(field.FieldId); }
public void NameNotSupplied_Null() { // Arrange var input = ParserInput .FromString("const i32 = 100") .ParseInput(parser => parser.constDefinition()); var parent = Substitute.For <IDocument>(); // Act var result = this.constantBinder.Bind <IConstant>(input, parent); // Assert Assert.Null(result.Name); }
public void Bind_FieldRequirednessNotSupplied_UsesDefault() { // Arrange var @struct = new StructBuilder().Build(); var fieldContext = ParserInput .FromString("i32 Id") .ParseInput(parser => parser.field()); // Act var field = this.binder.Bind <Field>(fieldContext, @struct); // Assert Assert.Equal(FieldRequiredness.Default, field.Requiredness); }
public void BasicTest() { var parser = new StringTokenParser(); using (var input = ParserInput.CreateFromString("\"Hello World!\"")) Assert.Equal("Hello World!", parser.Parse(input)); using (var input = ParserInput.CreateFromString("\"\\\\\"")) Assert.Equal("\\", parser.Parse(input)); parser.EscapedCharLookup.Add('t', '\t'); using (var input = ParserInput.CreateFromString("\"\\tHello\"")) Assert.Equal("\tHello", parser.Parse(input)); }
public void CanResolveAllBaseTypes(string baseType, string requiredType, string optionalType) { // Arrange var node = ParserInput .FromString(baseType) .ParseInput(parser => parser.baseType()); var parent = Substitute.For <IField>(); // Act var type = BaseType.Resolve(node, parent); // Assert Assert.Equal(baseType, type.Name); Assert.Equal(requiredType, type.CSharpRequiredTypeName); Assert.Equal(optionalType, type.CSharpOptionalTypeName); }
public void NamespaceProvided_SetsNamespace() { // Arrange var document = new DocumentBuilder().Build(); var binderProvider = Substitute.For <IBinderProvider>(); var binder = new NamespaceBinder(binderProvider); var namespaceStatement = ParserInput .FromString("namespace * Thrift.Net.Examples") .ParseInput(parser => parser.namespaceStatement()); // Act var @namespace = binder.Bind <Namespace>(namespaceStatement, document); // Assert Assert.Equal("Thrift.Net.Examples", @namespace.NamespaceName); }
public void KeyAndValuesProvided_IncludesBothInType() { // Arrange var node = ParserInput .FromString("map<string, bool>") .ParseInput(parser => parser.mapType()); var mapType = new MapTypeBuilder() .SetNode(node) .SetParent(this.field) .SetBinderProvider(this.binderProvider) .Build(); var binder = Substitute.For <IBinder>(); this.binderProvider.GetBinder(default).ReturnsForAnyArgs(binder);
public void ScopeNotProvided_Null() { // Arrange var document = new DocumentBuilder().Build(); var binderProvider = Substitute.For <IBinderProvider>(); var binder = new NamespaceBinder(binderProvider); var namespaceStatement = ParserInput .FromString("namespace Thrift.Net.Examples") .ParseInput(parser => parser.namespaceStatement()); // Act var @namespace = binder.Bind <Namespace>(namespaceStatement, document); // Assert Assert.Null(@namespace.Scope); }
public void BasicLookupTest() { const string source = "abcdef 12345"; using (var input = ParserInput.CreateFromString(source)) { Assert.Equal(0, input.LookaheadCount); Assert.Equal(0, input.Offset); var pos1 = TextPosition.Start; // lookahead 1 Assert.Equal(pos1, input.TextPosition); Assert.True(input.TryPeekChar(out var ch)); Assert.Equal('a', ch); Assert.Equal(pos1, input.TextPosition); Assert.Equal(1, input.LookaheadCount); Assert.Equal(0, input.Offset); // lookahead 2 Assert.True(input.TryPeekChar(out ch)); Assert.Equal('b', ch); Assert.Equal(pos1, input.TextPosition); Assert.Equal(2, input.LookaheadCount); Assert.Equal(0, input.Offset); input.ClearLookahead(); Assert.Equal(0, input.LookaheadCount); Assert.Equal(pos1, input.TextPosition); // lookahead 1 Assert.Equal(pos1, input.TextPosition); Assert.True(input.TryPeekChar(out ch)); Assert.Equal('a', ch); Assert.Equal(pos1, input.TextPosition); Assert.Equal(1, input.LookaheadCount); Assert.Equal(0, input.Offset); // lookahead 2 Assert.True(input.TryPeekChar(out ch)); Assert.Equal('b', ch); Assert.Equal(pos1, input.TextPosition); Assert.Equal(2, input.LookaheadCount); Assert.Equal(0, input.Offset); } }
public void NodeIsOnlyMember_ReturnsZero() { // Arrange var input = @"enum UserType { User }"; var enumNode = ParserInput .FromString(input) .ParseInput(parser => parser.enumDefinition()); // Act var member = this.Binder.Bind <EnumMember>(enumNode.enumMember()[0], this.parent); // Assert Assert.Equal(0, member.Value); }
protected void AssertCompilerDoesNotReturnMessage( string input, CompilerMessageId messageId) { // Arrange var compiler = new ThriftCompiler(); var parserInput = ParserInput.FromString(input); // Act var result = compiler.Compile(parserInput.GetStream()); // Assert var message = result.Messages.FirstOrDefault(m => m.MessageId == messageId); Assert.True( message == null, $"Message Id '{messageId}' should not have been reported"); }
public void Bind_FieldIdNotProvided_IndicatesFieldIdIsImplicit() { // Arrange var input = @"struct User { i32 Id }"; var @struct = new StructBuilder().Build(); var structDefinition = ParserInput .FromString(input) .ParseInput(parser => parser.structDefinition()); // Act var field = this.binder.Bind <Field>(structDefinition.field()[0], @struct); // Assert Assert.True(field.IsFieldIdImplicit); }
public void PreviousSiblingHasCustomValue_ReturnsNextValue() { // Arrange var input = @"enum UserType { User = 5, Administrator }"; var enumNode = ParserInput .FromString(input) .ParseInput(parser => parser.enumDefinition()); // Act var member = this.Binder.Bind <EnumMember>(enumNode.enumMember()[1], this.parent); // Assert Assert.Equal(6, member.Value); }
public void Bind_UserType_ResolvesType() { // Arrange var field = new FieldBuilder().Build(); var node = ParserInput .FromString("User") .ParseInput(parser => parser.fieldType()); this.binderProvider.GetBinder(node.userType()).Returns(this.typeBinder); var userType = Substitute.For <IUserType>(); this.typeBinder.Bind <IFieldType>(node.userType(), field).Returns(userType); // Act var type = this.binder.Bind <IFieldType>(node, field); // Assert Assert.Same(userType, type); }
public void TypeCanBeResolvedFromParent_ResolvesType() { // Arrange var binder = new UserTypeBinder(); var resolvedType = Substitute.For <INamedTypeSymbol>(); var field = Substitute.For <IField>(); field.ResolveType("UserType").Returns(resolvedType); var node = ParserInput .FromString("UserType") .ParseInput(parser => parser.userType()); // Act var result = binder.Bind <UserType>(node, field); // Assert Assert.Same(resolvedType, result.Definition); }
public void TestParser() { System.Console.WriteLine(Directory.GetCurrentDirectory()); var files = Directory .GetFiles("../../TestPrograms") .Where(_ => _.EndsWith(".c")); var sources = files.Select(File.ReadAllText).ToArray(); foreach (var source in sources) { var scanner = new Scanner(source); var tokens = scanner.Tokens; var env = new ParserEnvironment(); var input = new ParserInput(env, scanner.Tokens); var result = CParsers.TranslationUnit.Parse(input); Assert.IsTrue(result.IsSuccessful); Assert.IsTrue(result.Source.Count() == 1); } }
public void TestCompiler() { Console.WriteLine(Directory.GetCurrentDirectory()); var files = Directory .GetFiles("../../TestPrograms") .Where(_ => _.EndsWith(".c")); var sources = files.Select(File.ReadAllText).ToArray(); foreach (var source in sources) { var scanner = new Scanner(source); var tokens = scanner.Tokens; var env = new ParserEnvironment(); var input = new ParserInput(env, tokens); var parserResult = CParsers.TranslationUnit.Parse(input); var semantResult = parserResult.Result.GetTranslnUnit(); semantResult.Value.CodeGenerate(new CGenState()); } }
public void ValueNotProvided_DoesNotIncludeInName() { // Arrange var node = ParserInput .FromString("map<string,>") .ParseInput(parser => parser.mapType()); var mapType = new MapTypeBuilder() .SetNode(node) .SetParent(this.field) .SetBinderProvider(this.binderProvider) .Build(); // Act var name = mapType.Name; // Assert Assert.Equal("map<string,>", name); }
public void PreviousSiblingValueIsInvalid_IgnoresPreviousSibling() { // Arrange var input = @"enum UserType { User = 2, Administrator = -1, Guest }"; var enumNode = ParserInput .FromString(input) .ParseInput(parser => parser.enumDefinition()); // Act var member = this.Binder.Bind <EnumMember>(enumNode.enumMember()[2], this.parent); // Assert Assert.Equal(3, member.Value); }
public void Bind_FieldIdNotProvided_SkipsExplicitFieldsWhenGeneratingIds() { // Arrange var input = @"struct User { i32 Id 1: string Username string Email }"; var @struct = new StructBuilder().Build(); var structDefinition = ParserInput .FromString(input) .ParseInput(parser => parser.structDefinition()); // Act var field = this.binder.Bind <Field>(structDefinition.field()[2], @struct); // Assert Assert.Equal(-2, field.FieldId); }
public void Bind_FieldIdNotProvided_GeneratesNegativeIds() { // Arrange var input = @"struct User { i32 Id string Username }"; var @struct = new StructBuilder().Build(); var structDefinition = ParserInput .FromString(input) .ParseInput(parser => parser.structDefinition()); // Act var idField = this.binder.Bind <Field>(structDefinition.field()[0], @struct); var usernameField = this.binder.Bind <Field>(structDefinition.field()[1], @struct); // Assert Assert.Equal(-1, idField.FieldId); Assert.Equal(-2, usernameField.FieldId); }
public YamlStream ParseYamlStream(ParserInput<Char> input, out bool success) { this.SetInput(input); YamlStream yamlStream = ParseYamlStream(out success); return yamlStream; }
private void SetInput(ParserInput<char> input) { Input = input; position = 0; ParsingResults.Clear(); }
private void SetInput(ParserInput<char> input) { Input = input; position = 0; }