private void ParseTypes() { var pi = 0; for (int i = 0; i < _solution.Projects.Count; i++) { pi = i; var types = _solution.Projects[i].Compilation.MainAssembly.TopLevelTypeDefinitions.ToList(); for (int j = 0; j < types.Count; j++) { if (types[j].Kind != TypeKind.Delegate) { PostProgress(_sdBuildStrings.ParsingClass + ": " + string.Format("{0}.{1}", types[j].Namespace, types[j].Name), j, types.Count, pi, _solution.Projects.Count); var sdType = CreateSDType(types[j]); EventParser.ParseMinimalFields(sdType, types[j]); PropertyParser.ParseMinimalProperties(sdType, types[j]); FieldParser.ParseMinimalFields(sdType, types[j]); MethodParser.ParseMinimalConstructors(sdType, types[j]); MethodParser.ParseMinimalMethods(sdType, types[j]); _repository.AddNamespaceTypeRelation(types[j].Namespace, sdType.Identifier); } } } }
protected internal static Field[] ParseFields(System.Xml.XmlElement template, ParsingContext context) { System.Xml.XmlNodeList childNodes = template.ChildNodes; var fields = new List <Field>(); for (int i = 0; i < childNodes.Count; i++) { System.Xml.XmlNode item = childNodes.Item(i); if (IsElement(item)) { if ("typeRef".Equals(item.Name) || "length".Equals(item.Name)) { continue; } var element = (System.Xml.XmlElement)item; FieldParser fieldParser = context.GetFieldParser(element); if (fieldParser == null) { context.ErrorHandler.Error(Error.FastConstants.PARSE_ERROR, "No parser registered for " + element.Name); } if (fieldParser != null) { fields.Add(fieldParser.Parse(element, context)); } } } return(fields.ToArray()); }
/// <summary> /// Le Main /// </summary> /// <param name="args"> /// Program arguments /// </param> public static void Main(string[] args) { var counter = 1; // repeat until "0 0" is entered for dimension size input while (true) { // read dimension Console.Write("Field dimension (format 'n m'): "); string dimensionInput = Console.ReadLine(); if (String.IsNullOrEmpty(dimensionInput)) { Console.WriteLine("Expecting dimension input"); break; } string[] dimensionParts = dimensionInput.Trim().Split(new[] { ' ' }, 2); if (dimensionParts.Length != 2) { Console.WriteLine("Invalid input given, expecting dimension in format \"Width Height\" (e.g. \"4 3\""); break; } int width, height; if (!ParseDimension(dimensionParts[0], "Width", out width)) { break; } if (!ParseDimension(dimensionParts[1], "Height", out height)) { break; } // validate input if (width == 0 && height == 0) { break; } string fieldString = ReadField(width, height); // init var fieldParser = new FieldParser(MaxSize); var mineCounter = new MineCounter(); var fieldSolver = new FieldSolver(mineCounter); Field field = fieldParser.ParseAsync(width, height, fieldString).Result; char[,] result = fieldSolver.GetTextualRepresentation(field); // output Console.WriteLine(); Console.WriteLine("Field #{0}: ", counter); WriteResult(result); Console.WriteLine(); ++counter; } }
public void UninitializedParserTest() { FieldParser parser = FieldParser.BuildParserWithTwoDelimitersAndQualifier(",", "\r\n", "\""); Assert.AreEqual <bool>(false, parser.RowDelimiterMatch); Assert.AreEqual <string>(string.Empty, parser.CurrentText); }
public override void InitModel(TestModel model, Dictionary <string, string> cellMap) { /// id; if (cellMap["Id"] != null) { model.Id = FieldParser.IntParser(cellMap["Id"]); } /// 测试1; if (cellMap["Test1"] != null) { model.Test1 = FieldParser.IntParser(cellMap["Test1"]); } /// 测试2; if (cellMap["Test2"] != null) { model.Test2 = FieldParser.FloatParser(cellMap["Test2"]); } /// 测试3; if (cellMap["Test3"] != null) { model.Test3 = FieldParser.IntArrayParser(cellMap["Test3"]); } /// 测试4; if (cellMap["Test4"] != null) { model.Test4 = FieldParser.IntArraysParser(cellMap["Test4"]); } /// 测试5; if (cellMap["Test5"] != null) { model.Test5 = cellMap["Test5"]; } }
public List <StudentEntity> ReadRecords(string filePath) { try { var reader = new StreamReader(File.OpenRead(filePath)); List <StudentEntity> students = new List <StudentEntity>(); StudentEntity student; while (!reader.EndOfStream) { var line = reader.ReadLine(); var studentDataArray = line.Split(Separator); if (studentDataArray.Length == 4) { var stage = studentDataArray[0]; var gender = studentDataArray[2]; var lastModifiedDate = FieldParser.ConvertToDate(studentDataArray[3]); student = new StudentEntity(stage, studentDataArray[1], gender, lastModifiedDate); students.Add(student); } } return(students); } catch (Exception ex) { throw new InvalidOperationException("ReadRecords:" + ex.Message + ex.StackTrace); } }
public void TestParseFailure() { var reader = ReaderFromCode(string.Empty); var parser = new FieldParser(null, Modifier.None); parser.TryParse(reader, out var _).IsFalse(); }
private void StructureParseTypes(CSharpProject project, SDRepository sdRepository) { var types = project.Compilation.MainAssembly.TopLevelTypeDefinitions.ToList(); for (int j = 0; j < types.Count; j++) { var type = types[j]; if (types[j].Kind != TypeKind.Delegate) { PostParseMessage(_parserStrings.ParsingClass + ": " + string.Format("{0}.{1}", types[j].Namespace, types[j].Name)); var nameSpace = sdRepository.GetNamespaceByIdentifier(type.Namespace); var namespaceRef = nameSpace ?? new SDNamespace(type.Namespace) { IsProjectStranger = true }; var sdType = new SDType(type.GetIdentifier(), type.Name, namespaceRef) { Accessibility = type.GetDefinition().Accessibility.ToString().ToLower() }; sdRepository.AddType(sdType); EventParser.ParseMinimalFields(sdType, types[j]); PropertyParser.ParseMinimalProperties(sdType, types[j]); FieldParser.ParseMinimalFields(sdType, types[j]); MethodParser.ParseMinimalConstructors(sdType, types[j]); MethodParser.ParseMinimalMethods(sdType, types[j]); sdRepository.AddNamespaceTypeRelation(types[j].Namespace, sdType.Identifier); } } }
public void TestField() { var res = FieldParser.ParseOrThrow("string bar"); Assert.That(res.Name, Is.EqualTo("bar")); Assert.That(res.FieldType, Is.EqualTo(new MTypePrimitive(PrimitiveTypeCode.String))); }
public void Should_Generate_GetHashCode_Method_For_Partial_Fields() { // Arrange var updateSummaryMessageType = UpdateSummaryDynamicMessageTypesFactory.GenerateDynamicObjectType(PartialFields); // Act var emptyInstance = Activator.CreateInstance(updateSummaryMessageType); var parseMethod = updateSummaryMessageType.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static); var parsedInstance = parseMethod.Invoke(null, new object[] { "P,AAPL,188.3500,52500,03/30/2021,19:59:14.503633,2" }); // calculate the expected hashes var expectedHashCodeEmptyInstance = 17; expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + ((string)null).GetHashCodeOrDefault(); expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(double).GetHashCode(); expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(int).GetHashCode(); expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(DateTime).GetHashCode(); expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(TimeSpan).GetHashCode(); expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(int).GetHashCode(); var expectedHashCodeParsedInstance = 17; expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + "AAPL".GetHashCode(); expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + 188.35.GetHashCode(); expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + 52500.GetHashCode(); expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + FieldParser.ParseDate("03/30/2021", FundamentalMessage.FundamentalDateTimeFormat).GetHashCode(); expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + FieldParser.ParseTime("19:59:14.503633", UpdateSummaryMessage.UpdateMessageTimeFormat).GetHashCode(); expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + 2.GetHashCode(); // Assert Assert.IsNotNull(emptyInstance); Assert.AreEqual(expectedHashCodeEmptyInstance, emptyInstance.GetHashCode()); Assert.IsNotNull(parsedInstance); Assert.AreEqual(expectedHashCodeParsedInstance, parsedInstance.GetHashCode()); }
private static void checkFields(String expected) { String field = expected.Replace("(", "").Replace(")", ""); String actual = FieldParser.parseFieldsInGeneralPurpose(field); Assert.AreEqual(expected, actual); }
public void TryParse_ParseAttributeTryParseThrowsException_ExceptionIsPropogated() { var property = typeof(MockRecord).GetProperty(nameof(MockRecord.ExceptionThrowingField)); var fieldParser = new FieldParser(); fieldParser.TryParse(property, "1", out var parsedFieldValue, out var failureMessage); }
public void Should_Generate_ToString_Method_For_Partial_Fields() { // Arrange var updateSummaryMessageType = UpdateSummaryDynamicMessageTypesFactory.GenerateDynamicObjectType(PartialFields); // Act var emptyInstance = Activator.CreateInstance(updateSummaryMessageType); var parseMethod = updateSummaryMessageType.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static); var parsedInstance = parseMethod.Invoke(null, new object[] { "P,AAPL,188.3500,52500,03/30/2021,19:59:14.503633,2" }); // generate the expected string values var expectedStringEmptyInstance = $"Symbol: <NULL>, MostRecentTrade: {default(double)}, MostRecentTradeSize: {default(int)}, " + $"MostRecentTradeDate: {default(DateTime)}, " + $"MostRecentTradeTime: {default(TimeSpan)}, " + $"MostRecentTradeAggressor: {default(int)}"; var expectedStringParsedInstance = $"Symbol: AAPL, MostRecentTrade: 188.35, MostRecentTradeSize: 52500, " + $"MostRecentTradeDate: {FieldParser.ParseDate("03/30/2021", FundamentalMessage.FundamentalDateTimeFormat)}, " + $"MostRecentTradeTime: {FieldParser.ParseTime("19:59:14.503633", UpdateSummaryMessage.UpdateMessageTimeFormat)}, " + $"MostRecentTradeAggressor: 2"; // Assert Assert.IsNotNull(emptyInstance); Assert.AreEqual(expectedStringEmptyInstance, emptyInstance.ToString()); Assert.IsNotNull(parsedInstance); Assert.AreEqual(expectedStringParsedInstance, parsedInstance.ToString()); }
public void ParseAsyncWhenInvalidInputWithShortLineGivenThenExceptionExpected() { var parser = new FieldParser(); Func <Task> act = async() => await parser.ParseAsync(10, 10, "..."); act.ShouldThrow <Exception>(); }
private static void DoGetTests(string dataFile, Dictionary <string, string> good, Dictionary <string, string> bad) { const string sep = "#------------------------------------------------------------------------------"; string contents = File.ReadAllText(dataFile); string[] tests = contents.Split(new string[] { sep }, StringSplitOptions.RemoveEmptyEntries); foreach (string test in tests) { Field[] fields = FieldParser.Parse(test); if (fields[1].Name == "stdout") { good.Add(DoSanitize(fields[0].Value), DoSanitize(fields[1].Value)); } else if (fields[1].Name == "stderr") { bad.Add(DoSanitize(fields[0].Value), DoSanitize(fields[1].Value)); } else { System.Diagnostics.Debug.Assert(false); } } }
public void ParseAsyncWhenInvalidHeightPassedThenArgumentExceptionExpected() { var parser = new FieldParser(); Func <Task> act = async() => await parser.ParseAsync(100, -1, "dummy"); act.ShouldThrow <ArgumentException>(); }
public void ParseAsyncWhenNullPassedAsFieldThenArgumentNullExceptionExpected() { var parser = new FieldParser(); Func <Task> act = async() => await parser.ParseAsync(100, 100, null); act.ShouldThrow <ArgumentException>(); }
/// <summary> /// Exporta as tabelas existentes no database para arquivos XML, os dados são gravados no XML em /// formato pronto para INSERT (sem informação de tipo porém no formato esperado pelo BD) /// </summary> public Boolean DBExport(String databaseName) { if (!OpenConnection()) { return(false); } currentDatabase = databaseName; decimalSeparatorIsComma = FieldParser.IsCommaDecimalSeparator(); DBQuery dbQuery = new DBQuery(sqlConnection); dbQuery.Query = "use " + currentDatabase; dbQuery.Execute(false); dbQuery.Query = "SELECT name, id FROM sysObjects WHERE xtype = 'U'"; dbQuery.Execute(true); List <Object> tableList = dbQuery.ExtractFromResultset(typeof(DBObject)); if (tableList.Count < 1) { CloseConnection(); return(false); } foreach (DBObject table in tableList) { // Verifica a quantidade de registros da tabela dbQuery.Query = "SELECT COUNT(1) FROM " + table.name; dbQuery.Execute(true); int?rowCount = dbQuery.ExtractFromResultset(); if (rowCount > 1000000) { continue; // Pula tabelas com mais de 1 milhão de registros ( backup manual ) } dbQuery.Query = "SELECT name FROM sysColumns WHERE id = " + table.id; dbQuery.Execute(true); List <Object> fieldList = dbQuery.ExtractFromResultset(new String[] { "name" }); String[] fieldNames = new String[fieldList.Count]; for (int index = 0; index < fieldList.Count; index++) { fieldNames[index] = (String)((Object[])fieldList[index])[0]; } dbQuery.Query = "SELECT * FROM " + table.name; dbQuery.Execute(true); List <Object> rowList = dbQuery.ExtractFromResultset(fieldNames); Boolean tableExported = ExportTable(table.name, fieldNames, rowList); if (!tableExported) { CloseConnection(); return(false); } } CloseConnection(); return(true); }
public ContentTypeFieldParser(FieldParser original) : base(original) { m_TokenPattern = PatternFactory.GetInstance().Get(typeof(RFC822.Pattern.TokenPattern)); m_ContentPattern = PatternFactory.GetInstance().Get(typeof(Pattern.ContentTypePattern)); m_TypePattern = PatternFactory.GetInstance().Get(typeof(Pattern.TypePattern)); SubTypePattern = PatternFactory.GetInstance().Get(typeof(Pattern.SubTypePattern)); m_ParameterPattern = PatternFactory.GetInstance().Get(typeof(Pattern.ParameterPattern)); m_ValuePattern = PatternFactory.GetInstance().Get(typeof(Pattern.ValuePattern)); }
/** Static constructor. */ static Parser() { var SFBool = new FieldParser(ParseSFBool); //var MFBool = new FieldParser(ParseMFBool); var SFColor = new FieldParser(ParseSFColor); var MFColor = new FieldParser(ParseMFColor); var SFFloat = new FieldParser(ParseSFFloat); var MFFloat = new FieldParser(ParseMFFloat); var SFImage = new FieldParser(ParseSFImage); var SFInt32 = new FieldParser(ParseSFInt32); var MFInt32 = new FieldParser(ParseMFInt32); var SFNode = new FieldParser(ParseSFNode); var MFNode = new FieldParser(ParseMFNode); var SFRotation = new FieldParser(ParseSFRotation); var MFRotation = new FieldParser(ParseMFRotation); var SFString = new FieldParser(ParseSFString); var MFString = new FieldParser(ParseMFString); var SFTime = new FieldParser(ParseSFFloat); //var MFTime = new FieldParser(ParseMFFloat); var SFVec2f = new FieldParser(ParseSFVec2f); var MFVec2f = new FieldParser(ParseMFVec2f); var SFVec3f = new FieldParser(ParseSFVec3f); var MFVec3f = new FieldParser(ParseMFVec3f); // Dictionary<string, (FieldParser, object)> fields; // Lookup table for Vrml97 node types. // For each node type a NodeParseInfo entry specifies how // to handle this kind of node. m_parseInfoMap = new SymbolDict <NodeParseInfo> { // DEF [Vrml97Sym.DEF] = new NodeParseInfo(new NodeParser(ParseDEF)), // USE [Vrml97Sym.USE] = new NodeParseInfo(new NodeParser(ParseUSE)), // ROUTE [Vrml97Sym.ROUTE] = new NodeParseInfo(new NodeParser(ParseROUTE)), // NULL [Vrml97Sym.NULL] = new NodeParseInfo(new NodeParser(ParseNULL)) }; var defaultBBoxCenter = (SFVec3f, (object)V3f.Zero); var defaultBBoxSize = (SFVec3f, (object)new V3f(-1, -1, -1)); (FieldParser, object) fdd(FieldParser fp, object obj) => (fp, obj); (FieldParser, object) fd(FieldParser fp) => (fp, null); // Anchor m_parseInfoMap["Anchor"] = new NodeParseInfo( new SymbolDict <(FieldParser, object)>() { { "children", fd(MFNode) }, { "description", fd(SFString) },
public void ParseSimpleRowsTest() { IFileReader reader = FileReaderTest.GetReader("A,B,C\r\n1,2,3"); FieldParser parser = FieldParser.BuildParserWithSingleDelimiter("\r\n"); VerifySuccessfulFieldParsing(parser, reader, "A,B,C"); VerifyFieldParsing(parser, reader, "1,2,3"); Assert.AreEqual(reader.IsEOF, true); }
public void ParseDelimitedRowsWithQualifiersTest() { IFileReader reader = FileReaderTest.GetReader("\"A,B,C\r\n1\",2,3\r\n1,2,3,\"4\""); FieldParser parser = FieldParser.BuildParserWithSingleDelimiterAndQualifier("\r\n", "\""); VerifySuccessfulFieldParsing(parser, reader, "A,B,C\r\n1,2,3"); VerifyFieldParsing(parser, reader, "1,2,3,\"4\""); Assert.AreEqual(reader.IsEOF, true); }
public void TryParse_EnumFieldWithInvalidStringValue_ParseFails() { var property = typeof(MockRecord).GetProperty(nameof(MockRecord.EnumField)); var fieldParser = new FieldParser(); var couldParse = fieldParser.TryParse(property, "Four", out var parsedFieldValue, out var failureMessage); Assert.IsFalse(couldParse); Assert.IsNull(parsedFieldValue); Assert.AreEqual("Field is invalid.", failureMessage); }
public void TryParse_UnparsableStringFieldWithParseAttribute_ParseFails() { var property = typeof(MockRecord).GetProperty(nameof(MockRecord.UnparsableStringFieldWithParseAttribute)); var fieldParser = new FieldParser(); var couldParse = fieldParser.TryParse(property, "1", out var parsedFieldValue, out var failureMessage); Assert.IsFalse(couldParse); Assert.IsNull(parsedFieldValue); Assert.AreEqual("Could not parse.", failureMessage); }
public void TryParse_ParsableStringFieldWithParseAttribute_ParsedFieldIsReturned() { var property = typeof(MockRecord).GetProperty(nameof(MockRecord.ParsableStringFieldWithParseAttribute)); var fieldParser = new FieldParser(); var couldParse = fieldParser.TryParse(property, "1", out var parsedFieldValue, out var failureMessage); Assert.IsTrue(couldParse); Assert.AreEqual("A", parsedFieldValue); Assert.IsNull(failureMessage); }
public void TryParse_EnumFieldWithInvalidIntValue_ParsedFieldIsReturned() { var property = typeof(MockRecord).GetProperty(nameof(MockRecord.EnumField)); var fieldParser = new FieldParser(); var couldParse = fieldParser.TryParse(property, "4", out var parsedFieldValue, out var failureMessage); Assert.IsTrue(couldParse); Assert.AreEqual((MockEnum)4, parsedFieldValue); Assert.IsNull(failureMessage); }
private static void ParseTypeConfig(TypeConfig cfg) { if (cfg.Methods != null) { var list = new List <WhitelistMethodDefine>(); foreach (var m in cfg.Methods) { try { list.Add(MethodParser.ParseOrThrow(m)); } catch (ParseException e) { Logger.ErrorS("res.typecheck", $"Parse exception for '{m}': {e}"); } } cfg.MethodsParsed = list.ToArray(); } else { cfg.MethodsParsed = Array.Empty <WhitelistMethodDefine>(); } if (cfg.Fields != null) { var list = new List <WhitelistFieldDefine>(); foreach (var f in cfg.Fields) { try { list.Add(FieldParser.ParseOrThrow(f)); } catch (ParseException e) { Logger.ErrorS("res.typecheck", $"Parse exception for '{f}': {e}"); } } cfg.FieldsParsed = list.ToArray(); } else { cfg.FieldsParsed = Array.Empty <WhitelistFieldDefine>(); } if (cfg.NestedTypes != null) { foreach (var nested in cfg.NestedTypes.Values) { ParseTypeConfig(nested); } } }
public void TestSimpleField() { var labelName = "Article.List"; var templateContent = @"@title"; var field = FieldParser.Parse(labelName, templateContent).FirstOrDefault(); Assert.AreNotEqual(null, field); Assert.AreEqual("title", field.Name); }
private static void TestEmbeddedQualifiers(string textToParse, string[] expectedFields) { IFileReader reader = FileReaderTest.GetReader(textToParse); FieldParser parser = FieldParser.BuildParserWithTwoDelimitersAndQualifier(",", "\r\n", "\""); foreach (string fieldData in expectedFields) { VerifySuccessfulFieldParsing(parser, reader, fieldData); } Assert.AreEqual(reader.IsEOF, true); }
public void TestCustomField() { var labelName = "PageLink"; var templateContent = "@next"; var field = FieldParser.Parse(labelName, templateContent).FirstOrDefault(); Assert.AreNotEqual(null, field); Assert.AreEqual("next", field.Name); Assert.AreEqual("SparrowCMS.Base.Labels.PageLink.Fields.Next", field.GetType().FullName); }
//todo: remove second argument public static ProtoFieldStatement Parse(ParserContext context, Action<ParserContext> nodeStatementParser) { context.ReadKeyword("field"); var fieldType = context.ParseFieldType(); var fieldId = context.ParseFieldId(); var field = context.CreateField(fieldType); var fieldParser = new FieldParser(context, nodeStatementParser); field.AcceptVisitor(fieldParser); return new ProtoFieldStatement { FieldType = fieldType, FieldId = fieldId, Value = field }; }
public virtual void AddFieldParser(FieldParser parser) { FieldParsers.Add(parser); }
public void AddFieldParser(FieldParser fieldParser) { initialContext.FieldParsers.Add(fieldParser); }