public void Default_Ctor_Initialises_To_Sensible_Values()
{
var parser = new KeyValueParser();
Assert.AreEqual('=', parser.Separator);
Assert.AreEqual("", parser.MissingValue);
}
public void ThrowsIfDuplicateAttribute()
{
string value = "Name=\"Foo\" Name=\"Hey\"";
IDictionary <string, string> props = KeyValueParser.Parse(value);
Assert.AreEqual(2, props.Count);
}
public void ShouldParseAttributes()
{
string value = "Name=\"Foo\" Value=\"Hey\"";
IDictionary <string, string> props = KeyValueParser.Parse(value);
Assert.AreEqual(2, props.Count);
}
public void Custom_Parameters_Ctor_Initialises_Properties()
{
var parser = new KeyValueParser(':', "oops");
Assert.AreEqual(':', parser.Separator);
Assert.AreEqual("oops", parser.MissingValue);
}
public void ShouldSupportMixingQuoteTypes()
{
string value = "Name='Foo' Value=\"Bar\"";
IDictionary <string, string> props = KeyValueParser.Parse(value);
Assert.AreEqual(2, props.Count);
}
public void ShouldBuildCaseInsensitiveDictionary()
{
string value = "Name=\"Foo\"";
IDictionary <string, string> props = KeyValueParser.Parse(value);
Assert.IsTrue(props.ContainsKey("name"));
}
public void TestSetup()
{
parser = new KeyValueParser();
contentBuilder = new StringBuilder();
content = Substitute.For <IFileContent>();
content.AsStream.Returns(_ => new MemoryStream(Encoding.UTF8.GetBytes(contentBuilder.ToString())));
fileName = Guid.NewGuid().ToString();
}
public void Parse_Uses_MissingValue()
{
var parser = new KeyValueParser('=', "ug");
string key, value;
parser.Parse("a", out key, out value);
Assert.AreEqual("a", key);
Assert.AreEqual("ug", value);
}
public void Parse_Uses_Separator()
{
var parser = new KeyValueParser(':', "");
string key, value;
parser.Parse("Z1: a=b", out key, out value);
Assert.AreEqual("Z1", key);
Assert.AreEqual(" a=b", value);
}
public void Parse_Splits_Key_And_Value_Correctly(string text, string expectedKey, string expectedValue)
{
var parser = new KeyValueParser();
string key, value;
parser.Parse(text, out key, out value);
Assert.AreEqual(expectedKey, key);
Assert.AreEqual(expectedValue, value);
}
public Config Parse(string path)
{
var configBuilder = new Config.Builder();
using (var fs = File.OpenRead(path))
using (var sr = new StreamReader(fs, Encoding.UTF8))
{
var validSection = false;
BaseSection.Builder currentSectionBuilder = null;
while (!sr.EndOfStream)
{
var line = sr.ReadLine();
if (line.Length == 0)
{
continue;
}
var lineType = CheckLineType(line);
if (lineType == LineType.COMMENT)
{
continue;
}
if (lineType == LineType.SECTION)
{
var sectionParser = new SectionParser();
validSection = sectionParser.TryParse(line, out var sectionBuilder);
if (validSection)
{
sectionBuilder.AddToConfigBuilder(configBuilder);
currentSectionBuilder = sectionBuilder;
}
}
else if (lineType == LineType.PARAMETER)
{
if (validSection)
{
var kvParser = new KeyValueParser();
if (kvParser.TryParse(line, out var kv))
{
currentSectionBuilder.SetValue(kv);
}
}
}
}
}
return(configBuilder.Build());
}
public bool ParseAllEntities(string mapEntites)
{
var groups = new List <Dictionary <String, String> >();
if (!KeyValueParser.ParseEntities(mapEntites, groups))
{
return(false);
}
foreach (var g in groups)
{
if (!g.ContainsKey("classname"))
{
continue;
}
var ent = CreateEntity(g["classname"]);
ent.LoadMapData(g);
_MapEntityList.Add(ent);
}
return(true);
}
public void ParseKeys_ThrowsODataException_HasABadFormatForSingleQuote(string segment, string expectedError)
{
ExceptionAssert.Throws <ODataException>(() => KeyValueParser.ParseKeys(segment), expectedError);
}
public void ParseKeys(string str, IEnumerable <string> expectedKeyValues)
{
var result = KeyValueParser.ParseKeys(str);
Assert.Equal(result.Select(r => r.Key + ":" + r.Value).OrderBy(r => r), expectedKeyValues.OrderBy(k => k));
}
public void ThrowsIfNullValue()
{
KeyValueParser.Parse(null);
}
protected void LoadConfig ()
{
var config = new Dictionary<string, string[]> ();
if (File.Exists (IsAudioPlayerPath)) {
try {
using (var reader = new StreamReader (IsAudioPlayerPath)) {
config = new KeyValueParser (reader);
has_is_audio_player_file = true;
}
} catch (Exception e) {
Log.Exception ("Error parsing " + IsAudioPlayerPath, e);
}
}
name = GetPreferredValue ("name", config, DefaultName);
cover_art_file_type = GetPreferredValue ("cover_art_file_type", config, DefaultCoverArtFileType);
cover_art_file_name = GetPreferredValue ("cover_art_file_name", config, DefaultCoverArtFileName);
cover_art_size = GetPreferredValue ("cover_art_size", config, DefaultCoverArtSize);
audio_folders = MergeValues ("audio_folders", config, DefaultAudioFolders);
video_folders = MergeValues ("video_folders", config, DefaultVideoFolders);
playback_mime_types = MergeValues ("output_formats", config, DefaultPlaybackMimeTypes);
playlist_formats = MergeValues ("playlist_formats", config, DefaultPlaylistFormats);
playlist_path = GetPreferredValue ("playlist_path", config, DefaultPlaylistPath);
folder_depth = GetPreferredValue ("folder_depth", config, DefaultFolderDepth);
}
public void ParseKeys_ThrowsODataException_DuplicateKey()
{
ExceptionAssert.Throws <ODataException>(() => KeyValueParser.ParseKeys("id=1,id=2"),
"Duplicate key 'id' found in segment 'id=1,id=2'.");
}
public void ParseKeys_ThrowsODataException_InvalidCountOfSingleQuoteForNonStringLiteral(string segment, string expectedError)
{
ExceptionAssert.Throws <ODataException>(() => KeyValueParser.ParseKeys(segment), expectedError);
}
public void ParseKeys_ThrowsODataException_NoValueWasFound(string segment, string expectedError)
{
ExceptionAssert.Throws <ODataException>(() => KeyValueParser.ParseKeys(segment), expectedError);
}
public void ParseKeys_ThrowsODataException_UnterminatedStringLiteral()
{
ExceptionAssert.Throws <ODataException>(() => KeyValueParser.ParseKeys("id1='123"),
"Unterminated string literal at 4 in segment 'id1='123'.");
}
protected void LoadConfig ()
{
IDictionary<string, string[]> config = null;
if (File.Exists (IsAudioPlayerPath)) {
try {
using (var reader = new StreamReader (IsAudioPlayerPath)) {
config = new KeyValueParser (reader);
has_is_audio_player_file = true;
}
} catch (Exception e) {
Log.Exception ("Error parsing " + IsAudioPlayerPath, e);
}
}
LoadConfig (config);
}
public void ParseKeys_ThrowsODataException_SegmentHasNoKeyName(string segment, string expectedError)
{
ExceptionAssert.Throws <ODataException>(() => KeyValueParser.ParseKeys(segment), expectedError);
}
