public void MakeParseOperation_Always_SplitsLinesAndParamsCorrectly(string[][] configData)
{
var testContext = new TestContext()
{
Config = BuildConfig(configData)
};
var mockConfigParseHandler = testContext.AddFakeConfigParseHandler(ParseResult.Success);
var configLines = new List <ConfigLine>();
mockConfigParseHandler
.Setup(x => x.OnParsing(It.IsAny <ConfigLine>()))
.Callback <ConfigLine>(x => configLines.Add(x))
.Returns(ParseResult.Success);
testContext.Uut.MakeParseOperation()
.ShouldRunToCompletion(testContext.MockBackgroundWorker);
configLines.Count.ShouldBe(configData.Length);
foreach (var i in Enumerable.Range(0, configLines.Count))
{
var expectedConfigLine = new ConfigLine(configData[i]);
configLines[i].Option.ShouldBe(expectedConfigLine.Option);
configLines[i].ParamCount.ShouldBe(expectedConfigLine.ParamCount);
foreach (var index in Enumerable.Range(0, configLines[i].ParamCount))
{
configLines[i].GetParam(index).ShouldBe(expectedConfigLine.GetParam(index));
}
}
}
public ParseResult OnParsing(ConfigLine configLine)
{
Func <DockingManagerSettingsProvider, ConfigLine, ParseResult> parser;
if (_parsersByOption.TryGetValue(configLine.Option, out parser))
{
return(parser.Invoke(this, configLine));
}
return(ParseResult.Ignored);
}
public void ShouldParseConfigLine()
{
var config = new FirefoxConfigReader();
// comments
ConfigLine line = config.ReadLine("");
Assert.AreEqual(true, line.Comment);
line = config.ReadLine("/*");
Assert.AreEqual(true, line.Comment);
line = config.ReadLine("# Mo");
Assert.AreEqual(true, line.Comment);
// values
line = config.ReadLine("user_pref(\"accessibility.typeaheadfind.flashBar\", 0);");
Assert.AreEqual(true, line.Value.Valid);
Assert.AreEqual(false, line.Comment);
Assert.AreEqual(false, line.Value.Comma);
Assert.AreEqual("accessibility.typeaheadfind.flashBar", line.Key);
Assert.AreEqual("0", line.Value.Value);
line = config.ReadLine("user_pref(\"app.update.lastUpdateTime.addon-background-update-timer\", 1334434686);");
Assert.AreEqual(true, line.Value.Valid);
Assert.AreEqual(false, line.Comment);
Assert.AreEqual(false, line.Value.Comma);
Assert.AreEqual("app.update.lastUpdateTime.addon-background-update-timer", line.Key);
Assert.AreEqual("1334434686", line.Value.Value);
line = config.ReadLine("user_pref(\"app.update\", true);");
Assert.AreEqual(true, line.Value.Valid);
Assert.AreEqual(false, line.Comment);
Assert.AreEqual(false, line.Value.Comma);
Assert.AreEqual("app.update", line.Key);
Assert.AreEqual("true", line.Value.Value);
line = config.ReadLine("user_pref(\"app.update\", \"value\");");
Assert.AreEqual(true, line.Value.Valid);
Assert.AreEqual(false, line.Comment);
Assert.AreEqual(true, line.Value.Comma);
Assert.AreEqual("app.update", line.Key);
Assert.AreEqual("value", line.Value.Value);
line = config.ReadLine("user_pref(\"app.update\", \"\");");
Assert.AreEqual(true, line.Value.Valid);
Assert.AreEqual(false, line.Comment);
Assert.AreEqual(true, line.Value.Comma);
Assert.AreEqual("app.update", line.Key);
Assert.AreEqual("", line.Value.Value);
line = config.ReadLine("user_pref(, false);");
Assert.AreEqual(false, line.Value.Valid);
line = config.ReadLine("user_pref(\"app.update\", );");
Assert.AreEqual(false, line.Value.Valid);
}
private static ConfigLine _ParseField
(
RecordField field
)
{
ConfigLine result = new ConfigLine
{
From = field.GetFirstSubFieldText('a'),
To = field.GetFirstSubFieldText('b')
};
return(result);
}
public void OnParsing_OptionIsUnknown_ReturnsIgnoredAndDoesNotChangeSettings(params string[] linePieces)
{
var configLine = new ConfigLine(linePieces);
var uut = new DoorManagerSettingsProvider();
var settings = uut.Settings;
var result = uut.OnParsing(configLine);
result.IsIgnored.ShouldBeTrue();
uut.Settings.ShouldBe(settings);
}
private void PopulateConfigLines()
{
ConfigLine ConfigItem = new ConfigLine();
//[Company Detail]
ConfigItem.Group = "Company";
ConfigItem.Key = "dbServerType";
ConfigItem.Value = ((int)dbType).ToString();
ConfigLines.Add(ConfigItem);
ConfigItem.Group = "Company";
ConfigItem.Key = "DatabaseName";
ConfigItem.Value = DatabaseName;
ConfigLines.Add(ConfigItem);
ConfigItem.Group = "Company";
ConfigItem.Key = "ServerName";
ConfigItem.Value = ServerName;
ConfigLines.Add(ConfigItem);
ConfigItem.Group = "Company";
ConfigItem.Key = "LicenseServer";
ConfigItem.Value = LicenseServer + ":" + LicensePort;
ConfigLines.Add(ConfigItem);
ConfigItem.Group = "Company";
ConfigItem.Key = "User";
ConfigItem.Value = User;
ConfigLines.Add(ConfigItem);
ConfigItem.Group = "Company";
ConfigItem.Key = "Password";
ConfigItem.Value = Password;
ConfigLines.Add(ConfigItem);
ConfigItem.Group = "Company";
ConfigItem.Key = "UseTrusted";
ConfigItem.Value = UseTrusted.ToString();
ConfigLines.Add(ConfigItem);
ConfigItem.Group = "Company";
ConfigItem.Key = "DBPassword";
ConfigItem.Value = DBPassword;
ConfigLines.Add(ConfigItem);
ConfigItem.Group = "Company";
ConfigItem.Key = "DBUser";
ConfigItem.Value = DBUser;
ConfigLines.Add(ConfigItem);
}
public void OnParsing_ParamsAreInvalid_ReturnsErrorAndDoesNotChangeSettings(params string[] linePieces)
{
var configLine = new ConfigLine(linePieces);
var uut = new DoorManagerSettingsProvider();
var settings = uut.Settings;
var result = uut.OnParsing(configLine);
result.IsError.ShouldBeTrue();
result.Error.ShouldContain(linePieces[0]);
uut.Settings.ShouldBe(settings);
}
public void OnParsing_ParamsAreValidForBlockTag_ReturnsSuccessAndSetsBlockTag(params string[] linePieces)
{
var configLine = new ConfigLine(linePieces);
var uut = new ManagerSettingsProvider();
var settings = uut.Settings;
settings.BlockTag = linePieces[1];
var result = uut.OnParsing(configLine);
result.IsSuccess.ShouldBeTrue();
uut.Settings.ShouldBe(settings);
}
public void OnParsing_ParamsAreValidForAutoManageOtherGrids_ReturnsSuccessAndSetsAutoManageOtherGrids(params string[] linePieces)
{
var configLine = new ConfigLine(linePieces);
var uut = new ManagerSettingsProvider();
var settings = uut.Settings;
settings.AutoManageOtherGrids = true;
var result = uut.OnParsing(configLine);
result.IsSuccess.ShouldBeTrue();
uut.Settings.ShouldBe(settings);
}
public void OnParsing_ParamsAreValidForAutoCloseInterval_ReturnsSuccessAndSetsAutoCloseInterval(params string[] linePieces)
{
var configLine = new ConfigLine(linePieces);
var uut = new DoorManagerSettingsProvider();
var settings = uut.Settings;
settings.AutoCloseInterval = TimeSpan.FromMilliseconds(int.Parse(linePieces[1]));
var result = uut.OnParsing(configLine);
result.IsSuccess.ShouldBeTrue();
uut.Settings.ShouldBe(settings);
}
public void OnParsing_ParamsAreValidForBlockTag_ReturnsSuccessAndSetsBlockTag(params string[] linePieces)
{
var configLine = new ConfigLine(linePieces);
var uut = new ProgramSettingsProvider();
var settings = uut.Settings;
settings.ManageInterval = TimeSpan.FromMilliseconds(int.Parse(configLine.GetParam(0)));
var result = uut.OnParsing(configLine);
result.IsSuccess.ShouldBeTrue();
uut.Settings.ShouldBe(settings);
}
public void OnParsing_ParamsAreValidForInstructionsPerTick_ReturnsSuccessAndSetsBlockTag(params string[] linePieces)
{
var configLine = new ConfigLine(linePieces);
var uut = new BackgroundWorkerSettingsProvider();
var settings = uut.Settings;
settings.InstructionsPerTick = int.Parse(linePieces[1]);
var result = uut.OnParsing(configLine);
result.IsSuccess.ShouldBeTrue();
uut.Settings.ShouldBe(settings);
}
public void OnParsing_ParamsAreValidForIgnoreThrusters_ReturnsSuccessAndSetsIgnoreThrusters(params string[] linePieces)
{
var configLine = new ConfigLine(linePieces);
var uut = new DockingManagerSettingsProvider();
var settings = uut.Settings;
settings.IgnoreThrusters = true;
var result = uut.OnParsing(configLine);
result.IsSuccess.ShouldBeTrue();
uut.Settings.ShouldBe(settings);
}
public void OnParsing_ParamsAreValidForMaxLogSize_ReturnsSuccessAndSetsMaxLogSize(params string[] linePieces)
{
var configLine = new ConfigLine(linePieces);
var uut = new LoggerSettingsProvider();
var settings = uut.Settings;
settings.MaxLogSize = int.Parse(linePieces[1]);
var result = uut.OnParsing(configLine);
result.IsSuccess.ShouldBeTrue();
uut.Settings.ShouldBe(settings);
}
private void ReadOptions()
{
foreach (string ConfigLine in ConfigFile)
{
string OptionFound = null;
string OptionEntry = null;
foreach (string OptionName in OptionsDirNames)
{
if (ConfigLine.ToLower().Contains(OptionName.ToLower()) && !ConfigLine.Contains("#"))
{
OptionFound = OptionName;
break;
}
}
if (OptionFound == null)
{
foreach (string OptionName in OptionsDefaultNames)
{
if (ConfigLine.ToLower().Contains(OptionName.ToLower()) && !ConfigLine.Contains("#"))
{
OptionFound = OptionName;
break;
}
}
}
if (OptionFound == null)
{
continue;
}
OptionEntry = @ConfigLine.Substring(OptionFound.Length + 1);
OptionEntry = OptionEntry.Trim();
if (OptionFound.ToLower().Contains("packageroot"))
{
OptionsPackageRoots.Add(OptionEntry);
continue;
}
if (Options.ContainsKey(OptionFound))
{
Options[OptionFound].Replace(Options[OptionFound], OptionEntry);
}
else
{
Options.Add(OptionFound, OptionEntry);
}
}
}
public ParseResult OnParsing(ConfigLine configLine)
{
switch (configLine.Option)
{
case "auto-close-interval":
int autoCloseIntervalMilliseconds;
if ((configLine.ParamCount != 1) ||
!int.TryParse(configLine.GetParam(0), out autoCloseIntervalMilliseconds) ||
(autoCloseIntervalMilliseconds < 1))
{
return(ParseResult.FromError("Usage: \"auto-close-interval:<AutoCloseInterval>\" (> 0) (ms)"));
}
_settings.AutoCloseInterval = TimeSpan.FromMilliseconds(autoCloseIntervalMilliseconds);
return(ParseResult.Success);
default:
return(ParseResult.Ignored);
}
}
public ParseResult OnParsing(ConfigLine configLine)
{
switch (configLine.Option)
{
case "instructions-per-tick":
int instructionsPerTick;
if ((configLine.ParamCount != 1) ||
!int.TryParse(configLine.GetParam(0), out instructionsPerTick) ||
(instructionsPerTick < 1))
{
return(ParseResult.FromError("Usage: \"instructions-per-tick:<InstructionsPerTick>\" (> 0)"));
}
_settings.InstructionsPerTick = instructionsPerTick;
return(ParseResult.Success);
default:
return(ParseResult.Ignored);
}
}
public ParseResult OnParsing(ConfigLine configLine)
{
switch (configLine.Option)
{
case "max-log-size":
int maxLogSize;
if ((configLine.ParamCount != 1) ||
!int.TryParse(configLine.GetParam(0), out maxLogSize) ||
(maxLogSize < 0))
{
return(ParseResult.FromError("Usage: \"max-log-size:<MaxLogSize>\" (>= 0) (lines)"));
}
_settings.MaxLogSize = maxLogSize;
return(ParseResult.Success);
default:
return(ParseResult.Ignored);
}
}
private void SortConfigLines(System.Collections.Generic.List <ConfigLine> ConfigLines)
{
ConfigLine item = new ConfigLine();
for (int i = ConfigLines.Count - 1; i >= 0; i--)
{
for (int j = ConfigLines.Count - 1; j >= 0; j--)
{
if (ConfigLines[j].Group.CompareTo(ConfigLines[i].Group) < 0)
{
item.Group = ConfigLines[j].Group;
item.Key = ConfigLines[j].Key;
item.Value = ConfigLines[j].Value;
ConfigLines[j] = ConfigLines[i];
ConfigLines[i] = item;
}
}
}
}
public ParseResult OnParsing(ConfigLine configLine)
{
switch (configLine.Option)
{
case "block-tag":
if (configLine.ParamCount != 1)
{
return(ParseResult.FromError("Usage: \"block-tag:<BlockTag>\""));
}
_settings.BlockTag = configLine.GetParam(0);
return(ParseResult.Success);
case "manage-other-grids":
if (configLine.ParamCount != 0)
{
return(ParseResult.FromError("Usage: \"manage-other-grids\""));
}
_settings.ManageOtherGrids = true;
return(ParseResult.Success);
case "auto-manage-this-grid":
if (configLine.ParamCount != 0)
{
return(ParseResult.FromError("Usage: \"auto-manage-this-grid\""));
}
_settings.AutoManageThisGrid = true;
return(ParseResult.Success);
case "auto-manage-other-grids":
if (configLine.ParamCount != 0)
{
return(ParseResult.FromError("Usage: \"auto-manage-other-grids\""));
}
_settings.AutoManageOtherGrids = true;
return(ParseResult.Success);
default:
return(ParseResult.Ignored);
}
}
// End of IPhotoRenderContext interface method implementation.
//========================================================================================================================
// Retrieve the list of extra search paths for Revit texture files.
// This is done by reading user's Revit.ini file and searching for field AdditionalRenderAppearancePaths
// which contains search paths that Revit will use to locate texture files.
// Note that the behavior in Revit is to search in the directory itself and not in child sub-directories.
private void RetrieveExtraTexturePaths()
{
string UserSpecificDirectoryPath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
if (!string.IsNullOrEmpty(UserSpecificDirectoryPath) && Path.IsPathRooted(UserSpecificDirectoryPath) && Directory.Exists(UserSpecificDirectoryPath))
{
string FullRevitIniPath = $"{UserSpecificDirectoryPath}\\AppData\\Roaming\\Autodesk\\Revit\\Autodesk Revit {ProductVersion}\\Revit.ini";
if (File.Exists(FullRevitIniPath))
{
FileStream RevitIniStream = new FileStream(FullRevitIniPath, FileMode.Open, FileAccess.Read, FileShare.Read);
using (StreamReader RevitIniReader = new StreamReader(RevitIniStream))
{
string ConfigLine;
while ((ConfigLine = RevitIniReader.ReadLine()) != null)
{
if (ConfigLine.Contains("AdditionalRenderAppearancePaths"))
{
string[] SplitLineArray = ConfigLine.Split('=');
if (SplitLineArray.Length > 1)
{
string[] TexturePaths = SplitLineArray[1].Split('|');
foreach (string TexturePath in TexturePaths)
{
ExtraTexturePaths.Add(TexturePath);
}
break;
}
}
}
}
}
}
}
private ConfigManager()
{
FileInfo fi = new FileInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "BlazeGamesIM", "config.ini"));
if (fi.Exists)
{
string[] FileData = File.ReadAllLines(fi.FullName);
if (FileData.Length > 0)
{
if (FileData[0] != "config_ver=2")
{
File.WriteAllText(fi.FullName, DefaultConfig);
FileData = File.ReadAllLines(fi.FullName);
}
}
else
{
File.WriteAllText(fi.FullName, DefaultConfig);
FileData = File.ReadAllLines(fi.FullName);
}
foreach (string ConfigLine in FileData)
{
if (ConfigLine.Trim() == "")
{
continue;
}
else if (ConfigLine.Split('=').Length < 2)
{
continue;
}
else
{
string[] ConfigLineData = ConfigLine.Split('=');
ConfigData.Add(ConfigLineData[0], String.Join("=", ConfigLineData, 1, ConfigLineData.Length - 1));
}
}
}
}
public void OnParsing_Always_IgnoresLine(params string[] linePieces)
{
var testContext = new TestContext();
var configLine = new ConfigLine(linePieces);
var result = testContext.Uut.OnParsing(configLine);
result.IsIgnored.ShouldBeTrue();
testContext.MockBackgroundWorker
.Invocations.ShouldBeEmpty();
testContext.MockBlockCollectionManager
.Invocations.ShouldBeEmpty();
testContext.MockDoorManager
.Invocations.ShouldBeEmpty();
testContext.MockProgramSettingsProvider
.Invocations.ShouldBeEmpty();
}
/// <summary>
/// Saves the Ecompile.Cfg back to file with any changes. File Output
/// is tabbed so that settings are in a straight column and all original
/// lines that were NOT settings are retained as original.
/// </summary>
/// <returns>Bool for success</returns>
public bool SaveConfig()
{
// Let's Ditch ALL PackageRoot Entries, and mark it's first location
int PRBegin = ConfigFile.FindIndex(FindPackageRoots);
ConfigFile.RemoveAll(FindPackageRoots);
foreach (string PackageRootElem in OptionsPackageRoots)
{
int i = (28 - "PackageRoot".Length);
string TabString = "";
while (i > 0)
{
TabString += "\t";
i -= 4;
}
ConfigFile.Insert(PRBegin, "PackageRoot" + TabString + PackageRootElem);
}
string[] SaveContents = new string[ConfigFile.Count];
ConfigFile.CopyTo(SaveContents);
int LineIndex = 0;
foreach (string ConfigLine in ConfigFile)
{
foreach (string OptionName in OptionsDirNames)
{
if (ConfigLine.ToLower().Contains(OptionName.ToLower()) && !ConfigLine.Contains("#") && OptionName != "PackageRoot")
{
// We found a Directory Option! REPLACE IT!
int i = (28 - OptionName.Length);
string TabString = "";
while (i > 0)
{
TabString += "\t";
i -= 4;
}
SaveContents[LineIndex] = OptionName + TabString + Options[OptionName];
break;
}
}
// Now we add all the Default Option Stuff
foreach (string OptionName in OptionsDefaultNames)
{
if (ConfigLine.ToLower().Contains(OptionName.ToLower()) && !ConfigLine.Contains("#"))
{
// We found a Default Option! REPLACE IT!
int i = (28 - OptionName.Length);
string TabString = "";
while (i > 0)
{
TabString += "\t";
i -= 4;
}
SaveContents[LineIndex] = OptionName + TabString + Options[OptionName];
break;
}
}
LineIndex++;
}
// Now we write it all back to the ecompile.cfg. OHHH! AHHH! Go away.
if (ConfigFileName != null)
{
try
{
File.WriteAllLines(ConfigFileName, SaveContents);
return(true);
}
catch (Exception ex)
{
throw new Exception(ex.ToString());
}
}
return(false);
}
public void ConfigLine()
{
ConfigLine line = new ConfigLine();
Assert.AreEqual("", line.Content);
line = new ConfigLine("content");
Assert.AreEqual("content", line.Content);
}
public void GetParam_Always_ReturnsPieceAtIndexPlus(int index, IReadOnlyList <string> linePieces)
{
var uut = new ConfigLine(linePieces);
uut.GetParam(index).ShouldBe(linePieces[index + 1]);
}
public void ParamCount_Always_ReturnsPieceCountMinus1(IReadOnlyList <string> linePieces)
{
var uut = new ConfigLine(linePieces);
uut.ParamCount.ShouldBe(linePieces.Count - 1);
}
public void Option_Always_ReturnsPiece0(IReadOnlyList <string> linePieces)
{
var uut = new ConfigLine(linePieces);
uut.Option.ShouldBe(linePieces[0]);
}
public static void ShouldHaveReceivedOnParsing(this Mock <IConfigParseHandler> mockHandler, ConfigLine expectedConfigLine)
=> mockHandler
.ShouldHaveReceived(x => x.OnParsing(It.Is <ConfigLine>(configLine =>
(configLine.Option == expectedConfigLine.Option) &&
(configLine.ParamCount == expectedConfigLine.ParamCount) &&
Enumerable.Range(0, configLine.ParamCount)
.All(index => configLine.GetParam(index) == expectedConfigLine.GetParam(index)))));
public ParseResult OnParsing(ConfigLine configLine) => ParseResult.Ignored;
private static ParseResult ParseIgnoreGyros(DockingManagerSettingsProvider @this, ConfigLine configLine)
{
if (configLine.ParamCount != 0)
{
return(ParseResult.FromError("Usage: \"ignore-gyros\""));
}
@this._settings.IgnoreGyros = true;
return(ParseResult.Success);
}
