public void ParseMethodShouldThrowErrorWhenThereAreDuplicatedNameOptions() { var parser = new ObjectParser <CollisionOfOptionNameAttributeClass>(); var exception = Assert.Throws <DuplicatedOptionsException>( () => parser.Parse(null)); exception.Duplications.Should().BeEquivalentTo("foo"); }
public void ParseMethodShouldDoNothingForEmptyArgs(string args) { var parser = new ObjectParser <object>(); var parsed = parser.Parse(args); parsed.Should().NotBeNull(); parsed.Should().BeOfType <object>(); }
public void ParseMethodShouldParseSingleOptionAliasAttributeClass(string args, string expectedValue) { var parser = new ObjectParser <SingleOptionAliasAttributeClass>(); var parsed = parser.Parse(args); parsed.Should().NotBeNull(); parsed.Should().BeOfType <SingleOptionAliasAttributeClass>(); parsed.Item.Should().Be(expectedValue); }
/// <summary> /// Create a serializer for specified type /// </summary> /// <param name="type">Type representing a Bond schema</param> public Serializer(Type type) { var parser = new ObjectParser(type); serialize = SerializerGeneratorFactory <object, W> .Create( (o, w, i) => serialize[i](o, w), type) .Generate(parser) .Select(lambda => lambda.Compile()).ToArray(); }
public void TestParseNullableEnum() { ObjectParser.Parse(typeof(ExpressionType?), "").Should().BeNull(); ObjectParser.Parse(typeof(ExpressionType?), null).Should().BeNull(); ObjectParser.Parse(typeof(ExpressionType?), "Dynamic").Should().Be(ExpressionType.Dynamic); Assert.Throws <ArgumentException>(() => ObjectParser.Parse(typeof(ExpressionType?), "xyu")); }
public void TestParseNullableDateTime() { ObjectParser.Parse(typeof(DateTime?), "").Should().BeNull(); ObjectParser.Parse(typeof(DateTime?), null).Should().BeNull(); ObjectParser.Parse(typeof(DateTime?), "2014-10-16T14:13:00").Should().Be(new DateTime(2014, 10, 16, 14, 13, 0, 0, DateTimeKind.Utc)); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime?), "2014-10-14")); }
public void CreateWithObject3() { var options = new TestOptions(); var parser = new ObjectParser(); parser.Parse(new[] { "--foo", "foo", "-s" }, options); Assert.Equal("foo", options.Foo); Assert.True(options.Switch, "Switch should be true."); }
public void TestParseNullableInt() { var type = typeof(int?); ObjectParser.Parse(type, null).Should().BeNull(); ObjectParser.Parse(type, "2").Should().Be(2); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "19.0")); }
public void TestParseString() { var type = typeof(string); Assert.That(ObjectParser.Parse(type, "a"), Is.EqualTo("a")); Assert.That(ObjectParser.Parse(type, "TestParseString"), Is.EqualTo("TestParseString")); Assert.That(ObjectParser.Parse(type, ""), Is.EqualTo("")); Assert.That(ObjectParser.Parse(type, null), Is.EqualTo(null)); }
public SerializerDebugView(Type type) { var parser = new ObjectParser(type); var serializerTransform = SerializerGeneratorFactory <object, W> .Create( (o, w, i) => serialize[i](o, w), type); var expressions = serializerTransform.Generate(parser); debugView = DebugViewHelper.ToString(expressions); }
public JSONParser() { typeParser = TypeParser.Instance; predicateParser = PredicateParser.Instance; operatorParser = OperatorParser.Instance; objectParser = ObjectParser.Instance; initStateParser = StateParser.Instance; goalStateParser = StateParser.Instance; }
public TwoPassSerializerHelper(ObjectParser parser, Type type, bool inlineNested) : base(parser, type, inlineNested) { firstPassSerialize = new Lazy <Action <object, FPW>[]>(() => { return(SerializerGeneratorFactory <object, FPW> .Create( (o, w, i) => firstPassSerialize.Value[i](o, w), type, inlineNested) .Generate(parser) .Select(lambda => lambda.Compile()).ToArray()); }, LazyThreadSafetyMode.PublicationOnly); }
public void Decode_SampleObject_ExtraPropertiesShouldBeSave() { var input = "10:hello:33:9"; var actual = ObjectParser.Decode <ObjectSample>(input); Assert.AreEqual(9, actual.X); Assert.AreEqual(1, actual.WithoutLoaded.Count); Assert.AreEqual("hello", actual.WithoutLoaded["10"]); }
public void DecodeBlock_BaseBlock() { var input = "1,1,2,3,3,6"; var actual = ObjectParser.DecodeBlock(input); Assert.AreEqual(1, actual.Id); Assert.AreEqual(3, actual.PositionX); Assert.AreEqual(6, actual.PositionY); }
public void ParseMethodShouldParseMultipleOptionAliasAttributeClass(string args, string expectedValue1, string expectedValue2) { var parser = new ObjectParser <MultipleOptionAliasAttributeClass>(); var parsed = parser.Parse(args); parsed.Should().NotBeNull(); parsed.Should().BeOfType <MultipleOptionAliasAttributeClass>(); parsed.Item1.Should().Be(expectedValue1); parsed.Item2.Should().Be(expectedValue2); }
public void ParseMethodShouldParsePrimitiveAttributes(string args, bool expectedBool, char expectedChar) { var parser = new ObjectParser <PrimitivePropertyForAttributeClass>(); var parsed = parser.Parse(args); parsed.Should().NotBeNull(); parsed.Should().BeOfType <PrimitivePropertyForAttributeClass>(); parsed.ItemBool.Should().Be(expectedBool); parsed.ItemChar.Should().Be(expectedChar); }
public void TestParseDouble() { var type = typeof(double); Assert.That(ObjectParser.Parse(type, "1.1"), Is.EqualTo(1.1)); Assert.That(ObjectParser.Parse(type, "0.999"), Is.EqualTo(0.999)); Assert.That(ObjectParser.Parse(type, "-345345.435"), Is.EqualTo(-345345.435)); Assert.That(ObjectParser.Parse(type, "1,1"), Is.EqualTo(11)); Assert.Throws <ArgumentNullException>(() => ObjectParser.Parse(type, null)); }
public void TestObjectWithComplexStringParsing() { var sourceList = new List <string> { ObjectWithComplexString }; var parser = new ObjectParser(TokenStreamer.CreateFromList(sourceList)); var parsedObj = parser.ReadSingleObject() as PdfArray; Assert.Equal(4, parsedObj.Count); }
public void TestParseFloat() { var type = typeof(float); Assert.That(ObjectParser.Parse(type, "1.1"), ApproximatelyEqualTo(1.1)); Assert.That(ObjectParser.Parse(type, "0.999"), ApproximatelyEqualTo(0.999)); Assert.That(ObjectParser.Parse(type, "-3545.435"), ApproximatelyEqualTo(-3545.435, 1e-2)); Assert.That(ObjectParser.Parse(type, "1,1"), ApproximatelyEqualTo(11)); Assert.Throws <ArgumentNullException>(() => ObjectParser.Parse(type, null)); }
public virtual void WriteExcelDocument <TObject>(string filePath, Dictionary <string, List <TObject> > lstObject) where TObject : class { if (File.Exists(filePath)) { File.Delete(filePath); } var document = SpreadsheetDocument.Create(filePath, SpreadsheetDocumentType.Workbook); var workbookpart = document.AddWorkbookPart(); workbookpart.Workbook = new Workbook(); var sheets = document.WorkbookPart.Workbook.AppendChild(new Sheets()); var headers = Activator.CreateInstance <TObject>().GetExcelHeaders(); UInt32 i = 1; foreach (var item in lstObject) { var worksheetPart = document.WorkbookPart.AddNewPart <WorksheetPart>(); var sheetData = new SheetData(); var sheetName = item.Key; worksheetPart.Worksheet = new Worksheet(sheetData); var data = new OpenXmlEntities.SLExcelData { Headers = headers.ToList(), SheetName = sheetName }; foreach (var itemRow in item.Value) { var row = ObjectParser.FillExcelObject(itemRow); data.DataRows.Add(row.ToList()); } #region Incluindo Sheet var sheet = new Sheet { Id = document.WorkbookPart .GetIdOfPart(worksheetPart), SheetId = i++, Name = sheetName }; workbookpart.Workbook.LastChild.AppendChild(sheet); #endregion this.InsertSheetData(document, sheetData, data); } document.Close(); }
public void Decode_MultipleSense_ShouldBeCorrect() { var input = "1~|~2"; var expected = new MultipleSense() { X1 = 2 }; var actual = ObjectParser.Decode <MultipleSense>(input); actual.Should().BeEquivalentTo(expected); }
protected override void ParseElement(XElement element) { var objectParser = new ObjectParser(State); objectParser.Parse(element); var addExpression = new CodeMethodInvokeExpression( new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(Parent.VariableName), Name), "Add", new CodeVariableReferenceExpression(objectParser.VariableName)); State.AddStatement(new CodeExpressionStatement(addExpression)); }
public void ParseArgs_WithAnonymousArg_ReturnsExpectedDictionary() { var args = new { Number = 1, Text = "Hello", CreateDate = new DateTime(2018, 1, 1, 1, 1, 1), Mark = 2.0 }; var parser = new ObjectParser(); var result = parser.ParseArgs(args); Assert.Equal(4, result.Count); Assert.Equal(1, result[nameof(args.Number)]); Assert.Equal("Hello", result[nameof(args.Text)]); Assert.Equal(new DateTime(2018, 1, 1, 1, 1, 1), result[nameof(args.CreateDate)]); Assert.Equal(2.0, result[nameof(args.Mark)]); }
public static AutoExpression <T> Make <T>() { IObjectParser objParser = new ObjectParser(); IAutoBuilder interfaceBuilder = new AutoProxyBuilder(); Func <IAutoConfigurationResolver, IAutoBuilder, IObjectParser, IAutoFiller> fillerFactory = (config, builder, parser) => new AutoFiller(config, builder, parser); Func <IAutoConfigurationResolver, Func <IAutoConfigurationResolver, IAutoBuilder, IObjectParser, IAutoFiller>, IAutoBuilder> builderFactory = (config, filler) => new AutoBuilder(config, filler, objParser, interfaceBuilder); return(new AutoExpression <T>(builderFactory, fillerFactory, Configure)); }
public void EncodeBlock_BaseBlock() { var input = new BaseBlock(1) { PositionX = 44, PositionY = 77 }; var expected = "1,1,2,44,3,77"; var actual = ObjectParser.EncodeBlock(input); Assert.AreEqual(expected, actual); }
public void ParseDuplicateOptionWithoutValue() { var parser = new ObjectParser(); try { parser.Parse <TestOptions>(new[] { "-f", "-f" }); } catch (DuplicateOptionException) { return; } throw new Exception("DuplicateOptionException was expected, but was not thrown."); }
public void TestParseGuid() { var type = typeof(Guid); Assert.That(ObjectParser.Parse(type, "4552F34E-0164-429E-8B1C-22E69254D556"), Is.EqualTo(new Guid("4552F34E-0164-429E-8B1C-22E69254D556"))); Assert.That(ObjectParser.Parse(type, "{15B8BBF5-3E61-4D41-B6C8-F36AEB822F02}"), Is.EqualTo(new Guid("{15B8BBF5-3E61-4D41-B6C8-F36AEB822F02}"))); Assert.That(ObjectParser.Parse(type, "5D26A5040B1440548C1AE5CC4F56BC0F"), Is.EqualTo(new Guid("5D26A5040B1440548C1AE5CC4F56BC0F"))); Assert.That(ObjectParser.Parse(type, "1c5652cf-c9c4-4e6c-b2f7-dec3fbce09fd"), Is.EqualTo(new Guid("1c5652cf-c9c4-4e6c-b2f7-dec3fbce09fd"))); Assert.That(ObjectParser.Parse(type, "{3127fa5d-6a89-4fa3-8686-0696fb30eea5}"), Is.EqualTo(new Guid("{3127fa5d-6a89-4fa3-8686-0696fb30eea5}"))); Assert.That(ObjectParser.Parse(type, "b39552405bdb4b08868578cf77f1ca8d"), Is.EqualTo(new Guid("b39552405bdb4b08868578cf77f1ca8d"))); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "")); Assert.Throws <ArgumentNullException>(() => ObjectParser.Parse(type, null)); }
public void ParseValueWithoutOption() { var parser = new ObjectParser(); try { parser.Parse <TestOptions>(new[] { "foo" }); } catch (MissingOptionException) { return; } throw new Exception("MissingOptionException was expected, but was not thrown."); }
public void ParseInvalidOption() { var parser = new ObjectParser(); try { parser.Parse <TestOptions>(new[] { "-x" }); } catch (InvalidOptionException) { return; } throw new Exception("InvalidOptionException was expected, but was not thrown."); }
public void TestParseComplexAttribs() { using var linesReader = CreateStringReader(ComplexString); var streamer = TokenStreamer.CreateFromReader(linesReader); var attribParser = new ObjectParser(streamer); var attribDict = attribParser.ReadSingleObject(); Assert.IsType <PdfDictionary>(attribDict); var nextTerm = attribParser.ReadSingleObject(); Assert.Null(nextTerm); }
/// ----------------------------------------------------------------------------- /// <summary> /// SkinFileProcessor class constructor. /// </summary> /// <param name="SkinPath">File path to the portals upload directory.</param> /// <param name="SkinRoot">Specifies type of skin (Skins or Containers)</param> /// <param name="SkinName">Name of folder in which skin will reside (Zip file name)</param> /// <remarks> /// The constructor primes the file processor with path information and /// control data that should only be retrieved once. It checks for the /// existentce of a skin level attribute file and read it in, if found. /// It also sorts through the complete list of controls and creates /// a hashtable which contains only the skin objects and their source paths. /// These are recognized by their ControlKey's which are formatted like /// tokens ("[TOKEN]"). The hashtable is required for speed as it will be /// processed for each token found in the source file by the Control Parser. /// </remarks> /// <history> /// [willhsc] 3/3/2004 Created /// </history> /// ----------------------------------------------------------------------------- public SkinFileProcessor(string SkinPath, string SkinRoot, string SkinName) { Message += SkinController.FormatMessage(INITIALIZE_PROCESSOR, SkinRoot + " :: " + SkinName, 0, false); //Save path information for future use m_SkinRoot = SkinRoot; m_SkinPath = SkinPath; m_SkinName = SkinName; //Check for and read skin package level attribute information file string FileName = this.SkinPath + this.SkinRoot + "\\" + this.SkinName + "\\" + SkinRoot.Substring(0, SkinRoot.Length - 1) + ".xml"; if (File.Exists(FileName)) { try { SkinAttributes.Load(FileName); Message += SkinController.FormatMessage(PACKAGE_LOAD, Path.GetFileName(FileName), 2, false); } catch (Exception ex) { //could not load XML file Logger.Error(ex); Message += SkinController.FormatMessage(string.Format(PACKAGE_LOAD_ERROR, ex.Message), Path.GetFileName(FileName), 2, true); } } //Look at every control string Token; foreach (SkinControlInfo objSkinControl in SkinControlController.GetSkinControls().Values) { Token = objSkinControl.ControlKey.ToUpper(); //If the control is already in the hash table if (m_ControlList.ContainsKey(Token)) { Message += SkinController.FormatMessage(string.Format(DUPLICATE_ERROR, objSkinControl.ControlKey.ToUpper()), string.Format(DUPLICATE_DETAIL, m_ControlList[Token], objSkinControl.ControlSrc), 2, true); } else { //Add it Message += SkinController.FormatMessage(string.Format(LOAD_SKIN_TOKEN, objSkinControl.ControlKey.ToUpper()), objSkinControl.ControlSrc, 2, false); m_ControlList.Add(Token, objSkinControl.ControlSrc); } } //Instantiate the control parser with the list of skin objects m_ControlFactory = new ControlParser(m_ControlList); //Instantiate the object parser with the list of skin objects m_ObjectFactory = new ObjectParser(m_ControlList); }
public SkinFileProcessor(string SkinPath, string SkinRoot, string SkinName) { this.Message += SkinController.FormatMessage(INITIALIZE_PROCESSOR, SkinRoot + " :: " + SkinName, 0, false); m_SkinRoot = SkinRoot; m_SkinPath = SkinPath; m_SkinName = SkinName; string FileName = this.SkinPath + this.SkinRoot + "\\" + this.SkinName + "\\" + SkinRoot.Substring(0, SkinRoot.Length - 1) + ".xml"; if (File.Exists(FileName)) { try { this.SkinAttributes.Load(FileName); this.Message += SkinController.FormatMessage(PACKAGE_LOAD, Path.GetFileName(FileName), 2, false); } catch (Exception ex) { this.Message += SkinController.FormatMessage(string.Format(PACKAGE_LOAD_ERROR, ex.Message), Path.GetFileName(FileName), 2, true); } } string Token; foreach (SkinControlInfo objSkinControl in SkinControlController.GetSkinControls().Values) { Token = objSkinControl.ControlKey.ToUpper(); if (m_ControlList.ContainsKey(Token)) { this.Message += SkinController.FormatMessage(string.Format(DUPLICATE_ERROR, objSkinControl.ControlKey.ToString().ToUpper()), string.Format(DUPLICATE_DETAIL, (string)m_ControlList[Token], objSkinControl.ControlSrc.ToString()), 2, true); } else { this.Message += SkinController.FormatMessage(string.Format(LOAD_SKIN_TOKEN, objSkinControl.ControlKey.ToString().ToUpper()), objSkinControl.ControlSrc.ToString(), 2, false); m_ControlList.Add(Token, objSkinControl.ControlSrc); } } m_ControlFactory = new ControlParser(m_ControlList); m_ObjectFactory = new ObjectParser(m_ControlList); }
public SkinFileProcessor(string ControlKey, string ControlSrc) { m_ControlList.Add(ControlKey, ControlSrc); m_ControlFactory = new ControlParser(m_ControlList); m_ObjectFactory = new ObjectParser(m_ControlList); }
/// ----------------------------------------------------------------------------- /// <summary> /// SkinFileProcessor class constructor. /// </summary> /// <remarks> /// This constructor parses a memory based skin /// </remarks> /// <history> /// [cnurse] 3/21/2005 Created /// </history> /// ----------------------------------------------------------------------------- public SkinFileProcessor(string ControlKey, string ControlSrc) { m_ControlList.Add(ControlKey, ControlSrc); //Instantiate the control parser with the list of skin objects m_ControlFactory = new ControlParser(m_ControlList); //Instantiate the object parser with the list of skin objects m_ObjectFactory = new ObjectParser(m_ControlList); }