public TElement ParseToObject <TElement>(params string[] args) where TElement : new() { var parser = new ObjectParser <TElement>(); var jointArgs = string.Join(" ", args); return(parser.Parse(jointArgs)); }
public void ParseMethodShouldParseNumericAttributes( string args, byte expectedByte, sbyte expectedSByte, int expectedInt, uint expectedUInt, long expectedLong, ulong expectedULong, short expectedShort, ushort expectedUShort) { var parser = new ObjectParser <NumericPropertyForAttributeClass>(); var parsed = parser.Parse(args); parsed.Should().NotBeNull(); parsed.Should().BeOfType <NumericPropertyForAttributeClass>(); parsed.ItemByte.Should().Be(expectedByte); parsed.ItemSByte.Should().Be(expectedSByte); parsed.ItemInt.Should().Be(expectedInt); parsed.ItemUInt.Should().Be(expectedUInt); parsed.ItemLong.Should().Be(expectedLong); parsed.ItemULong.Should().Be(expectedULong); parsed.ItemShort.Should().Be(expectedShort); parsed.ItemUShort.Should().Be(expectedUShort); }
private static ConstantExpression CreateValueExpression(string stringValue, Type targetType) { var parsedValue = ObjectParser.Parse(targetType, stringValue); var valueExpression = Expression.Constant(parsedValue, targetType); return(valueExpression); }
public void TestParseDateTime() { ObjectParser.Parse(typeof(DateTime), "635488416000000000").Should().Be(new DateTime(2014, 10, 14, 0, 0, 0, 0, DateTimeKind.Utc)); ObjectParser.Parse(typeof(DateTime), "2014-10-14T12:11:00.0000000Z").Should().Be(new DateTime(2014, 10, 14, 12, 11, 0, 0, DateTimeKind.Utc)); ObjectParser.Parse(typeof(DateTime), "2014-10-14T12:11:00.0000000").Should().Be(new DateTime(2014, 10, 14, 12, 11, 0, 0, DateTimeKind.Utc)); ObjectParser.Parse(typeof(DateTime), "2014-10-15T13:12:00.00000Z").Should().Be(new DateTime(2014, 10, 15, 13, 12, 0, 0, DateTimeKind.Utc)); ObjectParser.Parse(typeof(DateTime), "2014-10-15T13:12:00.00000").Should().Be(new DateTime(2014, 10, 15, 13, 12, 0, 0, DateTimeKind.Utc)); ObjectParser.Parse(typeof(DateTime), "2014-10-16T14:13:00.000Z").Should().Be(new DateTime(2014, 10, 16, 14, 13, 0, 0, DateTimeKind.Utc)); ObjectParser.Parse(typeof(DateTime), "2014-10-16T14:13:00.000").Should().Be(new DateTime(2014, 10, 16, 14, 13, 0, 0, DateTimeKind.Utc)); 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")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "14.10.2014")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "14.10.2014")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "14.10.2014 10:10:10.000")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "14.10.2014 10:10:10")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "14.10.2014 10:10")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "2014-10-14 10:10:10.000")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "2014-10-14 10:10:10")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "2014-10-14 10:10")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "14 октября 2014")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "5 февраля 2013")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "14.10.2014 34")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "48.10.2014")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "29.02.2014")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "2014-31-03")); Assert.Throws <FormatException>(() => ObjectParser.Parse(typeof(DateTime), "дата")); }
public void ParseOptionAndValue() { var parser = new ObjectParser(); var options = parser.Parse <TestOptions>(new[] { "-f", "foo" }); Assert.Equal(options.Foo, "foo"); }
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 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 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); }
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 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 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 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 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 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 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 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)); }
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 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 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 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 ParseMethodShouldParseDecimalAttributes( string args, float expectedFloat, double expectedDouble, decimal expectedDecimal) { var parser = new ObjectParser <DecimalPropertyForAttributeClass>(); var parsed = parser.Parse(args); parsed.Should().NotBeNull(); parsed.Should().BeOfType <DecimalPropertyForAttributeClass>(); parsed.ItemFloat.Should().Be(expectedFloat); parsed.ItemDouble.Should().Be(expectedDouble); parsed.ItemDecimal.Should().Be(expectedDecimal); }
public void TestParseBool() { var type = typeof(bool); Assert.That(ObjectParser.Parse(type, "true"), Is.EqualTo(true)); Assert.That(ObjectParser.Parse(type, "True"), Is.EqualTo(true)); Assert.That(ObjectParser.Parse(type, "false"), Is.EqualTo(false)); Assert.That(ObjectParser.Parse(type, "False"), Is.EqualTo(false)); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "фалс")); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "1")); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "0")); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "")); Assert.Throws <ArgumentNullException>(() => ObjectParser.Parse(type, null)); }
public void TestParseLong() { var type = typeof(long); Assert.That(ObjectParser.Parse(type, "2"), Is.EqualTo(2)); Assert.That(ObjectParser.Parse(type, "0"), Is.EqualTo(0)); Assert.That(ObjectParser.Parse(type, "9223372036854775807"), Is.EqualTo(9223372036854775807L)); Assert.That(ObjectParser.Parse(type, "-9223372036854775808"), Is.EqualTo(-9223372036854775808L)); Assert.Throws <OverflowException>(() => ObjectParser.Parse(type, "9223372036854775808")); Assert.Throws <OverflowException>(() => ObjectParser.Parse(type, "-9223372036854775809")); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "19.0")); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "19.")); Assert.Throws <ArgumentNullException>(() => ObjectParser.Parse(type, null)); }
public void TestParseByte() { var type = typeof(byte); Assert.That(ObjectParser.Parse(type, "2"), Is.EqualTo(2)); Assert.That(ObjectParser.Parse(type, "0"), Is.EqualTo(0)); Assert.That(ObjectParser.Parse(type, "255"), Is.EqualTo(255)); Assert.Throws <OverflowException>(() => ObjectParser.Parse(type, "-1")); Assert.Throws <OverflowException>(() => ObjectParser.Parse(type, "256")); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "xxx")); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "19.0")); Assert.Throws <FormatException>(() => ObjectParser.Parse(type, "19.")); Assert.Throws <ArgumentNullException>(() => ObjectParser.Parse(type, null)); }
public void CreateWithObject() { const string Value = "This is a pre-set value."; var options = new TestOptions { Foo = Value }; var parser = new ObjectParser(); parser.Parse(new string[] {}, options); Assert.Equal(Value, options.Foo); Assert.Null(options.Bar); Assert.Null(options.FooBar); Assert.False(options.Switch); }
public void CreateWithObject2() { var options = new TestOptions(); var parser = new ObjectParser(); try { parser.Parse(new string[] {}, options); } catch (RequirementException) { return; } new Exception("RequirementException was expected, but was not thrown."); }
public void TestParseEnum() { ObjectParser.Parse(typeof(ExpressionType), "Dynamic").Should().Be(ExpressionType.Dynamic); ObjectParser.Parse(typeof(ExpressionType), "42").Should().Be(ExpressionType.Subtract); ObjectParser.Parse(typeof(OurEnum), "1").Should().Be(OurEnum.One); ObjectParser.Parse(typeof(OurEnum), "3").Should().Be((OurEnum)3); ObjectParser.Parse(typeof(OurEnum), "11").Should().Be((OurEnum)11); ObjectParser.Parse(typeof(OurEnum), "-1").Should().Be((OurEnum)(-1)); Assert.Throws <ArgumentException>(() => ObjectParser.Parse(typeof(ExpressionType), "dynamic")); Assert.Throws <ArgumentException>(() => ObjectParser.Parse(typeof(ExpressionType), "xyu")); Assert.Throws <ArgumentException>(() => ObjectParser.Parse(typeof(ExpressionType), "")); Assert.Throws <ArgumentNullException>(() => ObjectParser.Parse(typeof(ExpressionType), null)); }
public static object?Parse(Type type, string value) { if (type == typeof(LocalDate)) { return(ParseDate(value).ToLocalDate()); } if (type == typeof(LocalTime)) { return(ParseDate(value).ToLocalTime()); } if (type == typeof(TimeUuid) || type == typeof(TimeUuid?)) { return(TimeUuid.Parse(value)); } return(ObjectParser.Parse(type, value)); }