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);
}
